In preparazione delle prossime lezioni con i miei studenti condivido la traccia dell’attività di laboratorio in cui mostro come con Arduino è possibile comandare i dispositivi collegati al microcontrollore utilizzando un telecomando ad infrarossi.

La comunicazione ad infrarossi (IR) è una tecnologia wireless ampiamente utilizzata e facilmente realizzabile. Tra gli impieghi più noti: telecomandi TV, termometri ad infrarossi, sensori di movimento (PIR) utilizzati ad esempio per gli antifurti.

Utilizzando Arduino si potrebbero realizzare sperimentazioni che utilizzano la comunicazione IR per realizzare telecomandi per il controllo di robot, telecomandi per TV o fotocamere DSLR, oppure sistemi per monitorare la frequenza cardiaca o realizzare sensori di distanza.

In questa lezione spiegherò, spero in maniera in maniera accessibile a studenti ed appassionati di elettronica cosa sono gli infrarossi e come funzionano e successivamente mostrerò come utilizzare qualsiasi telecomando IR e comandare qualsiasi dispositivo  connesso ad Arduino.

Cosa sono gli infrarossi

La radiazione infrarossa è una forma di luce simile alla luce che vediamo intorno a noi, la differenza tra la luce visibile la la radiazione IR risiede nella frequenza e nella lunghezza d’onda. La radiazione infrarossa si trova al di fuori della gamma di luce visibile, quindi gli esserti umani non possono vederla.

Lo spettro elettromagnetico

Di Annuale. Original version in English by Inductiveload – Translation from English version, Pubblico dominio, Collegamento

Luce visibile

Di Teolindo04 – Opera propria, CC0, Collegamento

La comunicazione IR richiede che tra trasmettitore e ricevitore non vi siano ostacoli, si devono trovare in condizione di visibilità reciproca, non sarà quindi possibile trasmettere attraverso ostacoli, come i muri, come invece risulta possibile per la comunicazione WiFi o Bluetooth.

Come funzionano i trasmettitori ed i ricevitori IR

Un tipico sistema di comunicazione ad infrarossi richiede un trasmettitore IR e un ricevitore IR. Il trasmettitore è contenuto molto spesso in un contenitore simile a quello di un LED standard, con la differenza che produce una redazione elettromagnetica nel campo IR invece che nello spettro visibile.

Se guardate la parte anteriore di un telecomando del TV noterete il LED del trasmettitore IR:

Modulazione di un segnale IR

La radiazione elettromagnetica IR viene emessa da molte fonti: dal sole, dalle lampadine e da qualsiasi altra fonte di calore, ciò implica che queste fonti possono disturbare la comunicazione tra i nostri dispositivi IR comportandosi come dei veri e propri segnali di rumore. Per evitare che il rumore IR interferisca con il segnale IR dei nostri dispositivi, viene utilizzata una tecnica che prende il nome di modulazione.

Se prendiamo in considerazione il telecomando di un TV, quando premiamo uno dei pulsanti verrà emesso, tramite il LED IR, una sequenza di accensioni e spegnimenti del LED IR a frequenza fissata (tipica è la frequenza di 38 kHz) secondo uno schema specifico per ogni pulsante premuto.
Ad ogni pulsante è associato uno schema (detti pattern) specifico di 0 ed 1. Ad ogni stato logico è associata la frequenza di 0 Hz nel caso si voglia inviare uno 0 logico ed una frequenza di  38 kHz nel caso si voglia inviare un 1 logico. Gli schemi sono in genere costituiti da sequenze 12 o 32 bit.

Esistono diverse tecniche per ridurre la quantità di errori derivanti dal rumore esterno (soprattutto dalla luce solare), una di queste prevede che alla pressione di uno dei tasti del telecomando un oscillatore interno al trasmettitore fa “lampeggiare” il LED IR ad una frequenza f_a per il livello logico 0 e ad una frequenza f_b per un valore logico 1.

Il ricevitore prenderà in considerazione solo le sequenze di segnali alle frequenze f_a e f_b  associate ai valori 1 e 0 e scarterà tutte le altre frequenze che potrebbero essere derivanti da rumore IR esterno.

Sintesi schema di trasmissione e ricezione 

Il trasmettitore invierà la sequenza di o e 1 ad un decoder che riconoscerà la sequenza corretta.

La modalità in cui il segnale IR modulato viene convertito in binario è definito dal protocollo di trasmissione. Esistono diversi protocolli di trasmissione IR definiti dalle aziende produttrici: NEC,  Sony, Matsushita, NEC, RC5 sono tra i protocolli più comuni.

Nel caso del protocollo NEC il ricevitore converte il segnale IR modulato in un segnale binario, usando la seguente regola:

il livello logico 0 viene trasmesso con un impulso IR a livello ALTO lungo 562.5 μs seguito da un impulso IR BASSO lungo 562.5 μs. Un livello logico 1 inizia con un impulso IR a livello ALTO lungo 562,5 μs ad una frequenza di 38 kHz seguito da un impulso IR a livello BASSO lungo 1.687,5 μs.

Ogni volta che si preme un pulsante sul telecomando, viene generato un codice esadecimale univoco, questo sarà il codice che viene modulato ed inviato tramite il segnale IR al ricevitore. Per decifrare quale pulsante è stato premuto sul telecomando bisognerà  fare in modo che il microcontrollore sappia quale codice corrisponde a ciascun tasto sul telecomando.

Tenete in conto che ciascun telecomando, anche di stessa marca, invia codici esadecimali diversi anche per stessa funzionalità del pulsante,  quindi per i vostri progetti dovrete determinare, prima di procedere nelle sperimentazioni, il codice generato per ciascun tasto sul vostro telecomando.

Le schede tecniche dei telecomandi forniscono i codici esadecimali corrispondenti ad ogni tasto, nel caso non riusciate a trovare la scheda tecnica, in questo tutorial mostro come, con un semplice sketch, è possibile trovare immediatamente i codici associati ad ogni pulsante.

Prima di partire con le sperimentazioni

Durante le attività di sperimentazioni potrete utilizzare il telecomando del vostro TV, nel caso desiderate utilizzare telecomandi IR provenienti da apparati che non possedete più probabilmente potrebbe essere il caso verificarne il funzionamento.

Premesso che abbiate controllato la carica delle batterie del telecomando, un modo pratico per verificare il funzionamento del telecomando consiste nell’utilizzare una qualsiasi macchina fotografica digitale, anche quella del vostro smartphone, dispositivi in grado di visualizzare le frequenze IR.

• Passo 1: spegnete l’illuminazione della stanza (per ridurre il rumore IR)
• Passo 2: puntata il telecomando verso l’obiettivo
• Passo 3: premete un qualsiasi pulsante ed osservate lo schermo della fotocamera, dovreste notare una luce tendente al blu, ciò identifica il funzionamento della trasmissione del segnale

Connettere il ricevitore IR ad Arduino

I ricevitori IR più comuni sono: TSOP4838, PNA4602, TSOP2438, TSPO2236

Tutti questi dispositivi presentano gli stessi collegamenti ed il circuito di collegamento ad Arduino è il medesimo, tranne che per il TSOP2438 in cui i piedini +5V e GND sono invertiti rispetto agli altri componenti elencati.

Per questo esercizio utilizzerò un ricevitore IR TSOP2236 – con demodulazione a 36 KHz.

Per poter utilizzare un ricevitore IR è indispensabile includere all’interno degli sketch la libreria IRremote.h che permette la gestione della trasmissione e la ricezione di segnali infrarossi.

Per i dettagli sull’uso della libreria vi rimando:

• A Multi-Protocol Infrared Remote Library for the Arduino
• IRremote Library

Nel caso abbiate problemi di utilizzo della libreria IRremote.h vi consiglio la lettura dell’articolo pubblicato su questo sito:

Arduino: problemi con la libreria IRremote.h – come risolverli

Ricordo che per l’invio dei segnali la libreria IRremote.h utilizza la modulazione PWM ed un timer specifico che utilizzando il pin numero 3. Nel caso abbiate la necessità di variare il pin è indispensabile modificare la libreria. Parlerò di ciò in una prossima lezione.

La spiegazione del funzionamento dei metodi utilizzati fate riferimento ai commenti inclusi nel codice.

Per l’esatto orientamento del TSOP2236 mantenere la protuberanza di fronte a se, in tal modo partendo da sinistra verso destra, come indicato nell’immagine che segue si avrà:

• segnale (a sinistra)
• +Vcc (centrale)
• GND (a destra)

Esercizio 1

Realizzare uno sketch che permetta di far accendere e spegnere il led di controllo (collegato al pin 13) di Arduino ogni volta che si preme un pulsante del telecomando.

// Prof. Michele Maffucci
// 28.04.2019

// Il LED sul pin 13 si accende o si spegne ogni volta che viene
// un pulsante del telecomando

// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

#include <IRremote.h>

const int pinRicevitoreIR = 4;             // pin a cui  collegato il ricevitore
const int ledPin = 13;                     // LED connesso al pin 13

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

boolean lightState = false;                // ricorda se il LED e' acceso
unsigned long last = millis();             // ricorda quando e' stato ricevuto
                                           // l'ultima volta un segnale IR

void setup() {
    pinMode(ledPin, OUTPUT);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
}

void loop() {
  if (irrecv.decode(&risultato) == true) // vero se si e' ricevuto un messaggio
  {
    if (millis() - last > 250) {             // e' passato 1/4 di secondo dopo l'ultimo messaggio
      lightState = !lightState;              // se vero si cambia lo stato del LED
      digitalWrite(ledPin, lightState);
    }
    last = millis();
    irrecv.resume();                         // presta attenzione ad un altro messaggio
  }
}

