Ebook Arduino Desde Cero

0- Comencemos...
no te
saltees ningún paso
Esta guía se trata de como descargar, instalar y cargar nuestro primer
programa a la placa Arduino. Si recién comienzan con Arduino, no se salteen
ninguno de estos pasos. Además leer todas las instrucciones!
1) Descargar el Entorno de programación o también llamado IDE de

Arduino de la pagina oficial.
https://www.arduino.cc/en/Main/Software
Allí seleccionar correctamente el sistema operativo que posee y
proceder a descargarlo.
2) Una vez descargado, proceder a instalar del IDE o entorno de

programación del Arduino haciendo doble click en el archivo descargado
y siguiendo las instrucciones de la misma.
3) Terminada la
instalación, nos
debería aparecer
un icono de
Arduino en el
escritorio o en la
barra de
herramientas, lo
abrimos y
procedemos a la
configuración del
mismo.
Autor: Ing. Konrad Peschka https://tribumaker.com/ 1

4) Hora de configurar y seleccionar la placa que vamos a utilizar para
programar.
5) Si nos hemos descargado la última versión de Arduino de la WEB oficial,

seguramente debemos configurar el tipo de Procesador que vamos a
utilizar. La forma de hacerlo es la siguiente

6) Ahora tenemos que avisarle a nuestro programa en que puerto de
nuestra computadora esta conectado el Arduino. Estos puertos en
Windows se llaman “comX” (donde X puede ser un numero entre 0 y
100) y en MAC se llaman “dev/tty.usbserial”
7) Ahora vamos analicemos las 2 funciones que nos aparecen por defecto
en al pantalla del IDE de arduino.

8) Es hora de abrir y buscar dentro de este IDE de programación uno de
los ejemplos clásicos de la programación en Arduino que es hacer titilar
un LED que ya viene embebida en la placa de casi cualquier arduino.
9) Procedemos a cargar el programa con la flecha y listo!!!!

10) En caso de no funcionar la carga o no nos aparezca el puerto com,
habrá que instalar un driver necesario para nuestra placa Arduino.
Dicho driver se llama “CH340” y lo vamos a tener que buscar en google
como: “Driver CH340 para Arduino”
Este es un link probable de donde descargarlo
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/driver-ch340-
para-arduino-chinos-o-genericos/

1- El famoso…titila Led
Problemática: queremos hacer titilar una luz a una velocidad que
nosotros como programadores lo podamos controlar y ajustar 1 sola vez.
Por titilar se entiende que queremos que la luz se prenda por un tiempo
determinado y que luego se apague por otro tiempo determinado.
Solución: conectamos un led a nuestro Arduino, escribimos un

programa en el IDE de Arduino y luego le vamos a cargar ese código.
Para ello vamos a utilizar una instrucción (también llamado función) que se
encargue de declarar como vamos a utilizar cada uno de los pines del Arduino
pinMode(led, OUTPUT);
Luego vamos a necesitar otra función que va a ser la encargada de activar y

desactivar la salida….donde los parámetros de esta función es el número de
pin y la segunda es como queremos que este, “HIGH” o “LOW”
digitalWrite(13, HIGH);
Y por último vamos a necesitar una función que maneje el tiempo, donde el
parámetro que admite esta función es un número que será el equivalente al
tiempo en milisegundos.
delay(1000);
Tip extra: este mismo ejemplo lo podemos encontrar bajo los ejemplos
que ya trae el arduino, y esta ubicado en
Archivo > Ejemplos >Basicos > Blink
Conexión Eléctrica al Arduino

Código de Programación
/*
El Objetivo de este código es prender un led
que está conectado en el pin 13
*/
//------------ Aquí inicia la Función Setup ---------------
void setup()
{
pinMode(13, OUTPUT); //le decimos que el pin 13 es de salida
} //fin de la función loop
/*------------ Aquí inicia la Función Loop ---------------*/
void loop() //recordemos que esta es una función que

{
digitalWrite(13, HIGH); // activamos el pin 13 con un HIGH
delay(1000); // esperamos 1 segundo=1000milisegundos
digitalWrite(13, LOW); // apagamos el pin 13 con un LOW
delay(1000); // esperamos otro segundo y se repite el ciclo
}
IMPORTANTE: recordar que después de cada modificación que hagamos en el

código, hay que volver a cargar nuestro código al arduino!!!
Desafíos para entretenerse un rato ;)
1) Hacer que dicho led titile más rápido, cada 500 mili segundos.
2) Buscar el tiempo mínimo en el cual todavía podemos ver que la luz está
titilando.
3) Hacer una secuencia donde la luz vaya titilando cada vez más rápido.

2- ¿Que son esas cosas raras
llamadas funciones?
Uno de los temas centrales del código de programación con Arduino y el
lenguaje que este utiliza, son las funciones…por ello es importante abordar de
antemano que es esto de las funciones, de que se trata y como se los utiliza.
¿Que es una función?

Una función es un bloque de código que realiza alguna operación.
Una función puede tener parámetros de entradas (puede ser 1 solo o
muchísimos!!!! ), mediante la cual está (la función) recibe información para
procesar dentro del Bloque de Código mencionado antes.
A su vez, una función puede devolver 1 y solo UN parámetro de salida

también llamado RETORNO. Por ejemplo, dentro de la función suma, le
pasamos 2 o más parámetros para que sume y queremos que nos devuelva el
resultado.

Estructura de una función
Hablando generalmente, una función es una forma ordenada de escribir
una operación, muy similar a las operaciones matemáticas.
Para ello esta “forma de escribir” las funciones tiene que tener un
estándar a modo de que todos los programadores entiendan que es lo que
nuestra función hace.
Para ello vamos a nombrar de izquierda a derecha lo que tiene una

función:
a) El tipo del valor que nuestra función va a retornar (o no)

b) Nombre de la propia función, tiene que ser una palabra única, puede
estar separado por guion bajo y no puede comenzar con un número.
c) ¡¡¡¡Abre y cierra paréntesis, es una regla de ORO!!!!
d) Dentro del paréntesis van ( separados por coma) el tipo y la variable
que le queremos pasar. O no…no es obligatorio pasarle algo, en ese
caso queda paréntesis vacío.
e) Dicho bloque de código se define siempre fuera del loop, pero puede
ser “llamado” o “utilizado” desde cualquier parte de nuestro código.
f) Siempre lleva punto y coma después de cerrar el paréntesis…a no
ser que estemos definiendo fuera del Loop. En tal caso se abre y
cierra llave, escribiendo lo que sea que queramos que haga nuestra
función dentro de dichas llaves.
Ejemplos de una Función

La función SUMA
// regresar la suma de dos números cargados en a y b

int Suma(int a,int b)
{
return a+b;
}
La función CUADRADO
// regresar el cuadrado de un número que esta cargado en n

double Cuadrado(double n)
{
return n*n;
}

3- Reglas básicas para sobrevivir
Estas son algunas de las reglas o más bien recomendaciones a tener en
cuenta a la hora de programar. ¡El objetivo es ir acostumbrándose a estas
pequeñas reglas para poder ser más eficiente, prolijo y programar como los
dioses!
Case Sensitive
¡Es muy importante

acordarse de cómo se escriben
las instrucciones ya que una
mayúscula o una minúscula mal
puesta el compilador lo va a
interpretar como ERROR!
El consejo a esto, es tener un machete de instrucciones al cual podamos

consultar cuando estén en problemas y no se acuerden como se escribe
o…simplemente chequear si no hay algún ejemplo dentro del IDE de
programación del Arduino que nos pueda salvar.
¿Cómo nos damos cuenta de que está bien escrito?
Nos damos cuenta de que lo que escribimos está bien porque el IDE de
Arduino generalmente nos pinta de algún color cuando está bien escrito.
Creo que es una de las fallas mas comunes cuando comenzamos a

programar, escribimos la instrucción, colocamos los paréntesis, colocamos los
parámetros que van dentro del paréntesis, le damos enter y seguimos como si
nada.
Pero noooo!!!!! Antes de escribe la siguiente instrucción hay que colocar un

punto y coma. Ya que esta es la única manera en la cual el compilador sabe e
interpreta que terminaste con una instrucción y que después de ese punto y
coma viene la siguiente.

La regla nemotécnica que deberíamos recordar en este caso es….
“Siempre que abrimos una llave….hay que volver a cerrarla”.
Esto es importante, ya que las llaves son la única forma de indicarle al

compilador donde comienza y donde termina un bloque de código
correspondiente a una subsunción.
En caso de que abramos una llave y no la cerremos nunca, el

compilador va a interpretar que todo lo que está escrito debajo de esa llave
está dentro de dicha función hasta encontrar la siguiente llave que lo cierre.
Lo bueno es que el compilador es inteligente y cuenta cuantas llaves

hemos abierto y cuantas hemos cerrado. Y…en caso de no coincidir los valores
de dicha cuenta, nos marca un error de código.
Abrir y cerrar paréntesis
Es una regla nemotécnica Idéntica a la anterior, ya que abrir un

paréntesis indica que vamos a escribir algún parámetro dentro de la función
o…que queremos indicarle al programa que ejecute primero alguna acción.
De todas formas, lo importante es que cada paréntesis que se abra

tenga su par que lo cierre.

Es muy importante dejar comentarios a medida que vamos haciendo
códigos que supere la Carilla de código. He aquí algunas razones por la cual es
RECOMENDABLE comentar códigos:
a) Para que cuando uno mismo retome un código hecho hace varios meses
o años y quiera entender de qué se trata CIERTO bloque de código o
para que creamos CIERTA variable.
b) Para que otros compañeros que vayan a utilizar dicho código también lo
puedan comprender.
c) También nos sirve para separar partes de un mismo bloque, con el fin de
que quede todo más ordenado.
d) Se los pueden utilizar como embellecedores de código o de títulos de

bloques de códigos.
El famoso autoformato y la Tabulación

Al igual que los comentarios, la tabulación se utiliza con fines de
emprolijamiento y mejor lectura del código.
La regla básica es…cada vez que abrimos una llave, todo lo que va
adentro de la misma debe quedar tabulado con respecto a la anterior.
De esta forma sabemos donde comienza y donde termina cierta SUB-

Porción de código y podemos entender mas rápido lo que hemos escrito.
Un shortcut para el Autoformato es: CTRL +T

4- La Protoboard tu mejor amigo
Como su nombre lo indica “ Placa de Prototipado”, nos permite probar
rápido y sencillo nuestros circuitos, componentes, cableríos y programas del
Arduino.
Internamente, una protoboard, tiene conexiones preestablecidas que te

