Lampada solare ricaricabile alimentata da XOD: 9 passaggi (con immagini)

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

Ci sono lampade solari da giardino/passerella economiche disponibili nella maggior parte dei negozi di articoli per la casa e ferramenta. Ma come dice il vecchio proverbio, di solito ottieni quello per cui paghi. I soliti circuiti di ricarica e illuminazione che usano sono semplici ed economici, ma l'emissione luminosa che ottieni è tutt'altro che impressionante (e appena sufficiente per chiunque usi la tua passerella per vedere dove stanno andando!)

Questo è il mio tentativo di progettare un modulo di illuminazione off-grid che rappresenti un miglioramento significativo, pur essendo relativamente economico da realizzare. Dandogli un po' di "cervello". XOD.io è un nuovo IDE compatibile con la piattaforma di sviluppo embedded Arduino, dove è possibile "scrivere" il codice graficamente. L'ambiente traspone il tuo schizzo grafico nel moderno C++, che è notevolmente efficiente nel generare codice compatto e genera un sorgente completamente compatibile con l'IDE Arduino di serie senza richiedere ulteriori dipendenze esterne. In questo modo è possibile utilizzare anche microcontrollori piccoli ed economici con risorse di archiviazione dati e programmi limitate per svolgere compiti complessi.

Questo progetto mostra come due microcontrollori ATTiny85 compatibili con Arduino che lavorano insieme possono essere utilizzati per gestire i requisiti di alimentazione della lampada. Il primo processore gestisce i dati ambientali di rilevamento dall'hardware esterno e il secondo cerca di raccogliere la maggior quantità di energia possibile dal sole durante il giorno, quindi controlla l'illuminazione di un LED ad alta potenza mentre una batteria di accumulo si scarica di notte. Il secondo processore svolge il suo lavoro tramite un'implementazione compatta del controllo "fuzzy logic". Il software per entrambi i chip è stato sviluppato esclusivamente all'interno dell'ambiente XOD.

Passaggio 1: materiali necessari

Arduino IDE, ultima versione, con estensione ATTinyCore installata dal gestore "Boards"

Sparkfun USBTinyISP Programmatore ATTiny, 11801 o pagina prodotto Sparkfun equivalente

Convertitore boost a bassa tensione regolabile Pololu con ingresso di spegnimento, U1V11A o pagina prodotto Pololu equivalente

LED bianco o RGB ad alta potenza con dissipatore di calore, anodo comune, Adafruit 2524 o pagina prodotto Adafruit equivalente

Microchip ATTiny85 in pacchetto DIP a 8 pin, 2 pagine del prodotto Mouser

Prese DIP IC a 8 pin, 2

Condensatore di accumulo di massa, 16 v 220 uF

Condensatore di uscita, 6.3v 47uF

Resistori limitatori di corrente, 50 ohm 1/4 watt

Resistori di pull-up i2c, 4.7k, 2

Resistori del partitore di rilevamento della tensione del pannello, 1/4 watt, 100k, 470k

Resistenza di rilevamento della corrente, tolleranza 10 ohm 1⁄2 watt 1%

Condensatori di bypass, ceramica 0.1uF, 2

2 batteria ricaricabile agli ioni di litio da 3,7 v 100 mAh, PKCELL LP401 o equivalente

Jack di ingresso a barilotto per pannello, 1

Minimorsettiere Scheda saldata da 3"x3" e filo a nucleo solido sottile per effettuare i collegamenti

Per i test saranno quasi certamente necessari un oscilloscopio, un multimetro e un alimentatore da banco

Passaggio 2: configurazione dell'ambiente

L'ambiente XOD non supporta la serie ATTiny di processori pronti all'uso, ma utilizzando un paio di librerie di terze parti dall'universo Arduino è semplice aggiungere il supporto per questa serie di AVR. Il primo passo è installare la libreria "ATTinyCore" dal menu a discesa "Tools → Board → Board Manager" dell'IDE Arduino. Assicurati che le impostazioni come mostrato nell'immagine inclusa siano corrette - ricorda che devi premere "Burn bootloader" per cambiare i fusibili di impostazione della tensione di brownout e della velocità di clock prima di caricare qualsiasi codice!

