1

Conociendo a mi robot
Otto

OTTO DIY es un robot bípedo pensado

para ser armado de forma muy fácil e
intuitiva, Otto es completamente de
código abierto, compatible con Arduino
y con él podrás experimentar diferentes
programaciones, hacerlo andar, bailar,
hacer sonidos, evitar obstáculos entre
muchas acciones más.

Componentes

Sensor
1 ultrasónico Cable de datos
1
micro USB

Servomotores
6 SG90
1 Buzzer activo 5V

Arduino 1 Cabeza del

1 nano shield robot

1 Cuerpo del
robot
1 Arduino nano
4 Bases
piernas/brazos
Porta
1 baterías AA Bases patas del
2 robot

Cables de
40
conexión 1 Switch

2
Lección I. Introducción a Arduino

¿Qué es Arduino?

¿Qué es Arduino?
Se trata de una placa Open Hardware por lo que su diseño es de libre
distribución y utilización. En nuestro robot utilizaremos una placa de desarrollo
de tamaño compacto, completa y compatible con protoboards, basada en
el microcontrolador ATmega328P. Tiene 14 pines de entrada/salida digital (de
los cuales 6 pueden ser usando con PWM), 6 entradas analógicas, un cristal de
16Mhz, conexión Mini-USB, terminales para conexión ICSP y un botón de
reseteo.

En la ilustración 1 se observa los componentes del Arduino nano.

Ilustración 1. Componentes del Arduino nano

Instalación de Arduino

1. Descarga la aplicación para manejar

el Arduino en tu computadora Gratis
desde:
www.arduino.cc
2. Ingresa a la pestaña software,
posteriormente nos dirigimos a la
sección de “descargas”

3
3. Elija el paquete de instalación del sistema operativo apropiado para su
computadora.

4. Una vez descargada la aplicación, ejecutar el archivo .exe

(ilustración), leer y aceptar los términos y condiciones de la
aplicación.

¡Listo, ya puedes utilizar Arduino en tu computadora!

La pantalla principal

1 2 3 4 5

4
 2. Verificar 1. Abrir

4. Cargar 3. Guardar

5. Nuevo

7. Panel de notificaciones

6. Indicador de puerto

Estructura de un programa

La estructura básica del lenguaje de programación de Arduino es bastante

simple y se compone de al menos dos partes. Estas dos partes necesarias, o
funciones, encierran bloques que contienen declaraciones, estamentos o
instrucciones.

void setup()
{
estamentos;
}
void loop()
{
estamentos;
}

¡Vamos a explicar cada elemento del programa!

Función setup()

La función setup() se invoca una sola vez cuando el programa empieza. Se

utiliza para inicializar los modos de trabajo de los pins, o el puerto serie. Debe
ser incluido en un programa, aunque no haya declaración que ejecutar.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
}

5
Función loop()

Después de llamar a setup(), la función loop() hace precisamente lo que

sugiere su nombre, se ejecuta de forma cíclica, lo que posibilita que el
programa este respondiendo continuamente ante los eventos que se
produzcan en la tarjeta

void loop()

digitalWrite(pin, HIGH); // pone en uno (on, 5v) el ´pin´

delay(1000); // espera un segundo (1000 ms)

digitalWrite(pin, LOW); // pone en cero (off, 0v.) el ´pin´

delay(1000);

¡Ahora, expliquemos el código completo!

void setup() En esta sección inicializamos entradas/salidas

{
pinMode(pin, OUTPUT); Declaramos la variable “pin” como salida
}

void loop() Aquí el programa se ejecuta de forma cíclica

{

digitalWrite(pin, HIGH); Mandamos un alto(activado/5v) al puerto

delay(1000);

digitalWrite(pin, LOW); Mandamos un bajo(desactivado/0v) al puerto

delay(1000);
Mandamos un retraso de 1 segundo
}

6
 • Con ayuda de su maestro realicen los siguientes ejercicios:

1. ¡Vamos a crear un semáforo! Observa la secuencia de diodos led y crea un

programa que te permita realizar la siguiente animación:

A) Inician los tres Leds apagados por un segundo

B) Enciende el Led verde por 6 segundos
C) Se apaga el Led verde y automáticamente parpadea el Led amarillo en
dos ocasiones con duración de un segundo entre cada parpadeo.
D) Se apaga por completo el Led amarillo y enciende el Led rojo por 4
segundos.

Leds apagados Verde por 6s Amarillo 2o/1s Rojo 4s

7
Lección II. Tipo de datos y
operadores

Al igual que en c++ los datos tiene un tamaño y rango que soporta la
cantidad de valor, en la siguiente tabla encontrar el detalle de dicha
información

Tipo Tamaño Rango Descripción

boolean 1 bit 0a1 Entero de 1 bit
byte 8 bit 0 a 255 Entero
unsigned char 8 bit 0 a 255 Entro sin signo
char 8 bit -128 a 127 Entero con signo
int 8 bit -32,768 a 32,767 Entero de 8 bit con signo
long 16 bit -2,147'483,648 a 2,147'483,647 Entero de 16 bit con signo
float / double 4 byte -3.4028235e+37 a 3.4028235e+38 Decimal con signo de 4 bytes

Las constantes son expresiones predefinidos en el lenguaje de Arduino. Se

utilizan para hacer que los programas más fáciles de leer.

Clasificamos constantes en grupos:

• Definición de nivel lógico en donde utilizamos valores como true y false

• Definición de niveles de pin HIGH y LOW donde podemos declarar el
comportamiento eléctrico de un pin por medio de la función pinMode().
• Definición de los modos de pines digitales: INPUT, INPUT_PULLUP y OUTPUT.

Declaración de constantes

También se pueden declarar las constantes para propósitos generales

dentro de nuestra aplicación, ya que le dan a la estructura del programa
una forma de mencionar valores sin que sufran cambios a lo largo del
programa.

Las variables se utilizan para nombrar posiciones de memoria RAM; se deben

declarar obligatoriamente antes de utilizarlas; para ello se debe inicial el
nombre y el tipo de dato que se manejara.

8
Donde:

• Tipo hace referencia a cualquiera de los tipos de datos vistos en la tabla

anterior.
• Nombre_variable puede ser cualquier nombre de variable (el usurario la
asigna).
• Valor_inicial si se requiere es el valor que se le puede dar a la variable.

Las variables definidas en un programa pueden ser de tipo LOCAL o GLOBAL. Las
variables locales se utilizan en la función de donde se encuentran declaradas; las
variables globales se pueden utilizar en todas las funciones del programa.

9
 Operadores Aritméticos

