Come costruire un telecomando IR universale e programmabile

In questo post del blog imparerai come costruire un telecomando IR universale e programmabile usando Arduino. Un telecomando a infrarossi (IR) è un dispositivo comune usato per controllare vari apparecchi elettronici come TV, condizionatori d’aria e lettori DVD. Con l’aiuto di Arduino, possiamo creare il nostro telecomando IR programmabile per controllare più dispositivi e unificare più telecomandi in uno solo.

Alla fine di questo tutorial saprai come usare ricevitori e trasmettitori a infrarossi e come memorizzare dati nella EEPROM non volatile. Avrai anche il prototipo di un telecomando IR programmabile che potrai modificare o estendere a piacere. Ti permetterà di prendere i telecomandi IR esistenti per TV, ventilatori e così via, e copiare le funzioni dei loro tasti sul telecomando IR che stiamo costruendo.

Allora, iniziamo e immergiamoci nel mondo entusiasmante di Arduino e del controllo remoto IR!

Componenti necessari

Di seguito trovi i componenti necessari per costruire il telecomando IR programmabile. Ti servirà anche un telecomando IR, se non ne possiedi già uno.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Collegamento dei componenti

In questa sezione ti mostrerò come collegare i componenti ad Arduino. L’immagine sotto mostra il cablaggio completo. Inizieremo collegando l’alimentazione alla breadboard.

Alimentazione

Collega un filo blu dal pin GND di Arduino alla linea di alimentazione negativa della breadboard (contrassegnata da una linea blu). Poi collega il pin 5V di Arduino alla linea di alimentazione positiva (contrassegnata da una linea rossa) con un filo rosso.

Inoltre, collega entrambe le linee di alimentazione positive della breadboard con un altro filo rosso. Questo assicura che ci sia alimentazione positiva su entrambe le linee.

Modulo ricevitore IR

Ora ti mostrerò come collegare il ricevitore IR. Riceve i segnali infrarossi emessi da un telecomando IR e li invia ad Arduino, dove vengono decodificati.

Collega un filo blu e uno rosso dal ricevitore alle corrispondenti linee di alimentazione della breadboard. Il lato negativo è solitamente contrassegnato con il segno (-) sul ricevitore, mentre il pin centrale tende ad essere quello positivo. Poi collega il pin segnale (S) del ricevitore al pin 2 di Arduino; mostrato sotto con un filo viola.

Dopo aver collegato il ricevitore, colleghiamo il modulo trasmettitore.

Modulo trasmettitore IR

Il trasmettitore IR è il modulo con il LED IR bianco/trasparente. Questo modulo emette i segnali infrarossi usati per controllare i dispositivi.

Ancora una volta, colleghiamo prima l’alimentazione (fili rosso e blu). Poi colleghiamo il pin segnale (S) del trasmettitore al pin 3 di Arduino usando un filo bianco.

Poiché il nostro telecomando IR sarà programmabile, ci serve un LED di stato. Ci indica se siamo in modalità programmazione o invio. Di seguito la descrizione di come collegare il LED di stato.

LED di stato

Posiziona un LED rosso sulla breadboard e collega il catodo (il pin più corto) con un filo blu alla linea di alimentazione negativa della breadboard. Poi collega una resistenza da 330 Ohm all’anodo del LED (il pin più lungo). Infine, collega la resistenza con un filo arancione al pin 11 di Arduino.

Pulsanti

Infine, servono tre pulsanti. Un pulsante per passare tra la modalità programmazione e la modalità normale del telecomando IR. E due pulsanti per due funzioni diverse del telecomando, ad esempio aumentare e diminuire il volume.

Come vedi sotto, tutti e tre i pulsanti sono collegati allo stesso modo. Una resistenza da 10K funge da pull-up resistor ed è collegata alla linea di alimentazione positiva. Il pin dall’altro lato del pulsante è collegato a un pin di input su Arduino (ne parleremo più avanti). L’ altro pin è collegato con un filo blu alla linea di alimentazione negativa della breadboard.

Nello stato normale, aperto, del pulsante, l’input è collegato a 5V tramite la resistenza e leggeremo un segnale HIGH. Se premi un pulsante, la linea di input si collega a massa e leggeremo un segnale LOW sull’input.

Il pulsante superiore/primo sarà il nostro pulsante di cambio modalità. Collegalo con un filo giallo al pin 4 di Arduino. Il pulsante sotto sarà per la prima funzione. Collegalo al pin 5 (filo ciano). L’ultimo pulsante è per la seconda funzione e lo colleghiamo con un filo verde al pin 6 .

