Ebook 10 Proyectos Con Arduino

T OOS
S
Y E
ECCT
P R
ROOY
1
100 P
INN O
O
RDDU
U I
N A
A R
C
COON
PROYECTOS PARA INICIARSE

EN ESTE EMOCIONANTE MUNDO
ING. JUAN DAMIÁN LUCERO

ÍNDICE

Cómo usar una pantalla LCD de 16×2 caracteres con Arduino 12

Resumen de hardware 13
Especificaciones LCD 16x2 13
Hoja de datos LCD de 16×2 caracteres 13
Hoja de datos LCD de 20×4 caracteres 13
Hoja de datos de HD44780 13
Componentes de hardware 15
Software 16
Probar la pantalla LCD y ajustar el contraste 16
Cómo conectar la pantalla LCD a Arduino UNO 17
Código de ejemplo de Arduino para LCD de caracteres 18
Cómo funciona el código 19
Otras funciones de la biblioteca LiquidCrystal 20
clear() 20
home() 20
cursor() 21
noCursor() 21
blink() 21
noBlink() 22
display() 22
noDisplay() 22
write() 23
scrollDisplayLeft() 23
scrollDisplayRight() 23
autoscroll() 24
noAutoscroll() 24
leftToRight() 25
rightToLeft() 25
¿Cómo crear y mostrar caracteres personalizados? 25
Código de ejemplo Arduino de caracteres personalizados 26
Cómo usar los sensores DHT11 y DHT22 con Arduino 31

¿Cómo funcionan los sensores de temperatura y humedad DHT11 y
DHT22/AM2302? 32

10 PROYECTOS CON ARDUINO ELECTROGEEK
¿Qué es la humedad relativa? 32
Especificaciones DHT11 32
Hoja de datos DHT11 33
Especificaciones DHT22/AM2302 33
Hoja de datos DHT22 34
Herramientas y materiales 34
Hardware 34
Software 35
Cableado: conexión de DHT11 y DHT22/AM2302 a Arduino Uno 35
Conexiones de 4 pines DHT11 y DHT22 36
Conexiones de 3 pines DHT11 37
Conexiones de 3 pines DHT22/AM2302 38
Instalar las bibliotecas Arduino requeridas 38
DHT-sensor-library-master.zip 39
Adafruit_Sensor-master.zip 39
Código de ejemplo Arduino DHT11/DHT22 40
Salida de monitor en serie 42
Explicación del código 42
Código de ejemplo para DHT11 y DHT22/AM2302 con LCD 45
Cómo usar una pantalla LCD de 16×2 con Arduino 45
Conexiones LCD I2C 46
LiquidCrystal_I2C-master.zip 47
Guía de solución de problemas DHT11/DHT22 49
"No se pudo leer desde el sensor DHT!" 49
Error fatal: Adafruit_Sensor.h: No existe tal archivo o directorio 49
Cómo utilizar el sensor de movimiento PIR HC-SR501 con Arduino 50

Herramientas y materiales 51
Hardware 51
Software 51
¿Cómo funciona un sensor de movimiento PIR? 51
Sensor de movimiento PIR HC-SR501 53
Especificaciones de HC-SR501 53
Hoja de datos de HC-SR501 54
BISS0001 Hoja de datos 54
Hoja de datos RE200B 54
Ajuste del HC-SR501 54
Ajuste de sensibilidad ( rango) 55
Ajuste de retardo de tiempo (Tx) 55
Puente de selección de disparador 55

3
Agregar un termistor y/o LDR al HC-SR501 56

Uso del sensor de movimiento PIR HC-SR501 como unidad independiente 57
Sensor de movimiento PIR HC-SR501 con diagrama de cableado LED 57
Cableado: conexión del sensor de movimiento PIR HC-SR501 a Arduino UNO 58
Conexiones del sensor de movimiento PIR HC-SR501 59
Sensor de movimiento PIR HC-SR501 con código de ejemplo Arduino UNO 59
Salida del sensor PIR en el monitor en serie 61
Explicación del código: 61
Cree un sistema de alarma con sensor de movimiento PIR y zumbador 63
Cosas a considerar al diseñar un sistema de sensor PIR 65
Cómo usar un sensor de distancia ultrasónico HC-SR04 con Arduino 66

¿Cómo funciona un sensor de distancia ultrasónico? 67
Principios de funcionamiento de los sensores de distancia ultrasónicos. 67
Dependencia de la temperatura de la velocidad de la velocidad del sonido. 68
Cómo funciona el HC-SR04 68
Especificaciones de HC-SR04 69
Hoja de datos de HC-SR04 70
Software 70
HC-SR04 con diagrama de cableado Arduino 71
Conexiones HC-SR04 71
Código de ejemplo para HC-SR04 con Arduino 72
Código de ejemplo HC-SR04 con biblioteca Arduino y NewPing 75
NewPing_v1.9.1.zip 75
Sensores ultrasónicos de interfaz en modo de 3 pines 77
Código de ejemplo HC-SR04 con I2C LCD y Arduino 78
HC-SR04 con diagrama de cableado LCD Arduino e I2C. 78
LiquidCrystal_I2C-master.zip 79
Código de ejemplo HC-SR04 con sensor de temperatura DHT11 y Arduino 81
HC-SR04 con diagrama de cableado Arduino y DHT11. 81
Conexiones DHT11 81
Código de ejemplo HC-SR04 con DHT11 y LCD I2C 84
HC-SR04 Dimensiones 84

4
TM1637 Tutorial de Arduino de display de 7 Segmentos 4 Dígitos 87

Software 88
Información sobre la pantalla. 88
Especificaciones de la pantalla TM1637 de 4 dígitos y 7 segmentos 89
TM1637 Hoja de datos 89
Cableado: conexión de la pantalla TM1637 de 4 dígitos y 7 segmentos a Arduino
UNO 90
Conexiones de pantalla TM1637 90
TM1637 código de ejemplo Arduino de 4 dígitos y 7 segmentos 91
TM1637-master.zip 91
Código de ejemplo 91
setSegments (segmentos [], longitud, posición) 96
showNumberDec ( number, Leading_zeros, length, position) 97
showNumberDecEx( number, dots, leading_zeros, length, position) 97
setBrightness (brillo, verdadero/falso) 98
Ejemplo de reloj: pantalla TM1637 de 4 dígitos con DS3231 RTC 98
TM1637 con diagrama de cableado DS3231 RTC y Arduino UNO. 99
Conexiones DS3231 RTC 99
RTClib-master.zip 100
Ejemplo de termómetro: pantalla TM1637 de 4 dígitos con sensor de temperatura
y humedad DHT11 102
Conexiones DHT11 102
Cómo usar los sensores DHT11 y DHT22 con Arduino 103
Cómo controlar servomotores con Arduino 106

Software 107
¿Cómo funciona un servomotor? 107
Esquema de un servomotor RC (Hwang et al.2018) 108
Control de servo 108
Servo de 360 grados (continuo) frente a 180 grados (estándar) 109
¿Cómo conectar un servomotor al Arduino? 110
Servomotor con diagrama de cableado Arduino Uno. 111
Servomotor alimentado con fuente de alimentación externa. 112

5
Servomotor con conexiones de alimentación externa 112

Servomotor con código de ejemplo Arduino 112
Ángulo/posición de control: 115
Control de velocidad: 115
Por qué mi servo no gira de 0 a 180 grados? 116
Controlar un servomotor con un potenciometro y Arduino 117
Servomotor con potenciómetro Código de ejemplo de Arduino 117
Controlar varios servomotores 119
Controladores de servo/PWM PCA9685 120
Arduino con código de ejemplo de múltiples servos 120
Especificaciones del servomotor 121
Micro servo analógico SG90 122
Pinout 122
Especificaciones 122
Dimensiones 123
Servo micro digital MG90S 124
Pinout 124
Dimensiones 125
Servo digital de alto par MG996R 126
Pinout 126
Dimensiones 127
Cómo controlar un motor paso a paso con A4988 y Arduino 129

Herramientas 130
Software 131
Sobre el Driver 131
Especificaciones de A4988 131
Diferencias entre A4988 y DRV8825 132
Configuración de microstep 133
Pinout A4988 133
Cableado: conexión de A4988 a Arduino y motor paso a paso 135
Advertencia 136
¿Cómo determinar el cableado correcto del motor paso a paso? 137
¿Cómo establecer el límite de corriente? 137
Fórmula de límite actual 139
Midiendo Vref 140

6
Puntos de sonda Vref (GND y potenciómetro). 140

Preguntas frecuentes sobre el límite actual 141
Enfriando al Driver A4988 142
Código de ejemplo básico de Arduino para controlar un motor paso a paso 142
Cómo funciona el código: 142
Control de la dirección de giro: 145
Número de control de pasos o revoluciones: 146
Control de velocidad 146
Tutorial de la biblioteca AccelStepper 146
AccelStepper-1.59.zip 146
Código de ejemplo de rotación continua 147
Código de ejemplo para controlar el número de pasos o revoluciones 151
Código de ejemplo de aceleración y desaceleración 153
Explicación del código: 154
La guía completa para sensores de temperatura digitales DS18B20 156

Software 157
Acerca del sensor de temperatura DS18B20 de 1 cable 158
Especificaciones del sensor de temperatura digital DS18B20 158
Tipos de sensores DS18B20 159
Cableado: conexión del DS18B20 a un Arduino 161
Conexiones del sensor de temperatura digital DS18B20 162
Conexiones del sensor de temperatura digital impermeable DS18B20 162
Instalación de las bibliotecas DallasTemperature y OneWire Arduino 163
Sensor de temperatura DS18B20 con código de ejemplo Arduino 165
Usando múltiples sensores DS18B20 con Arduino 169
Cableado: conexión de varios sensores DS18B20 al Arduino 169
Múltiples sensores DS18B20 con código de ejemplo Arduino 170
Leer sensores por dirección 173
Buscador de direcciones DS18B20 173
Leer sensores por dirección Código de ejemplo de Arduino 176
Otras funciones de la biblioteca DallasTemperature Arduino 179
setResolution () 179

7
toFahrenheit () 181
setHighAlarmTemp () y setLowAlarmTemp () 181
bool hasAlarm() 181
Muestre las lecturas de temperatura DS18B20 en una pantalla LCD I2C 181
DS18B20 con LCD I2C de 16x2 caracteres y Arduino 182
Instalación de la biblioteca Arduino LiquidCrystal_I2C 183
DS18B20 con código de ejemplo de LCD I2C 183
Cómo usar un receptor de infrarrojos y un control remoto 186

Software 187
¿Cómo funcionan un receptor y un mando a distancia de infrarrojos (IR)? 188
Conceptos básicos de comunicación por infrarrojos 189
LED IR al final de un control remoto 189
Protocolo NEC 190
Tipos de receptores de infrarrojos 190
Diodo receptor de infrarrojos y receptor montado en una PCB 191
Conexión de un receptor de infrarrojos al Arduino 192
Instalación de la biblioteca IRremote Arduino 193
Determine el protocolo de infrarrojos utilizado por su control remoto 194
Buscador de protocolo remoto por infrarrojos 195
Protocolos de infrarrojos detectados desde varios controles remotos 198
Encontrar los códigos clave para su control remoto 198
Código de ejemplo de Arduino del receptor y mando a distancia por infrarrojos:
imprimir valores clave en el monitor serie 202
Receptor y control remoto por infrarrojos con Arduino y ejemplo de LCD 208
Conexiones del receptor de LCD e infrarrojos 209
Receptor y control remoto IR con código de ejemplo de LCD y Arduino 211
Salida de pantalla LCD 214
LED de control (salidas Arduino) con control remoto IR y receptor 214
Diagrama de cableado para controlar LED con control remoto IR 215
Tutorial de Arduino con pantalla de matriz de puntos LED MAX7219 221

Software 222
Acerca del controlador LED MAX7219 222
Especificaciones de la pantalla de matriz de puntos LED MAX7219 223

8
MAX7219 Hoja de datos 223

1088AS Hoja de datos 223
Cómo conectar la pantalla de matriz de puntos al Arduino 224
Ubicaciones de los pines SPI de hardware 224
Conexiones de pantalla de matriz de puntos LED MAX7219 226
Requerimientos de energía 226
Instalación de las bibliotecas Arduino MD_Parola y MD_MAX72XX 226
Diferentes tipos de pantallas de matriz de puntos LED 229
Módulo FC-16 8×8 o 8×32 229
Orientación y conexiones del módulo 229
Configuración de hardware en código Arduino 230
Módulo genérico de 8×8 230
Orientación y conexiones del módulo 231
Configuración de hardware en código Arduino 232
Códigos de ejemplo de Arduino 232
Código de ejemplo básico de Arduino para imprimir texto 233
Código de ejemplo de Arduino de texto en desplazamiento 238
Otros efectos de texto 240
Sprites de texto 241

9

Cómo usar una pantalla

LCD de 16×2 caracteres
con Arduino

Este tutorial incluye todo lo que necesita saber sobre el control de un LCD de
caracteres con Arduino. He incluido un diagrama de cableado y muchos
códigos de ejemplo. Estas pantallas son excelentes para mostrar datos o texto
del sensor y también son bastante baratas.
La primera parte de este artículo cubre los conceptos básicos de visualización
de texto y números. En la segunda mitad, entraré en más detalles sobre cómo
mostrar caracteres personalizados y cómo puede usar las otras funciones de la
biblioteca LiquidCrystal Arduino.
Como verá, necesita muchas conexiones para controlar estas pantallas. Por lo
tanto, me gusta usarlos con un módulo de interfaz I2C montado en la parte
posterior.

10

Con este módulo I2C, solo necesita dos conexiones para controlar la
pantalla LCD. Consulte el tutorial a continuación si también desea usar un
módulo I2C:

Resumen de hardware

Estas pantallas LCD están disponibles en muchos tamaños diferentes (16x2
1602, 20×4 2004, 16×1, etc.), pero todas utilizan el mismo chip de controlador
LCD de interfaz paralela HD44780 de Hitachi. Esto significa que puede
intercambiarlos fácilmente. Solo necesitará cambiar las especificaciones de
tamaño en su código Arduino.

Especificaciones LCD 16x2

Tensión de funcionamiento 5 V
Controlador Controlador LCD Hitachi HD44780
Resolución de la pantalla 2 líneasx16 caracteres
Resolución de personaje 5x8 píxeles
Dimensiones del módulo 80x36x12 mm
Ver dimensiones del área 64,5x16,4 mm

Para obtener más información, puede consultar las hojas de datos a
continuación. Las hojas de datos de 16×2 y 20×4 incluyen las dimensiones de
la pantalla LCD y en la hoja de datos HD44780 puede encontrar más
información sobre el controlador LCD de Hitachi.

11
🔗 Hoja de datos LCD de 16×2 caracteres
🔗 Hoja de datos LCD de 20×4 caracteres
🔗 Hoja de datos de HD44780

Pinout LCD 16×2

La pantalla LCD tiene 16 pines de conexión, numerados del 1 al 16 de
izquierda a derecha.

El pinout de un LCD HD44780 estándar se da en la tabla a continuación:

Pin no. Símbolo Conexión Función
1 VSS GND Arduino Señal de tierra
2 VDD 5V Arduino Potencia lógica para LCD
3 V0 Potenciómetro de 10 kΩ Ajuste de contraste
4 RS Pin 2 Arduino Registrar seleccionar

señal
5 R/W GND Arduino Señal de selección de

lectura/escritura

12
6 E Pin 3 Arduino Señal de habilitación de

operación
7 - 14 D0 - D7 - Líneas de bus de datos

utilizadas para el modo
de 8 bits
11 - 14 D4 - D7 Pin 4 - 7 Arduino Líneas de bus de datos

utilizadas para el modo
de 4 bits
15 A (LED 5 V Arduino Ánodo para

+) retroiluminación LCD
16 K (LED) GND Arduino Cátodo para

retroiluminación LCD

Componentes de hardware

LCD de 16x2 caracteres x 1 Electrogeek
LCD de 20x4 caracteres x 1 Electrogeek
Arduino UNO R3 x 1 Electrogeek

Si desea controlar múltiples pantallas LCD, puede
usar un Arduino Mega .
Protoboard x 1 Electrogeek

Cables de protoboard ~ 10 Electrogeek
Cable USB tipo B x 1 Electrogeek

13
Potenciómetro de 10 kΩ x 1 Electrogeek
Resistencia (opcional) x 1 Electrogeek

Software
IDE Arduino

Probar la pantalla LCD y ajustar el contraste

Para probar la pantalla, deberá realizar las conexiones como se muestra en la
figura a continuación.
La mayoría de los LCD tienen una resistencia en serie incorporada para la
retroiluminación LED. Debería encontrarlo en la parte posterior de la pantalla
LCD conectada al pin 15 (Ánodo). Si su pantalla no incluye una resistencia,
necesitará agregar una entre 5 V y el pin 15. Debería ser seguro usar una
resistencia de 220Ω, pero este valor puede hacer que su pantalla sea un poco
tenue. Puede consultar la hoja de datos para conocer la clasificación de
corriente máxima de la luz de fondo y utilizarla para seleccionar un valor de
resistencia apropiado.

Cableado de ajuste de contraste

14
Después de haber conectado la pantalla LCD, deberá ajustar el contraste de la
pantalla. Esto se hace girando el potenciómetro de 10 kΩ en sentido horario o
antihorario.
Conecte el conector USB del Arduino para alimentar la pantalla LCD. Debería
ver la luz de fondo iluminada. Ahora gire el potenciómetro hasta que aparezca
una (16×2 LCD) o 2 filas (20×4 LCD) de rectángulos.

Gire el potenciómetro hasta que vea aparecer una fila de rectángulos.

Puede ajustar el contraste más tarde si es necesario.

Cómo conectar la pantalla LCD a Arduino
UNO

Para controlar la pantalla LCD y mostrar caracteres, necesitará agregar algunas
conexiones adicionales. Consulte el diagrama de cableado a continuación y la
tabla de pines de la introducción de este artículo.

15

LCD 16×2 con diagrama de cableado Arduino UNO

Utilizaremos la pantalla LCD en modo de 4 bits, esto significa que no necesita
conectar nada a D0-D3. El pin R/W está conectado a tierra, esto tirará el pin
LOW y configura la pantalla LCD en modo WRITE.
Una vez que haya conectado todo, podemos comenzar a programar la pantalla
LCD.

Código de ejemplo de Arduino para LCD de
caracteres

Para controlar la pantalla LCD utilizaremos la biblioteca LiquidCrystal . Esta
biblioteca debe venir preinstalada con el IDE de Arduino . Puede encontrarlo
yendo a sketch> Incluir biblioteca> LiquidCrystal .
La biblioteca LiquidCrystal viene con muchas funciones integradas y hace que
el control de los LCD de caracteres sea muy fácil.
El siguiente código de ejemplo muestra cómo mostrar un mensaje en la
pantalla LCD. A continuación, le mostraré cómo funciona el código y cómo
puede usar las otras funciones de la biblioteca LiquidCrystal.

// Include the library:
#include <LiquidCrystal.h>
// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):

LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);
void setup() {

16
// Specify the LCD's number of columns and rows. Change to (20, 4) for a
20x4 LCD:
lcd.begin(16, 2);
}
void loop() {
// Set the cursor on the third column and the first row, counting starts
at 0:
lcd.setCursor(2, 0);
// Print the string 'Hello World!':
lcd.print("Hello World!");
// Set the cursor on the third column and the second row:
// Print the string 'LCD tutorial':
lcd.print("LCD tutorial");

Debería ver la siguiente salida en la pantalla LCD:

Cómo funciona el código

Después de incluir la biblioteca, el siguiente paso es crear una nueva instancia
de la clase LiquidCrystal. El se hace con la función LiquidCrystal(rs,
enable, d4, d5, d6, d7). Como parámetros utilizamos los pines Arduino
a los que conectamos la pantalla. Tenga en cuenta que hemos llamado a la
pantalla 'lcd'. Puede darle un nombre diferente si lo desea como
'menu_display'. Deberá cambiar 'lcd' al nuevo nombre en el resto del sketch.


17
// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):


En la setup()pantalla LCD se inicia con la función begin(cols,rows).
Cuando utilice una pantalla LCD de 20×4, cambie esta línea a lcd.begin (20,4);
void setup() {
// Specify the LCD's number of columns and rows. Change to (20, 4) for a
20x4 LCD:
lcd.begin(16, 2);
}

En el loop()cursor se establece en la tercera columna y la primera fila de la
pantalla LCD con lcd.setCursor(2,0).

Tenga en cuenta que el recuento comienza en 0 y el primer argumento
especifica la columna. Si no especifica la posición del cursor, el texto se
imprimirá en la posición inicial predeterminada (0,0) si la pantalla está vacía o
detrás del último carácter impreso.
A continuación, la cadena '¡Hola mundo!' está impreso con
lcd.print("Hello World!"). Tenga en cuenta que debe colocar comillas
("") alrededor del texto. Cuando desee imprimir números o variables, no se
necesitan comillas.

void loop() {
// Set the cursor on the third column and the first row, counting starts
at 0:
// Print the string 'Hello World!':
lcd.print("Hello World!");
// Set the cursor on the third column and the second row:
// Print the string 'LCD tutorial':
lcd.print("LCD tutorial");
}

18

Otras funciones de la biblioteca
LiquidCrystal

La biblioteca LiquidCrystal Arduino tiene muchas otras funciones integradas
que pueden resultar útiles. Puede encontrar una descripción general de ellos a
continuación con una explicación y algunos fragmentos de código.

clear()

Borra la pantalla LCD y coloca el cursor en la esquina superior izquierda
( primera fila y primera columna) de la pantalla. Puede usar esta función para
mostrar diferentes palabras en un bucle.

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

void setup() {
lcd.begin(16, 2);
}
void loop() {
lcd.clear();
lcd.print("Monday");
delay(2000);
lcd.clear();
lcd.print("13:45");
delay(2000);
}

home()

Posiciona el cursor en la esquina superior izquierda de la pantalla LCD. Use
clear() si también desea borrar la pantalla.

19

cursor()

Muestra el cursor LCD: un guión bajo (línea) en la posición del siguiente
carácter a imprimir.

noCursor()

Oculta el cursor LCD. El siguiente ejemplo crea un cursor parpadeante al final
de "cursor()".


void setup() {
lcd.begin(16, 2);
lcd.print("cursor()");
}
void loop() {
lcd.cursor();
delay(500);
lcd.noCursor();
delay(500);
}

blink()

Crea un cursor LCD de estilo de bloque parpadeante: un rectángulo
parpadeante en la posición del siguiente carácter a imprimir.

noBlink()

Deshabilita el cursor LCD de estilo bloque. El siguiente ejemplo muestra el
cursor parpadeante durante 5 segundos y luego lo desactiva durante 2
segundos.


20
void setup() {
lcd.begin(16, 2);
lcd.print("blink() example");
}
void loop() {
lcd.blink();
delay(5000);
lcd.noBlink();
delay(2000);
}

display()

Esta función enciende la pantalla LCD y muestra cualquier texto o cursores que
se hayan impreso en la pantalla.

noDisplay()

Esta función apaga cualquier texto o cursores impresos en la pantalla LCD. El
texto/datos no se borran de la memoria LCD. Esto significa que se volverá a
mostrar cuando se llame a la función display().
El siguiente ejemplo crea un efecto de texto parpadeante.


void setup() {
lcd.begin(16, 2);
lcd.print("Blinking text");
}
void loop() {
lcd.display();
delay(2000);
lcd.noDisplay();

21
delay(2000);
}

write()

Esta función se puede usar para escribir un carácter en la pantalla LCD.
Consulte la sección sobre creación y visualización de caracteres personalizados
a continuación para obtener más información.

scrollDisplayLeft()

Desplaza el contenido de la pantalla (texto y cursor) un espacio a la izquierda.
Puede usar esta función en la sección de bucle del código en combinación con
delay (500), para crear una animación de texto desplazable.


void setup() {
lcd.begin(16, 2);
lcd.print("scrollDisplayLeft() example");
}
void loop() {
lcd.scrollDisplayLeft();
delay(500);
}

scrollDisplayRight()

Desplaza el contenido de la pantalla (texto y cursor) un espacio a la derecha.

autoscroll()

Esta función activa el desplazamiento automático de la pantalla LCD. Esto hace
que cada salida de caracteres a la pantalla empuje los caracteres anteriores en
un espacio. Si la dirección del texto actual es de izquierda a derecha (el valor

22
predeterminado), la pantalla se desplaza hacia la izquierda; Si la dirección
actual es de derecha a izquierda, la pantalla se desplaza hacia la derecha. Esto
tiene el efecto de enviar cada nuevo personaje a la misma ubicación en la
pantalla LCD.
El siguiente sketch de ejemplo permite el desplazamiento automático e
imprime el carácter 0 a 9 en la posición (16,0) de la pantalla LCD. Cambie esto
a (20,0) para una pantalla LCD de 20×4.


void setup() {
lcd.begin(16, 2);
}
void loop() {
lcd.autoscroll();
for (intx= 0;x< 10; x++) {
lcd.print(x);
delay(500);
}
lcd.clear();
}

noAutoscroll()

Desactiva el desplazamiento automático de la pantalla LCD.

leftToRight()

Esta función hace que el texto fluya hacia la derecha desde el cursor, como si la
pantalla estuviera justificada a la izquierda ( por defecto).

rightToLeft()

Esta función hace que el texto fluya hacia la izquierda desde el cursor, como si
la pantalla estuviera justificada a la derecha.

23

¿Cómo crear y mostrar caracteres
personalizados?

Con la función createChar(), es posible crear y mostrar caracteres
personalizados en la pantalla LCD. Esto es especialmente útil si desea mostrar
un carácter que no es parte del conjunto de caracteres ASCII estándar.
Información técnica: Los LCD que se basan en el controlador LCD Hitachi
HD44780 tienen dos tipos de memorias: CGROM y CGRAM (Generador de
caracteres ROM y RAM). CGROM genera todos los patrones de caracteres de
5x8 puntos a partir de los códigos de caracteres estándar de 8 bits. CGRAM
puede generar patrones de caracteres definidos por el usuario.
Para pantallas de 5x8 puntos, CGRAM puede escribir hasta 8 caracteres
personalizados y para pantallas de 5x10 puntos 4 .

Código de ejemplo Arduino de caracteres
personalizados

El siguiente boceto de ejemplo crea y muestra ocho caracteres personalizados
( numerados del 0 al 7).


// Make custom characters:

byte Heart[] = {
B00000,
B01010,
B11111,
B11111,
B01110,
B00100,
B00000,
B00000
};
byte Bell[] = {
B00100,

24
B01110,
B01110,
B01110,
B11111,
B00000,
B00100,
B00000
};
byte Alien[] = {
B11111,
B10101,
B11111,
B11111,
B01110,
B01010,
B11011,
B00000
};
byte Check[] = {
B00000,
B00001,
B00011,
B10110,
B11100,
B01000,
B00000,
B00000
};
byte Speaker[] = {
B00001,
B00011,
B01111,
B01111,
B01111,
B00011,
B00001,
B00000
};
byte Sound[] = {
B00001,
B00011,
B00101,
B01001,

25
B01001,
B01011,
B11011,
B11000
};
byte Skull[] = {
B00000,
B01110,
B10101,
B11011,
B01110,
B01110,
B00000,
B00000
};
byte Lock[] = {
B01110,
B10001,
B10001,
B11111,
B11011,
B11011,
B11111,
B00000
};
void setup() {
// Specify the LCD's number of columns and rows:
lcd.begin(16, 2);
// Create a new characters:

lcd.createChar(0, Heart);
lcd.createChar(1, Bell);
lcd.createChar(2, Alien);
lcd.createChar(3, Check);
lcd.createChar(4, Speaker);
lcd.createChar(5, Sound);
lcd.createChar(6, Skull);
lcd.createChar(7, Lock);
// Clears the LCD screen:

lcd.clear();

26
// Print a message to the lcd:

lcd.print("Custom Character");
}
void loop() {
// Print all the custom characters:
lcd.write(byte(0));
lcd.write(byte(1));
lcd.write(byte(2));
lcd.write(byte(3));
lcd.write(byte(4));
lcd.write(byte(5));
lcd.write(byte(6));
lcd.write(byte(7));
}


27


Después de incluir la biblioteca y crear el objeto LCD, se definen las matrices
de caracteres personalizados. Cada matriz consta de 8 bytes, 1 byte para cada
fila. En este ejemplo, se crean 8 caracteres personalizados.

// Make custom characters:
byte Heart[] = {
B00000,
B01010,
B11111,
B11111,
B01110,
B00100,
B00000,
B00000
};

Al mirar de cerca la matriz, verá lo siguiente. Cada fila consta de 5 números
correspondientes a los 5 píxeles en un carácter de 5x8 puntos. Un 0 significa
píxel desactivado y un 1 significa píxel activado.
Es posible editar cada fila a mano, pero recomiendo usar esta herramienta
visual en GitHub. Esta aplicación crea automáticamente la matriz de caracteres
y puede hacer clic en los píxeles para activarlos o desactivarlos.
En el setup(), los caracteres personalizados se crean con
lcd.createChar(num, data).

El primer argumento en esta función es el número del carácter personalizado
(0-7) y el segundo argumento es la matriz de caracteres que creamos.

// Create a new characters:
lcd.createChar(0, Heart);
lcd.createChar(1, Bell);
lcd.createChar(2, Alien);
lcd.createChar(3, Check);
lcd.createChar(4, Speaker);
lcd.createChar(5, Sound);
lcd.createChar(6, Skull);
lcd.createChar(7, Lock);

28

En el loop()se muestran todos los caracteres con lcd.write(). Como
parámetro usamos el número del personaje que reservamos.

lcd.write(byte(0));

29

Cómo usar los sensores

DHT11 y DHT22 con
Arduino

En este tutorial, aprenderá cómo funcionan los sensores digitales de

temperatura y humedad DHT11 y DHT22/AM2302 y cómo puede usarlos con
Arduino. Estos sensores son muy populares para proyectos electrónicos de
bricolaje y son perfectos para estaciones meteorológicas remotas, proyectos
de automatización del hogar y sistemas de monitoreo de plantas/jardines.
En este artículo, he incluido un diagrama de cableado y códigos de ejemplo
para que pueda comenzar a experimentar con su sensor. Después de cada
ejemplo, desgloso y explico cómo funciona el código, por lo que no debería
tener problemas para modificarlo según sus necesidades.
Primero echaremos un vistazo a la biblioteca Adafruit DHT. A continuación, le
mostraré cómo puede combinar el sensor con una pantalla LCD de 16x2 para
crear una estación meteorológica simple.

30

¿Cómo funcionan los sensores de
temperatura y humedad DHT11 y
DHT22/AM2302?

Si abre un sensor DHT11 o DHT22/AM2302, verá que contiene dos elementos
sensores: un elemento sensor de humedad y un NTC (termistor).
El elemento sensor de humedad consta de dos electrodos con un sustrato de
retención de humedad en el medio. El sensor mide la resistencia entre los
electrodos, que cambia según la cantidad de humedad en el aire.
En la parte posterior del sensor, encontrará un pequeño IC que mide y procesa
la señal analógica. También almacena los coeficientes de calibración y realiza la
conversión de analógico a digital.

¿Qué es la humedad relativa?

Cuando mira la hoja de datos de los sensores DHTxx, verá que miden la
humedad relativa (HR) del aire y no la humedad absoluta. ¿Pero cuál es la
diferencia? La humedad absoluta es la cantidad de vapor de agua en el aire
(expresada en g/m³), independientemente de la temperatura. La humedad
relativa tiene en cuenta la temperatura.
La humedad relativa es la relación entre la cantidad real de vapor de agua
presente en el aire y la cantidad máxima de vapor de agua que el aire puede
contener a una temperatura dada.
El aire caliente puede contener más agua que el aire frío. Esto significa que
para la misma cantidad de vapor de agua en el aire, la humedad relativa en el
aire frío será mayor que en el aire caliente. Con una humedad relativa del 100
por ciento, el aire está saturado y está en su punto de rocío.

Especificaciones DHT11

Tensión de funcionamiento 3.3 - 5.5 V
Corriente de funcionamiento Medición: 0,3 mA, en espera: 60 μA
Rango de medición de humedad 5 - 95% HR ± 5% HR

31
Rango de medición de temperatura -20-60 ° C ± 2 ° C
Periodo de muestreo > 2 segundos
Dimensiones del cuerpo 15,5x12x5,5 mm
Dimensiones del pin 8 mm de longitud, 2,54 mm de

espacio
Ventaja Ultra bajo costo

Para obtener más información, puede consultar la hoja de datos a
continuación:

🔗 Hoja de datos DHT11

Especificaciones DHT22/AM2302

Tensión de funcionamiento 3.3 - 5.5 V
Corriente de funcionamiento Medición: 0,5 mA, en espera: 15 μA
Rango de medición de humedad 0 - 99.9% HR ± 2% HR
Rango de medición de temperatura -40 - 80 ° C ± 1 ° C
Periodo de muestreo 2 segundos
Dimensiones del cuerpo 25x15x7 mm, agujero de montaje

de mounting 3 mm
Dimensiones del pin 7 mm de longitud, 2,54 mm de

espacio

32
Ventaja Más preciso

Puede descargar la hoja de datos para el DHT22/AM2302 a continuación:

🔗
Hoja de datos DHT22

Como puede ver, las especificaciones del DHT11 y el DHT22/AM2302 son
bastante similares. La principal diferencia es que el DHT22 es más preciso y
tiene un rango de medición mayor.
El DHT11 es un poco más pequeño que el DHT22 y también es menos
costoso.
Lo bueno de estos sensores es que son intercambiables, lo que significa que
puede reemplazar el DHT11 con un DHT22 o viceversa, el cableado es
exactamente el mismo. Solo tendrá que hacer un pequeño cambio en la
configuración del código, como verá más adelante.

Herramientas y materiales

Para seguir este tutorial necesitará los siguientes componentes:

Hardware

4 pines DHT11 x 1 Electrogeek
4 pines DHT22/AM2302 x 1 Electrogeek

Si quieres controlar muchos sensores, puedes
usar un Arduino Mega .
Cables para protoboard ~ 10 Electrogeek

33
Resistencia de 5 - 10 kΩ (solo para sensores x 1 Electrogeek

de 4 pines)
1602 I2C LCD (opcional) x 1 Electrogeek

Software
IDE Arduino

Cableado: conexión de DHT11 y
DHT22/AM2302 a Arduino Uno

Los diagramas/esquemas de cableado a continuación le muestran cómo
conectar sensores de temperatura y humedad de 3 o 4 pines del Arduino Uno.
Se necesita una resistencia pull-up de 10 kΩ entre la línea de señal y 5 V para
asegurarse de que el nivel de señal se mantenga alto de forma
predeterminada.

Cableado del sensor de temperatura y humedad DHT11 de 4 pines a Arduino Uno

34
Cableado del sensor de temperatura y humedad DHT22/AM2302 de 4 pines a Arduino

Uno

Tenga en cuenta que el sensor DHT22/AM2302 está conectado exactamente
de la misma manera que el DHT11. Las conexiones también se dan en la tabla
a continuación. Numeré los pines 1 a 4 de izquierda a derecha cuando los
agujeros del sensor están orientados hacia usted.

Conexiones de 4 pines DHT11 y DHT22

DHT11/DHT22 Arduino
Pin 1 5 V
Pin 2 Conecte al pin digital 2 y a 5 V a

través de una resistencia de 10 kΩ
Pin 3 No conectado
Pin 4 GND

También puede comprar los sensores montados en una pequeña PCB
(sensores de 3 pines). Estos PCB facilitan el montaje del sensor y también
incluyen una resistencia pull-up. Asegúrese de revisar la etiqueta del sensor, el
orden de los pines puede ser diferente según el fabricante .

35
Cableado del sensor de temperatura y humedad DHT11 de 3 pines a Arduino Uno

Conexiones de 3 pines DHT11

3 pines DHT11 Arduino
S Pin digital 2
+ 5 V
- GND

Los ejemplos de código a continuación utilizan el pin digital 2 para recibir los
datos del sensor, pero, por supuesto, puede cambiarlo a cualquier pin digital
que desee.

36
Cableado del sensor de temperatura y humedad DHT22/AM2302 de 3 pines para Arduino Uno

Conexiones de 3 pines DHT22/AM2302

3 pines DHT22 Arduino
DAT Pin digital 2
VCC 5 V
GND GND

Instalar las bibliotecas Arduino requeridas

El siguiente código utiliza la biblioteca de sensores DHT Adafruit que puede
descargar aquí en GitHub . Esta biblioteca solo funciona si también tiene
instalada la biblioteca Adafruit Unified Sensor, que también está disponible en
GitHub .
También puede descargar las dos bibliotecas haciendo clic en los botones a
continuación:

37

🔗 DHT-sensor-library-master.zip
🔗 Adafruit_Sensor-master.zip
Puede instalar la biblioteca yendo a Sketch> Incluir biblioteca> Agregar
biblioteca .ZIP en el IDE de Arduino.
Otra opción es navegar a Herramientas> Administrar bibliotecas ... o escribir
Ctrl + Shift + I en Windows. El Administrador de bibliotecas abrirá y actualizará
la lista de bibliotecas instaladas.

Puede buscar 'dht' y 'DHT sensor library' y buscar la biblioteca de Adafruit.
Seleccione la última versión y luego haga clic en Instalar.

38

Código de ejemplo Arduino DHT11/DHT22

Puede cargar el siguiente código de ejemplo en su Arduino utilizando el IDE de
Arduino . A continuación, explicaré cómo funciona el código.

// Initialize DHT sensor for normal 16mhz Arduino:
DHT dht = DHT(DHTPIN, DHTTYPE);
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Setup sensor:
dht.begin();
}
void loop() {
// Wait a few seconds between measurements:
delay(2000);
// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds 'old' (its a very
slow sensor)
// Read the humidity in %:
float h = dht.readHumidity();
// Read the temperature as Celsius:
float t = dht.readTemperature();
// Read the temperature as Fahrenheit:
float f = dht.readTemperature(true);

