Migoczący most świecy: 6 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:29

Ta instrukcja pokazuje, jak zamienić prosty świecowy most ze statycznym światłem w przyjemne, świecące nastrojowe światło z nieskończonymi wariacjami migoczących świateł, migotania, wzorów fal i tak dalej. Kupiłem z After Christmas Sales mostek świecowy za 8 €. Posiada 7 diod LED i adapter ścienny 33 V 3 W. Świeci jasnym i ciepłym białym kolorem i będzie idealny do tego projektu, w którym umieszczę Arduino, aby świece migotały. Najpopularniejszym Arduino jest Arduino Uno. W tym projekcie będę używał Arduino Mega 2560.

Zrezygnuję z zasilania 30 V i użyję prostego powerbanku 5 V przeznaczonego do telefonów komórkowych jako źródła zasilania.

Dobrą rzeczą, aby wiedzieć o power bankach jest to, że mają wewnętrzny obwód, który przekształca baterię z 3,7 V na 5 V. Ponieważ proces zużywa trochę energii, power bank zamyka się sam, jeśli nie jest używany. Jeśli power bank jest używany do gadżetów DIY opartych na Arduino, gadżet nie może po prostu przejść w tryb oszczędzania energii i uruchomić ponownie po kilku minutach. To wyłączy bank mocy. Ten migoczący most świecowy nie ma trybu uśpienia. Wykorzystuje stale zasilanie, utrzymując aktywny power bank, dopóki kabel zasilający nie zostanie odłączony.

Film pokazuje most świecy w trybie statycznym i w pełnym migotaniu. Pełne migotanie jest naprawdę bardzo denerwujące dla oczu, podczas gdy wideo nieco je wygładza. Po naprawieniu sprzętu, w tym przecięciu kabli, lutowaniu nowych połączeń i dodaniu niektórych komponentów, wszystkie pożądane wzory świetlne są tworzone poprzez napisanie kodu dla Arduino. Wzory, które zawieram w tej instrukcji, to:

• 4 różne migoczące światła imitujące prawdziwe świece
• 2 różne migotanie (losowe miganie innych statycznych świateł)
• 2 różne wzory fal
• proste statyczne światło

Przełączanie wzorców odbywa się za pomocą przycisku, pojedynczego elementu interfejsu użytkownika. Im więcej wzorów i im więcej możliwości regulacji, tym więcej przycisków i pokręteł trzeba dodać. Ale piękno tkwi w prostocie. Zmniejsz liczbę wzorów do wyboru. Wybierz najlepsze ustawienia podczas kodowania i testowania, a nie dodawania wielu elementów sterujących do sprzętu.

Kieszonkowe dzieci

• 1 mostek świecowy LED z 7 żarówkami. Upewnij się, że jest to model zasilany prądem stałym o niskim napięciu, z bateriami lub ze źródłem zasilania naściennym, które przekształca śmiertelne napięcie 110-240 V AC na około 6-30 V DC. Więc zhakowanie mostu świec jest całkowicie bezpieczne.
• 1 Arduino Mega (zrobi każdy inny mikrokontroler, tylko upewnij się, że możesz go zaprogramować)
• 1 prototypowa płytka prototypowa
• przewody połączeniowe i inne przewody
• narzędzie do lutowania
• multimetr
• 7 rezystorów, 120 Ω
• 1 przycisk (pokażę, jak można użyć wbudowanego przycisku na Arduino)
• Układ scalony tranzystora darlington dla 7 tranzystorów, ULN2803AP zrobi (jeśli używasz Arduino Uno lub Meaga, naprawdę tego nie potrzebujesz)
• Power bank 5 V przeznaczony do telefonów komórkowych

Krok 1: Sprawdź, co masz

Dowiedz się, na jakim napięciu działa każda dioda LED i ile prądu przepływa.

