CURSOS GRATUITOS DE FORMACIÓN PROFESIONAL

ARDUINO
CLASE 3

RAMÓN A. ORIS
VICENTE FRANCHINO
 ¡BIENVENIDOS!

Estimados Alumnos, les doy la bienvenida a la tercera instancia virtual de este trayecto de
formación, espero que sea un espacio de aprendizaje e interacción conjunta, en el cual podamos
aprender nuevas herramientas que nos ayuden a mejorar nuestra práctica cotidiana en el ámbito
laboral fortaleciendo además los conocimientos para el desarrollo productivo. ¡Adelante!

¿QUÉ APRENDEREMOS EN ESTA CLASE?

Comenzaremos repasando y aclarando algunos conceptos básicos sobre Arduino y

programación vistos en las dos primeras clases.
Luego nos introduciremos un poco más en la programación para así, finalmente,
profundizar en los ciclos o estructuras de control en la programación de Arduino mediante
distintos ejemplos prácticos..

OBJETIVOS DE LA CLASE

1. Controlar entradas y salidas digitales de Arduino.

2. Manejar estructuras de control en Arduino.

1 ARDUINO – CLASE 1
 ÍNDICE

ESTRUCTURA DE UN PROGRAMA PAG. 3

VARIABLES PAG. 7
CONSTANTES PAG. 9
OPERADORES PAG. 10
ESTRUCTURAS DE CONTROL PAG. 12
DIAGRAMA DE FLUJO PAG. 18
PRÁCTICA N°1: PARPADEO DE UN LED PAG. 21
PRÁCTICA N° 2: SEMÁFORO SIMPLE PAG. 23
PRÁCTICA N° 3: CONTROL DE UN LED CON UN PULSADOR PAG. 25
PULSADORES PAG. 27
PRÁCTICA N° 4: EL AUTO FANTÁSTICO PAG. 32
PRÁCTICA N° 5: SECUENCIAS DE LUCES CON LEDS Y PULSADOR PAG. 40
PRÁCTICA N° 6: SENSOR PIR PAG. 43
BIBLIOGRAFÍA PAG. 48

2 ARDUINO – CLASE 1
 ESTRUCTURA DE UN PROGRAMA

La estructura de un programa en Arduino puede llegar a ser muy diferente en función de

la complejidad de la aplicación que queramos crear, pero como en la mayoría de los lenguajes
de programación esta estructura está formada por funciones, sentencias, bucles y otros
elementos que conforman la estructura de programa.

Funciones

Una función es un bloque de código con un nombre y un conjunto de estamentos que son
ejecutados cuando se llama a dicha función. Las funciones de usuario se crean para realizar
tareas repetitivas reduciendo de esa manera el tamaño del programa.
Las funciones están asociadas a un tipo de valor "type", este es el valor que devolverá la
función una vez termine su ejecución.

type nombreFunción (parámetros)

{
Estamentos o instrucciones;
}

Si la función no devuelve ningún valor, se le asignará el tipo "void" o función vacía. No es

obligatorio pasarle parámetros a la función, se pueden crear funciones independientes que
obtengan sus propios parámetros para trabajar.

Ejemplo de función:

/* Define la función "multiplicar" a la que se le pasarán los 2 números

que se deseen multiplicar devolviendo un valor entero (int). */

int multiplicar (int x, int y) //función multiplicar

{
int resultado; //declaro la variable donde se almacena el resultado
resultado= x * y; //ejecuta la operación de multiplicar
return resultado; //devuelve el resultado de la multiplicación
}

3 ARDUINO – CLASE 1
 Para hacer uso de la función anterior, tan solo habrá que llamarla desde cualquier parte
del programa. Esta llamada a la función se realiza de la siguiente manera:

void loop()
{
int i =2;
int j =3;
int k;
k = multiplicar (i, j); //llama a la función multiplicar pasándole los
//parámetros “i” y ''j"
}

En Arduino los programas pueden estar compuestos por infinidad de funciones, pero
existe una estructura básica que deben de cumplir todos los programas. Esta estructura básica,
está formada por dos funciones totalmente necesarias para la ejecución del programa, la función
setup() y loop(), las cuales vimos en las dos primeros clases.
La función setup() es la primera función que se ejecuta en nuestro programa,
ejecutándose sólo una vez, y se utiliza para configurar la comunicación con nuestro equipo,
inicializar los pines de nuestra tarjeta de Arduino e inicialización de las variables.
La función loop() se ejecuta repetidamente después de la función setup(). Dentro de la
misma vamos a introducir el programa que queremos ejecutar dentro de la placa de Arduino.

4 ARDUINO – CLASE 1
Llaves {}

Las llaves definen el principio y el final de un bloque de instrucciones. Se usan para

delimitar el inicio y fin de funciones como setup() o para delimitar el alcance de los bucles y
condicionales del programa.

funcion ()
{
Estamentos o instrucciones;
}

Punto y coma “; “

El punto y coma ";" se utiliza para definir el final de una instrucción y separarla de la
siguiente. Si no colocamos punto y coma, el programa va a interpretar mal las instrucciones y se
va a producir un error de compilación.

digitalWrite (10, HIGH);

El error más común a la hora de programar suele ser olvidar poner punto y coma al final
de la instrucción.

Bloque de comentarios /* ... * /

Los bloques de comentarios son áreas de texto que nos ayudan a describir o comentar un
programa, estos bloques serán ignorados a la hora de compilar el programa en nuestro Arduino.

/*
El bloque de comentario ayuda
al programador a describir el programa
*/

Se pueden introducir todas las líneas de texto que se deseen siempre que se encuentren
entre los caracteres /* ... */.

5 ARDUINO – CLASE 1
 Se recomienda el uso de bloques de comentarios siempre que se pueda, ya que ayudan
a la comprensión del programa a personas ajenas al mismo, además, estos comentarios no van
a ocupar espacio de programa, ya que son ignorados a la hora de compilar.

