Un trasmettitore IR fatto con Arduino è uno di quei progetti piccoli solo in apparenza: con pochi componenti puoi controllare TV, decoder, climatizzatori e altri dispositivi che parlano a infrarossi. Il punto, però, non è soltanto far lampeggiare un LED: per avere un segnale stabile bisogna scegliere bene pilotaggio, libreria e protocollo. In questa guida ti mostro come costruire un arduino ir transmitter affidabile, come inviare i primi comandi e quali errori evitare quando il segnale non arriva abbastanza lontano.
In breve, la riuscita del progetto dipende soprattutto da corrente, portante e protocollo
- Un pin Arduino da solo raramente basta: per un segnale forte serve quasi sempre un transistor di pilotaggio.
- La libreria più pratica oggi è IRremote, che gestisce protocolli comuni e consente anche l’invio di codici raw.
- Per la maggior parte dei telecomandi consumer la portante di riferimento è 38 kHz, ma non sempre è l’unica possibile.
- Se il dispositivo usa un formato proprietario, spesso conviene registrare il comando e ritrasmettere i tempi esatti.
- La portata reale dipende più da LED, corrente e geometria del montaggio che dal codice in sé.
Perché conviene costruirlo invece di affidarsi a un telecomando qualsiasi
Io parto sempre dal motivo pratico, perché è quello che decide se il progetto ha senso davvero. Un trasmettitore IR con Arduino torna utile quando vuoi centralizzare più dispositivi, automatizzare una stanza, replicare un telecomando perso oppure integrare un vecchio elettrodomestico in un sistema più ampio. Con una spesa contenuta puoi ottenere un controllo flessibile, molto più facile da modificare di un telecomando fisico tradizionale.
Il vantaggio vero non è solo il risparmio, che spesso si ferma a pochi euro di componenti se hai già la scheda. È la possibilità di capire e riusare i comandi: puoi memorizzare i codici, crearne una mappa, associare pulsanti o persino comandare tutto da una pagina web o da un sensore. Su questo tipo di progetto, la differenza tra un esperimento e uno strumento utile sta nella struttura del segnale, non nel numero di righe di codice.
Per questo, quando mi chiedono da dove iniziare, consiglio di pensare al progetto come a un piccolo sistema di emissione, non come a un LED che si accende e si spegne. La logica dell’hardware viene prima, e da lì si passa al cablaggio corretto.
Componenti e collegamenti che fanno davvero la differenza
In un progetto serio io non collegherei mai il LED IR direttamente al pin come soluzione definitiva. Per test veloci può anche funzionare, ma se vuoi portata affidabile e comportamento ripetibile serve un driver a transistor. La configurazione più comune usa un NPN come 2N2222 o BC337, una resistenza di base e una resistenza in serie al LED, così il pin Arduino lavora in sicurezza e il diodo riceve la corrente necessaria.
| Componente | Ruolo | Nota pratica |
|---|---|---|
| Arduino Uno, Nano o simile | Genera il segnale di controllo | Per un primo progetto basta una scheda semplice, senza Wi-Fi o funzioni extra. |
| LED IR da 940 nm | Emette il segnale a infrarossi | Meglio un LED ad alta efficienza e, se serve più portata, con angolo di emissione stretto. |
| Transistor NPN | Pilota il LED senza sovraccaricare il pin | 2N2222 e BC337 sono scelte comuni e facili da reperire. |
| Resistenza di base | Limita la corrente verso il transistor | 470 ohm è un buon punto di partenza per prototipi semplici. |
| Resistenza del LED | Regola la corrente del diodo | Con 5 V e un solo LED IR, 100 ohm è un valore prudente per iniziare; il valore finale dipende dal LED e dalla tensione. |
| Ricevitore IR demodulato | Serve per copiare i codici dal telecomando originale | È utile quando non conosci ancora il protocollo o vuoi verificare il segnale ricevuto. |
Se vuoi spingere la portata, la via più semplice è usare due o tre diodi IR in serie, purché la tensione disponibile lo consenta. Con 5 V, la documentazione della libreria IRremote indica che 2 LED in serie possono lavorare con circa 130 ohm e 3 LED con circa 70 ohm, ma io lo considero un passo successivo, non il punto di partenza. Prima fai funzionare bene un singolo LED, poi alzi la potenza solo se il dispositivo non risponde da distanza normale.
Un dettaglio che molti ignorano è la massa comune: Arduino, transistor e alimentazione del driver devono condividere lo stesso riferimento. Sembra banale, ma è una delle cause più frequenti di “non funziona” nei progetti IR. Da qui in poi il codice diventa molto più semplice da capire.Il primo comando IR con la libreria giusta
Per Arduino, oggi la scelta più pratica è IRremote. La libreria gestisce diversi protocolli diffusi, tra cui NEC, JVC, LG e Denon/Sharp, e consente anche l’invio di dati raw quando il protocollo non è riconosciuto. Io preferisco questo approccio perché ti lascia partire con i protocolli standard e, quando serve, ti permette di salire di livello senza cambiare ecosistema.
La base minima è molto semplice. Se vuoi un esempio leggibile, puoi usare una configurazione con pin esplicito e un invio NEC di prova:
#include
const uint8_t kIrSendPin = 3;
void setup() {
IrSender.begin(kIrSendPin);
delay(2000);
IrSender.sendNEC(0x04, 0x02, 2);
}
void loop() {
} Qui stai dicendo alla libreria di usare il pin 3 e di inviare un comando NEC con due ripetizioni. Nella pratica, io uso questo tipo di sketch per verificare subito tre cose: che il LED emetta davvero, che il ricevitore del dispositivo reagisca e che il montaggio non perda energia per colpa di un cablaggio debole. Se il test funziona vicino ma non funziona a tre o quattro metri, il problema è quasi sempre hardware, non logico.
- Installa IRremote dal gestore librerie dell’IDE.
- Collega il LED IR con transistor e resistenze, non direttamente al pin se vuoi una prova credibile.
- Carica lo sketch di test e punta il LED verso il dispositivo da controllare.
- Se il comando arriva solo da vicino, alza la corrente in modo prudente o usa due LED in serie.
Se vuoi ridurre un po’ il codice su AVR, puoi anche definire `IR_SEND_PIN` prima dell’include, ma per un primo articolo io preferisco mostrare la versione chiara e facile da adattare. Il passaggio successivo è capire quando basta un protocollo noto e quando invece devi lavorare con tempi raw.
Protocolli, codici raw e compatibilità con i dispositivi reali
Il punto che separa il progetto scolastico da quello davvero utile è la compatibilità con il dispositivo finale. Molti apparecchi di consumo usano protocolli standard, quindi puoi inviare address e command con funzioni come `sendNEC()`. Altri, soprattutto i climatizzatori, usano sequenze più lunghe o proprietarie, e in quel caso conviene registrare il comando e reinviarlo come raw timing.
| Scenario | Cosa inviare | Scelta che io consiglierei |
|---|---|---|
| TV, decoder, soundbar | Protocollo standard | Partire da NEC, Samsung o Sony, se il dispositivo lo supporta. |
| Climatizzatori | Sequenze lunghe e spesso proprietarie | Registrare e ritrasmettere i tempi raw quando il protocollo non è chiaro. |
| Progetti fai-da-te | Protocollo scelto da te | Usare un formato semplice e documentato, così il codice resta leggibile. |
| Telecomandi misti | Più codici diversi | Creare una piccola tabella di mapping tra pulsanti e comandi. |
La libreria IRremote gestisce anche i repeat frame, e questo non è un dettaglio da poco. Alcuni dispositivi accettano un comando solo se lo ricevono una o due volte, mentre altri si aspettano una cadenza precisa tra un frame e l’altro. Nel caso di NEC, per esempio, il periodo di ripetizione è intorno ai 110 ms da inizio a inizio: se improvvisi una sequenza troppo rapida, rischi che il dispositivo ignori tutto.
Qui entra in gioco una regola pratica che uso spesso: se il codice noto non funziona, non cambiare subito cento cose insieme. Verifica prima la portante, poi la ripetizione, poi la potenza del LED, e solo dopo passa alla cattura raw. È un ordine noioso, ma fa risparmiare molto tempo.
Gli errori che riducono portata e affidabilità
Gli insuccessi nei progetti IR sembrano tutti simili dall’esterno, ma in realtà hanno cause diverse. Io li raggruppo quasi sempre in quattro categorie: corrente insufficiente, protocollo errato, cablaggio sbagliato e disturbi ambientali. Se li separi bene, il debug diventa molto più rapido.
- LED pilotato male: un pin che alimenta direttamente il diodo spesso non basta per una portata reale.
- Massa non comune: senza un riferimento condiviso, il transistor non lavora in modo prevedibile.
- Protocollo sbagliato: il telecomando può usare NEC, ma anche un formato differente o una variante proprietaria.
- Ripetizioni assenti: alcuni dispositivi reagiscono solo se il frame viene inviato più di una volta.
- Portante non compatibile: 38 kHz è il valore più comune, ma non è universale.
- Luce ambientale e ricezione debole: sole diretto, LED scarso o ricevitore economico possono falsare il risultato.
Un altro errore tipico è confondere il segnale IR con il LED visibile. Il fatto che tu non veda nulla non significa che il progetto sia spento: l’emissione è fuori dallo spettro visibile e va verificata con il ricevitore giusto. Quando faccio debugging, io controllo sempre prima il comportamento del ricevitore e poi la distanza utile, perché è lì che emergono i limiti reali del montaggio.
Se usi un ricevitore demodulato da 38 kHz per catturare i codici, tieni presente che una lettura “UNKNOWN” non è automaticamente un fallimento. Spesso significa solo che il protocollo non è riconosciuto oppure che il segnale è troppo debole o disturbato. In quel caso ha senso passare ai tempi raw e confrontare la sequenza con una nuova trasmissione.
Quando Arduino basta e quando conviene cambiare architettura
Per un trasmettitore IR puro, un Arduino Uno o un Nano sono spesso più che sufficienti. Hanno una curva di apprendimento bassa, un ecosistema maturo e una libreria come IRremote che funziona bene senza complicazioni inutili. Se il tuo obiettivo è replicare pochi telecomandi e usare un pulsante, questa è quasi sempre la strada più pulita.
| Scelta | Quando la preferisco | Limite principale |
|---|---|---|
| Arduino Uno / Nano | Prototipo semplice, pochi comandi, massima chiarezza | Niente connettività integrata e poche funzioni extra. |
| Arduino Mega | Molti ingressi, più logica, progetto più articolato | È spesso più del necessario per un semplice emettitore IR. |
| ESP32 | Controllo via Wi-Fi, automazione e integrazione domotica | Richiede più attenzione su pin, timer e compatibilità del firmware. |
| Microcontrollori molto piccoli | Progetti compatti e a basso consumo | Hai meno margine per memoria, debugging e future modifiche. |
Il mio criterio è semplice: se devi solo emettere infrarossi, resta sul percorso più lineare possibile. Se invece vuoi un telecomando connesso, scenari di automazione o aggiornamenti via rete, allora un microcontrollore diverso ha più senso. L’importante è non sovradimensionare il progetto solo perché lo spazio “microcontrollori” sembra invitare a complicarsi la vita.
Per la maggior parte delle persone che iniziano, la combinazione Arduino + IRremote + transistor + LED IR è la migliore. Ti porta al risultato con pochi pezzi, ti fa capire la parte elettrica e ti lascia abbastanza libertà per aggiungere pulsanti, memoria o controllo remoto più avanti.
Dal prototipo a un telecomando che uso davvero ogni giorno
Quando il primo test funziona, io non mi fermo al “va”. È il momento di rendere il progetto usabile: fissare i componenti, etichettare i pin, salvare i codici in una struttura chiara e, se serve, chiudere tutto in un contenitore che protegga il LED dall’allineamento casuale e dai contatti instabili. Un progetto IR ben fatto deve essere ripetibile, non solo dimostrabile una volta.
- Organizza i codici in una tabella o in un piccolo array, così puoi cambiare telecomando senza riscrivere tutto.
- Prova il segnale a 1 m, 3 m e 5 m per capire dove si ferma davvero la portata utile.
- Se il comando arriva solo frontalmente, valuta un LED con angolo più stretto o due diodi in serie.
- Se il dispositivo è un climatizzatore, prepara spazio per i tempi raw e per i frame più lunghi.
- Se vuoi un sistema affidabile, conserva anche una copia del telecomando originale per confronti rapidi.
In pratica, un buon trasmettitore IR con Arduino non dipende da un trucco singolo ma da una catena coerente: componente giusto, cablaggio pulito, libreria adatta e protocollo corretto. Quando questi quattro elementi sono allineati, il progetto smette di essere un esperimento da banco e diventa uno strumento davvero utile nel quotidiano.
