Ponte delle candele tremolanti: 6 passaggi (con immagini)

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

Questo tutorial mostra come trasformare un semplice ponte di candele con luce statica in una bella luce d'atmosfera incandescente con infinite variazioni di luci tremolanti, scintillii, motivi a onde e quant'altro. Ho comprato da After Christmas Sales un ponte di candele per 8 €. Dispone di 7 luci led e alcuni adattatori da parete 33 V 3 W. Brilla di un colore bianco brillante e caldo e sarà perfetto per questo progetto, dove metterò un Arduino per far tremolare le candele. L'Arduino più popolare è Arduino Uno. In questo progetto, userò un Arduino Mega 2560.

Abbandonerò l'alimentatore da 30 V e utilizzerò un semplice power bank da 5 V pensato per i telefoni cellulari come alimentatore.

Una buona cosa da sapere sui power bank è che hanno un circuito interno, che trasforma la batteria da 3,7 V a 5 V. Poiché il processo utilizza un po' di energia, il power bank si spegne da solo, se non viene utilizzato. Se il power bank viene utilizzato per gadget fai-da-te basati su Arduino, il gadget non può semplicemente mettersi in modalità di risparmio energetico e ricominciare dopo pochi minuti. Questo spegnerà il power bank. Questo ponte di candele tremolante non ha la modalità di sospensione. Utilizza costantemente energia, mantenendo attivo il power bank, fino a quando il cavo di alimentazione non viene staccato.

Il video mostra il ponte delle candele in modalità statica e in pieno sfarfallio. Lo sfarfallio completo è davvero abbastanza fastidioso per gli occhi, mentre il video lo attenua un po'. Dopo che l'hardware è stato riparato, incluso il taglio dei cavi, la saldatura di nuove connessioni e l'aggiunta di alcuni componenti, vengono creati tutti i modelli di luce desiderati scrivendo il codice per Arduino. I modelli che includo in questo istruibile sono:

• 4 diverse luci tremolanti che imitano le vere candele
• 2 diversi luccichii (lampeggio casuale di luci altrimenti statiche)
• 2 diversi modelli di onde
• luce statica semplice

La commutazione dei modelli avviene tramite un pulsante, il singolo elemento dell'interfaccia utente. Più modelli si vogliono e più regolabilità si vogliono, più pulsanti e manopole si devono aggiungere. Ma la bellezza sta nella semplicità. Mantieni basso il numero di modelli selezionabili. Scegli le impostazioni migliori durante la codifica e il test, non aggiungendo molti controlli all'hardware.

Forniture

• 1 ponte candela a LED con 7 lampadine. Assicurati che sia un modello CC a bassa tensione, con batterie o con una fonte di alimentazione per montaggio a parete, che trasforma i micidiali 110 - 240 V CA in circa 6 - 30 V CC. Quindi è perfettamente sicuro hackerare il ponte delle candele.
• 1 Arduino Mega (qualsiasi altro microcontrollore andrà bene, assicurati solo di poterlo programmare)
• 1 breadboard di prototipazione
• cavi per ponticelli e altri cavi
• strumento di saldatura
• multimetro
• 7 resistori, 120 Ω
• 1 pulsante (mostrerò come utilizzare invece il pulsante integrato su un Arduino)
• Un transistor darlington IC per 7 transistor, ULN2803AP lo farà (se usi un Arduino Uno o Meaga, non ne hai davvero bisogno)
• Un power bank da 5 V pensato per i telefoni cellulari

Passaggio 1: esamina ciò che hai

Scopri su quale tensione opera ciascun LED e quanta corrente scorre attraverso.

1. Apri la parte inferiore del ponte delle candele. Trova i due fili che vanno a una candela.
2. Rimuovere un po' di isolamento dai cavi rivelando i fili di rame senza tagliare i fili di rame.
3. Accendi le luci (rilassati, sono solo pochi volt) e misura la tensione sui fili di rame rivelati.
4. Tagliare il cavo in uno dei punti di misura (a questo punto ovviamente le luci si spengono), togliere un po' di isolamento (3 - 4 mm) ad entrambe le estremità. Misura la corrente che passa. Quello che fai è ricollegare il cavo tagliato con il tuo multimetro, lasciando che tutta la corrente fluisca attraverso il tuo multimetro, che ora ti dice la quantità di corrente.