ayudarán a conectar unos componentes con otros. El esquema de conexiones
internas de una protoboard es el siguiente:
Las Líneas de colores nos indican que internamente todas esas barras
están interconectadas. Lo cual significa que, si en un agujero de la protoboard
conectamos un cable conductor, significa que este también estará conectado a
otros agujeros de la placa, según corresponda. Es como unir 2 cables!!!

Un ejemplo de aplicación de la protobard , donde un led es alimentado
desde la Bateria de 9v que a su ves posee una resistencia para limitar la
corriente.
Algunos Consejos sobre la Protoboard

• Utilizar las conexiones laterales para la alimentación, por convención se
recomienda que las líneas rojas para el positivo de la alimentación, y las
líneas negras para tierra (GND o negativo). Y los cables que salgan de
la alimentación de la protoboard (líneas rojas) sean de color rojo; y los
de GND, de color negro.
• Si utilizas distintos voltajes de alimentación, te recomiendo utilizar cables
de distintos colores para cada “canal” (voltaje) de alimentación, así
evitarás graves problemas.
• Procura mantener siempre un orden dentro de lo posible. En un diseño
bien organizado es más fácil encontrar un fallo que en uno
desorganizado.
• Si necesitas más espacio, siempre puedes acoplar más protoboards
entre ellas.
• Para realizar tus propias conexiones, puedes emplear simples cables
pelados, o bien utilizar unos cables que vienen ya preparados para este
trabajo. Se trata de unos cables de longitud fija, los cuales tienen en los
extremos unos contactos que facilitan ese trabajo de “pinchar” en la
placa de prototipado.

5- Titila Led en protoboard
Problemática: queremos prender o activar un elemento que este
montado en la protoboard. El que sea un led no significa que no se puedan
activar otros elementos. Por ejemplo, Podríamos poner un módulo rele y activar
cualquier artefacto doméstico.
Solución: para comenzar con el montaje + código simple, vamos a

hacer titilar un led que este montado en al protoboard.
Para ello vamos a utilizar la instrucción pinMode(led, OUTPUT);
Luego para activar dicha salida digitalWrite(led, HIGH);
Y por último vamos a necesitar una instrucción de tiempo delay(1000);
Conexión Eléctrica al Arduino.

Código de Programación.
/*
El Objetivo de este código es prender un led
Montado en el protoboard, utilizando el pin 13
*/
const int led = 13; //definimos un alias para el pin 13
//------------Aqui inicia la Funcion Setup---------------

void setup()
{
pinMode(led, OUTPUT); //le decimos que el pin 13 es de salida
} //fin de la funcion loop
//------------Aqui inicia la Funcion Loop---------------

void loop() //recordemos que esta es una funcion que
{
digitalWrite(led, HIGH); // activamos el LED 13 con un HIGH
digitalWrite(led, LOW); // apagamos el pin led con un LOW
}
1) Utilizar para prender le mismo led el Pin 12. Para lo cual habrá que
modificar el código y la conexión del cable que va del led al Arduino.
2) Hacer que dicho led titile más rápido, cada 500 mili segundos.

6- Activemos más Leds
Problemática: en esta ocasión queremos activar la mayor cantidad de
leds posibles, comandar cada uno de ellos y realizar alguna secuencia de
prendido determinado pro el usuario.
Solución: para ello vamos a necesitar tener un cierto orden con la

disposición de leds, recordar en que pin está conectado cada color para luego
poder programarlos.
Podemos utilizar como base el código de ejemplo que viene con Arduino
ubicado en:
Archivo > Ejemplos >Basicos > Blink

Tip IMPORTANTE!!!!!
En lo posible hay que evitar usar los pines 0 y 1 del Arduino, ya que
estos dos pines son utilizados por la interface con el puerto USB y poder
programar nuestro Arduino.
Lo cual significa, de que si tenemos algún elemento conectado en estos pines y
estamos intentando programar al Arduino, puede llegar a causar algún
conflicto.
/*
El Objetivo de este código es prender la mayor cantidad de leds
Que tengamos a disposicion
*/
//------------Aqui inicia la Funcion Setup---------------

void setup()
{
pinMode(12, OUTPUT); //le decimos que el pin 13 es de salida
pinMode(11, OUTPUT);
pinMode(10, OUTPUT);
pinMode(9, OUTPUT);
pinMode(8, OUTPUT);
pinMode(7, OUTPUT);
} //fin de la funcion loop
//------------Aqui inicia la Funcion Loop---------------

void loop() //recordemos que esta es una funcion que
{
digitalWrite(12, HIGH); // activamos el LED 13 con un HIGH
digitalWrite(12, LOW); // apagamos el pin 13 con un LOW

digitalWrite(11, LOW);

}
IMPORTANTE: recordar que después de cada modificación que hagamos en el

código, hay que volver a cargar nuestro código al arduino!!!

1) Activar una secuencia de luces incrementales, prendiéndose las luces

de a 1 hasta que estén todos prendidos. Y para comenzar se vuelvan a
apagar todos.
2) Realizar la Programación de la siguiente secuencia cíclica y repetitiva.

7- El “#define” vino a
salvar al Semáforo
Problemática: queremos independizarnos de tener que recordar que led
y de qué color es el que hemos conectado en el “PIN X”. ¡Además,
aprovecharemos este ejercicio para hacer nuestro primer semáforo con código!
Solución: para ello se utiliza una asociación de palabra con los números
de los pines. Y esto se puede lograr con la siguiente función:
#define Nombre_que_quiero_usar NUM_PIN ;
Esta línea de código es especial, ya que en principio no necesita del

símbolo IGUAL que vamos a ver más adelante en las asignaciones de
variables. Y en principio también funciona si no le colocamos el PUNTO Y
COMA. Pero por buenas costumbres les pido que lo coloquen.
Además, en este ejercicio, aprovecharemos y vamos a programar el

semáforo, pero ahora con código!!!

/*
El Objetivo de este código es programar un semáforo
Y utilizar la función #define para asocial nombre a pines
*/
// -------- Acá asociamos los nombres a cada pin ------

#define led_rojo 10;
#define led_amarillo 11;
#define led_verde 12;
//------------ Aqui inicia la Función Setup ---------------

void setup()
{
pinMode(led_rojo , OUTPUT);
pinMode(led_amarillo , OUTPUT);
pinMode(led_verde , OUTPUT);
}
//------------ Aqui inicia la Funcion Loop ---------------

void loop()
{
digitalWrite(led_rojo, HIGH);
delay(3000);
digitalWrite(led_rojo, LOW );
digitalWrite(led_amarillo, HIGH);
delay(1000);
digitalWrite(led_amarillo, LOW );
digitalWrite(led_verde, HIGH);
delay(3000);
digitalWrite(led_verde, LOW );
digitalWrite(led_amarillo, HIGH);
delay(1000);
digitalWrite(led_amarillo, LOW );
}
1) Agregar un factor más al semáforo, de que cuando este volviendo del
verde al rojo, antes de apagarse el verde, me muestro verde con
amarillo y por ultimo comience de nuevo en ROJO.
2) ¡Hacer el semáforo doble que funcionen en simultáneo!! Como en un

cruce de Avenida, cuando un semáforo está en rojo, el otro debería estar
en verde y viceversa. ¡Ojo con la transición de los Amarillos!

8- Secuencia 6 leds con FOR
Problemática: el otro problema detectado es que en caso de utilizar 6
o mas leds se vuelve tedioso tener que escribir las secuencias uno debajo de
otro. Necesitamos una condicional que nos permita automatizar una cantidad
conocida de veces una acción.
Solución: en esos casos es que se utiliza la condicional del for, esto

significa que el for se utiliza cuando se conocen cuantas veces quiero ejecutar
una acción determinada.
El for tiene como parámetros:
for (valor de inicio; valor de llegada; de a cuanto incrementa)

/*
El objetivo de este código es hacer las definiciones y las
activaciones de los leds con el for, reduciendo así la cantidad
de código y la cantidad de ifs para hacer la secuencia del
ejemplo anterior
*/
//------------Aquí inicia la Función Setup---------------
void setup()
{
//el for tiene 3 argumentos primero es el valor inicial
//segundo es hasta cuando hacerlo...mientras se cumpla..
//y el tercero es de cuanto en cuanto incrementar la variable
for(int i=7;i<13;i=i+1) //acá define una variable auxiliar “i”

{
pinMode(i, OUTPUT); //vamos definiendo los podes como salida
}
} //fin de la función loop

{
int j; //defino una variable auxiliar para el for
for(j=7;j<13;j=j+1) //con este for activo los leds

{
digitalWrite(j,HIGH); //activo los leds
delay(1000); //espero un segundo entre activaciones
}
for(j=7;j<13;j=j+1) //con este for apago los leds

{
digitalWrite(j,LOW); //desactivo los leds
delay(1000); //espero un segundo entre activaciones
}
}
Desafíos para que te entretengas

1) Hacer que apague los leds en el sentido opuesto
2) Que el mismo código prenda en un sentido y apague a la vuelta.

9- ¿De que se trata el Pulsador?
El pulsador es un componente que interrumpe el paso de la corriente.

Existen 2 Tipos:
-Los Normal Cerrado (n/c), siempre dejan pasar y cuando pulsas corta.
-Y los Normal Abierto (n/a), solo dejan pasar corriente cuando son pulsados.
Por lo general tienen cuatro patillas que están conectadas a pares como
se ve en el siguiente esquema.
Se pueden usar en un montón de áreas como:
• Botones que toman la decisión de activar o desactivar Acciones.

• Botones para realizar contadores e incrementar variables
• Existen también los llamados “fines de carrera” que son similares a los
botones que sirven para detestar si una pieza mecánica llego al extremo
de su recorrido.
Circuito eléctrico con pulsadores

Programando pulsadores con Arduino
El siguiente código lo que hace, es que cuando esta pulsado el Botón,
prende la luz, caso contrario lo apaga.
Una cosa a destacar de este código, es que utiliza algo que se llama
Resistencia de Pull-Up INTERNO, ya lo explicaremos mas adelante que
significa y para que sirve.
void setup()
{
pinMode(2, INPUT_PULLUP); //define la entrada con la resistencia interna
pinMode(13, OUTPUT); //defino el led interno como salida
}
void loop()
{
int sensorVal = digitalRead(2); //leo el pin 2 donde esta conectado el pulsador
if (sensorVal == LOW) //cuando pulso el boton prendo led

{
}
else //caso contrario al anterior, lo apago
{
}
}

¿Por qué es importante que tengan resistencia?
La respuesta a esta pregunta se entiende imaginándonos un circuito sin
resistencia como la siguiente:
• Caso 1: que pasa si decidiéramos no ponerle ninguna

