Decodifica dei telecomandi neri o bianchi con Arduino

Decodifica dei telecomandi neri o bianchi con Arduino

In questo tutorial, impareremo come decodificare i tasti dei telecomandi infrarossi in bianco e nero utilizzando un Arduino e un ricevitore IR. Alla fine di questo progetto, sarai in grado di determinare quale tasto è stato premuto sul telecomando e visualizzare questa informazione sul monitor seriale. Questo può essere utile per controllare dispositivi con qualsiasi telecomando che tu possa avere, come televisori o altri apparecchi (nel video a 01:00).

Utilizzeremo una configurazione semplice che include un Arduino, un modulo ricevitore infrarossi e il codice necessario per decodificare i segnali. Il ricevitore infrarossi catturerà i segnali dal telecomando, e l'Arduino interpreterà quei segnali per determinare quale pulsante è stato premuto. Questo progetto è semplice e può essere adattato per vari telecomandi.

Hardware Spiegato

I componenti principali per questo progetto includono la scheda Arduino e un modulo ricevitore IR, solitamente designato come VS1838B. L'Arduino fungerà da controllore principale, eseguendo il codice che elabora i segnali ricevuti dal telecomando. Il ricevitore IR cattura i segnali infrarossi emessi dal telecomando e li converte in un formato che l'Arduino può comprendere.

Pin del ricevitore remoto IR VS1838B — Piedini del ricevitore remoto IR VS1838B

Il VS1838B opera con un intervallo di tensione di 2,7V a 5,5V, rendendolo compatibile con la maggior parte delle schede Arduino. Può rilevare segnali da una distanza di 10 a 15 metri, a seconda delle condizioni. Il ricevitore a infrarossi emette un segnale digitale che indica quale pulsante del telecomando è stato premuto, consentendo all'Arduino di rispondere di conseguenza.

Dettagli della scheda tecnica

Produttore	VS1838B
Numero parte	VS1838B
Tensione logica/IO	2,7-5,5 V
Tensione di alimentazione	5 V
Corrente di uscita (per canale)	1,5 mA
Distanza di ricezione	10-15 m
Frequenza di ingresso	38 kHz
Corrente di quiescenza	0,8 mA (tip.)
Angolo di funzionamento	70 gradi
Pacchetto	TO-220

Assicurati di fornire la corretta tensione per evitare di danneggiare il ricevitore IR.
Tenere il modulo ricevitore lontano dalla luce solare diretta o da forti fonti di infrarossi.
Usa resistori di pull-up se necessario per stabilizzare le letture del segnale.
Le connessioni cablate devono essere sicure per prevenire segnali intermittenti.
Prova diversi telecomandi per vedere quanto bene funzionano con la configurazione.
Deconding-IR-remote-main-1

Istruzioni di cablaggio

Per collegare il ricevitore IR all'Arduino, prima collega il pin VCC del ricevitore IR al pin 5V dell'Arduino. Successivamente, collega il pin GND del ricevitore a uno dei pin GND dell'Arduino. Infine, collega il pin di segnale (spesso etichettato come SIG o OUT) del ricevitore IR al pin digitale 11 dell'Arduino.

Assicurati che le connessioni siano sicure, poiché connessioni allentate possono portare a letture incoerenti. Se stai utilizzando una versione PCB del ricevitore IR o un modulo nudo, il cablaggio rimane lo stesso; assicurati solo di identificare correttamente i pin secondo l'etichettatura del modulo (nel video alle 03:15).

Installa la libreria IRremote

Avvia l'IDE di Arduino.Arduino.ccper gratis) Fai clic sull'icona della biblioteca a sinistra e cerca perIRremotee fare clic su "Installa" per installarlo.

#include <IRremote.h>

Esempi di codice e guida passo passo

int RECV_PIN = 11;
const char type ='W'; // W for white, B for black
const boolean PCB = 0; // 1 for PCB, 0 for bare module
IRrecv irrecv(RECV_PIN);

In questo estratto, definiamo il numero di pin per il ricevitore IR conRECV_PINimpostato su 11. Specifichiamo anche il tipo di telecomando utilizzato con iltypevariabile, dove 'W' indica un telecomando bianco e 'B' indica un telecomando nero. IlPCBla variabile distingue tra l'uso di una versione PCB del ricevitore o di un modulo nudo.