Le mie letture

La tensione su una candela (passo 3): 3,1 V

Si noti che la fonte di alimentazione del ponte di candele era 33 V. Quindi sette volte 3,1 V è solo 21,7 V. Su alcune candele deve esserci un resistore in più. Se avessi misurato quella tensione della candela, doveva essere di circa 11 V.

La corrente che scorre quando si accende la candela (fase 4): 19 mA

Alimenterò tutto con una batteria da 5 V 2 A. Per le candele, devo ridurre la tensione da 5 V a 3 V. Ho bisogno di un resistore, che abbasserà la tensione di 2 V a una corrente di 19 mA.

2 V / 0,019 A = 105 Ω

La potenza dissipata è:

2 V * 19 mA = 38 mW

Questo è trascurabile. Molto di più potrebbe far saltare la resistenza stessa. Tuttavia, senza un resistore da 105 potrei far saltare il LED. Ho resistori da 100 e 120 Ω. Vado con 120. Dà più protezione.

Il test di tutte e 7 le candele con 3 V ha fornito una luce brillante, ad eccezione di una candela, che aveva solo una luce molto fioca, con solo 0,8 mA di passaggio. Questa era la mia candela con la resistenza extra. Si è scoperto che le altre candele non avevano affatto resistori. Le luci a LED utilizzate nel lampadario sono semplicemente pensate per 3 V! La candela con la resistenza extra doveva essere aperta con una lieve violenza, ma non si ruppe nulla. La resistenza è stata trovata appena sotto il minuscolo LED all'interno del bulbo di plastica della candela. Ho dovuto dissaldare e risaldare i fili. Era un po' disordinato, dato che il saldatore ha scaldato della colla a caldo, che era stata usata per l'assemblaggio.

Quindi ora so che qualunque sia la fonte di alimentazione che uso, qualunque sia la tensione, devo abbassare la tensione a 3 V lasciando passare 19 mA.

Se avessi avuto più dimestichezza con la tecnologia LED, avrei riconosciuto il tipo di LED utilizzato e avrei saputo che aveva bisogno di 3 V.

Passaggio 2: alcune saldature

In questo passaggio collego tutti i fili positivi (+) dalle 5 candele a un filo. Quindi aggiungo un filo negativo (-) separato per ogni candela. Una luce LED si accende solo quando '+' e '-' vanno a destra. Poiché hai solo due estremità del cavo identiche da ciascuna candela, devi testare quale è "+" e quale è "-". Per questo è necessaria una fonte di alimentazione da 3 V. Avevo un piccolo pacco batterie che includeva due batterie AAA. Una batteria a bottone da 3 V funziona benissimo anche per i test.

Il ponte delle candele ha bisogno di 8 cavi per passare tra Arduino e il ponte. Se trovi un cavo con 8 fili isolati, sarebbe fantastico. Un filo deve contenere 120 mA, gli altri portano solo 20 mA al massimo. Ho scelto di utilizzare 4 cavi a doppio filo, che mi è capitato di avere.

La prima immagine mostra come ho preparato un filo comune per collegare tutti i fili "+" delle candele. Rimuovere un po' di isolamento del filo comune per ogni candela. Aggiungi un pezzo di tubo isolante termoretraibile (la striscia gialla nell'immagine) per ogni giunto e posizionalo nel punto giusto del cavo comune. Saldare il filo '+' da ciascuna candela al suo giunto, coprire il giunto con il tubo termoretraibile e restringerlo. Ovviamente va bene anche un semplice nastro adesivo, alla fine sarà tutto coperto.