Línea de comentarios //

La línea de comentarios tiene la misma función que los bloques de comentarios, la única
diferencia es que las líneas de comentarios suelen usarse para comentar instrucciones ya que
solo afectan a una línea.

int x =10; //declara la variable 'x' como tipo entero de valor 10

6 ARDUINO – CLASE 1
 VARIABLES

Las variables son elementos donde se almacenan valores numéricos que serán usados
por el programa. Como su nombre indica, las variables van a cambiar de valor con la evolución
del programa y nos van a permitir crear la lógica del programa en función de estos cambios.

int variable_entrada = 0; //declara una variable y le asigna el valor 0

variable_entrada = analogRead(2); //la variable toma el valor de la entrada analógica 2

Una variable debe ser declarada y opcionalmente asignarle un valor antes de ser usada
por el programa, si no hemos declarado la variable o lo hemos hecho con posterioridad a su uso
va a dar un error al compilar el programa.
Es recomendable asignarle un valor inicial a las variables para no tener un valor
indeterminado que pudiera ocasionar algún error a la hora de la ejecución del programa.
Cuando se asignen nombres a las variables, se deben de usar nombres que identifiquen
claramente a dichas variables, para ello se usan nombres como "pulsador", "led", "entrada_1" ....
esto va a ayudar a hacer un código legible y fácil de entender

Utilización de variables

Las variables pueden ser declaradas en diferentes lugares del programa, en función del
lugar donde sean declaradas, las variables van a ser de tipo global o local, determinando esto
el ámbito de aplicación o la capacidad de ciertas partes del programa para hacer uso de estas.
Una variable global es aquella que puede ser vista y utilizada por cualquier función y
estamento de un programa. Las variables globales se declaran al comienzo del programa, antes
de la función setup().
Una variable local es aquella que se define dentro de una función o como parte de un
bucle. Solo será visible y podrá utilizarse dentro de la función o bucle donde es declarada.
La existencia de variables globales y locales, permite el uso de variables con el mismo
nombre en partes diferentes del programa, estas variables podrán almacenar valores distintos
sin que se produzca ningún conflicto, ya que a las variables locales solo tendrán acceso las
funciones donde se declaren dichas variables.
Ejemplo de variables globales y locales:

7 ARDUINO – CLASE 1
 int led = 10; //"led" es una variable global visible para cualquier función
void setup()
{
pinMode (led, OUTPUT); //establece el pin "led" como salida
}
void loop()
{
float valor; //"valor" es una variable local solo visible dentro de "loop"
for {int i=0; i<20; i++) //"i" es una variable local usada por el buclefor
{
digitalWrite (led, HIGH); //uso de la variable global "led"
}
}

Tipos de variable

A la hora de usar una variable dentro del programa debemos de pararnos a pensar que
información o qué tipo de operaciones vamos a aplicar a estas variables y en función de esto
asignarle un tipo u otro. Debemos de asegurarnos que el tipo de variable que estemos usando
tiene rango suficiente para almacenar los datos sin llegar a ser desproporcionada, ya que usar
variables grandes va a consumir más recursos de memoria.

8 ARDUINO – CLASE 1
 CONSTANTES

La diferencia fundamental entre una variable y una constante es que la constante va a ser
un valor de solo lectura que no va a poder ser modificado con la evolución del programa.
Si queremos definir una constante, podemos hacerlo de manera muy similar a como
definíamos las variables, tan solo hay que indicar al programa que se trata de un valor "no
modificable", para ello hay que añadir antes del "tipo" la palabra "const", que va a hacer que la
variable sea de solo lectura.

const float pi= 3.1415; //crea una constante de tipo ''float" y le asigna el valor 3.1415

Es posible crear constantes usando #define, esta sentencia va a nombrar las constantes
antes de ser compiladas por Arduino. Las constantes creadas de esta manera no van a ocupar
memoria de programa, ya que el compilador va a remplazar estas constantes con el valor definido
en el momento de compilar.

#define pi 3.1415 //crea una constante usando #define a lo que le asigna el valor 3.1415

Hay que tener cuidado a la hora de usar #define, ya que la sintaxis es diferente, no hay
que poner el operador de asignación "=" ni cerrar sentencia con el punto y coma ";".
Usar #define puede ser problemático, ya que si existe en cualquier parte del programa
alguna constante o variable con el mismo nombre que tengamos asignado en #define, el
programa lo va a sustituir con el valor que tengamos asignado a esta constante, por ello se debe
tener cuidado a la hora de asignar constantes con #define y no crear constantes muy genéricas
cómo #define x 10,ya que "x" es muy común usarlo como variable dentro de alguna función o
bucle.

9 ARDUINO – CLASE 1
 OPERADORES

Los operadores son los elementos con los que vamos a transformar las variables del
programa, hacer comparaciones, contar un número determinado de eventos. Los operadores se
pueden considerar como uno de los elementos más importantes junto con las estructuras de
control. Dentro de los operadores, podemos encontrarlos de varios tipos.

Operadores aritméticos

Los operadores aritméticos son operadores que nos van a permitir realizar operaciones
básicas como sumar, restar, dividir o multiplicar.

x = x + 5; //suma x+5 y guarda el valor en x

y= y - 8; //resta 8 a el valor "y" almacena el resultado en "y"
z = z * 2; //multiplica z*2 y guarda el valor en z
k = k / 3; //divide k entre 3 y guarda el valor en k
p = 10; // asigna a p el valor 10

Hay que tener en cuenta el tipo de variable que estamos usando a la hora de realizar
operaciones, ya que si vamos a efectuar una operación que da como resultado un numero con
decimales y hemos definido estas variables como int (entero), el resultado no va a mostrar la
parte decimal (10 / 3 va a devolver 3 en lugar de 3.33).

Asignaciones compuestas

Las asignaciones compuestas combinan una operación aritmética con una variable
asignada. Estas asignaciones son usadas comúnmente en bucles.