39
// Check if any reads failed and exit early (to try again):
if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
// Compute heat index in Fahrenheit (default):
float hif = dht.computeHeatIndex(f, h);
// Compute heat index in Celsius:
float hic = dht.computeHeatIndex(t, h, false);
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" % ");
Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" \xC2\xB0");
Serial.print("C | ");
Serial.print(f);
Serial.print("F ");
Serial.print("Heat index: ");
Serial.print(hic);
Serial.print(hif);
Serial.println("F");
}

Debería ver la siguiente salida en el monitor serie (Ctrl + Shift + M):

40

Salida de monitor en serie

Explicación del código

El primer paso es incluir la biblioteca Adafruit DHT y Unified Sensor.

// Include the libraries:
#include <Adafruit_Sensor.h>
#include <DHT.h>

A continuación, debemos definir el pin de conexión DHT a Arduino y también
configurar el tipo de sensor DHT. En nuestro ejemplo, estamos utilizando un
sensor DHT11 conectado al pin 2.
La declaración #define se usa para dar un nombre a un valor constante. El
compilador reemplazará cualquier referencia a esta constante con el valor
definido cuando se compila el programa. Entonces, en todas partes que
mencione DHTPIN, el compilador lo reemplazará con el valor 2 cuando se
compile el programa.

// Set DHT pin:
#define DHTPIN 2
// Set DHT type, uncomment whatever type you're using!

#define DHTTYPE DHT11 // DHT 11

41
//#define DHTTYPE DHT22 // DHT 22 (AM2302)


A continuación, debe crear una nueva instancia de la clase DHT con el tipo y la
conexión DHT adecuados. Para esto usamos la función DHT( pin,type).
En este caso, llamé al sensor "dht", pero también puede usar otros nombres,
como "sensor_temperatura" o "dht11", etc. DHT sensor_temperatura =
DHT(DHTPIN, DHTTYPE);. Puede crear varias instancias de la clase DHT con
diferentes nombres y pines/tipos. Esto le permite usar fácilmente 2 o más
sensores al mismo tiempo.


En el setup(), comenzamos la comunicación en serie a una velocidad en
baudios de 9600. ¡Asegúrese de que el Monitor en serie también esté
configurado en 9600! También inicializamos el sensor con dht.begin ().

void setup() {
Serial.begin(9600);
// Setup sensor:
dht.begin();
}

La sección loop() del código comienza con un retraso de 2 segundos. Este
retraso está ahí para darle al sensor algo de tiempo para hacer las lecturas. La
tasa de detección máxima del DHT22 es cada 2 segundos y la del DHT11 es
una vez cada segundo.

delay(2000);

Tomar lecturas de temperatura y humedad es muy fácil porque la biblioteca
tiene varias funciones integradas. Para obtener una lectura de humedad en ‘%’,
puede usar la función readHumidity(). En este caso, estamos guardando la
lectura como la variable "h". Tenga en cuenta que es del tipo float.

42
Cuando desee utilizar una función en el objeto DHT, primero debe especificar
el nombre que le dio al sensor. Entonces, en nuestro caso, esto es "dht".


Tomar lecturas de temperatura es igual de fácil con la función
readTemperature().


Si desea obtener la temperatura en Fahrenheit en lugar de Celsius, tiene dos
opciones. Puede pasar fiel a la función readTemperature, o puede usar la
función de conversión:

// Alternative, use convert function:
float f = dht.convertCtoF(t);

A continuación, hay una pequeña sección de código que comprueba si el
sensor está conectado correctamente y está devolviendo una lectura. De lo
contrario, se imprimirá un mensaje de error en el monitor serie.

// Check if any reads failed and exit early (to try again):
if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println("Failed to read from DHT sensor!");
return;
}

La biblioteca también tiene una función incorporada que puede calcular el
índice de calor combinando las lecturas de temperatura y humedad. El “Heat
Index” también se conoce como "Sensación Térmica" o "temperatura
aparente".


43

Finalmente, las lecturas se muestran en el monitor serie. Tenga en cuenta que
la línea Serial.print ("\ xC2 \ xB0"); se usa para imprimir el símbolo de grado.

Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" % ");
Serial.print(t);
Serial.print(f);
Serial.print("F ");
Serial.print("Heat index: ");
Serial.print(hic);
Serial.print(hif);

Código de ejemplo para DHT11 y
DHT22/AM2302 con LCD

Al combinar un sensor de temperatura y humedad con una pequeña pantalla
LCD, se puede crear una estación meteorológica barata.
En el siguiente ejemplo, usaré una pantalla LCD de caracteres I2C como esta
de Electrogeek . Puede leer más sobre el uso de una pantalla LCD I2C con
Arduino en el siguiente artículo:

🔗Cómo usar una pantalla LCD de 16×2 con Arduino

Deberá realizar algunas conexiones adicionales al Arduino para que podamos
controlar la pantalla LCD de 16x2 caracteres. El sensor DHT11 o
DHT22/AM2302 está conectado de la misma manera que antes.
El siguiente diagrama de cableado le muestra cómo conectar un LCD I2C al
Arduino.

44

Sensor de temperatura y humedad DHT11 con LCD de caracteres I2C de 16×2 y diagrama de
cableado Arduino

Las conexiones también se dan en la siguiente tabla:

Conexiones LCD I2C

LCD I2C Arduino
GND GND
VCC 5 V
SDA A4
SCL A5

Si no está utilizando un Arduino Uno, los pines SDA y SCL pueden estar en
una ubicación diferente. Un Arduino UNO con el diseño R3 (1.0 pinout),
también tiene los encabezados de pin SDA (línea de datos) y SCL (línea de
reloj) cerca del pin AREF. Consulte la tabla a continuación para obtener más
detalles.

45

Placa SDA SCL
Arduino Uno A4 A5
Arduino Nano A4 A5
Arduino Micro 2 3
Arduino Mega 2560 20 21
Arduino Leonardo 2 3
Due Arduino 20 21

El código utiliza la biblioteca LiquidCrystal_I2C , que puede descargar aquí en
GitHub. También incluye la biblioteca Wire.h , que le permite comunicarse con
dispositivos I2C. Esta biblioteca debe venir preinstalada con el IDE de Arduino.

🔗 LiquidCrystal_I2C-master.zip

El siguiente código es casi el mismo que antes, pero ahora mostramos la
temperatura y la humedad en la pantalla LCD en lugar del monitor serie.

#include <DHT.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Set DHT pin:

#define DHTPIN 2
// Define SDA and SCL pin for LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin


46


// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); //Change to
(0x27,20,4) for 2004 LCD
void setup() {
// Setup sensor:
dht.begin();
// Initiate the LCD:

lcd.init();
lcd.backlight();
}
void loop() {
delay(2000);
// Reading temperature or humidity takes about 250 milliseconds!

// Sensor readings may also be up to 2 seconds 'old' (its a very slow
sensor)


// Print the temperature and the humidity on the LCD:

lcd.print("Temp: ");

47
lcd.print(t);
lcd.print(" " "\xDF" "C");
lcd.print("Humid: ");
lcd.print(h);
lcd.print(" %");
}

Guía de solución de problemas DHT11/DHT22

Al trabajar con estos sensores, puede recibir los siguientes mensajes de error:

"No se pudo leer desde el sensor DHT!"

Este mensaje puede aparecer en el monitor en serie cuando el sensor no
devuelve una lectura. Esto puede tener varias causas:
● Tipo de sensor: asegúrese de haber descomentado el DHTTYPE
correcto en la configuración del código. Mira el ejemplo de arriba.
● Frecuencia de muestreo: los sensores DHT son bastante lentos, la
frecuencia de muestreo máxima es de alrededor de 2 segundos.
Aumentar el retraso entre las mediciones podría resolver este error.
● Alimentación: aunque los sensores DHTxx pueden funcionar entre 3,3 y
5 V, el fabricante recomienda 5 V. En algunos casos, alimentar el sensor
con 5 V resuelve el problema. Asegúrese de que su microcontrolador
también admita 5 V en los pines GPIO.

Error fatal: Adafruit_Sensor.h: No existe tal archivo
o directorio

Es posible que reciba este error cuando intente compilar el código. Esto
significa que no instaló (correctamente) la biblioteca Adafruit Unified Sensor .

48

Cómo utilizar el sensor

de movimiento PIR
HC-SR501 con Arduino

En este tutorial, aprenderá cómo funciona el sensor de movimiento PIR
HC-SR501 y cómo puede usarlo con Arduino. Puede encontrar sensores de
infrarrojos pasivos (PIR) a su alrededor, no solo se utilizan con fines de
seguridad, sino también en la mayoría de los sistemas de iluminación activados
automáticamente.
En este artículo, he incluido un diagrama de cableado y códigos de ejemplo
para que pueda comenzar a experimentar con su sensor. Después de cada
ejemplo, desgloso y explico cómo funciona el código, por lo que no debería
tener problemas para modificarlo según sus necesidades.
Primero, le mostraré cómo puede usar el HC-SR501 como una unidad
independiente. A continuación, lo conectaremos a un Arduino UNO y le
mostraré cómo usarlo como un sistema de alarma simple.

49

Este tutorial se centra en el sensor HC-SR501, pero también puede usar el
código proporcionado para sensores similares como el HC-SR505 o AM312 .
La principal diferencia es que estos sensores más baratos tienen un rango de
detección más pequeño y no tienen un potenciómetro para ajustar la
sensibilidad y el retraso de tiempo.

Herramientas y materiales

Para seguir este tutorial necesitará los siguientes componentes:

Hardware

Sensor de movimiento PIR HC-SR501 × 1
Arduino Uno Rev3 × 1
Protoboard × 1
Cables para Protoboard × 10
Cable USB tipo A/B × 1
Surtido de resistencias × 1
LEDs × 1
Zumbador pasivo × 1

Software
IDE Arduino

¿Cómo funciona un sensor de movimiento
PIR?

Los sensores de movimiento PIR constan de dos partes principales: un
elemento sensor piroeléctrico y una lente Fresnel . El elemento sensor

50
piroeléctrico puede detectar radiación infrarroja. Todos los objetos con una
temperatura superior al cero absoluto (0 Kelvin/-273.15 ° C) emiten energía
térmica en forma de radiación infrarroja, incluidos los cuerpos humanos.

Un sensor piroeléctrico tiene dos ranuras rectangulares hechas de un material
que permite que pase la radiación infrarroja. Detrás de estos, hay dos
electrodos sensores infrarrojos separados, uno responsable de producir una
salida positiva y el otro negativo. La razón de esto es que estamos buscando
un cambio en los niveles de IR y no en los niveles de IR ambientales. Los dos
electrodos están conectados para que se cancelen mutuamente. Si una mitad
ve más o menos radiación IR que la otra, la salida oscila alto o bajo.
El IC de procesamiento de señal incorporado procesa esta señal y gira el pin de
salida del sensor HIGH o LOW en consecuencia.

51

La cúpula blanca frente al elemento sensor es una lente Fresnel. Esta lente
enfoca la radiación infrarroja en el sensor.

Sensor de movimiento PIR HC-SR501

El sensor de movimiento PIR HC-SR501 está construido alrededor del IC del
detector de movimiento PIR Micro Power BISS0001. Este IC está
específicamente desarrollado para procesar la señal de los sensores de
movimiento PIR.
Si retira la lente Fresnel, verá el elemento sensor piroeléctrico RE200B. En la
PCB también se puede encontrar un regulador de voltaje incorporado. Esto
significa que puede alimentar la placa con un amplio rango de voltaje de CC,
generalmente se utilizan 5V.
Las especificaciones del HC-SR501 se dan en la tabla a continuación, tenga en
cuenta que puede haber pequeñas diferencias entre los fabricantes.

Especificaciones de HC-SR501

Tensión de funcionamiento 4,5 - 20 V
Corriente de reposo 50 μA
Salida de nivel ALTO 3.3 V/BAJO 0 V
Disparador L disparador simple/H disparador

repetido

52
Tiempo de retardo 3 - 300 s
Tiempo de bloqueo 2.5 s ( predeterminado)
Rango de medición 3 - 7 m máximo
Ángulo de medición Ángulo de cono <110 °
Dimensiones de PCB 32,5x24 mm
Orificios de montaje 2 mm, espacio de 28.5 mm
Dimensiones de lentes Fresnel 15 mmx23 mm de diámetro
Temperatura de funcionamiento -15 - 70 ° C

Para obtener más información, puede consultar las hojas de datos a
continuación:

🔗
Hoja de datos de HC-SR501
🔗 BISS0001 Hoja de datos

🔗 Hoja de datos RE200B
Ajuste del HC-SR501

En la parte posterior de la placa encontrará dos potenciómetros y un puente,
que puede usar para ajustar varios parámetros:

53

Ajuste de sensibilidad (rango)

El HC-SR501 tiene una distancia de detección máxima ( rango de detección) de
7 metros. Puede ajustar la distancia de detección girando el potenciómetro de
sensibilidad CW o CCW (vea la imagen de arriba). Girar el potenciómetro en
sentido horario aumenta la distancia de detección hasta un máximo de 7
metros. Girarlo en sentido antihorario disminuye la distancia de detección a un
mínimo de 3 metros.

Ajuste de retardo de tiempo (Tx)

Este potenciómetro se puede utilizar para ajustar el tiempo que la salida
permanece ALTA para después de detectar el movimiento. Como mínimo, el
retraso es de 3 segundos y, como máximo, es de 300 segundos o 5 minutos.
Gire el potenciómetro en sentido horario para aumentar el retraso y en sentido
antihorario para disminuirlo.

Puente de selección de disparador

El puente (amarillo) se puede utilizar para seleccionar uno de los dos modos de
activación. Se puede configurar en L (disparador único) o H (disparador
repetido):

● Disparador único : la salida se pondrá ALTA tan pronto como se detecte
movimiento. Se mantendrá ALTO durante el tiempo establecido por el
potenciómetro. Cualquier movimiento durante este período no se
procesa y no reinicia el temporizador.

● Disparador repetido : cada vez que se detecta movimiento, el
temporizador de retardo se reinicia.

La diferencia entre el modo de disparo simple y repetido se muestra en la
figura a continuación.

54

Diferencia entre modo disparador simple y repetido. Las flechas indican el
tiempo de retraso establecido.

Agregar un termistor y/o LDR al HC-SR501

Como se puede ver en la imagen a continuación, el HC-SR501 tiene
almohadillas de soldadura para dos componentes adicionales. Estas
almohadillas suelen etiquetarse como 'RL' y 'RT'.

● RL : aquí puede agregar una resistencia dependiente de la luz (LDR) o un
fotorresistor que tiene una baja resistencia bajo luz ambiental intensa.
Esto hace que el detector esté operativo sólo cuando el área de
detección es lo suficientemente oscura.

55

● RT : este pad está diseñada para un termistor . Agregar esto hace que la
sensibilidad del sensor sea menos dependiente de la temperatura
ambiente

Desafortunadamente, no se proporciona información adicional en las hojas de
datos, por lo que no estoy completamente seguro de qué valores de
componentes debe usar.

Uso del sensor de movimiento PIR HC-SR501
como unidad independiente

Para la mayoría de las aplicaciones, puede usar el HC-SR501 como una unidad
independiente. Puede usar la señal de salida para activar cosas como relés y
LED.
El cableado es muy simple como se puede ver en la imagen a continuación.
Simplemente conecte VCC y GND a una batería y un LED rojo entre el pin de
salida y tierra. El voltaje de salida es de 3.3 V, así que agregué una resistencia
limitadora de corriente de 68 Ω en serie con el LED.

Sensor de movimiento PIR HC-SR501 con diagrama de cableado LED

Tenga en cuenta que después de encender el sensor, debe esperar 30 a 60
segundos para que el sensor se inicialice. Durante este período, el LED podría
parpadear un par de veces. Después de esperar un minuto, puede mover su
mano frente al sensor y debería poder ver el LED iluminado.

56

Con esta configuración, es fácil probar la funcionalidad del sensor. Este
también es un buen momento para jugar con los ajustes de sensibilidad y
retardo de tiempo, así como con los dos modos de disparo diferentes.

Cableado: conexión del sensor de
movimiento PIR HC-SR501 a Arduino UNO

Al conectar el sensor de movimiento a un microcontrolador como el Arduino
UNO, puede usarlo para controlar todo tipo de cosas: LED, relés, motores,
zumbadores, etc.
En el diagrama de cableado a continuación, puede ver cómo conectarlo al
Arduino. Puede leer el sensor con uno de los pines de entrada/salida de uso
general (GPIO) del Arduino. En este ejemplo, lo conecté al pin digital 2. Los
pines VCC y GND están conectados a 5V y GND respectivamente.

Sensor de movimiento PIR HC-SR501 con diagrama de cableado Arduino

Las conexiones también se dan en la tabla a continuación:

57

Conexiones del sensor de movimiento PIR
HC-SR501

Sensor de movimiento PIR HC-SR501 Arduino
VCC 5 V
OUT Pin 2
GND GND

Una vez que haya conectado el sensor, el siguiente paso es cargar un código
de ejemplo.

Sensor de movimiento PIR HC-SR501 con
código de ejemplo Arduino UNO

Con el siguiente código de ejemplo, puede leer el sensor y controlar el LED
incorporado del Arduino (conectado al pin 13). Este código también se puede
usar para controlar relés simples para encender o apagar una luz más grande.
Puede cargar el código de ejemplo con el IDE de Arduino .
Para que este código funcione correctamente, es mejor configurar el puente del
modo de disparo en 'H' ( modo de disparo repetido). Ajuste también el
potenciómetro de retardo de tiempo al valor más bajo. Gíralo en sentido
antihorario hasta el tope.
El código leerá el estado del sensor (ALTO o BAJO) y encenderá o apagará el
LED incorporado en consecuencia. También imprimirá un mensaje en el
Monitor de serie, al que puede acceder en Herramientas o escriba (Ctrl + Shift
+ M).

// Define connection pins:
#define pirPin 2
#define ledPin 13
// Create variables:
int val = 0;
bool motionState = false; // We start with no motion detected.

58
void setup() {
// Configure the pins as input or output:
pinMode(ledPin, OUTPUT);
pinMode(pirPin, INPUT);

Serial.begin(9600);
}
void loop() {
// Read out the pirPin and store as val:
val = digitalRead(pirPin);
// If motion is detected (pirPin = HIGH), do the following:

if (val == HIGH) {
digitalWrite(ledPin, HIGH); // Turn on the on-board LED.
// Change the motion state to true (motion detected):

if (motionState == false) {
Serial.println("Motion detected!");
motionState = true;
}
}
// If no motion is detected (pirPin = LOW), do the following:

else {
digitalWrite(ledPin, LOW); // Turn off the on-board LED.
// Change the motion state to false (no motion):

if (motionState == true) {
Serial.println("Motion ended!");
motionState = false;
}
}
}

Debería ver la siguiente salida en el monitor serie:

59
Salida del sensor PIR en el monitor en serie

Explicación del código:

El código es bastante simple y no necesita ninguna biblioteca Arduino para
usar este sensor.
El sketch comienza con la definición del pin del sensor PIR y el pin del LED. Los
conecté a los pin 2 y 13 de Arduino (LED integrado).
La declaración #define se usa para dar un nombre a un valor constante. El
mencione pirPin, el compilador lo reemplazará con el valor 2 cuando se compile
el programa.
También creé dos variables, val y motionState, que son un número entero y
booleano (verdadero/falso) respectivamente. La variable val se usa para
almacenar la salida del sensor PIR (ALTO o BAJO) y motionState se convertirá
en verdadero mientras se detecta movimiento y en falso cuando no hay
movimiento.

