Una lampada d'atmosfera a LED da $ 1 con ATtiny13 e WS2812: 7 passaggi

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

Di arduinocelentanoSegui altro dell'autore:

Questa è una lampada d'atmosfera a basso costo con quattro modalità.

1. Scintilla arcobaleno. Una scintilla di luce si muove di volta in volta verso l'alto e cambia gradualmente colore.

2. Bagliore arcobaleno. Un bagliore stabile che cambia gradualmente colore.

3. Simulazione del fuoco di candela.

4. Spento.

Puoi cambiare modalità toccando un pulsante a sfioramento in alto. La modalità corrente viene salvata nella memoria EEPROM dopo lo spegnimento.

Quanto è piccolo ATtiny13?

L'idea era di ottenere le massime funzionalità da un hardware minimo, qualcosa di più complesso di un interruttore automatico o di un termometro, un progetto vicino al limite di questo minuscolo microcontrollore. Dopotutto, le restrizioni ti fanno pensare creativo, giusto? Beh, all'inizio sembrava così.

La parte più impegnativa in questo progetto è stata quella di inserire tutto il codice in ATtiny13. Il microcontrollore ha 1K byte di flash e solo 64 byte di RAM. Sì, quando dico “byte” intendo quelli composti da otto bit. 64 byte per tutte le variabili locali e lo stack di chiamate. Per chiarire, considera che dobbiamo controllare 8 LED RGB. Ciascuno di essi è definito da 3 byte (uno rispettivamente per il canale rosso, verde e blu). Quindi, solo per memorizzare lo stato di 8 LED, dovremo implementare un array di 8 strutture da 3 byte ciascuna e un puntatore all'inizio di questo array richiederebbe un byte in più. Pertanto, 25 byte su 64 sono out. Abbiamo appena utilizzato il 39% della RAM e non abbiamo ancora iniziato. Inoltre, per memorizzare sette colori di base dell'arcobaleno, avrai bisogno di 7 × 3 = 21 byte, quindi il 72% della RAM è esaurito. Beh, per quanto riguarda i colori base, esagero: non ci servono tutti contemporaneamente in RAM e non cambiano mai, quindi possono essere implementati come un array costante da archiviare in flash anziché in RAM. Ad ogni modo, dà un'impressione generale sull'hardware usato.

Ricordando l'affermazione di Knuth sull'ottimizzazione prematura, ho iniziato a prototipare separatamente tre modalità di lampada per vedere cosa succede. Li ho testati separatamente per assicurarmi che funzionino correttamente e che ognuno si adatti al mio microcontrollore. Ci sono volute un paio di sere per realizzarlo e tutto è andato bene… finché non ho provato a metterli insieme all'interno di switch statement. L'utility avr-size ha riportato una dimensione della sezione di testo di 1,5 Kb (con il flag -s di avr-gcc). In quel momento la mia intenzione originale era di prendere degli ATtiny25 con flash da 2Kb e quello avrebbe potuto essere il lieto fine di questa storia.

Ma in qualche modo ho sentito che dopo una notevole ottimizzazione potevo riuscire a ridurre quel codice schifoso in 1Kb. Tuttavia, ci è voluta un'altra settimana per rendersi conto che è impossibile e un'altra settimana per realizzarlo comunque. Ho dovuto tagliare un arcobaleno in cinque colori di base (senza differenze visive significative). Mi sono liberato delle istruzioni case e ho usato una catena di if-then-if per ridurre la dimensione del codice binario. L'animazione del fuoco ha bisogno di un generatore di numeri pseudocasuali che è piuttosto ingombrante, quindi ho implementato una versione semplificata di LFSR con un valore iniziale costante. Non mi interessa la lunghezza del ciclo completo del PRNG e cerco solo un equilibrio di discesa tra la dimensione del codice e "animazione realistica del fuoco". Ho anche implementato molte ottimizzazioni minori che non ricordo in questo momento e sono persino riuscito a far lampeggiare tutte le modalità a parte il fuoco nel chip. Quando ho esaurito le idee, il mio codice totale era di circa 1200 byte.

Ho preso il timeout e ho letto molto sull'ottimizzazione del codice AVR. Stavo per arrendermi e riscrivere tutto in linguaggio assembly, ma gli ho dato l'ultima possibilità. Durante la corsa all'ottimizzazione finale, ho tagliato un arcobaleno in tre colori di base e ne ho fatti altri da calcolare al volo, ho ispezionato tutto e seguito i consigli di ottimizzazione dell'AVR e infine…

avrdude: scrittura flash (1004 byte):

Scrittura | ################################################# | 100% 0,90 secondi

Non c'è bisogno di dire che ho usato quasi tutta la RAM e solo un byte di EEPROM per memorizzare la modalità corrente. Non voglio dire che questa sia un'implementazione ideale e definitiva. Funziona e si adatta al microcontrollore. Sono sicuro, potresti farlo meglio. lo sono davvero. Voglio solo condividere il divertimento di risolvere un problema apparentemente poco pratico che all'inizio consideri quasi impossibile. “Così, hackerare significa esplorare i limiti di ciò che è possibile…” --Richard Stallman.

Forniture:

1x MCU ATtiny13 ($ 0,28 = $ 0,24 per MCU nel pacchetto SOP-8 e $ 0,04 per adattatore DIP8)

8 LED RGB WS2812 (consiglio una scheda o un pezzo di striscia LED) ($ 0,42)

1x pulsante a sfioramento TTP223 ($ 0,10)

1x adattatore da micro USB a DIP ($ 0,14)

1x resistore da 10kΩ (<$0,01)

1x condensatore ceramico da 100nF (<$0,01)

1x condensatore elettrolitico 10-47µF (<$0.01)

Totale <$ 0,97

Passaggio 1: installazione del software

Avrai bisogno della toolchain avr-gcc per compilare il codice sorgente e l'utility avrdude per caricare la ROM del microcontrollore. Il processo di installazione è abbastanza semplice e diretto, ma dipende dal tuo sistema operativo. Se usi una sorta di GNU/Linux, probabilmente hai già i pacchetti appropriati nell'albero del repository. Il codice sorgente di questo progetto può essere scaricato qui:

github.com/arduinocelentano/t13_ws2812_lamp

Avrai anche bisogno di una libreria light_ws2812:

github.com/cpldcpu/light_ws2812

Una volta che hai la toolchain avr-gcc e i sorgenti del progetto, esegui il tuo terminale e digita il seguente codice:

cd percorso/a/progetto

fare

Passaggio 2: Programmazione del microcontrollore

Se hai una sorta di programmatore USBASP, collegalo ad Attiny in base alla sua piedinatura. Di solito sembrerebbe così, ma consiglio vivamente di controllare il tuo pinout effettivo!

In alternativa, puoi usare una scheda Arduino come programmatore. Apri Arduino IDE e trova l'esempio dell'ISP Arduino nel menu "File→Esempi". Dopo aver caricato lo schizzo, la tua scheda Arduino funge da programmatore. I commenti nel codice dello schizzo ti darebbero un indizio sulla piedinatura.

Ora corri

fare lampeggiare

per eseguire il flashing dell'MCU e

fare fusibile

per impostare i bit dei fusibili.