Ecco fatto. Tutto è collegato – speriamo correttamente. Nella prossima sezione vedremo il software.

Scrivere il software

Prima ti mostro tutto il codice e poi analizzeremo le singole parti per capire come funziona. Dai un’occhiata veloce per avere una panoramica.

#include "EEPROM.h"
#include "IRremote.hpp"
#include "TinyIRSender.hpp"

const uint8_t irReceivePin = 2;
const uint8_t irSendPin = 3;
const uint8_t modePin = 4;
const uint8_t func1Pin = 5;
const uint8_t func2Pin = 6;
const uint8_t ledPin = 11;
const uint8_t sRepeats = 2;

uint8_t modeReceive = HIGH;

struct Code {
  uint16_t adr;
  uint16_t cmd;
} code;

bool isOn(int btn) {
  return btn == LOW;
}

bool pressed(int pin) {
  return isOn(digitalRead(pin));
}

int memadr(int btnId) {
  return (btnId - 1) * sizeof(Code);
}

void store_code(int btnId, IRData &irData) {
  digitalWrite(ledPin, LOW);
  code = { irData.address, irData.command };
  EEPROM.put(memadr(btnId), code);
  delay(200);
  digitalWrite(ledPin, HIGH);
}

void send_code(int btnId) {
  digitalWrite(ledPin, HIGH);
  EEPROM.get(memadr(btnId), code);
  sendNECMinimal(irSendPin, code.adr, code.cmd, sRepeats);
  delay(200);
  digitalWrite(ledPin, LOW);
}

void toggle_mode() {
  modeReceive = modeReceive == LOW ? HIGH : LOW;
  digitalWrite(ledPin, isOn(modeReceive) ? HIGH : LOW);
  isOn(modeReceive) ? IrReceiver.start() : IrReceiver.stop();
  delay(200);
}

void send() {
  if (pressed(func1Pin)) {
    send_code(1);
  } else if (pressed(func2Pin)) {
    send_code(2);
  }
}

void receive() {
  if (IrReceiver.decode()) {
    IRData &irData = IrReceiver.decodedIRData;
    IrReceiver.printIRResultShort(&Serial);
    if (pressed(func1Pin)) {
      store_code(1, irData);
    } else if (pressed(func2Pin)) {
      store_code(2, irData);
    }
    IrReceiver.resume();
  }
}

void setup() {
  Serial.begin(9600);
  IrReceiver.begin(irReceivePin, ENABLE_LED_FEEDBACK);
  pinMode(ledPin, OUTPUT);
  pinMode(modePin, INPUT);
  pinMode(func1Pin, INPUT);
  pinMode(func2Pin, INPUT);
  digitalWrite(ledPin, LOW);
}

void loop() {
  if (pressed(modePin)) toggle_mode();
  isOn(modeReceive) ? receive() : send();
  delay(100);
}

Librerie incluse

Per questo progetto ti serviranno install le seguenti librerie. EEPROM è usata per memorizzare i codici IR programmati. La libreria IRremote serve a decodificare i segnali IR ricevuti da un telecomando. E TinyIRSender fa parte della libreria IRremote e ci permette di inviare segnali IR – anche se limitato al NEC protocol .

#include "EEPROM.h"
#include "IRremote.hpp"
#include "TinyIRSender.hpp"

Costanti

Nel blocco di codice seguente definiamo quali pin di Arduino sono usati per quale componente. irReceivePin e irSendPin sono i pin collegati al ricevitore e trasmettitore IR. modePin, func1Pin e func2Pin sono collegati ai pulsanti. Il LED di stato è controllato tramite il ledPin . E sRepeats definisce quante volte un IR command is repeated viene ripetuto durante l’invio.

const uint8_t irReceivePin = 2;
const uint8_t irSendPin = 3;
const uint8_t modePin = 4;
const uint8_t func1Pin = 5;
const uint8_t func2Pin = 6;
const uint8_t ledPin = 11;
const uint8_t sRepeats = 2;

Strutture dati

Oltre alle costanti, serve una variabile per memorizzare la modalità corrente (programmazione o normale) del telecomando IR. modeReceive è HIGH quando siamo in modalità programmazione, LOW altrimenti.

uint8_t modeReceive = HIGH;

struct Code {
  uint16_t adr;
  uint16_t cmd;
} code;