1. Otwórz spód mostu świecy. Znajdź dwa przewody prowadzące do jednej świecy.
2. Zdejmij część izolacji z kabli, odsłaniając przewody miedziane bez przecinania przewodów miedzianych.
3. Włącz światła (odpręż się, to tylko kilka woltów) i zmierz napięcie na odsłoniętych miedzianych przewodach.
4. Przetnij kabel w jednym z punktów pomiarowych (w tym miejscu oczywiście zgaśnie światło), zdejmij izolację (3 - 4 mm) na obu końcach. Zmierz przepływ prądu. To, co robisz, to ponowne podłączenie odciętego kabla do multimetru, pozwalając, aby cały prąd przepływał przez multimetr, który teraz informuje o ilości prądu.

Moje odczyty

Napięcie na jednej świecy (krok 3): 3,1 V

Zauważ, że źródło zasilania mostka świecowego wynosiło 33 V. Czyli siedem razy 3,1 V to tylko 21,7 V. Na niektórych świecach musi być dodatkowy rezystor. Gdybym zmierzył to napięcie świecy, musiało to być jakieś 11 V.

Prąd płynący podczas świecenia świecy (krok 4): 19 mA

Zasilam wszystko akumulatorem 5 V 2 A. Dla świec muszę obniżyć napięcie z 5 V do 3 V. Potrzebuję rezystora, który przy prądzie 19 mA obniży napięcie o 2 V.

2 V / 0,019 A = 105 Ω

Moc rozpraszana to:

2 V * 19 mA = 38 mW

To nieistotne. Dużo więcej może wysadzić sam rezystor. Jednak bez rezystora 105 Ω mógłbym przepalić diodę. Mam rezystory 100 Ω i 120 Ω. Idę z 120 Ω. Daje większą ochronę.

Testowanie wszystkich 7 świec z napięciem 3 V dało jasne światło, z wyjątkiem jednej świecy, która miała bardzo słabe światło, z przepływem tylko 0,8 mA. To była moja świeca z dodatkowym rezystorem. Okazało się, że pozostałe świece w ogóle nie miały rezystorów. Światła LED zastosowane w żyrandolu są po prostu przeznaczone na 3 V! Świeca z dodatkowym rezystorem musiała zostać otwarta z niewielką siłą, ale nic się nie zepsuło. Rezystor został znaleziony tuż pod maleńką diodą LED wewnątrz plastikowej żarówki świecy. Musiałem go wylutować i przelutować przewody. Było trochę bałaganu, ponieważ lutownica rozgrzała trochę gorącego kleju, który został użyty do montażu.

Więc teraz wiem, że bez względu na to, jakie źródło zasilania używam, bez względu na napięcie, muszę obniżyć napięcie do 3 V, pozwalając na przejście 19 mA.

Gdybym był bardziej zaznajomiony z technologią LED, rozpoznałbym rodzaj zastosowanej diody LED i wiedziałbym, że potrzebuje 3 V.

Krok 2: Trochę lutowania

W tym kroku podłączam wszystkie przewody dodatnie (+) od 5 świec do jednego przewodu. Następnie dodaję oddzielny przewód ujemny (-) dla każdej świecy. Dioda LED zapala się tylko wtedy, gdy „+” i „-” idą w prawo. Ponieważ masz tylko dwie identyczne końcówki kabla z każdej świecy, musisz sprawdzić, która z nich to '+', a która '-'. Do tego potrzebne jest źródło zasilania 3 V. Miałem mały pakiet baterii zawierający dwie baterie AAA. Bateria pastylkowa 3 V świetnie sprawdza się również w testach.

Mostek świecy potrzebuje 8 kabli do uruchomienia między Arduino a mostkiem. Jeśli znajdziesz kabel z 8 izolowanymi przewodami, byłoby świetnie. Jeden przewód musi mieć prąd 120 mA, pozostałe maksymalnie tylko 20 mA. Zdecydowałem się na użycie 4-żyłowego kabla dwużyłowego, który akurat miałem.

Pierwsze zdjęcie pokazuje jak przygotowałem jeden wspólny przewód do podłączenia wszystkich przewodów '+' od świec. Zdejmij część izolacji ze wspólnego przewodu dla każdej świecy. Dodaj kawałek termokurczliwej rurki izolacyjnej (żółty pasek na obrazku) dla każdego złącza i umieść go we właściwym miejscu wspólnego kabla. Przylutuj przewód „+” od każdej świecy do jej złącza, zakryj złącze rurką termokurczliwą i obkurcz ją. Oczywiście zwykła taśma samoprzylepna też jest w porządku, wszystko zostanie ostatecznie zakryte.

