Ci sono una miriade di situazioni in cui è utile comandare un sensore a raggi infrarossi (IR) per azionare dei dispositivi dotati di questa interfaccia. Ad esempio potremmo usare Arduino per accendere un climatizzatore quando rileva una temperatura eccessivamente alta anche in nostra assenza. Potremmo automatizzare tutti quei casi in cui dobbiamo usare multipli telecomandi: chi di voi ha il decoder Sky e deve commutare su TV ed accenderla, commutare sul decoder e accendere il decoder; tutte azioni che potrebbero venir eseguite con un singolo tasto. Potreste usare lo stesso sensore per accendere la TV nel contesto di un sistema che crea “scenari domotici”, cosa del tipo “abbasso le tapparelle, metto le luci soffuse, accendo la TV”. Vi faccio però notare la piccola grossa differenza fra quest’ultimo tipo di applicazione e le precedenti, infatti in questo caso con il telecomando andiamo a pilotare Arduino, mentre nei restanti è Arduino che va a pilotare dispositivi esterni. I sensori infrarosso possono essere usati anche per trasmettere dati binari da un dispositivo ad un’altro, purtroppo però i due dispositivi devono “vedersi” per comunicare fra loro. Non ci soffermeremo su quest’ultimo aspetto nel’articolo odierno, semmai potremmo pensare di farlo in futuro; dopotutto ci sono un sacco di casi in cui può essere utile trasmettere piccoli pacchetti di dati fra due schede Arduino in modo estremamente semplice ed economico senza scomodare complessi circuiti radio, interfacce cablate o quant’altro.

TSPOP22xx

In questo articolo ho utilizzato, come ricevitore, il TSPOP2238. Nel titolo ho usato la desinenza xx in quanto vi è un’intera famiglia di sensori simili le cui ultime due cifre indicano la frequenza in kHz a cui sono selettivi. Benchè lo standard sia di 38kHz, vi  sono sensori anche a 30, 33, 36, 36.7, 40 e 56kHz. Questo tipo di sensore non contiene unicamente il vero e proprio fotodiodo ad infrarossi, ma contiene al suo interno un filtro per le frequenze indesiderate, un preamplificatore di segnale e fornisce in output un segnale TTL gestibile direttamente da qualunque IC. Se avessimo usato unicamente il fotodiodo nudo e crudo, avremmo avuto in ingresso una tensione variabile in base a quanto ricevuto e diventerebbe nostro arduo compito decodificare il segnale con inutile spreco di risorse software. Questo vale per la ricezione, invece per la trasmissione è sufficiente un banale LED IR, che altro non è che un LED che invece che emettere luce visibile invia sulla frequenza dell’infrarosso. La prima cosa da notare è che se vogliamo sia inviare che ricevere dobbiamo utilizzare due componenti distinti.

Il pinout del sensore  è quello a lato. Come vedete ci sono solo tre pin, VCC, GND e OUT (DATA). I pin potete collegarli direttamente, nel senso che potete collegare la massa del sensore a quella di Arduino, la VCC allo stesso modo e DATA ad uno dei pin digitali. Attenzione però che il datasheet suggerisce l’uso di una resistenza da 100Ohm ed un consensatore da 100microF per ridurre il disturbo sulla linea di alimentazione. Fate estrema attenzione che esistono altre famiglie di sensori di altre ditte molto simili a questi e con i quali sono praticamente intercambiabili se non per il fatto che i pin 5V e GND sono invertiti per cui se usate lo schema qui proposto andreste con tutta probabilità a bruciare il sensore.

Il collegamento del sensore è quindi estremamente semplice, in figura vi lascio lo schema di collegamento preso dal datasheet, con la resistenza e il condensatore per ridurre i disturbi sulla linea di alimentazione. Ho comunque fatto delle verifiche con l’oscilloscopio e sinceramente il rumore era molto basso per cui, almeno per i nostri esperimenti, possiamo tranquillamente fare il collegamento diretto dei tre pin. Prima di passare alla questione software vorrei prima fare alcune precisazioni. Istintivamente potremmo pensare che per inviare dei dati binari via infrarossi potrebbe bastare inviare un segnale, e quindi accendere un LED IR, per gli “1” e toglierlo per gli “0”. Questo però non è fattibile perchè non sono solo i led ad infrarosso ad utilizzare queste frequenza, ma anche le lampadine, il sole, etc. Per distinguere perciò un segnale non voluto dalla nostra comunicazione si usa inviare dei pacchetti di 0-1 per indicare uno stato alto, e l’assenza di segnali per quello basso. Questo è il motivo per cui i sensori sono sensibili ad una specifica frequenza e tagliano le frequenze indesiderate.

