Dzięki swoim złączom GPIO Raspberry Pi jest bardzo ciekawym urządzeniem, które pozwala na dołączenie do świata kodu i systemów odrobiny fizyczności w postaci różnych komponentów elektrycznych. Pokażę Ci, w jaki sposób podpiąć do “malinki” diody i przyciski, a następnie wywołać dla nich odpowiednie funkcje tak, aby diody zaświeciły się po wykonaniu konkretnej akcji – na przykład po wciśnięciu konkretnego przycisku.
Złącze GPIO
Raspberry Pi posiada dwa rzędy po 20 pinów, czyli łącznie GPIO zbudowane z 40 pinów komunikacyjnych. Wiele z nich ma funkcję przypisaną na stałe, inne pozwalają na dowolną konfigurację. Najlepiej zerknąć na schemat poniżej, który przedstawia tzw. pinout – spis wszystkich funkcji, które udostępnia każdy z pinów.
Jak łatwo zauważyć kilka pinów odpowiada za zasilanie (3,3V i 5V), jeszcze inne za masę (Ground). Tych pinów nie przeprogramujemy, ale nie ma to większego znaczenia – pozostałe piny (GPIO) można skonfigurować dowolnie i korzystać z nich we wszystkich projektach. Niektóre GPIO mają dodatkową informację w nawiasie – to dodatkowe funkcje, z których możemy skorzystać podczas programowania Raspberry Pi. Na przykład, jeśli potrzebujemy komunikacji RS485, to możemy wykorzystać piny 8 (GPIO14 – TX), 10 (GPIO15 – RX) i 14 (masa). Malinka jest praktycznie od razu gotowa do skorzystania z tych pinów do komunikacji szeregowej. W naszym przypadku wystarczy na razie wiedza, że te piny, które są opisane jako GPIO możemy wykorzystać do podłączania dowolnych komponentów. Dodatkowo warto pamiętać, że jeśli potrzebujemy zasilania 3,3V lub 5V, to możemy skorzystać z nich bez żadnej konfiguracji (napięcie jest tam zawsze).
Płytki stykowe
Cały układ, z którego będę korzystał buduję na tak zwanej płytce stykowej (nazywanej często breadboardem). Płytka pozwala na szybkie wpinanie i wymienianie elementów układu. Działa ona w ten sposób, że linie zasilania (+/-) biegną wzdłuż całej płytki i każdy pin jest ze sobą połączony. Dzięki temu wystarczy wpiąć zasilanie na początku płytki i przez całą mamy takie samo zasilanie. Dodatkowo mamy dwie strony płytki, wiec możemy mieć jednocześnie zasilanie 3,3V i 5V na jednej płytce. Na środku płytka posiada sekcje poprzeczne, które są połączone ze sobą w linie po 5 styków. Pozwala to na łączenie elementów wzdłuż i w poprzek płytki, wystarczy znać jedynie zasadę przepływu prądu. Schemat obrazujący jak połączone są ze sobą piny płytki stykowej wrzucam poniżej.
Diody, przyciski i okablowanie
Do pracy z Raspberry Pi i płytką stykową wykorzystałem cztery diody: zieloną, żółtą, czerwoną i niebieską. Podłączam je do układu przez rezystor 1 kOhm. Do całości dołożyłem dwa przyciski (zwykłe przyciski stykowe), które posłużą za źródło informacji. Przy diodach warto pamiętać, że krótsza nóżka to katoda (-), natomiast dłuższa to anoda (+). Dodatkowo przyjęło się, że rezystor podłącza się mnożnikiem w stronę odbiornika. Nie jest to wymóg konieczny, ale warto znać tą zasadę.
Do tego dochodzą przewody. Osobiście mam żelazna zasadę – minus (oznaczany jako “-” lub “GND”) zawsze podłączam czarnym przewodem. Jeśli wszystko wychodzi z jednego źródła zasilania, to zasilanie (“+”) zawsze podłączam czerwonym przewodem. Jeśli połączeń zasilających jest więcej (np. sterowanych z GPIO, jak w moim układzie) to diody podłączam takim kolorem przewodu, jakie światło emituje dioda – np. niebieska dioda = niebieski przewód. Dodatkowo przyciski podłączam zawsze przewodem pomarańczowym lub brązowym. Układając sobie w głowie taki schemat połączeń oznaczonych kolorami wystarczy mi jedno zerkniecie na piny Raspberry i od razu wiem, który przewód za co odpowiada. Całość mojego układu wygląda jak poniżej.
To trzeba złożyć
To teraz trochę więcej o układzie, który złożyłem. Układ składa się z dwóch systemów – diod zielonej, żółtej i czerwonej sterowanych przyciskiem pierwszym oraz diody niebieskiej sterowanej przyciskiem drugim. Oczywiście nic nie stoi na przeszkodzie, żeby dowolnie wymieszać zależność, w końcu wszystko jest podłączone do jednego systemu. Chodzi mi tutaj tylko i wyłącznie o samo rozdzielenie logiczne funkcji. Diody pracują z napięciem znamionowym 2V, co oznacza, że musimy podłączyć je poprzez odpowiedni rezystor. Wszystko to, aby uniknąć podania bezpośredniego napięcia z pinu GPIO, czyli 3,3V. W tym przypadku odpowiedni będzie każdy rezystor pomiędzy 300 Ohm a 1200 Ohm. Ja zdecydowałem się na rezystor 1 kOhm (1000 Ohm).
Przechodzimy teraz do samego podłączenia przewodów do Raspberry. Do podłączenia używam przewodów, które w zależności od potrzeby posiadają na końcach piny lub gniazda. Wpinając się z przewodami w płytkę stykowa potrzebujemy pinu, natomiast podpinając się do Raspberry potrzebujemy gniazda. Przechodząc płynnie do “malinki” podpinamy kolejno przewody do pinów:
Dioda Zielona – Przewód Zielony – Pin 40
Dioda Żółta – Przewód Żółty – Pin 38
Dioda Czerwona – Przewód Czerwony – Pin 36
Dioda Niebieska – Przewód Niebieski – Pin 37
Przycisk 1 – Przewód Brązowy – Pin 35
Przycisk 2 – Przewód Pomarańczowy – Pin 33
Masa (-) – Przewód Czarny – Pin 39
Całość powinna wyglądać jak na zdjęciu poniżej.
Program do kodowania – Mu
Widziałem już wiele programów do pisania skryptów na Raspberry, ale niezmiennie moim ulubieńcem jest Mu. Posiada bardzo przejrzyste menu (duże przyciski funkcyjne) i koloruje składnię kodu, co w zupełności wystarcza do stworzenia dowolnego programu wykorzystującego możliwości Raspberry Pi, szybkie zdebugowanie go i uruchomienie. Jeśli w Twoim systemie nie ma jeszcze Mu to można zainstalować go wpisując w Terminalu dwa polecenia:
sudo apt update
sudo apt install mu-editor
Program ma dwie sekcje – sekcja Menu głównego pozwalająca na zarządzanie plikami i funkcjami oraz sekcja Kodu, gdzie można wpisywać treść nowego programu. Po wpisaniu treści skryptu możliwe jest zdebugowanie go (przycisk z robaczkiem), a następnie uruchomienie (przycisk imitujący funkcję Play w odtwarzaczach muzyki).
Kod – Zielona dioda
Zestaw złożony, wszystko podłączone? Czas na kod! Na początku zacznijmy od prostego przykładu, w którym po wciśnięciu przycisku zaświeci zielona dioda, a następnie po wyznaczonym czasie dioda zgaśnie. Pętla będzie wykonywała się tak długo, dopóki nie przerwiemy działania programu. W tym celu musimy skorzystać z bibliotek gpiozero oraz time. Następnie musimy zadeklarować na których wyjściach GPIO mamy diodę i przycisk, oraz stworzyć samą pętlę, która będzie oczekiwała na wciśnięcie przycisku, po czym włączy diodę, odczeka dwie sekundy i zgasi diodę. Kod powinien wyglądać jak poniżej:
from gpiozero import LED, Button
from time import sleep
led_r = LED(21)
button = Button(19)
while True:
button.wait_for_press()
led_r.on()
sleep(2)
led_r.off()
Po uruchomieniu układu i wciśnięciu przycisku powinniśmy otrzymać wynik w postaci zielonej diody LED świecącej się przez dwie sekundy. Jeśli chcesz zmienić czas świecenia diody wystarczy, że zmienisz parametr liczbowy w nawiasie przy poleceniu sleep wewnątrz pętli while.
Kod – Trzy diody na przemian
Kolejne ćwiczenie to dopisanie do kodu sekwencji, która zapali na sekundę każdą diodę w kolejności zielona – żółta – czerwona. W tym celu dodaję do programu informację o tym, na jakich wyjściach GPIO mam podpięte diody LED, oraz rozpisuję zapalanie i gaszenie diod LED w odpowiedniej sekwencji.
from gpiozero import LED, Button
from time import sleep
led_g = LED(21)
led_y = LED(20)
led_r = LED(16)
led_b = LED(26)
button_1 = Button(19)
while True:
button_1.wait_for_press()
led_g.on()
sleep(1)
led_g.off()
led_y.on()
sleep(1)
led_y.off()
led_r.on()
sleep(1)
led_r.off()
W tym momencie po naciśnięciu przycisku zapala się zielona dioda, po sekundzie zielona gaśnie i zapala się żółta, a po kolejnej sekundzie żółta gaśnie i zapala się czerwona. Na koniec czerwona dioda gaśnie i program oczekuje na kolejne wciśnięcie przycisku.
Kod – Sygnalizacja
Mając podłączone LED’y w takiej kolejności nie sposób nie spróbować zaprogramować sygnalizacji świetlnej. Program domyślnie uruchamia diodę zieloną, która czeka na przycisk. Po naciśnięciu przycisku program czeka chwile, a następnie wyzwala program sygnalizacji. Światła zmieniają się na żółte, następnie czerwone, i przez żółte z czerwonym wraca do zielonego czekając na kolejne wciśnięcie przycisku.
from gpiozero import LED, Button
from time import sleep
led_g = LED(21)
led_y = LED(20)
led_r = LED(16)
led_b = LED(26)
button_1 = Button(19)
while True:
led_g.on()
button_1.wait_for_press()
sleep(2)
led_g.off()
led_y.on()
sleep(2)
led_y.off()
led_r.on()
sleep(5)
led_y.on()
sleep(2)
led_r.off()
led_y.off()
Kod – Sygnalizacja plus niebieska dioda
W kolejnym ćwiczeniu zadałem sobie pytanie, czy możliwe jest niezależne obsługiwanie więcej niż jednej funkcji w pętli. Okazuje się, że tak, jednak tutaj dochodzą tak zwane wątki. Dzielę więc kod na wątek sygnalizacji wyzwalanej pierwszym przyciskiem i dodaję do programu drugi wątek, który po wciśnięciu drugiego przycisku zapala niebieską diodę. Układy działają niezależnie od siebie, więc mogę zapalać niebieską diodę w dowolnym momencie – niezależnie od tego, czy któreś światło sygnalizacji świeci, czy nie.
from gpiozero import LED, Button
from time import sleep
import threading
led_g = LED(21)
led_y = LED(20)
led_r = LED(16)
led_b = LED(26)
button_1 = Button(19)
button_2 = Button(13)
def handle_blue_led():
while True:
if button_2.is_pressed:
led_b.on()
else:
led_b.off()
sleep(0.05)
blue_led_thread = threading.Thread(target=handle_blue_led)
blue_led_thread.daemon = True
blue_led_thread.start()
while True:
led_g.on()
button_1.wait_for_press()
sleep(2)
led_g.off()
led_y.on()
sleep(2)
led_y.off()
led_r.on()
sleep(5)
led_y.on()
sleep(2)
led_r.off()
led_y.off()
Nie da się ukryć, że ten kod nie należy już do najłatwiejszych. Trzeba tutaj skorzystać z biblioteko threading, umieć uruchomić daemona czekającego na odpowiednie polecenia i wszystko porozmieszczać w odpowiednich pętlach. Oczywiście wszystko jest do zrobienia i wystarczy odrobina skupienia.
Podsumowanie
Programowanie na Raspberry Pi z wykorzystaniem GPIO jest bardzo proste i przystępne. Wystarczy wysterować odpowiednimi pinami i ułożyć właściwą sekwencję zachowania po wciśnięciu przycisku. Już niedługo na Strefie przedstawię kompletny poradnik krok po kroku pokazujący w jaki sposób dzięki małemu silnikowi, akumulatorom, kilku przekaźnikom i Raspberry Pico zmienić ręcznie regulowany stół domowy w automatyczny stół sterowany ze smartfona.
