1

Robótica. Conectando con el mundo físico
Guía didáctica del módulo 1
1
Robótica. Conectando con
el mundo físico

2
Índice
¿Cómo funciona esta guía?................................................................................ 6
1. Computación física........................................................................................ 7
1.1. Definición................................................................................................ 7
1.2 Breve historia........................................................................................... 7
1.3. Desarrollo en el campo educativo .......................................................... 9
1.4. Tipos de herramientas............................................................................ 9
1.5. Campos relacionados........................................................................... 10
2. Sensores ...................................................................................................... 10
2.1. Definición.............................................................................................. 10
2.2 ¿Qué miden los sensores?..................................................................... 11
2.3. Tipos de sensores................................................................................. 11
2.4. Sensores en el mundo digital ............................................................... 12
2.5. Aspectos a tener en cuenta.................................................................. 13
3. Actuadores................................................................................................... 14
3.1. Definición: ¿Qué son los actuadores?................................................... 14
3.2. Ejemplos de actuadores ....................................................................... 14
3.4. Actuadores en el mundo digital............................................................ 16
4. Arduino......................................................................................................... 17
4.1. ¿Qué es Arduino?.................................................................................. 17
4.2. La placa Arduino UNO........................................................................... 17
4.3. ¿Qué se puede hacer con Arduino? ...................................................... 18
4.4. El bootloader y la vida de tu programa................................................. 19
4.5. Funcionamiento con baterías............................................................... 19
5. IDE................................................................................................................ 19
5.1. ¿Qué es un IDE? .................................................................................... 19

3
5.2. El IDE de Arduino .................................................................................. 20
5.3. La barra de tareas................................................................................. 20
5.4. El sketchbook y las preferencias .......................................................... 21
5.5. ¿Qué no se puede hacer con el IDE?..................................................... 22
6. Verificar y cargar.......................................................................................... 23
6.1. Definición: ¿Qué es verificar y cargar?.................................................. 23
6.2. Ejemplo de programa: BLINK................................................................ 24
6.3. Estructura de un programa: setup() y loop()......................................... 25
6.4. Nuevos comandos: pinMode, digitalWrite, delay.................................. 26
6.5. Instalación de drivers............................................................................ 26
7. Generación de sonido .................................................................................. 27
7.1. ¿Sonido con microcontroladores?........................................................ 27
7.2. Ejemplo de programa: BEEP................................................................. 27
7.3. Tocar tonos, notas y melodías ............................................................. 29
7.4. Pestañas en el IDE, definición de constantes....................................... 29
7.5. Otros métodos para tocar sonido......................................................... 31
8. Variables y melodías.................................................................................... 31
8.1. ¿Qué es una variable?........................................................................... 31
8.2. Ejemplos de variables........................................................................... 32
8.3. Arrays.................................................................................................... 32
8.4. Toca una melodía ................................................................................. 33
8.5. Repaso de funciones de programación: bucle for................................ 33
9. Entrada digital.............................................................................................. 34
9.1. ¿Qué es una entrada digital?................................................................. 34
9.2. La entrada digital más sencilla............................................................. 34
9.3. Ejemplo con Arduino............................................................................. 34
9.4. Nuevo comando: digitalRead() ............................................................. 35
10. Entrada analógica...................................................................................... 35
10.1. ¿Qué es una entrada analógica?......................................................... 35

4
10.2. El sensor más sencillo: el potenciómetro........................................... 36
10.3. Ejemplo con Arduino........................................................................... 36
10.4. Nuevo comando: analogRead() .......................................................... 37
10.5. Aspectos a tener en cuenta................................................................ 37
11. Puerto serie básico .................................................................................... 37
11.1. ¿Qué es el puerto serie?...................................................................... 37
11.2. Envía desde Arduino ........................................................................... 38
11.3. Nuevos comandos.............................................................................. 39
11.4. Recibe en Arduino............................................................................... 39
11.5. Nuevos comandos (2) ........................................................................ 40
12. Uso en el aula............................................................................................. 40
12.1. Qué es Arduino ................................................................................... 41
12.1.1. Introducción a Arduino ............................................................... 41
12.1.2. La placa y que se puede hacer ................................................... 41
12.1.3. El IDE y como se usa .................................................................. 42
12.2. Salidas digitales.................................................................................. 42
12.2.1. Primer ejemplo: BLINK................................................................ 43
12.2.2. Explica los ledes brevemente ..................................................... 43
12.2.3. Explica las resistencias brevemente .......................................... 44
12.2.4. Explica la protoboard brevemente.............................................. 44
12.2.5. Monta tu propio led .................................................................... 45
12.2.6. Simula el pulso cardiaco............................................................. 45
12.2.7. Monta dos ledes ......................................................................... 46
12.3. Entradas digitales............................................................................... 46
12.3.1. El ejemplo del cable.................................................................... 47
12.3.2. Monta el botón en la protoboard................................................ 47
12.3.3. Explica las variables ................................................................... 48
12.3.4. Recuerda las estructuras condicionales “IF…THEN” .................. 49
12.4. Entradas analógicas ........................................................................... 50
12.4.1. El primer sensor: potenciómetro ................................................ 50

5
12.4.2. LDR: midiendo la cantidad de luz ............................................... 51
12.5. Introducción al puerto serie................................................................ 51
12.5.1. Envía datos sencillos: “hola caracola” ........................................ 51
12.5.2. Envía los valores del potenciómetro........................................... 52
12.5.3. Recibe en Arduino: “physical pixel”............................................. 52
12.6. Tocando sonidos ................................................................................ 53
12.6.1. Explica brevemente el piezo eléctrico ........................................ 53
12.6.2. BEEP: conecta el piezo al programa BLINK................................ 53
12.6.3. Usa “tone” para tocar melodías .................................................. 54
12.6.4. Refresca el uso de “FOR(init; end; increment)”........................... 54
12.7. Proyectos posibles ............................................................................. 55

6
¿Cómo funciona esta guía?
Esta guía es una introducción a la computación física como actividad
educativa. Recoge los aspectos más relevantes y da una serie de pistas sobre
donde encontrar más información para poder llevar a cabo tu propio curso.
Esta guía ha sido escrita para ti, profesora o profesor, y no para los alumnos.
Aquí encontrarás explicaciones en profundidad a los diferentes temas que
podrían formar parte de tu curso. Al final de la guía, hemos confeccionado una
propuesta de como podrías llevar a cabo las clases de un modo práctico y
entretenido.
La idea central de esta guía es dar una aproximación a la computación física.
Este concepto, tal y como lo manejamos en este curso, se construye sobre la
visión que el investigador y profesor Bill Verplank utiliza para describir la
interacción entre los humanos y el mundo.
Esta imagen pone el cuerpo en el centro de la imagen actuando como
intermediario (interface) entre lo físico y nuestro intelecto. Podemos actuar
sobre el mundo (en inglés “to do”) y podemos sentir el mundo (en inglés “to
feel”). A través de la interacción podemos crear conocimiento en forma de
visiones generales de las cosas o mapas (“map”) o como guías paso a paso
(“path”).

7
1. Computación física
1.1. Definición
La computación física es el campo de la computación que estudia la conexión
entre el mundo físico y los ordenadores. Esta conexión es bi-direccional, es
decir, puede consistir en sensar información del entorno y enviarla a
ordenadores para su procesado o bien, el uso de información para controlar
motores, solenoides, sistemas de calor y otros dispositivos capaces de actuar
sobre el entorno.
Del mismo modo que a los dispositivos que pueden medir el entorno los
llamamos sensores, a los que pueden actuar sobre el mismo, los
denominamos actuadores.
La computación física se centra mayormente en la relación entre humanos y
en como las máquinas pueden intervenir para mejorarla. De ese modo, este
campo se diferencia de otros como la robótica o sencillamente la informática.
Si bien las herramientas son las mismas, el campo de aplicación no es
necesariamente igual.
1.2 Breve historia
El concepto computación física aparece por primera vez en la literatura en un
libro titulado “Physical Computing: Sensing and Controlling the Physical World
with Computers. Premier Press. ISBN 1-59200-346-X” por Dan O'Sullivan y
Tom Igoe, ambos profesores de la Universidad de Nueva York, en la escuela
de Telecomunicaciones Interactivas.
En cualquier caso, si bien el nombre se les atribuye a estos autores, lo cierto
es que la computación física es un fenómeno emergente que surge de la
evolución de la tecnología de sensores y actuadores, al hacerse más accesible
para su uso en educación.

8
La computación fisica, como otros paradigmas de la computación actuales,
se define a partir de la llamada computación ubicua. Este término, acuñado
por Mark Weiser, un investigador de los EEUU a principios de los 90, establece
que habría de llegar el momento en que habría más ordenadores que
personas.
Weiser entendía el concepto de ordenador desde un punto de vista más
abierto que mucha gente. Un ordenador es sencillamente un dispositivo capaz
de realizar operaciones de control de entorno de forma precisa. El termino
ordenador no implica que deba tener un interface de control con pantalla,
teclado o similar, tal y como lo concebimos en el lenguaje coloquial.

