Robot C2

Plataforma robtica Multipropsito

Gua de usuario

Introduccin
C3 es un robot autnomo de morforloga mvil, diseado como plataforma
multipropsito para resolucin de los principales retos de la mini-robtica. Se trata de un robot
de tipo diferencial, su traccin basa en dos motores de corriente directa, alimentado por
un paquete de bateras de 9 Voltios.

C3 utiliza un microcontrolador de la marca Atmel modelo Atmega328, con firmware de

Arduino, lo cual facilita su programacin.
Advertencias de seguridad y precauciones de uso

C3 no es un juguete. Puede ser usado por nios y jvenes bajo la supervisin y ayuda de un
adulto. El uso o abuso del producto es responsabilidad del usuario final. El distribuidor no se
hace responsable por daos o lesiones que ste pueda causar durante su uso.
Este producto no est diseado para jugar, no debe usarse fuera de las condiciones de
trabajo. A continuacin se indican las precauciones:
Antes de comenzar por favor lea cuidadosamente el manual.
Utiliza bateras alcalinas o recargables. En el caso de las alcalinas asegrate 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 metlicas.
El robot C3 esta ensamblado y soldado con piezas que contienen plomo y estao, por lo
cual es necesario lavarse las manos despus de manipularlo.
Los componentes del robot estn expuestos, por lo que es importante no tocarlo con las
manos mientras est en funcionamiento. Si nuestras manos estn mojadas puede
causarse un corto circuito y daar uno o varios componentes.

Primeros pasos de C3

Qu necesitas?
6 bateras tipo AA Utilice de preferencia bateras alcalinas o recargables. Si trabajar
durante tiempos prolongados con el robot, le recomendamos usar bateras recargables
de Niquel-Metal Hidruro, NiMH. No olvide comprar el cargador correspondiente.
Cable A B USB. C3 no requiere un programador externo, todo el hardware
electrnico ya se incluye en el robot, pero para la comunicacin 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 programacin 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 ms de C3

Figura 1. Vista frontal de C3

C3 es un robot de morfologa mvil 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 Uno R3, y
est encargado de procesar la informacin que le proveen los sensores para realizar
correccines a travs de los motores, bajo el esquema bsico de control.

Hardware de C3
En la figura 1 se muestra el hardware del robot. Observe que se cuenta con varios componentes
y dispositivos electrnicos. Reconoce alguno?, a continuacin se explican brevemente.
Sensores reflectivos de contraste, son los encargados de percibir la informacin 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 cmara digital se observa.
Sensores de contacto, a travs de ellos se detectan obtculos pequeos cercanos al piso,
con una altura mnima de 1.5 centmetros.
LEDs. Diodos emisores de luz por sus siglas en ingls, son dispositivos que emiten una
luz al circular una corriente por sus terminales. C3 se usan como indicadores de
encendido.
 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 uno para
reiniciar el microcontrolador (arduino)
Motorreductores. Son motores de corriente directa (CD, como el de las bateras), con
una caja de engranes adaptada. Los usados en A3 tienen una reduccin 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.
Batera. Es la que provee de energa elctrica a todo el robot, arduino, sensores, LEDs,
motores, pulsadores. En el caso de C3 se trata de 6 bateras tipo AA.

Arduino UNO R3
Es una placa basada en el mirocontrolador Atmega328 que generalmente se usa para hacer
prototipo.

Especificaciones
Microcontrolador: Atmega328.
Tensin de operacin (nivel lgico): 5 Voltios.
Tensin de entrada (recomendada): 7-12 Voltios.
Tensin de entrada (lmites): 6-20 Voltios.
Pines E/S digitales: 14 (de los cuales 6 proveen de salida PWM).
Entradas Analgicas: 8
Corriente mxima por cada PIN de Entrada/Salida: 40mA
Memoria Flash: 32KB.
SRAM: 2KB
EEPROM: 1KB.
Dimensiones: 18.5 mm x 23.2 mm.