Drugi obraz przedstawia przewody „-”, których potrzebuje każda świeca. Wspólny przewód „+” idzie bezpośrednio do pinu 5 V Arduino (lub może przez płytkę stykową). Każdy przewód „-” idzie do własnego pinu tranzystora IC (ponownie, prawdopodobnie przez płytkę stykową).

Arduino jest często nazywane płytą prototypową. Płytka prototypowa to także coś, czego używasz w prototypach. To, co opisuję w tej instrukcji, to prototyp. Nie zrobię z tego wytwornego, błyszczącego produktu z wszystkim schowanym w ładnych plastikowych etui. Przeniesienie go z prototypu na wyższy poziom oznaczałoby zastąpienie płytki stykowej płytką drukowaną i wlutowanymi podzespołami, a nawet zastąpienie Arduino zwykłym układem mikrokontrolera (właściwie taki układ jest mózgiem Arduino). I mieć wszystko, co mieści się w plastikowej skrzynce lub w zhakowanym moście świecy.

Krok 3: Połączenia

O Arduino, zaczerpnięte z tej strony:

• Całkowity maksymalny prąd na pin wejścia/wyjścia: 40mA
• Suma prądów ze wszystkich pinów wejścia/wyjścia łącznie: 200mA

Moje świece pobierają 19 mA przy zasilaniu 3 V. Jest ich siedem, co daje 133 mA. Mogłem więc zasilać je bezpośrednio z pinów wyjściowych. Mam jednak kilka zapasowych układów scalonych Darlington. Więc pomyślałem, dlaczego nie. Mój obwód robi to we właściwy sposób: piny danych służą tylko do sygnałów, a nie do zasilania. Zamiast tego używam pinu 5 V na Arduino do zasilania świateł LED. Podczas testu mam laptopa podłączonego do Arduino. Wszystko zasilane jest z laptopa USB, co daje 5 V. Arduino Mega posiada własny bezpiecznik, który przepala prądem 500 mA, aby chronić komputer. Moje świece pobierają najwyżej 133 mA. Arduino prawdopodobnie znacznie mniej. Wszystko działa dobrze, gdy jest zasilane z laptopa, więc użycie akumulatora 5 V podłączonego do portu USB Arduino jest w porządku.

Piny danych D3 - D9 idą do IC ULN2803APGCN. Diody LED działają na 3 V. Każda żarówka jest podłączona do źródła 5 V i dalej do rezystora 120 Ω. Dalej do jednego kanału układu scalonego, który ostatecznie łączy obwód z masą przez tranzystor darlingtona w układzie scalonym.

Do obwodu dodawany jest przycisk, aby umożliwić użytkownikowi wykonanie pewnych czynności. Most świecowy mógłby zatem mieć kilka programów wybieranych przez użytkownika.

Przycisk w obwodzie jest podłączony do RESET i GND. To jest dokładnie to, co robi wbudowany przycisk resetowania. Ponieważ nie zamykam wszystkiego w plastikowej obudowie, do sterowania programem używam przycisku resetowania na Arduino. Dodanie przycisku zgodnie z obrazem będzie działać dokładnie tak, jak przycisk resetowania tablicy. Program działa poprzez zapamiętywanie, jaki program świetlny był używany podczas ostatniego uruchomienia programu. W ten sposób każdy reset spowoduje przejście do następnego programu świetlnego.

Na zdjęciach widać, jak z mostka wychodzą nowe kable, jak ułożyłem na płytce stykowej układ scalony tranzystora i rezystory oraz jak przewody zworki łączą się z Arduino Mega. Przeciąłem 4 zworki męsko-męskie na 8 półprzewodów, które przylutowałem do 8 kabli wychodzących z mostka świecy. W ten sposób mogę po prostu włożyć kable do płytki stykowej.