Son aquellos operadores Arduino que ofrecen la posibilidad de trabajar con las
operaciones básicas. Es decir que, los operadores aritméticos que se añaden en
el entorno de programación, hacen referencia a la suma, resta, multiplicación,
división y módulo. Por lo tanto, tienen la capacidad de devolver la suma,
diferencia, producto, cociente o resto de dos operandos.

De tal forma, dichos operadores son esenciales para efectuar cálculos

matemáticos en Arduino a fin de desarrollar una determinada tarea.

+ Suma - Resta * Multiplicación / División % Módulo

Operadores de comparación

Así como su nombre lo indica, estos operadores son empleados para hacer
comparaciones entre valores. Es decir que, son aptos para comparar dos
expresiones y como resultado, generalmente, devuelven un valor booleano que
representa la relación de sus valores.

En ese sentido, existen operadores para poder contrastar valores numéricos, al

igual que, para comparar cadenas e incluso, objetos. Por otro lado, las
comparaciones de una constante o variable con otra en Arduino, son usadas
frecuentemente en las estructuras condicionales (del tipo if, while, etc.) para
lograr testear si alguna condición es verdadera o falsa. Sumado a ello, también se
pueden utilizar sin ninguna estructura de comparación especificada.

== Igual que =! Diferente a < Menor que

> Mayor que <= Menor o igual que >= Mayor o igual que

Operadores booleanos

Estos, también son conocidos como “operadores lógicos” y hacen referencia a

aquellos que permiten comparar dos variables entre sí o, en su defecto, con
constantes. Por ende, usualmente, son una forma de comparar dos expresiones
específicas.

Ahora bien, por lo general, este tipo de operadores en Arduino se caracterizan

por devolver un valor “VERDADERO” o “FALSO”, según sea el operador que esté
trabajando. Sumado a ello, se distinguen tres operadores booleanos que casi
siempre se emplean en estamentos de tipo “if”. Los cuales, son los siguientes:

&& AND || OR ! NOT

10
El siguiente Sketch demuestra el uso de todos los operadores aritméticos
anteriores. Copia y carga el Sketch en tu Arduino para probarlo.

void setup() {
int a = 2;
int b = 7;
int result;
float result_fl;
Serial.begin(9600);
Pega una captura de pantalla de tus
Serial.print("Suma b): ");
resultados obtenidos en Arduino
result = a + b;
Serial.println(result);
Serial.print("Resta- 2): ");
result = 10 - 2;
Serial.println(result);
Serial.print("Multiplicación 3): ");
result = 4 * 3;
Serial.println(result);
Serial.print("División (5 / 4): ");
result = 5 / 4;
Serial.println(result);
Serial.print("Floar (5.0 / 4.0): ");
result_fl = 5.0 / 4.0;
Serial.println(result_fl);
Serial.print("Residuo% 4): ");
result = 11 % 4;
Serial.println(result);
}
void loop() {
}

Escribe tus resultados

11
Lección III. Sentencias
condicionales
Sentencia IF

La instrucción if en Arduino, seguida de una condición, hará posible que

nuestro programa coja distintos caminos dependiendo de si se cumplen o
no.

Es una estructura de gran utilidad y que vamos a ver su uso y programación

en detalle. La estructura condicional tiene la siguiente sintaxis:

if (condición) {……..}

Comenzamos con la instrucción if.

Seguido, y entre paréntesis, escribiremos una condición. Si esta condición se

cumple, será validada y por tanto se ejecutará el código que pongamos
entre las llaves {…………}. En caso contrario, el programa continuará en la
siguiente instrucción sin ejecutar lo encerrado entre llaves.

Para escribir la condición a cumplir usaremos los operadores de

comparación dentro de los paréntesis, por ejemplo:

En esta línea de código vemos que el led conectado a la salida no se

encenderá si la variable x no es mayor que 5 ya que la instrucción de
encendido del led no se ejecutará hasta que no se cumpla la condición
escrita después del comando if.

Esta es la forma básica de uso de la estructura if en arduino.}

Sentencia IF ELSE

Una variante a la estructura de control if en Arduino, es cuando usamos

else, que nos permite la posibilidad de ejecutar unas instrucciones de
programa concretas tanto si se cumple como si no, la condición que
hayamos puesto inicialmente.

12
Con esto tenemos la posibilidad que el programa tome uno de los
dos caminos dependiendo de que una única expresión se cumpla o no.
Una vez ejecutada, el programa continuará en la siguiente línea de código
restante.

Crear un programa en Arduino utilizando la sentencia de control IF ELSE con las

siguientes especificaciones:

Utilizaremos los siguientes materiales:

• 1 interruptor
• 1 placa Arduino
• 1 led

El programa deberá realizar la siguiente rutina: Si el interruptor es presionado, el

led deberá encender, Si no es presionado, deberá permanecer apagado.

13
 Sentencia FOR

La declaración for se usa para repetir un bloque de sentencias encerradas

entre llaves un número determinado de veces. Cada vez que se ejecutan las
instrucciones del bucle se vuelve a testear la condición. La declaración for tiene
tres partes separadas por (;).

Para poder comprender la estructura y funcionamiento del bucle for realizaremos

la siguiente actividad.

El objetivo de esta práctica es construir una serie de luces, es decir, se va a

programar un código encargado de prender y apagar una serie de luces por un
determinado orden y tiempo.

La conexión de nuestro circuito será la siguiente:

Se conectan los LEDs rojo, amarillo y verde a los pines digitales 13, 12
y 11 de la placa de Arduino (utilizando su debida resistencia). La patilla
larga del LED debe ser conectada al voltaje positivo (ánodo) y la corta al
voltaje negativo (cátodo) pasando por la resistencia.

Programación en Arduino

El código empieza utilizando un ciclo for para asignar los pines digitales 2 a 4
como salidas para los 6 LEDs utilizados.

En el ciclo principal del código, se utilizan dos ciclos for para recorrer de forma
incremental, paso a paso a través de los LEDs, uno por uno, del pin 2 al pin 4.
Cuando el pin 4 está encendido, el proceso se invierte, haciendo que los LEDs se
prendan al contrario de como ya se había hecho.

14
int timer = 100;

for (int thisPin = 2; thisPin < 84 thisPin++) {

pinMode(thisPin, OUTPUT);
}
}
void loop() {
for (int thisPin = 2; thisPin < 5; thisPin++) {
digitalWrite(thisPin, HIGH);
delay(timer);
digitalWrite(thisPin, LOW);
}
for (int thisPin = 4; thisPin >= 2; thisPin--) {
digitalWrite(thisPin, HIGH);
delay(timer);
digitalWrite(thisPin, LOW);
}
}

