Arduino: Índice

Arduino
Versión 1.0
Índice:
1. Introducción a Arduino 1
2. La placa Arduino UNO 3
3. Programar la placa Arduino 5
4. Salidas digitales 1 7
5. Salidas digitales 2 9
6. Entradas digitales 1 12
7. Entradas digitales 2 16
8. Entradas analógicas 19
9. Salidas analógicas 23
Este texto es la versión offline/imprimible de uno de los capítulos del libro de texto multimedia de la web educativa www.tecno12-18.com.
Todos los derechos reservados. Se permite a los alumnos que han comprado una suscripción a la versión individual del libro que incluya este
capítulo, y a los profesores de estos alumnos, mantener una copia de este archivo PDF y/o imprimirlo, en ambos casos para uso exclusivamente
personal. En todos los demás casos no está permitida la reproducción total o parcial de esta obra, ni su almacenamiento en un sistema
informático, ni la distribución mediante cualquier medio electrónico, mecánico u otros sin el permiso previo y por escrito de los titulares del
copyright.
1. Introducción a Arduino
Introducción
Arduino es una plataforma de control automático basada en hardware y software open source que se ha hecho muy
popular. Se utiliza ampliamente en educación y en la creación de prototipos tecnológicos y artísticos.
Arduino se basa en unos componentes electrónicos llamados microcontroladores, así que empezaremos viendo qué
son los microcontroladores y después pasaremos a ver cuáles son las características y las aplicaciones de Arduino.
En otras miniunidades haremos una introducción a la programación de Arduino.
1.1. ¿Qué es un microcontrolador?

Los microcontroladores son pequeños ordenadores integrados en un solo chip. Recuerda que un chip, también
llamado circuito integrado o microchip, es un circuito electrónico miniaturizado que tiene un encapsulado de plástico
o cerámica que lo protege.
Lo que hace diferentes a los microcontroladores de otros chips es que tienen dentro un programa que modifica su
comportamiento en función de la información que llega del exterior. Este programa puede ser muy complejo y se
puede cambiar fácilmente si es necesario. Usar microcontroladores es la manera más sencilla y barata de hacer que
una máquina sea inteligente.
Hay muchos microntroladores diferentes y pueden tener apariencias y tamaños muy diversos, es necesario consultar
la documentación técnica del fabricante para poderlos identificar y saber qué pueden hacer.
1.2. Los microcontroladores siguen el esquema entrada-proceso-salida