void setup() {
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

Nellasetup()Nella funzione, inizializziamo la comunicazione seriale a 9600 baud e avviamo il ricevitore IR. Questo è fondamentale per monitorare l'output sul monitor seriale, permettendo di vedere quale tasto è stato premuto.

void loop() {
  if (irrecv.decode(&results)) {
    robojaxValidateCode(results.value); // Validate the received code
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

Il principaleloop()verifica se il ricevitore IR ha decodificato un segnale. Se sì, chiama ilrobojaxValidateCodefunzione per elaborare il valore ricevuto e poi riprende ad ascoltare il prossimo segnale. Ildelay(100)assicura che il ciclo non venga eseguito troppo velocemente, il che può aiutare con l'elaborazione dei segnali.

Dimostrazione / Cosa Aspettarsi

Una volta che tutto è impostato e il codice è caricato, apri il monitor seriale per vedere l'output. Quando premi un tasto sul telecomando, dovresti vedere il nome corrispondente del tasto visualizzato sul monitor. Se il tasto non viene riconosciuto, verrà visualizzato "Tasto sconosciuto." Assicurati di premere i tasti con fermezza, poiché connessioni allentate possono causare letture errate (nel video a 05:40).

Se premi un tasto in modo continuato, l'output potrebbe mostrare valori ripetuti o codici esadecimali. Questo comportamento è normale e puoi modificare il codice per filtrare questi segnali continui se lo desideri. Inoltre, puoi regolare il codice per eseguire azioni basate su pressioni di tasti specifici, come accendere luci o controllare altri dispositivi.

Marca temporale del video

00:00 Inizio
00:56 L'hardware è spiegato
04:26 Spiegazione dei cablaggi
05:20 Il codice è spiegato
12:27 Dimostrazione della decodifica del codice

Immagini

Decodifica qualsiasi telecomando nero o telecomando bianco con Arduino

Piedini del ricevitore remoto IR VS1838B

Deconding-IR-remote-main

Deconding-IR-remote-main-1

Deconding-IR-remote-main-2

Si prega di visualizzare questa pagina in inglese se il codice non è visibile. Ci scusiamo per l'inconveniente.

137-Source code for decoding infrared remote controllers using Arduino

Lingua: C++

/*
 * Original code and library from - http://arcfn.com
 * 
 * This code decodes keys of Black IR remote and White IR remote
 * 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 either as PCB or bare module. See video for details
 * 
 * Modified/Written by Ahmad Shamshiri
 * on July 28, 2018 at 22:48 in Ajax, Ontario, Canada
 * for Robojax.com
 * Watch video instruction for this code:https://youtu.be/muAkBQb24NI
 * 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 = 0;// if receiver is PCB set to 1, if not set to 0. See video for details

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 labels 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 Remote Decoder");
  irrecv.enableIRIn(); // Start the receiver

}

void loop() {

  if (irrecv.decode(&results)) {
     //Serial.println(results.value, HEX);
    robojaxValidateCode(results.value);// used the "robojaxValidateCode" below
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

/*
 * function: robojaxValidateCode
 * validates the remote code and prints 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 Black remote code
      for(int i=0; i< sizeof(whiteRemote)/sizeof(int); i++)
      {
        if(whiteRemote[i] ==cd)
        {
          
          Serial.print("Key pressed:");
          Serial.println(whiteRemoteKey[i]);
    
          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 Black remote code
      for(int i=0; i< sizeof(whiteRemotePCB)/sizeof(int); i++)
      {
        if(whiteRemotePCB[i] ==cd)
        {
          
          Serial.print("Key pressed:");
          Serial.println(whiteRemoteKey[i]);
    
          found=1;
        }// if matched
      }// for  
 }else if(type =='B' && PCB){
    // Robojax IR White 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]);
    
          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)
        {
          if(blackRemoteKey[i] == "OK"){
            digitalWrite(9,HIGH);
          }
          Serial.print("Key pressed:");
          Serial.println(blackRemoteKey[i]);
    
          found=1;
        }// if matched
      }// for  
 }// else
  if(!found){
    if(cd !=0xFFFFFFFF)
      {
    Serial.println("Key unknown");
      }
  }// found
}