Expliquemos por partes el código.

En esta sección declaramos una variable del tipo entero llamada “timer”
con valor de 100 milisegundos.

int timer = 100;

Posteriormente, declaramos nuestro bucle for con una variable del tipo entera
llamada “thisPin”, iniciando en el puerto 2 del Arduino, hacemos la comparación:
si las variables thisPin < 5”; esto quiere decir que solo utilizaremos el puerto 2,3 y 4
del Arduino, por último indicamos que aumentaremos en uno la variable con el
“thisPin++”.

for (int thisPin = 2; thisPin < 5; thisPin++) {

Declaramos la variable “thisPin” como salida.

pinMode(thisPin, OUTPUT);

En esta sección del código se ejecutará nuestro ciclo for, iniciamos en el puerto 2
del Arduino, concluyendo en el puerto 4. Mandamos una señal de encendido
“HIGH” la cual nos permitir encender uno a uno nuestros Leds.

for (int thisPin = 2; thisPin < 5; thisPin++) {

digitalWrite(thisPin, HIGH);
delay(timer);
digitalWrite(thisPin, LOW);

15
Por último, realizaremos la rutina en retroceso. Como puedes observar,
iniciamos ahora en el pin 4, concluyendo en el pin 2.

for (int thisPin = 4; thisPin >= 2; thisPin--) {

digitalWrite(thisPin, HIGH);
delay(timer);
digitalWrite(thisPin, LOW);

NOTA: ya que se usa el operador de incrementos, la variable será incrementada

al final del bucle; después de correrse el código dentro del mismo.

Para disminuir en 1 el valor de la expresión de inicio cada vez que se ejecutan

todas las instrucciones que hay dentro del bucle se utiliza “i–“.

¡Es tu turno! Realiza un programa en Arduino que permita prender tres leds de
forma secuencial en incremento con tiempo de espera de 2 segundos y
apagarlos de en decremento con un tiempo de espera de ½ segundo.

16
 Sentencia WHILE

El ciclo while en Arduino por su traducción en español “mientras” es un

bloque que implementa un ciclo de instrucciones dentro de las llaves { } un
numero infinito de veces hasta que la condición sea falsa, es decir: Mientras la
condición sea verdadera (true o 1) ejecuta las instrucciones dentro de las llaves.

Su sintaxis es la siguiente:

while (condición){// mientras la condición sea "true o 1"

// instrucción 1
// instrucción 2
// instrucción n
}

Bucle While en Arduino

Para poder comprender la estructura y funcionamiento del bucle while

realizaremos la siguiente actividad.

En el siguiente ejemplo se muestra el funcionamiento, como se puede observar en

el “Serial monitor” los primeros 10 mensajes dirán que el “resultado es menor a 10”.

Pero la variable va sumando uno cada vez que regresa el ciclo, por lo tanto, en
algún momento será igual a 10 o mayor y entonces ya no cumplirá la condición,
por lo que el mensaje cambiará a “El resultado es igual a 10”.

int variable=0; //La variable la inicializamos con 0

void setup() {
Serial.begin(9800); // iniciamos el serial monitor.
}
void loop() {
while(variable < 10){ //La condición se avalúa al principio.
Serial.println("Resultado es menor a 10");
variable=variable+1; // Lo que tenga la variable le sumamos uno y se lo asignamos a la
misma variable.
delay(1000); //Retardo de un segundo para observar lo que sucede.
}
Serial.println("El resultado es igual a 10"); //Cuando aparezca este resultado entrará en un
ciclo infinito.
}

17
Con ayuda de tu profesor realicen y ejecuten un programa en Arduino que te
permita realizar la siguiente rutina:

30cm

SI el sensor ultrasónico detecta SI el sensor ultrasónico No

un objeto a una distancia menor detecta objetos a una distancia
a 30cm, enciende un led. menor de 30cm, el led se apaga.

18
Lección IV. Servomotores

Un servomotor es un actuador rotativo o motor que

permite un control preciso en términos de posición
angular, aceleración y velocidad, capacidades que
un motor normal no tiene. Utiliza un motor normal y lo
combina con un sensor para la retroalimentación de
posición.

Partes de un servomotor

Carcaza

Engranes
Eje

Motor DC

Potenciometro

19
 Conexionado con Arduino

Todos los servomotores deben tener 3 cables. Uno irá a tierra (cable negro),
otro a la alimentación de 5 Voltios (cable rojo) y el tercero a un pin PWM (cable
verde).

Programación con Arduino

Ahora vamos a ir a lo interesante, la programación. Para ello tenemos que hacer

uso de una librería externa para poder controlar el servo desde Arduino. Para
incorporar la librería tenemos que ir a Programa/incluir librería/Servo.

20
La señal o dato que hay que enviarle al servo es una señal de PWM
donde el tiempo en alto es equivalente al ángulo o posición del
servo.
Estos valores pueden variar y van desde 0.5 a 1 milisegundo para la
posición 0° y 2 a 2.4 milisegundos para la posición de 180°, el
periodo de la señal debe ser cercano a 20 milisegundos.

Izquierda (0°)

Centro (90°)

Derecha (180°)

A continuación, se muestran las funciones de la librería Servo:

attach(Pin)

Establece el pin indicado en la variable servo. Ej: servo.attach(2);

attach(Pin,min,max)

Establece el pin indicado en la variable servo, considerando min el ancho de

pulso para la posición 0° y max el ancho de pulso para 180°.Ej:
servo.attach(2,900,2100);

write(angulo)

Envía la señal correspondiente al servo para que se ubique en el ángulo indicado,

ángulo es un valor entre 0 y 180°. Ej: servo.write(45);

writeMicroseconds(tiempo)

Envía al servo el ancho de pulso=tiempo en microsegundos. Ej:

servo.writeMicroseconds(1500);

21
read ()

Lee la posición actual del servo, devuelve un valor entre 0 y 180.

Ej: angulo=read () ;

attached(Pin)

Verifica si la variable servo está unido al pin indicado, devuelve true o false. Ej:
if(attached(2))

detach(pin)

Separa la variable Servo del pin indicado. Ej: servo. detach(2);

¡Ahora, realicemos un ejercicio!

A continuación, se muestran una imagen con tres servomotores, cada uno en

diferente posición; el objetivo es realizar la programación que nos permita
desplazar a nuestro servomotor a la posición 0°, 90° y 180°.

0° 90° 180°

#include <Servo.h> Incluimos la librería para poder controlar el servo

Servo servoMotor; Declaramos la variable para controlar el servo
void setup() { Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600); Incluimos la librería para poder controlar el servo
servoMotor.attach(9); Iniciamos el servo para que empiece a trabajar
} con el pin 9

void loop() {
servoMotor.write(0); Desplazamos el servomotor a la posición 0º
delay(1000); Esperamos 1 segundo
servoMotor.write(90); Desplazamos el servomotor a la posición 90º
delay(1000); Esperamos 1 segundo
servoMotor.write(180); Desplazamos el servomotor a la posición 180º
delay(1000); Esperamos 1 segundo
}
22
 ¡Ayuda a Otto!

Otto quiere comenzar a bailar, pero necesita de tu apoyo para

lograrlo. Realiza un programa que permita mover sus dos patas, las
cuales son accionadas mediante servomotores.

Tu código deberá realizar lo siguiente:

El primer servomotor El primero servomotor El segundo servomotor

deberá avanzar 110° regresa a 0° deberá avanzar 110°

23
Lección V. Sensor ultrasónico

Los sensores de ultrasonidos son detectores de proximidad que

trabajan libres de roces mecánicos y que detectan objetos a
distancias que van desde pocos centímetros hasta varios metros.

El sensor emite un sonido y mide el tiempo

que la señal tarda en regresar. Estos reflejan
en un objeto, el sensor recibe el eco
producido y lo convierte en señales
eléctricas, las cuales son elaboradas en el
aparato de valoración. Estos sensores
trabajan solamente en el aire, y pueden Tiempo = 2* (Distancia/Velocidad)
detectar objetos con diferentes formas,
colores, superficies y de diferentes Distancia = Tiempo * Velocidad/2
materiales.

Datasheet del sensor

24
Conexionado con Arduino

Programación con Arduino

Para la realización de este código desglosaremos paso a paso su

programación, explicando cada una de las instrucciones; presta mucha
atención.

Primero configuramos los pines del sensor ultrasónico

const int Trigger = 2; Pin digital 2 para el Trigger del sensor

const int Echo = 3; Pin digital 3 para el echo del sensor

void setup() {

Serial.begin(9600); Inicializamos la comunicación

pinMode(Trigger, OUTPUT); Declaramos a Trigger como pin de salida

pinMode(Echo, INPUT); Declaramos a Echo como pin de entrada

digitalWrite(Trigger, LOW); Inicializamos el pin con 0

Ahora en el bucle void loop() empezamos enviando un pulso de 10us al Trigger

del sensor

digitalWrite(Trigger, HIGH); Mandamos un 1(activamos) al Trigger

delayMicroseconds(10); Enviamos un pulso de 10us

digitalWrite(Trigger, LOW); Mandamos un 0(desactivamos) al Trigger

25
 Seguidamente recibimos el pulso de respuesta del sensor por el pin
Echo, para medir el pulso usamos la función pulseIn(pin, value)

t = pulseIn(Echo, HIGH); obtenemos el ancho del pulso

La variable t, tiene el tiempo que dura en llegar el eco del ultrasonido, el

siguiente paso es calcular la distancia entre el sensor ultrasónico y el objeto

Partimos de la siguiente formula:

𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 𝑟𝑒𝑐𝑜𝑟𝑟𝑖𝑑𝑎
𝑉𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑 =
𝑇𝑖𝑒𝑚𝑝𝑜

Donde Velocidad es la velocidad del sonido 340m/s, pero usaremos las

unidades en cm/us pues trabajaremos en centímetros y microsegundos, tiempo
es el tiempo que demora en llegar el ultrasonido al objeto y regresar al sensor, y
la distancia recorrida es dos veces la distancia hacia el objeto, reemplazando
en la formula tenemos:
340𝑚 1𝑠 100𝑐𝑚 2𝑑
𝑥 𝑥 =
𝑠 1000000𝑢𝑠 1𝑚 𝑡
𝑡(𝑢𝑠)
𝑑(𝑐𝑚) =
59
Finalmente enviamos serialmente el valor de la distancia y terminamos
poniendo una pausa de 100ms, que es superior a los 60ms recomendado por
los datos técnicos del sensor

A continuación, se muestra el código completo del programa.

const int Trigger = 2; //Pin digital 2 para el Trigger del sensor

const int Echo = 3; //Pin digital 3 para el Echo del sensor

void setup() {
Serial.begin(9600);//iniciailzamos la comunicación
pinMode(Trigger, OUTPUT); //pin como salida
pinMode(Echo, INPUT); //pin como entrada
digitalWrite(Trigger, LOW);//Inicializamos el pin con 0
}

void loop()
{

long t; //timepo que demora en llegar el eco

long d; //distancia en centimetros

digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);

t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso

d = t/59; //escalamos el tiempo a una distancia en cm

26
 Serial.print("Distancia: ");
Serial.print(d); //Enviamos serialmente el valor de la distancia
Serial.print("cm");
Serial.println();
delay(100); //Hacemos una pausa de 100ms
}

Realiza un programa en Arduino que nos permita ejecutar la siguiente rutina:

A) Si el sensor ultrasónico detecta una distancia de 20cm o menor deberá

encender el Led
B) Si el sensor ultrasónico detecta una distancia mayor a 20 cm deberá
apagarse el Led.