La struttura Code memorizza l’indirizzo ( adr ) e il comando ( cmd ) dei codici IR che riceveremo, memorizzeremo e invieremo. Ad esempio, il mio telecomando IR invia l’indirizzo 0x20 e il comando 0x17 quando premo il tasto VOL+.

Per maggiori dettagli, consulta la documentazione della IRremote lib o dai un’occhiata al nostro tutorial su How to use an IR receiver and remote with Arduino .

Funzioni di supporto

Per mantenere il codice semplice e leggibile, implementiamo alcune funzioni di supporto. La funzione isOn() restituisce True se un pulsante è LOW , cioè premuto. Con la funzione pressed() leggiamo lo stato di un pin di input e poi usiamo isOn() per determinare se il pulsante collegato è premuto.

bool isOn(int btn) {
  return btn == LOW;
}

bool pressed(int pin) {
  return isOn(digitalRead(pin));
}

Funzione indirizzo memoria

Per memorizzare i codici IR ricevuti in memoria serve una funzione che ci dica a quale indirizzo salvare i dati. La funzione memadr() calcola a quale indirizzo di memoria nella EEPROM salviamo e leggiamo i codici comando IR.

int memadr(int btnId) {
  return (btnId - 1) * sizeof(Code);
}

Questa funzione prende un btnId , che è 1 o 2 (per funzione 1 o 2) e calcola l’indirizzo di memoria. Dai un’occhiata all’immagine seguente per capire meglio la relazione tra btnId , la dimensione di una struttura Code e l’indirizzo di memoria.

Funzioni per i codici IR

Per memorizzare e inviare i codici IR usiamo due funzioni. La funzione store_code() prende un id pulsante ( btnId ) e un blocco di dati ( irData ) di dati IR ricevuti.

Nel primo passo spegniamo il LED di stato per indicare che stiamo memorizzando i dati.

void store_code(int btnId, IRData &irData) {
  digitalWrite(ledPin, LOW);
  code = { irData.address, irData.command };
  EEPROM.put(memadr(btnId), code);
  delay(200);
  digitalWrite(ledPin, HIGH);
}

Poi estraiamo l’indirizzo e il comando dal blocco dati e li memorizziamo in una struttura Code . Scriviamo questa struttura nella EEPROM con put() , usando la funzione memadr() per calcolare l’indirizzo di memoria.

Dobbiamo memorizzare i dati nella EEPROM perché altrimenti ogni volta che si spegne l’alimentazione Arduino perde tutti i dati memorizzati. Con i dati nella EEPROM i comandi/tasti programmati rimangono memorizzati anche a Arduino spento.

Dopo aver memorizzato i dati aspettiamo 200ms per evitare memorizzazioni ripetute inutili se il tasto di programmazione resta premuto. Infine riaccendiamo il LED di stato per indicare che la programmazione è completata.

L’invio dei codici funziona essenzialmente al contrario. Dai un’occhiata alla funzione send_code() qui sotto. Prima accendiamo il LED di stato per indicare che stiamo inviando. Poi get il codice da inviare dalla EEPROM per il pulsante premuto ( btnId ). La funzione sendNECMinimal() invia l’indirizzo e il comando con il numero di ripetizioni specificato ( sRepeats ).

void send_code(int btnId) {
  digitalWrite(ledPin, HIGH);
  EEPROM.get(memadr(btnId), code);
  sendNECMinimal(irSendPin, code.adr, code.cmd, sRepeats);
  delay(200);
  digitalWrite(ledPin, LOW);
}

Dopo aspettiamo di nuovo 200ms e spegniamo il LED di stato per indicare che l’invio è completato.

Funzioni principali

Ora abbiamo tutte le funzioni base per costruire le funzioni principali. Iniziamo con una funzione toggle_mode() che cambia il telecomando dalla modalità programmazione/ricezione a quella invio e viceversa. La prima riga fa il toggle della modalità. Nella seconda riga accendiamo il LED di stato se siamo in modalità programmazione. Se siamo in modalità normale il LED di stato sarà spento.

void toggle_mode() {
  modeReceive = modeReceive == LOW ? HIGH : LOW;
  digitalWrite(ledPin, isOn(modeReceive) ? HIGH : LOW);
  isOn(modeReceive) ? IrReceiver.start() : IrReceiver.stop();
  delay(200);
}