Alternatywa bez tranzystorów

W poprzednim kroku przygotowałem wspólny przewód '+' dla świec i osobne przewody '-', które przechodzą przez IC tranzystora do masy. Gdy jeden pin danych przechodzi w stan wysoki, odpowiedni przewód „-” zostaje uziemiony przez tranzystor i świeci się dioda LED.

Podłączenie przewodów „-” bezpośrednio do pinów danych Arduino również działałoby, ale zawsze pamiętaj, ile prądu mogą wytrzymać piny danych! Takie podejście wymagałoby zmiany w moim programie. Aby zapalić świece, piny danych musiałyby zejść w dół. Aby używać mojego programu w takim stanie, w jakim jest, musisz przełączyć '+' i '-' w świecach. Mieć wspólny przewód '-' dla świec, który przechodzi do GND na Arduino. A oddzielne przewody biegną między przewodem „+” świecy a pinem danych Arduino.

Krok 4: Programy Światła

Mój program, który przedstawiam w kolejnym kroku, przechodzi przez 9 programów świetlnych. Naciśnięcie przycisku spowoduje wyłączenie świateł na sekundę, a następnie rozpocznie się następujący program oświetlenia. Programy są następujące:

1. Silne migotanie. Świece migoczą losowo. Wygląda to bardzo irytująco, gdy patrzysz na nie z bliskiej odległości, ale może wyglądać dobrze z daleka i być może za mroźnym oknem na poddaszu. Chociaż twój sąsiad może wezwać straż pożarną.
2. Miękkie migotanie. Wygląda bardzo dobrze. Jak prawdziwe świece w pokoju bez przeciągów.
3. Różne migotanie. Świece naprzemiennie przechodzą między silnym i miękkim migotaniem w odstępach około 30 sekundowych.
4. Różne migotanie. Jak #3, ale każda świeca zmienia się w swoim tempie od 30 s do 60 s.
5. Szybkie migotanie. Świece świecą na statycznie przyciemnionym poziomie i losowo migoczą. Średnio co sekundę pojawia się jedno migotanie.
6. Powolny błysk. Jak nr 5, ale w znacznie wolniejszym tempie.
7. Szybka fala od środkowej górnej świecy do niższych.
8. Powolna fala od środkowej górnej świecy do niższych.
9. Statyczne jasne światło. Musiałem to uwzględnić, nie chciałem pozbyć się pierwotnej funkcji.

Krok 5: Kodeks

