In questo tutorial imparerai come utilizzare un IR telecomando e ricevitore con Arduino. Ho incluso schemi di collegamento e diversi codici di esempio per aiutarti a iniziare.
Seguendo le istruzioni di questo tutorial potrai utilizzare praticamente qualsiasi telecomando IR (come quello della tua TV) per controllare dispositivi collegati ad Arduino.
Nei seguenti esempi di codice useremo la IRremote libreria Arduino. Questa libreria è abbastanza semplice da usare e supporta molti diversi protocolli di comunicazione IR. Con i primi due esempi puoi identificare il protocollo IR del tuo telecomando e determinare quale codice viene inviato quando premi un tasto. Successivamente, ti mostrerò come associare il codice ricevuto ai valori dei tasti e visualizzarli nel Serial Monitor o su un display LCD. Infine, vedremo come controllare le uscite di Arduino con un telecomando e ricevitore IR.
Materiale necessario
Componenti hardware
| IR remote and receiver | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Jumper wires | × 15 | Amazon |
| 16×2 character LCD display | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| 10 kΩ potentiometer (tipo breadboard) | × 1 | Amazon |
| Resistor assortment | × 1 | Amazon |
| LED assortment | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Software
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.
Come funziona un telecomando e ricevitore a infrarossi (IR)?
Un telecomando e ricevitore IR comunicano tra loro trasmettendo e decodificando un segnale sotto forma di radiazione IR modulata a impulsi.
La radiazione infrarossa (IR), o luce infrarossa, è un tipo di radiazione elettromagnetica con lunghezze d’onda che vanno da 700 nm a 1 mm. Poiché l’occhio umano può vedere solo la luce con lunghezze d’onda tra circa 400 (viola) e 700 (rosso) nanometri, la radiazione IR è invisibile all’occhio umano.
Poiché la trasmissione IR è un protocollo wireless basato su un tipo di luce, richiede una linea di vista libera tra il trasmettitore (il telecomando) e il ricevitore. Questo significa che non può trasmettere attraverso muri o soffitti, a differenza di WiFi o Bluetooth.
Basi della comunicazione IR
Purtroppo, il LED IR del tuo telecomando non è l’unica fonte di radiazione IR. Qualsiasi oggetto che ha una temperatura emette anche radiazione nello spettro infrarosso. Questo fenomeno viene sfruttato anche dalle termocamere per rilevare il calore.
Tutta questa radiazione IR ambientale può interferire con la comunicazione tra telecomando e ricevitore. Quindi, come fa il ricevitore a rilevare solo il segnale IR proveniente dal telecomando? La risposta è la modulazione del segnale.
Con la modulazione del segnale, la sorgente di luce IR all’estremità del telecomando lampeggia a una frequenza specifica. Nei dispositivi elettronici di consumo, questa frequenza portante è solitamente intorno ai 38 kHz.
Questa frequenza specifica viene usata per la trasmissione IR commerciale perché è rara in natura e quindi può essere distinta dalla radiazione IR ambientale.
Il ricevitore è progettato in modo da lasciar passare solo la radiazione IR che arriva a 38 kHz. Questo viene ottenuto tramite un filtro passa-banda e un amplificatore. Il segnale binario demodulato viene poi inviato al microcontrollore (l’Arduino) dove viene decodificato.
Protocollo del segnale IR
Ma come appare effettivamente un segnale IR?
Nell’immagine sopra, l’asse verticale rappresenta la tensione applicata al LED IR del telecomando, mentre l’asse orizzontale rappresenta il tempo. Quindi, quando il LED IR è acceso, lampeggia (modulato) a 38 kHz e quando è spento, non viene applicata alcuna tensione.
Quello che conta è per quanto tempo il LED IR rimane alto o basso (acceso o spento). Nel protocollo NEC, uno dei più diffusi per la trasmissione IR, i bit (“1” o “0”) sono rappresentati così:
Ogni bit consiste in un burst a 38 kHz lungo 560 µs (circa 21 cicli) seguito da una pausa. Un “1” logico ha un tempo totale di trasmissione di 2,25 ms, mentre uno “0” logico solo 1,125 ms.
La durata del segnale alto o basso e il numero di bit inviati per ogni comando variano a seconda del protocollo IR. Nel protocollo NEC, il messaggio totale di solito consiste in quattro byte da 8 bit.
Tipi di ricevitori IR
I ricevitori IR, a volte chiamati sensori IR o diodi di rilevamento IR, di solito sono disponibili in due formati diversi. Puoi acquistare i diodi separatamente oppure già montati su una piccola breakout board.
Funzionano esattamente allo stesso modo, quindi non importa quale usi. L’unica differenza è che la breakout board spesso include un piccolo LED che lampeggia ogni volta che il ricevitore rileva un segnale, utile per il debug.
Collegare un ricevitore IR ad Arduino
Collegare un ricevitore IR ad Arduino è molto semplice: bastano tre fili. Il filo di uscita può essere collegato a uno qualsiasi dei pin digitali di Arduino. In questo caso, l’ho collegato al pin 2 per i primi esempi qui sotto.
Il pin di alimentazione va collegato a 5 V e il pin centrale di massa a GND. Se usi un ricevitore montato su breakout board, controlla le etichette sul PCB perché l’ordine dei pin potrebbe essere diverso!
I collegamenti sono riportati anche nella tabella qui sotto
Collegamenti ricevitore IR
| Ricevitore IR | Arduino |
|---|---|
| OUT (sinistra) | Pin 2 |
| GND (centrale) | GND (-) |
| Vcc (destra) | 5 V (+) |
Installazione della libreria IRremote per Arduino
Per questo tutorial useremo la popolare libreria IRremote. Questa libreria è facile da usare e supporta molti tipi diversi di telecomandi IR.
Per installare la libreria, vai su Tools > Manage Libraries (Ctrl + Shift + I su Windows) nell’ Arduino IDE. Si aprirà il Library Manager e aggiornerà l’elenco delle librerie installate.
Puoi cercare ‘IRremote’ e trovare la libreria di shirriff e z3to. Seleziona l’ultima versione e poi clicca su Install.
Determina il protocollo IR usato dal tuo telecomando
NEC è probabilmente il protocollo di trasmissione IR più conosciuto e diffuso, usato dalla maggior parte dei dispositivi elettronici di consumo prodotti in Giappone. Tuttavia, esistono molti altri tipi di protocolli. Può essere utile sapere quale protocollo IR usa il tuo telecomando se vuoi lavorare su progetti più avanzati. O magari sei solo curioso
A settembre 2023, la libreria IRremote supporta i seguenti protocolli IR:
- PulseWidth
- PulseDistance
- Apple
- Denon
- JVC
- LG
- LG2
- NEC
- NEC2
- Onkyo
- Panasonic
- Kaseikyo
- Kaseikyo Denon
- Kaseikyo Sharp
- Kaseikyo JVC
- Kaseikyo Mitsubishi
- RC5
- RC6
- Samsung
- Samsung48
- SamsungLG
- Sharp
- Sony
- Bang&Olufsen
- BoseWave
- Lego
- MagiQuest
- Whynter
- FAST
Con il breve codice qui sotto puoi identificare quale protocollo usa il tuo telecomando. Puoi anche provare altri telecomandi che hai in casa e vedere se il protocollo viene rilevato.
Rilevatore di protocollo telecomando IR
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
IrReceiver.printIRResultShort(&Serial);
IrReceiver.resume();
}
}
Ho provato con tre telecomandi che avevo in casa: due sono stati rilevati come NEC, mentre il terzo (di un condizionatore) è risultato UNKNOWN:
Tuttavia, esiste un’ottima libreria chiamata IRremoteESP8266, che supporta specificamente i protocolli di vari condizionatori. Quindi, se vuoi controllare il tuo condizionatore via IR, quella è la libreria giusta, ma non è quella che usiamo qui.
Nota: per i telecomandi con protocolli sconosciuti vedrai anche l’errore “Overflow” oltre alle info sul protocollo. Questo succede semplicemente perché la fine del comando IR non è stata rilevata, dato che il protocollo era sconosciuto.
Trovare i codici dei tasti del tuo telecomando
Poiché esistono molti tipi diversi di telecomandi (con numero e funzioni dei tasti differenti), dobbiamo determinare quale segnale ricevuto corrisponde a ciascun tasto.
La libreria IRremote leggerà il segnale e restituirà tutte le informazioni sul segnale nella seguente Data Structure:
struct IRData {
decode_type_t protocol; // UNKNOWN, NEC, SONY, RC5, PULSE_DISTANCE, ...
uint16_t address; // Decoded address
uint16_t command; // Decoded command
uint16_t extra;
uint16_t numberOfBits; // Number of bits received for data
uint8_t flags; // IRDATA_FLAGS_IS_REPEAT, IRDATA_FLAGS_WAS_OVERFLOW
IRRawDataType decodedRawData; // Up to 32 bit decoded raw data,
uint32_t decodedRawDataArray[RAW_DATA_ARRAY_SIZE]; // 32 bit decoded raw data for send function.
irparams_struct *rawDataPtr; // Pointer of the raw timing data to be decoded.
};
Ci interessa in particolare la parte command di quella struttura. Qui troverai il codice inviato dal telecomando a seconda del tasto premuto. Stampando il valore del comando nel Serial Monitor, possiamo creare una tabella di conversione.
Il codice qui sotto fa proprio questo. Nota che aggiungiamo un delay di 100 ms per rallentare la stampa se un tasto viene tenuto premuto, evitando così stampe ripetute.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Serial.println(command);
delay(100); // wait a bit
IrReceiver.resume();
}
}
Dopo aver caricato il codice, apri il Serial Monitor. Ora premi ogni tasto del telecomando e annota il valore corrispondente che vedi nel Serial Monitor.
Per il mio telecomando che controlla un lettore audio, ho ottenuto i seguenti codici:
| Tasto | Codice |
|---|---|
| Play | 7 |
| Stop | 3 |
| Mute | 20 |
| Traccia successiva | 8 |
| Traccia precedente | 2 |
| Volume su | 31 |
| Volume giù | 23 |
La tua tabella sarà probabilmente diversa! Dovrai crearne una tua per usare gli esempi di codice qui sotto.
Stampa i nomi dei tasti nel Serial Monitor
Ora che sappiamo quale codice corrisponde a ogni tasto, possiamo modificare il codice per stampare il nome del tasto premuto nel Serial Monitor.
Per farlo, useremo una struttura di controllo switch case. Questo ci permette di eseguire un codice diverso a seconda del tasto premuto.
L’esempio di codice qui sotto stampa il nome del tasto nel Serial Monitor invece del valore intero come nell’esempio precedente. Nota che manteniamo il delay per non sovraccaricare il ricevitore con segnali ripetuti quando un tasto viene tenuto premuto.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
case 20:
Serial.println("MUTE");
break;
case 8:
Serial.println("NEXT");
break;
case 2:
Serial.println("PREV");
break;
case 31:
Serial.println("VOL+");
break;
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Ecco cosa vedo sul Serial Monitor premendo alcuni tasti del mio telecomando:
Se il tuo telecomando ha tasti diversi e invia codici diversi da quelli mostrati nella tabella sopra, basta sostituire valore e nome delle righe nello switch case che assomiglia a questo:
case 31:
Serial.println("VOL+");
Queste righe significano: quando il valore del comando è uguale a 31, stampa “VOL+” nel Serial Monitor. Se non c’è una case per un valore comando, viene attivata la clausola default e viene stampato “UNDEFINED”.
Come funziona il codice
La prima riga del codice include la libreria IRremote.hpp. Questa libreria fornisce le funzioni necessarie per interagire con i segnali IR.
#include "IRremote.hpp"
Poi definiamo il pin che riceverà i segnali IR. In questo caso, usiamo il pin 2.
#define IR_RECEIVE_PIN 2
Nella funzione setup() avviamo la comunicazione seriale a 9600 baud. Inizializziamo anche il ricevitore IR sul pin definito prima, con il feedback LED attivo. Questo significa che ogni volta che viene ricevuto un codice, un LED su Arduino (e sul modulo ricevitore IR) lampeggerà, utile per il debug.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
Nella funzione loop() controlliamo se il ricevitore IR ha decodificato un segnale. Se sì, otteniamo il valore del comando dai dati decodificati.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Poi usiamo uno switch per interpretare il comando. Ogni case corrisponde a un comando diverso inviato dal telecomando. Ad esempio, se il comando è 7, Arduino stampa “PLAY” sul serial monitor.
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
...
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
Dopo aver interpretato il comando, aspettiamo 100 millisecondi e poi riattiviamo il ricevitore IR. Così può decodificare il prossimo segnale.
delay(100);
IrReceiver.resume();
}
}
Questo codice fornisce una base per leggere e interpretare i segnali da un telecomando IR. Puoi modificarlo secondo le tue esigenze.
Esempio: telecomando e ricevitore IR con Arduino e LCD
Il seguente esempio può essere usato per stampare i valori dei tasti premuti su un display LCD alfanumerico. Ho scritto un tutorial dettagliato sull’uso dei display LCD che puoi trovare qui:
Se preferisci usare un LCD I2C che richiede meno collegamenti, vedi il tutorial qui sotto:
Per questo esempio, ho collegato l’uscita del ricevitore IR al pin digitale 8 invece che al 2. I collegamenti per il display LCD sono mostrati nello schema qui sotto. Nota che serve anche un potenziometro da 10 kΩ per regolare il contrasto del display e una resistenza da 220 Ω per controllare la luminosità della retroilluminazione.
I collegamenti sono riportati anche nella tabella qui sotto. Il pin più a sinistra dell’LCD è il pin 1 (GND).
Collegamenti LCD e ricevitore IR
| Pin | Collegamento |
|---|---|
| LCD pin 1 (GND) | Arduino GND |
| LCD pin 2 (VCC) | Arduino 5 V |
| LCD pin 3 (VO) | Pin centrale potenziometro |
| Pin sinistro potenziometro | Arduino 5 V |
| Pin destro potenziometro | Arduino GND |
| LCD pin 4 (RS) | Arduino pin 2 |
| LCD pin 5 (RW) | Arduino GND |
| LCD pin 6 (E) | Arduino pin 3 |
| LCD pin 11 (DB4) | Arduino pin 4 |
| LCD pin 12 (DB5) | Arduino pin 5 |
| LCD pin 13 (DB6) | Arduino pin 6 |
| LCD pin 14 (DB7) | Arduino pin 7 |
| LCD pin 15 (LED-anodo) | Arduino 5 V tramite resistenza da 220Ω |
| LCD pin 16 (LED-catodo) | Arduino GND |
| Ricevitore IR OUT (sinistra) | Arduino pin 8 |
| Ricevitore IR GND (centrale) | Arduino GND |
| Ricevitore IR Vcc (destra) | Arduino 5 V |
Se hai problemi con il display LCD, consulta il tutorial How to use a 16×2 character LCD with Arduino per maggiori dettagli.
Con il codice di esempio qui sotto puoi stampare il tasto premuto sull’LCD. Se il tuo telecomando invia codici diversi, basta sostituire i valori dei comandi e i nomi dei tasti nello switch case.
Esempio di codice: telecomando e ricevitore IR con Arduino e display LCD
Puoi copiare il codice cliccando sul pulsante in alto a destra del campo codice.
#include "IRremote.hpp"
#include "LiquidCrystal.h"
// LCD object with pin parameters (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);
#define IR_RECEIVE_PIN 8
void setup() {
lcd.begin(16, 2); // LCD with 16 columns and 2 rows
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
lcd.print("PLAY");
break;
case 3:
lcd.print("STOP");
break;
case 20:
lcd.print("MUTE");
break;
case 8:
lcd.print("NEXT");
break;
case 2:
lcd.print("PREV");
break;
case 31:
lcd.print("VOL+");
break;
case 23:
lcd.print("VOL-");
break;
default:
lcd.print("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Dovresti vedere il seguente output sull’LCD se premi il tasto VOL+. Potresti dover regolare il potenziometro per aumentare il contrasto del display.
Controlla i LED (uscite Arduino) con telecomando e ricevitore IR
Anche se è divertente vedere i valori dei tasti nel Serial Monitor o su un display LCD, probabilmente vorrai usare il telecomando per qualcosa di più utile, cioè controllare davvero qualcosa. Nel prossimo esempio ti mostro come accendere e spegnere dei LED con il telecomando. Puoi usare questo tipo di codice anche per controllare relè, luci e motori.
Il codice è molto simile agli esempi precedenti, ma ho aggiunto la funzionalità per controllare i LED.
Dovrai realizzare il seguente circuito per controllare i LED:
I LED sono collegati ai pin da 2 a 5 di Arduino e l’uscita del ricevitore IR al pin 6. Ho usato delle resistenze da 470 Ω per limitare la corrente nei LED. La corrente di funzionamento tipica dei LED da 3 e 5 mm è circa 20 mA. Puoi calcolare il valore della resistenza necessaria con un online calcolatore.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 6
#define RED_LED_PIN 2
#define YELLOW_LED_PIN 3
#define GREEN_LED_PIN 4
#define BLUE_LED_PIN 5
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT);
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW);
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
Spiegazione del codice
Per prima cosa includiamo di nuovo la libreria IRremote.hpp, che fornisce le funzioni per lavorare con i telecomandi IR.
#include "IRremote.hpp"
Poi definiamo i numeri di pin per il ricevitore IR e i LED. Nota che usiamo un pin diverso (PIN 6) per il ricevitore rispetto a prima (PIN 2).
#define IR_RECEIVE_PIN 6 #define RED_LED_PIN 2 #define YELLOW_LED_PIN 3 #define GREEN_LED_PIN 4 #define BLUE_LED_PIN 5
Poi definiamo una funzione chiamata toggleLED che cambia lo stato di un pin LED. Prende un parametro int che rappresenta il numero del pin del LED. Se il pin è HIGH lo portiamo a LOW e viceversa. pin, che rappresenta il pin del LED. Se il pin è HIGH lo portiamo a LOW e viceversa.
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
Nella funzione setup inizializziamo la comunicazione seriale a 9600 baud. Inizializziamo anche il ricevitore IR e impostiamo i pin dei LED come output. Infine spegniamo tutti i LED.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT); // set the LED pins as output
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW); // turn all the LEDs off
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
Nella funzione loop controlliamo se il ricevitore IR ha ricevuto un segnale. Se sì, estraiamo il comando dai dati IR decodificati. In base al comando, eseguiamo azioni diverse.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
In questo esempio di codice abbiamo tre casi per diversi comandi ricevuti dal telecomando IR. Se il comando è 7, stampiamo “PLAY-BLUE” sul serial monitor e cambiamo lo stato del LED blu. Per il comando 3, stampiamo “STOP-YELLOW” e cambiamo lo stato del LED giallo. Per il comando 20, stampiamo “MUTE-GREEN” e cambiamo lo stato del LED verde. Per qualsiasi altro comando, stampiamo “UNDEFINED-RED” e cambiamo lo stato del LED rosso.
Dopo aver eseguito le azioni necessarie, aggiungiamo un delay di 100 millisecondi e riattiviamo il ricevitore IR per ascoltare il prossimo segnale.
Conclusione
In questo tutorial ti ho mostrato come usare un telecomando e ricevitore IR con Arduino. Abbiamo visto diversi esempi di codice per determinare il protocollo IR e identificare i codici dei tasti del tuo telecomando.
Abbiamo poi visto come visualizzare i valori dei tasti nel Serial Monitor e su un display LCD 16×2. Infine, ti ho mostrato come controllare le uscite di Arduino con il telecomando per accendere e spegnere dei LED. Ci sono molte altre applicazioni per ricevitori e telecomandi IR, quindi lascia pure suggerimenti nei commenti.
Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, lascia un commento qui sotto.
Altri link utili dal web
- Arduino-IRremote
- IRremote – Arduino Reference
- Arduino Infrared Remote Tutorial : 7 Steps
- How to Set Up an IR Remote and Receiver on an Arduino
- Arduino IR Remote Controller Tutorial
- Arduino – Control LED’s with IR Remote Control
- IR Remote Control | Arduino Tutorial