Alimentacin
El Arduin puede ser alimentado usando el cable USB B , con una fuente externa no regulada de
6-20V, o con una fuente externa regulada de 5V. La fuente de alimentacin es seleccionada
automticamente a aquella con mayor tensin.

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, (tambin 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 librera EEPROM); el ATmega328 posee 2 KB de SRAM y 1KB de EEPROM.
 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 mximo de 40mA y poseen una resistencia de pull-up (desconectada por defecto)
de 20 a 50 kOhms. Adems algunos pines poseen funciones especializadas:
Serial: 0 (RX) y 1 (TX). (RX) usado para recibir y (TX)usado para transmitir datos TTL va
serie. Estos pines estn 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 interrupcin por paso a nivel bajo, por flanco de bajada o flanco de subida, o por un
cambio de valor. Mira la funcin attachInterrupt() para ms detalles.
PWM: pines 3, 5, 6, 9, 10, y 11. Proveen de una salida PWM de 8-bits cuando se usa la
funcin analogWrite().
SPI: pines 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan la comunicacin
SPI, la cual, a pesar de poseer el hardware, no est 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 analgicas, cada unas de ellas provee de 10 bits de resolucin (1024
valores diferentes). Por defecto miden entre 5 voltios y masa, sin embargo es posible cambiar el
rango superior usando la funcin analogReference(). Tambin, algunos de estos pines poseen
funciones especiales:
I2C: Pines 4 (SDA) y 5 (SCL). Soporta comunicacin I2C (TWI) usando la librera Wire
(documentacin en la web Wiring).
Hay algunos otros pines en la placa:
AREF. Tensin de referencia por las entradas analgicas. Se configura con la funcin
analogReference().
Reset. Pon esta linea a nivel bajo para resetear el microcontrolador. Normalmente se usa
para aadir un botn de reset que mantiene a nivel alto el pin reset mientras no es
pulsado.
Programando en Arduino
Para programa el robot luchador de sumo es necesario contar con el entorno de programacin
de Arduino. Si an no lo tiene lo puede descargar en: www.arduino.cc en la seccin de
descargas. Es recomendable que la versin de arduino que descargue sea igual o posterior a la
1.0.1

Figura 5. Captura de pantalla de entorno de programacin Arduino versin 1.0.1

Componentes de Arduino IDE

Figura 6. Icono Verificar

Verificar. inspecciona el cdigo generado, marca errores y posibles soluciones.
 Figura 7. cono: Cargar
Cargar: Cuando se presiona este botn se compila y ensambla el cdigo contenido en la
ventana y se descarga a la tarjeta electrnica 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, cdigo, ya existente.

Figura 10. cono: Guardar.

Guardar: salva las modificaciones realizadas en el cdigo.

Figura 11. cono: Monitor Serial.

Monitor Serial: abre la aplicacin de monitor serial, que puede servir para diferentes
propsitos.

Referencias del lenguaje

Los programas hechos con Arduino se dividen en tres partes principales:
Estructura,
valores (variables y constantes),
funciones.
El lenguaje de programacin 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 mdulos. Es
llamado tambin como inicializacin. Lo contenido en esta estructura se ejecuta
slamente una vez al inicio del programa.
loop(), es la estructura donde se escribe el cdigo, y se repetir infintas veces.

Valores
Constantes
 HIGH, alto,
LOW, bajo,
INPUT, entrada,
OUTPUT, salida,
True, verdadero,
false, falso,

Variables:
boolean, booleando,
char, carcter,
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 analgico del pin especificado,
analogWrite(), configura la modulacin por anchura de pulso de un pin (PWM),
delay(), pausa en milisegundos.
Serial, librera incluida para el uso y configuracin del mdulo serial.

Revisa la referencia del lenguaje de arduino para aprender ms acerca de las estructuras,
variables y funciones de Arduino.
El primer programa en Arduino para C3
Un sencillo programa de demostracin est disponible en los ejemplos de Arduino,
Archivo/Ejemplos/01.Basics/Blink.

Figura 12. El primer 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, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

Abierto el programa de ejemplo es necesario seleccionar la tarjeta correspondiente, en el caso

del robot seguidor de lnea, se trata de un Arduino Nano Atmega328, para ello dirjase al men
Herramientas/Tarjeta/Arduino Nano w/Atmega328.