27
Lección VI. ¡Armemos a Otto!

28
A continuación, se muestran los pasos para la construcción del robot Otto.
Sigue cada instrucción, prestando especial atención en la correcta colocación
de los objetos apoyándote en las imágenes. Todos los materiales vienen incluidos
en tu Kit.

1. Colocación de los servomotores en la base del robot. Deberás ejercer

una pequeña presión para que lo motores queden bien sujetos en los
orificios. No se recomienda utilizar pegamentos para la adherencia de
los servomotores.

29
2. Una vez colocados los servomotores, debemos insertar los
tornillos incluidos en el kit. Tener cuidado en la elección
correcta del tornillo, no debemos forzar demasiado
porque podemos barrer la cabeza del tornillo.

30
3. Cortamos dos hélices incluidas en los servomotores, de tal
forma que queden justas para poder colocarlas en las uniones.
Para un corte más sencillo, apóyate en la imagen que te
mostramos a continuación, guiándote en los orificios de la
hélice.

31
4. Colocamos las uniones en la base, metiendo la hélice en el eje
del servomotor. Una vez colocadas las uniones, corroborar que
giren 180 grados de forma suave, serán las encargadas de dar
movimiento a piernas y patas del humanoide.

32
5. Colocamos los tornillos pequeños entre la unión de las hélices
del servomotor y las uniones, recuerda no apretar demasiado
para evitar barrer el tornillo.

