Ricevitore USB IR ATtiny85: 11 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

ATTENZIONE, QUESTO ISTRUZIONI È DIVENTATO OBSOLETO

La libreria v-usb è progettata per funzionare con il protocollo USB 1.1 che al giorno d'oggi difficilmente esiste. Con l'arrivo di USB3 avrai più di un mal di testa nel tentativo di far funzionare i dispositivi v-usb. Dopo aver cambiato il mio centro multimediale, ho molti problemi di stabilità e anche se il ricevitore funziona, dopo un po' smette di funzionare. Non sono riuscito a cercare di risolverlo. Ho realizzato anche una versione atmega328p ma questa ha avuto gli stessi problemi. L'uso di un timer watchdog per ripristinare periodicamente la scheda non è stato d'aiuto, quindi ho rinunciato a v-usb.

Fatti un favore e non andare avanti con questo istruibile a meno che non sia per scopi educativi. Consiglio invece di acquistare un modulo chip ATmega 32U4 che ha già integrato l'interfaccia usb e seguire questa guida:

www.sparkfun.com/tutorials/337

Quindi inserisci un sensore IR TSOP31238 e sei a posto.

Ciao creatori! questa è una guida per costruire un ricevitore IR USB funzionante usando un microcontrollore Attiny85. Ho iniziato questo progetto per superare la mancanza di supporto (almeno supporto completo) per alcuni telecomandi IR nel sistema operativo GNU/Linux. Seguendo queste istruzioni potresti costruire un ricevitore IR USB programmabile che funzioni con qualsiasi telecomando IR per pochi dollari.

Prima di tutto, questo istruibile non esisterebbe senza il duro lavoro delle persone che hanno creato le librerie che uso qui:

• David A. Mellis per il suo core attiny
• Rowdy Dog Software per la loro libreria TinyTuner
• Rowdy Dog Software per il loro piccolo bootloader
• Rancidbacon (https://rancidbacon.com/) per il suo port arduino della libreria v-usb (https://code.google.com/archive/p/vusb-for-arduino/downloads)
• seejaydee per la sua libreria IR per piccoli core trovata nei commenti del codice https://www.instructables.com/id/Attiny-IR-librar… su https://www.instructables.com/id/Attiny-IR -biblioteca…

A volte non è facile trovare il proprietario giusto di una libreria, quindi nel caso avessi commesso un errore, lascia un commento e risolverei il problema al più presto.

Questa guida esiste perché non ho trovato un tutorial/guida completo funzionante fuori dagli schemi (potrebbe esistere, ma non sono riuscito a trovarlo) quindi ho raccolto tutte le informazioni disponibili sul web e dopo una buona quantità di prove e errori Mi è venuta in mente una guida completa per costruire un ricevitore IR USB funzionante che funzioni abbastanza bene.

Le principali fonti di informazione che ho seguito:

• https://nathan.chantrell.net/20121014/tinypcremot…
• https://forum.arduino.cc/index.php?PHPSESSID=ap4jg…
• https://blog.petrockblock.com/2012/05/19/usb-keybo…
• https://learn.adafruit.com/using-an-infrared-libr…
• https://codeandlife.com/2012/03/03/diy-usb-passwor…
• https://codeandlife.com/2012/02/22/v-usb-with-atti…
• https://www.instructables.com/id/Attiny-IR-librar…

Passaggio 1: alcune considerazioni

• Non possiedo un programmatore ISP AVR e non mi va di comprarne uno, quindi ho usato un Arduino per programmare attiny85
• Non mi interessa nessun altro sistema operativo oltre a GNU/Linux, quindi non so se funzionerà diversamente.
• ci sono altre librerie IR ma non sono riuscito a farle funzionare nemmeno con un arduino. Considera però che ho iniziato con una conoscenza limitata delle librerie IR. Forse potrei farli funzionare adesso, dopo l'esperienza acquisita nel trattare una discreta quantità di problematiche. Ad ogni modo, ero perso e disperato prima di trovare la libreria fornita da Seejaydee e da allora l'ho usata (molte grazie amico!).
• Ci sono altre configurazioni hardware, ma ho usato solo quella che usa 5V per alimentare attiny85 e due diodi zener da 3.6V 0.5W per bloccare la tensione delle linee dati, funziona fuori dalla scatola quindi non ho scherzato con altre configurazioni.
• Puoi usare un cristallo da 16 Mhz oppure puoi usare la libreria tinytuner per calibrare l'orologio interno del tuo attiny85. Consiglio vivamente l'uso del cristallo, è molto più stabile e probabilmente vi risparmierà un sacco di grattacapi.
• Sto usando qui due diversi bootloader per attiny85:

a) Versione Rowdy Dog Software, ha integrato un'interfaccia seriale che è molto bella ed è molto piccola in modo da avere più spazio per il tuo programma e altre librerie. Il problema è che per alcuni motivi anche se funziona abbastanza bene, dopo un po' di tempo il dispositivo usb si è disconnesso (puoi trovare i problemi con il comando dmesg). Non so se questo è un problema del core o una combinazione mista del core più le librerie scelte quindi dopo un po' ho deciso di usare questo core solo per decodificare i tasti del telecomando e calibrare l'orologio (quando non si usa un 16Mhz cristallo). Dopodiché, masterizzo il bootloader Mellis e carico lo sketch definitivo che non utilizza l'interfaccia seriale.