Figura 13. Seleccin de tarjeta Arduino Nano Arduino Uno

Ahora se verificar que el cdigo escrito sea correcto, presione el cono verificar:
Lo que har esta funcin 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:

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 comunicacin serial COM correcto. Para ello se puede hacer lo siguiente:
Abra el administrador de dispositivos,
En la pestaa Puertos (COM y LPT), verifique el puerto en el cual est ubicado el
Arduino. Generalmente tiene el nombre de USB Serail Port.

Figura 15. Verificacin del puerto COM del Arduino

Una vez identificado, se selecciona en el IDE, Herramientas/Puerto serial/COMx

Figura 16. Seleccin del Puerto Serial

Cargue el programa a la tarjeta de Arduino presionando el cono de cargar. Esta accin 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

Ejemplos y proyectos
Ahora que sabe como compilar y cargar un prorama a la tarjeta de Arduino es tiempo de
aprender a disear y codificar programas ms complicados. Comenzar con los ms sencillos.

Ejemplo 1: Accionar de motores.

C3 cuenta con dos motores y dos ruedas para realizar sus movimientos. Los motores son
controlados por el arduino (microcontrolador) a travs de un circuito integrado de potencia
denomidado inversor o puente H. ste se encarga de proveer de corriente al motor e invertir el
sentido de giro del mismo.
Para cada motor del robot se tienen dos pines de salida para el control. El primer pin es para el
control de su direccin, es decir si gira para adelante o para atrs. El segundo sirve para indicar
la velocidad del motor y es llamado PWM.
En la siguiente tabla se muestra el funcionar del motor de acuerdo con los pines de control.
Direcin PWM Movimiento de motor
HIGH HIGH Adelante
LOW HIGH Atrs
HIGH/LOW LOW Detenido

Teniendo encuenta la tabla anterior podemos escribir un cdigo para que el robot se dirija hacia
adelante y luego hacia atrs. Se propone a continuacin una forma de realizarlo.

/*
Prueba de Motores con control por anchura de pulso (PWM)
El siguiente programa es para hacer una prueba del movimiento del robot.
*/

//Alias para pines de control de Motor Derecho

int pwmtoder = 10; //Pin de velocidad
int mtoder = 12; //Pin de direccin
int velocidadDer = 127; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Alias para pines de control de Motor Izquierdo

int pwmtoizq = 11; //Pin de velocidad
int mtoizq = 13; //Pin de direccin
int velocidadIzq = 127; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo
//Configuracin de Mdulos y I/Os
void setup() {
//Se declaran como salida los pines de control de los motores
pinMode(pwmtoizq, OUTPUT);
pinMode(mtoizq, OUTPUT);

pinMode(pwmtoder, OUTPUT);
pinMode(mtoder, OUTPUT);

//Se pone en 0 la velocidad del motor, lo tanto el robot estar detenido durante 1 segundo
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
delay(1000); //Pausa o periodo de inactividad dado en miliseguntos (1000 = 1 segundo)
}

//Ciclo principal
void loop()
{
/*Recuerde que las variables velocidadDer y velocidadIzq indican la velocidad del motor,
y de acuerdo a la declaracin del valor de las variables se encuentra en el valor 127,
es decir al 50% de la velocidad mxima del motor*/
analogWrite(pwmtoder, velocidadDer);
analogWrite(pwmtoizq, velocidadIzq);

/*Recuerde que si el pin de direccin derecho, mtoder,est en alto, HIGH, el motor rodar
hacia adelante. Por lo consiguiente si est en bajo, LOW, lo har hacia atrs.
Si el pin de direccin izquierdo, mtoder, est en alto, HIGH, el motor rodar hacia
adelante. Por lo consiguiente si est en bajo, LOW, lo har hacia atrs.
Entonces... si se ponen en alto tanto el mtoder como el mtoizq el motor se desplazar hacia
adelante*/
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, HIGH);
delay(1000); //Tiempo por el cual el robot ir hacia adelante (milisegundos)