// Define connection pins:
#define pirPin 2
#define ledPin 13
int val = 0;
bool motionState = false; // We start with no motion detected.

60

En el setup(), configuramos los pines como entrada o salida con la función
pinMode( pin,mode). El pirPin es una entrada y el ledPin es una salida. También
comenzamos la comunicación en serie a una velocidad en baudios de 9600.
Asegúrese de que el Monitor en serie también esté configurado en 9600.

void setup() {
// Configure the pins as input or output:

Serial.begin(9600);
}
En el loop(), primero leí el sensor con la función digitalRead( pin). Esta función
devuelve ALTO o BAJO.


Si la salida/val del sensor es ALTA, enciendo el LED con la función
digitalWrite( pin,value).

if (val == HIGH) {

motionState = true;
}
}

A continuación, motionState cambia a verdadero y aparece el mensaje
"¡Movimiento detectado!" se imprime en el monitor serie. Tenga en cuenta que
primero verifico el estado de movimiento actual, esto asegura que el mensaje
solo se imprima una vez por evento de movimiento.

61

Si ya no hay movimiento delante del sensor, val cambiará a BAJO y el LED se
apagará y aparecerá el mensaje "¡Movimiento finalizado!" se imprime en el
monitor en serie.

Cree un sistema de alarma con sensor de
movimiento PIR y zumbador

Con algunos cambios simples, puede crear un sistema de alarma con el
HC-SR501 y un zumbador piezoeléctrico . Conecté el zumbador con una
resistencia de 100 Ω entre el pin digital 5 y GND. Probablemente pueda usar el
timbre sin una resistencia (esto lo hace más fuerte), pero no sonará tan bien.
Sensor de movimiento PIR HC-SR501 con Arduino UNO y diagrama de

cableado del zumbador.

El siguiente código es en su mayoría el mismo que el ejemplo anterior. Solo
agregué una función para crear el sonido de la alarma. Puede cambiar el tono
del timbre cambiando el parámetro de entrada de la función
alarm(duration,frequency).

// Definir pines de conexión:
#define buzzerPin 5
#define pirPin 2
#define ledPin 13
// Crear variables:

62
int val = 0;
bool motionState = false; // Comenzamos sin movimiento
detectado.
void setup() {
// Configure los pines como entrada o salida:
pinMode(buzzerPin, OUTPUT);
// Comience la comunicación en serie a una velocidad en

baudios de 9600:
Serial.begin(9600);
}
void loop() {

if (val == HIGH) {
alarm(500, 1000); // Call the alarm(duration, frequency)
function.
delay(150);

motionState = true;
}
}
// If no motion is detected (pirPin = LOW), do the following:

else {
digitalWrite(ledPin, LOW); // Turn off the on-board LED.

63
noTone(buzzerPin); // Make sure no tone is played when no

motion is detected.
delay(150);
// Change the motion state to false (no motion):

if (motionState == true) {
Serial.println("Motion ended!");
motionState = false;
}
}
}
// Function to create a tone with parameters duration and

frequency:
void alarm(long duration, int freq) {
tone(buzzerPin, freq);
delay(duration);
noTone(buzzerPin);
}

Cosas a considerar al diseñar un sistema de
sensor PIR

Al igual que otros sensores PIR, el HC-SR501 necesita algo de tiempo para
inicializarse y ajustarse a los niveles infrarrojos de la habitación. Esto toma
aproximadamente 1 minuto cuando se enciende por primera vez. Intente
eliminar cualquier movimiento delante del sensor durante este período.
El viento y una fuente de luz cerca del sensor pueden causar interferencias, por
lo tanto, intente ajustar su configuración para evitar esto. También tenga en
cuenta que debe montar el sensor horizontalmente, ya que la mayoría del
movimiento ocurrirá en el plano horizontal ( por ejemplo, caminar).
Además del tiempo de retardo (Tx), el sensor también tiene un 'tiempo de
bloqueo' (Ti). Por defecto, el tiempo de bloqueo es de 2.5 segundos y no es
muy fácil de cambiar (consulte la hoja de datos BISS0001). Cada vez que la
salida pasa de ALTA a BAJA, comienza el período de bloqueo. Durante este
período de tiempo, el sensor no detectará ningún movimiento.
Al diseñar un sistema basado en el HC-SR501, deberá tener en cuenta estos
períodos de retraso.

64

Cómo usar un sensor de

distancia ultrasónico
HC-SR04 con Arduino

El HC-SR04 es un sensor de distancia económico y fácil de usar, con un rango
de 2 a 400 cm. Se usa comúnmente en obstáculos para evitar robots y
proyectos de automatización. ¿Y sabía que su automóvil usa sensores similares
en el sistema de asistencia de estacionamiento?
En este tutorial aprenderá cómo funciona el sensor y cómo usarlo con Arduino.
He incluido 5 ejemplos con un diagrama de cableado y un código para que
pueda comenzar a experimentar con su sensor. Primero veremos un ejemplo
que no usa una biblioteca Arduino. A continuación, le mostraré cómo puede
usar la biblioteca NewPing para crear código más compacto.

65

¿Cómo funciona un sensor de distancia
ultrasónico?

Los sensores ultrasónicos funcionan emitiendo ondas de sonido con una
frecuencia que es demasiado alta para que un humano la escuche. Estas ondas
sonoras viajan por el aire con la velocidad del sonido, aproximadamente 343
m/s. Si hay un objeto delante del sensor, las ondas de sonido se reflejan y el
receptor del sensor ultrasónico las detecta. Al medir cuánto tiempo pasó entre
el envío y la recepción de las ondas de sonido, se puede calcular la distancia
entre el sensor y el objeto.

Principios de funcionamiento de los sensores de distancia ultrasónicos.

Fuente: https://www.maxbotix.com/

A 20 ° C, la velocidad del sonido es aproximadamente de 343 m/so 0.034
cm/µs. Digamos que el tiempo entre enviar y recibir las ondas de sonido es de
2000 microsegundos. Si multiplica la velocidad del sonido por el tiempo que
viajaron las ondas de sonido, obtendrá la distancia que recorrieron las ondas
de sonido.
Distancia = Velocidad x Tiempo
Pero ese no es el resultado que estamos buscando. La distancia entre el sensor
y el objeto es en realidad solo la mitad de esta distancia porque las ondas de
sonido viajaron desde el sensor al objeto y regresaron del objeto al sensor.
Entonces necesitas dividir el resultado entre dos.

66

Distancia (cm) = Velocidad del sonido (cm/µs)xTiempo ( µs)/2

Y así, para el ejemplo, esto se convierte en:

Distancia (cm) = 0.0343 (cm/µs)x2000 ( µs)/2 = 34.3 cm

Dependencia de la temperatura de la
velocidad de la velocidad del sonido.

La velocidad del sonido en realidad depende en gran medida de la temperatura
y, en un grado mucho menor, de la humedad del aire. Wikipedia afirma que la
velocidad del sonido aumenta con aproximadamente 0.6 m/s por grado Celsius.
Para la mayoría de los casos a 20 ° C, puede usar 343 m/s, pero si desea
obtener lecturas más precisas, puede calcular la velocidad del sonido con la
siguiente fórmula:

V ( m/s) = 331.3 + (0.606xT)
V = Velocidad del sonido ( m/s)
T = Temperatura del aire (° C)

Esta fórmula no incluye la humedad ya que su efecto sobre la velocidad del
sonido es muy pequeño.

Cómo funciona el HC-SR04

En la parte frontal del sensor HC-SR04 puede encontrar dos cilindros
plateados (transductores ultrasónicos), uno es el transmisor de las ondas de
sonido y el otro es el receptor. Para permitir que el sensor genere una
explosión sónica, debe configurar el pin Trig en alto durante al menos 10 µs. El
sensor crea una ráfaga de ultrasonido de 8 ciclos a 40 kHz.
Esta explosión sónica viaja a la velocidad del sonido, rebota y es recibida por el
receptor del sensor. El pin Echo luego emite el tiempo que las ondas de sonido
viajaron en microsegundos.

67

Puede usar la pulseIn()función en el código Arduino para leer la longitud del
pulso desde el pin Echo. Después de eso, puede usar la fórmula mencionada
anteriormente para calcular la distancia entre el sensor y el objeto.

Especificaciones de HC-SR04

Corriente de funcionamiento 15 mA
Frecuencia 40 kHz
Rango de medición 2 - 400 cm
Resolución 3 mm
Ángulo de medición 15 grados
Señal de entrada de disparo Pulso alto de 10 µs

68

Para obtener más información, puede consultar la hoja de datos aquí.

🔗
Hoja de datos de HC-SR04


Sensor HC-SR04 x 1 Electrogeek

También puede usar otros microcontroladores
como un Arduino Mega o esp32.

Cables para Protoboard ~ 10 Electrogeek
Cable USB tipo B x 1 Electrogeek
Sensor DHT11 (opcional) x 1 Electrogeek
2004 I2C LCD (opcional) x 1 Electrogeek

1602 I2C LCD también se puede utilizar.
Software
IDE Arduino

69

Cableado - Conexión de HC-SR04 a Arduino
UNO

El siguiente diagrama de cableado le muestra cómo conectar el sensor
HC-SR04 al Arduino.
HC-SR04 con diagrama de cableado Arduino

Los ejemplos de código a continuación usan el pin digital 2 y 3 para el gatillo y
el pin de eco, pero, por supuesto, puede cambiarlo a cualquier pin digital que
desee.

Conexiones HC-SR04

HC-SR04 Arduino
VCC 5 V
Trigger Pin 2
Echo Pin 3
GND GND

70

Código de ejemplo para HC-SR04 con
Arduino

Ahora que ha conectado el sensor, es hora de conectar el Arduino a la
computadora y cargar un código. Puede cargar el siguiente código de ejemplo
en su Arduino utilizando el IDE de Arduino . A continuación, te explicaré cómo
funciona el código.

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3
// Define variables:
long duration;
int distance;
void setup() {
// Define inputs and outputs:
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
//Begin Serial communication at a baudrate of 9600:

Serial.begin(9600);
}
void loop() {
// Clear the trigPin by setting it LOW:
digitalWrite(trigPin, LOW);
delayMicroseconds(5);
// Trigger the sensor by setting the trigPin high for 10

microseconds:
digitalWrite(trigPin, HIGH);

71
// Read the echoPin, pulseIn() returns the duration (length of

the pulse) in microseconds:
duration = pulseIn(echoPin, HIGH);
// Calculate the distance:
distance= duration*0.034/2;
// Print the distance on the Serial Monitor (Ctrl+Shift+M):

Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(50);
}


Primero, se definen el pin de activación y el pin de eco. Los llamo trigPin y
EchoPin. El pin de disparo está conectado al pin digital 2 y el pin de eco al pin
digital 3 en el Arduino.
mencione trigPin, el compilador lo reemplazará con el valor 2 cuando se

#define trigPin 2
#define echoPin 3

Luego definí dos variables: duration y distance. La duración almacena el
tiempo entre el envío y la recepción de las ondas sonoras. La variable de
distancia se usa para almacenar la distancia calculada.

long duration;
int distance;

72

En el setup(), comienza configurando el trigPin como salida y el echoPin
como entrada. A continuación, inicializa la comunicación en serie a una
velocidad en baudios de 9600. Más adelante, mostrará la distancia medida en
el monitor en serie, al que se puede acceder con Ctrl + Shift + M o
Herramientas> Monitor en serie. Asegúrese de que la velocidad en baudios
también esté establecida en 9600 en el monitor en serie.

void setup() {
//Begin Serial communication at a baudrate of 9600:

Serial.begin(9600);
}

En el loop(), activa el sensor configurando el trigPin HIGH para 10 µs. Tenga
en cuenta que para obtener una señal limpia, comience borrando el trigPin
configurándose BAJO durante 5 microsegundos.

void loop() {
// Trigger the sensor by setting the trigPin high for 10

microseconds:

A continuación, debe leer la longitud del pulso enviado por echoPin. Yo uso la
función pulseIn()para esto. Esta función espera a que el pin pase de BAJO a
ALTO, comienza a cronometrar, luego espera a que el pin pase a BAJO y
detiene el cronometraje.

73

Después de eso, calcula la distancia utilizando la fórmula mencionada en la
introducción de este tutorial.

// Read the echoPin, pulseIn() returns the duration (length of
the pulse) in microseconds:
distance= duration*0.034/2;

Finalmente, imprima la distancia calculada en el monitor en serie.

// Print the distance on the Serial Monitor (Ctrl+Shift+M):
delay(50);
}

Código de ejemplo HC-SR04 con biblioteca
Arduino y NewPing

La biblioteca NewPing escrita por Tim Eckel se puede usar con muchos
sensores de distancia ultrasónicos. La última versión de esta biblioteca se
puede descargar aquí en bitbucket.org. Puede notar que el código a
continuación, que usa la biblioteca NewPing, es mucho más corto que el
código que usamos antes. Además de eso, la biblioteca NewPing incluye
algunas otras características agradables. Le permite establecer una distancia
máxima para leer, no se retrasa por un segundo completo cuando no se reciba
eco y tenga un filtro de mediana incorporado.

🔗 NewPing_v1.9.1.zip

biblioteca .ZIP en el IDE de Arduino.
La biblioteca incluye algunos ejemplos que puede usar, pero tendrá que
modificarlos para que coincidan con la configuración de su hardware. He

74

incluido un código de ejemplo modificado a continuación que se puede usar
con la misma configuración de cableado que antes.

#include <NewPing.h>
// Define pins and max distance:

#define trigPin 2
#define echoPin 3
#define MAX_DISTANCE 350 // Maximum distance we want to ping
for (in centimeters). Maximum sensor distance is rated at
400-500cm.
NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // NewPing

setup of pins and maximum distance.
float duration, distance;
void setup() {
Serial.begin(9600); // Open serial monitor at 9600 baud to
see ping results.
}
void loop() {
delay(50); // Wait 50ms between pings (about 20 pings/sec).
29ms should be the shortest delay between pings.
duration = sonar.ping();
distance = (duration/2) * 0.0343;
Serial.print(distance); // Distance will be 0 when out of set
max range.
}

75

También puede usar distance = sonar.ping_cm() o distance =
sonar.ping_in()que devuelve la distancia medida en centímetros o
pulgadas enteras. Con esta función no se necesita tomar una medición de
duración y calcular la distancia.

Sensores ultrasónicos de interfaz en modo
de 3 pines

La biblioteca NewPing también facilita la interfaz con sensores ultrasónicos
mientras se usa solo 1 pin de E/S. Esto puede ser útil si tiene muy pocos pines
de E/S disponibles o si desea usar un sensor ultrasónico de 3 pines como el
Parallax Ping .
Para crear una configuración de 3 pines (GND, 5V y SIG), debe conectar tanto
el pin de activación como el pin de eco al mismo pin digital en el Arduino. En el
código, lo único que tiene que cambiar es la línea 6-7 y definir el mismo pin
tanto para el trigPin como para el echoPin. Por ejemplo pin digital 2.

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 2

Cómo usar el filtro digital ping_median ()

Lo principal que me gusta de la biblioteca NewPing es que tiene un filtro de
mediana incorporado. Este filtro puede mejorar en gran medida la precisión de
sus lecturas HC-SR04. La ping_median() función toma muchas mediciones
de duración seguidas, descarta las lecturas fuera de rango y luego promedia
las restantes. Por defecto, tomará 5 lecturas, pero puede especificar cuántas
debería tomar. Reemplace la línea 19 con las siguientes líneas.

int iterations = 5;
duration = sonar.ping_median(iterations);

76

Código de ejemplo HC-SR04 con I2C LCD y
Arduino

Para mostrar la distancia medida en una pantalla LCD I2C 2004 o 1602 , todo
lo que tiene que hacer es realizar las siguientes conexiones y cargar el código a
continuación. El sensor HC-SR04 está conectado de la misma manera que
antes.
HC-SR04 con diagrama de cableado LCD Arduino e I2C.

Conexiones LCD I2C

LCD I2C Arduino
GND GND
VCC 5 V
SDA A4
SCL A5

Si no está utilizando un Arduino Uno, los pines SDA y SCL pueden estar en
una ubicación diferente. Un Arduino UNO con el diseño R3 (1.0 pinout),
también tiene los encabezados de pin SDA (línea de datos) y SCL (línea de
reloj) cerca del pin AREF. Consulte la tabla a continuación para obtener más
detalles.

77

Placa SDA SCL
Arduino Uno A4 A5
Arduino Nano A4 A5
Arduino Micro 2 3
Arduino Mega 2560 20 21
Arduino Leonardo 2 3
Due Arduino 20 21

El código utiliza la biblioteca LiquidCrystal_I2C , que puede descargar aquí en
GitHub . ¡Asegúrese de tener esta biblioteca exacta instalada! También incluye
la biblioteca Wire.h , que le permite comunicarse con dispositivos I2C. Esta
biblioteca debe venir preinstalada con el IDE de Arduino.

🔗 LiquidCrystal_I2C-master.zip

#include <Wire.h>

#define trigPin 2
#define echoPin 3
// Define SDA and SCL pin for LCD:

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4); //Change to
(0x27,16,2) for 1602 LCD

78
long duration;
int distance;
void setup() {

lcd.init();
lcd.backlight();
}
void loop() {
// Trigger the sensor by setting the trigPin high for 10 microseconds:

// Read the echoPin. This returns the duration (length of the pulse) in
microseconds:

distance = duration*0.034/2;
// Display the distance on the LCD:

lcd.setCursor(0,0); // Set the cursor to column 1, line 1 (counting
starts at zero)
lcd.print("Distance = "); // Prints string "Display = " on the LCD
lcd.print(distance); // Prints the measured distance
lcd.print(" cm "); // Prints "cm" on the LCD, extra spaces are needed
to clear previously displayed characters
delay(50);
}

79

Tenga en cuenta que utilicé una pantalla LCD de 20x4. Si tiene una pantalla
LCD de diferente tamaño (16x2 también es común), debe cambiar la línea 20 a
LiquidCrystal_I2C lcd(0x27,16,2);. Si su LCD no tiene la dirección I2C
predeterminada, 0x27, consulte el tutorial completo de I2C donde le explico
cómo puede averiguar cuál es la dirección.

Código de ejemplo HC-SR04 con sensor de
temperatura DHT11 y Arduino

Como se mencionó anteriormente, la velocidad del sonido depende en gran
medida de la temperatura del aire. Si desea medir largas distancias (3-4 m),
puede ser una buena idea agregar un sensor de temperatura y humedad
DHT11 o DHT22 a su configuración. Esto le permitirá calibrar la velocidad del
sonido en tiempo real y así aumentar la precisión de sus mediciones.
Agregar un sensor DHT11 es realmente simple. El siguiente diagrama de
cableado le muestra las conexiones que necesita hacer. Tenga en cuenta que
estoy usando un DHT11 con placa de conexión , por lo que solo necesito
conectar 3 pines. Asegúrese de revisar la etiqueta del sensor, el orden de los
pines puede ser diferente según el fabricante. El sensor HC-SR04 está
conectado de la misma manera que antes.

HC-SR04 con diagrama de cableado Arduino y DHT11.

80

Conexiones DHT11

DHT11 Arduino
VCC (+) 5 V
Señal (S) Pin 4
GND (-) GND

El siguiente código utiliza la biblioteca de sensores de humedad y temperatura
Adafruit DHT que puede descargar aquí en GitHub . Esta biblioteca solo
funciona si también tiene instalada la biblioteca Adafruit_Sensor , que también
está disponible en GitHub . También puede descargar las dos bibliotecas
haciendo clic en los botones a continuación:


// Include Adafruit sensor library:
//https://github.com/adafruit/Adafruit_Sensor
// Include Adafruit DHT library:
#include <DHT.h> //https://github.com/adafruit/DHT-sensor-library
// Define Trig pin, Echo pin and DHTPin:

#define trigPin 2
#define echoPin 3
#define DHTPin 4
// Define DHT sensor type:

#define DHTType DHT11
long duration;
int distance;
float speedofsound;

81
// Create a DHT sensor object:

DHT dht = DHT(DHTPin,DHTType);
void setup() {
dht.begin();
// Begin Serial communication:

Serial.begin(9600); // Starts the serial communication
}
void loop() {

microseconds:
// Read the temperature:

float temperature = dht.readTemperature();
// Calculate speed of sound in m/s:

speedofsound = 331.3+(0.606*temperature);
// Calculate the distance in cm:

distance = duration*(speedofsound/10000)/2;
// Print the distance and temperature on the Serial Monitor:

Serial.print("Temperature = ");
Serial.print(temperature);
Serial.print(" Celsius");
Serial.print(", Distance = ");

82
Serial.println("cm");
delay(100);
}

Código de ejemplo HC-SR04 con DHT11 y LCD
I2C

HC-SR04 con diagrama de cableado LCD Arduino, DHT11 e I2C.

El siguiente código se puede usar para combinar los 3 ejemplos anteriores.
Muestra la temperatura, la velocidad del sonido y la distancia medida en la
pantalla LCD.

// Include Adafruit sensor library:
#include <Adafruit_Sensor.h> //
https://github.com/adafruit/Adafruit_Sensor
// Include Adafruit DHT library:
#include <DHT.h> // https://github.com/adafruit/DHT-sensor-library
#include <Wire.h> // Library for I2C communication
#include <LiquidCrystal_I2C.h> // Library for LCD
// Define Trig pin, Echo pin and DHTPin:

#define trigPin 2
#define echoPin 3
#define DHTPin 4
// Define SDA and SCL pin from LCD:

// Connect to LCD via i2c, default address 0x27 (A0-A2 not jumpered):

83
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4);
// Define DHT sensor type:

#define DHTType DHT11
long duration;
int distance;
float speedofsound;
// Create a DHT sensor object:

DHT dht = DHT(DHTPin,DHTType);
void setup() {
dht.begin();

lcd.init();
lcd.backlight();
// Begin Serial communication at a baudrate of 9600:

Serial.begin(9600);
}
void loop() {

microseconds:
// Read the temperature:

84
int temperature = dht.readTemperature();
// Calculate speed of sound in m/s:

speedofsound = 331.3+(0.606*temperature);
// Calculate the distance in cm:

distance = duration*(speedofsound/10000)/2;
// Print the distance and temperature on the Serial Monitor:

lcd.setCursor(0,0);
lcd.print("Temperature: ");
lcd.print(temperature);
lcd.print(" " "\xDF" "C");
lcd.setCursor(0,1);
lcd.print("Speed: ");
lcd.print(speedofsound);
lcd.print(" m/s ");
lcd.setCursor(0,2);
lcd.print("Distance: ");
lcd.print(distance);
lcd.print(" cm ");
delay(100);
}

HC-SR04 Dimensiones

A continuación puede encontrar las dimensiones del sensor ultrasónico
HC-SR04.

85

TM1637 Tutorial de

Arduino de display de 7
Segmentos 4 Dígitos

En este tutorial, aprenderá cómo controlar las pantallas TM1637 de 4 dígitos y
7 segmentos con Arduino. Estas pantallas son fantásticas para mostrar los
datos del sensor, la temperatura, el tiempo, etc.
He incluido 3 ejemplos en este tutorial. En el primer ejemplo, veremos las
funciones básicas de la biblioteca TM1637Display. En el segundo ejemplo, le
mostraré cómo puede mostrar la hora en una pantalla de 4 dígitos. El último
ejemplo se puede utilizar para crear una pantalla de temperatura simple en
combinación con el DHT11.
Diagramas de cableado también están incluidos. Después del ejemplo,
desgloso y explico cómo funciona el código, por lo que no debería tener
problemas para modificarlo según sus necesidades.

86


TM1637 Pantalla de 7 segmentos de 4
× 1 Electrogeek
dígitos
Arduino Uno Rev3 × 1 Electrogeek
Protoboard × 1 Electrogeek
DS3231 RTC × 1 Electrogeek
Sensor de temperatura y humedad DHT11 × 1 Electrogeek
Cable USB tipo A/B × 1 Electrogeek

Software
IDE Arduino

Información sobre la pantalla.

Las pantallas de 4 dígitos y 7 segmentos generalmente requieren 12 pines de
conexión. Eso es bastante y no deja mucho espacio para otros sensores o
módulos. Gracias al IC TM1637 montado en la parte posterior del módulo de
pantalla, este número se puede reducir a sólo cuatro. Se requieren dos pines
para las conexiones de alimentación y los otros dos pines se utilizan para
controlar los segmentos.
Las pantallas de 7 segmentos contienen 7 (u 8) LED direccionables
individualmente. Los segmentos están etiquetados de A a G y algunas
pantallas también tienen un punto (el octavo LED). Use esta imagen como
referencia cuando configure los segmentos individuales en el código más
adelante.

87

Puede comprar muchos módulos de pantalla diferentes que usan un IC
TM1637. El color, el tamaño, los puntos y los puntos de conexión pueden ser
diferentes. No tengo experiencia con todas las diferentes versiones de esta
pantalla, pero siempre que utilicen el TM1637, los ejemplos de código que se
proporcionan a continuación deberían funcionar.
Aquí puede encontrar las especificaciones básicas del módulo de pantalla que
utilicé en este tutorial.

Especificaciones de la pantalla TM1637 de 4
dígitos y 7 segmentos

Tensión de funcionamiento 3.3 - 5 V
Consumo de corriente 80 mA
Niveles de luminancia 8
Dimensiones de la pantalla 30x14 mm (dígitos de 0.36 ″)
Dimensiones totales 42x24x12 mm
Dimensiones del agujero 38x20, ⌀ 2.2 mm
Temperatura de funcionamiento -10 - 80 ° C

El TM1637 IC está fabricado por Titan Micro Electronics . Para obtener más
información, puede consultar la hoja de datos a continuación:

88

🔗 TM1637 Hoja de datos

Cableado: conexión de la pantalla TM1637 de
4 dígitos y 7 segmentos a Arduino UNO

Conectar la pantalla a un Arduino u otro microcontrolador es súper fácil. Solo
necesita conectar 4 cables: 2 para la alimentación y 2 para transferir los datos.
El siguiente diagrama de cableado le muestra cómo puede conectar la pantalla
al Arduino.
TM1637 Pantalla de 4 dígitos y 7 segmentos con diagrama de cableado Arduino UNO.


Conexiones de pantalla TM1637

Pantalla TM1637 de 4 dígitos Arduino
VCC 5 V
GND GND
CLK Pin digital 2

89
DIO Pin digital 3

¡Tenga en cuenta que el orden y la ubicación de los pins pueden variar según el
fabricante!

Para este tutorial, conecté CLK y DIO a los pines 2 y 3 respectivamente, pero
puede cambiar esto a cualquiera de los pines digitales que desee. Solo tiene
que cambiar la configuración del pin en el código en consecuencia.

TM1637 código de ejemplo Arduino de 4
dígitos y 7 segmentos

Avishay Orpaz ha escrito una excelente biblioteca para pantallas TM1637, la
biblioteca TM1637Display . Esta biblioteca tiene varias funciones integradas
que hacen que controlar la pantalla sea bastante fácil.
Las funciones principales incluyen:

● setSegments () - Establece el valor bruto de los segmentos de cada
dígito
● showNumberDec () - Muestra un número decimal
● showNumberDecEx () - Muestra un número decimal con puntos
decimales o dos puntos
● setBrightness () - Establece el brillo de la pantalla
● clear () : borra la pantalla

El siguiente ejemplo de código presenta todas estas funciones. Explicaré cómo
se puede usar cada función con más detalle a continuación.
Puede cargar el código de ejemplo en su Arduino usando el IDE de Arduino .
Para instalar la biblioteca, puede descargarla como un .zip desde GitHub aquí .
A continuación, vaya a Sketch> Incluir biblioteca> Agregar biblioteca .ZIP ...
en el IDE de Arduino.

🔗 TM1637-master.zip
Otra opción es navegar a Herramientas> Administrar bibliotecas ... o escribir

Puede buscar 'tm1637' y buscar la biblioteca por Avishay Orpaz. Seleccione la
última versión y luego haga clic en Instalar.

90

Código de ejemplo

Puede abrir el código en una nueva ventana haciendo clic en el botón en la
esquina superior derecha del campo de código.

#include <TM1637Display.h>
// Define the connections pins:

#define CLK 2
#define DIO 3
// Create display object of type TM1637Display:

TM1637Display display = TM1637Display(CLK, DIO);
// Create array that turns all segments on:

const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:

const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};
// You can set the individual segments per digit to spell words or create
other symbols:
const uint8_t done[] = {
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};
// Create degree Celsius symbol:

const uint8_t celsius[] = {
SEG_A | SEG_B | SEG_F | SEG_G, // Circle
SEG_A | SEG_D | SEG_E | SEG_F // C
};
void setup() {
// Clear the display:
display.clear();
delay(1000);
}

