Robot MP / Hummingbird

Al lector,

Muchísimas gracias a usted estimado lector, ¿Por qué?, bueno principalmente al tener en
sus manos la presente obra demuestra su vivo interés en la ciencia y la tecnología, su
curiosidad lo llevará a descubrir más del fabuloso mundo que lo rodea. Nos motiva el hecho
de saber que más personas tienen el ansia de superarse a sí mismos, a causa de llevar el
espíritu creador, materializando sus sueños y haciendo realidad lo que antes se decía “ser
imposible”.

En la presente obra exponemos información valiosa sobre nuevas tecnologías para el

desarrollo académico juvenil, sin embargo, no está reservado para un grupo de personas en
precisión, más bien, el objetivo que se persigue es hacer asequible los conocimientos para
entender y usar los novedosos dispositivos de apoyo para la enseñanza en ciencias básicas,
sistemas de la información, electrónica y robótica en plataforma Arduino.

La obra es una compilación sobre principios de ciencias básicas (matemáticas, física,

informática), presentado de forma práctica con ayuda de material electrónico de pruebas,
conocido como “Hummingbird Robotics Kit”, las actividades están diseñadas para que el
lector experimente, observe y analice lo realizado por él. Con ayuda de una computadora
el lector puede dar sus primeros pasos en programación usando la interfaz amigable de
“Snap!”.

También se incluye en este tomo un primer acercamiento al fascinante mundo de la

robótica, empleando un robot de competencia multipropósito “Robot Andromie MP”. No
sólo se manejan principios de robótica, también se aborda la electrónica avanzada con el
uso de la tarjeta “Arduino UNO”, la cual es una plataforma de desarrollo para prototipos
tecnológicos. Esta popular plataforma de desarrollo cede al lector la oportunidad para
desatar toda su creatividad de una manera muy divertida.

Nuevamente le agradecemos su interés por la ciencia y la tecnología. Sin más por el

momento nos despedimos, deseando disfrute del contenido de la obra.

ATTE,
Los Autores.

1 1
 “Descubre hasta dónde te puede llevar una idea”
Nuestro objetivo es fomentar y llevar la competencia educativa a su nivel máximo, y
apoyar a los profesores y alumnos en su interés por aportar algo de beneficio a la
comunidad.

La Sociedad Latinoamericana de Ciencia y Tecnología Aplicada SOLACYT está integrada por

varios movimientos independientes, que giran en torno a la Educación, todos los
profesionistas inmersos en el sector educativo, ahora confluyen en SOLACYT, con el objetivo
de tener una plataforma multinacional de apoyo a Profesores, Estudiantes, Instituciones y
Empresas de servicios educativos, con el fin de mejorar la calidad educativa de
Latinoamérica por medio de la correcta aplicación de ciencia y tecnología en la construcción
de proyectos en mejora de la sociedad.
SOLACYT A.C. es una asociación civil, sin fines de lucro, dedicada al desarrollo de eventos y
concursos de ciencia y tecnología aplicada a la educación. Entre ellos desarrolla: Proyecto
Multimedia, Infomatrix América, Olimpiada de Informática del Estado de Jalisco,
Robomatrix, Código Ciencia, Expo CIENTEC Guanajuato, Expo CIENTEC Aguascalientes,
ExpoCiencias Michoacán, Campamento de Pandillas Científicas, Concurso Nacional Abierto
de Programación, Seminario de Investigación en la Enseñanza de la Ciencia y Tecnología, y
en 2015 se anexa el Verano Nacional Científico para Estudiantes Sobresalientes.

BENEFICIOS PARA EL ALUMNO

Vivir la experiencia de competir, demostrar sus habilidades, aplicar en forma
interdisciplinaria sus conocimientos, conocer jóvenes con sus mismas inquietudes y
aprender a retarse.

BENEFICIOS PARA EL PROFESOR

Mejorar su didáctica por medio de la forma de trabajo por proyectos, de creación de ideas
y contenidos. Revisar el material de otros participantes, interactuar con otros profesores y
complementar su labor docente. Convivir con los alumnos en un plan de desarrollo de
proyectos y ser parte incluyente de ellos, no sólo evaluador de los mismos.

2 2
 Torneo Latinoamericano de Robótica en Competencia ROBOMATRIX

Robomatrix es el concurso robótico de mayor influenza en México, su objetivo es el

fomento de la robótica en competencia desde la temprana edad, donde los partícipes
aplican sus conocimientos y habilidades por medio de la programación y construcción de
sus prototipos robóticos afines a las categorías de: Mini Sumo, Micro Sumo, Mega Sumo,
Seguidor de líneas, Seguidor de líneas con obstáculos, Seguidor de líneas avanzado,
Seguidor de líneas profesional, laberinto, entre otras, dependiendo la demanda se abren
nuevas categorías en las distintas sedes.

Robomatrix además funge como eliminatoria continental oficial para asistir a diversos
eventos internacionales, entre ellos: El Concurso Internacional de Robotchallenge a
celebrarse en Viena, Austria, el Concurso Internacional de Proyectos de Cómputo
INFOMATRIX, a celebrarse en Bucarest, Rumania, entre otros.

Mayores informes
www.solacyt.org
[email protected]
facebook.com/solacyt
twitter.com/Solacyt

3 3
Contenido
CAPÍTULO 1 ......................................................................................................................................... 7
Advertencias de seguridad y precauciones de uso. ...................................................................... 9
Introducción.................................................................................................................................. 10
Primeros pasos con el robot Andromie MP. ................................................................................ 10
Conoce más sobre el robot Andromie MP................................................................................... 11
Hardware de robot Andromie MP. .............................................................................................. 11
Arduino UNO. ............................................................................................................................... 14
Especificaciones. ....................................................................................................................... 14
Alimentación............................................................................................................................. 15
Comunicación. .......................................................................................................................... 15
Entrada y Salida ........................................................................................................................ 15
CAPÍTULO 2 ....................................................................................................................................... 16
Programando en Arduino. ............................................................................................................ 17
Componentes del programa de Arduino. .................................................................................... 17
¿Qué es un “Sketch”? ................................................................................................................... 18
Estructuras. ............................................................................................................................... 18
Valores constantes. .................................................................................................................. 19
Variables. .................................................................................................................................. 19
Funciones .................................................................................................................................. 20
Pasos para programar la tarjeta Arduino Uno. ........................................................................... 20
CAPÍTULO 3 ....................................................................................................................................... 23
Un relato del desarrollo de los robots: ........................................................................................ 24
Aparecen los drones. .................................................................................................................... 24
Aprende jugando. ......................................................................................................................... 25
Actividad 1: Danza con robots. ................................................................................................ 25
Un relato del desarrollo de los robots: ........................................................................................ 32
Robots móviles. ............................................................................................................................ 32
Actividad 2: Pisando el acelerador........................................................................................... 33
Un relato del desarrollo de los robots: ........................................................................................ 40
Robots de servicio. ....................................................................................................................... 40
Actividad 3: Insecto bot. ........................................................................................................... 41
Un relato del desarrollo de los robots: ........................................................................................ 48

4 4
 Visión artificial. ............................................................................................................................. 48
Actividad 4: Reconociendo el camino. ..................................................................................... 49
Un relato del desarrollo de los robots: ........................................................................................ 55
Teleoperación robótica ................................................................................................................ 55
Actividad 5: Buscando el tesoro. .............................................................................................. 56
Un relato del desarrollo de los robots: ........................................................................................ 63
Un robot de exploración espacial. ............................................................................................... 63
Actividad 6: Escuchando el camino. ......................................................................................... 64
Un relato del desarrollo de los robots: ........................................................................................ 71
El robot Da Vinci. .......................................................................................................................... 71
Actividad 7: El murciélago buscador. ....................................................................................... 72
Un relato del desarrollo de los robots: ........................................................................................ 78
Robótica educativa. ...................................................................................................................... 78
Actividad 8: El camino del guerrero. ........................................................................................ 79
Un relato del desarrollo de los robots: ........................................................................................ 86
El futuro de la robótica. ................................................................................................................ 86
Actividad 9: Regresando a casa. ............................................................................................... 87
CAPÍTULO 4 ....................................................................................................................................... 95
Programando en “Snap!” ............................................................................................................. 97
Instalación en Windows. .............................................................................................................. 97
Ejecutando “Snap!” ...................................................................................................................... 97
Programando un módulo “Hummingbird” en “Snap!” ............................................................... 98
“Motion” (Comandos de movimiento). ................................................................................... 98
“Looks” (Comandos de visualización). ..................................................................................... 98
“Sensing” (Comandos de detección). ....................................................................................... 98
El bloque “Say This” (Decir esto).............................................................................................. 99
Guardando y cargando un Proyecto. ....................................................................................... 99
CAPÍTULO 5 ..................................................................................................................................... 100
“Hummingbird” .......................................................................................................................... 101
Actividad 1: Simulación de terremoto (Geografía). .............................................................. 101
Principios de ciencia: Terremotos y sus tipos. ....................................................................... 105
Actividad 2. Ahorro de energía (ecología). ............................................................................ 106
Principios de ciencia: Aprovechamiento de los recursos energéticos. ................................. 109

5 5
 Actividad 3. Termómetro (Química). ..................................................................................... 111
Principios de ciencia: Escalas de Temperatura. ..................................................................... 113
ANEXO A...................................................................................................................................... 115
Instalación de Controladores ................................................................................................. 115

6 6
CAPÍTULO 1

7 7
 Arduino / Hummingbird

ROBÓTICA CON ARDUINO Vol. III

ROBOT ANDROMIE MP

8 8
 Capitulo 1

Advertencias de seguridad y precauciones de uso.

Antes de comenzar a utilizar el robot Andromie MP (Multipropósito) por favor lea

cuidadosamente esta guía de usuario.

Utilice baterías alcalinas nuevas o baterías recargables con carga completa, para obtener
una mejor experiencia de uso con el robot Andromie MP.

Las condiciones de trabajo del Andromie MP será sobre superficies lisas de preferencia, no
conductoras de la electricidad (madera, papel, cartón, vitropiso) y en el interior de
habitaciones con luz controlada.

No colocar la tarjeta de circuito impreso (PCB) del robot Andromie MP sobre superficies
metálicas que produzcan daño por corto circuito eléctrico.

El robot Andromie MP está ensamblado con componentes electrónicos expuestos, soldados

con plomo y estaño, no debe tocarse ningún componente con las manos húmedas o
mojadas cuando esté en funcionamiento, se puede causar un corto circuito y dañarlo.

No ingerir alimentos y bebidas cuando se esté trabajando con el robot Andromie MP, será
necesario lavarse las manos después de manipularlo.

Andromie MP, no es un juguete y no debe usarse fuera de las condiciones de trabajo

recomendadas, puede ser usado por niños y jóvenes bajo la supervisión de un adulto. El uso
o abuso del producto es responsabilidad del usuario final. Andromie y/o Aico Soluciones no
se hacen responsables por daños o lesiones que éste pueda causar durante su operación.

Al momento de encender el robot Andromie MP, tenga cuidado, no lo coloque en el suelo

de inmediato, existe una parte llamada bootloader en la tarjeta Arduino UNO, la cual emite
energía por un breve instante durante el encendido, provocando reacciones inesperadas
por parte del robot, sujételo firmemente, espere un momento y posteriormente continúe.
Esto solo sucede con actividades relacionadas a los motores, si la tarea no los emplea el
robot no reaccionará abruptamente.

9 9
 Arduino / Hummingbird

Introducción.

Andromie MP es un robot autónomo de morfología móvil, se diseñó como plataforma

multipropósito para competencias en retos de mini- robótica. Se trata de un robot de tipo
diferencial, su tracción se basa en dos motores de corriente directa, alimentado por un
conjunto de 6 baterías tipo AA que proporcionan 9 volts. Andromie MP utiliza un
microcontrolador de la marca Atmel modelo Atmega328.

Primeros pasos con el robot Andromie MP.

¿Qué requerimos antes de usar el robot Andromie MP?

- Baterías, se recomienda utilizar baterías recargables de Níquel-Metal-Hidruro

(NIMH), tipo AA, el robot trae incorporado un portapilas para 6 baterías.

- Cable de datos USB con configuración USB-A a USB-B, para la comunicación entre el
robot Andromie MP y la computadora.

- Computadora con puertos USB, para programar en la interfaz de Arduino de

plataforma libre, el cual puede funcionar bajo diferentes Sistemas Operativos
(Windows, Linux y Mac).

Se recomienda que tenga a la mano papel, cartulina y cartoncillo de diferentes tamaños, así
como cinta aislante de color negro o blanco, todo esto con el fin de improvisar pistas y poner
a prueba el robot Andromie MP.

10 10
 Capitulo 1

Conoce más sobre el robot Andromie MP.

Figura 1.1. Vista superior de robot multipropósito Andromie MP

El robot Andromie MP es un robot de morfología móvil de tipo diferencial, es decir, se

desplaza en la superficie donde fue colocado por medio de dos ruedas, cada una de ellas
acoplada a un motor eléctrico. El cerebro del robot es un Arduino UNO y está encargado de
procesar la información del entorno físico a través de los sensores de proximidad, sensores
de contraste de piso, sensores de contacto y sensor de proximidad ultrasónico.

Hardware de robot Andromie MP.

En la figura 1.1, la figura 1.2 y la figura 1.3 se muestran los componentes de vista superior,
inferior y trasera del robot Andromie MP, se da una explicación breve de algunos de ellos.

 Sensores de proximidad (D4, D5 y D6) y Sensores de contraste de piso (A0, A1, A2

y A3): Son sensores reflectivos de contraste encargados de percibir la información
del entorno físico frente a ellos, en este caso el contraste o mejor dicho la diferencia
entre lo blanco y lo negro, entre lo brilloso y lo opaco. Este dispositivo se compone
de dos partes: un emisor y un receptor ambos operando en el rango infrarrojo de la

11 11
 Arduino / Hummingbird

luz, que no es perceptible para el ojo humano pero es visible con ayuda de una
cámara digital.

 Sensor de proximidad ultrasónico (D7 y D8): Es un sensor que emite y capta ondas
ultrasónicas, inaudibles para el ser humano, cuenta con un emisor y un receptor,
que opera en la frecuencia de 40 KHz.

 Botón Reset: Interruptor de contacto sobre la placa Arduino Uno que tiene como
propósito reiniciar el programa almacenado en el microcontrolador.

 Controlador de Motores (D10, D11, D12 y D13): Basado en un circuito integrado de

Puente H, es el que provee de potencia a los motores, siendo la interfaz entre el
microcontrolador en la placa Arduino y los motores eléctricos.

 Motorreductores: Son motores de corriente directa (como las baterías), con una
caja de engranes adaptada y una relación de reducción de 48:1, por cada 48 vueltas
de giro del motor eléctrico el eje del reductor gira 1 vuelta, de este modo se
incrementa el torque y la fuerza al mismo tiempo que se reduce la velocidad.

 Portabaterías: Componente que contiene las baterías que proveen de energía

eléctrica a todo el robot Andromie MP, placa Arduino Uno, sensores y motores.

 Interruptor de encendido: Componente que permite el paso de corriente desde las

baterías a todos los elementos que lo requieren en el robot Andromie MP.

 LEDs: Son dispositivos que emiten una luz al circular una corriente por sus
terminales. En el robot Andromie MP se usan como indicadores de encendido tanto
en la placa Arduino Uno como en la placa controladora de motores. También cuenta
con LEDs en la placa Arduino Uno para indicar que está recibiendo y enviando datos
al ser programado desde la computadora, se identifican por la leyendas TX
(transmitir) y RX (recibir).

12 12
 Capitulo 1

Figura 1.2. Vista inferior de robot multipropósito Andromie MP

Figura 1.3 Vista trasera del robot multipropósito Andromie MP

13 13
 Arduino / Hummingbird

Arduino Uno.

El Arduino Uno es una placa microcontroladora basada en el ATmega 328. Tiene 14 pins de
entrada y salida, 6 pueden usarse como salidas PWM, 6 entradas analógicas, conexión USB-
B, jack de poder y botón de reset. Todo listo para conectarlo a la computadora con un cable
USB o baterías y comenzar a programarlo. (Ver figura 1.4).

Figura 1.4. Arduino Uno

NOTA: Debe desconectar el cable USB de la placa Arduino antes de proporcionar voltaje
desde una fuente externa.

Especificaciones.

 Microcontrolador ATmega328.
 Tensión de operación (nivel lógico) de 5 volts.
 Tensión de entrada (recomendada) de 7 a 12 volts.
 Tensión de entrada (límites) de 6 a 20 volts.
 Se cuenta con 14 pins Entrada/Salida digitales, 6 proveen de salida PWM.
14 14
 Capitulo 1

 Se cuenta con 6 entradas analógicas.

 Corriente máxima por cada pin de Entrada /Salida hasta 40mA.
 Corriente máxima para el pin de 3.3 Volt de 50mA.
 Memoria Flash de 32 KB de los cuales 0.5 KB son usados por el bootloader.
 Dimensiones de 68.6 mm x 53.4 mm.
 Peso de 25 gr.

Alimentación.

El Arduino Uno puede ser alimentado a través de la conexión USB o con una fuente de
alimentación externa. Por diseño, el robot Andromie MP usa un conjunto de baterías como
fuente de alimentación externa. El Arduino Uno puede funcionar con un suministro externo
de 6 a 20 volts.

Comunicación.

El Arduino Uno es fácil de comunicar con la computadora mediante un adaptador USB-Serial

integrado en la tarjeta electrónica, solo requiere de un cable USB-A a USB-B. El software de
Arduino incluye una herramienta llamada “Monitor serial”, el cual permite el envío de datos
simples, desde y hacia la placa Arduino. Mientras el cable USB esté conectado, la
computadora proveerá energía para el encendido del Arduino Uno.

NOTA: Para instalar los controladores de la tarjeta Arduino Uno consulte el anexo A.

Entrada y Salida.

Cada uno de los 14 pins digitales del Arduino Uno puede ser usado como entrada o salida,
usando las funciones “pinMode()”, “digitalWrite()” y “digitalRead()”.

La tarjeta Arduino Uno posee 6 entradas analógicas, cada una de ellas provee de 10 bits de
resolución (1024 valores diferentes). Por defecto miden entre 5 volts y tierra.

15 15
CAPÍTULO 2

16 16
 Capitulo 2

Programando en Arduino.

Para programar el robot Andromie MP, es necesario contar con el entorno de programación
Arduino (ver figura 2.1), el cual puede ser descargado completamente gratis desde la
dirección www.arduino.cc. Se recomienda descargar la versión más reciente del programa.

Figura 2.1. Entorno de programación Arduino.

Componentes del programa Arduino.

En la barra superior de la interfaz del programa Arduino, encontrará todos los elementos
necesarios para interactuar con la tarjeta Arduino Uno, se enlistan a continuación:

17 17
 Arduino / Hummingbird

Verificar: inspecciona el código generado, marca errores y posibles soluciones.

Cargar: cuando se presiona este botón se compila y se ensambla el código
contenido en la ventana y se descarga a la tarjeta electrónica Arduino. Este
proceso puede tardar algunos segundos.
Nuevo: crea un nuevo “sketch” en blanco.
Abrir: abre un “sketch”, código ya existente.
Guardar: salva todas las modificaciones realizadas en el código.
Monitor Serial: abre la aplicación del “Monitor serial”, sirve para propósitos de
comunicación con el dispositivo Arduino y el entorno de programación. Por
ejemplo, realizar la calibración de sensores de piso.

¿Qué es un “Sketch”?

