Funkcja delay (do wprowadzania opóźnień) to jedna z pierwszych rzeczy, której uczymy się podczas poznawania Arduino. Jej działanie może jednak generować wiele kłopotów.
Na szczęście z pomocą przychodzi nam bardziej rozbudowane rozwiązanie bazujące na funkcji millis. Dzięki niej Arduino może wykonywać kilka zadań "jednocześnie".
Miganie diodą, to najpopularniejszy przykład, od którego zaczyna się naukę Arduino. Najczęściej wygląda on następująco:
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
#define LED1pin 3
voidsetup(){
//Pin, do którego podłączono diodę jako wyjście
pinMode(LED1pin,OUTPUT);
}
voidloop(){
digitalWrite(LED1pin,HIGH);//Włącz diodę
delay(1000);//Odczekaj 1000 ms
digitalWrite(LED1pin,LOW);//Wyłącz diodę
delay(1000);//Odczekaj 1000 ms
}
Krótka zawartość pętli loop() wystarcza do tego, aby migać diodą. Uwaga: Przejście od ustawienia odpowiedniego stanu na wyjściu do delay() jest błyskawiczne, na poniższej animacji zajmuje ono "drobną chwilę", aby było widać, co się dzieje:
Zawartość pętli loop() - miganie jedną diodą.
Wiele osób od razu wpada na pomysł migania dwiema diodami (i to z różną częstotliwością). Tym samym dochodzą do następującego programu:
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#define LED1pin 3
#define LED2pin 4
voidsetup(){
//Pin, do którego podłączono diodę jako wyjście
pinMode(LED1pin,OUTPUT);
pinMode(LED2pin,OUTPUT);
}
voidloop(){
digitalWrite(LED1pin,HIGH);//Włącz diodę
delay(1000);//Odczekaj 1000 ms
digitalWrite(LED1pin,LOW);//Wyłącz diodę
delay(1000);//Odczekaj 1000 ms
digitalWrite(LED2pin,HIGH);//Włącz diodę
delay(500);//Odczekaj 500 ms
digitalWrite(LED2pin,LOW);//Wyłącz diodę
delay(500);//Odczekaj 500 ms
}
Działanie tego kodu odbiega od tego, czego spodziewa się zdecydowana większość osób. Trzeba pamiętać, że Arduino wykonuje wszystkie instrukcje z pętli loop() linijka, po linijce. W danym momencie mikroprocesor może zająć się tylko jedną operacją.
Dodatkowo trzeba pamiętać, że funkcja opóźniająca delay() zupełnie zatrzymuje działanie programu!
Zamiast oczekiwanego, równoległego migania diod otrzymujemy coś dziwnego:
Działanie programu, który pozornie miał migać dwiema diodami (równolegle).
Początkowo może to budzić zdziwienie. W końcu komputery, którymi się posługujemy wykonują masę różnych operacji jednocześnie (nawet te, które mają procesor z jednym rdzeniem). Tak naprawdę procesor z PC nie jest w tym przypadku lepszy od mikrokontrolera z Arduino. On też wykonuje w danej chwili tylko jedną operację. Wielozadaniowość komputerów polega na tym, że przełączają się bardzo szybko między różnymi zadaniami (tysiące razy na sekundę). Z punktu widzenia człowieka jest to niezauważalne.
Efekt jest analogiczny do multipleksowania wyświetlaczy 7-seg. Tam też świeci się jednocześnie tylko 1 cyfra, całą resztę zawdzięczamy bezwładności naszych oczu.
Kiedy można korzystać z delay()?
Funkcja opóźniająca delay() jest niezwykle prosta i wygodna. Niestety każde jej wystąpienie blokuje cały program. W przypadku prostych przykładów nie stanowi to dużego problemu. Przy dużych projektach jest to problematyczne. Korzystanie z tej funkcji może nieść za sobą trudne do zidentyfikowania błędy w działaniu programów (np. chwilowe problemy z pewnymi bibliotekami).
Z funkcji delay() można korzystać, tylko jeśli cały czas mamy świadomość, że jej działanie polega na "zamrożeniu" wykonywania całego programu!
Co zamiast delay()?
Istnieje wiele bibliotek, które pozwalają na wprowadzanie "magicznych", nieblokujących opóźnień. Oczywiście życie należy sobie ułatwiać, więc można sięgać po takie gotowce. Jednak wiele osób zupełnie nie wie jak działają te opóźnienia, co w efekcie prowadzi do kolejnych, jeszcze dziwniejszych błędów.
Dlatego na początek warto zacząć od przestawienia sposobu myślenia i rozpoczęcia pisania programów w innych sposób. Stąd najlepiej zacząć od zera, bez gotowych bibliotek...
Stoper wbudowany w Arduino - millis()!
W Arduino znajdziemy funkcję millis(). Jej działanie najlepiej przyrównać do stopera, który rusza w momencie uruchomienia Arduino. Funkcja ta zwraca liczbę milisekund, która upłynęła od podłączenia płytki do prądu. Nie musimy uruchamiać tego "stopera", Arduino zrobi to za nas. Działa on zawsze i w każdym programie. Liczenie zrealizowane jest sprzętowo, czyli z użyciem liczników (timerów). Wskazań millis() nie da się przypadkiem zafałszować.
Arduino posiada wbudowany stoper!
Nawet funkcja delay() nie da rady zatrzymać wewnętrznego stopera, którego wynik możemy odczytać z użyciem millis()!
Łączenie obu wspomnianych funkcji (delay i millis) mija się z celem i może generować pewne problemy, jednak warto wiedzieć, że jest to możliwe - jeszcze do tego wrócimy.
Jak wykorzystać millis()?
Funkcja ta nie przyjmuje żadnego argumentu. Po prostu zwraca liczbę milisekund, która upłynęła od momentu uruchomienia Arduino. Każda sekunda, to 1000 ms, więc zwracana wartość będzie rosła bardzo szybko. Trzeba zadbać o to, aby zmienna, do której zapisujemy informację była odpowiednio pojemna. W tym celu korzystamy z typu danych unsigned long, np.:
Arduino
1
unsignedlongaktualnyCzas=millis();
Sprawdźmy teraz, jak ten stoper działa w praktyce. Możemy zacząć od wysyłania aktualnego czasu do komputera przez UART. Oczywiście nie możemy wysyłać go bez żadnych przerw, bo zapchamy bufor danych i wszystko się zawiesi.
Nie umiemy jeszcze zatrzymywać programu w "sprytny sposób", więc skorzystajmy ostatni raz z "nieszczęsnego" delay():
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
unsignedlongaktualnyCzas=0;
voidsetup(){
Serial.begin(9600);
}
voidloop(){
//Pobierz liczbe milisekund od startu
aktualnyCzas=millis();
//Wyslij do PC
Serial.println(aktualnyCzas);
//Odczekaj 1000 ms
delay(1000);
}
Po uruchomieniu programu w monitorze portu szeregowego, co około 1 sekundę, pojawi się liczba milisekund, która upłynęła od startu Arduino:
Efekt działania programu.
Nie bez powodu napisałem "co około 1 sekundę", jak widać pojawiają się drobne nieregularności o +/- 1 milisekundę. Eksperyment ten pokazał przy okazji kolejną wadę delay() liczenie czasu tą metodą nie jest dokładne. Oczywiście tutaj 1 milisekunda wiele nie zmienia. Jednak, jeśli układ miałby działać cały czas (np. jako zegar), to z czasem rozbieżności byłyby znaczne.
Gotowe zestawy do kursów Forbota
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Części do wykonania ćwiczeć z kursu Arduino (poziom 2) dostępne są w formie gotowych zestawów! W komplecie m.in. diody programowalne, termometry analogowe i cyfrowe, wyświetlacze 7-segmentowe oraz czujnik ruchu (PIR).
Masz już zestaw? Zarejestruj go wykorzystując dołączony do niego kod. Szczegóły »
Jakie jest ograniczenie funkcji millis()?
Jak było widać na wcześniejszej animacji zwracana wartość rośnie szybko. Kiedyś licznik ten się przepełni (przekroczy swoją maksymalną wartość i wróci do zera). Na szczęście w tym przypadku przepełnienie nastąpi dopiero po 50 dniach pracy.
Oczywiście nie oznacza to, że należy resetować Arduino co 50 dni. Licznik się przepełni i zacznie pracować od początku. Jeśli program będzie napisany poprawnie, to wyzerowanie licznika nie wpłynie na jego działanie.
Dodatkowo warto pamiętać, że operacje na tak dużych liczbach (unsigned long) mogą prowadzić do pewnych błędów i przekłamań logicznych. Szczególnie, gdy spróbujemy wykonywać działania matematyczne z mniejszymi zmiennymi (np. typu int)!
Lepsza wersja odmierzania czasu
Wiemy już, że w Arduino wbudowany jest dokładny stoper. Pora wykorzystać go do generowania opóźnień. Stopera nie możemy zerować, nie będziemy też na niego w żaden sposób wpływać. Wystarczy, że będziemy "znać aktualny czas" względem startu Arduino.
Jak powinno wyglądać odmierzenie sekundy?
Sprawdzamy aktualny czas i go zapamiętujemy.
W każdym obiegu pętli sprawdzamy aktualny czas:
Jeśli różnica między czasem aktualny, a poprzednio zapamiętanym jest mniejsza od 1 sekundy, to znaczy, że pożądany czas jeszcze nie upłynął.
Jeśli różnica między czasem zapamiętanym i aktualnym wynosi 1 sekundę, to... właśnie tyle czasu minęło!
Kluczowe w takim podejściu jest to, że program cały czas "biega w kółko" i nigdzie się nie zatrzymuje. Jego działanie polega na ciągłym sprawdzaniu ile czasu minęło, a równocześnie może robić jeszcze inne rzeczy.
Pora przelać powyższy algorytm na kod:
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
unsignedlongaktualnyCzas=0;
unsignedlongzapamietanyCzas=0;
unsignedlongroznicaCzasu=0;
voidsetup(){
Serial.begin(9600);
}
voidloop(){
//Pobierz liczbe milisekund od startu
aktualnyCzas=millis();
roznicaCzasu=aktualnyCzas-zapamietanyCzas;
//Jeśli różnica wynosi ponad sekundę
if(roznicaCzasu>=1000UL){
//Zapamietaj aktualny czas
zapamietanyCzas=aktualnyCzas;
//Wyslij do PC
Serial.println(aktualnyCzas);
}
}
Zmienne przechowujące czas są typu unsigned long, więc aby uniknąć problemów z porównywaniem wartości, liczbę milisekund wpisano z dopiskiem UL (1000UL).
Dzięki temu kompilator będzie traktował 1000 jak wartość typu unsigned long.
Program sprawdza aktualny czas, liczy różnicę i jeśli jest ona większa lub równa 1000, to wiemy, że na pewno minęła sekunda. Dla bezpieczeństwa w warunku umieszczona jest nierówność, zamiast sztywnego "== 1000". Czasami może się zdarzyć, że przy bardzo rozbudowanych programach z jakiegoś powodu nie wstrzelimy się idealnie w 1000. Taka nierówność zapewnia nas, że program się "nie zatrzaśnie" i wejdziemy do warunku przy najbliższej okazji (np. 1001ms).
Wiemy, że minęła sekunda, gdy warunek zostanie spełniony. Dlatego zaraz na jego początku zapamiętujemy aktualny czas jako poprzedni (w którym był spełniony warunek). Kolejną sekundę będziemy liczyć od nowej wartości. W tym wypadku warunek będzie spełniony, gdy licznik millis wskaże kolejne 1000, 2000, 3000, 4000 itd.
Działanie programu w praktyce widoczne jest poniżej:
Od razu widać przewagę względem funkcji delay() tutaj wypisanie czasu wywoływane jest idealnie co sekundę!
Działanie drugiej wersji programu w praktyce.
Oczywiście zmienna roznicaCzasu jest zbędna (tutaj użyta dla większej czytelności). Równie dobrze można różnicę czasu policzyć bezpośrednio w warunku:
Arduino
1
2
//Jeśli różnica wynosi ponad sekundę
if(aktualnyCzas-zapamietanyCzas>=1000UL){
Miganie diody bez delay()
Teraz pora wykorzystać zdobyte informacje do migania diodą. Potrafimy odmierzyć dokładnie czas, więc pozostaje zmiana stanu diody w odpowiednim momencie. Podłączamy diodę do pinu numer 3 i działamy!
W przykładach korzystam z dwóch diod, aby były lepiej widoczne na zdjęciach. Jeśli nie masz diod z zestawu do kursu Arduino (poziom I) możesz wykorzystać diodę RGB z zestawu do poziomu II i sterować niezależnie każdym kolorem.
Aby układ działał poprawnie musimy zapamiętać aktualny stan diody (świeci/nie świeci). Wtedy w warunku, który będzie prawdziwy co sekundę będziemy mogli zmienić stan diody na przeciwny. Informację na ten temat przechowamy w zmiennej int stanLED1 = LOW;. Negację stanu diody możemy wykonać później następującą operacją: stanLED1 = !stanLED1;
LOW to stała, która oznacza 0, więc możemy ją przypisać do do zmiennej typu int.
Kod realizujący to zadanie widoczny jest poniżej:
Arduino
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
#define LED1 3
intstanLED1=LOW;
unsignedlongaktualnyCzas=0;
unsignedlongzapamietanyCzasLED1=0;
voidsetup(){
Serial.begin(9600);
pinMode(LED1,OUTPUT);
}
voidloop(){
//Pobierz liczbe milisekund od startu
aktualnyCzas=millis();
//Jeśli różnica wynosi ponad 1 sekundę
if(aktualnyCzas-zapamietanyCzasLED1>=1000UL){
//Zapamietaj aktualny czas
zapamietanyCzasLED1=aktualnyCzas;
//Zmieniamy stan diody na przeciwny
stanLED1=!stanLED1;
//ustawiamy nowy stan na diodzie
digitalWrite(LED1,stanLED1);
}
}
Po jego uruchomieniu dioda będzie migała zgodnie z pierwszym przykładem:
Miganie LED dzięki millis().
Negacja stanu w formie stanLED1 = !stanLED1; jest krótka i wygodna, ale nie musi być dla wszystkich intuicyjna (działa tylko dzięki odpowiedniej deklaracji stałych LOW i HIGH). Dla większego bezpieczeństwa można ten fragment kodu przerobić na taką postać:
Arduino
1
2
3
4
5
if(stanLED1==LOW){
stanLED1=HIGH;
}else{
stanLED1=LOW;
}
Wielozadaniowość na Arduino - miganie diodami
Pora rozbudować powyższy przykład, aby migać niezależnie dwiema diodami. Dopiero wtedy widoczna będzie przewaga tego rozwiązania. Tym razem chcemy, aby jedna dioda zmieniała swój stan częściej od drugiej:
Pętla loop() nadal będzie tylko jedna, a wszystkie zadania będą wykonywane linijka po linijce. Tym razem program będzie mógł niezależnie migać dwiema diodami.
Dwa "równoległe" zadania w jednej pętli loop.
Potrzebujemy dwie dodatkowe zmienne. W pierwszej przechowamy informację "kiedy" ostatni raz zmieniliśmy stan drugiej diody. Kolejna będzie trzymała informacje o jej stanie (świeci/nie świeci).
Cała reszta programu będzie analogiczna. Podłączamy drugą diodę do pinu nr 4 i ruszamy:
Arduino
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
31
32
33
34
35
36
37
38
39
40
#define LED1 3
#define LED2 4
intstanLED1=LOW;
intstanLED2=LOW;
unsignedlongaktualnyCzas=0;
unsignedlongzapamietanyCzasLED1=0;
unsignedlongzapamietanyCzasLED2=0;
voidsetup(){
Serial.begin(9600);
pinMode(LED1,OUTPUT);
pinMode(LED2,OUTPUT);
}
voidloop(){
//Pobierz liczbe milisekund od startu
aktualnyCzas=millis();
//Jeśli różnica wynosi ponad 1 sekundę
if(aktualnyCzas-zapamietanyCzasLED1>=1000UL){
//Zapamietaj aktualny czas
zapamietanyCzasLED1=aktualnyCzas;
//Zmieniamy stan diody na przeciwny
stanLED1=!stanLED1;
//ustawiamy nowy stan na diodzie
digitalWrite(LED1,stanLED1);
}
//Jeśli różnica wynosi ponad 0,5 sekundy
if(aktualnyCzas-zapamietanyCzasLED2>=500UL){
//Zapamietaj aktualny czas
zapamietanyCzasLED2=aktualnyCzas;
//Zmieniamy stan diody na przeciwny
stanLED2=!stanLED2;
//ustawiamy nowy stan na diodzie
digitalWrite(LED2,stanLED2);
}
}
Od teraz diody będą migały niezależnie! Jedna zmienia swój stan co sekundę, a druga co pół:
Dla łatwiejszego zauważenia różnicy można sobie
przysłonić na chwilę jedną diodę, a później drugą.
Niezależne miganie dwóch diod.
Zmiany będą widoczne najlepiej, jeśli wprowadzimy większe różnice. Niech pierwsza dioda zmienia stan co sekundę, a druga co 200 ms. Najlepiej dodać w tym celu dwie zmienne np.: miganieLED1 oraz miganieLED2.
Nowe zmienne deklarujemy jako unsigned long, dzięki czemu unikniemy ewentualnych problemów podczas porównywania dużych wartości. Oczywiście w tym przypadku nie trzeba dodawać już do liczby dopisku UL.
Jeszcze lepszy efekt uzyskamy, jeśli dodamy do programu przycisk. Standardowo, gdybyśmy korzystali z delay() to funkcja ta blokowałaby możliwość natychmiastowego sprawdzania wejść. Należałoby trzymać przycisk do czas, aż program dotrze do linijki sprawdzającej. Działoby się to rzadko, bo delay() zamrażałby program na kilka sekund.
Tutaj nie będzie takiego problemu, możemy zwyczajnie dodać warunek, który będzie działał natychmiast. Przykładowo niech wciśnięcie przycisku (pin 2) powoduje, że dioda LED1 będzie zmieniała swój stan znacznie szybciej (co 100 ms).
No i gotowe - prosta wielozadaniowość w praktyce! Migamy niezależnie diodami i błyskawicznie reagujemy na wciśnięcie przycisku. Oczywiście to tylko przykład. Zamiast zmiany stanu LEDów może się tam pojawić coś zupełnie innego.
Niezależne miganie diod + reakcja na wejście.
Inteligentne oświetlenie
Pierwotnie artykuł ten miał dotyczyć zupełnie czegoś innego (automatyki domowej), na koniec nawiąże więc do tego tematu w formie "bardzo luźnego" przykładu.
Coraz więcej osób interesuje się tematem inteligentnych budynków. Automatyczne podnoszące się rolety, zdalne sterowanie urządzeniami i oświetleniem, zdalny podgląd temperatury. Na rynku znaleźć można wiele gotowych rozwiązań dla automatyki domowej. Niestety większość z tych systemów łączy jedna, niepożądana cecha - wysoka cena.
Tym razem zajmiemy się tematem "inteligentnego oświetlenia", które będzie oświetlało schody. Wśród czytelników Forbota mamy również młodych adeptów elektroniki. W związku z tym nie będę poruszał tematów sterowanie normalnym oświetleniem (230V) - zajmiemy się bezpiecznym przykładem. Osoby zainteresowane implementacją bardziej rozbudowanych rozwiązań na pewno będą już samodzielnie potrafiły dostosować układ (korzystając z przekaźników).
Przykład prostej automatyzacji z Arduino
Podczas schodzenia wieczorem po schodach zawsze włączamy światło. Podobnie, gdy idziemy przez ciemny korytarz. Jest to idealne zadanie do zautomatyzowania! Tym razem załóżmy, że sytuacja wygląda następująco: tuż obok drzwi wejściowych znajdują się schody, do tego na dole i u góry mamy małe korytarze.
Załóżmy, że chcemy uruchamiać światło w momencie wykrycia ruchu. Gdy czujnik PIR zauważy kogoś w okolicy schodów uruchomi światło na 180 sekund lub do czasu otworzenia drzwi.
Przykładowe pomieszczenie, które warto zautomatyzować.
Wybór odpowiedniego oświetlenia
Tak jak wspomniałem wcześniej, zabawę z 230V zostawmy dla bardziej doświadczonych osób. Sterowanie normalnym oświetleniem najczęściej realizowane jest za pomocą przekaźników.
Druga, znacznie bezpieczniejsza opcja, to popularne ostatnio paski LEDowe. Najpopularniejsze moduły tego typu można bezpiecznie zasilać z mniejszego napięcia (np. 12V). Do Arduino można je podłączyć za pomocą przekaźnika lub tranzystora (MOSFET). Informacje na temat sterowania peryferiów przez MOSFET zostały opisane podczas #3 części kursu.
Warto pamiętać, że przekaźnik pozbawia nas możliwości sterowania PWM (regulacja jasności paska LED). Co więcej przy każdym włączeniu/wyłączeniu oświetlenie będzie słyszalny dźwięk przełączania przekaźnika.
Trzecia opcja, to wykorzystanie diod programowalnych, np. WS2812, którymi zajmowaliśmy się podczas drugiej części kursu. Rozwiązanie to będzie droższe od zwykłych diod, ale pozwoli na ciekawsze efekty.
Przykładowy moduł diod RGB.
W ramach testów (ja wybrałem taką opcję) można też podłączyć zwykłą diodę świecącą, która będzie symulowała oświetlenie. Diodę podłączyłem do pinu numer 4.
Czujniki
Pora dobrać czujniki. Oczywiście ruch wykryjemy czujnikiem typu PIR (pin numer 5). Natomiast do monitorowania drzwi najlepszy będzie kontaktron (pin numer 3). Wszystkie te czujniki były opisane w artykule o tworzeniu prostej centralki alarmowej.
Czujnik PIR montujemy w korytarzu u góry, a kontaktron na drzwiach:
W praktyce moja platforma testowa wyglądała następująco:
Symulacja opisanego przypadku.
Program wykorzystujący millis()
Przed wykonaniem ćwiczeń z tego odcinka włączenie światłą na 180 sekund robilibyśmy za pomocą delay(). Po wykryciu ruchu następowałoby włączenie oświetlenia i delay(180) w tym czasie układ byłby "zamrożony". Nie reagowałby na kontaktron ani na żadne inne czujniki...
Oczywiście w opisywanym przypadku można byłoby podłączyć kontaktron pod przerwanie. Jednak przy większej liczbie czujników nie byłoby to możliwe!
Pora więc wykorzystać poznany dziś mechanizm. Program ma działać następująco: jeśli wykryty będzie ruch, to uruchamiamy oświetlenie na 180 sekund. Światło zgaśnie po upływie tego czasu (jeśli nie ma kolejnych ruchów) lub, gdy ktoś będzie wychodził, czyli otworzy drzwi.
Jedna z wielu możliwości realizacji tego przykładu wygląda następująco:
Arduino
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
31
32
#define OSWIETLENIE 4
#define KONTAKTRON 3
#define PIR 5
unsignedlongaktualnyCzas=0;
unsignedlongzapamietanyCzasOswietlenie=0;
voidsetup(){
Serial.begin(9600);
pinMode(OSWIETLENIE,OUTPUT);
pinMode(KONTAKTRON,INPUT_PULLUP);//Kontaktron jako wejście
Oczywiście same założenia tego przykładu mają pewne wady i układ należałoby rozbudować, aby był przydatny w życiu codziennym. Warto byłoby chociażby dodać fotorezystor, dzięki któremu światło byłoby włączane jedynie w ciemności. Dalsze rozbudowanie układu zostawiam dla chętnych majsterkowiczów.
Podsumowanie
Ostatni przykład był bardzo prosty, ale pokazuje praktyczne zastosowanie dla funkcji millis, która była głównym bohaterem tego odcinka. Mam nadzieję, że od teraz nikt już nie będzie miał problemów z blokowaniem całego programu przez funkcję delay.
Zachęcam do własnych testów! Warto rozbudować opisane tutaj programy. Dodać więcej LEDów, przycisków i innych sensorów. Gdy wszystko będzie już jasne będzie można spokojnie przejść do bibliotek, które "same w magiczny sposób" wykonują takie opóźnienia.
Czy wpis był pomocny? Oceń go:
Średnia ocena 4.9 / 5. Głosów łącznie: 335
Nikt jeszcze nie głosował, bądź pierwszy!
Artykuł nie był pomocny? Jak możemy go poprawić? Wpisz swoje sugestie poniżej. Jeśli masz pytanie to zadaj je w komentarzu - ten formularz jest anonimowy, nie będziemy mogli Ci odpowiedzieć!
Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY na bazie Arduino i Raspberry Pi.
Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY z Arduino i RPi.
Trwa ładowanie komentarzy...