9
En ese sentido, la computación ubicua se desmarca de la llamada
computación personal, que consistió en la aparición de los llamados PC (del
inglés personal computer, ordenadores personales). Los PCs marcan una
época en la que los ordenadores aparecen en el hogar tanto para la
realización de tareas de gestión, como para el ocio.
Los sistemas ubicuos dejan atrás la idea de interacción hombre máquina a
través de un ratón y teclado, ya que sería imposible hacer muchas de las
tareas del cada día a través de dichos interfaces.
1.3. Desarrollo en el campo educativo
La computación física es un campo en constante evolución. Con la aparición
de nuevos dispositivos, se generan nuevos campos del conocimiento por
explorar. Por ejemplo, principios de la decada de los 2000, surgieron los
primeros sensores acelerometros de bajo coste, lo que permitió la creación de
nuevos prototipos que desembocarían en sistemas como los controles
interactivos de videojuegos, etc.
Dentro del campo educativo, la aparición de nuevos dispositivos suele ser
estudiada dentro de las universidades. Es en las carreras de diseño y arte
donde se buscan aplicaciones a todo tipo de nuevas tecnologías. Una vez los
dispositivos han sido probados, resulta más sencillo introducirlos dentro de
otros ámbitos educativos como centros de educación secundaria o incluso en
niveles anteriores.
1.4. Tipos de herramientas
Las herramientas que podemos encontrar son, por ejemplo:
 Placas de control, comandadas por microcontroladores comerciales de
bajo coste. Ejemplos de placas son: Arduino, PicAxe, Basic Stamp,
Condor, etc.

10
 Nota: no hemos incluido microcomputadores como Raspberry Pi,
Arduino Tre, Beagle Bone Black y otras, puesto que la complejidad para
comenzar a usarlas cae fuera del alcance de este curso.
 Sensores de diferentes tipos: humedad, presencia, temperatura,
acelerómetros, de campo magnético, botones, potenciómetros, etc.
 Actuadores: motores paso a paso, motores de corriente continua,
servos, ledes, pantallas, peltzier, etc.
 Software de desarrollo: las placas de control se pueden reprogramar
mediante entornos de desarrollo de software. Esto permite cambiar
algunas de sus propiedades como que pines son entradas y cuales
salidas. Estos programas suelen ser específicos para cada placa de
control.
 Software de representación de datos: los datos se pueden capturar a
partir de puertos de comunicación como el puerto USB dentro de un
ordenador para poder representar sus valores mediante gráficas, tablas
excel o similar. De este modo se puede hacer uso de la tecnología
digital dentro de otros campos como por ejemplo la física o la química.
 Software de control: del mismo modo que las placas de control pueden
capturar datos de sensores, podrán usar información venida del
ordenador para controlar algún aspecto del mundo real. Ejemplos de
software de control podrían ser: LabView, Simulink y S4A entre otros.
1.5. Campos relacionados
Tal y como se mencionó anteriormente, campos como el control automático,
la domótica, la robótica o la computación vestible hacen uso de las mismas
herramientas. La posible diferencia entre unos y otros es el tipo de proyectos
a acometer con los conocimientos adquiridos.
2. Sensores
2.1. Definición
Un sensor es un dispositivo, también conocido como transductor, que puede
medir un dato del entorno para digitalizarlo y así poder usarlo dentro de un
sistema con capacidad de computo. En otras palabras, es un sistema,

11
componente electrónico, o dispositivo electrónico capaz de capturar una
cualidad del entorno para transferirla a un ordenador.
2.2 ¿Qué miden los sensores?
Los sensores pueden medir cualquier variable del entorno, desde la
temperatura hasta la humedad, pasando por la presencia de personas o el tipo
de objeto que alguien sujeta en su mano.
Los sensores pueden capturar una o varias características del entorno, pero
somos nosotros, las peronas, quienes tenemos que hacer una interpretación
de esos datos.
Imagina, por ejemplo que quieres medir la presencia de personas en una
habitación, podrás emplear todo un rango de sensores diferentes para hacer
esto. Desde una LDR (resistencia variable con la luz), un sistema de luz
infrarroja pasiva (PIR), o algún sensor medidor de distancia como un
ultrasonido o un infrarrojo. Cualquiera de ellos puede detectar la presencia de
personas, sólo tienes que calibrarlos para que la información que te
proporcionen sea relevante a tu caso.
2.3. Tipos de sensores
Los sensores se pueden clasificar de muchas formas, pero nosotros
preferimos mirar a aquellos que están listos para su uso directo y cuales
necesitan de algún tipo de acondicionamiento, como un circuito específico
para poder sacar información relevante de ellos.
Los sensores listos para usar tienen al menos tres pines: uno de alimentación,
uno de tierra/común y uno o varios para extraer la información relevante de
los mismos.
Los sensores que requieren acondicionamiento, suelen ser el puro
transductor, es decir, el dispositivo que puede convertir una característica del
entorno en una señal eléctrica que mediremos dentro de un ordenador.

12
Otros tipos de clasificación de los sensores podría ser por el tipo de cambio
que generan: sensores resistivos (que varían su resistencia con algún
parámetro del entorno como la temperatura, la humedad, o la luz), sensores
capacitivos (que varían la cantidad de electrones que pueden almacenar en
función de los mismos parámetros que los anteriores), etc.
Hay casi tantos modos de clasificar los sensores como sensores en sí
mismos, por lo tanto nos quedamos con la primera clasificación que
presentamos en esta sección.
2.4. Sensores en el mundo digital
Los sensores responden a cambios del entorno con cambios en alguna
propiedad eléctrica como la resistencia, la corriente o el voltaje. Los
microcontroladores, como el chip que está en la placa Arduino, pueden
responder a cambios de voltaje sin problemas.
Para convertir el voltaje en datos utilizables dentro del ordenador, los
microcontroladores suelen contar con un periférico interno (está dentro del
mismo chip) que convierte niveles de voltaje en números enteros que
podremos usar dentro de los programas como variables. Este periférico se
llama Conversor Analógico – Digital, si bien se suele nombrar con sus sigla en
inglés: ADC, de “Analog to Digital Converter”.

13
2.5. Aspectos a tener en cuenta
Cómo siempre que busques información sobre algo nuevo, recuerda que
podrás encontrar mucha información en internet. Antes de ponerte a hacer un
nuevo proyecto, si tienes una idea de que es lo que quieres medir, busca si
alguien ha conseguido usar un sensor para hacer eso mismo que quieres
hacer tú. Te ahorrará mucho tiempo y te dará ideas de que se puede y que no
se puede hacer.
La tecnología digital está a mitad de una evolución en la que se está
cambiando el voltaje tipo con el que se alimentan los sensores. Desde
prácticamente los años 60 hasta hoy mismo, hemos trabajado con sensores
que funcionan a 5V, que ha sido también el voltaje al que han funcionado los
microcontroladores. Estamos a mitad de cambiar a tecnologías que funcionan
a 3V3. Es por esto que Arduino, por ejemplo, te da la posibilidad de alimentar
sensores desde la placa, con salida de 5V y de 3V3. Cuando uses sensores,
mira bien que los conectes al voltaje correspondiente.
Hay diferentes tipos de sensores listos para usar y que pueden usar
diferentes tipos de comunicación hacia el microcontrolador. Los hay que
sencillamente dan un valor digital o analógico, sencillo de leer. Pero también
que usan un protocolo de comunicación para transferir la información como:
puerto serie, I2C, o SPI. Familiarizate con esto, dentro de Arduino hay una
multitud de librerías y ejemplos que te permite usar estos sensores sin
problemas.
Finalmente, mira a ver si tu sensor no necesita un periodo de calentamiento.
Por ejemplo, hay sensores de gases que pueden requerir estar conectados
varios minutos antes de empezar a dar datos fiables.

14
3. Actuadores
3.1. Definición: ¿Qué son los actuadores?
Los actuadores son dispositivos electrónicos, transductores, que pueden
afectar el entorno transformando un valor digital en un movimiento mecánico,
la producción de sonido, un cambio de temperatura, o de intensidad de la luz.
3.2. Ejemplos de actuadores
Hay muchos tipos de actuadores, una serie de ejemplos podrían ser:
 los motores y solenoides: se trata de dispositivos que transforman la
energía eléctrica en movimiento. El cambio de la corriente eléctrica
sobre una bobina de hilo puede producir el movimiento de una barra
metálica, bien para hacerla girar en círculos (motores), bien para que
reproduzca un movimiento lineal (solenoides).
 los piezo-eléctricos y altavolces: son dispositivos que pueden
transformar la corriente eléctrica en sonido al hacer vibrar
mecánicamente una membrana metálica (piezo-eléctrico) o de papel
(altavoz).
 las células peltier: son dispositivos que pueden cambiar su temperatura
de forma súbita.
 los ledes: transforman el flujo de electrones en luz, sirven tanto como
indicadores en paneles de instrumentos y aparatos, como para
iluminar.
 las pantallas LCD: sirven para mostrar información.

15
En el caso de, por ejemplo, querer controlar la apertura de una puerta en una
maqueta que hubieras construido con tus alumnos, podrías utilizar motores,
bien tipo servo motor, bien paso-a-paso. Veremos los dos tipos de motores
más adelante en el curso, en cualquier caso, te intersa saber que suele haber
más de una forma de resolver un proyecto, por lo que tener un conocimiento
amplio de las posibilidades es importante.
3.3. ¿Cómo se controlan?
Muchos de los dispositivos requieren de un driver físico que permita alcanzar
determinados niveles de corriente o voltaje que harán falta para estimular el
actuador. Por ejemplo, para mover un motor de corriente continua y poder
operar tanto su velocidad de giro como su dirección, hará falta usar bien 4
transistores, bien un circuito integrado (chip) que incluya esos transistores en
un solo encapsulado.
Cada actuador tiene diferentes métodos de control. Permanece atento
durante el módulo 2 del curso para que estudies las posibilidades.

