Lampki choinkowe sterowane z Raspberry Pi

Lampki choinkowe sterowane z Raspberry Pi

Święta to ten okres, w którym każdy elektronik tęsknie spogląda w kierunku wszystkich układów mrugających diodami. Postęp w elektronice zawitał i do tej grupy układów elektronicznych. Tak jak kiedyś do sterowania lampkami na świątecznym drzewku używano prostych multiwibratorów czy układów opartych na klasycznym NE555, tak teraz do sterowania nimi stosuje się moduły takie jak komputer jednopłytkowy Raspberry Pi.

Przedstawiony w poniższym artykule projekt obejmuje użycie minikomputera Raspberry Pi do sterowania ośmioma gniazdkami prądu zmiennego, które są podłączone do łańcuchów lampek choinkowych. Każdy z łańcuchów lampek jest prostym, jednokolorowym sznurem żaróweczek. Aby nadać pokazowi świateł na drzewku bardziej dynamiczny charakter, w systemie można zamontować dodatkowo gwiazdę RGB z 25 diodami LED RGB, które również będą sterowane.

Dodatkową funkcją wynikającą z zastosowania komputera jednopłytkowego Raspberry Pi zamiast prostszych kontrolerów jest to, że popularna Malina umożliwia synchronizację świateł z muzyką. Natomiast dzięki podłączeniu Raspberry Pi do bezprzewodowej sieci Wi-Fi istnieje możliwość łatwego zdalnego sterowania lampkami.

Potrzebne elementy

Poniżej znajduje się lista elementów, jakie do konstrukcji układu zastosował autor projektu. Należy jednakże pamiętać, że wiele z nich można zastąpić innymi, kompatybilnymi urządzeniami, więc konstruując własny sterownik do światełek choinkowych, nie trzeba się trzymać w 100% poniższej listy. Do budowy sterownika potrzebne będą:

  • Komputer jednopłytkowy Raspberry Pi. Każdy model i każda wersja tych minikomputerów poradzi sobie w opisanej tutaj aplikacji, więc zastosujemy ten, który mamy pod ręką albo który będzie najtańszy,
  • Karta microSD do zapisania systemu operacyjnego i oprogramowania sterownika. Rekomendowana jest markowa karta o pojemności co najmniej 8 GB,
  • Karta sieciowa (Wi-Fi) na USB, jeżeli wybrany przez nas minikomputer nie ma zintegrowanej karty bezprzewodowej,
  • Moduł przekaźników elektronicznych. Autor użył ośmiokanałowego modułu SainSmart, dostępny na Amazonie. Przekaźniki elektroniczne w układzie mają maksymalny prąd 2 A, co jest wartością wystarczającą do zasilania chyba dowolnych lampek choinkowych. Należy unikać w tym systemie sterowania przekaźnikami elektromechanicznymi, ponieważ przekaźniki takie są głośne podczas pracy (klikają w czasie przełączania),
  • Zasilacz 5 V, 3 A do zasilania diod gwiazd i Raspberry Pi,
  • Zasilacz 5 V, 1A do zasilania przekaźników elektronicznych,
  • Okablowanie do połączenia ze sobą wszystkich modułów,
  • Osiem przedłużaczy dla światełek choinkowych,
  • Złączki i inne elementy łączeniowe – wedle uznania i wygody podczas montażu,
  • Obudowa (może być zrobiona samodzielnie albo kupiona obudowa uniwersalna),
  • Głośniki do odtwarzania muzyki z Raspberry Pi.

Do zestawienia LED-owej gwiazdy RGB są potrzebne:

  • 25 sztuk 12 mm diody RGB z sterownikiem (WS2801),
  • Arkusz plastiku do zamontowania w nim diod,
  • Arkusz matowego leksanu/pleksiglasu itp. do zakrycia LED-ów i rozmycia ich światła,
  • Materiały do zrobienia obudowy gwiazdy (np. listewki drewniane),
  • Czarna i biała farba w sprayu.

