MS Luchador de Sumo Guía de usuario
Introducción
MS es un robot autónomo de morforlogía móvil, diseñado para competiciones de luchador de sumo en la categoría de Min Mi n (10 X 10 cm y un peso de 500 gramos). Se trata de un robot de tipo diferencial, diferencia l, su tracción basa en dos motores de corriente directa, alimentado por una batería de 9 Voltios. MS utiliza utiliza un microcontrolador de d e la marca Atmel modelo Atmega328, con firmware de Arduino, lo cual facilita su programación. programación.
Advertencias de seguridad y precauciones de uso
MS, Mini-sumo, no es un juguete. Puede ser usado por niños niños y jóvenes bajo la supervisión y ayuda de un adulto. El uso o abuso del producto es responsabilidad del usuario final. El distribuidor no se hace responsable por daños o lesiones que éste pueda causar durante su uso. Este producto no está diseñado para jugar, no debe usarse fuera de la A continuación se indican las precauciones: • •
•
• •
•
Antes de comenzar por favor lea cuidadosamente el manual. Utiliza baterías alcalinas o recargables. En el caso de las alcalinas asegúrate asegúrate que sean nuevas, y si compras recargables verifica que tengan suficiente carga, de lo contradio al programar lo puedes inutilizar para siempre. Condiciones de trabajo: ◦ superficie lisa, de preferencia melamina, ◦ interiores con luz controlada. controlada. No colocar la tarjeta de circuito impreso (PCB) sobre superficies metálicas. El robot MS esta ensamblado y soldado con piezas que contienen plomo y estaño, por lo cual es necesario lavarse las manos después de manipularlo. Los componentes del robot están expuestos, por lo que es importante no tocarlo con las manos mientras está en funcionamiento. Si nuestras manos están mojadas se puede causar un corto circuito y dañar uno o varios componentes.
Primeros pasos de MS ¿Qué necesitas? • Batería Batería de 9V. 9V. Utilice Utilice de prefer preferencia encia baterías baterías alcalinas alcalinas o recarga recargables. bles. Si trabaja trabajará rá durante durante tiempos prolongados con el robot, le recomendamos usar baterías recargables de NiquelMetal Hidruro, NiMH. No olvide comprar el cargador cargador correspondiente. • Cable A – B, USB a Micro USB. MS no requiere un programador externo, todo el hard hardwa ware re elect electró róni nico co ya se inclu incluye ye en el robo robot, t, pero pero para para la comu comuni nica cació ción n entr entree la computadora computadora y el e l robot se requiere dicho cable. • Computadora. Necesitas una computadora para programar el robot. Para ello se utiliza la interfaz de programación de Arduino, plataforma libre, que funciona en cualquiera de los siguientes sistemas operativos: ◦ Windows ◦ Mac ◦ Linux • Material para pruebas. Es necesario que tenga a mano papel, cartulinas, cartoncillo y cinta aislante negra o blanca, blanca, para improvisar pistas y probar el robot.
Conoce más de MS
Figura 1. Vista frontal de robot luchador de sumo MS Ms es un robot de morfología móvil de tipo diferencial, es decir se desplaza por medio de dos ruedas con dos motores, uno para cada una. El cerebro de esta robot es un Arduino Nano, y está encargado de procesar la información que le proveen los sensores para realizar correcciónes a través de los motores, bajo el esquema básico de control. Hardware de MS
En la figura 1 se muestra el hardware del robot. Observe que se cuenta con varios componentes y dispositivos electrónicos. ¿Reconoce alguno?, a continuación se explican brevemente. • Sensores reflectivos de contraste, son los encargados de percibir la información del ambiente, en este caso el contraste, la diferencia entre o blanco y lo negro, lo que no brilloso y lo opaco. Este dispositivo se compone de dos partes: emisor y receptor. Tanto el primero como el segundo trabajan en el rango infrarrojo de la luz. Ésta no es perceptible por el ojo humano, pero con ayuda de una cámara digital se observa.
•
•
•
•
•
LEDs. Diodos emisores de luz por sus siglas en inglés, son dispositivos que emiten una luz al
circular una corriente por sus terminales. En MS se usan como indicadores indicadores y son programables por el usuario por medio del Arduino. Driver para motor. Basado en un circuito integrado integrado de Puente H, es el que proveen de potencia a los motores, siendo la interfaz entre el microcontrolador y el motor. Botones. Son interruptores de encendido al contacto. El robot cuenta con 2, el primero para reiniciar el microcontrolador (arduino), y el segundo como botón de usuario para propósito general. Motorreductores. Son motores de corriente directa (CD, como el de las baterías), con una caja de engranes adaptada. Los usados en MS tienen una reducción de 48:1, esto es, por cada 48 vueltas que gire el motor, el eje del reductor girará 1 vuelta. De este modo se incrementa el torque, fuerza, y se reduce la l a velocidad. Batería. Es la que provee de energía eléctrica a todo el robot, arduino, sensores, LEDs, motores, pulsadores. Es tipo rectangular de 9V.
Figura 2. Vista trasera de MS de MS
Arduino Nano
Es una pequeña y completa placa basada en el mirocontrolador Atmega328 que generalmente se usa para hacer prototipos. Tiene más o menos la misma funcionalidad que el Arduino UNO, pero con una presentación más compacta. No posee conector para alimentación externa, y funciona con un cable USB Mini-B en ez del cable estándar.
Figura 3. Arduino Nano Especificaciones • Microcontrolador: Atmega328. • Tensión de operación (nivel lógico): 5 Voltios. • Tensión de entrada (recomendada): 7-12 Voltios. • Tensión de entrada (límites): 6-20 Voltios. • Pines E/S digitales: 14 (de los cuales 6 proveen de salida PWM). • Entradas Analógicas: 8 • Corriente máxima por cada PIN de Entrada/Salida: Entrada/Salida: 40mA • Memoria Flash: 32KB. • SRAM: 2KB • EEPROM: 1KB. • Dimensiones: 18.5 mm x 23.2 mm.
Alimentación
El Arduino Nano puede ser alimentado usando el cable USB Mini-B , con una fuente externa no regulada de 6-20V (pin 30), o con una fuente externa regulada de 5V (pin 27). La fuente de alimentación es seleccionada automáticamente a aquella con mayor tensión. El chip FTDI FT232RL que posee el Nano solo es alimentado si la placa esta siendo alimentada usando el cable USB. como resultado, cuando se utiliza una fuente externa (no USB), la salida de 3.3V (la cual es proporcionada por el chip FTDI) no está disponible y los pines 1 y 0 parpadearán si los pines digitales 0 o 1 están a nivel alto. Memoria
El ATmega168 posee 16KB de memoria flash para almacenar el codigo (de los cuales 2KB son usados por el bootloader); el ATmega 328 posee 32KB, (también con 2 KB usados por el bootloader). El Atmega168 posee 1KB de SRAM y 512 bytes de EEPROM (la cual puede ser leida y escrita con la librería EEPROM); el ATmega328 ATmega328 posee 2 KB de SRAM y 1KB de EEPROM. EE PROM. Entrada y Salida
Cada uno de los 14 pines digitales del Nano puede ser usado como entrada o salida, usando las funciones pinMode(), digitalWrite(), y digitalRead(). Operan a 5 voltios. Cada pin puede proveer o recibir un máximo de 40mA y poseen una resistencia de pull-up (desconectada (desconectada por defecto) de 20 a 50 kOhms. Además algunos pines poseen funciones especializadas: especializadas: • Serial: 0 (RX) y 1 (TX). (RX) usado para recibir y (TX)usado para transmitir datos TTL vía serie. Estos pines están conectados a los pines correspondientes del chip USB-a-TTL de FTDI. • Interrupciones Externas: pines 2 y 3. Estos pines pueden ser configurados para activar una interrupción por paso a nivel bajo, por flanco de bajada o flanco de subida, o por un cambio de valor. Mira la función attachInterrupt() para más detalles. • PWM: pines 3, 5, 6, 9, 10, y 11. Proveen de una salida PWM de 8-bits cuando se usa la función analogWrite(). • SPI: pines 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan la comunicación SPI, la cual, a pesar de poseer el hardware, hardware, no está actualmente actualmente soportada en el lenguaje Arduino. • LED: Pin 13. Existe un LED conectado al pin digital 13. Cuando el pin se encuentra en nivel alto, el LED está encendido, cuando el pin está a nivel bajo, el LED estará apagado. El Nano posee 8 entradas analógicas, cada unas de ellas provee de 10 bits de resolución (1024 valores diferentes). Por defecto miden entre 5 voltios y masa, sin embargo es posible cambiar el rango superior usando la función analogReference(). También, algunos de estos pines poseen funciones especiales: • I2C: I2C: Pine Piness 4 (SDA (SDA)) y 5 (SCL (SCL). ). Sopo Soport rtaa comu comuni nica cació ción n I2C I2C (TWI) (TWI) usan usando do la libre librerí ríaa Wire Wire (documentación en la web Wiring). Hay algunos otros pines en la l a placa: • AREF. AREF. Tensión ensión de refer referenc encia ia por las entra entrada dass analóg analógica icas. s. Se config configur uraa con la función función analogReference(). • Reset. Pon esta linea a nivel bajo para resetear el microcontrolador. Normalmente se usa para añadir un botón de reset que mantiene a nivel alto el pin reset mientras no es pulsado.
Diagrama Pictórico
Figura 4. Diagrama pictórico de circuito de MS
Programando en Arduino
Para programa el robot luchador de sumo es neces ario contar con el entorno de programación de Arduino. Si aún no lo tiene lo puede descargar en: www.arduino.cc www.arduino.cc en en la sección de descargas. Es recomendable que la versión de arduino que descarque sea igual i gual o posterior a las 1.0.
Figura 5. Captura de pantalla de entorno de programación Arduino versión 1.0.1 Componentes de Arduino IDE
•
•
Figura 6. Icono “Verificar” Verificar. inspecciona el código generado, marca errores y posibles soluciones.
Figura 7. Ícono: “Cargar” Cargar: Cuando se presiona este botón se compila y ensambla el código contenido en la ventana y se descarga a la tarjeta electrónica de Arduino. Este proceso puede tardar algunos segundos o tal vez un para de minutos.
•
Figura 8. Ícono: “Nuevo”. Nuevo: crea un nuevo “sketch” en blanco.
•
Figura 9. Ícono: “Abrir”. Abrir: abre un “sketch”, código, ya existente.
•
Figura 10. Ícono: “Guardar”. Guardar: salva las modificaciones realizadas en el código.
•
Figura 11. Ícono: “Monitor Serial”. Monito Monitorr Serial Serial:: abre abre la aplica aplicació ción n de monito monitorr serial serial,, que que puede puede servir servir para para difere diferent ntes es propósitos.
Referencias Referencias del lenguaje Los programas hechos con Arduino se dividen en tres partes principales: • Estructura, • valores (variables y constantes), • funciones. El lenguaje de programación Arduino se basa en C/C++. Estructuras Las dos estructuras principales son las siguientes: • setup(), es la estructura donde se configura las entradas, salidas y los módulos. Es llamado también como “inicialización”. “inicialización”. Lo contenido en esta estructura se ejecuta sólamente una vez al inicio del programa. programa. • loop(), es la estructura donde se escribe el código, y se repetirá infintas veces. Valores Constantes • HIGH, alto, • LOW, bajo, • INPUT, entrada, • OUTPUT, salida, • True, verdadero, • false, falso,
Variables: • boolean, booleando, • char, carácter, • byte, 8 bits • int, entero, • unsigned int, entero sin signo, • long, entero de 32 bits, • unsigned long, entero 32 bits sin si n signo, • float, punto flotante. Funciones • pinMode(), configura si el pin digital será salida o entrada, • digitalWrite(), si el pin ha sido configurado como salida digital, su voltaje de salida será 0 o 5V. • digitalRead(), digitalRead(), lectura del valor digital del pin especificado, • analogRead(), analogRead(), lectura del valor analógico del pin especificado, • analogWrite(), analogWrite(), configura la modulación por anchura de pulso de un pin (PWM), • delay(), pausa en milisegundos. • Serial, librería incluida para el uso y configuración del módulo serial. Revisa la referencia del lenguaje de arduino para aprender más acerca de las estructuras, variables y funciones de Arduino.
El primer programa en Arduino para MS
Un sencillo programa de demostración está disponible en los ejemplos de Arduino, “Archivo/Ejemplos/01.Basics/Blink”.
Figura 12. El primer programa programa en Arduino Este sencillo programa prende y apaga un LED, colocado en la patilla, pin 13. /* Blink Turns on an LED on for one second, then off for one second, repeatedly. */ // Pin 13 has an LED connected on most Arduino boards. int led = 13; // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinMode(led, OUTPUT); } // the loop routine runs over and over again forever: void loop() {
digitalWrite(led, digitalWrite(led, HIGH); // turn the LED on (HIGH is the the voltage voltage level) delay(1000); // wait for a second digitalWrite(led, digitalWrite( led, LOW); // turn the LED off by making the voltage LOW LOW delay(1000); // wait for a second } Abierto el programa de ejemplo es necesario seleccionar la tarjeta correspondiente, en el caso del robot robot seguidor seguidor de línea, línea, se trat trataa de un Ardui Arduino no Nano Nano Atmeg Atmega32 a328, 8, para para ello diríjase diríjase al menú menú Herramientas/Tarjeta/Arduino Nano w/Atmega328.
Figura 13. Selección de tarjeta Arduino Nano w/ATmega328 Ahora se verificará que el código escrito sea correcto, presione el ícono verificar:
Lo que hará esta función será “traducir” todo lo codificado a un “idioma” que entienda el microcont contro rola lado dorr. Obse Observ rvee los los avis avisos os y erro errore ress de sali salida da most mostra rado dos. s. Si el prog progra rama ma se comp compililaa
correctamente, correctamente, el mensaje de salida deberá ser como se muestra en la figura:
Figura14. Mensajes de salida Una vez compilado y verificado el programa, y en vista que no existen errores o advertencias, se procede a cargar el programa a la tarjeta de Arduino. Para ello antes es importante seleccionar el puerto de comunicación serial “COM” correcto. Para ello se puede hacer lo siguiente: • Abra el administrador administrador de dispositivos, • En la pestaña “Puertos (COM y LPT)”, verifique el puerto en el cual está ubicado el Arduino. Generalmente tiene el nombre de “USB Serail Port”.
Figura 15. Verificación del del puerto COM del del Arduino
Una vez identificado, identificado, se selecciona en el IDE, Herramientas/Puerto Herramientas/Puerto serial/COMx serial/COMx
Figura 16. Selección del Puerto Serial Cargue el programa a la tarjeta de Arduino presionando el ícono de cargar. Esta acción puede tardar algunos segundos.
Figura 17. Carga de programa a tarjeta de Arduino Si la carga fue exitosa se desplegará el siguiente mensaje:
Figura 18. Carga Exitosa
Eemplos y proyectos Ahora que sabe como compilar y cargar un prorama a la tarjeta de Arduino es tiempo de aprender a diseñar y codificar programas más complicados. Comenzará con los más sencillos. Ejemplo 1: Luces estilo el “serie de navidad”
Figura 19. Tarjeta de MS La tarjeta del robot seguidor de línea incluye 3 indicadores LED's para el propósito General. Éstos se encuentran en los pines digitales 9,10, 13 marcados como B4, B5, RUN en ese preciso orden. La secuencia que se quiere lograr es la siguiente:
Figura 20. Luces de navidad El código de este este progra programa ma se encuentr encuentraa disponible disponible en la página Web: www.andromie.com www.andromie.com en la sección del blog en la l a etiqueta de Luchador de Sumo MS. /* --------------------Inicio de Código-------------------- */ int runled = 13; //Alias para pin 13 int led0 = 9; //Alias para pin 9
int led1 = 10; //Alias para pin 10 void setup() { //Configuración de entradas y salidas pinMode(runled, OUTPUT); OUTPUT); //Salida digital en runled runled = pin 13 pinMode(led0, OUTPUT); //Salida digital en led0 = pin 9 pinMode(led1, OUTPUT); //Salida digital en led1 = pin 10 //Configuración de módulos } void loop() { //Código que se repetirá infititamente infititamente digitalWrite(led0, HIGH); //Puesta en alto de led0, prende digitalWrite(led1, digitalWrite(led1, LOW); //Puesta en bajo de led1, apaga apaga //OJOOOO! //RunLED usa lógica negativa, cuando es ato apaga, y cuando es bajo prende digitalWrite(runled, HIGH);//Pues en alto de RunLED delay(250); digitalWrite(led0, digitalWrite(led0, LOW); //Puesta en bajo de led0, apaga apaga digitalWrite(led1, HIGH); //Puesta en alto de led1, prende //OJOOOO! //RunLED usa lógica negativa, cuando es ato apaga, y cuando es bajo prende digitalWrite(runled, HIGH); delay(250); digitalWrite(led0, digitalWrite(led0, LOW); //Puesta en bajo de led0, apaga apaga digitalWrite(led1, LOW); //Puesta en alto de led1, prende //OJOOOO! //RunLED usa lógica negativa, cuando es ato apaga, y cuando es bajo prende digitalWrite(runled, LOW); delay(250); } /* --------------------Fin de código-------------------- */ Es un ejemplo sencillo pero ayuda a comprender el manejo de los pines digitales como salidas.
Eercicio ! Desarrollo un código para realice la siguiente secuencia de encendido y apagado de LEDs.
Eemplo ": Encendido de un LE# con un interruptor sin contacto$ La tarjeta de MS cuenta con 2 sensores del tipo reflectivo infrarrojo. Este tipo está compuesto de dos componentes un emisor y un receptor. El primero es un LED infrarrojo, luz que no podemos ver los ojos; el segundo es un fototransistor fototransistor con filtro de luz de día. El funcionamiento es el siguiente:
Figura 21. Sensor Reflectivo sobre superficie reflejante. Cuando el LED infrarrojo se encuentre emitiendo luz, si la superfice es reflejante, por ejemplo blanca, se refleja una cantidad de luz que es percebida por el fototransistor fototransistor,, que convierte la señal luminosa en voltaje, permite un flujo de corriente entre sus terminales y por la configuración de carga de emisor se obtiene un valor.
Figura 22. Sensor Reflectivo sobre superficie opaca Por lo contrario si el la superficie es opaca, por ejemplo negra, se refleja poca luz, la cual es percibida por el fototransisto, pero se genera poca corriente en sus terminales y por consiguiente poco voltaje. Este sensor no puede servir como un interruptor sin contacto, y se usa comúnmente en muchos procesos de la industra y cotidianos, tal es caso de las llaves automáticas de agua usadas en los baños públicos. La intensión es que cuando coloque su dedo frente al sensor este active el LED. A continuación se propone el código. /*--------------------------------Inicio del código--------------------------------*/ //Declaración de variables globales int PisoDerecho; int runled = 13; //Alias para pin 13 int led0 = 9;
void setup() { //Configuración de entradas y salidas pinMode(led0, OUTPUT); OUTPUT); //Salida digital digital en led0 = pin 9 //Configuración de módulos } void loop() { //Código que se repetirá infititamente infititamente PisoDerecho = analogRead(A2); //Lectura del sensor Izquierdo I zquierdo if (PisoDerecho > 512) //Si la superficie es blanca entonces entonces prende prende LED { digitalWrite(led0, HIGH); } else //Sino, es decir, es negro, entonces apaga LED { digitalWrite(led0, digitalWrite(led0, LOW); } delay(50); } /*--------------------------------Fin del código--------------------------------*/ El funcionamiento de este será el siguiente, cuando coloque su dedo cerca del sensor marcado como “A2” en el PCB del robot el indicador LED marcado como B4 se encenderá, sino se mantendrá apagado, como se muestra en la siguiente figura.
Figura 23. Funcionamiento del programa
Eemplo %: Accionar de motores$ Para probar los motores tenemos que conectarlos en los terminales (verdes con tornillos), marcados como “Motor A” y “Motor B”. En la siguiente figura se muestra a manera de ejemplo la conexión.
Figura 24. Conexión de motores También es necesario conectar la batería con interruptor. Sea cuidadoso al conectar la batería, conecte el cable rojo del broche de la batería (positivo) en el tornillo del terminal verde marcado con “+V”, y el negro (común, tierra) conéctelo al otro lado del terminal, marcado con “GND”. Puede guiarse de la siguiente figura para conectarlo. Corte la alimentación con el interruptor.
Figura 25. Conexión de batería
Copie y pegue el siguiente código en la ventana del IDE de Arduino. /*--------------------------------Inicio del código--------------------------------*/ int runled = 13; //Alias para pin 13 int led0 = 9; //Alias para pin 9 int led1 = 10; //Alias para pin 10 int motorDerecha0 = 6; int motorDerecha1 = 11; int pwmDerecha = 5; int motorIzquierda0 motorIzquierda0 = 7; int motorIzquierda1 motorIzquierda1 = 8; int pwmIzquierda= 3; int ProximidadDerecho; ProximidadDerecho; int ProximidadIzquierdo; void setup() { //Configuración de entradas y salidas pinMode(runled, OUTPUT); OUTPUT); //Salida digital en runled runled = pin 13 pinMode(led0, OUTPUT); //Salida digital en led0 = pin 9 pinMode(led1, OUTPUT); //Salida digital en led1 = pin 10 pinMode(motorDerecha0,OUTPUT); pinMode(motorDerecha1,OUTPUT); pinMode(motorDerecha1,OUTPUT); pinMode(pwmDerecha, OUTPUT); pinMode(motorIzquierda0,OUTPUT); pinMode(motorIzquierda0,OUTPUT); pinMode(motorIzquierda1,OUTPUT); pinMode(motorIzquierda1,OUTPUT); pinMode(pwmIzquierda, pinMode(pwmIzquierda, OUTPUT); //Configuración de módulos } void loop() { //Código que se repetirá infititamente infititamente //Adelante digitalWrite(motorDer digitalWrite(motorDerecha0, echa0, HIGH); digitalWrite(motorDerecha1, LOW); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIz digitalWrite(motorIzquierda0, quierda0, HIGH); digitalWrite(motorIzquierda1, LOW); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); delay(1000); //Atras digitalWrite(motorDerecha0, LOW); digitalWrite(motorDer digitalWrite(motorDerecha1, echa1, HIGH); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIzquierda0, LOW); digitalWrite(motorIz digitalWrite(motorIzquierda1, quierda1, HIGH); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); delay(1000); //detenido digitalWrite(pwmDerecha, LOW); digitalWrite(pwmIzquierda, LOW); delay(1000); } /*--------------------------------Fin del código--------------------------------*/ Funcionamiento
El robo robott debe deberá rá ir hacia hacia adel adelan ante te,, desp despué uéss hacia hacia atrá atráss y por por últi último mo dete detene ners rse. e. Se repe repeti tirá rá infinitamente. Verifique que la secuencia descrita corresponda con el movimiento del robot. Si alguno de los motores gira en sentido contrario contrario invierta los cables en los terminales de tornillo (verdes).
Eercicio "
Acomplete la siguiente tabla. Con los movimientos propuestos propuestos y resultantes resultantes desarrolle un código en el ejecuten con una duración de 1 segundo. Motor izquierdo
Motor Derecho
Movimiento de Robot
Adelante
Adelante
Adelante
Atrás
Atrás
Atrás
Atrás
Adelante
Adelante
Atrás
Adelante
Detenido
Detenido
Detenido
Detenido
Eemplo &: 'isuali(ación del valor de los sensores en monitor serial$ Una de las grandes ventajas de las tarjetas de Arduino es su simplicidad para establecer conexión con una computadora. Esto se realiza gracias al convertivor USB a serial incluido en la tarjeta. A demás el entorno de programación cuenta con una aplicación, monitor serial, que sirve para visualizar, visualizar, recibir y enviar informa i nformación. ción. El siguiente programa obtiene el valor de los sensores reflectivos analógico, los cuantifica y los despliega. La cuantificación es el proceso por el cual se le asigna un valor en bits a una señal. Los convertidores convertidores CAD, Analógico a Decimal, cuantifican las señales, es decir entregan un valor en número dependiendo de la resolución que posean. En el caso del microcontrolador que se usa, Atmega328, la resolució resolución n es de 10 bits, es decir 1024 divisione divisioness en la escala del 0 al 5V. 5V. Una buen analogía analogía es la siguiente: Suponga que tiene una escalera de 5 metros con 1024 escalones, cada escalón le hará subir 0.0048 metros. Si otra persona le indica que tiene que pintar una linea a 2.5 metros del piso, ¿Cuántos escalones tendrá que subir?, esto puede resolverse por una simple regla de tres: Dato =
2.5metros∗1024escalones 5metros
512escalones
=
A grosso modo eso es lo que hace un convertidor Analógico a Digital, convierte un voltaje en un dato que pueda manipular. Para realizar la calibración los sensores o para obtener información de ellos se puede realizar un programa que muestre los datos en el monitor serial. A continuación se propone el código para realizar esta tarea. /*--------------------------------Inicio del código--------------------------------*/ int runled = 13; //Alias para pin 13 int led0 = 9; //Alias para pin 9 int led1 = 10; //Alias para pin 10 int PisoDerecho; int PisoIzquierdo; PisoIzquierdo; void setup() { //Configuración de entradas y salidas pinMode(runled, OUTPUT); OUTPUT); //Salida digital en runled runled = pin 13 pinMode(led0, OUTPUT); //Salida digital en led0 = pin 9 pinMode(led1, OUTPUT); //Salida digital en led1 = pin 10 //Configuración de módulos Serial.begin(9600); //Configuración de baudrate baudrate } void loop() {
//Código que se repetirá infititamente infititamente PisoDerecho = analogRead(A2); //Lectura analógico del sensor derecho PisoIzquierdo = analogRead(A3); analogRead(A3); //Lectura analógica del sensor izquierdo Serial.print("Sensor de piso derecho: "); //Impresión de leyenda (texto) Serial.println(PisoDerecho); //Imprime el valor obtenido en la l a lectura Serial.print("Sensor de piso izquierdo: "); //Impresión de leyenda (texto) Serial.println(PisoIzquierdo); Serial.println(PisoIzquier do); //Imprime el valor obtenido en la lectura delay(1000); } /*--------------------------------Fin del código--------------------------------*/ Funcionamiento
Una vez compilado y descargado el código se deberá abrir el monitor serial dentro del IDE de Arduino para ver los datos.
Figura 26. Recepción de datos por el monitor Serial En la figura se puede observar los valores obtenidos sobre una superficie opaca, en la parte superior, y en la posterior sobre una superficie reflejante. Estos datos son importantes para la determinación del umbral para la detección del borde del dohyo.
Eercicio %
Desarrolle el código para un programa que muestre por el monitor serial el valor de los sensores en Voltaje. Sugerencia
Para obtener obtener el valor en voltaje puede emplear la l a siguiente fórmula: Voltaje =
ValorObtenidoCAD∗5Voltios 1024
Si en el ejemplo anterior se obtuvo el valor de 217 para el sensor de piso derecho su equivalente en voltaje se puede obtener la siguiente manera: manera: Voltaje =
217∗5Voltios 1024
1.05 voltios es el valor que se deberá desplegar.
=1.05
Voltios
Eercicio &:
Desarrolle un código para desplegar el valor obtenido por CAD del sensor conectado en la entrada A0. Coloque el robot en una posición fija. Coloque objetos a diferentes distancias distancias y haga anotaciones.
Figura 27. Caraterización del sensor Dist istancia cia (ce (cen ntíme ímetros)
Valor lor Ob Obtenid enido o en en CA CAD (0 (0-10 -1024) Valor lor en en Vo Volta ltaje (0-5Voltio ltioss)
60 50 40 20 10 5 A partir de los voltajes obtenidos en cada una de las distancias construya una gráfica, colocando en el eje “X” la distancia (centímetros) y en el eje “Y” el voltaje.
Figura 28. Curva característica del Sensor SHARP GP2Y0A21YK Compare sus resultados con los datos característicos del sensor mostrados en la figura.
Eemplo ): Minisumo * +ásico Explicación del concurso
Consiste en un combate entre dos robots que discurrirá por una tarima, también denominada dohyo o ring, y consiste en marcar puntos “Yukoh”. Los combates se componen de dos asaltos de 3 minutos máximo, cada uno, más un terecer asalto en caso de empate. El primer competidor en alcanzar dos puntos de Yukoh Yukoh será el ganador de la lucha. El competidor que gane un punto de yukoh en el tercer combate, será el ganador.
Figura 29. Competición seguidor de línea, lí nea, persecución Construya una pista para prueas
Es importante tener una pista o construir una con los siguientes materiales. • Cartulina blanca, • cinta de aislar negra, • tijeras. Para hacer pruebas dibuje un dohyo como el que se muestra en la figura. Por facilidad use una cartulina blanca, fondo, fondo, y la linea que delimite el “ring” “ring ” de color negro. Se propone el siguiente código, copie y pegue en el área de código del IDE de Arduino. /*--------------------------------Inicio del código--------------------------------*/ int runled = 13; //Alias para pin 13 int led0 = 9; //Alias para pin 9 int led1 = 10; //Alias para pin 10 int motorDerecha0 = 6; int motorDerecha1 = 11;
int pwmDerecha = 5; int motorIzquierda0 motorIzquierda0 = 7; int motorIzquierda1 motorIzquierda1 = 8; int pwmIzquierda= 3; int ProximidadDerecho; ProximidadDerecho; int ProximidadIzquierdo; int PisoDerecho; int PisoIzquierdo; PisoIzquierdo; //Funciones void adelante(); void atras(); void detenido(); void giroderecha(); void giroizquierda(); giroizquierda(); void setup() { //Configuración de entradas y salidas pinMode(runled, OUTPUT); OUTPUT); //Salida digital en runled runled = pin 13 pinMode(led0, OUTPUT); //Salida digital en led0 = pin 9 pinMode(led1, OUTPUT); //Salida digital en led1 = pin 10 pinMode(motorDerecha0,OUTPUT); pinMode(motorDerecha1,OUTPUT); pinMode(motorDerecha1,OUTPUT); pinMode(pwmDerecha, OUTPUT); pinMode(motorIzquierda0,OUTPUT); pinMode(motorIzquierda0,OUTPUT); pinMode(motorIzquierda1,OUTPUT); pinMode(motorIzquierda1,OUTPUT); pinMode(pwmIzquierda, pinMode(pwmIzquierda, OUTPUT); //Configuración de módulos } void loop() { //Código que se repetirá infititamente infititamente PisoDerecho = analogRead(A2); analogRead(A2);
PisoIzquierdo = analogRead(A3); analogRead(A3); if(PisoDerecho < 512 || PisoIzquierdo < 512) { atras(); delay(200); giroderecha(); delay(200); } else { adelante(); } } void adelante() { digitalWrite(motorDer digitalWrite(motorDerecha0, echa0, HIGH); digitalWrite(motorDerecha1, LOW); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIz digitalWrite(motorIzquierda0, quierda0, HIGH); digitalWrite(motorIzquierda1, LOW); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } void atras() { digitalWrite(motorDerecha0, LOW); digitalWrite(motorDer digitalWrite(motorDerecha1, echa1, HIGH); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIzquierda0, LOW); digitalWrite(motorIz digitalWrite(motorIzquierda1, quierda1, HIGH); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } void detenido() { digitalWrite(pwmDerecha, LOW); digitalWrite(pwmIzquierda, LOW); } void giroderecha()
{ digitalWrite(motorDerecha0, LOW); digitalWrite(motorDer digitalWrite(motorDerecha1, echa1, HIGH); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIz digitalWrite(motorIzquierda0, quierda0, HIGH); digitalWrite(motorIzquierda1, LOW); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } void giroizquierda() giroizquierda() { digitalWrite(motorDer digitalWrite(motorDerecha0, echa0, HIGH); digitalWrite(motorDerecha1, LOW); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIzquierda0, LOW); digitalWrite(motorIz digitalWrite(motorIzquierda1, quierda1, HIGH); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } /*--------------------------------Fin del código--------------------------------*/ ,uncionamiento
Una vez descargado el código y en funcionamiento el robot deberá deslizarse sobre la superficie del “ring”, al llegar al borde, línea negra, deberá regresar hacia atrás y dar vuelta. En este ejemplo únicamente se usan los sensores para detectar el borde.
Eemplo -: Minisumo Intermedio En el siguiente código se emplean los sensores de proximidad proximidad para ubicar al oponente. El código propuesto /*--------------------------------Inicio del código--------------------------------*/ int runled = 13; //Alias para pin 13 int led0 = 9; //Alias para pin 9 int led1 = 10; //Alias para pin 10 int motorDerecha0 = 6; int motorDerecha1 = 11; int pwmDerecha = 5; int motorIzquierda0 motorIzquierda0 = 7; int motorIzquierda1 motorIzquierda1 = 8; int pwmIzquierda= 3; int ProximidadDerecho; ProximidadDerecho; int ProximidadIzquierdo; int PisoDerecho; int PisoIzquierdo; PisoIzquierdo; //Funciones void adelante(); void atras(); void detenido(); void giroderecha(); void giroizquierda(); giroizquierda(); void setup() { //Configuración de entradas y salidas pinMode(runled, OUTPUT); OUTPUT); //Salida digital en runled runled = pin 13 pinMode(led0, OUTPUT); //Salida digital en led0 = pin 9 pinMode(led1, OUTPUT); //Salida digital en led1 = pin 10 pinMode(motorDerecha0,OUTPUT); pinMode(motorDerecha1,OUTPUT); pinMode(motorDerecha1,OUTPUT); pinMode(pwmDerecha, OUTPUT); pinMode(motorIzquierda0,OUTPUT); pinMode(motorIzquierda0,OUTPUT);
pinMode(motorIzquierda1,OUTPUT); pinMode(motorIzquierda1,OUTPUT); pinMode(pwmIzquierda, pinMode(pwmIzquierda, OUTPUT); //Configuración de módulos giroderecha(); giroderecha(); } void loop() { //Código que se repetirá infititamente infititamente ProximidadDerecho = analogRead(A0); analogRead(A0); ProximidadIzquierdo ProximidadIzquierdo = analogRead(A1); analogRead(A1); PisoDerecho = analogRead(A2); analogRead(A2); PisoIzquierdo = analogRead(A3); analogRead(A3); //Condición principal if(PisoDerecho > 512 || PisoIzquierdo > 512) { atras(); delay(200); giroderecha(); delay(200); } if(ProximidadDerecho if(ProximidadDerecho > 350 && ProximidadIzquierdo ProximidadIzquierdo > 300) { adelante(); } if(ProximidadDerecho < 350 && ProximidadIzquierdo ProximidadIzquierdo > 300) { giroizquierda(); } if(ProximidadDerecho > 350 && ProximidadIzquierdo ProximidadIzquierdo < 300) { giroderecha(); } } void adelante() { digitalWrite(motorDer digitalWrite(motorDerecha0, echa0, HIGH);
digitalWrite(motorDerecha1, LOW); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIz digitalWrite(motorIzquierda0, quierda0, HIGH); digitalWrite(motorIzquierda1, LOW); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } void atras() { digitalWrite(motorDerecha0, LOW); digitalWrite(motorDer digitalWrite(motorDerecha1, echa1, HIGH); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIzquierda0, LOW); digitalWrite(motorIz digitalWrite(motorIzquierda1, quierda1, HIGH); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } void detenido() { digitalWrite(pwmDerecha, LOW); digitalWrite(pwmIzquierda, LOW); } void giroderecha() { digitalWrite(motorDerecha0, LOW); digitalWrite(motorDer digitalWrite(motorDerecha1, echa1, HIGH); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIz digitalWrite(motorIzquierda0, quierda0, HIGH); digitalWrite(motorIzquierda1, LOW); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); } void giroizquierda() giroizquierda() { digitalWrite(motorDer digitalWrite(motorDerecha0, echa0, HIGH); digitalWrite(motorDerecha1, LOW); digitalWrite(pwmDerecha, digitalWrite(pwmDerecha, HIGH); digitalWrite(motorIzquierda0, LOW); digitalWrite(motorIz digitalWrite(motorIzquierda1, quierda1, HIGH); digitalWrite(pwmIzquier digitalWrite(pwmIzquierda, da, HIGH); }
/*--------------------------------Fin del código--------------------------------*/ ,uncionamiento
El robot comenzará a rotar sobre su eje hasta encontrar un objeto cercano, con una distancia no mayor a 25 centímetros. Cuando lo encuentre lo empujará hasta el borde del dohyo y retornará a él. Eercicio &:
Modifique el código para que el robot comience su funcionamiento 5 segundos después de su encendido.