resistencia? La pregunta es, si no pulso, que lee el Arduino, ¿alto
o bajo? Crea un estado que se conoce como alta impedancia,
puede valer cualquier cosa.
• Caso 2: para fijar el valor que queramos que tenga cuando el
pulsador no esta conectado, lo que se hace es colocarle un GND.
¿Pero…que pasa si positivo y negativo se juntan? Explota todo!!!
• Caso 3: justamente, para evitar que haya un cortocircuito entre
positivo y negativo, se colona una resistencia que limita la
corriente cuando se pulsa el botón.
Como vemos en la siguiente imagen, existen 2 configuraciones posible

para la utilización del pulsador con su respectiva Resistencia. Una con la
resistencia arriba y otra abajo (por eso se llaman pull-up u pull-down.
Las características de c/u es que en la de pull up vemos siempre HIGH y

cuando se pulsa vemos LOW en la entrada de nuestro Arduino. EN el caso del
pull down ocurre lo inverso.

¿Y cual elijo, pull_up o pull_down?
EL único criterio para ello es si queres que tu entrada sea de lógica
positiva o negtiva. Esto significa: si queres que cuando se pulse el botón te
aparezca HIGH, entonces usas el pull-down.
Aquí les dejo las 2 configuraciones.

10- Prender y apagar
una luz con el Pulsador
Problemática: hasta ahora todo lo visto fueron salidas digitales.
Supongamos ahora que necesitamos de alguna manera activar, dale la orden o
avisarle de algo al Arduino.
Solución: para ello se utiliza el pulsador, para tener una interacción

digital con el programa. Y poder decidir que hacer cuando se pulse. En este
caso vamos a activar el led cada vez que el pulsador sea pulsado.
Para leer el pulsador usamos la instrucción
if(digitalRead(pulsador)==HIGH)
Dentro del “if” que significa “si” en español, va la condición que queremos que
se cumpla para poder ejecutar lo que después vamos a escribir entre llaves “{ }”

/*
El objetivo de este código es leer un pulsador y mediante el
condicional IF detectar si fue pulsado o no. En caso de que
fuera pulsado activar un led, caso contrario apagarlo
*/
const int led = 2;
const int pulsador = 3;
int lectura_pulsador =LOW;
//-----función donde se setean entradas y salidas------
void setup()
{
pinMode(led, OUTPUT); //defino al led como salida
pinMode(pulsador, INPUT); //defino al pulsador como entrada
}
//-----------Programa loop Principal----------

void loop()
{
lectura_pulsador = digitalRead(pulsador);
if(lectura_pulsador ==HIGH) //leo el pulsador y detecto si esta en alto
{
digitalWrite(led, HIGH); //activo el led
}
if(lectura_pulsador ==LOW) //leo el pulsador y detecto si esta en bajo

{
digitalWrite(led, LOW); //apago el led
}
}
Algunos desafíos para que te entretengas :D

4) Hacer lo inverso a lo anterior, que siempre este prendido y cuando pulso
que se apague.
5) Hacer que en vez de prender y apagar cuando se presione, que el led
titile cada 300 milisegundos cuando el botón es pulsado.
6) Hacer el ejercicio original, pero en vez de usar 2 if’s usar el ELSE.

El Else funciona oponiéndose a la condición que esta en el if anterior.
Ejemplo: if(pepe==HIGH)
{ prender led;
}
else
{ apagar led;
}

11- Dos pulsadores y un led
Problemática: en el ejemplo anterior vimos como activar un led con
un pulsador. ¿Ahora la siguiente pregunta siguiente es, como hago para con un
pulsador prender el led y con otro apagarlo?
Solución: ahí es donde entran en juego el manejo de los dos

pulsadores, utilizando las instrucciones de
if(digitalRead(pulsador_on)==HIGH)
Para cada uno de los pulsadores pro separado.

/*
El objetivo de este ejercicio es hacer que con un pulsador se
prenda el led y con otro apagarlo.
*/
const int led = 12; //defino pin del led
const int pulsador_on=7; //defino pin pulsador
const int pulsador_off=2; //defino el pin del pulsador
//en la funcion setup se definen las entradas y salidas

void setup()
{
pinMode(led, OUTPUT); //defino led como salida
pinMode(pulsador_on, INPUT); //defino pulsador como entrada
pinMode(pulsador_off, INPUT); //defino pulsador como entrada
}
//funcion loop principal

void loop()
{
if(digitalRead(pulsador_on)==HIGH) //leo pulsador 1
{
digitalWrite(led,HIGH); //activo el led
}
if(digitalRead(pulsador_off)==HIGH) //leo el pulsador 2
{
digitalWrite(led,LOW); //apago el led
}
}
Desafíos para entretenerse
1) Hacer que presionando un pulsador quede prendido y con el otro

pulsador titile el led.
2) Hacer que con un pulsador titile rápido, y con el otro pulsador titile más
lento.

12- Activar dos leds
con dos pulsadores
Problemática: tenemos 2 leds que simulan ser artefactos que se

prenden y apagan y para controlar los mismos tenemos solo 2 entradas hechas
con pulsadores.
Solución: para ello vamos a utilizar un pulsador para cada led como ya
lo vimos con los ejemplos anteriores. Ósea, lo que vamos a hacer es, prender
led1 cuando pulsador 1 sea pulsado , si no esta pulsado que led1 este
apagado. Y lo mismos con el led2 con el pulsador2.

/*
En este ejemplo vamos a leer dos pulsador y que cada uno de ellos
prenda un led cuando sea pulsado
*/
const int led_verde = 11; //define pin para el led
const int led_rojo = 12;
const int pulsador_rojo = 3; //defino pines para le pulsador

const int pulsador_verde = 2;
//en la función setup defino las entradas y salidas

void setup()
{
pinMode(led_rojo, OUTPUT); //defino led como salida
pinMode(led_verde, OUTPUT);
pinMode(pulsador_verde, INPUT); //defino pulsador como entrada

pinMode(pulsador_rojo, INPUT);
}
//loop principal o bucle de repeticion

void loop()
{
if(digitalRead(pulsador_verde)==HIGH) //detecto si fue pulsado
{
digitalWrite(led_verde, HIGH); //activo led verde
}
else //detecto si no fue pulsado
{
digitalWrite(led_verde, LOW); //desactivo led verde
}
if(digitalRead(pulsador_rojo)==HIGH) //detecto si fue pulsado

{
digitalWrite(led_rojo, HIGH); //activo led rojo
}
{
digitalWrite(led_rojo, LOW); //desactivo led rojo
}

Desafíos extras para vos… ;D
1) Hacer que presionando un pulsador mantenga prendidos ambos leds y
que con el otro pulsador titilen ambos leds.
2) Hacer que con un pulsador prendan ambos leds y que con el otro se
apaguen.
3) Hacer que con un pulsador se prenda uno y apague el otro, y que con el
otro pulsador se prendan opuestos.
13- Dos Pulsadores y

Operadores Lógicos
Problemática: tenemos 2 pulsadores y lo que queremos hacer es
combinar los dos pulsadores. Por un lado, queremos que se prenda un led
cuando cualquiera de los pulsadores fue Pulsado. Y por el otro lado, queremos
que prenda el otro led si y solo si…los dos pulsadores son pulsados a la vez.
Solución: para ello vamos a utilizar los Operadores Lógicos!

El operador lógico de “Y” se escribe como &&,se tienen que cumplir ambas
sentencias.
El operador lógico de “o” se escribe como ||, con que se cumpla una ya
alcanza.
Entonces en el caso del “y” vamos a tener un if((a==4)&&(b==3))
Entonces en el caso del “o” vamos a tener un if((a==4)||(b==3))

/*
En este ejemplo vamos a leer dos pulsador y que
Se active led1 cuando cualquier pulsador sea pulsado
Y que se prenda led2 solo cuando se pulsan los
Dos a la vez*/
const int led_verde = 11; //define pin para el led
const int led_rojo = 12;
const int pulsador1 = 3; //defino pines para le pulsador

const int pulsador2 = 2;
//en la función setup defino las entradas y salidas

void setup()
{
pinMode(led_rojo, OUTPUT); //defino led como salida
pinMode(led_verde, OUTPUT);
pinMode(pulsador1, INPUT); //defino pulsador como entrada

pinMode(pulsador2, INPUT);
}
//loop principal o bucle de repeticion

void loop()
{
//chequeo si fueron pulsados los dos, pero entra si almenos uno esta pulsado
if((digitalRead(pulsador1)==HIGH)|| (digitalRead(pulsador2)==HIGH))
{
digitalWrite(led_verde, HIGH); //activo led verde
}
{
digitalWrite(led_verde, LOW); //desactivo led verde
}
//chequeo si fueron pulsados los dos, pero entra solo si los 2 son pulsados
if((digitalRead(pulsador1)==HIGH)&& (digitalRead(pulsador2)==HIGH))
{
digitalWrite(led_rojo, HIGH); //activo led rojo
}
{
digitalWrite(led_rojo, LOW); //desactivo led rojo
}

Algunos desafíos extras con el mismo circuito
1) Con 3 leds hacer que, se prenda un led con cada pulsador y que el
tercer led se prenda si y solo si cuando los 2 pulsadores sean pulsados.
2) Que cuando se pulsen los 2 pulsadores, el tercer led titile.
14- ¡No se quede Prendido!

En este caso vamos a ver 2 cosas:
• por un lado, el “truco del while” para hacer que el pulsador se quede
frizado mientras lo mantengamos pesionado.
• Y por otro lado vamos a ver como hacer para que la luz quede prendida
cuando presionamos el pulsador 1 sola vez
Problemática: cuando hacemos el ejercicio anterior, nos surge la duda de

como hacer que el led quede prendido con el mismo pulsador y que volviéndolo
a pulsar se apague.
Solución: para lograr esto lo que vamos a hacer es utilizar una variable,
entonces cada vez que pulso el pulsador cambio el estado de esa variable.
Con lo cual, hay que tener cuidado de que el led se prenda de acuerdo al
estado de esa variable y no cuando el pulsador es pulsado.

/*
El objetivo de este código es prender y que quede prendido el led
una vez pulsado, y después volviendo a pulsar que lo apague
*/
const int led = 2; //defino pines de los leds
const int pulsador=3;
int auxiliar=0; // auxiliar= cero -> led apagado
//auxiliar =1 -> led prendido
//función setup para entradas y salidas

void setup()
{
pinMode(led, OUTPUT); //defino led como salida
pinMode(pulsador,INPUT); //defino pulsador como entrada
}
//esta es la funcion loop principal que se repite

void loop()
{
{
delay(50); //tiempo de antirebote
while(digitalRead(pulsador)==HIGH)
; //pierdo tiempo hasta que el pulsador sea soltado
if(auxiliar==0) //chequeo si auxiliar vale 0

auxiliar=1;
else //caso contrario vale 1
auxiliar=0;
}
if(auxiliar==1) //si auxiliary vale 1 prendo led
{
digitalWrite(led, HIGH);
}
else //caso contrario vale cero y apago led
{
digitalWrite(led,LOW);
}
}
Ahhh…te aburriste? Te dejo mas desafíos!