Cada ambiente de desarrollo tiene un área de trabajo específica y bien delimitada, por
ejemplo, considere un editor de texto, su tarea es clara, la generación de escritos
electrónicos y la redacción está determinada en cada página virtual, de igual manera la hoja
de trabajo donde se realiza la composición de un código fuente en plataforma Arduino se
llamada “sketch”.

El “sketch” contiene toda la información programable o no a la tarjeta Arduino (los

comentarios son un ejemplo de información dentro del “sketch” que no se transfiere,
simplemente se deja como ilustración o guía para el programador), la estructura se
generaliza para todos los “sketch”, las modificaciones radican principalmente en las
funciones y arreglos de instrucciones, permitiendo alcanzar la meta por parte del diseñador
con base en las características de la tarjeta Arduino a ocupar. Los programas hechos con
Arduino se dividen en tres partes principales:

 Estructura
 Variables y constantes
 Funciones

NOTA: El lenguaje de programación Arduino se basa en C/C++.

Estructuras.

La estructura del lenguaje de programación de Arduino es bastante simple y se compone

principalmente de dos secciones, “void setup()” y “void loop()”. Éstas encierran bloques
más complejos conteniendo declaraciones e instrucciones. La sintaxis sería la siguiente:

void setup()
{
Instrucción_1;
18 18
 Capitulo 2

}
void loop()
{
Instrucción_2;
}

Las dos secciones se definen a continuación:

 setup(): Es la parte donde se configuran las entradas, salidas y los módulos. Es

llamado también “inicialización”, lo contenido en este bloque se ejecuta solamente
una vez al inicio del programa.
 loop(): Es el ciclo principal donde se escribe el código del programa, y se repetirá
indefinidamente.

Valores constantes.

El lenguaje de programación de Arduino tiene valores predeterminados, los cuales no

presentan cambios por lo que son llamados “constantes”. Se utilizan para hacer los
programas más fáciles de leer. Las constantes más usadas se enlistan a continuación:

 HIGH: Alto
 LOW: Bajo
 INPUT: Entrada
 OUTPUT: Salida
 TRUE: Verdadero
 FALSE: Falso

Variables.

Una variable es una manera de nombrar y almacenar un valor numérico para su uso
posterior por el programa. Como su nombre indica, las variables son cantidades que pueden
variar continuamente, es lo contrario de las constantes. Una variable debe ser declarada y,
opcionalmente, asignarle un valor. Los siguientes son los tipos de variables más comunes:

 char: Caracter
 byte: 8 bits
 int: Entero
 unsigned int: Entero sin signo
 long: Entero de 32 bits
 unsigned long: Entero de 32 bits sin signo
 float: Punto flotante

19 19
 Arduino / Hummingbird

Funciones.

Es el conjunto de palabras clave dentro del lenguaje de Arduino, para ordenar la realización
de una tarea al interior de la tarjeta electrónica del Arduino Uno. Las funciones que se
utilizarán en el presente texto son las siguientes:

 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á de 0V (LOW) o 5V (HIGH).
 digitalRead(): Lectura del valor digital del pin especificado.
 analogRead(): Lectura del valor analógico del pin especificado.
 analogWrite(): Configura la modulación por anchura del pulso, es decir, genera una
señal analógica aproximada.
 delay(): Genera una pausa en milisegundos.

Pasos para programar la tarjeta Arduino Uno.

Una vez generado su código fuente (programa para el robot), lo siguiente es configurar el
programa de Arduino para comunicarse por medio de la computadora y transmitir su código
a la tarjeta Arduino Uno del robot Andromie MP. Primer paso, seleccione la tarjeta Arduino
Uno, dentro del programa Arduino abra la pestaña Herramientas, desplace el cursor a la
opción Tarjeta, luego en el submenú elija Arduino Uno (ver figura 2.2)

Figura 2.2. Selección de tarjeta Arduino Uno.

20 20
 Capitulo 2

Segundo paso, se verifica que el código escrito sea correcto, presione el ícono verificar (ver
figura 2.3):

Figura 2.3. Ícono Verificar.

Esta función traduce todo lo codificado al idioma entendido por el microcontrolador.

Observe los avisos y errores de salida mostrados, si el programa se compila correctamente,
el mensaje de salida será el mostrado tal como se muestra en la figura 2.4.

Figura 2.4. Compilación correcta.

Una vez compilado y verificado el programa, y en vista de no haber errores o advertencias,

se procede a cargar el programa a la tarjeta de Arduino Uno. Para ello antes es importante
seleccionar el puerto de comunicación serial “COM” correcto. Para verificar el puerto de
comunicación serial en su computadora siga la ruta: Ir a Inicio, Equipo, dar clic secundario
sobre Equipo y después Propiedades, abra el Administrador de dispositivos (ver figura 2.5).
En la pestaña “Puertos (COM y LPT)”, verifique el puerto en el cual está ubicado el Arduino.
Generalmente tiene el nombre de “USB Serial Port”.

Figura 2.5. Administrador de dispositivos Windows.

21 21
 Arduino / Hummingbird

Una vez identificado el puerto, continúe con el tercer paso, seleccione en el entorno de
programación la pestaña Herramientas, luego puerto serial y marque el puerto COMx (ver
figura 2.6).

Figura 2.6. Selección de puerto.

Cuarto paso, cargar el programa en la tarjeta Arduino, presione el ícono de cargar (ver figura
2.7). Esta acción puede tardar algunos segundos.

Figura 2.7. Ícono Cargar.

Si la carga fue exitosa se desplegará el mensaje de confirmación carga terminada (ver figura
2.8). ¡Listo!, ha finalizado el proceso para programar la tarjeta Arduino Uno.

Figura 2.8. Mensaje de confirmación.

En la próxima sección aplicará las herramientas explicadas en este capítulo, para producir
sus primeros códigos en lenguaje Arduino, trabajando con su robot Andromie MP.

22 22
CAPÍTULO 3

23 23
 Arduino / Hummingbird

Un relato del desarrollo de los robots:

Aparecen los drones.

Su historia se remonta a finales de la Segunda Guerra Mundial, se utilizaban en un principio

como armamento ya que contaban con bombas o explosivos y se hacían detonar después
de un cierto tiempo o se accionaba la carga a distancia.
Al avanzar en su desarrollo se logró agregar más aditamentos que permitieran dar
comunicación a pilotos en vuelo o la toma de información fotográfica desde el aire.
La palabra dron, se refiere a un vehículo aéreo no
tripulado, en fechas recientes se han desarrollado
equipos similares a helicópteros en forma de X con
motores y hélices montadas en los extremos.
Son controlados por un operador por radio
frecuencia, aunque ya se está utilizando
información de dispositivos que le permiten tomar
ciertas decisiones, como posición apoyada por
GPS, equilibrio para mantener sustentabilidad al
hacer girar más rápido o más lento sus rotores y
manejo de carga de su batería.

Existe un mercado creciente en la producción y venta de

este tipo de dispositivo, un ejemplo es el mexicano Jordi
Muñoz y el estadounidense Chris Anderson que en Tijuana
fundaron la empresa 3DRobotics.

Otro ejemplo es el mexicano Pedro

Matabuena quien fabrica drones
con madera, lo que supone una
autonomía mayor, ahorro en
batería y más ligeros. Director de la
empresa Dialipso fundada en 2006,
pero fue hasta 2011 que entra al
mundo de los drones.

24 24
 Capitulo 3

Aprende jugando.

Bienvenido, usted está por comenzar una increíble aventura y convertirse en un maestro
de la robótica. En esta sección se presentan actividades prácticas con su robot Andromie
MP, donde aprenderá aspectos básicos de la programación en plataforma Arduino,
conocerá las diferentes partes que forman su robot y su funcionamiento, además pondrá
en marcha su creatividad, trabajará en equipo, se interesará más en la ciencia y la
tecnología.

Recuerde, los ejemplos expuestos sólo son un estilo de programación, cada código puede
ser mejorado por usted y superar sus propios límites. Disfrute de cada lección y diviértase
mientras aprende.

Actividad 1: Danza con robots.

¿Qué vamos a aprender?

En esta lección usted estudiará acerca de las salidas digitales, salidas analógicas, orientación
de las ruedas y movimientos básicos del robot Andromie MP. Utilizará las funciones
“pinMode()”, “digitalWrite()”, “analogWrite()” y “delay()”, trabajará con variables de tipo
entero “int” e instrucciones en “void setup()”. Conocerá la ubicación física de los motores
del robot Andromie MP y el método de manipulación. El lector entrenará su capacidad de
abstracción al interpretar la secuencia lógica del código propuesto en esta actividad.

¿Cómo lo vamos hacer?

Primero usted se familiarizará con su robot Andromie MP, el cual es de morfología móvil,
es decir, se puede desplazar de un punto a otro, su tracción es diferencial lo que significa
que no cuenta con ruedas de dirección como los automóviles, únicamente tiene dos ruedas
de tracción y un rodamiento de apoyo llamado rueda loca (tipo roll-on), las ruedas de
tracción se localizan a la izquierda y derecha del robot Andromie MP (ver figura 1.2). El
rodamiento está por debajo del compartimiento de baterías, no ejerce movimiento,
solamente se emplea para disminuir la fricción por arrastre en la superficie. Los
movimientos laterales los realiza mediante combinación de movimientos mecánicos con el
sentido de giro de las ruedas.

Las ruedas son impulsadas por dos motores de corriente directa (CD), los cuales son
manipulados por el controlador de motores, se trata de un chip llamado en electrónica
puente H, ubicado en la parte superior del robot Andromie MP, junto con la tarjeta Arduino
Uno (ver figura 1.1). El controlador de motores necesita cuatro pins de la tarjeta Arduino
para poder trabajar, se designan dos pins digitales (12 y 13) y dos pins analógicos (10 y 11),
más adelante se explicará su uso.

25 25
 Arduino / Hummingbird

¿Usted reconoció los elementos de su robot Andromie MP mencionados anteriormente?

Muy bien, usted aprende rápido, es hora de dejar por el momento la parte física y pasar a
la programación. En esta actividad escribiremos un código sencillo para poder visualizar los
movimientos básicos del robot Andromie MP, por ejemplo: avanzar, retroceder, girar, etc.
Estos mismos se usarán a lo largo del presente volumen durante las diversas actividades.

¿Ha bailado alguna vez? ¿Le parece simple?, bueno, usted le enseñará al robot Andromie
MP algunos pasos. Ponga mucha atención en la siguiente rutina:

1.- Bailarín quieto.

2.-Contoneo a la derecha.
3.- Contoneo a la izquierda.
4.-Pasitos hacia adelante.
5.- Contoneo a la derecha.
6.- Contoneo a la izquierda.
7.-Pasitos hacia atrás.

Esta rutina natural, es una secuencia lógica de movimiento para el baile, al finalizar solo se
tiene que repetir para volver a bailar, y claro, no perder el ritmo. De esta forma se
comportan los robots y casi todos los equipos autónomos existentes, repitiendo secuencias
lógicas diseñadas por personas hábiles como usted.

Figura 3.1. Ícono del acceso directo al programa Arduino.

Por favor, abra el programa Arduino en su computadora haciendo doble clic en un ícono
parecido al mostrado en la figura 3.1, en la interfaz de desarrollo abra un nuevo sketch (si
requiere más información vea el capítulo 1 bajo el tema Componentes del programa de
Arduino), transcriba el código propuesto para esta actividad:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores, se necesitan cuatro pins: 10, 11,
12 y 13
//pins 10 y 12 para motor derecho
int motordervel = 10; //Se relaciona pin 10 a variable "motordervel" para manipular
velocidad
int motorderdir = 12; //Se relaciona pin 12 a variable "motorderdir" para manipular
dirección
//pins 11 y 13 para motor izquierdo

26 26
 Capitulo 3

int motorizqvel = 11; //Se relaciona pin 11 a variable "motorizqvel" para manipular
velocidad
int motorizqdir = 13; //Se relaciona pin 13 a variable "motorizqdir" para manipular
dirección
//OJO
//Se introduce el valor "127" no es un pin de la tarjeta Arduino Uno
int acelerador = 127; //Se relaciona "acelerador" variable tipo entero con 127 valor
decimal

//Configuración de entradas y salidas

void setup()
{
//Salidas digitales
pinMode(motorderdir, OUTPUT); //Los pins 12 y 13 son digitales
pinMode(motorizqdir, OUTPUT);

//Motores apagados al iniciar

analogWrite(motordervel, 0); //Salidas analógicas con valor cero
analogWrite(motorizqvel, 0); //para mantener el robot en reposo
}

//Ciclo principal
void loop()
{

//Robot en alto
analogWrite(motordervel, 0); //Salidas analógicas con valor cero
analogWrite(motorizqvel, 0); //para mantener el robot en reposo
delay(500); //Retardo de ejecución

//Robot gira a la derecha

analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
delay(500); //Retardo de ejecución

//Robot gira a la izquierda

analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
delay(500); //Retardo de ejecución

27 27
 Arduino / Hummingbird

//Robot avanza
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo
digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
delay(500); //Retardo de ejecución

//Robot gira a la derecha

analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
delay(500); //Retardo de ejecución

//Robot gira a la izquierda

analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
delay(500); //Retardo de ejecución

//Robot retrocede
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
delay(500); //Retardo de ejecución

}
/* --------------------Fin de código-------------------- */

Una vez transcrito en el programa Arduino, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej: “robot
bailarín”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
éste buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

28 28
 Capitulo 3

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

ADVERTENCIA: Al momento de encender el robot Andromie MP, tenga cuidado, no lo

coloque en el suelo de inmediato, existe una parte llamada bootloader en la tarjeta Arduino
Uno, la cual emite energía por un breve instante durante el encendido, provocando
reacciones inesperadas por parte del robot, sujételo firmemente, espere un momento y
posteriormente continúe. Esto solo sucede con actividades relacionadas a los motores, si la
tarea no los emplea, el robot no reaccionará abruptamente.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
observando.

¿Qué fue lo que pasó?

Reconozcamos las terminales de la tarjeta Arduino Uno que ocupamos, se mencionó al

comienzo sobre el controlador de motores y la necesidad de cuatro pins. Los digitales “12”
y “13”, son para indicar la polaridad de los motores, aquí se obtiene el sentido de giro de la
rueda positiva (HIGH) y negativa (LOW), por esta razón se necesitan señales digitales las
cuales sólo pueden tener valor alto (HIGH) y bajo (LOW), se necesita un pin por cada motor.
Los analógicos “10” y “11”, determinan la cantidad de energía para los motores, el método
de aproximación numérica usado para controlar la velocidad se aborda en la siguiente
lección.

Para poder iniciar, solo se crea la variable de tipo entera llamada “acelerador” y se le asigna
un valor decimal constante de 127, para obtener una velocidad media, también se crean
variables para relacionar los pins para el controlador de motores.

En la sección “void setup()” configuramos los pins digitales dedicados para el controlador
de motores como salidas con la instrucción “pinMode()”, con la siguiente sintaxis:

pinMode(pin, OUTPUT); //La leyenda OUTPUT indica el comportamiento del pin como
salida.

El lector notará las sentencias dentro de la sección “void setup()”, esto para aprovechar la
propiedad de ejecutarse al principio durante el arranque de la tarjeta Arduino, recuerde
que dichas sentencias sólo se llevan a cabo una vez.

29 29
 Arduino / Hummingbird

Ahora analizaremos las funciones del lenguaje Arduino aplicadas en el ciclo principal “void
loop()”, para condicionar el sentido de giro de las ruedas de tracción izquierda y derecha se
usa la expresión “digitalWrite()”, acorde a la sintaxis:

digitalWrite(pin , HIGH); //Para obtener un sentido positivo

digitalWrite(pin , LOW); //Para indicar un sentido negativo

Para definir la velocidad se usa el estamento “analogWrite()” para permitir una salida
analógica aproximada, la sintaxis se escribe:

analogWrite(pin , valor); //Donde pin y valor pueden sustituirse por variables haciendo más
dinámico el código.

También se usa la instrucción “delay()” en milisegundos, por ejemplo: 1 segundo equivale a

1000 milisegundos, su sintaxis es simple:

delay(valor); //El valor implica la demora en milisegundos.

Posteriormente se llega a la construcción de movimientos básicos, se mencionó al empezar

que se conseguían a través de combinaciones mecánicas de los elementos de tracción
diferencial (ver figura 3.4), aquí los elementos están en reposo equiparable al alto total, en
el código ejemplo aparece bajo el título comentado: Robot en alto.

Se hizo la consideración sobre el baile como una secuencia lógica de movimientos, en el

código propuesto como ejemplo se enlista dicha secuencia mediante la combinación de
salidas digitales y analógicas para controlar los motores, y subsecuentemente el sistema
mecánico de tracción diferencial. Las sentencias descritas en el código ejemplo se resumen
en los siguientes movimientos básicos:

Giro derecha: Para construir este movimiento se ordena girar a la rueda derecha en sentido
negativo, al mismo tiempo la rueda izquierda gira en sentido positivo, creando un
movimiento en su propio eje, dando la vuelta a la derecha como se ve en la figura 3.2a. En
el código lo encuentra con el título comentado: Robot gira a la derecha.

Giro izquierda: Se tiene que generar un efecto contrario al movimiento de girar a la

derecha, se logra invirtiendo el sentido de giro de ambas ruedas, de forma similar crea un
desplazamiento sobre su eje, se ilustra en la figura 3.2b. Para ver las sentencias en el código
propuesto busque el título comentado: Robot gira a la izquierda.

Adelante: Se consigue este movimiento polarizando positivamente ambas ruedas, así

avanzara sin problemas (ver figura 3.2c). Sus instrucciones aparecen en el código con el
título comentado: Robot avanza.

30 30
 Capitulo 3

Retroceso: Este último movimiento sumamente básico y necesario, es el opuesto al

desplazamiento frontal de avanzar, se hace al polarizar las ruedas negativamente (ver figura
3.2d). Las sentencias se escriben en el código fuente con el título comentado: Robot
retrocede.

Ha dado el primer paso para convertirse en un gran maestro de la robótica, pero no pierda
el ritmo, la próxima lección es mucho más emocionante, a tal grado que acelerará su
corazón.

a)

b)

c)

d)

Figura 3.2. Movimientos básicos Robot Andromie MP.

31 31
 Arduino / Hummingbird

Un relato del desarrollo de los robots:

Robots móviles.

Los robots móviles se desplazan gracias a

actuadores o motores integrados a su
estructura, éste tipo de robots están dotados de
sensores que les proporcionan información del
entorno y que además poseen un
microcontrolador o circuito lógico, el cual
mediante un programa y la información recibida
por los sensores le indicarán al robot de qué
forma actuar o moverse en el entorno. Éste tipo
de robots son los más utilizados debido a las
características que trae consigo su diseño al
estar dotado de ruedas para que se desplacen,
esto permite que tengan un mayor control y
estabilidad mecánica, dentro de esta categoría
se citan los robots seguidores, de lucha y velocistas.

Este tipo de robots actualmente son empleados en la industria, particularmente en cadenas

de grandes almacenes, donde se tienen que mover gran cantidad de artículos o cargas de
un lugar a otro, se emplean bandas electromagnéticas incorporadas en el suelo que le
indican la posición en la que se encuentra el robot, además los diferentes sensores ubicados
a los costados le permiten no chocar con otros robots.

Robot móvil utilizado para mover cargas de hasta 350 kg.

32 32
 Capitulo 3

Actividad 2: Pisando el acelerador.

¿Qué vamos a aprender?

En esta lección usted estudiará el concepto de variables globales, señales analógicas de