Los microcontroladores, como todos los ordenadores, siguen un esquema denominado entrada-proceso-salida
("input-process-output", en inglés). Reciben información del exterior a través de dispositivos de entrada, como
pulsadores o sensores diversos. Dentro tienen un circuito que procesa información (la CPU, del inglés "Central
Processing Unit", Unidad Central de Proceso) y una memoria. Los datos del exterior se procesan en la CPU
siguiendo las instrucciones de un programa guardado en la memoria. Como resultado se generan órdenes que van a
los dispositivos de salida o actuadores. Los actuadores (motores, indicadores luminosos, pantallas, etc.) efectúan el
trabajo práctico que sea necesario.
1.3. Microcontroladores por todas partes

Los microcontroladores están por todas partes: ascensores, hornos microondas, televisores, teléfonos, sistemas de
domótica, herramientas eléctricas, instrumentos de medida... casi todas las máquinas actuales tienen
microcontroladores; las máquinas más complejas, como los automóviles, tienen decenas de ellos. En las impresoras
de inyección de tinta, por ejemplo, un microcontrolador se encarga de controlar los motores eléctricos que mueven el
papel y los cartuchos y de hacer que la tinta se inyecte cuando es necesario para formar las letras y los dibujos.
Razones del éxito de los microcontroladores
1. Son flexibles: Cambiando el programa que tienen en la memoria se puede hacer que un mismo microcontrolador
controle máquinas totalmente diferentes.
2. Son baratos: Los más sencillos tienen un precio de decenas de céntimos de euro.
3. Son pequeños: Se pueden integrar en cualquier máquina independientemente de su tamaño.
4. Consumen poca energía: Se pueden instalar en máquinas alimentadas por baterías.
1.4. ¿Qué es Arduino?

Arduino es una plataforma de control automático basada en microcontroladores. El proyecto se inició en el Instituto
de Diseño Interactivo de Ivrea (Italia) en el año 2005. Entre sus cinco fundadores se hallan el italiano Massimo Banzi
y el español David Cuartielles. El objetivo de Arduino es facilitar el uso de los microcontroladores: permitir que
cualquier persona pueda crear proyectos tecnológicos y artísticos controlados por microcontroladores de una manera
sencilla y barata.
La plataforma Arduino está formada por "hardware" y "software". El hardware consiste en una placa electrónica que
contiene un microcontrolador y todo lo necesario para conectarlo a los dispositivos de entrada y salida. El software es
un programa que permite programar el microcontrolador conectándolo (normalmente mediante un cable USB) a un
ordenador.
1.5. Arduino es hardware y software open source

Además de ser sencillo y de bajo coste, el tercer elemento que define la plataforma Arduino es que es "open source",
tanto el software como el hardware.
El software que se usa para programar Arduino es open source
Un programa informático es open source (también llamado de "código abierto") cuando sus creadores hacen público
el código fuente: se puede descargar desde una página web. Cualquier técnico puede bajar este código, analizarlo
para aprender cómo funciona y, si es necesario, modificarlo para mejorar sus características. Recuerda que el código
fuente es el texto que un informático escribe usando un lenguaje de programación para crear un programa de
ordenador. Si el código fuente no está disponible decimos que se trata de software propietario.
Las placas Arduino son hardware open source
No es tan conocido el concepto de hardware open source (también llamado "hardware abierto", "open hardware" o
"hardware libre"), que consiste en aplicar este concepto al diseño de objetos físicos. Cuando una máquina o un
www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados.

dispositivo tiene una licencia de hardware open source, los creadores hacen públicos los planos del diseño, el listado
de todos los componentes necesarios y las técnicas que se deben usar para construirlo. Cualquier persona o
empresa puede utilizar esta información pública para materializar el diseño, modificarlo o incluso fabricarlo
industrialmente y venderlo.
Las licencias open source también tienen límites
Las licencias open source conceden muchas libertades que no están disponibles en productos "cerrados" protegidos
por patentes o derechos de autor. Pero una licencia open source también puede tener límites, cosas que el creador
de la licencia no permite hacer. En el caso de Arduino, por ejemplo, en el mercado hay muchas placas casi idénticas
a las de Arduino creadas por diferentes empresas, lo cual es legal porque tiene licencia open source. Pero estas
placas no pueden usar la marca Arduino, que es una marca registrada propiedad de BCMI, la empresa que crea la
plataforma Arduino. Estos productos deben usar otras marcas, aunque sus fabricantes pueden indicar que son
placas compatibles con Arduino.
1.6. Arduino es un proyecto que va evolucionando

La placa más conocida de la plataforma Arduino es Arduino UNO, la que normalmente se utiliza en educación y en
proyectos sencillos. Pero Arduino no es una placa, sino una plataforma que dispone de muchas placas diferentes y
que va evolucionando con nuevas placas y nuevos programas. Cada placa tiene características diferentes: la placa
Arduino Mega, por ejemplo, tiene más memoria que Arduino UNO. La placa Arduino Nano es como un Arduino UNO,
pero más pequeña, muy útil si el proyecto tiene que ser de tamaño reducido. También existen placas especializadas
como la Arduino Yún, que, además del microcontrolador, tiene un pequeño procesador con el sistema operativo
Linux que le da más potencia de cálculo.
1.7. ¿Qué se puede hacer con Arduino?

Conectando sensores y actuadores a una placa Arduino y programándola podemos controlar todo tipo de
dispositivos, desde actuadores básicos a máquinas complejas. Un ejemplo sencillo: una alarma. Se ha conectado un
sensor de movimiento y un zumbador (un actuador que emite sonido) a una placa Arduino UNO. Después se ha
puesto un programa en la memoria del microcontrolador que hace sonar el zumbador si el sensor detecta
movimiento.
Arduino facilita a los estudiantes iniciarse en el mundo de la robótica y el control automático, a los inventores fabricar
prototipos de sus inventos y a los artistas y diseñadores crear instalaciones interactivas. Si quieres ver algunos
ejemplos de proyectos, te recomendamos que consultes esta página: https://create.arduino.cc/projecthub
1.8. Módulos para Arduino

Para que la placa Arduino pueda hacer un trabajo útil necesita conectarse con el exterior a través de dispositivos de
entrada y de salida. Como hemos visto, se pueden conectar componentes electrónicos directamente a la placa
Arduino, pero frecuentemente se utilizan módulos, que son circuitos electrónicos que tienen todos los componentes
necesarios para hacer una función compleja, como proporcionar conexión a internet o controlar un motor. Los 3 tipos
de módulos más importantes son:
1. Módulos de sensores: Permiten captar información del exterior. Hay módulos con sensores de luz, sonido,
temperatura, humedad, gases, etc.
2. Módulos de electrónica de potencia: Sirven para controlar actuadores que requieren de mucha potencia, como
bombillas, motores, electroválvulas, etc.
3. Módulos de comunicaciones: Conectan Arduino a internet mediante wifi, mediante un cable "Ethernet" o mediante
la red de telefonía móvil usando la tarjeta SIM de un teléfono. Algunas placas Arduino tienen un módulo de conexión
a internet integrado (por ejemplo, el modelo Arduino UNO WiFi). También hay módulos "Bluetooth", que se suelen
usar para conectar directamente un "smartphone" a una placa Arduino.
1.9. Arduino y el internet de las cosas (IoT)

Se denomina internet de las cosas o IoT (de "Internet of Things") a la interconexión a través de internet de elementos
físicos: objetos, dispositivos, máquinas e incluso los cuerpos de las personas y los animales. En el mercado hay
muchos productos IoT, por ejemplo aparatos que permiten saber dónde está un vehículo en cada momento, pulseras
o relojes que monitorizan nuestra salud o sistemas de control de energía en casas e industrias. Un ejemplo de
dispositivo IoT doméstico son los termostatos wifi. Con estos termostatos podemos ver desde un móvil qué
temperatura hay en casa y encender o apagar a distancia la calefacción o el aire acondicionado.
El desarrollo de nuevos productos IoT es algo lento, caro y arriesgado económicamente. Antes de fabricar un nuevo
producto de forma masiva algunas empresas crean prototipos rápidos y baratos usando la plataforma Arduino. Estos
prototipos les permiten decidir si el producto es viable sin hacer grandes inversiones.
Para crear un sistema IoT con Arduino tenemos que conectarlo a internet mediante un módulo de comunicaciones (o
usar una tarjeta que ya tenga el módulo incorporado). Entonces podremos enviar la información captada por los
sensores conectados a Arduino a un servidor de internet, donde puede ser almacenada. Desde un navegador web o
una aplicación para móviles podremos consultar esta información.
También se puede hacer lo contrario: enviar órdenes desde un navegador web o una aplicación móvil a una placa
Arduino para controlar actuadores (como motores o luces) desde cualquier parte del mundo.
www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 2

1.10. Arduino y las smart cities
Desde hace unos años se está trabajando en convertir las ciudades en "smart cities" (ciudades inteligentes). Este
concepto consiste en aplicar las tecnologías de la información y de la comunicación (TIC) a las ciudades con el
objetivo de mejorarlas desde un punto de vista económico, social y ambiental.
Situando sensores en el emplazamiento adecuado se puede captar información relacionada con el tráfico, las
emisiones de gases contaminantes, el uso de energía en los edificios, la iluminación, la protección civil, etc. A
continuación esta información se hace llegar a aquellas instituciones públicas, empresas y ciudadanos que puedan
utilizarla para conseguir una mejora en la ciudad o en la calidad de vida de sus habitantes. Los alcaldes, por ejemplo,
podrán mejorar sus políticas públicas si disponen de información de calidad.
Un ejemplo cotidiano de sistema smart city son las aplicaciones que permiten saber a los usuarios cuándo llegará un
autobús a una parada. Para poder ofrecer este servicio es necesario que todos los autobuses estén geolocalizados y
que se envíe esta información a un servidor de internet para que la aplicación móvil pueda leerla y calcular cuánto
tardará un autobús en llegar.
Muchos técnicos y estudiantes universitarios o de secundaria están usando placas Arduino para crear prototipos de
internet de las cosas (IoT) dirigidos a mejorar algún aspecto de la ciudad. Por ejemplo: distribuyendo por la ciudad
placas Arduino con conexión a internet y sensores de gases, se puede tener un modelo de la contaminación que hay
en la ciudad en tiempo real.
1.11. Arduino y la industria

Debido a su sencillez y bajo precio, se está usando Arduino para crear prototipos de máquinas industriales. Pero
también se pueden encontrar productos comerciales hechos con Arduino y otras plataformas de hardware abierto.
El ejemplo más común es el de las impresoras 3D, muchas de las cuales utilizan Arduino como controlador: una
placa Arduino controla el movimiento del cabezal de extrusión (por donde sale el plástico fundido para imprimir
objetos). Lo hace accionando 4 motores mediante un módulo de electrónica de potencia (Arduino no puede accionar
los motores directamente, necesita usar un módulo de electrónica de potencia especializado en el control de
motores).
2. La placa Arduino UNO
Introducción
En la miniunidad anterior vimos qué es la plataforma Arduino y para qué se utiliza. Vimos también que la plataforma
Arduino está formada por varias placas electrónicas que tienen un microcontrolador y por programas que permiten
programar estas placas. Ahora vamos a estudiar cómo es la placa más popular, la placa Arduino UNO.
2.1. Microcontrolador
Arduino UNO está compuesto por una placa o tarjeta electrónica (también llamada PCB, de "Printed Circuit Board",
Tarjeta de Circuito Impreso) donde se sueldan diversos componentes electrónicos. El componente más importante
es el microcontrolador, un chip Atmega328P del fabricante Atmel. El microcontrolador tiene una memoria donde se
guarda un programa y un circuito miniaturizado que procesa información (la CPU, "Central Processing Unit").
Podemos decir que es el "cerebro" del sistema.
2.2. Programa
Las placas Arduino sirven para controlar actuadores (como luces o motores). El void setup(){
programa que hay en la memoria del microcontrolador ordena cuándo deben pinMode(13, OUTPUT);
encenderse o apagarse. Aquí puedes ver qué aspecto tiene un programa sencillo. }
Para programar la placa (cambiar el programa) primero se debe escribir el programa void loop(){
en un ordenador, en las próximas miniunidades veremos cómo se hace. digitalWrite(13, HIGH);
delay(1000);
2.3. Puerto USB digitalWrite(13, LOW);
El cable USB sirve para programar la placa y también para alimentarla con delay(1000);
electricidad (a 5 V). Una vez que tenemos el programa que ejecutará la placa Arduino }
UNO, debemos grabarlo en la memoria del microcontrolador. Se hace conectando la
placa al ordenador mediante un cable USB. Este cable tiene una segunda función: alimentar la placa con electricidad
que sale del ordenador.
2.4. Indicadores luminosos

La placa Arduino UNO tiene 4 ledes (indicadores luminosos). El led ON o led de encendido se ilumina cuando la
placa está en funcionamiento. El Led L o led integrado se puede encender y apagar mediante el programa que hay
en la memoria, sirve para hacer pruebas. Los ledes TX y RX parpadean cuando la placa se está comunicando con el
ordenador a través del cable USB, por ejemplo al cargar un programa. El TX se ilumina cuando la placa está
enviando datos y el RX cuando los está recibiendo.

2.5. Botón de reset
A veces necesitamos que el programa que está siendo ejecutado en la placa se pare y vuelva a comenzar desde el
principio, esto se consigue pulsando brevemente el botón de reset.
2.6. Jack de alimentación

Para hacer prácticas normalmente tendremos la placa Arduino UNO conectada al ordenador mediante un cable USB.
Sin embargo, en proyectos acabados (un robot móvil, por ejemplo) es necesario que la placa funcione sin ordenador.
Si ya tiene el programa cargado en la memoria, solo hay que alimentarla con energía eléctrica para que comience a
funcionar. Se hace conectando en el jack de alimentación de la placa una pila o una fuente de alimentación
(parecidas a los cargadores de los móviles). Admite entre 7 y 12 V de corriente continua.
2.7. Pines de potencia

La placa Arduino UNO funciona internamente con corriente
continua de 5 V, que es la tensión que recibe del ordenador
cuando está alimentada por el cable USB. También funciona
con 5 V cuando se alimenta con el jack de alimentación
(entre 7 y 12 V), un chip regulador de tensión se encarga de
reducirla. Esta corriente interna se puede usar para alimentar
pequeños circuitos externos, como el que puedes ver en el
ejemplo de la derecha. La placa tiene dos conectores (se les
suele llamar "pines") que suministran corriente continua a 5 y
a 3,3 V. En el ejemplo, el cable rojo se conecta al pin de
alimentación a 5 V (es el terminal positivo, desde donde sale
corriente) y llega hasta el led rojo (la resistencia intercalada
reduce la corriente que llega al led, evitando que se queme).
Para cerrar el circuito y que circule la corriente, el otro
terminal del led se conecta al polo negativo del circuito
mediante el cable negro. El polo negativo en los circuitos
electrónicos se llama también "masa" o, en inglés, "ground",
que suele indicarse con las siglas GND. Como puedes ver en
el dibujo, Arduino UNO tiene 3 pines GND. Los 3 están
conectados internamente, se pueden usar indistintamente.
2.8. Salidas digitales

Vimos que Arduino sirve para controlar actuadores (como luces o motores), pero, ¿cómo los controla? ¿Cómo les
ordena que se enciendan o se apaguen? Lo hace a través de las salidas digitales. Son pines donde se insertan
cables para conectar componentes electrónicos o circuitos externos. Arduino UNO tiene 14 salidas digitales, la
primera es el pin 0 y la última el pin 13 (ver dibujo). Cuando el programa que hay en el microcontrolador decide
encender un actuador envía una pequeña corriente de 5 V al pin donde está conectado ese actuador. Cuando decide
apagarlo retira la corriente (y la tensión en el pin vuelve a ser de 0 V). Las salidas digitales sólo pueden tener dos
valores: 0 (apagado, 0 V) o 1 (encendido, 5 V).
Si el actuador es un componente electrónico que no requiere mucha energía (como un led o un zumbador), se
encenderá o apagará directamente. Pero si conectamos actuadores que consumen mucha energía, la pequeña
corriente que llega al pin no podrá encenderlos directamente, se debe usar entonces un módulo de electrónica de
potencia (un circuito que abre o cierra circuitos externos siguiendo las órdenes de Arduino).
2.9. Entradas digitales

Las entradas le sirven al microcontrolador para captar información del exterior y saber "qué está pasando ahí fuera".
Las entradas de tipo digital solo pueden tener dos valores: 0 o 1. Tienen valor 0 cuando en el pin de la entrada digital
hay una tensión de 0 V y tienen valor 1 cuando hay 5 V.
Arduino UNO tiene 14 entradas digitales, que son las mismas que las salidas digitales: los pines del 0 al 13. Es decir,
los pines del 0 al 13 pueden funcionar como salidas o como entradas digitales, solo hay que indicarlo en el programa
que es ejecutado por la placa, en otra miniunidad veremos cómo se hace.
Ejemplo: se utiliza el pin 7 como entrada digital para que el microcontrolador sepa si alguien ha presionado un
pulsador. Se toma corriente de la salida de potencia a 5 V y se envía hasta uno de los pines de masa (GND). Para
evitar que pase mucha corriente y la placa pueda estropearse, se coloca una resistencia intercalada. La corriente
solo circulará si se activa el pulsador (que es un tipo de sensor). Una derivación de esta corriente se hace llegar
hasta la entrada digital del pin 7, donde el microcontrolador puede detectarla y saber de esta manera que alguien ha
presionado el pulsador. La intensidad que circula por las entradas es muy pequeña ya que tienen una resistencia
interna muy alta.
2.10. Entradas analógicas

Hemos visto que las entradas digitales pueden recibir sólo dos valores de tensión: 0 V y 5 V. En el ejemplo anterior 0
V indicaría al microcontrolador que nadie presiona el pulsador y 5 V que alguien lo presiona. Pero además de las

entradas digitales, Arduino UNO tiene también 6 pines de entradas analógicas: los pines A0, A1, A2, A3, A4 y A5.
Estas entradas pueden recibir tensiones de cualquier valor comprendido entre 0 y 5 V (por ejemplo: 3,5 V).
Los datos analógicos son muy útiles porque dan al microcontrolador una información más rica de lo que pasa en el
exterior. No solo le informan de si un suceso está pasando o no (pulsador presionado o no), sino que también le
indican qué intensidad tiene el parámetro que se está midiendo. Si, por ejemplo, se está midiendo la luz del exterior,
con una entrada analógica el microprocontrolador no sólo podrá saber si hay luz o no (lo que sería una entrada
digital) sino también si hay mucha o poca luz (recibiría más o menos tensión en la entrada analógica).
Ejemplo: se conecta una fuente de alimentación que suministra tensiones de entre 0 y 5 V a la entrada analógica A0
para simular la recepción de datos analógicos. La lectura de valores analógicos en Arduino UNO tiene 1024 niveles
de sensibilidad, por lo que el microcontrolador traduce la tensión que le llega (entre 0 y 5 V) proporcionalmente a
valores entre 0 y 1023.
2.11. Salidas analógicas

Algunas placas con microcontroladores, además de entradas analógicas, tienen también salidas analógicas. Son
pines con una tensión de salida que puede ser variada continuamente por el microcontrolador, normalmente entre 0 y
5 V.
Las salidas analógicas son útiles para controlar con precisión algunos actuadores: el brillo de una bombilla, la
temperatura de un horno y también para reproducir sonidos con calidad.
Arduino UNO no tiene salidas analógicas porque incrementarían su precio (necesitan un chip denominado
"Conversor Digital Analógico"), pero sí que tiene 6 salidas digitales que pueden emular parcialmente las salidas
analógicas. Son los pines 3, 5, 6, 9, 10 y 11, los que están marcados con el símbolo ~. Utilizan una técnica llamada
PWM ("Pulse Width Modulation", Modulación de Ancho de Pulso), que consiste en apagar y encender muy
rápidamente las salidas digitales de 5 V para reducir la tensión equivalente que recibe el circuito externo. Ejemplo: el
microcontrolador enciende y apaga rápidamente la salida 6 (980 de veces por segundo en la realidad). Cuando la
salida está encendida el led recibe 5 V y cuando está apagada recibe 0 V. Como la salida está encendida el mismo
tiempo que apagada, el resultado es que de media el led recibe una tensión de 2,5 V y por lo tanto brilla con la mitad
de intensidad que si estuviera alimentado a 5 V. Aumentando o disminuyendo el tiempo que está encendida la salida
(el ancho del pulso) podemos modificar la tensión equivalente que se aplica al circuito exterior.
3. Programar la placa Arduino
Introducción
En la miniunidad anterior vimos cómo es la placa Arduino UNO. Ahora vamos a programarla y ponerla en
funcionamiento por primera vez. La haremos funcionar de la manera más sencilla posible: sin conectarla a ningún
circuito externo y grabando en su memoria un programa muy básico que hará que el led L (el indicador luminoso
integrado en la placa que sirve para hacer pruebas) se encienda y se apague cada segundo. Para programar la placa
usaremos el entorno de programación de Arduino (el IDE de Arduino). Finalmente veremos en qué consiste la
programación visual.
3.1. El IDE de Arduino

Un IDE (del inglés "Integrated Development Environment", Entorno de Desarrollo Integrado) es un programa
informático que sirve para crear otros programas. Arduino tiene un IDE oficial, el IDE de Arduino, que permite crear
los programas que se ejecutan en las placas. Para hacer las prácticas de este capítulo puedes usar la versión de
escritorio del IDE de Arduino o la versión web. Sigue las instrucciones que encontrarás en sus páginas web:
Versión de escritorio: Es un programa que debes descargar e instalar en tu ordenador.
URL: https://www.arduino.cc/en/software
Versión web: También se llama "Arduino Web Editor". Para usarlo debes crear una cuenta con tu email e instalar el
agente de Arduino, un pequeño programa (o una app en Chromebooks) necesario para que el editor web se
comunique con tu ordenador. Muchas placas no oficiales no son compatibles con esta versión del IDE. Se puede
comprobar desde su interfaz, en el desplegable "Select Board and Port". URL: https://create.arduino.cc/editor
3.2. Programar la placa Arduino. Crear un nuevo programa

Abre el IDE de Arduino (en este capítulo se utilizará la versión web del IDE, pero puedes usar la versión de escritorio
si lo prefieres). Aparecerá por defecto una ventana. Se trata de un programa vacío, preparado para que podamos
empezar a escribir nuestro código. Los programas en Arduino se llaman "sketches" (bocetos). Veremos qué partes
tiene un sketch y cómo crear uno desde cero.
Nombre del archivo. En la versión web puedes cambiarlo clicando encima, en la versión de escritorio debes ir a
Archivo > Guardar Como. Los programas creados con el IDE de Arduino se guardan en archivos que tienen la
extensión "ino".
Siempre que quieras crear un nuevo programa:
Versión web: Sketchbook > New Sketch
Versión de escritorio: Archivo > Nuevo

3.2. Programar la placa Arduino. Encender y apagar el led integrado (led L)
Durante el resto de la miniunidad iremos introduciendo código en el programa vacío para crear el programa para
Arduino más sencillo que existe: hacer que parpadee el led integrado en la placa.
3.2. Programar la placa Arduino. Introducir comentarios en el código

Lo primero que vamos a hacer es poner comentarios en el programa. Los comentarios son explicaciones que facilitan
a los programadores entender para qué sirve el código, especialmente si es un proyecto complejo donde trabajan
varias personas. Para evitar que los comentarios sean leídos por el microcontrolador y generen errores hay que
poner unas marcas: /* y */ para comentarios multilínea y // para los de una sola línea.
1. En la línea 1 pon una diagonal y un asterisco para iniciar un comentario multilínea.
2. En las líneas 2 y 3 escribe este comentario que explica qué hará el programa que vamos a escribir debajo.
3. En la línea 4 pon un asterisco y una diagonal para finalizar el comentario multilínea.
4. Si el comentario ocupa una sola línea solo hay que poner dos diagonales al principio.
1 /*
2 Este programa hace parpadear el led
3 integrado de la placa Arduino.
4 */
5
6 //La función setup se ejecuta una sola vez.
7 void setup(){
8 pinMode(13, OUTPUT);
9 }
10
11 // La función loop se ejecuta continuamente.
12 void loop(){
13 digitalWrite(13, HIGH);
14 delay(1000);
15 digitalWrite(13, LOW);
16 delay(1000);
17 }
3.2. Programar la placa Arduino. Funciones setup y loop

Al crear un nuevo programa, el IDE escribe las funciones setup() y loop() vacías. Las funciones son un conjunto de
instrucciones (las que pongamos entre las llaves { } ) que se ejecutan al ser llamadas desde otra parte del código.
Estas dos funciones son especiales porque son llamadas automáticamente por el programa que hace funcionar a la
placa (el firmware): primero llama a la función setup() que solo se ejecuta una vez al encenderse la placa y a
continuación a la función loop(), que se ejecuta continuamente.
1. La función setup() solo se ejecuta una vez, al encender la placa o pulsar el botón Reset. Escribe el comentario
para que puedas recordarlo fácilmente (línea 6).
2. La función loop() se ejecuta continuamente. Actualiza el comentario para recordarlo (línea 11).
3.2. Programar la placa Arduino. Programar la función setup (línea 8)

Las funciones se declaran escribiendo el nombre de la función, en este caso es "setup" (configuración), seguido de
un doble paréntesis y una doble llave. Entre las llaves se deben escribir las instrucciones que se ejecutarán
automáticamente cuando la función sea llamada. La palabra "void" (vacío) se pone al principio para indicar que la
función no va a devolver ningún dato si es llamada desde otra parte del código.
Escribe en la línea 8 la instrucción. En ella se usa la función pinMode para decirle al microcontrolador que ponga el
pin 13 en modo salida ("output", en inglés), es decir, listo para enviar órdenes hacia el exterior.
Si pusiéramos "pinMode(13, INPUT);" el pin 13 se pondría en modo entrada, es decir, listo para captar información
del exterior.
Fíjate en que las instrucciones que hay dentro de las funciones deben terminan con un punto y coma.
El led L está conectado internamente al PIN 13. Si activamos la salida digital 13, se ilumina el led L.
3.2. Programar la placa Arduino. Programar la función loop (línea 13)

Escribe en la línea 13 la primera instrucción dentro de la función loop(). La función digitalWrite se usa para activar o
desactivar pines digitales (los pines del 0 al 13). El número del paréntesis indica al microcontrolador el pin que debe
activar o desactivar. Si se pone el valor "HIGH" se envía una tensión de 5 V (encendido), mientras que con "LOW" la
tensión es de 0 V (apagado). Como el led L está conectado al pin 13, cuando el pin 13 reciba corriente eléctrica a 5
V, el led L se iluminará.
3.2. Programar la placa Arduino. Programar la función loop (línea 14)

Escribe en la línea 14 la segunda instrucción. En ella se usa la función delay (demorar, en inglés) para decirle al
microcontrolador que haga una pausa durante el tiempo que le indicamos entre paréntesis, expresado en
milisegundos. Como hemos puesto 1000, el microcontrolador esperará 1000 milisegundos, es decir, 1 segundo.

3.2. Programar la placa Arduino. Programar la función loop (líneas 15 y 16)
Para acabar el programa escribe en las líneas 15 y 16 las dos instrucciones. La línea 15 tiene el valor LOW, que
indica al microcontrolador que debe dejar de enviar 5 V a la salida 13, por lo que el led L se apagará. La última línea
es otra pausa de 1 segundo. Tras esta pausa la placa volverá a leer la línea 13 donde se da la orden de volver a
encender el led.
Recuerda que la función "loop" (bucle, en inglés), se ejecuta constantemente mientras que la placa esté alimentada
con electricidad. Se irán ejecutando línea a línea todas las instrucciones que hayamos escrito entre las llaves de la
función: primero la línea 13, luego la 14, la 15, finalmente la 16 y después volverá a ejecutar la línea 13 de nuevo, sin
parar.
3.2. Programar la placa Arduino. Conectar la placa al ordenador

Ya entendemos el programa. Ahora conectamos la placa al ordenador.
1. Conecta la placa Arduino a un puerto USB de tu ordenador.
2. En Arduino Web Editor el programa detecta automáticamente la placa conectada al ordenador y se muestra. En la
versión de escritorio se debe configurar la conexión la primera vez que se usa la placa, se hace de la siguiente
manera: Herramientas > Placa: "Arduino Uno" > Arduino Uno. Y después Herramientas > Puertos > Selecciona el
puerto donde aparezca Arduino Uno.
3.2. Programar la placa Arduino. Grabar el programa en la memoria de la placa

Para finalizar cargamos el programa en la placa Arduino. Desde ese momento, como la placa tiene alimentación
eléctrica que proviene del ordenador a través del cable USB, comenzará a funcionar y a ejecutar el programa.
1. Haz clic en el icono de la flecha para hacer que el IDE de Arduino grabe en la memoria de la placa el programa
que hemos escrito. Antes de grabarlo, el IDE compilará el programa, es decir, lo traducirá a código máquina, un
lenguaje basado en 0 y 1 que es el único que puede entender el microcontrolador.
2. El led L de la placa empezará a parpadear siguiendo el programa.
3.3. Programación visual

En el IDE de Arduino se usa una adaptación del lenguaje de programación C++ (pronunciado "ce más más" o "ce
plus plus"). Como hemos visto, es un lenguaje de programación basado en texto: los programas se escriben línea a
línea, de forma parecida a como escribimos un texto en inglés. Merece la pena aprender la base de los lenguajes
basados en texto porque son los que utilizan los programadores profesionales, pero para hacer pequeños proyectos
de Arduino también es interesante usar editores de programación visual. En la programación visual los programas se
crean uniendo bloques, que son dibujos que tienen código asociado. Son sencillos de usar porque no es necesario
aprender ningún lenguaje de programación, aunque sí tener conocimientos de pensamiento computacional (cómo
resolver problemas ordenadamente y usando la lógica, como hacen los programadores profesionales). Hay muchos
editores visuales, uno de ellos: Arduinoblocks.
4. Salidas digitales 1
Introducción
En la miniunidad anterior practicamos por primera vez con Arduino creando un programa que hace parpadear el led L
(un led integrado en la placa que sirve para hacer pruebas). Ahora, usando el mismo programa, vamos a hacer
parpadear un led situado en un circuito externo. Es un circuito muy sencillo, pero muy importante por sus
aplicaciones prácticas, ya que desde Arduino se controla igual un humilde led que una máquina industrial de miles de
vatios de potencia: enviando 0 o 5 V al pin de la salida digital donde está conectado el actuador. Recuerda que
Arduino UNO tiene 14 salidas digitales.
Cuando el programa que hay en el microcontrolador decide encender un actuador envía una pequeña corriente de 5
V al pin donde está conectado. Cuando decide apagarlo retira la corriente y la tensión en el pin vuelve a ser de 0 V.
Las salidas digitales sólo pueden tener dos valores: 0 (apagado, 0 V, LOW en el código) o 1 (encendido, 5 V, HIGH
en el código). En el circuito que vamos a estudiar el led externo está conectado a la salida digital 13, que es la salida
a la que también está conectado internamente el led L, por lo que podremos usar el programa de la miniunidad
anterior.
4.1. Material necesario

Para hacer esta práctica necesitarás los siguientes componentes:
- Placa Arduino UNO y cable USB para conectarla al ordenador.
- Protoboard.
- Led rojo. La pata más larga siempre se conecta al polo positivo del generador.
- Resistor de 220 Ω.
- 2 cables para hacer las conexiones. También se les llama "jumpers" o cables puente.

4.2. La placa de pruebas o protoboard
Para montar el circuito utilizaremos una placa de pruebas o
protoboard. Es una placa de plástico que tiene una matriz de
agujeritos (los "pines") conectados eléctricamente entre sí
mediante conductores internos (las líneas de color rosa en la
imagen de la derecha). Permiten montar rápidamente un
circuito pinchando las patillas de los componentes y los
cables en los agujeritos. El circuito se puede desmontar
fácilmente estirando de los componentes y los cables.
Los pines de los buses de alimentación están conectados
internamente en filas. Sirven para conectar la placa a un
generador.
Los pines centrales están conectados internamente en
columnas.
4.3. Montar el circuito

Conecta los componentes como se indica en la imagen de la
derecha. Antes de poner en marcha el circuito repasa
atentamente que todo esté bien conectado. Si el circuito está
mal conectado no funcionará, e incluso podría estropearse
alguno de sus componentes.
A destacar:
- El led tiene polaridad: la pata más larga debe conectarse al
polo +.
- El cable rojo (quizás tú uses otro color) debe conectarse al
pin digital 13 de Arduino.
4.4. Esquema eléctrico

El esquema eléctrico del circuito es el que se muestra a la derecha. Un
esquema eléctrico es un dibujo que describe cómo están conectados
los componentes de un circuito. Cada componente tiene un símbolo,
que es un dibujo que lo representa de forma simplificada. Arriba
puedes ver cómo están conectados los componentes en las
conexiones internas de la protoboard.
4.5. Escribir el programa

Abre el IDE de Arduino y escribe el mismo programa que en la miniunidad anterior. Es interesante recordar que…
La función setup() se ejecuta una sola vez al encender la placa o pulsar el botón reset.
La función loop() se ejecuta constantemente mientras la placa está encendida.
La función pinMode sirve para configurar si el pin digital indicado es de salida o de entrada.
La función digitalWrite enciende (HIGH) o apaga (LOW) salidas digitales.
La función delay pausa el programa durante el tiempo (en milisegundos) que escribamos entre paréntesis.
4.6. Grabar el programa en la memoria de la placa

1. Haz clic en el icono de la flecha para hacer que el IDE de Arduino grabe en la memoria del microcontrolador el
programa que hemos escrito.
2. El led de la protoboard empezará a parpadear siguiendo el programa.
4.7. Hacer las prácticas en un simulador de Arduino

Si no dispones de los componentes para hacer las prácticas, puedes usar un simulador de Arduino. Los simuladores
son programas que permiten crear circuitos seleccionando los componentes necesarios, escribir el código asociado y
comprobar que funcionan correctamente sin tener que montarlos en la realidad. Te recomendamos dos simuladores
online:
Tinkercad: Muy completo. Para usarlo debes crear una cuenta con tu email.
URL: https://www.tinkercad.com/dashboard?type=circuits
Wokwi: Más limitado (no dispone de placa de prototipos), pero se puede usar sin crear una cuenta.
URL: https://wokwi.com/
1. Se crea el circuito arrastrando los componentes necesarios.
2. Se escribe el código y se pulsa el botón Iniciar simulación. El led de la protoboard virtual empezará a parpadear
siguiendo el programa.

4.8. Usar módulos de electrónica de potencia para controlar actuadores potentes
Hemos visto que Arduino puede encender directamente actuadores de poca potencia como los ledes. Pero para
controlar actuadores en aplicaciones prácticas (bombillas, sistemas de calefacción, motores grandes...), la pequeña
corriente que llega al pin de salida no puede encenderlos directamente, se debe usar un módulo de electrónica de
potencia. Ejemplo: se utiliza un módulo de relé para poder encender y apagar una bombilla. Un relé es un interruptor
controlado por la electricidad. Tiene un electroimán que, a través de una palanca, abre o cierra un interruptor
formado por dos láminas metálicas. Cuando las dos láminas se tocan circula corriente por el circuito de potencia, que
está formado por una bombilla conectada a un enchufe de 230 V de corriente alterna. Arduino controla el relé a
través de tres cables: dos proporcionan corriente para que funcione el electroimán y el tercero, envía una señal de 5
V al circuito electrónico del módulo de relé cuándo este debe activar el electroimán.
5. Salidas digitales 2
Introducción
En la miniunidad anterior montamos un circuito con un led externo y escribimos un programa que lo hacía parpadear.
Ahora crearemos un circuito un poco más completo: 3 ledes que parpadean de forma secuencial, de derecha a
izquierda. La salida digital 2 controlará el led de la derecha, la salida 3 el led del centro y la salida 4, el led de la
izquierda. El retorno de la corriente que atraviesa cada uno de los ledes se produce a través del pin GND ("ground",
masa) que hay a la izquierda del pin 13.
Primero montaremos el circuito en una protoboard y después escribiremos el programa que lo controlará. Haremos
una primera versión del programa repitiendo las instrucciones del programa que hicimos en la miniunidad anterior.
Después lo mejoraremos introduciendo una variable para controlar el tiempo de parpadeo y finalmente haremos una
tercera versión con una estructura de programación llamada "bucle for".
Versión 1: Repitiendo instrucciones

Versión 2: Delay con variable timer
Versión 3: Bucle for

- Protoboard.
- 3 ledes rojos.
- 3 resistores de 220 Ω.
- 7 cables.

Conecta los componentes como se indica en esta imagen. Antes de
poner en marcha el circuito, repasa atentamente que todo esté bien
conectado.
A destacar:
- El led tiene polaridad: la pata más larga debe conectarse al polo +.
- Los cables rojos (quizás tú uses otro color) deben conectarse a los
pines digitales 2, 3 y 4 de la placa Arduino.

A la derecha se muestra el esquema eléctrico del circuito.

5.4. Diagrama de flujo
Antes de comenzar a escribir un programa hay que describir exactamente, paso a paso,
qué queremos que haga el programa y en qué orden. Es lo que se conoce como algoritmo.
La representación gráfica de un algoritmo se hace mediante un diagrama de flujo. Aquí
puedes ver el diagrama de flujo del programa que vamos a escribir para que haga
parpadear de forma secuencial los 3 ledes.
Símbolos básicos de los diagramas de flujo:
Inicio o final de diagrama
Entrada o salida de datos
Realización de una actividad/proceso/orden
Análisis de la situación y toma de decisiones
Indica el flujo del proceso
5.5. Escribir el programa. Versión 1: Repitiendo instrucciones

Abre el IDE de Arduino y escribe el programa de debajo. Es un programa basado en el que
hicimos en la miniunidad anterior para hacer parpadear un led, solo que ahora se repiten
las instrucciones tres veces porque hay tres ledes:
1. En la función setup() se definen los pines digitales 2, 3 y 4 como salidas (OUTPUT).
2. En la función loop() se van encendiendo y apagando los pines 2, 3 y 4 de forma secuencial.
Graba el programa en la placa y comprueba que funciona.
Versión 1 Versión 2
1 void setup(){ 1 int timer = 500;
2 pinMode(2, OUTPUT); 2
3 pinMode(3, OUTPUT); 3 void setup(){
4 pinMode(4, OUTPUT); 4 pinMode(2, OUTPUT);
5 } 5 pinMode(3, OUTPUT);
6 6 pinMode(4, OUTPUT);
7 void loop(){ 7 }
8 digitalWrite(2, HIGH); 8
9 delay(500); 9 void loop(){
10 digitalWrite(2, LOW); 10 digitalWrite(2, HIGH);
11 delay(500); 11 delay(timer);
12 digitalWrite(3, HIGH); 12 digitalWrite(2, LOW);
16 digitalWrite(4, HIGH); 16 digitalWrite(3, LOW);
20 } 20 digitalWrite(4, LOW);
21 delay(timer);
22 }
5.6. Escribir el programa. Versión 2: Delay con variable timer

Ahora vamos a hacer una mejora en el programa, que será la versión 2. En la versión 1 la instrucción "delay(500)",
que ordena al microcontrolador a hacer una pausa de 500 milisegundos, se repite 6 veces. Si queremos cambiar este
tiempo, debemos cambiar el número 500 en las 6 líneas donde está escrito. Esto se puede simplificar poniendo el
valor del tiempo dentro de una variable. Una variable es un espacio en la memoria del microcontrolador donde se
guardan datos. Podemos imaginarla como una caja donde guardamos información. Al poner el tiempo dentro de una
variable solo hay que cambiar su valor una sola vez, en la línea 1, para que cambie en todo el programa.
1. Escribe la instrucción de la línea 1. Le dice al microcontrolador que debe crear una variable llamada "timer", que es
de tipo int (de "integer", número entero) y que tiene valor 500 (en milisegundos). La línea debe acabar en punto y
coma.
2. Pon "timer" en las 6 líneas donde antes ponía 500.
3. Prueba en la placa.

Hay muchos otros tipos de variables, como bool, byte, float, etc. Cada tipo tiene su utilidad. Si necesitas más
información sobre las variables o cualquier otro aspecto de la programación de Arduino es conveniente consultar la
página de referencia de su lenguaje de programación. Su dirección web es: https://www.arduino.cc/reference/en/
Variables globales versus variables locales
Las variables definidas fuera de una función, como nuestra variable "timer", son variables globales, lo que permite
leer su valor desde cualquier parte del código, en este caso es leída desde la función loop(). En cambio, las variables
que han sido definidas entre las llaves de una función (por ejemplo dentro de setup(), loop() u otras funciones) son
variables locales y sólo pueden ser leídas desde dentro de esa función.
5.7. Escribir el programa. Versión 3: Bucle for

Y finalmente haremos una segunda mejora, que será la versión 3. En el programa anterior (versión 2) se repiten tres
veces cuatro líneas de código, solo va cambiando el número de la salida que controlan. En programación, para evitar
tener que repetir varias veces las mismas instrucciones, se utilizan unas estructuras llamadas bucles ("loops", en
inglés). Uno de los bucles más usados es el bucle "for", lo vamos a usar para acortar el código que hay entre las
líneas 10 y 21.
1. Borra todas las líneas de código que hay dentro de la función loop(), excepto las líneas 10 a 13 (el primer grupo de
instrucciones que se repite).
Antes de utilizar el loop "for" debemos crear una variable en la que vamos a guardar el número del pin de salida. La
hemos llamado thisPin (aunque puede tener cualquier otro nombre). La declaramos como integer (número entero) y
le damos valor 2. Debes modificar también las líneas 11 y 13 sustituyendo el número 2 por la variable thisPin. A
continuación prueba el programa en la placa Arduino. Verás que el led conectado a la salida digital 2 parpadeará
siguiendo las instrucciones de las líneas 11 a 14. Si quieres cambiar el led que parpadea solo hay que cambiar el
valor de la variable thisPin en la línea 10. Si pones thisPin = 3, por ejemplo, parpadeará el led de la salida 3.
2. Declara la variable "thisPin" de tipo int ("integer") y ponle valor 2.
3. Pon "thisPin" en las 2 líneas donde antes ponía 2.
Ahora escribimos el bucle "for" para que vaya cambiando automáticamente el led que parpadea: primero el de la
salida 2, después el de la 3 y finalmente el de la 4. Solo tienes que escribir la línea 10 y la llave que hay en la 15.
Después prueba el programa en la placa Arduino. En la página siguiente veremos cómo funciona.
1. Escribe en la línea 10 el encabezado del bucle "for".
2. El bucle "for" se delimita con una llave de cierre.
1 int timer = 500;

2
3 void setup(){
7 }
8
9 void loop(){
10 for (int thisPin = 2; thisPin < 5; thisPin++) {
11 digitalWrite(thisPin, HIGH);
12 delay(timer);
13 digitalWrite(thisPin, LOW);
14 delay(timer);
15 }
16 }
El bucle "for" sigue 3 pasos:

1. Inicialización: Se define una variable que sirve como contador del número de repeticiones que hace el bucle. Se
ejecuta sólo una vez. Se crea una variable llamada "thisPin" y se le pone valor 2.
2. Condición: Se indica qué valor o rango de valores debe tener la variable contador para que el bucle ejecute el
código que hay entre las llaves. Si la variable no tiene este valor, el bucle se para. Si la variable "thisPin" es menor
que 5, se ejecuta el código entre las llaves.
3. Incremento: Se indica cuánto debe aumentar (o disminuir) el valor de la variable contador cada vez que se repite el
bucle. Se suma 1 a la variable "thisPin" y se vuelve a comprobar la condición.
Es fácil modificar un bucle "for" cambiando el valor inicial de la variable o cambiando la condición del bucle:
== Igual que. > Mayor que. >= Mayor o igual que.
!= No igual que. < Menor que. <= Menor o igual que.

O poniendo en el incremento la expresión "--", para que la variable thisPin se
decremente en 1, en lugar de incrementarse en 1. También se puede poner otras
condiciones. Por ejemplo, con thisPin = thisPin + 5, el incremento en cada repetición
será de 5 unidades y no de 1.
El bucle "for" se va a repetir 3 veces: cuando thisPin tiene valor 2, cuando tiene valor
3 y cuando tiene valor 4. Cuando thisPin pasa a valer 5, en la siguiente repetición, el
bucle se para porque ya no cumple la condición thisPin < 5. Pero, cuando lo
probamos en la placa, lo que ocurre es que después de parpadear el led 2, el 3 y el 4,
vuelve a comenzar de nuevo el led 2 y otra vez el 3 y el 4. ¿No se había parado el
bucle? La respuesta es que sí, el bucle "for" se ha parado después de 3 repeticiones,
pero entonces el bucle loop(), como ya no tiene más instrucciones, vuelve a activar el
bucle "for" otra vez y el proceso se reinicia.
A la derecha se muestra el diagrama de flujo.
5.8. Prácticas de ampliación

En internet encontrarás muchas prácticas que pueden servir para ampliar lo que vas
aprendiendo en este capítulo, desde circuitos sencillos hasta sofisticados proyectos
de robótica o automatización. Para ampliar esta miniunidad te sugerimos un par de
prácticas de la web "Arduino Documentation", editada por la empresa que fabrica las
placas oficiales de Arduino.
1. For Loop Iteration (aka The Knight Rider)
Ampliación de la práctica de esta miniunidad utilizando 6 ledes y 3 bucles "for" en el
código.
https://docs.arduino.cc/built-in-examples/control-structures/ForLoopIteration
2. How to Use Arrays
Las matrices ("arrays", en inglés) son un tipo de variable que puede almacenar en su interior varios valores, lo cual
las hace muy útiles y por lo tanto muy usadas en programación. En esta práctica se utilizan las matrices para
controlar el parpadeo de 6 ledes. Usando matrices es muy fácil variar la secuencia de encendido de los ledes.
https://docs.arduino.cc/built-in-examples/control-structures/Arrays
6. Entradas digitales 1
6.1. Captar información del exterior

Algo muy importante para crear sistemas automáticos inteligentes es captar información del exterior, sin información
no se pueden tomar decisiones acertadas. Los sistemas electrónicos, como Arduino, captan información a través de
unos pines llamados entradas. La información llega a las entradas en forma de un valor de tensión eléctrica. El
microcontrolador lee el valor de esta tensión y, gracias al programa que hay en su memoria, es capaz de interpretar
qué está pasando en el exterior. Las entradas más sencillas son las entradas digitales, que son las que estudiaremos
en esta miniunidad.
En las entradas de tipo digital los pines solo pueden recibir dos valores de tensión: 0 V o 5 V. Cuando reciben 0 V se
dice que tienen valor LOW, que se corresponde con un 0 lógico. Cuando reciben 5 V se dice que tienen valor HIGH,
o un 1 lógico.
Ejemplo: se utiliza el pin 7 como entrada digital para que el microcontrolador sepa si alguien está presionando el
pulsador. Se toma corriente del pin de potencia a 5 V y se envía hasta el pin de masa (GND). Se coloca un resistor
intercalado para evitar que pase mucha corriente y la placa pueda estropearse.
La corriente solo circulará si se activa el pulsador, que es un tipo de sensor. Una derivación de esta corriente se hace
llegar hasta el pin 7, donde el microcontrolador la detectará. En el programa podemos escribir que cuando el
microcontrolador detecte corriente en el pin 7 ejecute algunas órdenes, como encender un led, lo veremos más
adelante. La intensidad que circula por los pines de entrada es muy pequeña, ya que tienen una resistencia interna
muy alta, no necesitan un resistor externo.
6.2. Entradas digitales

La placa Arduino UNO tiene 14 entradas digitales: los pines del 0 al 13. Recuerda que estos pines también pueden
funcionar como salidas, tal y como hemos visto en las miniunidades anteriores. Cuando vamos a usar un pin digital
hay que indicar en el programa de la placa en qué modo queremos que funcione: como una entrada o como una
salida. Para este propósito se usa la función pinMode. Por ejemplo, para decirle al microcontrolador que ponga el pin
12 en modo entrada ("input", en inglés), es decir, listo para captar información del exterior, hay que poner esta línea
de código en la función setup(): pinMode(12, INPUT);
Si pusiéramos "pinMode(12, OUTPUT);" el pin 12 se pondría en modo salida, es decir, listo para enviar órdenes al
exterior.

6.3. Sensores digitales básicos
Como las entradas digitales de Arduino UNO solo pueden recibir dos valores de tensión, 0 V o 5 V, los sensores que
se conectan a estas entradas, los llamados sensores digitales, deben trabajar con estos dos valores como forma de
transmitir información del exterior hacia las entradas digitales. Los sensores digitales más comunes simplemente
abren o cierran un circuito cuando pasa algo en el exterior. Al cerrar el circuito hacen llegar 5 V a uno de los pines
digitales de la placa Arduino; al abrir el circuito, hacen llegar 0 V. Algunos de los sensores digitales más comunes
son:
- Pulsadores: Abren o cierran un circuito cuando una persona presiona un botón.
- Sensores de final de carrera: Abren o cierran un circuito cuando una pieza de una máquina presiona un pulsador.
- Sensores magnéticos: Abren o cierran un circuito cuando hay cerca un imán.
- Sensores de inclinación: Abren o cierran un circuito cuando se inclina un objeto.
- Sensores de nivel de líquidos: Abren o cierran un circuito cuando un líquido llega a una cierta altura.
6.4. El circuito
A continuación, para practicar con las entradas digitales, montaremos un circuito que tiene un pulsador y un led
conectados a una placa Arduino UNO y escribiremos un programa para controlar el led en función de la información
que el microcontrolador capta del exterior a través del pulsador (un sensor digital). Este programa tendrá dos
versiones. La primera versión hará que al presionar el pulsador se encienda el led y al dejar de presionarlo se
apague. En la segunda versión haremos que mientras el pulsador esté presionado el led parpadee.
6.4.1. El circuito. Material necesario

Para hacer esta práctica necesitarás estos componentes:
- Placa Arduino UNO y cable USB.
- Protoboard.
- 1 led rojo.
- 1 pulsador.
- 1 resistor de 220 Ω.
- 1 resistor de 10kΩ.
- 7 cables.
6.4.2. El circuito. Montaje

Conecta los componentes en la protoboard como se indica en esta
imagen. Antes de poner en marcha el circuito, repasa atentamente
que todo esté bien conectado.
A destacar:
- El resistor del led está conectado al pin 2 y el pulsador al pin 12.
- El cable largo de color negro va conectado al pin GND y al terminal
negativo del bus de alimentación de la protoboard. El cable largo de
color rojo va conectado al pin de alimentación a 5 V y al terminal
positivo del bus de alimentación de la protoboard.
El pulsador debe instalarse en la protoboard con las patas arriba y
abajo, como en el dibujo de la derecha. Si lo giras y las patas
quedan en los laterales, actuará como si siempre estuviera pulsado.
Las patas de los pulsadores están conectadas internamente. La 1
con la 3 y la 2 con la 4. En rosa se muestra el circuito equivalente.
6.4.3. El circuito. Esquema eléctrico


6.5.1. Versión 1: led que se enciende al pulsar un botón.
Diagrama de flujo
Ahora que ya tenemos el circuito montado, toca escribir el
programa para la placa Arduino. Pero, antes de empezar a
escribir el código, tenemos que tener claro qué queremos que
haga el programa. En esta versión es sencillo: al presionar el
pulsador, se debe encender el led; al dejar de presionarlo, se
debe apagar. Una buena manera de representarlo es dibujar su
diagrama de flujo.
6.5.1. Versión 1: Led que se enciende al pulsar un botón. Código

Para empezar a escribir el código de la versión 1, abre el IDE de Arduino y crea un nuevo programa:
1 cons int ledPin = 2;

2 cons int buttonPin = 12;
3 int buttonState = 0;
4
5 void setup(){
6 pinMode(ledPin, OUTPUT);
7 pinMode(buttonPin, INPUT);
8 }
9
10 void loop(){
11 buttonState = digitalRead (buttonPin);
12 if (buttonState == HIGH) {
13 digitalWrite(ledPin, HIGH);
14 }
15 else {
16 digitalWrite(ledPin, LOW);
17 }
18 }
1. En las dos primeras líneas debes crear dos variables de tipo int (de "integer", número entero). En la primera
variable (ledPin) guardaremos el número del pin donde está conectado el led, en este caso es el pin 2. En la segunda
variable (buttonPin) guardaremos el número del pin donde está conectado el pulsador, en este caso es el pin 12. Al
poner delante de las variables la expresión "const" (de constante) le estamos diciendo al microcontrolador que son
variables cuyo contenido no va a cambiar una vez declaradas, es decir, que deben ser tratadas como constantes.
Esto sirve como sistema de control de errores: si se intenta cambiar el valor de esta constante, se mostrará
automáticamente un error.
2. En la tercera línea declara la variable buttonState, de tipo "integer", y ponle valor 0. En esta variable guardaremos
el estado del botón. Si el botón no está pulsado, la variable tendrá valor 0 (equivalente a LOW); si el botón está
pulsado, la variable tendrá valor 1 (equivalente a HIGH).
Esta variable también se podría definir como tipo "boolean", que es un tipo de dato que solo tiene dos valores
posibles: true (equivalente a HIGH y a 1) o false (equivalente a LOW y a 0). En este caso la línea 3 sería: boolean
buttonState = false;
3. En las líneas 6 y 7, dentro de la función setup(), utilizamos la función pinMode para decirle al microcontrolador que
el pin que hemos guardado dentro de la variable ledPin (el pin número 2, ver la línea 1) debe ser un pin de salida
(OUTPUT) y que el pin que hay dentro de la variable buttonPin (el pin 12, ver la línea 2) debe ser un pin de entrada
(INPUT).
4. Ahora hay que captar información del exterior: debemos saber si el botón está pulsado o no. Esto lo hacemos
utilizando la función digitalRead(), que sirve para leer el estado de una entrada digital. Si el botón está pulsado
llegará corriente de 5 V a la entrada digital 12 (la que está dentro de la variable buttonPin), digitalRead devolverá el
valor HIGH. Si el botón no está pulsado no llegará corriente a la entrada digital 12 y su tensión eléctrica será de 0 V,
digitalRead devolverá el valor LOW.
Tenemos ya la información del exterior: sabemos si el botón está pulsado o no. Ahora toca tomar decisiones con esta
información: encender o apagar el led que hay en la protoboard. Lo haremos usando la estructura condicional if...
else.
5. Escribe las líneas 12 a 17. Se trata de una estructura condicional if... else. Esta estructura tiene una condición que
se pone entre paréntesis. Si se cumple esta condición (if...), se ejecuta la instrucción 1. Si no se cumple la condición
(else), se ejecuta la instrucción 2.

6. Y acaba de escribir las instrucciones de las líneas 13 y 16. Estas líneas dicen que si el pulsador está presionado
buttonState == HIGH), entonces la placa pondrá una corriente de 5 V en la salida digital a la que está conectado el
led (digitalWrite(ledPin, HIGH)) y el led se encenderá. Si el pulsador no está presionado (la variable buttonState no
es HIGH), entonces la placa pondrá 0 V en esa salida digital (digitalWrite(ledPin, LOW)) y el led se apagará.
7. Prueba el programa en la placa.
6.5.2. Versión 2: Led que parpadea mientras se pulsa un botón. Diagrama de flujo
Ahora toca escribir la segunda versión del programa. En esta versión la placa Arduino
debe hacer parpadear el led externo mientras el pulsador esté presionado; cuando deje
de estar presionado, debe apagar el led. Aquí puedes ver el diagrama de flujo.
6.5.2. Versión 2: Led que parpadea mientras se pulsa un botón. Código

Abre el IDE de Arduino y crea un nuevo Sketch para escribir el código de la versión 2.
1 cons int ledPin = 2;

2 cons int buttonPin = 12;
3 int timer = 500;
4
5 void setup(){
7 pinMode(buttonPin, INPUT);
8 }
9
10 void loop(){
11 while (digitalRead (buttonPin) == HIGH) {
13 delay(timer);
15 delay(timer);
16 }
17 }
1. En las dos primeras líneas mantenemos el código de la versión 1:

- En la variable ledPin se guarda el número del pin donde está conectado el led.
- En buttonPin se guarda el número del pin donde está conectado el pulsador.
2. También mantenemos el código de la versión 1 en la función setup():
- El pin donde está conectado el led se declara de salida.
- El pin donde está conectado el pulsador se declara de entrada.
3. El código de la función loop() lo escribiremos desde cero.
4. Declara la variable timer de tipo "integer" en la línea 3 y ponle valor 500 milisegundos. Es una variable global
porque no está dentro de ninguna función. La usaremos en la función loop() para controlar la velocidad de parpadeo
del led.
Ahora utilizaremos un bucle "while" para conseguir que el led parpadee mientras que se mantiene pulsado el botón.
5. Escribe en la línea 11 el encabezado del bucle "while".
6. El bucle " while" se delimita con una llave de cierre (línea 16).
Un bucle "while" está ejecutando continuamente las líneas de código que tiene entre la llave de inicio y la llave de
cierre mientras que se cumpla la condición que se escribe entre paréntesis. Nosotros hemos puesto como condición:
while(digitalRead(buttonPin)==HIGH)
Que se podría traducir por:
"mientras que el pin donde está conectado el pulsador tenga valor HIGH, es decir, mientras reciba 5 V de tensión".
7. Ahora ya podemos escribir las líneas de código que se ejecutarán en bucle: primero se ejecutará la 12, después la
13, la 14, la 15 y vuelta a empezar. Es código que ya conoces: mediante la función digitalWrite se envía tensión a la
salida digital donde está conectado el led y mediante la función delay se hacen pausas que mantienen el led
encendido o apagado durante un tiempo.
8. Prueba el programa en la placa.

7. Entradas digitales 2
Introducción
En esta miniunidad vamos a utilizar las entradas digitales de Arduino para simular un sistema de seguridad en una
nave industrial que tiene dos puertas de acceso. Cada puerta tiene un sensor que indica al personal de seguridad si
está abierta o no, esta información se muestra en el monitor de un ordenador que hay en la sala de control de
seguridad.
Para implementar este sistema mediante una placa Arduino necesitaremos estudiar tres conceptos nuevos:
1. La estructura de programación if... else if... else.
2. El operador AND.
3. La comunicación de tipo serie entre una placa Arduino y un ordenador.
7.1. Sensores para controlar la apertura de puertas y ventanas

Hay varios sensores que pueden usarse para saber si una puerta o una ventana está abierta o cerrada. El más
usado es el sensor magnético, también llamado interruptor reed. Está formado por dos laminillas de hierro
encerradas en un tubo de vidrio sin aire. Al acercarle un imán o un electroimán, las dos láminas se magnetizan y se
atraen entre sí hasta tocarse y cerrar el circuito. Cuando el campo magnético se aleja, las láminas vuelven a
separarse y el circuito se abre. Este sensor es muy utilizado en sistemas antirrobo. Se coloca un imán en la puerta y
un interruptor reed en el marco. Si un ladrón abre la puerta, el sistema antirrobo recibe una señal.
Además de los sensores magnéticos, también se usan mucho los sensores de final de carrera. Tienen una palanca
que presiona un pulsador interno al tocar la hoja de la puerta. En la práctica que haremos no usaremos sensores
magnéticos ni de final de carrera (si los tienes, puedes usarlos también), en su lugar usaremos pulsadores
normalmente abiertos, que son más económicos y fáciles de encontrar. Consideraremos que cada puerta tiene un
pulsador que cierra un circuito cuando la puerta está cerrada y lo abre cuando está abierta. Si enviamos corriente al
pulsador desde la tarjeta Arduino, podremos comprobar si la corriente vuelve a la placa (el estado de la entrada
digital a la que se conecte el sensor será HIGH) o si no vuelve (el estado de la entrada digital será LOW).

- Placa Arduino UNO y cable USB.
- Protoboard.
- 2 pulsadores.
- 2 resistores de 10kΩ.
- 8 cables.

Conecta los componentes en la protoboard como se indica en esta
imagen. Antes de poner en marcha el circuito, repasa atentamente
que todo esté bien conectado.
A destacar:
- El pulsador 1 está conectado al pin 7 de la placa, el pulsador 2
está conectado al pin12.
- El cable largo de color negro va conectado al pin GND y al
terminal negativo del bus de alimentación de la protoboard. El
cable largo de color rojo va conectado al pin de alimentación a 5 V
y al terminal positivo del bus de alimentación de la protoboard.
- Los pulsadores deben instalarse en la protoboard con las patas
arriba y abajo, como en el dibujo de la derecha. Si los giras y las
patas quedan en los laterales, actuarán como si siempre estuvieran
pulsados. Las patas de los pulsadores están conectadas
internamente.


7.5. Diagrama de flujo
Ahora toca escribir el código del programa para la placa
Arduino. Pero antes hemos de concretar qué queremos que
haga. Queremos que se muestre un mensaje en la pantalla
de un ordenador indicando el estado de las dos puertas. Si
ambas están abiertas, se mostrará el mensaje "Puerta 1 y
puerta 2 abiertas"; si solo la puerta 1 está abierta, se
mostrará "Puerta 1 abierta"; si solo la puerta 2 está abierta,
se mostrará "Puerta 2 abierta"; si ninguna de las puertas
está abierta, se mostrará "Ninguna puerta abierta". Aquí
puedes ver el diagrama de flujo que corresponde a este
funcionamiento.
7.6. Escribir el programa. Crear un nuevo archivo

Para empezar a escribir el código del programa, abre el IDE
de Arduino y crea un nuevo archivo:
7.6. Escribir el programa. Variables para los pines de

los pulsadores
1. En las dos primeras líneas creamos las variables
buttonPin1 y buttonPin2, que guardan el número del pin
al que están conectados el pulsador 1 y el pulsador 2 1 cons int buttonPin1 = 7;
respectivamente. Son variables de tipo "integer", es 2 cons int buttonPin2 = 12;
decir, solo pueden contener números enteros. La 3 int buttonState1 = 0;
palabra "const", de constante, indica que su valor no 4 int buttonState2 = 0;
puede cambiar una vez creadas. 5
6 void setup(){
7.6. Escribir el programa. Variables para el estado de 7 pinMode(buttonPin1, INPUT);
los pulsadores 8 pinMode(buttonPin2, INPUT);
2. En las líneas 3 y 4 declaramos las variables 9 Serial.begin(9600);
buttonState1 y buttonState2, de tipo "integer", donde 10 }
guardaremos el estado del pulsador 1 y del pulsador 2. 11
Igualamos las dos variables a 0. Si un pulsador está 12 void loop(){
presionado, el valor de la variable correspondiente será 13 buttonState1 = digitalRead (buttonPin1);
1 (equivalente a HIGH); si no está presionado, será 0 14 buttonState2 = digitalRead (buttonPin2);
(equivalente a LOW). 15 if (buttonState1 == LOW && buttonState2 == LOW) {
16 Serial.println(“Puerta 1 y puerta 2 abiertas.”);
7.6. Escribir el programa. Declarar dos pines como 17 }
entradas 18 else if (buttonState1 == LOW ) {
3. En las líneas 7 y 8, dentro de la función setup(), 19 Serial.println(“Puerta 1 abierta.”);
configuramos los pines digitales como entradas (INPUT) 20 }
usando la función pinMode. Recuerda que configurar 21 else if (buttonState2 == LOW ) {
estos pines como entradas nos permite usarlos para 22 Serial.println(“Puerta 2 abierta.”);
captar información del exterior (el microcontrolador 23 }
podrá leer si los sensores hacen llegar o no corriente a 24 else {
esos pines). Si los configuráramos como salidas 25 Serial.println(“Ninguna puerta abierta.”);
(OUTPUT), nos servirían para enviar órdenes a los 26 }
actuadores. 27 delay(1000);
28 }
7.6. Escribir el programa. Iniciar la comunicación serie
4. En la línea 9 debes escribir el código que hace que el microcontrolador inicie una comunicación serie con el
ordenador al que está conectado mediante un cable USB. La comunicación serie consiste en el envío de información
en forma de bits (0 o 1) de forma secuencial (bit tras bit) a través de un cable. El número 9600 determina la velocidad
de la comunicación en baudios (en Arduino 1 baudio es 1 bit por segundo), debe ser la misma que en el IDE de
Arduino. Cuando se usa la comunicación serie los pines digitales 0 y 1 de la placa Arduino no se pueden utilizar ya
que están conectados internamente con el cable USB y se producirían interferencias.
7.6. Escribir el programa. Detectar si los botones están pulsados

5. El código que debes escribir en las líneas 13 y 14, dentro de la función loop(), sirve para saber si alguno de los dos
botones está pulsado. Para averiguarlo utilizamos la función digitalRead(), que lee el estado de los pines que están

configurados como entradas digitales. Si el botón está pulsado, llegará corriente de 5 V al pin donde está conectado
el botón (está guardado en la variable buttonPin) y digitalRead devolverá el valor HIGH. Si el botón no está pulsado,
no llegará corriente a su pin y digitalRead devolverá el valor LOW.
7.6. Escribir el programa. Decidir qué mensaje enviar al ordenador

Mediante las líneas 13 y 14 sabemos si los botones están pulsados o no (recuerda que si alguno de los dos botones
no está pulsado quiere decir que la puerta correspondiente está abierta). Ahora toca enviar esta información al
ordenador para que aparezca un mensaje en la pantalla. Lo haremos usando la estructura condicional if... else if...
else.
6. Escribe en tu programa las líneas 15 a 26. Se trata de una estructura condicional if... else if... else. Esta estructura
está compuesta por un conjunto de condiciones organizadas jerárquicamente:
1ª condición (if...):
Si se cumple, se ejecuta la 1ª instrucción.
2ª condición (else if...):
Si no se cumple la 1ª condición, se comprueba si se cumple la 2ª condición. Si se cumple la 2ª condición, se ejecuta
la 2ª instrucción.
3ª condición (else if...):
Si no se cumple la 2ª condición, se comprueba si se cumple la 3ª condición. Si se cumple la 3ª condición, se ejecuta
la 3ª instrucción.
No se cumple ninguna de las condiciones anteriores (else):
Se ejecuta la 4ª instrucción.
7. Como 1ª condición ponemos: Si el botón 1 no está pulsado (buttonState1 == LOW) y el botón 2 no está pulsado
(buttonState2 == LOW), entonces se debe ejecutar la 1ª instrucción.
Fíjate en dos cosas:
1. Para decir "y" en el lenguaje de Arduino se usa el símbolo &&. Se trata del operador lógico AND, que devuelve
true (verdadero) si los dos operandos (las expresiones) que tiene antes y después son verdaderos. Otro operador
importante es OR ("o"), que en el lenguaje de Arduino se escribe con dos líneas verticales: ||.
2. Cuando se pone una variable con dos signos de igual y un valor, por ejemplo:
buttonState1 == LOW
Quiere decir "si la variable buttonState1 es igual a LOW...".
Si solo pusiéramos un signo:
buttonState1 = LOW
Estaríamos diciéndole al microcontrolador que a partir de ahora la variable buttonState1 tiene valor LOW.
8. Como 1ª instrucción ponemos:
Enviar (o imprimir) a través del puerto serie la frase: "Puerta 1 y puerta 2 abiertas.". En Arduino el puerto de
comunicación serie es el puerto USB de la placa y la información circula a través del cable USB. Para enviar una
frase al ordenador utilizamos la función Serial.println (la penúltima letra es una ele, de "line"). Como veremos más
adelante, esta frase se mostrará en un apartado del IDE de Arduino llamado Monitor serie.
9. Como 2ª condición y 2ª instrucción ponemos:
Si el botón 1 no está pulsado (buttonState1 == LOW), entonces se debe enviar al ordenador la frase: "Puerta 1
abierta."
10. Como 3ª condición y 3ª instrucción ponemos:
Si el botón 2 no está pulsado (buttonState2 == LOW), entonces se debe enviar al ordenador la frase: "Puerta 2
abierta."
11. Si ninguna de las condiciones anteriores se cumple, se ejecutará la instrucción que hay en la línea 25: Enviar al
ordenador "Ninguna puerta abierta.".
12. Pon en la línea 27 una pausa ("delay") de 1000 milisegundos (1 s). El código de la función loop() no se volverá a
ejecutar hasta pasado este tiempo. Es una manera sencilla de determinar la frecuencia con la que se comprueban
los pulsadores y se envían los mensajes al ordenador.
7.6. Escribir el programa. Abrir el monitor de comunicación serie
13. Clica en este icono para abrir el monitor serie, donde podremos ver los mensajes que envía la placa
Arduino. Si usas el IDE de escritorio clica en Herramientas > Monitor serie.
14. Comprueba que la velocidad de la comunicación sea la misma en el IDE que en el programa de la placa.
15. Carga el programa en la placa.
7.6. Escribir el programa. Visualizar la información enviada por la placa

16. Cuando el programa esté cargado en Arduino, en el monitor se empezarán a mostrar los mensajes que envía la
placa. La frecuencia de los mensajes dependerá de la duración de la pausa que pongas en la línea 27.

8. Entradas analógicas
8.1. Entradas analógicas

En las miniunidades anteriores estudiamos las entradas digitales, que son el método más sencillo que tiene la placa
Arduino de captar información del exterior. Vimos que las entradas digitales son útiles para detectar eventos que
pueden monitorizarse con un "SÍ" o con un "NO". Por ejemplo: ¿Está presionado el pulsador?
¿Está cerrada la puerta que tiene un sensor magnético? La respuesta será un "SÍ" si el pin de la entrada digital
recibe 5 V de tensión y será un "NO" si recibe 0 V.
Pero no todos los eventos se pueden monitorizar de esta manera, a veces necesitamos saber qué intensidad tienen.
Por ejemplo:
- ¿Qué cantidad de luz hay en el exterior?
- ¿Qué temperatura hay en una habitación?
- ¿Qué ángulo tiene el eje de un botón giratorio?
Para supervisar la intensidad de magnitudes exteriores, los microcontroladores disponen de otro tipo de entradas, las
entradas analógicas. Mientras que las entradas digitales sólo pueden recibir dos valores de tensión, 0 V y 5 V, las
entradas analógicas de Arduino UNO pueden recibir tensiones de cualquier valor comprendido entre 0 y 5 V.
La placa Arduino UNO tiene 6 pines de entradas analógicas: los pines A0, A1, A2, A3, A4 y A5. Están situadas en la
parte inferior derecha de la placa.
8.2. Sensores analógicos básicos

Los sensores analógicos más frecuentes son resistencias variables. El valor de su resistencia eléctrica (recuerda que
se mide en ohmios, símbolo Ω) varía en función de la intensidad de un parámetro exterior (luz, temperatura, sonido,
etc.). Ejemplo: un sensor de luz (es un fotorresistor o LDR, de "light dependent resistor"). Esta LDR está conectada
en serie con un resistor. Cuando el sensor recibe mucha luz, su resistencia disminuye; cuando recibe poca luz, su
resistencia aumenta. Si lo conectamos a una de las entradas analógicas de Arduino, esta entrada recibirá una
pequeña corriente cuya tensión variará en función de la intensidad luminosa que recibe el sensor. Es una manera de
transmitir la información hacia el microcontrolador. Cuando tenemos, como en este caso, una pequeña corriente
eléctrica que transporta información, decimos que es una "señal eléctrica".
Tres de los sensores analógicos más comunes: un fotorresistor, un sensor de temperatura y potenciómetro. Como
hemos visto, la resistencia interna de los fotorresistores disminuye conforme aumenta la cantidad de luz que reciben.
Lo mismo sucede con el sensor de temperatura: su resistencia disminuye conforme aumenta la temperatura
ambiental. Se trata de un sensor llamado TMP36; no debes confundirlo con un transistor, muchos de los cuales
tienen un encapsulado parecido. En el caso de los potenciómetros, la resistencia interna depende del ángulo de giro
que tiene su eje.
8.3. El potenciómetro como sensor analógico

Externamente los potenciómetros tienen 3 terminales (A, B y C) y un eje que
puede ser girado usando una herramienta, normalmente un destornillador
pequeño, o con los dedos si tienen un mando acoplado. En el interior hay
una pista resistiva que une al terminal A con el terminal C y una plaquita
metálica giratoria (el cursor) unida al terminal B y que roza la pista resistiva.
Los potenciómetros se caracterizan por su resistencia máxima: hay
potenciómetros de 1.000 Ω, de 10.000 Ω, etc. A continuación veremos cómo
usar un potenciómetro para transmitir información a una placa Arduino a
través de sus entradas analógicas.
El potenciómetro se conecta a la placa Arduino como se muestra en la
imagen. Uno de los extremos de la placa resistiva se conecta al pin de
potencia a 5 V y el otro extremo se conecta a uno de los pines GND (0 V).
Obtenemos así un circuito cerrado por el que pasa una pequeña cantidad de
corriente desde el pin de 5 V al pin GND (representada en el dibujo con
flechitas rojas). No pasa mucha corriente porque la pista opone bastante
resistencia. La corriente que sale del pin de potencia tiene un potencial
eléctrico de 5 V y poco a poco, conforme va atravesando la pista resistiva, va
perdiendo su potencial hasta llegar a 0 V cuando llega al pin GND. La
diferencia de potencial entre el terminal de entrada y el terminal GND es por
tanto: 5 V - 0 V = 5 V. A continuación veremos cómo se conecta el terminal B.
El terminal B, el del centro, se conecta a una de las entradas analógicas de la placa Arduino. Por ejemplo se conecta
a la entrada A3 mediante un cable azul. El terminal B está conectado internamente con el cursor, que roza en la pista
resistiva. Esta pista está hecha con un material que dificulta el paso de la electricidad. En función del ángulo del
cursor, la corriente que llega a la entrada A3 atravesará más o menos longitud de pista resistiva. Cuanto mayor sea
la longitud de pista, menor será la tensión de la corriente que sale del terminal B y llega a la entrada analógica A3.
Girando el eje del potenciómetro hacemos llegar más o menos tensión a la entrada analógica. Así podemos simular
fácilmente cómo se comportaría un sensor analógico de luz o de temperatura, por ejemplo, sin tener que modificar la
iluminación ni la temperatura.

A la entrada analógica A3 llegará corriente con mayor o menor tensión eléctrica. La tensión de esta corriente que
llega es un valor analógico ya que no está expresada en forma de números. Pero Arduino es una máquina digital, lo
que quiere decir que internamente funciona con números. Si queremos que pueda interpretar la señal que llega a las
entradas analógicas debemos darle los datos en forma de números. Una manera de digitalizar el valor de la tensión
sería medirla manualmente con un voltímetro e introducir los datos en el programa, pero esto no sería práctico. Para
automatizar este proceso se utiliza un conversor de valores analógicos a digitales o ADC (de "analog to digital
converter"). Arduino UNO tiene dentro de su microcontrolador un circuito ADC. Este conversor analógico digital tiene
1024 niveles de sensibilidad. Si recibe 0 V, lo convertirá en el número 0. Si recibe 5 V, lo convertirá en el número
1023. Si recibe un valor intermedio como 2,45 V, lo convertirá en el número 501. Como veremos más adelante, este
número será importante a la hora de hacer programas que utilicen sensores analógicos.
¿Por qué se usa el número 1024?
El conversor analógico digital de Arduino UNO tiene 1024 niveles de sensibilidad porque en realidad internamente no
representa los números del 0 al 1023, sino que lo hace en código binario de 10 bits, es decir, como un conjunto de 10
ceros y unos (los únicos números que comprenden los computadores) y resulta que el número de diferentes
combinaciones posibles de 10 ceros o unos es de 1024.
8.4. Los sensores analógicos más avanzados son sensores digitales

Los sensores analógicos más avanzados acostumbran a ser, en realidad, sensores digitales. ¿Cómo puede ser? Es
sencillo: son sensores que captan valores analógicos, es decir, de cualquier valor dentro de un rango, pero cuando
los transmiten a la placa Arduino no lo hacen como un valor de tensión que sube o baja (señal analógica), sino
codificando este valor como un conjunto de ceros y unos (señal digital) que se envían a una de las entradas digitales
de Arduino.
8.5. Prácticas
A continuación haremos dos prácticas para aprender a usar las entradas analógicas. En la primera práctica
utilizaremos el monitor serie del IDE de Arduino para visualizar qué lecturas genera un sensor analógico (usaremos
un potenciómetro). En la segunda práctica aprenderemos a utilizar las lecturas de este sensor para decidir si se debe
encender o apagar un actuador (usaremos un led). La segunda práctica tiene dos versiones. En la primera versión se
utiliza un potenciómetro como sensor analógico, en la segunda
versión se utiliza una LDR.
8.5. Prácticas. Material necesario

Para hacer las prácticas necesitarás los siguientes componentes:
- Protoboard.
- 1 led rojo.
- 1 potenciómetro.
- 1 LDR.
- 1 resistor de 10 kΩ.
- 7 cables.
8.6. Práctica 1. Montar el circuito

Conecta los componentes en la protoboard como se indica en
esta imagen. Antes de poner en marcha el circuito, repasa
atentamente que todo esté bien conectado.
A destacar:
- El cable azul debe conectarse al terminal central del
potenciómetro y al pin A0 (que es una entrada analógica).
- El cable largo de color negro va conectado al pin GND y al
terminal negativo del bus de alimentación de la protoboard.
- El cable largo de color rojo va conectado al pin de alimentación
a 5 V y al terminal positivo del bus de alimentación de la
protoboard.
Los potenciómetros tienen 3 patas. Es importante que se
conecten tal y como se indica en el dibujo.
8.6. Práctica 1. Esquema eléctrico


8.6. Práctica 1. Diagrama de flujo
Ahora toca empezar a escribir el programa para la placa Arduino. El programa
deberá leer el valor de la señal eléctrica que recibe la entrada analógica A0 y
seguidamente escribir esta lectura en el monitor serie del IDE de Arduino para
que puedas visualizarla en tu ordenador. Estas dos tareas las deberá ir haciendo
continuamente, en bucle, esperando 100 milisegundos entre lectura y lectura.
8.6. Práctica 1. Escribir el programa

Para empezar a escribir el código del programa, abre el IDE de Arduino y crea un
nuevo archivo.
1 // Este programa envía las lecturas a un potenciómetro al monitor serie.

2
3 void setup(){
4 Serial.begin(9600);
5 }
6
7 void loop(){
8 int sensorValue = analogRead(A0);
9 Serial.println(sensorValue);
10 delay(100);
11 }
1. Pon el comentario en la línea 1 del código.

2. En la línea 4 escribe el código que hace que se inicie una comunicación serie con el ordenador a través del cable
USB.
3. Ahora debemos mirar si llega información en forma de una señal eléctrica a la entrada analógica A0. Se hace
utilizando la función analogRead(), que sirve para leer la tensión eléctrica que recibe una entrada analógica.
Recuerda que Arduino no capta la tensión en voltios, sino como un valor numérico comprendido entre el 0 y el 1023,
donde una lectura de 0 V tendrá el valor 0, una lectura de 5 V tendrá el valor 1023 y el resto de valores de tensión
tendrán un valor proporcional. Como puedes ver, la lectura de la entrada analógica se guarda en la variable llamada
sensorValue que es de tipo integer.
4. Para enviar el valor de la lectura de la entrada digital al ordenador, a través del cable USB, se utiliza la función
Serial.Println (la penúltima letra es una ele, de "line").
5. En la línea 10 se hace una pausa de 100 milisegundos mediante la función delay(). De esta manera las lecturas
aparecen en la pantalla del ordenador más espaciadamente.
8.6. Práctica 1. Abrir el monitor de comunicación serie

6. Clica en el icono para abrir el monitor serie, donde podremos ver los mensajes que envía la placa Arduino. Si usas
el IDE de escritorio clica en Herramientas > Monitor serie.
7. Comprueba que la velocidad de la comunicación sea la misma en el IDE que en el programa de la placa (línea 4).
8. Carga el programa en la placa.

8.6. Práctica 1. Visualizar la información enviada por la placa
9. Cuando el programa esté cargado en Arduino, en el monitor se
empezarán a mostrar los mensajes que envía la placa, que
mostrarán la tensión que deja pasar el potenciómetro hacia la
entrada analógica A0 (expresada en valores del 0 al 1023).
La frecuencia de los mensajes que aparecen en el monitor
dependerá de la duración de la pausa, en milisegundos, que pongas
en la línea 10.
8.7. Práctica 2. Versión 1: Montar el circuito

En la práctica 2 debes conectar los componentes como se indica en
la imagen. La parte derecha del circuito, la que corresponde al
potenciómetro, es la misma que la de la práctica 1. Sólo se ha
añadido un led, un resistor y los cables que sirven para conectarlos.
Como siempre, antes de poner en marcha el circuito debes repasar
atentamente que todo esté bien conectado.
A destacar:
- El cable rojo que sale de uno de los terminales del resistor debe
conectarse al pin digital 9 de la placa Arduino.

8.7. Práctica 2. Versión 1: Esquema eléctrico
8.7. Práctica 2. Versión 1: Diagrama de flujo

En el programa de la práctica 2 vamos a usar las lecturas del potenciómetro
para decidir si un led se enciende o se apaga. Si la lectura de la entrada
analógica A0 es igual o superior a 512 (habrá bastante luz), se apagará el
led; si es inferior a este valor, se encenderá el led. Este programa es un
ejemplo de cómo se pueden tomar decisiones sobre actuadores (encender o
apagar una bombilla o un motor, por ejemplo), a partir de los datos que nos
suministra un sensor analógico.
8.7. Práctica 2. Versión 1: Escribir y probar el programa
1 int sensorPin = A0;

2 int ledPin = 9;
3 int sensorValue = 0;
4
5 void setup(){
7 }
8
9 void loop(){
10 sensorValue = analogRead(A0);
11 if (sensorValue >= 512) {
13 }
14 else {
16 }
17 }
1. En las tres primeras líneas se crean las variables donde se guardan el número del pin analógico donde está el
potenciómetro (sensorPin) y del pin de la salida digital donde está el led (ledPin). Finalmente se crea la variable
sensorValue, que guardará el valor de la tensión recibida por la entrada analógica.
2. Se declara el pin digital 9 como salida.
3. Se lee el valor del pin analógico A0.
4. Entre las líneas 11 y 16 hay una estructura if... else que enciende o apaga el led en función del valor de la entrada
A0. Para activar o desactivar la salida se usa la función digitalWrite.
5. Carga el programa en la placa y comprueba que funcione correctamente.
Escribe este programa y cárgalo en la placa Arduino. A continuación gira poco a poco el eje del potenciómetro para
modificar el valor de tensión que llega a la entrada analógica A0. Cuando el valor sea mayor o igual que 512, el
programa apagará el led; cuando sea menor, lo encenderá.
8.8. Práctica 2. Versión 2: Montar el circuito

En la versión 2 de esta práctica se mantiene la parte izquierda del
circuito (el led y el resistor) y se cambia el potenciómetro por una
LDR y un resistor. A destacar:
- La LDR no tiene polaridad.
8.8. Práctica 2. Versión 2: Probar el programa

El programa es el mismo que el de la versión 1, solo es necesario
hacer un pequeño cambio si hay mucha luz ambiental en la
habitación: cambiar el número 512 de la línea 11 por un número
más grande, como 800. Carga el programa en la placa y
comprueba que funcione, verás que se comporta igual que la
versión anterior, solo que encender o apagar el led ya no está
controlado por el ángulo del eje del potenciómetro, sino por la
intensidad de la luz que recibe la LDR. Si tapas la LDR para que no
le llegue luz, el valor que leerá el microcontrolador en la entrada
analógica será bajo, alrededor de 400 sobre un máximo de 1023, y
entonces el programa encenderá el led. Si iluminas la LDR, el
microcontrolador leerá un valor alto, alrededor de 1000 sobre un
máximo de 1023, y entonces el programa apagará el led.

9. Salidas analógicas
9.1. Salidas analógicas en microcontroladores

Algunos microcontroladores, además de entradas analógicas, tienen también salidas analógicas. Son pines con una
tensión de salida que puede ser variada continuamente por el microcontrolador, normalmente entre 0 y 5 V (o entre 0
y 10 V en sistemas industriales). Un ejemplo: un PLC (de "programmable logic controller", controlador lógico
programable) controlando una electroválvula mediante una salida analógica. Los PLC son microcontroladores,
parecidos a los de Arduino, solo que tienen una electrónica más robusta y una carcasa exterior que los protege. Los
PLC se usan en la industria para controlar máquinas. Ejemplo: un PLC con 2 salidas analógicas y se está utilizando
una de ellas para controlar una electroválvula. Esta electróválvula recibe del PLC una señal eléctrica cuya tensión
puede variar entre 0 y 10 V.
Cuanto mayor sea la tensión de la señal, más abierta estará la válvula. El caudal de agua que deja pasar la válvula
es, por tanto, proporcional a la tensión de la señal.
A nivel industrial se utilizan sistemas parecidos para controlar la velocidad de giro de un motor eléctrico, la
temperatura en un horno, etc.
9.2. Salidas analógicas en Arduino UNO

Aunque hay placas Arduino que tienen salidas analógicas, como la placa Arduino Due, la que nosotros usamos para
las prácticas, la placa Arduino UNO, no tiene salidas analógicas verdaderas por una razón de coste: se necesita un
chip denominado "Conversor Digital Analógico", que transforma señales digitales (ceros y unos) en una señal
analógica (tensión eléctrica que sube y baja). Arduino UNO no tiene este chip, pero sí que tiene 6 salidas digitales
que pueden emular a las salidas analógicas. Son los pines 3, 5, 6, 9, 10 y 11, los que están marcadas con el símbolo
~. Utilizan una técnica llamada PWM ("Pulse Width Modulation", Modulación de Ancho de Pulso), que consiste en
encender y apagar muy rápidamente las salidas digitales (salen 5 V) para reducir la tensión de salida promedio, que
se puede modular entre 0 y 5 V. Esta técnica tiene muchas limitaciones, no es una salida analógica verdadera, pero
en aplicaciones sencillas se puede usar para controlar el brillo de ledes (haremos dos prácticas en esta miniunidad),
para controlar la velocidad de giro de pequeños motores o para reproducir sonidos con calidad baja. Si una
aplicación necesita una verdadera salida analógica, existen en el mercado módulos de salidas analógicas para
Arduino UNO.
Un ejemplo de uso de la técnica PWM: el microcontrolador enciende y apaga rápidamente la salida 6, en la que hay
conectado un led. Cuando la salida está encendida el led recibe 5 V y cuando está apagada recibe 0 V. Como en
este ejemplo la salida está encendida el mismo tiempo que apagada, el resultado es que de promedio el led recibe
una tensión de 2,5 V y por lo tanto brilla con la mitad de intensidad que si estuviera alimentado a 5 V. Aumentando o
disminuyendo el tiempo que está encendida la salida (el ancho del pulso) podemos modificar la tensión promedio que
se aplica al circuito exterior.
Las salidas PWM se encienden y apagan muy rápidamente. En Arduino UNO 980 veces por segundo en los pines 5
y 6 y 490 veces por segundo en el resto de pines.
Para utilizar las salidas PWM de Arduino se utiliza la función analogWrite(). Hay que poner este código en la función
setup(): analogWrite(pin, ancho);
Donde pone "pin" hay que indicar el número del pin digital que queremos usar (sólo los que tengan el símbolo ~).
Donde pone "ancho" hay que escribir un número entre el 0 y el 255. El ancho de pulso se divide en 256 partes (el
cero se cuenta como una parte más). Si ponemos 0, el pin enviará 0 V continuamente; si ponemos 255, el pin
enviará 5 V continuamente. El resto de valores será proporcional. Por ejemplo, si ponemos 127, el pulso tendrá una
anchura de 127 partes sobre 256 (el 50 % del ancho posible), lo que generará una tensión promedio de 2,5 V.
Se utiliza la expresión "ciclo de trabajo" cuando se da el ancho de pulso como porcentaje del ancho posible. Un ciclo
de trabajo del 50 % generará 2,5 V, el 50 % de 5 V.
¿Por qué se usa el número 256?
La anchura de pulso en digital de Arduino UNO tiene 256 niveles de resolución porque en realidad internamente no
representa los números del 0 al 255, sino que lo hace en código binario de 8 bits, es decir, como un conjunto de 8
ceros y unos (los únicos números que comprenden los computadores) y resulta que el número de diferentes
combinaciones posibles de 8 ceros o unos es de 256.
9.3. Prácticas
A continuación realizaremos dos prácticas para aprender a usar las salidas analógicas. En la primera práctica
haremos que un led se encienda y se apague paulatinamente. En la segunda controlaremos el brillo de un led a
través de un potenciómetro: girando el eje del potenciómetro haremos que el led luzca más o menos.
9.3. Prácticas. Material necesario

Para hacer las prácticas necesitarás los siguientes componentes:
- Protoboard.
- 1 led rojo.
- 1 potenciómetro.
- 7 cables.

Conecta los componentes como se indica en esta imagen. Antes de
poner en marcha el circuito, repasa atentamente que todo esté bien
conectado.
A destacar:
- El cable rojo debe conectarse al pin 9 de la placa Arduino. Este
pin permite modulación por ancho de pulso (PWM), que es la
técnica que vamos a usar para encenderlo y apagarlo, lo sabemos
porque está marcado con el símbolo ~.

Debajo se muestra el esquema eléctrico del circuito.

Ahora toca escribir el programa para la placa. Queremos que el programa vaya incrementando poco a poco el brillo
que tiene el led conectado a la salida digital 9. Cuando llegue al máximo, queremos que vaya disminuyendo poco a
poco hasta apagarse. Para modificar el brillo habrá que ir variando la tensión que recibe el led: cuanta más tensión,
más brillará. La tensión la expresaremos como un valor entre el 0 y el 255, que es la anchura de los pulsos en la
técnica PWM. Al principio la tensión será 0 y el led estará apagado. Cada vez que se ejecute la función loop() se
deberá incrementar la tensión en 5 unidades. Cuando la tensión sea mayor o igual que 255 (5 V de tensión
promedio), se cambiará el signo del incremento para que empiece a restar en lugar de sumar. Cuando la tensión sea
menor o igual que 0 (0 V de tensión promedio), se volverá a cambiar el signo del incremento para que empiece a
sumar en lugar de restar.

Para empezar a escribir el código del programa, abre el IDE de Arduino y crea un nuevo archivo.
1 int ledPin = 9;
2 int tension = 0;
3 int increment = 5;
4
5 void setup(){
7 }
8
9 void loop(){
10 analogWrite(ledPin, tension);
11 tension = tension + increment;
12 if (tension <= 0 || tension >= 255) {
13 Increment = -increment;
14 }
15 delay(30);
16 }
1. En la línea 1 se crea la variable "ledPin", que guarda el número del pin donde está conectado el led, el pin 9. En
las líneas 2 y 3 se crean las variables "tension" e "increment". La variable "tension" guarda el valor de la tensión
eléctrica que se enviará al pin 9, recuerda que no se indica en voltios, sino como un número comprendido entre el 0 y
el 255. La variable "increment" almacena cuánto se debe incrementar la variable "tension" cada vez que se ejecuta la
función loop().
3. Usando la función "analogWrite" se envía el valor de la tensión al pin digital 9.
4. Se incrementa el valor de la tensión en 5 unidades (ver línea 3).

5. En las líneas 12 a 14 hay una estructura "if...then" que ordena que si la tensión es mayor o igual a 0 o es menor o
igual a 255, la variable "increment" debe cambiar de signo. Si es + pasará a ser - y si es - pasará a ser +.
6. Pausa de 30 ms (línea 15).
Cuando se llega a la línea 15 vuelve a comenzar el bucle loop() y la variable "tension" se incrementa (si la variable
"increment" es +) o se reduce (si la variable "increment" es -).

Es el circuito de la práctica 1, al que añadimos un potenciómetro. Este circuito ya lo montamos en la práctica 2 de la
miniunidad anterior, donde lo usamos para que se encendiera o apagara automáticamente el led en función de la
posición del eje del potenciómetro. Ahora vamos a controlarlo con un programa que hará que el led sea más o
menos brillante en función de la posición del eje del potenciómetro.
A destacar:
- El cable azul debe conectarse al terminal central del potenciómetro y al pin A0 (que es una entrada analógica).
- El cable largo de color negro va conectado al pin GND y al terminal negativo del bus de alimentación de la
protoboard.
- El cable largo de color rojo va conectado al pin de alimentación a 5 V y al terminal positivo del bus de alimentación
de la protoboard.

Aquí puedes ver el esquema eléctrico del circuito.

En la práctica 2 vamos a usar las lecturas del potenciómetro para aumentar
o disminuir el brillo del led. Como ya sabes, el brillo del led varía en función
de la tensión que recibe: cuanta más tensión, más brillará. Primero se
deberá leer la tensión de la señal eléctrica que envía el potenciómetro al pin
analógico A0. A continuación esta lectura se deberá transformar
proporcionalmente en una tensión, generada con la técnica PWM, que se
enviará al led.
1 int ledPin = 9;
2 int sensorPin = A0;
3 int sensorValue = 0;
4
5 void setup(){
7 }
8
9 void loop(){
10 sensorValue = analogRead(sensorPin);
11 float tension = sensorValue * (255.0 / 1023.0);
12 analogWrite(ledPin, tension);
13 }
1. En la línea 1 se crea la variable "ledPin", que guarda el número del pin digital donde está conectado el led, el pin 9.
En la línea 2 se crea la variable "sensorPin", que guarda el número del pin analógico donde está conectado el
potenciómetro, el pin A0. En la línea 3 se crea la variable "sensorValue", donde se guarda el valor de la tensión
eléctrica que se recibe del potenciómetro, recuerda que no se indica en voltios, sino como un número comprendido
entre el 0 y el 1023.
3. Usando la función "analogRead" se lee el pin analógico A0. El valor de la lectura, un número entre 0 y 1023, se
guarda dentro de la variable "sensorValue".
4. Se crea la variable "tension". Es una variable de tipo "float", que sirve para guardar números con decimales.
Ponemos dentro de "tension" el contenido de la variable "sensorValue" multiplicado por un coeficiente que transforma
proporcionalmente el valor de la lectura del potenciómetro (rango: 0 a 1023) a una salida analógica PWM (rango: 0 a
255). Simplemente se divide la señal recibida del potenciómetro entre 1023 y el resultado se multiplica por 255.
5. Usando la función "analogWrite" se ordena al pin 9 que genere un tren de pulsos PWM. Los pulsos tendrán una
anchura equivalente al valor de la variable "tension". La tensión promedio (en voltios) generada por el tren de pulsos
será proporcional a la señal enviada por el potenciómetro.

Arduino: Índice

Cargado por

Copyright:

Formatos disponibles

Arduino: Índice

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arduino: Índice

Cargado por

Copyright:

Formatos disponibles

Arduino

1.1. ¿Qué es un microcontrolador?

1.2. Los microcontroladores siguen el esquema entrada-proceso-salida

1.3. Microcontroladores por todas partes

1.4. ¿Qué es Arduino?

1.5. Arduino es hardware y software open source

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados.

1.6. Arduino es un proyecto que va evolucionando

1.7. ¿Qué se puede hacer con Arduino?

1.8. Módulos para Arduino

1.9. Arduino y el internet de las cosas (IoT)

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 2

1.11. Arduino y la industria

2. La placa Arduino UNO

2.4. Indicadores luminosos

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 3

2.6. Jack de alimentación

2.7. Pines de potencia

2.8. Salidas digitales

2.9. Entradas digitales

2.10. Entradas analógicas

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 4

2.11. Salidas analógicas

3. Programar la placa Arduino

3.1. El IDE de Arduino

3.2. Programar la placa Arduino. Crear un nuevo programa

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 5

3.2. Programar la placa Arduino. Introducir comentarios en el código

3.2. Programar la placa Arduino. Funciones setup y loop

3.2. Programar la placa Arduino. Programar la función setup (línea 8)

3.2. Programar la placa Arduino. Programar la función loop (línea 13)

3.2. Programar la placa Arduino. Programar la función loop (línea 14)

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 6

3.2. Programar la placa Arduino. Conectar la placa al ordenador

3.2. Programar la placa Arduino. Grabar el programa en la memoria de la placa

3.3. Programación visual

4.1. Material necesario

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 7

4.3. Montar el circuito

4.4. Esquema eléctrico

4.5. Escribir el programa

4.6. Grabar el programa en la memoria de la placa

4.7. Hacer las prácticas en un simulador de Arduino

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 8

Versión 1: Repitiendo instrucciones

5.1. Material necesario

5.2. Montar el circuito

5.3. Esquema eléctrico

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 9

Símbolos básicos de los diagramas de flujo:

Inicio o final de diagrama

Entrada o salida de datos

Realización de una actividad/proceso/orden

Análisis de la situación y toma de decisiones

Indica el flujo del proceso

5.5. Escribir el programa. Versión 1: Repitiendo instrucciones

5.6. Escribir el programa. Versión 2: Delay con variable timer

www.tecno12-18.com © 2022 Saganet Multimedia S.L. Todos los derechos reservados. 10

5.7. Escribir el programa. Versión 3: Bucle for