33
6. Cortamos un extremo de ambas hélices, apóyate en la imagen
para hacer el corte exacto.
Posteriormente, las colocamos sobre el eje del motor y
revisamos que tenga la libertad de girar 180°.

34
7. Colocamos los servomotores en las patas del robot,
ambas patas son iguales. Cerciórate que el orificio de unión
entre el motor y la hélice quede sobre el orificio lateral de la
pata del robot.

35
8. Colocamos los tornillos entre la unión de las hélices del
servomotor y las patas del robot, recuerda no apretar
demasiado para evitar barrer el tornillo y cerciorarte que la
pata haya quedado bien fija en el servomotor.

36
9-10. Es momento de colocar las patas en las uniones, para
ello atraviesa el cable del servomotor por uno de los orificios de
la base, lo utilizaremos más adelante en las conexiones
eléctricas.

37
11. Sacamos ambos cables de los servomotores por la parte
superior de la base.

38
12. Atornillamos las patas del robot a la base utilizando los
tornillos grandes incluidos en el kit.

39
13. Con mucho cuidado, colocamos nuestro Arduino nano
en los pines del Shield, evitar doblar alguna pata del Arduino.

40
12. Colocamos los servomotores a las uniones de los brazos
del robot. Observa detenidamente la imagen, el eje del motor
debe ir de frente.

41
15. Con un poco de cinta, pegamos nuestro sensor
ultrasónico, Buzzer y sensor de tacto a la base del robot,
colocando jumpers hembra-hembra en sus pines.

42
16. Esquema de conexiones para sensores y servomotores a
la placa de expansión de Arduino

43
17. Colocación de tornillos en la cabeza del robot

44
18. Colocamos nuestro panel led de 8x8 en la parte frontal
de la base del robot, nuestra base es blanca para que la luz
del panel se vea reflejado en nuestro robot. Recuerda sujetarlo
con un pequeño trozo de cinta adhesiva y no usar
pegamentos para adherirlo.

45
19. Colocamos nuestra porta baterías con interruptor en la
base del robot, tal como se muestra en la imagen. Nuestra
porta batería cuenta con cuatro espacios para pilas del tipo
AA de 1.5 V, por tal motivo nuestro robot será alimentado con
6V.

46
20. Colocamos la hélice simple del servomotor en las
uniones de los brazos ubicados en nuestra base.

47
21. Atornillamos nuestras hélices a las uniones de la base.

48
22. Alimentación de la Shield de Arduino con la porta
baterías de pilas AA

49
23. Colocamos el Buzzer del Arduino en la base, observa
que tiene un pequeño orificio; en ocasiones los componentes
electrónicos varían sus dimensiones, en caso de que el Buzzer
quede un poco flojo puedes fijarlo con un poco de cinta
adhesiva,

50
24. Metemos nuestra porta batería a la base del robot a un
costado.

51
25. Colocamos las uniones de los brazos del robot a la base,
enroscando el tornillo colocado con anterioridad.

52
26. Diagrama de conexión de servomotores y sensores a la
placa de expansión de Arduino

53
26. Por último, colocamos la cabeza del robot sobre la base,
observa que cuenta con dos pequeñas uniones laterales para
unirlas sin necesidad de tornillo o pegamento,

54
28. ¡Es momento de programar tu robot Otto y divertirte!

55
Lección VII. Interactuando con Otto

A continuación, explicaremos la forma de programar nuestro

robot, para ello existen 3 formas diferentes:

En lecciones anteriores trabajamos en la programación con Arduino,

ahora utilizaremos el programa Otto Blockly.
Para descargar el programa accedemos al siguiente enlace:
https://github.com/OttoDIY/blockly/releases. Es un programa
gratuito disponibles para sistemas operativos Windows y Mac OS.

Nuestro robot puede ser controlado mediante bluetooth de forma

instantánea o programarlo para hacer un Otto autónomo, a
continuación, te explicamos las diferencias

56
Interfaz de Otto Blockly

Prueba de inicio rápido

57
58
59
60
Lección VIII. ¿Otto puede hablar?

61
 Buzzer en Arduino

Técnicamente tanto buzzers como altavoces son transductores electroacústicos,

es decir, dispositivos que convierten señales eléctricas en sonido. La diferencia
entre ambos es el fenómeno en el que basan su funcionamiento.

Los buzzer son transductores piezoeléctricos. Los materiales piezoeléctricos tienen

la propiedad especial de variar su volumen al ser atravesados por corrientes
eléctricas.

Un buzzer aprovecha este fenómeno para hacer vibrar una membrana al

atravesar el material piezoeléctrico con una señal eléctrica.

Los buzzer son dispositivos pequeños y compactos, con alta durabilidad, y bajo
consumo eléctrico. Por contra, la calidad de sonido es reducida.

Programación en Arduino

Arduino dispone de dos funciones que nos permiten generar fácilmente señales
eléctricas para convertir en sonido, usando cualquiera de las salidas digitales
disponibles.

Estas funciones son tone() y noTone() y, como su nombre indican, permiten

generar o detener la señal del tono en un pin

62
tone(pin, frecuencia); //activa un tono de frecuencia determinada
en un pin dado
noTone(pin); //detiene el tono en el pin

La función tone() también permite especificar la duración del sonido generado.

tone(pin, frequencia, duracion); //activa un tono de frecuencia y duración

determinados en un pin dado

Pese a su sencillez, al usar las funciones para la generación de tone tenemos que
asumir importantes limitaciones.

• La función Tone emplea el Timer 2, por lo que mientras esté funcionando no

podremos usar las salidas PWM en los pines 3 y 11 en Arduino Nano y Uno
(pines 9 y 10 en Arduino Mega).
• No podemos usar la función tone() en dos pines de forma simultánea.
Deberemos apagar el tono con la función noTone() antes de poder usarlo
en otro pin.
• Los rangos de la función tone son de 31 Hz a 65535 Hz.

El siguiente código muestra el uso de estas funciones estas funciones en un

ejemplo simple, en el que empleamos el buzzer o altavoz conectado en el Pin9
para generar una función de 440Hz durante un segundo, pararlo durante 500ms, y
finalmente un tono de 523Hz durante 300ms, para repetir el programa tras una
pausa de 500ms

const int pinBuzzer = 9;

void setup()
{
}
void loop()
{
//generar tono de 440Hz durante 1000 ms
tone(pinBuzzer, 440);
delay(1000);
//detener tono durante 500ms
noTone(pinBuzzer);
delay(500);
//generar tono de 523Hz durante 500ms, y detenerlo durante 500ms.
tone(pinBuzzer, 523, 300);
delay(500);
}