salida con PWM y construcción de sub-funciones. Trabajará con variables enteras “int” para
designar pins de la tarjeta Arduino Uno, y también la usará para almacenar la información
de manera dinámica. Utilizará las instrucciones “pinMode()”, “digitalWrite()”,
“analogWrite()” y “delay()”. El lector desarrollará su habilidad para sintetizar, al evitar
repetir líneas de código, agrupándolas de forma sistematizada.

¿Cómo lo vamos hacer?

Imaginemos por un momento que su robot Andromie MP va a participar en un circuito de

carreras, lo primero sería reconocer la pista, se trata de cuatro tramos de concreto
hidráulico para alta velocidad, estos se entrelazan dibujando una especie de rectángulo, es
decir, sus curvas son casi de 90°, claro, usted es un piloto con experiencia, sabe lo peligroso
de tomar ese tipo de curvas a muy alta velocidad, por lo tanto debe aminorar el acelerador,
de lo contrario podría sufrir un percance.

Su robot Andromie MP no puede ver el camino, pero con su ayuda podrá hacerlo, usted
programará al robot con una secuencia lógica para trazar un rectángulo semejante al
circuito de carreras, con curvas de 90°.

Figura 3.3. Esquema del circuito de carreras.

Como se habla de un rectángulo, esta figura geométrica se compone por dos lados largos y
dos cortos, sus vértices son rectos, es decir, las intersecciones forman ángulos de 90° (ver
figura 3.3).

33 33
 Arduino / Hummingbird

Primero, se propone un punto de referencia para la navegación, como se trata de un

vehículo se sostiene la regla de tránsito de circular por la derecha, en tal caso el robot gira
a la derecha y conservará este sentido durante todo el recorrido.

Segundo, el robot Andromie MP iniciará desde uno de los lados más largos como lo refleja
la imagen de la figura 3.3, lo hará a máxima velocidad.

Tercero, al llegar al vértice disminuye la velocidad al punto de frenar, cambia el acelerador

a una velocidad media y gira a la derecha con un ángulo de 90°, prosigue con la siguiente
intersección, realiza un nuevo giro de 90° da vuelta a la derecha, coloca el acelerador al
fondo y vuelve a comenzar.

NOTA: Recuerde, si el texto aparece después de “//” o está encerrado por “/*…*/”, se trata
de comentarios que son únicamente para explicar las líneas del código, la tarjeta Arduino
Uno no usa esa información, son una ayuda para que usted comprenda la ejecución de cada
línea de código en el programa.

¿Emocionado? Sujete su cinturón de seguridad, porque esta rutina usted la programará en

su robot Andromie MP, se propone el siguiente código fuente, por favor transcríbalo a un
nuevo sketch:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores, se necesitan cuatro pins: 10, 11, 12
y 13
//pins 10 y 12 para motor derecho
int motordervel = 10; //Se relaciona pin 10 a variable "motordervel" para manipular
velocidad
int motorderdir = 12; //Se relaciona pin 12 a variable "motorderdir" para manipular
dirección
//pins 11 y 13 para motor izquierdo
int motorizqvel = 11; //Se relaciona pin 11 a variable "motorizqvel" para manipular
velocidad
int motorizqdir = 13; //Se relaciona pin 13 a variable "motorizqdir" para manipular dirección

//OJO Las salidas analógicas pins 10 y 11, requieren se defina el valor de operación
//OJO Las salidas analógicas de la tarjeta Arduino Uno, usan métodos de aproximación
numérica
//OJO El método de aproximación empleado se llama PWM, el cual determina la cantidad
de energía
//OJO La energía liberada se mide en volts "V", tiene un rango de trabajo de 0 V a 5 V
físicamente
//OJO Para aproximar numéricamente este valor se usa el esquema de división de 5 V entre
255 valores

34 34
 Capitulo 3

//OJO Es decir, cada valor decimal permite la salida analógica de 0.0196 V aprox.
//OJO Por lo tanto la velocidad está definida entre 0 y 255 valores equivalente 0 V y 5 V
int acelerador; //Variable tipo entera llamada "acelerador"

//Se indican los nombres de sub-funciones de movimiento

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();

//Configuración de entradas, salidas e instrucciones iniciales

void setup()
{
//Salidas digitales
pinMode(motorderdir, OUTPUT); //Solo los pins 12 y 13 son digitales
pinMode(motorizqdir, OUTPUT);

//Motores apagados al iniciar

alto();
}

//Ciclo principal
void loop()
{
//Secuencia de instrucciones para la rutina de movimiento
acelerador = 255; //Define una velocidad máxima para todas las sub-funciones de
movimiento
avanza();
delay(500); //Demora para el movimiento
alto();
delay(500); //Demora para el movimiento
acelerador = 127; //Define una velocidad media para todas las sub-funciones de
movimiento
derecha();
delay(250); //Demora para el movimiento, son 250 ms aprox. para obtener un giro de 90°
avanza();
delay(500); //Demora para el movimiento
alto();
delay(500); //Demora para el movimiento
derecha();
delay(250); //Demora para el movimiento, son 250 ms aprox. para obtener un giro de 90°
}

35 35
 Arduino / Hummingbird

//Sub-función robot en alto

void alto()
{
analogWrite(motordervel, 0); //Salidas analógicas con valor cero
analogWrite(motorizqvel, 0); //para mantener el robot en reposo
}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador"
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
}
//Sub-función robot gira a la izquierda
void izquierda()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador"
digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
}
//Sub-función robot avanza
void avanza ()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador"
digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo
digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
}
//Sub-función robot retrocede
void retrocede ()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador"
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
}
/* --------------------Fin de código-------------------- */

Una vez transcrito el programa de Arduino, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej: “carrera”.

36 36
 Capitulo 3

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

Expliquemos un poco sobre el cálculo para obtener salidas analógicas por el método de
modulación de ancho de pulso (PWM por sus siglas en inglés), el cual es una aproximación
numérica de una variable física, en este caso voltaje unidad básica en electrónica, no es
objetivo en el curso un análisis a profundidad sobre PWM se deja a criterio del lector una
investigación más detallada. Basta por el momento con formular la relación entre energía
liberada por la tarjeta Arduino Uno y los valores decimales de referencia de salida. El voltaje
de salida está en el rango de 0 a 5 V, y la configuración interna de PWM para la salida, opera
entre 0 a 255 valores decimales. La fórmula es una simple regla de tres:

5 V = 255 valores.
0 V = 0 valores.

Suponiendo la variable “X” y relacionándola a un valor, tenemos:

X= ( (5 V) (1 valores) ) / (255 valores)

X= 0.0196 V aprox.

Por lo tanto, cada valor libera en la salida analógica 0.0196 V, entre más valores mayor
energía.

Ya sabe cómo trabajan las salidas analógicas, pero ¿se imagina tener que cambiar los valores
de referencia en cada instrucción “analogWrite()”?, con el fin de evitar esta circunstancia

37 37
 Arduino / Hummingbird

se utilizan variables globales, usted las ha usado antes pero no se había percatado, un
ejemplo simple es:

int acelerador; //Variable abierta no está asociada a ningún valor

Se considera global porque la puede modificar en cualquier parte del proceso dentro de su
código fuente, si al principio la asocia a un valor, éste será constante para cualquier función,
pero si la deja abierta puede actualizarse en algún momento.

Muy bien, ahora reconoce las variables globales, otra representación es usada por usted al
asignar un pin de la tarjeta Arduino Uno a cierta variable, por ejemplo: las dedicadas al
controlador de motores.

¿Distingue mejor las partes del programa?, si es así, notará la sencillez del ciclo principal,
esto es resultado del uso de sub-funciones, ¿Qué son?, bueno, son instrucciones también
del lenguaje Arduino, se usan para no repetir secuencias y disminuir líneas de código.
Semejante a hacer una síntesis de un texto. La construcción es sencilla, se toma como
ejemplo la rutina de girar a la derecha de la actividad 1:

//Robot gira a la derecha

analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
delay(500);

Se elimina lo no necesario, ej: la función “delay()” la puede colocar en el ciclo principal; si

conserva las variables se tienen que declarar al principio del código fuente porque trabajan
como variables globales, después se crea la sub-función con la siguiente sintaxis:

void sub_función_nombre() //Se le coloca nombre para hacer referencia en el ciclo principal
{
sentencias; //Líneas de instrucciones a ejecutar
} //Los corchetes “{}” indican el alcance de la sub-función

38 38
 Capitulo 3

Visto lo anterior, se sustituyen sentencias y se nombra la sub-función:

void derecha() //Sub-funcion “void derecha()”

{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}

Una vez creada, se tiene que declarar escribiendo el nombre de la sub-función antes del
“void setup()” y su código debe estar al final del ciclo “void loop()”, si usted requiere
emplear la sub-función solo la nombra en el ciclo “void loop()” y se llevará a cabo, ejemplo
de sintaxis:

void derecha();

void setup()
{
………
}
void loop()
{
derecha();
………
}
//Área para sub-funciones
void derecha()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}

NOTA: No intercambie mayúsculas por minúsculas tanto en variables como en funciones o

sub-funciones, podría confundirse y ocurrir un error de compilación.

Ahora entiende por qué fue tan simple grabar en el ciclo principal la ruta de circuito de
carreras, pero no se confié pues en la pista no había obstáculos, ¿Cómo reaccionará el robot
si se topa con un objeto a medio camino? Esto lo averiguará en la siguiente lección.

39 39
 Arduino / Hummingbird

Un relato del desarrollo de los robots:

Robots de servicio.

El término robot de servicio se da al robot que

ayuda a realizar tareas de servicio a los humanos y
que sean excluyentes de tareas de manufactura.
Por ejemplo, un robot de servicio puede ser aquel
que ayude en exploración espacial, un robot de
servicio puede ser también aquel que ayude a las
tareas de limpieza en la casa.
Los robots de servicio pueden operar de forma
totalmente autónoma o parcial, ayudando y
facilitando las tareas de los humanos.
Entre las diferentes categorías de robots de servicio
se pueden citar las siguientes:
- Exploración y seguridad: rescate, minería,
manejo de explosivos y uso de armamento.
- De salud: sistemas de cirugía, cuidado de
personas.
- De limpieza: servicios domésticos y limpieza
en zonas industriales.
- Trabajos peligrosos: vigilancia y seguridad,
construcción, robots contra incendios.
Robot de exploración

Robot limpiador Roomba

40 40
 Capitulo 3

Actividad 3: Insecto bot.

¿Qué vamos a aprender?

En esta lección usted estudiará los sensores de contacto, señales digitales de entrada y
establecerá condiciones de operación. Reconocerá físicamente en el robot Andromie MP la
ubicación de los sensores de contacto. Practicará lo aprendido con las sub-funciones para
determinar el movimiento del robot Andromie MP, usará las funciones “pinMode()”,
“digitalRead()” y la estructura de control “if … else”. El lector pondrá en práctica su
capacidad de discernimiento en la toma de decisiones.

¿Cómo lo vamos hacer?

Si el robot Andromie MP estuviera en movimiento y de repente se encontrara con algún

obstáculo, ¿qué pasaría? ¿cómo reaccionaría el robot? Son excelentes preguntas, usted
sabe dar marcha a los motores, también cambiar la velocidad, pero no distinguir objetos y
mucho menos programar al robot para tomar decisiones.

¿Le parece difícil?, pierda el temor, pues usted diseñará un robot muy inteligente capaz de
resolver las problemáticas planteadas en el párrafo anterior. Para identificar los obstáculos
se necesitan sensores, estos dispositivos son el canal por donde el robot Andromie MP
puede procesar la información del medio ambiente a su alrededor, ahora el robot podrá ver
de una forma simbólica. En esta lección trabajará con los sensores de contacto.

Conozca más sobre el robot Andromie MP, los sensores de contacto se ubican en la parte
inferior frontal sobre el disco bajo de la estructura del robot Andromie MP (ver figura 3.4).
Cuenta con uno a la izquierda y el otro a la derecha, son dos switches mecánicos diseñados
para impacto, pero tenga cuidado porque pueden dañarse si se maltratan, tienen
extensiones en forma de antenas para mayor alcance, semejante a un insecto. Estos
sensores de contacto se encuentran conectado a los pins digitales 2 y 3 de la tarjeta Arduino
Uno. Operan con lógica negativa o inversa, significa que si perciben un contacto generan un
pulso digital bajo (LOW), en caso contrario, su pulso digital es alto (HIGH).

Figura 3.4. Sensores de contacto.

41 41
 Arduino / Hummingbird

Ahora el robot Andromie MP distingue obstáculos, ¿qué sigue? Tomar decisiones como se
comentó anteriormente. Usted programará un robot inteligente por medio de programas
que determinarán el comportamiento y la capacidad de elegir del robot. El método
propuesto busca determinar las posibles causas de interferencia en el funcionamiento del
robot, las cuales implican no terminar su tarea, la cual es desplazarse de un punto a otro sin
atorarse. Imagine por un instante que usted es un robot caminando de frente y se encuentra
los siguientes casos:

A) Caso donde no hay nada, usted sigue caminando.

B) Caso donde topa con algo a su izquierda, retrocede y gira a la derecha para evadir.
C) Caso donde topa con algo a su derecha, retrocede y gira a la izquierda para evadir.
D) Caso donde se encuentra con el obstáculo de frente, retrocede y gira a la derecha
para evadir (por convención de navegación).

Perfecto, usted es un gran robot. Esta toma lógica de decisiones formará la inteligencia
artificial de su robot Andromie MP. Por favor escriba el código ejemplo propuesto en un
nuevo sketch del programa Arduino:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores, se necesitan cuatro pins: 10, 11, 12
y 13
//pins 10 y 12 para motor derecho
int motordervel = 10;
int motorderdir = 12;
//pins 11 y 13 para motor izquierdo
int motorizqvel = 11;
int motorizqdir = 13;

//Se nombra variables para los sensores de contacto izquierdo y derecho, se usan 2 pins: 2
y3
int contactoizq; //La variable entera "contactoizq" para sensor de contacto izquierdo
int contactoder; //La variable entera "contactoder" para sensor de contacto derecho

//Variable para control de velocidad

int acelerador = 127; //Variable tipo llamada "acelerador" ajustada para velocidad media

//Se indican los nombres de sub-funciones

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();

42 42
 Capitulo 3

//Configuración de entradas, salidas e instrucciones iniciales

void setup()
{
//Salidas digitales
pinMode(motorderdir, OUTPUT); //Los pins 12 y 13 son digitales
pinMode(motorizqdir, OUTPUT); //Se configuran como salida

//Entradas digitales
pinMode(2, INPUT); //Los pins 2 y 3 son digitales
pinMode(3, INPUT); //Se configuran como entrada

//Motores apagados al iniciar

alto();
delay(250);
}

//Ciclo principal
void loop()
{
contactoizq = digitalRead(2); //Lectura digital de sensores de contacto y asignación a
variables
contactoder = digitalRead(3);

//Condición principal del programa para avanzar

if(contactoizq == HIGH && contactoder == HIGH) //Caso principal no hay obstáculo
{
avanza();
delay(250);
}
else
{
if(contactoizq == LOW) //Caso con obstáculo a la izquierda
{
retrocede(); //Acción retroceder y girar a la derecha para librar obstáculo
delay(250);
derecha();
delay(250);
}
else
{
if(contactoder == LOW) //Caso con obstáculo a la derecha
{
retrocede(); //Acción retroceder y girar a la izquierda para librar obstáculo
delay(250);

43 43
 Arduino / Hummingbird

izquierda();
delay(250);
}
else
{
if(contactoizq == LOW && contactoder == LOW) //Caso con obstáculo frontal
{
retrocede(); //Acción retroceder y girar a la derecha para librar obstáculo
delay(250);
derecha();
delay(250);
}
}
}
}

}
//Sub-función robot en alto
void alto()
{
analogWrite(motordervel, 0); //Salidas analógicas con valor cero
analogWrite(motorizqvel, 0); //para mantener el robot en reposo
}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
}
//Sub-función robot gira a la izquierda
void izquierda()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
}
//Sub-función robot avanza
void avanza ()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127

44 44
 Capitulo 3

digitalWrite(motorderdir, HIGH); //Hace girar la rueda derecha en sentido positivo

digitalWrite(motorizqdir, HIGH); //Hace girar la rueda izquierda en sentido positivo
}
//Sub-función robot retrocede
void retrocede ()
{
analogWrite(motordervel, acelerador); //Salidas analógicas cuyo valor lo determina
analogWrite(motorizqvel, acelerador); //la variable "acelerador" que equivale a 127
digitalWrite(motorderdir, LOW); //Hace girar la rueda derecha en sentido negativo
digitalWrite(motorizqdir, LOW); //Hace girar la rueda izquierda en sentido negativo
}
/* --------------------Fin de código-------------------- */

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej:
“insectobot”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

El código fuente comienza declarando las variables necesarias, se relacionan aquellas

exclusivas para trabajar con los pins de la tarjeta Arduino y se indican las sub-funciones a
ocupar. En la actividad anterior aprendió a construir sub-funciones, ese mismo método se
aplica en todos los movimientos básicos del robot Andromie MP, creando un conjunto de
sub-funciones muy útil a lo largo de este libro, se enlistan a continuación:

45 45
 Arduino / Hummingbird

void alto(); //Detiene la marcha de los motores

void derecha(); //Provoca un giro a la derecha
void izquierda(); //Provoca un giro a la izquierda
void avanza(); //Ordena desplazarse al frente
void retrocede(); //Se inicia la reversa

Sus sentencias aparecen en el código propuesto como ejemplo al final del ciclo “void
loop()”, simplificando mucho las líneas de código y facilitando su lectura. Solo se escribe el
nombre de la sub-función deseada en el ciclo principal “void loop()”, para ejecutar su acción.

Después en la sección de “void setup()”, se usa la instrucción “pinMode()” para configurar

las salidas y entradas digitales, en el caso relevante de esta lección, lo correspondiente a
pins de los sensores de contacto 2 y 3, se utiliza la siguiente sintaxis:

pinMode(pin, INPUT); //La leyenda “INPUT” determina al pin como entrada digital

Hecho esto con los pins 2 y 3, se incluye en “void setup()” algo muy importante para un
robot: las primeras instrucciones, éstas dictan el estado primario del robot, es decir, su
origen.

Más adelante en el ciclo principal, se realiza la lectura digital de los sensores de contacto
mediante la sentencia “digitalRead()”, debe estar antes de otra sentencia para dar prioridad
a la lectura recuerde que los programas son secuenciales, significando la ejecución de línea
de instrucción por línea de instrucción, salvo cuando hay un salto como los provocados por
sub-funciones. Para almacenar la lectura de los pins 2 y 3, se asigna el valor a una variable,
la sintaxis se escribe:

contacto = digitalRead(pin); //El valor de lectura en pin se guarda en la variable “contacto”

Realizada la lectura el robot podrá distinguir si hay un obstáculo en su paso, tomar una
decisión y seguir avanzando.

En párrafos anteriores, se realizó una comparación de usted como un robot, concluyendo

en la lógica para elegir la acción más conveniente y evadir el obstáculo. Estos casos se
transcriben al robot con ayuda de la estructura de control “if … else”, su interpretación es
sencilla: Se plantea una condición, “if” si se cumple (se toma como verdadera), se realiza la
acción abarcada por corchetes “{}”, en caso contrario, es decir, no se cumple la condición
(se toma como falsa), se realiza la acción siguiente abarcada por “else”. Se pueden anidar
varios “if … else”, así se crea un control en el flujo de la información y por lo tanto de las
acciones a ejecutar.

Hay cuatro casos muy importantes en el comportamiento del robot Andromie MP, todos
dependen de los sensores de contacto:

46 46
 Capitulo 3

A) Los sensores de contacto no detectan nada.

B) El sensor de contacto izquierdo fue activado.
C) El sensor de contacto derecho fue activado.
D) Ambos sensores de contacto fueron activados.

Pero, cómo sabe si fue pulsado un sensor de contacto, pues haciendo la comparación en la
condición al interior del “if … else”, tome por ejemplo el caso A, no debe existir ninguna
señal baja (LOW), la referencia inmediata es la señal digital opuesta alto (HIGH), porque solo
pueden tener esos valores, en el código se usa el operador lógico de igualdad “==”:

if(contactoizq == HIGH && contactoder == HIGH) // El símbolo “&&” implica doble

cumplimiento, es decir, las dos condiciones deben ser verdaderas de lo contrario no se
efectúan la sentencias.

Las sentencias subsecuentes son el llamado a las sub-funciones de movimiento, para tener
una respuesta inmediata.

Su robot actúa igual a un pequeño insecto detectando los obstáculos con sus pequeñas
antenas, pero un par de antenas no superan la visión de tres ojos, ¿A qué nos referimos? Lo
averiguará en la próxima lección.

47 47
 Arduino / Hummingbird

Un relato del desarrollo de los robots:

Visión artificial.
Con los avances en tecnología se ha dotado a los robots con gran cantidad de sensores para
reconocer su entorno, sin embargo, desde los primeros robots desarrollados, siempre se
planteó la idea de dotarlos con visión, el hacer que un robot reconozca la ubicación de un
objeto o reconozca el objeto como tal, es una tarea muy difícil.
Con el desarrollo de la robótica nació una rama de estudio llamada inteligencia artificial,
esta rama de la robótica se encarga del estudio, análisis y procesamiento de datos a través
del estudio de imágenes digitales.
Dotando de visión a los robots, éstos pueden realizar diferentes tareas entre las cuáles
podemos citar, reconocimiento de rostros en las personas, inspección de objetos,
reconocimiento de colores y manejo de herramientas.
Para dotar de visión a un robot se suelen utilizar imágenes obtenidas a través de una cámara
o sensores especializados que reconozcan colores y a través de software realizar el
reconocimiento de objetos. Quizá llegue pronto el día en que los robots puedan reconocer
y disfrutar de la belleza de un atardecer.

Robot Nao, dotado con sistema de reconocimiento de imágenes

48 48
 Capitulo 3

Actividad 4: Reconociendo el camino.

¿Qué vamos a aprender?

En esta lección usted reconocerá los sensores de proximidad del robot Andromie MP,
aplicará metodología inversa sobre el ejemplo propuesto en la actividad 3, manipulará
señales digitales de entrada, usará estructura de control y sub-funciones de movimiento
básicas. Repasará las funciones “pinMode”, “digitalRead()” e “if … else”. El lector ampliará
su mente con la nueva herramienta del robot Andromie MP, dando otra perspectiva para
obtener la solución a problemas similares.

¿Cómo lo vamos hacer?

Los sensores de contacto vistos en la lección pasada, sólo son un modo de evitar obstáculos,
pero esto implica objetos con una altura menor a la del robot, piense en una saliente, por
ejemplo el refuerzo de una silla, este se coloca entre las patas de la silla, sin embargo, no
toca el suelo, si el robot pasa por el arco formado por las patas de la silla, seguro se atora,
porque los sensores de contacto jamás percibieron algo.

No se preocupe, conocerá otro tipo de canal para percibir el medio alrededor del robot
Andromie MP, los sensores de proximidad, los cuales son dispositivos optoelectrónicos, es
decir, trabajan con fenómenos de la luz, en precisión con la reflexión del espectro infrarrojo
del haz de luz, el cual no se percibe a simple vista. Muchos aparatos en la vida cotidiana lo
ocupan como servidores de papel, llaves automáticas para el agua, controles remotos, etc.

Estos geniales sensores de proximidad se localizan en la parte superior del robot Andromie
MP, sobre el disco de acrílico transparente en la zona del frente como se muestra en la
figura 3.5.

Figura 3.5. Ubicación de sensores de proximidad.

Son tres dispositivos que se ubican a la izquierda, centro y derecha, los laterales
proporcionan un ángulo de visión de 45° respecto al centro, están conectados a la tarjeta
Arduino Uno en los pins 4, 5 y 6, en ese preciso orden. La señal de respuesta es digital,
puede ser alto (HIGH) o bajo (LOW), si un sensor de proximidad reconoce algún objeto
manda un pulso bajo (LOW), si el camino está libre siempre estarán en alto (HIGH).

49 49
 Arduino / Hummingbird

Explicado lo anterior, se propone reestructurar el código de la actividad 3, en este ejercicio

no se trabajará con los sensores de contacto solo con los sensores de proximidad, el robot
Andromie MP reconocerá objetos de tamaño similar, evadiéndolos a su paso.

ADVERTENCIA: Se recomienda trabajar esta actividad en un área donde no incida

directamente la luz del sol. Los sensores de proximidad son ópticos, pueden tener
comportamientos erráticos si hay interferencia lumínica. Se recomienda un lugar techado
como el salón de clases, evite realizar la actividad al aire libre.

Se propone el siguiente código, por favor escríbalo en un nuevo sketch en el programa

Arduino:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores

int motordervel = 10;
int motorderdir = 12;
int motorizqvel = 11;
int motorizqdir = 13;

//Se nombran variables para los sensores de proximidad izquierdo, centro y derecho
int proxizq;
int proxcen;
int proxder;

//Variable para control de velocidad

int acelerador = 127; //Variable tipo llamada "acelerador" ajustada para velocidad media

//Se indican los nombres de sub-funciones

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();

//Configuración de entradas y salidas

void setup()
{
//Salidas digitales pins 12 y 13
pinMode(motorderdir, OUTPUT); //PIN 12 para motor derecho
pinMode(motorizqdir, OUTPUT); //PIN 13 para motor izquierdo

//Entradas digitales pins 4, 5 y 6

pinMode(4,INPUT); //PIN 4 para sensor de proximidad izquierdo

50 50
 Capitulo 3

pinMode(5,INPUT); //PIN 5 para sensor de proximidad centro

pinMode(6,INPUT); //PIN 6 para sensor de proximidad derecho

//Motores apagados al iniciar

alto();
delay(250);
}

//Ciclo principal
void loop()

{
//Lectura digital de sensores de proximidad y asignación a variables
proxizq = digitalRead(4); //PIN 4 a sensor de proximidad izquierdo
proxcen = digitalRead(5); //PIN 5 a sensor de proximidad centro
proxder = digitalRead(6); //PIN 6 a sensor de proximidad derecho

if(proxizq == HIGH && proxcen == HIGH && proxder == HIGH) //Condición principal del
programa para avanzar
{
avanza(); //Indicación de avance
delay(250);
}
else
{
if(proxizq == LOW) //Caso con obstáculo a la izquierda
{
retrocede(); //Acción retroceder y girar a la derecha para librar obstáculo
delay(500);
derecha();
delay(250);
}
else
{
if(proxder == LOW) //Caso con obstáculo a la derecha
{
retrocede(); //Acción retroceder y girar a la izquierda para librar obstáculo
delay(500);
izquierda();
delay(250);
}
else
{
if(proxcen == LOW) //Caso con obstáculo al centro

51 51
 Arduino / Hummingbird

{
retrocede(); //Acción retroceder y girar a la derecha para librar obstáculo
delay(500);
derecha();
delay(250);
}
}
}
}

}
//Sub-función robot en alto
void alto()
{
analogWrite(motordervel, 0);
analogWrite(motorizqvel, 0);
}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot gira a la izquierda
void izquierda()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, LOW);
}
//Sub-función robot avanza
void avanza ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot retrocede
void retrocede ()
{

52 52
 Capitulo 3

analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, LOW);
}
/* --------------------Fin de código-------------------- */

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej: “tres_ojos”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

La declaración de variables es la misma a la actividad 3, se conservan los mismos pins para

el controlador de motores, y las sub-funciones de movimiento básicas se mantienen.
Únicamente se agregan las variables para guardar las lecturas de las entradas digitales de
los tres sensores de proximidad, además se configuran los pins 4, 5 y 6, en el “void setup()”
con la instrucción “pinMode()” acorde a la siguiente sintaxis:

pinMode(pin , INPUT); //La leyenda “INPUT” establece el comportamiento de pin como

entrada.

Analicemos lo sucedido, los sensores de proximidad sustituyen a los de contacto de piso,

esto es posible debido a que los sensores ópticos tienen lógica inversa al igual que los
sensores mecánicos, es decir, si hay alguna perturbación generan un pulso bajo (LOW), caso

53 53
 Arduino / Hummingbird

contrario están siempre en alto (HIGH), luego los criterios para tomar decisiones son
semejantes:

A) Si ningún sensor de proximidad percibe obstáculo, avanza frontalmente.

B) Si el sensor de proximidad izquierdo percibe obstáculo, retrocede y gira a la derecha.
C) Si el sensor de proximidad derecho percibe obstáculo, retrocede y gira a la izquierda.
D) Si el sensor de proximidad central percibe obstáculo, retrocede y gira a la derecha.

Estos se construyen con la estructura de control “if … else” anidada (una estructura dentro
de otra), controlando el flujo de la información en el ciclo principal “void loop()”, la sintaxis
resumida es:

if(condición_1)
{
Sentencia_1;
}
else
{
if(condición_2)
{
Sentencia_2;
}
else
{
… … … etc.
}

Las condiciones la imponen los tres sensores de proximidad. El ciclo se repetirá

indefinidamente permitiendo al robot Andromie MP deambular libremente por el área de
trabajo.

NOTA: Los sensores de proximidad tienen un rango muy pequeño de alcance

aproximadamente 2 cm desde el punto focal del propio sensor.

Finalmente, el objetivo del ejercicio es ilustrar las diversas formas para resolver alguna
problemática, tenga en cuenta las ventajas y desventajas de cada método, elija el más
conveniente a la situación.

Pero estas no son todas las herramientas, el robot Andromie MP puede percibir por
contacto, detectar cuando un objeto se aproxima, sin embargo, no ve el suelo donde se
encuentra. Esto lo aprenderá en la siguiente lección.

54 54
 Capitulo 3

Un relato del desarrollo de los robots:

Teleoperación robótica

Un sistema robótico de
teleoperación es aquel que
permite manipular objetos que
se encuentran ubicados en
lugares remotos o distantes y
que pueden ser utilizados para
realizar tareas complejas.
Desde un principio el hombre
se ayudó de herramientas que
le permitieran manipular
objetos que fueran peligrosos,
el desarrollo de la robótica
trajo consigo el nacimiento de
la teleoperación, un sistema de
teleoperación permite
controlar el movimiento de un
robot ubicado en una zona
remota.
Teleoperación con exoesqueleto.

La teleoperación ha sido aplicada en diferentes campos de estudio: existen robots que son
empleados para realizar cirugías a distancia, también hay robots que ayudan a desactivar
bombas de manera remota.

Teleoperación en cirugía

55 55
 Arduino / Hummingbird

Actividad 5: Buscando el tesoro.

¿Qué vamos a aprender?

En esta lección el lector reconocerá los sensores de contraste de piso del robot Andromie
MP, estudiará sobre señales analógicas de entrada y repasará lo aprendido de las
estructuras de control. Usará la función “analogRead()” para capturar los valores de los
sensores de contraste de piso y practicará con todo lo visto en las lecciones anteriores. El
lector desarrollará su habilidad de integración y organización.

¿Cómo lo vamos a hacer?

Los sensores de contraste de piso son dispositivos optoelectrónicos que perciben el rebote
del espectro infrarrojo del haz de luz (no es visible a los ojos), su funcionamiento es
semejante al de sus primos en la parte superior del robot, pero éstos sí varían sus valores
dependiendo de la cantidad de energía registrada, por esta razón se utiliza señales
analógicas.

Los sensores de contraste de piso se componen por dos partes emisor y receptor. El primero
es un LED infrarrojo, es decir, despide una luz no visible para el ojo humano. El segundo es
un fototransistor que se encarga de captar los rayos del espectro infrarrojo, el cual tiene un
filtro diseñado para permitir el paso de este tipo de luz.

El robot Andromie MP tiene cuatro sensores de contraste de piso, usted los puede localizar
si gira el robot y lo observa desde la parte inferior, orientado con las antenas de los sensores
de contacto hacia arriba, están en la parte superior como lo muestra la figura 3.6.

Figura 3.6. Sensores de contrate de piso.

Los sensores de contraste de piso están conectado a la tarjeta Arduino Uno, en los pins
analógicos “A0”, “A1”, “A2” y “A3”, éstos son de uso exclusivo y no se utilizan para otra
tarea. Físicamente los puede identificar como izquierdo, izquierdo-centro, derecho-centro
y derecho, en ese preciso orden.

56 56
 Capitulo 3

a) b)
Figura 3.7. Efecto de reflexión
a) Con superficie opaca y b) con superficie clara.

El funcionamiento es sencillo, normalmente el LED infrarrojo emite sus rayos en dirección

frontal, si la superficie es opaca no hay casi rebote de rayos infrarrojos al receptor por lo
que la energía recibida será poca (ver figura 3.7a). Si la superficie es clara, los rayos
infrarrojos chocan y casi todos regresan incidiendo en el receptor, por lo tanto la energía
captada será alta (ver figura 3.7b). A este fenómeno en física se le llama reflexión de la luz.

Teniendo presente lo explicado arriba, los sensores de contraste de piso le permiten al

robot Andromie MP distinguir la superficie donde está caminando, piense en los ejemplos
de los ejercicios 3 y 4, en éstos el robot se desplaza evadiendo obstáculos de un punto a
otro, pero en ningún momento había una instrucción indicando que ya ha llegado a su
destino. Aquí planteamos la búsqueda del tesoro, se pondrá una marca obscura “X” en el
suelo (superficie de pruebas), el robot iniciará su marcha en un extremo, evitará los objetos
como en las actividades 3 y 4, pero una vez localizada la marca “X” en la superficie, dará por
terminada la tarea.

NOTA: Para tener un mejor desempeño recuerde colocar su robot en una superficie lisa, se
recomienda crear una pista de pruebas con cartulina y cinta color negra.

El código propuesto utiliza los sensores de contacto para evitar objetos, por favor redacte
el siguiente código en un nuevo sketch:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores

int motordervel = 10;
int motorderdir = 12;
int motorizqvel = 11;
int motorizqdir = 13;

//Se nombra variables para sensores de contacto izquierdo y derecho

int contactoizq;
int contactoder;

//Se nombran variables para sensores de contraste de piso

int pisoizq; //Sensor lado izquierdo (A0)
int pisocenizq; //Sensor centro lado izquierdo (A1)

57 57
 Arduino / Hummingbird

int pisocender; //Sensor centro lado derecho (A2)

int pisoder; //Sensor lado derecho (A3)

//Variable para control de velocidad

int acelerador = 127;

//Se indican los nombres de sub-funciones

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();

//Configuración de entradas, salidas e instrucción inicial

//OJO
//Recuerda los pins para sensores analógicos no se configuran en la sección "setup()"
void setup()
{
//Salidas digitales pins 12 y 13
pinMode(motorderdir, OUTPUT);
pinMode(motorizqdir, OUTPUT);

//Motores apagados al iniciar

alto();
delay(2000);
}

//Ciclo principal
void loop()
{
//Lectura analógica de sensores de contraste de piso y asignación a variable
pisoizq = analogRead(A0);
pisocenizq = analogRead(A1);
pisocender = analogRead(A2);
pisoder = analogRead(A3);
//Lectura digital de sensores de contacto y asignación a variables
contactoizq = digitalRead(2);
contactoder = digitalRead(3);

//La condición principal para avanzar depende de los sensores de contraste de piso
//El robot no debe encontrarse sobre una superficie opaca para poder avanzar
//Sí el robot encuentra una superficie opaca significa que ha llegado a su destino
if(pisoizq > 512 && pisocenizq > 512 && pisocender > 512 && pisoder > 512)
{

58 58
 Capitulo 3

avanza();
}
else
{
alto();
}
if(contactoizq == LOW) //Caso con obstáculo a la izquierda
{
retrocede();
delay(250);
derecha();
delay(250);
}
if(contactoder == LOW) //Caso con obstáculo a la derecha
{
retrocede();
delay(250);
izquierda();
delay(250);
}
if(contactoizq == LOW && contactoder == LOW) //Caso con obstáculo frontal
{
retrocede();
delay(250);
derecha();
delay(250);
}

}
//Sub-función robot en alto
void alto()
{
analogWrite(motordervel, 0);
analogWrite(motorizqvel, 0);
}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot gira a la izquierda

59 59
 Arduino / Hummingbird

void izquierda()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, LOW);
}
//Sub-función robot avanza
void avanza ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot retrocede
void retrocede ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, LOW);
}

/* --------------------Fin de código-------------------- */

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej: “buscador”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

60 60
 Capitulo 3

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

El lector se habrá percatado que en los ejemplos propuestos la estructura general no varía,
es decir, se mantiene íntegra, para ilustrarlo se escribe la siguiente sintaxis:

//Declaración de variables
//Declaración de sub-funciones

Void setup()
{
pinMode(pin , salida/entrada);
}

void loop()
{
lectura_digital = digitalRead(pin);
digitalWrite(pin , valor); //Escritura digital

lectura_analogica = analogRead(pin);
analogWrite(pin , valor); //Escritura analógica

if (condición)
{
sentencias_1;
}
else
{
sentecnia_2
}
}
//Sub-funciones

Se podría decir que este es el armazón de todos los códigos propuestos hasta el momento,
téngalo presente mientras se analiza el código fuente para la búsqueda del tesoro. Se
declaran cuatro variables para almacenar los datos suministrados por los sensores
analógicos, estos valores son interpretados por la tarjeta Arduino por un método de
aproximación numérico conocido en electrónica como convertidor analógico digital (ADC
por sus siglas en inglés), no es propósito del curso profundizar sobre el tema, se deja a
criterio del lector investigar al respecto. Para fines prácticos de la obra basta con hacer la

61 61
 Arduino / Hummingbird

formulación correspondiente, primero la tarjeta Arduino Uno trabaja con electricidad

donde la unidad básica es el volt, los rangos de operación son de 0 a 5 V y el sistema digital
interno de la tarjeta Arduino Uno para aproximación numérica de entrada está en el rango
de 0 a 1024 valores decimales. La relación se expresa:

5 V = 1024 valores
0 V = 0 valores

Suponga “X” variable de señal analógica de entrada por un valor decimal:

5 V = 1024 valores
X = 1 valores

Por regla de tres, la fórmula se escribe:

X= ( (1 valor) (5 V) ) / (1024 valores)

X= 0.00488 aprox. V

Dada esta relación, en el código ejemplo se busca un contraste en la superficie, si es clara

(blanca por ejemplo) se presupone una entrada máxima de energía, como lo indica la
relación matemática, pero si es opaca (negro por ejemplo) la energía tiende a disminuir al
grado de casi llegar a cero.

Esta variación la registran los sensores de contraste con la instrucción “analogoRead()”, y

es almacenada para posteriormente ser comparada en la estructura de control “if … else”,
aquí el valor de referencia 512 alude a una entrada de energía promedio aproximadamente
2.5 V, ideal para suelo estándar, se obtuvo en pruebas de calibración, este método se
expone en próximas lecciones. Las condiciones usadas en este ejemplo para los sensores de
contraste de piso, son comparadores de desigualdad, mayor que “>”, a diferencia de las
señales digitales solo tienen dos valores, las señales analógicas pueden variar, por lo tanto
se crean límites con puntos de referencia, como el indicado anteriormente, ejemplo:

if(pisoizq > 512 && pisocenizq > 512 && pisocender > 512 && pisoder > 512) //El símbolo
“&&” implica el cumplimiento de la siguiente condición, en este caso las cuatro tienen que
ser verdaderas.

Resumiendo las acciones, el robot Andromie MP avanzará siempre y cuando no esté sobre
alguna área oscura, durante su recorrido los sensores de contacto estarán pendientes de
los obstáculos a su paso, tomando las decisiones ilustradas en la actividad 3, durante su
marcha el robot estará percibiendo el brillo del suelo con los sensores de contraste,
buscando la marca del tesoro “X”, si pasara por ella finaliza la búsqueda.

Felicitaciones, consiguió hallar el tesoro, su recompensa es un merecido descanso, porque

la siguiente lección pondrá a prueba sus oídos con la actividad 6: Escuchando el camino.

62 62
 Capitulo 3

Un relato del desarrollo de los robots:

Un robot de exploración espacial.

La exploración espacial puede ser algo emocionante pero al mismo tiempo puede ser una
tarea muy peligrosa, desde tiempos remotos el hombre ha observado las estrellas con la
ilusión de algún día poder viajar hasta ellas.
Viajar al espacio puede ser peligroso ya que no existe oxígeno ni un ambiente favorable
para el desarrollo de la vida. La astronáutica es la ciencia que estudia lo relacionado con la
tecnología y los vuelos espaciales, desde que se realizaron los primeros viajes al espacio fue
primordial crear robots que ayudaran a los humanos en las tareas de exploración.

La era espacial empezó a mediados de los años 50’s con el lanzamiento del satélite ruso
Sputnik, desde entonces el desarrollo de satélites, vehículos espaciales y robots
exploradores con tecnología cada vez más avanzada ha sido constante.

En noviembre de 2011 la NASA lanzó a Marte el robot Curiosity un robot de morfología móvil para
la exploración del planeta marciano, el robot tiene por objetivo realizar muestras del suelo del
planeta rojo, está equipado con diferentes instrumentos científicos, cámaras de alta resolución,
sensores de radiación, espectrógrafos y un brazo mecánico, además de poseer un generador con
capacidad de vida de 14 años. El Curiosity es el robot más avanzado creado por el hombre en materia
de exploración, se espera que durante los dos años de misión planeados para el robot aporte
conocimientos acerca de la existencia de agua y datos que puedan servir para la futura colonización
del planeta rojo.

63 63
 Arduino / Hummingbird

Actividad 6: Escuchando el camino.

¿Qué vamos a aprender?

El lector ubicará el sensor de proximidad ultrasónico del robot Andromie MP y conocerá su

principio de operación. Estudiará el concepto de librerías en lenguaje Arduino y aplicará las
funciones exclusivas del sensor ultrasónico. Empleará la herramienta “Monitor serial” del
programa Arduino para calibración de sensores, usará las funciones “Serial.begin()” y
“Serial.print()”. El lector creará su propio criterio para el diseño y fabricación de un robot
basado en la experiencia obtenida en las actividades anteriores.

¿Cómo lo vamos a hacer?

El sensor de proximidad ultrasónico se localiza en la parte frontal, debajo del disco de

acrílico como se aprecia en la figura 3.8. Este dispositivo electroacústico se forma por dos
elementos, una pequeña bocina (emisor de sonido) y un micrófono (receptor de sonido),
los pins asociados a la tarjeta Arduino Uno son 7 (emisor) y 8 (receptor).
NOTA: tenga mucho cuidado con estas terminales (pin 7 y 8) y no las invierta, de lo contrario
podría causar daño al sensor.

Figura 3.8. Sensor de proximidad ultrasónico.

Sobre el funcionamiento del sensor de proximidad ultrasónico, este aparato emite por la
bocina una señal sonora no audible para el ser humano, porque supera la frecuencia del
umbral de audición de las personas (de 20 Hz a 20 KHz), a estos sonidos por su frecuencias
se les llama ultrasónicos. Otro fenómeno acústico relacionado con el sensor es el eco, el
cual se define como el rebote de ondas sonoras en el medio, aquí entra el micrófono del
sensor, el cual capta las ondas sonoras ultrasónicas producto del rebote con algún objeto
(ver figura 3.9). ¿Le suena familiar?, posiblemente porque es semejante al funcionamiento
de los sensores optoelectrónicos vistos en lecciones anteriores.

64 64
 Capitulo 3

Figura 3.9. Operación del sensor de proximidad ultrasónico.

Después de haber leído la descripción del sensor de proximidad ultrasónico, lo pondrá en

operación, no se alarme, únicamente se visualizarán los valores para reforzar su
entendimiento sobre el funcionamiento del sensor, para ello también se empleará el
método de calibración con ayuda de la herramienta “Monitor serial”, la cual se explicará
más adelante, por favor, redacte el siguiente código en un nuevo sketch del programa
Arduino:

/* --------------------Inicio de Código-------------------- */

//Declaración de librerías a usar dentro del programa

//OJO
//La librería "Ultrasonic.h" contiene todas las funciones para manejar el sensor de
proximidad ultrasonico
//Si no se declara el sensor simplemente no trabaja y el programa de Arduino indica error.
#include <Ultrasonic.h>
//OJO
//El sensor de proximidad ultrasónico necesita 2 pins para trabajar
//Un pin emite sonido ultrasónico, llamado "Disparo"
//El otro pin recibe el rebote del sonido, se le llama "Eco"
//En la tarjeta Arduino Uno se utilizan exclusivamente los pins 7 y 8, para el sensor de
proximidad ultrasónico
//OJO
//Para no dañar el sensor de proximidad ultrasónico, los pins siempre deben estar en el
siguiente orden:
Ultrasonic Ultrasonic(7,8); //Esta instrucción indica a la librería cual es el pin disparo(7) y
pin eco (8)

//Declaración de variables
int distancia; //Variable tipo entera para almacenar datos del sensor de proximidad
ultrasonico

//Configuración de Módulos
void setup()
{
//Se inicia el módulo de comunicación serial
65 65
 Arduino / Hummingbird

Serial.begin(9600);
//OJO
//Nota que no se declaró ningún pin como entrada o salida
//La razón es sencilla, solo se está usando el sensor de proximidad ultrasónico y la librería
"Ultrasonic.h"
//Esta librería contiene la información necesaria e inclusive configura los puertos de la
tarjeta Arduino Uno
//Por ese motivo es muy importante el orden de los pins en la instrucción del principio

//Ciclo principal
void loop()
{
//Lectura del sensor de proximidad ultrasónico
//OJO
//La función "Ultrasonic.Ranging()" proporciona la distancia en línea recta a algún objeto
enfrente del robot
//Sí usa la función "Ultrasonic.Ranging(CM)", las letras "CM" indica la unidad de conversión
en centímetros
//Sí usa la función "Ultrasonic.Ranging(INC)", las letras "INC" indica la unidad de conversión
en pulgadas
//La distancia máxima de detección del sensor ultrasónico son 50 cm
distancia = Ultrasonic.Ranging(CM); //El valor del sensor de proximidad ultrasónico se
guarda en "distancia"
Serial.print("distancia: "); //Texto que aparece en la pantalla de monitor serial a renglón
seguido
Serial.print(distancia); //Valores que aparece en la pantalla de monitor serial a renglón
seguido
Serial.println(" cm"); //Texto que aparece en la pantalla de monitor serial a renglón seguido
con salto de línea
delay(1000); //Demora de 1 segundo

/* --------------------Fin de código-------------------- */

NOTA: Para abrir la ventana del “Monitor serial”, haz doble clic en el ícono que se
localiza en la esquina superior derecha del programa Arduino, debes tener conectado el
cable USB a la tarjeta Arduino Uno del robot Andromie MP, en caso contrario ocasiona un
error de comunicación indicando ‘Puerto serial COM# no encontrado’.

66 66
 Capitulo 3

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej:
“ultrasónico”.

NOTA: Se recomienda leer la sección ¿Qué fue lo que pasó?, antes de continuar, para
aclarar el uso de librerías en lenguaje Arduino, una vez finalizada la lectura regrese a este
paso.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Puede omitir este paso si no requiere alimentación externa para los motores,
es decir, no activara el interruptor de encendido del robot Andromie MP. Lo anterior lo
realiza en actividades de comunicación con el monitor serial del programa de Arduino.

Ejecutar: Observe, tome nota y disfrute su programa con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

Uso de librería Ultrasonico.h

Antes de analizar el código propuesto, se definen algunos conceptos necesarios sobre

librerías en el programa Arduino, en específico la librería “Ultrasonico.h” como lo son la
declaración de parámetros con “Ultrasonic ()” y la función “Ultrasonic.Ranging()”.

Una librería en lenguaje Arduino, es un código práctico comprobado para adicionar

funcionalidad al entorno de programación, por ejemplo, para la manipulación de nuevo
hardware no incluido en las tarjetas Arduino.

Este es el caso del sensor de proximidad ultrasónico, al no ser un hardware fabricado

directamente con Arduino, el programa para desarrollo no tiene parámetros para usarlo, el
lector puede hacer la semejanza al tratar de conectar su nueva impresora a la computadora,
esta no tiene los programas básicos necesarios para la comunicación y menos aún poder
imprimir, pues se requiere la instalación de sus controladores para poder trabajar.

67 67
 Arduino / Hummingbird

Las librerías configuran los parámetros básicos necesarios para ocupar el nuevo hardware,
también proporcionan el canal o funciones para comunicación con él. De esta forma
simplifica el código y agregan nuevas herramientas al lenguaje de Arduino. Tal es el caso de
la librería “Ultrasonic.h”, la descarga segura la puede hacer desde la siguiente dirección web
(requiere conexión a internet):

http://ingenieriamx.wix.com/aicosoluciones

Dentro del portal diríjase a la pestaña servicios, sección de descargas, el archivo está
comprimido por lo que necesita tener instalado “winrar” en su pc, una vez terminada la
descarga, debe extraer la carpeta llamada “Ultrasonic” al interior de su computadora para
adicionar la librería al programa de Arduino, se ejemplifica la ruta:

"Mis Documentos\Arduino\libraries"

NOTA: Los nombres indicados son ilustrativos, pueden cambiar dependiendo de la

configuración de cada PC y sistema operativo instalado.

Para confirmar la instalación en el programa de Arduino, abra la interfaz de desarrollo, haga

clic en la pestaña “Sketch”, dentro del menú de selección desplace el cursor hasta “importar
librería”, en la lista desplegada diríjase a la parte inferior donde debe aparecer “Ultrasonic”,
¡listo! ha finalizado (ver figura 3.10).

Una vez agregada la librería “Ultrasonic.h” a la interfaz de desarrollo de Arduino, se debe

relacionar con el código, para hacerlo únicamente al inicio del código fuente se escribe la
leyenda:

#include <Ultrasonic.h> //Declaración de librería

Hecho esto, todas las funciones de la librería están disponibles para usar en el código, la
primera instrucción para configurar el hardware del sensor ultrasónico es:

Ultrasonic Ultrasonic(7,8); //Esta instrucción indica a la librería cuál es el pin disparo(7) y

pin eco (8).

NOTA: debe respetar el orden al interior del paréntesis, los pins de la tarjeta Arduino Uno
siempre serán 7 y 8. Los pins disparo (bocina) y eco (micrófono) están físicamente
direccionados al sensor de proximidad ultrasónico. No respetar el orden puede causar daño
permanente en el sensor de proximidad ultrasónico.

Ahora, para realizar la lectura de la distancia percibida por el sensor de proximidad

ultrasónico, se emplea la función:

Ultrasonic.Ranging(CM);

68 68
 Capitulo 3

Esta sentencia regresa la distancia en centímetros a un objeto frente al robot Andromie MP,
los cálculos los realiza automáticamente la librería “Ultrasonic.h”, el rango de operación
efectivo es 0 a 50 cm, con error de +/- 1 cm aprox. (el sensor puede dar un mayor alcance
pero el comportamiento del robot se vuelve inestable).

Figura 3.10. Librería Ultrasonic en el programa Arduino.

Usted adicionó exitosamente la librería “Ultrasonic.h” al programa Arduino y conoce las

funciones para ocupar el sensor de proximidad ultrasónico, es hora de iniciar la herramienta
“Monitor serial” de la interfaz de comunicación con la tarjeta Arduino Uno. Finalice el
proceso descrito después de capturar el código ejemplo y abra el “Monitor serial”, debe
aparecer una nueva ventana como en la figura 3.11.

NOTA: Se recomienda tener una regla a la mano para realizar comparaciones en las
mediciones del sensor de proximidad ultrasónico y los valores que aparecen en la ventana
del “Monitor serial”.

69 69
 Arduino / Hummingbird

El código propuesto es muy sencillo, después de declarar la librería “Ultrasonic.h” y sus

parámetros, se usa una variable llamada “distancia” para asignar la lectura del sensor de
proximidad ultrasónico y ser visualizada por medio del “Monitor serial”.

Figura 3.11. Monitor serial.

El “Monitor serial” es una herramienta muy usada para el proceso de calibración de los
sensores, permite ver el comportamiento de estos ante algún estímulo y con ello poder
determinar la acción del robot mediante alguna estructura de control, dentro de estas
mediciones se puede obtener un valor de referencia, por ejemplo, el sensor de proximidad
ultrasónico tiene un rango efectivo de 0 a 50 cm. Regresando al código en “void setup()”,
se inicializa el puerto de comunicación serial entre la tarjeta Arduino Uno y la computadora,
con la sentencia:

Serial.begin(9600); //El valor estándar 9600 es para sincronizar la transferencia de datos

para equipo electrónico.

Para enviar la distancia registrada por el sensor de proximidad ultrasónico, mediante el

cable USB, se usan las instrucciones:

Serial.print("distancia: "); //Envía texto a renglón seguido

Serial.print(distancia); //Transfiere el valor de la variable

Serial.println(" cm"); //Envía texto pero al final realiza un salto de línea.

Compruebe los valores con ayuda de una regla, apoye el robot en la mesa de trabajo,
coloque la marca del cero por debajo del sensor de proximidad ultrasónico, ponga un objeto
sólido (la caja del robot por ejemplo), desplace sobre la regla y compare las lecturas.

70 70
 Capitulo 3

Un relato del desarrollo de los robots:

El robot Da Vinci.

El robot Da Vinci es el robot quirúrgico más avanzado del mundo. Está compuesto por una
consola de comandos, una plataforma con 4 brazos robóticos y un sistema de visualización
de alta definición, este robot es un sistema de teleoperación, el cual puede realizar tareas
quirúrgicas especializadas con precisión y control.
El robot puede realizar intervenciones quirúrgicas menos invasivas en los pacientes ya que
a los brazos robóticos jamás les temblará el pulso, de esta forma puede evitar daños en el
paciente por hemorragias causadas por realizar un corte demasiado grande, una
intervención quirúrgica menos invasiva también permite que el paciente tenga una
recuperación de salud más pronta.

El cirujano manipula el robot a través de un par de mandos que ofrecen un control en

tiempo real de cada una de las articulaciones del robot, el robot reproduce movimientos de
mano, muñeca y dedos en movimientos muy precisos.
Hasta el año 2013 había unos 3000 robots Da Vinci en diferentes hospitales alrededor del
mundo, se calcula que en ese año se realizaron unas 300,000 cirugías con este robot.

71 71
 Arduino / Hummingbird

Actividad 7: El murciélago buscador.

¿Qué vamos a aprender?

En esta lección pondrá en práctica lo aprendido sobre el sensor de proximidad ultrasónico,

empleará la librería “Ultrasonic.h”, la configuración “Ultrasonic Ultrasonic()” y la instrucción
“Ultrasonic.Ranging()”, los aplicará en la búsqueda de objetos y condicionará los
movimientos del robot Andromie MP. El lector recordará todas las funciones del lenguaje
Arduino estudiadas hasta el momento.

¿Cómo lo vamos a hacer?

¿Sabía usted que el murciélago detecta a sus presas mediante sonidos ultrasónicos?, ¿sabe
cómo lo logran? Por el fenómeno de eco-localización, este mamífero volador emite por
boca o nariz una especie de chillido a una muy alta frecuencia, superior a los 20 KHz, este
sonido impacta sobre insectos (normalmente base de su alimentación), el eco producido
por las ondas sonoras regresa al murciélago y con ayuda de sus orejas las detecta, lo
fantástico es que a través de esta información el murciélago puede orientarse, medir la
distancia y distinguir a su presa (ver figura 3.12).

Figura 3.12. Ilustración del fenómeno de eco-localización del murciélago.

¿Le parece conocido?, efectivamente así funciona el sensor de proximidad ultrasónico, y de

forma similar el robot Andromie MP navegará buscando atrapar a su desprevenida presa.

72 72
 Capitulo 3

Se describe el comportamiento del robot haciendo la analogía con el murciélago:

1.- El robot Andromie MP iniciará en reposo, igual el murciélago cuando sale de su

gruta para cazar.
2.- El robot realiza la lectura del sensor de proximidad, el murciélago genera su
chillido para percibir si el camino se encuentra libre.
3.- Si no hay objetos dentro del rango de medición, inicia la búsqueda girando. Igual
el murciélago si no hay presa, hace un rondín sobre el área.
4.- Pero si existe un objeto avanza hacia él y se detendrá sólo cuando lo tenga de
frente a menos de 15 cm. Si encontró una presa el murciélago se abalanza sobre ella
hasta haberla capturado.

La naturaleza es impresionante, esta secuencia lógica fue inspirada justamente al observar

el comportamiento del murciélago y su efectividad se traslada ahora a su robot Andromie
MP, se propone el siguiente código por favor transcríbalo a un nuevo sketch:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores

int motordervel = 10;
int motorderdir = 12;
int motorizqvel = 11;
int motorizqdir = 13;

//Declaración de variables
int acelerador = 127;
int distancia; //Variable tipo entera para almacenar datos del sensor de proximidad
ultrasónico

//Declaración de librerías a usar dentro del programa

//OJO
//La libreria "Ultrasonic.h" contiene todas las funciones para manejar el sensor de
proximidad ultrasónico
//Si no se declara el sensor simplemente no trabaja y el programa de Arduino indica error.
#include <Ultrasonic.h>
//OJO
//El sensor de proximidad ultrasónico necesita dos pins para trabajar
//Un pin emite sonido ultrasónico, llamado "Disparo "
//El otro pin recibe el rebote del sonido, se le llama "Eco"
//En la tarjeta Arduino Uno se utilizan exclusivamente los pins 7 y 8, para el sensor de
proximidad ultrasónico

73 73
 Arduino / Hummingbird

//OJO
//Para no dañar el sensor de proximidad ultrasónico, los pins siempre deben estar en el
siguiente orden:
Ultrasonic Ultrasonic(7,8); //Esta instrucción indica a la librería cual es el pin disparo(7) y
pin eco (8)

//Se indican los nombres de sub-funciones

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();

//Configuración de entradas, salidas e instrucción inicial

void setup()
{
//Salidas digitales pins 12 y 13
pinMode(motorderdir, OUTPUT);
pinMode(motorizqdir, OUTPUT);

//Motores apagados al iniciar

alto();
delay(2000);
}

//Ciclo principal
void loop()
{

//Lectura del sensor de proximidad ultrasónico

//OJO
//La función "Ultrasonic.Ranging()" proporciona la distancia en línea recta de algún objeto
enfrente del robot
//Sí usa la función "Ultrasonic.Ranging(CM)", las letras "CM" indica la unidad de conversión
en centímetros
//La distancia máxima del sensor ultrasónico son 50 cm
distancia = Ultrasonic.Ranging(CM); //El valor del sensor de proximidad ultrasónico se
guarda en "distancia"

derecha(); //Búsqueda inicial al girar a la derecha

//El robot tiene 3 acciones principales:

//1: Avanzar si el objeto está cerca
//2: Alto si el objeto está enfrente del robot

74 74
 Capitulo 3

//3: Buscar el objetivo más cercano

if(distancia < 50 && distancia > 15) //El objeto se debe ubicar en el rango de 15 a 50 cm de
de distancia
{
avanza(); //Indicación de avance
}
else
{
if(distancia < 15) //El objeto debe está enfrente del robot
{
alto(); //Indicación de alto
delay(500);
}
else
{
izquierda(); //Búsqueda secundaria girando a la izquierda
}
}
}
//Sub-función robot en alto
void alto()
{
analogWrite(motordervel, 0);
analogWrite(motorizqvel, 0);
}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot gira a la izquierda
void izquierda()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, LOW);
}
//Sub-función robot avanza
void avanza ()
{

75 75
 Arduino / Hummingbird

analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot retrocede
void retrocede ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, LOW);
}
/* --------------------Fin de código-------------------- */

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej: “batbot”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