x ++; //equivale a x= x + 1 (incrementa x en 1)

x --; //equivale a x= x - 1 (decrementa x en 1)
x += y; //equivale a x= x + y
x -= y; //equivale a x= x - y
x *= y; //equivale a x= x * y
x /= y; /equivale a x= x / y

10 ARDUINO – CLASE 1
Operadores de comparación

Los operadores de comparación se usan con frecuencia en estructuras condicionales para

comprobar si una condición se cumple o no. Normalmente estos condicionales realizan la
comparación entre las variables y constantes del programa.

x == y; //x es igual a y
x != y; //x es distinto de y
x < y; //x es menor que y
x > y; //x es mayor que y
x <= y; //x es menor o igual que y
x >= y; // x es mayor o igual que y

Operadores Booleanos

Son operadores lógicos que se usan para comparar 2 o más expresiones y que no
devuelven un valor, sino que dan un estado de "verdadero" (si se cumple la expresión) o "falso"
(si no se cumple). Existen 3 operadores lógicos, AND "&&", OR "||" y NOT "!".

if (x<3 && x>0) //Cierto si se cumplen las dos expresiones

if (x<7 || x=20) //Cierto si se cumple alguna de las dos expresiones
if (!x=3) //Cierto si x es distinto de 3

11 ARDUINO – CLASE 1
 ESTRUCTURAS DE CONTROL

Dentro de las estructuras de control se engloban todos los estamentos que sirven para
guiar al programa en una u en otra dirección en función de si se cumplen o no las condiciones
que le marquemos al programa. Dentro de estas estructuras podemos encontrar condicionales,
bucles o elementos de control de flujo.

Condicionales

Los condicionales son elementos que chequean un estado o condición y si esta condición
se cumple se pasa a ejecutar las sentencias englobadas dentro de la condición.

if (si...)

if es un estamento que se utiliza para comprobar si una determinada condición se cumple.

Si la condición se cumple, se pasará a if (x==10) / /Si x es igual a 10 ejecuta la instrucción
ejecutar las sentencias encerradas {
dentro del bloque if, si no se cumple la ejecuta instrucciones;
condición, el programa saltará este }
bloque sin ejecutar ninguna
instrucción.

if ... else (si... si no ...)

if... else funciona de igual forma que if, pero añade la posibilidad de que la condición no
se cumpla, pasando a ejecutar
if (y != 10) // Si "y" es distinto de 10 ejecuta las instrucciones
las instrucciones encerradas
{
dentro de else.
ejecuta instrucciones;
Este condicional puede
}
ir precedido de otras
else //si no, ejecuta esta instrucción
estructuras condicionales del
{
mismo tipo, anidando unas
ejecuta instrucciones;
dentro de otras y haciendo que
}
sean mutuamente excluyentes.

12 ARDUINO – CLASE 1
 if (valor< 100) // Si valor es menor que 100 ejecuta la instrucción
{
ejecuta instrucciones;
}
else if (valor >=500) // Si valor es mayor o igual que 500 ejecuta la instrucción
{
ejecuta instrucciones;
}
else //si no se cumplen las condiciones anteriores, ejecuta esta instrucción
{
ejecuta instrucciones;
}

Bucles

Los bucles son elementos que hacen que el programa entre en un ciclo de repetición
mientras se cumplan las condiciones del bucle.

for

El bucle for se usa para repetir un bloque de sentencias un número determinado de veces.
Cada vez que se terminan de ejecutar las sentencias encerradas dentro del bucle, se comprobará
la condición inicial, repitiéndose el buche mientras se cumpla dicha condición.

for (inicialización; condición; expresión)

{
ejecuta instrucciones;
}

El buche for está formado por 3 partes, la inicialización, la condición del bucle y una
expresión (la expresión no es necesaria o puede ponerse dentro de las sentencias del bucle).
Ejemplo de bucle for:

13 ARDUINO – CLASE 1
 for (int x=0: x<10; x++) //declara la variable x y la inicializa a 0, comprueba la
//condición (x<10}, incrementa x en 1
{
digitalWrite (13, HIGH); //envía un 1 al pin 13
delay {500); //espera 500ms
digitalWrite (13, LOW); //envía un O al pin 13
delay (500); //espera 500ms
}

while

El bucle while es un bucle que se repetirá constantemente mientras se cumpla la

expresión del bucle. Dentro de la expresión del bucle se pueden usar variables que cambien
dentro del propio bucle o que tomen el valor de alguna de las entradas de Arduino que podemos
tener asociadas a sensores u otros elementos.

while (sensor< 150) //ejecuta el bucle mientras "sensor" sea menor a 150
{
ejecuta instrucciones;
}

do ... while

El bucle do ... while funciona de la misma manera que while, con la única diferencia de
que va a ejecutar al menos 1 vez el bucle, ya que la condición del mismo se comprueba al final.

do
{
sensor= analogRead (1); //asigna a "sensor" el valor de la entrada analógica 1
} while (sensor< 150) //repite el bucle mientras "sensor" sea menor que 150

14 ARDUINO – CLASE 1
 ENTRADAS Y SALIDAS E/S

Arduino es una plataforma de desarrollo Hardware que cuenta con pines E/S para
comunicarse con el exterior. Estos pines E/S tienen características especiales que los hacen
propicios para una u otra tarea en función del tipo de pin. Estas E/S pueden englobarse en 3
tipos básicos, E/S analógicas, E/S digitales y E/S para la comunicación serie. Existen también
pines de propósito especiales como salidas de reloj u osciladores y pines de alimentación con
los que podemos suministrar diferentes tensiones a placas externas

Antes de empezar a trabajar con Arduino, deben de ser configurados los pines de la placa
que vayan a ser usados, asignándolos como entradas o como salidas. En ningún caso un mismo
pin podrá hacer de entrada y de salida al mismo tiempo.
La configuración de los pines se hará dentro de la función setup(), estableciendo el modo
de trabajo del pin como entrada o como salida.
La instrucción que se utiliza para realizar la configuración de los pines es pinMode, donde
habrá que asignarle el pin que queremos configurar y si queremos que actúe como entrada
(INPUT) o como salida (OUTPUT).

