Módulo

Educativo de construcción de robots

para estudiantes

Gobernación de Arauca Secretaría de Educación

x
Departamental de Arauca
Autor: Ingeniero José Luis Susa Rincón

1
 Agradecimientos:
Agradezco al doctor Luis Eduardo Ataya Arias Gobernador de Arauca. Y al doctor José Orlando
Cespedes García Secretario de Educación Departamental por apoyar el programa “USO Y
APROVECHAMIENTO DE NUEVAS TECNOLOGÍAS EN ROBÓTICA Y RECICLAJE TECNOLÓGICO”.
Igualmente al director del proyecto José Félix Susa Lizarazo por sus valiosos consejos y por
compartir su gran experiencia conmigo, sin la cual no se hubiera logrado obtener los buenos
resultados del programa en general.
A todas las demás personas que de una u otra manera colaboraron con el desarrollo exitoso
del programa. Finalmente a la ingeniera Paola Fernanda Santos le agradezco por sus acertadas
opiniones y correcciones hechas a la cartilla. Gracias por poner un poquito de ella misma para
que todos apreciaran aún más este trabajo.

Gobernador de Arauca: Luis Eduardo Ataya Arias

Secretario de Educación de Arauca: Orlando Cespedes Garcia
Gerente de Nuevas Tecnologías: Roberto Antonio Melo Padilla
Autor: José Luis Susa Rincón
Contratista: Fundaset
Diseño Y Diagramación: Silvia Vargas
Ilustraciones: José Luis Susa Rincón
Revisión de Estilo: Ingeniera Paola Fernanda Santos
Director del proyecto: José Félix Susa Lizarazo

Módulo educativo de construcción de robots para estudiantes 2

Acerca de la Cartilla: 4
Introducción: 5
TALLER 1: QUÉ ES LA ROBÓTICA, PARA QUÉ SIRVE, Y QUÉ ES UN ROBOT? 6
TALLER 2: RECONOCIENDO LOS ELEMENTOS CON LOS QUE CONTAMOS 8
Experimento 1: Conectando elementos, Primer Circuito: 9

Experimento 2: Prendiendo un LED con un interruptor NA: 9

Experimento 3: Prendiendo un LED con un interruptor NC: 9

Experimento 4: Prendiendo un LED con un potenciómetro de 10k ohm: 10

TALLER 3: JUGUEMOS CON ARDUINO 12

APRENDIENDO A USAR LA TARJETA ARDUINO: 12

Experimento 5: Conectando la tarjeta Arduino al computador con ayuda del cable USB: 12

PROCEDIMIENTO DE INSTALACIÓN DE ARDUINO EN WINDOWS XP: 13

Experimento 6: En este experimento vamos a comenzar a utilizar

la tarjeta Arduino para encender un LED o un mini parlante: 14

Experimento 7: Presionando un pulsador se activan varias luces: 17

Experimento 8: Prender 4 LEDs con la ayuda de un potenciómetro de 10 K ohm: 18

TALLER 4: BIENVENIDOS AL MUNDO DE LA ROBÓTICA,

JUGUEMOS CON LOS SENTIDOS DE UN ROBOT. 19

Experimento 9: Sensor de luz, ¿cuál es su utilidad en robótica? 19

Experimento 10: Sensor de choque o fin de carrera, cuál es su utilidad en robótica? 20

Experimento 11: Sensor distancia, cuál es su utilidad en robótica? 21

Experimento 12: Sensor proximidad, cuál es su utilidad en robótica? 22

TALLER 5: BIENVENIDOS AL MUNDO DE LA ROBÓTICA,

JUGUEMOS CON LOS MOTORES DE UN ROBOT. 24

Experimento 13: Controlando 1 motor: 24

Experimento 14: Controlando 2 motores: 25

TALLER 6: A DIVERTIRNOS CONSTRUYENDO UN VERDADERO ROBOT! 27

Experimento 15: Construir un robot que se mantenga separa de un objeto: 27

Experimento 16: Construir un robot seguidor de muro: 29

Experimento 17: Construir un robot que avance cuando detecte luz: 30

3
 Acerca de la cartilla
Esta cartilla fue desarrollada por el ingeniero José Luis Susa Rincón, basado en su experiencia
obtenida durante el programa “USO Y APROVECHAMIENTO DE NUEVAS TECNOLOGÍAS EN
ROBÓTICA Y RECICLAJE TECNOLÓGICO”, el cual fue coordinado por él mismo y dirigido por
el doctor José Félix Susa Lizarazo.
En esta cartilla encontrarán la manera fácil y rápida de ingresar al mundo de la robótica,
contiene información útil para desarrollar una serie de experimentos divertidos e
interesantes sobre los robots y sus partes, igualmente será una guía didáctica para el
desarrollo del curso de robótica que podrán dirigir los docentes especializados en el tema
que participaron en el programa.
Los componentes conceptuales de la cartilla pueden ser divididos en 4 módulos de
aprendizaje:
1. Módulo de Electrónica digital
2. Módulo de Programación
3. Modulo Conociendo Arduino
4. Robótica
Cada módulo ira desarrollándose a medida que se realicen los juegos y los experimentos
x

que soportan toda esta cartilla y que han sido pensados y probados para alcanzar la meta
de que un niño entre los 13 y 17 años aprenda de robótica móvil fácilmente. Al final
los niños y jóvenes habrán aprendido como construir un robot, entendiendo y usando
todas sus partes, podrán luego diseñar por ellos mismos cualquier tipo de robot posible, o
cualquier aplicación o invento novedoso que en su mente creen usando los conocimientos
adquiridos y los materiales con lo que ya disponen. Es importante contar el apoyo de un
docente que haya participado en el programa, ya que es necesario hacer complementos
teóricos en algunos de los experimentos.
La cartilla está divida en talleres, y experimentos, cada taller consta de una teoría básica y
una serie de experimentos dirigidos y creados para aprender robótica. En la cartilla habrán
indicaciones como esta: donde deberá hacerse una complementación teórica del tema
tratado. Igualmente si el símbolo es el siguiente: se deberá complementar la teoría con
ayuda de exposiciones o ejercicios adicionales.
Finalmente tendremos en la cartilla una serie de experimentos a realizar para afianzar los
conocimientos en robótica. Se identificarán de la siguiente manera: cada experimento tendrá
un número para hacer más fácil su ejecución a la hora de trabajar en clase con los alumnos.
No queda más que decirles BIENVENIDOS al mundo de la robótica, serán participes de
la última tecnología en el mundo y más adelante con esfuerzo y estudio podrán liderar
proyectos que cambien el mundo y lo conviertan en un mejor lugar para vivir.

Módulo
Módulo educativo deEducativo de Construccion
construcción de robotsde Robots para estudiantes
para estudiantes 4
Introducción
Echemos una muy rápida mirada al pasado en el que utilizábamos piedras, ramas, pieles Pongámonos cómodos
y otros materiales para desarrollar pequeños y básicos utensilios para ayudarnos en
nuestras tareas diarias, se pueden imaginar viviendo en esa época?...cogiendo una piedra
y empecemos a aprender
para cortar, uniéndola a un palito para cazar y poder comer?...solo imaginen… y a jugar para luego poder
El mundo fue bueno y nosotros como humanos empezamos a mejorar nuestras primeras INVENTAR!
invenciones, poco a poco fuimos creando herramientas más complejas, con el vapor,
la pólvora, la mecánica y finalmente con la energía eléctrica, convertimos un palito y
una piedra en máquinas para volar, para nadar como los peces, hasta para ir al espacio!
igualmente creamos aparatos para entretenernos, el televisor, el cine, las cámaras, el Xbox,
el play station, etc. Finalmente inventamos el computador, el invento moderno que mueve
al mundo actual y que junto con nuestra mente nos ha llevado a sobrepasar los límites
humanos. ¿Se dan cuenta que siempre buscamos crear nuevas cosas, las inventamos y las
construimos para beneficiarnos y ayudarnos?, siempre desde que usábamos solo palitos y
piedras, ¿Se dan cuenta que desde ese tiempo deseamos lo mismo?
Nuestra imaginación se ha dejado llevar y la necesidad de crear más y mejores cosas para
realizar nuestros sueños ha sido tan alta que en nuestros días tenemos máquinas y aparatos
que en tiempos pasados parecían sacados de un cuento. La magia no es que no exista, sino
que aún no la hemos descubierto o inventado, todo es posible en este mundo, solo se necesita
paciencia, estudio, mucho tiempo para pensar y permitirnos inventar. La electricidad fue
magia en sus primeros días, nadie entendía cómo, ni por qué salía, y mucho menos alguien se
imaginó algo semejante antes, por eso es razonable pensar que hay cosas aún desconocidas
por nosotros, que tarde o temprano descubriremos, será esa magia que ahora nos parece
irreal, debemos prepararnos entonces podamos gozar de ella en el futuro y aprovecharla para
que todos estemos mejor con los demás y con el medio ambiente.
Alguna vez han pensado cómo participar activamente en esta corriente de invenciones?…
tomémonos un tiempo…
…
…
Si su respuesta es “No Se” tranquilos les diré cómo hacerlo, eso sí espero que nadie
haya dicho “No se puede”, porque esa respuesta elimina cualquier solución y bloquea
inmediatamente todo. Entonces creamos en que todo es posible y haremos maravillas. La
manera como ustedes comenzarán a inventar es con algo que llaman robots! Y aprendiendo
la ciencia que los estudia: La robótica.