1) Cuando pulso que titile, y cuando vuelvo a pulsar que apague
2) Hacer que con 1er pulsado se prenda, después con el pulsado 2do
titile y que con el 3ero se apague el led.

15- Hagamos un contador con luces!
Problemática: en las fábricas o en los artefactos domésticos se utiliza
mucho el ajustar el volumen, o ajustar l velocidad o ajustar cualquier parámetro
que queramos con dos pulsadores. Uno para que incremente y otro para que lo
decremente.
Solución: para ello que vamos a hacer nosotros es utilizar 6 leds para
simular volumen y con un led vamos a incrementar el valor de un contador y
con otro lo decrementamos.

/*
El objetivo de este código es utilizar un contador el cual
se incrementa con un pulsador y decrementa con otro.
A su vez, por cada valor del contador se prendera un led.
Máximo valor de conteo hasta 5
*/
const int led1 = 12; //definimos los leds
const int led2 = 11;
const int led4 = 9;
const int led5 = 8;
const int led6 = 7;
const int pulsador1 = 3; //definimos los pulsadores
const int pulsador2 = 2;
int contador=0; //defino un contador y lo inicio en cero

void setup()
{
pinMode(led1, OUTPUT); //le decimos que el pin 13 es de salida
pinMode(led2, OUTPUT);
pinMode(pulsador1, INPUT); //defino los pulsadores como entradas

pinMode(pulsador2, INPUT);

{
if(digitalRead(pulsador1)==HIGH) //chequeamos si fue pulsado
{
delay(200); //espero 200 milisegundos
contador=contador+1; //incremento el contador
if(contador>5) //chequeo si el contador vale mas de 5 y lo reseteo

contador=0;
}
if(digitalRead(pulsador2)==HIGH) //chequeamos si fue pulsado

{
delay(200); //espero 200 milisegundos
contador=contador-1; //decremento el contador
if(contador<0) //chequeo si el contador es menor a 0
contador=5;
}
//----ahora chequeamos el contador para prender los leds-------
if(contador==0) //chequeo el estado de la cuenta
digitalWrite(led1 , HIGH); //prendo el led
else
digitalWrite(led1 , LOW); //apago el led

else

else

else

else

else
Algunos desafíos Extras para vos ;)
1) Hacer que cuando me pase del 5 la cuenta se vuelva a iniciar en cero.

2) Hacer que prendan dos leds juntos y se vayan corriendo.

16- ¿Varios leds con un solo pulsador?
Problemática: la problemática que tenemos ahora es que queremos

activar 4 salidas con un solo pulsador. Es una especie de contador, que va
sumando o que va prendiendo leds a medida que vamos pulsando el mismo
botón.
Y cuando llegue al final que reinicie.
Solución: una de las soluciones que ya hemos visto es usar un monton

de if’s + un pulsador. La otra opción mas linda y ordenada es utilizar la función
switch(contador) //el switch toma lo que hay en el contador

{
case 0: //y salta al caso que corresponde al cero

const int led1 = 12; //defino pines de los leds

const int led4 = 9;
const int pulsador=5; //defino el pulsador
int contador=0; //defino un contador
void setup()
{
pinMode(led1, OUTPUT); //defino leds como salida
}
//esta es la función loop principal que se repite
void loop()
{
{
delay(50); //espero hasta soltar el pulsador
while(digitalRead(pulsador)==HIGH) ;
contador=contador+1; //incremento el contador
if(contador>4) //chequeo si es mayor a 4 y reseteo
contador=0;
}
switch(contador) //el switch trabaje con el contador
{
case 0: //caso cero apaga todo
digitalWrite(led1,LOW); //apago los leds
digitalWrite(led2,LOW);
break;
case 1: //despues va prendiendo de a un led
digitalWrite(led1,HIGH); //active un led
break;
case 2:
digitalWrite(led2,HIGH);
break;
case 3:
break;
case 4:
break;
}
}

Algunos desafíos para que te diviertas
1) Hacer que se prendan de a dos leds.
2) Hacer que en cada caso haga una secuencia de luz distinta.
3)
17- Potenciómetro y Led por Nivel

Primero tenemos que ver
de que se tratan las señales
analógicas y después
estudiaremos en detalle cómo
funciona el potenciómetro.
La diferencia entre
analógico y digital es abismal,
incluso infinito. Veamos la
gráfica.
¿Como hace
Arduino para leer una
señal analógica?
Ejemplo de un ADC con 2 Bits de

Resolución

¿Como funciona el Potenciómetro?
El potenciómetro no es mas que una resistencia que puede ser variado,

modificado gracias a un elemento mecánico que en este caso es de rotación.
Pero también hay potenciómetros de movimiento lineal e incluso hay
potenciómetros digitales!
Asi como la resistencia, el potenciómetro no tiene LADO, 1 y 3 son

prácticamente lo mismo…el pin que si hay que tener en cuenta y cuidado es el
2, ya que de allí es que salimos para conectarlo en el Arduino.
Ahora si…vayamos a la practica!
Problemática: hasta ahora solo hicimos entradas y salidas digitales,

puede suceder que necesitemos leer entradas analógicas como un
potenciómetro o un sensor que nos devuelva sus valores con tensiones
analógicas.
Lo que necesitamos ahora es que se active el led cuando el potenciómetro
supere el valor de 500 (es casi la mitad de 0-1023).
Solución: para ello vamos a utilizar las entradas analógicas con la

siguiente instrucción.
analogRead(Pin Analogico)
Que nos devuelve un valor entre 0 a 1023. Cero si la señal analógica esta en 0
voltios
Y 1023 cuando la entrada esta en 5V. Todos los demás son valores
intermedios.

/*
El objetivo de este código es leer el potenciómetro
y cuando llegue a un valor prender el led. A su vez
cuando este por debajo de un valor lo apague
*/
const int led = 2; //define el led a utilizar
void setup()
{
pinMode(led, OUTPUT); //define dicho led como salida
}
void loop()
{
if(analogRead(A0)>500) //comparo y chequeo si es mayor a 500
{
digitalWrite(led, HIGH); //prendo led
}
else //caso contrario, osea que es menor a 500
{
digitalWrite(led, LOW); //que apague led
}
}

¡¡¡A ver si te animas!!! :P
7) Hacer que se prenda cuando este por encima de los 800.

8) Hacer que se prenda en un rango entre 400 y 600.
9) Que no se prenda en los rangos 400 y 600.
18- Comunicación por puerto serie USB

La comunicación serial se trata de enviar información desde el Arduino a
la PC y viceversa. Muy utilizado para poder recibir datos, información y texto en
ambas direcciones. Gracias a ello por ejemplo se pueden guardar los datos
medidos por Arduino en un Excel o directamente enviarlo a un graficador en
tiempo real.
Problemática: ahora lo que necesitamos es comunicarnos con la PC.

Esto nos puede ser útil para estar monitoreando algún sensor o alguna variable
de alguna maquina.
La conexión que vamos a realizar ahora es a travez del puerto USB.
Solución: para ello vamos a utilizar 2 instrucciones:
Serial.begin(9600); que nos sirve para definir la velocidad de comunicación

con al PC
Serial.print(“Dato=”); que nos imprime por pantalla el texto escrito entre
comillas.
Serial.print(variable); que nos imprime el valor que contiene la variable

/*
El objetivo es leer el potenciómetro y enviar
el dato de esa lectura por puerto serie
*/
//defino una variable para guardar lo que se lee
int analogico=0;
void setup()
{
Serial.begin(9600); //inicializamos el puerto serial
//9600 es la velocidad de comunicación con la PC
}
void loop()
{
analogico=analogRead(A0); //leemos el pin Analogico 0
Serial.print(“Dato=”); //imprimimos “Dato ” por el puerto
Serial.print(analogico); //enviamos el valor leído de analógico
Serial.print(“\n”); //esta \n es para que haga un enter
}
Donde puedo ver los datos que recibo???
Los datos los podemos ver desde Herramientas > Monitor Serial o Plotter Serial

La otra opción es desde
la Lupita que vemos al
Costado de Arduino
¡Ahora siii, estos desafíos están picantes!
1) Que envíe el texto “Temperatura” y me muestre el valor del

potenciómetro.
2) Hacer que el valor del potenciómetro, en vez de ir de 0-1023 vaya de 0-
100.
3) Leer Potenciómetro + un pulsador para luego enviarlo por puerto serie.
SI pulsador esta activo quedaría -> Dato=XXX Pulsador=ON
SI pulsador desactivado quedaría -> Dato=XXX Pulsador=OFF
Donde dato es lo que viene del Potenciómetro.
Se puede usar la línea de código > Serial.print(“\t”); < para hacer un
tabulador entre dato .
Recordar que al final se pone un > Serial.print(“\n”); < para indicarle
que termine de imprimir todo y lo que sigue lo imprima en una nueva
línea.

19- Potenciómetro y Brillo LED
Antes de Adentrarnos al desafío de este ejercicio me gustaría contarles
como hace Arduino para generar una salida Analógica. En realidad, lo que se
hace es un truco que se conoce como PWM (pulse width modulation),
modulación por ancho de pulso y se trata de lo siguiente.
Muy IMPORTANTE recordar la diferencia entre una ENTRADA digital

del Arduino que es de 10 BITS (va de 0 a 1023) y la SALIDA analógica del
Arduino que es de 8 Bits (va de 0 a 255)

¡Ahora si, vayamos con el Desafío!
Problemática: una vez definido como se lee un potenciómetro, nos

puede ser de mucha utilidad poder regular el brillo las salidas, podría ser un
led, una lámpara, un motor o cualquier otro tipo de salida.
Solución: para ello vamos a aprender lo que es una salida analógica y

el valor que se le puede entregar.
analogWrite(Pin PWM,valor de 0-255);
Con esto lo que vamos a lograr es que a la salida vamos a tener entre 0-5v
acorde a los valores que le entreguemos de 0-255.

/*
El objetivo es leer el potenciómetro y usarlo de referencia
para ajustar el brillo del led con la función analogWrite.
Recordar que solo se pueden usar pines que sean PWM para
Salida analógica.
*/
int lectura=0; //defino una variable para guardar lo que se lee
void setup()
{
//solo los pines digitales se definen como In/out
//en este caso el pin 3 también es analógico
}
void loop()
{
//la función lectura me devuelve un valor entre 0-1023
lectura=analogRead(A0);
analogWrite(3,lectura/4);
//el problema es que la función Write solo acepta valores
//entre 0 y 255, por eso dividimos pro 4
Ahhh ya terminaste? Acá te van algunas más…
1) Hacer que brille solo cuando supera el valor de lectura del

