PyBoard i MicroPython w przykładach - skryptujemy elektronikę
Kontynuujemy naszą przygodę z PyBoard i MicroPythonem. W tym artykule pokażę jak skryptować różne części elektroniczne i elektryczne jak serwa, silniki, przekaźniki, urządzenia z interfejsem I2C i inne.
Zaprezentowane poniżej klasy dostępne są też w repozytorium na githubie.
Serwo o pracy ciągłej
Większość serwomechanizmów posiada ograniczony zakres ruchu, np. 180 stopni. Są też jednak serwomechanizmy o pracy ciągłej. Modulacja impulsowa mówi
serwomechanizmowi jak szybko i w którym kierunku ma się poruszać (a nie na jaką pozycję).
Podłączając serwo o pracy ciągłej do pyboard tak jak w poprzednim artykule wykorzystujemy klasę Servo by sterować serwem, np.:
import pyb
servo = pyb.Servo(1)
servo.speed(10)
Metoda speed nie ustawia kąta jak metoda angle, ale wpływa na prędkość poruszania się silnika w serwomechanizmie (-100 do 100).
Silnik krokowy
Sterownik silników krokowych ULN2003 posiada cztery piny do kontroli pracy silnika. Żeby przesunąć silnik o jeden krok należy ustawić odpowiednie piny w stan wysoki (kolejny zestaw pinów z sekwencji np. 8 kroków). Inne kontrolery mogą nieco się różnić np. sekwencją, ale ogólna zasada jest taka sama.
W przypadku MicroPythona i pyboard do dyspozycji mamy wiele pinów i wystarczy podłączyć kontroler silników do czterech z nich i skonfigurować te piny jako cyfrowe wyjście, po czym można ustawiać je w stan wysoki i niski. Oto klasa obsługująca cały proces:
import pyb
class Stepper:
"""
Handles common 4-pin ULN2003 stepper motor controllers
"""
steps = [
[1],
[1, 2],
[2],
[2, 3],
[3],
[3, 4],
[4],
[1, 4]
]
step_delay_ms = 5
def __init__(self, pins):
self.pins = [pyb.Pin(pin, pyb.Pin.OUT_PP) for pin in pins]
self.current_step = 0
def do_step(self):
self._low_on_all()
self._high_on_step_pins()
self._record_step()
pyb.delay(self.step_delay_ms)
def _low_on_all(self):
for pin in self.pins:
pin.low()
def _high_on_step_pins(self):
high_pins = self.steps[self.current_step]
for pin_number in high_pins:
self.pins[pin_number - 1].high()
def _record_step(self):
self.current_step += 1
if self.current_step == len(self.steps):
self.current_step = 0
from stepper_motor import *
motor = Stepper(['X2', 'X3', 'X4', 'X5'])
for _ in range(2000):
motor.do_step()
Metoda do_step wykonuje całą pracę. Ustawia piny w stan niski, a później ustawia w stan wysoki piny obecnego kroku i przekręca licznik kroków. W konstruktorze piny podane jako lista łańcuchów zamieniane są na listę obiektów - pinów skonfigurowanych jako cyfrowe wyjście. Po odpaleniu pętli silnik wykona 2000 kroków. Żeby silnik działał w przeciwnym kierunku należy odwrócić kolejność kroków (motor.steps.reverse()).
Silniki DC
Do sterowania prędkością i kierunkiem obrotu silnika DC stosuje się układy z mostkiem H. W najprostszej postaci będzie to mała płytka z przylutowanym scalakiem. Do testów użyłem płytki ze sterownikiem DRV8833, który wcześniej testowałem z PyMCU. Schemat płytki wygląda następująco:
Po jednej stronie podłączamy GND oraz dwa piny PWM, po drugiej zasilanie silnika oraz sam silnik (4 piny). Jako że do testów użyłem mały silniczek o małej mocy zasilanie szło z pinów 5V pyboard (a GND było wspólne):
Jeżeli pin X1 (Servo 1) jest podłączony jako BIN1, to wystarczy ustawić długość impulsu by kontrolować prędkość obrotów, np:
s = pyb.Servo(1)
s.pulse_width(2500)
...
s.pulse_width(0)
W moim przypadku znaczenie miały wartości między 2000 a 2600. Przy niższych silnik nadal się obracał, ale bardzo powoli. Klasa Servo jak na razie nie pozwala wyłączyć
modulacji. Żeby wymusić wyłączenie pinu należy wykonać:
pyb.Pin('X1', pyb.Pin.OUT_PP).low()
W nowszej wersji firmware pyboard klasa Timer ma dostęp do czystego PWM co powinno pozwolić sterować modulacją aż do zera.
Przekaźniki
Przekaźniki to podstawa automatyzacji. Mogą włączać lub wyłączać zasilanie urządzeń, w tym tych zasilanych z sieci 230V. Na rynku dostępnych jest wiele przekaźników cewkowych, w tym na ładnych i poręcznych płytkach. Oznaczone są jako kompatybilne z Arduino
i do pracy wymagają 5V (czasami 12V). Wiele płytek Arduino stosuje właśnie 5V na pinach, dzięki czemu mogą przełączać 5V przekaźniki. Pyboard jak i Raspberry Pi używają 3.3V na pinach GPIO. Mimo 5V zasilania nie udało mi się przełączyć przekaźnika na płytce z wydzielonym zasilaniem cewki. Dioda LED zapala się, ale cewka nie przełącza zasilania. Jeżeli uda Ci się znaleźć płytkę kompatybilną z 3.3V na pinach sterujących to powinno działać. Jak nie - trzeba przełączać 5V poprzez np. tranzystor.
Płytka z przekaźnikie, którą użyłem do testów posiada cztery piny: dwa na zasilanie i dwa na sterowanie (jeden musi być w stanie niski, drugi w wysokim). Przełączenie przekaźnika z poziomu pyboard jest proste, np:
pin_high = pyb.Pin('X2', pyb.Pin.OUT_PP)
pin_low = pyb.Pin('X3', pyb.Pin.OUT_PP)
pin_low.low()
pin_high.high()
Bezproblemowo powinno działać przełączanie przełączników półprzewodnikowych, czy przekaźników SSR (o ile obsługują niskie napięcia sterowania, co w ich przypadku jest raczej dość powszechne).
Przekaźnik półprzewodnikowy LAA110
Z tym przekaźnikiem sterowałem kamerką cyfrowo przyciskając przyciski w jakie została wyposażona.
Pyboard radzi sobie z tym przekaźnikiem bez problemów. Wystarczy ustawić pin w stan wysoki i kontrolowany obwód zostanie zamknięty. Od strony mikrokontrolera potrzebujemy pinu cyfrowego (np. X1) oraz GND. Od strony kontrolowanej jakiś układ, który zostanie zamknięty gdy pin ustawimy na stan wysoki.
p = pyb.Pin('X1', pyb.Pin.OUT_PP)
p.high()
Zdalnie sterowany moduł XD-YK04
W chińskich sklepach (jak i polskich) coraz częściej można spotkać zestawy pilot + płytka z odbiornikiem. Prosty gotowy zestaw do automatyzacji. W zależności od zestawu pilot może ustawiać piny w stan wysoki albo przełączać przekaźnik. Omawiany model robi to pierwsze. Na pilocie ma cztery przyciski, które po wciśnięciu ustawiają w stan wysoki jeden z czterech pinów cyfrowych na płytce. Żeby pin spadł do wartości niskiej trzeba... wcisnąć inny przycisk. Pomocny może być pin VT, który jest w stanie wysokim tylko wtedy, gdy wciśnięty jest jakiś przycisk.
Zestaw z przekaźnikami może działać nawet i bez mikrokontrolera. Zestaw taki jak ten musi współpracować z innym układem, który wykorzysta informację o zmianie stanu pinów. Jeżeli podłączymy wyjście D0 do pinu X1 na pyboard to odczytanie stanu jest bardzo proste:
x = pyb.Pin('X1', pyb.Pin.IN)
x.value()
Czujnik zbliżeniowy
Tak samo odczytamy stan czujnika zbliżeniowego, którego stan przejdzie w stan niski jeżeli będzie dostatecznie blisko przeszkody. Czerwony pin to VCC, zielony to GND a żółty to pin sygnałowy, którego stan musimy odczytać:
x = pyb.Pin('X1', pyb.Pin.IN)
x.value()
Ultradźwiękowy czujnik odległości
Czujniki odległości tego typu popularne są w robotyce. Służą do wykrywania i omijania przeszkód (choć można też stosować prostsze czujniki zbliżeniowe). Czujniki ultradźwiękowe wysyłają impuls i nasłuchują kiedy powróci. Im więcej czasu upłynie do powrotu echa tym większą odległość impuls przebył.
Dla MicroPythona mamy już gotową bibliotekę. Wystarczy zaimportować klasę, podać w konstruktorze nazwy pinów podłączonych do pinów Trig
i Echo
i gotowe. Metoda distance_in_cm dokona pomiaru i zwróci wynik.
BlinkM - sterowanie diodą LED po I2C
Pisałem o BlinkM wcześniej przy okazji PyMCU. Prosty układ pozwalający sterować wielokolorową diodą LED poprzez I2C. Czasami bywa oporna w użyciu, ale pozwala sprawdzić działanie komunikacji I2C.
Do komunikacji poprzez I2C wykorzystywane są dwa piny. Na pyboard są dwa interfejsy I2C po bokach płytki SDA1/SCL1 i SDA2/SCL2. W zależności gdzie podepniemy BlinkM lub inne urządzenie używające tego samego mechanizmu komunikacji trzeba aktywować odpowiedni interfejs 1 lub 2. Klasa I2C ma przydatną metodę scan, która wykrywa urządzenia oraz is_ready pozwalającą sprawdzić czy urządzenie jest już gotowe.
W przypadku BlinkM możemy nieco pobawić się kolorami:
from pyb import I2C
i2c = I2C(2, I2C.MASTER)
i2c.send('c x00 0x00 0xff', 0x09)
0x09 to domyślny adres BlinkM, a dane które wysyłamy to według dokumentacji zaświecić jasnoniebiesko
.
Pehametr MinipH
Kolejnym urządzeniem wykorzystującym komunikację po I2C jest pehametr minipH. Tak jak w przypadku pyMCU obsługa jest dość prosta. Trzeba odczytać dwa bajty. Pierwszy to cyfra przed, a drugi to cyfra po przecinku pomiaru (np. 4,15):
from pyb import I2C
i2c = I2C(2, I2C.MASTER)
ord(i2c.recv(2, 0x4D)[0:1])
ord(i2c.recv(2, 0x4D)[1:])