void setup()
{
pinMode (10, OUTPUT); //configura el pin 10 como salida
}

15 ARDUINO – CLASE 1
 Los pines de Arduino están configurados por defecto como entradas, por lo que no es
necesario indicarles el modo de trabajo si vamos a trabajar con ellos como entradas.
La razón de tener los pines configurados por defecto como entradas, es que las entradas
se encuentran en un estado de alta impedancia, lo que va a evitar en muchos casos que dañemos
la placa al realizar una mala conexión. Si establecemos un pin como salida y por error entra
corriente por dicho pin lo más seguro es que dañemos el microcontrolador de manera irreversible.
Los pines que tengamos configurados como salida (OUTPUT) van a suministrar una
corriente máxima de 40mA por separado, sin que la corriente total de las salidas pueda superar
los 200mA. Esta corriente es suficiente para hacer brillar un led, pero insuficiente para activar
elementos de mayor potencia.

E/S Digitales

Los pines asignados a E/S digitales, son pines que trabajan con dos estados HIGH (alto)
o LOW (BAJO). Según el modelo de Arduino que estemos usando, va a tomar el estado HIGH
(alto) como 5v o como 3.3v, el estado LOW (bajo) está asociado a un nivel de voltaje 0.

Lectura de entradas digitales (digitalRead)

Al hacer una lectura digital, vamos a leer el valor de un pin almacenando el resultado como
HIGH (alto o 1) o como LOW (bajo o 0).

valor= digitalRead (pin); //la variable "valor" toma el estado asociado al pin

Podemos especificar el pin asignándole directamente la numeración del pin digital que
queremos leer o con una variable o constante previamente definida.

16 ARDUINO – CLASE 1
 Escritura de salidas digitales (digitalWrite)

Cuando hacemos una escritura digital vamos a mandar al pin definido previamente como
salida el valor HIGH o LOW. El valor HIGH se va a traducir (en función del tipo de Arduino) por
una señal de 5 o 3.3 voltios.

digitalWrite (pin, HIGH); //Establece el pin en estado alto (5 o 3.3v)

Ejemplo E/S digital:

int ledPin = 13; // pin de salida para el LED

int inPin = 2; // pin de entrada para el switch

void setup()
{
pinMode(ledPin, OUTPUT); // Se declara el LED como salida
pinMode(inPin, INPUT); // Se declara el Switch como entrada
}
void loop()
{
If (digitalRead(inPin) == HIGH) // Comprueba si la entrada está en HIGH
{
digitalWrite(ledPin, HIGH); // prende el LED
delay(1000); // pausa por un segundo
digitalWrite(ledPin, LOW); // apaga el LED
delay(1000); // pausa por un segundo
}
}

17 ARDUINO – CLASE 1
 DIAGRAMA DE FLUJO

El diagrama de flujo es una manera de representar gráficamente un algoritmo o un

proceso de alguna naturaleza, a través de una serie de pasos estructurados y vinculados que
permiten su revisión como un todo.
La representación gráfica de estos procesos emplea, en los diagramas de flujo, una serie
determinada de figuras geométricas que representan cada paso puntual del proceso que está
siendo evaluado. Estas formas definidas de antemano se conectan entre sí a través de flechas
y líneas que marcan la dirección del flujo y establecen el recorrido del proceso, como si de un
mapa se tratara.
Hay cuatro tipos de diagrama de flujo en base al modo de su representación:
 Horizontal. Va de derecha a izquierda, según el orden de la lectura.
 Vertical. Va de arriba hacia abajo, como una lista ordenada.
 Panorámico. Permiten ver el proceso entero en una sola hoja, usando el modelo vertical
y el horizontal.
 Arquitectónico. Representa un itinerario de trabajo o un área de trabajo.

Los diagramas de flujo son un mecanismo de control y descripción de procesos, que

permiten una mayor organización, evaluación o replanteamiento de secuencias de actividades y
procesos de distinta índole, dado que son versátiles y sencillos. Son empleados a menudo en
disciplinas como la programación, la informática, la economía, las finanzas, los procesos
industriales e incluso la psicología cognitiva.

Proceso de un diagrama de flujo

En este ámbito, hablamos de procesos para referirnos a una secuencia específica de

actividades, es decir, a los pasos a dar dentro del diagrama de flujo. Por ejemplo, en informática,
los procesos son secuencias iniciadas o bien por disparadores programados dentro del sistema,
o por intervenciones del usuario del sistema. Cada uno posee una dirección, un propósito y una
serie de pasos que abarca.

18 ARDUINO – CLASE 1
Simbología de un diagrama de flujo

Los principales símbolos convencionales que se emplean en los diagramas de flujo son
los siguientes:

Ejemplos de diagrama de flujo

Diagrama de flujo para la compra de unos zapatos:

19 ARDUINO – CLASE 1
 Diagrama de flujo para reproducir un DVD:

20 ARDUINO – CLASE 1
 PRÁCTICA Nº 1: PARPADEO DE UN LED

Materiales

- Protoboard.
- Arduino.
- Cables de conexión.
- 1 LED.
- 1 resistencia de 220 Ω.

Objetivo

Con esta práctica se pretende explicar al alumno el esquema de programación de

microcontroladores, el montaje de circuitos sencillos y la estructura de la placa Arduino y
además el concepto de salida digital. El programa es sencillo y consiste en hacer parpadear
un LED con una frecuencia de 1 segundo
El alumno debe aprender:
1. Definir variables int
2. Inicializar las variables de salida pinMode(variable,OUTPUT);
3. Hacer bucles para que se repita la secuencia void loop()
4. Función para hacer que funcione el LED digitalWrite(variable,HIGH);
5. Función para hacer que no funcione el LED digitalWrite(variable,LOW);
6. Función para mantener una variable en un estado durante un tiempo delay (tiempo en
ms).