16
3.4. Actuadores en el mundo digital
Hay muchas formas distintas de controlar los actuadores desde un
microcontrolador, como Arduino. Las más comunes son tres:
 bit-banging: es un término en inglés que quiere decir algo así como
“empujando bits” consiste en usar una serie de pines digitales en
un microcontrolador y mediante una serie de combinaciones de
encendido y apagado se puedan controlar las características del
actuador.
 PWM, del inglés Pulse Width Modulation o modulación por ancho de
pulso: es un método que consiste en poner una señal cuadrada de un
periodo determinado para cambiar la velocidad de motores o la
intensidad de la luz mediante el control de algunos parámetros de la
señal.
 muchos actuadores requieren un sistema de comunicación digital
como un puerto serie, SPI, o I2C.
 ¿Has mirado en internet a ver si alguien usó y documentó el uso de ese
actuador que tienes en mente? Interne es una fuente inagotable de
recursos en este sentido, podrás encontrar mucha gente que está
trabajando con dispositivos como los tuyos.
 Si vas a usar un motor, ¿estás seguro de que podrás cargar el peso de
aquello que quieres mover?
 Estudia en qué forma controlaras el dispositivo: bit-banging, PWM, o
por un puerto de comunicación digital.
 ¿Requiere tu actuador un periodo de calentamiento? Las células
peltizer, por ejemplo, no cambian de temperatura de forma inmediata,
es posible que tengas que implementar un sistema de control con tus
actuadores para asegurarte de que hacen exactamente lo que tú
quieres que hagan.

17
4. Arduino
4.1. ¿Qué es Arduino?
Arduino es una plataforma de prototipado que incluye circuitos electrónicos,
software y documentación abiertos. Toda la información oficial sobre Arduino
la puedes encontrar en la página web: http://arduino.cc
Arduino tiene usos industriales y dentro del hogar, pero se aplica mayormente
dentro del campo educativo por su sencillez de uso y su bajo coste.
4.2. La placa Arduino UNO
La placa Arduino UNO es la más empleada en el mundo en educación en este
momento. Fue diseñada para ser robusta y soportar toda una serie de
situacioines de uso con estudiantes.
La placa incluye, entre otras cosas:
 14 pines digitales de entrada y salida.
 6 pines analógicos de entrada.

18
 un botón de reset que reinicia el programa corriendo en la placa.
 un puerto USB que sirve para programar la placa, hacer que comunique
con un ordenador, o alimentar todos los circuitos (a 5V) conectados a
ella.
 un conector de alimentación externa.
 un puerto donde se puede sacar alimentación de 5V, 3V3 y tierra para
tus sensores y actuadores.
 una serie de ledes para informar del estado del circuito.
 una serie de pines digitales que, además, pueden actuar como fuente
de señales moduladas por ancho de pulso (PWM).
 conexiones para puerto serie, SPI, e I2C.
4.3. ¿Qué se puede hacer con Arduino?
Arduino se utiliza para la realización de todo tipo de proyectos. Aquí ves un
robot que se controla remotamente con un guante. Existen muchísimos más
ejemplos que podrás explorar a través de internet.

19
Lo importante realmente es encontrar una serie de casos con los que te
sientas familiarizado, de modo que los puedas utilizar a la hora de
confeccionar tus clases.
4.4. El bootloader y la vida de tu programa
La memoria del microcontrolador que lleva Arduino es de tipo Flash, es decir
que persiste aunque se le desconecte de la alimentación. En cualquier caso,
para cambiar el programa dentro de la placa, hace falta otro programa, que
reside en una parte protegida de la placa. Este programa se llama bootloader.
El bootloader es un programa que está precargado en la placa Arduino y que
permite reprogramarlo desde un ordenador. Una vez se carga un programa en
la placa, el programa permance ahí hasta que se cargue uno nuevo.
4.5. Funcionamiento con baterías
La placa tiene un conector de alimentación donde es posible conectar un
alimentador externo o bien un sistema de baterias. Cualquier sistema de mas
de 6V (y menos de 30V) sirve para alimentar el circuito.
Por lo tanto podrás reciclar las fuentes de alimentación de antiguos modems,
o dispositivos varios del hogar. Arduino se diseño con el conector de
alimentación más estándar del mercado.
5. IDE
5.1. ¿Qué es un IDE?
IDE, del inglés Integrated Development Environment es un sistema de
desarrollo de software. Se utiliza para la creación de programas que compilar
y descargar en tu placa microcontroladora.

20
5.2. El IDE de Arduino
El IDE de Arduino es un paquete de software que permite crear y descargar
programas en placas Arduino y compatibles. Este IDE lo creó y mantiene
Arduino. Se trata de un programa hecho en software libre que se puede
instalar sobre cualquier sistema operativo (Windows, Mac, Linux), incluidos
muchas versiones viejas de los mismos. Es por esto que resulta ideal para
educación, al poder correr sobre ordenadores relativamente desfasados, algo
que -desafortunadamente- es la realidad en muchos centros educativos.
El software es libre y gratuito. Se puede descargar de la página:
http://arduino.cc/en/Main/Software
Además, para los usuarios de Ubuntu (y de algunas otras distribuciones de
Linux), Arduino está disponible en la distribución oficial de programas del
sistema operativo.
5.3. La barra de tareas
El IDE permite escribir programas, compilarlos, descargarlos en placas y hacer
una gestión simple de ficheros. El 90% de las actividades que necesitas hacer
cuando creas programas para Arduino están representadas en la barra de
tareas.

21
Estas tareas son:
 Verify (verificar): compila el programa y te indica si la sintaxis es la
correcta y si las funciones a las que llama tu programa existen dentro
de las librerías de código que estas utlizando.
 Upload (descargar o subir el programa – depende de nomenclaturas):
compila el programa, pero además intenta escribirlo en la memoria de
tu placa Arduino. Te dará un mensaje final de éxito o error.
 New (nuevo): crea un nuevo programa, si tenías algo escrito en el
editor, te dará la posibilidad de guardarlo antes de crear uno nuevo.
 Open (abrir): abre un buscador de ficheros para que le indiques que
programa quieres abrir. Los programas de Arduino tienen la extensión
*.ino.
 Save (guardar): te permite guardar tu programa donde quieras en tu
disco duro, unidad USB, disco de red, etc.
 Serial monitor (monitor puerto serie): es una ventana de diálogo que te
permite comunicar con el puerto de comunicación de tu placa Arduino,
veremos más sobre esto al final de módulo.
5.4. El sketchbook y las preferencias
El IDE de Arduino está basado en el de Processing, si bien en los últimos años,
el desarrollo del de Arduino va mucho más rápido. Es por esto que verás
muchas similitudes entre ellos.
Una de las características más relevantes es que los programas, dentro de
Arduino no se llaman así, sino “sketches” que siginifica bocetos en inglés. De
ese modo, la carpeta donde se almacenan tus programas se llama
“sketchbook” que quiere decir block de dibujo.
Por defecto todos tus ficheros se almacenan esa carpeta, Arduino la creará
para tí la primera vez que ejecutes el programa. Podrás encontrar todos tus
programas de forma sencilla navegando desde el menú “Archivo →
Sketchbook”.

22
Físicamente, esta carpeta se encuentra dentro de tu ordenador. Búscala en
“Mis Documentos” en Windows, “Documentos” en Mac, y “home” en Linux. Tus
programas aparecerán como subcarpetas. Si quieres cambiar la localización
del “sketchbook”, selecciona el menú “Archivo → Preferencias”. Ahí verás
otras opciones como cambiar el tamaño de letra de tu editor (cosa que
recomiendo hacer mayor si es que vas a mostrar tu código con un proyector a
tus alumnos), el idioma de los menús del IDE, etc.
5.5. ¿Qué no se puede hacer con el IDE?
Arduino ha existido desde el año 2005 y el IDE actual desde finales de ese
mismo año. Esta no es la única herramienta educativa, por lo que mucha
gente nos ha pedido en ocasiones si podríamos implementar algunas
funciones que han encontrado en otros sistemas de desarrollo de hardware.
La idea es que el IDE de Arduino es un sistema muy sencillo orientado a no-
iniciados. Para aquellos que quieren usar herramientas más avanzadas, ya
hay otras alternativas.

23
En cualquier caso, aquí van un par de cosas que el IDE de Arduino no puede
hacer:
 El IDE no puede sacar un programa de una placa.
 La versión actual del IDE no puede hacer el llamado “debugueo por
línea”
 El IDE no hace simulación de circuitos.
6. Verificar y cargar
6.1. Definición: ¿Qué es verificar y cargar?
Verificar es lo que en lenguaje informático se conoce como “compilar”. Es la
acción del IDE de Arduino que transforma el código fuente (el programa tal y
como lo leemos al escribirlo) en código máquina (el programa tal y como lo
ejecuta la placa Arduino). La acción de verificar no implica nada más que la
compilación.
Por otra parte, cargar consiste en tomar ese fichero compilado tras la
verificación y grabarlo en la memoria flash de la placa Arduino. Para la placa
Arduino Uno, el programa se envía por el cable USB. Para otros modelos de
placa, el programa se podría enviar, por ejemplo, por Bluetooth o WiFi.