Purtroppo non è sufficiente intercettare gli zeri e uno, infatti esistono tutta una serie di codifiche del segnale, la maggior parte delle quali valuta la lunghezza degli zeri e degli uni per determinare i singoli bit. Non ci addentreremo in queso infinito capitolo ma faremo le zecche solo che invece di succhiare il sangue, ci limiteremo a succhiare il software scritto da altri. Infatti esiste una libreria, la IRremote, scritta da Ken Shirriff. Visto il lavoro che ha fatto un click sulla sua pubblicità potete anche farglielo. Questa libreria permette di gestire sia gli invii di codici IR che la loro ricezione. Purtroppo la stragrande maggioranza della documentazione che trovate in giro è obsoleta, fa infatti riferimento alla precedente versione con la quale è retrocompatibile ma vi sono stati notevoli miglioramenti nel codice ed è stata ampliata la compatibilità con altri tipi di telecomandi. La libreria di base è compatibile con NEC, SONY, RC5, RC6, DISH, SHARP, PANASONIC, JVC, SANYO e MITSUBISHI. Io per le mie prove volevo utilizzare anche un telecomando Samsung che purtroppo non è supportato nativamente, ma ho modificato la libreria aggiungendo anche il protocollo per telecomandi Samsung. Non date a me il merito, ho solamente copiato il codice scitto da altri ed inserito nella libreria. Per evitarvi la fatica a fine articolo vi lascio un link per il download.

LED IR

Per la trasmissione IR vi è sufficiente un LED IR ed una resistenza per limitare la corrente, 100Ohm possono andare bene. Vi faccio notare che l’aumento della resistenza riduce la “luminosità” del LED I riducendo la portata del segnale fino ad impedire del tutto la cominicazione. Io ho usato, per la cronaca, un LTR301. Il collegamento è banale ma uno schemino non guasta mai per cui eccolo qui a lato. Il fatto che abbia detto che il collegamento è banale non significa che non vi siano alcune insidie. La prima è che non a caso il pin utilizzato è il numero 3. Per inviare IR la libreria IRRemote utilizza la tecnologia PWM ed il timer che gestisce i segnali è appunto collegato al pin numero 3. Se volete cambiare pin dovete mettere mano alla libreria e modificarla, cosa che peraltro nelle ultime versioni è decisamente più semplice da farsi, comunque, a meno che non abbiate esigenze particolari, non dovrebbe essere un problema usare il pin 3 anzichè altri.

Il Software

Devo confessarvi che la parte software questa volta mi ha dato molti più grattacapi che nelle scorse puntate anche perchè non c’è una documentazione ufficiale a cui rifarsi per cui i problemi riscontrati un po’ li ho risolti guardando i diversi forum sparsi per il mondo, un po’ li ho risolti dotandomi di tanta pazienza e facendo infinite prove.  Ho preparato un circuito di prova in cui il LED IR di trasmissione è collegato al pin 3 come in figura mentre il TSPOP22xx è collegato al pin 12. La primissima cosa da sapere è che la ricezione e la trasmissione non possono avvenire in contemporanea e, anzi, il passaggio fra l’una è l’altra richiede un tempo minimo di attesa senza il quale otterrete il blocco del ricevitore che si sbloccherà solo riavviando Arduino oppure chiudendo e riaprendo il monitor seriale. Un’altra cosa da sapere e che non troverete documentata, è che ogni volta che fate una trasmissione ci sarà lo “spegnimento” del ricevitore che dovrà essere riattivato via software, sempre rispettando le corrette tempistiche, altrimenti si blocca tutto ed impazzirete quanto me a capire dove stà il problema. Prima di andare a studiare la sketch di oggi, occorre vedere quali sono i comandi di base della libreria e capirne il funzionamento, almeno a grosse linee visto che a differenza delle solite sketch pronte all’uso, in questo caso dobbiamo adattare il software in base al telecomando che andiamo ad usare o al dispositivo che vogliamo controllare.