91
void loop() {
// Set the brightness:
display.setBrightness(7);
// All segments on:
display.setSegments(data);
delay(1000);
display.clear();
delay(1000);
// Show counter:
int i;
for (i = 0; i < 101; i++) {
display.showNumberDec(i);
delay(50);
}
delay(1000);
display.clear();
delay(1000);
// Print number in different locations, loops 2 times:

int j;
for (j = 0; j < 2; j++) {
for (i = 0; i < 4; i++) {
display.showNumberDec(i, false, 1, i);
delay(500);
display.clear();
}
}
delay(1000);
display.clear();
delay(1000);
// Set brightness (0-7):

int k;
for (k = 0; k < 8; k++) {
display.setBrightness(k);
display.setSegments(data);
delay(500);
}

92
delay(1000);
display.clear();
delay(1000);
// Print 1234 with the center colon:

display.showNumberDecEx(1234, 0b11100000, false, 4, 0);
delay(1000);
display.clear();
delay(1000);
int temperature = 24;

display.showNumberDec(temperature, false, 2, 0);
display.setSegments(celsius, 2, 2);
delay(1000);
display.clear();
delay(1000);
display.setSegments(done);
while(1);
}

Cómo funciona el código:

El código comienza con la inclusión de la biblioteca. Asegúrese de tener
instalada la biblioteca correcta; de lo contrario, recibirá un mensaje de error al
compilar el código.

// Incluye la biblioteca:

El siguiente paso es especificar los pines de conexión. La declaración #define
se usa para dar un nombre a un valor constante. El compilador reemplazará
cualquier referencia a esta constante con el valor definido cuando se compila el
programa. Entonces, en todas partes que mencione CLK, el compilador lo
reemplazará con el valor 2 cuando se compile el programa.

93

#define CLK 2
#define DIO 3

A continuación, creamos un objeto de visualización del tipo TM1637Display
con los pines CLK y DIO definidos. Tenga en cuenta que llamé a la pantalla
'pantalla', pero también puede usar otros nombres como 'temperatura_display'.
El nombre que le dé a la pantalla se usará más adelante para escribir datos en
esa pantalla en particular. Puede crear y controlar múltiples objetos de
visualización con diferentes nombres y pines de conexión. Actualmente no hay
límite en la biblioteca.

// Crear objeto de visualización de tipo TM1637Display:
TM1637Display display = TM1637Display ( CLK, DIO ) ;
// Puede crear más de un objeto de visualización. Dales diferentes

nombres y pines de conexión:
TM1637Display display_1 = TM1637Display ( 2 , 3 ) ;

Hay varias formas de controlar los segmentos individuales de la pantalla.
Antes de la sección de configuración del código, especifiqué varias matrices
para configurar los segmentos de visualización individuales. Usaremos la
función setSegments()más tarde para escribirlos en la pantalla.
La primera opción es escribir números hexadecimales en la pantalla para cada
dígito. El 0xff hexadecimal se traduce a 11111111 en binario, esto activa todos
los segmentos (incluido el punto si su pantalla tiene uno). 0xef, por ejemplo, se
traduce en 11101111. Esto activaría todos los segmentos, excepto el
segmento E. Tenga en cuenta que el conteo va de derecha a izquierda, por lo
que 11111111 corresponde a segmentos ( punto) GFEDCBA. Puede encontrar
un gráfico de conversión de hexadecimal a binario aquí .

// Create array that turns all segments on:
const uint8_t data[] = {0xff, 0xff, 0xff, 0xff};
// Create array that turns all segments off:

const uint8_t blank[] = {0x00, 0x00, 0x00, 0x00};

94

La biblioteca tiene una función incorporada que facilita un poco la
configuración de segmentos individuales. Vea el fragmento de código a
continuación. Puede crear matrices para deletrear palabras. Cada segmento
está separado por un | y los dígitos de la pantalla están separados por una
coma.

// You can set the individual segments per digit to spell words or create
other symbols:
const uint8_t done[] = {
SEG_B | SEG_C | SEG_D | SEG_E | SEG_G, // d
SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F, // O
SEG_C | SEG_E | SEG_G, // n
SEG_A | SEG_D | SEG_E | SEG_F | SEG_G // E
};

Puede dejar la sección de configuración del código vacía si lo desea. Acabo de
usar la función clear() para asegurarse de que la pantalla se borró.

void setup() {
display.clear();
delay(1000);
}

En la sección de bucle del código, muestro varios ejemplos de las diferentes
funciones de la biblioteca:
setSegments (segmentos [], longitud,

posición)

Esta función se puede usar para configurar los segmentos individuales de la
pantalla. El primer argumento es la matriz que incluye la información del
segmento. El segundo argumento especifica el número de dígitos a modificar
(0-4). Si desea deletrear dOnE, esto sería 4, para un símbolo de ° C, esto sería
2. El tercer argumento establece la posición desde la cual imprimir (0 - más a la
izquierda, 3 - más a la derecha). Entonces, si desea imprimir un símbolo ° C en
el tercer y cuarto dígito, usaría:

95

};

El segundo y tercer argumento también pueden omitirse.

showNumberDec (number, Leading_zeros,
length, position)

Esta es probablemente la función que usará más. El primer argumento es un
número que desea mostrar en la pantalla. El resto de los argumentos son
opcionales.

El segundo argumento se puede usar para activar o desactivar los ceros
iniciales. 10 sin ceros a la izquierda se imprimirán como __10 y con ceros a la
izquierda como 0010. Puede activarlos estableciendo este argumento como
verdadero o desactivarlos estableciéndose como falso. NOTA: el cero inicial no
es compatible con números negativos.
El tercer y cuarto argumento son los mismos que en la función anterior.

// Print the number 12 without leading zeros on the second and
third digit:
display.showNumberDec(12, false, 2, 1);

showNumberDecEx(number, dots,
leading_zeros, length, position)

Esta función le permite controlar los puntos de la pantalla. Solo el segundo
argumento es diferente de la función showNumberDec. Le permite establecer
los puntos entre los dígitos individuales.
Puede usar los siguientes valores.

96

Para pantallas con puntos entre cada dígito:

● 0b10000000 - 0.000
● 0b01000000 - 00.00
● 0b00100000 - 000.0
● 0b11100000 - 0.0.0.0
Para pantallas con solo dos puntos:
● 0b01000000 - 00:00
Para pantallas con puntos y dos puntos, dos puntos:
● 0b11100000 - 0.0: 0.0
Entonces, si desea mostrar un reloj con dos puntos en el centro (vea el ejemplo
del reloj a continuación), usaría algo como:

// Imprime 1234 con los dos puntos centrales:
monitor.showNumberDecEx ( 1234 , 0b11100000 , falso , 4 , 0 ) ;

setBrightness (brillo, verdadero/falso)

Esta función establece el brillo de la pantalla (como su nombre indica). Puede
especificar un nivel de brillo de 0 (brillo más bajo) a 7 (brillo más alto). El
segundo parámetro se puede usar para encender o apagar la pantalla, falso
significa apagado.

// Establecer el brillo de la pantalla (0-7):
monitor. setBrightness ( 7 ) ;

Ejemplo de reloj: pantalla TM1637 de 4
dígitos y 7 segmentos con DS3231 RTC

Uno de los usos típicos de una pantalla de 4 dígitos y 7 segmentos es mostrar
la hora. Al combinar el TM1637 con un módulo de reloj en tiempo real (RTC),
puede crear fácilmente un reloj de 24 horas.

97
En este ejemplo, utilicé este módulo RTC DS3231 de uso común .
Este módulo se comunica con el Arduino a través de I2C, por lo que solo
necesita dos conexiones para leer la hora.
El siguiente diagrama de cableado le muestra cómo puede conectar el DS3231
RTC al Arduino. Tenga en cuenta que la pantalla TM1637 está conectada de la
misma manera que antes.
TM1637 con diagrama de cableado DS3231 RTC y Arduino UNO.


Conexiones DS3231 RTC

DS3231 Arduino
VCC 5 V
GND GND
SDA A4
SCL A5

98

El siguiente ejemplo de código se puede usar para mostrar la hora en un
formato de 24 horas. Si su pantalla tiene dos puntos centrales, entonces este
código hará que parpadee. También puede deshabilitar esto eliminando las
últimas líneas de código.
La primera vez que cargue el código, el RTC se configurará a la hora en que se
compiló el sketch.
Puede instalar una batería de botón en la parte posterior del módulo, de modo
que el tiempo se almacene en caso de que pierda energía.
El código usa la biblioteca Adafruit RTC, que puede descargar aquí en GitHub .
También puede instalarlo a través del Administrador de biblioteca en el IDE de
Arduino buscando 'RTClib', o haga clic en el botón de descarga a continuación:

🔗 RTClib-master.zip

Código de ejemplo

#include "RTClib.h"

#define CLK 2
#define DIO 3
// Create rtc and display object:

RTC_DS3231 rtc;
void setup() {
Serial.begin(9600);
// Wait for console opening:
delay(3000);
// Check if RTC is connected correctly:

if (! rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);

99
}
// Check if the RTC lost power and if so, set the time:
if (rtc.lostPower()) {
Serial.println("RTC lost power, lets set the time!");
// The following line sets the RTC to the date & time this sketch was
compiled:
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to
set
// January 21, 2014 at 3am you would call:
//rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}
// Set the display brightness (0-7):

display.clear();
}
void loop() {
// Get current date and time:
DateTime now = rtc.now();
// Create time format to display:

int displaytime = (now.hour() * 100) + now.minute();
// Print displaytime to the Serial Monitor:

Serial.println(displaytime);
// Display the current time in 24 hour format with leading zeros enabled
and a center colon:
display.showNumberDecEx(displaytime, 0b11100000, true);
// Remove the following lines of code if you want a static instead of a

blinking center colon:
delay(1000);
display.showNumberDec(displaytime, true); // Prints displaytime without

center colon.
delay(1000);
}

100

Ejemplo de termómetro: pantalla TM1637 de
4 dígitos y 7 segmentos con sensor de
temperatura y humedad DHT11

Las pantallas de 4 dígitos y 7 segmentos son excelentes para mostrar lecturas
de sensores como temperatura, humedad, voltaje o velocidad. En el siguiente
ejemplo, le mostraré cómo puede mostrar las lecturas de temperatura en la
pantalla TM1637.
Utilizaremos el popular sensor de temperatura y humedad DHT11 .
El siguiente diagrama de cableado le muestra cómo puede conectar el sensor
DHT11 en combinación con la pantalla TM1637 al Arduino.
Tenga en cuenta que la pantalla TM1637 está conectada de la misma manera
que antes.
TM1637 Pantalla de 4 dígitos y 7 segmentos con sensor de temperatura y humedad DHT11 y

diagrama de cableado Arduino UNO.


101

Conexiones DHT11

DHT11 Arduino
+ 5 V
- GND
s Pin digital 4

Tenga en cuenta que el orden de los pines puede ser diferente, según el
fabricante.
Si desea utilizar un sensor de 4 pines, consulte el tutorial para los sensores de
temperatura y humedad DHT11 y DHT22.

🔗 Cómo usar los sensores DHT11 y DHT22 con Arduino
El siguiente código de ejemplo se puede usar para mostrar las lecturas de
temperatura en la pantalla. Alterna entre la temperatura en Celius y Fahrenheit,
ambas se muestran durante 2 segundos.
La función setSegments()se utiliza para mostrar los símbolos Celsius y
Fahrenheit.
El código utiliza la biblioteca de sensores DHT Adafruit que puede descargar
aquí en GitHub . Esta biblioteca solo funciona si también tiene instalada la
biblioteca Adafruit Unified Sensor , que también está disponible en GitHub .
También puede descargar las dos bibliotecas haciendo clic en los botones a
continuación:


Para obtener más información, consulte mi tutorial DHT11 con Arduino.

102

Código de ejemplo

#include <DHT.h>

#define CLK 2
#define DIO 3
#define DHTPIN 4
// Create variable:
int temperature_celsius;
int temperature_fahrenheit;

};
// Create degree Fahrenheit symbol:

const uint8_t fahrenheit[] = {
SEG_A | SEG_E | SEG_F | SEG_G // F
};

// Create display object of type TM1637Display:

// Create dht object of type DHT:
void setup() {
// Set the display brightness (0-7):

103
display.clear();
// Setup sensor:
dht.begin();
Serial.begin(9600);
// Wait for console opening:
delay(2000);
}
void loop() {
// Read the temperature as Celsius and Fahrenheit:
temperature_celsius = dht.readTemperature();
temperature_fahrenheit = dht.readTemperature(true);
// Print the temperature to the Serial Monitor:
Serial.println(temperature_celsius);
Serial.println(temperature_fahrenheit);
// Show the temperature on the TM1637 display:

display.showNumberDec(temperature_celsius, false, 2, 0);
delay(2000);
display.showNumberDec(temperature_fahrenheit, false, 2, 0);

display.setSegments(fahrenheit, 2, 2);
delay(2000);
}

104

Cómo controlar
servomotores con
Arduino

En este tutorial, aprenderá cómo funcionan los servomotores y cómo
controlarlos con Arduino. ¡He incluido diagramas de cableado y varios códigos
de ejemplo! Los servomotores se utilizan a menudo en proyectos de robótica
pero también los puedes encontrar en coches RC, aviones, etc. Son muy útiles
cuando necesitas un control de posición preciso y/o un par elevado.
En la primera parte de este artículo, veremos el funcionamiento interno de un

servo y qué tipo de señal de control utiliza. También explicó cuáles son las
diferencias entre un servo estándar y uno continuo. A continuación, le mostraré
cómo conectar un servomotor al Arduino.

105

Con el primer ejemplo de código, puede controlar tanto la posición como la
velocidad del servomotor. Después de eso, veremos cómo controlar un servo
con un potenciómetro y cómo puede modificar el código para controlar

múltiples servomotores al mismo tiempo. Por último, al final de este artículo,
puede encontrar las especificaciones y dimensiones de algunos de los
servomotores más populares del mercado.

Micro servo SG90 × 1 Electrogeek
Servo de alto torque MG996R × 1 Electrogeek
Cables para Protoboard × 15 Electrogeek
Potenciómetro de 10 kΩ × 1 Electrogeek
Fuente de alimentación de 5V (opcional) × 1 Electrogeek

Software
IDE Arduino

¿Cómo funciona un servomotor?
Un servo de hobby estándar generalmente consiste en un pequeño motor
eléctrico, un potenciómetro, electrónica de control y una caja de cambios. La
posición del eje de salida se mide constantemente mediante el potenciómetro
interno y se compara con la posición objetivo establecida por el controlador

106
( por ejemplo, el Arduino).Según el error, la electrónica de control ajusta la
posición real del eje de salida para que coincida con la posición objetivo. Esto
se conoce como sistema de control de circuito cerrado.

Esquema de un servomotor RC (Hwang et al.2018)

La caja de engranajes disminuye la velocidad del motor, lo que aumenta el par
en el eje de salida. La velocidad máxima del eje de salida suele ser de alrededor
de 60 RPM.

Control de servo

Los servomotores se controlan enviando una señal PWM ( modulación de
ancho de pulso) a la línea de señal del servo. El ancho de los pulsos determina
la posición del eje de salida. Cuando envía al servo una señal con un ancho de
pulso de 1,5 milisegundos ( ms), el servo se moverá a la posición neutral (90
grados). La posición mínima (0 grados) y máxima (180 grados) normalmente
corresponden a un ancho de pulso de 1 ms y 2 ms respectivamente. Tenga en
cuenta que esto puede variar ligeramente entre diferentes tipos y marcas de
servomotores. Muchos servos solo giran unos 170 grados (o incluso solo 90),
pero la posición media casi siempre es de 1,5 ms.

107

Los servomotores generalmente esperan un pulso cada 20 milisegundos o 50
Hz, pero muchos servos RC funcionan bien en un rango de 40 a 200 Hz.

Servo de 360 grados (continuo) frente a 180
grados (estándar)
La mayoría de los servos RC son de la variedad de 180 grados, lo que significa
que solo pueden girar en un rango de 0 a 180 grados. Sin embargo, también
está disponible la rotación continua, también conocida como servomotores de
360 grados.
Los servos de rotación continua reaccionan de manera diferente a la señal de
control que los servos estándar de 180 grados. Con un servo de rotación
continua, no puede controlar la posición exacta del eje de salida, solo la
velocidad y la dirección . Un pulso de 1 ms establecerá la velocidad del
servomotor a máxima velocidad en una dirección y un pulso de 2 ms a máxima
velocidad en la otra. Un valor cercano a 1,5 ms permite que el motor se
detenga.
Si su servo se comporta de una manera inesperada, es posible que esté
usando un servo continuo en lugar de uno estándar.

108

TowerPro SG90-HV Servo digital continuo de 360 ° 9g (izquierda) vs TowerPro SG90 Micro
Servo Digital 9g (derecha). Observe que se ven casi idénticos por fuera.

¿Cómo conectar un servomotor al Arduino?

El cableado de un servomotor es muy fácil porque solo necesita conectar tres
cables: alimentación, tierra y señal. El cable de alimentación suele ser rojo y
debe conectarse a 5 V.
Un micro servo como el SG90 consume alrededor de 10 mA cuando está

inactivo y 100-250 mA cuando gira, por lo que puede alimentarlo directamente
con la salida de 5V del Arduino. Sin embargo, debe tener cuidado al utilizar
varios o más grandes servomotores. Si sus motores consumen más de 300
mA, debe usar una fuente de alimentación externa para evitar dañar el
Arduino. Consulte el esquema a continuación para utilizar fuentes de
alimentación externas.
El cable de tierra suele ser negro o marrón y debe conectarse al pin de tierra
del Arduino. Cuando utilice una fuente de alimentación separada, conecte el
cable de tierra tanto al Arduino como a la tierra de la fuente de alimentación.
El cable de señal suele ser amarillo, naranja o blanco y se puede conectar a

cualquiera de los pines digitales del Arduino. En este caso, lo conecté al pin
digital 9.

109

Servomotor con diagrama de cableado Arduino Uno.

Conexiones del servomotor

Servo motor Arduino
VCC ( rojo) 5 V
GND ( negro o marrón) GND
Señal (amarilla, naranja o blanca) Pin 9

Como mencioné antes, si está usando servomotores grandes o múltiples, debe
usar una fuente de alimentación externa. Simplemente conecte la fuente de
alimentación como se muestra en el diagrama de cableado a continuación.
Asegúrese de conectar el pin GND del Arduino y la fuente de alimentación
juntos.
También puede usar esta configuración si su servomotor requiere un voltaje
diferente al que el Arduino puede proporcionar, por ejemplo, 6 V o más.

110

Servomotor alimentado con fuente de alimentación externa.

Servomotor con conexiones de alimentación
externa

Servo motor Conexión
VCC ( rojo) Fuente de alimentación de 5 V
GND ( negro o marrón) Tierra de la fuente de alimentación y

Arduino GND
Señal (amarilla, naranja o blanca) Pin 9 Arduino

Servomotor con código de ejemplo Arduino

Para controlar el servomotor usaremos la biblioteca Servo.h que viene
preinstalada con el IDE de Arduino. Con el código de ejemplo a continuación,
puede controlar la posición exacta del servomotor y también incluye un código
para mover el brazo del servo hacia adelante y hacia atrás automáticamente.
Puede cargar el código de ejemplo en su Arduino a través del IDE de Arduino.

A continuación, explicaré cómo funciona el código.

111
// Include the servo library:

#include <Servo.h>
// Create a new servo object:

Servo myservo;
// Define the servo pin:

#define servoPin 9
// Create a variable to store the servo position:

int angle = 0;
void setup() {
// Attach the Servo variable to a pin:
myservo.attach(servoPin);
}
void loop() {
// Tell the servo to go to a particular angle:
myservo.write(90);
delay(1000);
myservo.write(180);
delay(1000);
myservo.write(0);
delay(1000);
// Sweep from 0 to 180 degrees:

for (angle = 0; angle <= 180; angle += 1) {
myservo.write(angle);
delay(15);
}
// And back from 180 to 0 degrees:

for (angle = 180; angle >= 0; angle -= 1) {
delay(30);
}
delay(1000);
}

112


El primer paso es incluir la biblioteca Arduino requerida. También puede
encontrar esta biblioteca en Sketch> Incluir biblioteca> Servo.

// Include the servo library:
#include <Servo.h>

A continuación, debe crear un nuevo objeto de la clase Servo. En este caso,
llamé al servo 'myservo' pero también puedes usar otros nombres. Tenga en
cuenta que también tendrá que cambiar el nombre del servo en el resto del
código.
// Create a new servo object:

Servo myservo;

Después de eso, define a qué pin Arduino está conectado el servomotor.

// Definir el pin del servo:
#define servoPin 9
La declaración #define se usa para dar un nombre a un valor constante. El

definido cuando se compile el programa. Entonces, en cualquier lugar que
menciona servoPin, el compilador lo reemplazará con el valor 9 cuando se
La variable angle se utiliza para almacenar la posición actual del servo en
grados.

// Crea una variable para almacenar la posición del servo:
int angle = 0;

En la sección de configuración del código, vinculamos el objeto servo que
creamos al pin que controlará el servo. La función attach() también tiene dos
parámetros opcionales, se verá más adelante.

113

void setup() {
// Attach the Servo variable to a pin:
}

Ángulo/posición de control:

En la primera parte del ciclo, simplemente le decimos al servomotor que se
mueva a un ángulo particular con la función write(). Tenga en cuenta que
necesita un retardo entre los comandos para darle al servomotor algo de
tiempo para moverse a la posición establecida.

// Dile al servo que vaya a un ángulo particular:
myservo.write(90);
delay(1000);
myservo.write(180);
delay(1000);
myservo.write(0);
delay(1000);

Control de velocidad:

En la última parte del código, utilicé dos bucles for para mover el servomotor
hacia adelante y hacia atrás. Este fragmento de código también puede resultar
útil si desea controlar la velocidad del servomotor. Al cambiar el valor de
retardo al final del bucle for, puede ajustar la velocidad del brazo del servo.

114
// Barrido de 0 a 180 grados:

for (angle = 0; angle <= 180; angle += 1) {
delay(15);
}
// Y de vuelta de 180 a 0 grados:
for (angle = 180; angle >= 0; angle -= 1) {
delay(30);
}

Por qué mi servo no gira de 0 a 180 grados?

Como comenté en la introducción, el ángulo del eje de salida del servomotor
está determinado por el ancho del pulso eléctrico que se aplica al cable de
control. Generalmente, un ancho de pulso de aproximadamente 1 ms
( milisegundo) corresponde a la posición mínima, 2 ms a la posición máxima y
1,5 ms a 90 ° ( posición neutra). Sin embargo, esto puede variar ligeramente
entre marcas e incluso diferentes servos de la misma marca. Esto significa que
tendrá que ajustar los valores mínimo y máximo en el código para que coincida
con el servo que está utilizando.
La biblioteca Arduino Servo hace que sea muy fácil ajustar el ángulo mínimo y
máximo del servomotor especificando dos parámetros opcionales en la función
attach(). En esta función, el primer parámetro es el número de pin al que está
conectado el servo. El segundo parámetro es el ancho de pulso, en
microsegundos ( μs), correspondiente al ángulo mínimo (0 grados) del
servomotor. El tercer parámetro es el ancho de pulso, en microsegundos,
correspondiente al ángulo máximo (180 grados) del servomotor.
De forma predeterminada, el ancho de pulso mínimo y máximo se establece en
544 y 2400 microsegundos. Estos valores funcionan para la mayoría de los
servos comunes, pero a veces es necesario ajustar los valores ligeramente.
Recomiendo ajustar los valores mínimo y máximo en pequeños incrementos
(10-20 microsegundos) para evitar dañar el servo. Si el brazo del servo alcanza
los límites físicos del motor, aumente el valor mínimo y disminuya el valor
máximo.

#define servoPin 9
int min = 480;

115
int max = 2500;

Servo myservo;
void setup() {
myservo.attach(servoPin, min, max);
}

Controlar un servomotor con un
potenciometro y Arduino

Diagrama de cableado para controlar un servomotor con potenciometro y Arduino.

Controlar la posición de un servomotor con un potenciómetro es muy fácil y
puede ser muy útil si desea ajustar la posición del motor a mano. Como puede
ver en el diagrama de cableado anterior, el servomotor está cableado de la
misma manera que antes. La única diferencia es que utilicé una placa para
distribuir la energía del Arduino.
El potenciómetro tiene tres pines, conecte los pines exteriores a 5V y GND. El
pin central del potenciómetro está conectado al pin analógico A0 del Arduino.

Servomotor con potenciómetro Código de
ejemplo de Arduino

El código de ejemplo a continuación le permite controlar un servomotor con un
potenciómetro.

116
#include <Servo.h> // incluye la biblioteca Arduino requerida

#define servoPin 9 // Pin Arduino para el servo
#define potPin A0 // Pin Arduino para el potenciómetro
int angle = 0; // variable para almacenar la posición del

servo en grados
int reading = 0; // variable para almacenar la lectura de la
entrada analógica
Servo myservo; // crea un nuevo objeto de la clase servo
void setup() {
}
void loop() {
reading = analogRead(potPin); // lee la entrada analógica
angle = map(reading, 0, 1023, 0, 180); // mapea la entrada a
un valor entre 0 y 180 grados
myservo.write(angle); // le dice al servo que vaya a la
posición establecida
delay(15); // esperar 15 ms para que el servo alcance la
posición
}

Observe que antes de la sección de configuración y bucle del código reading
se agrega una nueva variable y se define el pin de entrada del potenciómetro.
En la sección de bucle del código, leemos el valor del pin analógico A0 con la
función analogRead().
reading = analogRead(potPin); // lee la entrada analógica

Las placas Arduino contienen un convertidor de analógico a digital (ADC) de
10 bits, por lo que este nos da un valor entre 0 y 1023 dependiendo de la
posición del potenciómetro.

117

Debido a que el servomotor solo puede girar entre 0 y 180 grados,
necesitamos reducir los valores con la función map () . Esta función vuelve a
mapear un número de un rango a otro.

angle = map(reading, 0, 1023, 0, 180); // mapea la entrada a
un valor entre 0 y 180 grados
Por último, escribimos el ángulo del servomotor:
myservo.write(angle); // le dice al servo que vaya a la

posición establecida
delay(15); // esperar 15 ms para que el servo alcance la
posición

Controlar varios servomotores

Controlar varios servos es tan fácil como controlar solo uno, pero a menudo
recibo preguntas sobre cómo modificar el código. Por lo tanto, he agregado un
ejemplo simple a continuación.

Múltiples servomotores conectados al Arduino Uno y una fuente de alimentación externa.

118

Tenga en cuenta que tendrá que usar una fuente de alimentación externa para
alimentar los servos porque el Arduino no puede proporcionar suficiente
corriente para alimentar todos los motores.
Para este ejemplo, solo usamos más pines Arduino para los servos adicionales.
Sin embargo, esto significa que está limitado a 12 servos cuando usa un
Arduino Uno, y es posible que no le queden suficientes pines para otros
componentes.
Otra opción es utilizar uno o varios controladores PWM/servo PCA9685 . Este

controlador le permite controlar 16 servos con solo 2 pines del Arduino usando
I2C.
Controladores de servo/PWM PCA9685

Debido a que la configuración de estos servocontroladores es un poco más
difícil, cubriré esto en un tutorial separado.

Arduino con código de ejemplo de múltiples
servos

Como puede ver en el siguiente ejemplo, solo tiene que crear más objetos de la
clase Servo con diferentes nombres. Puede direccionar cada servo utilizando el
nombre correcto en la sección de configuración y bucle del código.
#include <Servo.h>
Servo servo1;

119
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;
void setup()
{
servo1.attach(9);
servo2.attach(10);
servo3.attach(11);
servo4.attach(12);
servo5.attach(13);
}
void loop()
{
servo1.write(0);
servo2.write(0);
servo3.write(0);
servo4.write(0);
servo5.write(0);
delay(2000);
servo1.write(90);
servo2.write(90);
servo3.write(90);
servo4.write(90);
servo5.write(90);
delay(1000);
servo1.write(180);
servo2.write(180);
servo3.write(180);
servo4.write(180);
servo5.write(180);
delay(1000);
}

120

Especificaciones del servomotor

A continuación puede encontrar las especificaciones de algunos de los
servomotores más populares del mercado. El fabricante original de estos
servomotores es Tower Pro Pte Ltd. pero también se pueden comprar modelos
similares de muchos otros proveedores.

Micro servo analógico SG90

[Fuente: towerpro.com.tw ]

Pinout

Marrón GND
Rojo VCC
Amarillo Señal (PWM)

Especificaciones