Potenciómetro de 500.
2) Mismo que anterior, pero que cuando supere el valor de 500 el brillo sea
mínimo y cuando llegue a 1023 que el brillo sea máximo.

20- Salida Analógica con Led RGB
Si ya tuvieron en sus manos un led RGB, ¿se darán cuenta
que solo tiene 4 patitas, como hace para controlar los 3 leds
independientes que tiene adentro? La respuesta está en la siguiente
imagen.
¿También recordaran que cada led tiene que llevar una resistencia,
como será en este caso? ¿Una pregunta más…la resistencia va en el positivo y
negativo? ¿Importa donde lo colocamos?
Problemática: ahora necesitamos controlar un led RGB, que son R de

RED, G de Green, B de Blue…estos son los 3 colores primarios con los cuales
podemos después hacer un montón de combinación de colores.
Solución: para ello vamos a necesitar 3 salidas analógicas, osea las

que son las salidas PWM. Y después utilizar la función de salida analógica que
ya hemos visto
analogWrite(pin_salida,valor);

//como vamos a usar las salidas analógicas
//todos los leds tienen que ir en las salidas
//de PWM o salidas analógicas
const int led_red = 11;

const int led_blue = 10;
const int led_green = 9;
const int pulsador=5;

//funcion setup para entradas y salidas

void setup()
{
//pines analogicos no es necesario definirlos como output
}

//esta es la función loop principal que se repite
void loop()
{
{
delay(100); //espero hasta soltar el pulsador
contador=contador+1;
if(contador>3) //chequeo si es mayor a 4 y reseteo
contador=0;
}
{
analogWrite(led_red,0);
analogWrite(led_green,0);
analogWrite(led_blue,0);
break;
case 1: //prendo led rojo
break;
case 2: //prendo led verde
break;
case 3: //prendo led azul
break;
}
}
Mas desafíos para que te entretengas

1) Agregar un caso mas donde combinamos los colores rojo y azul para
obtener el lila o violeta.
2) Agregar mas casos y combinar los demás colores de a 2 para obtener
nuevos colores.

21- ¿Qué es un Vúmetro?
Problemática: el objetivo ahora es crearnos un marcador de nivel, o

indicador de cuanto estamos girando el potenciómetro. Una especie de
marcador de volumen.
O medidor de intensidad que también se conoce como Vúmetro.
Solución: esto se hace primeramente leyendo el potenciómetro y

después con las funciones que ya vimos en ejemplos anteriores como el Switch
() case:
Y la función map(variable para mapear,0,1023,0,6); que nos permite
cambiar el rango de 0-1023 que tiene el potenciómetro a valores entre 0-6.

/*
El objetivo de este codigo es hacer un vumetro
que nos permite ir variando el encendido de los
leds a medida que vamos incrementando el
potenciometro
*/
const int led1 = 12; //defino pines de los leds
const int led4 = 9;
const int led5 = 8;
const int led6 = 7;

int lectura=0;
//funcion setup para entradas y salidas

void setup()
{
pinMode(led1, OUTPUT); //defino leds como salida
//esta es la funcion loop principal que se repite

void loop()
{
lectura=analogRead(A0); //leemos el potenciometro A0
contador=map(lectura,0,1023,0,6);
{
break;
case 1: //despues va prendiendo de a un led

break;

case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
}
}
Mas desafíos para vos
1) Hacer que a la vuelta se vayan apagando de a uno.

2) Que los últimos 2(que serían cuando este llegando a su valor máximo el
potenciómetro) titilen en vez de quedar prendidos.

22- Recibiendo ordenes
desde la computadora
Problemática: queremos obtener datos, comandos u órdenes desde la
pc para ejecutar alguna acción. Esto puede ser útil en caso de tener algún
programa en al PC que este recibiendo datos del Arduino y que a su vez
podamos hacer una acción desde dicha aplicación (que esta en al PC) para
corregir lo que está sucediendo o activar alguna alarma.
Solución: debemos utilizar la librería “Serial” para dicho fin, para lo cual
debemos de utilizar la función:
If(Serial.available>0)
Gracias al cual podemos saber si están entrando datos pro puerto serie.
Después los datos serán leidos con:
Serial.read();
Y el paos final es comparar lo leído con Serial.read con el valor que esperamos
que llegue desde la PC, esto se hace con el if() que ya conocemos

/*
El objetivo es leer el puerto serie y acorde al dato
Que nos llega, ya sea a,b o c prendemos un led
*/
//defino una variable para guardar lo que se lee
char lectura;
void setup()
{
pinMode(12,OUTPUT);
pinMode(11,OUTPUT);
Serial.begin(9600); //inicializamos el puerto serial

//9600 es la velocidad de comunicación con la PC
}
void loop()
{
//utilizo la función Serial.available() para ver si llegaron datos
If(Serial.available()>0) //significa que llegaron datos
{
//aca leo puerto serie y guardo en lectura
lectura=Serial.read();
if(lectura==’a’) //si la lectura es igual a ‘a’

digitalWrite(12,HIGH); //prendo el led 12
else //caso contrario, osea si no es ‘a’
digitalWrite(12,LOW); //apago el led 12
if(lectura==’b’) //si la lectura es igual a ‘b’

digitalWrite(11,HIGH);
else
digitalWrite(11,LOW);
}
}
Mas desafíos, a ver si te animas?
1) Que prenda el led del pin10 cuando llega la letra ‘c’.

2) Hacer que apaguen todos los leds con la letra ‘d’.
3) Hacer que titilen los leds con la letra ‘t’.
4) Implementar los ejercicios anteriores con switch case.

23- Lectura Sensor de luz
El sensor de Luz también llamado LDR (light dependend resistor), ósea
que es una resistencia que varia según la intensidad de luz que recibe. Este
dato nos sirve para poder configurar una conexión eléctrica y poder medir dicha
variación de resistencia en función de una tensión. Que en ultima instancia
después lo leemos con la entrada analógica del Arduino.
Problemática: queremos medir la intensidad de la luz ambiente para

luego activar o desactivar una luz. A su vez queremos monitorear dicha
luminosidad desde la PC.
Solución: debemos leer el sensor de Luz con el puerto analógico +

utilizar un if para activarlo por nivel + enviarlo por puerto Serie a la PC.

/*
El objetivo de este ejercicio es leer el valor analógico
del sensor de luz, mostrarlo por el puerto serie
y activar led cuando llegue a un cierto valor
*/
const int ledpin = 2; //defino pin donde voy a conectar led
int analogico= 0; //declaro una variable para guardar

//la lectura del puerto Analogico 0
void setup()
{
Serial.begin(9600); //activo el puerto serie + velocidad
pinMode(ledpin, OUTPUT); //defino el led como salida
}
void loop()
{
analogico=analogRead(A0); //lectura del puerto analogico
Serial.print("Luz=");
Serial.print(analogico); //envio el dato por puerto serie
Serial.print("\n");
if(analogico > 800) //si llega a 800 activo el led

digitalWrite(ledpin, HIGH); //activo led
else //caso contrario lo apago
digitalWrite(ledpin, LOW);
}
1) Hacer que prenda el led cuando este por debajo del nivel y apague en
caso contrario.
2) Hacer que en pantalla muestre 100% cuando llegue a máxima
luminosidad y 0% en luminosidad minima.
3) Que por puerto serie también muestre el estado del led, “Led = Activo” ,
“Led = Apagado”

24- El sensor LM35
Es un sensor muy utilizado por su pendiente tan lineal y valor redondo
de 10mV por cada grado de variación. Esto facilita mucho el cálculo /
conversión final de la temperatura.
El tema de la conversión de Volts a Grados

Según hoja de datos, el sensor nos devuelve 10mV por cada grado de
variación. Por ente, la formula para obtener la Temperatura a partir de la
tensión medida será: T= Volts/K , donde K=10mV/C
Supongamos que el sensor esta midiendo 100grados, ósea nos esta

entregando 1V clavado.
El valor que lee Arduino cuando el sensor nos entrega 1V entonces es:
analogRead() = 1V*(1024/5V)=205
Este valor hay que pasarlo de nuevo a tensión y multiplicarlo por el factor del
sensor para obtener la temperatura final.
T = ( analogRead() *( 5/1024 ) ) / K donde K = 0.01
Reformulando la ecuación para que nos quede mas cómodo será:
Float Temperatura = (analogRead()*500.0)/1024.0
Los ceros después de la coma son intensionales, son para que Arduino
los tome como valores flotantes para hacer el calculo y no redondee a valores
Enteros.

¡Ahora si, vamos al ejercicio!
Problemática: queremos medir la temperatura de ambiente para luego

activar o desactivar una luz cuando la temperatura llegue a un nivel de 20°C.
A su vez queremos monitorear dicha luminosidad desde la PC.
Solución: debemos leer el sensor de Temperatura con el puerto

analógico + utilizar un if para activarlo por nivel + enviarlo por puerto Serie a la
PC.

/*
El objetivo de este ejercicio es leer el valor analógico
del sensor de temperatura, mostrarlo por el puerto serie
y activar led cuando llegue a un cierto valor
*/
const int ledpin = 2; //defino pin donde voy a conectar led
float temperatura= 0; //declaro una variable para guardar

//la lectura del puerto Analogico 0
void setup()
{
Serial.begin(9600); //activo el puerto serie + velocidad
pinMode(ledpin, OUTPUT); //defino el led como salida
}
void loop()
{
temperatura =(analogRead(A0)/1024.0)*500.0; //lectura del puerto analogico
Serial.print("Temp=");
Serial.print(temperatura); //envio el dato por puerto serie
Serial.print("\n");
if(temperatura > 20) //si supera los 20°C

digitalWrite(ledpin, HIGH); //activo led
else //caso contrario lo apago
digitalWrite(ledpin, LOW);
}
1) Que nos envíe por Puerto Serie el valor de tensión y el valor de

temperatura calculado.
2) Además que envíe por puerto serie el estado del led, “Led = Activo” ,
“Led = Apagado”

25- ¿De que se tratan las Librerías?
Las librerías son un conjunto de códigos hechos pro otras personas que
facilitan la programación de módulos, componentes y secuencias
predeterminadas para Arduino.
Un ejemplo clásico es el Sensor de Humedad y Temperatura que vamos
a utilizar en esta ocasión. Si quisiéramos utilizar el sensor con lo que
aprendimos hasta ahora, nos tendríamos que descarar el manual del Sensor,
analizar y estudiar como funciona el protocolo de comunicación que posee y
ponernos a decodificar el mismos.
¿No es imposible, pero nos llevaría demasiado tiempo poder lograrlo, la
pregunta del millón es…realmente vale la pena?
En este caso vamos a descargar la librería del siguiente LINK
https://github.com/adafruit/DHT-sensor-library
Pasos para descargar el Archivo comprimido.
Una vez descargado, lo ubicamos ya sea en el escritorio o lo dejamos en

