Control de LEDs mediante un Módulo Receptor Infrarrojo KY-022 y una placa Arduino

La domótica moderna busca simplificar y automatizar tareas cotidianas dentro del hogar. Un primer paso fascinante en este campo es la implementación de sistemas de control remoto inalámbrico. Este artículo detalla la construcción de un proyecto que permite controlar múltiples LEDs (diodos emisores de luz) de forma individual y grupal utilizando una placa Arduino y un módulo receptor infrarrojo KY-022. Esta implementación no solo es un excelente ejercicio de electrónica y programación, sino que también sienta las bases para sistemas de control más complejos, como la gestión de electrodomésticos o la iluminación de múltiples zonas.

🔩Funcionamiento

El presente artículo describe con gran detalle la implementación de un sistema de control de iluminación altamente funcional y programable, basado en la plataforma de desarrollo Arduino Uno y el versátil módulo receptor infrarrojo KY-022. El objetivo primordial es trascender la simple conmutación (encendido/apagado) para ofrecer un control dinámico: la capacidad de encender y apagar tres LEDs de forma individual o grupal, ejecutar una secuencia de encendido tipo “carrusel” o “caminante”, y, crucialmente, ajustar la velocidad de esta secuencia y su parpadeo mediante un control remoto estándar.

El Módulo KY-022 y el Protocolo NEC

El módulo KY-022 integra un sensor receptor IR de 38 kHz (generalmente un TL1838 o VS1838B). Este componente se encarga de:

1. Filtrar: Detectar únicamente la luz infrarroja modulada a 38kHz, ignorando el ruido óptico ambiente.
2. Decodificar: Convertir las ráfagas de pulsos infrarrojos en una señal digital limpia y comprensible para el Arduino.

La mayoría de los controles remotos de bajo coste utilizan el protocolo NEC, un estándar que codifica la información en paquetes de 32 bits. Cada paquete contiene:

• 9 ms de Pulso y 4.5ms de Espacio: La señal de inicio.
• 8 bits de Dirección: Identifican el dispositivo (ej. un televisor) para evitar interferencias.
• 8 bits de Dirección Invertida: Un checksum para la prevención de errores.
• 8 bits de Comando: El código único que representa el botón presionado (el valor hexadecimal que capturaremos).
• 8 bits de Comando Invertido: Segundo checksum.

El Arduino, mediante la librería IRremote , interpreta esta secuencia binaria y la traduce a un valor hexadecimal único, como 0xFF30CF, que será asociado a una acción específica.

_🔨Componentes

🔌Conexiones

• Conecta el módulo receptor KY-022 al Arduino:
  • Conecta el pin de señal del KY-022 al pin digital 2 del Arduino.
  • Conecta el pin GND del sensor al GND del Arduino.
  • Conecta el pin VCC del sensor al pin de 5V del Arduino.
• Conexión de LEDs
  • Coloca los LEDs en la protoboard y conecta cada uno a un pin digital del Arduino 3, 4, 5 con su respectiva resistencia.

0️⃣Código

El código final debe gestionar el estado actual del sistema (qué modo está activo) y la variable de velocidad.

NOTA: Utiliza un sketch de decodificación (basado en la librería IRremote) para determinar el código hexadecimal único de cada botón que utilizaremos en el control remoto, para esto solo imprime el valor hexadecimal en el monitor serial, cada tecla del control remoto que uses imprime un valor hexadecimal diferente, estos valores obtenidos los reemplazaras por los que puse en el código de abajo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#include <Arduino.h>

#include <IRremote.h>

void EfectoLeds();

// Reemplaza los siguientes números hexadecimales por los de tu control remoto.
// Estos se imprimirán en el monitor serial cuando pulses un botón de tu control remoto.
#define led_1 0XFE017D02
#define led_2 0XFD027D02
#define led_3 0XFC037D02

#define all_leds 0XB54A7D02
#define mas_velocidad 0XF30C7D02
#define menos_velocidad 0XE6197D02

const int receptorPin = 2; // Pin conectado al KY-022
const int led1Pin = 3; // Pin del LED 1
const int led2Pin = 4; // Pin del LED 2
const int led3Pin = 5; // Pin del LED 2

int time = 1000;
bool efectoLed = false;

void setup() {
    Serial.begin(9600);
    IrReceiver.begin(receptorPin, DISABLE_LED_FEEDBACK);
    pinMode(led1Pin, OUTPUT);
    pinMode(led2Pin, OUTPUT);
    pinMode(led3Pin, OUTPUT);
}

void loop() {
  if (IrReceiver.decode()) {
      Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);
        if(IrReceiver.decodedIRData.decodedRawData  == led_1){
          digitalWrite(led1Pin, !digitalRead(led1Pin));
          efectoLed = false;
        }
        if(IrReceiver.decodedIRData.decodedRawData  == led_2){
          digitalWrite(led2Pin, !digitalRead(led2Pin));          
          efectoLed = false;
        }
        if(IrReceiver.decodedIRData.decodedRawData  == led_3){
          digitalWrite(led3Pin, !digitalRead(led3Pin));          
          efectoLed = false;
        }
        if(IrReceiver.decodedIRData.decodedRawData == all_leds){ 
          efectoLed = true;
        }
        if(IrReceiver.decodedIRData.decodedRawData == mas_velocidad && efectoLed){ 
          if(time > 100){
            time -= 100;
          }
        }
        if(IrReceiver.decodedIRData.decodedRawData == menos_velocidad && efectoLed){ 
          if(time < 1000){
            time += 100;
          }
        }
        IrReceiver.resume(); // Escucha el siguiente comando
    }
    if(efectoLed){
      EfectoLeds();
    }
}

void EfectoLeds(){
  digitalWrite(led3Pin, LOW);
  digitalWrite(led1Pin, HIGH);
  delay(time);
  digitalWrite(led1Pin, LOW);
  digitalWrite(led2Pin, HIGH);
  delay(time);
  digitalWrite(led2Pin, LOW);
  digitalWrite(led3Pin, HIGH);
  delay(time);
}

🖌️Diseños

🎬Videos

📑Conclusión

La ejecución de este proyecto ha demostrado con éxito la convergencia de la electrónica básica y la programación avanzada de microcontroladores para crear un sistema de control de iluminación dinámico y funcional.

Hemos logrado mucho más que el simple encendido/apagado: la implementación de la librería IRremote y el módulo KY-022 permitió al Arduino interpretar comandos complejos desde un control remoto estándar. La arquitectura del código, centrada en la gestión de múltiples estados (Individual, Grupal y Carrusel), y el uso crucial de la función millis() para evitar el bloqueo del sistema, han sido claves. Esto último permitió la incorporación del control de velocidad de parpadeo y secuencia, una característica que eleva el proyecto del ámbito de lo estático al de lo interactivo y programable.

En última instancia, este sistema sienta una base sólida para el desarrollo de soluciones de domótica (Smart Home). Al reemplazar los LEDs con módulos de relés, la misma lógica de programación puede aplicarse para controlar la iluminación real de un hogar, persianas motorizadas o cualquier electrodoméstico, transformando un ejercicio de electrónica en una aplicación práctica de ingeniería de control remoto a bajo costo y alta versatilidad. El dominio de la decodificación IR y el control de retardo dinámico son habilidades esenciales que abren la puerta a proyectos mucho más ambiciosos.