63
Con ayuda de su profesor, realicen un programa en Arduino y Otto Blockly que
permita reproducir al robot un sonido cuando detecte un objeto cercano.

64
Lección IX. Las emociones
de Otto
Nuestro robot Otto puede realizar diferentes gestos gracias a la
matriz led incorporada en su parte frontal.

Como puedes observar,

mediante la aplicación de Otto
Blockly podemos colocar
diferentes gestos a nuestro
panel led, por ello nuestro
cuerpo del robot es de color
blanco.

65
Mediante la aplicación de Otto Blockly programa a tu robot, haz que
reproduzca tres gestos diferentes. Tómale una fotografía a cada uno de ellos y
pégalos a continuación.

66
Lección X. Módulo Bluetooth

El Módulo Bluetooth HC-06 tiene dos estados de funcionamiento los cuales

es importante conocer:

Modo AT (Desconectado):

- Entra a este modo tan pronto alimentamos el módulo, y cuando no se ha

establecido una conexión bluetooth con ningún otro dispositivo.

- EL LED del módulo está parpadeando (frecuencia de parpadeo del LED es

de 102ms).

- En este modo es cuando se debe enviar los comandos AT en caso se quiera

configurar algún parámetro, si se envían otros datos diferentes a los comandos
AT, el HC-06 los ignorará.

Modo Conectado:

- Entra a este modo cunado se establece una conexión con otro dispositivo
bluetooth.

- El LED permanece encendido sin parpadear.

- Todos los datos que se ingresen al HC-06 por el Pin RX se trasmiten por
bluetooth al dispositivo conectado, y los datos recibidos se devuelven por el
pin TX. La comunicación es transparente para el programador.

- En este Modo el HC-06 no puede interpretar los comandos AT.

Conexión entre la PC y el módulo Bluetooth

Entendido lo anterior, veamos las conexiones para configurar el HC-06.

Se puede hacer un programa o "sketch" en Arduino que haga toda la

configuración, pero nosotros lo haremos manualmente desde la PC, esto lo
podemos hacer de la siguiente forma:

Hacer la comunicación entre la PC y el módulo de forma indirecta a través de

un Arduino:

Monitor serial Módulo

del IDE Arduino Placa Arduino Bluetooth
(PC) UNO/NANO HC-06

67
Las conexiones serían las siguientes:

Ahora es necesario compilar y cargar el siguiente sketch que hemos preparado,

que como vemos lee el Monitor Serial de nuestro IDE y se lo envía serialmente
hacia los pines RXD y TXD de nuestro módulo HC-06.

#include <SoftwareSerial.h> // Incluimos la librería SoftwareSerial

SoftwareSerial BT(10,11); // Definimos los pines RX y TX del Arduino conectados
al Bluetooth

void setup()
{
BT.begin(9600); // Inicializamos el puerto serie BT que hemos creado
Serial.begin(9600); // Inicializamos el puerto serie
}

void loop()
{
if(BT.available()) // Si llega un dato por el puerto BT se envía al monitor
serial
{
Serial.write(BT.read());
}

if(Serial.available()) // Si llega un dato por el monitor serial se envía al

puerto BT
{
BT.write(Serial.read());
}
}

68
Configurando nuestro Módulo HC-06:

En nuestro ejemplo usaremos un conversor USB serial PL2303 que se ha

instalado en nuestra PC como puerto serial "COM5", por lo que antes de
abrir el Monitor serial en el IDE Arduino debemos escoger dicho puerto.

Es bueno recordar que para enviar los comandos AT, nuestro HC-06 debe estar en
Modo AT, esto significa sin conexión bluetooth con otro dispositivo o verificar que
LED del HC-06 esté parpadeando.

Una vez hecho las configuraciones y conexión correspondientes, abrimos el

Monitor serial del IDE de Arduino, también podemos usar cualquier otro monitor
serial como: Termite.

En la parte inferior del monitor debemos escoger “No hay fin de línea” y la
velocidad “9600 baudios” (la velocidad por defecto de nuestro HC-06, si se lo ha
cambiado poner la velocidad correspondiente)

Realizado lo anterior, podemos ahora enviar los comandos AT a nuestro Bluetooth:

Test de comunicación:

Lo primero es comprobar si nuestro bluetooth responde a los comandos AT

✓ Enviar: AT
✓ Recibe: OK

Si recibimos como respuesta un OK entonces podemos continuar, sino verificar las

conexiones o los pasos anteriores.

69
Cambiar nombre de nuestro módulo HC-06:

Por defecto nuestro módulo bluetooth se llama “HC-06” o “Linvor” esto

se puede cambiar con el siguiente comando AT

Enviar: AT+NAME<Nombre> Ejm: AT+NAMERobot

Respuesta: OKsetname

El nombre puede ser de hasta 20 caracteres como máximo

Cambiar Código de Vinculación:

Por defecto viene con el código de vinculación (Pin) “1234”, para cambiarlo hay
que enviar el siguiente comando AT

Enviar: AT+PIN<Pin> Ejm: AT+PIN1465

Respuesta: OKsetPIN

Control de robot mediante bluetooth

Para controlar el Robot usaremos una aplicación en nuestro

celular, para esto debemos de instalar en nuestro celular la
siguiente aplicación.

Naylamp Car

La aplicación consta de 4 botones una para cada

dirección, al presionar el botón para mover adelante, la
aplicación envía por Bluetooth el carácter ‘a’ y lo sigue
enviando constantemente mientras se tenga presionado.
De igual manera para los otros botones, la aplicación envía
‘r’ para retroceso, ‘i’ para izquierda y ‘d’ para mover a la
derecha.

Nuestro Arduino debe de leer estos 4 caracteres y realizar

el movimiento, además al no tener un botón stop, nuestro
Arduino deberá detener de forma automática los
movimientos cuando no se tenga presionado ningún
botón.

70
Antes de cargar el programa a nuestro Arduino debemos de
desconectar los cables de nuestro Bluetooth y después de terminado la
carga podemos volverlo a conectarlo.

El código que debemos de cargar a nuestro Arduino es el siguiente:

//Pines de conexión del driver
int Pin_Motor_Der_A = 8;
int Pin_Motor_Der_B = 9;
int Pin_Motor_Izq_A = 10;
int Pin_Motor_Izq_B = 11;