descarga, ahora procederemos a instalarlo desde Arduino.

Sensor de Humedad y Temperatura DHT11
Este sensor es muy conocido en el mundo de Arduino, ya que es

económico y mediante las librerias muy fácil de utilizar. El único inconveniente
es que es muy impreciso. Según hojas de dato del sensor, tiene un rango de
error de +- 2 Grados.
En caso de necesitar mayor precisión, esta su hermano mayor el
DHT22, de +-0.5 Grados
Desafío con el sensor

Una vez instalado la librería del sensor (antes explicado) vamos a
proceder a abrir el primer ejemplo del mismo que es:

Conexión Eléctrica del Sensor
Una vez conectado y cargado el programa, abrimos el Puerto Serie y

deberíamos ver los datos que nos envía el sensor.
Desafíos con este sensor
1) Hacer que se prenda una luz y una alarma sonora cuando el sensor
llegue a 80% de humedad.
2) Que nos grafique solo la temperatura en el PLOTTER Serial de Arduino.

26- El Sensor de Ultrasonido HC-SR04
El Sensor HC-SR04 , también conocido como sensor de ultrasonido, lo
que haces es una especie de radar ULTRASONICO (lo cual significa que
nuestro oído humano no lo puede escuchar).
Con este método tipo radar (emitiendo ondas en uno de sus ojitos y
recibiendo la onda en el otro) lo que podemos hacer obtener la distancia a la
cual se encuentra un objeto físico que se atravesó en el camino de la onda.
Observamos en esta imagen como funciona el Sensor y sus pines de
TRIGGER y ECHO correspondiente.
Arduino trae pro defecto un código ejemplo para poder programar y
medir la distancia de este sensor, para ellos vamos a….

¡Procedemos a realizar la conexión eléctrica del sensor al Arduino,
donde para este ejemplo lo único que hay que tener en cuenta es que los pines
TRIGGER y ECHO están Puenteados!
¡Una vez conectado el sensor al Arduino y cargado el programa,

deberíamos ver el resultado de la medición por el Puerto SERIAL!

Problemáticas de este sensor
• Uno de los grandes problemas de este sensor es el doble significado

que le asigna al valor de distancia = 0cm.
• Por un lado o hace cuando realmente esta midiendo algo a muy corta
distancia
• Pero también lo hace cuando esta “fuera de rango”. Esto significa que el
HAZ nunca volvió.
• Para evitar este error lo que se suele hacer es directamente IGNORAR
el valor CERO de las mediciones.
• O la otra opción es Promediar 3 o mas mediciones y siempre trabajar
con el valor promediado.
¡A ver si te animas hacer esos desafíos!
3) Promediar 3 mediciones consecutivas y enviar pro puesto serie el valor

sin promediar y el Promediado.
4) ¡Hacer un sistema de alarma para la puerta, que detesta cuando alguien
paso por la misma para que suene una alarma!
5) Hacer un sistema de esos que suelen haber en las farmacias que te
miden la altura.

27- Sensor de Humedad
Suelo y Buzzer Pasivo
El sensor de humedad suelo es muy sencillo de utiliza, ya que nos envia
una señal analógica que varía según la humedad del suelo. Incluso diría que se
lo utiliza por lo general como un sensor digital, donde lo que importa es si “hay
humedad” en el suelo o “NO hay humedad” para proceder a regar.
El elemento novedoso en este caso es el parlante o Buzzer Pasivo,
quien necesita que le enviemos una frecuencia para que suene. A diferencia
del Parlante o Buzzer Activo el cual suena solo, lo único que necesita es
alimentación de 5v.
Para diferenciar entre uno y otro parlante, debemos fijarnos en la parte
baja del mismos.
EL Buzzer Pasivo se maneja con una función llamada TONE.
tone(numero de Pin , frecuencia , duración en ms);
En caso de necesitar apagar el sonido antes de lo esperado, se puede utilizar

la función noTone(numero de
pin);
Aquí les dejo una table con algunas

frecuencias de referencia. Con estas
frecuencias se podría llegar a componer
una melodía musical.

¡Vayamos a nuestro desafío!
En esta ocasión lo que queremos hacer es un sistema de alarma para riegos.
Las pautas son las siguientes:
• Cuando la planta esta humedad, que el parlante este apagado y la luz
verde tiene que estar prendida.
• Cuando la planta o la tierra de la planta comienza a estar seco, que el
rojo se prenda (verde apagado) y comience a tocar una nota suave.
• Cuando la tierra de la planta esta completamente seca, que el led rojo
titile (verde apagado) y nos emita una nota mucha mas aguda.
1) En vez de solamente emitir notas de mayor o menor frecuencia en

cada caso mencionado arriba, que emita un estribillo de alguna
canción. Buscar en Google: “Arduino tone melody example”

28- ¿Que es la pantalla de 7 Segmento?
La pantalla 7 Segmento es un conjunto de leds dispuestos de tal forma
que según como están activos, nos pueden mostrar números del 0 al 9.Sobre
todo utilizado en equipos industriales, relojes, contadores y muchas otras
aplicaciones donde solo se requieran números.
La distribución del 7 Segmento es de la siguiente forma.
Así como cuando vimos el led RGB, estos también pueden venir de
Ánodo común (todos comparten el mismo positivo) o de Cátodo común( todos
comparten el negativo)
Existe otra pantalla con mas dígitos, pero que no tiene mucho mas pines
que el 7 Segmento, cómo lo hacen?
En este caso, todos los 7 segmentos individuales están todos

conectados entre si, lo que cambia es que cada digito tiene su ANODO o
CATODO común, el cual ahora nos sirve de activador.

Imaginemos que queremos ilustrar en pantalla el numero 1234
Hacer todo este manejo de número y dígitos solo con digitalWrite()

puede ser bastante tedioso, para ello existen soluciones como al siguiente
librería:
https://github.com/DeanIsMe/SevSeg
¡Pasemos a la Practica!
El objetivo ahora es que conecten primero 1 7segmento y con

un pulsador armen un contador de 0 a 9. Ademas que cuando
llegue a 9 vuelva a reiniciarse desde 0.

Conexión Eléctrica al Arduino de un 7Segmento
A ver si te animas!!! :P
1) Hacer un contador don el 7 Segmento x4, ósea que va de 0 a 9999.

2) Armar un reloj Real y funcional!
Conexión Eléctrica al Arduino del 7Segmento x4

29- Hola Mundo con Pantalla LCD 16x2
Problemática: queremos mostrar datos, variables, estados de

sensores, estados de salidas y muchas otras cosas mediante texto , números y
valores!
Para ello necesitamos algo mas que Leds para mostrar texto y estados. Lo
podríamos hacer a través del puerto serial…pero la idea es no siempre
depender o tener que tener al Arduino conectado a una PC.
Solución: vamos a utilizar el lcd 16x2, lo cual significa que tiene 16

columnas y 2 filas para mostrar los datos que queramos ver en pantalla.
En este ejemplo lo primero que vamos a aprender es a definir todos los pines
necesarios del LCD + imprimir por pantalla en famoso y conocido HOLA
MUNDO.

Código de Programación (ojo es distinto con i2c)
/*
El objetivo de este ejercicio Imprimir por pantalla
el Clásico "Hola Mundo"
*/
//lo primero es incluir la librería del LCD
#include <LiquidCrystal.h>
//Indicamos cuales serán los pines del LCD a utilizar

//LiquidCrystal lcd(RS,E,D4,D5,D6,D7);
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
void setup()
{
lcd.begin(16, 2); //inicializamos LCD como una de 16x2
}
void loop()
{
lcd.setCursor(0,0); //nos posicionamos en la pantalla
//eso significa que lo que sigue lo va a imprimir desde esa posición
lcd.print("Hola Mundo"); //imprimimos el texto deseado

}
¡Desafíos para que te entretengas!
1) Que imprima por pantalla: “Hola, ¿qué tal?”

2) Que imprima abajo en la pantalla: “Bien y vos?”
3) Que muestre el texto “Cuenta=” y al lado imprima la cuenta de un
contador que se va incrementando cada segundo. Para ellos dejo acá
abajo las instrucciones a utilizar.
contador++; //incremento variable cada 1 segundo

delay(1000); //espero 1 segundo
lcd.print("Cuenta="); //imprimimos el texto deseado
lcd.print(contador); //imprimimos el valor de la variable

30- ¿Que es el protocolo i2c?
I²C viene del inglés Inter-Integrated Circuit, que es un bus serie de datos
desarrollado en 1982 por Philips Semiconductors para intercomunicar diversos
dispositivos dentro de una misma placa, sin la necesidad de usar tantos cables.
La forma que tienen para saber el master a quien le esta mandando la

info o de quien procede un dato, es mediante las direcciones. El protocolo i2c
permite hasta 128 direcciones/dispositivos posibles.
Nosotros para nuestro ejemplo de utilización del LCD, vamos a

descargar una librería del siguiente link:
https://github.com/Konredus/LiquidCrystal_I2C

Ya instalada la librería y conectado el LCD a nuestra placa Arduino, vamos a
proceder a abrir el ejemplo que se llama “Scanner dirección i2c”
Una vez cargado, abrimos el puerto Serial, y obtendremos la dirección

de nuestra pantalla LCD que puede ser: “0x27” “0x30” “0x3F” o similares.
Esta información la copiamos, ya que la vamos a necesitar para el otro

ejemplo que se llama “Hola mundo”.
Colocamos la dirección y cargamos dicho código!
1) Que muestre un mensaje: “Hola Me llamo XXX ”. Y despues de 1

segundo que diga abajo: “ ¿Cómo estas? ”
2) Que muestre arriba un mensaje : “ Sistema Activado ” y Abajo nos
muestro el valor del potenciómetro.

31- Mostrar datos por Pantalla
Problemática: la idea ahora es comenzar a tener una interacción entre
el usuario y lo que se ve en la pantalla LCD, para ello lo que proponemos es
que muestre el dato del potenciómetro y a su vez muestre el estado de 2
pulsadores, que bien pueden ser 2 sensores o dos acciones que están
ocurriendo.
Solución: la solución a esto es utilizar todas las funciones que ya
vinimos utilizando hasta ahora de:
-Lectura digital
-Lectura analógica
-Impresión por pantalla de textos
//lo primero es incluir la libreria del LCD
//Indicamos cuales seran los pines del LCD a utilizar

const int pulsador1=6;


