En este tutorial, aprenderás a usar un IR mando a distancia y un receptor con Arduino. He incluido diagramas de conexión y varios códigos de ejemplo para ayudarte a empezar.
Siguiendo las instrucciones de este tutorial, podrás usar prácticamente cualquier mando IR (como el de tu televisor) para controlar dispositivos conectados al Arduino.
En los ejemplos de código a continuación, usaremos la IRremote librería de Arduino. Esta librería es bastante fácil de usar y es compatible con muchos protocolos de comunicación IR diferentes. Con los dos primeros ejemplos, podrás identificar el protocolo IR de tu mando y determinar qué código envía al pulsar una tecla o botón. Después, te mostraré cómo asignar el código recibido a los valores de las teclas y mostrar estos en el Monitor Serie o en una pantalla LCD. Por último, veremos cómo controlar las salidas del Arduino con un mando y receptor IR.
Materiales
Componentes de hardware
| IR remote and receiver | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Jumper wires | × 15 | Amazon |
| 16×2 character LCD display | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| 10 kΩ potentiometer (tipo breadboard) | × 1 | Amazon |
| Resistor assortment | × 1 | Amazon |
| LED assortment | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
¿Cómo funciona un mando a distancia y receptor infrarrojo (IR)?
Un mando y receptor IR se comunican transmitiendo y decodificando una señal en forma de radiación IR pulsada.
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 hasta 1 mm. Como los humanos solo podemos ver luz con longitudes de onda de aproximadamente 400 (violeta) a 700 (rojo) nanómetros, la radiación IR es invisible para el ojo humano.
Como la transmisión IR es un protocolo inalámbrico basado en un tipo de luz, necesita una línea de visión clara entre el transmisor (el mando) 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 la comunicación IR
Desafortunadamente, el LED IR de tu mando no es la única fuente de radiación IR. Cualquier objeto que tenga temperatura también emite en el espectro infrarrojo. Este fenómeno también lo utilizan las cámaras térmicas para detectar el calor.
Toda esta radiación IR ambiental puede interferir en la comunicación entre el mando y el receptor. Entonces, ¿cómo detecta el receptor solo la señal IR que viene del mando? 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 mando parpadea a una frecuencia específica. En la electrónica de consumo, esta frecuencia portadora suele ser de unos 38 kHz.
Esta frecuencia específica se utiliza para la transmisión IR comercial porque es poco común en la naturaleza y, por tanto, se puede distinguir de la IR ambiental.
El receptor está diseñado para dejar pasar solo la IR que llega a 38 kHz. Esto se consigue 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.
Protocolo de señal IR
¿Cómo es realmente una señal IR?
En la imagen de arriba, el eje vertical puede interpretarse como el voltaje que va al LED IR del mando y el eje horizontal es el tiempo. Así que cuando el LED IR está encendido, parpadea (modulado) a 38 kHz y cuando está apagado, no se aplica voltaje.
Lo importante es el tiempo que el LED IR permanece alto o bajo (encendido o apagado). En el protocolo NEC, que es uno de los más populares, los bits («1» o «0») se representan así:
Cada bit consiste en un pulso de 560 µs de la portadora de 38 kHz (unas 21 ciclos) seguido de una pausa. Un «1» lógico tiene un tiempo total de transmisión de 2,25 ms, mientras que un «0» lógico solo 1,125 ms.
El tiempo que la señal permanece alta o baja y el número de bits enviados por cada comando es diferente en cada protocolo IR. En el protocolo NEC, el mensaje total suele consistir en cuatro bytes de 8 bits.
Tipos de receptores IR
Los receptores IR, a veces llamados sensores IR o diodos de detección IR, suelen venir en dos formatos diferentes. Puedes comprar los diodos por separado o montados en una pequeña placa breakout.
Funcionan exactamente igual, así que no importa cuál uses. La única diferencia es que la placa breakout suele tener un pequeño LED que parpadea cada vez que el receptor detecta una señal, lo cual es útil para depurar.
Conectar un receptor IR al Arduino
Es muy fácil conectar un receptor IR al Arduino, ya que solo necesitas tres cables. El cable de salida puede conectarse a cualquiera de los pines digitales del Arduino. En este caso, lo conecté al pin 2 para los primeros ejemplos de abajo.
El pin de alimentación se conecta a 5 V y el pin central de tierra a GND. Si usas un receptor montado en una placa breakout, revisa las etiquetas en la PCB porque el orden de los pines puede ser diferente.
Las conexiones también se muestran en la tabla de abajo
Conexiones del receptor IR
| Receptor IR | Arduino |
|---|---|
| OUT (izquierda) | Pin 2 |
| GND (centro) | GND (-) |
| Vcc (derecha) | 5 V (+) |
Instalando la librería IRremote para Arduino
Para este tutorial, usaremos la popular librería IRremote. Esta librería es bastante fácil de usar y es compatible con muchos tipos de mandos IR.
Para instalar la librería, ve a Tools > Manage Libraries (Ctrl + Shift + I en Windows) en el Arduino IDE. Se abrirá el Library Manager y actualizará la lista de librerías instaladas.
Puedes buscar ‘IRremote’ y buscar la librería de shirriff y z3to. Selecciona la última versión y haz clic en Install.
Determinar el protocolo IR que usa tu mando
NEC es probablemente el protocolo de transmisión IR más conocido y extendido, ya que lo usan la mayoría de los dispositivos electrónicos de consumo fabricados en Japón. Sin embargo, existen muchos otros tipos de protocolos. Puede ser útil saber qué tipo de protocolo IR usa tu mando si quieres trabajar en proyectos más avanzados. O simplemente por curiosidad.
A fecha de septiembre de 2023, la librería IRremote es compatible con los siguientes protocolos IR:
- PulseWidth
- PulseDistance
- Apple
- Denon
- JVC
- LG
- LG2
- NEC
- NEC2
- Onkyo
- Panasonic
- Kaseikyo
- Kaseikyo Denon
- Kaseikyo Sharp
- Kaseikyo JVC
- Kaseikyo Mitsubishi
- RC5
- RC6
- Samsung
- Samsung48
- SamsungLG
- Sharp
- Sony
- Bang&Olufsen
- BoseWave
- Lego
- MagiQuest
- Whynter
- FAST
Con el siguiente código corto puedes identificar qué protocolo usa tu mando. También puedes probar con otros mandos que tengas en casa y ver si detecta el protocolo.
Buscador de protocolo de mando IR
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
IrReceiver.printIRResultShort(&Serial);
IrReceiver.resume();
}
}
He probado con tres mandos de mi casa y dos se detectaron como NEC, mientras que el tercero (de un aire acondicionado) fue UNKNOWN:
Sin embargo, existe una excelente librería llamada IRremoteESP8266, que soporta específicamente los protocolos de varios aires acondicionados. Así que, si quieres controlar tu aire acondicionado por IR, esa es la librería que debes usar, pero no es la que usamos aquí.
Nota: para mandos con protocolos desconocidos también verás el error «Overflow» además de la información del protocolo. Esto es simplemente porque no se pudo detectar el final del comando IR, ya que el protocolo era desconocido.
Encontrar los códigos de las teclas de tu mando
Como hay muchos tipos de mandos en el mercado (con diferente número de teclas y funciones), necesitamos determinar qué señal recibida corresponde a cada tecla.
La librería IRremote leerá la señal y devolverá toda la información sobre la señal en la siguiente Data Structure:
struct IRData {
decode_type_t protocol; // UNKNOWN, NEC, SONY, RC5, PULSE_DISTANCE, ...
uint16_t address; // Decoded address
uint16_t command; // Decoded command
uint16_t extra;
uint16_t numberOfBits; // Number of bits received for data
uint8_t flags; // IRDATA_FLAGS_IS_REPEAT, IRDATA_FLAGS_WAS_OVERFLOW
IRRawDataType decodedRawData; // Up to 32 bit decoded raw data,
uint32_t decodedRawDataArray[RAW_DATA_ARRAY_SIZE]; // 32 bit decoded raw data for send function.
irparams_struct *rawDataPtr; // Pointer of the raw timing data to be decoded.
};
Nos interesa especialmente la parte command de esa estructura. Aquí estará el código que envía el mando según la tecla que pulses. Imprimiendo el valor del comando en el Monitor Serie, podemos crear una tabla de conversión.
El siguiente código hace justo eso. Ten en cuenta que añadimos un retardo de 100 ms para ralentizar la impresión si se mantiene pulsada una tecla, lo que provocaría una impresión repetida.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Serial.println(command);
delay(100); // wait a bit
IrReceiver.resume();
}
}
Después de subir el código, abre el Monitor Serie. Ahora pulsa cada tecla del mando y apunta el valor correspondiente que veas en el Monitor Serie.
Para mi mando, que controla un reproductor de audio, obtuve los siguientes códigos:
| Tecla | Código |
|---|---|
| Play | 7 |
| Stop | 3 |
| Mute | 20 |
| Siguiente pista | 8 |
| Pista anterior | 2 |
| Subir volumen | 31 |
| Bajar volumen | 23 |
¡Tu tabla seguramente será diferente! Tendrás que crear la tuya propia para usar los ejemplos de código de abajo.
Imprimir nombres de teclas en el Monitor Serie
Ahora que sabemos qué código corresponde a cada tecla, podemos modificar el código para imprimir el nombre de la tecla pulsada en el Monitor Serie.
Para esto, usaremos una estructura de control switch case. Esto nos permite ejecutar un código diferente según la tecla pulsada.
El siguiente ejemplo de código imprime el nombre de la tecla en el Monitor Serie en vez del valor numérico como en el ejemplo anterior. Ten en cuenta que mantenemos el retardo para no saturar el receptor con señales repetidas si se mantiene pulsada una tecla.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
case 20:
Serial.println("MUTE");
break;
case 8:
Serial.println("NEXT");
break;
case 2:
Serial.println("PREV");
break;
case 31:
Serial.println("VOL+");
break;
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Esto es lo que veo en el Monitor Serie al pulsar algunas teclas de mi mando:
Si tu mando tiene teclas diferentes y envía códigos distintos a los de la tabla anterior, simplemente cambia el valor y el nombre de las líneas en la declaración switch case que se ve así:
case 31:
Serial.println("VOL+");
Estas líneas significan: cuando el valor del comando es igual a 31, imprime «VOL+» en el Monitor Serie. Si no hay una instrucción case para un valor de comando, se activa la cláusula default y se imprime «UNDEFINED».
Cómo funciona el código
La primera línea del código incluye la librería IRremote.hpp. Esta librería proporciona las funciones necesarias para interactuar con señales IR.
#include "IRremote.hpp"
A continuación, definimos el pin que recibirá las señales IR. En este caso, usamos el pin 2.
#define IR_RECEIVE_PIN 2
En la función setup(), iniciamos la comunicación serie a 9600 baudios. También iniciamos el receptor IR en el pin que definimos antes, con la retroalimentación LED activada. Eso significa que cada vez que se recibe un código, un LED en el Arduino (y en el módulo receptor IR) parpadeará, lo cual es útil para depurar.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
En la función loop(), comprobamos si el receptor IR ha decodificado una señal. Si es así, obtenemos el valor del comando de los datos decodificados.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Luego usamos una instrucción switch para interpretar el comando. Cada case corresponde a un comando diferente enviado desde el mando. Por ejemplo, si el comando es 7, el Arduino imprime «PLAY» en el monitor serie.
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
...
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
Después de interpretar el comando, esperamos 100 milisegundos y reanudamos el receptor IR. Esto permite decodificar la siguiente señal.
delay(100);
IrReceiver.resume();
}
}
Este código proporciona una base para leer e interpretar señales de un mando IR. Puedes modificarlo según tus necesidades.
Ejemplo de mando y receptor IR con Arduino y LCD
El siguiente ejemplo se puede usar para mostrar los valores de las teclas pulsadas en una pantalla LCD de caracteres. He escrito un tutorial detallado sobre el uso de pantallas LCD de caracteres que puedes encontrar aquí:
Si prefieres usar una LCD I2C que necesita menos conexiones, consulta el siguiente tutorial:
Para este ejemplo, conecté la salida del receptor IR al pin digital 8 en vez del 2. Las conexiones para la pantalla LCD de caracteres se muestran en el diagrama de cableado de abajo. Ten en cuenta que también necesitas un potenciómetro de 10 kΩ para ajustar el contraste de la pantalla y una resistencia de 220 Ω para controlar el brillo de la retroiluminación.
Las conexiones también se muestran en la tabla de abajo. El pin más a la izquierda de la LCD es el pin 1 (GND).
Conexiones de la LCD y el receptor IR
| Pin | Conexión |
|---|---|
| LCD pin 1 (GND) | Arduino GND |
| LCD pin 2 (VCC) | Arduino 5 V |
| LCD pin 3 (VO) | Pin central del potenciómetro |
| Pin izquierdo del potenciómetro | Arduino 5 V |
| Pin derecho del potenciómetro | Arduino GND |
| LCD pin 4 (RS) | Arduino pin 2 |
| LCD pin 5 (RW) | Arduino GND |
| LCD pin 6 (E) | Arduino pin 3 |
| LCD pin 11 (DB4) | Arduino pin 4 |
| LCD pin 12 (DB5) | Arduino pin 5 |
| LCD pin 13 (DB6) | Arduino pin 6 |
| LCD pin 14 (DB7) | Arduino pin 7 |
| LCD pin 15 (LED-anodo) | Arduino 5 V a través de resistencia de 220Ω |
| LCD pin 16 (LED-cátodo) | Arduino GND |
| IR receiver OUT (izquierda) | Arduino pin 8 |
| IR receiver GND (centro) | Arduino GND |
| IR receiver Vcc (derecha) | Arduino 5 V |
Si tienes algún problema con la pantalla LCD, consulta el tutorial de How to use a 16×2 character LCD with Arduino para más detalles.
Con el siguiente código de ejemplo, puedes mostrar la tecla pulsada en la LCD. De nuevo, si tu mando envía códigos diferentes, solo tienes que cambiar los valores de comando y los nombres de las teclas en la declaración switch case.
Ejemplo de código de mando y receptor IR con Arduino y pantalla LCD
Puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código.
#include "IRremote.hpp"
#include "LiquidCrystal.h"
// LCD object with pin parameters (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);
#define IR_RECEIVE_PIN 8
void setup() {
lcd.begin(16, 2); // LCD with 16 columns and 2 rows
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
lcd.print("PLAY");
break;
case 3:
lcd.print("STOP");
break;
case 20:
lcd.print("MUTE");
break;
case 8:
lcd.print("NEXT");
break;
case 2:
lcd.print("PREV");
break;
case 31:
lcd.print("VOL+");
break;
case 23:
lcd.print("VOL-");
break;
default:
lcd.print("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Deberías ver la siguiente salida en la LCD si pulsas la tecla VOL+. Ten en cuenta que puede que tengas que ajustar el potenciómetro para aumentar el contraste de la pantalla.
Controlar LEDs (salidas de Arduino) con mando y receptor IR
Aunque es divertido ver los valores de las teclas en el Monitor Serie o en una pantalla LCD, probablemente querrás usar el mando para algo más útil, es decir, controlar algo de verdad. En el siguiente ejemplo, te mostraré cómo encender y apagar LEDs con el mando. También puedes usar este tipo de código para controlar relés, luces y motores.
El código es muy parecido a los ejemplos anteriores, pero he añadido funcionalidad extra para controlar los LEDs.
Tendrás que montar el siguiente circuito para controlar los LEDs:
Los LEDs están conectados a los pines 2 al 5 del Arduino y la salida del receptor IR al pin 6. He usado resistencias de 470 Ω para limitar la corriente que pasa por los LEDs. La corriente típica de funcionamiento de los LEDs de 3 y 5 mm es de unos 20 mA. Puedes calcular el valor de la resistencia que necesitas con una online calculadora.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 6
#define RED_LED_PIN 2
#define YELLOW_LED_PIN 3
#define GREEN_LED_PIN 4
#define BLUE_LED_PIN 5
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT);
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW);
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
Explicación del código
Primero, de nuevo incluimos la librería IRremote.hpp, que proporciona funciones para trabajar con mandos IR.
#include "IRremote.hpp"
Después, definimos los números de pin para el receptor IR y los LEDs. Ten en cuenta que usamos un pin diferente (PIN 6) para el receptor en vez del anterior (PIN 2).
#define IR_RECEIVE_PIN 6 #define RED_LED_PIN 2 #define YELLOW_LED_PIN 3 #define GREEN_LED_PIN 4 #define BLUE_LED_PIN 5
Luego, definimos una función llamada toggleLED que cambia el estado de un pin de LED. Recibe un parámetro int que representa el número de pin del LED. Si el pin está en HIGH lo ponemos en LOW y viceversa. pin, que representa el número de pin del LED. Si el pin está en HIGH lo ponemos en LOW y viceversa.
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
En la función setup, inicializamos la comunicación serie a 9600 baudios. También inicializamos el receptor IR y configuramos los pines de los LEDs como salida. Por último, apagamos todos los LEDs.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
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);
}
En la función loop, comprobamos si el receptor IR ha recibido una señal. Si se recibe una señal, extraemos el comando de los datos IR decodificados. Según el comando, realizamos diferentes acciones.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
En este fragmento de código, tenemos tres casos para diferentes comandos recibidos del mando IR. Si el comando es 7, imprimimos «PLAY-BLUE» en el monitor serie y cambiamos el estado del LED azul. Para el comando 3, imprimimos «STOP-YELLOW» y cambiamos el estado del LED amarillo. Y para el comando 20, imprimimos «MUTE-GREEN» y cambiamos el estado del LED verde. Para cualquier otro comando, imprimimos «UNDEFINED-RED» y cambiamos el estado del LED rojo.
Después de realizar las acciones necesarias, añadimos un retardo de 100 milisegundos y reanudamos el receptor IR para escuchar la siguiente señal.
Conclusión
En este tutorial, te he mostrado cómo usar un mando y receptor IR con Arduino. Hemos visto varios ejemplos de código para determinar el protocolo IR e identificar los códigos de las teclas de tu mando.
Luego vimos cómo mostrar los valores de las teclas/botones en el Monitor Serie y en una pantalla LCD 16×2. Por último, te mostré cómo controlar las salidas del Arduino con el mando para encender y apagar algunos LEDs. Hay muchas más aplicaciones para receptores y mandos IR, así que no dudes en dejar sugerencias en los comentarios.
Si tienes alguna pregunta, sugerencia o crees que falta algo en este tutorial, por favor deja un comentario abajo.
Otros enlaces útiles de la web
- Arduino-IRremote
- IRremote – Arduino Reference
- Arduino Infrared Remote Tutorial : 7 Steps
- How to Set Up an IR Remote and Receiver on an Arduino
- Arduino IR Remote Controller Tutorial
- Arduino – Control LED’s with IR Remote Control
- IR Remote Control | Arduino Tutorial