/*

FLICKERING CANDLE BRIDGE */ // Zadeklaruj, że zmienna mode będzie utrzymywać stan // poprzez operację resetowania _attribute_((section(".noinit"))) unsigned int mode; // Gdy program uruchamia się po resecie, ta część pamięci // nie jest inicjowana, ale przechowuje wartość // którą miała przed resetem. Przy pierwszym uruchomieniu programu // znajduje się w nim losowa wartość. /* * Klasa świecy zawiera wszystko, co jest potrzebne * do obliczenia poziomu światła dla * migoczącej świecy. */ class candle { private: long maxtime; długi czas minutowy; długi maxlite; długi minlit; długi meanlite; długi czas origmax; długi czas powstania; długi origmaxlite; długi origminlit; długi origmeanlite; długi czas deltamax; długi czas deltaminu; długi deltamaxlit; długi deltaminlit; długi deltameanlit; długi lforat; długi wieczór; długi start; długi cel; współczynnik pływakowy; długi czas docelowy; długi czas startu; długi czas delta; nieważny nowy cel(unieważniony); długi jedencel (nieważny); publiczne: świeca(long mat, long mit, long mal, long mil, long mel, long eo); długi levelnow(void); void initlfo(długa deltamat, długa deltamit, długa deltamal, długa deltamil, długa deltamean, długa stopa); nieważne setfo(nieważne); }; 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; nowycel(); } /* * levelnow() zwraca poziom światła, jaki powinna mieć świeca w tej chwili. * Funkcja zajmuje się zdefiniowaniem nowego losowego poziomu światła i * czasu, jaki powinien upłynąć, aby osiągnąć ten poziom. Zmiana nie jest liniowa, * lecz przebiega po krzywej sigmoidalnej. Gdy nie jest czas na definiowanie nowego * poziomu, funkcja po prostu zwraca poziom światła. */ długa świeca::levelnow(void) { długa pomoc, teraz; pływak t1, t2; teraz = mili(); if (teraz >= czas docelowy) { pomoc = cel; nowycel(); pomoc w powrocie; } else { //help = target * (millis() - czas startu) / deltatime + start * (targettime - millis()) / deltatime; t1 = float(czas docelowy - teraz) / czas delta; t2 = 1. - t1; // To jest pomoc do obliczeń sigmoid = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; pomoc w powrocie; } } void candle::newtarget(void) { długa suma; suma = 0; for (long i = 0; i < evenout; i++) suma += onetarget(); początek = cel; cel = suma / wyrównanie; czas rozpoczęcia = mili(); czas docelowy = czas rozpoczęcia + losowy (czas minimalny, czas maksymalny); deltatime = czas docelowy - czas rozpoczęcia; } długa świeca::onetarget(void) { if (losowy (0, 10) lastcheck + 100) { lastcheck = now; /* * Algorytm migania "po szybkości w milisekundach": * Rozpocznij sprawdzanie po szybkości / 2 milisekundy * W okresie szybkości / 2 milisekundy spraw, aby * szansa na miganie wynosiła 50%. * Jeśli stopa wynosi 10000 ms, w ciągu 5000 ms moneta jest * rzucana 50 razy. * 1/50 = 0,02 * If random(10000) starttime + rate / 2) { if (random(rate) targettime) return lowlite; return (start - lowlite) * (targettime - teraz) / (targettime - starttime) + lowlite; } void twinkler::twink(void) { starttime = millis(); czas docelowy = losowy(czas minimalny, czas maksymalny) + czas rozpoczęcia; start = losowy(minlite, maxlite); } void setup() { int led; // Odczytaj zmienną trybu magicznego, która powinna // powiedzieć, jaki program light był ostatnio uruchomiony, zwiększ ją // i zresetuj do zera w przypadku przepełnienia. tryb++; tryb %= 9; // To zajmuje się jakąkolwiek wartością // była pierwszym uruchomieniem tego programu przez // Arduino. /* * WAŻNA UWAGA * ============== * * Podstawową czynnością tego programu jest wysyłanie sygnałów PWM * do świateł LED. Tutaj ustawiam piny od 3 do 9 w tryb wyjścia *. W Arduino Mega2560 te piny wyprowadzają * ładnie sygnały PWM. Jeśli masz inne Arduino, sprawdź * jakich pinów (i ile) możesz użyć. Zawsze możesz * przepisać kod, aby użyć programowego PWM, jeśli twoje Arduino * nie może zapewnić wystarczającej ilości sprzętowych pinów PWM. * */ pinMode(3, WYJŚCIE); pinMode(4, WYJŚCIE); pinMode(5, WYJŚCIE); pinMode(6, WYJŚCIE); pinMode(7, WYJŚCIE); pinMode(8, WYJŚCIE); pinMode(9, WYJŚCIE); pinMode (LED_BUILTIN, WYJŚCIE); analogWrite(LED_BUILTIN, 0); // Po prostu wyłącz irytującą czerwoną diodę świecy Arduino *can[7]; // przygotuj się do użycia migoczących świec, niezależnie od tego, czy ich używasz, czy nie twinkler *twink[7]; // przygotuj się do użycia migoczących świec… if (mode == 8) { for (int i = 3; i < 10; i++) analogWrite(i, 255); podczas (prawda); // Za każdym razem, gdy ten program jest uruchamiany, // przechodzi w ten rodzaj nieskończonej pętli, // dopóki nie zostanie naciśnięty przycisk resetowania. } if (mode < 2) // migotanie { long maxtime_; długa minuta_; długi maxlite_; długi minlite_; długi meanlite_; długi parzysty_; if (tryb == 0) { maxtime_ = 250; minczas_ = 50; maxlite_ = 256; minlite_ = 0; średnia_= 128; parzysty_ = 1; } if (tryb == 1) { maxtime_ = 400; minczas_ = 150; maxlite_ = 256; minlit_ = 100; średnia_= 200; parzysty_ = 1; } for (int i = 0; i < 7; i++) { can = nowa świeca(maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // Niekończąca się pętla migających świec { for (int i = 0; i levelnow()); } } if (mode < 4) // lfo dodane do migotania { if (mode == 2) // to samo lfo (30 s) dla wszystkich świec { for (int i = 0; i initlfo(75, 50, 0, 50, 36, 30000); } } if (mode == 3) // zmienne lfo:s dla świec { 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) // Niekończąca się pętla migających świec z 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) // migoczące świece { int speedo; if (mode == 4) speedo = 6000; w przeciwnym razie 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()); } } // Fale. // Ta sekcja zaczyna się od nawiasów klamrowych, tylko // aby upewnić się, że nie ma sprzecznych nazw zmiennych. // Nie ma potrzeby stosowania nawiasów, nie ma potrzeby sprawdzania // wartości trybu.{ wewn. lolit = 2; int hilite = 255; int średnia; wewn. pływak fasedelta = 2,5; pływak; int wydłużony; współczynnik pływakowy; długi okres; średnia = (lolit + hilit) / 2; ampl = hilite - średnia; jeśli (tryb == 6) okres = 1500; inny okres = 3500; faktor = 6.28318530718 / okres; while (true) { fase = phactor * (millis() % okres); elong = średnia + ampl * sin(fase); analogZapis(7, podłużny); analogWrite(9, podłużny); faza = współczynnik * ((millis() + okres / 4) % okres); elong = średnia + ampl * sin(fase); analogZapis(3, podłużny); analogZapis(8, podłużny); faza = współczynnik * ((millis() + okres / 2) % okres); elong = średnia + ampl * sin(fase); analogWrite(4, podłużny); analogZapis(5, podłużny); faza = współczynnik * ((millis() + 3 * okres / 4) % okres); elong = średnia + ampl * sin(fase); analogZapis(6, podłużny); } // Podłączając przewody świecy do Arduino, // pomieszałem je i nigdy nie ułożyłem. // Kolejność jest ważna przy tworzeniu wzorów fal, // więc właśnie napisałem dla mnie tę małą tabelkę: // // Candle# w mostku: 2 3 5 4 7 6 1 // Data pin na Arduino: 3 4 5 6 7 8 9 } } void loop() { // Ponieważ każdy program light jest własną nieskończoną pętlą, // napisałem wszystkie pętle w sekcji begin() // i nic nie zostawiłem w tej sekcji loop(). }