Ricezione

La ricezione IR prevede la creazione di un’istanza all’oggetto IRrecv. Come unico parametro viene passato il pin digitale da utilizzare per la ricezione.

IRrecv irrecv(12);

A questo punto il ricevitore deve essere inizializzato:

irrecv.enableIRIn();

Fatto ciò dobbiamo intercettare i dati ricevuti:

irrecv.decode(&results);

dove result è una struttura dati così composta:

• results.decode_type: NEC, SONY, RC5, RC6, DISH, SHARP, PANASONIC, JVC, SANYO e MITSUBISHI, UNKNOWN. Ricordatevi che nella libreria modificata che trovate in fondo all’articolo c’è anche il supporto ai telecomandi SAMSUNG.
• results.value: Attule codice IR letto (zero se il tipo è sconosciuto)
• results.bits: Numero di bits utilizzati da questo codice.
• results.rawbuf: Array con la durata temporale degli impulsi IR.
• results.rawlen: Numero di elementi memorizzati nell’array

Una volta letto un codice, il ricevitore deve essere preparato per leggere un nuovo codice, per farlo utilizziamo:

irrecv.resume();

Dato che i rraggi infrarossi sono invisibili alla nostra vista, c’è un’utile funzione che ci permette di “vederli”, ossia la rrecv.blink13(true) che fà lampeggiare il LED interno sul pin 13 quando vengono ricevuti dei dati.

Trasmissione

Anche la trasmissione necessita di un “oggetto trasmettitore”, ma in questo caso non possiamo specificare il pin in quanto abbiamo già detto che siamo obbligati ad utilizzare il 3 a meno di non andare a modificare la libreria stessa:

IRsend irsend;

Una volta fatto ciò non ci resta che la funzione di trasmissione dei dati. C’è una funzione specifica per ogni protocollo supportato ed una generica per i protocolli non supportati. Nel caso di protocolli già supportati abbiamo:

irsend.sendXXX(IRcode, numBits);

XXX deve essere cambiato con il nome del protocollo per cui ci sarà la sendNEC, sendSONY, sendRC5, etc.

IRcode è il codice infrarossi da inviare mentre numBits è il numero di bits da inviare.

La funzione generica è invece:

irsend.sendRaw(rawbuf, rawlen, frequency);

dove rawbuf è un buffer contenete i singoli dati da inviare, rawlen la lunghezza del buffer e frequency la frequenza di invio dei dati (tipicamente 38 kHz).

La sketch di ricezione

Vediamo ora un esempio concreto di ricezione minimale. In questa prima fase prendiamo pari pari l’esempio IRrecvDemo fornito con la libreria:

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
 Serial.begin(9600);
 irrecv.enableIRIn(); // Start the receiver
}
void loop() {
 if (irrecv.decode(&results)) {
 Serial.println(results.value, HEX);
 irrecv.resume(); // Receive the next value
 }
}

L’esempio è molto semplice ma vale la pena perdere due minuti a descriverlo. All’inizio includiamo la libreria IRremote e prepariamo la variabile RECV_PIN per selezionare il pin che desideriamo usare per ricevere i dati, ossia il pin a cui è collegato l’OUT (DATA) del nostro TSPOP22. La riga successiva prepara un oggetto di nome irrecv che verrà usato per la lettura dei dati del sensore IR. Si noti che come dicevamo prima viene specificato in questa fase il pin da utilizzare. Viene poi preparata una stuttura “decode_results” per tenere traccia dei dati decodificati del segnale IR in ingresso, poi vedremo più nei particolari cosa contiene questa truttura. Nella fase di setup viene preparata sia la connessione con il terminale per vedere da PC i dati letti, sia viene attivata la ricezione dei dati.