Nella terza riga accendiamo o spegniamo il IrReceiver a seconda della modalità. Se siamo in modalità ricezione, il IrReceiver viene avviato, altrimenti fermato. Infine, abbiamo il solito ritardo di 200ms per gestire le pressioni prolungate dei pulsanti.

La funzione send() qui sotto usa send_code() per inviare i codici IR memorizzati per i pulsanti 1 e 2. In altre parole, a seconda del pulsante premuto, invierà il codice corrispondente.

void send() {
  if (pressed(func1Pin)) {
    send_code(1);
  } else if (pressed(func2Pin)) {
    send_code(2);
  }
}

Infine, l’ultima delle funzioni principali è receive() . Qui riceviamo i dati trasmessi da un telecomando IR e li memorizziamo per il pulsante 1 o 2, a seconda di quale pulsante è premuto. Per maggiori dettagli su come ricevere dati IR, dai un’occhiata al nostro tutorial: How to use an IR receiver and remote with Arduino .

void receive() {
  if (IrReceiver.decode()) {
    IRData &irData = IrReceiver.decodedIRData;
    IrReceiver.printIRResultShort(&Serial);
    if (pressed(func1Pin)) {
      store_code(1, irData);
    } else if (pressed(func2Pin)) {
      store_code(2, irData);
    }
    IrReceiver.resume();
  }
}

Funzione setup

Siamo quasi alla fine! Mancano solo due funzioni molto semplici da implementare. Nella funzione setup() stabiliamo la comunicazione seriale, inizializziamo il IrReceiver e impostiamo le modalità IO per i pin. Assicuriamo anche che il LED di stato sia spento, indicando che all’avvio siamo in modalità invio.

void setup() {
  Serial.begin(9600);
  IrReceiver.begin(irReceivePin, ENABLE_LED_FEEDBACK);
  pinMode(ledPin, OUTPUT);
  pinMode(modePin, INPUT);
  pinMode(func1Pin, INPUT);
  pinMode(func2Pin, INPUT);
  digitalWrite(ledPin, LOW);
}

Funzione loop

Dopo tutto il lavoro sopra, il loop principale è molto semplice. Controlliamo il pulsante modalità collegato al modePin e se è pressed facciamo il toggle della modalità. Poi controlliamo se siamo in modalità ricezione tramite isOn(modeReceive) . Se sì, riceviamo e potenzialmente memorizziamo dati IR. Altrimenti inviamo dati.

void loop() {
  if (pressed(modePin)) toggle_mode();
  isOn(modeReceive) ? receive() : send();
  delay(100);
}

E questo è tutto! Nella prossima sezione spiegherò rapidamente come usare il telecomando che abbiamo appena costruito.

Come usare il telecomando

In questa sezione ti spiego come usare il telecomando. Abbiamo tre pulsanti. Il pulsante Modalità serve a passare dalla modalità programmazione o ricezione a quella invio. All’inizio il telecomando è in modalità invio e il LED di stato è spento. Se premi brevemente il pulsante Modalità il telecomando passa in modalità programmazione e il LED di stato si accende.

Programmazione

Per programmare una delle due funzioni devi puntare il tuo altro telecomando IR verso il diodo ricevitore e premere due tasti insieme: il tasto sull’altro telecomando che vuoi memorizzare e il tasto funzione sul nostro telecomando universale. L’immagine seguente mostra come memorizzeremmo il tasto Next Track come Funzione 1 .

Il LED di stato lampeggia brevemente per indicare che la funzione è stata memorizzata e puoi rilasciare i pulsanti.

Invio

Per inviare comandi IR, premi semplicemente il pulsante Modalità (il LED di stato dovrebbe spegnersi) e premi uno dei tasti funzione che hai programmato. Anche in questo caso il LED di stato lampeggia per indicare che il comando è stato inviato.

Debug

Alcuni telecomandi IR non sono supportati e non potrai programmarli. Puoi verificarlo collegando il monitor seriale, passando in modalità programmazione (LED di stato acceso) e controllando se la libreria IRremote riesce a decodificare il segnale. L’output dovrebbe essere simile a questo:

Qui abbiamo ricevuto con successo un comando con indirizzo 0x20 e codice comando 0x8 .

Per il debug della funzione di invio, uno di questi tester di componenti sarà molto utile. Altrimenti devi affidarti a tentativi ed errori per capire cosa non va.

Il tester di componenti sopra può decodificare segnali IR e un segnale ricevuto con successo appare così:

Conclusioni

