Cómo utilizar un receptor IR y un mando con Arduino

Cómo utilizar un receptor IR y un mando con Arduino

En este tutorial, aprenderás a utilizar un mando y un receptor IR con el Arduino. He incluido diagramas de cableado y varios códigos de ejemplo para ayudarte a empezar.

Siguiendo las instrucciones de este tutorial podrás utilizar prácticamente cualquier mando a distancia por infrarrojos (como el de tu televisor) para controlar cosas conectadas al Arduino.

En los ejemplos de código a continuación, vamos a utilizar la biblioteca IRremote Arduino . Esta biblioteca es bastante fácil de usar y soporta 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 cuando pulsas una tecla/botón. A continuación, le mostraré cómo asignar el código recibido a los valores de las teclas y mostrarlos en el Monitor Serial o en una pantalla LCD. Por último, veremos cómo controlar las salidas del Arduino con un mando y un receptor IR.

Si tiene alguna pregunta, deje un comentario a continuación.

Artículos recomendados


Suministros

Componentes de hardware

Mando a distancia y receptor IR× 1Amazon
Arduino Uno× 1Amazon
Cables de puente× 15Amazon
Pantalla LCD de 16×2 caracteres× 1Amazon
Tablero de pruebas× 1Amazon
Potenciómetro de 10 kΩ (tipo placa de pan)× 1Amazon
Surtido de resistencias× 1Amazon
Surtido de LEDs× 1Amazon
Cable USB tipo A/B× 1Amazon

Software

Arduino IDEArduino IDE

Makerguides.com participa en el Programa de Asociados de Amazon Services LLC, un programa de publicidad de afiliados diseñado para proporcionar un medio para que los sitios ganen honorarios de publicidad mediante la publicidad y los enlaces a productos en Amazon.com.


¿Cómo funciona un mando y un receptor de infrarrojos (IR)?

Un mando a distancia y un receptor IR se comunican entre sí mediante la transmisión y descodificación de 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 de 700 nm a 1 mm. Como el ser humano sólo puede 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 la luz visible resaltada (Fuente: Wikipedia)

Como 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 mando) y el receptor. Esto significa que no puede transmitir a través de paredes o techos, a diferencia del WiFi o el Bluetooth.

Fundamentos de la comunicación IR

Desgraciadamente, el LED IR del mando a distancia 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 es utilizado por las cámaras térmicas para detectar el calor.

LED IR en el extremo de un mando (Fuente: SparkFun)

Toda esta IR ambiental puede interferir en la comunicación entre el mando y el receptor. Entonces, ¿cómo hace el receptor para detectar sólo la señal de infrarrojos procedente del mando? La respuesta es la modulación de la señal.

Con la modulación de la señal, la fuente de luz IR situada en el extremo del mando a distancia parpadea con una frecuencia determinada. 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 de IR comercial porque es poco frecuente en la naturaleza y, por tanto, puede distinguirse del IR ambiental.

El receptor está construido de tal manera que sólo deja pasar los IR que llegan a 38 kHz. Para ello se utiliza un filtro de paso de banda y un amplificador. La señal binaria demodulada se envía al microcontrolador (el Arduino) donde se decodifica.

¿Qué aspecto tiene una señal de infrarrojos?

Protocolo NEC (Fuente: SB-Projects)

En la imagen de arriba, el eje vertical puede verse como el voltaje que va al LED IR en el mando y el eje horizontal es el tiempo. Así, cuando el LED está encendido, parpadea (se modula) a 38 kHz y cuando está apagado, no se aplica ninguna tensión.

Lo importante es la cantidad de tiempo que el LED IR 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 consiste en una ráfaga de portadora de 38 kHz de 560 µs de duración (unos 21 ciclos) seguida de una pausa. Un "1" lógico tiene un tiempo total de transmisión de 2,25 ms, mientras que un "0" lógico sólo 1,125 ms.

El 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 IR. En el protocolo NEC, el mensaje total suele constar de cuatro bytes de 8 bits.

Tipos de receptores IR

Los receptores de infrarrojos, a veces llamados sensores de infrarrojos o diodos de detección de infrarrojos, suelen tener 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 utilices. La única diferencia es que la placa de circuito impreso suele contener un pequeño LED que parpadea cada vez que el receptor detecta una señal, lo que puede ser útil para la depuración.


Conexión de un receptor de infrarrojos al Arduino