Tensión de funcionamiento 4,8 V

121
Peso 9 g
Par de bloqueo 1,8 kg/cm (4,8 V)
Tipo de engranaje Juego de engranajes POM
Velocidad de operación 0,12 segundos/60 ° (4,8 V)
Temperatura de funcionamiento 0 - 55 ° C

Dimensiones

A 34,5 milímetros
B 22,8 milímetros
C 26,7 milímetros
D 12,6 milímetros
E 32,5 milímetros
F 16 mm

122

Servo micro digital MG90S


Pinout

Marrón GND
Rojo VCC

123

Especificaciones

Tensión de funcionamiento 4,8 V
Peso 13,4 g
Par de bloqueo 1,8 kg/cm (4,8 V), 2,2 kg/cm (6,6 V)
Tipo de engranaje Aluminio 6061-T6
Velocidad de operación 0,10 segundos/60 ° (4,8 V), 0,08

segundos/60 ° (6,0 V)

Dimensiones

A 32,5 milímetros
B 22,8 milímetros
C 28,4 milímetros
D 12,4 milímetros
E 32,1 milímetros
F 18,5 milímetros

124

Servo digital de alto par MG996R


Pinout

Marrón GND
Rojo VCC

125

Especificaciones

Tensión de funcionamiento 4,8 - 6,6 V
Consumo de corriente en reposo 10 mA
Consumo de corriente de 170 mA

funcionamiento sin carga
Detener el consumo de corriente 1400 mA
Peso 55 g
Par de bloqueo 9,4 kg/cm (4,8 V), 11 kg/cm (6,0 V)
Tipo de engranaje Engranaje de metal
Velocidad de operación 0,19 segundos/60 ° (4,8 V), 0,15

segundos/60 ° (6,0 V)

Dimensiones

A 42,7 milímetros
B 40,9 milímetros
C 37 mm
D 20 mm
E 54 mm
F 26,8 milímetros

126

127

Cómo controlar un

motor paso a paso con
controlador A4988 y
Arduino

Este artículo incluye todo lo que necesita saber sobre el control de un motor
paso a paso con el controlador de motor paso a paso A4988 y Arduino. He
incluido un diagrama de cableado, un tutorial sobre cómo establecer el límite
de corriente y muchos códigos de ejemplo.
Aunque puede usar este controlador sin una biblioteca Arduino, le recomiendo
que también eche un vistazo al código de ejemplo para la biblioteca
AccelStepper al final de este tutorial. Esta biblioteca es bastante fácil de usar
y puede mejorar enormemente el rendimiento de su hardware.

128

Después de cada ejemplo, desgloso y explico cómo funciona el código, por lo
que no debería tener problemas para modificarlo para adaptarlo a sus
necesidades.

Controlador de motor paso a paso

× 1 Electrogeek
A4988
Motor paso a paso NEMA 17 × 1 Electrogeek
Fuente de alimentación (8-35 V) × 1 Electrogeek
Condensador (100 µF) × 1 Electrogeek

Me gusta usar este controlador en combinación con un Shield CNC . Dicho
Shield ya incluye condensadores y ofrece una manera fácil de seleccionar la
resolución de micropasos. Hace que el cableado sea mucho más fácil y es una
excelente opción si necesita una solución más permanente que una placa de
pruebas.

129

Herramientas

Destornillador pequeño Electrogeek
Multímetro Electrogeek
Cables de prueba de cocodrilo (opcional) Electrogeek

Software
IDE Arduino

Sobre el Driver

En el corazón del controlador A4988 encontrará un chip fabricado por Allegro
MicroSystems: el controlador de micropasos DMOS A4988 con traductor y
protección contra sobrecorriente. Este controlador de motor integrado hace
que la interfaz con un microcontrolador sea muy fácil, ya que solo necesita dos
pines para controlar tanto la velocidad como la dirección del motor paso a
paso.
El controlador tiene una capacidad de salida máxima de 35 V y ± 2 A, lo que es
ideal para impulsar motores paso a paso de tamaño pequeño a mediano, como
un motor paso a paso bipolar NEMA 17 .
El chip controlador A4988 tiene varias funciones de seguridad integradas,

como sobrecorriente, cortocircuito, bloqueo de bajo voltaje y protección contra
sobrecalentamiento. Puede encontrar más especificaciones en la siguiente
tabla

130

Especificaciones de A4988

Voltaje mínimo de funcionamiento 8 V
Voltaje de funcionamiento máximo 35 V
Corriente continua por fase 1 A
Corriente máxima por fase 2 A
Voltaje lógico mínimo 3 V
Voltaje lógico máximo 5,5 V
Resolución de micropasos completo, 1/2, 1/4, 1/8 y 1/16
¿Protección de voltaje inverso? No
Dimensiones 15,5x20,5 mm (0,6 ″x0,8 ″)

Diferencias entre A4988 y DRV8825

El DRV8825 es bastante similar al A4988, pero existen algunas diferencias
clave:
● El DRV8825 ofrece micropasos de 1/32, mientras que el A4988 solo

baja a 1/16 de paso. Los micropasos más altos dan como resultado un
funcionamiento más suave y silencioso, pero no siempre son necesarios.

● El potenciómetro de límite de corriente está en una ubicación diferente

● La relación entre el voltaje de referencia y el límite de corriente es
diferente.

● El DRV8825 requiere una duración mínima de pulso STEP de 1,9 µs; el
A4988 requiere un mínimo de 1 µs.

131

● El DRV8825 se puede utilizar con una fuente de alimentación de motor
de mayor voltaje (45 V frente a 35 V). Esto significa que es menos
susceptible a daños por picos de voltaje LC.

● El DRV8825 puede entregar un poco más de corriente que el A4988 sin
ningún enfriamiento adicional.

Tenga en cuenta que el pinout del DRV8825 es exactamente el mismo que el
del A4988, por lo que se puede usar como reemplazo directo.

A4899 (izquierda) vs DRV8825 (derecha)

Configuración de microstep

Los motores paso a paso suelen tener un tamaño de paso de 1.8 ° o 200 pasos
por revolución, esto se refiere a pasos completos. Un controlador de
micropasos como el A4988 permite resoluciones más altas al permitir
ubicaciones de pasos intermedios. Esto se logra energizando las bobinas con
niveles de corriente intermedios.
Por ejemplo, conducir un motor en modo de cuarto de paso le dará al motor de
200 pasos por revolución 800 micropasos por revolución usando cuatro niveles
de corriente diferentes.

132

Pinout A4988

Los pines selectores de resolución (tamaño de paso) (MS1, MS2 y MS3) le
permiten seleccionar una de las resoluciones de cinco pasos de acuerdo con la
tabla siguiente.

MS1 MS2 MS3 Resolución de micropasos
Bajo Bajo Bajo Paso completo
Alto Bajo Bajo 1/2 paso
Bajo Alto Bajo 1/4 paso
Alto Alto Bajo 1/8 paso
Alto Alto Alto 1/16 paso

Las tres entradas tienen resistencias desplegables internas de 100 kΩ, por lo
que dejar los tres pines de selección de micropasos desconectados da como
resultado el modo de paso completo.

133

Cableado: conexión de A4988 a Arduino y
motor paso a paso

Diagrama de cableado/esquema para el controlador de motor paso a paso A4988 con Arduino y
motor paso a paso.

El diagrama de cableado/esquema anterior muestra cómo conectar el
controlador A4988 a un motor paso a paso y al Arduino.
Conexiones A4988

A4988 Conexión
VMOT 8-35V
GND Tierra del motor
SLP REINICIAR
RST SLP

134
VDD 5V
GND Tierra lógica
STP Pin 3
DIR Pin 2
1A, 1B, 2A, 2B Motor paso a paso

● La fuente de alimentación del motor está conectada a GND y VMOT
(arriba a la derecha).

● Las dos bobinas del motor paso a paso están conectadas a 1A, 1B y 2A,
2B (ver más abajo).

● El pin GND (abajo a la derecha) está conectado al pin de tierra del
microcontrolador y VDD está conectado a 5V.

● El pin STP ( paso) y DIR (dirección) están conectados al pin digital 3 y 2
respectivamente. Puede elegir un pin digital diferente si lo desea, pero
estos son los que usé para este tutorial y el código de ejemplo.

● El pin SLP es una entrada baja activa. Es decir, bajar este pin pone al
conductor en modo de suspensión, minimizando el consumo de energía.
RST también es una entrada baja activa. Cuando se baja, todas las
entradas de PASO se ignoran hasta que se tira hacia arriba. Si no está
utilizando el pin, puede conectarlo al pin SLP/SLEEP adyacente para
elevarlo y habilitar el controlador.

● El pin EN (habilitar) se puede dejar desconectado, está bajado por
defecto. Cuando este pin está alto, el controlador está desactivado.

En el resto de este tutorial, dejé MS1, MS2 y MS3 desconectados , por lo que
el controlador funciona en modo de paso completo. Esto facilita un poco la
explicación del código. Normalmente, usaría micropasos de 1/8 o 1/16 y
conectaría los pines apropiados a 5V (consulte la tabla en la introducción).

135

Advertencia

La placa portadora A4988 utiliza condensadores cerámicos de baja ESR, lo
que la hace susceptible a picos de voltaje LC destructivos, especialmente
cuando se utilizan cables de alimentación de más de unas pocas pulgadas.
Para proteger el controlador, puede conectar un condensador electrolítico entre

VMOT y GND. Pololu sugiere un capacitor de 47 µF o más (yo usé un capacitor
de 100 µF).

¿Cómo determinar el cableado correcto del
motor paso a paso?

Si no puede encontrar la hoja de datos de su motor paso a paso, puede ser
difícil averiguar cómo cablear su motor correctamente. Utilizó el siguiente truco
para determinar cómo conectar motores paso a paso bipolares de 4 cables:
Lo único que necesita identificar son los dos pares de cables que están
conectados a las dos bobinas del motor. Los cables de una bobina se conectan
a 1A y 1B y el otro a 2A y 2B, la polaridad no importa.
Para encontrar los dos cables de una bobina, haga lo siguiente con el motor
desconectado:
1. Intente hacer girar el eje del motor paso a paso con la mano y observe lo
difícil que es girar.
2. Ahora elija un par de cables al azar del motor y junte los extremos
desnudos.
3. A continuación, intente hacer girar el eje del motor paso a paso
nuevamente.

Si siente mucha resistencia, ha encontrado un par de cables de la misma
bobina. Si puede girar el eje libremente, pruebe con otro par de cables. Ahora
conecte las dos bobinas a los pines que se muestran en el diagrama de
cableado anterior.

136

¿Cómo establecer el límite de corriente?

Antes de comenzar a programar su Arduino y comenzar a usar el controlador,
hay una cosa muy importante que debe hacer y que mucha gente olvida :
¡establecer el límite de la corriente!
Este paso no es muy complicado pero absolutamente necesario para proteger

su motor paso a paso y el controlador. Si no establece un límite de corriente
apropiado, su motor puede consumir más corriente de la que puede manejar su
controlador, es probable que esto dañe uno o ambos.
Para establecer el límite de corriente, debe medir un voltaje de referencia y

ajustar el potenciómetro integrado en consecuencia. Necesitará un
destornillador pequeño , un multímetro para medir el voltaje de referencia y
cables de prueba de cocodrilo (opcional pero muy útil).

Diagrama de cableado de límite de corriente para el controlador A4988.

137

Para medir el voltaje de referencia, el controlador debe estar encendido. El
A4988 solo necesita energía a través de VDD (5V) y necesita conectar RST y
SLP juntos; de lo contrario, el controlador no se encenderá. Es mejor
desconectar el motor paso a paso mientras hace esto.
Si ya ha conectado el controlador, puede dejarlo todo menos el motor paso a
paso conectado. Puede aplicar energía a través del puerto USB del Arduino.

A4988 Conexión
VDD 5V
RST SLP
SLP REINICIAR
GND GND

Fórmula de límite actual

El siguiente paso es calcular el límite actual con la siguiente fórmula:
Límite de corriente = Vref ÷ (8xRcs)
El Rcs es la resistencia del sentido actual. Si compro un controlador A4988 de

Pololu antes de enero de 2017, el Rcs será de 0.050 Ω . Los controladores
vendidos después de eso tienen resistencias de detección de corriente de
0.068 Ω .
Entonces, esto significa que para un límite de corriente de 1A para una placa
con resistencias de detección de corriente de 0.068 Ω, el Vref debe ser de 540
mV.

138

Ubicaciones de la resistencia de detección actual. Imagen: www.pololu.com

Para seleccionar el límite de corriente correcto, eche un vistazo a la hoja de
datos de su motor paso a paso. Si no puede encontrar la clasificación actual de
su motor, le recomiendo comenzar con un límite de corriente de 1A. Siempre
puede aumentarlo más tarde si a su motor/controlador le faltan pasos.
Información adicional: cuando se usa el controlador en modo de paso

completo, la corriente a través de cada bobina se limita a aproximadamente el
70% del límite de corriente establecido. Esto significa que deberá establecer el
límite de corriente un 40% más alto o 1,4 A en el modo de paso completo. Al
usar micropasos, se aplica la fórmula anterior.
Tenga en cuenta que debe volver a calibrar el límite de corriente si cambia el
voltaje de la fuente de alimentación del motor. Si su motor hace mucho ruido,
intente reducir el límite de corriente. Es mejor establecer el límite de corriente
lo suficientemente alto para que el motor no pierda pasos.
Midiendo Vref

Ahora deberá medir el voltaje de referencia (Vref) entre los dos puntos
marcados en la imagen de abajo (GND y el potenciómetro) y ajustarlo al valor
que calculó.

139

Puntos de sonda Vref (GND y potenciómetro).

Recomiendo usar cables de prueba de cocodrilo sujetos al destornillador para
establecer el límite de corriente. Esto le permite ajustar el potenciómetro y
medir el voltaje de referencia al mismo tiempo.
Nota: Hay otra forma de medir el límite de corriente y es medir directamente el
consumo de corriente del motor paso a paso. Personalmente, el método
anterior me parece mucho más fácil.
Pololu menciona lo siguiente en su sitio web:

Nota: La corriente de la bobina puede ser muy diferente de la corriente de la
fuente de alimentación, por lo que no debe utilizar la corriente medida en la
fuente de alimentación para establecer el límite de corriente. El lugar apropiado
para colocar su medidor de corriente es en serie con una de las bobinas de su
motor paso a paso.
Preguntas frecuentes sobre el límite actual

¿Necesito tener el motor paso a paso conectado o no?
No, no es necesario que conecte el motor paso a paso al controlador al

configurar el límite de corriente. Para estar seguro, desconecte su motor, a
veces interfiere con la medición del voltaje Vref.

140

¿Necesito encender el motor ejecutando el boceto del motor Arduino?

No, consulte la pregunta anterior.
¿Necesito girar el potenciómetro en el sentido de las agujas del reloj o en el

sentido contrario a las agujas del reloj para aumentar Vref?
Depende del fabricante del controlador. Si tiene una placa de ruptura Polulu
genuina del DRV8825 o A4988, gire el potenciómetro en el sentido de las
agujas del reloj para subir Vref y en el sentido contrario a las agujas del reloj
para bajarlo.

Enfriando al Driver A4988

El controlador IC A4988 tiene una clasificación de corriente máxima de 2 A por
bobina, pero sin un disipador de calor sólo puede suministrar alrededor de 1 A
por bobina antes de que comience a sobrecalentarse.
El controlador generalmente viene con un pequeño disipador de calor con

respaldo adhesivo, que le recomiendo que lo instale de inmediato.

Código de ejemplo básico de Arduino para
controlar un motor paso a paso

Ahora que ha conectado el controlador y establecido el límite actual, es hora de
conectar el Arduino a la computadora y cargar algún código. Puede cargar el
siguiente código de ejemplo en su Arduino usando el IDE de Arduino . Para
este ejemplo específico, no es necesario instalar ninguna biblioteca.
Este sketch controla tanto la velocidad, el número de revoluciones y la dirección

de giro del motor paso a paso.
// Define stepper motor connections and steps per revolution:

#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200
void setup() {

141
// Declare pins as output:

pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:

for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
digitalWrite(stepPin, LOW);
}
delay(1000);
// Set the spinning direction counterclockwise:

digitalWrite(dirPin, LOW);
// Spin the stepper motor 1 revolution quickly:

for (int i = 0; i < stepsPerRevolution; i++) {
}
delay(1000);


142
// Spin the stepper motor 5 revolutions fast:

for (int i = 0; i < 5 * stepsPerRevolution; i++) {
}
delay(1000);
// Set the spinning direction counterclockwise:

digitalWrite(dirPin, LOW);
//Spin the stepper motor 5 revolutions fast:

for (int i = 0; i < 5 * stepsPerRevolution; i++) {
}
delay(1000);
}


El Sketch comienza con la definición de los pines de paso y dirección. Los
conecté al pin 3 y 2 de Arduino.


143
menciona dirPin, el compilador lo reemplazará con el valor 2 cuando se
También definí una stepsPerRevolution constante. Cómo configuré el

controlador en el modo de paso completo, lo configuré en 200 pasos por
revolución. Cambie este valor si su configuración es diferente.
// Define stepper motor connections and steps per revolution:

#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200

En la setup() sección del código, todos los pines de control del motor se
declaran como SALIDA digital con la función pinMode().

void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}

En la sección loop()del código, dejamos que el motor gire una revolución
lentamente en la dirección CW y una revolución rápidamente en la dirección
CCW. A continuación, dejamos que el motor gire 5 revoluciones en cada
dirección a alta velocidad. Entonces, ¿cómo controlas la velocidad, la dirección
de giro y el número de revoluciones?

// Spin the stepper motor 1 revolution slowly:

for(int i = 0; i < stepsPerRevolution; i++)
{
}

144

Control de la dirección de giro:

Para controlar la dirección de giro del motor paso a paso, establecemos el pin
DIR (dirección) en ALTO o BAJO. Para esto usamos la función
digitalWrite(). Dependiendo de cómo conectó el motor paso a paso,
establecer el pin DIR alto permitirá que el motor gire en CW o CCW.

Número de control de pasos o revoluciones:

En este boceto de ejemplo, los bucles for controlan el número de pasos que
dará el motor paso a paso. El código dentro del bucle for da como resultado 1
paso del motor paso a paso. Debido a que el código en el ciclo se ejecuta 200
veces (stepsPerRevolution), esto da como resultado 1 revolución. En los dos
últimos bucles, el código dentro del bucle for se ejecuta 1000 veces, lo que da
como resultado 1000 pasos o 5 revoluciones.
Tenga en cuenta que puede cambiar el segundo término en el ciclo for a la
cantidad de pasos que desee. for(int i = 0; i < 100; i++) daría
como resultado 100 pasos, o media revolución.

Control de velocidad:

La velocidad del motor paso a paso está determinada por la frecuencia de los
pulsos que enviamos al pin STEP. Cuanto mayor sea la frecuencia, más rápido
funciona el motor. Puede controlar la frecuencia de los pulsos cambiando
delayMicroseconds() el código. Cuanto menor sea la demora, mayor será
la frecuencia y más rápido funcionará el motor.
Tutorial de la biblioteca AccelStepper

La biblioteca AccelStepper escrita por Mike McCauley es una biblioteca
increíble para usar en su proyecto. Una de las ventajas es que admite
aceleración y desaceleración, pero también tiene muchas otras funciones
interesantes.
Puede descargar la última versión de esta biblioteca aquí o hacer clic en el
botón de abajo.

🔗 AccelStepper-1.59.zip

145

biblioteca .ZIP… en el IDE de Arduino.
Otra opción es navegar a Herramientas> Administrar bibliotecas… o escribir


Puede buscar 'accelstepper' y buscar la biblioteca de Mike McCauley.
Seleccione la última versión y luego haga clic en Instalar.

146

Código de ejemplo de rotación continua
El siguiente esquema se puede utilizar para hacer funcionar uno o más motores
paso a paso de forma continua a una velocidad constante. (No se utiliza
aceleración y desaceleración).
// Include the AccelStepper library:

#include <AccelStepper.h>
// Define stepper motor connections and motor interface type.

Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1
// Create a new instance of the AccelStepper class:

AccelStepper stepper = AccelStepper(motorInterfaceType,
stepPin, dirPin);
void setup() {

147
// Set the maximum speed in steps per second:

stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed in steps per second:
stepper.setSpeed(400);
// Step the motor with a constant speed as set by
setSpeed():
stepper.runSpeed();
}


El primer paso es incluir la biblioteca con #include <AccelStepper.h>.


El siguiente paso es definir las conexiones A4988 a Arduino y el tipo de
interfaz del motor. El tipo de interfaz del motor debe establecerse en 1 cuando
se utiliza un controlador de paso y dirección. Puede encontrar los otros tipos de
interfaz aquí .

menciona dirPin, el compilador lo reemplazará con el valor 2 cuando se

#define dirPin 2
#define stepPin 3

A continuación, debe crear una nueva instancia de la clase AccelStepper con el
tipo de interfaz de motor y las conexiones adecuadas.

148

En este caso, llamé al motor paso a paso 'paso a paso' pero se puede usar
otros nombres, como 'z_motor' o 'liftmotor' etc AccelStepper liftmotor
= AccelStepper(motorInterfaceType, stepPin, dirPin);.
El nombre que le dé al motor paso a paso se utilizará más adelante para

establecer la velocidad, la posición y la aceleración de ese motor en particular.
Puede crear varias instancias de la clase AccelStepper con diferentes nombres
y pines. Esto le permite controlar fácilmente 2 o más motores paso a paso al
mismo tiempo.

stepPin, dirPin);

En la setup() sección del código definimos la velocidad máxima en
pasos/segundo. Las velocidades de más de 1000 pasos por segundo pueden
no ser confiables, así que establecer esto como el máximo. Tenga en cuenta
que especificar el nombre del motor paso a paso ('paso a paso'), para el cual
quiero definir la velocidad máxima. Si tiene varios motores paso a paso
conectados, puede especificar una velocidad diferente para cada motor:

void setup() {
stepper2.setMaxSpeed(500);
}

En el loop() primero establecemos la velocidad a la que queremos que
funcione el motor. Para ello usamos la función setSpeed(). (también puede
colocar esto en la sección de configuración del código).
stepper.runSpeed() sondea el motor y cuando vence un paso, ejecuta 1

paso. Esto depende de la velocidad establecida y del tiempo transcurrido
desde el último paso. Si desea cambiar la dirección del motor, puede establecer
una velocidad negativa: stepper.setSpeed(-400); gira el motor hacia el
otro lado.
void loop() {
// Set the speed in steps per second:

149
// Step the motor with a constant speed as set by
setSpeed():
stepper.runSpeed();
}

Código de ejemplo para controlar el número
de pasos o revoluciones
Para dejar que el motor gire un número específico de pasos, prefiero usar un
bucle while en combinación con stepper.currentPosition(). Puede
utilizar el siguiente código de ejemplo para dejar que el motor funcione de un
lado a otro.

// Define stepper motor connections and motor interface type.

Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3

stepPin, dirPin);
void setup() {
}
void loop() {
// Set the current position to 0:
stepper.setCurrentPosition(0);

150
// Run the motor forward at 200 steps/second until the motor

reaches 400 steps (2 revolutions):
while(stepper.currentPosition() != 400)
{
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:

// Run the motor backwards at 600 steps/second until the

motor reaches -200 steps (1 revolution):
while(stepper.currentPosition() != -200)
{
stepper.setSpeed(-600);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:


reaches 600 steps (3 revolutions):
{
stepper.runSpeed();
}
delay(3000);
}

151


La primera parte del código hasta la sección loop () es exactamente la misma
que en el ejemplo anterior.
En el bucle utilizó un bucle while en combinación con la currentPosition()

función. Primero, configuro la posición actual del motor paso a paso a cero con
stepper.setCurrentPosition(0).
// Set the current position to 0:


A continuación, hacemos uso del ciclo while. Un ciclo while se repetirá de
forma continua e infinita, hasta que la expresión dentro del paréntesis, () se
vuelva falsa. Entonces, en este caso, verifico si la posición actual del motor
paso a paso no es igual a 400 pasos (! = Significa: no es igual a). Si bien este
no es el caso, hacemos funcionar el motor paso a paso a una velocidad
constante establecida por setSpeed().

// reaches 400 steps (2 revolutions):
{
stepper.runSpeed();
}

En el resto del bucle, hacemos exactamente lo mismo, solo que con una
velocidad y una posición objetivo diferentes.

Código de ejemplo de aceleración y
desaceleración

Con el siguiente boceto, puede agregar aceleración y desaceleración a los
movimientos del motor paso a paso, sin ninguna codificación complicada. En el
siguiente ejemplo, el motor funcionará hacia adelante y hacia atrás con una

152
velocidad de 200 pasos por segundo y una aceleración de 30 pasos por
segundo por segundo.

// Define stepper motor connections and motor interface
#define dirPin 2
#define stepPin 3

stepPin, dirPin);
void setup() {
// Set the maximum speed and acceleration:
stepper.setAcceleration(30);
}
void loop() {
// Set the target position:
stepper.moveTo(600);
// Run to target position with set speed and
acceleration/deceleration:
stepper.runToPosition();
delay(1000);
// Move back to zero:

stepper.moveTo(0);
delay(1000);
}

153

Explicación del código:

En la configuración (), además de la velocidad máxima, necesitamos definir la
aceleración/desaceleración. Para esto usamos la función
setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setAcceleration(30);
}

En la sección de bucle del código, utilicé una forma diferente de dejar que el
motor girara un número predefinido de pasos. La función
stepper.moveTo() se utiliza para establecer la posición de destino. La
función stepper.runToPostion() mueve el motor (con
aceleración/desaceleración) a la posición de destino y bloquea hasta que está
en la posición de destino. Debido a que esta función está bloqueando, no debe
usarla cuando necesite controlar otras cosas al mismo tiempo.

// Set the target position:
stepper.moveTo(600);
// Run to target position with set speed and
acceleration/deceleration:

154
La guía completa para

sensores de
temperatura digitales
DS18B20 con Arduino

Este tutorial incluye todo lo que necesita saber sobre el uso de sensores de
temperatura digitales DS18B20 de 1 cable con Arduino. He incluido diagramas
de cableado y varios códigos de ejemplo para que pueda comenzar.
Para este tutorial, usaremos DallasTemperature en combinación con la

biblioteca OneWire Arduino. Estas bibliotecas facilitan la comunicación con
uno o varios sensores. En la primera parte de este artículo, puede encontrar las
especificaciones e información sobre los diferentes tipos de sensores
DS18B20. A continuación, veremos cómo conectar el sensor al Arduino.

155

En el primer ejemplo de código, le mostraré cómo tomar lecturas de
temperatura de un solo sensor y mostrar el resultado en el monitor serial. Los
ejemplos siguientes explican cómo leer varios sensores con un solo pin
Arduino. Por último, le mostraré cómo mostrar la temperatura en una pantalla
LCD I2C .


× 3 Electrogeek
Sensor de temperatura digital DS18B20 (TO-92)
× 1 Electrogeek
Impermeable DS18B20 (alternativa)
× 1 Electrogeek
Placa de conexión DS18B20 (alternativa)
× 1 Electrogeek
Arduino Uno
× 1 Electrogeek
Protoboard
Electrogeek
Cables para Protoboard ~ 15
× 1 Electrogeek
Resistencia pull-up de 4,7 kΩ
× 1 Electrogeek
LCD I2C de 16x2 caracteres
× 1 Electrogeek
Cable USB tipo A/B
Software
IDE Arduino

156

Acerca del sensor de temperatura DS18B20
de 1 cable
El DS18B20 es un sensor de temperatura digital fabricado por Maxim
Integrated (anteriormente Dallas Semiconductor). Es uno de los sensores de
temperatura más populares del mercado y proporciona una precisión bastante
alta (± 0,5 ° C) en un amplio rango de temperatura (-55 ° C a + 125 ° C).
Debido a que el voltaje de operación del sensor es de 3.0 a 5.5 V, puede usarlo
tanto con Arduino (que opera a 5 V), como con dispositivos como ESP32 y
Raspberry Pi que tienen pines GPIO de 3.3 V.
Una de las principales ventajas de este sensor es que solo requiere un pin
digital del Arduino para la comunicación. El sensor se comunica mediante el
protocolo Dallas Semiconductor 1-Wire ® . Este protocolo funciona de manera
similar a I2C, pero con velocidades de datos más bajas y mayor alcance.
Otra ventaja es que cada sensor DS18B20 tiene un código de serie único de
64 bits, que permite que varios sensores funcionen en el mismo bus de 1
cable. Por lo tanto, puede leer datos de varios sensores que están conectados
entre sí con un solo pin Arduino (consulte los ejemplos de código a
continuación).
La resolución del sensor se puede establecer mediante programación en 9, 10,