int tiempo=0;
void setup() {
// inicializar la comunicación serial a 9600 bits por segundo:
Serial.begin(9600);
// configuramos los pines como salida
pinMode(Pin_Motor_Der_A, OUTPUT);
pinMode(Pin_Motor_Der_B, OUTPUT);
pinMode(Pin_Motor_Izq_A, OUTPUT);
pinMode(Pin_Motor_Izq_B, OUTPUT);

void loop() {

if (Serial.available()) {
char dato= Serial.read();
if(dato=='a')
{
Mover_Adelante();
tiempo=0;
}
else if(dato=='r')
{
Mover_Retroceso();
tiempo=0;
}
else if(dato=='d')
{
Mover_Derecha();
tiempo=0;
}
else if(dato=='i')
{
Mover_Izquierda();
tiempo=0;
}

if(tiempo<200) // 100 cilcos de 1ms

{
tiempo=tiempo+1;
}
else //ya transcurrió 100ms (100ciclos)
{

71
 Mover_Stop();
}

delay(1); //pasusa de 1ms por ciclo

void Mover_Adelante()
{
digitalWrite (Pin_Motor_Der_A, HIGH);
digitalWrite (Pin_Motor_Der_B, LOW);
digitalWrite (Pin_Motor_Izq_A, HIGH);
digitalWrite (Pin_Motor_Izq_B, LOW);
}
void Mover_Retroceso()
{
digitalWrite (Pin_Motor_Der_A,LOW );
digitalWrite (Pin_Motor_Der_B,HIGH );
digitalWrite (Pin_Motor_Izq_A,LOW );
digitalWrite (Pin_Motor_Izq_B,HIGH );
}
void Mover_Derecha()
{
digitalWrite (Pin_Motor_Der_A,LOW );
digitalWrite (Pin_Motor_Der_B,HIGH );
digitalWrite (Pin_Motor_Izq_A,HIGH);
digitalWrite (Pin_Motor_Izq_B,LOW);
}
void Mover_Izquierda()
{
digitalWrite (Pin_Motor_Der_A,HIGH);
digitalWrite (Pin_Motor_Der_B,LOW);
digitalWrite (Pin_Motor_Izq_A,LOW );
digitalWrite (Pin_Motor_Izq_B,HIGH );
}
void Mover_Stop()
{
digitalWrite (Pin_Motor_Der_A, LOW);
digitalWrite (Pin_Motor_Der_B, LOW);
digitalWrite (Pin_Motor_Izq_A, LOW);
digitalWrite (Pin_Motor_Izq_B, LOW);

Como se observa al código del primer ejemplo solo le hemos agregado la parte
de la comunicación serial, en donde leemos el dato y comparamos para ver si es
el carácter correspondiente para realizar su respectivo movimiento,
adicionalmente si durante 100 milisegundos no llega ningún dato detenemos el
robot, y tan pronto le llega uno de los datos reiniciamos la cuenta de los 100ms.

Una vez que tengan todo listo, tan solo hay que abrir la App, conectarnos a
nuestro modulo Bluetooth y empezar a mover nuestro robot con los botones.

72
Lección XI. Minisumo

Las Categorías Minisumo consisten en una

lucha entre dos robots
autónomos/radiocontrolados que se
realiza sobre un área de combate
(también denominada Ring o Dhoyo) y
que consiste en lograr que el robot
oponente se salga del área de combate.

¡Es momento de que programes tu propio robot Minisumo y compitas con tus
compañeros!

Nuestro robot constará de:

• Sensor ultrasónico: Será el encargado de detectar al rival y atacarlo,

con el objetivo de sacarlo del área de combate.
• Dos motorreductores: Darán movimiento a nuestro robot, en las
siguientes sesiones aprenderás a controlar el giro y potencia,
• Módulo Bluetooth: Nos permitirá controlar el robot a distancia mediante
la Tablet o celular.
• Tarjeta Arduino: Será el cerebro del robot, en ella programaremos las
instrucciones de nuestro Minisumo.

A continuación, trabajaremos con cada elemento.

Conexiones de la placa de control

1. Conexión a motorreductores
2. Drivers para el control de motores
3. Placa Arduino nano
4. Conexión a módulo Bluetooth
5. Interruptor de encendido/apagado
6. Conexión de batería para alimentación de placa
7. Conexión a entrada analógicas y digitales del Arduino

73
 3
2 4
1

7
5 6

Sensor ultrasónico

Como mencionamos con anterioridad, el principal objetivo de nuestro robot será

detectar al rival e intentar desplazarlo fuera del área de combate (dohyo) y para
ello utilizaremos nuestro sensor ultrasónico.

Imaginemos lo siguiente:

Nos toca combatir con un amigo, ambos robots

inician en contornos opuestos del dohyo, de
frente, tal como se muestra en la imagen ¿Qué
acción programarías en tu robot para desplazar
al rival fuera del área de combate? ___________
_______________________________________________

74
Como puedes observar, dentro de esta categoría nos podemos
encontrar con un sinfín de programaciones diferentes, el analizar
diferentes conclusiones se vuelve fundamental, veamos otro ejemplo:

En esta ocasión a nuestro rival y a nosotros nos

toca iniciar en la parte central del dohyo, de
espaldas ¿Qué acción programarías en tu robot
para desplazar al rival fuera del área de
combate? ____________________________________
_______________________________________________

¿Utilizarías una programación diferente con

respecto al anterior caso? __________________

Esta categoría de la robótica de competencia es una de las más divertidas,

deberás pensar rápido como programar a tu robot y tener una mejor estrategia
que el rival.

Nuestro sensor ultrasónico deberá ser colocado

en la parte frontal del robot. ¿Colocarías el
sensor en alguna otra posición? _______________
_______________________________________________

En esta categoría no
contamos con un límite
de sensores, ¿Colocarías
más sensores a tu robot?
__________________

¿En qué posición?

_________________________
_________________________

75
 Control de motores

Para tener un control completo sobre el motor de corriente continua, tenemos

que controlar su velocidad y dirección de rotación. Esto puede lograrse
combinando estas dos técnicas:

• PWM – Para controlar la velocidad

• H-Bridge – Para controlar la dirección de rotación

PWM, para controlar velocidad

La velocidad de un motor de corriente continua puede ser controlada variando

su voltaje de entrada. Una técnica común para hacer esto es usar PWM
(Modulación de Ancho de Pulso)

• PWM es una técnica en la que el valor medio del voltaje de entrada se

ajusta enviando una serie de pulsos ON-OFF.
• El voltaje promedio es proporcional al ancho de los pulsos conocido como
Ciclo de Trabajo o Duty Cycle.
• Cuanto mayor sea el ciclo de trabajo, mayor será el promedio de voltaje
que se aplica al motor de CC (alta velocidad) y menor será el ciclo de
trabajo, menor será el promedio de voltaje que se aplica al motor de CC
(baja velocidad).

La siguiente imagen ilustra la técnica PWM con varios ciclos de trabajo y voltajes
medios.

76
 H-Bridge, Para controlar la dirección de rotación

La dirección de giro del motor de corriente continua puede ser

controlada cambiando la polaridad de su voltaje de entrada. Una técnica
común para hacer esto es usar un Puente H.

• Un circuito de Puente-H contiene cuatro interruptores con el motor en el

centro formando una disposición similar a la del Puente-H.
• Cerrar dos interruptores particulares al mismo tiempo invierte la polaridad
del voltaje aplicado al motor. Esto causa un cambio en la dirección de giro
del motor.

La siguiente imagen ilustra el funcionamiento del circuito H-Bridge.

Código de Arduino para controlar un motor de corriente continua

El siguiente código te dará una completa comprensión de cómo controlar la

velocidad y la dirección de giro de un motor de corriente continua con motor IC
L293D y puede servir como base para experimentos y proyectos más prácticos. El
código de arduino es bastante sencillo. No requiere ninguna biblioteca para que
funcione.

El código comienza declarando los pines de Arduino a los que están conectados
los pines de control de L293D.

// Motor A conexiones
int enA = 9;
int in1 = 8;
int in2 = 7;
// Motor B conexiones
int enB = 3;
int in3 = 5;

77
int in4 = 4;

En la sección de configuración del código, todos los pines de control del

motor se declaran como OUTPUT digital y se marcan LOW para apagar
ambos motores.

void setup() {
// Set all the motor control pins to outputs
pinMode(enA, OUTPUT);
pinMode(enB, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);

// Turn off motors - Initial state

digitalWrite(in1, LOW);
digitalWrite(in2, LOW);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);
}

En la sección de bucle del código llamamos a dos funciones definidas por el

usuario en un intervalo de un segundo.

void loop() {
directionControl();
delay(1000);
speedControl();
delay(1000);
}

Estas funciones son:

directionControl() – Esta función hace girar ambos motores hacia adelante a

máxima velocidad durante dos segundos. Luego invierte el sentido de giro del
motor y gira durante otros dos segundos. Finalmente apaga los motores.

void directionControl() {
// Set motors to maximum speed
// For PWM maximum possible values are 0 to 255
analogWrite(enA, 255);
analogWrite(enB, 255);
// Turn on motor A & B
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
digitalWrite(in3, HIGH);

78
digitalWrite(in4, LOW);
delay(2000);
// Now change motor directions
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
delay(2000);
// Turn off motors
digitalWrite(in1, LOW);
digitalWrite(in2, LOW);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);
}

speedControl(): Esta función acelera los dos motores desde cero hasta la
velocidad máxima produciendo señales PWM mediante la función analogWrite(),
y luego los desacelera de vuelta a cero. Finalmente, apaga los motores.

void speedControl() {
// Turn on motors
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
// Accelerate from zero to maximum speed
for (int i = 0; i < 256; i++) {
analogWrite(enA, i);
analogWrite(enB, i);
delay(20);
}
// Decelerate from maximum speed to zero
for (int i = 255; i >= 0; --i) {
analogWrite(enA, i);
analogWrite(enB, i);
delay(20);
}
// Now turn off motors
digitalWrite(in1, LOW);
digitalWrite(in2, LOW);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);
}

79
 Compendio de temas y actividades

Semana(s) Lección Temas Módulos

Introducción al
1 Conocer los componentes del kit 3
curso
Descargar el programa de Arduino
IDE para Windows/Mac OS
Introducción a Conocer los componentes de la
2-3 6
Arduino pantalla principal
Estructura de programa en Arduino

Actividades:
I. Semáforo con Leds programado en Arduino
Variables y constantes
Operadores Aritméticos
Tipo de datos y
4-6 Operadores de comparación 9
operadores
Operadores booleanos

Actividades:
II. Compilación y ejecución de programas mediante el Port View del Arduino.
Sentencia IF
Sentencia IF ELSE
Sentencias
7-12 Sentencia FOR 18
condicionales
sentencia WHILE

Actividades:
III. Programación de rutinas con un interruptor mediante la sentencia IF ELSE
IV. Encendido de leds por tuinas ascendente y descendente mediante la
sentencia FOR en Arduino
V. Detección de objetos y toma de decisiones con el sensor ultrasónico y la
sentencia While
Partes de un servomotor
Conexión de servomotores y
Arduino
Control de
13-15 Biblioteca servo.h 6
servomotores
Control de un servomotor mediante
grados y módulo de ancho de pulso
(PWM)
Actividades
VI. Movimiento de las articulaciones de Otto mediante servomotores
PROYECTO: “OTTO BAILA”. Programación de
16-17 6
coreografías de canciones navideñas con Otto.

80
Semana(s) Lección Temas Módulos
Datasheet del sensor
El sensor Conexionado con Arduino
18-19 6
ultrasónico Programación con Arduino

Actividades:
VII. Detección de objetos y distancias mediante el sensor ultrasónico
PROYECTO: “Mi robot autónomo” Otto toma decisión
20 mediante las señales obtenidas del sensor 3
ultrasónico.
Descargar del software de Oto
Blockly
Interactuando Interfaz del programa
21-22 con Otto Carga y depuración de programas 6
Blockly al robot

Actividades:
VIII. Acciones en actuadores y sensores a Otto
Funcionamiento de un Buzzer
Conexionado con Arduino
¿Otto puede Bloques de sonido predefinidos en
23-24 6
hablar? Otto Blockly
Programación del Buzzer en entorno
IDE de Arduino
Actividades:
IX. Reproducción de sonidos predefinidos en Otto
X. Reproducción de sonidos como respuesta al censado de objetos mediante el
sensor ultrasónico.
Funcionamiento de una matriz led
8*8
Creación de gestos predefinidos
Las emociones mediante la aplicación Otto Blockly
25-27 9
de otto Conexionado de la matriz con
Arduino
Programación mediante Arduino IDE

Actividades
XI. Creación de expresiones mediante la matriz Led
PROYECTO: “OTTO se expresa”. Simulación de
28 3
movimientos, expresiones y sonidos con Otto.
Estados de funcionamiento
Módulo Conexión entre PC y módulo
29-31 9
Bluetooth Bluetooth
Configuración de nombre y código

81
 de vinculación
Control de otto mediante
aplicaciones móviles
Actividades:
XI. Programación de botones para el control de otto mediante aplicaciones
móviles
Sensor ultrasónico
Control de motores mediante el
driver l293D
Robot Programación de rutinas mediante
32-40 27
Minisumo sentencias de control y sensores
Uso de aplicaciones móviles para el
control inalámbrico del robot

82