b) Versione Mellis, bootloader stabile, l'ho usato in molti progetti. Avrei usato sempre questo bootloader se avesse incluso un'interfaccia seriale. Uso questo core nello schizzo finale dopo aver decodificato tutti i tasti dei miei telecomandi.

Passaggio 2: iniziamo con l'hardware

Strumenti di cui hai bisogno:

• una scheda compatibile con Arduino
• un adattatore da seriale a usb per decodificare le tue chiavi remote (usa solo un FT232RL)
• un PC con installato GNU/Linux e l'IDE arduino configurato correttamente, sto usando l'IDE arduino 1.8.0
• un telecomando IR per testare il tuo dispositivo (anche uno scadente come quelli che si trovano negli starter kit di arduino funzionerà)
• un multimetro per eseguire il debug della tua scheda (spero non ne avrai bisogno, buona fortuna!)

L'elenco dei materiali:

• 1 attiny85
• 2 resistori 68R
• 1 resistenza da 1,5K
• 1 resistenza da 4,7K
• 1 cristallo 16Mhz
• 1 condensatore da 22 pF
• 1 condensatore da 0.1uF
• 1 condensatore da 10uF
• 2 diodi zener da 3,6 V 0,5 W
• 1 connettore USB tipo A maschio
• 1 pin strip con 6 pin per programmare ed eseguire il debug della scheda.
• 1 sensore IR TSOP31238
• tanto caffè per tenerti sveglio

Prima di saldare la scheda definitiva, probabilmente vorrai realizzare un prototipo di breadboard a scopo di test, seguire lo schema allegato a questa istruzione dovrebbe essere sufficiente per costruirlo.

Per collegare attiny85 al PC, il progetto finale utilizza un connettore USB di tipo A che viene saldato nella scheda, ma per il prototipo sarà necessario realizzare un cavo USB da collegare a una breadboard:

Saldare in un piccolo pezzo di perfboard 4 pin, quindi tagliare un vecchio cavo USB e saldare i pin a 4 dei fili all'interno del cavo USB:

• il rosso è VCC (5V)
• il nero è GND
• il bianco è D-
• il verde è D+

Tieni tutto insieme con la colla a caldo.

Ora dobbiamo collegare il programmatore ISP (Arduino), l'adattatore da USB a seriale (FT232RL) e il sensore IR all'attiny85.

Puoi lasciare collegati tutti insieme in modo da poter masterizzare diversi bootloader, caricare schizzi e controllare la porta seriale senza cambiare fili, Per fare ciò, collega tutto seguendo queste istruzioni:

Programmatore ISP (Arduino): questo ci permette di masterizzare bootloader e caricare sketch

• attiny85 PB0 (pin5) a pin11 (MOSI) in arduino
• attiny85 PB1 (pin6) a pin12 (MISO) in arduino
• attiny85 PB2 (pin7) a pin13 (SCK) in arduino
• attiny85 RESET (pin1) con pullup (4.6k a VCC) su pin10 in arduino
• attiny85 VCC a 5V in arduino
• attiny85 GND a GND in arduino

