Controlla una lampadina a LED con corrente alternata usando un telecomando infrarossi e un Arduino con un relè.
In questo tutorial, impareremo come utilizzare un telecomando a infrarossi per controllare una lampadina AC tramite un Arduino e un modulo relè. Questo progetto prevede la decodifica dei segnali dal telecomando e il loro uso per controllare il relè, che a sua volta accenderà e spegnerà la lampadina AC. Alla fine di questo tutorial, sarai in grado di utilizzare qualsiasi telecomando a infrarossi per controllare il tuo apparecchio di illuminazione.
Utilizzeremo un ricevitore a infrarossi per catturare i segnali del telecomando, e l'Arduino interpreterà questi segnali per eseguire azioni specifiche. Il codice fornito ti permetterà di selezionare il tipo di telecomando (nero o bianco) e se stai utilizzando un PCB o un modulo nudo per il ricevitore. Assicurati di guardare il video associato per ulteriori dettagli e chiarimenti (nel video a :00).
Hardware Spiegato
Per questo progetto, i componenti principali includono la scheda Arduino, un modulo ricevitore a infrarossi e un modulo relè. Il ricevitore a infrarossi è responsabile della cattura dei segnali dal telecomando e dell'invio a Arduino. Il modulo relè funge da interruttore per controllare la lampadina AC, consentendole di accendersi e spegnersi in base ai segnali ricevuti.
Il ricevitore a infrarossi opera tipicamente a una frequenza di 38 kHz e può rilevare segnali da una distanza di circa 10 a 15 metri. Una volta che l'Arduino riceve il segnale, lo decodifica e utilizza il relè per controllare l'alimentazione della lampadina.
Istruzioni di cablaggio
Inizia il cablaggio collegando il modulo ricevitore a infrarossi all'Arduino. Il pin VCC del ricevitore si collega al pin 5V sull'Arduino e il pin di terra si collega a un pin GND. Il pin di segnale del ricevitore a infrarossi dovrebbe essere collegato a un pin digitale.11sull'Arduino.
Successivamente, collega il modulo relè. Il pin di controllo del relè dovrebbe essere collegato al pin digitale2sull'Arduino. Collega anche i pin VCC e GND del relè ai 5V e GND dell'Arduino, rispettivamente. Infine, collega la lampadina AC al relè secondo le specifiche del relè per garantire un funzionamento sicuro.
Esempi di codice e guida passo passo
Nella fase di impostazione del programma, inizializziamo la comunicazione seriale e configuriamo il pin del relè. L'identificatoreRECV_PINè impostato per11, dove è collegato il pin del segnale del ricevitore a infrarossi. Questo ci permette di ricevere dati dal telecomando.
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
}Nella funzione loop, controlliamo continuamente i segnali in arrivo dal telecomando. Quando viene rilevato un segnale, il valore viene decodificato e viene intrapresa l'azione corrispondente in base al tasto premuto.
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);
}IlrobojaxValidateCodeLa funzione controlla il codice ricevuto rispetto ai valori noti per il telecomando. A seconda di quale tasto viene premuto, eseguirà l'azione corrispondente utilizzando il 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
}
}
}
}In questa funzione, il codice verifica se il tasto premuto corrisponde ai valori dell'array definiti. Se viene trovata una corrispondenza, chiama ilrelayActionfunzione per accendere o spegnere il relè, a seconda del tasto premuto.
Dimostrazione / Cosa Aspettarsi
Dopo aver completato il cablaggio e caricato il codice, puoi utilizzare il tuo telecomando infrarosso per controllare la lampadina AC. Premi i tasti designati sul telecomando e il relè dovrebbe attivare o disattivare la lampadina di conseguenza. Assicurati di testare ogni tasto per vedere la sua risposta (nel video alle 5:00).
Timestamp video
- 00:00 Inizio
- 00:49 Introduzione
- 02:00 Cablaggio e collegamento
- 05:27 Codice Arduino spiegato
- 09:51 Dimostrazione del controllo di una lampadina AC con diversi telecomandi
- 13:13 Utilizzando il telecomando della TV per controllare la lampadina AC
Immagini
/*
* 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 endCose di cui potresti avere bisogno
-
Amazon
-
eBay
Risorse e riferimenti
Nessuna risorsa ancora.
File📁
Nessun file disponibile.