Krok 6: O PWM

Diody świecą jasno przy zasilaniu 3 V. Przy jedynie 1,5 V w ogóle się nie zapalają. Światła LED nie blakną ładnie wraz z zanikającym napięciem, tak jak robią to żarówki. Zamiast tego muszą być włączone z pełnym napięciem, a następnie wyłączone. Kiedy dzieje się to 50 razy na sekundę, świecą ładnie z 50% jasnością, mniej więcej. Jeśli wolno im być włączone tylko 5 ms i wyłączone 15 ms, mogą świecić z 25% jasnością. Ta technika umożliwia ściemnianie światła LED. Ta technika nazywana jest modulacją szerokości impulsu lub PWM. Mikrokontroler taki jak Arduino zwykle ma piny danych, które mogą wysyłać sygnały włączania/wyłączania. Niektóre piny danych mają wbudowane możliwości PWM. Ale jeśli nie ma wystarczającej liczby pinów z wbudowanym PWM, zwykle można użyć dedykowanych bibliotek programistycznych do stworzenia "programowych pinów PWM".

W moim projekcie użyłem Arduino Mega2560, który ma sprzętowy PWM na pinach 3 - 9. Jeśli używasz Arduino UNO, masz tylko sześć pinów PWM. W takim razie, jeśli potrzebujesz 7 (lub więcej) świecy, mogę polecić bibliotekę oprogramowania PWM Bretta Hagmana, którą znajdziesz tutaj.