Flikkerende Candle Bridge - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Deze instructable laat zien hoe je een eenvoudige kaarsenbrug met statisch licht kunt veranderen in een mooi gloeiend sfeerlicht met eindeloze variaties van flikkerende lichten, fonkeling, golfpatronen en wat dan ook. Ik kocht bij After Christmas Sales een kaarsenbrug voor 8 €. Het heeft 7 led-lampjes en een muuradapter van 33 V 3 W. Het schijnt met een heldere en warme witte kleur en zal perfect zijn voor dit project, waar ik een Arduino zal plaatsen om de kaarsen te laten flikkeren. De meest populaire Arduino is de Arduino Uno. In dit project gebruik ik een Arduino Mega 2560.

Ik ga de 30 V-voeding weggooien en een eenvoudige 5 V-powerbank gebruiken die bedoeld is voor mobiele telefoons als voeding.

Een goed ding om te weten over powerbanks is dat ze een intern circuit hebben, dat de batterij van 3,7 V naar 5 V transformeert. Omdat het proces wat stroom verbruikt, schakelt de powerbank zichzelf uit als deze niet wordt gebruikt. Als de powerbank wordt gebruikt voor op Arduino gebaseerde doe-het-zelf-gadgets, kan de gadget zichzelf niet zomaar in de energiebesparende slaapstand zetten en na een paar minuten opnieuw beginnen. Dat zal de powerbank uitschakelen. Deze flikkerende kaarsenbrug heeft geen slaapstand. Het gebruikt constant stroom, waardoor de powerbank actief blijft, totdat het netsnoer wordt losgetrokken.

De video toont de kaarsenbrug in statische modus en in volle flikkering. Het volle flikkeren is echt heel vervelend voor de ogen, terwijl de video het wat afvlakt. Nadat de hardware is gerepareerd, inclusief het knippen van kabels, het solderen van nieuwe verbindingen en het toevoegen van enkele componenten, worden alle gewenste lichtpatronen gecreëerd door code voor de Arduino te schrijven. De patronen die ik in dit instructable opnemen zijn:

• 4 verschillende flikkerende lichten die echte kaarsen imiteren
• 2 verschillende fonkelingen (willekeurig knipperen van anders statische lichten)
• 2 verschillende golfpatronen
• eenvoudig statisch licht

Het wisselen van patronen gebeurt via een drukknop, het enkele gebruikersinterface-element. Hoe meer patronen je wilt en hoe meer aanpasbaarheid je wilt, hoe meer knoppen en knoppen je moet toevoegen. Maar de schoonheid ligt in de eenvoud. Houd het aantal selecteerbare patronen laag. Kies de beste instellingen tijdens het coderen en testen, niet door veel bedieningselementen aan de hardware toe te voegen.

Benodigdheden

• 1 LED kaarsenbrug met 7 lampjes. Zorg ervoor dat het een DC-model met laag voltage is, met batterijen of met een stroombron voor wandmontage, die de dodelijke 110 - 240 V AC omzet in ongeveer 6 - 30 V DC. Het is dus volkomen veilig om de kaarsenbrug te hacken.
• 1 Arduino Mega (elke andere microcontroller is voldoende, zorg er wel voor dat je hem kunt programmeren)
• 1 prototype breadboard
• jumperdraden en andere draad:
• soldeergereedschap
• multimeter
• 7 weerstanden, 120
• 1 drukknop (ik zal laten zien hoe je in plaats daarvan de ingebouwde knop op een Arduino kunt gebruiken)
• Een darlington-transistor-IC voor 7 transistors, ULN2803AP is voldoende (als je een Arduino Uno of Meaga gebruikt, heb je dit niet echt nodig)
• Een 5 V powerbank bedoeld voor mobiele telefoons

Stap 1: Onderzoek wat je hebt

Ontdek op welke spanning elke LED werkt en hoeveel stroom er doorheen gaat.