adattatore da usb a seriale (FT232RL): questo ci permette di controllare la porta seriale

• attiny85 PB0 (pin5 RX) a TX nell'FT232RL
• attiny85 PB2 (pin7 TX) a RX nell'FT232RL
• attiny85 GND (pin4) a GND sull'FT232RL
• visto che l'attiny85 è già alimentato dall'arduino non è necessario collegare il 5v sull'FT232RL, altrimenti collegare: attiny85 VCC (pin8) al 5V sull'FT232RL

usb to serial adapter (FT232RL) solo per la calibrazione dell'orologio (solo per il bootloader "ATtiny85 @ 8MHz (oscillatore interno;BOD disabilitato)")

• PB4 (pin3 RX) a TX nell'FT232RL attiny85
• PB3 (pin2 TX) a RX nell'FT232RL attiny85
• GND (pin4) a GND sull'FT232RL
• visto che l'attiny85 è già alimentato dall'arduino non è necessario collegare il 5v sull'FT232RL, altrimenti collegare: attiny85 VCC (pin8) al 5V sull'FT232RL

Se si utilizza un cristallo da 16 Mhz, collegarlo ai pin Attiny85 PB3 (pin2) e PB4 (pin3) e collegare ciascun pin anche a GND tramite un cappuccio da 22 pF ciascuno.

Filtra Attiny85 VCC con condensatori da 0.1uF e 10uF collegandoli in parallelo a GND

Collegare il pin di uscita del sensore IR all'attiny85 PB1 (pin6), accenderlo.

Costruisci e collega l'interfaccia USB:

• GND (filo nero): collegalo al comune GND (tutte le masse sono collegate insieme)
• D- (filo bianco) collegato a attiny85 PB0 (pin5) tramite un resistore 68R, collegalo anche a massa tramite uno zener da 3.6V 0.5W e tiralo fino a VCC con un resistore da 1.5K
• D+ (filo verde) collegato a PB2 tramite un resistore 68R, collegarlo a massa tramite uno zener da 3.6V 0.5W
• 5V, puoi lasciarlo scollegato poiché tutto è alimentato da Arduino in questa fase, altrimenti collegalo all'attiny85 VCC

I diodi zener sono collegati in modo che gli anodi siano collegati a GND e i catodi siano collegati alle linee dati D+ e D-.

Passaggio 3: progettazione finale

Per il design finale è possibile utilizzare perfboard con componenti a foro passante o incidere la propria scheda e utilizzare componenti smd. Per imparare come incidere una tavola, basta cercarla su Google, ci sono fantastici tutorial disponibili online.

Ho inciso la mia tavola e sono molto soddisfatto dei risultati finali (tavola piccola, stabile e robusta). Sì, lo so che il taglio fa schifo, ma non potevo usare nessun utensile elettrico così a tarda notte e io ho appena tagliato la tavola con le mie forbici per latta.

A proposito, le tracce sulle immagini non sono rame nudo, sono state trattate con una sostanza chimica sgradevole che intacca leggermente il rame (si sospetta che induca il cancro, quindi usalo con grande cura, globi di lattice e una maschera antipolvere):

Usa gli schemi sopra per progettare il tuo layout o puoi semplicemente usare l'impronta del mio pcb per incidere la tua scheda.

Passaggio 4: gestire il software

Il circuito in questo progetto è molto semplice, il software invece richiede uno sforzo maggiore.

Abbiamo bisogno di almeno 2 librerie (una in più se non stai usando un cristallo) più 2 bootloader per farlo funzionare. Quando ho iniziato questo progetto ho testato alcune librerie, a volte non funzionavano e molte volte semplicemente non erano configurate per funzionare con un Attiny85 pronto all'uso (non lo sapevo ancora). Quindi ho riscontrato problemi con le librerie / bootloader che si sovrappongono agli interrupt. Alla fine ho dovuto fare i conti con una discreta quantità di errori quando ho collegato il circuito finale al mio PC. Non avevo questa guida però, quindi penso che starai bene, segui i passaggi in questo istruibile, se lo fai senza commettere errori dovresti andare bene:)

Dobbiamo ora installare e configurare alcune librerie:

• libreria v-usb per arduino: questa libreria permette di riconoscere il microcontrollore dal PC come una tastiera USB HID, e la useremo per inviare i tasti al PC. Questa libreria necessita di alcune modifiche per essere compatibile con attiny85
• libreria tinytuner solo se non utilizzerai un cristallo da 16 Mhz. Sarà quindi necessario calibrare l'orologio interno del microcontrollore. Questa libreria funziona fuori dagli schemi.
• Attiny-IR-libreria per interagire con il sensore IR. Questa libreria funziona fuori dagli schemi.

Abbiamo bisogno anche di 2 bootloader:

• Versione Dog Software, con l'interfaccia seriale disponibile. Questo bootloader necessita di una piccola modifica per funzionare con attiny85 poiché utilizza il timer1 per la funzione millis() e non funzionerà con la libreria IR. Dobbiamo cambiare il timer in timer0.
• Versione Mellis, bootloader stabile che utilizzeremo nella fase finale. Questo funziona fuori dagli schemi.

Passaggio 5: installazione e configurazione della libreria V-usb

Scarica la libreria da https://code.google.com/archive/p/vusb-for-arduin… Decomprimi il file e copia la cartella library/UsbKeyboard nella cartella delle librerie degli sketchbook.

Ora devi modificare un paio di file per essere compatibile con ATtiny85 (è configurato per funzionare con arduino):

A) modifica usbconfig.h:

in "Configurazione hardware" cambia:

#define USB_CFG_IOPORTNAME Dto##define USB_CFG_IOPORTNAME B

e

#define USB_CFG_DMINUS_BIT 4to#define USB_CFG_DMINUS_BIT 0

in "Configurazione hardware opzionale" modificare:

#define USB_CFG_PULLUP_IOPORTNAME Dto##define USB_CFG_PULLUP_IOPORTNAME B

Per creare una specifica "HID compatibile con l'avvio" completa (altrimenti nessun tasto multimediale funzionerà), modificare anche:

#define USB_CFG_INTERFACE_SUBCLASS 0 // Bootto#define USB_CFG_INTERFACE_SUBCLASS 0x01 // Boot

e

#define USB_CFG_INTERFACE_PROTOCOL 0 // Tastiera per#define USB_CFG_INTERFACE_PROTOCOL 0x01 // Tastiera

Facoltativamente è anche possibile modificare il produttore e il nome del dispositivo nelle seguenti definizioni:

#define USB_CFG_VENDOR_NAME

#define USB_CFG_DEVICE_NAME

B) modificare UsbKeyboard.h:

modificare:

PORTAD = 0; // DA FARE: Solo per pin USB?DDRD |= ~USBMASK;

a

PORTAB = 0; // TODO: Solo per pin USB?DDRB |= ~USBMASK;

Per consentire anche la modifica dei codici chiave oltre 101:

0x25, 0x65, // MASSIMO_LOGICO (101) a:0x25, 0xE7, // MASSIMO_LOGICO (231)

e

0x29, 0x65, // USAGE_MAXIMUM (applicazione tastiera) a: 0x29, 0xE7, // USAGE_MAXIMUM (applicazione tastiera)

Potrebbe essere necessario modificare anche questi 3 file:

usbdrv.husbdrv.cUsbKeyboard.h

e ogni volta che vedi PROGMEM aggiungi "const" prima del nome del tipo di variabile (es: PROGMEN char usbHidReportDescriptor[35] ==> PROGMEM const char usbHidReportDescriptor[35])

Se questo non è chiaro, visita

Puoi evitare tutte queste modifiche se scarichi la libreria allegata (ho apportato tutte queste modifiche da solo) e la estrai nella cartella delle librerie degli album da disegno:

UsbKeyboard configurata per attiny85

Modifica: recentemente ho scoperto che Alejandro Leiva (https://github.com/gloob) si è preso cura di questa libreria e sembra funzionare anche bene. Puoi anche provare la sua versione con le modifiche necessarie che ho apportato per farlo funzionare con attiny, quindi se vuoi verificarlo basta estrarlo nella cartella delle librerie degli sketchbook.

UsbKeyboard configurata per attiny85 (versione Alejandro Leiva)

Passaggio 6: installazione delle librerie Attiny-IR e Tinytuner

A) Libreria Attiny-IR:

scaricalo da https://drive.google.com/open?id=0B_w9z88wnDtFNHlq… quindi decomprimilo nella cartella delle librerie degli sketchbook.

B) Libreria Tinytuner:

Questo è necessario solo se non stai usando un cristallo da 16Mhz, ma credimi, anche se funziona anche senza il cristallo, è molto più stabile con esso e costano pochi centesimi, quindi rendilo semplice, usa un cristallo e salta questa libreria.

Non sei ancora convinto? ok, scarica la libreria da https://storage.googleapis.com/google-code-archive… quindi decomprimila nella cartella delle librerie degli sketchbook.

Abbiamo finito con le librerie, ora passiamo all'installazione dei bootloader.

Passaggio 7: installazione e configurazione dei bootloader

Stiamo per installare due bootloader quello Mellis è secondo la mia esperienza più stabile e lo useremo nello sketch finale. L'altro sviluppato da Rowdy Dog Software è un core fantastico, molto piccolo e con un'interfaccia seriale integrata disponibile, ma il mio telecomando si è bloccato dopo un po' di tempo con esso quindi useremo questo bootloader solo per calibrare l'orologio interno attiny85 e per decodificare il nostro telecomando pulsanti.

So che ci sono librerie disponibili per dare le capacità seriali di attiny85, ma poi dovrai modificare le librerie che usano l'oggetto seriale … mi piace di più questa procedura.

Iniziamo con l'installazione:

A) Bootloader Mellis:

basta aprire le preferenze dell'IDE Arduino e aggiungere gli URL di Gestione schede aggiuntive:

raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Quindi apri il gestore delle schede IDE Arduino e cerca attiny, installa le schede da Mellis. Ora dovresti vedere l'ID Arduino delle schede ATtiny25/45/85 e ATtiny24/44/84.

B) Piccolo bootloader del software Rowdy Dog:

scarica il bootloader da

Decomprimi il file e copia la piccola cartella all'interno del tuo album da disegno/hardware (crea questa cartella se non esiste ancora). quindi spostati nella cartella sketchbook/hardware/tiny/avr/ e:

1) copiare il file Prospective Boards.txt nel file board.txt

2) modificare il file platform.txt e apportare alcune modifiche:

Decommenta la variabile compiler.path e lasciala puntare alla cartella hardware/tools/avr/bin/ all'interno della cartella di installazione di arduino:

compiler.path={PATH_TO_YOUR_ARDUINO_FOLDER}/hardware/tools/avr/bin/

cambia anche compilatore. S.flags=-c -g -assembler-con-cpptocompiler. S.flags=-c -g -x assembler-con-cpp

Quindi cambia le seguenti variabili assicurandoti che tutto sia al suo posto (quei file devono esistere, altrimenti punta le variabili nei percorsi giusti):

tools.avrdude.cmd.path={runtime.ide.path}/hardware/tools/avr/bin/avrdude

tools.avrdude.config.path={runtime.ide.path}/hardware/tools/avr/etc/avrdude.conf

tools.avrdude.cmd.path.linux={runtime.ide.path}/hardware/tools/avr/bin/avrdude

tools.avrdude.config.path.linux={runtime.ide.path}/hardware/tools/avr/etc/avrdude.conf

3) modifica il file cores/tiny/core_build_options.h e cambia:

#define TIMER_TO_USE_FOR_MILLIS 1 per#define TIMER_TO_USE_FOR_MILLIS 0

Questo è molto importante, altrimenti il ricevitore IR emetterà zero per ogni pulsante. Questa istruzione configura il timer0 per la funzione millis() lasciando il timer1 disponibile alla libreria IR. Lo schizzo finale disabiliterà comunque il timer0, quindi non avrai a disposizione né le funzioni millis() e delay(). Potresti avere invece la funzione delayMicroseconds() disponibile.

Questo bootloader è minimo, ma ha incluso il supporto per oggetti seriali:

Attiny85 PB2 (pin7) è TX e PB0 (pin5) è RX

Puoi avere una configurazione con il programmatore ISP (arduino) e l'adattatore seriale-usb collegati contemporaneamente in modo da non dover cambiare i cavi troppo spesso:

Ora abbiamo sia le librerie che i bootloader installati e configurati correttamente, il lavoro più duro è completato e possiamo iniziare a testare le cose.

