Controla una bombilla de corriente alterna usando cualquier control remoto de infrarrojos con un Arduino y un relé.
En este tutorial, aprenderemos a utilizar un control remoto infrarrojo para operar una bombilla de CA a través de un Arduino y un módulo de relé. Este proyecto implica decodificar las señales del control remoto y utilizarlas para controlar el relé, que a su vez encenderá y apagará la bombilla de CA. Al final de este tutorial, podrás usar cualquier control remoto infrarrojo para controlar tu accesorio de luz.
Usaremos un receptor infrarrojo para captar las señales del control remoto, y el Arduino interpretará estas señales para realizar acciones específicas. El código proporcionado te permitirá seleccionar el tipo de control remoto (negro o blanco) y si estás usando un PCB o un módulo desnudo para el receptor. Asegúrate de ver el video asociado para obtener detalles y aclaraciones adicionales (en el video a las 0:00).
Hardware Explicado
Para este proyecto, los componentes principales incluyen la placa Arduino, un módulo receptor de infrarrojos y un módulo de relé. El receptor de infrarrojos es responsable de capturar las señales del control remoto y enviarlas a la Arduino. El módulo de relé actúa como un interruptor para controlar la bombilla de CA, permitiendo que se encienda y apague según las señales recibidas.
El receptor infrarrojo típicamente opera a una frecuencia de 38 kHz y puede detectar señales desde una distancia de aproximadamente 10 a 15 metros. Una vez que Arduino recibe la señal, la decodifica y utiliza el relé para controlar la energía de la bombilla.
Instrucciones de cableado
Comience a conectar el cableado conectando el módulo receptor infrarrojo al Arduino. El pin VCC del receptor se conecta al pin de 5V en el Arduino, y el pin de tierra se conecta a un pin GND. El pin de señal del receptor infrarrojo debe estar conectado a un pin digital.11en el Arduino.
A continuación, conecta el módulo de relé. El pin de control del relé debe estar conectado al pin digital.2en el Arduino. Además, conecta los pines VCC y GND del relé a los 5V y GND del Arduino, respectivamente. Finalmente, conecta la bombilla de CA al relé de acuerdo con las especificaciones del relé para asegurar un funcionamiento seguro.
Ejemplos de código y guía paso a paso
En la fase de configuración del programa, inicializamos la comunicación serie y configuramos el pin del relé. El identificadorRECV_PINse establece para11, que es donde se conecta el pin de señal del receptor infrarrojo. Esto nos permite recibir datos del control remoto.
void setup() {
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
pinMode(RELAY_PIN, OUTPUT); // define a pin for relay as OUTPUT
digitalWrite(RELAY_PIN, HIGH); // set relay to OFF at the beginning
}En la función de bucle, verificamos continuamente si hay señales entrantes del control remoto. Cuando se detecta una señal, el valor se decodifica y se toma la acción correspondiente según la tecla presionada.
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX); // Print the received value
robojaxValidateCode(results.value); // Validate the code
irrecv.resume(); // Receive the next value
}
delay(100);
}ElrobojaxValidateCodeLa función verifica el código recibido contra valores conocidos para el control remoto. Dependiendo de qué tecla se presione, ejecutará la acción correspondiente usando el relé.
void robojaxValidateCode(int cd) {
if (type == 'W' && !PCB) {
// Check White remote codes
for (int i = 0; i < sizeof(whiteRemote) / sizeof(int); i++) {
if (whiteRemote[i] == cd) {
Serial.print("Key pressed: ");
Serial.println(whiteRemoteKey[i]);
relayAction(whiteRemoteKey[i]); // Take action
}
}
}
}En esta función, el código verifica si la tecla presionada corresponde a los valores definidos en el array. Si se encuentra una coincidencia, llama alrelayActionfunción para encender o apagar el relé, dependiendo de la tecla presionada.
Demostración / Qué Esperar
Después de completar el cableado y subir el código, puedes usar tu control remoto infrarrojo para controlar la bombilla de AC. Presiona las teclas designadas en el control remoto, y el relé debería activar o desactivar la bombilla en consecuencia. Asegúrate de probar cada tecla para ver su respuesta (en el video a las 5:00).
Marcas de tiempo del video
- 00:00 Inicio
- 00:49 Introducción
- 02:00 Cableado y conexión
- 05:27 Explicación del código de Arduino
- 09:51 Demostración de control de una bombilla de CA con diferentes mandos a distancia.
- 13:13 Usando el control remoto de tu televisor para controlar la bombilla del aire acondicionado
Imágenes
/*
* Original library from - http://arcfn.com
*
* This Arduino code decodes any remote code and then you can control an AC load using a relay
* sold on eBay for Arduino.
* You have to select the type of your remote as Black or White in the code below
* and also select your receiver 1838 as either a PCB or bare module. See video for details
*
* You have to watch this video: https://youtu.be/muAkBQb24NI
* before proceeding with this code.
*
* Modified/Written by Ahmad Shamshiri
* on July 31, 2018 at 20:33 in Ajax, Ontario, Canada
* for Robojax.com
* Watch video instructions for this code: https://youtu.be/j5kb0WBpD30
* Get other Arduino codes from Robojax.com
*
*/
#include <IRremote.h>
int RECV_PIN = 11;
const char type ='W';// W for white, B for black. Must keep single quotes like 'B' or 'W'
const boolean PCB = 1;// if receiver is PCB set to 1, if not set to 0. See video for details
boolean displayCode = true;// to display remote code. if not, set to false
//***** Relay settings begins
const int RELAY_PIN = 2;//
const String ON="3";// turn relay ON with + key on remote
const String OFF="1";// turn relay OFF with - key on remote
//**** Relay settings ends
IRrecv irrecv(RECV_PIN);
// this is array holding codes for White Remote when used with PCB version of receiver
unsigned int whiteRemotePCB[] ={
0xE318261B, // CH-
0x511DBB, // CH
0xEE886D7F, // CH+
0x52A3D41F, // |<<
0xD7E84B1B, // >>|
0x20FE4DBB, // >||
0xF076C13B, // -
0xA3C8EDDB, // +
0x12CEA6E6, // EQ
0xC101E57B, // 0
0x97483BFB, // 100+
0xF0C41643, // 200+
0x9716BE3F, // 1
0x3D9AE3F7, // 2
0x6182021B, // 3
0x8C22657B, // 4
0x488F3CBB, // 5
0x449E79F, // 6
0x32C6FDF7, // 7
0x1BC0157B, // 8
0x3EC3FC1B // 9
};
// this is array holding codes for White Remote when used with non-PCB version of receiver
unsigned int whiteRemote[] ={
0xFFA25D, // CH-
0xFF629D, // CH
0xFFE21D, // CH+
0xFF22DD, // |<<
0xFF02FD, // >>|
0xFFC23D, // >||
0xFFE01F, // -
0xFFA857, // +
0xFF906F, // EQ
0xFF6897, // 0
0xFF9867, // 100+
0xFFB04F, // 200+
0xFF30CF, // 1
0xFF18E7, // 2
0xFF7A85, // 3
0xFF10EF, // 4
0xFF38C7, // 5
0xFF5AA5, // 6
0xFF42BD, // 7
0xFF4AB5, // 8
0xFF52AD // 9
};
// key lables of white remote
String whiteRemoteKey[] ={
"CH-",
"CH",
"CH+",
"|<<",
">>|",
">||",
"-",
"+",
"EQ",
"0",
"100+",
"200+",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9"
};
// this is array holding codes for Black Remote when used with non-PCB version of receiver
unsigned int blackRemote[] ={
0xFF629D, // ^
0xFF22DD, // <
0xFF02FD, // OK
0xFFC23D, // >
0xFFA857, // v
0xFF6897, // 1
0xFF9867, // 2
0xF0C41643, // 3
0xFF30CF, // 4
0xFF18E7, // 5
0xFF7A85, // 6
0xFF10EF, // 7
0xFF38C7, // 8
0xFF5AA5, // 9
0xFF42BD, // *
0xFF4AB5, // 0
0xFF52AD // #
};
// this is array holding codes for Black Remote when used with PCB version of receiver
unsigned int blackRemotePCB[] ={
0x511DBB, // ^
0x52A3D41F, // <
0xD7E84B1B, // OK
0x20FE4DBB, // >
0xA3C8EDDB, // v
0xC101E57B, // 1
0x97483BFB, // 2
0xF0C41643, // 3
0x9716BE3F, // 4
0x3D9AE3F7, // 5
0x6182021B, // 6
0x8C22657B, // 7
0x488F3CBB, // 8
0x449E79F, // 9
0x32C6FDF7, // *
0x1BC0157B, // 0
0x3EC3FC1B // #
};
// Black remote key names
String blackRemoteKey[] ={
"^",
"<",
"OK",
">",
"v",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"*",
"0",
"#"
};
decode_results results;
void setup()
{
Serial.begin(9600);
// In case the interrupt driver crashes on setup, give a clue
// to the user what's going on.
Serial.println("Robojax IR Decode");
Serial.println("Control Relay with Remote");
irrecv.enableIRIn(); // Start the receiver
pinMode(RELAY_PIN,OUTPUT);// define a pin for relay as OUTPUT
digitalWrite(RELAY_PIN, HIGH);// set relay to OFF at the begining
}
void loop() {
if (irrecv.decode(&results)) {
if(displayCode)Serial.println(results.value, HEX);
robojaxValidateCode(results.value);// used the "robojaxValidateCode" bellow
irrecv.resume(); // Receive the next value
}
delay(100);
}
/*
* function: robojaxValidateCode
* validates the remote code and prints the correct key name
* cd is code passed from the loop
* Written by A. S. for Robojax
*/
void robojaxValidateCode(int cd)
{
// Robojax IR Remote decoder
int found=0;
if(type =='W' && !PCB)
{
// Robojax IR White Remote decoder
// if type is set to 'W' (white remote) and PCB=0 then check White remote code
for(int i=0; i< sizeof(whiteRemote)/sizeof(int); i++)
{
if(whiteRemote[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(whiteRemoteKey[i]);
relayAction(whiteRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}else if(type =='W' && PCB){
// Robojax IR White Remote decoder
// if type is set to 'W' (white remote) and PCB=1 then check White remote code
for(int i=0; i< sizeof(whiteRemotePCB)/sizeof(int); i++)
{
if(whiteRemotePCB[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(whiteRemoteKey[i]);
relayAction(whiteRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}else if(type =='B' && PCB){
// Robojax IR Black Remote decoder
// if type is set to 'B' (black remote) and PCB=1 then check Black remote code
for(int i=0; i< sizeof(blackRemotePCB)/sizeof(int); i++)
{
// Robojax IR black Remote decoder
if(blackRemotePCB[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(blackRemoteKey[i]);
relayAction(blackRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}else{
// if type is set to 'B' (black remote) and PCB =0 then check Black remote code
for(int i=0; i< sizeof(blackRemote)/sizeof(int); i++)
{
// Robojax IR black Remote decoder
if(blackRemote[i] ==cd)
{
Serial.print("Key pressed:");
Serial.println(blackRemoteKey[i]);
relayAction(blackRemoteKey[i]);// take action
found=1;
}// if matched
}// for
}// else
if(!found){
if(cd !=0xFFFFFFFF)
{
Serial.println("Key unknown");
}
}// found
}// robojaxValidateCode end
/*
*
* relayAction()
* receives string "value" as input and based on the settings,
* turns relay pin HIGH or LOW
*/
void relayAction(String value)
{
// Robojax IR Relay control
if(value == ON)
{
digitalWrite(RELAY_PIN, LOW);// Turn relay ON
Serial.println("Relay Turned ON");
}
if(value == OFF)
{
digitalWrite(RELAY_PIN, HIGH);// Turn relay OFF
Serial.println("Relay Turned OFF");
}
}//relayAction endCosas que podrías necesitar
-
Amazonas
-
eBay
Recursos y referencias
Aún no hay recursos.
Archivos📁
No hay archivos disponibles.