5
 Taller 1: Qué es la robótica, para
qué sirve, y qué es un robot?

Para comenzar es importante preguntarnos: qué es la

robótica?. Su definición es la siguiente:
La robótica es la ciencia y la tecnología de los robots. Se
ocupa del diseño, manufactura y aplicaciones de estos.
Esto nos lleva a una nueva pregunta, qué es un robot?
Un robot es una entidad virtual o mecánica artificial,
que generalmente realiza alguna tarea.
Robots móviles
Ok, ya tenemos algo más claro, pero qué exactamente
hacemos con un robot? La respuesta es la misma que si
pensamos en lo que hacíamos con una palito y una piedra,
ayudarnos a hacer nuestras tareas diarias, facilitarnos la
vida y ayudarnos a investigar y a aprender nuevas cosas
(por ejemplo cuando son enviados al espacio).
Como pueden imaginarse hay muchos tipos de robots,
hay pequeños que se pueden desplazar llamados robots
móviles: Hay robots que tratan de parecerse a nosotros
llamados humanoides: y los robots que construyen carros
y trabajan en fábricas se llaman robots industriales:
Finalmente los últimos tipos de robots que podemos
encontrar no son tangibles, no son aparatos reales en este
mundo sino programas y simulaciones en computadores,
se denominan robots virtuales, en esta categoría podemos Humanoides
encontrar igual a los virus de computador, ya que en
la actualidad se han vuelto tan complejos que algunos
pueden llamarse robots virtuales.

Industriales

Módulo educativo de construcción de robots para estudiantes 6

 Pero bueno, todos estos robots, que tienen en común para que sean llamados a todos así?
Qué los compone y caracteriza?

SENSORES

PROCESADOR
ACTUADORES
O MICROCONTROLADOR

INTELIGENCIA
ARTIFICIAL

Cables
Todos los robots tienen todas oAdaptador
de Protoboard
Complemento Teórico:
9v de las partes mostradas enRegulador
la mayoría el gráfico de arriba.
de volte Animo
Son alambres que
vienen en
Este es el elemento
diferentesdeberá hacer unaque le proporcionará
Se conecta a una de
laselementos,
terminales del
que el camino
El profesor breve explicación de cada uno de estos ayudándose
colores y tamaños
con el ejemplo
para interconectar del cuerpo
energía a nuestro
humano,
robot. los sensores son sentidos,
adaptador de 9v,
los
reduceactuadores
su voltaje nuestros apenas comienza!
músculos,
los elementos a 5v para
en el la inteligencia artificial nuestra inteligencia, y nuestro que es nuestro
cerebro
protoboard. puedan
procesador que controla todo. Qué es un Sensor y qué tipos hay, Qué es un actuador y
funcionar
qué tipos hay?, y Qué es la inteligencia artificial? los motores.

Ejercicios aconsejados:
1. Por grupos hacer exposiciones cortas acerca de los diferentes tipos de robot, que
cada grupo elija un robot e identifique las partes que lo componen, mostrar videos
de ejemplo de cada uno y explicar cuál es su utilidad de ellos para las personas o
para el mundo.
2. Hacer
Leds una discusión sobreMini
losparlante
siguientes temas y reconocer Resistencias
la importancia de la
robótica y su aprendizaje:
• Qué es la robótica, qué es un
Son pequeños Esrobot,
un pequeño
para qué sirve? Son componentes
bombillos
• que
Quéemiten parlante,
robots simples podríamos imaginar electrónicos
emitepara resolver problemas en la vida quereal?, buscar
luces de diferentes sonidos y tiene reducen la cantidad
personas? Recolectar comida? Detectar intrusos? Qué elementos deberían
polaridad. de tener
corriente queestos
otrosrobots?
colores segun el led.
elementos
• Es importante la robótica para el mundo? Para la gente? Puede ayudar reciben
a mejorar nuestra vida?
en el circuito.
Luego de entender que es la robótica y que tipos de robots hay y para qué sirven ahora si
pasemos a la práctica y empecemos a aprender a construirlos.

7
 Taller 2: Reconociendo los SENSORES

elementos con los que contamos

A continuación vamos a hacer un reconocimiento de los PROCESADOR

ACTUADORES
O MICROCONTROLADOR
materiales con los que debemos contar para comenzar
con la construcción de robots.
Ejercicios aconsejados:
Identificar los elementos con ayuda de las imágenes e INTELIGENCIA
información que se encuentra seguidamente. ARTIFICIAL
Los primeros componentes que tenemos son de electrónica:

Cables Regulador
Protoboard de Protoboard Adaptador 9v de volte

Este elemento Son alambres que Este es el elemento Se conecta a una de

permite conectar vienen en diferentes que le proporcionará las terminales del
las paticas de los colores y tamaños energía a nuestro adaptador de 9v,
elementos electrónicos para interconectar robot. reduce su voltaje
para formar los elementos en el a 5v para que
circuitos. protoboard. puedan
funcionar
los motores.

Potenciómetro Leds Mini parlante Resistencias

Este elemento es una Son pequeños Es un pequeño Son componentes

resistencia que varía bombillos que emiten parlante, emite electrónicos que
su valor al girar la luces de diferentes sonidos y tiene reducen la cantidad
perilla que tiene. colores segun el led. polaridad. de corriente que otros
elementos reciben
en el circuito.

Módulo educativo de construcción de robots para estudiantes 8

 Cables Regulador
de Protoboard Adaptador 9v de volte
Experimento 1: Conectando elementos, Primer Circuito:
Son alambres que Este es el elemento
Experimento 2: Prendiendo un LED con un interruptor NA:
Se conecta a una de
vienen en diferentes que le proporcionará las terminales del
colores yEn este experimento vamos
tamaños energíaaa conectar
nuestro una pila de 1.5 En deeste
adaptador 9v, experimento vamos a añadir un interruptor
para interconectar robot. a encenderlo pero vamos a reduce su voltaje
voltios AA
los elementos en el
a un LED y vamos normalmente
a 5v para que abierto NA al circuito anterior como lo
guiarnos por el siguiente diagrama electrónico del circuito:
protoboard. puedanvemos en el siguiente diagrama del circuito:
funcionar
los motores.

Leds Mini parlante Resistencias

Son pequeños Es un pequeño Son componentes

electrónicos que
bombillosMontar el siguiente
que emiten circuitoparlante, emite
en el yprotoboard:
sonidos tiene reducen la cantidad
luces de diferentes
polaridad. de corriente que otros
Complemento Teórico:
colores segun el led.
elementos reciben
en el circuito.
Se deberá explicar que es un protoboard, cómo funciona Vemos que cuando presionamos el interruptor el LED
y para qué lo usaremos más adelante. se enciende, ya que estamos cerrando el camino de
la corriente para permitir que llegue hasta el LED. El
interruptor como está normalmente abierto solo permite
el paso de corriente cuando se oprima y se cierre.

Experimento 3: Prendiendo un LED con un interruptor NC:

En este experimento podemos cambiar el interruptor NA
que usamos en el experimento 3 y lo cambiaremos por un
interruptor normalmente cerrado NC.

En este experimento conectamos una pila a una resistencia

de 1 kilo ohm cuyos colores son café negro y rojo.
Complemento Teórico:
Explicar el código de colores de las resistencias, cómo se
sabe qué valor tienen según los colores que tienen pintados.

Interruptor NA Interruptor NC

Es un interruptor que Es un interruptor que

esta normalmente esta normalmente
abierto, cuando se cerrado, cuando se
presiona se cierra, presiona se abre, y
dejando pasar detiene el paso
corriente. corriente. Vemos que el LED siempre esta prendido, y si oprimimos
el interruptor se apagará ya que el interruptor se abrirá y
no permitirá más el paso de corriente al LED. El interruptor
como está normalmente cerrado siempre permite el paso
de corriente pero cuando se oprime este interrumpe el
paso abriendo el circuito.

9
 Experimento 4: Prendiendo un LED con un potenciómetro de 10k ohm:
En este experimento vamos a variar la intensidad de luz del LED, para esto usaremos
un potenciómetro, el cual al girar variará su resistencia interna y cambiara por tanto la
cantidad de corriente que llega al LED. Para este montaje se debe conectar la patica central
del potenciómetro y una de sus dos patas de los extremos a la resistencia de 1k ohm como
lo muestra el siguiente circuito:

Ejercicios aconsejados:
Hacer girar el potenciómetro y descubrir como la intensidad de luz del LED cambia. Cambiar
el potenciómetro de 10k ohmios por el de 250k ohmios y hacer nuevamente la prueba.
Luego de repasar los elementos de electrónica básica ahora veremos los sensores usados
comúnmente en robótica, pero los aprenderemos a manejar en los experimentos del taller 4:

Sensor CNY70
de distancia infrarrojo 

Es el sensor encargado El sensor de proximidad

de medir distancias y
arrojar un voltaje
según la distancia
que mida.
sirve para detectar
objetos cercanos a él,
si detecta objeto
arroja voltaje, sino
arroja 0 voltios.

Fotocelda Fin de carrera

La fotocelda o El fin de carrera es un

fotoresistencia es una
resistencia que varía
su valor según la
cantidad de luz
que reciba.
sensor para detectar
cuando un objeto
choca al sensor. Se
cierra o se abre el
circuito interno.

