ROBOT POLOLU PROGRAMADO PARA SEGUIR REFERENCIA MOVIL Y OBEDECER COMANDOS INALAMBRICOS

1. ROBOT POLOLU PROGRAMADO PARA SEGUIR REFERENCIA MOVIL Y OBEDECER COMANDOS INALAMBRICOS Viviana Baque Gutiérrez Lenin Gómez Romero

2. OBJETIVO GENERAL • Programar el Robot Pololu 3pi para que siga una referencia móvil y obedezca comandos inalámbricos a través del AVR Butterfly.

3. OBJETIVOS ESPECIFICOS • Configurar los comandos que serán enviados por medio del Butterfly, usando el joystick. • Seleccionar los comandos de comunicación que sean necesarios para seguir el móvil. • Como son • Avanzar • Retroceder • Girar a la derecha • Girar a la izquierda

4. Descripción del Proyecto • Este proyecto tiene como función principal programar el robot pololu 3pi que seguirá una referencia móvil que será controlada mediante comandos inalámbricos, para esto se necesita un circuito receptor que recibirá los comandos que serán enviados a través del Butterfly que es el que hará las veces de transmisor. • EL sistema de control del proyecto será diseñado para que funcionen con los micro-controladores ATMEGA 328 y el ATMEGA 169 usando la interfaz del AVR Studio 4 que es un software que ofrece dos tipos de compiladores que son: ATMEL AVR assembler para lenguaje assembler y AVR GCC para lenguaje C.

5. Aplicaciones • Como el robot es controlado a través de Joystick comando inalámbrico cualquier persona puede enviarle instrucciones. Por lo cual, se puede diseñar un robot explorador de zonas urbanas, al cual se le ingresen coordenadas y el robot se moverá hacia ellas. • La principal aplicación de los robots tiene lugar en la industria, donde se necesitan repetir tareas, seguir cierto recorrido donde las personas no pueden llegar y estos robots llegarían a realizar ese trabajo . Un robot está programado para realizar los mismos movimientos con una buena precisión, por lo que es perfecto para aplicaciones industriales. Aunque todos los campos de la industria son susceptibles de emplear diferentes tipos de robots para determinadas operaciones.

6. Proyectos similares Pololu 3pi seguidor de pared. • Este proyecto demuestra una posible configuración donde dos sensores de distancia Sharp analógicos están conectados al mismo con un mínimo de soldadura. • Los dos sensores de distancia permiten explorar una habitación siguiendo la pared y evitando los obstáculos que encuentra en el recorrido. Este trata de mantener una distancia prudencial de la pared si ve a su lado izquierdo un obstáculo, éste gira a la derecha. Como medida de seguridad adicional, cada 15 segundos, el robot trata de una copia de seguridad en caso de que sin saberlo se ha atascado mientras explora.

7. Robot TRIC TRAC radio controlado por joystick de playstation 2 • TRI-TRAC es un robot todo terreno con orugas que puede ser usado mediante radio control o mediante control autónomo. Debido a su oruga el robot puede trabajar tanto en interior como exterior.

8. Robot controlado por comando Wii de cámara inalámbrica • Este proyecto está basado en Arduino. Posee una cámara inalámbrica con alcance de 30 metros montada sobre un sistema Pan&Tilt que es usado en mini cámaras en el que va montado un sonar de ultrasonidos y un láser en cruz. Su diseño permite girar hasta 360º para tener una visión periférica completa. • Ahora mismo, el control se realiza con un mando nunchuk de wii, El Nunchuk es una expansión para el mando inalámbrico de Wii. Con el acelerómetro para el movimiento de las orugas, el joystick para el control del Pan&Tilt y los botones para seleccionar entre modos y activar el láser.

9. Requerimientos para el proyecto Este proyecto se lo puede dividir en 2 secciones: Software y Hardware.

10. Requerimientos para el programa • Para realizar la aplicación que gestionará el pololu y el butterfly con los datos que serán enviados y recibidos a través de ellos usaremos el programa AVR studio 4 usando el lenguaje más acorde ya sea lenguaje ensamblador o c. Estos compiladores son los que nos ayudarán a entender el código base del robot Pololu 3pi y permitirá implementar una variedad al mismo.