Il codice sorgente per questa libreria è disponibile su:

Un'altra libreria utile da avere dal repository è "FixedPoints", che è un'implementazione in fase di compilazione della matematica a virgola fissa per i processori supportati da Arduino. L'ATTiny ha SRAM e memoria di programma limitate e aiuta molto a ridurre la dimensione dello schizzo finale per utilizzare un numero intero di 2 byte per l'archiviazione generale dei dati, piuttosto che un tipo a virgola mobile, che richiede 4 byte sull'AVR. Anche la velocità di esecuzione dovrebbe essere migliorata poiché ATTiny non ha un'unità di moltiplicazione hardware, tanto meno virgola mobile hardware!

Il codice sorgente è disponibile su:

Il tutorial su come creare, transpilare e distribuire schizzi grafici XOD su: https://github.com/Pharap/FixedPointsArduino aiuterà molto a capire come sono stati creati i file sorgente inclusi.

Passaggio 3: panoramica del design

Sulla scheda due processori ATTiny85 sono collegati tramite un'interfaccia i2c e vengono utilizzati insieme per gestire il rilevamento della tensione del pannello solare, la corrente che scorre nella batteria dal convertitore boost mentre il pannello è illuminato, la tensione della batteria e la batteria temperatura.

Il convertitore boost è un modulo standard basato su un circuito integrato TPS6120 di Texas Instruments, che può accettare una tensione di ingresso fino a 0,5 volt e aumentarla da 2 volt a 5 volt. Il nucleo del sensore comprende diversi blocchi funzionali. L'orologio principale inizia a funzionare non appena viene applicata l'alimentazione al convertitore boost dall'ingresso del pannello solare. Questo avvia l'esecuzione dello schizzo e la prima cosa è determinare se il pannello è illuminato abbastanza da fornire corrente di carica alla batteria.

La tensione del pannello solare viene passata attraverso due filtri digitali e, se è al di sopra di una certa soglia, il sistema determina che il pannello è illuminato e collega l'orologio principale al monitor di rilevamento della corrente. Questo è un canale di conversione da analogico a digitale del chip, configurato in modo differenziale, che rileva la tensione attraverso un resistore di tolleranza dell'1% da 10 ohm collegato in serie tra l'uscita del convertitore boost e l'ingresso della batteria. Quando il pannello non è illuminato, questo ATTiny invia un segnale al secondo ATTiny dicendogli di monitorare la potenza del LED invece di caricare la potenza e spegnere il convertitore boost e isolare l'ingresso in modo che la batteria non rimandi la corrente attraverso il pannello.

Il secondo nucleo ATTiny è dove vengono eseguiti il controller LED e il sistema di monitoraggio della carica della batteria. I dati di tensione del pannello, tensione della batteria e corrente di carica della batteria vengono inviati a questo core per l'elaborazione attraverso una rete a logica fuzzy, che tenta di generare un segnale PWM appropriato da applicare al pin SHTDN, controllando così la quantità di corrente inviata alla batteria per caricarlo quando è illuminato - una forma base di tracciamento del punto di massima potenza (MPPT). Riceve anche un segnale dal nucleo del sensore che gli dice se deve accendere o spegnere il LED, a seconda dell'uscita del nucleo del sensore giorno/ infradito notturno.

Quando il LED è attivo di notte, questo ATTiny monitora i dati sulla tensione della batteria inviati dal suo compagno e il proprio sensore di temperatura sul chip, per ottenere una stima approssimativa di quanta energia viene spinta nel LED (la tensione della batteria diminuisce e la temperatura del chip aumenta con la corrente prelevata dai suoi pin.) La rete a logica fuzzy associata alla patch LED PWM tenta di esprimere un giudizio su quanta carica della batteria è ancora disponibile e diminuisce l'intensità del LED quando la batteria è scarica.

Passaggio 4: creazione di patch personalizzate dalla libreria XOD Core

Per questo progetto sono stati utilizzati diversi nodi patch personalizzati, alcuni dei quali possono essere facilmente costruiti interamente da nodi XOD inclusi e altri implementati in C++.