11 o 12 bits. Esto corresponde a incrementos de temperatura de 0,5 ° C, 0,25 °
C, 0,125 ° C y 0,0635 ° C, respectivamente. La resolución predeterminada en el
encendido es de 12 bits.
Puede encontrar más especificaciones en la siguiente tabla.

Especificaciones del sensor de temperatura
digital DS18B20

Tensión de alimentación 3,0 a 5,5 V
Corriente de espera 1 μA
Corriente activa 1,5 mA

157
Rango de medición -55 ° C a + 125 ° C (-67 ° F a +257 °

F)
Precisión ± 0,5 ° C de -10 ° C a +85 ° C

(error de termómetro) ± 1 ° C de -30 ° C a +100 ° C
± 2 ° C de -55 ° C a +125 ° C
Resolución 9 bits a 12 bits ( programable)
Tiempo de conversión <750 ms ( resolución de 12 bits)
Protocolo de comunicación Protocolo de bus 1-Wire®
Paquete TO-92 de 3 clavijas
Fabricante Maxim integrado

Tipos de sensores DS18B20

El sensor generalmente viene en tres factores de forma. El tipo más común es
el paquete TO-92 de 3 pines, que se parece a un transistor.

158
Este tipo de sensor a veces se monta en una pcb que puede incluir un LED de
alimentación y la resistencia pull-up de 4,7 kΩ requerida. Siempre asegúrese
de verificar las marcas en la PCB, ya que el orden de los pines puede ser
diferente según el fabricante.

Por último, puede comprar el sensor en un estilo de sonda impermeable con un
cable ya conectado. Este estilo puede resultar útil si desea medir algo lejano,
bajo el agua o bajo tierra.

Tenga en cuenta que el cable del sensor impermeable suele estar revestido de
PVC, por lo que se recomienda mantenerlo por debajo de los 100 ° C.

159

Cableado: conexión del DS18B20 a un
Arduino

Conectar un DS18B20 al Arduino es bastante fácil ya que solo necesita
conectar 3 pines. Comience conectando el pin GND a tierra y el pin VDD a la
salida de 5V del Arduino.
A continuación, conecte el pin del medio (DQ) a cualquiera de los pines
digitales del Arduino. En este caso, utilicé el pin digital 2. También tiene que
agregar una resistencia pull-up de 4.7 kΩ entre el pin DQ y 5 V. Esto
mantendrá alto el estado inactivo del bus de 1 cable.

Sensor de temperatura digital DS18B20 con diagrama de cableado Arduino Uno

Las conexiones también se dan en la siguiente tabla.

Tenga en cuenta que el pin 1 (GND) es el pin más a la izquierda cuando el lado
plano del sensor (con el texto impreso en él) está orientado hacia usted.

160

Conexiones del sensor de temperatura
digital DS18B20

DS18B20 Arduino
Pin 1 (GND) GND
Pin 2 (DQ) Pin 2 Arduino y a través de una

resistencia de 4.7 kΩ a 5V
PIN 3 (VDD ) 5V

Un sensor DS18B20 resistente al agua se conecta de la misma manera. Sin
embargo, el color de los cables puede ser diferente según el fabricante. El cable
de tierra (GND) suele ser negro o azul, el cable de alimentación (VDD) suele ser
rojo y el cable de señal (DQ) suele ser amarillo o blanco. Le recomiendo que
consulte siempre la hoja de datos de su sensor si no está seguro.
Conexiones del sensor de temperatura

digital impermeable DS18B20

DS18B20 impermeable Arduino
Cable negro (GND) GND
Cable amarillo (DQ) Pin 2 Arduino y a través de una

resistencia de 4.7 kΩ a 5V
Cable rojo (V DD ) 5V

161

Instalación de las bibliotecas
DallasTemperature y OneWire Arduino

El protocolo de comunicación de 1 cable es algo complejo y requiere un
montón de código para analizar la comunicación. Por lo tanto, usaremos la
biblioteca DallasTemperature Arduino de Miles Burton para facilitar la
programación de estos sensores.
Esta biblioteca le permite emitir comandos simples para leer los datos de
temperatura de los sensores.
Puede encontrar el código fuente de esta biblioteca aquí en GitHub .
Para instalar la biblioteca, vaya a Herramientas> Administrar bibliotecas (Ctrl

+ Shift + I en Windows) en el IDE de Arduino . El Administrador de bibliotecas
abrirá y actualizará la lista de bibliotecas instaladas.

Puede buscar 'ds18b20' y buscar la biblioteca DallasTemperature de Miles
Burton . Seleccione la última versión y luego haga clic en Instalar.

162

La biblioteca DallasTemperature se basa en la biblioteca OneWire Arduino que
también debe instalar. Esta biblioteca se encarga del protocolo de
comunicación 1-Wire.
Busque 'onewire' y busque la biblioteca OneWire de Jim Studt .

163

Sensor de temperatura DS18B20 con código
de ejemplo Arduino

Con el siguiente código de ejemplo, puede leer la temperatura de un sensor
DS18B20 y mostrarla en el monitor en serie.
Puede cargar el código de ejemplo en su Arduino usando el IDE de Arduino .
Para copiar el código, marque el botón en la esquina superior derecha del

campo del código.
// Include the required Arduino libraries:

#include <OneWire.h>
#include <DallasTemperature.h>
// Define to which pin of the Arduino the 1-Wire bus is

connected:
#define ONE_WIRE_BUS 2
// Create a new instance of the oneWire class to communicate

with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);
// Pass the oneWire reference to DallasTemperature library:

DallasTemperature sensors(&oneWire);
void setup() {
Serial.begin(9600);
// Start up the library:
sensors.begin();
}
void loop() {
// Send the command for all devices on the bus to perform a
temperature conversion:

164
sensors.requestTemperatures();
// Fetch the temperature in degrees Celsius for device

index:
float tempC = sensors.getTempCByIndex(0); // the index 0
refers to the first device
// Fetch the temperature in degrees Fahrenheit for device
index:
float tempF = sensors.getTempFByIndex(0);
// Print the temperature in Celsius in the Serial Monitor:

Serial.print(tempC);
Serial.print(" \xC2\xB0"); // shows degree symbol
// Print the temperature in Fahrenheit

Serial.print(tempF);
// Wait 1 second:
delay(1000);
}

Debería ver la siguiente salida en el Monitor Serial (Ctrl + Shift + M).

165


Asegúrese de que la velocidad en baudios del monitor en serie también esté
configurada en 9600.


El primer paso es incluir las bibliotecas Arduino necesarias:


A continuación, definí a qué pin del Arduino está conectado el pin DQ del
sensor. La sentencia #define se puede utilizar para dar un nombre a un valor
constante. El compilador reemplazará todas las referencias a esta constante
con el valor definido cuando se compile el programa. Entonces, en cualquier
lugar que menciones ONE_WIRE_BUS, el compilador lo reemplazará con el
valor 2 cuando se compile el programa.

connected:

166

Después de esto, creé un nuevo objeto de la clase OneWire y pasé el pin DQ a
su constructor. También debe crear un objeto de la clase DallasTemperature y
pasar el objeto oneWire como parámetro.
Tenga en cuenta que llamé 'sensores' al objeto DallasTemperature, pero

también puede usar otros nombres.

En la sección de configuración del código, comenzamos la comunicación en
serie a una velocidad de 9600 baudios. Luego, inicialicé el bus con la función
begin().

void setup() {
Serial.begin(9600);
sensors.begin();
}

En la sección de bucle del código, comenzamos con el comando para que
todos los sensores del bus inicien una conversión de temperatura.


A continuación, utilicé las funciones getTempCByIndex(deviceIndex)y
getTempFByIndex(deviceIndex)para obtener la temperatura en grados
Celsius y Fahrenheit respectivamente. En este caso, solo tenemos 1 sensor
conectado al bus. Debido a que el conteo comienza en cero, configuro el índice
de nuestro sensor en 0.

// Fetch the temperature in degrees Celsius for device index:

167

index:
float tempF = sensors.getTempFByIndex(0);

Por último, las temperaturas se imprimen en el Monitor de serie:

// Print the temperature in Celsius in the Serial Monitor:

Como la conversión de temperatura en el modo de 12 bits puede tardar hasta
750 ms, agregué un segundo de retraso entre cada medición.

Usando múltiples sensores DS18B20 con
Arduino

Como mencioné en la introducción, puede leer la temperatura de múltiples
sensores DS18B20 con solo un pin del Arduino. A continuación puede
encontrar dos códigos de ejemplo. Con el primer ejemplo, puede leer la
temperatura de los sensores conectados por su índice. Debido a que todos los
sensores están conectados al mismo bus de 1 cable, el primer sensor tiene
índice 0, el segundo índice 1, y así sucesivamente.

Cableado: conexión de varios sensores
DS18B20 al Arduino

Conectar varios sensores DS18B20 al Arduino es tan sencillo como conectar
solo uno. Todos los sensores están conectados en paralelo, es decir, todos los
mismos pines están conectados entre sí. Al igual que antes, los pines GND
están conectados a tierra, los pines VDD a 5 V y los pines DQ al pin 2 del
Arduino. No olvide la resistencia pull-up de 4.7 kΩ entre el pin DQ y 5 V.

168
Varios sensores de temperatura digitales DS18B20 de 1 cable conectados a un Arduino

Múltiples sensores DS18B20 con código de
ejemplo Arduino

Con el siguiente ejemplo, puede leer la temperatura de cada sensor por su
índice y mostrarlo en el Monitor Serial.


connected:


int deviceCount = 0;

169
float tempC;
float tempF;
void setup() {
Serial.begin(9600);
sensors.begin();
// Locate the devices on the bus:

Serial.println("Locating devices...");
Serial.print("Found ");
deviceCount = sensors.getDeviceCount();
Serial.print(deviceCount);
Serial.println(" devices");
}
void loop() {
// Display temperature from each sensor

for (int i = 0; i < deviceCount; i++) {
Serial.print("Sensor ");
Serial.print(i + 1);
Serial.print(" : ");
tempC = sensors.getTempCByIndex(i);
tempF = sensors.getTempFByIndex(i);
}

170
Serial.println();
delay(1000);
}

La salida en Serial Monitor debería verse así:
Múltiples sensores DS18B20 Salida de monitor en serie


El código de este ejemplo es prácticamente el mismo que antes.
En la sección de configuración, agregue una función adicional que cuenta la

cantidad de dispositivos que están conectados al bus de 1 cable.


171
En la sección de bucle del código, utilicé un bucle for para recorrer una sección
de código que obtiene la temperatura de cada sensor conectado al bus por su
índice.

// Display temperature from each sensor
tempC = sensors.getTempCByIndex(i);
tempF = sensors.getTempFByIndex(i);
}

Leer sensores por dirección

Para leer los sensores por su dirección individual, primero necesitamos saber
cuál es la dirección de cada sensor. Para ello, puede utilizar el boceto de
ejemplo a continuación.
El boceto imprime las direcciones de los sensores conectados en el Monitor

Serial. Para saber qué sensor es cuál, puede cablear sólo un sensor a la vez o
agregar sucesivamente un nuevo sensor. Luego, puede etiquetar cada sensor
que esté conectado al bus de 1 cable.

Buscador de direcciones DS18B20


172
connected:


int deviceCount = 0; // variable to store the number of
devices connected
DeviceAddress deviceAddress; // variable to store the device
address
void setup() {
Serial.begin(9600);
sensors.begin();

Serial.println("Printing addresses...");
sensors.getAddress(deviceAddress, i);
printAddress(deviceAddress);

173
}
}
void loop() {
}
void printAddress(DeviceAddress deviceAddress) {

for (uint8_t i = 0; i < 8; i++) {
Serial.print("0x");
if (deviceAddress[i] < 0x10) {
Serial.print("0");
}
Serial.print(deviceAddress[i], HEX);
if (i < 7) {
Serial.print(", ");
}
}
Serial.println();
}

La salida en Serial Monitor debería verse así:

174
Ahora escriba las direcciones de todos los sensores, porque las necesitará en el
siguiente ejemplo.
Leer sensores por dirección Código de

ejemplo de Arduino

Con el siguiente ejemplo, puede leer la temperatura de cada sensor
especificando su dirección única.


connected:


// Addresses of DS18B20 sensors connected to the 1-Wire bus

byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00,
0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00,
0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00,
0x21};
void setup() {
Serial.begin(9600);
sensors.begin();

175
void loop() {
Serial.print("Sensor 1: ");
printTemperature(sensor1); // call the printTemperature
function with the address of sensor1 as input
printTemperature(sensor2);
printTemperature(sensor3);
Serial.println(); // prints an empty line

delay(1000);
}
void printTemperature(DeviceAddress address) {

address:
float tempC = sensors.getTempC(address);
address:
float tempF = sensors.getTempF(address);

}

176
Tenga en cuenta que debe reemplazar las direcciones en las líneas 17 a 19
con las direcciones que encontró usando el código de ejemplo anterior.

0x7C};
0xBB};
0x21};

Debería ver la siguiente salida en el Monitor Serial.


La dirección de cada sensor consta de 64 bits. En el código, especificamos la
dirección como una matriz de ocho bytes de 8 bits.

0x7C};

177
0xBB};
0x21};

La sección de configuración del código es la misma que en los ejemplos
anteriores.
En el ciclo, llamamos a la printTemperature(DeviceAddress

address)función. En esta función personalizada, usamos
getTempC(address)y getTempF(address)para obtener la temperatura de
un sensor cuya dirección se pasa como parámetro.

void printTemperature(DeviceAddress address) {
address:
float tempC = sensors.getTempC(address);
address:
float tempF = sensors.getTempF(tempC);

}

Otras funciones de la biblioteca
DallasTemperature Arduino

La biblioteca DallasTemperature tiene incorporadas otras funciones útiles que
aún no he cubierto en los ejemplos anteriores. Por lo tanto, he enumerado
algunos de ellos a continuación:

178

setResolution ()

Esta función se puede utilizar para establecer la resolución de la conversión de
temperatura a digital. Como mencioné en la introducción, esto se puede
configurar en 9, 10, 11 o 12 bits, correspondientes a incrementos de 0.5 ° C,
0.25 ° C, 0.125 ° C y 0.0625 ° C, respectivamente.
Quizás te preguntes por qué querrías cambiar la resolución, ¿no es mejor

siempre cuanto más alta? Una ventaja de seleccionar una resolución más baja
es que la conversión de temperatura a digital lleva mucho menos tiempo. Esto
significa que puede tomar más lecturas de temperatura en el mismo período de
tiempo.
De la hoja de datos obtuve la siguiente información:

Resolución Incremento de Tiempo de conversión
temperatura máximo
9 bits 0,5 ° C 93,75 ms
10 bits 0,25 ° C 187,5 ms
11 bits 0,125 ° C 375 ms
12 bits 0,0625 ° C 750 ms

La biblioteca DallasTemperature le permite configurar la resolución con la
función setResolution(). Esta función se puede agregar a la sección de
configuración o bucle de su código.
Puede configurar la resolución para todos los sensores conectados de la

siguiente manera:

// Set the resolution for all devices to 9, 10, 11, or 12
bits:
sensors.setResolution(9);

179

O puede configurarse individualmente para un sensor específico especificando
su dirección:

0x7C};
// Set the resolution of a specific device to 9, 10, 11, or 12

bits:
sensors.setResolution(sensor1, 9);

toFahrenheit ()

Esta función se puede utilizar para convertir la temperatura en grados Celsius a
Fahrenheit.

float tempC = sensors.getTempCbyIndex(0);
float tempF = DallasTemperature::toFahrenheit(tempC);

setHighAlarmTemp () y setLowAlarmTemp ()

Esta función configura las alarmas internas de temperatura alta y baja para un
dispositivo en grados Celsius.
bool hasAlarm()

Esta función devuelve verdadero cuando un dispositivo tiene una condición de
alarma. Puede encontrar un ejemplo de estas funciones aquí .

Muestre las lecturas de temperatura
DS18B20 en una pantalla LCD I2C

Si desea hacer un proyecto independiente que no necesita una computadora,
puede ser bueno saber cómo mostrar las lecturas de temperatura en una
pantalla LCD.

180
Con el código de ejemplo a continuación, puede mostrar las lecturas de
temperatura en una pantalla LCD I2C de 16x2 caracteres.

DS18B20 con LCD I2C de 16x2 caracteres y Arduino

Conexiones LCD I2C

LCD de caracteres I2C Arduino
GND GND
VCC 5 V
SDA A4
SCL A5

Para utilizar una pantalla LCD I2C, deberá instalar la biblioteca Arduino
LiquidCrystal_I2C.

181

Abra el administrador de la biblioteca en el IDE de Arduino y busque
'liquidcrystal_i2c'. Ahora desplácese hacia abajo y busque la biblioteca de
Frank de Brabander . Seleccione la última versión y luego haga clic en Instalar.
Instalación de la biblioteca Arduino LiquidCrystal_I2C

DS18B20 con código de ejemplo de LCD I2C


connected:


182
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Degree symbol:
byte Degree[] = {
B00111,
B00101,
B00111,
B00000,
B00000,
B00000,
B00000,
B00000
};
void setup() {
Serial.begin(9600);
sensors.begin();
// Start the LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create a custom character:
lcd.createChar(0, Degree);
}
void loop() {

index:

183
// Print the temperature on the LCD;

lcd.setCursor(0,0);
lcd.print("Temperature:");
lcd.setCursor(0,1);
lcd.print(tempC);
lcd.write(0); // print the custom character
lcd.print("C");
// Wait 1 second:
delay(1000);
}


184

Cómo usar un receptor

de infrarrojos y un
control remoto con
Arduino

En este tutorial, aprenderá a usar un control remoto y un receptor de infrarrojos
con Arduino. He incluido diagramas de cableado y varios códigos de ejemplo
para que pueda comenzar.
Siguiendo las instrucciones de este tutorial, debería poder usar prácticamente
cualquier control remoto IR (como el de su televisor) para controlar las cosas
conectadas al Arduino.
En los ejemplos de código a continuación, usaremos la biblioteca IRremote
Arduino. Esta biblioteca es bastante fácil de usar y admite muchos protocolos
de comunicación IR diferentes. Con los dos primeros ejemplos, puede
identificar el protocolo IR de su control remoto y determinar qué código envía

185
cuando presiona una tecla/botón. A continuación, le mostraré cómo asignar el
código recibido a los valores clave y mostrarlos en el monitor en serie o en una
pantalla LCD. Por último, veremos cómo controlar las salidas del Arduino con
un control remoto y un receptor de infrarrojos.


Receptor y control remoto por infrarrojos × 1 Electrogeek
Arduino Uno × 1 Electrogeek
Cables para Protoboard × 15 Electrogeek
Pantalla LCD de 16x2 caracteres × 1 Electrogeek
Potenciómetro de 10 kΩ × 1 Electrogeek
Surtido de resistencias × 1 Electrogeek
Surtido de LED × 1 Electrogeek

Software
IDE Arduino

186

¿Cómo funcionan un receptor y un mando a
distancia de infrarrojos (IR)?

Un control remoto IR y un receptor se comunican entre sí transmitiendo y
decodificando una señal en forma de radiación IR pulsada.

Señal enviada y detectada por el transmisor IR (izquierda) y el receptor (derecha) (Fuente:
SB-Projects )

La radiación infrarroja (IR), o luz infrarroja, es un tipo de radiación
electromagnética con longitudes de onda que van desde 700 nm a 1 mm.
Debido a que los humanos solo pueden ver la luz con longitudes de onda de
aproximadamente 400 (violeta) a 700 ( rojo) nanómetros, la radiación IR es
invisible para el ojo humano.

Espectro electromagnético con luz visible resaltada (Fuente: Wikipedia )

187
Dado que la transmisión por infrarrojos es un protocolo inalámbrico basado en
un tipo de luz, requiere una línea de visión clara entre el transmisor (el control
remoto) y el receptor. Esto significa que no puede transmitir a través de
paredes o techos, a diferencia de WiFi o Bluetooth.
Conceptos básicos de comunicación por

infrarrojos

Desafortunadamente, el LED IR de su control remoto no es la única fuente de
radiación IR. Cualquier objeto que tenga temperatura también irradia en el
espectro infrarrojo. Este fenómeno también lo utilizan las cámaras térmicas
para detectar el calor.

LED IR al final de un control remoto (Fuente: SparkFun )

Todo este IR ambiental puede interferir con la comunicación entre el control
remoto y el receptor. Entonces, ¿cómo detecta el receptor solo la señal de
infrarrojos que proviene del control remoto? La respuesta es la modulación de
la señal.
Con la modulación de señal, la fuente de luz IR al final del control remoto

parpadea con una frecuencia específica. En la electrónica de consumo, esta
frecuencia portadora suele rondar los 38 kHz.
Eligieron esta frecuencia específica para la transmisión de infrarrojos comercial

porque es poco común en la naturaleza y, por lo tanto, se puede distinguir del
infrarrojo ambiental.

188

El receptor está construido de tal manera que solo deja pasar el IR que llega a
38 kHz. Esto se hace usando un filtro de paso de banda y un amplificador. La
señal binaria demodulada se envía al microcontrolador (el Arduino) donde se

decodifica.
Entonces, ¿cómo se ve realmente una señal de infrarrojos?

Protocolo NEC (Fuente: SB-Projects )

En la imagen de arriba, el eje vertical se puede ver como el voltaje que va al
LED IR en el control remoto y el eje horizontal es el tiempo. Entonces, cuando
el LED está encendido, parpadea ( modula) a 38 kHz y cuando está apagado,
no se aplica voltaje.
Lo importante es la cantidad de tiempo que el LED de infrarrojos se mantiene

alto o bajo (encendido o apagado). En el protocolo NEC, que es uno de los
protocolos de transmisión IR más populares, los bits ("1" o "0") se representan
de la siguiente manera:
Cada bit consta de una ráfaga de portadora de 38 kHz de 560 µs de longitud

(aproximadamente 21 ciclos) seguida de una pausa. Un "1" lógico tiene un
tiempo de transmisión total de 2,25 ms, mientras que un "0" lógico sólo 1,125
ms.
La cantidad de tiempo que la señal permanece alta o baja y el número de bits

que se envían para cada comando es diferente para todos los protocolos de
infrarrojos. En el protocolo NEC, el mensaje total generalmente consta de
cuatro bytes de 8 bits.
Tipos de receptores de infrarrojos

Los receptores de infrarrojos, a veces denominados sensores de infrarrojos o
diodos de detección de infrarrojos, suelen tener dos formatos diferentes. Puede

189
comprar los diodos por separado o montarlos en una pequeña placa de
conexión.
●
●
Diodo receptor de infrarrojos (izquierda) y receptor montado en una placa de conexión (derecha)

Funcionan exactamente igual, por lo que no importa cual uses. La única
diferencia es que la placa de conexión a menudo contiene un pequeño LED que
parpadea cada vez que el receptor detecta una señal que puede ser útil para
depurar.

190

Conexión de un receptor de infrarrojos al
Arduino

Es muy fácil conectar un receptor de infrarrojos al Arduino, ya que solo
necesita conectar tres cables. El cable de salida se puede conectar a cualquiera
de los pines digitales del Arduino. En este caso, lo conecté al pin 2 para los
primeros ejemplos a continuación.
El pin de alimentación de suministro está conectado a 5V y el pin de tierra del

medio a GND. Si está utilizando un receptor que está montado en una placa de
conexión, verifique las etiquetas en la PCB ya que el orden de los pines puede
ser diferente.

El pin de salida del receptor de infrarrojos está conectado al pin 2

Las conexiones también se dan en la siguiente tabla.
Conexiones del receptor de infrarrojos

Receptor IR Arduino
OUT (izquierda) Pin 2
GND ( medio) GND

191
Vcc (derecha) 5 V

Instalación de la biblioteca IRremote Arduino

Para este tutorial, usaremos la popular biblioteca IRremote escrita por Rafi
Khan y otros. Esta biblioteca es bastante fácil de usar y admite muchos tipos
diferentes de controles remotos IR. Puede encontrar el código fuente de esta
biblioteca aquí en GitHub .
Para instalar la biblioteca, vaya a Herramientas> Administrar bibliotecas (Ctrl +

Shift + I en Windows) en el IDE de Arduino . El Administrador de bibliotecas
abrirá y actualizará la lista de bibliotecas instaladas.

Puede buscar 'IRremote' y buscar la biblioteca por shirriff y z3to. Seleccione la
última versión y luego haga clic en Instalar.

192

Determine el protocolo de infrarrojos
utilizado por su control remoto

NEC es probablemente el protocolo de transmisión IR más conocido y más
extendido, ya que lo utiliza la gran mayoría de los productos electrónicos de
consumo fabricados en Japón. Sin embargo, existen muchos otros tipos de
protocolos. Puede ser útil saber qué tipo de protocolo de infrarrojos está
usando su control remoto si desea trabajar en proyectos más avanzados. O tal
vez solo tengas curiosidad
La biblioteca IRremote admite actualmente 18 protocolos IR diferentes:
● Aiwa
● BoseWave
● Denon
● Plato
● JVC
● Lego
● LG
● MagiQuest
● Mitsubishi
● Comité ejecutivo nacional
● Panasonic

193
● Philips RC5
● Philips RC6,
● Samsung
● Sanyo
● Agudo
● Sony
● Whynter

Aunque la biblioteca es bastante antigua, todavía se están agregando nuevos
protocolos (consulte GitHub ).
Con el código a continuación, puede identificar qué protocolo está usando su
control remoto. También puede probar algunos otros controles remotos que
tiene en su casa y ver si puede detectar el protocolo.

Buscador de protocolo remoto por
infrarrojos

#include <IRremote.h> // include the IRremote library
#define RECEIVER_PIN 2 // define the IR receiver pin

IRrecv receiver(RECEIVER_PIN); // create a receiver object of
the IRrecv class
decode_results results; // create a results object of the
decode_results class
unsigned long key_value = 0; // variable to store the pressed
key value
void setup() {
Serial.begin(9600); // begin serial communication with a
baud rate of 9600
receiver.enableIRIn(); // enable the receiver
receiver.blink13(true); // enable blinking of the built-in
LED when an IR signal is received
}
void loop() {
if (receiver.decode(&results)) {

194
if (results.value == 0XFFFFFFFF) {
results.value = key_value;
}
Serial.println(results.value, HEX);
switch (results.decode_type) {
case NEC:
Serial.println("NEC");
break;
case SONY:
Serial.println("SONY");
break;
case RC5:
Serial.println("RC5");
break;
case RC6:
Serial.println("RC6");
break;
case DISH:
Serial.println("DISH");
break;
case SHARP:
Serial.println("SHARP");
break;
case JVC:
Serial.println("JVC");
break;
case SANYO:
Serial.println("SANYO");
break;
case MITSUBISHI:
Serial.println("MITSUBISHI");
break;
case SAMSUNG:
Serial.println("SAMSUNG");
break;
case LG:

195
Serial.println("LG");
break ;
case WHYNTER:
Serial.println("WHYNTER");
break;
case AIWA_RC_T501:
Serial.println("AIWA_RC_T501");
break;
case PANASONIC:
Serial.println("PANASONIC");
break;
case DENON:
Serial.println("DENON");
break;
case BOSEWAVE:
Serial.println("BOSEWAVE");
break;
case LEGO_PF:
Serial.println("LEGO_PF");
break;
case MAGIQUEST:
Serial.println("MAGIQUEST");
break;
default:
case UNKNOWN:
Serial.println("UNKNOWN");
break ;
}
key_value = results.value;
receiver.resume();
}
}

Experimenté con algunos de los controles remotos de mi casa y pude detectar
los siguientes protocolos:

196

Protocolos de infrarrojos detectados desde varios controles remotos

Encontrar los códigos clave para su control
remoto

Debido a que hay muchos tipos diferentes de controles remotos en el mercado
(diferente número de teclas y valores impresos en las teclas), necesitamos
determinar qué señal recibida corresponde a qué tecla.
La biblioteca IRremote leerá la señal y generará un código específico en forma

de número hexadecimal dependiendo de la tecla que se presione.
Al imprimir esta salida en Serial Monitor, podemos crear una tabla de
conversión.
Puede copiar el código a continuación haciendo clic en en la esquina superior

derecha del campo del código.


the IRrecv class

197
void setup() {
baud rate of 9600
}
void loop() {
if (receiver.decode(&results)) { // decode the received
signal and store it in results
Serial.println(results.value, HEX); // print the values in
the Serial Monitor
receiver.resume(); // reset the receiver for the next code
}
}

Una vez que haya cargado el código, abra Serial Monitor (Ctrl + Shift + M en
Windows). Ahora presione cada tecla en el control remoto y registre el valor
hexadecimal correspondiente que ve en el Monitor serial.

198