El código inicia con la declaración de variables, se relaciona la librería “Ultrasonic.h”, se

configuran los pins para el sensor ultrasónico, se indican las sub-funciones de movimiento
y en “void setup()” las salidas digitales para los motores.

76 76
 Capitulo 3

Ahora, en el “void loop()”se debe realizar primero la lectura del sensor ultrasónico y asignar
el valor a la variable “distancia”, ¿por qué? Por el tiempo de respuesta del sensor
ultrasónico, se debe permitir al rebote del sonido regresar linealmente al micrófono, así se
previenen errores de comportamiento con el robot.

La lectura y asignación lo hace con la sentencia:

distancia = Ultrasonic.Ranging(CM); //La distancia la indica en centímetros.

En la estructura de control “if … else”, la condición principal es el rango de cercanía para el

robot, en otras palabras, avanza si el objeto está cerca (entre 15 y 50 cm) y se detiene por
completo cuando se encuentra frente a él (menos de 15 cm), en caso contrario continúa la
búsqueda.

Para poder obtener este flujo de información se usa “if … else” anidado, los valores de
referencia están en centímetros para tener congruencia con la lectura, por ejemplo:

if(distancia < 50 && distancia > 15) // El símbolo “&&” es una expresión de implicación
necesaria, es decir, ambas condiciones deben ser verdaderas, de lo contrario no ejecuta la
sentencia.

Para hacer el sondeo, se apoya de las sub-funciones de movimiento, comienza quieto, por
un instante gira a la derecha y si aún no encuentra algo gira a la izquierda. En caso de
visualizar el objeto avanza directamente y al llegar a él se detiene.

ADVERTENCIA: Realice esta actividad sobre una superficie plana y firme, no trabaje sobre
la mesa pues el robot no detecta la altura y podría caer dañándose permanentemente.
Sobre los objetos que sirvan de presa deben estar hechos de preferencia con material
inanimado, no ponga al robot contra sus pies, por error podría golpearlo.

¿Disfrutó la búsqueda? Recuerde, los ejemplos propuestos son sólo un estilo para resolver
la tarea encomendada. No baje la guardia, hoy fue el depredador máximo pero en la
naturaleza también hay rivales a vencer, aprenderá a defenderse en la siguiente lección.

77 77
 Arduino / Hummingbird

Un relato del desarrollo de los robots:

Robótica educativa.

¿Le agradaría que su profesor de clases fuera un robot?, seguramente sería muy
interesante. Se define a la robótica educativa como el medio de aprendizaje para desarrollar
habilidades conceptuales y físicas, donde participan personas con intereses afines al diseño
y construcción, poniendo en práctica sus conocimientos de ciencias básicas y su destreza en
el manejo de herramienta, asistidos por equipo electrónico y computacional.

El objetivo pedagógico de la robótica educativa es crear un conjunto de actividades para

apoyar y fortalecer aptitudes de competencia del alumno, con el fin de adaptarlo
profesionalmente a los procesos productivos de la sociedad moderna. Todo basado en el
avance tecnológico, normalmente los ejercicios implican aspectos de mecánica, electrónica,
informática y automatización. Relacionados con organización, manejo de recursos, trabajo
en equipo y administración.

Lo anterior se logra con el uso de un robot, sea en el diseño, fabricación o resolución de

ejercicios a través de una didáctica práctica, el alumno desarrolla destrezas motoras y
cognoscitivas. Un buen ejemplo es su robot Andrmomie MP.

78 78
 Capitulo 3

Actividad 8: El camino del guerrero.

¿Qué vamos a aprender?

El lector aprenderá a integrar los diferentes tipos de sensores del robot Andromie MP y
crear estructuras de control para tareas complejas. Repasará las diferentes funciones del
lenguaje Arduino estudiadas a lo largo de las actividades. El lector dará sus primeros pasos
en la robótica de competencia al programar su robot Andromie MP como boxeador.

¿Cómo lo vamos a hacer?

Se recomienda construir un cuadrilátero o delimitar un área, a manera de lugar para el

evento, puede usar un pliego de cartulina blanca y dibujar el perímetro con cinta negra o
pintar con algún color obscuro. Deje un pequeño espacio de aproximadamente 5 cm entre
la orilla de la cartulina y el límite (ver figura 3.13).

Figura 3.13. Área de combate para robots.

Igual que los boxeadores profesionales el robot Andromie MP no puede salir del
cuadrilátero, ésta es la restricción más importante, aquí se proponen algunas reglas básicas:

79 79
 Arduino / Hummingbird

A) Los oponentes deben iniciar de espaldas en contra esquinas.

B) Únicamente pueden empujar al rival fuera de la plataforma, es un duelo de
caballeros, no se permiten golpes bajos.
C) El objetivo es sacar al contrario fuera del cuadrilátero, al realizarlo obtendrá un
punto.
D) Será a tres rounds, con una duración de 3 min cada uno.
E) Si finaliza el tiempo y ningún robot pudo sacar a su oponente, los dos obtienen un
punto.
F) El vencedor será aquel que obtenga más puntos.
G) En caso de empate, si los dos oponentes están de acuerdo se puede llevar acabo un
cuarto round para el desempate, si finalizara el tiempo sin existir vencedor o no
puede haber un cuarto duelo, se realiza un volado entre ambas partes para finalizar
la contienda (decisión de jurado).

Expuestas claramente las reglas del juego, pareciera muy fácil cumplir todos estos
requisitos, sin embargo, participar en un torneo no es sencillo, pueden pasar muchas cosas
al momento de la contienda. Por eso usted se anticipará, acondicionando su robot
Andromie MP con la mejor estrategia, generando la estructura de control para permitir el
mejor flujo de información y tomar las mejores decisiones.

Se debe determinar el comportamiento del robot por grado de importancia, paso a paso:

1.- No salir del cuadrilátero, sin importar la situación.

2.- Buscar al oponente, para derrotarlo debe verlo primero.

3.- Sacarlo de la plataforma, usando toda la potencia.

Esta secuencia lógica de casos define la táctica de desempeño del robot, y usted los
programará en el robot Andromie MP, cabe destacar que hay otros casos o eventos posibles
al momento del combate y entre más compleja sea la tarea mayor el reto de la contienda,
por ello, el método propuesto sintetiza lo más esencial para que su robot sea más fácil de
controlar y usted tenga mayor ventaja en el combate.

Para afirmar estos conceptos se propone el siguiente código ejemplo, por favor redacte el
mismo en un nuevo sketch en el programa de Arduino:

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores

int motordervel = 10;
int motorderdir = 12;
int motorizqvel = 11;

80 80
 Capitulo 3

int motorizqdir = 13;

//Se nombra variables para sensores de contacto izquierdo y derecho

int contactoizq;
int contactoder;

//Se nombran variables para sensores de contraste de piso

int pisoizq;
int pisocenizq;
int pisocender;
int pisoder;

//Variable para control de velocidad

int acelerador;

//Se indican los nombres de sub-funciones

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();

//Configuración de entradas, salidas e instrucción inicial

//OJO
//Recuerda los pins para sensores analógicos no se configuran en la sección "setup()"
void setup()
{
//Salidas digitales
pinMode(motorderdir, OUTPUT);
pinMode(motorizqdir, OUTPUT);
pinMode(2 , INPUT);
pinMode(3 , INPUT);

//Motores apagados al iniciar

alto();
delay(2000);
}

//Ciclo principal
void loop()
{
//Lectura analógica sensores de contraste de piso y asignación a variable
pisoizq = analogRead(A0);
pisocenizq = analogRead(A1);

81 81
 Arduino / Hummingbird

pisocender = analogRead(A2);
pisoder = analogRead(A3);
//Lectura digital de sensores de contacto y asignación a variables
contactoizq = digitalRead(2);
contactoder = digitalRead(3);

acelerador = 127; //Velocidad moderada para buscar al oponente

avanza();
//Condición principal para no salir de la plataforma de combate
//Si cualquier sensores de contraste de piso detecta la línea perimetral de la plataforma
//El robot retrocede al interior para seguir en el combate
if(pisoizq < 512 || pisocenizq < 512 || pisocender < 512 || pisoder < 512)
{
retrocede();
delay(250);
derecha();
delay(250);
}
if(contactoizq == LOW) //Caso con oponente a la izquierda
{
izquierda();
delay(250);
acelerador = 255; //Cambia la velocidad para atacar al oponente
avanza();
}
if(contactoder == LOW) //Caso con oponente a la derecha
{
derecha();
delay(250);
acelerador = 255; //Cambia la velocidad para atacar al oponente
avanza();
}
if(contactoizq == LOW && contactoder == LOW) //Caso con oponente al frente
{
acelerador = 255; //Cambia la velocidad para atacar al oponente
avanza();
}

}
//Sub-función robot en alto
void alto()
{
analogWrite(motordervel, 0);
analogWrite(motorizqvel, 0);

82 82
 Capitulo 3

}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot gira a la izquierda
void izquierda()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, LOW);
}
//Sub-función robot avanza
void avanza ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot retrocede
void retrocede ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, LOW);
}

/* --------------------Fin de código-------------------- */

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej:
“gladiador”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

83 83
 Arduino / Hummingbird

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

El código inicia de forma similar a los anteriores ejemplos, se declaran variables para
controlador de motores, sensores de contacto y sensores de contraste de piso, también la
variable global de control de velocidad. En “void setup()” se configuran entradas y salidas
digitales, y comienza por un breve momento en estado de reposo.

Luego en “void loop()” primero hace una lectura de todos los sensores de contraste de piso
y sensores de contacto, ajusta una velocidad media para comenzar la búsqueda del
oponente, el sistema está pendiente del límite del área de combate con la estructura “if”,
su condicional prioritaria depende de los sensores de contraste de piso para notar el borde
de la plataforma de combate, se explica su escritura:

if(pisoizq < 512 || pisocenizq < 512 || pisocender < 512 || pisoder < 512)

El símbolo “||” implica independencia en las condicionales, es decir, con solo cumplir una
es razón suficiente para ejecutar la sentencia, se usa el operador lógico de desigualdad
menor que “<” para realizar la comparación con el valor de referencia, 512 fue calculado
para una superficie con reflejo moderado como el suelo, si tiene algún inconveniente puede
hacer el ajuste con el proceso de calibración visto en la actividad 6.

¿Qué implica esta comparación?, si existe algún registro menor al umbral indicado por 512,
significa que el robot está llegando al borde del área de combate y la sentencia inmediata
es retroceder y girar a la derecha por convención de navegación. Con esto se cumple el
primer postulado para el comportamiento del robot Andromie MP.

El robot Andromie MP, hará un barrido sobre toda la arena para buscar a su adversario
utilizando las antenas conectadas a los sensores de contacto, si alguna llega a ser tocada
por el oponente, el robot gira en el mismo sentido para tenerlo de frente y arremeter contra

84 84
 Capitulo 3

él a máxima potencia. Aquí se consuma el segundo postulado para el buen desempeño del
robot.

NOTA: La estructura “if” no crea lazos forzosos con otras sentencias como lo ejerce la forma
“if … else”, porque sus casos son aislados e independientes del resto del programa,
permitiendo una respuesta más rápida.

La estocada final, si el robot Andromie MP localizó al oponente, seguramente lo tiene de

frente y lo está encarando, para dar la máxima potencia únicamente se actualiza la variable
“acelerador”, cambiando su valor de moderado al máximo 255, con ello el pin de salida
analógico libera toda la energía al controlador de motores, permitiendo inyectar un empuje
total y poder arrojar al oponente fuera de la plataforma de combate.

NOTA: Si no cuenta con otro robot puede usar algún objeto del mismo tamaño del robot
Andromie MP, a manera de sparring para practicar, un ejemplo sería la caja contenedora
del robot Andromie MP.

¿Siente la adrenalina correr por sus venas?, es normal cuando se trata de torneos
deportivos, y aunque se deje todo en el evento se debe recordar cómo regresar a casa, pero
eso lo descubrirá en la próxima lección.

85 85
 Arduino / Hummingbird

Un relato del desarrollo de los robots:

El futuro de la robótica.

Se ha hablado en las secciones anteriores de los avances de la robótica y sus aplicaciones

en aeronaves, sistemas móviles autónomos, robots de servicio, juguetes, asistentes
médicos y exploradores espaciales, la realidad supera la ficción. Los robots han contribuido
al crecimiento de la humanidad y la industria moderna depende cada vez más de ellos,
inclusive personas con situaciones incapacitantes tienen una esperanza de una vida digna
con la robótica.

Hay muchos investigadores trabajando sobre robots y fines prácticos, por citar algunos
ejemplos, considere a “Asimo” robot humanoide fabricado por Honda el cual posee
movimientos biomecánicos muy similares a los del ser humano; también se encuentra “Ask
Nao” desarrollado por Aldebaran Robotics, el cual tiene por objetivo de ayudar a niños
autistas por medio de juegos y aplicaciones para llamar la atención de los pequeños,
mejorando su sociabilidad.

La robótica es hoy en día lo que el fuego para los primeros hombres, es la llave del progreso
de la humanidad. Existen un sinfín de posibilidades y hoy tiene en sus manos ser parte de
esas posibilidades de crecimiento y desarrollo.

El recorrido ha llegado a su fin, le agradecemos a usted lector la atención prestada en “un

relato de la historia de los robots”.

86 86
 Capitulo 3

Actividad 9: Regresando a casa.

¿Qué vamos a aprender?

El lector reforzará su conocimiento sobre el sensor de proximidad ultrasónico, abrirá su

mente a las diversas formas para manipular el robot Andromie MP. Estudiará la estructura
de control “do … while”, repasará el uso de las funciones del lenguaje Arduino visto hasta
el momento y la librería “Ultrasonic”. Además trabajará con los sensores de contacto,
sensores de proximidad y las sub-unciones de movimiento. El lector entenderá la
importancia de la formulación con variables para evitar comportamientos inconvenientes o
desventajosos en el robot Andromie MP.

¿Cómo lo vamos a hacer?

Tal vez a usted haya tenido un día muy difícil en la escuela, un examen sorpresa,
posiblemente se desveló por hacer la tarea o simplemente tuvo clases de matemáticas y se
siente completamente agotado, su único pensamiento es volver a casa y descansar. Pero
para poder hacerlo tiene que guardar suficiente energía para realizar el viaje a su hogar de
lo contrario podría desmayarse.

Algo similar le pasa a su robot Andromie MP, recuerde que su robot usa una fuente de
energía limitada, aún no se fabrican generadores de energía auto regenerativos como en la
ciencia ficción, imagínese estar en medio de la competencia de robótica más importante de
la historia y no tener energía para continuar. En la ilustración propuesta, al regresar a casa
usted mide inconscientemente la cantidad de energía utilizada, por ejemplo, en lugar de
correr apresurado, camina tranquilamente.

Piense en sus clases de física, escuchó sobre la ley de la conservación de la energía: “La
energía no se crea ni se destruye solo se transforma”. Justamente de esto hablamos, su
robot Andromie MP emplea 6 baterías AA para generar una fuente de energía de corriente
directa de 9 V, alimentando a todas las partes de su robot (sensores, motores, LEDs y tarjeta
Arduino Uno), usted no lo percibe pero esa energía internamente se trasforma en corriente,
luz, fuerza mecánica, calor, etc. Por lo tanto llega un momento de extenuación en las
baterías, tal que no proporcionan los 9 V iniciales.

Haciendo referencia a la ilustración, su robot también puede caminar en vez de correr, de

hecho usted lo había programado de esta manera, ¿se acuerda de la actividad 2? ahí
aprendió a manipular la salida de energía del robot Andromie MP. También debe considerar
la navegación al evadir obstáculos semejantes a la actividad 3, y finalmente debe reconocer
su caja contenedora, aquí proponemos usar los sensores de proximidad.

¿Nota cómo ha ido desarrollando todas estas habilidades?, es momento de integrar todos
sus conocimientos, para este proceso se propone el siguiente código:

87 87
 Arduino / Hummingbird

/* --------------------Inicio de Código-------------------- */

//Se nombran variables para el controlador de motores

int motordervel = 10;
int motorderdir = 12;
int motorizqvel = 11;
int motorizqdir = 13;

//Se nombran variables para los sensores de proximidad izquierdo, centro y derecho,
int proxizq;
int proxcen;
int proxder;
//Se nombra variables para los sensores de contacto izquierdo y derecho,
int contactoizq;
int contactoder;
//Declaración de variables
int acelerador; //Para control de velocidad
int distancia; //Para determinar distancia

//Declaración de librerías a usar dentro del programa

//OJO
//La librería "Ultrasonic.h" contiene todas las funciones para manejar el sensor de
proximidad ultrasónico
//Si no se declara el sensor simplemente no trabaja y el programa de Arduino indica error.
#include <Ultrasonic.h>
//OJO
//El sensor de proximidad ultrasónico necesita 2 pins para trabajar
//Un pin emite sonido ultrasónico, llamado "Disparo"
//El otro pin recibe el rebote del sonido, se le llama "Eco"
//En la tarjeta Arduino Uno se utilizan exclusivamente los pins 7 y 8, para el sensor de
proximidad ultrasónico
//OJO
//Para no dañar el sensor de proximidad ultrasónico, los pins siempre deben estar en el
siguiente orden:
Ultrasonic Ultrasonic(7,8); //Esta instrucción indica a la librería cual es el pin disparo(7) y
pin eco (8)

//Se indican los nombres de sub-funciones

void alto();
void derecha();
void izquierda();
void avanza();
void retrocede();
void casa(); //Nueva sub-función para buscar la caja contenedora del robot

88 88
 Capitulo 3

//Configuración de entradas y salidas, instrucción inicial

void setup()
{
//Salidas digitales
pinMode(motorderdir, OUTPUT); //pin 12 para motor derecho
pinMode(motorizqdir, OUTPUT); //pin 13 para motor izquierdo

//Entradas digitales
pinMode(4,INPUT); //pin 4 para sensor de proximidad izquierdo
pinMode(5,INPUT); //pin 5 para sensor de proximidad centro
pinMode(6,INPUT); //pin 6 para sensor de proximidad derecho
pinMode(2, INPUT); //pin 2 para sensor de contacto izquierdo
pinMode(3, INPUT); //pin 3 para sensor de contacto derecho

//Motores apagados al iniciar

alto();
delay(250);
}