Es muy fácil conectar un receptor de infrarrojos al Arduino, ya que sólo hay que 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 de abajo.

La clavija de alimentación se conecta a 5 V y la clavija de tierra central a GND. Si utiliza un receptor montado en una placa de circuito impreso, compruebe las etiquetas de la PCB, ya que el orden de los pines puede ser diferente.

IR-remote-and-receiver-with-Arduino-wiring-diagram-schematic-circuit-tutorial-1
La clavija de salida del receptor IR se conecta a la clavija 2

Las conexiones también se indican en la siguiente tabla

Conexiones del receptor IR

Receptor IRArduino
OUT (izquierda)Clavija 2
GND (medio)GND
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 soporta muchos tipos diferentes de controles remotos IR. Puedes encontrar el código fuente de esta biblioteca aquí en GitHub.

Para instalar la biblioteca, vaya a Herramientas > Gestionar Bibliotecas (Ctrl + Shift + I en Windows) en el IDE de Arduino. El Gestor de Bibliotecas se abrirá y actualizará la lista de bibliotecas instaladas.

Instalar una librería Arduino paso 1 abrir Library Manager

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


Determine el protocolo IR utilizado por su mando a distancia

Esta sección es opcional

NEC es probablemente el protocolo de transmisión de infrarrojos más conocido y extendido, ya que es utilizado por la gran mayoría de los aparatos 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 utiliza tu mando si quieres trabajar en proyectos más avanzados. O puede que simplemente tengas curiosidad

La biblioteca IRremote soporta actualmente 18 protocolos IR diferentes:

  • Aiwa
  • BoseWave
  • Denon
  • Plato
  • JVC
  • Lego
  • LG
  • MagiQuest
  • Mitsubishi
  • NEC
  • Panasonic
  • Philips RC5
  • Philips RC6,
  • Samsung
  • Sanyo
  • Sharp
  • Sony
  • Whynter

Aunque la biblioteca es bastante antigua, se siguen añadiendo nuevos protocolos (véase el GitHub).

Con el código de abajo puedes identificar qué protocolo está usando tu mando. También puedes probar con otros mandos que tengas en casa y ver si puede detectar el protocolo.

Localizador de protocolos a distancia 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)) {
    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:
        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();
  }
}

He experimentado con algunos de los mandos a distancia de mi casa y he podido detectar los siguientes protocolos:

Detectados los protocolos IR de varios mandos a distancia

Cómo encontrar los códigos de las llaves del mando a distancia

Dado que existen muchos tipos de mandos a distancia en el mercado (diferente número de teclas y valores impresos en las mismas), tenemos que determinar qué señal recibida corresponde a cada tecla.

La librería IRremote leerá la señal y emitirá un código específico en forma de número hexadecimal en función de la tecla pulsada.

Imprimiendo esta salida en el Monitor Serial, podemos crear una tabla de conversión.

Puede copiar el código que aparece a continuación haciendo clic en la esquina superior derecha del campo de código.

/* Finding the key codes for your remote. More info: https://www.makerguides.com */

#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

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)) { // 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
  }
}

Después de haber cargado el código, abre el Monitor Serial (Ctrl + Shift + M en Windows). Ahora pulsa cada tecla del mando y registra el valor hexadecimal correspondiente que veas en el Monitor Serial.

Salida del monitor en serie

Observe que verá el código FFFFFFFF cuando pulse una tecla de forma continuada. Este es el código de repetición que envía el mando.

Para mi control remoto obtuve la siguiente tabla de conversión:

ClaveCódigo
POWER0xFD00FF
VOL+0xFD807F
FUNC/STOP0xFD40BF
│◄◄0xFD20DF
►││0xFDA05F
►►│0xFD609F
0xFD10EF
VOL-0xFD906F
0xFD50AF
00xFD30CF
EQ0xFDB04F
ST/REPT0xFD708F
10xFD08F7
20xFD8877
30xFD48B7
40xFD28D7
50xFDA857
60xFD6897
70xFD18E7
80xFD9867
90xFD58A7

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

Tenga en cuenta que su tabla probablemente tendrá un aspecto diferente. Tendrá que crear la suya propia para utilizarla en el resto de los ejemplos de código que aparecen a continuación.


Código de ejemplo de IR remoto y receptor Arduino - Imprimir los valores de las teclas en el Monitor Serial

Ahora que sabemos qué código (valor hexadecimal) corresponde a cada pulsación de tecla, podemos modificar el código para imprimir el valor de la tecla pulsada en el Monitor Serial.