/*Para hacer que el robot se detenga basta con poner la velocidad de los dos motores en
0, cero, no importando el sentido de giro de los motores.*/
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
delay(1000);//Tiempo por el cual el robot ir hacia adelante (milisegundos)

/*Para hacer que el robot se desplace hacia atrs es necesario poner la velocidad del motor
 en la constante, variable velocidadDer y velocidadIzq, los indicadores de direccin mtoder y
mtoizq en bajo*/
analogWrite(pwmtoder, velocidadDer);
analogWrite(pwmtoizq, velocidadIzq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, LOW);
delay(1000); //Tiempo por el cual el robot ir hacia adelante (milisegundos)

/*Para hacer que el robot se detenga basta con poner la velocidad de los dos motores en
0, cero, no importando el sentido de giro de los motores.*/
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
delay(1000); //Tiempo por el cual el robot ir hacia adelante (milisegundos)
}
//Fin del programa

Ejercicio 1:
Desarrolle un cdigo para hacer la siguiente secuencia de movimientos.
Adelante,
detenido,
atrs,
detenido,
izquierda,
detenido,
derecha,
detenido.

Tome como referencia la siguiente tabla de estados.

mtoder velocidadDer mtoizq velocidadIzq Movimiento
HIGH 127 HIGH 127 Adelante
LOW 0 LOW 0 Atrs
HIGH/LOW* 0 HIGH 127 Derecha
HIGH 127 HIGH/LOW* 0 Izquierda
HIGH/LOW* 0 HIGH/LOW* 0 Detenido

*HIGH/LOW, no importa el estado, ya que la velocidad es cero por lo consiguiente el motor se

detiene.
Ejemplo 2: Movimientos con funciones.
En el ejemplo anterior se realizaron los movimientos bsicos del robot. En ste se hace
bsicamente lo mismo con la diferencia de que se usan funciones. stas ya estn creadas y
representan los movimientos: adelante, atras, drecha, izquierda, giroderecha, giroizquierda.
Para usarlas slamente hay que llamarlas cuando se requieran.
Observe el siguiente cdigo para entender el funcionamiento de las funciones ya creadas.

/*
Prueba de Motores con control por anchura de pulso (PWM)
El siguiente programa es para hacer una prueba del movimiento del robot.
Se tiene creado funciones bsicas.
*/

//Alias para pines de control de Motor Derecho

int pwmtoder = 10;
int mtoder = 12;
int pwmvalder = 127; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Alias para pines de control de Motor Izquierdo

int pwmtoizq = 11;
int mtoizq = 13;
int pwmvalizq = 127; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Funciones
void adelante();
void atras();
void giroderecha();
void giroizquierda();
void derecha();
void izquierda();
void detenido();

//Configuracin de Mdulos y IO
void setup() {
pinMode(pwmtoizq, OUTPUT);
pinMode(mtoizq, OUTPUT);

pinMode(pwmtoder, OUTPUT);
 pinMode(mtoder, OUTPUT);

digitalWrite(pwmtoizq, LOW);
digitalWrite(mtoizq, LOW);

digitalWrite(pwmtoder, LOW);
digitalWrite(mtoder, LOW);
delay(1000);
}

//Ciclo principal
void loop()
{
adelante();
delay(1000);
detenido();
delay(1000);
atras();
delay(1000);
detenido();
delay(1000);
derecha();
delay(1000);
izquierda();
delay(1000);
}

void adelante()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, HIGH);
}

void atras()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
 digitalWrite(mtoizq, LOW);
}

void giroderecha()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void derecha()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void giroizquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void izquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, 0);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void detenido()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
}
Ejemplo 3: Deteccin de obstculos (sensor de contacto).

Fig. Deteccin de obstculos pequeos

El Robot C3 tiene 2 sensores de contacto, para la deteccin de obstculos pequeos. Estos

sensores son de tipo digital, solamente entregan dos valores, entregan 5 voltios, HIGH,
cuando no se encuentran presionados. En el momento que se encuentran presionados pasan de
alto, HIGH, a bajo a 0 Voltios.
Para obtener la lectura de los sensores es necesario utilizar la funcion digitalRead, la cual
regresa el estado del sensor.
A continuacin se propone un cdigo para realizar que el robot choque con los obstculos y
luego los evada.

