Flimrande ljusbro: 6 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:41

Denna instruerbara visar hur man gör en enkel ljusbro med statiskt ljus till ett fint glödande humörljus med oändliga variationer av flimrande ljus, blinkande, vågmönster och vad inte. Jag köpte en ljusbro från After Christmas Sales för 8 €. Den har 7 LED -lampor och en väggadapter på 33 V 3 W. Den lyser med en ljus och varm vit färg och kommer att vara perfekt för detta projekt, där jag kommer att sätta en Arduino för att få ljusen att flimra. Den mest populära Arduino är Arduino Uno. I det här projektet kommer jag att använda en Arduino Mega 2560.

Jag kommer att släppa 30 V -strömförsörjningen och kommer att använda en enkel 5 V -powerbank avsedd för mobiltelefoner som strömförsörjning.

En bra sak att veta om kraftbanker är att de har en inre krets, som omvandlar batteriet 3,7 V till 5 V. Eftersom processen använder lite ström stänger powerbanken av sig själv om det inte används. Om powerbanken används för Arduino -baserade DIY -prylar kan gadgeten inte bara lägga sig i energisparande sömn och börja om efter några minuter. Det stänger av strömbanken. Denna flimrande ljusbro har inget viloläge. Den använder ständig ström och håller powerbanken aktiv tills strömkabeln dras av.

Videon visar ljusbron i statiskt läge och i full flimmer. Hela flimmern är verkligen ganska irriterande för ögonen, medan videon slätar ut det lite. Efter att hårdvaran har fixats, inklusive skärning av kablar, lödning av nya anslutningar och tillsättning av några komponenter, skapas alla önskade ljusmönster genom att skriva kod för Arduino. Mönstren jag inkluderar i denna instruerbara är:

• 4 olika flimrande lampor som imiterar riktiga ljus
• 2 olika blinkningar (slumpmässigt blinkande av annars statiska lampor)
• 2 olika vågmönster
• enkelt statiskt ljus

Växlingsmönster sker genom en tryckknapp, det enda användargränssnittselementet. Ju fler mönster man vill ha och ju mer justerbarhet man vill ha, desto fler knappar och rattar måste man lägga till. Men skönheten ligger i enkelheten. Håll antalet valbara mönster nere. Välj de bästa inställningarna när du kodar och testar, inte genom att lägga till många kontroller till hårdvaran.

Tillbehör

• 1 LED -ljusbro med 7 lampor. Se till att det är en lågspännings DC -modell, antingen med batterier eller med en väggmonterad strömkälla, som omvandlar den dödliga 110 - 240 V AC till cirka 6 - 30 V DC. Så det är helt säkert att hacka ljusbron.
• 1 Arduino Mega (någon annan mikrokontroller kommer att göra, se bara till att du kan programmera den)
• 1 prototypformade brödbräda
• bygelkablar och annan tråd
• lödningsverktyg
• multimeter
• 7 motstånd, 120 Ω
• 1 tryckknapp (jag visar hur du kan använda den inbyggda knappen på en Arduino istället)
• En darlington transistor IC för sju transistorer kommer ULN2803AP att göra (Om du använder en Arduino Uno eller Meaga behöver du inte riktigt detta)
• En 5 V powerbank avsedd för mobiltelefoner

Steg 1: Undersök vad du har

Ta reda på vilken spänning varje lysdiod driver och hur mycket ström som flyter igenom.

1. Öppna botten av ljusbron. Hitta de två trådarna som går till ett ljus.
2. Ta bort lite isolering från kablarna som avslöjar koppartrådarna utan att klippa koppartrådarna.
3. Slå på lamporna (slappna av, det är bara några volt) och mät spänningen över de avslöjade koppartrådarna.
4. Klipp kabeln vid en av mätpunkterna (vid denna tidpunkt slocknar lamporna förstås), ta bort lite isolering (3 - 4 mm) i båda ändarna. Mät strömmen som går igenom. Det du gör är att du kopplar in den igenklippta kabeln med din multimeter, så att all ström flödar genom din multimeter, som nu berättar mängden ström.

Mina avläsningar

Spänningen över ett ljus (steg 3): 3,1 V

Observera att strömkällan till ljusbron var 33 V. Så sju gånger är 3,1 V bara 21,7 V. På några av ljusen måste det finnas ett extra motstånd. Hade jag mätt den ljusspänningen måste den ha varit cirka 11 V.

Strömmen flyter igenom när ljus tänds (steg 4): 19 mA

