Unidad 6

Programar en Arduino
Librerías y resolución de problemas

Síntesis
En esta unidad veremos cómo instalar librerías que nos permitirán utilizar mayor
cantidad de módulos y finalmente pondremos todo lo aprendido en acción para
resolver un problema real con Arduino.

Librerías, ¿de qué sirven?

Una librería sería el equivalente a un Shield para el software. Es un archivo o
conjunto de archivos que contienen información que nos permiten utilizar un shield
o sensor.

Las librerías funcionan de la misma manera que una biblioteca tradicional. Cuando
se necesita información, se acude a un libro específico que contiene la información
que precisamos. Del libro obtenemos la información específica que necesitamos o
que nos sirve.

Nos facilita el uso de sensores y shield, nos permite abstraernos de los problemas de
cómo interactuar con los dispositivos, ya que el creador de la librería nos proporciona
comandos que nos harán la vida más simple al momento de usarlos. Los fabricantes
de sensores suelen generar librerías oficiales para el uso de sus sensores, pero hay
usuarios que generar librerías propias para facilitar aún más el uso de los sensores y
shields.

En este punto es cuando vemos la gran importancia de la comunidad de Arduino, ya

que hay mucha gente colaborando en hacer la programación cada vez más simple y
esto nos permite concentrarnos en resolver los problemas a solucionar en lugar de
tratar de hacer funcionar un sensor o shield.

En el siguiente video podemos ver cómo instalar una librería:

[https://www.youtube.com/watch?v=WMXomxQ5zgo]

Programar en Arduino| 1
Sensor de Humedad y temperatura
Un sensor muy popular para iniciarse en el mundo Arduino es el de humedad y
temperatura.
Existen 2 modelos muy populares, el DHT11 y el DHT22, ambos funcionan de la misma
manera, pero se diferencia en la precisión al momento de medir la temperatura y la
humedad.

[https://pixy.org/5032925
/]
[https://www.flickr.com/photos/adafruit/11211295
045]

Sensor DHT11 Sensor DHT22

En el video siguiente la manera correcta de utilizarlo y poder sacarle provecho.

[https://www.youtube.com/watch?v=sxtP16dAVno]

¿Qué es una función?

Es un segmento de código que está separado del código principal del programa, que
realiza una tarea específica y una vez finalizada la tarea regresa al bloque loop.

Luego de declarar las funciones principales void setup() y void loop() podemos
agregar más funciones, pero Arduino solo ejecutará repetidamente será void loop().

La sintaxis utilizada es:

devolucionTipoDeDato nombreFuncion (tipoDeDato nombreDeVariable){

código;

Programar en Arduino| 2
 código;

return dato;

devolucionTipoDeDato: Indica que tipo de dato retorna o devuelve la función. Puede

ser de cualquier tipo el dato que devuelve, pero si indicamos que es del tipo void la
función no devuelve nada, por lo que la línea que contiene al return no es necesaria

nombreFuncion: nombre de la función con la que la voy a poder invocar desde el

bloque loop.

tipoDeDato: indica que tipo de dato recibimos como parámetro para usar en la
función.

nombreDeVariable: nombre que va a tener dentro de la función la variable que le

pasamos a la función cuando la invocamos desde el loop.

¿Para qué nos sirven?

Nos ayudan a ser mucho más organizados, haciendo que el código sea legible.

Al utilizar funciones podemos hacer más compacto nuestro código, organizándolo por
bloques y llamando a las funciones con solo utilizar su nombre. Esto nos permite que
nuestro código sea más ligero y más fácil de entender.

A continuación veremos un ejemplo donde utilizamos una función que calcula el 50%
del dato que recibe.

void setup(){

Serial.begin(9600);

void loop(){

int a;

int b;;

a = descuento(10);

b = descuento(100);

Programar en Arduino| 3
 Serial.print(“el 50% de 10 es: ”);

Serial.println(a);

Serial.print(“el 50% de 100 es: ”);

Serial.println(b);

int descuento(int valor){

int resultado;

resultaddo = valor*0.5;

return resultado;

void loop()

Resolución de problemas
Llegamos al momento en que tenemos que aplicar el conocimiento a un problema
real.
La manera de pensar el problema es tratar de “desarmarlo” en pequeños problemas
y de esta manera podemos solucionarlos y controlarlos en el caso de fallo. Veamos
el problema y analicémoslo.

Tengo un gran problema cuando quiero tomarme un té o mate. Pongo a calentar

agua y como me distraigo fácil, se me suele hervir. Por lo que tengo que volver a
empezar de nuevo.
Sé que el agua para té debe tener una temperatura entre 60°C y 65°C y que el agua
para mate debe tener entre 70°C y 80°C y que el agua hirviendo tiene una
temperatura de 100°C.

Ahora desarmemos el problema.

Empecemos analizando los datos que tenemos como válidos.
Sabemos que el agua:
• Para té va a 60°C a 65°C
• Para mate va de 70°C a 80°C
• Hervida tiene 100°C
Luego tengo que hacerme unas preguntas y tratar de responderlas.

Programar en Arduino| 4
¿Qué quiero medir? La temperatura del agua, por lo que voy a necesitar un sensor de
temperatura.
¿Cómo puedo enterarme de una manera amigable de la temperatura del agua? Como
estoy interesado en 3 rangos de temperatura, puedo utilizar 3 leds de distintos
colores.
¿Voy a medir la temperatura constantemente o como un termómetro (lo acerco y
realizo la medición en ese instante)? Para responder esto, necesito ver el modo de
uso o tomar una decisión de uso. En mi caso, como soy distraído, prefiero que sea
una medición constante y que pueda ir viendo el paso de la temperatura en los leds,
porque en caso contrario siempre voy a terminar midiendo el agua hervida.

Pasemos en limpio lo que tenemos hasta ahora:

el sistema que vamos a desarrollar va a tener 3 leds indicadores de temperatura.

Led Azul: Agua para Té, entre 60°C a 65°C.

Led Verde: Agua para Mate, entre 70°C y 80°C.
Led Rojo: Agua Hervida a 100°C. Pero voy a considerar que si está por encima de
90°C ya no la voy a poder utilizar para ninguna de las infusiones que quiero.

Además, vamos a tener un sensor de temperatura que va a estar en la pava.

¿Qué nos falta? Nos falta saber qué nivel de datos me entregará el sensor de
temperatura en los rangos de temperatura que necesito.
Para esto simulamos conectar un sensor de temperatura en Tinkercad y setemos los
valores que obtenemos en los rangos de temperatura.

Usamos el siguiente circuito:

Y el siguiente código:

Programar en Arduino| 5
int sondaTemperatura = 0;
int temperatura = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
temperatura = analogRead(sondaTemperatura);
Serial.println(temperatura);
delay(100);
}

Modificamos el valor de temperatura en el circuito y tomamos los datos de los

extremos de cada rango.

Obtenemos los siguientes datos:

60°C: 225
65°C: 237
70°C: 248
80°C: 268
90°C: 288
100°C: 309

Ya tenemos los valores de extremo de los rangos para poder verificar cuando el
sensor entregue un valor se encuentre dentro de los rangos de temperatura.

Programar en Arduino| 6
 En este punto ya tenemos los rangos y vamos a armar el circuito dentro de Tinkercad
para poder empezar a programar.

Utilizamos el circuito que utilizamos anteriormente y agregamos los leds y las

resistencias limitadoras de 330 Ω.

Y utilizamos el siguiente código:

//defino los pines que voy a utilizar

const int sondaTemp = 0;

const int ledTe = 5;
const int ledMate = 6;
const int ledHervida = 7;
const int fueraDeRango = 4;

//defino las variables que voy a utilizar

int teMin = 225;

int teMax = 237;
int mateMin = 248;
int mateMax = 268;
int hervidaMin = 288;
int hervidaMax = 309;
int temperatura = 0;
void setup() {
pinMode(ledTe, OUTPUT);
pinMode(ledMate, OUTPUT);
pinMode(ledHervida, OUTPUT);
pinMode(fueraDeRango, OUTPUT),
Serial.begin(9600);
}

void loop() {
//leemos la temperatura del sensor
temperatura = analogRead(sondaTemp);
Serial.print("temp: ");Serial.println(temperatura);

//Verifico que la temperatura está dentro del rango de Te

Programar en Arduino| 7
 if(temperatura >= teMin && temperatura <= teMax){
digitalWrite(ledTe, HIGH);
digitalWrite(ledMate, LOW);
digitalWrite(ledHervida, LOW);
digitalWrite(fueraDeRango, LOW);
Serial.println("te");

//Verifico que la temperatura está dentro del rango de Mate

}else if(temperatura >= mateMin && temperatura <= mateMax){
digitalWrite(ledTe, LOW)
digitalWrite(ledMate, HIGH);
digitalWrite(ledHervida, LOW);
digitalWrite(fueraDeRango, LOW);
Serial.println("mate");

//Verifico que la temperatura está dentro del rango de Hervido

}else if(temperatura >= hervidaMin && temperatura <= hervidaMax){
digitalWrite(ledTe, LOW);
digitalWrite(ledMate, LOW);
digitalWrite(ledHervida, HIGH);
digitalWrite(fueraDeRango, LOW);
Serial.println("Hervida");

//Cuando llega a este punto ya sé que la temperatura no está dentro

de ningún rango
}else{
digitalWrite(ledTe, LOW);
digitalWrite(ledMate, LOW);
digitalWrite(ledHervida, LOW);
digitalWrite(fueraDeRango, HIGH);
Serial.println("fuera de rango");
}
}

En las imágenes a continuación podemos ver como variando el valor de la

temperatura en el sensor, el led correcto se enciende.

Led “Fuera de Rango” encendido

Programar en Arduino| 8
 Led “Agua para Té” encendido

Led “Agua para Mate” encendido

Programar en Arduino| 9
 Led “Agua Hervida” encendido

Básicamente el problema estaría terminado, pero si quisiéramos agregar un rango

como para utilizar en otra cosa, tendríamos que modificar mucho código. Por lo que
vamos a utilizar una función que indiquemos en qué rango está la temperatura y nos
permite agregar otros rangos sin necesidad de modificar mucho código.
Si bien el problema estaría resuelto, no estaría correctamente resuelto, ya que el
código es engorroso de leer y estamos repitiendo código.

Por lo que la solución correcta sería:

const int sondaTemp = 0;

const int ledTe = 5;
const int ledMate = 6;
const int ledHervida = 7;
const int fueraDeRango = 4;
//defino las variables que voy a utilizar
int teMin = 225;
int teMax = 237;
int mateMin = 248;
int mateMax = 268;
int hervidaMin = 288;
int hervidaMax = 309;
int temperatura = 0;
void setup() {
pinMode(ledTe, OUTPUT);
pinMode(ledMate, OUTPUT);
pinMode(ledHervida, OUTPUT);
pinMode(fueraDeRango,
OUTPUT), Serial.begin(9600);

}
void loop() {

Programar en Arduino| 10
 //leemos la temperatura del sensor
temperatura =
analogRead(sondaTemp);
Serial.print("temp: ");Serial.println(temperatura);
//Verifico que la temperatura está dentro del rango de Te
if(temperatura >= teMin && temperatura <= teMax){
rango(ledTe);
Serial.println("te");
//Verifico que la temperatura está dentro del rango de Mate
}else if(temperatura >= mateMin && temperatura <=
mateMax){ rango(ledMate);
Serial.println("mate");
//Verifico que la temperatura está dentro del rango de Hervido
}else if(temperatura >= hervidaMin && temperatura <=
hervidaMax){ rango(ledHervida);
Serial.println("Hervida");
//Cuando llega a este punto ya sé que la temperatura no está dentro
de ningún rango
}else{
rango(ledFueraDeRango);
Serial.println("fuera de
rango");
}
}
void rango(int ledAPrender){
//Apago todos los leds para solo encender el que se debe
digitalWrite(ledTe, LOW);
digitalWrite(ledMate, LOW);
digitalWrite(ledHervida, LOW);
digitalWrite(ledFueraDeRango, LOW);
//Prendo sólamente el led que corresponde
digitalWrite(ledAPrender,HIGH);
}

Ahora podemos ver que el código es más fácil de leer y si quisiéramos agregar otro
rango con agregar un if con el rango del loop y agregar la línea de que apague el led
dentro de la función rango.

Si quisiéramos agregar otro rango en el código anterior debemos agregar la

verificación de otro rango y agregar en cada bloque if el led que agregamos. Los
invito a probar este circuito y los códigos dentro de sus cuentas de Tinkercad para
poder entender mejor la solución.

Lo que aprendimos en esta unidad

En esta unidad conocimos que es una función, que es una librería y como usar todo
lo aprendido hasta el momento en un problema real.

Programar en Arduino| 11