Oczywiście, potrzebne będą również lampki choinkowe. Autor wybrał następujący komplet:

  • Białe lampki (100 punktów) – 4 sztuki,
  • Białe lampki (50 punktów) – 1 sztuka,
  • Czerwone lampki (100 punktów) – 2 sztuki,
  • Zielone lampki (100 punktów) – 2 sztuki,
  • Niebieskie lampki (100 punktów) – 2 sztuki.

Do własnej choinki można zestawić dowolny zestaw lampek choinkowych w dowolnych kolorach.

Połączenia wewnętrzne w sterowniku

Zanim rozpoczniemy łączenie poszczególnych elementów z Raspberry Pi, należy skonfigurować komputer jednopłytkowy. Najlepiej zrobić to, zanim zamkniemy komputer w obudowie, gdyż niezbędne będzie dołączenie klawiatury i monitora lub telewizora. Celem jest takie skonfigurowanie systemu, by pracował bez kontroli z klawiatury, a jedynie przez sieć. Dodatkowo, na tym etapie powinniśmy doinstalować wszystkie wymagane biblioteki, takie jak te, które potrzebne są do obsługi diod LED WS2801.

Najprościej jest zainstalować system operacyjny Occidentalis na karcie microSD naszego komputera – ta dystrybucja Linuksa, stworzona przez Adafruit, ma wszystkie najpotrzebniejsze nam elementy. Po zainstalowaniu systemu musimy tylko skonfigurować kilka drobnych rzeczy:

  • Powinniśmy wyłączyć interfejs GUI – Raspberry Pi ma bootować się bezpośrednio do linii komend,
  • Edytując plik /etc/network/interfaces, wpisujemy dane do logowania do naszej sieci bezprzewodowej oraz przydzielamy komputerowi statyczny numer IP, aby zawsze można było odnaleźć go w naszej sieci,
  • Instalujemy usługi Telnet oraz FTP,
  • Instalujemy bibliotekę Pygame – będzie używana przez skrypty w Pythonie do odtwarzania plików MP3 i WAV.

W tym momencie odłączamy od komputera jednopłytkowego ekran, klawiaturę i mysz, i możemy połączyć się poprzez sieć (przez SSH). Teraz podłączamy Raspberry Pi do potrzebnych modułów i umieszczamy całość w obudowie.

Fotografia 1. Zmontowany układ w obudowie

Na fotografii 1 pokazano zmontowany układ w obudowie. Obudowę można wykonać w dowolny sposób - autor konstrukcji użył drewna do zrobienia prostej obudowy, ale system będzie działał tak samo dobrze np. w obudowie uniwersalnej. Pamiętajmy, aby była ona na tyle duża, by pomieściła wszystkie potrzebne moduły i ich zasilacze.

W obudowie wykonujemy dwa otwory o średnicy około 4 cm, przez które wyprowadzimy przewody do przedłużaczy sterowanych przez Raspberry Pi i doprowadzimy zasilanie sieciowe do znajdującego się w środku przedłużacza. Jedno z gniazd posłuży nam do zasilania Raspberry Pi (zasilacz zaznaczony na fotografii 1 na zielono). Zasilanie 5 V podłączamy do komputera jednopłytkowego zgodnie z listą połączeń z tabeli 1. Po podłączeniu zasilania możemy uruchomić Raspberry Pi i zalogować się do niego przez sieć. Po sprawdzeniu poprawności montażu zasilacza odłączamy zasilanie od sterownika i instalujemy w nim moduł z przekaźnikami elektronicznymi, jak pokazano na fotografii 2.

Tabela 1. Lista połączeń zasilacza z Raspberry Pi
Sygnał Pin Raspberry Pi
Zasilanie 5 V 2
Masa (GND) zasilacza 6
Fotografia 2. Podłączenie modułu z przekaźnikami