24
Las dos acciones: verificar y cargar, son invisibles al usuario. Sólo se
manifiestan a través de la barra de estado situada bajo el editor en el IDE.
6.2. Ejemplo de programa: BLINK
BLINK es el ejemplo más sencillo en computación física. Como las placas de
prototipado no suelen tener la posibilidad de mostrar nada sobre una pantalla,
se suele usar un led para comprobar que la placa es capaz de ejecutar
comandos.
BLINK, del inglés “to blink” que quiere decir parpadear, consiste en hacer que
un led conectado a un pin de una placa microcontroladora -Arduino Uno en
este caso- se encienda y apague de forma cíclica.
BLINK es el ejemplo que se emplea siempre como primer paso para que
aquellos que están aprendiendo puedan comprobar que, por una parte, su
placa funciona y, por otra, que son capaces de cargar programas desde sus
ordenadores.

25
El ejemplo se encuentra en el menú “Archivo → Ejemplos → Basics → Blink”.
Una vez abierto, hay qe seleccionar la placa apropiada en el menú
correspondiente. Haz click en “Herramientas → Tarjeta → Arduino Uno”.
Finalmente, asegurate de que tienes seleccionado el puerto de comunicación
que hace falta para poder cargar los programas. En Arduino, si bien la
comunicación sucede a través del cable USB, se produce mediante el
protocolo de comunicación serie, implementado sobre el USB.
El puerto serie tiene un nombre diferente según el sistema operativo en tu
ordenador:
 para Windows se llama COM##, donde ## representa un número
diferente para cada una de tus placas Arduino.
 para Mac se llama /dev/cu.usbmodem####, donde #### representa un
código identificador único para cada uno de tus Arduinos.
 para Linux se llama /dev/ttyACM##, siendo ## igual a cero para el
primer Arduino que conectes, uno para el segundo, y así
sucesivamente.
Puedes elegir el puerto apropiado en el menú “Herramientas → Puerto Serial”.
Una vez hayas hecho eso, ya podrás dar al botón de cargar. Verás como se
compila el programa en la zona de estados del editor, para seguidamente ver
como los ledes TX y RX de tu placa parpadean por un segundo. Eso quiere
decir que el programa se está enviando del ordenador a la placa.
Como último paso verás que el led marcado con L en la placa se encenderá
durante un segundo, para apagarse durante otro segundo. Esta acción se
repetirá indefinidamente. Habrás “subido” tu primer programa a Arduino.
6.3. Estructura de un programa: setup() y
loop()
Todos los programas en Arduino tienen que tener dos funciones básicas. Se
llaman “setup” y “loop”. En español se traducen como “configuración” y
“bucle”.

26
 setup() → es la función de inicialización, se ejecuta una sola vez al
resetear la placa o conectar la alimentación
 loop() → se repite continuamente después de haber terminado la
inicialización
Lo que quieres que tu programa haga se escribe dentro del loop. El código
dentro de setup es para preparar a tu placa para que sea capaz de ejecutar las
acciones que desees.
Acciones a ejecutar dentro del setup serían: configurar pines en la placa como
entradas o salidas, activar librerías de comunicación, declarar variables, etc.
6.4. Nuevos comandos: pinMode, digitalWrite,
delay
Si le echas un vistazo al código del programa BLINK, verás que, además de la
declaración de las funciones setup y loop, se utilizan una serie de funciones
que no habías visto antes:
 pinMode(pin, INPUT/OUTPUT) → declara un pin como entrada (INPUT)
o salida (OUTPUT)
 digitalWrite(pin, HIGH/LOW) → pone un pin a 5V (HIGH) o a 0V (LOW)
 delay(time) → hace un alto en el programa por un tiempo determinado
en milisegundos
Conociendo las acciones de cada una de estas funciones, resulta
relativamente sencillo leer el contenido del programa BLINK para comprender
que es lo que hacer realmente.
6.5. Instalación de drivers
Las placas Arduino son periféricos en tu ordenador, sería el equivalente a una
impresora o cualquier otro dispositivo externo. Como tales, puede ser
necesario instalar drivers, el programa que hacer posible la comunicación

27
entre la placa y el ordenador tanto para cargar programas como para
intercambio de información en determinadas aplicaciones.
La buena noticia es que es sencillo y que no siempre hace falta instalarlos.
Depende de nuevo, del sistema operativo de tu ordenador:
 Mac/Linux: no hacen falta drivers, el sistema operativo ya viene con
todo lo necesario, no tienes que instalar nada.
 Windows: se recomienda usar el instalador de Windows (el fichero
*.EXE) de la página de Arduino, eso instalará los driver. Si tuvieras
problemas, mira la página web de Arduino para instrucciones sobre
cómo resolver casos especiales.
7. Generación de sonido
7.1. ¿Sonido con microcontroladores?
La generación de sonido consiste en crear el sonido directamente desde el
dispositivo, es diferente de la reproducción. Los microcontroladores son
capaces de generar sonido siguiendo diferentes técnicas. Aquí vamos a
explorar la forma más sencilla de tocar sonido.
7.2. Ejemplo de
programa: BEEP
Para comenzar a tocar sonido, sólo
tienes que conectar un altavoz de
papel o un piezo eléctrico entre dos
pines de tu microcontrolador. En
concreto tendrás que conectar uno de
sus pines a tierra (GND, del inglés
ground) y el otro a un pin digital. En las

28
transparencias de la actividad, lo hemos conectado al pin digital 8.
El siguiente paso consiste en abrir el ejemplo BLINK y en editarlo para que
pueda ser utilizado con el altavoz. Como sabes, BLINK enciende y apaga el pin
13, en este caso quieres usar el pin 8. Por lo tanto, modifica el valor del pin en
las diferentes funciones que uses en tu programa: pinMode y digitalWrite.
Descarga el programa en tu placa y oiras que, ahí donde el led parpadeaba
antes, ahora oyes un pequeño chasquido una vez cada segundo. Este es el
resultado de estimular el altavoz con electricidad. El altavoz está hecho de un
electro-imán que mueve un cono de papel. Al moverlo, hace vibrar el aire,
efecto claramente audible para las personas.
Si cambias el retardo dentro de la función delay de 1000 a un número más
pequeño, toma por ejemplo 1, el sonido se modulará en un tono claramente
audible. Si tienes una serie de alumnos haciendo esto simultáneamente, tu
aula se transformará en un ejambre de abejas zumbando al mismo tiempo.
En inglés, un zumbido es lo que se conoce como beep, es por esto que a este
programa, le llamamos BEEP en lugar de BLINK.

29
Finalmente, te darás cuenta de que la función delay no permite usar
decimales, lo que reduce en mucho la capacidad de experimentar con el
sonido. Dentro de Arduino hemos creado otra función, llamada
delayMicroseconds, que tiene 1000 veces más resolución temporal.
Para que te hagas a la idea, la siguiente ecuación muestra la relación de
duración entre las funciones delay y delayMicroseconds:
delay(1) = delayMicroseconds(1000)
Gracias a este cambio de resolución, es posible reproducir los sonidos de los
tonos de la escala musical. Si por ejemplo cambias el retardo de 1000 a 1136,
estarás tocando el tono La (A4) con tu Arduino.
7.3. Tocar tonos, notas y melodías
El uso de los tonos es tan frecuente con Arduino, que hemos creado una
librería de código, es decir, un conjunto de funciones, con las que tocar
diferentes tonos. Puedes ver un ejemplo, si llamas al programa “Archivo →
Ejemplos → Digital → toneMultiple”, donde puedes ver como una serie de
funciones “tone” lanzan sonidos a través de diferente pines.
Aquí ves dos funciones nuevas:
 tone(pin, freq) → toca una tono en un pin a una frecuencia fija.
 tone(pin, freq, dur) → idem, pero por un tiempo determinado.
Para ver mejor el efecto de esto, sencillamente cambia el primer parámetro de
todas las llamadas a la función “tone” por 8.
7.4. Pestañas en el IDE, definición de
constantes
El IDE tiene la posibilidad de añadir pestañas (en inglés “tabs”) para ordenar el
código. El ejemplo anterior traía una pestaña extra con información sobre
frecuencias de tonos.

30
Para poder usar las definiciones de los tonos, tienes que usar un comando
llamado #include. Este comando, seguido por el nombre de la pestaña entre
paréntesis (nota que la pestaña tiene un nombre terminado en *.h) se pone al
principio de tu programa. Esto hace que todo lo contenido dentro de ese
fichero *.h se declare antes de que empiece a ejecutarse el programa.
Si te fijas dentro de la pestaña del ejemplo, llamada “pitches.h”, lo que hay es
una serie de llamadas al comando #define. Este comando sirve para declarar
constantes. Solemos declarar las constantes con mayúsculas, algo que no es
obligatorio, pero se considera un buen uso el lenguaje.