1. Open de onderkant van de kaarsenbrug. Zoek de twee draden die naar één kaars gaan.
2. Strip wat isolatie van de kabels zodat de koperdraden zichtbaar worden zonder de koperdraden door te knippen.
3. Doe de lichten aan (ontspan, het is maar een paar volt) en meet de spanning over de blootliggende koperdraden.
4. Knip de kabel bij een van de meetpunten door (op dit punt gaan de lampjes natuurlijk uit), verwijder aan beide uiteinden wat isolatie (3 - 4 mm). Meet de stroom die erdoor gaat. Wat u doet, is de doorgesneden kabel opnieuw verbinden met uw multimeter, zodat alle stroom door uw multimeter gaat, die u nu de hoeveelheid stroom vertelt.

Mijn lezingen

De spanning over één kaars (stap 3): 3,1 V

Merk op dat de stroombron naar de kaarsenbrug 33 V was. Dus zeven keer 3,1 V is slechts 21,7 V. Op sommige kaarsen moet een extra weerstand zitten. Had ik die kaarsspanning gemeten, dan moet het zo'n 11 V zijn geweest.

De stroom die doorloopt bij kaarslicht (stap 4): 19 mA

Ik ga alles van stroom voorzien met een 5 V 2 A batterijpakket. Voor de kaarsen moet ik de spanning verlagen van 5 V naar 3 V. Ik heb een weerstand nodig, die de spanning met 2 V verlaagt bij een stroom van 19 mA.

2 V / 0,019 A = 105

Het dissiperende vermogen is:

2 V * 19 mA = 38 mW

Dat is te verwaarlozen. Veel meer zou de weerstand zelf kunnen opblazen. Maar zonder een weerstand van 105 zou ik de LED kunnen opblazen. Ik heb weerstanden van 100 en 120 Ω. Ik ga met 120 Ω. Het geeft meer bescherming.

Het testen van alle 7 kaarsen met 3 V gaf een helder licht, behalve één kaars, die slechts een zeer zwak licht had, met slechts ongeveer 0,8 mA door. Dit was mijn kaars met de extra weerstand. Het bleek dat de andere kaarsen helemaal geen weerstanden hadden. De LED-lampjes die in de kroonluchter worden gebruikt, zijn gewoon bedoeld voor 3 V! De kaars met de extra weerstand moest met zacht geweld worden geopend, maar er ging niets kapot. De weerstand werd gevonden net onder de kleine LED in de plastic kaarslamp. Ik moest het desolderen en de draden opnieuw solderen. Het was een beetje rommelig, omdat de soldeerbout wat hete lijm opwarmde, die voor de montage was gebruikt.

Dus nu weet ik dat welke stroombron ik ook gebruik, wat de spanning ook is, ik de spanning moet verlagen tot 3 V, zodat 19 mA kan doorgaan.

Als ik meer bekend was geweest met LED-technologie, had ik het type LED herkend dat werd gebruikt en had ik geweten dat het 3 V nodig had.

Stap 2: wat solderen

In deze stap sluit ik alle positieve (+) draden van de 5 kaarsen aan op één draad. Dan voeg ik voor elke kaars een aparte negatieve (-) draad toe. Een LED-lampje gaat alleen branden als de '+' en '-' naar rechts gaan. Aangezien je van elke kaars maar twee identieke kabeluiteinden hebt, moet je testen welke '+' is en welke '-'. Hiervoor heb je een 3 V stroombron nodig. Ik had een klein batterijpakket met twee AAA-batterijen. Een knoopbatterij van 3 V werkt ook uitstekend om te testen.

De kaarsbrug heeft 8 kabels nodig om tussen de Arduino en de brug te lopen. Als je een kabel vindt met 8 geïsoleerde draden, zou dat geweldig zijn. Eén draad moet 120 mA bevatten, de rest mag maximaal 20 mA dragen. Ik koos ervoor om 4-draads kabel te gebruiken, die ik toevallig had.

De eerste afbeelding laat zien hoe ik één gemeenschappelijke draad heb voorbereid om alle '+' draden van de kaarsen te verbinden. Strip wat isolatie van de gemeenschappelijke draad voor elke kaars. Voeg voor elke verbinding een stuk krimpkous toe (de gele strook in de afbeelding) en plaats deze op de juiste plek van de gemeenschappelijke kabel. Soldeer de '+' draad van elke kaars aan zijn gewricht, bedek het gewricht met de krimpkous en krimp het. Simpel plakband is natuurlijk ook prima, uiteindelijk is alles bedekt.