Do pinów zasilania modułu podłączamy zasilacz 5 V (inny niż dla Raspberry Pi). Dzięki tranzystorom w obwodzie sterowania przekaźnikami, sygnały z Raspberry Pi o napięciu 3,3 V mogą sterować modułem wykonawczym. Komputer jednopłytkowy łączymy poprzez wyjścia GPIO0...GPIO7 z modułem przekaźników, zgodnie z danymi z tabeli 2. Jeśli zastosowaliśmy inny moduł niż Raspberry Pi Model B, upewnijmy się, że poszczególne linie GPIO są wyprowadzone w tych samych miejscach. Jeśli moduł, tak jak ten pokazany na fotografiach, ma na wejściu terminale śrubowe, dobrze jest połączenia te wykonać po zamontowaniu obu elementów w obudowie, aby można było przyciąć kable łączące do odpowiedniej długości. Na koniec upewnijmy się, że złącza są dobrze podłączone do Raspberry Pi i odpowiednio dokręcone w module z przekaźnikami elektronicznymi. Na module z przekaźnikami znajdują się także diody LED, sygnalizujące załączenie każdego z przekaźników, tj. wystawienie stanu wysokiego na odpowiednim pinie GPIO Raspberry Pi. Pozwoli nam to przetestować, czy wszystko zmontowaliśmy poprawnie.

Tabela 2. Lista połączeń modułu przekaźników z Raspberry Pi
Sygnał Pin Raspberry Pi
GPIO0 11
GPIO1 12
GPIO2 13
GPIO3 15
GPIO4 16
GPIO5 18
GPIO6 22
GPIO7 7
Masa (GND) 6, 9, 14, 20 lub 25

Program testowy dla przekaźników

Aby przetestować poprawność montażu elementów wewnątrz sterownika, możemy uruchomić na Raspberry Pi prosty skrypt napisany w Pythonie (listing 1), który przetestuje podłączone do układu przekaźniki elektroniczne.

Listing 1. Skrypt testujący działanie przekaźników #!/usr/bin/env python import RPi.GPIO as GPIO, time # Ustawienie trybu obsługi GPIO GPIO.setmode(GPIO.BOARD) # 10 sekund oczekiwaniua time.sleep(10.0) # GPIO0 # Konfiguracja pinu 11 (GPIO0) jako wyjścia GPIO.setup(11, GPIO.OUT) # Wystawienie na GPIO0 stanu wysokiego # załączenie przekaźnika GPIO.output(11, True) # 2 sekundy oczekiwania time.sleep(2.0) # Wystawienie na GPIO0 stanu niskiego # wyłączenie przekaźnika GPIO.output(11, False) #GPIO1 GPIO.setup(12, GPIO.OUT) GPIO.output(12, True) time.sleep(2.0) GPIO.output(12, False) #GPIO2 GPIO.setup(13, GPIO.OUT) GPIO.output(13, True) time.sleep(2.0) GPIO.output(13, False) #GPIO3 GPIO.setup(15, GPIO.OUT) GPIO.output(15, True) time.sleep(2.0) GPIO.output(15, False) #GPIO4 GPIO.setup(16, GPIO.OUT) GPIO.output(16, True) time.sleep(2.0) GPIO.output(16, False) #GPIO5 GPIO.setup(18, GPIO.OUT) GPIO.output(18, True) time.sleep(2.0) GPIO.output(18, False) #GPIO6 GPIO.setup(22, GPIO.OUT) GPIO.output(22, True) time.sleep(2.0) GPIO.output(22, False) #GPIO7 GPIO.setup(7, GPIO.OUT) GPIO.output(7, True) time.sleep(2.0) GPIO.output(7, False)

Musimy wpisać (będąc w folderze, w którym znajduje się skrypt test.py) w linii poleceń terminalu następujące polecenie:

python test.py

Skrypt włączy, po kolei, od GPIO0 do GPIO7, każdy z podłączonych przekaźników na dwie sekundy, po czym go rozłączy. Jeżeli któryś z przekaźników nie zadziałał, warto sprawdzić połączenia pomiędzy modułem SSR a komputerem jednopłytkowym Raspberry Pi.

Podłączanie lampek