Una volta attivata la ricezione Arduino legge in background i dati ricevuti dal sensore IR. Con l’istruzione decode otteniamo un valore true se il software della libreria è riuscita ad ottenere una decodifica di un segnale valido e ne ha messo i relativi dati nella struttura results.  La riga successiva stampa sul monitor seriale il valore estrapolato dalla trasmissione IR come numero esadecimale. Con questo codice, di fatto, identifichiamo il singolo tasto del telecomando. Ad esempio sul mio telecomando Samsung otterrò 0xE0E0E01F se premo il tasto per alzare il volume o 0xE0E040BF se premo quello per accendere e spegnere la TV. Ogni telecomando fornirà un codice diverso per ogni tasto premuto e telecomandi di marche differenti forniscono codici diversi che possiamo andare ad identificare. In questo modo ci  basta un ciclo switch o alcuni if e sarete già in grado di usare un telecomando qualsiasi per comandare Arduino. Ad esempio con un banale if(results.value==0xE0E0E01F ) ….. potete far compiere un’azione ad Arduino quando premiamo il tasto per alzare il volume sul telecomando Samsung. Prima di proseguire vi faccio notare l’ultima istruzione, ossia la irrecv.resume che prepara il ricevitore a leggere un nuovo codice. La sketch sopra è molto utile per andare a leggere i codici dei diversi tasti dei vari telecomandi per cui potete tranquillamente utilizzarla a questo scopo. Cosa importante da sapere è che questi codici li ottenete anche in gran parte delle codifiche non supportate per cui ad esempio il telecomando del mio climatizzatore che non è supportato ufficialmente dalla libreria, comunque mi genera un codice valido ed univoco per ogni tasto. Per dovere di cronaca vi segnalo che ci sono protocolli come l’RC5 che prevedono che il medesimo tasto fornisca differenti valori in base al fatto che sia la prima pressione o una ripetizione del medesimo tasto. Altre volte ho notato che il ricevitore probabilmente “vede” solo parte della trasmissione per cui fornisce talora dei codici differenti o parziali, ma in linea di massima ho notato un’ottima riproducibilità dei codici ricevuti.

Un po’ più in dettaglio…

La IRremote ci viene però in ulteriore aiuto e ci permette di ottenere dati più precisi sulla decodifica effettuata. Ad esempio se esistessero due codici identici inviati con codifiche differenti, questi possono essere differenziati. In particolare, come dicevamo nella descrizione iniziale, possiamo leggere il decode_type per vedere quale tipo di decodifica è stata rilevata, ricordandoci che i codici attualmente supportati sono NEC, SONY, RC5, RC6, DISH, SHARP, PANASONIC, JVC, SANYO, MITSUBISHI ed UNKNOWN. Vi ricordo che la codifica SAMSUNG non è presente nella libreria originale ma solamente in quella modificata che trovate nel link in fondo. A tal proposito vi vorrei segnalare che esiste già online una versione con decodifica Samsung, ma si basa su una vecchia versione della IRremote per cui mancano alcuni dei protocolli presenti in questa e funziona correttamente solo sulle vecchie versioni dell’IDE per cui con le versioni più recenti dovete fare alcune modifiche affinché possa funzionare.

Un esempio di identificazione del protocollo di decodifica potrebbe essere:

....
if(results.decode_type==NEC) Serial.println("NEC");
 else if(results.decode_type==SONY) Serial.println("SONY");
 else if(results.decode_type==RC5) Serial.println("RC5");
 else if(results.decode_type==RC6) Serial.println("RC6");
else if(results.decode_type==SHARP) Serial.println("SHARP");
.....

Se invece il protocollo di decodifica è “UNKNOWN”, ossia sconosciuto, ci sono alcune preziose ulteriori informazioni che possiamo raccogliere, in particolare rawlen che ci fornisce la lunghezza del buffer con i dati raccolti e l’array rawbuf che questi dati li contiene. Grazie a questi dati possiamo stamparne il contenuto:

for(int kk=1;kk<results.rawlen;kk++)
{
 Serial.print(results.rawbuf[kk], HEX);
 Serial.print(",");
}

Il risultato di un’istruzione simile varia per ogni codice, ma potrebbe essere qualcosa del tipo: 4650,4350,650,1550,650,1550,700,1550,700,400,700,400,700,400,700,450,650,450,650,1550,700,1500,700,1550,700,400,700,450,650,400,700,450,700,400,700,1500,700,1550,650,1550,700,1500,700,450,700,400,700,400,700,400,700,400,700,450,650,450,700,400,700,1500,700,1550,650,1550,700,1500,700