Jag ska driva allt med ett 5 V 2 A batteri. För ljusen måste jag tappa spänningen från 5 V till 3 V. Jag behöver ett motstånd, vilket kommer att släppa spänningen 2 V vid en 19 mA ström.

2 V / 0,019 A = 105 Ω

Den effekt som försvinner är:

2 V * 19 mA = 38 mW

Det är försumbart. Mycket mer kan spränga själva motståndet. Men utan ett 105 Ω motstånd kan jag blåsa lysdioden. Jag har 100 Ω och 120 Ω motstånd. Jag går med 120 Ω. Det ger mer skydd.

Att testa alla 7 ljus med 3 V gav ett starkt ljus, förutom ett ljus, som bara hade ett mycket svagt ljus, med bara 0,8 mA. Detta var mitt ljus med det extra motståndet. Det visade sig att de andra ljusen inte hade några motstånd alls. LED -lamporna som används i ljuskronan är helt enkelt avsedda för 3 V! Ljuset med det extra motståndet måste öppnas med milt våld, men inget gick sönder. Motståndet hittades precis under den lilla lysdioden inuti lampan av plastljus. Jag var tvungen att avlöda bort den och lösa trådarna. Det var lite rörigt, eftersom lödkolven värmde upp lite hett lim, som hade använts för montering.

Så nu vet jag att oavsett vilken strömkälla jag använder, oavsett spänning, måste jag sänka spänningen till 3 V så att 19 mA går igenom.

Om jag hade varit mer bekant med LED -teknik, skulle jag känna igen vilken typ av LED som används och jag hade vetat att den behövde 3 V.

Steg 2: Lite lödning

I detta steg ansluter jag alla positiva (+) ledningar från de 5 ljusen till en tråd. Sedan lägger jag till en separat negativ (-) tråd för varje ljus. En LED-lampa tänds bara när "+" och "-" går åt höger. Eftersom du bara har två identiska kabeländar från varje ljus, måste du testa vilket som är "+" och vilket är "-". För detta behöver du en 3 V strömkälla. Jag hade ett litet batteripaket med två AAA -batterier. Ett 3 V myntbatteri fungerar också utmärkt för testning.

Ljusbron behöver 8 kablar för att gå mellan Arduino och bron. Om du hittar en kabel med 8 isolerade ledningar, skulle det vara bra. En tråd måste hålla 120 mA, resten av dem bär högst 20 mA. Jag valde att använda 4 dubbelkabel, vilket jag råkade ha.

Den första bilden visar hur jag förberedde en gemensam tråd för att ansluta alla '+' trådar från ljusen. Ta bort lite isolering av den vanliga tråden för varje ljus. Lägg till en bit krympisoleringsrör (den gula remsan på bilden) för varje skarv och placera den på rätt plats i den gemensamma kabeln. Löd "+" -tråden från varje ljus till dess led, täck fogen med krympslangen och krympa den. Naturligtvis är enkel tejp bra, allt kommer att täckas till slut.

Den andra bilden visar '-' trådarna som varje ljus behöver. Den vanliga "+" - kabeln går direkt till 5 V -stiftet på Arduino (eller kanske genom brödbrädan). Varje '-' tråd går till sin egen stift på transistorn IC (igen, troligen genom brödbrädan).

En Arduino kallas ofta en prototypplatta. En brödbräda är också något du använder i prototyper. Det jag beskriver i denna instruerbara är en prototyp. Jag kommer inte att utveckla det till en lyxig blank produkt med allt dolt i fina plastfodral. Att ta den från prototypen till nästa nivå skulle innebära att byta ut brädbrädan med ett kretskort och lödda komponenter och till och med byta ut Arduino med bara ett enkelt mikrokontrollerchip (faktiskt är detta chip Arduino -hjärnan). Och att allt passar i ett plastfodral eller inuti den hackade ljusbron.

Steg 3: Anslutningarna

Om Arduinos, hämtat från denna sida:

• Total maxström per ingång/utgångsstift: 40mA
• Summa strömmar av alla ingångs-/utgångspinnar kombinerade: 200mA