La seconda immagine mostra i fili "-" di cui ogni candela ha bisogno. Il comune filo '+' va direttamente al pin 5 V dell'Arduino (o forse attraverso la breadboard). Ogni filo '-' va al proprio pin del transistor IC (di nuovo, probabilmente attraverso la breadboard).

Un Arduino è spesso chiamato una scheda di prototipazione. Una breadboard è anche qualcosa che usi nei prototipi. Quello che descrivo in questo istruibile è un prototipo. Non lo svilupperò in un prodotto elegante e brillante con tutto nascosto in belle custodie di plastica. Portarlo dal prototipo al livello successivo significherebbe sostituire la breadboard con un circuito stampato e componenti saldati e persino sostituire l'Arduino con un semplice chip di microcontrollore (in realtà tale chip è il cervello di Arduino). E avere tutto in una custodia di plastica o all'interno del ponte delle candele violato.

Passaggio 3: le connessioni

A proposito di Arduinos, tratto da questa pagina:

• Corrente massima totale per pin di ingresso/uscita: 40 mA
• Somma delle correnti di tutti i pin di ingresso/uscita combinati: 200 mA

Le mie candele assorbono 19 mA ciascuna, se alimentate da 3 V. Ce ne sono sette, il che fa 133 mA. Quindi potrei alimentarli direttamente dai pin di uscita. Tuttavia, ho alcuni circuiti integrati a transistor Darlington di riserva. Così ho pensato, perché no. Il mio circuito fa la cosa nel modo giusto: i pin dati sono solo per i segnali, non per l'alimentazione. Invece io uso il pin 5 V su Arduino per alimentare le luci a LED. Durante l'esecuzione del test, ho il mio laptop collegato ad Arduino. Tutto è alimentato dall'USB del laptop, che fornisce 5 V. L'Arduino Mega ha un proprio fusibile, che si brucia a 500 mA per proteggere il computer. Le mie candele assorbono al massimo 133 mA. L'Arduino probabilmente molto meno. Tutto funziona bene, quando alimentato dal laptop, quindi utilizzare un pacco batteria da 5 V collegato alla porta USB dell'Arduino va bene.

I pin dati D3 - D9 vanno all'IC ULN2803APGCN. I LED funzionano a 3 V. Ogni lampadina è collegata alla sorgente da 5 V e oltre a una resistenza da 120. Oltre a un canale dell'IC, che infine collega il circuito a terra attraverso un transistor darlington nell'IC.

Un pulsante viene aggiunto al circuito per abilitare alcune azioni dell'utente. Il ponte di candele potrebbe quindi avere alcuni programmi selezionabili dall'utente.

Il pulsante nel circuito è collegato a RESET e GND. Questo è esattamente ciò che fa il pulsante di ripristino integrato. Dal momento che non incapsulavo tutto in una custodia di plastica, sto usando il pulsante di ripristino su Arduino per controllare il programma. L'aggiunta di un pulsante in base all'immagine funzionerà esattamente come il pulsante di ripristino della scheda. Il programma funziona ricordando quale programma leggero è stato utilizzato l'ultima volta che il programma è stato eseguito. Pertanto, ogni reset avanzerà al successivo programma di illuminazione.

Le foto mostrano come escono i nuovi cavi dal ponte, come ho posato il transistor IC e le resistenze sulla breadboard e come i cavi dei jumper si collegano all'Arduino Mega. Ho tagliato 4 ponticelli maschio-maschio in 8 mezzi fili, che ho saldato agli 8 cavi uscenti dal ponte candela. In questo modo posso semplicemente inserire i cavi nella breadboard.

Alternativa senza transistor

Nel passaggio precedente, ho preparato un filo "+" comune per le candele e fili "-" separati, che passano attraverso il transistor IC a terra. Quando un pin di dati diventa alto, il filo "-" corrispondente viene messo a terra attraverso il suo transistor e il LED si accende.