int variable=0; //esta es la variable a mostrar
void setup()
{
pinMode(pulsador1,INPUT);
}
void loop()
{
lcd.print("Analogico="); //imprimimos el texto deseado
lcd.print(analogRead(A0)); //imprimimos el valor del Analogico
lcd.print(" "); //imprimimo 2 espacios para borrar
if(digitalRead(pulsador1)==HIGH) //con este pulsador incrementamos

{
lcd.print("Pul1="); //imprimimos el texto deseado
lcd.print("ON "); //imprimimos el texto ON
}
else
{
lcd.print("OFF"); //imprimimos el texto OFF
}
if(digitalRead(pulsador2)==HIGH) //con este pulsador decrementamos

{
lcd.print("ON "); //imprimimos el texto ON
}
else
{
lcd.print("OFF"); //imprimimos el texto OFF
}
}
Desafíos con el mismo Esquemático
1) Que el valor del potenciómetro vaya de 0 – 100 y que al final se indique
%. Osea, tendrá que verse -> Analógico= 75%
2) Que en la fila de abajo diga:
Cuando no se pulse ningún pulsador -> “No pulsado”
Cuando se pulse el pulsador 1 -> “Pulsador 1”
Cuando se pulse el pulsador 2 -> “Pulsador 2”

32- Un reloj hecho con pantalla LCD
Problemática: otra posible aplicación del LCD es mostrar el tiempo y la
fecha. En este caso lo que queremos hacer es mostrar un reloj común y
corriente, que cada vez que arranca el Arduino este todo en cero. Además, que
con un pulsador lo podamos pausar y con el otro darle play al reloj.
Solución: para hacer esto, vamos a utilizar lectura de pulsador y

muestreo de variables en la pantalla LCD.
//lo primero es incluir la librería del LCD
//Indicamos cuales serán los pines del LCD a utilizar

int segundo=0; //variable del segundo

int minuto=0; //variable del minuto
int hora=0; //variable de la hora
int pausa=0; //pausa=0 reloj funciona, pausa =1 reloj pausado

void setup()
{
}
void loop()
{
if(digitalRead(pulsador1)==HIGH) //con este pulsador incrementamos
{
pausa=0;
}
if(digitalRead(pulsador2)==HIGH) //con este pulsador decrementamos
{
pausa=1;
}
lcd.print("Reloj= "); //imprimimos el texto deseado
lcd.print(hora); //imprimimos la variable hora
lcd.print(":"); //imprimimos los dos puntos
lcd.print(minuto); //imprimimos el valor de la variable
lcd.print(":"); //imprimimos dos puntos
lcd.print(segundo); //imprimimos el valor de la variable
if(pausa==0) //el reloj tiene que contar

{
segundo++;
delay(1000);
if(segundo>59)
{
segundo=0;
minuto++;
if(minuto>59)
{
minuto=0;
hora++;
if(hora>23)
hora=0;
}
}
}
}
Desafíos para que te entretengas a full!!!
1) Hacer un reloj para ajedrez, donde con un pulsador arranco el reloj del
otro jugador y viceversa. Quedaría algo así:
“Reloj1 = XX:XX:XX ”
“Reloj2 = XX:XX:XX ”

33- Servo motor ¿de que se trata?
¡El servo motor es una combinación entre un motor común y corriente de
continua (de esos que venían en los juguetes cuando éramos chicos y los
rompíamos para ver que tienen adentro) y además tiene todo un conjunto de
engranajes y sistemas de control que nos permiten poder manejarlo por
ANGULOS!
En resumen, seria:
• Un motor de continua, con un sistema de control.
• Es un motor de muy fácil control, con solo 1 cable de señal se
comanda todo el motor.
• Poseen un sistema de engranajes que aumentan el torque.
• Son motores de torque bastante elevado en relación a su
pero/tamaño.
• Nos permite el control preciso por ángulo
Distintos Servos y colores

Lo que cambia entre un servo y otro es principalmente el tamaño que
esta directamente asociado al TORQUE o FUERZA que tiene el motor. Van
desde 0,5Kg/cm hasta 100Kg/cm

Ejemplos y Códigos de Programación
Para nuestra suerte, Arduino y atrae incorporado una librería para
manejo de servos y nos provee de 2 ejemplos clásicos.
El primero se llama SWEEP y se trata de que el servo se mueva a una

velocidad determinada de un lado para el otro. ¡Esto lo hace mediante un for,
vamos el ejemplo!
El circuito de conexión es la siguiente

Código Knoob de los ejemplos
Este código lo que hace es mover el servo según lo indica el Usuario. Y
para interaccionar con el usuario de nuestro equipo, utilizaremos un
Potenciómetro.
Diagrama de conexión Electrica

Mas desafíos con Servo
1) Armar un indicador de NIVEL de LUZ, una especie de velocímetro que

tenga 3 rangos o niveles (poca luz, algo de luz, mucha luz) .
Esto que nos lo marque con una aguja (como el velocímetro de los
autos). Para este proyecto van a utilizar el sensor de luz LDR y un servo
motor.
2) Con el Servo y el Ultrasonido, hacer un radar militar que escanee y
busque al oponente en todo el rango de 180 grados. ¡Si encuentra un
ponente a menos de 10cm que suene una alarma!
34- ¿Qué es un motor paso a paso?

Como su nombre lo indica y a diferencia del motor de continua y del
servo motor, esta gira 360 sin problemas, pero además se mueve por pasos
fijos.
Pare resumir sus características son:

• No es un motor de CONTINUA, pero si puede girar 360 sin problemas.
• Un motor que se mueve de a “pasos” ósea que se mueve en ángulos
determinados.
• Pueden llegar a necesitar 4 hasta 8 cables para poder controlarlos por
motor.
• Suelen ser motores con un TORQUE medio.
• Su tamaño es mas grande que el servo motor para el mismo torque.

¿Como funciona el paso a paso?
En la siguiente imagen podemos ver, por un lado, como está construido
el bobinado interior y en la tabla de abajo podemos ver una “secuencia de
activación” mediante la cual se logra ese movimiento “por pasos”

Vamos a descargar una librería del siguiente link:
https://github.com/Stan-Reifel/TinyStepper_28BYJ_48
Una vez descargado e instalado la librería, abrimos el primer ejemplo que trae!
Conectamos los pines de señal como nos indica el código ejemplo
Y por último, hay que estudiar un poco que hacen las diversas funciones que
vienen predefinidas en el código.

Desafíos para el motor paso a paso
3) Que cuando inicie el programa el motor este girando en el sentido

horario de las agujas del reloj. Y que con un pulsador le cambies de
sentido de giro. Osea, con el mismo pulsador, cada vez que sea
presionado, cambia de sentido de giro.
4) Hacer que se mueva como un motor de rotación continua, pero que la
velocidad la podamos variar con un potenciómetro.
35- Motores de continua

Ahora sí, tanto hemos hablado de este motor que es hora de que
veamos cómo funciona. Este motor es el que viene en prácticamente todos los
juguetes que tengan algún tipo de movimiento.
Su funcionamiento es tan simple como, positivo en un lado y negativo en
el otro ¡Si invertimos la polaridad…gira al revés!

Que son y para que los Drivers?
En principio podríamos pensar que con conectar el motor a 2 PINES de
nuestro Arduino y mandarle HIGH y LOW en cada caso es suficiente.
Mucho ojo, porque todos los motores tienen un consumo de corriente
“elevado” en comparación a lo que el PIN del Arduino puede entregar.
Allí es donde entra en función los llamados DRIVERS que actúan como un
amplificador de audio. Ellos reciben la señal de nuestro Arduino y lo amplifican
a la corriente que el motor necesite.
Aquí vemos algunos ejemplos de Drivers, tensiones y corrientes que
manejan y además una comparativa de precios.
Conectemos Arduino +Driver + Motor

Como primer código recomiendo que prueben como gira el motor para
un lado y para el otro. Con un intervalo de 5 segundos entre giro y giro.
El código es muy sencillo, los pasos a seguir y pensar el código son:

• Definir 2 pines como salida, en este caso el 11 y el 12
• Luego en el loop definir uno de los pones como HIGH y el otro como
LOW
• Esperar 5 segundos (o más…según lo que necesiten)
• Luego invertir el sentido de los pines, el que esta en HIGH para a LOW y
viceversa.
• ¡¡¡Esperamos 5 Segundos con un delay y listo!!!
Desafíos con el motor de continua
5) Podemos controlar la velocidad del motor, aplicando un PWM en uno de

los pines de señal. Lo que se suele hacer generalmente es aplicarlo en
el pin que esta en HIGH. El pin que esta en LOW queda así tal cual, sin
PWM.
6) Probar ajustar la velocidad del motor con un Potenciómetro.
Recordemos que el motor está girando en un solo sentido

36- ¿Que son las Interrupciones?
Las interrupciones se llaman asi por que INTERRUMPEN el
funcionamiento NORMAL de nuestro codigo de programacion.
Lo hay que tener en cuenta o en claro es que estas funciones existen
para solucionar problemas o problematicas que requieren un control
ABSOLUTO en ciertos momentos del programa.
En la siguiente imagen podemos ver un resumen de como funciona una
interrupcion.
Algunas aplicaciones de las interrupciuones son:
• Por ejemplo un boton de emergencia, que cuando el operario lo pulse,

nuestro programa deje de hacer absolutamente todo y atienda esa
EMERGENCIA!
• Otro ejemplo es con contadores, que cuando un contador llega a un
cierto valor LIMITE, este interrumpa nuestro programa y vayamos a
hacer algo mas “Importante” que lo que esta haciendo ahora.
• Otra posibilidad es la de contrar revoluciones, nuestro codigo puede
estar haciendo cualquier cosa (como pro ejemplo mostrar algo por LCD)
y en algun momento la “marca” de la rueda para por el sensor y como
esto ocurre super rapido, no habria forma de verlo con un simple IF.Si o
si hay que atenderlo con una interrupcion.

Una cosa a tener muy en cuenta, es que no todos los pines son o admiten
Interrupciones, y en cada arduino esos pines son distintos.
Estas interrupciones pueden “disparar o activarse” en ocasiones

especiales según lo determine el programador.
Los casos posibles son 4:
• Por nivel LOW.
• CHANGE que activa ante cualquier
cambio.
• En RISING, osea que cuando la
señar va de LOW a HIGH.
• Y en FALLING, osea cuando va de
HIGH a LOW.
Una interrupcion se define de la siguiente forma

• Definimos el pin que vamos a utilizar (dentro de lo que nos permite la
placa)
• Definimos la funcion y lo que va a hacer en esa funcion cuando la
interrupcion ocurra
• Definimos cuando queremos que se active esa interrupcion, por cambio,
por bajo, por subida o por bajada.
Reglas basicas a al hora de escribir un codigo
• Usar interrupciones solo en casos Exepcionales, no usarlo por ejemplo