Teraz możemy podłączyć do modułu z przekaźnikami przedłużacze, które posłużą nam do zasilania lampek choinkowych (czy dowolnych innych elementów oświetleniowych, jakimi możemy sterować). Od przedłużaczy należy odciąć wtyczkę sieciową, odizolować około 5 mm przewodu i rozciąć kawałek więcej (jeżeli mamy, tak jak na fotografii 3, przewód z dwoma żyłami w oddzielnej izolacji), aby ułatwić sobie podłączanie. Dodatkowo potrzebujemy jeszcze przewodu zakończonego odizolowanymi końcówkami z jednej strony i wtyczką sieciową z drugiej, aby podłączyć wszystkie linie do napięcia 230 V AC. Do wszystkich przekaźników musimy dołączyć przewód fazowy, można w tym celu użyć listwy jak z fotografii 4. Następnie drugie (wolne) zaciski przekaźników łączymy z przedłużaczami. Pozostałe wolne przewody przedłużaczy łączymy listwą z drugą linią zasilania (linia zerowa). Przykład gotowej instalacji pokazano na fotografii 5. Oznaczenia „110V” dotyczą innych parametrów sieci energetycznej, ale dla sieci 230 V połączenia będą takie same.

Fotografia 3. Przygotowanie przewodów od przedłużaczy
Fotografia 4. Listwa łącząca wiele przewodów
Fotografia 5. Instalacja łącząca moduł przekaźnikowy
Fotografia 6. Dołączone lampki testowe

Po zamontowaniu przedłużaczy sieciowych możemy podłączyć do nich lampki. Jak pokazano na fotografii 6, mogą to być zwykłe lampki podłączane do gniazdka, a nie lampki choinkowe. Aby przetestować, czy wszystko zostało podłączone poprawnie, można uruchomić ponownie skrypt z listingu 1. Przed podłączeniem lampek choinkowych należy upewnić się, że ich całkowity pobór prądu nie przekroczy dopuszczalnego prądu przekaźników (w tym wypadku 2 A). Warto zmierzyć to multimetrem ustawionym na pomiar prądu zmiennego. Zastosowane w projekcie lampki pobierają 0,34 A na jeden łańcuch, a autor planuje podłączyć po dwa łańcuchy na przekaźnik, co daje 0,68 A – istotnie poniżej limitu dwóch amperów.

Budowa gwiazdy RGB LED

Kolejnym elementem ozdobnym, jaki wykonamy, jest gwiazda RGB. Dzięki zastosowaniu trójkolorowych diod LED możliwa jest zmiana barwy ich świecenia na niemalże dowolny kolor. Moduły WS2801, zastosowane w tym projekcie, integrują w sobie sterownik PWM dla diody RGB z interfejsem cyfrowym. Po połączeniu sterowników z dyskretnymi diodami LED RGB stanową one całość, jak pokazano na fotografii 7. Dzięki temu ich połączenie jest niezwykle proste – diody łączy się szeregowo. Po umieszczeniu wszystkich diod w przygotowanej obudowie (patrz fotografia 8) łączymy je ze sobą szeregowo. Autor projektu wykonał gwiazdę z drewna, w której umieścił 25 diod LED RGB w podstawce z ABS-u. Przykrył ją następnie fragmentem mlecznej pleksi, aby rozmyć światło – dzięki temu gwiazda świeci bardziej jednorodnie i nie są widoczne poszczególne punkty świetlne.

Fotografia 7. Dioda LED RGB ze sterownikiem WS2801
Fotografia 8. Diody RGB w obudowie gwiazdy

Ostatnim krokiem jest wykonanie odpowiedniej długości przedłużacza dla gwiazdy RGB. Musi mieć cztery kable – dwa do zasilania i dwa dla danych i zegara. Diody zasilane są napięciem 5 V, więc podłączamy dwa kable do, odpowiednio, masy i zasilacza 5 V (tego samego, do którego podłączony jest komputer jednopłytkowy Raspberry Pi). Pozostałe dwa kable podłączamy do minikomputera zgodnie z tabelą 3. Po sprawdzeniu wszystkich połączeń diod do zasilania i Raspberry Pi możemy uruchomić program, który pozwoli przetestować jej działanie.