31
Por otra parte, te darás cuenta de que tanto #include, como #define, son
comandos que no tienen punto y coma al final. La razón de esto es que son
comandos que no se compilan igual que el resto del programa.
El compilador hace dos pasadas por tu código. En la primera, elimina todos
los comentarios y crea un solo archivo temporal muy largo, en el que
subsituye todo lo que este marcado con almohadilla (#) por su valor real. En la
segunda pasada, hace la compilacion.
7.5. Otros métodos para tocar sonido
Existen otras alternativas para tocar sonido. Este no es el momento de
profundizar en ellas, por lo que sencillamente las mencionamos:
 PCM o Pulse Code Modulation, consiste en tocar sonido haciendo que
un solo pin oscile a muy alta frecuencia, es lo que se usa en los
reproductores de CD.
 ficheros WAV sobre memorias SD, hay shields que pueden hacer esto.
 reproductores MP3 como shields de Arduino.
 activar solenoides que golpeen objetos.
8. Variables y melodías
8.1. ¿Qué es una variable?
Una variable es una representación en lenguaje natural de una posición de
memoria de un dispositivo digital.
Un buen ejemplo para comprender esto sería la lista de contactos de un
teléfono. Seguro que no eres capaz de recordar de memoria todos los
números de telefóno de la gente que conoces, pero si sus numbres. De modo
que cuando los buscas en tu libreta de contactos, los buscas por nombre. El
nombre sería el equivalente a la variable. Se trata de la dirección de memoria
en la que almacenas el número de teléfono.

32
El compilador de tus programas, se encarga de convertir las variables a
direcciones de memoria, de modo que tu no tengas que preocuparte de en que
lugares de la memoria de tu dispositivo se almacenarán los valores.
8.2. Ejemplos de variables
Las variables pueden representar diferentes tipos de valores. Por ejemplo, te
puede interesar almacenar el número de teléfono de tus amigos, eso es un
número, probablemente de 9 dígitos. Por otra parte, te puede interesar
almacenar su edad, algo que ocupa como mucho tres dígitos.
A primera vista está claro que no necesitamos la misma cantidad de memoria
para almacenar los teléfonos que la edad. Hará falta trozos de memoria de
mayor tamaño para los primeros que para los segundos. Decimos que los
valores almacenados por las variables teléfono y edad son de diferentes tipos.
Un tipo de variable define que clase de información almacena esa variable.
Los principales tipos de variables dentro de Arduino son:
 byte: un número entero entre 0 y 255, es decir, un número de 8 bits.
 int: un número entero de 16 bits.
 long: un número entero de 32 bits.
 float: un número decimal.
 String: un conjunto de caracteres.
 char: un símbolo del lenguaje escrito.
 boolean: una variable de tipo booleano.
8.3. Arrays
Un ARRAY es una composición de varias posiciones de memoria consecutivas
almacenando el mismo tipo de dato. Se utiliza para simplificar la
nomenclatura de las variables en tus programas.
Imagina que quieres almacenar los números de teléfono de todos tus amigos.
Una posibilidad sería tener una variable para el teléfono de cada uno:
telefono1, telefono2, etc. La otra sería tener una variable llamada telefonos

33
que pudiera, de algun modo, almacenar los números de todos. La forma en
que se accede a la información de cada celda por separado es mediante el
uso de llaves cuadradas al final del nombre de la variable. Dentro de las llaves
se escribe un número, llamado índice, que indica que valor de celda tomar.
Un array lo que hace es añadir una variable de índice al nombre de variable, de
modo que puedas almacenar una secuencia de valores del mismo tipo. En el
caso de los teléfonos, lo que tendríamos sería que el número de tu primer
amigo estaría en telefonos[0], el segundo en telefono[1], y así sucesivamente.
8.4. Toca una melodía
Abre el ejemplo “Archivo → Ejemplos → Digital → toneMelody”. Aquí ves
como la melodía se almacena en una estructura como esta:
int melody[] = { NOTE_C4, ... NOTE_C4};
Eso es lo que llamamos un array. Si sencillamente conectas un altavoz al pin
8, podrás escuchar la melodía tocada por este ejemplo.
8.5. Repaso de funciones de programación:
bucle for
El bucle for es una función que es común a muchos de los lenguajes de
programación existentes . La sintaxis es: for( inicio; final; incremento) . Se
utiliza para repetir una acción un número determinado de vecesque queda
dereminada por la diferencia entre la condición final y la de inicio y el
incremento entre las dos condiciones. En esta actividad lo utilizamos para
iterar operaciones sobre los arrays de notas y de duraciones de las mismas.

34
9. Entrada digital
9.1. ¿Qué es una entrada digital?
Una entrada digital en un microcontrolador, es un contacto (pin o terminal) en
el que podemos capturar vía software si el valor del voltaje en ese punto
corresponde a un voltaje bajo (0V) o alto (5V).
Los 5V a la entrada del pin se representarán con un número 1 en código. En
Arduino hay una constante pre-definida llamada HIGH que representa 1 o nivel
alto a la entrada del pin.
Los 0V se representarán con un 0 en código. La constante correspondiente es
LOW.
Por regla general todo aquello que esté por encima de 2V5 se considera que
es un nivel alto y lo que está por debajo es nivel bajo. Esta tolerancia permite
trabajar con sistemas que no funcionen exactamente igual en voltajes.
Solemos hablar de entradas digitales cuando realmente queremos hablar de
sensores digitales. Así, un botón, un sensor magnético, un sensor PIR y otros
los entenemos como mecanismos de entrada digital.
9.2. La entrada digital más sencilla
La entrada más sencilla sería un sencillo cable que podamos conectar a un
pin de entrada digital y con el conmutar los niveles alto y bajo.
9.3. Ejemplo con Arduino
Para probar esto con Arduino, conecta un cable al pin 5, abre el ejemplo de
código “Archivo → Ejemplos → Digital → Button”. Verás que ahí se define
una variable llamada buttonPin. Si quieres usarla con el cable que has
conectado, tendrás que asegurarte de que su valor inicial corresponda con el
número del pin del cable.

35
Este ejemplo utiliza el estado de la entrada para encender y apagar el led de la
placa.
9.4. Nuevo comando: digitalRead()
El comando digitalRead(pin) es un comando que lee el valor del voltaje a la
entrada de un pin de Arduino y devuelve valor alto (HIGH) o bajo (LOW) en
función del voltaje que haya a la entrada del pin. Ese valor lo tendrás que
almacenar en una variable si lo quieres usar en otras partes del programa.
En el ejemplo anterior, la variable buttonState almacena es valor de la lectura
del pin, de modo que se pueda usar en otras declaraciones y operaciones del
programa.
Un cable suelto no es un buen sistema para detectar que algo está encendido
o no (ver actividad sobre el botón en el módulo sobre componentes).
Arduino Uno tiene 14 entradas/salidas digitales, los pines 0 y 1 se usan
además para la comunicación con el ordenador.
Los pines analógicos se pueden usar como pines digitales. El pin analógico A0
es el 14 en digital, el A1 el 15 y así sucesivamente.
10. Entrada analógica
10.1. ¿Qué es una entrada analógica?
Una entrada analógica en un microcontrolador es un contacto (pin o terminal)
en el que podemos capturar, vía software, el valor del voltaje y mapearlo en un
número entero.
Esta captura se hace, en Arduino Uno, mediante un periférico interno (que
reside dentro del procesador) llamado conversor analógico digital aunque nos
referimos a él por sus siglas en inglés: ADC, del término Analog to Digital

36
Converter. Sólo 6 pines en Arduino Uno están conectados a ese periférico.
Están marcados con el texto A0 a A5.
En Arduino Uno, el conversor es de 10bits, es decir, puede convertir el voltaje
en un número que va desde 0 a 1023. La correspondencia es sencilla: 0V
corresponden al número 0, mientras que 5V a 1023. El resto de los valores van
en proporción, es decir, 2V5 sería 512, etc.
10.2. El sensor más sencillo: el
potenciómetro
El sensor más sencillo es un potenciómetro, puesto que permite explorar
todos los valores del rango que el ADC puede capturar.
El potenciómetro es una resistencia que tiene tres terminales. Dos de ellos
están a los extremos de un trozo de material que ofrece cierta resistencia al
paso de la corriente. La tercera está flotando sobre el material, de modo que
pueda tomar una sección del material resistivo.
El potenciómetro se explicará en más profundidad en el módulo 2 del curso.
En este momento, lo único que necesitas saber es que, al aplicar un voltaje
entre los terminales extremos del componente, al girar el ejer del
potenciómetro, el terminal central mostrará un cambio en voltaje
correspondiente al ángulo de giro. En cierto modo, el potenciómetro es un
sensor que puede representar cambios de ángulo.
10.3. Ejemplo con Arduino
En Arduino, puedes conectar un potenciómetro de forma sencilla con una
placa de entrenamiento. Sólo tienes que recordar que uno de los terminales
extremos tiene que ir a 5V y el otro a 0V, la señal la medirás sobre el terminal
central. Si no estás seguro de estar haciendo bien la conexión, prueba con un
multímetro antes de conectar el circuito a Arduino.
El ejemplo más sencillo lo encontrarás en “Archivo → Ejemplos → Analog →
AnalogInput”. Este ejemplo, al conectar un potenciómetro en A0, hace

37
parpadear el led del pin 13 a diferentes frecuencias. Fíjate bien que en la
transparencias hemos conectado el potenciómetro en la pata A2, es un
ejercicio para que tú cambies en el programa ese parámetro a la hora de
probar.
10.4. Nuevo comando: analogRead()
El comando analogRead(pin) leerá el valor de voltaje en el pin (entre 0V y 5V) y
lo traducirá en un número entero entre 0 y 1023. Tendrás que usar una
variable de tipo “int” para almacenar el valor que te proporcionará esta
función.
Las entradas analógicas nos dar un valor de mayor resolución que las
digitales.
Para poder experimentar con esta riqueza de valores, lo mejor es utilizar el
puerto de comunicación para ver los valores en la pantalla del ordenador.
11. Puerto serie básico
11.1. ¿Qué es el puerto serie?
El puerto serie es un puerto de comunicación estándar en muchos sistemas
digitales. Establece la comunicación entre dos puntos a una velocidad
determinada en bits por segundo (bps o baudios).
El puerto serie puede servir tanto para hacer que Arduino Uno comunique con
un ordenador, como para hacer que dos Arduinos “hablen” entre sí. El puerto
USB, con el que Arduino conecta a tu PC, tiene un modo de comunicación que
simula un puerto serie.
Muchos de los dispositivos que existen, usan el puerto serie como sistema de
comunicación básico. Si bien puede que no te ofrezcan una conexión física

38
donde hacerlo, tu ordenador, tu teléfono, tu lavadora o el ascensor de tu casa,
tienen un puerto serie de comunicación que se puede utilizar para reparar el
sistema a bajo nivel.
En Arduino Uno, el puerto serie está en los pines 0 y 1, por lo que se
recomienda dejar esos pines libres a la hora de hacer proyectos si es que
quieres usar el puerto de algún modo como para mandar datos a un
ordenador o leer un sensor complejo como un GPS.
11.2. Envía desde Arduino
Para probar a enviar datos desde Arduino, sólo tienes que cargar el programa
“Archivo → Ejemplos → Analog → AnalogInOutSerial”. Este ejemplo, lee el
valor de un potenciómetro conectado a Arduino y lo envía de vuelta al
ordenador.
Para poder ver los datos en la pantalla, la barra de tareas del IDE de Arduino
tiene la opción “Puerto Serie”; se trata de un icono con forma de lupa. Al hacer
click sobre él, se abre una venta de diálogo que permite tanto enviar como
recibir datos de Arduino.
Si ejecutas el mencionado ejemplo, verás una secuencia de datos que llegar a
tu ventana.
Por otra parte, puedes probar a hacer un ejemplo sencillo de comunicación
para ver cuales son los comandos básicos para establecer la comunicación.
El programa más sencillo sería así:
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(“Hola Caracola”);
delay(100);
}