Para ello, utilizaremos una estructura de control de caso de conmutación. Esto nos permite ejecutar un trozo de código diferente dependiendo de la tecla que se pulse.

El ejemplo de código de abajo imprime el valor de la clave en el Monitor Serial en lugar del valor hexadecimal como hicimos en el ejemplo anterior. Después de subir el código puedes leer la explicación de abajo para aprender cómo funciona el código.

/* IR remote and receiver Arduino example code. Print key values in the Serial Monitor. More info: https://www.makerguides.com */

#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 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)) { // decode the received signal and store it in results
    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:
        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:
        Serial.println("1");
        break ;
      case 0xFD8877:
        Serial.println("2");
        break ;
      case 0xFD48B7:
        Serial.println("3");
        break ;
      case 0xFD28D7:
        Serial.println("4");
        break ;
      case 0xFDA857:
        Serial.println("5");
        break ;
      case 0xFD6897:
        Serial.println("6");
        break ;
      case 0xFD18E7:
        Serial.println("7");
        break ;
      case 0xFD9867:
        Serial.println("8");
        break ;
      case 0xFD58A7:
        Serial.println("9");
        break ;
    }
    key_value = results.value; // store the value as key_value
    receiver.resume(); // reset the receiver for the next code
  }
}
Salida del monitor en serie

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

case 0xFD00FF: // si el valor es igual a 0xFD00FF
Serial.println("POWER"); // imprime "POWER" en el Monitor Serial

Estas líneas se traducen en: cuando results.value es igual a 0xFD00FF, imprime "POWER" en el Monitor Serial. Nuevamente note que necesita agregar "0x" antes de los valores que vio en el Monitor Serial en el ejemplo anterior.

Para evitar los dobles clics no deseados, puedes añadir un breve retardo (por ejemplo, 500 ms) al final del bucle.

Cómo funciona el código

El primer paso es incluir la biblioteca IRremote. Si recibe el mensaje de error "IRremote.h: No such file or directory", probablemente has olvidado instalar la biblioteca.

#include <IRremote.h> // include the IRremote library

A continuación, he definido a qué pin de Arduino se conecta la salida del receptor. La declaración #define se utiliza para dar un nombre a un valor constante. El compilador sustituirá cualquier referencia a esta constante por el valor definido cuando se compile el programa. Por lo tanto, en todos los casos en los que se menciona RECEIVER_PINel compilador lo sustituirá por el valor 2 al compilar el programa.

#define RECEIVER_PIN 2 // define el pin del receptor IR

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

IRrecv receiver(RECEIVER_PIN); // crear un objeto receptor de la clase IRrecv

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

decode_results results; // crear un objeto de resultados de la clase decode_results

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

unsigned long valor_clave = 0; // variable para almacenar el valor de la clave

En la sección de configuración del código, primero establecemos la tasa de datos para la comunicación serie en bits por segundo (tasa de baudios) a 9600. Asegúrate de que el Monitor Serial también está configurado con la misma velocidad de transmisión.

A continuación, inicializamos el receptor con la función enableIRIn(). La siguiente línea permite el parpadeo del LED incorporado en el Arduino. El blink13() parpadeará el LED conectado al pin digital 13 cada vez que el receptor reciba una señal del mando a distancia. Esto puede ser muy útil para la depuración.

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
}

La sección de bucle del código comienza con un declaración if comprueba una condición y ejecuta la sentencia o conjunto de sentencias que proceden si la condición es "verdadera". Cuando se recibe un código, la condición receiver.decode(&results) devuelve true y se ejecuta el resto del código.

Como he mencionado antes, cuando se pulsa continuamente una tecla empezamos a recibir 0xFFFFFFFF desde el mando. Esto significa una repetición de la tecla anterior. Como quiero seguir imprimiendo el valor de la tecla pulsada he añadido 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

valor_clave = resultados.valor; // almacenar el valor como valor_clave

al final del bucle. Cuando se recibe el código de repetición 0xFFFFFFFF, lo sustituimos por el valor de la clave anterior que almacenamos como key_value en la línea 86.

Después, la sentencia switch case se utiliza para comprobar el código recibido con los diferentes códigos de teclas que registramos en el ejemplo anterior. Los valores de las teclas correspondientes se imprimen entonces en el Monitor Serial en una nueva línea con la función Serial.println().