//Ciclo principal
void loop()
{
do//Ciclo principal para la búsqueda "do... while"
{
//Lectura del sensor de proximidad ultrasónico
distancia = Ultrasonic.Ranging(CM); //El valor del sensor de proximidad ultrasónico se
guarda en "distancia"

//Calculo de la velocidad del robot con la variable "acelerador"

//Entre más lejos este el objetivo mayor será la velocidad y viceversa
acelerador = 100 + distancia; //La velocidad depende del valor obtenido por el sensor de
proximidad ultrasónico

//Lectura digital de sensores de proximidad y asignación a variables

proxizq = digitalRead(4);
proxcen = digitalRead(5);
proxder = digitalRead(6);
//Lectura digital de sensores de contacto y asignación a variables
contactoizq = digitalRead(2);
contactoder = digitalRead(3);

if(contactoizq == HIGH && contactoder == HIGH) //Condición principal del programa para
avanzar

89 89
 Arduino / Hummingbird

{
avanza();
delay(250);
}
else
{
if(contactoizq == LOW) //Caso con obstáculo a la izquierda
{
casa(); //Sub-función para preguntar si el robot encontró la caja
delay(500);
retrocede();
delay(500);
derecha();
delay(500);
}
else
{
if(contactoder == LOW) //Caso con obstáculo a la derecha
{
casa(); //Sub-función para preguntar si el robot encontró la caja
delay(500);
retrocede();
delay(500);
izquierda();
delay(500);
}
else
{
if(contactoizq == LOW && contactoder == LOW) //Caso con obstáculo frontal
{
casa(); //Sub-función para preguntar si el robot encontró la caja
delay(500);
retrocede();
delay(500);
derecha();
delay(500);
}
}
}
}
}while(acelerador > 0); //Sólo se realiza el ciclo de búsqueda hasta encontrar la caja
alto();
delay(500);
}

90 90
 Capitulo 3

//Sub-función para buscar casa

void casa()
{
if(proxizq == LOW || proxcen == LOW || proxder == LOW) //Condición para encontrar caja
{
acelerador = 0; //Si el robot llego a casa se detiene por completo
alto();
delay(500);

}
}
//Sub-función robot en alto
void alto()
{
analogWrite(motordervel, 0);
analogWrite(motorizqvel, 0);
}
//Sub-función robot gira a la derecha
void derecha()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot gira a la izquierda
void izquierda()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, LOW);
}
//Sub-función robot avanza
void avanza ()
{
analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, HIGH);
digitalWrite(motorizqdir, HIGH);
}
//Sub-función robot retrocede
void retrocede ()
{

91 91
 Arduino / Hummingbird

analogWrite(motordervel, acelerador);
analogWrite(motorizqvel, acelerador);
digitalWrite(motorderdir, LOW);
digitalWrite(motorizqdir, LOW);
}
/* --------------------Fin de código-------------------- */

Una vez transcrito el programa, continúe con los siguientes pasos:

Guardar: Evite perder su información, ponga algún nombre fácil de recordar, ej:
“regresando”.

Compilar: Corrija los errores, al hacer clic en el botón de compilar del programa de Arduino,
el cual buscará si existe algún error de sintaxis en el código antes de grabarlo en el robot
Andromie MP.

Cargar: Escriba la información al robot Andromie MP, si no hay errores en el código se graba
en la memoria interna de la tarjeta Arduino Uno.

Desconectar: Antes de usar el robot retire el cable USB de la computadora y del mismo, no
olvide que el robot tiene un compartimiento para baterías las cuales proporcionan energía
necesaria para su funcionamiento, no desconectar el cable puede dañar tanto al robot como
a la computadora.

Ejecutar: Coloque las baterías al robot, encienda, observe, tome nota y disfrute su programa
con el robot Andromie MP.

Le recomendamos observe el comportamiento del robot y vaya comparando con el

programa fuente, trate de relacionar cada instrucción escrita en el código con lo que está
viendo.

¿Qué fue lo que pasó?

En el encabezado del código se declaran las variables generales, controlador de motores,

sensores de proximidad y sensores de contacto.

Lo siguiente es la declaración de la librería “Ultrasonic.h” y su configuración de parámetros.

Aquí se destaca la variable global “acelerador” que no se relaciona a ningún valor dejándola
abierta para poder modificarla dentro del ciclo principal. También se declaran las sub-
funciones de movimiento para ser usadas en “void loop()”.

En “void setup()” se configuran los pins de la tarjeta Arduino Uno para que actúen como
entradas o salidas digitales, además se incluye la función “alto” como estado inicial del
robot Andromie MP.

92 92
 Capitulo 3

Más adelante en “void setup()”, se determina el flujo de información para los diferentes
estados de comportamiento del robot Andromie MP, se hace una pausa para definir
conceptualmente la actividad del robot, retomando la analogía de una persona cansada, el
robot Andromie MP debe ahorrar energía, para lograr este cometido se regulará la
velocidad para desplazamiento entendiendo a los motores como consumidores primarios
de energía lo cual significa que es el único dispositivo al cual se le debe limitar el consumo
de energía, en otras palabra no hay otro elemento electrónico para ajustar su nivel de
energía. Por lo tanto, el robot Andromie MP, hará las actividades siguientes:

1.- Buscará la caja contenedora.

2.- Moderará su velocidad.
3.- Evadirá obstáculos en el camino.
4.- Localizada la caja, detendrá la marcha y finalizará la tarea.

Para la búsqueda, usted aprenderá una nueva estructura de control “do … while”, se trata
de un subciclo condicionado de operación, en principio es similar a “void loop()”, porque se
repite varias veces, sin embargo lo hace hasta el incumplimiento de su condición, su sintaxis
se escribe:

do
{

Sentencia;
Actualizar_condición;

} while (condición)

Esta estructura en el código ejemplo contiene todas las rutinas, implica si la condición del
subcliclo “do … while” deja de cumplirse se finaliza por completo la búsqueda, hasta
reiniciar el ciclo “void loop()”. Su condición depende de la variable “acelerador” el cual se
actualiza al interior del subciclo “do … while”.

Al moderar la velocidad el robot Andromie MP consume menos energía, imagine las

baterías a carga máxima y al robot trabajando con la salida analógica a 5 V, es decir, 255
valores decimales de salida, y resulta tener una duración total de una hora, aquí la batería
se agotó por completo. Piense si reducimos la salida analógica a la mitad 2.5 V, igual a 127
valores decimales de salida, por regla de tres se obtiene una duración de 2 horas.
Justamente es la razón de la propuesta de este ejercicio alargar el tiempo funcional del
robot Andromie MP aprovechando correctamente sus recursos.

Para lograrlo, se usa el sensor de proximidad ultrasónico, ¿por qué?, si hay un obstáculo
frente al robot no debe avanzar a la máxima potencia pues chocaría y toda la energía usada
se desperdiciaría. Lo correcto es aminorar la marcha, dando tiempo a los sensores de

93 93
 Arduino / Hummingbird

contacto para evadir el objeto. ¿Cómo se hace? Actualizando la variable “acelerador” de

manera dinámica, es decir, con una fórmula:

acelerador = 100 + distancia;

Se toma de base una velocidad baja con el valor 100 únicamente adicionando el valor de la
variable “distancia”, y al final solo se asigna a la variable “acelerador”, recuerde que es solo
un ejemplo, usted puede trabajar con su propias formulaciones. Casi de manera autónoma
el robot Andromie MP, decide la velocidad proporcionalmente, en otras palabras a mayor
distancia mayor velocidad, y viceversa, a menor distancia menor velocidad.

La estructura “if … else”, se aplica para controlar el flujo de información y enmarcar todos
los casos eventuales al topar con algún objeto. Con esta toma de decisiones se cumple el
tercer aspecto de las actividades a realizar por el robot Andromie MP.

Se destaca que dentro de la estructura “if” existe una nueva sub-función llamada “casa()”
usada para distinguir la caja contenedora del robot, esta sub-función se creó para no realizar
una lectura en cada caso de los sensores de proximidad (encomendados a la tarea de buscar
la caja). Sus sentencias son:

void casa()
{
if(proxizq == LOW || proxcen == LOW || proxder == LOW) //Condición para encontrar caja
{
acelerador = 0; //Si el robot llego a casa se detiene por completo
alto();
delay(500);

}
}

La lectura de sensores se hace solo al principio del subciclo “do … while”. Dando a entender
que el robot debe llegar y detectar la caja con los sensores de contacto, al llamar a la sub-
función “casa()”, es como preguntar ¿realmente es mi casa? Si la respuesta es verdadera,
cualquier sensor de proximidad cumple la condición, detiene el avance, caso contrario
continúa la búsqueda. Abarcando así la cuarta actividad, reconocer la caja y finalizar la
tarea.

¡Felicitaciones! Su ardua labor ha llegado a su fin, su robot Andromie MP encontró su casa.

Estimado lector, le agradecemos su atención prestada a esta sección “Robótica con
Arduino”, pero su recorrido por la ciencia y tecnología aún no finaliza, por favor, lo
invitamos a continuar con la sección titulada “La ciencia al alcance de todos”, esperamos la
disfrute.

94 94
CAPÍTULO 4

95 95
 Arduino / Hummingbird

LA CIENCIA AL ALCANCE DE TODOS.

Vol. III

HUMMINGBIRD ROBOTICS KIT

96 96
 Capitulo 4

Programando en “Snap!”

“Snap!” es un ambiente de programación de arrastrar y soltar, desarrollado por Jens

Möning y Brian Harvey. “Snap!” es un descendiente de “Scratch” y agrega un número de
características tales como creación de bloques personalizados, recursividad y ejecución en
un navegador.

Mediante la utilización del programa “BirdBrain Robot Server”, se permite que el módulo
“Hummingbird” sea controlado desde el interior de “Snap!”. Este capítulo describe la
instalación de la utilidad, la apertura de “Snap!” y la programación del módulo
“Hummingbird” en “Snap!”.

Instalación en Windows.

Descargar el instalador para Windows desde el siguiente enlace

http://www.hummingbirdkit.com/learning/snap-programming y guardarlo de preferencia
en el escritorio, dar doble clic en el ícono del “BirdBrainRobotServerInstaller.msi”. Seguir las
instrucciones del instalador, una vez completada la instalación, un acceso directo del
“BirdBrain Robot Server” aparecerá en tu escritorio.

Ejecutando “Snap!”

Conecta un módulo “Hummingbird” con un cable USB a la computadora, a continuación

ejecuta la aplicación “BirdBrain Robot Server”, aparecerá la ventana de la figura 4.1:

Figura 4.1. Ventana de verificación para “Hummingbird”.

Esta ventana verificará si tienes un módulo “Hummingbird” conectado y suministra una

manera conveniente de ejecutar el sitio web de “Snap!”. Una vez que tienes el módulo
“Hummingbird” conectado, dar clic en “Open Snap!”. Esta acción ejecutará tu navegador
predeterminado en la computadora con el sitio web de “Snap!”. Para una mejor experiencia
usando “Snap!” configura Chrome como navegador predeterminado.

97 97
 Arduino / Hummingbird

NOTA: La caja de verificación para “Open Snap! locally” permite ejecutar “Snap!” si no hay
una conexión de internet activa. La aplicación comprueba al iniciar si hay una conexión con
el sitio web de “Snap!” y automáticamente se marca si no encuentra alguna conexión.

Programando un módulo “Hummingbird” en “Snap!”

Nos enfocaremos en explicar cómo usar el módulo “Hummingbird” que hemos añadido a
“Snap!”.

Los módulos “Hummingbird” están distribuidos entre las categorías de “Motion”, “Looks” y
“Sensing” de “Snap!”.

“Motion” (Comandos de movimiento).

 Hummingbird Servo: Ajuste de servos de 1 hasta 4 con valores desde 0 hasta 180
grados.
 Hummingbird Motor: Ajuste de motores de 1 hasta 2 con valores desde -100 hasta
100.
 Hummingbird Vibration: Ajuste de motores de vibración de 1 hasta 2 con valores
de intensidad desde 0 hasta 100.

“Looks” (Comandos de visualización).

 Hummingbird LED: Ajusta la intensidad de la luz en un solo LED de color en los

puertos 1 a 4. La intensidad varía de 0 a 100.
 Hummingbird TRI-LED R G B: Establece el color del LED en el Puerto 1 o 2. Los
argumentos R, G y B controlan la intensidad de los elementos de color rojo, verde y
azul en el LED de tres colores. El rango es de 0 hasta 100 para cada color.

“Sensing” (Comandos de detección).

Todos los comandos de detección permiten al usuario especificar un número que

corresponde al puerto en donde está el sensor. Por ejemplo, un sensor de distancia en el
puerto 3 podría ser leído por el comando HB Distance CM 3 o por HB Distance Inch 3.

 Hummingbird Light: Devuelve el valor de un sensor de luz, el rango es de 0 a 100.

 HB Temperatute C: Devuelve el valor en grados Celcius de una onda de
temperatura.
 HB Temperaturta F: Devuelve el valor en grados Fahrenheit de una onda de
temperatura.
 HB Distance CM: Devuelve la distancia a un objeto desde un sensor de distancia en
centímetros. El rango es de 8 a 60 cm con el sensor de alcance del kit (un valor
superior a 60 cm debe ser considerado como no ver un objeto).

98 98
 Capitulo 4

 HB Distance Inch: Devuelve la distancia a un objeto desde un sensor de distancia en

pulgadas. El rango es de 3 a 24 pulgadas con el sensor de alcance del kit (un valor
mayor que 24 pulgadas debe considerarse como no ver un objeto).
 Hummingbird Sound: Devuelve el valor de un sensor de sonido, el rango es de 0 a
100.
 Hummingbird Raw Sensor: Devuelve el valor del potenciómetro en el puerto; el
rango es de 0 a 100 y corresponde al voltaje de corriente directa en el puerto. Un
voltaje de 5 V es equivalente a una lectura de 100 y un voltaje de 0 V es equivalente
a una lectura de 0.

El bloque “Say This” (Decir esto).

Hemos agregado un bloque más a las librerías de bloques del “Hummingbird”. Ésta es
llamada “Say This” y hará que la computadora pronuncie el texto que se coloque en el
espacio de la caja de texto. Está en la categoría “Snap! Sound”.

Guardando y cargando un Proyecto.

“Snap!” prevé tres diferentes maneras para guardar un proyecto; depende de usted cuál
usar, son:

 Guardar un proyecto en la nube. Esta opción permite fácilmente guardar y cargar

proyectos en diferentes computadoras, pero requiere una conexión de internet así
como una cuenta (la cual puede ser hecha dando clic en el botón “cloud” arriba a la
izquierda). Actualmente los proyectos de un usuario no se pueden compartir con los
demás usuarios, aunque esto puede cambiar en el futuro.
 Guardar un proyecto en el navegador. Esta opción guarda el proyecto en la
memoria caché del navegador, esto sólo es accesible si el mismo usuario abre el
mismo navegador en la misma computadora. Igual de importante, si la memoria
caché es limpiada el proyecto desaparece.
 Exportar proyecto. Esta opción abre una nueva ventana del navegador que contiene
un archivo *.xml almacenando los datos del proyecto, debes entonces usar la opción
guardar página (Save Page) del navegador, para guardar el archivo con una
extensión *.xml, esta es una buena manera de distribuir archivos de ejemplos a
muchas personas, haz esto hasta que la nube permita compartirlos en un futuro.

Para acceder al menú de archivo y guardar, da clic en el botón archivo en la esquina superior
izquierda. Si tú elijes “Save” o “Save as” abrirás una ventana desde la cual puedes elegir
entre guardar el archivo localmente o en la nube. Para crear un archivo *.xml en su lugar,
haga clic “Export Project”. Para cargar un proyecto desde la memoria caché del navegador
o desde la nube, da clic en “Open”. Para abrir un proyecto desde un archivo *.xml, da clic
en “Import” y navegar a la ubicación de tu archivo *.xml.

99 99
 Arduino / Hummingbird

CAPÍTULO 5

100 100
 Capitulo 5

“Hummingbird”

El kit de robótica “Hummingbird” es un proyecto de investigación de 6 años creado por el

laboratorio de “Carnegie Mellon”. Ha sido resultado de la búsqueda en la creación de planes
de estudio y tecnologías que integren las artes con las ciencias y la ingeniería.

Actividad 1: Simulación de terremoto (Geografía).

Figura 5.1. Simulador de terremotos.

Te has preguntado alguna vez, ¿Cómo es que un terremoto se manifiesta en una ciudad o
pueblo? ¿Qué tipo de efectos tiene sobre los edificios o casas? Simularemos un terremoto
en una pequeña ciudad (ver figura 5.1), para hacerlo debemos contar con el siguiente
material.

 Un pedazo de cartón plano y liso.

 Tijeras.
 Desarmador amarillo “Hummingbird”
 Silicón y cinta adhesiva.
 Palos de paleta reciclados.
 Un pedazo de estambre o cuerda delgada.
 Cajas pequeñas (recicladas).
 2 clips de metal
 Tarjeta electrónica “Hummingbird”
 2 motores “Hummingbird”
 2 servos “Hummingbird”

101 101
 Arduino / Hummingbird

Procedimientos:

Al pedazo de cartón se le hacen 6

orificios, uno en cada esquina y 2 a la
mitad de los costados largos con la
finalidad de pegar un trozo de estambre
de 30 cm de largo en cada orificio. Se
colocan 6 palos de paleta alrededor del
trozo de cartón de 2 a 4 cm de distancia,
se los pega a la mesa con silicón de una
de sus puntas. Se hace pasar cada uno de
los 6 pedazos de estambre sobre la parte
superior del palo de paleta que le
corresponde y después se pega cada
punta a la mesa con silicón, esto con la
finalidad de suspender el trozo de cartón
sobre la mesa de trabajo, observe la
imagen de la derecha.

Coloque las cajas recicladas sobre la

superficie y péguelas al cartón con un pedazo
de cinta adhesiva, distribúyalas sobre la
superficie flotante a su gusto, se recomienda
que las cajas sean lo más alto posible para
que aprecie de mejor manera el efecto que
tiene el movimiento en cada una de las cajas.
Ver imagen de la izquierda.

Después arme los dos servomotores con

un tornillo que viene en su caja dentro de
una bolsa de plástico y dos remaches de
latón, introduzca el tornillo sobre los
remaches que estarán encontrados y
colóquelo sobre el volante de color
blanco, observe la imagen de la derecha,
después pegue el servomotor a la mesa,
fíjelo con silicón para que no se mueva,
debe quedar el tornillo muy cerca del
cartón pero no pegado, esto para que el
cartón al moverse no se atore y oscile
libremente.

102 102
 Capitulo 5

A continuación arme los 2 motores eléctricos

con un clip sobre el eje que gira, puede
pegarlo con unas gotas de silicón para
mantenerlos fijos, después pegue de forma
inclinada cada motor colocando el clip debajo
del cartón que ya está suspendido, fije el
motor a la mesa con silicón para que no se
mueva, observe la imagen de la izquierda.
Debe conectar cada uno de los elementos
a la tarjeta “Hummingbird”, adaptador de
corriente, cable USB, servomotores y
motores eléctricos, para los servos hay
que cuidar la polaridad, recuerde que
debe colocar el adaptador cuidando que
el cable negro quede en el pin marcado
como negativo y el cable amarillo sobe el
pin marcado con la letra S y para los
motores no hay problema cómo se
conecten los cables.

Desarrollo del código para el programa:

Una vez conectada la tarjeta “Hummingbird” a la computadora, se abre el entorno “Snap!”,