Tenga en cuenta que verá el código FFFFFFFF cuando presione una tecla
continuamente. Este es el código de repetición enviado por el control remoto.
Para mi control remoto obtuve la siguiente tabla de conversión:

199
Botón Código
POWER 0xFD00FF
VOL + 0xFD807F
FUNC/STOP 0xFD40BF
│◄◄ 0xFD20DF
►││ 0xFDA05F
►►│ 0xFD609F
▼ 0xFD10EF
VOL- 0xFD906F
▲ 0xFD50AF
0 0xFD30CF
Ecualizador 0xFDB04F
ST/REPT 0xFD708F
1 0xFD08F7
2 0xFD8877
3 0xFD48B7
4 0xFD28D7
5 0xFDA857
6 0xFD6897

200
7 0xFD18E7
8 0xFD9867
9 0xFD58A7

Como puede ver en la tabla, los valores hexadecimales se indican con el prefijo
“0x”.

Código de ejemplo de Arduino del receptor y
mando a distancia por infrarrojos: imprimir
valores clave en el monitor serie

Ahora que sabemos qué código (valor hexadecimal) corresponde a qué
pulsación de tecla, podemos modificar el código para imprimir el valor de la
tecla pulsada en el Monitor de serie.
Para esto, usaremos una estructura de control de caso de interruptor . Esto nos
permite ejecutar un código diferente según la tecla que se presione.
El siguiente ejemplo de código imprime el valor de la clave en Serial Monitor en

lugar del valor hexadecimal como hicimos en el ejemplo anterior. Después de
cargar el código, puede leer la explicación a continuación para aprender cómo
funciona el código.


the IRrecv class
unsigned long key_value = 0; // variable to store the key
value
void setup() {

201
baud rate of 9600

}
void loop() {
if (results.value == 0xFFFFFFFF) { // if the value is
equal to 0xFFFFFFFF
results.value = key_value; // set the value to the key
value
}
switch (results.value) { // compare the value to the
following cases
case 0xFD00FF: // if the value is equal to 0xFD00FF
Serial.println("POWER"); // print "POWER" in the
Serial Monitor
break;
case 0xFD807F:
Serial.println("VOL+");
break;
case 0xFD40BF:
Serial.println("FUNC/STOP");
break;
case 0xFD20DF:
Serial.println("|<<");
break;
case 0xFDA05F:
Serial.println(">||");
break ;
case 0xFD609F:
Serial.println(">>|");
break ;
case 0xFD10EF:

202
Serial.println("DOWN");
break ;
case 0xFD906F:
Serial.println("VOL-");
break ;
case 0xFD50AF:
Serial.println("UP");
break ;
case 0xFD30CF:
Serial.println("0");
break ;
case 0xFDB04F:
Serial.println("EQ");
break ;
case 0xFD708F:
Serial.println("ST/REPT");
break ;
case 0xFD08F7:
break ;
case 0xFD8877:
break ;
case 0xFD48B7:
break ;
case 0xFD28D7:
break ;
case 0xFDA857:
break ;
case 0xFD6897:
break ;
case 0xFD18E7:

203
break ;
case 0xFD9867:
break ;
case 0xFD58A7:
break ;
}
key_value = results.value; // store the value as key_value
}
}


Si su control remoto envía códigos de clave diferentes a los que se muestran
en la tabla anterior, simplemente reemplace el valor hexadecimal y clave en
cada una de las líneas en la declaración de caso del interruptor que se ve así:

Serial.println("POWER"); // print "POWER" in the Serial
Monitor

204

Estas líneas se traducen a: cuando results.value es igual a 0xFD00FF, imprima
"POWER" en el Monitor serial. Una vez más, observe que debe agregar "0x"
antes de los valores que vio en el Monitor serie en el ejemplo anterior.
Para evitar dobles clics no deseados, puede agregar un breve retraso ( por
ejemplo, 500 ms) al final del ciclo.

El primer paso es incluir la biblioteca IRremote. Si recibe el mensaje de error
“IRremote.h: No existe tal archivo o directorio”, probablemente haya olvidado
instalar la biblioteca .


A continuación, define a qué pin Arduino está conectada la salida del receptor.
menciona RECEIVER_PIN, el compilador lo reemplazará con el valor 2 cuando
se compile el programa.


Después de eso, necesitamos crear un objeto de la IRrecv clase y vincularlo
al pin de salida del receptor ( pin 2). En este caso, llamé al objeto 'receptor' pero
también puedes usar otros nombres. Este objeto se encarga del protocolo IR y
el procesamiento de la señal del receptor.

the IRrecv class

205

A continuación, se crea un objeto llamado results de la clase
decode_results. Este objeto almacena los valores decodificados del objeto
receptor. Accederemos a estos valores en el resto del código.


En la última línea antes de la sección de configuración, creamos una variable
para almacenar el valor de la clave.

value

En la sección de configuración del código, primero establecemos la velocidad
de datos para la comunicación en serie en bits por segundo (velocidad en
baudios) de 9600. Asegúrese de que el Monitor en serie también esté
configurado a la misma velocidad en baudios.
A continuación, inicializamos el receptor con la función enableIRIn(). La

siguiente línea habilita el parpadeo del LED incorporado del Arduino. La
blink13()función hará parpadear el LED conectado al pin digital 13 cada vez
que el receptor reciba una señal del control remoto. Esto puede ser muy útil
para depurar.

void setup() {
baud rate of 9600
}

La sección de bucle del código comienza con una instrucción if verifica una
condición y ejecuta la instrucción de procedimiento o el conjunto de
declaraciones si la condición es 'verdadera'. Cuando se recibe un código, la
condición receiver.decode(&results)devuelve verdadera y se ejecuta el
resto del código.

206

Como mencioné antes, cuando presionas continuamente una tecla,
comenzamos a recibir 0xFFFFFFFF desde el control remoto. Esto significa una
repetición de la clave anterior. Como quiero seguir imprimiendo el valor de la
tecla presionada, agregué las siguientes líneas al código:

if (results.value == 0xFFFFFFFF) { // if the value is equal to
0xFFFFFFFF
results.value = key_value; // set the value to the key value
}

y


al final del ciclo. Cuando se recibe el código de repetición 0xFFFFFFFF, lo
reemplazamos con el valor de clave anterior que almacenamos como
key_value en la línea 86.
Después de eso, la declaración de caso de cambio se usa para comparar el

código recibido con los diferentes códigos de clave que registramos en el
ejemplo anterior. Los valores de clave correspondientes se imprimen en el
Monitor de serie en una nueva línea con la función Serial.println().
Al final de la sección de bucle, resume()se llama a la función , que reinicia el

receptor y lo prepara para recibir el siguiente código.


Receptor y control remoto por infrarrojos
con Arduino y ejemplo de LCD

El siguiente ejemplo se puede utilizar para imprimir los valores de las teclas
presionadas en una pantalla LCD de caracteres .
Para este ejemplo, conecté la salida del receptor de infrarrojos al pin digital 8
en lugar de 2. Las conexiones para la pantalla LCD de caracteres se muestran
en el diagrama de cableado a continuación.

207

Tenga en cuenta que también necesita un potenciómetro de 10 kΩ para
establecer el contraste de la pantalla y una resistencia de 220 Ω para controlar
el brillo de la luz de fondo.

Control remoto y receptor de infrarrojos con Arduino Uno y diagrama de cableado LCD de 16x2
caracteres

Las conexiones también se dan en la siguiente tabla. El pin más a la izquierda
de la pantalla LCD es el pin 1 (GND).

Conexiones del receptor de LCD e infrarrojos

PIN Conexión
Pin 1 de LCD (GND) Arduino GND
Pin 2 de LCD (VCC) Arduino 5 V
Pin 3 de LCD (VO) Potenciómetro pin medio
Potenciómetro pin izquierdo Arduino 5 V
Potenciómetro pin derecho Arduino GND

208
LCD pin 4 (RS) Pin 2 de Arduino
Pin 5 de LCD (RW) Arduino GND
Clavija LCD 6 (E) Pin 3 de Arduino
Pin 11 de LCD (DB4) Pin 4 de Arduino
Clavija 14 de LCD (DB7) Pin 7 de Arduino
Pin 15 de LCD (ánodo LED) Arduino 5 V a través de una

resistencia de 220Ω
Pin 16 de LCD (LED-kathode) Arduino GND
Receptor de infrarrojos OUT Pin 8 de Arduino

(izquierda)
Receptor de infrarrojos GND ( medio) Arduino GND
Receptor de infrarrojos Vcc (derecha) Arduino 5 V

Con el código de ejemplo a continuación, puede imprimir el valor de la tecla
presionada en la pantalla LCD. He programado el botón de encendido para que
borre la pantalla.
Nuevamente, si su control remoto envía códigos diferentes, simplemente

reemplace los valores hexadecimales y los valores de clave correspondientes
en la declaración de cambio de caso.

209

Receptor y control remoto IR con código de
ejemplo de pantalla LCD y Arduino

Puede copiar el código haciendo clic en el botón en la esquina superior derecha
del campo del código.

#include <LiquidCrystal.h> // include the LiquidCrystal
library
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7); //create

an LCD object with pin parameters (RS, E, D4, D5, D6, D7)

the IRrecv class
value
void setup() {
lcd.begin(16, 2); // enable LCD with 16 colums and 2 rows
}
void loop() {
if (results.value == 0xFFFFFFFF) { // if the value is
equal to 0xFFFFFFFF
results.value = key_value; // set the value to the key
value

210
}
switch (results.value) { // compare the value to the
following cases
lcd.clear(); // clear the display
break;
case 0xFD807F:
lcd.print("VOL+");
break;
case 0xFD40BF:
lcd.print("FUNC/STOP");
break;
case 0xFD20DF:
lcd.print("|<<");
break;
case 0xFDA05F:
lcd.print(">||");
break ;
case 0xFD609F:
lcd.print(">>|");
break ;
case 0xFD10EF:
lcd.print("DOWN");
break ;
case 0xFD906F:
lcd.print("VOL-");
break ;
case 0xFD50AF:
lcd.print("UP");
break ;
case 0xFD30CF:
lcd.print("0");
break ;
case 0xFDB04F:
lcd.print("EQ");
break ;

211
case 0xFD708F:
lcd.print("ST/REPT");
break ;
case 0xFD08F7:
lcd.print("1");
break ;
case 0xFD8877:
lcd.print("2");
break ;
case 0xFD48B7:
lcd.print("3");
break ;
case 0xFD28D7:
lcd.print("4");
break ;
case 0xFDA857:
lcd.print("5");
break ;
case 0xFD6897:
lcd.print("6");
break ;
case 0xFD18E7:
lcd.print("7");
break ;
case 0xFD9867:
lcd.print("8");
break ;
case 0xFD58A7:
lcd.print("9");
break ;
}
}
}

212

Debería ver la siguiente salida en la pantalla LCD si presiona la tecla VOL +.
Tenga en cuenta que es posible que deba ajustar el potenciómetro para
aumentar el contraste de la pantalla.

Salida de pantalla LCD

LED de control (salidas Arduino) con control
remoto IR y receptor

Aunque es divertido ver los valores clave en el monitor serial o en una pantalla
LCD, probablemente querrá usar el control remoto para algo más útil, es decir,
controlar algo. En el siguiente ejemplo, le mostraré cómo encender y apagar los
LED con el control remoto. También puede utilizar este tipo de código para
controlar relés, luces y motores.
El código se ve casi igual que los ejemplos anteriores, pero agregué funciones
adicionales para controlar los LED.
Tendrá que crear el siguiente circuito para controlar los LED:

213

Diagrama de cableado para controlar LED con control remoto IR, receptor y Arduino

Los LED están conectados a los pines 2 a 5 del Arduino y la salida del receptor
de infrarrojos al pin 6. Usé algunas resistencias de 470 Ω para limitar la
corriente que pasa por los LED. La corriente de funcionamiento habitual de los
LED de 3 y 5 mm ronda los 20 mA. Puede determinar qué valor de resistencia
necesita con una calculadora en línea como esta.

#include <IRremote.h>
#define RECEIVER_PIN 6 // define the connections

#define RED_LED_PIN 2
#define YELLOW_LED_PIN 3
#define GREEN_LED_PIN 4
#define BLUE_LED_PIN 5

the IRrecv class
unsigned long key_value = 0;
void setup() {
Serial.begin(9600); // begin serial communication at a baud
rate of 9600

214

pinMode(RED_LED_PIN, OUTPUT); // set the LED pins as output
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW); // turn all the LEDs off
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
void loop() {
if (receiver.decode(&results)) {
if (results.value == 0xFFFFFFFF) {
results.value = key_value;
}
switch (results.value) {
case 0xFD00FF:
Serial.println("POWER");
break;
case 0xFD807F:
Serial.println("VOL+");
break;
case 0xFD40BF:
Serial.println("FUNC/STOP");
break;
case 0xFD20DF:
Serial.println("|<<");
break;
case 0xFDA05F:
Serial.println(">||");
break ;
case 0xFD609F:
Serial.println(">>|");

215
break ;
case 0xFD10EF:
Serial.println("DOWN");
break ;
case 0xFD906F:
Serial.println("VOL-");
break ;
case 0xFD50AF:
Serial.println("UP");
break ;
case 0xFD30CF:
break ;
case 0xFDB04F:
Serial.println("EQ");
break ;
case 0xFD708F:
Serial.println("ST/REPT");
break ;
case 0xFD08F7:
toggleLED(RED_LED_PIN); // run the toggle LED function
with the red LED pin as input
break ;
case 0xFD8877:
toggleLED(YELLOW_LED_PIN);
break ;
case 0xFD48B7:
toggleLED(GREEN_LED_PIN);;
break ;
case 0xFD28D7:
toggleLED(BLUE_LED_PIN);
break ;

216
case 0xFDA857:
break ;
case 0xFD6897:
break ;
case 0xFD18E7:
break ;
case 0xFD9867:
break ;
case 0xFD58A7:
break ;
}
key_value = results.value;
receiver.resume();
}
}
void toggleLED(int pin) { // function to toggle the LED on and

off
if (digitalRead(pin) == HIGH) { // if the LED is on
digitalWrite(pin, LOW); // turn it off
}
else { // else
digitalWrite(pin, HIGH); // turn it on
}
}

Si presiona los botones 1 - 4 en el control remoto, puede encender y apagar los
LED correspondientes.

217


A continuación, destacaré rápidamente las diferencias en el código en
comparación con los ejemplos anteriores.
En la primera parte del código, define los pines de Arduino a los que están
conectados los LED y el receptor de infrarrojos. En la sección de configuración,
configure los pines del LED como salida y apague todos los LED con
digitalWrite(pin, value).
pinMode(RED_LED_PIN, OUTPUT); // set the LED pins as output

pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW); // turn all the LEDs off
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);

La sección de bucle del código es prácticamente la misma que antes, pero
ahora, en lugar de simplemente imprimir los valores de las claves en el Monitor
de serie, toggleLED(pin)se llama a la función si presiona las teclas 0 a 4.
Esta función toma el pin de LED específico como entrada y enciende o apaga el
LED si presiona la tecla. Tenga en cuenta que si presiona continuamente una
tecla, el LED seguirá encendiéndose y apagándose.

void toggleLED(int pin) { // function to toggle the LED on and
off
if (digitalRead(pin) == HIGH) { // if the LED is on
digitalWrite(pin, LOW); // turn it off
}
else { // else
digitalWrite(pin, HIGH); // turn it on
}

218

Dado que básicamente solo está controlando los 4 pines de salida del Arduino,
también puede usar esta función para encender y apagar los relés.
Ahora, si simplemente escribe una función diferente y la llama cuando se

presiona un botón específico, básicamente puede controlar lo que quiera. Me
encantaría saber qué cosas estás controlando con tu control remoto y sería
genial si pudieras compartir con los otros lectores cómo lo implementaste.

219

Tutorial de Arduino con

pantalla de matriz de
puntos LED MAX7219

En este tutorial, aprenderá a controlar una pantalla de matriz de puntos LED

MAX7219 con Arduino. ¡He incluido un diagrama de cableado y muchos
códigos de ejemplo! El código de este tutorial se puede utilizar para pantallas
de 8×8, 8×32 e incluso más grandes.
Para este tutorial, usaré MD_Parola en combinación con la biblioteca Arduino

MD_MAX72XX . Estas bibliotecas facilitan la visualización de texto en
desplazamiento y otras animaciones. En la primera parte de este artículo,
cubriré los conceptos básicos de la impresión de texto en la pantalla. A
continuación, veremos el texto en desplazamiento y otras animaciones de
texto. Por último, te mostraré cómo usar sprites de texto.

220


Pantalla de matriz de puntos LED 8×32

× 1 Electrogeek
MAX7219
Pantalla de matriz de puntos LED

× 1 Electrogeek
MAX7219 de 8×8 (alternativa)
Pantalla de matriz de puntos LED

× 1 Electrogeek
genérica MAX7219 de 8×8 (alternativa)
Cables dupont ( macho a hembra) × 4 Electrogeek
Pines machos ~ 20 Electrogeek
Jumpers ~ 20 Electrogeek

Software
IDE Arduino

Acerca del controlador LED MAX7219

El controlador LED MAX7219 se puede utilizar para controlar pantallas de 7
segmentos de hasta 8 dígitos, pantallas de gráfico de barras o 64 LED
individuales. El controlador se comunica con Arduino a través de SPI, por lo
que solo necesita tres cables para controlar la pantalla.

221

Dado que el MAX7219 puede controlar un máximo de 64 LED, la pantalla de
matriz de puntos de tamaño máximo que puede manejar es de 8×8 píxeles. Sin
embargo, puede conectar en cadena varios controladores y matrices y
controlar fácilmente pantallas mucho más grandes como 8×32, 8x64 o incluso
más grandes. Aún así, solo necesita tres cables para controlar todos los
circuitos integrados, por lo que necesita muy pocos pines de E/S del Arduino.
A continuación puede encontrar las especificaciones de una pantalla de matriz

de puntos LED MAX7219 8×32 típica.
Especificaciones de la pantalla de matriz de

puntos LED MAX7219

Controlador de pantalla MAX7219x4
Niveles de brillo dieciséis
Dimensiones de la pantalla 32x128x15 mm
Pixeles 8×32, ⌀ 3 mm

Para obtener más información, puede consultar la hoja de datos:

🔗 MAX7219 Hoja de datos
Casi todas las pantallas que he usado en el pasado usaban una matriz LED de
8×8 tipo 1088AS. Puede encontrar una hoja de datos de una de las empresas
que los fabrica a continuación:

🔗
1088AS Hoja de datos

222

Cómo conectar la pantalla de matriz de
puntos al Arduino

El controlador de pantalla LED MAX7219 se comunica con Arduino a través de
SPI (interfaz periférica en serie). Para obtener más información sobre este
protocolo de datos, consulte esta página en el sitio web de Arduino.
Con una interfaz SPI siempre hay un dispositivo maestro (el Arduino) que
controla los dispositivos periféricos (también conocidos como esclavos). Puede
controlar la pantalla a través de la interfaz SPI del hardware del
microcontrolador AVR de Arduino o tres pines digitales arbitrarios (software
SPI).
Los pines SPI de hardware (MOSI, MISO y SCK) están en una ubicación
específica en cada placa Arduino. Esta interfaz es más rápida que usar el
software SPI, pero deberá usar los siguientes pines de salida fijos:

Ubicaciones de los pines SPI de hardware

Placas MOSI MISO SCK Nivel
Arduino Uno 11 o ICSP-4 12 o ICSP-1 13 o ICSP-3 5 V
Arduino Mega 51 o ICSP-4 50 o ICSP-1 52 o ICSP-3 5 V
Arduino Leonardo ICSP-4 ICSP-1 ICSP-3 5 V
Arduino Due SPI-4 SPI1 SPI-3 3,3 V
Arduino MKR1000 8 10 9 3,3 V
Ubicaciones de pines SPI de hardware en diferentes placas Arduino.

Tenga en cuenta que los pines MOSI, MISO y SCK también se encuentran en
una ubicación física consistente en el encabezado ICSP de 6 pines:

223

Fuente: Arduino.cc

Para controlar las pantallas MAX7219 solo necesita realizar tres conexiones:
● MOSI (Master Out Slave In) conectado a DIN - La línea Master que envía
datos a los periféricos.
● SCK (Serial Clock) conectado a CLK: los pulsos de reloj que sincronizan la
transmisión de datos generada por el maestro.
● SS (Selección de esclavo) conectado a CS: el pin en cada dispositivo que
el maestro puede usar para habilitar y deshabilitar dispositivos
específicos.

Puede conectar en cadena múltiples pantallas para crear una pantalla grande
conectando DOUT de la primera pantalla a DIN de la siguiente pantalla. VCC,
GND, CLK y CS se comparten entre todas las pantallas.
Puede seleccionar cualquiera de los pines digitales del Arduino para el pin
SS/CS. Tenga en cuenta que para este tutorial utilicé el pin 3 (consulte la tabla
a continuación).
El diagrama de cableado a continuación le muestra cómo conectar la pantalla

de matriz de puntos LED MAX7219 al Arduino. Tenga en cuenta que al
utilizar la biblioteca MD_Parola, debe orientar la pantalla con el conector
DIN a la derecha; de lo contrario, el texto se imprimirá al revés.

Pantalla de matriz de puntos LED MAX7219 con diagrama de cableado Arduino

224


Conexiones de pantalla de matriz de puntos
LED MAX7219

Pantalla MAX7219 Arduino
VCC 5 V
GND GND
DIN 11 (MOSI)
CS 3 (SS)
CLK 13 (SCK)

Si desea utilizar el software SPI en su lugar, puede conectar DIN, CS y CLK a
cualquiera de los pines digitales del Arduino. Sólo necesita especificar los
números de pin en la configuración del código Arduino (vea los ejemplos a
continuación).
Requerimientos de energía

La potencia máxima que el Arduino Uno puede entregar de manera segura
cuando se alimenta desde USB es de alrededor de 400 mA a 5 V. Si desea
controlar una pantalla grande, se recomienda utilizar una fuente de
alimentación externa.
Instalación de las bibliotecas Arduino

MD_Parola y MD_MAX72XX

Para controlar la pantalla MAX7219 utilizaremos dos fantásticas bibliotecas
Arduino creadas por Marco Colli de MajicDesigns. La biblioteca MD_Parola se
puede utilizar para crear muchas animaciones de texto diferentes, como
efectos de texto de desplazamiento y sprites. Esta biblioteca depende de la

225
biblioteca MD_MAX72XX que implementa las funciones de hardware de la
matriz de LED.
Estas son algunas de las funciones y características de la biblioteca:
● Justificación de texto izquierda, derecha o central

● Desplazamiento de texto con efectos de entrada y salida
● Controlar los parámetros de visualización y la velocidad de la animación.
● Varias pantallas virtuales (zonas) en cada cadena de módulos LED
● Soporte para interfaz SPI de hardware
● Fuentes definidas por el usuario y/o sustituciones de caracteres
individuales
● Soporte para pantallas de doble altura
● Soporte para mezclar texto y gráficos en la misma pantalla

El código fuente y la documentación de las bibliotecas se pueden encontrar
aquí:
● Código fuente de MD_Parola en GitHub

● Documentación de MD_Parola
● Código fuente MD_MAX72XX en GitHub
● Documentación de MD_MAX72XX

Puede instalar las bibliotecas a través del Administrador de bibliotecas del IDE
de Arduino . Vaya a Herramientas> Administrar bibliotecas ... o escriba Ctrl +
Shift + I en Windows. El Administrador de bibliotecas abrirá y actualizará la
lista de bibliotecas instaladas.

226

Busque 'MD_MAX72XX' y busque las bibliotecas de majicDesigns. Seleccione
la última versión y luego haga clic en instalar. Asegúrese de instalar tanto la
biblioteca MD_MAX72XX como la biblioteca MD_Parola.

227

Diferentes tipos de pantallas de matriz de
puntos LED

Hay muchos tipos y tamaños diferentes de pantallas de matriz de puntos LED
MAX7219 disponibles en el mercado. La biblioteca MD_MAX72XX es
compatible con casi todas estas pantallas, pero debe configurar la biblioteca
correctamente para el tipo de matriz que se está utilizando.
A continuación, puede encontrar información sobre cómo conectar y configurar

las pantallas de matriz de puntos LED MAX7219.
Módulo FC-16 8×8 o 8×32

Esta es probablemente la pantalla MAX7219 más común que se puede
encontrar. Por lo general, viene como una matriz de LED de 8×8 u 8×32 y
puede comprarlos con diferentes colores de LED .

Orientación y conexiones del módulo

Puede conectar fácilmente varios módulos de 8×8 u 8×32 juntos para crear
una pantalla más grande. Por lo general, suelo soldar conectores macho rectos
en la parte posterior de los módulos y los conecto mediante puentes.
De esta forma puede desmontarlos sin tener que desoldar ninguna conexión.

228

La pantalla está orientada con el lado DIN a la derecha. Tenga en cuenta que el
texto serigrafiado en la parte posterior de la PCB puede estar al revés en esta
orientación.
DP A B C D E F G
+ ------------------------ +
| 7 6 5 4 3 2 1 0 | D0
CLK <---| 1 | D1 <--- CLK
CS <---| 2 | D2 <--- CS
DOUT <---| 3 | D3 <--- DIN
GND ----| O 4 | D4 ---- TIERRA
VCC ----| OO 5 | D5 ---- VCC
| OOO 6 | D6
| OOOO 7 | D7
+ ------------------------ +

Configuración de hardware en código
Arduino

Al configurar la pantalla en su código Arduino, debe configurar
HARDWARE_TYPE en FC16_HW y especificar la cantidad de dispositivos que
ha conectado. Una matriz de 8×8 cuenta como 1 dispositivo, por lo que si
desea controlar un módulo de 8×32, debe configurar MAX_DEVICES en 4 (una
pantalla de 8×32 contiene 4 circuitos integrados MAX7219).

// Hardware SPI:
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CS_PIN 2
// Create a new instance of the MD_MAX72XX class:

MD_Parola matrix = MD_Parola(HARDWARE_TYPE, CS_PIN,

229
MAX_DEVICES);
// For software SPI you also need to specify the DATA_PIN and
the CLK_PIN connections:
// #define DATA_PIN 3
// #define CLK_PIN 4

// MD_Parola matrix = MD_Parola(HARDWARE_TYPE, DATA_PIN,
CLK_PIN, CS_PIN, MAX_DEVICES);

Módulo genérico de 8×8

Este es un módulo de 8×8 montado en una PCB verde con el IC MAX7219
debajo de la matriz de LED. Se caracterizan por los conectores de 5 pines en
los extremos cortos de la PCB rectangular.

Orientación y conexiones del módulo

El módulo genérico debe orientarse con el MAX7219 IC en la parte superior.
Puede conectar varios módulos junto con algunos cables dupont cortos de
hembra a hembra. Simplemente conecte todos los pines del lado DOUT del
primer módulo al lado DIN del siguiente módulo.

230
C C D G V
L S I N C
K N D C
| | | | |
V V V | |
D7 D6 D5 D4 D3 D2 D1 D0
+------------------------+
| 7 6 5 4 3 2 1 0 | DP
| 1 | A
| 2 | B
| 3 | C
| O 4 | D
| O O 5 | E
| O O O 6 | F
| O O O O 7 | G
+------------------------+
| | | | |
V V V | |
C C D G V
L S O N C
K U D C
T

Configuración de hardware en código
Arduino

Para los módulos de visualización genéricos, debe establecer
HARDWARE_TYPE en GENERIC_HW . El resto de la configuración y
MAX_DEVICES es el mismo que para los módulos FC-16.

// Hardware SPI:
#define HARDWARE_TYPE MD_MAX72XX::GENERIC_HW
#define CS_PIN 2

MD_Parola matrix = MD_Parola(HARDWARE_TYPE, CS_PIN,
MAX_DEVICES);
// For software SPI you also need to specify the DATA_PIN and
the CLK_PIN connections:
// #define DATA_PIN 3

// MD_Parola matrix = MD_Parola(HARDWARE_TYPE, DATA_PIN,

231

Códigos de ejemplo de Arduino

A continuación, encontrará varios códigos de ejemplo que cubren las funciones
básicas de la biblioteca MD_Parola Arduino. Después de cada ejemplo, explicó
cómo funciona el código para que pueda modificarlo para adaptarlo a sus
necesidades. También puede encontrar más ejemplos cuando vaya a Archivo>
Ejemplos> MD_Parola en el IDE de Arduino, pero no incluyen ninguna
explicación, por lo que pueden ser un poco difíciles de seguir.

Código de ejemplo básico de Arduino para
imprimir texto

Con el código de ejemplo a continuación, puede imprimir texto en la pantalla
sin animaciones.
Puede cargar el código de ejemplo en su Arduino a través del IDE de Arduino.