Questi valori, approssimativamente moltiplicati per USECPERTICK che è impostato nella libreria a 50, permette di  ottenere i microsecondi degli zeri e uni che si susseguono nella trasmissione e che in gergo sono chiamati rispettivamente Space e Mark. Vedremo più avanti come utilizzare questi dati, ma per adesso è importante sapere che possiamo ricavarli. Vi faccio notare che il ciclo for comincia da 1 e non da zero perché il primo valore è il cosiddetto gap che non è un vero e proprio codice. Successivamente c’è l’alternanza di mark (1) e space (0) che, in base alla loro lunghezza e tipo di decodifica, determinano gli 0 e 1 binari per ottenere il risultato finale.

La sketch di trasmissione

La trasmissione è secondo me quella che può creare maggiori problemi. Questo perché a differenza della ricezione in cui l’interpretazione di un codice univo ci è più che sufficiente per controllare Arduino, nella trasmissione se il ricevente non capisce il nostro messaggio non fà nulla di nulla e non abbiamo nessun modo concreto per comprendere dove sta il problema, almeno che non si analizzino i segnali con l’oscilloscopio alla ricerca delle differenze fra quanto inviato da Arduino ed il telecomando originale, cosa che comunque non è così semplice e che non tutti possono permettersi di fare. Se dobbiamo utilizzare un protocollo compatibile con la nostra libreria è un gioco da ragazzi, basta ad esempio un irsend.sendSamsung(0xE0E0D02F,68); per inviare il codice esadecimale 0xE0E0D02F di 68 bit ad un dispositivo con codifica Samsung. Allo stesso modo useremo la sendSony, sendRC5, etc per i vari protocolli supportati. Attenzione che gli invii con codifica Sanyo e Mitsubishi non sono ancora implementate al momento in cui scrivo questo articolo. Ma aspettate un attimo. Avevamo detto che la libreria non modificata non supporta la codifica Samsung per cui come facciamo se non vogliamo usare la versione modificata?

Facciamo finta che abbiamo provato la sketch di prima ed abbiamo visto che i dati raw (grezzi) ottenuti premendo il tasto “mute” corrispondono a quelli riportati sopra. In questo caso non facciamo altro che assegnare ad un array quei valori in questo modo:

unsigned int S_mute[68]={4650,4350,650,1550,650,1550,700,1550,700,400,700,400,700,400,700,450,650,450,650,1550,700,1500,700,1550,700,400,700,450,650,400,700,450,700,400,700,1500,700,1550,650,1550,700,1500,700,450,700,400,700,400,700,400,700,400,700,450,650,450,700,400,700,1500,700,1550,650,1550,700,1500,700};

per poi usare l’utilissima funzione sendRaw in questo modo:

irsend.sendRaw(S_mute,68,38);

dove S_mute è l’array definito sopra, 68 è la lunghezza dell’array stesso e 38 è la frequenza di trasmissione (nota che la sendraw è progettata per funzionare fra 36 e 40kHz). Con questa istruzione Arduino invierà l’istruzione “mute” ad un televisore Samsung, anche senza usare l’apposita funzione. Purtroppo questa modalità di invio dei dati non funziona con tutte le apparecchiature ma comunque ci permette di usare la IRremote in una gran quantità di dispositivi non supportati direttamente dalla libreria.

La sketch mista

Come vi accennavo all’inizio vi sono alcuni accorgimenti da usare quando vogliamo utilizzare sia la ricezione che la trasmissione che, ricordiamo, non possono avvenire in contemporanea. Uno degli accorgimenti è inserire un ritardo di almeno 50ms dopo ogni trasmissione con una delay(50);. Un’altra cosa da ricordare è che dopo ogni trasmissione il ricevitore sarà disabilitato per cui deve essere riabilitato con una irrecv.enableIRIn();. Se però fate questa operazione prima di aver aspettato a sufficienza, il ricevitore resterà disabilitato per cui vi ritroverete con un classico circuito che funziona a singhiozzo senza apparenti ragioni. Se perciò il vostro software funziona ma poi si blocca e magari riparte chiudendo e riaprendo il monitor seriale, state certi che si è disabilitato il ricevitore per cui o manca qualche delay o un enablreIRIn.

#include <IRremote.h>
int RECV_PIN = 12;
IRrecv irrecv(RECV_PIN);
IRsend irsend; //usare pin 3
decode_results results;

