Documentos de Académico
Documentos de Profesional
Documentos de Cultura
RTP Guia de Usuario Robot Ms
RTP Guia de Usuario Robot Ms
Luchador de Sumo
Guía de usuario
Introducción
MS, Mini-sumo, no es un juguete. Puede ser usado por 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 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.
• 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 de 9V. Utilice de preferencia baterías alcalinas o recargables. Si trabajará durante
tiempos prolongados con el robot, le recomendamos usar baterías recargables de Niquel-
Metal Hidruro, NiMH. No olvide comprar el cargador correspondiente.
• Cable A – B, USB a Micro USB. MS no requiere un programador externo, todo el
hardware electrónico ya se incluye en el robot, pero para la comunicación entre la
computadora y el 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, para improvisar pistas y probar el robot.
Conoce más de 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 y son programables
por el usuario por medio del Arduino.
• Driver para motor. Basado en un circuito 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 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.
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”. Lo contenido en esta estructura se ejecuta sólamente una vez al
inicio del 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 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(), lectura del valor digital del pin especificado,
• analogRead(), lectura del valor analógico del pin especificado,
• 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”.
Lo que hará esta función será “traducir” todo lo codificado a un “idioma” que entienda el micro-
controlador. Observe los avisos y errores de salida mostrados. Si el programa se compila
correctamente, el mensaje de salida deberá ser como se muestra en la figura:
/* --------------------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); //Salida digital en 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
digitalWrite(led0, HIGH); //Puesta en alto de led0, prende
digitalWrite(led1, LOW); //Puesta en bajo de led1, 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, LOW); //Puesta en bajo de led0, 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, LOW); //Puesta en bajo de led0, 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.
Ejercicio 1
Desarrollo un código para realice la siguiente secuencia de encendido y apagado de LEDs.
Ejemplo 2: Encendido de un LED 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 con filtro de luz de día.
El funcionamiento es el siguiente:
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, 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.
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.
//Configuración de módulos
}
void loop()
{
//Código que se repetirá infititamente
PisoDerecho = analogRead(A2); //Lectura del sensor Izquierdo
if (PisoDerecho > 512) //Si la superficie es blanca entonces prende LED
{
digitalWrite(led0, HIGH);
}
else //Sino, es decir, es negro, entonces apaga LED
{
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.
int motorIzquierda0 = 7;
int motorIzquierda1 = 8;
int pwmIzquierda= 3;
int ProximidadDerecho;
int ProximidadIzquierdo;
void setup()
{
//Configuración de entradas y salidas
pinMode(runled, OUTPUT); //Salida digital en 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(pwmDerecha, OUTPUT);
pinMode(motorIzquierda0,OUTPUT);
pinMode(motorIzquierda1,OUTPUT);
pinMode(pwmIzquierda, OUTPUT);
//Configuración de módulos
void loop()
{
//Código que se repetirá infititamente
//Adelante
digitalWrite(motorDerecha0, HIGH);
digitalWrite(motorDerecha1, LOW);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, HIGH);
digitalWrite(motorIzquierda1, LOW);
digitalWrite(pwmIzquierda, HIGH);
delay(1000);
//Atras
digitalWrite(motorDerecha0, LOW);
digitalWrite(motorDerecha1, HIGH);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, LOW);
digitalWrite(motorIzquierda1, HIGH);
digitalWrite(pwmIzquierda, HIGH);
delay(1000);
//detenido
digitalWrite(pwmDerecha, LOW);
digitalWrite(pwmIzquierda, LOW);
delay(1000);
}
/*--------------------------------Fin del código--------------------------------*/
Funcionamiento
El robot deberá ir hacia adelante, después hacia atrás y por último detenerse. Se repetirá
infinitamente. Verifique que la secuencia descrita corresponda con el movimiento del robot. Si alguno
de los motores gira en sentido contrario invierta los cables en los terminales de tornillo (verdes).
Ejercicio 2
Acomplete la siguiente tabla. Con los movimientos propuestos y resultantes desarrolle un código en el
ejecuten con una duración de 1 segundo.
Atrás Adelante
Adelante Atrás
Adelante Detenido
Detenido
Detenido Detenido
Ejemplo 4: Visualizació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, recibir y
enviar informació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 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ón es de 10 bits, es decir 1024 divisiones en la escala del 0 al 5V. Una buen 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:
2.5metros∗1024escalones
Dato= =512escalones
5metros
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.
void setup()
{
//Configuración de entradas y salidas
pinMode(runled, OUTPUT); //Salida digital en 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
}
void loop()
{
//Código que se repetirá infititamente
PisoDerecho = analogRead(A2); //Lectura analógico del sensor derecho
PisoIzquierdo = analogRead(A3); //Lectura analógica del sensor izquierdo
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.
Ejercicio 3
Desarrolle el código para un programa que muestre por el monitor serial el valor de los sensores en
Voltaje.
Sugerencia
Para obtener el valor en voltaje puede emplear la siguiente fórmula:
ValorObtenidoCAD∗5Voltios
Voltaje=
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:
217∗5Voltios
Voltaje= =1.05Voltios
1024
1.05 voltios es el valor que se deberá desplegar.
Ejercicio 4:
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 y haga anotaciones.
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.
Para hacer pruebas dibuje un dohyo como el que se muestra en la figura. Por facilidad use una
cartulina blanca, fondo, y la linea que delimite el “ring” de color negro.
Se propone el siguiente código, copie y pegue en el área de código del IDE de Arduino.
int motorIzquierda0 = 7;
int motorIzquierda1 = 8;
int pwmIzquierda= 3;
int ProximidadDerecho;
int ProximidadIzquierdo;
int PisoDerecho;
int PisoIzquierdo;
//Funciones
void adelante();
void atras();
void detenido();
void giroderecha();
void giroizquierda();
void setup()
{
//Configuración de entradas y salidas
pinMode(runled, OUTPUT); //Salida digital en 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(pwmDerecha, OUTPUT);
pinMode(motorIzquierda0,OUTPUT);
pinMode(motorIzquierda1,OUTPUT);
pinMode(pwmIzquierda, OUTPUT);
//Configuración de módulos
void loop()
{
//Código que se repetirá infititamente
PisoDerecho = analogRead(A2);
PisoIzquierdo = analogRead(A3);
if(PisoDerecho < 512 || PisoIzquierdo < 512)
{
atras();
delay(200);
giroderecha();
delay(200);
}
else
{
adelante();
}
}
void adelante()
{
digitalWrite(motorDerecha0, HIGH);
digitalWrite(motorDerecha1, LOW);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, HIGH);
digitalWrite(motorIzquierda1, LOW);
digitalWrite(pwmIzquierda, HIGH);
}
void atras()
{
digitalWrite(motorDerecha0, LOW);
digitalWrite(motorDerecha1, HIGH);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, LOW);
digitalWrite(motorIzquierda1, HIGH);
digitalWrite(pwmIzquierda, HIGH);
}
void detenido()
{
digitalWrite(pwmDerecha, LOW);
digitalWrite(pwmIzquierda, LOW);
}
void giroderecha()
{
digitalWrite(motorDerecha0, LOW);
digitalWrite(motorDerecha1, HIGH);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, HIGH);
digitalWrite(motorIzquierda1, LOW);
digitalWrite(pwmIzquierda, HIGH);
}
void giroizquierda()
{
digitalWrite(motorDerecha0, HIGH);
digitalWrite(motorDerecha1, LOW);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, LOW);
digitalWrite(motorIzquierda1, HIGH);
digitalWrite(pwmIzquierda, HIGH);
}
Funcionamiento
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.
Ejemplo 6: Minisumo Intermedio
En el siguiente código se emplean los sensores de 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 = 7;
int motorIzquierda1 = 8;
int pwmIzquierda= 3;
int ProximidadDerecho;
int ProximidadIzquierdo;
int PisoDerecho;
int PisoIzquierdo;
//Funciones
void adelante();
void atras();
void detenido();
void giroderecha();
void giroizquierda();
void setup()
{
//Configuración de entradas y salidas
pinMode(runled, OUTPUT); //Salida digital en 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(pwmDerecha, OUTPUT);
pinMode(motorIzquierda0,OUTPUT);
pinMode(motorIzquierda1,OUTPUT);
pinMode(pwmIzquierda, OUTPUT);
//Configuración de módulos
giroderecha();
}
void loop()
{
//Código que se repetirá infititamente
ProximidadDerecho = analogRead(A0);
ProximidadIzquierdo = analogRead(A1);
PisoDerecho = analogRead(A2);
PisoIzquierdo = analogRead(A3);
//Condición principal
if(PisoDerecho > 512 || PisoIzquierdo > 512)
{
atras();
delay(200);
giroderecha();
delay(200);
}
void adelante()
{
digitalWrite(motorDerecha0, HIGH);
digitalWrite(motorDerecha1, LOW);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, HIGH);
digitalWrite(motorIzquierda1, LOW);
digitalWrite(pwmIzquierda, HIGH);
}
void atras()
{
digitalWrite(motorDerecha0, LOW);
digitalWrite(motorDerecha1, HIGH);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, LOW);
digitalWrite(motorIzquierda1, HIGH);
digitalWrite(pwmIzquierda, HIGH);
}
void detenido()
{
digitalWrite(pwmDerecha, LOW);
digitalWrite(pwmIzquierda, LOW);
}
void giroderecha()
{
digitalWrite(motorDerecha0, LOW);
digitalWrite(motorDerecha1, HIGH);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, HIGH);
digitalWrite(motorIzquierda1, LOW);
digitalWrite(pwmIzquierda, HIGH);
}
void giroizquierda()
{
digitalWrite(motorDerecha0, HIGH);
digitalWrite(motorDerecha1, LOW);
digitalWrite(pwmDerecha, HIGH);
digitalWrite(motorIzquierda0, LOW);
digitalWrite(motorIzquierda1, HIGH);
digitalWrite(pwmIzquierda, HIGH);
}
/*--------------------------------Fin del código--------------------------------*/
Funcionamiento
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.
Ejercicio 4:
Modifique el código para que el robot comience su funcionamiento 5 segundos después de su
encendido.