Tabela 3. Lista połączeń łańcucha diod w gwieździe RGB LED i Raspberry Pi
Sygnał Pin Raspberry Pi
Dane (MOSI) 19
Zegar (SCLK) 23

Program testowy dla diod RGB

Po podłączeniu gwiazd RGB LED możemy przetestować ich działanie. W tym celu uruchomimy skrypt ledtest.py, umieszczony na listingu 2. Należy przejść do folderu, w którym znajduje się skrypt i w linii komend wpisać:

python ledtest.py
Listing 2. Skrypt testujący działanie diod LED RGB #!/usr/bin/python import RPi.GPIO as GPIO, time # Konfigurowalne wartości - interfejs SPI dev = „/dev/spidev0.0” # Uruchamia interfejs SPI, ładuje obraz # w formacie RGB i ustala jego wymiar spidev = file(dev, „wb”) # Oblicza tablicę korekcji wartości gamma # to konkretne obliczenia dla diod z WS2801 gamma = bytearray(256) for i in range(256): gamma[i] = int(pow(float(i) / 255.0, 2.5) * 255.0 + 0.5) test_set = bytearray(25 * 3); for y in range(255): for x in range(25): test_set[x*3 ] = gamma[y] test_set[x*3 + 1] = gamma[00] test_set[x*3 + 2] = gamma[255-y] spidev.write(test_set) spidev.flush() time.sleep(0.06) print(„Done!”)

Po uruchomieniu skrypt powinien spowodować najpierw zapalenie wszystkich diod na niebiesko i powolną zmianę koloru do czerwonego (fotografia 9 oraz 10).

Fotografia 9. Działanie skryptu testowego – gwiazda świeci na niebiesko
Fotografia 10. Działanie skryptu testowego – gwiazda w kolorze czerwonym

Instalacja na drzewku

Po sprawdzeniu wszystkich elementów oświetlenia możemy dokończyć montaż sterownika. Dołączamy do Raspberry Pi głośniki, które będą odtwarzać muzykę, a całą obudowę zamykamy.

Po przygotowaniu sterownika możemy ubrać choinkę. Autor rozmieścił białe lampki strefami, jak na fotografii 11. Pozostałe łańcuchy (czerwony zielony i niebieski) podłączone zostały po dwa do pozostałych trzech kanałów sterownika. Gwiazda spoczęła na czubku drzewka. Takie rozmieszczenie oferuje największą elastyczność w projektowaniu sekwencji, które będą uruchamiane wraz z muzyką. To, do którego przedłużacza podłączony będzie konkretny łańcuch lampek choinkowych, nie jest krytyczne, gdyż można to skonfigurować w programie sterującym systemem.

Fotografia 11. Rozmieszczenie lampek na choince

Oprogramowanie do animacji i synchronizacji z muzyką

Najistotniejszy fragment programu sterującego lampkami umieszczony jest na listingu 3. Do uruchomienia skryptu xmas.py potrzebujemy, oprócz samego skryptu napisanego w Pythonie, także pliku tekstowego z sekwencją oraz pliku audio (MP3 lub WAV) z muzyką, która ma towarzyszyć sekwencji. Program uruchamiamy, wpisując w linii komend:

python xmas.py <plik z sekwencją> <plik z muzyką>

gdzie w odpowiednim miejscu podajemy ścieżki do plików z sekwencją i muzyką. Plik z sekwencją ma następujący format:

czas w milisekundach, komenda, wartość
Listing 3. Fragment programu sterującego pracą urządzenia # Konfiguracja płytki GPIO.setmode(GPIO.BOARD) for i in range(1,9): GPIO.setup(pin_map[i], GPIO.OUT) time.sleep(2.0); dev = „/dev/spidev0.0” spidev = file(dev,”wb”) # Obliczenie korekcji gamma gamma = bytearray(256) for i in range(256): gamma[i] = int(pow(float(i) / 255.0, 2.5) * 255.0 + 0.5) starinit(1) # W pliku setup.txt zapisane jest mapowanie wyjść GPIO. with open(„setup.txt”,’r’) as f: data = f.readlines() for i in range(8): logical_map[i+1] = int(data[i]) # Otwieranie pliku sekwencji i jego parsowanie with open(sys.argv[1],’r’) as f: seq_data = f.readlines() for i in range(len(seq_data)): seq_data[i] = seq_data[i].rstrip() # Obecny stan światełek lights = [False for i in range(8)] # Załadowanie i odtwarzanie muzyki pygame.mixer.init() pygame.mixer.music.load(sys.argv[2]) pygame.mixer.music.play() # Start sekwencji start_time = int(round(time.time()*1000)) step = 1 #ignore the header line while True : next_step = seq_data[step].split(„,”); next_step[1] = next_step[1].rstrip() cur_time = int(round(time.time()*1000)) - start_time # Czas trwania komendy if int(next_step[0]) <= cur_time: print next_step # Jeżeli komenda dotyczy któregoś z przekaźników od 1 do 8 if next_step[1] >= „1” and next_step[1] <= „8”: # zmień stan pinu na odpowiedni if next_step[2] == „1”: GPIO.output(pin_map[logical_map[int(next_step[1])]],True) else: GPIO.output(pin_map[logical_map[int(next_step[1])]],False) # Parsowanie komend dla gwiazdy if next_step[1].rstrip() == „BLINK”: blink_active = 0 blink_max = int(next_step[2]) blink_R1 = int(next_step[3]) blink_G1 = int(next_step[4]) blink_B1 = int(next_step[5]) blink_R2 = int(next_step[6]) blink_G2 = int(next_step[7]) blink_B2 = int(next_step[8]) for i in range(25): blinks[i*3] = 0 blinks[i*3+1] = 0 blinks[i*3+2] = 0 blink_next_time = int(round(time.time()*1000)) - start_time if next_step[1].rstrip() == „BLINK_END”: blink_active = -1 if next_step[1].rstrip() == „STAR_VERT”: star_vert(next_step[2],next_step[3],next_step[4], next_step[5], next_step[6], next_step[7], next_step[8]) if next_step[1].rstrip() == „STAR_TIPS”: star_tips(next_step[2],next_step[3],next_step[4], next_step[5], next_step[6], next_step[7]) if next_step[1].rstrip() == „STAR_SOLID”: star_solid(next_step[2],next_step[3],next_step[4]) if next_step[1].rstrip() == „STAR_INSIDE_SOLID”: star_inside_solid(next_step[2],next_step[3],next_step[4]) if next_step[1].rstrip() == „STAR_POINT1”: star_point1(next_step[2],next_step[3],next_step[4]) if next_step[1].rstrip() == „STAR_POINT2”: star_point2(next_step[2],next_step[3],next_step[4]) if next_step[1].rstrip() == „STAR_POINT3”: star_point3(next_step[2],next_step[3],next_step[4]) if next_step[1].rstrip() == „STAR_POINT4”: star_point4(next_step[2],next_step[3],next_step[4]) if next_step[1].rstrip() == „STAR_POINT5”: star_point5(next_step[2],next_step[3],next_step[4]) # jeżeli napotkana jest komenda końca (END) sekwencji if next_step[1].rstrip() == „END”: for i in range(1,9): GPIO.output(pin_map[logical_map[i]],False) break step += 1 # Obsługa mrugania if blink_active > -1 and cur_time > blink_next_time: blink_next_time = cur_time + 100 for i in range (25): if blinks[i*3]>0 or blinks[i*3+1]>0 or blinks[i*3+2]>0: blinks[i*3] += blink_R1 blinks[i*3+1] += blink_G1 blinks[i*3+2] += blink_B1 if blinks[i*3]==255 or blinks[i*3+1]==255 or blinks[i*3+2]==255: blinks[i*3] = 0 blinks[i*3+1] = 0 blinks[i*3+2] = 0 blink_active -= 1 if blink_active < blink_max and random.randrange(1,5) == 1: pick = random.randrange(0,24) if blinks[pick*3] == 0 and blinks[pick*3+1]==0 and blinks[pick*3+2]==0: blink_active += 1 blinks[pick*3] = blink_R1 blinks[pick*3+1] = blink_G1 blinks[pick*3+2] = blink_B1 for i in range (25): if blinks[i*3]==0 and blinks[i*3+1]==0 and blinks[i*3+2]==0: set[i*3] = blink_R2 set[i*3+1] = blink_G2 set[i*3+2] = blink_B2 else: set[i*3] = blinks[i*3] set[i*3+1] = blinks[i*3+1] set[i*3+2] = blinks[i*3+2] spidev.write(set) spidev.flush() # koniec obsługi mrugania