Módulo educativo de construcción de robots para estudiantes 10

Tarjeta Arduino Cable usb
 La fotocelda o El fin de carrera es un
fotoresistencia es una sensor para detectar
resistencia que varía cuando un objeto
Fotocelda
su valor según la chocaFinalde
sensor. Se
carrera
cantidad de luz cierra o se abre el
que reciba. circuito interno.
La fotocelda o El fin de carrera es un
fotoresistencia es una sensor para detectar
cuando un objeto
La cabeza de nuestro robot,que
resistencia el microcontrolador
varía es
chocaquien recibe
al sensor. Se las señales de los sensores
su valor según la
y ejecuta órdenescantidad
para que nuestro
de luz robot haga lo que
cierra nosotros
o se abre el deseemos:
que reciba. circuito interno.

Tarjeta Arduino Cable usb

Esta es la tarjeta Con este cable

donde está el conectaremos nuestra
microcontrolador que tarjeta Arduino al
seTarjeta
programaArduino
para que Cable usb
computador.
funcione nuestro
robot.
Esta es la tarjeta Con este cable
donde está el conectaremos nuestra
microcontrolador que tarjeta Arduino al
se programa para que computador.
funcione nuestro
robot.

Pero nuestro robot no se moverá sin estos elementos, los aprenderemos a usar en el taller 5:
Chasis de robot Motores

En este chasis se El chasis contiene dos

montarán los elementos motores DC que hacen
del robot y este podrá girar las ruedas del
Chasissegún
moverse de robot
lo robot. Motores
programemos.
En este chasis se El chasis contiene dos
montarán los elementos motores DC que hacen
del robot y este podrá girar las ruedas del
moverse según lo robot.
programemos.

Controlador
de motores

Este chip sirve para

manejar los voltajes
de los motores, ya que
Controlador
no se
depueden
motores conectar
directamente a la
tarjeta arduino.
Este chip sirve para
manejar los voltajes
de los motores, ya que
no se pueden conectar
directamente a la
tarjeta arduino.

11
 Taller 3: Juguemos con Arduino
Aprendiendo a usar la tarjeta Arduino:
Lo primero que vamos a aprender es a manejar la tarjeta
Arduino, pero qué es? Y para qué nos sirve?
Arduino es una tarjeta electrónica que está basada en un
microcontrolador (le diremos desde ahora MICRO), como
vimos anteriormente un micro es el cerebro de nuestro
robot y por tanto debemos enseñarle cosas y darle
órdenes para que se ejecuten. Entonces nuestra tarjeta
Arduino es el camino para poder conectar el mundo de
la electrónica con nuestro computador, en el computador
escribiremos las ordenes que debe ejecutar nuestro robot
y luego debemos grabar esas órdenes en el micro para
que se hagan realidad. La tarjeta posee pines, o puntos
donde conectaremos diferentes elementos electrónicos
y están marcados con números en la tarjeta. Hay pines
digitales, análogos, y de alimentación donde podremos
sacar energía para conectar otros elementos.
Complemento Teórico:
Con el profesor identificar y definir que son los puertos
digitales, análogos, y de alimentación. Qué sale por un
puerto digital?, Qué recibe un puerto análogo?, Cómo
se transforma una señal real en un valor numérico que
podemos usar en nuestro micro para hacer nuestros
programas?, Qué es poner un voltaje en un pin de la
tarjeta, poner en HIGH, enviar un 1 a un pin?. Dónde
están los pines de alimentación 5v y GND?
Módulo educativo de construcción de robots para estudiantes
Igual que nosotros como seres humanos para entendernos
debemos hablar un idioma, algunos hablamos español,
otros hablan inglés, y otros hasta usan sus manos para
hablar, igualmente debemos hablarle a nuestro micro
para que nos entienda y nos haga caso, pero para esto
debemos usar un lenguaje específico y decirle las cosas
de una manera especial. Le decimos las cosas mediante
un “código” o “programa” es decir, un texto escrito con
instrucciones que entenderá nuestro micro, y así podrá hacer
lo que le queremos. En el transcurso de los experimentos
iremos aprendiendo a darle órdenes a nuestro micro.
Para hacer menos confuso el aprendizaje vamos a hablar
de ahora en adelante de programar la tarjeta Arduino
o programar el micro indistintamente, pero entendiendo
bien que el único que se programa es el microcontrolador.
Experimento 5: Conectando la tarjeta Arduino al
computador con ayuda del cable USB.
Lo primero que debemos hacer es tener a la mano el
programa de Arduino que podemos descargar desde la
página, usaremos la versión 0018 en este caso:
http://arduino.cc/es/Main/Software1
O si tienen el programa ya en cd o en algún otro lugar
buscaremos en su interior una carpeta con el nombre
DRIVERS, en esta carpeta es donde están ubicados los
controladores para que funcione la tarjeta con el computador.
Verificar que tenemos
la carpeta drivers.
1 “En esta página encontrarán tutoriales, ejemplos y muchas ayudas para aprender más sobre Ardui-
no, no duden en ir a visitarla”
12
 Si poseen una buena conexión a internet y tiene el
computador actualizado con solo conectar la tarjeta el
sistema operativo Windows buscará el controlador y se
instalará el Arduino automáticamente, si no es el caso
veremos el procedimiento a realizar para instalar los
drivers en un sistema operativo Windows XP, si requieren
más ayuda de como instalar los drivers en otros sistemas
vayan a la siguiente dirección:
http://arduino.cc/es/Guide/HomePage

Procedimiento de instalación de Arduino en Windows XP:

Tomamos nuestro cable USB y lo conectamos tanto a
la tarjeta Arduino como al computador. Inicialmente
empezará el sistema operativo a buscar los drivers de la
tarjeta:

Seleccionamos la casilla “Incluir esta ubicación en la

búsqueda:” y damos clic en el botón examinar, donde
buscaremos la carpeta FTDI USB Drivers que se encuentra
dentro de la carpeta Driver del programa Arduino:

Luego nos pedirá buscar el controlador en internet

desde Windows update, pero le diremos que “No por el
momento” y damos clic en siguiente:

Finalmente para verificar que todo esté en orden, hacemos

clic derecho en el icono de mi PC que generalmente
está en el escritorio, seleccionamos propiedades luego
Le decimos “Instalar desde una lista o ubicación especifica seleccionamos la pestaña “Hardware” y luego damos clic
(avanzado)” y damos clic en siguiente: donde dice “Administrador de Dispositivos”:

13
 Para la reinstalación debemos hacer clic derecho donde
se presenta el icono con el conflicto y hacemos clic en
propiedades, luego en actualizar controlador y hacemos
nuevamente los pasos iniciales que acabamos de mostrar.

Experimento 6: En este experimento vamos a comenzar

a utilizar la tarjeta Arduino para encender un LED o un mini
parlante.
Vamos a hacerlo funcionar por primera vez. Que se haga
la luz!...prendiendo un LED.
Lo primero que debemos hacer es abrir el programa de
Arduino que podemos descargar desde la página:

Hacemos click en el signo mas (+) donde dice controladores http://arduino.cc/es/Main/Software2

de bus serie universal (USB), y verificamos que el icono O si tienen el programa ya en cd o en algún otro lugar
donde dice “USB Serial Converter” esta tal como muestra podemos abrirlo:
la imagen siguiente:

Hacer doble clic (para abrir)

Abrirá el programa y tendremos que seleccionar el tipo de

tarjeta con la que estamos trabajando, debemos seguir
este proceso:

Si todo está en orden podemos empezar a utilizar

Arduino en nuestro Pc sin inconvenientes. En caso tal
que aparezca un icono con un símbolo amarillo encima 2 “En esta página encontraran tutoriales, ejemplos y muchas ayudas para aprender más
debemos reinstalar los drivers: sobre Arduino, no duden en ir a visitarla”

Módulo educativo de construcción de robots para estudiantes 14

1. Ir a “Menu tools” en la parte superior del programa que
acabamos de abrir
2. Pasar el mouse donde dice “board” y de desplegará una
lista
3. Hacer clic donde dice “Arduino Diecimila, Duelminanove, or
Nano w/ AT Mega 168”
6.
Luego de que automáticamente se abra una nueva
ventana se debe verificar que el código está bien escrito
haciendo clic en la flecha “Verify” (compilación del código
o verificación de sintaxis)

7. Vamos a grabar el código en el micro hacer clic en

Upload

8. Verificar que se haya programado correctamente:

4. Ir a “Menú tools” -> Serial port -> Elegir Puerto activo

(ejemplo: COM5)
En caso tal que no aparezcan puertos COM es posible que la
tarjeta Arduino haya quedado mal instalada.
9. Se debe conectar un LED tal como muestra la siguiente
imagen :

5. Menú File ->Examples -> Digital-> Blink

10.Y eso es todo! vemos como el LED prende y apaga

sucesivamente, podemos cambiar el LED por un mini
parlante para escuchar un sonido intermitente.
11.Pueden cambiar el valor que está en la función
“delay(1000)” por un valor más grande como 4000, y
luego por uno más pequeño como 200. Qué pasa? Que
hace esta función delay?

15
 Complemento Teórico:
En este punto es necesario que el profesor haga la
introducción teórica sobre programación con la ayuda del
código “Blink” para prender un LED. Deberá enseñarse
sobre qué es un algoritmo y un programa, cuales son las 3
partes fundamentales de un programa (variables, funciones
y función principal main que en Arduino es “Loop”), explicará
que es la Sintaxis de un código, que es un “comentario” y
que tipos de variables podemos usar.
Análisis del código:
Como puede verse en este código, hay tres partes
fundamentales, que todo código debe tener SIEMPRE, la
primera de ellas es la declaración de variables:
int ledPin = 13; // LED conectado al pin digital 13
En esta parte vamos a definir los pines que usaremos
de nuestra tarjeta, e igualmente todas las variables que
necesitemos usar.
El siguiente componente es la función configuración
“setup()”, todo lo que está encerrado dentro los 2
corchetes de la función es parte de esta configuración:
void setup(){
// Inicializar el pin digital ledPin como salida:
pinMode(ledPin, OUTPUT);
}
En esta parte le decimos a la tarjeta como vamos a utilizar
sus pines, si va a salir voltaje de ellos (OUTPUT) o si van
a recibir voltajes o señales (INPUT), para esto usamos
la función pinMode(número de pin, INPUT u OUTPUT). Por
último tenemos la función principal “main” que llamamos
en Arduino loop(), al igual que la función setup() la funcion
loop() debe encerrar todo el código entre 2 corchetes que
se abren apenas se escribe loop() y se cierran al final de
todo el código. Esta función se llama loop (en español
clico) ya que repetirá indefinida una y otra vez lo que
escribamos entre sus corchetes:
Módulo educativo de construcción de robots para estudiantes
void loop(){
// Prender el led enviando
// 5 volios por el pin 13 ledPIN
digitalWrite(ledPin, HIGH);
delay(1000); // esperar un segundo
// Apagar el led enviando
//0 voltios por el pin 13 ledPIN
digitalWrite(ledPin, LOW);
delay(1000); // esperar un segundo
}
En este código vemos funciones especiales que usa
Arduino para poner voltaje en sus pines como la función
digitalWrite(número de pin, LOW/HIGH, ), para poner 5 voltios
en un pin y prender el LED que tenemos conectado
escribimos digitalWrite(ledPin, HIGH); La función “delay()” si se
dieron cuenta sirve para hacer una pausa en el programa,
es decir, se congela el programa y no se ejecutan más
instrucciones, por eso en el código de “Blink” cuando
prendemos el LED y hacemos una espera de 1 segundo
el LED permanece en ese estado, cuando acaba la espera
y la nueva instrucción se ejecuta, el LED se apaga y lo
dejamos en este estado por 1 segundo más, antes de
volver a encenderlo. Como se mencionó hace un momento
la función “Loop()” repite el código indefinidamente, en
este ejemplo prende y apaga el LED repetidamente.
A medida que vayamos realizando más experimentos
veremos algunas otras funciones especiales de Arduino.
Ejercicios aconsejados:
Los niños deben desarrollar un algoritmo para hacer que
uno de sus compañeros que debe hacer de robot, pueda
llegar a un lugar del salón partiendo de otro punto. Definir
las reglas y las órdenes para que el robot pueda llegar al
lugar deseado.
Hacer que los niños respondan las siguientes preguntas
luego de la clase teórica, uno responde y otro lo corrige:
• Qué es un programa, para que sirve, en que lo vamos a utilizar?
• Cómo se escribe un programa, y Qué es un lenguaje de
programación?
• Qué es un algoritmo? Para qué sirve crear un algoritmo?
• Las partes de un programa: Qué es y para qué sirve una
variable, en qué forma la usaremos, qué es un tipo de
variable?, Qué operaciones podemos hacer con los datos o
variables, sumar, restar, multiplicar, operaciones lógicas,
comparativas, etc.?
16
 • Las partes de un programa: Qué es y para qué sirve una El siguiente Código es con el que se programará la tarjeta Arduino, se debe copiar en una
función, en qué forma la usaremos? nueva ventana de programa, compilar (triángulo izquierdo verify) y programar (flecha
• Las partes de un programa: Qué es y para qué sirve la derecha upload):
función principal, en qué forma la usaremos?
• Qué usamos para programar: las herramientas con las que Código:
disponemos son, FOR, WHILE, IF, IF ELSE, SWITCH, para
qué nos sirven en nuestros programas? /**************************************************************/
// Creado por José Luis Susa - 2010
Experimento 7: Presionando un pulsador se activan
/*variable que guarda los 4 números donde
varias luces: estarán conectados los 4 LEDs */
int cadenaLeds[ ]={6,7,8,9};
Vemos a continuación la imagen del montaje en protoboard,
se usan 4 LEDs (Representados como semicírculos con un /*Declaración de la variable que guarda el nº del PIN al que se conecta el pulsador*/
int puls=5;
signo + y -), 4 resistencias de 330 ohm (naranja naranja café)
conectadas a los 4 LEDs, un interruptor NA y su resistencia de /*tiempo es la variable que guarda el valor de la espera
1K ohm (café negro rojo). que usaremos con la función delay*/
int tiempo=200;
/*La variable n es el contador en el FOR*/
int n=0;
void setup (){
for(n=0;n<4;n++){
/*Configuración de los pines para los 4 LEDs como salidas*/
pinMode(cadenaLeds[n],OUTPUT);
}
/*Configuración del PIN “puls” como entrada*/
pinMode(puls,INPUT);
}
void flash(){ /*esta function flash prende los 4 LEDs*/
for(n=0;n<4;n++){
digitalWrite(cadenaLeds[n],HIGH);
}
delay(tiempo);
for(n=0;n<4;n++){
digitalWrite(cadenaLeds[n],LOW);
}
delay(tiempo);
}
void loop(){
/*Condición que se ejecuta si detecta se presiona el pulsador*/
if(digitalRead(puls)==HIGH){
/*se llama a la función flash para prender LEDs*/
flash();
}
}

/**************************************************************/

Explicación:
En este experimento se conecta un interruptor NA al pin 5 de la tarjeta Arduino de tal forma
que sea la entrada del sistema para determinar cuándo encender los 4 LEDs conectados a los
pines 6, 7, 8, y 9 por medio de sus resistencias. Cada vez que el interruptor (normalmente
abierto) es presionado, el pin 5 recibe una señal de 5 voltios y esto enciende los LEDs.

17
 Complemento Teórico:
• Se debe analizar y entender cómo actúa la variable
cadenaLed[], explicar cómo actúan las variables tipo
arreglo como esta. Cómo se usa la variable cadenaLed[]
en la sentencia FOR.
• Se debe analizar y entender cómo actúa la función flash,
cómo se usa la función en el programa, para que usamos
Código:
/**************************************************************/
// Creado por José Luis Susa - 2010
/*variable que guarda los 4 números donde
estarán conectados los 4 LEDs*/
int cadenaLeds[ ]={6,7,8,9};
/*nº de la entrada analógica a la que va conectado el potenciómetro*/
int pot=0;

una sentencia FOR y la condición IF, cómo es la sintaxis /*La variable n es el contador en el FOR*/
int n=0;
te estas sentencias?
• Cómo se relacionan las tablas de verdad, con la electrónica /*variable que guarda la lectura de la señal en la entrada*/
int medida=0;
física, los 1 y 0 con las tablas de verdad, para qué me
sirven (generación condiciones IF y ejecución de acciones /*no es necesario configurar las entradas analógicas, siempre son entradas*/
dependientes de estas). void setup(){
for(n=0;n<4;n++){
• Qué hace la función digitalRead? Para que la usamos en pinMode(cadenaLeds[n],OUTPUT);
este código? }
}
Ejercicios aconsejados: void loop(){
/*Guardamos el valor de la entrada analógica en la variable medida*/
Hacer que las luces se prendan y apaguen de manera medida=analogRead(pot);
intercalada cuando se oprima el pulsador (estilo auto
fantástico). /*la señal analógica está entre 0 y 1024. La dividimos en 4 partes.*/

if(medida<1024/4){
Experimento 8: Prender 4 LEDs con la ayuda de un /*se enciende el primer LED si la señal está en el primer cuarto*/
digitalWrite(cadenaLeds[0],HIGH);
potenciómetro de 10 K ohm:
/*los demás se apagan para que cuando la señal disminuya no se queden encendidos*/
En este montaje usamos los mismos 4 LEDs y sus digitalWrite(cadenaLeds[1],LOW);
digitalWrite(cadenaLeds[2],LOW);
respectivas resistencias de 330 ohmios, usamos un digitalWrite(cadenaLeds[3],LOW);
potenciómetro conectando a una de sus 3 patas a 5v, la }
otra a una resistencia de 1k ohmios y la pata central se /*señal en el segundo cuarto, 2 LEDs encendidos*/
conecta al pin análogo 10 de la tarjeta Arduino. if((medida>=1024/4)&&(medida<1024/2)){
Imagen montaje: digitalWrite(cadenaLeds[0],HIGH);
digitalWrite(cadenaLeds[1],HIGH);
digitalWrite(cadenaLeds[2],LOW);
digitalWrite(cadenaLeds[3],LOW);
}
/*señal en el tercer cuarto, 3 LEDs encendidos*/

if((medida>=1024/2)&&(medida<1024*3/4)){
digitalWrite(cadenaLeds[0],HIGH);
digitalWrite(cadenaLeds[1],HIGH);
digitalWrite(cadenaLeds[2],HIGH);
digitalWrite(cadenaLeds[3],LOW);
}

/*señal en el último cuarto, 4 LEDs encendidos*/

if(medida>=1024*3/4){
digitalWrite(cadenaLeds[0],HIGH);
digitalWrite(cadenaLeds[1],HIGH);
digitalWrite(cadenaLeds[2],HIGH);
digitalWrite(cadenaLeds[3],HIGH);
}
}
/**************************************************************/