Al final de la sección del bucle, la función resume() que reinicia el receptor y lo prepara para recibir el siguiente código.

    receiver.resume(); // reiniciar el receptor para el siguiente código

Control remoto y receptor IR con Arduino y ejemplo de LCD

El siguiente ejemplo se puede utilizar para imprimir 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 puede encontrar aquí:

Si prefiere utilizar una pantalla LCD I2C que necesite menos conexiones, consulte el tutorial que aparece a continuación:

Para este ejemplo, conecté la salida del receptor IR al pin digital 8 en lugar del 2. Las conexiones para la pantalla LCD de caracteres se muestran en el diagrama de cableado de abajo. Tenga en cuenta que también necesita un potenciómetro de 10 kΩ para ajustar el contraste de la pantalla y una resistencia de 220 Ω para controlar el brillo de la luz de fondo.

IR-remote-y-receptor-con-Arduino-y-caracteres-LCD-ejemplo-cableado-diagrama-esquemático-circuito-tutorial-1
Control remoto y receptor IR con Arduino Uno y diagrama de cableado de la pantalla LCD de 16×2 caracteres

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

Conexiones del LCD y del receptor IR

PinConexión
Clavija 1 del LCD (GND)Arduino GND
Clavija 2 del LCD (VCC)Arduino 5 V
LCD pin 3 (VO)Potenciómetro de clavija central
Potenciómetro del pin izquierdoArduino 5 V
Potenciómetro de clavija derechaArduino GND
LCD pin 4 (RS)Arduino pin 2
LCD pin 5 (RW)Arduino GND
Clavija 6 del LCD (E)Arduino pin 3
Clavija 11 del LCD (DB4)Arduino pin 4
Clavija 12 del LCD (DB5)Arduino pin 5
Clavija 13 del LCD (DB6)Arduino pin 6
Clavija 14 del LCD (DB7)Arduino pin 7
Clavija 15 del LCD (ánodo del LED)Arduino 5 V a través de una resistencia de 220Ω
Clavija 16 del LCD (LED-cátodo)Arduino GND
Receptor IR OUT (izquierda)Arduino pin 8
Receptor IR GND (medio)Arduino GND
Vcc del receptor IR (derecha)Arduino 5 V

Si tiene algún problema con la pantalla LCD, consulte este tutorial para obtener más detalles.

Con el código de ejemplo de abajo, puede imprimir el valor de la tecla pulsada en la pantalla LCD. He programado el botón de encendido para que borre la pantalla.

De nuevo, si su mando envía códigos diferentes, sólo tiene que reemplazar los valores hexadecimales y los valores de clave correspondientes en la declaración del caso del interruptor.

Código de ejemplo de control remoto y receptor IR con Arduino y pantalla LCD

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

/* IR remote and receiver with Arduino and character LCD example code. More info: https://www.makerguides.com/ */

#include <IRremote.h> // include the IRremote library
#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)

#define RECEIVER_PIN 8 // 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 key value

void setup() {
  lcd.begin(16, 2); // enable LCD with 16 colums and 2 rows
  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)) { // decode the received signal and store it in results
    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
        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 ;
      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 ;
    }
    key_value = results.value; // store the value as key_value
    receiver.resume(); // reset the receiver for the next code
  }
}

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

Salida de la pantalla LCD

Controla los LEDs (salidas de Arduino) con el mando y el receptor IR

Aunque es divertido ver los valores de las teclas en el Monitor Serial o en una pantalla LCD, probablemente querrás usar el control remoto para algo más útil, es decir, para controlar realmente algo. En el siguiente ejemplo, le mostraré cómo encender y apagar los LEDs con el control remoto. También puedes usar este tipo de código para controlar relés, luces y motores.

El código es mayormente el mismo que el de los ejemplos anteriores, pero he añadido una función extra para controlar los LEDs.

Tendrás que crear el siguiente circuito para controlar los LEDs:

cómo-controlar-LEDs-con-remote-IR-infrarrojo-y-receptor-Arduino-diagrama-cableado-esquemático-circuito-tutorial-1
Diagrama de cableado para controlar los LEDs con el control remoto IR, el receptor y el Arduino

Los LEDs se conectan a los pines 2 a 5 del Arduino y la salida del receptor IR al pin 6. He utilizado unas resistencias de 470 Ω para limitar la corriente que pasa por los LEDs. La corriente de funcionamiento habitual de los LEDs de 3 y 5 mm es de unos 20 mA. Puedes determinar qué valor de resistencia necesitas con una calculadora online como ésta. A mí me gusta comprar estos surtidos de resistencias en Amazon para tener siempre a mano el valor adecuado.

