Sie sind auf Seite 1von 29

Ing.

Arnulfo Alegre Elera


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.
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
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.
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.
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.
Robot TRIC TRAC radio controlado por joystick de
play station 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.
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.
Requerimientos para el proyecto
Este proyecto se lo puede dividir en 2 secciones: Software
y Hardware.
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.
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.
Requerimientos para el proyecto
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).
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 ).
Diagrama de Bloque del Transmisor
Inicio

Inicialización de puertos

Inicialización de LCD y Joystick

Configuración de USART a 9600


baudios

Espera por botón

SI
Mostrar en LCD Transmitir carácter
Botón Arriba
“ARRIBA” ‘C’

NO

SI Mostrar en LCD Transmitir carácter


Botón Abajo
“ABAJO” ‘a’

NO

SI Mostrar en LCD Transmitir carácter


Botón Izquiedo
“IZQUIERDA” ‘I’

NO

SI Mostrar en LCD Transmitir carácter


Botón Derecho
“DERECHA” ‘R’

NO

SI Mostrar en LCD Transmitir carácter


Botón Centro
“CENTRO” ‘U’

NO
Código del transmisor
 //Declaración de constantes  //Prototipo de funciones
 #define Centro 0  int Obtener_Boton(void);
 #define Arriba 1
 #define Abajo 2  //Programa principal
 #define Izquierda 3  int main(void)
 #define Derecha 4  {
 #define Otros 5  //Se habilita las interrupciones globales
 sei();
 //Libreias a usar 
 #include <avr/io.h>  //Se muestra un mensaje a través del LCD
 #include <avr/interrupt.h>  PGM_P statetext = PSTR("AVR BUTTERFLY");
 #include <avr/pgmspace.h> 
 #include <avr/delay.h>  // Disable Analog Comparator (power save)
 #include <inttypes.h>  ACSR = (1<<ACD);

 //Librerias a usar  // Disable Digital input on PF0-2 (power save)
 #include <pololu/3pi.h>  DIDR0 = (7<<ADC0D);
 #include <pololu/orangutan.h>
 // Enable pullups
 //Librerias a usar que no pertenecen al entorno  PORTB = (15<<PB0);
 #include "mydefs.h"  PORTE = (15<<PE4);
 #include "LCD_functions.h" 
 #include "LCD_driver.h"
 #include "button.h" 
 #include "usart.h"
 //Lazo infinito

 while (1)
 {
 // Initialize pin change interrupt on joystick
 _delay_ms(50); // TIEMPO MINIMO DE
 Button_Init();
RETARDO DEL HM-TR ANTES DE ENVIAR OTRO
 DATO
 // initialize the LCD  if (statetext)
 LCD_Init();  {
 LCD_puts_f(statetext, 1);
 // set Clock Prescaler Change Enable  LCD_Colon(0);
 CLKPR = (1<<CLKPCE);  statetext = NULL;
 // set prescaler = 8, Inter RC 8Mhz / 8 = 1Mhz  }
 CLKPR = (0<<CLKPS1) | (1<<CLKPS0); 
 //Se espera a que sea presionado un botón
 //Configuración del USART a 52= 9600 baudios  input = Obtener_Boton();
 USART_Init(52); 
  //Se realiza una determinada acción según el
 if (statetext) botón presionado
 {  switch (input)
 LCD_puts_f(statetext, 1);  {
 LCD_Colon(0);  case Centro: // PRESIONO EL BOTON
 statetext = NULL; CENTRO
 }  statetext = PSTR("CENTRO");
 Usart_Tx('S');
  break;
 case Derecha: // PRESIONO EL BOTON DERECHA  /*
 statetext =  Función que retorna un valor entero correspondiente
PSTR("DERECHA"); al botón
 Usart_Tx('R');  presionado en el JoyStick
 break;  */
 case Izquierda: // PRESIONO EL BOTON  int Obtener_Boton(void)
IZQUIERDA  { int Temp1;
 statetext =
PSTR("IZQUIERDA");  //PB4-->O Centro
 Usart_Tx('L');  //PB6-->A Arriba
 break;  //PB7-->B Abajo
 case Arriba: // PRESIONO EL BOTON  //PE2-->C Izquierda
ARRIBA  //PE3-->D Derecha
 statetext = PSTR("ARRIBA");
 //Centro
 Usart_Tx('U');  Temp1=(PINB) & 0b00010000;
 break;  if(Temp1==0b00000000)
 case Abajo: // PRESIONO EL BOTON ABAJO  {
 statetext = PSTR("ABAJO");  sei();
 Usart_Tx('D');  return Centro;
 break;  }
 default:
 break;  //Arriba
 }  Temp1=PINB & 0b01000000;
 }  if(Temp1==0b00000000)
 return 0;  {
 }  sei();
 return Arriba;
 }
 //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;
 }
Diagrama de Bloque del Receptor
Inicio

Inicialización de puertos

Configuración de USART a 4800


baudios

Espera por dato

SI
Mostrar en LCD
Caracter C’ recibido Mover motores
ADELANTE

NO

SI Mostrar en LCD
Caracter ’a’ recibido Mover motores
“ATRÁS

NO

SI Mostrar en LCD
Caracter ‘I’ recibido Mover motores
IZQUIERDA

NO

SI Mostrar en LCD
Caracter R’ recibido Mover motores
DERECHA

NO

SI Mostrar en LCD
Caracter ‘U’ recibido Detener motores
“CENTER”

NO

Caracter erróneo Mostrar en LCD


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

 //Tiempo de refresco de la pantalla  //Configuración de USART a 9600 baudios


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

 }

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

set_motors(100,100);
 //rutina para el uso del sensor sharp de proximidad, de
acuerdo a las siguientes condiciones como prioriodad  //Implementación de procedimiento

 }else if( (front_proximity > set_point_l) &&  /*


(left_proximity > set_point_l)){ // MUY CERCA
 Se configuran los registros para la
 set_motors(-75, -75); // retrocedo transmisión por USART
 de manera que el dato recibido indica el
 }else if( (front_proximity > set_point_f) && BAUDRATE al cual
(left_proximity > set_point_f)){ // MUY LEJOS
 se va a trabajar
 set_motors(100, 100); // me aproximo
 */
}else if(front_proximity > set_point_f){ // ESTA A LA
DERECHA  void USART_Init(unsigned int baudrate)
  {
set_motors(75, -75); // roto a la derecha  // Set baud rate
 UBRR0H = (unsigned char)(baudrate>>8);
 }else if(left_proximity > set_point_l){ // ESTA A  UBRR0L = (unsigned char)baudrate;
LA IZQUIERDA  //UCSR0A = (0<<U2X0);

set_motors(-75, 75); // roto a la izquierda
 // Enable receiver and transmitter
 UCSR0B = (1<<RXEN0)|(1<<TXEN0);
 }else if( (front_proximity > 10) && (left_proximity >
10)){ // no encuentra el objeto del rango deseado
set_motors( 0, 0); // detengo el vehiculo  // Async. mode, 8N1
 UCSR0C = (1<<USBS0)|(3<<UCSZ00);
} delay_ms(50);  }
}
 }
Simulación Y Pruebas del Proyecto
 Pruebas de simulación del Butterfly, que se encarga de transmitir
los datos mediante RF
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.
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.
Gracias

Das könnte Ihnen auch gefallen