//Alias para pines de control de Motor Derecho

int pwmtoder = 10;
int mtoder = 12;
int pwmvalder = 127; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Alias para pines de control de Motor Izquierdo

int pwmtoizq = 11;
int mtoizq = 13;
int pwmvalizq = 127; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Funciones
void adelante();
void atras();
void giroderecha();
void giroizquierda();
void derecha();
void izquierda();
void detenido();

// the setup routine runs once when you press reset:

void setup() {
pinMode(2, INPUT);
pinMode(3, INPUT);

pinMode(pwmtoizq, OUTPUT);
pinMode(mtoizq, OUTPUT);

pinMode(pwmtoder, OUTPUT);
pinMode(mtoder, OUTPUT);

digitalWrite(pwmtoizq, LOW);
digitalWrite(mtoizq, LOW);

digitalWrite(pwmtoder, LOW);
digitalWrite(mtoder, LOW);
delay(1000);

// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
int sensorValue0 = digitalRead(2);
int sensorValue1 = digitalRead(3);
// print out the value you read:
 if(sensorValue0 == HIGH && sensorValue1 == HIGH )
{
adelante();
}

if(sensorValue0 == HIGH && sensorValue1 == LOW )

{
atras();
delay(200);
derecha();
delay(1000);
}

if(sensorValue0 == LOW && sensorValue1 == HIGH)

{
atras();
delay(200);
izquierda();
delay(1000);
}
}

void adelante()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, HIGH);
}

void atras()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, LOW);
}

void giroderecha()
{
 analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void derecha()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void giroizquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void izquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, 0);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void detenido()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
}
Ejemplo 4: Deteccin de obstculos (sensor proximidad)

Figura . Deteccin de obstculos grandes.

Para detectar objetos de tamao grande C3 cuenta con 3 sensores de tipo infrarrojo
reflectivo. Esto es que funcionan emitiendo una luz infrarroja, a travs de un LED, y si un objeto
se encuentra prximo se refleja y se recibe por medio de un fototransistor. De tal modo que con
este tipo de sensores no es necesario tener un contacto con el objeto para que pueda ser
detectado.
Los estados del sensor son los siguientes:
Estado Valor entregado
Obstculo cercano LOW
Libre HIGH

Para realizar una prueba de los sensores de proximidad realice un programa en el cual use la
comunicacin serial entre el arduino y la computadora. A continuacin se propone el cdigo
para realizar esta actividad.

// Inicio de programa
void setup() {
pinMode(4, INPUT);
 pinMode(5, INPUT);
pinMode(6, INPUT);

pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
int sensorValue0 = digitalRead(4);
int sensorValue1 = digitalRead(5);
int sensorValue2 = digitalRead(6);
// print out the value you read:
if(sensorValue0 == HIGH)
{
Serial.print("Sensor izquierdo: ");
Serial.println("libre");
}
else
{
Serial.print("Sensor izquierdo: ");
Serial.println("Objeto cercano");
}

if(sensorValue1 == HIGH)
{
Serial.print("Sensor centro: ");
Serial.println("libre");
}
else
{
Serial.print("Sensor centro: ");
Serial.println("Objeto cercano");
}
 if(sensorValue2 == HIGH)
{
Serial.print("Sensor derecho: ");
Serial.println("libre");
}
else
{
Serial.print("Sensor derecho: ");
Serial.println("objeto cercano");
}
delay(1000); // delay in between reads for stability
}

Verifique y cargue en la tarjeta arduino del robot el cdigo. Enseguida abra el monitor serial y
visualice los resultados.

Figura. Visualizacin de datos en monitos serial.