Módulo educativo de construcción de robots para estudiantes 18

Explicación:
En este experimento se aprecia cómo puede incluirse En el montaje usamos una resistencia de 330 ohmios (naranja naranja cafe), una fotocelda
un componente análogo (potenciómetro) para controlar y entre estas sacaremos un cable para llevar el voltaje variable de la fotocelda al pin análogo
según su valor cual debe ser la acción a ejecutar. En este 0 de la tarjeta Arduino:
caso el valor máximo de 5 voltios encenderá todos los
LEDs en cambio ¼ de este voltaje máximo solo encenderá
1, a medida que aumente el voltaje se irán encendiendo
cada uno de los LEDs hasta que todos estén prendidos.
Complemento Teórico:
Cómo hacemos la lectura del valor del potenciómetro?
Para qué sirve la función analogRead().

Código:
/**************************************************************/
Taller 4: Bienvenidos al mundo de la
//Creado por José Luis Susa - 2010
robótica, juguemos con los sentidos de
un robot. //Entrada donde se conecta el sensor
int sensorPin = 0;

//Salida digital donde se conecta un LED o una bocina

A partir de este momento vamos a aprender sobre las int ledPin = 13;
partes de un robot, iniciaremos con sensores y luego
pasaremos al manejo de los motores. Haremos 4 //Variable para guardar el valor medido del sensor
experimentos para manejar los 4 sensores más utilizados int sensorValue = 0;
en robótica. Los sensores son los sentidos de nuestro void setup() {
robot, con ellos podrán tocar y saber quién está cerca, // declare the ledPin as an OUTPUT:
si hay luz o no, luego de saber cómo usarlos podemos pinMode(ledPin, OUTPUT);

ponerlos en un robot y hacer grandes e interesantes //inicialización serial para mostrar datos en la pantalla
cosas…Así que comencemos! Serial.begin(9600);
}

Experimento 9: Sensor de luz, ¿cuál es su utilidad void loop() {

int distanciaCm;
en robótica? // la lectura del sensor va de 0 a 500 aproximadamente
sensorValue = analogRead(sensorPin);
El sensor de luz o fotocelda es el primer sensor con el que
jugaremos, este sensor es una resistencia variable que if(sensorValue>80){ //si el valor medido es > 80 detecta luz
depende de la cantidad de luz que reciba en su superficie, // se enciende la salida ledPin
entre más luz reciba menos resistencia tendrá y viceversa. digitalWrite(ledPin, HIGH);
}else{
En el circuito que montaremos veremos como cambiando la // se pone a cero la salida ledPin
luz, cambiará el voltaje que recibe la tarjeta Arduino. digitalWrite(ledPin, LOW);
}
Las aplicaciones de este sensor son muy diversas, se
puede agregar este sensor a un robot y programar un //imprimimos en pantalla el valor medido
comportamiento tal que si hay luz el robot avance o de lo Serial.print (“\nValor Medido:”);
Serial.print (sensorValue);
contrario permanezca en su sitio, igualmente podríamos
hacer que un robot al detectar luz genere una señal sonora, }
o ejecute una serie de movimientos determinados. /**************************************************************/

19
 Explicación:
En este montaje se recibe una señal análoga por el pin 0
de Arduino, y se visualiza una salida digital por el pin 13.
El rango para que encienda o apague el LED dependerá de
las necesidades de uno como programador, dependiendo de
la cantidad de luz captada, modificaremos a conveniencia el
valor 80 que está en el IF por cualquier otro que deseemos
que se ajuste a lo que queremos, el voltaje de salida enviado
por la fotocelda será menor si la esta no recibe luz, ya que
su resistencia interna aumenta tanto que se aproxima a un
circuito abierto donde no conduce corriente.
Se usa una función Serial.print que sirve para visualizar
en pantalla lo que deseemos, en este caso imprimimos
en pantalla la frase “Valor Medido” y luego imprimimos
el valor que tiene la variable “sensorValue”, el signo “\n”
sirve para generar una nueva línea, como cuando damos
“Enter” en un teclado. Para ver estos valores en la pantalla
del computador, damos clic en el icono monitor del puerto
serial (serial monitor):
Podemos usar los dos interruptores al tiempo, por ejemplo
si conectamos un LED al interruptor NC, este permanecerá
encendido siempre, a menos que el interruptor sea oprimido,
si queremos que el robot retroceda apenas reciba una señal
cuando el NA se cierre, estaremos logrando dos efectos
diferentes presionando el sensor, apagaremos el LED y
haremos que nuestro robot retroceda de forma simultánea.
Igualmente los fines de carrera son altamente utilizados
para controlar los movimientos de algunos motores, si un
motor tiene unido una pequeña barra, cuando este gire
la barra giraría, así si se coloca un fin de carrera de tal
manera que luego de cierto giro del motor se toque el
sensor con la barra, es posible programar nuestra tarjeta
para que detengamos el motor cuando esto suceda y
cambiarle el sentido de giro, si colocamos un segundo
sensor fin de carrera al otro lado, y hacemos lo mismo,
lograremos que el motor se encienda haga girar la barra a
un lado hasta tocar el primer sensor y luego regrese hasta
que choque con el segundo y vuelva a cambiar el giro. De
esta manera lograremos controlar el movimiento de un
motor al controlar su giro máximo.
El experimento siguiente veremos como es el funcionamiento
de este sensor, conectando dos LED como muestra el
siguiente diagrama:

Ejercicios aconsejados:
Imprimir en pantalla el valor medido multiplicado por 2,
Cómo haríamos que la función Serial.print() muestre este
nuevo valor?.
Experimento 10: Sensor de choque o fin de carrera,
cuál es su utilidad en
El sensor que usaremos a continuación es llamado fin de
carrera, se puede decir que son dos interruptores en uno,
hay un interruptor NA y otro NC, cuando se preciosa el
interruptor NA se cierra y el NC se abre, de esta manera
es posible enviar dos señales a nuestra tarjeta Arduino al
mismo tiempo si queremos. Por ejemplo, si le ponemos
este sensor en la parte frontal de nuestro robot si este
se chocara de frente oprimiría el sensor, si se oprime
enviaria una señal digital (5 voltios) a una de las entradas
de la tarjeta, podemos programar nuestro robot para que
cuando esto suceda retroceda y haga un giro de 180 grados
para alejarse del lugar donde se chocó.

Módulo educativo de construcción de robots para estudiantes 20

Código: Experimento 11: Sensor distancia, cuál es su
/*****************************************************/ utilidad en robótica?
// Creado por José Luis Susa - 2010
Este es quizás el sensor más usado de todos, el sensor
int finCarrera=7; //Declaración de la variable que guarda el nº del infrarrojo de distancia es muy útil para diversas aplicaciones
PIN al que se //conecta el fin de carrera en robótica, ese sensor envía un haz de luz infrarroja (no
int pinLed =13; visible) que al rebotar en algún objeto es recibida por un
receptor especial llamado sensor lineal que determina que
void setup (){ tan lejos está el objeto, el sensor envía un voltaje por una
de sus terminales correspondiente a la distancia medida,
//pin donde se conecta el LED entre más lejos esté el objeto más pequeño el voltaje y
pinMode(pinLed,OUTPUT); entre más cerca esté mayor es el voltaje.
//Configuración del PIN cuyo nº guarda la variable Con la tarjeta Arduino leemos el voltaje y determinamos
//finCarrera como salida digital que tan lejos o cerca está el objeto y que queremos que
pinMode(finCarrera,INPUT); } haga nuestro robot, por ejemplo si queremos que evite
obstáculos le diremos que si el objeto se detectó a menos
void loop(){ de 15 cm debe parar y girar a la derecha para no estrellarse.
//Condicional que se ejecuta cuando
A continuación vamos a hacer el montaje para hacer
//detecta el finCarrera presionado
if(digitalRead(finCarrera)==HIGH){ funcionar el sensor, en este momento ya deben tener bien
claro cómo usar el protoboard para conectar el sensor
// se activa la salida ledPin encendiendo el LED como indica el siguiente diagrama, deben tener cuidado
digitalWrite(pinLed, HIGH); conectando 5v, si se conecta erróneamente se daña el
}else{ sensor, por eso tomen el sensor tal y como muestra el
// se desactiva la salida ledPin apagando el LED diagrama, el hueco largo hacia la derecha, identificar
el cable de la derecha como 5v, el de la mitad como 0v
digitalWrite(pinLed, LOW); (GND) y el de la izquierda como la salida propia del sensor
}
que irá a la tarjeta Arduino (voltaje de salida):
}
/*****************************************************/

