Bestuur een AC-lamp met behulp van elke infraroodafstandsbediening met een Arduino en relais
In deze tutorial leren we hoe we een infrarood afstandsbediening kunnen gebruiken om een AC-lamp te bedienen via een Arduino en een relaismodule. Dit project omvat het decoderen van de signalen van de afstandsbediening en het gebruiken ervan om het relais te bedienen, dat op zijn beurt de AC-lamp aan en uit zal zetten. Aan het einde van deze tutorial kun je elke infrarood afstandsbediening gebruiken om je verlichting te bedienen.
We gebruiken een infraroodontvanger om de signalen van de afstandsbediening op te vangen, en de Arduino zal deze signalen interpreteren om specifieke acties uit te voeren. De meegeleverde code stelt je in staat om het type afstandsbediening (zwart of wit) te selecteren en of je een PCB of een losse module voor de ontvanger gebruikt. Zorg ervoor dat je de bijbehorende video bekijkt voor aanvullende details en verduidelijkingen (in video op 0:00).
Hardware uitgelegd
Voor dit project zijn de belangrijkste componenten het Arduino-bord, een infraroodontvangermodule en een relaismodule. De infraroodontvanger is verantwoordelijk voor het opvangen van de signalen van de afstandsbediening en het verzenden ervan naar de Arduino. De relaismodule fungeert als een schakelaar om de AC-lamp te bedienen, waardoor deze aan en uit kan worden gezet op basis van de ontvangen signalen.
De infraroodontvanger werkt doorgaans op een frequentie van 38 kHz en kan signalen detecteren vanaf een afstand van ongeveer 10 tot 15 meter. Zodra de Arduino het signaal ontvangt, decodeert hij het en gebruikt het relais om de stroom naar de lamp te regelen.
Bedradingsinstructies
Begin met het bedraden door de infraroodontvangermodule op de Arduino aan te sluiten. De VCC-pin van de ontvanger wordt verbonden met de 5V-pin op de Arduino, en de aardingspin wordt verbonden met een GND-pin. De signaalpin van de infraroodontvanger moet worden aangesloten op digitale pin 11 op de Arduino.
Sluit vervolgens de relaismodule aan. De regelpin van het relais moet worden bedraad naar digitale pin 2 op de Arduino. Verbind ook de VCC- en GND-pinnen van het relais met respectievelijk de 5V en GND van de Arduino. Bedraad ten slotte de AC-lamp op het relais volgens de specificaties van het relais om een veilige werking te garanderen.
Codevoorbeelden & uitleg
In de setup-fase van het programma initialiseren we de seriële communicatie en stellen we de relaispin in. De identifier RECV_PIN is ingesteld op 11, waar de signaalpin van de infraroodontvanger is aangesloten. Dit stelt ons in staat om gegevens van de afstandsbediening te ontvangen.
void setup() {
Serial.begin(9600);
irrecv.enableIRIn(); // Start de ontvanger
pinMode(RELAY_PIN, OUTPUT); // definieer een pin voor relais als OUTPUT
digitalWrite(RELAY_PIN, HIGH); // zet relais aan het begin op UIT
}In de loop-functie controleren we continu op inkomende signalen van de afstandsbediening. Wanneer een signaal wordt gedetecteerd, wordt de waarde gedecodeerd en wordt de bijbehorende actie uitgevoerd op basis van de ingedrukte toets.
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX); // Print de ontvangen waarde
robojaxValidateCode(results.value); // Valideer de code
irrecv.resume(); // Ontvang de volgende waarde
}
delay(100);
}De functie robojaxValidateCode controleert de ontvangen code tegen bekende waarden voor de afstandsbediening. Afhankelijk van welke toets wordt ingedrukt, voert deze de bijbehorende actie uit met behulp van het relais.
void robojaxValidateCode(int cd) {
if (type == 'W' && !PCB) {
// Controleer codes van witte afstandsbediening
for (int i = 0; i < sizeof(whiteRemote) / sizeof(int); i++) {
if (whiteRemote[i] == cd) {
Serial.print("Toets ingedrukt: ");
Serial.println(whiteRemoteKey[i]);
relayAction(whiteRemoteKey[i]); // Voer actie uit
}
}
}
}In deze functie controleert de code of de ingedrukte toets overeenkomt met de gedefinieerde arraywaarden. Als er een overeenkomst wordt gevonden, roept het de functie relayAction aan om het relais aan of uit te zetten, afhankelijk van de ingedrukte toets.
Demonstratie / Wat te verwachten
Na het voltooien van de bedrading en het uploaden van de code, kun je je infrarood afstandsbediening gebruiken om de AC-lamp te bedienen. Druk op de aangewezen toetsen op de afstandsbediening en het relais moet de lamp dienovereenkomstig activeren of deactiveren. Zorg ervoor dat je elke toets test om de reactie te zien (in video op 5:00).
Videotijdstempels
- 00:00 Start
- 00:49 Introductie
- 02:00 Bedrading en aansluiting
- 05:27 Arduino-code uitgelegd
- 09:51 Demonstratie van het bedienen van een AC-lamp met een andere afstandsbediening
- 13:13 Je tv-afstandsbediening gebruiken om een AC-lamp te bedienen
Afbeeldingen
/*
* 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 endDingen die je misschien nodig hebt
-
Amazon
-
eBay
Hulpmiddelen en referenties
Nog geen middelen.
Bestanden📁
Fritzing-bestand
-
VS1838B Infrared receiver
VS1838B_part.fzpz