39
Si ejectuas este programa y abres el monitor serie, verás como se escribe el
mensaje “Hola Caracola” sobre el monitor a una velocidad de 10 veces por
segundo.
Verás que hemos puesto un retardo (delay) dentro del loop. Esto es
recomendable puesto que tu Arduino Uno es capaz de enviar datos más
rápido de lo que tu PC es capaz de leer. Si no lo hicieras así, segurament
saturarías el puerto de comunicación de tu ordenador.
11.3. Nuevos comandos
 Serial.begin(velocidad) establece como se ha de configurar el puerto
para enviar datos entre Arduino y el ordenador. Es importante notar que
Serial.begin(9600) -tal y como lo vimos en el ejemplo anterior- usa la
velocidad de envío de datos de 9600 baudios por el puerto. Esto quiere
decir que, cada segundo, se envían 9600 bits, o 9600 1's y 0's por el
puerto. Esta velocidad es la que se usa por defecto. Prácticamente
todos los dispositivos que pueden comunicar por puerto serie, pueden
hacerlo a esa velocidad.
 Serial.println(texto) envía una cadena de texto hacia el ordenador
incluyendo un final de línea/retorno de carro al final.
11.4. Recibe en Arduino
El ejemplo más sencillo para probar la comunicación desde el PC hacia
Arduino Uno se encuentra en “Archivo → Ejemplos → Comunication →
Physical Pixel”. La idea detrás de este ejemplo es transformar tu placa en un
pixel que puedas controlar remotamente desde el PC. Como Arduino Uno tiene
un led en el pin 13 que puedes controlar por software, es como si fuera un
pixel físico.
Carga el programa en tu placa y abre el monitor serie. El campo de texto de
arriba en la ventana de diálogo te permite escribir datos através del puerto. En
este caso la hache mayúscula o “H” encenderá el led, mientras que la ele
mayúscula o “L” lo apagará. El dato no se envía automáticamente, tienes que

40
bien hacer click en el botón “send” o presionar “enter” en tu teclado para que
se envíe el dato.
11.5. Nuevos comandos (2)
Dentro del ejemplo “Physical Pixel” verás estos comandos nuevos:
 Serial.available(): sirve para ver si han llegado datos por el puerto serie.
Al invocarlo, nos responde con el número de datos que han llegado por
el puerto y que se han almacenado en la memoria de Arduino.
 Serial.read(): nos devuelve el primer dato que llegó por el puerto de
comunicación. Además borra ese valor de la memoria, de modo que
Serial.available() decrementará en una unidad la próxima vez que lo
llames.
12. Uso en el aula
Esta sección describe en qué manera puedes hacer uso de los contenidos de
esta guía en el desarrollo de las actividades de clase. Las secciones
anteriores describen contenidos que no tienes porque compartir en su
totalidad con los alumnos, ni hacerlo de forma lineal.
El desarrollo de una clase, depende como siempre de cual sea tu metodología
de trabajo. En cualquier caso, desde la organización de CODE MADRID te
recomendamos que tomes una aproximación al curso basada en proyectos.
Como no es posible comenzar desde un principio a hacer un proyecto aquí te
recomendamos una serie de pasos, basados en la experiencia, para que tus
alumnos puedan llegar a montar proyectos sencillos usando botones, ledes,
potenciómetros, resistecias LDR y piezo eléctricos.
Cada unidad indica el tiempo aproximado que creemos debiera llevarte
presentar cada una de las actividades aquí descritas. Además, a la hora de
presentar estos contenidos a los alumnos, deberás adelantar brevemente
algunos de los contenidos del módulo 2.

41
12.1. Qué es Arduino
Esta serie de actividades sirve para inspirar a los alumnos. Recuerda que
buscamos no sólo ayudarles a comprender determinados términos técnicos,
sino también introducirles al mundo de la invención y el uso de herramientas
digitales para su aplicación en otros campos.
12.1.1. Introducción a Arduino
Duración: 20m
Presenta a tus alumnos la secuencia de transparencias que has preparado
sobre Arduino. Recuerda que deberás incluir:
Un par de transparencias sobre las herramientas: software, hardware y
documentación en línea.
Ejemplos en fotografía sobre proyectos interesantes como:
 Un Segway hecho con taladradoras.
 Las impresoras 3D libres.
 Robots, quadcopteros.
 Ropa interactiva.
Incluye algún vídeo, breve, especialmente de proyectos hechos por jóvenes
en las edades de los alumnos de tu clase.
12.1.2. La placa y que se puede hacer
Duración: 5m
Presenta la placa, sus conectores y menciona que tiene:
 14 entradas y salidas digitales.
 6 entradas analógicas.
 Conexión USB para poder descargar programas.
 Conexión de batería o alimentador externo.

42
 Conexión de salida de 5V, 3V3 y GND, para poder conectar los sensores
directamente.
12.1.3. El IDE y como se usa
Duración: 10m
Presenta el IDE a tus alumnos, explica que tiene un menú sencillo, pero que la
mayor parte de las veces van a interactuar con el a través de la barra de
tareas.
 Explica brevemente la barra de tareas, volverás a las diferentes
funciones más adelante.
 Explica donde están las preferencias por si quieren cambiar el tamaño
de letra o el idioma del sistema.
 Explica que los programas se llaman “sketches” y que se almacenan en
una carpeta llamada “sketchbook”.
 Recuerdales que todos sus programas se podrán buscar desde el menú
“Archivo” a no ser que, por ejemplo, los guarden en una llave USB.
 Recomiéndales que tengan una llave USB para guardar sus ficheros o,
en su defecto, que los copien en un mail o similar al terminar cada
clase, para que no los pierdan.
12.2. Salidas digitales
Lo ideal sería que la primera actividad práctica (BLINK) la hicieras en la misma
clase en que haces la introducción a Arduino, de modo que los alumnos se
vayan a casa viendo que tan sencillo puede ser hacer que un led parpadee en
un circuito.
A partir de ahí, el resto de actividades las puedes tomar o dejar en función de
como veas a tu grupo. La composición que te propongo aquí es para poder
introducir la mayor cantidad de contenidos posibles de una manera lineal pero
alternando práctica y teoría.

43
12.2.1. Primer ejemplo: BLINK
Duración: 20m
Explica como encontrar el ejemplo BLINK en el menú, aprovecha para
recordarles que hay toda una serie de ejemplos a los que pueden recurrir y
que están disponibles siempre en el IDE. Para que este experimento funcione
bien, recuerda que:
 El IDE tendrá que estar ya instalado en los ordenadores, incluidos los