11. Requerimientos para el proyecto Robot Pololu 3π El robot Pololu 3π es un robot el cual fue diseñado para ser un seguidor de línea y éste es capaz de resolver laberintos de forma autónoma. Posee una alimentación de 4 baterías AAA los cuales alimentan a los motores con 9.25 V, este robot es capaz de alcanzar velocidades de 100cm/s. A continuación se mencionarán las características del robot: • Posee 4 sensores reflectantes QTR-RC • Microcontrolador ATmega328P • Un sensor de luz • Un display 8 x 2 • 2 Motores • Leds para marcar alimentación de 5v al microcontrolador y 9.25v para los motores.

12. Requerimientos para el proyecto

13. AVR Butterfly • El kit de evaluación del AVR Butterfly está diseñado para demostrar los beneficios y características claves. • Se trata de un solo módulo microprocesador soporte que puede ser utilizado en numerosas aplicaciones: • Diseño de bajo poder. • Controlador LCD. • -Interfaces de comunicación. • - UART, SPI, USI. • - Selfprogramming / gestor de arranque, SPI, en paralelo, JTAG. • - Temporizadores / Contadores. • - Reloj en Tiempo Real (RTC). • - Modulación de Ancho de Pulso (PWM).

15. Diseño del Proyecto • Diagrama de Bloques • El diagrama de bloques del sistema se encuentra establecido por la etapa del transmisor (Butterfly )y la etapa del receptor (Robot Pololu 3pi ).

16. Diagrama de Bloque del Transmisor

17. Código del transmisor • //Declaración de constantes • #define Centro 0 • #define Arriba 1 • #define Abajo 2 • #define Izquierda 3 • #define Derecha 4 • #define Otros 5 • //Libreias a usar • #include <avr/io.h> • #include <avr/interrupt.h> • #include <avr/pgmspace.h> • #include <avr/delay.h> • #include <inttypes.h> • //Librerias a usar • #include <pololu/3pi.h> • #include <pololu/orangutan.h> • //Librerias a usar que no pertenecen al entorno • #include "mydefs.h" • #include "LCD_functions.h" • #include "LCD_driver.h" • #include "button.h" • #include "usart.h" • //Prototipo de funciones • int Obtener_Boton(void); • //Programa principal • int main(void) • { • //Se habilita las interrupciones globales • sei(); • //Se muestra un mensaje a través del LCD • PGM_P statetext = PSTR("AVR BUTTERFLY"); • // Disable Analog Comparator (power save) • ACSR = (1<<ACD); • // Disable Digital input on PF0-2 (power save) • DIDR0 = (7<<ADC0D); • // Enable pullups • PORTB = (15<<PB0); • PORTE = (15<<PE4);

18. // Initialize pin change interrupt on joystick • Button_Init(); • // initialize the LCD • LCD_Init(); • // set Clock Prescaler Change Enable • CLKPR = (1<<CLKPCE); • // set prescaler = 8, Inter RC 8Mhz / 8 = 1Mhz • CLKPR = (0<<CLKPS1) | (1<<CLKPS0); • //Configuración del USART a 52= 9600 baudios • USART_Init(52); • if (statetext) • { • LCD_puts_f(statetext, 1); • LCD_Colon(0); • statetext = NULL; • } • //Lazo infinito • while (1) • { • _delay_ms(50); // TIEMPO MINIMO DE RETARDO DEL HM-TR ANTES DE ENVIAR OTRO DATO • if (statetext) • { • LCD_puts_f(statetext, 1); • LCD_Colon(0); • statetext = NULL; • } • //Se espera a que sea presionado un botón • input = Obtener_Boton(); • //Se realiza una determinada acción según el botón presionado • switch (input) • { • case Centro: // PRESIONO EL BOTON CENTRO • statetext = PSTR("CENTRO"); • Usart_Tx('S'); • break;