In questo tutorial hai imparato come costruire un telecomando IR universale e programmabile usando Arduino. Seguendo le istruzioni passo passo, puoi facilmente creare il tuo telecomando per controllare una vasta gamma di dispositivi a infrarossi.

Abbiamo iniziato parlando dei componenti necessari per questo progetto, che includono una scheda Arduino, un modulo ricevitore IR e un modulo trasmettitore IR. Abbiamo descritto il cablaggio tra questi componenti e fornito il codice per controllarli. Inoltre, abbiamo spiegato come usare il telecomando per programmare comandi IR da altri telecomandi.

Se hai altre domande o hai bisogno di ulteriori indicazioni, consulta la sezione Domande Frequenti o esplora i link forniti per ulteriori risorse e ispirazioni.

Buon divertimento con il fai-da-te!

Domande Frequenti

Ecco alcune domande comuni sulla costruzione di un telecomando IR universale e programmabile con Arduino:

Posso avere più pulsanti funzione?

Sì, basta replicare il cablaggio dei pulsanti esistenti per i nuovi pulsanti ed estendere il codice. In particolare, le funzioni receive() e send() devono essere estese per gestire i pulsanti aggiuntivi.

Come posso aumentare la portata del telecomando IR?

Puoi collegare LED IR aggiuntivi ad altri pin di uscita. Oppure puoi alimentare un LED IR a una tensione più alta, ma questo richiede un transistor o MOSFET per controllare il segnale in ingresso al LED. Ecco un circuito di esempio che usa una batteria da 9V per pilotare un diodo trasmettitore IR:

Per maggiori dettagli ed esempi sui MOSFET dai un’occhiata al nostro tutorial su Control Air-Conditioner via IR with ESP32 or ESP8266 e How To Control Fan using Arduino UNO .

Non funziona con il mio telecomando IR?

La libreria IRremote è ottima ma non supporta tutti i protocolli di comunicazione IR esistenti. In particolare, per l’invio usiamo TinyIRSender , che è limitato al protocollo NEC, ma la libreria IRremote supporta anche altri protocolli. Se non basta, dai un’occhiata a IRremoteESP8266 come possibile alternativa.

Voglio controllare il mio condizionatore con il telecomando IR?

Prova la libreria IRremoteESP8266 . Ha un ottimo supporto per molte unità di condizionamento.

Posso usare qualsiasi scheda Arduino per questo progetto?

Sì, puoi usare qualsiasi scheda Arduino per questo progetto purché tu possa collegare un ricevitore e trasmettitore IR e le librerie richieste siano supportate. Un ESP32, ad esempio, sarebbe un’ottima alternativa ad Arduino.

Come faccio a sapere quali codici IR usare per i miei dispositivi?

Puoi trovare i codici IR per i tuoi dispositivi cercando online o consultando il manuale d’uso del dispositivo. Molti produttori forniscono database di codici IR utilizzabili con librerie Arduino. In alternativa, puoi usare un modulo ricevitore IR per catturare i codici da un telecomando esistente. Vedi il nostro tutorial su How to use an IR receiver and remote with Arduino .

Posso controllare più dispositivi con questo telecomando IR?

Sì, puoi controllare più dispositivi con questo telecomando IR. Programmando codici IR diversi per ogni dispositivo, puoi passare da uno all’altro usando pulsanti o un sistema di menu nel codice Arduino. Nota però che il codice sopra supporta solo il protocollo NEC, ma per fortuna la maggior parte dei telecomandi IR lo usa.

Posso aggiungere funzionalità extra al telecomando IR?

Assolutamente! La piattaforma Arduino permette infinite personalizzazioni. Puoi aggiungere funzionalità come un display LCD retroilluminato, un encoder rotativo per la navigazione nel menu, o integrarlo con altri dispositivi smart home usando protocolli wireless come Wi-Fi o Bluetooth.

Se hai altre domande o hai bisogno di ulteriore assistenza, sentiti libero di chiedere nella sezione commenti qui sotto.

Link

Di seguito alcuni link utili per spiegazioni aggiuntive e costruzioni alternative.

• IR Remote and Receiver with Arduino Tutorial (4 Examples)
• ESP32 And IR Remote Interface – A Complete Tutorial
• How to Control a Servo with an IR Remote
• Universal Arduino Remote : 10 Steps (with Pictures)
• Arduino Infrared (IR) Control… The Universal Remote …
• Arduino based universal TV Remote
• Arduino IR Remote Controller Tutorial – Setup and Map …
• Arduino Infrared Remote Tutorial : 7 Steps