Mina ljus drar 19 mA vardera, när de drivs av 3 V. Det finns sju av dem, vilket gör 133 mA. Så jag kunde driva dem direkt från utgångsstiften. Jag har dock några extra darlington -transistor -IC: er. Så jag tänkte, varför inte. Min krets gör saken på rätt sätt: datapinnar är endast för signaler, inte för ström. Istället använder jag 5 V -stiftet på Arduino för att driva LED -lamporna. När jag kör testet har jag min bärbara dator ansluten till Arduino. Allt drivs från den bärbara USB -enheten, vilket ger 5 V. Arduino Mega har en egen säkring som blåser på 500 mA för att skydda datorn. Mina ljus drar som mest 133 mA. Arduino förmodligen mycket mindre. Allt går bra, när det drivs av den bärbara datorn, så att använda ett 5 V -batteri som är anslutet till USB -porten på Arduino är helt ok.

Datastiften D3 - D9 går till IC ULN2803APGCN. Lysdioderna fungerar på 3 V. Varje lampa är ansluten till 5 V -källan och vidare till ett 120 Ω motstånd. Vidare till en kanal av IC, som slutligen förbinder kretsen till marken genom en darlington -transistor i IC.

En tryckknapp läggs till i kretsen för att möjliggöra viss användaråtgärd. Ljusbron kan således ha några program som kan väljas av användaren.

Tryckknappen i kretsen är ansluten till RESET och GND. Detta är exakt vad den inbyggda återställningsknappen gör. Eftersom jag inte inkapslar allt i ett plastfodral använder jag återställningsknappen på Arduino för att styra programmet. Att lägga till en knapp enligt bilden kommer att fungera exakt som knappen för återställning av kortet. Programmet fungerar genom att komma ihåg vilket ljusprogram som användes senast programmet kördes. Varje återställning går alltså vidare till nästa ljusprogram.

Bilderna visar hur de nya kablarna kommer ut ur bron, hur jag lade transistorn IC och motstånden på brödbrädet och hur bygelkablarna ansluter till Arduino Mega. Jag skar upp 4 manliga-manliga bygeltrådar i 8 halvtrådar, som jag lodde till de 8 kablarna som kom ut ur ljusbron. På så sätt kan jag bara fästa kablarna i brödbrädan.

Alternativ utan transistorer

I föregående steg förberedde jag en vanlig "+" tråd för ljusen och separata "-" trådar, som går genom transistorn IC till marken. När en datastift går högt, jordas motsvarande '-' tråd genom dess transistor och LED-lamporna lyser.

Att ansluta '-' trådarna direkt till datastiften på Arduino skulle också fungera, men tänk alltid på hur mycket ström datastiften kan tåla! Detta tillvägagångssätt skulle behöva ändras i mitt program. Det skulle behöva datapinnarna gå för lågt för att tända ljusen. För att använda mitt program som det är måste du växla '+' och '-' i ljusen. Ha en gemensam '-' tråd för ljusen, som går till GND på Arduino. Och de separata trådarna går mellan "+" -tråden på ljuset och en datapinne på Arduino.

Steg 4: Ljusprogrammen

Mitt program, som jag presenterar i nästa steg, går igenom 9 ljusprogram. Genom att trycka på knappen slocknar lamporna en sekund och sedan startar följande ljusprogram. Programmen är följande:

1. Starkt flimmer. Ljusen flimrar slumpmässigt. Det här ser väldigt irriterande ut när du stirrar på dem på nära håll, men kan se bra ut på avstånd och kanske bakom ett frostigt vindfönster. Men din granne kan ringa brandkåren.
2. Mjukt flimrande. Ser väldigt bra ut. Som riktiga ljus i ett rum utan drag.
3. Varierande flimmer. Ljusen växlar smidigt mellan starka och mjuka flimrande i cirka 30 sek intervall.
4. Varierande flimmer. Som #3, men varje ljus varierar i sin egen takt mellan 30 s och 60 s.
5. Snabb glimt. Ljusen lyser på en statisk nedtonad nivå och glimtar slumpmässigt. I genomsnitt är det en glimt varje sekund.
6. Långsam glimt. Som #5, men i mycket långsammare takt.
7. Snabb våg från mitten översta ljuset till de nedre.
8. Långsam våg från mittljuset till de nedre.
9. Statiskt starkt ljus. Jag var tvungen att inkludera detta, ville inte bli av med den ursprungliga funktionen.

Steg 5: Koden