Montaje

21 ARDUINO – CLASE 1
Programa y Diagrama de Flujo

/*
Parpadeo: Enciende un LED un segundo, entonces se apaga
1 segundo y así sucesivamente. El LED está conectado al
Pin 3 y lleva en serie una resistencia de protección cuyo valor
podrá estar entre 120 Ω y 220 Ω.
*/
int ledPin = 3; // LED conectado a pin 3

void setup()
{
pinMode(ledPin, OUTPUT);
// inicializa el pin 3 como salida
}
// ahora hacemos un bucle
void loop()
{
digitalWrite(ledPin, HIGH); // enciende el LED
delay(1000); // espera un segundo
digitalWrite(ledPin, LOW); // apaga el LED
delay(1000); // espera un segundo
}

22 ARDUINO – CLASE 1
 PRÁCTICA N° 2: SEMÁFORO SIMPLE

Materiales

 1 Arduino UNO
 1 Protoboard
 4 Cables para conexión
 3 LEDs
 3 Resistencias de 220Ω (rojo-rojo-marrón)

Objetivo

El objetivo de esta práctica es construir un semáforo simple, es decir, se va a programar

un código encargado de simular un semáforo como el que se puede encontrar en cualquier
ciudad.

Esquema eléctrico

Se conectan los LEDs rojo, amarillo y verde

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

V = 5V - 2.1V = 2.9V
I = 20mA

V=IxR;R=V/I

R = 2.9V / 0.02A = 145Ω -> 220Ω (por

aproximación)

23 ARDUINO – CLASE 1
Programa

En primer lugar, se configuran los pines digitales 11, 12 y 13 en modo salida (OUTPUT).
Esta configuración se establece en la función setup(), ya que solamente se ejecuta una vez.
Además, se ha creado la inicialización de los pines a un valor bajo (LOW).
Al ejecutar el código se deberán establecer los pines digitales a un valor bajo para
inicializar así los LEDs. A continuación, se procede a activar y desactivar los diferentes pines
simulando el funcionamiento del semáforo.

void setup()
{
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
digitalWrite(13, LOW);
digitalWrite(12, LOW);
digitalWrite(11, LOW);
}

void loop()
{
digitalWrite(13, LOW);
digitalWrite(11, HIGH);
delay(5000);
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
delay(5000);
}

24 ARDUINO – CLASE 1
 PRÁCTICA Nº 3: CONTROL DE UN LED CON PULSADOR

Materiales

- Protoboard.
- Arduino.
- Cables de conexión.
- 1 LED.
- 1 Pulsador.
- 2 resistencias (220 Ω y 1 KΩ).

Objetivo

El LED rojo se debe encender cuando accionamos el pulsador.

En esta práctica introducimos los siguientes conceptos:
- Variable val (donde se almacena el estado del pulsador).
- Inicializar una variable de entrada de información pinMode(variable,INPUT);
- Función que nos dice el estado del interruptor digitalRead(variable);
- Función que permite actuar de una forma cuando el interruptor está cerrado y de otra forma
cuando el interruptor está abierto if (val==HIGH){ } else{}

Montaje

25 ARDUINO – CLASE 1
Programa y Diagrama de Flujo

/* El objetivo de este programa es

controlar el encendido y apagado de un
led. Si el pulsador está presionado se
enciende el LED si no está apagado */

int pulsador=8;
int led=1;
int val=0;

void setup()
{
pinMode(pulsador,INPUT);
pinMode(led,OUTPUT);
}
void loop()
{
val=digitalRead(pulsador);
if(val==HIGH)
{
digitalWrite(led,HIGH);
}
else
{
digitalWrite(led,LOW);
}
}

26 ARDUINO – CLASE 1
 PULSADORES

Para aprovechar las entradas digitales para leer el estado de un interruptor o pulsador con
Arduino necesitaremos realizar correctamente un montaje específico y la
ayuda de dos nuevas amigas las resistencias de Pull Down y Pull Up. Aunque
ambos casos son muy similares, el montaje y el tipo de resistencia a usar
dependerá de si queremos que al accionar el pulsador o interruptor leamos un
valor LOW o HIGH.
Para entender el funcionamiento de ambos montajes vamos a presentar el razonamiento
lógico por el cual se llega al mismo, para lo cual utilizaremos dos montajes incorrectos que nos
ayudarán a entender el papel de cada elemento en el montaje definitivo.
Por tanto, empezamos con el primer intento de realizar una lectura del estado del pulsador.

Primer intento, conexión directa

Nuestra primera idea para leer un pulsador podría ser conectar directamente un PIN digital
de Arduino a un valor de tensión de referencia, ya sea este 0V o 5V. Al cerrar el pulsador la
tensión en el PIN sería el valor de referencia (0V o 5V depende del montaje) y podríamos realizar
la lectura como en cualquier entrada digital.

¿Cuál es el problema? Bueno, esto funcionará cuando el interruptor está cerrado. Pero,
¿qué pasa cuando el interruptor está abierto? En este caso estamos dejando el PIN totalmente
desconectado de cualquier tensión, algo que denominaremos estado de alta impedancia.
¿Qué valor registra un autómata si realizamos la medición en estado de alta impedancia?
Pues depende de varios factores, como la construcción interna del autómata o el último estado
al que haya estado conectado. Pero, en resumen, la entrada está en un estado indeterminado,

27 ARDUINO – CLASE 1
es decir, que puede asumir cualquier valor. Por tanto, es necesario evitar esta situación en
nuestros diseños.
¿Cómo podemos resolver este estado de indeterminación? Bueno, esto nos lleva
directamente a nuestro segundo intento.

Mejorando nuestra solución, doble conexión

Lo siguiente que podríamos pensar es conectar el PIN a dos referencias de tensión,