Esercizio 2

Realizzare uno sketch che decodifica i segnali di un telecomando in modo che si possa realizzare un sistema di automazione comandato con i pulsanti del telecomando.
Per i collegamenti utilizzare lo schema dell’esercizio 01.

// Prof. Michele Maffucci
// 28.04.2019

// lettura codici esadecimali di un telecomando IR generico
// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

#include <IRremote.h>

const int pinRicevitoreIR = 4;             // pin a cui  collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

void setup() {
    Serial.begin(9600);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
}

void loop() {
    if (irrecv.decode(&risultato)) {           // vero se si riceve un risultato
        Serial.print("0x");                    // stampa 0x che identifica un codice esadecimale
        Serial.println(risultato.value, HEX);  // stampa il valore esadecimale
        delay(50);                             // attesa di 50 millisecondi
        irrecv.resume();                       // ricezione del successivo valore
    }
}

Esercizio 3

Sfruttando lo sketch degli esercizi 1 e 2 identificare il codice di 5 pulsanti ed inviare sulla Serial Monitor i seguenti messaggi alla pressione dei pulsanti:

CODICE 1: Centrale
CODICE 2: Destro
CODICE 3: Sinistro
CODICE 4: Su
CODICE 5: Giù

Suggerimento
Utilizzare l’istruzione switch per discriminare tra la pressione dei diversi pulsanti

// Prof. Michele Maffucci
// 28.04.2019

// associazione codice invio messaggio sulla Serial Monitor
// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

// N.B. nell'esempio sono stati inseriti nei rispettivi case i codici
// esadecimali utilizzati per il telecomando utilizzato
// sostituite questi valori a quelli che rilevate con lo sketch per la rilevazione
// dei codici esadecimali di qualsiasi telecomando  


#include <IRremote.h>

int pinRicevitoreIR = 4;                   // pin a cui  collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

void setup() {
    Serial.begin(9600);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
}

void loop() {
    if (irrecv.decode(&risultato)) {       // vero se si riceve un risultato
        
        switch (risultato.value) {         // in funzione di uno dei 4 pulsanti premuti invia messaggio sulla Serial Monitor
            case 0x77E1A086:
            Serial.println("Centrale");
            break;
            
            case 0x77E16086:
            Serial.println("Destro");
            break;
            
            case 0x77E19086:
            Serial.println("Sinistro");
            break;
            
            case 0x77E15086:
            Serial.println("Su'");
            break;
            
            case 0x77E13086:
            Serial.println("Giu'");
            break;
        } 
        irrecv.resume();                  // ricezione del successivo valore
    }
}

Esercizio 4

Accensione e spegnimento di un LED collegato al pin  8 con un solo pulsante di un telecomando. Visualizzare sulla Serial Monitor un messaggio che indica la pressione del pulsante.

Componenti

• TSOP2236
• LED
• Resistenza da 220 Ohm

Nota
Tra pressione e successiva lettura della pressione di un pulsante lasciare trascorrere un tempo di 200 ms

// Prof. Michele Maffucci
// 28.04.2019

// accensione spegnimento di un LED con un telecomando IR generico
// ricevitore IR TSOP2236 - demulatore 36 KHz

// piedinatura vista frontale TSPO2236
// pin 1 (sx): pin Arduino
// pin 2 (centrale): +Vcc
// pin 3 (dx): GND

// N.B. nell'esempio è stato utilizzato come valore di controllo memorizzato in risultato.value
// il codice esadecimali del pulsante utilizzato per il telecomando usato come test
// sostituite questo valore con il pulsante del vostro telecomando

#include <IRremote.h>

const int pinRicevitoreIR = 4;             // pin a cui  collegato il ricevitore

IRrecv irrecv(pinRicevitoreIR);            // pin a cui  collegato il ricevitore
decode_results risultato;                  // salva il risultato ricevuto dal rilevatore IR

int ledPin = 8;                            // pin a cui  collegato il LED
int stato = 0;                             // se stato= 0 ledPin off - se stato = 1 ledPin on

void setup() {
    Serial.begin(9600);
    irrecv.enableIRIn();                   // Attiva l'oggetto del ricevitore
    pinMode(ledPin, OUTPUT);
}
 
void loop() {
    if ((irrecv.decode(&risultato)) && (risultato.value==0x77E1A086)) {
        if (stato == 0) {
            stato = 1;
            digitalWrite(ledPin, HIGH); 
            Serial.println("Centro - HIGH");
            } else {
            stato = 0;
            digitalWrite(ledPin, LOW);
            Serial.println("Centro - LOW");
        }
        delay(200);
        irrecv.resume();
    }
}

Buon Coding a tutti 🙂