Cześć, w dzisiejszej części pokażemy jak obsługiwać PWM w środowisku Lua. Do dzieła ! ;)
Spis treści:
- Co to jest PWM ?
- Podstawowe funkcje dla PWM w Lua
- Pierwszy program: Ustawiamy PWM
- Drugi program sterujemy wartością PWM
1. Co to jest PWM ?
PWM, czyli Pulse Width Modulation to Modulacja szerokości impulsu, wykorzystywana jest w większości urządzeń, które używasz na co dzień lecz co to jest ? Już wyjaśniam. Załóżmy, że mamy zwykłą lampkę z przełącznikiem. W momencie zamknięcia obwodu przyciskiem, do lampki dostarczana jest maksymalna moc z sieci jaką może pobrać ta lampka, natomiast, gdybyśmy ten przyciski w równych odstępach czasu włączali i wyłączali z dostatecznie dużą częstotliwością, to byśmy zauważyli, że nasza lampka świeci słabiej, niż przy stale włączonym przycisku. W zależności od częstotliwości przełączania przycisku moglibyśmy otrzymać różne poziomy świecenia się lampki. W taki właśnie sposób działa PWM, gdzie ten impuls jest stanem „włączenia” (w tym przypadku lampki), a szerokość to jest właśnie ten regulowany czas, czy też częstotliwość. Animacją poniżej postaram się zilustrować jak to wygląda w praktyce. Dla ułatwienia zrozumienia tej część, wszelkie wartości będą dostosowane do ESP8266:
Podstawowe parametry dla PWM:
- Wypełnienie (Duty Cycle): jest to wartość wyrażona procentowo, która określa czas występowania stanu wysokiego podczas jednego okresu
- Częstotliwość, a tak właściwie to szybkość działania, jest parametrem oznaczającym częstotliwość pracy PWM. Dla ESP8266 jest regulowana w zakresie od 1Hz do 1000Hz, czyli to oznacza, że ESP8266 jest w stanie włączać i wyłączać 1000 razy na sekundę. Zatem okres wynosi 1 milisekundy.
- Czas trwania impulsu to czas trwania stanu wysokiego w jednym okresie. Czyli 1/1000Hz = 0.001s
Tyle części teoretycznej. Czas teraz przejść do wykorzystania PWM w ESP8266.
Rejestr przetwarzający sygnał PWM w ESP8266 jest 10-bitowy. Oznacza to, że mamy 1024 poziomów regulowania. Skąd ta liczba ? już pokazuję:
Każdy bit posiada swoją wagę idąc od prawej do lewej strony, waga bitu wzrasta dwukrotnie. Po zsumowaniu tych wszystkich wag otrzymamy 1023 poziomów kwantyzacji od 1 do 1023. Natomiast PWM posiada 1024 poziomów kwantyzacji. Ten 1024. poziom to zero. Więc regulacja naszego PWM odbywa się w zakresie 0 – 1023 co w efekcie daje nam 1024 poziomów kwantyzacji. Im rejestr większy, tzn. „ma więcej bitów” tym mamy więcej poziomów = większa dokładność zapisu.
Nie mniej jednak musimy pamiętać, że piny w ESP8266 są wyzwalane stanem niskim więc poziom zerowy będzie oznaczać 100% wypełnienie, a poziom 1023, wypełnienie 0%
2.Podstawowe funkcje dla PWM w Lua
Pierwsza funkcja, która powinna nam się nasuwać to taka, przy pomocy, której ustawimy parametry PWM. Funkcja ta nazwa się pwm.setup()
|
1 2 3 4 5 |
pwm.setup(pin, czestotliwosc, wypelnienie) //pin - piny PWM (sprawdz dla swojej wersji ESP, jak są rozpisanie) //czestotliwosc - ustawiamy czestotliosc PWM w zakresie 1-1000 [Hz] //wypełnienie- ustawiamy jakie wypełenie chcemy na pinie w zakresie 0-1023 |
Przy tej funkcji należy zapamiętać, że poziom wypełnienia zero oznacza 100% wypełnienia, a 1023 0% wypełnienia. W jednym programie możemy wykorzystać maksymalnie 6 pinów dla PWM
Po ustawieniu parametrów PWM, należy je uruchomić. W tym celu posłużymy się funkcją pwm.start()
|
1 2 3 |
pwm.start(pin) //pin - pin, na którym mamy skonfigurowany PWM |
W modułach ESP fajne jest to, że częstotliwość PWM nie jest stała i można ją w zależności od potrzeb zmieniać w wybranym przez nas momencie programu. by tego dokonać, wywołujemy funkcję pwm.setclock():
|
1 2 3 4 |
pwm.setclock(pin, czestotliwosc) //pin- skonfigurowany pin PWM //czestotliwosc- zakres 1-1000 [Hz] |
Wadą tej funkcji jest to, że automatycznie zmienia częstotliwości, dla pozostałych pinów PWM.
Co by to było za PWM, gdzie jego wartość byłaby wpisana raz na sztywno do programu bez możliwości zmian w trakcie wykonywania programu. Do zmiany wypełnienia sygnału używamy funkcji pwm.setduty():
|
1 2 3 4 |
pwm.setduty(pin, wypelnienie) //pin- skonfigurowany pin PWM //wypelnienie- ustawiamy na danym pinie w zakresie 0-1023 |
ESP8266 pozwala nam jeszcze na wstrzymanie sygnału PWM przy pomocy funkcji pwm.pause();
|
1 2 3 |
pwm.stop(pin) //pin- skonfigurowany pin PWM |
Możemy również kompletnie wyłączyć tryb PWM na danym pinie:
|
1 2 3 |
pwm.close(pin) //pin- skonfigurowany pin PWM |
Pozostały nam jeszcze dwie funkcje, które zwracają wartości wypełnienia i częstotliwości i są to odpowiednio:
|
1 2 3 |
pwm.getduty(pin) //pin- skonfigurowany pin PWM |
|
1 2 3 |
pwm.getclock(pin) //pin- skonfigurowany pin PWM |
3. Pierwszy program: Ustawiamy PWM
Jak można się domyśleć to pierwszy program nie będzie trudny i będzie się składać z paru linijek:
Schemat:
Program:
|
1 2 3 4 5 6 7 8 9 |
pwm.setup(1,1000,0) --wypelnienie 100% pwm.setup(2,1000,256) --wypelnienie 75% pwm.setup(3,1000,512) --wypelnienie 50% pwm.setup(4,1000,768) --wypelnienie 25% pwm.start(1) --uruchom PWM na pinie 1 pwm.start(2) --uruchom PWM na pinie 2 pwm.start(3) --uruchom PWM na pinie 3 pwm.start(4) --uruchom PWM na pinie 4 |
Program jest bardzo prosty, ale przypomnę. W funkcji pwm.setup() ustawiamy kolejno: pin, częstotliwość, wypełnienie. Następnie przy pomocy funkcji pwm.start() uruchamiamy PWM na wybranych pinach. Po wgraniu programu powinniśmy uzyskać taki efekt:
Idąc od lewej do prawej strony to mamy 100%, 75%, 50%, 25%. Program jak widać jest bardzo prosty i nie ma większej potrzeby jego dalszego tłumaczenia :)
4.Drugi program sterujemy wartością PWM
Drugi program będzie „o wiele” trudniejszy w porównaniu do pierwszego. Poniższy program będzie działać następująco: Jeżeli przycisk nie będzie wciśnięty to wypełnienie PWM będzie się zwiększać o 50 jednostek, a jak przycisk zostanie wciśnięty to PWM będzie się zwiększać co 100 jednostek (dwa razy szybciej).
Schemat:
Program:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
gpio.mode(3, gpio.INPUT) --pin 3 jako wejście poziom = 1020 --zmienna odpowiadająca za regulację PWM krok = 0 --zmienna odpowiadająca za to, o ile wypełnienie PWM ma być zmniejszane pwm.setup(1, 1000, 1020) --ustawiamy pin 1 jako PWM o zadanej częstotliwości --i wstepnym wypelnieniu function ledPWM() --rozpoczynamy funkcję krok = 50 pwm.setduty(1, poziom) --ustaw wypełnienie równej zmiennej poziom pwm.start(1) --włącz PWM poziom = poziom - krok --zmniejsz zmienną poziom o 50 if gpio.read(3) == 0 then --jeżeli przycisk został wciśnięty krok = 100 pwm.setduty(1, poziom) --ustaw wypełnienie równej zmiennej poziom pwm.start(1) --włącz PWM poziom = poziom - krok --zmniejsz zmienną poziom o 100 end --zamknij warunek wciśnięcia przycisku if (poziom <= 0) then --jeżeli wartość zmiennej poziom jest mniejsza, równa 0 poziom = 1020 --przypisz zmiennej wartość 1020 end --zamknij warunek end --zamknij funckję ledPWM tmr.alarm(0, 50, tmr.ALARM_AUTO, ledPWM) --wykonuj funkcję ledPWM co 50ms |
Po wgraniu programu powinniśmy uzyskać taki efekt:
Podsumowanie
Po tej części kursu powinieneś umieć:
- podstawowe funkcje dla obsługi PWM
- ustawić wypełnienie sygnału PWM
- płynnie zmieniać wartość wypełnienia sygnału PWM w trakcie wykonywania programu
Jeżeli chcesz być informowany na bieżąco o nowych częściach kursu to kliknij „Lubię to!” bądź subskrybuj naszą stronę, aby otrzymywać na adres e-mail nowości ze strony. Jeżeli masz jakieś pytania to śmiało zadawaj je na forum ; )