para leer un simple pulsador cuando se lo puede hacer trnquilamente
con un if, a no ser que el codigo sea muy extenso o tenga muchos
delays y sea de muy alta prioridad.
• El programa que se escriba dentro de la interrupcion debe ser lo mas
corto posible. De esta forma si nuestro programa estaba pro ejemplo
contando un tiempo o algo, no se defasa demasiado de la cuenta que
estaba haciendo.

Codigo y programa de Ejemplo
En este programa lo que queremos hacer es activar una luz a pesar de
que el programa tengo solo un DELAY GIGANTE, lo cual seria impisible de
hacer en un codigo con un if.
//definimos los pines que vamos a utilizar y una variable deestado

const byte ledPin = 13;
const byte interruptPin = 2;
volatile byte state = LOW;
void setup()
{
pinMode(ledPin, OUTPUT);
pinMode(interruptPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(interruptPin), funcion_blink, CHANGE);
}
//la function loop donde se ejecuta el programa “normal”

void loop()
{
delay(10000);
}
//Esta función va fuera del Loop y es la encargada de la interrupción

void función_blink()
{
state = !state;
digitalWrite(ledPin, state);
}
Mas desafíos con Interrupciones
1) Hacer que un led este titilando todo el tiempo en el pin 13, y que
cuando se presione un pulsador INMEDIATAMENTE se prenda o
apague una luz que estará conectado en el pin 12 (este pin va a
estar inicialmente apagado)

37- ¿Como evitar usar los delays?
Hay un gran problema con Arduino a la hora de usar los delays() y es que
los mismos nos bloquean los programas.
Para ellos hay que comenzar a utilizar los llamados “timers” o contadores
internos de la placa Arduino.
Uno de ellos se llama millis();
Cada vez que se utiliza este código o se lo llama, nos devuelve el tiempo
en milisegundos, a partir del cual nuestro código comenzó a funcionar.
La función millis() me devuelve el número de milisegundos

desde que Arduino se ha reseteado, dado que millis devuelve un unsigned long
puede tener un valor de hasta 4.294.967.295 que son 49 días, 17 horas, 2
minutos, 47 segundos y 292 milisegundos, por lo tanto al cabo de ese periodo
el contador se resetea.
La forma de utilizarlo es mediante una variable auxiliar que guarda el

“tiempo anterior” que se hizo una acción y luego procedemos a realizar una
resta dentro de un if.
Por ejemplo, si quiero que suceda algo cada 1 segundo:
Conexión Eléctrica del Sensor al Arduino

Para ello lo que vamos a hacer es que un led titile cada 1 segundo pero
sin utilizar delay(); Conectamos un led en el pin 13 o usamos el que la placa ya
trae por defecto.

Nuestro Código de Programación
const int Led = 13;

bool EstadoLed = LOW;
unsigned long tiempoAnterior = 0;
void setup()
{
pinMode(Led, OUTPUT);
}
void loop()
{
unsigned long tiempo=millis();
if((tiempo-tiempoAnterior)>1000)
{
tiempoAnterior = millis();
if ( EstadoLed == LOW)
{
EstadoLed = HIGH;
}
else
{
EstadoLed = LOW;
}
digitalWrite(13, EstadoLed);
}
}
1) Hacer que titile cada 2 segundos

2) Hacer que 2 luces titilen cada 1 segundo de forma opuesta. Osea, si uno
esta prendido, el otro debería estar apagado.

38- ¿Como medir Revoluciones?
La idea ahora que ya sabemos cómo funcionan y como se programan
los motores, es medir la revolución de los mismos (solo valido para motores
que giran 360).
En principio esto funciona mediante un principio muy sencillo de
colocarle una “marca” al eje del motor y que esta marca suceda o pase 1 vez
pro vuelta.
Entonces, mediante un sensor, podemos detectar esa “marca” y
midiendo el intervalo de tiempo que paso entre marca y marca, podemos decir
que l revolución es XXX RPM (revoluciones por minuto).
Sería una configuración similar a la siguiente.
Ahora bien, muy probable que las revoluciones que queramos medir
sean relativamente elevadas, pro ende vamos a tener que utilizar
INTERRUPCIONES ya que con un simple IF puede que se nos pase de largo
el programa. Especialmente si después este dato lo vamos a mostrar por una
pantalla LCD o por puerto Serial.

Conexión Eléctrica del Sensor al Arduino
En este caso vamos a utilizar el Módulo sensor FC-03 o también

conocido como Sensor Horquilla, el cual va conectado al pin 2 del Arduino UNO
porque es allí donde este tiene una de sus interrupciones.

Nuestro Código de Programación
unsigned int rpmcount=0;

unsigned int rpm=0;
unsigned long timeold=0;
void setup()
{
Serial.begin(9600);
//Interrupt 0 es la que esta asociada al PIN 2 de nuestro Arduino
attachInterrupt(0, rpm_count, FALLING);
void loop()
{
//Ejecuto el calculo de RPM cada 1 segundo
delay(500);
pinMode(2,INPUT);
//desabilito la interrupcion mientras estoy haciendo el calculo
detachInterrupt(0);
//En teoria hasta aca medimos las revoluciones por segundo

//este valor multiplicado por 60, nos da las Revoluciones por minuto
rpm = (30000*rpmcount/(millis() - timeold));
timeold = millis();
Serial.print("RPM = ");
Serial.println(rpm);
rpmcount = 0;
//Volvemos a activar la interripcion para que siga contando

attachInterrupt(0, rpm_count, RISING);
}
//aqui esta la funcion a la que va la interrupcion cuando este sucede

void rpm_count()
{
//en cada vuelta incrementa el contador
rpmcount++;
}
1) Mostrar las RPM en una pantalla LCD.

Palabras finales y contacto
Desde ya muchísimas gracias pro llegar hasta el final de esta mini guía
en el cual intentamos de que aprendas, te diviertas y te desafíes más allá de
los ejercicios planteados.
¡Sin duda Arduino es un mundo muy amplio y abierto que no tiene fin! Todos
los días salen nuevas librerías, nuevos sensores, nuevos Shields y esto es un
camino de IDA.
Espero de corazón que esta mini guía te haya sido de gran utilidad y
cualquier duda o consulta no dudes en escribirme que me podes encontrar en
la Tribumaker:
https://tribumaker.com/
Por Instagram:
https://www.instagram.com/tribu.maker
O por nuestro WhatsApp:

https://bit.ly/3rhmywU
En caso de que necesites un curso en video y un acompañamiento más

personalizado, te recomiendo estos dos cursos:
https://tribumaker.com/curso-arduino-1/
https://tribumaker.com/curso-arduino-2/
¡Sin más, eso es todo de mi parte y nos vemos en una próxima ocasión!
Ing. Konrad Peschka

Ebook Arduino Desde Cero

Cargado por

Copyright:

Formatos disponibles

Ebook Arduino Desde Cero

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

Ebook Arduino Desde Cero

Cargado por

Copyright:

Formatos disponibles

0- Comencemos...

1) Descargar el Entorno de programación o también llamado IDE de

2) Una vez descargado, proceder a instalar del IDE o entorno de

Autor: Ing. Konrad Peschka https://tribumaker.com/ 1

5) Si nos hemos descargado la última versión de Arduino de la WEB oficial,

Autor: Ing. Konrad Peschka https://tribumaker.com/ 2

Autor: Ing. Konrad Peschka https://tribumaker.com/ 3

9) Procedemos a cargar el programa con la flecha y listo!!!!

Autor: Ing. Konrad Peschka https://tribumaker.com/ 4

Este es un link probable de donde descargarlo

Autor: Ing. Konrad Peschka https://tribumaker.com/ 5

Solución: conectamos un led a nuestro Arduino, escribimos un

Luego vamos a necesitar otra función que va a ser la encargada de activar y

Archivo > Ejemplos >Basicos > Blink

Conexión Eléctrica al Arduino

Autor: Ing. Konrad Peschka https://tribumaker.com/ 6

//------------ Aquí inicia la Función Setup ---------------

/*------------ Aquí inicia la Función Loop ---------------*/

void loop() //recordemos que esta es una función que

IMPORTANTE: recordar que después de cada modificación que hagamos en el

Desafíos para entretenerse un rato ;)

Autor: Ing. Konrad Peschka https://tribumaker.com/ 7

¿Que es una función?

A su vez, una función puede devolver 1 y solo UN parámetro de salida

Autor: Ing. Konrad Peschka https://tribumaker.com/ 8

Para ello vamos a nombrar de izquierda a derecha lo que tiene una

a) El tipo del valor que nuestra función va a retornar (o no)

Ejemplos de una Función

// regresar la suma de dos números cargados en a y b

// regresar el cuadrado de un número que esta cargado en n

Autor: Ing. Konrad Peschka https://tribumaker.com/ 9

¡Es muy importante

El consejo a esto, es tener un machete de instrucciones al cual podamos

¿Cómo nos damos cuenta de que está bien escrito?

Creo que es una de las fallas mas comunes cuando comenzamos a

Pero noooo!!!!! Antes de escribe la siguiente instrucción hay que colocar un

Autor: Ing. Konrad Peschka https://tribumaker.com/ 10

“Siempre que abrimos una llave….hay que volver a cerrarla”.

Esto es importante, ya que las llaves son la única forma de indicarle al

En caso de que abramos una llave y no la cerremos nunca, el

Lo bueno es que el compilador es inteligente y cuenta cuantas llaves

Abrir y cerrar paréntesis

Es una regla nemotécnica Idéntica a la anterior, ya que abrir un

De todas formas, lo importante es que cada paréntesis que se abra

Autor: Ing. Konrad Peschka https://tribumaker.com/ 11

d) Se los pueden utilizar como embellecedores de código o de títulos de

El famoso autoformato y la Tabulación

De esta forma sabemos donde comienza y donde termina cierta SUB-

Un shortcut para el Autoformato es: CTRL +T

Autor: Ing. Konrad Peschka https://tribumaker.com/ 12

Internamente, una protoboard, tiene conexiones preestablecidas que te

Autor: Ing. Konrad Peschka https://tribumaker.com/ 13

Algunos Consejos sobre la Protoboard

Autor: Ing. Konrad Peschka https://tribumaker.com/ 14

Solución: para comenzar con el montaje + código simple, vamos a

Conexión Eléctrica al Arduino.

Autor: Ing. Konrad Peschka https://tribumaker.com/ 15

//------------Aqui inicia la Funcion Setup---------------

//------------Aqui inicia la Funcion Loop---------------

/------------ Aquí inicia la Función Loop ---------------/