Ejemplo 5: Visualizacin de valor de sensores en monitor serial
La tarjeta de C3 cuenta con 4 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 da.
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, que convierte la
seal luminosa en voltaje, permite un flujo de corriente entre sus terminales y por la
configuracin 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 comnmente en muchos
procesos de la industra y cotidianos, tal es caso de las llaves automticas de agua usadas en los
baos pblicos. La intensin es que cuando coloque su dedo frente al sensor este active el LED.
Una de las grandes ventajas de las tarjetas de Arduino es su simplicidad para establecer
conexin con una computadora. Esto se realiza gracias al convertivor USB a serial incluido en la
tarjeta. A dems el entorno de programacin cuenta con una aplicacin, monitor serial, que
sirve para visualizar, recibir y enviar informacin.
El siguiente programa obtiene el valor de los sensores reflectivos analgico, los cuantifica y los
despliega. La cuantificacin es el proceso por el cual se le asigna un valor en bits a una seal.
Los convertidores CAD, Analgico a Decimal, cuantifican las seales, es decir entregan un valor
en nmero dependiendo de la resolucin que posean. En el caso del microcontrolador que se
usa, Atmega328, la resolucin es de 10 bits, es decir 1024 divisiones en la escala del 0 al 5V. Una
buen analoga es la siguiente: Suponga que tiene una escalera de 5 metros con 1024 escalones,
cada escaln le har subir 0.0048 metros. Si otra persona le indica que tiene que pintar una
linea a 2.5 metros del piso, Cuntos escalones tendr que subir?, esto puede resolverse por
una simple regla de tres:
2.5metros1024escalones
Dato= =512escalones
5metros

A grosso modo eso es lo que hace un convertidor Analgico a Digital, convierte un voltaje en un
dato que pueda manipular.
Para realizar la calibracin los sensores o para obtener informacin de ellos se puede realizar un
programa que muestre los datos en el monitor serial. A continuacin se propone el cdigo para
realizar esta tarea.

/*--------------------------------Inicio del cdigo--------------------------------*/

void setup() {

pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
digitalWrite(10, LOW);
digitalWrite(11, LOW);
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
int sensorValue1 = analogRead(1);
int sensorValue2 = analogRead(2);
// int sensorValue2 = digitalRead(6);
// print out the value you read:

Serial.print("Sensor centro derecho: ");

Serial.println(sensorValue1);
Serial.print("Sensor centro izquierdo: ");
Serial.println(sensorValue2);
 delay(1000); // delay in between reads for stability
}
/*--------------------------------Fin del cdigo--------------------------------*/
Funcionamiento
Una vez compilado y descargado el cdigo se deber abrir el monitor serial dentro del IDE de
Arduino para ver los datos.

Figura 26. Recepcin 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
determinacin del umbral para la deteccin del borde del dohyo.
Ejercicio
Desarrolle el cdigo 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 frmula:
ValorObtenidoCAD5Voltios
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:
2175Voltios
Voltaje= =1.05Voltios
1024
1.05 voltios es el valor que se deber desplegar.
Ejemplo 5: Minisumo Bsico
Explicacin del concurso
Consiste en un combate entre dos robots que discurrir por una tarima, tambin denominada
dohyo o ring, y consiste en marcar puntos Yukoh.
Los combates se componen de dos asaltos de 3 minutos mximo, cada uno, ms un terecer
asalto en caso de empate. El primer competidor en alcanzar dos puntos de Yukoh ser el
ganador de la lucha. El competidor que gane un punto de yukoh en el tercer combate, ser el
ganador.

Figura 29. Competicin seguidor de lnea, persecucin

Construya una pista para pruebas

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, y la linea que delimite el ring de color negro.

Se propone el siguiente cdigo, copie y pegue en el rea de cdigo del IDE de Arduino.
//Alias para pines de control de Motor Derecho
int pwmtoder = 10;
int mtoder = 12;
int pwmvalder = 100; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Alias para pines de control de Motor Izquierdo

int pwmtoizq = 11;
int mtoizq = 13;
int pwmvalizq = 100; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

int sensorderc;
int sensorder;
int sensorizqc;
int sensorizq;

//Funciones
void adelante();
void atras();
void giroderecha();
void giroizquierda();
void derecha();
void izquierda();
void detenido();