alternadas en función del estado del interruptor:
 Para medir un valor LOW al accionar el interruptor, podemos conectar el PIN de forma fija
a 5V, y a 0V a través del interruptor. Con el interruptor abierto leeríamos HIGH, y al cerrar
el interruptor se forzaría 0V en el PIN, por lo que leeríamos LOW.
 Para medir un valor HIGH al accionar el interruptor, podemos conectar el PIN de forma
fija a 0V, y a 5V a través del interruptor. Con el interruptor abierto leeríamos LOW, y al
cerrar el interruptor se forzaría 5V en el PIN, por lo que leeríamos HIGH.

¿Cuál es el problema de este montaje? Pues que al pulsar el interruptor estamos

conectando directamente los valores de 0V y 5V, lo que significa que estamos causando un
cortocircuito. Esto provocaría el paso de un elevado de corriente y un rápido calentamiento de
componentes y conductores.
¿Cómo evitar este cortocircuito? Bueno, estamos cerca. Esto lo veremos a continuación
en el montaje definitivo.
Los cortocircuitos son fallos peligrosos. Además de dañar algún componente podéis llegar
a provocar un incendio. Ser cuidadosos.

28 ARDUINO – CLASE 1
 El montaje tampoco funcionaría porque estaríamos conectando el PIN simultáneamente a
0V y 5V, por lo que tendríamos nuevamente una indeterminación, y la medición real dependería
de la resistencia de los conductores a ambos niveles de tensión.

Montaje correcto, resistencias de pull-down o pull-up

Como habíamos adelantado, para resolver el montaje correctamente necesitaremos la

presencia de dos nuevas amigas, las resistencias de Pull Down y Pull Up. Estas dos resistencias
son un mecanismo básico, muy habitual dentro del mundo de la electrónica y automatización.

Las resistencias de Pull-Down y Pull-Up se conectan entre el PIN digital y una de las
tensiones de referencia (0V o 5V) y "fuerzan" (de ahí su nombre) el valor de la tensión a LOW o
HIGH, respectivamente.
La resistencia de Pull-Up fuerza HIGH cuando el pulsador está abierto. Cuando está
cerrado el PIN se pone a LOW, la intensidad que circula se ve limitada por esta resistencia
La resistencia de Pull-Down fuerza LOW cuando el pulsador está abierto. Cuando está cerrado
el PIN se pone a HIGH, y la intensidad que circula se ve limitada por esta resistencia
Así es como quedaría el montaje final en vista esquemática (la conexión de puede realizar
en empleando cualquiera de los PIN digital) y, a continuación, el cableado en una placa de
prototipos.
.

29 ARDUINO – CLASE 1
 Por último, la lectura del estado del PIN se realiza normalmente podemos utilizar el
siguiente ejemplo:

30 ARDUINO – CLASE 1
 const int inputPin = 2;
int value = 0;

void setup() {
Serial.begin(9600);
pinMode(inputPin, INPUT);
}

void loop(){
value = digitalRead(inputPin); //lectura digital de pin
//mandar mensaje a puerto serie en función del valor leído
if (value == HIGH) {
Serial.println("Encendido");
}
else {
Serial.println("Apagado");
}
delay(1000);
}

Arduino dispone de resistencias de Pull Up internas de 30k pero no suelen ser usadas por
dos motivos. Tienen poca autoridad (valor de resistencia demasiado alto).
Si la configuramos incorrectamente desde el programa, podemos generar un cortocircuto,
por lo que es preferible conectara físicamente para verificar que no nos la hemos dejado.

¿Qué valor de resistencia elegir?

El valor de la resistencia viene condicionado por la intensidad que pasa al accionar el

interruptor, y por un concepto llamado la “autoridad del Pull Down/up” que está relacionado con
el ruido en la medición.
Una resistencia muy pequeña, tendrá mucha autoridad, pero permitirá el paso de una
mayor corriente, lo que supone mayor consumo y mayor calentamiento.
Una resistencia muy grande, dejará pasar poca corriente, pero tendrá poca autoridad, por
lo que será más susceptible a mediciones incorrectas debidas a ruido.

31 ARDUINO – CLASE 1
 PRÁCTICA N° 4: El AUTO FANTÁSTICO

Descripción del ejercicio

Se ha denominado este ejemplo como "El auto fantástico" en memoria de la serie de TV

de los años 80 en la que David Hasselhoff tenía una máquina de I.A. conduciendo su Pontiac.
El coche estaba equipado con gran cantidad de LEDs de todos los tamaños posibles que
realizaban efectos parpadeantes.
De esta manera hemos decidido, con el objetivo de aprender programación secuencial y
buenas técnicas para programar la placa E/S, sería interesante usar el coche fantástico como
una metáfora.
Este ejemplo hace uso de 6 LED-s conectados a los PIN 2 a 7 de la placa mediante
resistencias de 220 Ohmios. El primer código de ejemplo hace parpadear a los LED en secuencia
de uno en uno, utilizando sólo las funciones digitalWrite(pinNum,HIGH/LOW) y delay(time). El
segundo ejemplo muestra cómo usar una secuencia de control for(;;;) para hacer lo mismo, pero
en menos líneas de código. El tercer y último ejemplo se centra en el efecto visual de apagar y
encender los LED-s de una forma más suave.

Elementos necesarios Esquema

• Arduino.
• 6 LED-s.
• 6 resistencias de 220 Ohmios.
• Una protoboard.
• Cables para realizar las conexiones

32 ARDUINO – CLASE 1
Diagramas de flujo y códigos

Ejemplo 1

// Básicamente es una extensión del LED parpadeante.

int pin2 = 2; // PIN-es de los LED
int pin3 = 3;
int pin4 = 4;
int pin5 = 5;
int pin6 = 6;
int pin7 = 7;
int timer = 100; // Temporizador