Anche collegare i cavi '-' direttamente ai pin dati dell'Arduino funzionerebbe, ma ricorda sempre quanta corrente possono sopportare i pin dati! Questo approccio avrebbe bisogno di un cambiamento nel mio programma. Avrebbe bisogno che i pin dei dati si abbassassero per accendere le candele. Per usare il mio programma così com'è, devi cambiare '+' e '-' nelle candele. Avere un filo "-" comune per le candele, che va a GND su Arduino. E i fili separati corrono tra il filo "+" della candela e un pin dati dell'Arduino.

Passaggio 4: i programmi luce

Il mio programma, che presento nel passaggio successivo, passa attraverso 9 programmi luce. Premendo il pulsante si spegneranno le luci per un secondo, quindi si avvierà il seguente programma luci. I programmi sono i seguenti:

1. Forte sfarfallio. Le candele tremolano casualmente. Questo sembra molto fastidioso quando li guardi da vicino, ma potrebbe sembrare bello da lontano e forse dietro una finestra gelida della soffitta. Tuttavia, il tuo vicino potrebbe chiamare i vigili del fuoco.
2. Sfarfallio morbido. Sembra molto buono. Come vere candele in una stanza senza correnti d'aria.
3. Sfarfallio variabile. Le candele si alternano dolcemente tra lo sfarfallio forte e morbido a intervalli di circa 30 s.
4. Sfarfallio variabile. Come n. 3, ma ogni candela varia nel proprio ritmo tra 30 e 60 secondi.
5. Scintillio veloce. Le candele brillano a un livello smorzato statico e brillano casualmente. In media c'è uno scintillio ogni secondo.
6. Scintillio lento. Come #5, ma a un ritmo molto più lento.
7. Onda veloce dalla candela media superiore a quella inferiore.
8. Onda lenta dalla candela media superiore a quella inferiore.
9. Luce statica brillante. Ho dovuto includerlo, non volevo eliminare la funzione originale.

Passaggio 5: il codice