Explicación:
En este ejemplo se puede ver inicialmente el LED de la derecha esta encendido sin que el
fin de carrera este presionado, ya que este LED está conectado al pin NC (normalmente
cerrado) y por tanto el circuito conduce, pero cuando el fin de carrera es presionado el LED
de la derecha se apaga y es el de la izquierda quien se prende, ya que el interruptor NA
(normalmente abierto) cierra el circuito que enciende este segundo LED. Al tiempo que se
enciende este segundo LED se envía una señal digital a la tarjeta Arduino por el pin digital
7 y que según nuestro programa provoca que se encienda un tercer LED conectado al pin
digital 13 de salida.
Ejercicios aconsejados:
Hacer que cuando se oprima el fin de carrera a parte de encender el LED en el pin 13 de
la tarjeta Arduino, apaguemos un cuarto LED conectado a otro pin digital. OJO! El nuevo
LED debe conectarse con una resistencia de mínimo 330 ohmios entre este y GND, no se
debe conectar directamente el LED entre el pin digital y GND porque quemaríamos el LED.

21
 Código: Explicación:
/**************************************************************/ En este experimento se puede ver como la velocidad en
// Creado por José Luis Susa - 2010
que prende y apaga el LED varía de manera inversa a la
//Entrada donde se conectará el sensor distancia medida por el sensor. Entre más lejos el sensor
int sensorPin = 0; detecte un objeto más rápido prende y apaga el LED.
// Salida digital donde se conecta un LED o una bocina La distancia es medida mediante la salida de voltaje
int ledPin = 13; del sensor, a mayor distancia menor voltaje de salida e
viceversa, este voltaje es recibido por la tarjeta Arduino
// Variable para guardar el valor medido del sensor
int sensorValue = 0; y convertido con su conversor análogo-digital y guardado
en una variable llamada “sensorValue”.
//variable donde guardaremos las distancia en cm,
//luego de hacer la conversión necesaria con la fórmula de abajo Ejercicios aconsejados:
int distanciaCm;
Modificar el código para que se encienda el LED solo si
la distancia medida es menor a 15 cm, si es mayor debe
void setup() { estar apagado el LED. Borrar lo que no necesitaremos,
// declarar el ledPin como OUTPUT:
pinMode(ledPin, OUTPUT); usar la variable “sensorValue”, la fórmula de conversión
a cm, la variable “distanciaCm” y una condición IF ELSE.
//inicialización serial para mostrar datos en la pantalla
Serial.begin(9600); Experimento 12: Sensor proximidad, cuál es su
}
utilidad en robótica?
void loop() {
Este sensor se usa generalmente para detectar colores
//lectura del voltaje arrojado por el sensor
//que va aproximadamente de 0 a 600. como negro y blanco, ya que como el blanco refleja la luz
//este valor debe ser convertido luego a centímetros totalmente el sensor envía una señal de 5v, cuando se
sensorValue = analogRead(sensorPin); pone frente a un color negro, este no permite que haya
//Se enciende la salida ledPin rebote de la luz infrarroja y por tanto el sensor envía una
digitalWrite(ledPin, HIGH); señal de 0v. Este efecto es útil para hacer robot que sigan
líneas, si se ubican dos sensores a los costados de una
//Tiempo de espera de <sensorValue> millisegundos:
delay(sensorValue); línea negra, cada vez que se salga un poco de la línea solo
basta hacer girar un poco el robot en sentido contrario
//Se desactiva la salida ledPin para alinearlo nuevamente y seguir la línea.
digitalWrite(ledPin, LOW);
Hay que tener en cuenta que la luz ambiente puede modificar
//Tiempo de espera de <sensorValue> millisegundos: fuertemente las lecturas del sensor, así que es mejor dejarlo
delay(sensorValue); siempre oculto de la luz, si es posible debajo del robot y
//imprimimos en pantalla el valor medido cubierto por los lados, otra solución es mantener a su
Serial.print (“\nValor Medido:”); alrededor una luz constante rodeándolo por ejemplo de LEDs.
Serial.print (sensorValue);
Lo primero que debemos hacer es clasificar las 4 patas del
//cálculo de la distancia en centímetros sensor con ayuda del siguiente gráfico:
//a partir del voltaje medido anteriormente
distanciaCm = (2914 / (sensorValue + 5)) - 1;

/* Como la variable distanciaCm tiene el valor en centímetros que

el sensor midió, se puede usar esta variable para hacer las condiciones*/
Serial.print (“\n Distancia en Cm:”); //imprimimos en pantalla la distancia en cm
Serial.print (distanciaCm);
}
/**************************************************************/

Módulo educativo de construcción de robots para estudiantes 22

El sensor tiene una especie de bombillito de color azul, Código:
si ubicamos este, según el diagrama cada patica vamos
a identificarla con una letra, estas letras son importantes /***********************************************************/
para montar correctamente el siguiente diagrama: //Creado por José Luis Susa 2010

Nota: El bombillo azul esta en la parte superior de la imagen int sensorPin = 0; // entrada donde se conectara el sensor
int ledPin = 13; // salida digital donde se conecta un LED o una bocina
int sensorValue = 0; // variable para guardar el valor medido del sensor

void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
Serial.begin(9600); //inicialización serial para mostrar datos en la pantalla
}

void loop() {
// la lectura del sensor que será fuertemente afectada
//por la cantidad de luz ambiente
sensorValue = analogRead(sensorPin);

//si el valor medido es > 80 detecta color blanco

// se enciende la salida ledPin
if(sensorValue>80){
digitalWrite(ledPin, HIGH);
}else{
// se pone a cero la salida ledPin
digitalWrite(ledPin, LOW);
}

//imprimimos en pantalla el valor medido

Serial.print (“\nValor Medido:”);
Serial.print (sensorValue);

}
/***********************************************************/

Ejercicios aconsejados:
Poner el sensor en la luz del sol y visualizar como afecta la luz ambiente las medidas obtenidas.
Arreglar el código para que funciones bajo estas nuevas condiciones ambientales.

23
 Taller 5: Bienvenidos al mundo
de la robótica, juguemos con
los motores de un robot.
En los siguiente dos talleres vamos a aprender a controlar Para el trabajo que se realizará se va a usar el puente H de referencia L293D:
2 motores de corriente directa llamados motores DC, y 1 Habilitar motor1
serán quienes hagan andar nuestro robot. Inicialmente 2 Entrada1 motor1 ENABLE 1 1 16 VSS
haremos el experimento para manejar un solo motor luego 3 Salida 1 motor1
partiendo de este aprenderemos cómo poder usar un S1
4, 5 Negativo alimentación motores y driver S2 INPUT 1 2 15 INPUT 4

segundo motor, controlando su velocidad y su dirección, 6 Salida2 motor1 OUTPUT 1 3 14 OUTPUT 4

para hacer giros, andar en línea recta o retroceder. 7 Entrada2 motor1
8 Positivo alimentación motores (5v a 36v) GND 4 13 GND
Comencemos entonces!
9 Habilitar motor 2
5 12
Experimento 13: Controlando 1 motor. 10 Entrada2 motor2
S3 S4
GND GND

11 Salida2 motor2 OUTPUT 2 6 11 OUTPUT 3

Para comenzar este montaje es necesario aprender 12,13 Negativo alimentación motores y driver
sobre un dispositivo llamado puente H, el objetivo de 14 Salida1 motor2 INPUT 2 7 10 INPUT 3

este dispositivo es servir como interface entre el micro 15 Entrada1 motor2 VS 8 9 ENABLE 2
y un motor, ya que no es conveniente conectarlos 16 Positivo alimentación chip (5v)
directamente porque el motor maneja corrientes muy
altas para el micro y esto lo dañaría inminentemente. El cierre y apertura
Figura 1: Cerrando interruptores S1 y S4
de los interruptores estará a cargo del micro que está conectado a este
Figura 2: Cerrando interruptores S2 y S3
Un puente H generalmente es conocido como “driver” puente H mediante los pines de entrada Input 1, 2, 3 y 4.
(controlador, conductor, manejador) de un motor, ya En el pin 8 (alimentación de los motores) se conectará el cable que sale del regulador de
que este dispositivo es quien alimenta al motor, define voltaje amarillo que tenemos, el cual que a su vez estará conectado al adaptador de 9v (9
su dirección, y controla su velocidad mediante una salida voltios). 0El regulador reducirá los 9v a 5v para no dañar los motores con exceso de voltaje:
7
PWM (obtenida del micro). CNY
Un puente H es un conjunto de interruptores que se cierran
y abren para controlar la dirección del motor. Si se quiere
A
hacer girar el robot es necesario cerrar los interruptores E
S1 y S4 o bien S2 y S3 para que circule la corriente por C
el motor: K= Cátodo
Patillaje del CNY70

Módulo educativo de construcción de robots para estudiantes 24