19. case Derecha: // PRESIONO EL BOTON DERECHA • statetext = PSTR("DERECHA"); • Usart_Tx('R'); • break; • case Izquierda: // PRESIONO EL BOTON IZQUIERDA • statetext = PSTR("IZQUIERDA"); • Usart_Tx('L'); • break; • case Arriba: // PRESIONO EL BOTON ARRIBA • statetext = PSTR("ARRIBA"); • Usart_Tx('U'); • break; • case Abajo: // PRESIONO EL BOTON ABAJO • statetext = PSTR("ABAJO"); • Usart_Tx('D'); • break; • default: • break; • } • } • return 0; • } • /* • Función que retorna un valor entero correspondiente al botón • presionado en el JoyStick • */ • int Obtener_Boton(void) • { int Temp1; • //PB4-->O Centro • //PB6-->A Arriba • //PB7-->B Abajo • //PE2-->C Izquierda • //PE3-->D Derecha • //Centro • Temp1=(PINB) & 0b00010000; • if(Temp1==0b00000000) • { • sei(); • return Centro; • } • //Arriba • Temp1=PINB & 0b01000000; • if(Temp1==0b00000000) • { • sei(); • return Arriba; • }

20. //Abajo • Temp1=PINB & 0b10000000; • if(Temp1==0b00000000) • { • sei(); • return Abajo; • } • //Izquierda • Temp1=PINE & 0b00000100; • if(Temp1==0b00000000) • { • sei(); • return Izquierda; • } • //Derecha • Temp1=PINE & 0b00001000; • if(Temp1==0b00000000) • { • sei(); • return Derecha; • } • sei(); • return Otros; • }

21. Diagrama de Bloque del Receptor

22. Código del receptor • /Declaración de constantes • #define F_CPU 20000000UL • #define PIND_MASK ((1<<PIND0)|(1<<PIND1)) • //Librerias a usar • #include <pololu/3pi.h> • #include <avr/pgmspace.h> • #include <pololu/orangutan.h> • //Texto para la lcd • const char welcome_line1[] PROGMEM = " Pololu"; • const char welcome_line2[] PROGMEM = "3\xf7 Robot"; • const char name_line1[] PROGMEM = "Wall"; • const char name_line2[] PROGMEM = "Follower"; • //Tiempo de refresco de la pantalla • const int display_interval_ms = 100; • #define MS_ELAPSED_IS(n) (get_ms() % n == 0) • #define TIME_TO_DISPLAY (MS_ELAPSED_IS(display_interval_ms)) • //Prototipo de procedimientos • void USART_Init( unsigned int ); • unsigned char ReceiveByte (void); • //Parametros iniciales configuracion 3pi • void inicializar(){ • //registro puerto b • DDRB = 0x08; // set PORTD for output • PORTB = 0x00; // set LEDs off • //registro puerto c • DDRC &= ~(1<< PORTC5); • PORTC &= ~(1<< PORTC5); • //registro puerto d • DDRD = 0xFE; • PORTD |= PIND_MASK; • //Configuración de USART a 9600 baudios • USART_Init(130);

23. //Mostramos por pantalla "pololu 3pi robot" • print_from_program_space(welcome_line1); • lcd_goto_xy(0,1); • print_from_program_space(welcome_line2); • delay_ms(1000); • //Mostramos por pantalla "wall follower" • clear(); • print_from_program_space(name_line1); • lcd_goto_xy(0,1); • print_from_program_space(name_line2); • delay_ms(1000); • //Muestra el voltaje de la bateria hasta que se presiona el boton b • while(!button_is_pressed(BUTTON_B)) • { • clear(); • print_long(read_battery_millivolts()); • print("mV"); • lcd_goto_xy(0,1); • print("Press B"); • delay_ms(100); • } • //Se mantendra hasta que se halla dejado de presionar el boton b • wait_for_button_release(BUTTON_B); • clear(); • print("Go!"); • } • //Programa principal • int main () • { • //Configuracion del 3pi • inicializar(); • //Declaración de variable • int i=0, j=0; • // valores que se obtienen del sensor de proximidad • // cerca da un valor superior a 350 • // lejos da un valor menor a 10 • const int set_point_f = 200; // distancia maxima • const int set_point_l = 300; // distancia minima