drivers para las placas Arduino (el software lo puedes descargar e
instalar desde http://arduino.cc).
 Cada grupo de alumnos tendrá una placa y un cable USB.
 Cuando digas a los alumnos que abran el ejemplo, explica que hace
cada una de las líneas. Comentales como las funciones representan
acciones sobre el mundo real. Por ejemplo “digitalWrite” escribe un
valor digital en un pin; “delay” hace una pausa en milisegundos; “setup”
es la parte de configuración, mientras que “loop” es la de ejecución y
que se repite mientras que la placa tenga alimentación; “pinMode”
prepara un pin como salida o como entrada; etc.
 Todos los alumnos tienen que ir al menú “Herramientas” seleccionar la
placa “Arduino UNO”, o la placa que estéis usando en clase.
 Todos tienen que asegurarse de haber seleccionado –también en el
menú “Herramientas” el puerto serie apropiado para su placa.
 Tienes que explicar el concepto de “Verificar” y el de “Cargar”.
Con todo esto en mentee, haz que carguen el programa y que cambien el
tiempo de “delay” para ver cómo afecta a la velocidad de parpadeo del led.
Esto servirá, además, para asegurarte de que está funcionando como se
espera.
12.2.2. Explica los ledes brevemente
Duración: 5m
Para poder seguir en el curso, tienes que hacer una incursión en el módulo 2 y
explicar, brevemente, que es un led.

44
 Explica la polaridad, las patas positiva y negativa, el ánodo y el cátodo.
 Puedes hacer un ejemplo práctico de conectartlo directamente entre el
pin 13 y GND para ver como en una dirección parpadea mientras que en
la otra no (Arduino deberá tener el programa BLINK precargado).
12.2.3. Explica las resistencias brevemente
Duración: 5m
Explica que los ledes se encienden a un voltaje determinado y que los pines de
Arduino dan 5V a la salida. Es decir, que al poner un pin en “HIGH” es como
poner ahí 5V y que eso, si bien no rompe el led a priori, si que le acorta mucho
la vida. Es por eso que se usan resistencias para disipar el resto de la energía
en forma de calor.
 Explica que las resistencias se miden en Ohms.
 Explica que su valor se determina con las líneas de colores, pero no
hace falta que expliques ahora la tabla de colores, porque eso viene en
el módulo 2.
 Explica que los ledes necesitan de resistencias de entre 100 y 330
Ohms para maximizar su brillo (esto es así en el 90% de los casos, así
que puedes hacer una norma de ello).
12.2.4. Explica la protoboard brevemente
Duración: 5m
Explica que es la prototboard or placa de prototipado rápido.
 Sirve para hacer montajes de circuitos de forma rápida y sin soldadura.
 Permite reutilizar los componentes para otros proyectos.
Puedes mostrar una imagen de una protoboard transparente o de una
ilustración para que comprendan que lo que tiene son una serie de listas de
metal que comunican los orificios en filas o columnas según el caso.

45
12.2.5. Monta tu propio led
Duración: 20m
Los alumnos han de montar un circuito sobre una protoboard con un led y una
resitencia. El circuito lo conectarán a la tierra de Arduino y al pin 13 de su
placa, en la que correrá el programa BLINK.
 Primero deja que comprueben que funciona, es la primera vez que usan
la protoboard y es posible que cometan errores al conectar cables y
componentes.
 Una vez les funcione, invitales a cambiar la conexión del pin 13 a, por
ejemplo, el pin 5. Deja que piensen en que forma han de cambiar el
código para que el led parpadee ahora en este nuevo pin.
12.2.6. Simula el pulso cardiaco
Duración: 15m
Una vez todos los grupos hayan conseguido tener su led parpadeando en un
pin distinto del 13, es hora de darles un ejercicio sencillo de programación.
Pídeles hacer una simulación del pulso. Como sabes el pulso, medido por
ejemplo en la muñeca, nos da siempre dos batidos seguidos de una pausa
larga. Es decir, algo así como: dum-dum ….. dum-dum ….
 Da a tus alumnos 10 minutos para que resuelvan este ejercicio, es una
mera operación de copiar y pegar, en la que tienen que cambiar los
retardos para que el led parpadee simulando el pulso.
 Una vez se haya pasado el tiempo, no tienen porque haber terminado
todos, elige a un grupo que haya funcionado bien y deja que explique
como lo han hecho.
Para compartir el código durante la clase en tiempo real puedes usar un
documento de Google Docs o un página hecha para tal efecto como
http://sketchpad.cc o http://piratepad.net.

46
12.2.7. Monta dos ledes
Duración: 20m
Este nuevo ejercicio incrementa la complejidad del anterior mediante la
introducción de un segundo led. La idea será que los alumnos monten un
circuito con dos ledes, conectados a pines distintos en Arduino, y que los
hagan parpadear en secuencia. El objetivo es mostrar que se pueden conectar
múltiples dispositivos a un sistema de control y que se pueden direccionar de
forma indpendiente mediante el software.
 Explica que pueden conectar, de forma sencilla hasta un total de 20
ledes a Arduino, si es que no quieren conectar nada más (los pines
analógicos también pueden funcionar como digitales).
 Recuérdales que los pines 0 y 1 se emplean para cargar programas en
la placa, puesto que llevan las señales del puerto serie. Si tienen algo
conectado ahí, lo tienen que desconectar físicamente cada vez que
quieran cargar un nuevo programa.
12.3. Entradas digitales
El microcontrolador dentro de la placa Arduino UNO –el Atmega328- tiene una
característica interesante: todos los pines pueden ser declarados como
entrada digital. Como ya habrás comentado a tus alumnos en este momento,
la función “pinMode” es responsable de declarar un pin como entrada “INPUT”
o salida “OUTPUT”.
Existe además un tercer modo llamado “INPUT_PULLUP” que introduce una
resistencia interna al chip, para que por defecto el pin asignado este a nivel
alto “HIGH”. Esto permite conectar entradas sin necesidad de usar una
resistencia de PULL-UP o PULL-DOWN.
En cualquier caso, no introduzcas este aspecto teórico de entrada a tus
alumnos. Guárdalo para una vez hayas explicado la necesidad de usar un

47
PULL-UP. Es mucho más difícil imaginarlo que montarlo en la placa y después
interiorizar que ese mismo circuito existe dentro del microchip. Veamos la
secuencia práctica para hablar sobre entradas digitales introduciendo, entre
otros aspectos, lo aquí expliado.
12.3.1. El ejemplo del cable
Duración: 10m
Vamos a ver como usar una entrada digital sencilla. Carga el programa
ejemplo “Archivos  Ejemplos  02. Digital  Button”. Explica el código a
tus alumnos. Muestrales la declaración de variables que se usa para declarar
el pin de entrada (2) y el pin de salida (13). Recuérdales que el 13 es donde
está conectado el led. Como entrada usaréis un cable conectado al pin 2 y que
moveréis de 5V a 0V (GND) en el otro extremo. De ese modo los alumnos
verán como el led se enciende y se apaga.
Introduce los siguientes temas:
 La función “pinMode” tiene el modo “INPUT”.
 En el programa aparecen una serie de cosas nuevas: variables y
condicionales, los vamos a explicar luego, diles que sean pacientes con
esto por unos minutos, porque la explicación llega en breve.
 Preguntales que pasa cuando el cable está suelto en el aire: ¿el led está
encendido o apagado? La respuesta será distinta para unos y otros.
Explica que se debe a que no podemos saber el voltaje del extremo del
cable, que depende de la electricidad estática y no esta ni a 0 ni a 5,
puede que esté a más o puede que esté a menos. Explica, como
apertura a la siguiente actividad que para estar seguros del valor, hay
que emplear un circuito que se llama de PULL-DOWN.
12.3.2. Monta el botón en la protoboard
Duración: 20m

48
Montad el botón sobre la protoboard con una resistencia de PULL-DOWN.
Explica que de este modo, por defecto la entrada estará a 0V o “LOW” y que
cuando se presione el botón se pondrá a 5V o “HIGH”.
 Esta actividad require revisar bien los circuitos en las protoboards,
suele haber problemas con alumnos que no conectan bien los cables.
 Seguimos trabajando con el mismo programa que en la actividad
anterior, el botón tiene que estar conectado al pin 2 en Arduino.
12.3.3. Explica las variables
Duración: 20m
Las variables han aparecido ya en el código de los alumnos, y es el momento
apropiado para explicar brevemente que son y para que sirven. En este caso
las habéis usado para almacenar el valor de la lectura del botón o para
declarar los pines del botón o del led. Utiliza las notas de esta guía para
explicar que son y como se usan. Los aspectos más importantes a resaltar
son:
 Las variables en un programa son la descripción en lenguaje humano
de una posición de la memoria de un microchip.
 Las variables toman una o más celdas de memoria para almacenar
valores.
 Cada tipo de variable describe cuantas celdas de memoria toma.
 Los chips en Arduino tienen celdas de memoria de 8bits, un ordenador
moderno tiene celdas de memoria de 64bits.
 Los tipos de variable que más usamos en Arduino son: “int”, “boolean”,
“byte”, “long”, “char” y “String”.
 Recuerda a los alumnos que las variables pueden ser cualquier nombre
tan ridículo como quieran (por ejemplo “meGustaLaButifarra”) pero que
lo mejor es poner nombres que tengan sentido de cara a hacer más
fácil la lectura del programa.
 Los nombres de variable tienen que empezar por un carácter no
numérico, y pueden contener letras, números y algunos símbolos.
Alternamos mayúsculas y minúsculas para dar más claridad. Ejemplos:
 velocidad

49
 aceleracionCoche
 numero_bolas
 …
12.3.4. Recuerda las estructuras condicionales “IF…THEN”
Duración: 20m
El ejemplo del botón también ha introducido el uso de condicionales. Si aún no
habéis hecho un curso de programación en clase, tendrás que explicar esto a
tus alumnos en este momento. No voy a profundizar sobre esto en esta guía,
puesto que no es el objetivo el centrarse en estructuras básicas de
programación, sin embargo, aquí los aspectos más importantes a notar:
 “if…then…else” son las estructuras condicionales en programación,
“then” no se escribe en programación para Arduino, está implícito.
 Se usan para comprobar que una variable ha llegado a un valor
determinado, o que este en un rango que queramos analizar.
 Este comando responde a la lógica de realizar una acción si es que la
variable o variables que se están monitorizando cumplen unas
determinadas condiciones.
 Permite, además, introducir una acción en caso de que no se cumpla la
condición en estudio.
 Permite además consultar directamente funciones cuyo valor
podríamos almacenar o no en una variable.
 Las condiciones se escriben entre paréntesis y pueden añadirse más
mediante las proposiciones lógicas AND (&& en programación para
Arduino) y OR (||).
 Ejemplos de uso:
 if (valorBoton == HIGH) digitalWrite(pinLed, HIGH);
 if (digitalRead(pinBoton) == LOW) {
// haz algo aqui
}
 if (valorPot > 100) {
// haz algo aqui

50
} else {
// haz otra cosa aquí
}
12.4. Entradas analógicas
Explica que dentro de los procesadores, podemos encontrar diferentes
bloques electrónicos funcionales. Hay una unidad aritmeticológica que hace
operaciones matemáticas y permite sumar variables o comparar valores. Hay
también una zona reservada únicamente al almacenamiento de variables. Hay
una parte dedicada a las comunicaciones serie –que veremos en la siguiente
sección-. Y hay un bloque, llamado conversor analógico digital (o ADC en
inglés) que convierte los valores de voltaje en el rango de 0V a 5V en números
enteros que podemos usar dentro de un programa.
Es decir, la lectura de sensores analógicos es tan sencilla como la conversión
de un valor de voltaje, en el rango apropiado, a un número que poder operar,
mapear y comparar dentro de un programa. La función encargada de la
lectura es “analogRead”, lo hace sobre los pines de entrada analógicos,
marcados como A0..A5 en la placa, y convierte 0V al número 0, 5V al número
1023 y todos los demás van en proporción.
12.4.1. El primer sensor: potenciómetro
Duración: 20m
El potenciómetro es una resitencia en la que hay un terminal metálico extra
que se puede desplazar entre los dos terminales extremos. Al aplicar un
voltaje entre los extremos, el voltaje en el pin central será propocional a la
catidad de maerial resistivo a cada lado de ese pin.
 Monta un potenciómetro en una protoboard y conecta 5V y 0V en los
terminales extremos.
 Conecta el pin central al primero de los pines analógicos de entrada en
Arduino (A0).
 Carga el programa “Archivo  Ejemplos  03. Analog  AnalogInput”.
 Al mover el potenciómetro verás cómo cambia la velocidad de
parpadeo del led del pin 13 en tu Arduino.

51
12.4.2. LDR: midiendo la cantidad de luz
Duración: 30m
La LDR (del inglés Light Dependant Resistor) es una resistencia cuyo valor
varía con la cantidad de luz que incide sobre ella. La puedes montar con una
resistencia de PULL-UP o PULL-DOWN para leer su valor en un pin analógico
de Arduino.
 Monta el circuito con la LDR y conectala al pin A0.
 Carga el programa “Archivo  Ejemplos  03. Analog  AnalogInput”.
 Al acercar la mano a la LDR se producirá un cambio en la cantidad de
luz sobre el sensor, lo que cambiará el voltaje en el pin A0 y, por lo
tanto, la velocidad de parpadeo del led.
12.5. Introducción al puerto serie
El puerto serie sirve para poder comunicar tu Arduino tanto para mandar
datos desde un ordenador a Arduino como al revés. En esta parte del curso
sería interesante explicar brevemente a los alumnos el potencial de estas
funciones para pasar en el siguiente módulo a profundizar en su uso.
12.5.1. Envía datos sencillos: “hola caracola”
Duración: 20m
Como ejemplo te recomiendo hacer un programa muy sencillo que envíe una
frase corta y fácil de reconocer para llamar la atención de los alumnos. Yo
suelo hacer que mi Arduino envíe la frase “hola caracola” de vuelta al
ordenador.
 Crea un programa nuevo y llama a “Serial.begin(9600)” en el setup.
 Dentro del loop haz una llamada a “Serial.println(“hola caracola”)”.
 Nota que la función “println” añade un final de línea tras el mensaje.

52
 Añade, también en el loop, una llamada a la función de retardo
“delay(500)” para que cada vez que se mande algo por el puerto serie, el
programa haga una pausa y no se sature el puero de comunicación.
 Carga el programa en Arduino y abre el monitor de puerto serie (es el
incono con forma de lupa a la derecha en tu IDE).
 Verás el resultado de tu mensaje imprimirse en la ventana de diálogo
que se habrá abierto un par de veces por segundo.
12.5.2. Envía los valores del potenciómetro
Duración: 20m
Una de las grandes aplicaciones del puerto serie es poder leer toda la riqueza
de valores de un sensor (requerda que el conversor ADC da valores de 0 a
1023) en formato texto.
 Monta el circuito del potenciómetro o de la LDR.
 Carga el ejemplo: “Archivo  Ejemplos  03. Analog 
AnalogInOutSerial”.
 Abre el monitor de puerto serie.
 Al girar el potenciómetro verás las lecturas del sensor en la ventana de
diálogo.
12.5.3. Recibe en Arduino: “physical pixel”
Duración: 20m
“Archivo  Ejemplos  04. Communication  PhysicalPixel” es un ejemplo
que se suele utilizar para explicar cómo funciona la comunicación de vuelta
desde el ordenador hacia Arduino.
 Carga ese programa en la placa.
 Abre el monitor de puerto serie.
 Al escribir el caracter ‘H’ en el campo de entrada de texto del monitor
de puerto serie y presionar el botón “send”, verás cómo se enciende el
led de tu placa.

53
 Al escribir el caracter ‘L’ en el campo de entrada de texto del monitor de
puerto serie y presionar el botón “send”, verás cómo se apaga el led de
tu placa.
 Presenta a tus alumnos las funciones: “Serial.available()” y
“Serial.read()” usadas para comprobar si hay datos en el puerto y
leerlos respectivamente.
12.6. Tocando sonidos
Hay diferentes formas de tocar sonido con Arduino. La forma más sencilla
consiste en tocar tonos usando un piezo eléctrico y hacer oscilar un pin.
12.6.1. Explica brevemente el piezo eléctrico
Duración: 10m
Explica el fenómeno piezo eléctrico y el componente correspondiente.
12.6.2. BEEP: conecta el piezo al programa BLINK
Duración: 15m
Toma un piezo eléctrico o un altavoz y conéctalo entre el pin 13 y uno de los
pines GND.
 Carga el programa “Blink” en tu placa.
 Oirás un pequeño sonido cada vez que se encienda o apague el led.
 Poco a poco cambia el valor dentro de las funciones de retardo “delay”
hasta hacer que lleguen a ‘1’.
 En ese momento estarás oyendo un pitido bastante agudo.
 Para cambiar el tono del pitido, puedes cambiar las funciones “delay”
por funciones “delayMicroseconds”, de ese modo tendrás más
resolución temporal, recuerda que “delay(1)” es lo mismo que
“delayMicroseconds(1000)” .

54
12.6.3. Usa “tone” para tocar melodías
Duración: 20m
Si en lugar de tocar un solo tono, quieres tocar notas y componer melodías,
echa un vistazo al ejemplo: “Archivo  Ejemplos  02. Digital 
ToneMelody”
 Este programa tiene un par de arrays que contienen una melodía, o
secuencia de notas y otro array con las duraciones de cada una de las
notas.
 Al conectar un altavoz o un piezo eléctrico al pin 8, podrás oir una
pequeña melodía.
 Haz notar a tus alumnos que hay una seguna pestaña en el programa
que contiene una declaración de constantes que representan toda una
serie de notas en varias escalas.
 Un buen ejercicio de continuación es pedirles que cambien los valores
de las notas y de las duraciones para hacer su propia canción.
12.6.4. Refresca el uso de “FOR(init; end; increment)”
Duración: 10m
Este es un buen momento para recordar a tus alumnos sobre el uso del bucle
“for” en programación:
 Lo usamos para poder repetir una acción un número determinado de
veces.
 Sirve también para navegar dentro de un array.
 Tiene tres parámetros que, al contrario que otras funciones, están
separados por punto y coma.

55
12.7. Proyectos posibles
Con botones, ledes, potenciómetros, LDRs y piezo eléctricos es posible hacer
muchos proyectos diferentes. Puedes pedir a tus alumnos que hagan un
pequeño proyecto para practicar, entre otros:
 Hacer un contador con ledes y un botón para iniciar la cuenta.
 Haz un pequeño juego que ilumine varios ledes en secuencia hasta que
se presione un botón. Si el led encendido es uno determinado, suena
una melodía.
 Haz un círculo de ledes y con un pontenciómetro haz que los ledes se
iluminen en una secuencia circular más o menos rápido.
 Haz el juego “simón dice”.
 Haz un piano con un piezo eléctrico y varios botones.
 Haz un theremin con una LDR y un piezo eléctrico.
Para encontrar más proyectos hechos con Arduino, te recomiendo visitar la
página web del proyecto Arduino: http://arduino.cc, en especial el blog, dónde
se presentan nuevos inventos cada semana

56

1

Más contenido relacionado

La actualidad más candente (15)

Similar a 1 (20)

Más de informaticacuitlahuac (20)

Último (20)

1