/*

FLICKERING CANDLE BRIDGE */ // Deklarera lägesvariabeln för att hålla tillståndet // genom en återställning _attribut _ ((avsnitt (". Noinit"))) osignerat int -läge; // När programmet startar efter en återställning, initieras inte detta minne //, utan det innehåller värdet // som det hade före återställningen. Första gången // programmet körs har det ett slumpmässigt värde. / * * Ljusklassen rymmer allt som behövs * för att beräkna en ljusnivå för * ett flimrande ljus. */ klassljus {privat: lång maxtime; lång tid; lång maxlit; lång minlit; lång medelbit; lång origmaxtime; lång ursprungstid; lång origmaxlit; lång origminlit; lång origmeanlite; lång deltamaxtime; lång deltamintime; lång deltamaxlit; lång deltaminlit; lång deltameanlit; lång lforat; lång jämnhet; lång start; långt mål; floatfaktor; lång måltid; lång starttid; lång deltatid; void newtarget (void); lång onetarget (tomrum); offentligt: ljus (lång matta, lång mit, lång mal, lång mil, lång mel, lång eo); long levelnow (void); void initlfo (lång deltamat, lång deltamit, lång deltamal, lång deltamil, lång deltamean, lång hastighet); void setlfo (void); }; ljus:: ljus (lång matta, lång mit, lång mal, lång mil, lång mel, lång 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 () returnerar ljusnivån som ljuset ska ha just nu. * Funktionen tar hand om att definiera en ny slumpmässig ljusnivå och * den tid det bör ta för att nå den nivån. Förändringen är inte linjär, * men följer en sigmoidkurva. När det inte är dags att definiera en ny * nivå, returnerar funktionen helt enkelt ljusnivån. */ långt ljus:: levelnow (void) {lång hjälp, nu; flyta t1, t2; nu = millis (); if (nu> = måltid) {help = target; newtarget (); återvändandehjälp; } annat {// hjälp = mål * (millis () - starttid) / deltatime + start * (måltid - millis ()) / deltatime; t1 = float (måltid - nu) / deltatime; t2 = 1. - t1; // Detta är sigmoidberäkningshjälpen = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*mål*3 + t2*t2*t2*mål; återvändandehjälp; }} void candle:: newtarget (void) {lång summa; summa = 0; för (lång i = 0; i <evenout; i ++) summa+= onetarget (); start = mål; target = summa / jämnhet; starttid = millis (); måltid = starttid + slumpmässig (mintid, maxtid); deltatime = måltid - starttid; } långt ljus:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = nu; / * * Algon för blinkande "efter takt millisekunder": * Börja kontrollera efter hastighet / 2 millisekunder * Under en period av takt / 2 millisekunder, gör * chansen att en glimt blir 50 %. * Om hastigheten är 10000 ms, vänds myntet under 5000 ms 50 gånger. * 1/50 = 0,02 * Om slumpmässig (10000) starttid + hastighet / 2) {if (slumpmässig (hastighet) måltid) returnerar lowlite; retur (start - lowlite) * (måltid - nu) / (måltid - starttid) + lowlite; } void twinkler:: twink (void) {starttime = millis (); måltid = slumpmässig (mintid, maxtid) + starttid; start = random (minlite, maxlite); } void setup () {int led; // Läs variabeln i magiskt läge, som ska berätta // vilket ljusprogram som kördes förra gången, öka det // och återställ till noll om det flödar över. läge ++; läge %= 9; // Detta tar hand om vilket värde // som var allra första gången Arduino // körde det här programmet. / * * VIKTIG OBS * =============== * * Det viktiga detta program gör är att mata ut PWM * -signaler till LED -lampor. Här ställer jag in stiften 3 till 9 till * utgångsläge. På en Arduino Mega2560 matar dessa stift ut * fint PWM -signaler. Om du har en annan Arduino, kolla * vilka stift (och hur många) du kan använda. Du kan alltid * skriva om koden för att använda programvara PWM, om din Arduino * inte kan tillhandahålla tillräckligt med hårdvara PWM -stift. * */ pinMode (3, OUTPUT); pinMode (4, OUTPUT); pinMode (5, OUTPUT); pinMode (6, OUTPUT); pinMode (7, OUTPUT); pinMode (8, OUTPUT); pinMode (9, OUTPUT); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // Stäng bara av den irriterande röda lysdioden på Arduino -ljuset *burk [7]; // förbered dig på att använda de flimrande ljusen, oavsett om du använder dem eller inte blinkar *twink [7]; // förbered dig på att använda de blinkande ljusen … if (mode == 8) {för (int i = 3; i <10; i ++) analogWrite (i, 255); medan (sant); // Varje gång detta program körs går det in i // denna typ av oändlig slinga, tills reset // -knappen trycks in. } if (läge <2) // flimrande {long maxtime_; lång tid_; lång maxlite_; lång minlite_; lång meanlite_; lång jämn_; if (mode == 0) {maxtime_ = 250; mintid_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; jämn_ = 1; } if (mode == 1) {maxtime_ = 400; mintid_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; jämn_ = 1; } för (int i = 0; i <7; i ++) {kan = nytt ljus (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } medan (true) // Den oändliga slingan för flimrande ljus {för (int i = 0; i levelnow ()); }} om (läge <4) // lfo läggs till flimmer {if (mode == 2) // samma lfo (30 s) för alla ljus {för (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // varierande lfo: s för ljusen {för (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); kan [1]-> initlfo (75, 50, 0, 50, 36, 25000); kan [2]-> initlfo (75, 50, 0, 50, 36, 30000); kan [3]-> initlfo (75, 50, 0, 50, 36, 35000); kan [4]-> initlfo (75, 40, 0, 50, 36, 40000); kan [5]-> initlfo (75, 30, 0, 50, 26, 45000); kan [6]-> initlfo (75, 20, 0, 50, 16, 50000); kan [7]-> initlfo (75, 10, 0, 50, 6, 55000);} medan (true) // Den oändliga slingan för flimrande ljus med en 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) // blinkande ljus {int speedo; if (mode == 4) speedo = 6000; annars speedo = 22000; för (int i = 0; i <7; i ++) twink = ny twinkler (300, 295, 255, 250, speedo); medan (true) {för (int i = 0; i levelnow ())); }} // Vågor. // Det här avsnittet börjar med lockiga parenteser bara // för att säkerställa att det inte finns några motstridiga variabelnamn. // Inget annat behov av parenteser, inget behov av att kontrollera // värdet på läge.{int lolite = 2; int hilite = 255; int betyder; int ampl; float fasedelta = 2,5; flyta fas; int förlängd; floatfaktor; lång period; medelvärde = (lolite + hilite) / 2; ampl = hilite - medelvärde; om (mode == 6) period = 1500; annan period = 3500; faktor = 6,28318530718 / period; medan (true) {fas = faktor * (millis () % period); elong = medelvärde + ampl * sin (fas); analogWrite (7, långsträckt); analogWrite (9, långsträckt); fas = faktor * ((millis () + period / 4) % period); elong = medelvärde + ampl * sin (fas); analogWrite (3, långsträckt); analogWrite (8, långsträckt); fas = faktor * ((millis () + period / 2) % period); elong = medelvärde + ampl * sin (fas); analogWrite (4, långsträckt); analogWrite (5, långsträckt); fas = faktor * ((millis () + 3 * period / 4) % period); elong = medelvärde + ampl * sin (fas); analogWrite (6, långsträckt); } // När jag kopplade ljuskablarna till Arduino, // jag blandade dem och fick dem aldrig i ordning. // Ordningen är viktig för att skapa vågmönster, // så jag skrev precis det här lilla bordet för mig: // // Ljus# i bron: 2 3 5 4 7 6 1 // Datastift på Arduino: 3 4 5 6 7 8 9}} void loop () {// Eftersom varje ljusprogram är en egen oändlig loop, // skrev jag alla loopar i avsnittet begin () // och lämnade ingenting för detta loop () -avsnitt. }