24. //Lazo infinito en espera de caracter recibido • while(1) • { • int front_proximity = analog_read(5); // lectura del sensor derecho • int left_proximity = analog_read(7); // lectura del sensor izquierdo • if(UCSR0A & (1 << RXC0)){ // pregunto si a llegado un dato por rx • i = UDR0; • } // rutina para obedecer las ordenes del butterfly, cuando se hallan presionado los botones siguientes // como prioridad 1 if(i == 'U') // ARRIBA { clear(); print("FORWARD"); set_motors(100,100); • }else if (i == 'D' ) //ATRÁS • { • clear(); print("BACK"); set_motors(-50,-50); • }else if (i == 'L') //IZQUIERDA • { clear(); print("LEFT"); • set_motors(-50,50); • }else if (i == 'R') //DERECHA • { clear(); print("RIGHT"); • set_motors(50, -50); • }else if(i == 'S'){ //ALTO • clear(); • print("STOP"); • set_motors(0,0); • i=0;

25. //rutina para el uso del sensor sharp de proximidad, de acuerdo a las siguientes condiciones como prioriodad • }else if( (front_proximity > set_point_l) && (left_proximity > set_point_l)){ // MUY CERCA • set_motors(-75, -75); // retrocedo • }else if( (front_proximity > set_point_f) && (left_proximity > set_point_f)){ // MUY LEJOS • set_motors(100, 100); // me aproximo }else if(front_proximity > set_point_f){ // ESTA A LA DERECHA • set_motors(75, -75); // roto a la derecha • }else if(left_proximity > set_point_l){ // ESTA A LA IZQUIERDA • set_motors(-75, 75); // roto a la izquierda • }else if( (front_proximity > 10) && (left_proximity > 10)){ // no encuentra el objeto del rango deseado set_motors( 0, 0); // detengo el vehiculo } delay_ms(50); } • } • //Implementación de procedimiento • /* • Se configuran los registros para la transmisión por USART • de manera que el dato recibido indica el BAUDRATE al cual • se va a trabajar • */ • void USART_Init(unsigned int baudrate) • { • // Set baud rate • UBRR0H = (unsigned char)(baudrate>>8); • UBRR0L = (unsigned char)baudrate; • //UCSR0A = (0<<U2X0); • // Enable receiver and transmitter • UCSR0B = (1<<RXEN0)|(1<<TXEN0); • // Async. mode, 8N1 • UCSR0C = (1<<USBS0)|(3<<UCSZ00); • }

26. Simulación Y Pruebas del Proyecto • Pruebas de simulación del Butterfly, que se encarga de transmitir los datos mediante RF

27. CONCLUSIONES • Al realizar el proyecto nos hemos familiarizado con las herramientas que ofrece el AVR studio 4, para programar microcontroladores de la familia ATMEL conociendo las beneficios y limitaciones del robot pololu 3pi y el Butterfly. • El Robot Pololu es un dispositivo muy útil en el campo de la Robótica ya que este puede realizar recorridos evitando obstáculos siguiendo a un móvil o no y puede ser controlado inalámbricamente o via remota. • El Kit AVR Butterfly es una poderosa herramienta de aprendizaje, es práctico, eficaz y muy amigable; que con el desarrollo del proyecto se va descubriendo progresivamente las características del microcontrolador ATmega169.

28. RECOMENDACIONES • Es necesario revisar las hojas de especificaciones antes de trabajar con los dispositivos y en el caso de el Butterfly y el Robot Pololu revisar su guía de usuario ya que ahí dan las recomendaciones para trabajar con ellos. • Es recomendable que las baterías para que el pololu trabaje este bien cargadas ya que este puede no permitir grabar bien el programa o más aun que el programador se queme. • Fijar bien las frecuencias de trabajo para que el buttetfly como para el pololu pueda transmitir.

29. Gracias