Passaggio 8: masterizzazione di bootloader e caricamento di schizzi

Consiglio vivamente di attivare l'output dettagliato nelle preferenze IDE di Arduino in modo da poter capire qualsiasi eventuale problema.

Per masterizzare un bootloader in Attiny85 è necessario caricare l'esempio dell'ISP su Arduino e quindi selezionare il programmatore Arduino come ISP.

Ora posiziona un condensatore da 10uF tra i pin di reset e di massa sull'arduino (non è necessario per il processo di masterizzazione, ma serve per caricare gli schizzi su attiny85).

Ora l'arduino è pronto per masterizzare bootloader e caricare sketch. Devi solo selezionare la scheda giusta compatibile con il tuo attiny e masterizzarla.

Per caricare uno schizzo in Attiny85, caricalo nell'IDE di arduino e fai clic su "Carica utilizzando il programmatore".

IMPORTANTE: quando si carica lo sketch ci sono 3 passaggi, compilazione, scrittura e verifica. Se la compilazione e la scrittura hanno funzionato correttamente, ma il processo di verifica fallisce, è possibile che lo schizzo funzioni comunque.

Passaggio 9: calibrare l'orologio interno Attiny85 (saltare questo se si utilizza un cristallo)

Nel caso in cui decidi di non utilizzare il cristallo da 16Mhz devi calibrare il tuo orologio attiny85, quindi avremo bisogno di un bootloader con un'interfaccia seriale disponibile e utilizzeremo la libreria tinytuner per ottenere la calibrazione corretta.

Segui i passaggi successivi

• seleziona sotto strumenti Arduino come programmatore ISP
• selezionare la scheda "ATtiny85 @ 8MHz (oscillatore interno;BOD disabilitato)"
• Presumo che tu abbia la connessione ISP pronta come descritto prima della connessione, altrimenti fai le connessioni
• masterizzare bootloader
• questo bootloader ha configurato diversi pin per l'interfaccia seriale, usa questa configurazione solo per il bootloader corrente

- Da PB4 (pin3 RX) a TX nell'FT232RL attiny85 - PB3 (pin2 TX) a RX nell'FT232RL attiny85 - GND (pin4) a GND sull'FT232RL poiché attiny85 è già alimentato dall'arduino non è necessario collegare il 5v sull'FT232RL, altrimenti collegare: attiny85 VCC (pin8) al 5V sull'FT232RL

• carica l'esempio di tinytuner su attiny85
• aprire il programma screen per monitorare la comunicazione seriale: screen /dev/ttyUSB0 9600
• resettare l'attiny85 collegando il pin RESET (pin1) a GND (solo un momento), un messaggio di benvenuto dovrebbe essere visualizzato sulla finestra dello schermo
• Continuare a inviare singoli caratteri 'x' (nessun ritorno a capo, nessun avanzamento riga) fino al termine della calibrazione
• annotare da qualche parte il valore della calibrazione (OSCCAL = 0x). Questo è il valore che dovrai dichiarare sui bozzetti finali

Passaggio 10: decodifica i pulsanti del telecomando

Ora è il momento di decodificare i nostri pulsanti remoti e assegnarli a specifici tasti premuti nel PC, per farlo segui i passaggi successivi:

• selezionare la scheda "ATtiny85 @ 16 MHz (PLL interno; 4.3V BOD)" se non si utilizza un cristallo, "ATtiny85 @ 16 MHz (cristallo esterno; 4.3 V BOD" altrimenti, quindi masterizzarlo
• carica lo schizzo:
• Se non utilizzi un cristallo, decommenta la riga che contiene la variabile OSCCAL e assegnala al valore che hai trovato quando hai fatto la calibrazione dell'orologio
• Presumo che il sensore sia collegato come descritto prima, altrimenti collegalo
• Presumo anche che l'adattatore seriale-usb FT232RL sia collegato, altrimenti collegalo
• resettare attiny85 collegando il pin RESET (pin1) a GND (solo un attimo)
• premi ripetutamente i pulsanti del telecomando e controlla la finestra dello schermo, devi annotare l'ultimo numero per ogni record, ogni pulsante può produrre 2 numeri diversi

Esempio:

RICEVUTO D44 3396 RICEVUTO 544 1348