De tweede afbeelding toont de '-' draden die elke kaars nodig heeft. De gemeenschappelijke '+'-draad gaat rechtstreeks naar de 5 V-pin van de Arduino (of misschien via het breadboard). Elke '-'-draad gaat naar zijn eigen pin van het transistor-IC (opnieuw, waarschijnlijk via het breadboard).

Een Arduino wordt vaak een prototyping board genoemd. Een breadboard gebruik je ook in prototypes. Wat ik beschrijf in dit instructable is een prototype. Ik zal het niet uitwerken tot een chique glanzend product met alles verborgen in mooie plastic hoesjes. Om het van het prototype naar het volgende niveau te brengen, zou betekenen dat het breadboard moet worden vervangen door een printplaat en gesoldeerde componenten en zelfs de Arduino moet vervangen door slechts een eenvoudige microcontroller-chip (eigenlijk is zo'n chip het brein van de Arduino). En alles past in een plastic koffer of in de gehackte kaarsenbrug.

Stap 3: De verbindingen

Over Arduino's, overgenomen van deze pagina:

• Totale maximale stroom per ingangs-/uitgangspen: 40mA
• Som van de stromen van alle input/output-pinnen gecombineerd: 200mA

Mijn kaarsen trekken elk 19 mA, wanneer ze worden gevoed door 3 V. Er zijn er zeven, wat neerkomt op 133 mA. Dus ik kon ze rechtstreeks van de uitgangspinnen voeden. Ik heb echter wat reserve darlington-transistor-IC's. Dus ik dacht, waarom niet. Mijn circuit doet het op de juiste manier: datapinnen zijn alleen voor signalen, niet voor stroom. In plaats daarvan gebruik ik de 5 V-pin op de Arduino voor het aandrijven van de LED-verlichting. Tijdens het testen heb ik mijn laptop aangesloten op de Arduino. Alles wordt gevoed via de USB van de laptop, die 5 V geeft. De Arduino Mega heeft een eigen zekering, die doorbrandt op 500 mA om de computer te beschermen. Mijn kaarsen trekken maximaal 133 mA. De Arduino waarschijnlijk veel minder. Alles werkt prima, wanneer het wordt gevoed door de laptop, dus het gebruik van een 5 V-batterijpakket dat is aangesloten op de USB-poort van de Arduino is prima.

De datapinnen D3 - D9 gaan naar de IC ULN2803APGCN. De LED's werken op 3 V. Elke lamp is aangesloten op de 5 V-bron en verder op een 120 Ω-weerstand. Verder naar één kanaal van het IC, dat uiteindelijk de schakeling met de aarde verbindt via een darlington-transistor in het IC.

Er is een drukknop aan het circuit toegevoegd om enige actie van de gebruiker mogelijk te maken. De kaarsenbrug zou dus een paar door de gebruiker selecteerbare programma's kunnen hebben.

De drukknop in het circuit is verbonden met RESET en GND. Dit is precies wat de ingebouwde resetknop doet. Omdat ik niet alles in een plastic behuizing stop, gebruik ik de resetknop op de Arduino om het programma te besturen. Het toevoegen van een knop volgens de afbeelding werkt precies zoals de knop voor het resetten van het bord. Het programma werkt door te onthouden welk lichtprogramma de laatste keer is gebruikt dat het programma werd uitgevoerd. Elke reset gaat dus door naar het volgende lichtprogramma.

De foto's laten zien hoe de nieuwe kabels uit de brug komen, hoe ik het transistor IC en de weerstanden op het breadboard heb gelegd en hoe de jumperdraden aansluiten op de Arduino Mega. Ik sneed 4 mannelijke-mannelijke jumperdraden in 8 halve draden, die ik gesoldeerd heb aan de 8 kabels die uit de kaarsenbrug kwamen. Op deze manier kan ik de kabels gewoon in het breadboard steken.

Alternatief zonder transistors

In de vorige stap heb ik een gemeenschappelijke '+'-draad voor de kaarsen voorbereid en afzonderlijke '-'-draden, die door het transistor-IC naar de grond gaan. Wanneer een datapin hoog wordt, wordt de corresponderende '-'-draad geaard via de transistor en de LED-lampjes.

Het rechtstreeks aansluiten van de '-'-draden op de datapinnen van de Arduino zou ook werken, maar let altijd op hoeveel stroom de datapinnen kunnen verdragen! Deze aanpak zou een verandering in mijn programma nodig hebben. Het zou de datapinnen nodig hebben om laag te worden om de kaarsen aan te zetten. Om mijn programma te gebruiken zoals het is, moet je '+' en '-' in de kaarsen verwisselen. Heb een gemeenschappelijke '-'-draad voor de kaarsen, die naar GND op de Arduino gaat. En de aparte draden lopen tussen de '+' draad van de kaars en een datapin van de Arduino.

Stap 4: De lichtprogramma's

Mijn programma, dat ik in de volgende stap presenteer, doorloopt 9 lichtprogramma's. Door op de knop te drukken doven de lichten een seconde, daarna start het volgende lichtprogramma. De programma's zijn als volgt:

1. Sterk flikkerend. De kaarsen flikkeren willekeurig. Dit ziet er erg vervelend uit als je ze van dichtbij bekijkt, maar ziet er misschien goed uit van een afstand en misschien achter een ijzig zolderraam. Maar je buurman kan de brandweer bellen.
2. Zacht flikkerend. Ziet er heel goed uit. Als echte kaarsen in een kamer zonder tocht.
3. Afwisselend flikkeren. De kaarsen wisselen vloeiend af tussen sterk en zacht flikkerend in intervallen van ongeveer 30 s.
4. Afwisselend flikkeren. Zoals #3, maar elke kaars varieert in zijn eigen tempo tussen 30 s en 60 s.
5. Snelle twinkeling. De kaarsen schijnen op een statisch gedimd niveau en fonkelen willekeurig. Gemiddeld is er één twinkeling per seconde.
6. Langzame twinkeling. Zoals #5, maar in een veel langzamer tempo.
7. Snelle golf van middelste bovenste kaars naar de onderste.
8. Langzame golf van middelste bovenste kaars naar de onderste.
9. Statisch helder licht. Ik moest dit opnemen, wilde niet van de originele functie af.

Stap 5: De code

/*

FLICKERING CANDLE BRIDGE */ // Declareer de modusvariabele om de status // vast te houden door een resetbewerking _attribute_((section(".noinit"))) unsigned int mode; // Wanneer het programma start na een reset, wordt dit stuk // geheugen niet geïnitialiseerd, maar behoudt het de waarde // die het had voor de reset. De allereerste keer dat het //-programma wordt uitgevoerd, heeft het een willekeurige waarde. /* * De kaarsenklasse bevat alles wat nodig is * voor het berekenen van een lichtniveau voor * een flikkerende kaars. */ klasse kaars { privé: lange maxtime; lange minuten; lange maxliet; lange miniliet; lange gemiddelde; lange originele maxtijd; lange oorsprongstijd; lange origmaxliet; lang origminliet; lang origmeanliet; lange deltamaxtijd; lange deltamintijd; lange deltamaxliet; lange deltaminliet; lange deltameanliet; lang blad; lange avond; lange start; lang doelwit; drijvende factor; lange richttijd; lange starttijd; lange deltatijd; ongeldig nieuw doel (ongeldig); lange ééntarget (leeg); publiek: kaars (long mat, long mit, long mal, long mil, long mel, long eo); lang levelnow (leegte); void initlfo (lange deltamat, lange deltamit, lange deltamal, lange deltamil, lange deltamean, lange snelheid); ongeldige setlfo (leegte); }; kaars::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; nieuw doel(); } /* * levelnow() geeft het lichtniveau terug dat de kaars nu zou moeten hebben. * De functie zorgt voor het definiëren van een nieuw willekeurig lichtniveau en * de tijd die nodig is om dat niveau te bereiken. De verandering is niet lineair, * maar volgt een sigmoïde curve. Wanneer het geen tijd is om een nieuw * niveau te definiëren, retourneert de functie eenvoudig het lichtniveau. */ lange kaars::levelnow(void) { lange hulp, nu; vlotter t1, t2; nu = millis(); if (nu >= targettime) { help = target; nieuw doel(); terug hulp; } else { //help = target * (millis() - starttime) / deltatime + start * (targettime - millis()) / deltatime; t1 = float (targettime - nu) / deltatime; t2 = 1. - t1; // Dit is de sigmoid-berekeningshulp = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; terug hulp; } } void candle::newtarget(void) { long sum; som = 0; for (long i = 0; i < evenout; i++) sum += onetarget(); begin = doel; doel = som / gelijkmatigheid; starttijd = millis(); targettime = starttijd + willekeurig (mintime, maxtime); deltatime = streeftijd - starttijd; } lange kaars::onetarget(void) { if (random(0, 10) lastcheck + 100) { lastcheck = nu; /* * De algo voor fonkeling "na snelheid milliseconden": * Begin met controleren na snelheid / 2 milliseconden * Maak tijdens een periode van snelheid / 2 milliseconden * de kans op een twinkeling op 50%. * Als de snelheid 10000 ms is, wordt de munt gedurende 5000 ms * 50 keer omgedraaid. * 1/50 = 0,02 * Als willekeurig (10000) starttijd + snelheid / 2) { als (willekeurige (snelheid) doeltijd) lowlite retourneert; return (start - lowlite) * (targettime - nu) / (targettime - starttime) + lowlite; } void twinkler::twink(void) { starttime = millis(); targettime = willekeurig (mintime, maxtime) + starttijd; start = willekeurig (minlite, maxlite); } void setup() { int led; // Lees de magische modusvariabele, die moet vertellen // welk lichtprogramma de laatste keer is uitgevoerd, verhoog het // en reset naar nul als het overloopt. modus++; modus %= 9; // Dit zorgt voor wat de waarde ook is // was de allereerste keer dat de Arduino // dit programma uitvoerde. /* * BELANGRIJKE OPMERKING * ============== * * Het belangrijkste dat dit programma doet, is het uitvoeren van PWM *-signalen naar LED-verlichting. Hier stel ik de pinnen 3 tot 9 in op * uitvoermodus. Op een Arduino Mega2560 geven deze pinnen * mooie PWM-signalen af. Als je een andere Arduino hebt, controleer dan * welke pinnen (en hoeveel) je kunt gebruiken. U kunt altijd * de code herschrijven om software PWM te gebruiken, als uw Arduino * niet genoeg hardware PWM-pinnen kan leveren. * */ pinMode (3, UITGANG); pinMode (4, UITGANG); pinMode (5, UITGANG); pinMode (6, UITGANG); pinMode (7, UITGANG); pinMode (8, UITGANG); pinMode(9, UITGANG); pinMode (LED_BUILTIN, UITGANG); analogWrite(LED_BUILTIN, 0); // Zet gewoon de irritante rode led op de Arduino-kaars *can[7] uit; // bereid je voor op het gebruik van de flikkerende kaarsen, of je ze nu gebruikt of niet twinkler *twink[7]; // bereid je voor om de fonkelende kaarsen te gebruiken … if (mode == 8) { for (int i = 3; i < 10; i++) analogWrite (i, 255); terwijl (waar); // Elke keer dat dit programma wordt uitgevoerd, gaat het in // dit soort eindeloze lus, totdat de reset //-knop wordt ingedrukt. } if (mode < 2) // flikkeren { lange maxtime_; lange minimale tijd_; lange maxlite_; lange minilite_; lange gemiddelde_; lang even_; if (modus == 0) { maxtime_ = 250; mintijd_ = 50; maxlite_ = 256; minilite_ = 0; meanlite_ = 128; even_ = 1; } if (modus == 1) { maxtime_ = 400; mintijd_ = 150; maxlite_ = 256; minilite_ = 100; meanlite_ = 200; even_ = 1; } for (int i = 0; i < 7; i++) { can = nieuwe kaars (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // De eindeloze lus voor flikkerende kaarsen { for (int i = 0; i levelnow()); } } if (mode < 4) // lfo toegevoegd aan het flikkeren { if (mode == 2) // dezelfde lfo (30 s) voor alle kaarsen { for (int i = 0; i initlfo(75, 50, 0, 50, 36, 30000);} } if (mode == 3) // variërende lfo:s voor de kaarsen { 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) // De eindeloze lus voor flikkerende kaarsen met een 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) // fonkelende kaarsen {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()); } } // Golven. // Deze sectie begint met accolades alleen // om ervoor te zorgen dat er geen conflicterende variabelenamen zijn. // Geen andere noodzaak voor haakjes, geen noodzaak om // de waarde van mode te controleren.{ int lolite = 2; int hiliet = 255; int betekent; int ampl; vlotter fasedelta = 2,5; vlotterfase; int lang; drijvende factor; lange periode; gemiddelde = (loliet + hiliet) / 2; ampl = hiliet - gemiddeld; als (modus == 6) periode = 1500; anders periode = 3500; factor = 6.28318530718/periode; while (true) { fase = phactor * (millis() % periode); elong = gemiddelde + ampl * sin(fase); analogWrite(7, lang); analogWrite(9, elong); fase = phactor * ((millis() + periode / 4) % periode); elong = gemiddelde + ampl * sin(fase); analogWrite(3, lang); analogWrite(8, lang); fase = phactor * ((millis() + periode / 2) % periode); elong = gemiddelde + ampl * sin(fase); analogWrite(4, lang); analogWrite(5, lang); fase = phactor * ((millis() + 3 * periode / 4) % periode); elong = gemiddelde + ampl * sin(fase); analogWrite(6, lang); } // Terwijl ik de kaarsdraden op de Arduino aansloot, // Ik heb ze gemengd en nooit op volgorde gekregen. // De volgorde is belangrijk voor het maken van golfpatronen, // daarom heb ik deze kleine tabel voor mij geschreven: // // Candle# in the bridge: 2 3 5 4 7 6 1 // Datapin op Arduino: 3 4 5 6 7 8 9 } } void loop() { // Aangezien elk light-programma zijn eigen oneindige lus is, // heb ik alle lussen in de begin()-sectie // geschreven en niets overgelaten voor deze loop()-sectie. }

Stap 6: Over PWM

De leds schijnen helder wanneer ze worden gevoed met 3 V. Met slechts 1,5 V lichten ze helemaal niet op. LED-lampen vervagen niet mooi met de vervagende spanning, zoals gloeilampen. In plaats daarvan moeten ze worden ingeschakeld met volledige spanning en vervolgens worden uitgeschakeld. Wanneer dit 50 keer per seconde gebeurt, schitteren ze mooi met een helderheid van 50%, min of meer. Als ze slechts 5 ms aan en 15 ms uit mogen staan, kunnen ze met een helderheid van 25% schijnen. Deze techniek maakt LED-verlichting dimbaar. Deze techniek wordt pulsbreedtemodulatie of PWM genoemd. Een microcontroller zoals Arduino heeft meestal datapinnen, die aan/uit-signalen kunnen verzenden. Sommige datapinnen hebben ingebouwde mogelijkheden voor PWM. Maar als er niet genoeg pinnen zijn met ingebouwde PWM, is het meestal mogelijk om speciale programmeerbibliotheken te gebruiken om "software PWM-pinnen" te maken.

In mijn project heb ik een Arduino Mega2560 gebruikt, die hardware PWM op pinnen 3 - 9 heeft. Als je een Arduino UNO gebruikt, heb je slechts zes PWM-pinnen. In dat geval, als je een 7e (of zelfs meer) kaars nodig hebt, kan ik Brett Hagman's software PWM-bibliotheek aanbevelen, die je hier kunt vinden.