Para este tutorial, utilicé esta pantalla de matriz de puntos LED estándar de
8x32, pero también puede usar otros tipos y/o tamaños (consulte la explicación
del código a continuación).

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
// Define hardware type, size, and output pins:

#define CS_PIN 3
// Create a new instance of the MD_Parola class with hardware

SPI connection:
MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, CS_PIN,
MAX_DEVICES);
// Setup for software SPI:

// #define DATAPIN 2

232
// MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, DATA_PIN,
void setup() {
// Intialize the object:
myDisplay.begin();
// Set the intensity (brightness) of the display (0-15):
myDisplay.setIntensity(0);
myDisplay.displayClear();
}
void loop() {
myDisplay.setTextAlignment(PA_CENTER);
myDisplay.print("Center");
delay(2000);
myDisplay.setTextAlignment(PA_LEFT);
myDisplay.print("Left");
delay(2000);
myDisplay.setTextAlignment(PA_RIGHT);
myDisplay.print("Right");
delay(2000);
myDisplay.setInvert(true);
myDisplay.print("Invert");
delay(2000);
myDisplay.setInvert(false);
myDisplay.print(1234);
delay(2000);
}

233
Debería ver el siguiente resultado:


El primer paso es incluir todas las bibliotecas Arduino necesarias. Como
mencioné antes, la biblioteca MD_MAX72XX implementa las funciones de
hardware de la matriz LED y la biblioteca MD_Parola los efectos de texto.
También deberá incluir la biblioteca SPI, que viene preinstalada en el IDE de
Arduino. Esta biblioteca se utiliza para la comunicación de la interfaz de
periféricos en serie entre la pantalla y Arduino.

#include <SPI.h>

A continuación, necesitamos especificar qué hardware estamos usando. Como
utilicé una pantalla estándar de 8×32 (también conocida como FC-16),
configuré HARDWARE_TYPE en FC16_HW. El número de circuitos integrados
MAX7219 en una pantalla de 8×32 es 4, por lo que configuró MAX_DEVICES
en 4. Por último, define a qué pin está conectado el pin CS de la pantalla ( pin
de salida 3 en este caso).

menciones CS_PIN, el compilador lo reemplazará con el valor 3 cuando se


234
#define CS_PIN 3

Después de esto, se crea una nueva instancia de la clase MD_Parola con la
función MD_Parola(). Esta función necesita tres parámetros, el primero es el
tipo de hardware, el segundo el pin CS y el tercero el número máximo de
dispositivos conectados.
Tenga en cuenta que he llamado al objeto MD_Parola 'myDisplay' pero también

puede usar otros nombres. Deberá cambiar 'myDisplay' por el nuevo nombre
en el resto del boceto.
Cuando desee utilizar SPI de software en lugar de SPI de hardware, también

debe definir los pines de salida de reloj y datos y pasarlos como parámetros al
configurar el objeto de visualización.

SPI connection:
MAX_DEVICES);


En la sección de configuración del código, primero inicializamos el objeto con la
función begin(). El brillo de la pantalla se puede configurar con la función
setIntensity(). Puede ingresar un valor entre 0 (brillo mínimo) y 15 (brillo
máximo). La pantalla se borra con la función displayClear().

void setup() {
myDisplay.begin();
}

235

En la sección de bucle del código, primero establecemos la alineación del texto
que se imprimirá con la función setTextAlignment (). Puede alinear el texto a la
izquierda, al centro y a la derecha con PA_LEFT, PA_CENTER y PA_RIGHT
respectivamente.
A continuación, se imprime la cadena 'Centro'

myDisplay.print("Center"). Tenga en cuenta que debe colocar comillas
("") alrededor del texto, ya que estamos imprimiendo una cadena de texto.
Cuando desee imprimir números, no son necesarias las comillas. Por ejemplo
myDisplay.print(1234). Puede invertir la pantalla, es decir, los LED
normalmente encendidos se apagan y viceversa, con
myDisplay.setInvert(true).

void loop() {
myDisplay.print("Center");
delay(2000);
myDisplay.setTextAlignment(PA_LEFT);
myDisplay.print("Left");
delay(2000);
myDisplay.setTextAlignment(PA_RIGHT);
myDisplay.print("Right");
delay(2000);
myDisplay.setInvert(true);
myDisplay.print("Invert");
delay(2000);
myDisplay.setInvert(false);
myDisplay.print(1234);
delay(2000);
}

236

Código de ejemplo de Arduino de texto en
desplazamiento

Cuando desee imprimir un mensaje en una pantalla de matriz de puntos, a
menudo encontrará que la pantalla es demasiado pequeña para ajustarse a
todo el mensaje. La solución está en la biblioteca MD_Parola, lo que hace que
sea muy fácil crear efectos de texto de desplazamiento. En los siguientes
ejemplos, le mostraré cómo configurar esto, así cómo cómo usar algunos de los
otros efectos de texto disponibles.

#include <SPI.h>

#define CS_PIN 3

SPI connection:
MAX_DEVICES);


237
void setup() {
myDisplay.begin();
myDisplay.displayText("Scrolling text", PA_CENTER, 100, 0,
PA_SCROLL_LEFT, PA_SCROLL_LEFT);
}
void loop() {
if (myDisplay.displayAnimate()) {
myDisplay.displayReset();
}
}


La primera parte del código hasta el final de la sección de configuración es
exactamente la misma que en el ejemplo anterior. Al final de la sección de
configuración, especificamos cómo queremos mostrar el texto con la función
displayText(pText, align, speed, pause, effectIn,
effectOut). Esta función toma 5 argumentos.
El primer parámetro es la cadena de texto, en este caso "Texto en

desplazamiento".
El segundo argumento establece la alineación del texto durante la pausa

opcional. Puede utilizar las mismas opciones de alineación que en el ejemplo
anterior, es decir, PA_CENTER, PA_LEFT o PA_RIGHT.

238

Los argumentos tercero y cuarto establecen la velocidad de la animación y el
tiempo de pausa respectivamente. La velocidad de la pantalla es el tiempo en
milisegundos entre los cuadros de animación. Cuanto menor sea este tiempo,
más rápida será la animación. Si desea pausar el texto entre la animación de
entrada y salida, puede establecer el tiempo de pausa en milisegundos. Lo
puse en cero para que el texto se desplace continuamente.
A continuación, se especifican los efectos de entrada y salida. En este caso

utilicé PA_SCROLL_LEFT para ambos. Consulte el ejemplo siguiente para ver
otros efectos de texto.

myDisplay.displayText("Scrolling text", PA_CENTER, 100, 0,
PA_SCROLL_LEFT, PA_SCROLL_LEFT);

En la sección de bucle, solo necesita dos funciones para crear una pantalla de
texto con desplazamiento.
Primero, usamos la función displayAnimate() en una declaración if. Esta

función anima la pantalla utilizando el texto y los parámetros de animación
especificados actualmente y devuelve verdadero cuando la animación ha
terminado. Cuando la animación ha terminado, reiniciamos la pantalla con la
función displayReset()para que el texto se muestre en un bucle.

void loop() {
}
}

Otros efectos de texto

La biblioteca incluye varios otros efectos de texto que puede utilizar:
● PA_PRINT,
● PA_SCAN_HORIZ,
● PA_SCROLL_LEFT,
● PA_WIPE,
● PA_SCROLL_UP_LEFT,

239
● PA_SCROLL_UP,
● PA_OPENING_CURSOR,
● PA_GROW_UP,
● PA_MESH,
● PA_SCROLL_UP_RIGHT,
● PA_BLINDS,
● PA_CLOSING,
● PA_RANDOM,
● PA_GROW_DOWN,
● PA_SCAN_VERT,
● PA_SCROLL_DOWN_LEFT,
● PA_WIPE_CURSOR,
● PA_DISSOLVE,
● PA_OPENING,
● PA_CLOSING_CURSOR,
● PA_SCROLL_DOWN_RIGHT,
● PA_SCROLL_RIGHT,
● PA_SLICE,
● PA_SCROLL_DOWN

El siguiente código de ejemplo muestra los diferentes efectos para que pueda
ver cómo se ven.

#include <SPI.h>
int i = 0;
textEffect_t texteffect[] =
{
PA_PRINT,
PA_SCAN_HORIZ,
PA_SCROLL_LEFT,
PA_WIPE,
PA_SCROLL_UP_LEFT,
PA_SCROLL_UP,
PA_OPENING_CURSOR,

240
PA_GROW_UP,
PA_MESH,
PA_SCROLL_UP_RIGHT,
PA_BLINDS,
PA_CLOSING,
PA_RANDOM,
PA_GROW_DOWN,
PA_SCAN_VERT,
PA_SCROLL_DOWN_LEFT,
PA_WIPE_CURSOR,
PA_DISSOLVE,
PA_OPENING,
PA_CLOSING_CURSOR,
PA_SCROLL_DOWN_RIGHT,
PA_SCROLL_RIGHT,
PA_SLICE,
PA_SCROLL_DOWN
};

#define CS_PIN 3

SPI connection:
MAX_DEVICES);

void setup() {

241
myDisplay.begin();
myDisplay.setPause(1000);
myDisplay.setSpeed(100);
}
void loop() {
if (i < sizeof(texteffect)) {
i++;
}
else {
i = 0;
}
myDisplay.displayText("Hello",
myDisplay.getTextAlignment(), myDisplay.getSpeed(),
myDisplay.getPause(), texteffect[i], texteffect[i]);
}
}

Sprites de texto

Una función relativamente nueva de la biblioteca MD_Parola son los sprites de
texto animados. En gráficos por computadora, un sprite es un mapa de bits
bidimensional que se integra en una escena más grande (en este caso, la
pantalla de matriz).
Un objeto se compone de una serie de fotogramas que se ejecutan

secuencialmente para hacer la animación en la pantalla. Una vez que la
animación llega al último fotograma, se reinicia desde el primer fotograma.
Tenga en cuenta que utilicé una pantalla de matriz de 8×64 para este ejemplo
conectando dos pantallas de 8×32 juntas (MAX_DEVICES está configurado en
8).

242

#include <SPI.h>

#define CS_PIN 3

SPI connection:
MAX_DEVICES);

// Sprite definitions:
const uint8_t F_PMAN1 = 6;
const uint8_t W_PMAN1 = 8;
const uint8_t PROGMEM pacman1[F_PMAN1 * W_PMAN1] = //
gobbling pacman animation
{
0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c,
0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c,
};

const uint8_t PROGMEM pacman2[F_PMAN2 * W_PMAN2] = // pacman
pursued by a ghost
{
0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c, 0x00, 0x00,

243
0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,

0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00,
0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00,
0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00,
};
const uint8_t F_WAVE = 14;

const uint8_t W_WAVE = 14;
const uint8_t PROGMEM wave[F_WAVE * W_WAVE] = // triangular
wave/worm
{
0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
0x80, 0x40, 0x20, 0x10,
0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
0x40, 0x80, 0x40, 0x20,
0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10,
0x20, 0x40, 0x80, 0x40,
0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08,
0x10, 0x20, 0x40, 0x80,
0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04,
0x08, 0x10, 0x20, 0x40,
0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02,
0x04, 0x08, 0x10, 0x20,
0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
0x02, 0x04, 0x08, 0x10,
0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02,
0x01, 0x02, 0x04, 0x08,
0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04,
0x02, 0x01, 0x02, 0x04,
0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08,
0x04, 0x02, 0x01, 0x02,
0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10,
0x08, 0x04, 0x02, 0x01,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20,

244
0x10, 0x08, 0x04, 0x02,

0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40,
0x20, 0x10, 0x08, 0x04,
0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x40, 0x20, 0x10, 0x08,
};
const uint8_t F_ROLL1 = 4;

const uint8_t W_ROLL1 = 8;
const uint8_t PROGMEM roll1[F_ROLL1 * W_ROLL1] = // rolling
square
{
0xff, 0x8f, 0x8f, 0x8f, 0x81, 0x81, 0x81, 0xff,
0xff, 0xf1, 0xf1, 0xf1, 0x81, 0x81, 0x81, 0xff,
0xff, 0x81, 0x81, 0x81, 0xf1, 0xf1, 0xf1, 0xff,
0xff, 0x81, 0x81, 0x81, 0x8f, 0x8f, 0x8f, 0xff,
};

octagon
{
0x3c, 0x4e, 0x8f, 0x8f, 0x81, 0x81, 0x42, 0x3c,
0x3c, 0x72, 0xf1, 0xf1, 0x81, 0x81, 0x42, 0x3c,
0x3c, 0x42, 0x81, 0x81, 0xf1, 0xf1, 0x72, 0x3c,
0x3c, 0x42, 0x81, 0x81, 0x8f, 0x8f, 0x4e, 0x3c,
};
const uint8_t F_LINES = 3;

const uint8_t W_LINES = 8;
const uint8_t PROGMEM lines[F_LINES * W_LINES] = // spaced
lines
{
0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00,
0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00,
0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff,
};
const uint8_t F_ARROW1 = 3;

const uint8_t W_ARROW1 = 10;

245
const uint8_t PROGMEM arrow1[F_ARROW1 * W_ARROW1] = // arrow

fading to center
{
0x18, 0x3c, 0x7e, 0xff, 0x7e, 0x00, 0x00, 0x3c, 0x00, 0x00,
0x18, 0x3c, 0x7e, 0xff, 0x00, 0x7e, 0x00, 0x00, 0x18, 0x00,
0x18, 0x3c, 0x7e, 0xff, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x18,
};

fading to outside
{
0x18, 0x3c, 0x7e, 0xe7, 0x00, 0x00, 0xc3, 0x00, 0x00,
0x18, 0x3c, 0x7e, 0xe7, 0xe7, 0x00, 0x00, 0x81, 0x00,
0x18, 0x3c, 0x7e, 0xe7, 0x00, 0xc3, 0x00, 0x00, 0x81,
};
const uint8_t F_SAILBOAT = 1;

const uint8_t W_SAILBOAT = 11;
const uint8_t PROGMEM sailboat[F_SAILBOAT * W_SAILBOAT] = //
sail boat
{
0x10, 0x30, 0x58, 0x94, 0x92, 0x9f, 0x92, 0x94, 0x98, 0x50,
0x30,
};
const uint8_t F_STEAMBOAT = 2;

const uint8_t W_STEAMBOAT = 11;
const uint8_t PROGMEM steamboat[F_STEAMBOAT * W_STEAMBOAT] =
// steam boat
{
0x10, 0x30, 0x50, 0x9c, 0x9e, 0x90, 0x91, 0x9c, 0x9d, 0x90,
0x71,
0x10, 0x30, 0x50, 0x9c, 0x9c, 0x91, 0x90, 0x9d, 0x9e, 0x91,
0x70,
};
const uint8_t F_HEART = 5;

const uint8_t W_HEART = 9;
const uint8_t PROGMEM heart[F_HEART * W_HEART] = // beating

246
heart
{
0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
0x0e, 0x1f, 0x33, 0x66, 0xcc, 0x66, 0x33, 0x1f, 0x0e,
0x0e, 0x1f, 0x3f, 0x7e, 0xfc, 0x7e, 0x3f, 0x1f, 0x0e,
0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
};
const uint8_t F_INVADER = 2;

const uint8_t W_INVADER = 10;
const uint8_t PROGMEM invader[F_INVADER * W_INVADER] = //
space invader
{
0x0e, 0x98, 0x7d, 0x36, 0x3c, 0x3c, 0x36, 0x7d, 0x98, 0x0e,
0x70, 0x18, 0x7d, 0xb6, 0x3c, 0x3c, 0xb6, 0x7d, 0x18, 0x70,
};
const uint8_t F_ROCKET = 2;

const uint8_t W_ROCKET = 11;
const uint8_t PROGMEM rocket[F_ROCKET * W_ROCKET] = // rocket
{
0x18, 0x24, 0x42, 0x81, 0x99, 0x18, 0x99, 0x18, 0xa5, 0x5a,
0x81,
0x18, 0x24, 0x42, 0x81, 0x18, 0x99, 0x18, 0x99, 0x24, 0x42,
0x99,
};
const uint8_t F_FBALL = 2;

const uint8_t W_FBALL = 11;
const uint8_t PROGMEM fireball[F_FBALL * W_FBALL] = //
fireball
{
0x7e, 0xab, 0x54, 0x28, 0x52, 0x24, 0x40, 0x18, 0x04, 0x10,
0x08,
0x7e, 0xd5, 0x2a, 0x14, 0x24, 0x0a, 0x30, 0x04, 0x28, 0x08,
0x10,
};
const uint8_t F_CHEVRON = 1;

const uint8_t W_CHEVRON = 9;

247
const uint8_t PROGMEM chevron[F_CHEVRON * W_CHEVRON] = //

chevron
{
0x18, 0x3c, 0x66, 0xc3, 0x99, 0x3c, 0x66, 0xc3, 0x81,
};
const uint8_t F_WALKER = 5;

const uint8_t W_WALKER = 7;
const uint8_t PROGMEM walker[F_WALKER * W_WALKER] = //
walking man
{
0x00, 0x48, 0x77, 0x1f, 0x1c, 0x94, 0x68,
0x00, 0x90, 0xee, 0x3e, 0x38, 0x28, 0xd0,
0x00, 0x00, 0xae, 0xfe, 0x38, 0x28, 0x40,
0x00, 0x00, 0x2e, 0xbe, 0xf8, 0x00, 0x00,
0x00, 0x10, 0x6e, 0x3e, 0xb8, 0xe8, 0x00,
};
void setup() {
myDisplay.begin();
myDisplay.setSpriteData(pacman2, W_PMAN2, F_PMAN2, pacman2,
W_PMAN2, F_PMAN2);
myDisplay.displayText("Parola sprites", PA_CENTER, 50, 1000,
PA_SPRITE, PA_SPRITE);
}
void loop() {
}
}* Example code for sprite text effect on MAX7219 LED dot
matrix display with Arduino. More info:
https://www.makerguides.com */

#include <SPI.h>

248

#define CS_PIN 3

SPI connection:
MAX_DEVICES);

{
};

const uint8_t PROGMEM pacman2[F_PMAN2 * W_PMAN2] = // pacman
pursued by a ghost
{
0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c, 0x00, 0x00,

249
0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00,
};
const uint8_t F_WAVE = 14;

const uint8_t W_WAVE = 14;
const uint8_t PROGMEM wave[F_WAVE * W_WAVE] = // triangular
wave/worm
{
0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
0x80, 0x40, 0x20, 0x10,
0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
0x40, 0x80, 0x40, 0x20,
0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10,
0x20, 0x40, 0x80, 0x40,
0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08,
0x10, 0x20, 0x40, 0x80,
0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04,
0x08, 0x10, 0x20, 0x40,
0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x02,
0x04, 0x08, 0x10, 0x20,
0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
0x02, 0x04, 0x08, 0x10,
0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02,
0x01, 0x02, 0x04, 0x08,
0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04,
0x02, 0x01, 0x02, 0x04,
0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08,
0x04, 0x02, 0x01, 0x02,
0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10,
0x08, 0x04, 0x02, 0x01,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20,
0x10, 0x08, 0x04, 0x02,
0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40,
0x20, 0x10, 0x08, 0x04,
0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x40, 0x20, 0x10, 0x08,

250
};

square
{
0xff, 0x8f, 0x8f, 0x8f, 0x81, 0x81, 0x81, 0xff,
0xff, 0xf1, 0xf1, 0xf1, 0x81, 0x81, 0x81, 0xff,
0xff, 0x81, 0x81, 0x81, 0xf1, 0xf1, 0xf1, 0xff,
0xff, 0x81, 0x81, 0x81, 0x8f, 0x8f, 0x8f, 0xff,
};

octagon
{
0x3c, 0x4e, 0x8f, 0x8f, 0x81, 0x81, 0x42, 0x3c,
0x3c, 0x72, 0xf1, 0xf1, 0x81, 0x81, 0x42, 0x3c,
0x3c, 0x42, 0x81, 0x81, 0xf1, 0xf1, 0x72, 0x3c,
0x3c, 0x42, 0x81, 0x81, 0x8f, 0x8f, 0x4e, 0x3c,
};
const uint8_t F_LINES = 3;

const uint8_t W_LINES = 8;
const uint8_t PROGMEM lines[F_LINES * W_LINES] = // spaced
lines
{
0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00,
0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00,
0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff,
};

fading to center
{
0x18, 0x3c, 0x7e, 0xff, 0x7e, 0x00, 0x00, 0x3c, 0x00, 0x00,
0x18, 0x3c, 0x7e, 0xff, 0x00, 0x7e, 0x00, 0x00, 0x18, 0x00,

251
0x18, 0x3c, 0x7e, 0xff, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x18,
};

fading to outside
{
0x18, 0x3c, 0x7e, 0xe7, 0x00, 0x00, 0xc3, 0x00, 0x00,
0x18, 0x3c, 0x7e, 0xe7, 0xe7, 0x00, 0x00, 0x81, 0x00,
0x18, 0x3c, 0x7e, 0xe7, 0x00, 0xc3, 0x00, 0x00, 0x81,
};
const uint8_t F_SAILBOAT = 1;

const uint8_t W_SAILBOAT = 11;
const uint8_t PROGMEM sailboat[F_SAILBOAT * W_SAILBOAT] = //
sail boat
{
0x10, 0x30, 0x58, 0x94, 0x92, 0x9f, 0x92, 0x94, 0x98, 0x50,
0x30,
};
const uint8_t F_STEAMBOAT = 2;

const uint8_t W_STEAMBOAT = 11;
const uint8_t PROGMEM steamboat[F_STEAMBOAT * W_STEAMBOAT] =
// steam boat
{
0x10, 0x30, 0x50, 0x9c, 0x9e, 0x90, 0x91, 0x9c, 0x9d, 0x90,
0x71,
0x10, 0x30, 0x50, 0x9c, 0x9c, 0x91, 0x90, 0x9d, 0x9e, 0x91,
0x70,
};
const uint8_t F_HEART = 5;

const uint8_t W_HEART = 9;
const uint8_t PROGMEM heart[F_HEART * W_HEART] = // beating
heart
{
0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
0x0e, 0x1f, 0x3f, 0x7e, 0xfc, 0x7e, 0x3f, 0x1f, 0x0e,

252

0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
};
const uint8_t F_INVADER = 2;

const uint8_t W_INVADER = 10;
const uint8_t PROGMEM invader[F_INVADER * W_INVADER] = //
space invader
{
0x0e, 0x98, 0x7d, 0x36, 0x3c, 0x3c, 0x36, 0x7d, 0x98, 0x0e,
0x70, 0x18, 0x7d, 0xb6, 0x3c, 0x3c, 0xb6, 0x7d, 0x18, 0x70,
};
const uint8_t F_ROCKET = 2;

const uint8_t W_ROCKET = 11;
const uint8_t PROGMEM rocket[F_ROCKET * W_ROCKET] = // rocket
{
0x18, 0x24, 0x42, 0x81, 0x99, 0x18, 0x99, 0x18, 0xa5, 0x5a,
0x81,
0x18, 0x24, 0x42, 0x81, 0x18, 0x99, 0x18, 0x99, 0x24, 0x42,
0x99,
};
const uint8_t F_FBALL = 2;

const uint8_t W_FBALL = 11;
const uint8_t PROGMEM fireball[F_FBALL * W_FBALL] = //
fireball
{
0x7e, 0xab, 0x54, 0x28, 0x52, 0x24, 0x40, 0x18, 0x04, 0x10,
0x08,
0x7e, 0xd5, 0x2a, 0x14, 0x24, 0x0a, 0x30, 0x04, 0x28, 0x08,
0x10,
};
const uint8_t F_CHEVRON = 1;

const uint8_t W_CHEVRON = 9;
const uint8_t PROGMEM chevron[F_CHEVRON * W_CHEVRON] = //
chevron
{
0x18, 0x3c, 0x66, 0xc3, 0x99, 0x3c, 0x66, 0xc3, 0x81,
};

253
const uint8_t F_WALKER = 5;

const uint8_t W_WALKER = 7;
const uint8_t PROGMEM walker[F_WALKER * W_WALKER] = //
walking man
{
0x00, 0x48, 0x77, 0x1f, 0x1c, 0x94, 0x68,
0x00, 0x90, 0xee, 0x3e, 0x38, 0x28, 0xd0,
0x00, 0x00, 0xae, 0xfe, 0x38, 0x28, 0x40,
0x00, 0x00, 0x2e, 0xbe, 0xf8, 0x00, 0x00,
0x00, 0x10, 0x6e, 0x3e, 0xb8, 0xe8, 0x00,
};
void setup() {
myDisplay.begin();
W_PMAN2, F_PMAN2);
}
void loop() {
}
}


Después de configurar la pantalla como antes, se definen los sprites de texto.
Se utilizan dos constantes para definir el sprite, una para los datos de ancho
( número de bytes) de un sprite y la otra para el número de fotogramas
contenidos en la animación. El número total de bytes necesarios es el ancho *
número de tramas. Tenga en cuenta que los datos del sprite se almacenan en
PROGMEM para ahorrar espacio en la RAM.

254
Cada fila de la matriz está formada por números hexadecimales que establecen
qué LED deben iluminarse en cada columna del sprite.
El ejemplo incluye muchas definiciones de sprites diferentes, que también

puede encontrar en uno de los ejemplos que vienen con la biblioteca.
{
};

En la configuración, la función setSpriteData(inData, inWidth,
inFrames, outData, outWidth, outFrames) se usa para configurar los
datos del usuario necesarios para que la biblioteca pueda mostrar el sprite
cuando se selecciona el tipo de animación PA_SPRITE en la
displayText()función.
Puedes seleccionar cualquiera de los sprites predefinidos, en este caso usé

pacman2 ( pacman perseguido por un fantasma).

W_PMAN2, F_PMAN2);

La sección de bucle es la misma que antes.

255

Ebook 10 Proyectos Con Arduino

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 10 Proyectos Con Arduino

Cargado por

Copyright:

Formatos disponibles

T OOS

PROYECTOS PARA INICIARSE

ING. JUAN DAMIÁN LUCERO

Cómo usar los sensores DHT11 y DHT22 con Arduino 31

Cómo utilizar el sensor de movimiento PIR HC-SR501 con Arduino 50

Agregar un termistor y/o LDR al HC-SR501 56

Cómo usar un sensor de distancia ultrasónico HC-SR04 con Arduino 66

TM1637 Tutorial de Arduino de display de 7 Segmentos 4 Dígitos 87

Cómo controlar servomotores con Arduino 106

Servomotor con conexiones de alimentación externa 112

Cómo controlar un motor paso a paso con A4988 y Arduino 129

Puntos de sonda Vref (GND y potenciómetro). 140

La guía completa para sensores de temperatura digitales DS18B20 156

Cómo usar un receptor de infrarrojos y un control remoto 186

Tutorial de Arduino con pantalla de matriz de puntos LED MAX7219 221

MAX7219 Hoja de datos 223

Cómo usar una pantalla

Especiﬁcaciones LCD 16x2

Controlador Controlador LCD Hitachi HD44780

Resolución de la pantalla 2 líneasx16 caracteres

Resolución de personaje 5x8 píxeles

Dimensiones del módulo 80x36x12 mm

Ver dimensiones del área 64,5x16,4 mm

1 VSS GND Arduino Señal de tierra

2 VDD 5V Arduino Potencia lógica para LCD

3 V0 Potenciómetro de 10 kΩ Ajuste de contraste

4 RS Pin 2 Arduino Registrar seleccionar

5 R/W GND Arduino Señal de selección de

6 E Pin 3 Arduino Señal de habilitación de

7 - 14 D0 - D7 - Líneas de bus de datos

11 - 14 D4 - D7 Pin 4 - 7 Arduino Líneas de bus de datos

15 A (LED 5 V Arduino Ánodo para

16 K (LED) GND Arduino Cátodo para

LCD de 16x2 caracteres x 1 Electrogeek

LCD de 20x4 caracteres x 1 Electrogeek

Arduino UNO R3 x 1 Electrogeek

Cables de protoboard ~ 10 Electrogeek

Cable USB tipo B x 1 Electrogeek

Potenciómetro de 10 kΩ x 1 Electrogeek

Resistencia (opcional) x 1 Electrogeek

Cableado de ajuste de contraste

Gire el potenciómetro hasta que vea aparecer una ﬁla de rectángulos.

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)

// Make custom characters:

// Create a new characters:

// Clears the LCD screen:

// Print a message to the lcd:

Cómo usar los sensores

En este tutorial, aprenderá cómo funcionan los sensores digitales de

Tensión de funcionamiento 3.3 - 5.5 V

Corriente de funcionamiento Medición: 0,3 mA, en espera: 60 μA

Rango de medición de humedad 5 - 95% HR ± 5% HR

Rango de medición de temperatura -20-60 ° C ± 2 ° C

Periodo de muestreo > 2 segundos