Steg 6: Om PWM

Lysdioderna lyser starkt när de drivs med 3 V. Med endast 1,5 V lyser de inte alls. LED -lampor bleknar inte snyggt med blekningsspänningen, som glödlampor gör. Istället måste de slås på med full spänning och sedan stängas av. När detta händer 50 gånger per sekund lyser de fint med 50 % ljusstyrka, mer eller mindre. Om de får vara på endast 5 ms och av 15 ms kan de lysa med 25 % ljusstyrka. Denna teknik är det som gör LED -ljuset dimbart. Denna teknik kallas pulsbreddsmodulation eller PWM. En mikrokontroller som Arduino har vanligtvis datapinnar som kan skicka på/av -signaler. Några av datastiften har inbyggda funktioner för PWM. Men om det inte finns tillräckligt med stift med inbyggt PWM är det vanligtvis möjligt att använda dedikerade programmeringsbibliotek för att skapa "programvara PWM -stift".

I mitt projekt har jag använt en Arduino Mega2560, som har hårdvara PWM på stift 3 - 9. Om du använder en Arduino UNO har du bara sex PWM -stift. I så fall, om du behöver ett sjunde (eller ännu mer) ljus, kan jag rekommendera Brett Hagmans programvara PWM -bibliotek, som du hittar här.