Annota 3396 e 1348 in associazione al pulsante che hai appena premuto, quindi devi decidere cosa vuoi fare con quel pulsante. Ad esempio, potrei volere che quel pulsante invii il codice chiave multimediale "Volume su", quindi devo trovare l'ID per quel codice chiave. Per farlo, scarica il PDF:

Cerca la sezione "Pagina tastiera/tastiera" a pagina 53 e usa i numeri nella colonna ID utilizzo (Dec) per associare i pulsanti del telecomando ai codici della tastiera. Nel nostro esempio possiamo vedere che il codice chiave per "Volume su" è: 128.

Modifica il file il file UsbKeyboard.h all'interno della libreria UsbKeyboard dal pacchetto v-usb che abbiamo installato prima e aggiungi ai define esistenti se non è già lì:

#define KEY_VOL_UP 128

Quando abbiamo finito con tutti i nostri pulsanti del telecomando e tutte le definizioni nel file UsbKeyboard.h sono pronte, possiamo passare all'ultimo passaggio.

Passaggio 11: caricamento dello schizzo finale e speranza per il meglio

Ora abbiamo tutti i pulsanti remoti decodificati, il file UsbKeyboard.h è riempito con i nostri keycode, quindi ora possiamo caricare nell'IDE di arduino lo sketch definitivo da:

github.com/venumz/ATtiny85-USB-IR-ricevitore…

Questo file è il file esatto che sto usando per il mio ricevitore e funziona per 2 telecomandi diversi, quindi chiaramente dovresti aggiornarlo per funzionare con il tuo telecomando.

Se non utilizzi un cristallo, decommenta la riga che contiene la variabile OSCCAL e assegnala al valore che hai trovato quando hai fatto la calibrazione dell'orologio

Nota che nella funzione loop ci sono molte istruzioni come questa:

if(results.value==3405 || results.value==1357) { // freccia su

if(lastStroke!=results.value) UsbKeyboard.sendKeyStroke(KEY_ARROW_UP);

}

Devi creare le tue dichiarazioni, una per ogni pulsante del telecomando. Nella condizione "if" devi inserire in results.value i valori che hai trovato decodificando il tuo telecomando e come argomento del metodo UsbKeyboard.sendKeyStroke devi inserire uno dei keycode già definiti nel file UsbKeyboard.h.

La condizione " if(lastStroke!=results.value) " è necessaria perché alcuni telecomandi inviano lo stesso codice due volte per colpo, e questo impedisce il secondo colpo. Non ne sono del tutto sicuro e potrebbe dipendere dal protocollo IR che hai programmato nel tuo telecomando (non sono proprio un esperto di protocolli IR) ma secondo la mia esperienza con i miei telecomandi, ogni pulsante può produrre 2 codici diversi e mentre si tiene premuto il pulsante, invia lo stesso codice, ma se si preme nuovamente il pulsante invia l'altro. Quindi sembra che i codici vengano inviati in modo alternativo, immagino sia una modalità standard per sapere quante volte si preme davvero il pulsante.

Ok, abbiamo quasi finito, basta caricare lo schizzo finale, collegarlo al PC e vedere come va.

Per questo passaggio, è meglio scollegare sia l'arduino che l'adattatore da USB a seriale e solo allora, collegare l'USB alla porta del PC (nel caso in cui qualcosa vada storto, sarà più semplice eseguire il debug del circuito).

Se tutto ha funzionato bene, quando apri un terminale e invii il comando dmesg dovresti vedere qualcosa di simile alla prima immagine in questo passaggio. Se ci fossero problemi, dovresti avere errori come quelli trovati nella seconda immagine e devi iniziare a eseguire il debug del tuo circuito e/o del software. Una delle fonti degli errori iniziali che avevo era un hub USB che non funzionava con il mio ricevitore IR (gli altri funzionavano però) … quindi è meglio per questo passaggio finale collegare il ricevitore IR direttamente alla porta del PC. Eventuali errori potrebbero essere difficili da trovare, ma alla fine, come me, impareresti molto e il prezzo da pagare ne vale la pena, te lo assicuro.

Questo è tutto gente, fammi sapere se noti errori in questo istruibile e goditi il tuo nuovissimo ricevitore USB IR!