// Libreroias de AVR #include #include #include // Librerias de C #include #include #include // Librerias componentes #include "Stepper.h" #include "LCD.h" #include "Keypad.h" #include "Servo.h" #include "USART_data.h" #define F_CPU 16000000UL // Frecuencia del oscilador en Hz #define size 64 // Tamaño del buffer char steps_string[100]; // String de almacenamiento de los pasos para el serial char angle_string[100]; // String de almacenamiento de los angulos para elserial // Variable int stepper_status, servo_status; int stepper_direction; int servo_angle = 0; int option = 0; bool flag, flag_1, flag_2, flag1_, flag_stepper1, flag_stepper2, flag_servo, flag_steps; char key_control, serial_control; // Entradas del keypad y el serial // Variable para almacenar los dígitos ingresados char key_steps[16]; char input_steps[16]; int buffer_steps = 0; char key_angle[16]; char input_angle[16]; int buffer_angle = 0; #include "Menu.h" // Pines de las terminales del motor Stepper #define IN1 3 #define IN2 2 #define IN3 1 #define IN4 0 // Funcion prinipal int main () { serial_begin(9600); // Inicializacion del serial MStep_begin(IN1, IN2, IN3, IN4); // Incializacion del Stepper LCD_begin(); // Inicializacion del LCD Keypad_begin(); // Inicializacion del Keypad servo_begin(); // Inicializacion del servo // Configuracion del Timer1 para el control en paralelo del stepper TCCR1B |= (1 << WGM12) | (1 << CS11) | (1 << CS10); TCNT1 = 0; OCR1A = 100000; TIMSK1 |= (1 << OCIE1A); sei (); // Habilitacion de las interrupciones while (1) { // El codigo implementado se encuentra dentro de la funcion "interfaz_de_motor()". // La logica de implementacion de la navegacion entre menus es el uso de bucles anidados. // En donde los bucles se activan o desactivan segun las entradas que se reciban // Cambiando unos flags correspondientes. interfaz_de_motor(); } return 0; } // Función de interrupción para el temporizador ISR(TIMER1_COMPA_vect) { // Cuando el Timer alcanza el valor de comparacion se entra en esta interrupcion // esto permite el trabajo en paralelo. La funcion esta diseñada para que pueda // ir cambiando y no se quede dentro de igual manera MStep(stepper_direction); // Se ejecuta la funcion de movimiento del Stepper } // Menu principal de seleccion void interfaz_de_motor () { flag = false; // Se declara flag como false key_control = ' '; // Se limpia key_control // Se imprimen los caracteres tanto en el serial como en el LCD print_menu("1. Control", "2. Status"); flag = true; // Se declara flag como true // La declaracion de flag se hace para anidar el bucle y evitar que se mantenga imprimiendo // Lineas tanto en el serial como en el LCD. De esta forma solo se imprime una sola vez // Esta estructura se vera para cada uno de los submenus de este codigo. while (flag) { serial_control = serial_check(1); // Verifica si acaba de llegar algo al serial key_control = get_key(1); // Verifica el teclado matricial // Opcion 1 if (serial_control == '1' || key_control == '1') { serial_control = '\0'; // Se limpia serial_control menu_1(); // Se va al menu1 } // Opcion 2 else if (serial_control == '2' || key_control == '2') { serial_control = '\0'; // Se limpia serial_control menu_2(); // Se va al menu2 } } } // Menu de seleccion del motor a manejar void menu_1 () { flag_1 = false; // flag_1 se declara como falso key_control = ' '; // Impresion en el serial como en el LCD print_menu("1. Stepper", "2. Servomotor"); flag_1 = true; // flag_1 se declara como true // Se con el bucle de igual forma a como se hizo con el menu principal while (flag_1) { serial_control = serial_check(1); // Se verifica el serial key_control = get_key(1); // Verifica el teclado matricial // Opcion de regreso if (serial_control == '*' || key_control == '*') { // Se declaran todas las flags como falsas para romper los bucles anidados y regresar al menu principal serial_control = '\0'; flag_1 = false; flag = false; break; } // Opcion 1 else if (serial_control == '1' || key_control == '1') { serial_control = '\0'; option = 1; // Stepper menu_1_(); } // Opcion 2 else if (serial_control == '2' || key_control == '2') { serial_control = '\0'; option = 2; // Servo menu_1_(); } } } // Menu de seleccion de accion, es el mismo para el stepper y el servo void menu_1_ () { flag1_ = false; // Se declara a flag1_ como falsa key_control = ' '; // Impresion de valores en el LCD y en el serial print_menu("1. Rotate", "2. Stop"); flag1_ = true; // Se declara a flag1_ como verdadera // Misma estructura que en el menu principal while (flag1_) { serial_control = serial_check(1); // Se verifica si hubo alguna entrada en el serial key_control = get_key(1); // Verifica el teclado matricial // Opcion de regreso if (serial_control == '*' || key_control == '*') { // Se declaran todas las flags como falsas para romper los bucles anidados y regresar al menu principal serial_control = '\0'; option = 0; flag1_ = false; flag_1 = false; flag = false; break; } // Opcion 1 else if ((serial_control == '1' || key_control == '1') && option == 1) { menu_stepper1(); // Se va al menu del Stepper serial_control = '\0'; } // Opcion 2 else if ((serial_control == '1' || key_control == '1') && option == 2) { menu_servo(); // Se va al menu del servo serial_control = '\0'; } else if ((serial_control == '2' || key_control == '2') && option == 1) { stepper_status = 0; serial_control = '\0'; option = 0; flag1_ = false; flag_1 = false; flag = false; break; } else if ((serial_control == '2' || key_control == '2') && option == 2) { servo_status = 0; servo_write(0); serial_control = '\0'; option = 0; flag1_ = false; flag_1 = false; flag = false; break; } } } // Menu de control del servo void menu_servo () { flag_servo = false; // Se declara flag_servo como falsa key_control = ' '; // Impresion en el serial y en el LCD clean_LCD (); print_menu("Angle: ", ""); flag_servo = true; // Se declara flag_servo como true // Misma estructura que en el menu principal while (flag_servo) { // Ahora se lee una string entera serial_read_string(angle_string, size); serial_control = angle_string[0]; key_control = get_key(1); if (key_control == '*') { serial_control = '\0'; option = 0; flag_servo = false; flag1_ = false; flag_1 = false; flag = false; break; } else if (key_control == '#') { strcpy(key_angle, input_angle); servo_angle = string_a_entero (input_angle); LCD_set_cursor(8, 1); LCD_print(input_angle); buffer_angle = 0; input_steps[buffer_angle] = '\0'; servo_status = 1; servo_write(servo_angle); serial_println(key_angle); serial_println("\n"); _delay_ms(1000); serial_control = '\0'; key_angle[0] = '\0'; option = 0; flag_servo = false; flag1_ = false; flag_1 = false; flag = false; break; } else if (key_control == 'C') { LCD_set_cursor(8, 1); LCD_print(" "); buffer_angle = 0; input_angle[buffer_angle] = '\0'; } else if (key_control >= '0' && key_control <= '9') { if (buffer_angle < 15) { input_angle[buffer_angle++] = key_control; input_angle[buffer_angle] = '\0'; LCD_set_cursor(8, 1); LCD_print(input_angle); } } if (angle_string[0] != '\0') { if (serial_control == '*') { serial_control = '\0'; option = 0; flag_servo = false; flag1_ = false; flag_1 = false; flag = false; break; } if (char_es_numero(serial_control)) { servo_angle = string_a_entero(angle_string); servo_status = 1; serial_print(angle_string); serial_println("\n\n"); LCD_print(angle_string); servo_write(servo_angle); _delay_ms(1000); serial_control = '\0'; option = 0; flag_servo = false; flag1_ = false; flag_1 = false; flag = false; break; } } } } // Menu de control del puerto void menu_stepper1 () { flag_stepper1 = false; // Se declara el flag correspondiente como falso key_control = ' '; // Se imprime valores en el serial y en el LCD print_menu("1. Rotate Left", "2. Rotate Right"); flag_stepper1 = true; // Se declara el flag correspondiente como true // Misma estructura que en el menu principal while (flag_stepper1) { serial_control = serial_check(1); // Se verifica las entradas del serial key_control = get_key(1); // Verifica el teclado matricial // Opcion de regreso if (serial_control == '*' || key_control == '*') { // Se declaran todas las flags como falsas para romper los bucles anidados y regresar al menu principal key_control = '\0'; option = 0; flag_stepper1 = false; flag1_ = false; flag_1 = false; flag = false; break; } // Opcion 1 else if (serial_control == '1' || key_control == '1') { stepper_direction = 0; // Sentido hacia la derecha menu_steps(); // Pasos serial_control = '\0'; } // Opcion 2 else if (serial_control == '2' || key_control == '2') { stepper_direction = 1; // Sentido hacia la izquierda menu_steps(); // Pasos serial_control = '\0'; } } } // Menu de control de pasos void menu_steps () { clean_LCD (); flag_stepper2 = false; // Declara flag_stepper2 como falso key_control = ' '; // Impresion en el serial y en el LCD print_menu("# of Steps: ", ""); flag_stepper2 = true; // Declara flag_stepper2 como true // Misma secuencia que en el menu principal while (flag_stepper2) { // Ahora se verifica una string serial_read_string(steps_string, size); serial_control = steps_string[0]; // Control se vuelve el primer digito de dicha string key_control = get_key(1); if (key_control == '*') { // Se declaran todas las flags como falsas para romper los bucles anidados y regresar al menu principal key_control = '\0'; option = 0; flag_stepper2 = false; flag_stepper1 = false; flag1_ = false; flag_1 = false; flag = false; break; } else if (key_control == '#') { strcpy(key_steps, input_steps); LCD_set_cursor(13, 1); LCD_print(input_steps); buffer_steps = 0; input_steps[buffer_steps] = '\0'; stepper_status = 1; steps = string_a_entero(key_steps); serial_println(key_steps); serial_println("\n\n"); _delay_ms(500); key_control = '\0'; key_steps[0] = '\0'; option = 0; flag_stepper2 = false; flag_stepper1 = false; flag1_ = false; flag_1 = false; flag = false; break; } else if (key_control == 'C') { LCD_set_cursor(13, 1); LCD_print(" "); buffer_steps = 0; input_steps[buffer_steps] = '\0'; } else if (key_control >= '0' && key_control <= '9') { if (buffer_steps < 15) { input_steps[buffer_steps++] = key_control; input_steps[buffer_steps] = '\0'; LCD_set_cursor(13, 1); LCD_print(input_steps); } } if (steps_string[0] != '\0') { if (serial_control == '*') { serial_control = '\0'; option = 0; flag_stepper2 = false; flag_stepper1 = false; flag1_ = false; flag_1 = false; flag = false; break; } if (char_es_numero(serial_control)) { steps = string_a_entero(steps_string); stepper_status = 1; serial_print(steps_string); serial_println("\n\n"); LCD_print(steps_string); _delay_ms(1000); serial_control = '\0'; steps_string[0] = '\0'; option = 0; flag_stepper2 = false; flag_stepper1 = false; flag1_ = false; flag_1 = false; flag = false; break; } } } } // Menu de estado de los motores void menu_2 () { clean_LCD (); flag_2 = false; // Se declara a flag_2 como falsa key_control = ' '; // Secuencia de impresion // Stepper serial_println("Stepper "); LCD_set_cursor(1, 1); LCD_print("Stepper "); if (stepper_status == 1) { serial_println("ON \n"); // En caso de que este encendido LCD_print("ON "); } else { serial_println("OFF \n"); // En caso de que este apagado LCD_print("OFF "); } // Stepper serial_println("Servomotor "); LCD_set_cursor(1, 2); LCD_print("Servomotor "); if (servo_status == 0) { LCD_print("0"); serial_println("0\n\n"); } if (servo_status == 1) { LCD_print(entero_a_string(servo_angle)); serial_println(entero_a_string(servo_angle)); serial_println("\n\n"); } flag_2 = true; // flag_2 se vuelve true // Lo mismo que en el menu principal while (flag_2) { serial_control = serial_check(1); key_control = get_key(1); // Verifica el teclado matricial // Se declaran todas las flags como falsas para romper los bucles anidados y regresar al menu principal if (serial_control == '*' || key_control == '*') { serial_control = '\0'; flag_2 = false; flag = false; break; } } } // Funcion de cambio de decimal a string char *decimal_a_string(float n) { static char string[2]; int parte_entera = (int)n; // La sentencia "(int)f" solo se queda con la parte entera de f float parte_decimal = n - parte_entera; // Se queda con los decimales int i = 0; // Conversion de la parte entera en un string while (n > 0 && i < sizeof(string)) { string[i++] = parte_entera % 10 + '0'; // Se adquiere el último dígito del número parte_entera /= 10; // Se divide entre 10, para eliminar dicho último dígito } // Aqui el valor de la string es invertido, para ello, se invierte la cadena // Invierte la cadena char temp; for (int j = 0; j < i / 2; j++) { temp = string[j]; string[j] = string[i - j - 1]; string[i - j - 1] = temp; } string[i++] = '.'; // Se agrega el punto decimal // Conversion de la parte decimal en un string for (int k = 0; k < 1; k++) { parte_decimal *= 10; int digito = (int)parte_decimal; string[i++] = digito + '0'; parte_decimal -= digito; } string[i] = '\0'; // Cuando se llega al tope, se cierra la cadena return string; // Devuelve el valor convertido en una cadena } // Funcion de transformacion de string a entero int string_a_entero (const char *str) { int result = 0; // Resultado de la conversion int sign = 1; // Reconocer los signos // Verifica la presencia de un guion, osea, un signo negativo if (*str == '-') { sign = -1; // Si se detecta, sign pasa a ser -1 str++; // Se continua con la cadena } // Bucle que se acaba cuando el string se acaba while (*str != '0') { if (*str >= '0' && *str <= '9') { result = result * 10 + (*str - '0'); // Aqui lo que se hace es que por cada elemento de la cadena, y se saca // Su valor numerico, en ASCII los numeros se disponen de forma continua // Es decir, el '0' es 48, el '1' es 49... y asi, entonces, si ejecuto la // operacion '1' - '0', es lo mismo que 49 - 48 que es 1. De esta forma me // devuelve el valor que es. } else { break; } str++; } return result * sign; } char *entero_a_string(int n) { static char str[20]; // Almacena la cadena resultante int i = 0; // Índice para recorrer la cadena int sign = 0; // Variable para el signo (0 para positivo, 1 para negativo) if (n < 0) { sign = 1; n = -n; // Convierte el número a positivo si es negativo } // En el caso especial de 0, simplemente añade '0' como el único carácter if (n == 0) { str[i++] = '0'; } char tempStr[20]; // Utilizado para almacenar la representación de los dígitos while (n > 0) { int digit = n % 10; // Obtiene el último dígito del número tempStr[i++] = digit + '0'; // Convierte el dígito a carácter y lo agrega a tempStr n /= 10; // Elimina el último dígito del número } if (sign) { tempStr[i++] = '-'; // Si el número era negativo, agrega el signo '-' a tempStr } // Invierte la cadena en tempStr y copia los resultados en str int len = i; for (i = 0; i < len; i++) { str[i] = tempStr[len - 1 - i]; // Copia los caracteres desde tempStr a str en orden inverso } str[len] = '\0'; // Agrega el carácter nulo al final de la cadena en str return str; // Devuelve la cadena resultante } int char_es_numero (char c) { return (c >= '0' && c <= '9'); } int string_es_numero(const char *str) { int i = 0; if (str[i] == '-') { i++; } while (str[i] != '\0') { if (str[i] < '0' || str[i] > '9') { return 0; break; } i++; } return 1; } void MStep (unsigned int sentido) { // Para que el Stepper funcione, este debe de experimentar una secuencia de encendido // y apagado de bobinas. El control de dicha secuencia de encendido y apagado se hara // Por medio de un bucle while que cuenta la cantidad de pasos. if (steps > 0 && stepper_status == 1) { if (sentido == 0) { switch(case_state) { case 0: PORTM |= (1 << A); PORTM &=~ (1 << B); PORTM &=~ (1 << C); PORTM &=~ (1 << D); break; case 1: PORTM |= (1 << B); PORTM &=~ (1 << A); PORTM &=~ (1 << C); PORTM &=~ (1 << D); break; case 2: PORTM |= (1 << C); PORTM &=~ (1 << A); PORTM &=~ (1 << B); PORTM &=~ (1 << D); break; case 3: PORTM |= (1 << D); PORTM &=~ (1 << A); PORTM &=~ (1 << B); PORTM &=~ (1 << C); break; } } else { switch(case_state) { case 0: PORTM |= (1 << D); PORTM &=~ (1 << A); PORTM &=~ (1 << B); PORTM &=~ (1 << C); break; case 1: PORTM |= (1 << C); PORTM &=~ (1 << A); PORTM &=~ (1 << B); PORTM &=~ (1 << D); break; case 2: PORTM |= (1 << B); PORTM &=~ (1 << A); PORTM &=~ (1 << C); PORTM &=~ (1 << D); break; case 3: PORTM |= (1 << A); PORTM &=~ (1 << B); PORTM &=~ (1 << C); PORTM &=~ (1 << D); break; } } case_state++; if (case_state > 3) { case_state = 0; steps--; } } else { steps = 0; } }