/*

FLICKERING CANDLE BRIDGE */ // Dichiara la variabile mode per mantenere lo stato // tramite un'operazione di reset _attribute_((section(".noinit"))) unsigned int mode; // Quando il programma si avvia dopo un reset, questo pezzo // di memoria non viene inizializzato, ma mantiene il valore // che aveva prima del reset. La prima volta che il programma // viene eseguito, contiene un valore casuale. /* * La classe della candela contiene tutto il necessario * per calcolare un livello di luce per * una candela tremolante. */ class candle { private: long maxtime; tempo minimo lungo; lungo maxlite; lungo minlite; medio lungo; origmaxtime lungo; lungo tempo di origine; origmaxlite lungo; origminlite lunga; lungo origmeanlite; tempo deltamax lungo; tempo deltamin lungo; deltamaxlite lungo; deltaminlite lungo; lunga deltameanlite; lungo lforato; lungo pareggio; inizio lungo; obiettivo lungo; fattore di galleggiamento; lungo targettime; tempo di avvio lungo; tempo delta lungo; void newtarget(void); long onetarget(void); public: candela(long mat, long mit, long mal, long mil, long mel, long eo); livello lungo ora (vuoto); void initlfo(long deltamat, long deltamit, long deltamal, long deltamil, long deltamean, long rate); void setlfo(void); }; candle::candle(long mat, long mit, long mal, long mil, long mel, long eo): maxtime(mat), mintime(mit), maxlite(mal), minlite(mil), meanlite(mel), evenout (eo), origmaxtime(mat), origmintime(mit), origmaxlite(mal), origminlite(mil), origmeanlite(mel) { target = meanlite; newtarget(); } /* * levelnow() restituisce il livello di luce che la candela dovrebbe avere in questo momento. * La funzione si occupa di definire un nuovo livello di luce casuale e * il tempo che dovrebbe impiegare per raggiungere quel livello. Il cambiamento non è lineare, * ma segue una curva sigmoide. Quando non è il momento di definire un nuovo * livello, la funzione restituisce semplicemente il livello di luce. */ long candle::levelnow(void) { long help, now; galleggiante t1, t2; ora = millis(); if (ora >= targettime) { help = target; newtarget(); restituire aiuto; } else { //help = target * (millis() - starttime) / deltatime + start * (targettime - millis()) / deltatime; t1 = float(targettime - now) / deltatime; t2 = 1. - t1; // Questo è l'aiuto per il calcolo sigmoide = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; restituire aiuto; } } candela vuota::newtarget(void) { somma lunga; somma = 0; for (long i = 0; i < evenout; i++) sum += onetarget(); inizio = destinazione; obiettivo = somma / pareggio; ora di inizio = millis(); targettime = starttime + random(mintime, maxtime); deltatime = targettime - starttime; } long candle::onetarget(void) { if (random(0, 10) lastcheck + 100) { lastcheck = now; /* * L'algoritmo per lo scintillio "dopo la frequenza millisecondi": * Inizia il controllo dopo la frequenza / 2 millisecondi * Durante un periodo di frequenza / 2 millisecondi, * fa in modo che la probabilità di uno scintillio sia del 50%. * Se la frequenza è 10000 ms, durante 5000 ms la moneta viene * lanciata 50 volte. * 1/50 = 0,02 * If random(10000) starttime + rate / 2) { if (random(rate) targettime) return lowlite; return (start - lowlite) * (targettime - now) / (targettime - starttime) + lowlite; } void twinkler::twink(void) { starttime = millis(); targettime = random(mintime, maxtime) + starttime; start = random(minlite, maxlite); } void setup() { led int; // Legge la variabile della modalità magica, che dovrebbe dire // quale programma light è stato eseguito l'ultima volta, incrementarlo // e ripristinarlo a zero in caso di overflow. modalità++; modalità %= 9; // Questo si occupa di qualunque // valore fosse la prima volta che Arduino // ha eseguito questo programma. /* * NOTA IMPORTANTE * ============== * * La cosa essenziale che fa questo programma è emettere segnali PWM * alle luci LED. Qui ho impostato i pin da 3 a 9 su * modalità di uscita. Su un Arduino Mega2560, questi pin emettono * segnali ben PWM. Se hai un altro Arduino, controlla * quali pin (e quanti) puoi usare. Puoi sempre * riscrivere il codice per utilizzare il software PWM, se il tuo Arduino * non può fornire abbastanza pin PWM hardware. * */ pinMode(3, OUTPUT); pinMode(4, USCITA); pinMode(5, USCITA); pinMode(6, USCITA); pinMode(7, USCITA); pinMode(8, USCITA); pinMode(9, USCITA); pinMode(LED_BUILTIN, OUTPUT); analogWrite(LED_BUILTIN, 0); // Basta spegnere il fastidioso led rosso sulla candela Arduino *can[7]; // preparati a usare le candele tremolanti, che tu le usi o meno twinkler *twink[7]; // prepararsi a usare le candele scintillanti… if (mode == 8) { for (int i = 3; i < 10; i++) analogWrite(i, 255); mentre (vero); // Ogni volta che questo programma viene eseguito, entra in // questo tipo di ciclo infinito, finché non viene premuto il pulsante // reset. } if (mode < 2) // sfarfallio { long maxtime_; lungo mintime_; lungo maxlite_; lungo minlite_; lungo mediolite_; lungo pari_; if (modalità == 0) { maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; pari_ = 1; } if (modalità == 1) { maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; pari_ = 1; } for (int i = 0; i < 7; i++) { can = new candle(maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // Il ciclo infinito per le candele tremolanti { for (int i = 0; i levelnow()); } } if (mode < 4) // lfo aggiunto allo sfarfallio { if (mode == 2) // stesso lfo (30 s) per tutte le candele { for (int i = 0; i initlfo(75, 50, 0, 50, 36, 30000); } } if (mode == 3) // variando lfo:s per le candele { for (int i = 0; i initlfo(75, 50, 0, 50, 36, 20000); can[1]->initlfo(75, 50, 0, 50, 36, 25000); can[2]->initlfo(75, 50, 0, 50, 36, 30000); can[3]->initlfo(75, 50, 0, 50, 36, 35000); can[4]->initlfo(75, 40, 0, 50, 36, 40000); can[5]->initlfo(75, 30, 0, 50, 26, 45000); can[6]->initlfo(75, 20, 0, 50, 16, 50000); can[7]->initlfo(75, 10, 0, 50, 6, 55000); } while (true) // Il ciclo infinito per le candele tremolanti con un lfo { long lastclock = 0; for (int i = 0; i levelnow()); if (millis() > lastclock + 4000) { lastclock = millis(); for (int i = 0; i setlfo(); } } } if (mode < 6) // candele scintillanti { int speedo; if (mode == 4) speedo = 6000; else speedo = 22000; for (int i = 0; i < 7; i++) twink = new twinkler(300, 295, 255, 250, speedo); while (true) { for (int i = 0; i levelnow()); } } // Onde. // Questa sezione inizia con parentesi graffe solo // per garantire che non vi siano nomi di variabili in conflitto. // Nessun'altra necessità di parentesi, nessuna necessità di controllare // il valore di mode.{ int lolite = 2; int hilite = 255; int significa; int ampli; galleggiante fasedelta = 2,5; fase galleggiante; int lungo; fattore di galleggiamento; lungo periodo; media = (lolite + hilite) / 2; ampl = hilite - medio; if (modalità == 6) periodo = 1500; altro periodo = 3500; fattore = 6.28318530718 / periodo; while (vero) { fase = phactor * (millis() % periodo); elong = media + ampl * sin(fase); analogWrite(7, lungo); analogWrite(9, lungo); fase = fattore * ((millis() + periodo / 4) % periodo); elong = media + ampl * sin(fase); analogWrite(3, elong); analogWrite(8, lungo); fase = fattore * ((millis() + periodo / 2) % periodo); elong = media + ampl * sin(fase); analogWrite(4, lungo); analogWrite(5, lungo); fase = fattore * ((millis() + 3 * periodo / 4) % periodo); elong = media + ampl * sin(fase); analogWrite(6, lungo); } // Mentre collegavo i fili della candela all'Arduino, // li ho mescolati e non li ho mai messi in ordine. // L'ordine è importante per creare modelli d'onda, // quindi ho appena scritto questa piccola tabella per me: // // Candle# nel bridge: 2 3 5 4 7 6 1 // Pin dati su Arduino: 3 4 5 6 7 8 9 } } void loop() { // Poiché ogni programma light è un proprio loop infinito, // ho scritto tutti i loop nella sezione begin() // e non ho lasciato nulla per questa sezione loop(). }