//Configuracin de Mdulos y IO
void setup() {

pinMode(pwmtoizq, OUTPUT);
pinMode(mtoizq, OUTPUT);

pinMode(pwmtoder, OUTPUT);
pinMode(mtoder, OUTPUT);

digitalWrite(pwmtoizq, LOW);
digitalWrite(mtoizq, LOW);

digitalWrite(pwmtoder, LOW);
digitalWrite(mtoder, LOW);
delay(1000);
}

//Ciclo principal
void loop()
{
sensorderc = analogRead(1);
sensorizqc = analogRead(2);

if(sensorderc < 700 || sensorizqc < 700)

{
atras();
delay(200);
giroderecha();
delay(250);
}
else
{
adelante();
}

void adelante()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, HIGH);
}

void atras()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, LOW);
}

void giroderecha()
{
 analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void derecha()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void giroizquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void izquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, 0);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void detenido()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
}
Ejemplo 5: Seguidor de lnea Bsico
El seguimiento de una lnea es una buena introduccin en la programacin de robots.

Por qu un seguidor de lneas?

Es fcil entender el funcionamiento y la lgica de programacin para el seguimiento de una
lnea. Optimizar el programa para hacer que el robot se deslice sobre una lnea a la velocidad
ms rpida es un reto que puse llevarle a algunos conceptor avanzados de programacin.

Explicacin del concurso

El concurso de velocidad consiste en una carrera de persecucin entre dos robots en una pista
cerrada, comenzando en puntos opuestos y avanzando en el mismo sentido. El objeto, por
tanto, ser la consecucin de altas velocidades de marca en un recorrido perfectamente
establecido.

Figura 24. Competicin seguidor de lnea, persecucin

Construya una pista para pruebas

Es importante tener una pista o construir una con los siguientes materiales.
Cartulina blanca,
cinta de aislar negra,
tijeras.
Para hacer pruebas dibuje con la cita de aislar una pista sencilla, tal vez sea suficiente con un
rectngulo con las esquinas redondeadas o una elipse. No se recomienda vueltas con ngulos
rectos, 90 grados.
Se propone el siguiente cdigo, copie y pegue en el rea de cdigo del IDE de Arduino.

//Inicio de programa
//Alias para pines de control de Motor Derecho
int pwmtoder = 10;
int mtoder = 12;
int pwmvalder = 100; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

//Alias para pines de control de Motor Izquierdo

int pwmtoizq = 11;
int mtoizq = 13;
int pwmvalizq = 100; //Esta variable es la que se modifica para variar la velocidad de giro del
motor. Va de 0 a 255, siendo 0 el mnimo y 255 el mximo

int sensorderc;
int sensorder;
int sensorizqc;
int sensorizq;

//Funciones
void adelante();
void atras();
void giroderecha();
void giroizquierda();
void derecha();
void izquierda();
void detenido();

//Configuracin de Mdulos y IO
void setup() {

pinMode(pwmtoizq, OUTPUT);
pinMode(mtoizq, OUTPUT);

pinMode(pwmtoder, OUTPUT);
pinMode(mtoder, OUTPUT);
 digitalWrite(pwmtoizq, LOW);
digitalWrite(mtoizq, LOW);

digitalWrite(pwmtoder, LOW);
digitalWrite(mtoder, LOW);
delay(1000);
}

//Ciclo principal
void loop()
{
sensorderc = analogRead(1);
sensorizqc = analogRead(2);

if(sensorderc < 700 && sensorizqc < 700)

{
adelante();
}

if(sensorderc < 700 && sensorizqc > 700)

{
izquierda();
}

if(sensorderc > 700 && sensorizqc < 700)

{
derecha();
}
}

void adelante()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, HIGH);
}
void atras()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, LOW);
}

void giroderecha()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void derecha()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, LOW);
digitalWrite(mtoizq, HIGH);
}

void giroizquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, pwmvalizq);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}

void izquierda()
{
analogWrite(pwmtoder, pwmvalder);
analogWrite(pwmtoizq, 0);
digitalWrite(mtoder, HIGH);
digitalWrite(mtoizq, LOW);
}
void detenido()
{
analogWrite(pwmtoder, 0);
analogWrite(pwmtoizq, 0);
}