Il primo dei due nodi patch personalizzati nelle immagini è un'implementazione di un filtro a media mobile esponenziale. Si tratta di un filtro digitale passa-basso utilizzato in serie nello schizzo, una volta per filtrare la tensione del pannello solare in ingresso per il nucleo logico e ancora una volta per alimentare il trigger che determina l'illuminazione ambientale a lungo termine. Vedi la voce di Wikipedia sul livellamento esponenziale.

La struttura del nodo nell'immagine è solo una rappresentazione grafica diretta della funzione di trasferimento nell'articolo, collegati tra loro tramite collegamenti dagli input appropriati agli output. C'è un nodo di rinvio dalla libreria che consente di creare un ciclo di feedback (XOD ti avviserà se crei un ciclo di feedback senza inserire un ritardo nel ciclo, come descritto nel modello di esecuzione XOD). la patch funziona bene, è semplice.

Il secondo nodo patch personalizzato è una variazione del flip-flop di serie incluso con XOD, che viene alimentato con la tensione del pannello filtrata. Si blocca in alto o in basso a seconda che il segnale di ingresso sia al di sopra o al di sotto di una certa soglia. I nodi cast vengono utilizzati per convertire i valori di uscita booleani nel tipo di dati a impulsi per attivare il flip flop, quando lo stato passa da basso ad alto. Si spera che il design di questo nodo di patch sia in qualche modo autoesplicativo dallo screenshot.

Passaggio 5: creazione di patch personalizzate utilizzando C++

Per requisiti speciali in cui la funzionalità del nodo necessaria sarebbe troppo complessa da rappresentare graficamente facilmente, o che si basano su librerie Arduino non native dell'ambiente Arduino di serie, XOD rende facile per chi ha una certa conoscenza di C/C++ scrivere blocchi di dimensioni ridotte di codice che può quindi essere integrato in una patch come qualsiasi altro nodo creato dall'utente o stock. Selezionando "crea una nuova patch" dal menu file si crea un foglio vuoto con cui lavorare e i nodi di input e output possono essere trascinati dalla sezione "nodi" della libreria principale. Quindi il nodo "not-implemented-in-xod" può essere trascinato e, quando si fa clic, verrà visualizzato un editor di testo in cui la funzionalità richiesta può essere implementata in C++. Come gestire lo stato interno e accedere alle porte di input e output dal codice C++ è spiegato qui.

Come esempio di implementazione di patch personalizzate in C++, vengono utilizzate altre due patch personalizzate per il core del driver per fornire una stima della tensione di alimentazione e della temperatura del core del driver. Insieme alla sua rete sfocata, ciò consente una stima approssimativa della carica residua della batteria disponibile per alimentare i LED quando è buio.

La patch del sensore di temperatura viene anche alimentata con l'uscita del sensore di tensione di alimentazione per ottenere una stima migliore: il rilevamento della temperatura interna ci consente di ottenere una stima approssimativa di quanta potenza viene bruciata nei LED e combinata con la lettura della tensione di alimentazione quando scaricando la batteria un'ulteriore stima approssimativa della carica residua della batteria. Non deve essere super-preciso; se il nucleo "sa" che i LED assorbono molta corrente ma la tensione della batteria sta calando rapidamente, è probabilmente sicuro dire che la carica della batteria non durerà molto più a lungo, ed è ora di spegnere la lampada.

Passaggio 6: costruzione

Ho costruito il progetto su un piccolo pezzo di scheda di prototipazione con cuscinetti in rame per le parti a foro passante. L'uso di socket per i circuiti integrati aiuta molto per la programmazione/modifica/test; l'ISP USBTiny di Sparkfun ha una presa simile sulla sua scheda, quindi la programmazione dei due chip consiste semplicemente nel collegare il programmatore a una porta USB del PC, caricare il codice XOD trapiantato dai file Arduino.ino inclusi con la scheda appropriata e le impostazioni del programmatore e quindi rimuovendo delicatamente i chip dallo zoccolo del programmatore e inserendoli negli zoccoli della scheda prototipi.