para el desarrollo del programa serán utilizados los siguientes bloques.

 1 bloque “Al presionar tecla ‘espacio’”.

 1 bloque “repetir ‘x valor’”.
 6 bloques “Hummingbird Servo”.
 4 bloques “Hummingbird Motor”.
 2 bloques “esperar ‘x’ segs”.
 1 bloque “Say This ‘ ‘”.

En la figura 5.2, se muestran las conexiones entre cada uno de los bloques para el desarrollo
de la práctica.

103 103
 Arduino / Hummingbird

Figura 5.2. Código fuente de la Actividad 1.

Si las conexiones de los bloques han sido correctas, al presionar la tecla espaciadora de tu
computadora, el sistema hará una repetición de 10 momentos iguales, haciendo que los
servomotores se muevan de 0 grados a 180 grados consiguiendo que el tornillo colocado
en el volante, empuje por uno de los costados del cartón flotante, al terminar el recorrido
espera 1 segundo y regresa a su posición original, es decir se le indica que vaya de 180
grados a 0 grados y espere un segundo, el siguiente par de instrucciones indican que los
motores eléctricos deben comenzar a girar con el valor máximo de 100 que equivale a la
velocidad máxima a la que pueden hacerlo, ya que se acomodaron con la finalidad de
empujar el cartón hacia arriba, lo llevan a cabo con ayuda del clip acoplado en su eje. La
siguiente instrucción envía un mensaje sonoro que dice “Earthquake”. Al finalizar los 10
ciclos, las cuatro instrucciones regresan los motores a sus condiciones iniciales, en el caso
de los servomotores se regresan a cero grados de posición y para los motores eléctricos se
detienen.

104 104
 Capitulo 5

Principios de ciencia: Terremotos y sus tipos.

Conocidos también como Sismos, es un fenómeno de sacudida intensa y momentánea de

la corteza terrestre producida por la liberación de energía acumulada en forma de ondas
sísmicas, se han identificado placas de la corteza terrestre que están en constante
movimiento y se encuentran unas con otras en su constante y cambiante transitar, también
se han identificado temblores por la ruptura de fallas geológicas y hasta por erupciones
volcánicas, hasta la mano del hombre lo ha conseguido con la explosión de bombas
colocadas en el subsuelo que tienen tal poder que logran producir terremotos (ver figura
5.3).

Al punto de origen de un terremoto se le llama hipocentro y al punto sobre la superficie

que está sobre el hipocentro se le llama epicentro, se han desarrollado varias escalas para
medir su intensidad, una de ellas es la escala de Richter.

Figura 5.3. Imagen de las consecuencias de terremoto en la ciudad de México en 1985.

105 105
 Arduino / Hummingbird

Actividad 2. Ahorro de energía (ecología).

¿Ha escuchado de sacarle jugo al sol? No, bueno no sería de extrañar, estas palabras se
refieren a obtener el máximo provecho de la energía proveniente del sol, tal vez haya oído
hablar sobre celdas solares, sistemas ahorradores de electricidad o fuentes alternativas de
energía, son algunos esfuerzos por beneficiarnos del sol. Ha inspirado a personas para crear
equipos capaces de controlar la iluminación de un edificio con el fin de minimizar el
consumo eléctrico, todo con ayuda del sol.

Usted diseñará un sistema ahorrador de energía eléctrico, se hará paso a paso, por favor,
busque los materiales enlistados a continuación:

 Una caja de cartón grande y trozo de cartón (reciclado)

 Tijeras (punta redonda)
 Desarmador amarillo “Hummingbird”
 Silicón y cinta adhesiva
 Tarjeta electrónica “Hummingbird”
 4 LEDs sencillos (el color de su agrado) “Hummingbird”
 1 sensor de luz “Hummingbird”
 1 sensor rotatorio “Hummingbird”

Procedimiento:

Se trata de hacer la maqueta de una casa,

dependiendo del tipo de caja será el estilo
del diseño. Se inicia tomando la caja, con
ayuda de las tijeras se harán una serie de
ventanas y puertas para tener acceso a la
casa, muy particularmente se tiene que
hacer un compartimiento en la parte
superior para la colocación de LEDs, con el
trozo de cartón hacer las divisiones de los
cuartos. Ver imágenes.

106 106
 Capitulo 5

Pegue las divisiones al interior de la caja

con silicón. Debe resultar algo similar a la
estructura de la imagen de la derecha, en la
parte del fondo de su maqueta haga un
hoyo discreto pero suficientemente amplio
para hacer pasar el cable de los LEDs,
sensores de luz y rotatorio.

Fije cada LED en la pestaña superior con

ayuda de cinta adhesiva, uno por cada
cuarto, posteriormente ubique el sensor de
luz lo más expuesto en la superficie de la
caja. Como referencia vea la imagen
izquierda superior. Instale el sensor
rotatorio por fuera de la maqueta para
tener acceso, adhiéralo con cinta,
finalmente sitúe un LED en el exterior.

Conecte todo a la tarjeta “Hummingbird”,

los LEDs van en los bornes de 1 a 4, los
cables se enchufan negro en (-) y cable de
color (+), solo el LED externo debe ir en el
borne 4. El sensor de luz y sensor rotario se
acoplan en los bornes 1 y 2
respectivamente, el cable rojo en (+), negro
en (-) y amarillo (S). Como se ve en las
imágenes, la tarjeta puede estar atrás de la
maqueta.

107 107
 Arduino / Hummingbird

Desarrollo del código del programa:

Una vez realizada las conexiones con la tarjeta Hummingbird, se procede a conectar a la
computadora, se abre el entorno Snap, los bloques utilizados serán los siguientes:

 1 bloque “Al presionar”

 1 bloque “por siempre”
 7 bloques “Hummingbird LED”
 4 bloques “si”
 9 bloques “Hummingbird Ligth”
 3 bloques “Hummingbird Raw Sensor”
 4 bloques mayor que “>”
 4 bloques menor que “<”
 1 bloque igual “=”
 4 bloques operador “y”
 1 bloque operador “o”

La integración de los bloques aparece en la figura 5.4, es una cascada simple de

instrucciones, relacionadas unas dentro de otras, por favor solo busque cada bloque y
agrúpelos como se muestra.

La lógica es la siguiente, al hacer clic en la bandera de inicio, se realiza la lectura del sensor
de luz para poder seleccionar una acción de cuatro casos o eventos totales. Recuerde que
tratamos de ahorrar energía, por lo tanto los casos referidos son la cantidad de luz
despedida por el LED en el borne 4, si hay luz de sol no es necesario encender el LED, y
conforme anochece el LED incrementa su intensidad, minimizando la pérdida de
electricidad, muy semejante a los faros en vías públicas. Cada evento compara los niveles
del sensor de luz dentro de los rangos preestablecidos de operación, esto se logra
combinando los bloques “si”, “<”, “>”, “=”, “y” y “o”.

Para ahorrar electricidad en el interior de la casa, se aplica el sensor rotatorio en función de

control de iluminación, al girar la perilla del sensor éste varía su valor en una escala de 0 a
100 unidades, se relaciona directo con la cantidad de intensidad de los LEDs, provocando
108 108
 Capitulo 5

un cambio proporcional al valor del sensor rotatorio. Este tipo de sistemas es muy común
en las casas con principios de domótica. Toda esta actividad se realiza al instante, por éso
se anida todo en un bloque “por siempre”, para repetirse infinitamente.

Así de simple es sacar el mayor beneficio a nuestro gran amigo el sol y con ello minimizar el
impacto al medio ambiente por la generación de electricidad.

Figura 5.4. Bloques del programa ahorrador de energía.

Principios de ciencia: Aprovechamiento de los recursos energéticos.

El frenesí de la sociedad actual ha acarreado serios problemas al medio ambiente, en

particular la demanda energética ha puesto en jaque a la industria, comercio y vivienda,
pues casi todas las comodidades tecnológicas requieren electricidad, su demanda cada vez
es mayor, en ocasiones orillando a países desarrollados a importar recursos energéticos, sin
mencionar, la descarga de contaminantes a la atmósfera para su obtención.

Por esta razón, se han tomado acciones directas para tratar de optimizar el uso de los
recursos energéticos, desde la búsqueda de nuevas fuentes de energía renovable libre de

109 109
 Arduino / Hummingbird

contaminantes hasta concientizar a la sociedad para cambiar sus hábitos de consumo. Una
sociedad más conciente es la base para un cambio global, surgiendo la pregunta ¿Por qué
es importante ahorrar energía? Si la gente gasta menos energía, disminuye la presión de
aumentar el suministro de construir centrales de energía nuevas, o de importar energía. Por
consiguiente, ¿Cómo podemos ahorrar energía? Son varias las formas, a continuación se
enlistan algunas:

- Apagar los equipos eléctricos cuando no estén en uso.

- Limpiar con frecuencia los filtros del aire acondicionado.
- Aprovechar la energía solar.
- No permitir el desperdicio de energía.
- Apagar luces cuando no sean necesarias.
- Emplear tecnología con ahorro de energía.
- Evitar el uso de micro-ondas.

La actividad 2 es un ejemplo del aprovechamiento de la energía solar para la iluminación

exterior, la energía era inversamente proporcional a la producida por el sol, en otras
palabras si había mucha luz el LED estaba apagado, si no había luz el LED encendía al
máximo. En el interior de la casa se fabricó un control de iluminación regulada, el cual era
proporcional a sus necesidades de luz, si no requería mucha iluminación baja la intensidad,
caso contrario la elevaba, minimizando el consumo eléctrico.

Recuerde, cada recomendación no es excluyente y pueden ser combinadas y de esta forma

ayudar más a la conservación de nuestro medio ambiente. Un ejemplo es el sistema descrito
en la actividad 2 que puede adaptar con lámpara LED, tecnología ahorradora de electricidad
como la figura 5.5. Si tiene persianas o cortinas en ventanas recórralas, así sacará más jugo
al sol.

Figura 5.5. Lámpara LED de uso comercial.

110 110
 Capitulo 5

Actividad 3. Termómetro (Química).

En esta actividad realizaremos un termómetro simple de 3 escalas luminosas, el

termómetro nos devolverá un valor en escala “Frío” para temperaturas menores a 15 °C,
temperaturas entre los 15 y 30 °C nos devolverá una lectura con un valor en escala “Tibio”,
temperaturas mayores a 30 °C y con valores menores a 50 °C devolverá un valor en la escala
de “Caliente”.

Material a utilizar:

 1 caja de cartón chica (blanca de preferencia)

 Tarjeta electrónica “Hummingbird”
 1 sensor de temperatura “Hummingbird”
 2 LEDs sencillos (1 rojo, 1 naranja) “Hummingbird”
 1 LED multicolor “Hummingbird”
 Entorno Snap!
 Silicón
 Tijeras (de punta redonda)

Procedimiento:

Utilizar la caja y empleando las tijeras abrir

con mucho cuidado una de sus caras
laterales, tal como se muestra en la figura
de la derecha, también deberás realizar 3
perforaciones del lado contrario a la cual
realizaste el corte, por cada una de las
perforaciones se colocará un LED.

Coloca los LEDs dentro de la caja sobre cada

una de las perforaciones realizadas a la
misma, utiliza silicón para fijar los LEDs en
cada una de las perforaciones, el orden de
los LEDs es importante, en el lugar con la
leyenda “Frío” quedará el LED multicolor, el
LED naranja en el lugar de leyenda “Tibio” y
el LED rojo en el lugar con la leyenda
“Caliente”

111 111
 Arduino / Hummingbird

Conecta los LEDs en el orden

correspondiente a la imagen de la derecha,
recuerda conectar el cable en color negro
con el signo menos (-), también coloca el
sensor de temperatura del KIT
Hummingbird procurando conectar cable
color rojo en el borne con signo más (+),
cable negro con borne con signo menos (-)
y cable amarillo con borne con letra (s).

Desarrollo del código del programa:

Una vez realizada las conexiones con la tarjeta Hummingbird, se procede a conectar la
tarjeta a la computadora, se abre el entorno Snap, los bloques utilizados serán los
siguientes:

 1 bloque “Al presionar tecla –espacio-”

 1 bloque “por siempre”
 6 bloques “Hummingbird LED”
 3 bloques “Hummingbird TRI-LED”
 3 bloques “si”
 6 bloques “HB Temperature C”
 3 bloques mayor que “>”
 3 bloques menor que “<”
 3 bloques operador “y”

En la figura 5.6, se muestra el código fuente empleado y las conexiones de cada uno de los
bloques

Si se observa con detenimiento se utilizan operadores de comparación mayor que “>”,

menor que “<” los cuales son utilizados para filtrar cada una de las escalas establecidas en
el termómetro, estas escalas pueden variar si se colocaran más LEDs en la tarjeta, entonces
tendríamos un termómetro que se podría configurar al gusto del usuario.

112 112
 Capitulo 5

Figura 5.6. Código fuente para el programa “Termómetro”

Principios de ciencia: Escalas de Temperatura.

En 1724 Gabriel Farenheit construyó el primer termómetro de mercurio que indicaba la

temperatura en grados, el cual lo calibró de la siguiente forma:

- El punto de congelación, una solución de hielo o nieve y sal (el cual era el punto de
congelación más bajo que se podía obtener en esa época).
- Un punto correspondiente a la temperatura del ser humano

Ferenheit dividió en 96 partes iguales la distancia entre éstas 2 escalas obtenidas, ajustó la
medición para que la escala de congelación del agua fuera 32 °F y la temperatura de
ebullición del agua fuera de 212 °F.

En 1740 el científico Anders Celcius desarrolló una escala llamada centígrada debido a que
esta escala estaba dividida en 100 partes iguales, el punto de fusión del hielo le fue asignado
0 y 100 al punto de ebullición del agua. En 1948 el término grado centígrado fue
reemplazado por grado Celcius, también fue la escala utilizada en el Sistema Métrico
Decimal.

113 113
 Arduino / Hummingbird

Pese a ser bien conocida la escala, en la cual se asigna el valor más bajo como de 0 °C, y 100
°C a la temperatura de ebullición del agua, inicialmente Ander Celcius no la propuso así, él
tomó 0° para asignar el punto de ebullición del agua y 100° para el congelamiento del agua,
fue en 1745, un año después de la muerte de Celcius fue que el explorador y botánico Carlos
Linneo cambió la escala al revés, asignando 0° al punto de congelación del hielo y 100° al
punto de ebullición del agua, lo cual resultó que fuese mucho más práctica (ver figura5.7).

En 1848 el científico William Thomson Kelvin, buscó establecer un punto de temperatura

mínima, la cual estableció a través de cálculos realizados por él y determinó que la
temperatura más baja es de -273.15 °C, Kelvin definía éste número como cero absoluto o 0
K, es la temperatura más baja posible, en 0 K no hay movimiento molecular en los objetos.
Por razones prácticas Kelvin conservó el tamaño de las divisiones de la escala Celcius, la
escala kelvin es llamada temperatura absoluta y a diferencia de la escala Farenheit o Celcius,
las temperaturas en esta escala son designadas como Kelvin y no utilizan la palabra grados.

Figura 5.7. Termómetro ambiental con escalas Farenheit y Celcius.

114 114
 Anexo

ANEXO A

Instalación de Controladores

Instalación de controladores para el Arduino UNO en computadoras con sistemas Windows

7, Vista o XP.

- Conecte la placa a la computadora y espere que empiece el proceso de instalación

del controlador. (Si Windows no reconoce el controlador inmediatamente será
necesario instalarlo manualmente).
- De clic en el menú Inicio, Panel de Control, Sistema y seguridad, Sistema. Una vez
que se abrió la ventana de Sistema, abra el Administrador de dispositivos.
- En la sección llamada Puertos (COM y LPT). Abra el menú desplegable y se deberá
observar “Arduino UNO (COMxx)”. Si no existiera la sección de COM y LPT, abra la
sección de “Otros dispositivos” para “Dispositivos desconocidos”.
- De clic con el botón derecho del mouse en “Arduino UNO (COMxx)” y escoja la
opción “Actualizar software del controlador”.
- Siguiente, elija la opción “Buscar software del controlador en el equipo”.
- Finalmente, en el botón examinar busque la carpeta de instalación del entorno de
programación de Arduino, si se mantuvieron los valores de instalación de fábrica la
dirección será la siguiente C:\Program Files (x86)\Arduino\drivers, seleccione el
archivo del controlador llamado “arduino.inf”
- Seleccione “Aceptar” para finalizar la instalación del controlador.

Instalación de controlador para el Arduino Nano en computadoras con sistemas Windows

7, Vista o XP.

- Cuando conecte la tarjeta, Windows inicializará el proceso de instalación (sino se ha

utilizado la tarjeta en la computadora con un Arduino anteriormente).

- En Windows Vista, el controlador se debería descargar e instalar automáticamente.

Si el equipo no reconoce el controlador automáticamente después de haber conectado la

tarjeta Arduino Nano deberá realizar el procedimiento manual de instalación del
controlador.

- Dé clic en el menú Inicio, Panel de Control, Sistema y seguridad, Sistema. Una vez
que se abrió la ventana de Sistema, abra el Administrador de dispositivos.
- En el menú de la ventana de Administrador de dispositivos, la tarjeta Arduino Nano
aparece en la sección desplegable “Otros dispositivos” como “FT232R USB UART”
- Dé clic con el botón derecho del mouse en la opción “FT232R USB UART” y escoja la
opción “Actualizar software del controlador”
- En la siguiente ventana elija la opción “Buscar software del controlador en el
equipo”.

115 115
 Arduino / Hummingbird

- Elija la opción “Elegir una lista de controladores de dispositivo en el equipo”

- En la ventana que dice “Seleccione el tipo de dispositivo en la siguiente lista se elige
la opción “Mostrar todos los dispositivos” y se da clic con el mouse en “siguiente”.
- Se da clic en la opción “utilizar disco” y en el menú “examinar”
- Se busca el directorio de instalación de Arduino y la carpeta FTDI USB Drivers
(C:\Program Files (x86)\Arduino\drivers\FTDI USB Drivers) y se selecciona el archivo
“ftdibus”
- Se da clic en aceptar y se desplegará una ventana, se BUSCA y ELIGE la opción final
de la lista que dice “USB Serial Converter” y se da clic en “siguiente”
- En la advertencia de instalación de controlador de dispositivo ¿Desea continuar con
la instalación de este controlador? Damos clic en la opción “Sí”
- Regresamos nuevamente a la ventana del Administrador de dispositivos, en la
opción “Otros dispositivos” damos clic con el botón derecho del mouse sobre la
opción “USB Serial Port” en “Actualizar software del controlador”.
- Elija la opción “Elegir una lista de controladores de dispositivo en el equipo”
- En la ventana que dice “Seleccione el tipo de dispositivo en la siguiente lista se elige
la opción “Mostrar todos los dispositivos” y se da clic con el mouse en “siguiente”.
- Se da clic en la opción “utilizar disco” y en el menú “examinar”
- Se buscar el directorio de instalación de Arduino y la carpeta FTDI USB Drivers
(C:\Program Files (x86)\Arduino\drivers\FTDI USB Drivers) y se selecciona el archivo
“ftdibus”
- Se da clic en aceptar y se desplegará una ventana, se BUSCA y ELIGE la opción que
se encuentra al final de la lista que dice “USB Serial Port” y se da clic en siguiente
- En la advertencia de instalación de controlador de dispositivo ¿Desea continuar con
la instalación de este controlador? Damos clic en la opción “Sí”
- Finalmente ha quedado instalado el controlador de la tarjeta Arduino Nano, en el
Administrador de dispositivos se muestra en el menú desplegable “Puertos (COM y
LPT)” “USB Serial Port (COMxx)”.

116 116