33 ARDUINO – CLASE 1
void setup()
{
pinMode(pin2, OUTPUT); // Configuración de los PIN-es como salida
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(pin6, OUTPUT);
pinMode(pin7, OUTPUT);
}

void loop()
{
digitalWrite(pin2, HIGH); // Enciende y apaga secuencialmente LED-s
delay(timer);
digitalWrite(pin2, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
digitalWrite(pin3, LOW);
delay(timer);
digitalWrite(pin4, HIGH);
delay(timer);
digitalWrite(pin4, LOW);
delay(timer);
digitalWrite(pin5, HIGH);
delay(timer);
digitalWrite(pin5, LOW);
delay(timer);
digitalWrite(pin6, HIGH);
delay(timer);
digitalWrite(pin6, LOW);
delay(timer);
digitalWrite(pin7, HIGH);
delay(timer);
digitalWrite(pin7, LOW);

34 ARDUINO – CLASE 1
 delay(timer);
digitalWrite(pin6, HIGH);
delay(timer);
digitalWrite(pin6, LOW);
delay(timer);
digitalWrite(pin5, HIGH);
delay(timer);
digitalWrite(pin5, LOW);
delay(timer);
digitalWrite(pin4, HIGH);
delay(timer);
digitalWrite(pin4, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
digitalWrite(pin3, LOW);
delay(timer);
}

35 ARDUINO – CLASE 1
 Ejemplo 2

/* En este caso las luces se encenderán y apagarán todas en un sentido y luego, acabada la
secuencia en sentido contrario. */

// Reduciendo las líneas de código usando un for(;;).

int pinArray[] = {2, 3, 4, 5, 6, 7}; // Define el array de pines

int count = 0; // Contador
int timer = 100; // Temporizador

36 ARDUINO – CLASE 1
void setup()
{
for (count=0;count<6;count++)
{ // Configuramos todos los PIN-es
pinMode(pinArray[count], OUTPUT);
}
}

void loop()
{ // Enciende y apaga secuencialmente los LED-s
for (count=0;count<6;count++)
{ // utilizando la secuencia de control for(;;)
digitalWrite(pinArray[count], HIGH); // Recorrido de ida
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}
for (count=5;count>=0;count--)
{
digitalWrite(pinArray[count], HIGH); // Recorrido de vuelta
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}
}

37 ARDUINO – CLASE 1
 Ejemplo 3

// En este caso el efecto que se crea es una estela visual muy vistosa.

int pinArray[] = {2, 3, 4, 5, 6, 7}; // PIN-es

int count = 0; // Contador
int timer = 30; // Temporizador

38 ARDUINO – CLASE 1
void setup()
{
for (count=0;count<6;count++)
{ // Configuramos todas los PIN-es de golpe
pinMode(pinArray[count], OUTPUT);
}
}

void loop()
{
for (count=0;count<5;count++)
{ // Enciende los LED creando una estela visual
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count + 1], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer*2);
}
for (count=5;count>0;count--)
{
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count - 1], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer*2);
}
}
.

39 ARDUINO – CLASE 1
 PRÁCTICA N° 5: SECUENCIAS DE LUCES CON LEDS Y PULSADOR

Materiales

- ARDUINO.
- 8 leds de cualquier color.
- 10 Resistencias de 220ohms para los leds
- 2 pulsadores.
- 1 Protoboard.
- Cables de conexión.

Objetivo

La secuencia de leds va a encender hacia la derecha y cuando pulse el pulsador del PIN
11, la secuencia de leds cambia de dirección hacia la izquierda, y si pulsa el pulsador del PIN 10,
la secuencia de leds nuevamente cambia de dirección hacia la derecha.

Montaje

40 ARDUINO – CLASE 1
Programa

//Delcaración de Los Pines de los LED

byte led1=2;
byte led2=3;
byte led3=4;
byte led4=5;
byte led5=6;
byte led6=7;
byte led7=8;
byte led8=9;
byte Pizq=10; //Pulzador Izquierda
byte Pder=11; //Pulzador Derecha
int i; //Variable del Contador del FOR
long vel=40; //Velocidad de las Luces
byte valor=1; //Almacena el dato de los pulsadores
void setup()
{
// put your setup code here, to run once:
//Configura los 8 Pines digitales como SALIDAS
for(i=led1;i<=led8;i++){
pinMode(i,OUTPUT);
}
// Configura los PINES 10 y 11 Como Entradas
pinMode(Pizq,INPUT);
pinMode(Pder,INPUT);
}
void loop() {
//Si "valor" es Cero gire a la DERECHA
if(valor==0){
//Enciende los LED de Izquierda a Derecha
for(i=led1;i<=led8+3;i++){
if(i<=led8){
digitalWrite(i,HIGH); //Enciende el LED
}

41 ARDUINO – CLASE 1
 if(i>led3){
digitalWrite(i-3,LOW); //Apaga el LED
}
delay(vel); //Retardo (Espera el valor de vel)
//Lee los dos pulsadores
if(digitalRead(Pizq)){
valor=1;i=led8+3; //Cambia el valor y sale del FOR
}
if(digitalRead(Pder)){
valor=0;i=led8+3; //Cambia el valor y sale del FOR
}
}
}
//Si "valor" es uno gire a la IZQUIERDA
if(valor==1){
//Enciende los LED de Izquierda a Derecha
for(i=led8;i>=led1-3;i--){
if(i>=led1){
digitalWrite(i,HIGH); //Enciende el LED
}
if(i<led6){
digitalWrite(i+3,LOW); //Apaga el LED
}
delay(vel); //Retardo (Espera el valor de vel)
//Lee los dos pulsadores
if(digitalRead(Pizq)){
valor=1;i=led1-3; //Cambia el valor y sale del FOR
}
if(digitalRead(Pder)){
valor=0;i=led1-3; //Cambia el valor y sale del FOR
}
}
}
}

42 ARDUINO – CLASE 1
 PRÁCTICA N° 6: SENSOR PIR