Il modulo convertitore boost basato su Pololu TPS6120 viene fornito su una scheda riser saldata nella scheda prototipi sulle intestazioni dei pin, quindi è possibile risparmiare spazio montando alcuni componenti sottostanti. Sul mio prototipo ho messo sotto i due resistori di pullup da 4.7k. Questi sono necessari affinché il bus i2c tra i chip funzioni correttamente - la comunicazione non funzionerà senza di essi! Sul lato destro della scheda c'è il jack di ingresso per la spina del pannello solare e il condensatore di accumulo di ingresso. È meglio provare a collegare il jack e questo cappuccio direttamente insieme tramite "corse" di saldatura, non filo di collegamento, per ottenere un percorso a bassa resistenza possibile. Vengono quindi utilizzati tratti di saldatura solida per collegare il terminale positivo del condensatore di accumulo direttamente al terminale di tensione di ingresso del modulo boost e il pin di terra del modulo boost direttamente al pin di terra del jack.

A destra e a sinistra delle prese per i due ATTiny ci sono condensatori di depike/deglitch da 0.1uF. Anche questi componenti sono importanti da non tralasciare e dovrebbero essere collegati ai pin di alimentazione e di terra dei circuiti integrati attraverso un percorso il più breve e diretto possibile. Il resistore di rilevamento della corrente da 10 ohm è a sinistra, questo è collegato in linea con l'uscita dal convertitore boost e ciascun lato è collegato a un pin di ingresso del nucleo del sensore - questi pin sono impostati per funzionare come un ADC differenziale per misurare indirettamente il corrente nella batteria. Le connessioni tra i pin IC per il bus i2c e il pin di spegnimento del convertitore boost, ecc. possono essere effettuate utilizzando un cavo di collegamento sul lato inferiore della scheda prototipi, un cavo di collegamento a nucleo solido molto sottile funziona benissimo per questo. Rende le modifiche più facili e sembra anche molto più ordinato rispetto all'esecuzione di ponticelli tra i fori nella parte superiore.

Il modulo LED che ho usato era un'unità RGB a tre colori, il mio piano era di avere tutti e tre i LED attivi per produrre il bianco quando la batteria era quasi completamente carica e far sfumare lentamente il LED blu in giallo quando la carica era esaurita. Ma questa funzione deve ancora essere implementata. Anche un singolo LED bianco con un resistore di limitazione della corrente funzionerà bene.

Passaggio 7: test, parte 1

Dopo aver programmato entrambi i circuiti integrati ATTiny con i file di schizzo inclusi tramite il programmatore USB dall'ambiente Arduino, è utile verificare che i due core sul prototipo funzionino correttamente prima di provare a caricare la batteria dal pannello solare. Idealmente, ciò richiede un oscilloscopio di base, un multimetro e un alimentatore da banco.

La prima cosa da controllare è che non ci siano cortocircuiti da nessuna parte sulla scheda prima di collegare i circuiti integrati, la batteria e il pannello alle loro prese per evitare possibili danni! Il modo più semplice per farlo è utilizzare un alimentatore da banco in grado di limitare la sua corrente di uscita a un valore sicuro in caso di tale situazione. Ho usato il mio alimentatore da banco impostato a 3 volt e limite di 100 mA collegato ai terminali del jack di ingresso del pannello solare ai cavi di alimentazione positivo e negativo. Con nient'altro che i componenti passivi installati, non dovrebbe esserci essenzialmente nessun assorbimento di corrente registrato sul monitor di corrente dell'alimentatore di cui parlare. Se c'è un flusso di corrente significativo, o l'alimentazione va in limitazione di corrente, qualcosa è andato storto e la scheda dovrebbe essere controllata per assicurarsi che non ci siano collegamenti errati o condensatori con polarità invertita.

Il prossimo passo è assicurarsi che il convertitore boost funzioni correttamente. C'è un potenziometro a vite sulla scheda, con l'alimentatore ancora collegato e quattro dei pin del convertitore collegati in modo appropriato, il potenziometro deve essere ruotato con una piccola punta di cacciavite fino a quando la tensione al terminale di uscita del modulo non è compresa tra 3,8 e 3,9 volt. Questo valore CC non cambierà durante il funzionamento, il nucleo del driver controllerà la tensione di uscita media tramite l'impulso del pin di spegnimento del modulo.

Passaggio 8: test, parte 2