Czas w milisekundach to czas od początku utworu. Komenda to albo numer przekaźnika, którego stan chcemy zmienić (wtedy wartość przyjmuje 0 – wyłączony lub 1 – włączony), albo komenda sterująca gwiazdą RGB:

  • STAR_SOLID do zapalenia jej na jakiś kolor w całości do komendy podajemy trzy wartości (R, G, B) określające kolor diody,
  • STAR_SOLID_INSIDE do zapalenia wewnętrznej części, również potrzebuje parametrów określających kolor (R, G, B),
  • STAR_POINT1...STAR_POINT5 do zapalenie jednego z ramion – te komendy także wymagają koloru (R, G, B),
  • STAR_TIPS to komenda do zapalenia samych końcówek ramion gwiazdy na inny kolor niż reszta. Komenda przyjmuje sześć parametrów – pierwsze trzy to kolor, na jaki świecić mają końcówki ramion (Rt, Gt, Bt) a drugie trzy (R, G, B) to kolor pozostałej części ozdoby,
  • START_VERT – pokrywa gwiazdę liniami w naprzemiennych kolorach; funkcja przyjmuje siedem parametrów – okres (per) linii i ich kolory – (R1, G1, B2) oraz (R2, G2, B2),
  • BLINK do rozpoczęcia mrugania gwiazdy i BLINK_END do jego zakończenia. Funkcja BLINK przyjmuje siedem parametrów; pierwszy parametr to maksymalna liczba mrugnięć, a kolejne to dwa bloki kolorów (R1, G1, B1) oraz (R2, G2, B2), pomiędzy którymi przełączać się będzie mrugająca gwiazda.

Możemy w ten sposób stworzyć własną, dowolną sekwencję, dopasowaną do muzyki, jaką uświetnić chcemy działanie naszego świątecznego drzewka.

Źródło: http://bit.ly/2XoKNfi

Nikodem Czechowski, EP

Artykuł ukazał się w
Elektronika Praktyczna
grudzień 2019
Elektronika Praktyczna Plus lipiec - grudzień 2012

Elektronika Praktyczna Plus

Monograficzne wydania specjalne

Elektronik maj 2020

Elektronik

Magazyn elektroniki profesjonalnej

Raspberry Pi 2015

Raspberry Pi

Wykorzystaj wszystkie możliwości wyjątkowego minikomputera

Świat Radio czerwiec 2020

Świat Radio

Magazyn użytkowników eteru

APA - Automatyka Podzespoły Aplikacje maj 2020

APA - Automatyka Podzespoły Aplikacje

Technika i rynek systemów automatyki

Elektronika Praktyczna maj 2020

Elektronika Praktyczna

Międzynarodowy magazyn elektroników konstruktorów

Praktyczny Kurs Elektroniki 2018

Praktyczny Kurs Elektroniki

24 pasjonujące projekty elektroniczne

Elektronika dla Wszystkich maj 2020

Elektronika dla Wszystkich

Interesująca elektronika dla pasjonatów