Passaggio 6: informazioni su PWM

I led brillano luminosi quando alimentati con 3 V. Usando solo 1,5 V non si accendono affatto. Le luci a LED non si sbiadiscono bene con la tensione di dissolvenza, come fanno le luci a incandescenza. Invece devono essere accesi a piena tensione, quindi spenti. Quando ciò accade 50 volte al secondo, brillano piacevolmente con una luminosità del 50%, più o meno. Se possono essere accesi solo 5 ms e spenti 15 ms, potrebbero brillare con una luminosità del 25%. Questa tecnica è ciò che rende la luce LED dimmerabile. Questa tecnica è chiamata modulazione di larghezza di impulso o PWM. Un microcontrollore come Arduino di solito ha pin di dati, che possono inviare segnali on/off. Alcuni dei pin di dati hanno funzionalità integrate per PWM. Ma se non ci sono abbastanza pin con PWM integrato, di solito è possibile utilizzare librerie di programmazione dedicate per creare "pin software PWM".

Nel mio progetto, ho usato un Arduino Mega2560, che ha PWM hardware sui pin 3 - 9. Se usi un Arduino UNO, hai solo sei pin PWM. In tal caso, se hai bisogno di una settima (o anche più) candela, posso consigliarti la libreria PWM del software di Brett Hagman, che puoi trovare qui.