¿Qué es un sensor PIR?

Los sensores infrarrojos pasivos (PIR) son dispositivos para la detección de

movimiento. Son baratos, pequeños, de baja potencia, y fáciles de usar. Por esta razón son
frecuentemente usados en juguetes, aplicaciones domóticas o sistemas de seguridad.
Los sensores PIR se basan en la medición de la radiación infrarroja. Todos los cuerpos
(vivos o no) emiten una cierta cantidad de energía infrarroja, mayor cuanto mayor es su
temperatura. Los dispositivos PIR disponen de un sensor piro eléctrico capaz de captar esta
radiación y convertirla en una señal eléctrica.
En realidad, cada sensor está dividido en dos campos y se dispone de un circuito
eléctrico que compensa ambas mediciones. Si ambos campos reciben la misma cantidad de
infrarrojos la señal eléctrica resultante es nula. Por el contrario, si los dos campos realizan una
medición diferente, se genera una señal eléctrica.
De esta forma, si un objeto atraviesa uno de los campos se genera una señal eléctrica
diferencial, que es captada por el sensor, y se emite una señal digital.

El otro elemento restante para que todo funcione es la óptica del sensor. Básicamente
es una cúpula de plástico formada por lentes de fresnel, que divide el espacio en zonas, y enfoca
la radiación infrarroja a cada uno de los campos del PIR.
De esta manera, cada uno de los sensores capta un promedio de la radiación infrarroja
del entorno. Cuando un objeto entra en el rango del sensor, alguna de las zonas marcadas por
la óptica recibirá una cantidad distinta de radiación, que será captado por uno de los campos del
sensor PIR, disparando la alarma.

43 ARDUINO – CLASE 1
 ESQUEMA ELÉCTRICO
Este es el esquema de patillaje de un sensor PIR.

44 ARDUINO – CLASE 1
 El esquema eléctrico que necesitamos es el siguiente.

Esquema montaje
Mientras que el montaje en una protoboard sería el siguiente.

45 ARDUINO – CLASE 1
Ejemplo de código

El código necesario para realizar la lectura es simple. Simplemente leemos la salida del
PIR, y hacemos parpadear el LED mientras la señal esté activa.

const int LEDPin= 13;

const int PIRPin= 2;

void setup()
{
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
}

void loop()
{
int value= digitalRead(PIRPin);

if (value == HIGH)
{
digitalWrite(LEDPin, HIGH);
delay(50);
digitalWrite(LEDPin, LOW);
delay(50);
}
else
{
digitalWrite(LEDPin, LOW);
}
}

Si quisiéramos ejecutar una acción una única vez al detectar movimiento, en lugar de todo
el tiempo que la señal este activa, usaríamos el siguiente código:

46 ARDUINO – CLASE 1
 const int LEDPin = 13; // pin para el LED
const int PIRPin = 2; // pin de entrada (for PIR sensor)

int pirState = LOW; // de inicio no hay movimiento

int val = 0; // estado del pin

void setup()
{
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
Serial.begin(9600);
}
void loop()
{
val = digitalRead(PIRPin);
if (val == HIGH) //si está activado
{
digitalWrite(LEDPin, HIGH); //LED ON
if (pirState == LOW) //si previamente estaba apagado
{
Serial.println("Sensor activado");
pirState = HIGH;
}
}
else //si esta desactivado
{
digitalWrite(LEDPin, LOW); // LED OFF
if (pirState == HIGH) //si previamente estaba encendido
{
Serial.println("Sensor parado");
pirState = LOW;
}
}
}

47 ARDUINO – CLASE 1
Bibliografía
ALiverti, P. (2017). Electrónica para Makers. Barcelona: Marcombo.

Banzi, M. (2009). Introducción a Arduino. U.S.A: O'REILLY.

Beiroa Mosquera, R. (2019). Arduino, electrónica y programación. México: Alfaomega.

Crespo, E. (s.f.). Aprendiendo Arduino. Obtenido de https://www.aprendiendoarduino.com/

Descubre Arduino. (s.f.). Obtenido de https://descubrearduino.com/

Diosdado, R. (2014). Manual de Arduino. Zona Maker.

Gallardo García, D. (s.f.). Apuntes de Arduino nivel pardillo.

García, A., & García, M. (s.f.). DIY Makers. Obtenido de http://diymakers.es/

González García, A. (s.f.). Panama Hitek. Obtenido de http://panamahitek.com/

Hernández Bran, Á. D. (2015). Arduino. Libro Azul. Guatemala.

https://www.arduino.cc/. (s.f.). Obtenido de https://www.arduino.cc/

Libró básico de Arduino. (2012). Bogotá: Tienda de Robótica.

Luis Llamas. Ingeniería, informática y diseño. (s.f.). Obtenido de https://www.luisllamas.es/

Makers, D. (s.f.). Obtenido de https://ditecnomakers.com/

(s.f.). Manual Básico de ArduBlock. Probots Robótica Educativa.

Mecabot. (s.f.). Obtenido de http://mecabot-ula.org/

Mi Electrónica Fácil. (s.f.). Obtenido de https://mielectronicafacil.com/

Núñez, J. M. (s.f.). Todotecnologia-eso. Obtenido de https://todotecnologia-eso.blogspot.com/

Peña Millahual, C. (2017). Arduino. De cero a experto. Ciudad Autónoma de Buenos Aires: Six Ediciones.

Ruiz Gutierrez, J. M. (s.f.). Prácticas con Arduino Nivel I.

Saenz Flores, M. (2018). Curso Básico de Arduino. Mecatrónica LATAM.

Scratch for Arduino (S4A). (s.f.). Obtenido de http://s4a.cat/index_es.html

Sum, A. P. (s.f.). Programo Ergo Sum. Obtenido de https://www.programoergosum.es/

Vega, E. (s.f.). Arduino para todos. Obtenido de https://arduparatodos.blogspot.com/

48 ARDUINO – CLASE 1