Leggere e copiare i codici dei telecomandi di casa e più in generale di tutti i dispositivi dotati di Infra Red (IR) è spesso una buona base di partenza per poterli poi controllare da remoto o automatizzare dei processi che vogliamo si ripetano per esempio con cadenza regolare nel tempo.
Il manuale vi aiuterà a leggere e decodificare i codici di ciascun telecomando di casa per poi in un secondo momento inviarli attraverso la scheda stessa bypassando di fatto l’utilizzo del telecomando fisico.
Questa guida consente di leggere, decriptare, copiare i codici proveniente da un segnale IR. I segnali IR sono comunemente utilizzati per i telecomandi della TV e degli elettrodomestici in generale; ad esempio a casa comando DVD player, Sistema HiFi e perfino la cappa della cucina con questa tecnologia. Non tutti i telecomandi che troviamo dentro casa pero’ sono IR; alcuni telecomandi sono a radio frequenza e quindi utilizzano tutt’altra tecnologia e sarà quindi impossibile con questa guida poterli leggerli. Un esempio di telecomandi a radiofrequenza sono solitamente quelli dei cancelli telecomandati. Controllate sul prodotto o sul libretto delle istruzioni la tipologia di segnali se non volete trovarvi ad aver perso tempo per nulla.
Il manuale qui di seguito utilizza una libreria adatta alle schede ESP8266. Per questo esperimento io ho utilizzato la scheda NodeMcu che utilizza appunto come base una ESP8266-12E. Attenzione: la libreria non è compatibile con schede Arduino Uno o altre schede della famiglia Arduino per le quali vi consiglio la famosissima libreria di Ken Shirriff Arduino-IRremote.
Fatte le dovute premesse passio all’azione.
Vediamo il materiale da reperire o acquistare per poter leggere i codici di un telecomando IR:
- Arduino IDE. Ci serve per poter programmare la scheda; è il software che utilizzeremo e tramite il quale leggeremo i codici captati dal nostro sistema
- Un sensore IR reader TSOP4838, qui il link alla documentazione tecnica del produttore VISHAY. E’ un sensore molto comune con un prezzo solitamente intorno all’euro. Lo potete trovare facilmente su Ebay o nel vostro negozio di componentistica elettronica preferito. In alternativa potete utilizzare sensori come TL1838 V1838B; il lavoro che deve fare questo sensore è captare il segnale emesso.
- Una scheda ESP8266 alla quale collegare il sensore; io utilizzerò una la NodeMCU vista la sua comodità d’utilizzo (prezzo circa 5 euro).
- Una breadboard (opzionale) se volete avere una base di sviluppo più stabile
- Della cavetteria (jumpers) per collegare il sensore alla scheda.
Totale costo componenti: meno di 10 euro
Tempo richiesto per assemblare il progetto: 30 minuti circa.
Per prima cosa collegate il sensore alla scheda:
Sensore-TSOP4838
il primo Pin (OUT) è quello che trasporta il dato e va collegato al pin GPI02 che tradotto per la nostra NodeMcu diventa l’uscita digitale 4 ossia D4.
Se avete dubbi sul pin a cui collegare la scheda perchè questo passaggio non vi è chiaro vi consiglio di cercare su Google il con il nome della vostra scheda ESP + “pinout”. Esempio esp-07 pinout.
Le immagini di Google vi mostreranno le corrispondenze tra GPI e pin digitali sulla vostra scheda.
il secondo Pin (GND) va al ground sulla scheda
il terzo pin (VCC) va collegato alla 3.3V della nostra scheda.
A questo punto avete terminato la parte elettronica e dobbiamo passare alla parte di programmazione.
Scaricate la libreria <IRremoteESP8266.h> da Github ed aggiungetela alle librerie nel vostro ArduinoIDE. Una volta caricata la libreria impostate correttamente l’IDE selezionando nella sezione schede (nel mio caso) node MCU.
Connettete la scheda al computer.
A questo punto caricate il codice che trovate in GitHub denominato IRremoteESP8266.h sulla vostra scheda e che per comodità vi ho postato qui sotto. Il codice si basa sulla libreria originale di Ken Shirriff che è tra le migliori al mondo in questo campo.
[codesyntax lang=”c”]
/*
* IRremoteESP8266: IRrecvDumpV2 - dump details of IR codes with IRrecv
* An IR detector/demodulator must be connected to the input RECV_PIN.
* Version 0.1 Sept, 2015
* Based on Ken Shirriff's IrsendDemo Version 0.1 July, 2009, Copyright 2009 Ken Shirriff, http://arcfn.com
*/
#include <IRremoteESP8266.h>
int RECV_PIN = 2; //an IR detector/demodulator is connected to GPIO pin 2 --> D4 ON NODE MCU
IRrecv irrecv(RECV_PIN);
void setup ( )
{
Serial.begin(9600); // Status message will be sent to PC at 9600 baud
irrecv.enableIRIn(); // Start the receiver
}
//+=============================================================================
// Display IR code
//
void ircode (decode_results *results)
{
// Panasonic has an Address
if (results->decode_type == PANASONIC) {
Serial.print(results->panasonicAddress, HEX);
Serial.print(":");
}
// Print Code
Serial.print(results->value, HEX);
}
//+=============================================================================
// Display encoding type
//
void encoding (decode_results *results)
{
switch (results->decode_type) {
default:
case UNKNOWN: Serial.print("UNKNOWN"); break ;
case NEC: Serial.print("NEC"); break ;
case SONY: Serial.print("SONY"); break ;
case RC5: Serial.print("RC5"); break ;
case RC6: Serial.print("RC6"); break ;
case DISH: Serial.print("DISH"); break ;
case SHARP: Serial.print("SHARP"); break ;
case JVC: Serial.print("JVC"); break ;
case SANYO: Serial.print("SANYO"); break ;
case MITSUBISHI: Serial.print("MITSUBISHI"); break ;
case SAMSUNG: Serial.print("SAMSUNG"); break ;
case LG: Serial.print("LG"); break ;
case WHYNTER: Serial.print("WHYNTER"); break ;
// case AIWA_RC_T501: Serial.print("AIWA_RC_T501"); break ;
case PANASONIC: Serial.print("PANASONIC"); break ;
}
}
//+=============================================================================
// Dump out the decode_results structure.
//
void dumpInfo (decode_results *results)
{
// Show Encoding standard
Serial.print("Encoding : ");
encoding(results);
Serial.println("");
// Show Code & length
Serial.print("Code : ");
ircode(results);
Serial.print(" (");
Serial.print(results->bits, DEC);
Serial.println(" bits)");
}
//+=============================================================================
// Dump out the decode_results structure.
//
void dumpRaw (decode_results *results)
{
// Print Raw data
Serial.print("Timing[");
Serial.print(results->rawlen-1, DEC);
Serial.println("]: ");
for (int i = 1; i < results->rawlen; i++) {
unsigned long x = results->rawbuf[i] * USECPERTICK;
if (!(i & 1)) { // even
Serial.print("-");
if (x < 1000) Serial.print(" ") ;
if (x < 100) Serial.print(" ") ;
Serial.print(x, DEC);
} else { // odd
Serial.print(" ");
Serial.print("+");
if (x < 1000) Serial.print(" ") ;
if (x < 100) Serial.print(" ") ;
Serial.print(x, DEC);
if (i < results->rawlen-1) Serial.print(", "); //',' not needed for last one
}
if (!(i % 8)) Serial.println("");
}
Serial.println(""); // Newline
}
//+=============================================================================
// Dump out the decode_results structure.
//
void dumpCode (decode_results *results)
{
// Start declaration
Serial.print("unsigned int "); // variable type
Serial.print("rawData["); // array name
Serial.print(results->rawlen - 1, DEC); // array size
Serial.print("] = {"); // Start declaration
// Dump data
for (int i = 1; i < results->rawlen; i++) {
Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
if ( i < results->rawlen-1 ) Serial.print(","); // ',' not needed on last one
if (!(i & 1)) Serial.print(" ");
}
// End declaration
Serial.print("};"); //
// Comment
Serial.print(" // ");
encoding(results);
Serial.print(" ");
ircode(results);
// Newline
Serial.println("");
// Now dump "known" codes
if (results->decode_type != UNKNOWN) {
// Some protocols have an address
if (results->decode_type == PANASONIC) {
Serial.print("unsigned int addr = 0x");
Serial.print(results->panasonicAddress, HEX);
Serial.println(";");
}
// All protocols have data
Serial.print("unsigned int data = 0x");
Serial.print(results->value, HEX);
Serial.println(";");
}
}
//+=============================================================================
// The repeating section of the code
//
void loop ( )
{
decode_results results; // Somewhere to store the results
if (irrecv.decode(&results)) { // Grab an IR code
dumpInfo(&results); // Output the results
dumpRaw(&results); // Output the results in RAW format
dumpCode(&results); // Output the results as source code
Serial.println(""); // Blank line between entries
irrecv.resume(); // Prepare for the next value
}
}[/codesyntax]
Bene a questo punto siete in grado di leggere i codici del vostro telecomando.
Copia codici IR con NodeMcu
Tramite il menù di ArduinoIDE accedete al Monitor Seriale (è in Strumenti).
Avvicinate il telecomando a 20 cm dal sensore e premete un tasto a caso: la sua codifica apparirà sullo schermo pronta ad essere copia ed utilizzata tramite l’apposito sketch di invio del segnale IR.
La libreria IRremoteESP8266 è molto potente e consente di decodificare quasi tutti i telecomandi (personalmente non ho mai avuto alcuna difficoltà a decodificare).
Offre inoltre anche un servizio aggiuntivo: quello di rintracciare il decoder type ossia la tipologia di codifica che utilizza il telecomando; nel caso in cui il decoder type non sia già tra quelli codificati il sistema è cmq in grado di restituirvi i dati grezzi (row data) per poter copiare ed inviare il segnale.
Una volta ricevuto il segnale sul vostro monitor seriale dovrebbe apparire una cosa simile a questa:
Schermata acquisizione codici IR Arduino
La codifica mostra diversi dati:
- ENCODING: questa è la tipologia di codifica utilizzata per trasmettere e ricevere il messaggio. Nel caso la codifica non sia riconosciuta viene mostrato il valore Unknown. Attenzione: a volte alcuni produttori utilizzano delle codifiche di altri produttori; puo’ capitare ad esempio che TV LG usino codifiche SAMSUNG; questo perchè non tutti i produttori sviluppano un sistema di codifica preferendo pagare dei diritti per utilizzare quelli già sviluppati da terzi.
- CODE: è la parte più importante di tutta la stringa di codici è il codice univoco che è collegato a quel comando. Tra le parentesi c’è il numero di bit del segnale. entrambi i valori sono fondamentali per la trasmissione.
- Timing e unsigned int rawData: sono i dati grezzi del codice; qual’ora non si fosse in grado di codificare il codice attraverso code ed encoding (che sono di fatto una scorciatoia) attraverso i dati grezzi è possibile riprodurre il codice. Con questo sistema si puo’ riprodurre il 100% dei codici.
- Unsigned int data: è di fatto lo stesso dato presente in code, al quale viene aggiunto 0x. Questo è il codice che andrà poi riportato nello sketch di invio del segnale IR.
Nella prossima lezione impareremo come gestire il codice acquisito ed inviare un segnale IR dalla scheda ESP8266 attraverso il computer.