unsigned int S_pwr[68]={4600,4350,700,1550,650,1550,650,1600,650,450,650,450,650,450,650,450,700,400,700,1550,650,1550,650,1600,650,450,650,450,650,450,700,450,650,450,650,450,650,1550,700,450,650,450,650,450,650,450,650,450,700,400,650,1600,650,450,650,1550,650,1600,650,1550,650,1550,700,1550,650,1550,650};

void setup()
{
 Serial.begin(9600);
 irrecv.enableIRIn();
}
void loop() 
{
 if (irrecv.decode(&results)) 
 {
  if(results.value==0x35 || results.value==0X835)
  {
   Serial.println("ON");
   irsend.sendRaw(S_pwr,68,38);
   delay(50);
   irrecv.enableIRIn();
  } // if
  else Serial.println(results.value, HEX);
  irrecv.resume();
 } //if 
} // loop

Nella sketch qui sopra ho collegato il ricevitore al pin 12 ed il LED IR al pin 3. Ho preparato un array S_pwr per contenere il codice “ON” di un televisore Samsung. Nel loop viene identificato il codice 0x35 o il 0x835 generato da un telecomando con codifica RC5, nel caso venga identificato scrive “On” sul monitor seriale ed invia il codice di accensione Samsung. Notare l’attesa di 50 millisecondi ed il successivo enableIRn che riattiva il ricevitore dopo l’invio dei dati. Se il tasto premuto è un’altro viene semplicemente stampato il relativo codice esadecimale sul monitor seriale. Se volete anzichè usare un telecomando potete inviare codici IR anche comandando Arduino con il monitor seriale, vi basta infatti un pezzo di codice tipo questo:

if (Serial.available())
{
 char code = Serial.read();
 if(code=='7') {irsend.sendSamsung(0xE0E0E01F,68);Serial.println("Vol UP");} 
 else if(code=='1') {irsend.sendSamsung(0xE0E0D02F,68);Serial.println("Vol Down");}
 else if(code=='4') {irsend.sendSamsung(0xE0E0F00F,68);Serial.println("Mute");} 
 else if(code=='9') {irsend.sendSamsung(0x0E0E048B7,68);Serial.println("Ch+");} 
 else if(code=='3') {irsend.sendSamsung(0xE0E008F7,68);Serial.println("Ch-");}
 else if(code=='0') {irsend.sendSamsung(0xE0E040BF,68);Serial.println("ON /OFF");
}

In questo tratto di codice Arduino verifica se avete scritto qualcosa sul monitor seriale, in caso positivo preleva un carattere alla volta e lo assegna alla variabile code che confronta per eseguire le relative azioni. Nel caso qui sopra verranno usati i tasti 1 e 7 per abbassare e alzare il volume, 0 per ON/OFF, 4 per “Mute”, 3 e 9 per cambiare canale, tutto con televisori Samsung e con la libreria debitamente modificata.

Per completezza vi lascio una foto della breadboard con il circuito sperimentale ed il link per scaricare la libreria modificata con codifica Samsung. Vi faccio notare il Tspop rivolto “verso il basso” mentre l’LTR è rivolto sul versante opposto, in questo modo non ci sono interferenze fra i due. I cavetti gialli sono quelli collegati ai pin digitali di Arduino, i blu sono le masse ed il rosso è 5vcc. La resistenza è da 100Ohm: essendo la caduta di tensione del led IR di 1.6V abbiamo 5-1.6=3.4V. Con una resistenza da 100 Ohm abbiamo il passaggio di un massimo di 36mA che rientrano nel massimo range erogato da Arduino (40mA) e in quelli sopportati dal LED (questo modello è garantito sino a 50mA). In alcuni tutorial ho trovato scritto che essendo la corrente inviata in modo pulsato non serve mettere la resistenza per limitare la corrente. Credo sia utile rimarcare che in elettronica il “tanto funziona ugualmente” non è mai una buona pratica, potrebbe essere che il circuito funzioni, magari anche a lungo, ma la probabilità di riscontrare prima o poi un guasto ad Arduino è sicuramente più elevata per cui non vedo perchè dovremmo correre questo rischio per risparmiare una banale resistenza.

Ecco qui il link alla IRremote con aggiunta della codifica Samsung (luglio 2013): IR-Remote Samsung (4633 download )