La prossima cosa da verificare è che la comunicazione i2c funzioni correttamente, con la scheda che funziona senza alimentazione di banco è possibile installare l'IC del nucleo del sensore. Su un oscilloscopio dovrebbero esserci segnali pulsanti sia sul pin 5 che sul pin 7 del chip fisico, questo driver i2c sul chip tenta di inviare dati al suo amico. Dopo lo spegnimento è possibile installare il core del driver e controllare nuovamente la connessione con un oscilloscopio, dovrebbe essere visibile una sequenza di impulsi più ampia su entrambe le linee. Ciò significa che i chip comunicano correttamente.

È utile avere la batteria leggermente carica per il test completo finale. Per fare ciò può essere utilizzata anche l'alimentazione da banco, con il limite di corrente impostato a circa 50 mA e la tensione ancora a 3,8 volt, lasciando la batteria LiPo collegata direttamente per alcuni minuti.

Il passaggio finale è testare l'intero sistema: con tutto collegato se il pannello è coperto per dieci o 15 secondi, la luce dovrebbe accendersi essendo pilotata tramite l'uscita PWM del core del driver. Con il pannello in pieno sole, la batteria dovrebbe caricarsi dall'uscita del convertitore boost. La rete a logica fuzzy può essere ispezionata indirettamente per vedere se funziona correttamente osservando la linea PWM che guida il pin di spegnimento del convertitore boost; poiché l'illuminazione aumenta con la batteria con uno stato di carica basso, l'ampiezza dell'impulso dovrebbe aumentare, mostrando che man mano che diventa disponibile più energia dalla luce solare, il nucleo del driver segnala che è necessario inviare più energia alla batteria!

Passaggio 9: Appendice sulla logica fuzzy

La logica fuzzy è una tecnica di apprendimento automatico che può essere utilizzata nel controllo di sistemi hardware in cui vi è incertezza in molti dei parametri del sistema controllato, rendendo difficile da scrivere matematicamente una soluzione di controllo da input a output esplicita per l'obiettivo. Ciò si ottiene utilizzando valori logici che cadono da qualche parte tra 0 (falso) e 1 (vero), esprimendo l'incertezza in un valore più simile a come farebbe un essere umano ("principalmente vero" o "non proprio vero") e consentendo una zona grigia tra affermazioni vere al 100% e false al 100%. Il modo in cui ciò viene realizzato è innanzitutto il prelievo di campioni delle variabili di input su cui deve basarsi una decisione e la loro "confusione".

Il cuore di qualsiasi sistema a logica fuzzy è una "memoria associativa fuzzy". Questo ricorda una matrice, dove nel caso del circuito di carica della batteria viene memorizzato un insieme 3x3 di valori compresi tra 0 e 1. I valori nella matrice possono essere approssimativamente associati a come un essere umano ragiona su quale dovrebbe essere il fattore PWM che controlla il pin SHTDN del convertitore boost, a seconda di come la funzione di appartenenza sopra qualifica un determinato set di input. Ad esempio, se la tensione di ingresso del pannello è alta, ma la corrente assorbita dalla batteria è bassa, probabilmente significa che è possibile assorbire più energia e che l'impostazione PWM non è ottimale e dovrebbe essere aumentata. Al contrario, se la tensione del pannello si abbassa ma il caricabatterie sta ancora tentando di spingere una grande corrente nella batteria, verrà sprecata anche la potenza, quindi sarebbe meglio ridurre il segnale PWM al convertitore boost. Una volta che i segnali di ingresso sono "fuzzificati" in un insieme fuzzy, vengono moltiplicati per questi valori, in modo simile al modo in cui un vettore viene moltiplicato per una matrice, per generare un insieme trasformato che è rappresentativo di quanto pesantemente la "conoscenza" contenesse la cella della matrice dovrebbe essere scomposto nella funzione di combinazione finale.

Utilizzando il nodo "not-implemented-in-xod" che consente ai nodi XOD che implementano funzionalità personalizzate troppo complicate per essere ragionevoli da realizzare dai blocchi predefiniti di serie, e un po' di C++ in stile Arduino, la memoria associativa, la funzione di ponderazione e " fuzzifier" simili ai blocchi descritti in questo riferimento: https://www.drdobbs.com/cpp/fuzzy-logic-in-c/184408940 sono semplici da realizzare e molto più facili da sperimentare.