/* Example code to control LEDs with an IR remote and receiver with Arduino. More info: https://www.makerguides.com/ */

#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

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;

void setup() {
  Serial.begin(9600); // begin serial communication at 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
  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(">>|");
        break ;
      case 0xFD10EF:
        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:
        Serial.println("1");
        toggleLED(RED_LED_PIN); // run the toggle LED function with the red LED pin as input
        break ;
      case 0xFD8877:
        Serial.println("2");
        toggleLED(YELLOW_LED_PIN);
        break ;
      case 0xFD48B7:
        Serial.println("3");
        toggleLED(GREEN_LED_PIN);;
        break ;
      case 0xFD28D7:
        Serial.println("4");
        toggleLED(BLUE_LED_PIN);
        break ;
      case 0xFDA857:
        Serial.println("5");
        break ;
      case 0xFD6897:
        Serial.println("6");
        break ;
      case 0xFD18E7:
        Serial.println("7");
        break ;
      case 0xFD9867:
        Serial.println("8");
        break ;
      case 0xFD58A7:
        Serial.println("9");
        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 pulsas los botones 1 - 4 del mando a distancia, puedes encender y apagar los LEDs correspondientes.


Explicación del código

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, definí los pines de Arduino a los que se conectan los LEDs y el receptor IR. En la sección de configuración, establecí los pines de los LEDs como salida y apagué todos los LEDs con digitalWrite(pin, value).

  pinMode(RED_LED_PIN, OUTPUT); // establece los pines del LED como salida
  pinMode(YELLOW_LED_PIN, OUTPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(BLUE_LED_PIN, OUTPUT);
  digitalWrite(RED_LED_PIN, LOW); // apaga todos los LEDs
  digitalWrite(YELLOW_LED_PIN, LOW);
  digitalWrite(GREEN_LED_PIN, LOW);
  digitalWrite(BLUE_LED_PIN, LOW);

La sección de bucle del código es en su mayor parte la misma que antes, pero ahora en lugar de limitarse a imprimir los valores de las teclas en el Monitor Serial, el toggleLED(pin) se llama a la función si se pulsan las teclas 0 a 4.

Esta función toma el pin específico del LED como entrada y enciende o apaga el LED si se pulsa la tecla. Tenga en cuenta que si pulsa continuamente una tecla, el LED se seguirá encendiendo y apagando.

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
  }

Dado que básicamente sólo estás controlando los 4 pines de salida del Arduino, también puedes utilizar esta función para encender y apagar relés.

Ahora bien, si simplemente escribes una función diferente y la llamas cuando se pulsa un botón específico, básicamente puedes controlar lo que quieras. Me encantaría saber qué cosas controlas con tu mando y sería genial que compartieras con los demás lectores cómo lo has implementado.


Conclusión

En este tutorial, te he mostrado cómo utilizar un mando y un receptor IR con Arduino. Hemos visto diferentes ejemplos de código para determinar el protocolo IR e identificar los códigos de las teclas IR para su control remoto. Luego vimos cómo mostrar los valores de las teclas/botones en el Monitor Serial y en una pantalla LCD de 16×2 caracteres. Por último, le mostré cómo controlar las salidas del Arduino con el control remoto para encender y apagar algunos LEDs. Hay muchas más aplicaciones para los receptores IR y los mandos a distancia, así que asegúrate de dejar algunas sugerencias en los comentarios.

Espero que este artículo te haya resultado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica y hacer cosas!

Me encantaría saber qué proyectos piensas construir (o has construido ya) con un mando y un receptor IR. Si tienes alguna pregunta, sugerencia, o si crees que faltan cosas en este tutorial, por favor deja un comentario abajo.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.

Licencia Creative Commons

3disease

Thursday 26th of January 2023

3intuitive

mejor servicio de escritura de papel personalizado

Viernes 21 de octubre de 2022

mejor servicio de escritura de papel https://studentpaperhelp.com/

ayuda con la tesis

Viernes 21 de octubre de 2022

write my persuasive paper https://ypaywallpapers.com/

escribir mi trabajo de matemáticas

Viernes 21 de octubre de 2022

papeles personalizados https://premiumpapershelp.com/

servicios de escritura de papel

Viernes 21 de octubre de 2022

write my economics paper https://papercranewritingservices.com/