Código:
/***********************************************************/ Usamos la función “delay()” para que nuestra tarjeta no
//Creado por José Luis Susa 2010 ejecute más instrucciones y por tanto el chip recibirá el
mismo valor PWM durante estos 3 segundos ya que no se
int motor1A = 6; // salida de pwm al motor hace ningún cambio, al pasar los 3 segundos se modifican
int motor1B = 9; // salida2 de pwm al motor los PWM que se envían y se vuelve a detener todo en este
estado para que los motores giren en el nuevo sentido de
void setup() {
// PWM del motor giro 3 segundos igualmente.
pinMode(motor1A, OUTPUT);
pinMode(motor1B, OUTPUT); Ejercicios aconsejados:
} Hacer que el motor gire durante 4 segundos y luego pare
por otros 2 segundos, hacerlo girar hacia el otro lado por 4
void loop() {
//con analogWrite enviamos un PWM de 100 al pin 6 segundos y parar otros 2 segundos.
analogWrite(motor1A,100);
analogWrite(motor1B,0); Experimento 14: Controlando 2 motores.
Para conectar 2 motores vamos a usar el mismo montaje
delay(3000); //esperar 3 segundos
anterior pero añadiremos algunos cables más para poder
//cambio de sentido de giro usar un segundo motor:
analogWrite(motor1A,0);
Voltaje motor
analogWrite(motor1B,100);
delay(3000);

/***********************************************************/

Explicación:
En este montaje usamos el integrado (chip) L293 para controlar un motor, este gira en un
sentido y en otro alternadamente.
En cuanto al montaje, lo primero que se debe notar es que el chip 293 necesita de 2 voltajes
diferentes, el primero es el voltaje VSS (pin 16), que es el mismo con el que trabaja la
tarjeta Arduino de 5v y el segundo es el voltaje VS del motor (pin 8), que como ya dijimos
sale del regulador, NUNCA DEBE USARSE EL VOLTAJE DE LA TARJETA PARA ALIMENTAR LOS
MOTORES, SIEMPRE USAR EL REGULADOR EXTERNO. Al pin 8 se pueden conectar voltajes de
mínimo 5v hasta 36 voltios, según la capacidad del motor, para nuestro caso los motores que
tenemos reciben máximo 6 voltios.
Hay dos líneas que llegan al chip desde la tarjeta Arduino, estas son las señales PWM que Las conexiones para el segundo motor son similares a las
enviamos desde Arduino para controlar la velocidad del motor, en el código escribimos la del primero, las mismas conexiones que se hicieron en la
función analogWrite(número de pin, valor PWM), entre los paréntesis ponemos el “número de parte superior del chip se hacen abajo para controlar el
pin” por el que enviaremos el “valor PWM” que deseamos. El valor del PWM va de 0 a 255. segundo motor. En el primer montaje usábamos los pines
La razón por la que hay dos PWM para un motor es para poder controlar el sentido de giro, PWM 6 y 9 del Arduino, en este caso usamos los pines 9 y
enviando por un pin un PWM y por el otro 0, el motor girará, si queremos que vaya en sentido 11 para el motor de arriba y los pines 5 y 6 para el motor
contrario invertiremos lo que enviamos en los dos pines, en el primer pin enviaremos ahora 0 de abajo. Hay que fijarse bien que se conecten los cables
y en la segundo el PWM que queramos, si queremos detenerlo debemos enviar 0 por ambos en los pines marcados como PWM en la tarjeta Arduino
pines. Por eso en el código enviamos primero un PWM de 100 por un pin y 0 por el otro, y (pin 3, 5, 6, 9, 10, y 11), hay pines que no son PWM y por
al cambiar de sentido de giro enviamos 0 al primero y 100 al segundo. tanto no nos servirán.

25
 Código: Explicación:
/***********************************************************/ Al igual que en anterior experimento hacemos que ambos
//Creado por José Luis Susa 2010 motores giren en un sentido y luego en otro, invirtiendo las
señales PWM que enviamos desde la tarjeta Arduino. Esta
int motor1A = 11; // salida de pwm al motor vez tenemos 4 pines PWM para manejar los 2 motores,
int motor1B = 9; // salida2 de pwm al motor
debemos configurar los 4 pines como salidas en la función
int motor2A = 5; // salida de pwm al motor 2
int motor2B = 6; // salida2 de pwm al motor 2 “SETUP” y luego en la función “LOOP” enviar por ellos las
señales PWM que deseamos, primero ponemos a girar el
void setup() { primer motor, luego el segundo y hacemos una espera de
// PWM del primer motor 3 segundos para que giren así durante este tiempo, luego
pinMode(motor1A, OUTPUT); cambiamos las señales de ambos motores y esperamos
pinMode(motor1B, OUTPUT); otros 3 segundos girando en este nuevo sentido antes de
// PWM del segundo motor volver a invertir el giro.
pinMode(motor2A, OUTPUT);
pinMode(motor2B, OUTPUT); Cuando programemos nuestro robot para que vaya al
} frente, nos encontraremos que quizás las llantas no giran
como deseamos, una puede girar en sentido inverso a
void loop() { cómo queremos, y en vez de ir de frente el robot gira, la
//girar primer motor solución es invertir los cables de PWM, o los cables del
analogWrite(motor1A,100); motor, poniendo uno de los cables donde está el otro,
analogWrite(motor1B,0); lograremos que ambos motores giren de la misma forma
//girar segundo motor con la misma programación.
analogWrite(motor2A,100);
analogWrite(motor2B,0);

delay(3000); //esperar 3 segundos

//cambio de sentido de giro primer motor

analogWrite(motor1A,0);
analogWrite(motor1B,100);

//cambio de sentido de giro segundo motor

analogWrite(motor2A,0);
analogWrite(motor2B,100);

delay(3000); //esperar 3 segundos

/***********************************************************/

Módulo educativo de construcción de robots para estudiantes 26

Taller 6: A divertirnos construyendo
un verdadero robot!
Cuando pensamos en construir un robot siempre vamos a Experimento 15: Construir un robot que se mantenga separa de un objeto:
pensar en dos sencillas cosas antes de empezar:
1. Definir qué debe hacer nuestro robot?
El primer robot que vamos a construir es el robot que mantenga una distancia específica
2. Pensar en la Programación a un objeto. Si el objeto se aleja el robot debe acercarse, si el objeto se acerca más del
limite el robot debe alejarse.
El primer paso es aunque parezca muy simple, el más
Como ya sabemos que queremos hacer, ahora debemos pensar en los elementos que
importante. Debemos saber que queremos hacer, debemos
necesitaremos para construir el robot:
pensar en cómo vamos a hacerlo, qué algoritmo usaremos
para que haga lo que queremos, qué información recibirá 1. Sensor de distancia frente al robot
2. Dos motores
del exterior y cuáles sensores tendría nuestro robot,
3. Chasis de robot para acoplar los motores
finalmente tendremos que pensar en las salidas que
tendrá nuestro robot, se moverá? Utilizará motores?, Para la construcción del robot vamos a tener que montar en el protoboard el sensor de
parlantes, luces? distancia, el puente h L293 para manejar los dos motores como vimos anteriormente, y
conectar la tarjeta Arduino con nuestro adaptador de 9v y el regulador para alimentar los
El segundo paso parte del primero, como vimos un
motores con 5 voltios. Pidámosle ayuda a nuestro profesor guía para montar todos estos
programa comienza con la declaración de variables así que
elementos correctamente para seguidamente empezar a programar.
según los sensores que definimos en el paso 1 debemos
definir las variables donde vamos a guardar los valores de
los sensores. Luego de esto sigue la configuración de la
tarjeta Arduino, mediante la función “setup()”,debemos
definir cuáles son pines de salida y entrada, si utilizaremos
la comunicación serial para ver datos en pantalla que
necesitemos para probar nuestros códigos (Serial.begin,
Serial.print). Los pines de entrada serán los pines donde
conectamos los sensores, los pines de salida serán
los pines para sacar una señal PWM, prender LEDs, o
Parlantes. Solo nos resta empezar a programar nuestro
algoritmo, nuestras condiciones, nuestras acciones, etc.
Estas instrucciones irán como vimos anteriormente en la
función loop().

Complemento Teórico:
Hacer el ejercicio mental de pensar en varios tipos de
robot simples, reconocer sus objetivos, y pensar en
cómo hacerlo funcionar (el algoritmo), luego pensar en
las variables a utilizar, la configuración y el desarrollo
del código del algoritmo para lograr lo que queremos.
Por ejemplo si queremos hacer un robot que huya, si se
acerca una mano a un sensor de distancia el robot debe
alejarse y hacer sonar un parlante para dar una alerta.
Qué tipo de programación usaríamos? Qué variables y que
acciones efectuará nuestro robot. Entradas? Salidas?

27
 Código: if (distanciaCmMedida>12){ //el robot debe acercarce al objeto

/**********************************/ //motor 1 adelante

/* analogWrite(motor1A,pwm1);
El robot que implementa este código, es capaz de mantener delay(100);
una distancia de 12 cm de un objeto en frente de él. analogWrite(motor1B,0);
Este es un control IA basado en reglas.
//motor 2 adelante
Creado por Jose Luis Susa 2010 analogWrite(motor2A,pwm1);
*/ delay(100);
analogWrite(motor2B,0);
int sensorPin = 0; // entrada donde se conectara el sensor
int ledPin = 13; // salida digital donde digitalWrite(ledPin, HIGH); //cuando
se conecta un led o una bocina vaya hacia adelante prenda el led
int sensorValue = 0; // variable para Serial.print (“\nValor Medido:”);
guardar el valor medido del sensor Serial.print (pwm1);
int distanciaDeseada = 12; //el robot queremos que este a 12cm
int pwm1=255; }else if (distanciaCmMedida<12){ //
el robot debe alejarse del objeto
int motor1A = 5; // salida de pwm al motor 1
int motor1B = 6; // salida2 de pwm al motor 1 //motor 1 hacia atras
int motor2A = 9; // salida de pwm al motor 2 analogWrite(motor1A,0);
int motor2B = 11; // salida2 de pwm al motor 2 delay(100);
analogWrite(motor1B,pwm1);
void setup() {
//configuracion motor 1 //motor 2 hacia atras
pinMode(motor1A, OUTPUT); analogWrite(motor2A,0);
pinMode(motor1B, OUTPUT); delay(100);
analogWrite(motor2B,pwm1);
//configuracion motor 2
pinMode(motor2A, OUTPUT); digitalWrite(ledPin, LOW); //cuando
pinMode(motor2B, OUTPUT); vaya hacia atras apague el led

pinMode(ledPin, OUTPUT); }else if (distanciaCmMedida==12){ //

el robot debe alejarse del objeto
Serial.begin(9600); //inicialización serial
para mostrar datos en la pantalla //motor 1 hacia atras
} analogWrite(motor1A,0);
delay(100);
void loop() { analogWrite(motor1B,0);
int distanciaCmMedida;
//motor 2 hacia atras
// la lectura del sensor va de 0 a 600 aprox analogWrite(motor2A,0);
sensorValue = analogRead(sensorPin); delay(100);
analogWrite(motor2B,0);
//cálculo del valor medido en centímetros
distanciaCmMedida = (2914 / (sensorValue + 5)) - 1; }
}
Serial.print (“\n Distancia en Cm:”); // /***********************************************/
imprimimos en pantalla la distancia en cm
Serial.print (distanciaCmMedida);

Módulo educativo de construcción de robots para estudiantes 28

Complemento Teórico: Código:
Es necesario analizar el código completo, entender bien /***********************************************************/
las 2 condiciones que se escribieron, para ir hacia adelante /*si distancia >=5 ir de frente
si la distancia medida es mayor a 12cm, e ir hacia atrás si si distancia <5 despegarse del muro girando a la derecha
si distancia >5 pegarse al muro girando a la izquierda*/
la distancia es menor de 12cm.
Ejercicios aconsejados: //Creado por José Luis Susa 2010
Hacer que el robot se detenga si el objeto está a una int sensorPin = 0; // entrada donde se conectara el sensor
distancia entre 12 y 14. Si está a menos de 12 centímetros int ledPin = 13; // salida digital donde se conecta un LED o una bocina
alejarse, y si está a más de 14 cm acercarse al objeto. int sensorValue = 0; // variable para guardar el valor medido del sensor
int pwm1=255;
Experimento 16: Construir un robot seguidor de muro:
int motor1A = 5; // salida de pwm al motor 1
El segundo robot que vamos a realizar es el robot que int motor1B = 6; // salida2 de pwm al motor 1
sigue contornos de objetos, normalmente se llama a este
tipo de robots “seguidor de muro”, queremos que el robot int motor2A = 9; // salida de pwm al motor 2
pueda andar al lado de una pared sin estrellarse ni alejarse int motor2B = 11; // salida2 de pwm al motor 2
de ella. Para esto vamos a utilizar el código del anterior
robot para hacer este, ya que solo debemos modificar void setup() {
un poco las condiciones y las acciones y obtendremos el //configuracion motor 1
comportamiento que queremos. pinMode(motor1A, OUTPUT);
pinMode(motor1B, OUTPUT);
Vamos a analizar lo que debe hacer el robot, si queremos
que permanezca cerca al muro, debemos medir la //configuracion motor 2
distancia a la que se encuentra, para esto debemos poner pinMode(motor2A, OUTPUT);
un sensor de distancia al costado del robot, si la distancia pinMode(motor2B, OUTPUT);
que medimos se vuelve mayor, por ejemplo a 5 cm, es
porque el robot se está alejando del muro, por lo tanto pinMode(ledPin, OUTPUT);
debemos hacer que gire en dirección hacia el muro para
acercarse nuevamente, cuando vuelva a conseguir la //inicialización serial para mostrar datos en la pantalla
Serial.begin(9600);
distancia inferior a 5 cm deberá corregir su movimiento
}
y girar nuevamente en el otro sentido para separarse del
muro. De esta manera el robot se moverá siempre al lado void loop() {
del muro como deseamos. Aunque el movimiento no va a int distanciaCmMedida;
ser perfecto, el robot seguirá el muro haciendo los giros
sucesivos que vamos a programar. Veamos el código: //La lectura del sensor va de 0 a 600 aprox
sensorValue = analogRead(sensorPin);

//cálculo del valor medido en centímetros

distanciaCmMedida = (2914 / (sensorValue + 5)) - 1;

Serial.print (“\n Distancia en Cm:”);

Serial.print (distanciaCmMedida);

if (distanciaCmMedida>5){ //el robot debe acercarse al objeto

//motor 1 adelante
analogWrite(motor1A,0);

29
 delay(100); Ejercicios aconsejados:
analogWrite(motor1B,pwm1);
Hacer que el movimiento del robot sea más suave, corregir
//motor 2 adelante los movimientos para que los giros sean menos bruscos y
analogWrite(motor2A,pwm1); agregar una condición adicional para que si el robot está a
delay(100); una distancia entre 4 y 6 se mueva de frente, en las otras
analogWrite(motor2B,0); dos condiciones deberán modificar el valor de la condición
para que cuando la distancia sea menor a 4 el robot se
//cuando vaya hacia adelante prenda el LED
aleje y si es mayor a 6 se acerque al muro.
digitalWrite(ledPin, HIGH);

//el robot debe alejarse del objeto

Experimento 17: Construir un robot que avance
}else if (distanciaCmMedida<5){ cuando detecte luz:
//motor 1 hacia atrás El último robot que construiremos es un robot que siga la
analogWrite(motor1A,pwm1); luz, es decir que avance en el momento que detecte luz.
delay(100);
Para hacer este robot qué necesitamos entonces?...claro
analogWrite(motor1B,0);
una fotocelda!
//motor 2 hacia atrás Vamos a hacer el montaje de la fotocelda tal como
analogWrite(motor2A,0); aprendimos anteriormente en el experimento 9, igualmente
delay(100); vamos a necesitar montar el L293 para manejar nuestros
analogWrite(motor2B,pwm1); dos motores que moverán el robot.

//cuando vaya hacia atrás apague el LED

digitalWrite(ledPin, LOW);
//el robot debe alejarse del objeto
}else if (distanciaCmMedida>=5){
//motor 1 hacia atrás
analogWrite(motor1A,pwm1);
delay(100);
analogWrite(motor1B,0);

//motor 2 hacia atrás

analogWrite(motor2A,pwm1);
delay(100);
analogWrite(motor2B,0);

}
}
/***********************************************************/

Complemento Teórico:
Es necesario analizar el código completo, entender bien las 2 condiciones que se escribieron,
para acercarse al muro si la distancia medida es mayor a 5cm, y alejarse del muro si la
distancia es menor de 5cm.

Módulo educativo de construcción de robots para estudiantes 30

Código:
// Creado por José Luis Susa 2010

int sensorPin = 0; // entrada donde se conectara el sensor

int ledPin = 13; // salida digital donde se conecta un LED o una bocina
int sensorValue = 0; // variable para guardar el valor medido del sensor

int motor1A = 5; // salida de pwm al motor 1

int motor1B = 6; // salida2 de pwm al motor 1

int motor2A = 9; // salida de pwm al motor 2

int motor2B = 11; // salida2 de pwm al motor 2

int pwm1=255;

void setup() {
//configuracion motor 1
pinMode(motor1A, OUTPUT);
pinMode(motor1B, OUTPUT); void loop() {
int distanciaCm;
//configuracion motor 2 // la lectura del sensor va de 0 a 500 aproximadamente
pinMode(motor2A, OUTPUT); sensorValue = analogRead(sensorPin);
pinMode(motor2B, OUTPUT);
//imprimimos en pantalla el valor medido
// declare the ledPin as an OUTPUT: Serial.print (“\nValor Medido:”);
pinMode(ledPin, OUTPUT); Serial.print (sensorValue);
//inicializacion serial para mostrar datos en la pantalla
Serial.begin(9600); if(sensorValue>80){ //si el valor medido es > 80 detecta luz
} // se enciende la salida ledPin
digitalWrite(ledPin, HIGH);

//motor 1 adelante
analogWrite(motor1A,pwm1);
delay(100);
analogWrite(motor1B,0);

//motor 2 adelante
analogWrite(motor2A,pwm1);
delay(100);
analogWrite(motor2B,0);
}else{
// se pone a cero la salida ledPin
digitalWrite(ledPin, LOW);

//motor 1 parar
analogWrite(motor1A,0);
delay(100);
analogWrite(motor1B,0);

//motor 2 parar
analogWrite(motor2A,0);
delay(100);
analogWrite(motor2B,0);
}
}

31
 Módulo
Educativo
de construcción de robots
para estudiantes

Módulo educativo de construcción de robots para estudiantes 32

Con este último robot acabamos! Hemos hecho un recorrido por todas las partes del robot,
sus sensores, sus motores, su cabeza, la programación y hemos logrado hacer tres robots
con tres comportamientos diferentes.
Espero que hayan sido los experimentos divertidos y que hayan jugado con los códigos,
los elementos y con todo lo que tienen a la mano para crear nuevos robots, con tiempo y
dedicación lograran hacer más y mejores robots y luego verán cómo estos cambiarán el mundo.
Gracia por usar esta cartilla, espero que haya sido de gran utilidad para ustedes y hayan quedado
muy entusiasmados con todo lo que pueden hacer de aquí en adelante. Cualquier comentario
pueden escribir al correo: josesusa@gmail.com, con gusto recibiré recomendaciones, opiniones
y claro, felicitaciones!

Atentamente
Ing. José Luis Susa Rincón.