//Fin de programa
Ejemplo 6: Seguidor de lnea con Control PID
Para seguir la lnea con precisin es necesario aplicar mtodos de control. La tcnica usada en
este ejemplo es el control PID.
Proporcional, es un valor propocional a la posicin del robot sobre la lnea. Si el robot
est centrado sobre la lnea el error ser 0, pero si se encuentra a la derecho o izquierda
el valor del error ser positivo o negativo.
Integral, es una memoria de todos los eventos anteriores. Una integral en sistemas
discretos, generalmente usados por micro-controladores y microprocesadores, se pude
expresar como la sumatoria de todos los puntos anteriores, lo que en sistemas continuos
es el rea debajo de la curva.
Derivativo, es la razn de cambio, la tendencia, el diferencia de los valores actuales y
anteriores.

El cdigo propuesto.
//Inicio de programa
#include <QTRSensors.h> //Biblioteca para la lectura y calibracin de los sensores de contraste

//Declaracin de constantes
#define NUM_SENSORS 4 // Nmero de sensores
#define NUM_SAMPLES_PER_SENSOR 4 // Nmero de muestras por sensor
#define EMITTER_PIN 4 // Controlador de emisores LED's infrarrojos

//Los sensores reflectivos para detectar contraste de encuentran conectados en las entradas
//Analgicas A0 a A3
QTRSensorsAnalog qtra((unsigned char[]) {0, 1, 2, 3}, NUM_SENSORS,
NUM_SAMPLES_PER_SENSOR, EMITTER_PIN);
unsigned int sensorValues[NUM_SENSORS]; //Vector para almacenar seal de sensores

unsigned int sensors[5]; // Matriz para armazenar valores dos sensores

int MotorA = 11; //Alias para Motor B

int MotorB = 10; //Alias para Motor A

//Declaracin de variables
int total = 0;
float average = 0;
int index = 0;
int last_proportional;
int integral;
void setup(){
//Configuracin de entradas y salidas digitales
delay(500);

pinMode(12, OUTPUT);
pinMode(13, OUTPUT);

digitalWrite(12, HIGH);
digitalWrite(13, LOW);

//Se prende el indicador LED conectado en el pin 13, para indicar que se
//inicia la calibracin

//Rotacin del robot para calibracin

analogWrite(MotorA, 50);
analogWrite(MotorB, 50);

for (int i = 0; i < 200; i++) //Calibracin durante 5 segundos

{
qtra.calibrate(); // Se hace las lecturas para obtener valores de mximos y mnimos
}
digitalWrite(13, HIGH); //Se apaga el LED indicando que se completo la programacin

analogWrite(MotorA, 0);
analogWrite(MotorB, 0);
delay(1000);

void loop(){
while(1){
//Se obtiene el valor de cada uno de los sensores mediante la funcin qtra.readline();
unsigned int position = qtra.readLine(sensorValues);
//Determinacin del trmino proporcional
int proportional = ((int)position) - 1500;
 //Determinacin del trmino derivativo
int derivative = proportional - last_proportional;

//Determinacin del trmino integral

integral += proportional;

//Se almacena el estado anterior para determinar el prxmio trmino derivativo

last_proportional = proportional;

//Clculo para determinar la velocidad de cada uno de los motores

int power_difference = proportional/5 + integral/20000 + derivative*3;

const int max = 120;

if(power_difference > max)
power_difference = max;
if(power_difference < -max)
power_difference = -max;
if(power_difference < 0)
set_motors(max+power_difference, max);
else
set_motors(max, max-power_difference);
}
}

// Accionamiento dos motores

void set_motors(int left_speed, int right_speed){
if(right_speed >= 0 && left_speed >= 0){
analogWrite(MotorA, left_speed);
analogWrite(MotorB, right_speed);
}
if(right_speed >= 0 && left_speed < 0){
left_speed = -left_speed;
analogWrite(MotorA, left_speed);
analogWrite(MotorB, 0);
}
if(right_speed < 0 && left_speed >= 0){
right_speed = -right_speed;
analogWrite(MotorA, 0);
analogWrite(MotorB, right_speed);
}
}