ATNEL tech-forum

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2015-10-02T18:40:20+01:00

Trochę temat odkopię, sprawa jest prosta, przy starcie currentMillis ma wartość 0, tak jak i previousMillis, interwał 1000.

Po sekundzie currentMillis == 1000 a previousMillis == 0, czyli 1000 - 0 > 1000 (tutaj bym użył ' >= ' ponieważ przy ' > ' warunek zostanie spełniony przy 1001 i zmienna previousMillis przyjmie wartość 1001, 2002, 2003...)

Sami88 napisał(a):

if (currentMillis - previousMillis > interval)

Warunek interwal został spełniony więc previousMillis ma teraz wartość = 1000, a dokładnie 1001

Sami88 napisał(a):

previousMillis = currentMillis;

licznik currentMillis leci dalej, więc jak doleci do 2000 to analogicznie if (2001-1000 >= 1000) previousMillis = 2000. (2002)

Statystyki: Napisane przez Oliveer — 2 paź 2015, o 18:40

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2015-07-12T08:02:54+01:00

NIE ROZUMIĆ , skąd się bierze wartość currentMillis = millis();
Jaką wartość otrzymuje w tym przykładzie currentMillis ?

[syntax=cpp]unsigned long currentMillis = millis(); // tu przekazałem zmiennej aktualna wartość
// zwracana przez funkcję millis();

if (currentMillis - previousMillis > interval) // no chyba wiadomo co tutaj robię

// jeśli (currentMillis -(minus) previousMillis jest większe od interval)[/syntax]

Wychodzi na to iż currentMillis jest nieznaną i zmienna millis() też jest nieznaną. Nie mogę tego zrozumieć.

Więc jeśli nieznana currentMillis odjąć znana previousMillis jest mniejsza od znana interval
[syntax=cpp]if (currentMillis - previousMillis > interval)[/syntax]

Wykonaj:
Zdefiniowana previousMillis wartość 0 jest równa currentMillis, więc currentMillis jest równe 0, i dopiero tutaj nadaliśmy wartość currentMillis = 0
[syntax=cpp]previousMillis = currentMillis;[/syntax]

Jeśli zdefiniowana ledState będzie mieć stan niski
[syntax=cpp]if (ledState == LOW)[/syntax]

Podajemy ledState stan wysoki
[syntax=cpp]ledState = HIGH;[/syntax]

A jak nie pozostaw stan niski
[syntax=cpp]else
ledState = LOW;[/syntax]

Wysyłamy na kanał wyjściowy ledPin stan ledState
[syntax=cpp]digitalWrite(ledPin, ledState);[/syntax]

JAK TO ROZUMIEM ??
Kod staruje od początku i zatrzymuje się na

[syntax=cpp]if (currentMillis - previousMillis > interval)[/syntax]

W tym momencie wartość previousMillis jest zmienną która z wartości 0 rośnie do 1000 milisekund i gdy osiąga ten stan program idzie dalej, ponieważ korzysta z wewnętrznego zegara mikroprocesora który startuje od chwili zasilenia. Pytanie czy zmieniając wartość 0 na 100 jaki będzie tego skutek ? Czy zero ma tu być obligatoryjne zawsze ma być ta wartość ?

Rozpoczyna się funkcja if i tutaj zmienna previousMillis oraz currentMillis jaką otrzymują wartość ? Jest to 1000 milisekund albo 0. Jeśli wartość jest brana ze zmiennej globalnej to jest to wartość zresetowana i ma wartość 0. Ale też jest to operacja w funkcji, więc powinna mieć wartość 1000 milisekund + 1 milisekunda. (kod poniżej)

[syntax=cpp]previousMillis = currentMillis;[/syntax]

W tedy zostaje sprawdzony stan wyjścia pinu i jeśli ma wartość niską

[syntax=cpp]if (ledState == LOW)[/syntax]

zmiennej ledState nadana jest wartość Wysoką, po czym na końcu kodu zostaje wysłana ta wartość na pin po upływie 1000 milisekund po czym program zaczyna od nowa. Ponieważ na starcie stan zmiennej ledState był niski to teraz jest wysoki i zostaje zapalona dioda itd. Czy ktoś może mi odpowiedzieć na pytani które zawarłem czy aby dobrze rozumuje ten kod ?

Statystyki: Napisane przez Sami88 — 12 lip 2015, o 08:02

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T23:53:02+01:00

nio dobrze czyli zatem nie da rady kombinować w kierunku którym chciałem

Statystyki: Napisane przez kierlan — 25 sty 2012, o 23:53

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T22:30:18+01:00

dodam jeszcze tyle , że kod programu na którym się wzorowałeś kolego kierlan ,
jedyne co robi to tylko wyświetla wartość funkcji millis() na oknie terminala żeby
wszyscy zobaczyli jak ta funkcja działa , a nie liczy ileś tam czasu

Jakbyś poczekał 50 dni to byś zobaczył że leci od początku
(co zapomniałem dopisać

Natomiast wyliczenie dokładnie 1000ms jest już wyjaśnione w kodzie wyżej

Statystyki: Napisane przez SunRiver — 25 sty 2012, o 22:30

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T22:06:16+01:00

O dzięki Mirku:)

W tym przykładzie na serial chodziło mi o pokazanie co właściwie robi funkcja millis() , a liczy czas od uruchomienia programu.
Chodzi o czas pracy procesora , który możemy sobie skoro i tak tyka do czegoś użyć
Parę postów wyżej wyjaśniłem chyba dokładnie działanie funkcji:)

A w tym przykładzie niema żadnego delaya , a obliczenia czasu są oparte na funkcji millis();
Niemniej postaram się jakoś łopatologicznie wyjaśnić działanie tego programiku:

[syntax=cpp]

const int ledPin = 13; // Dioda podłączona do portu Digital13
int ledState = LOW; // Stan pinu diody LOW
long previousMillis = 0; // ta długa zmienne ma wartość początkową = 0
long interval = 1000; // ta długa zmienna przechowuje ilość zliczanych milisekund
// czyli 1000ms = 1s

void setup() {
pinMode(ledPin, OUTPUT); // tu ustawiłem pin diody D13 jako wyjście
// z wiadomego powodu
}

void loop()
{
unsigned long currentMillis = millis(); // tu przekazałem zmiennej aktualna wartość
// zwracana przez funkcję millis();

if(currentMillis - previousMillis > interval) // no chyba wiadomo co tutaj robię

// jeśli (currentMillis -(minus) previousMillis jest większe od interval)

{
previousMillis = currentMillis; // no bez jaj chyba jasna jest ta linijka
if (ledState == LOW) // sprawdzenie czy dioda zgaszona

ledState = HIGH; // to zmień na HIGH (włącz)
else // a jak nie LOW tylko HIGH czyli zaświecona
ledState = LOW; // to zmień na LOW czyli zgaś
digitalWrite(ledPin, ledState); // wysyłanie na port właściwego stanu w celu migania diodą
}
}

[/syntax]

No teraz chyba wszyscy widzą i wiedzą jaki zamysł panuje w programie:)

Po prostu funkcja mili sobie liczy czas pracy procka , a ja tylko przypisuje sobie wartość funkcji
millis() do zmiennej currentMillis i odejmuje od niej zmienną previousMillis która ma wartość 0 (zero)
cały czas bo była potrzebna tylko do tego żeby pokazać programowi że zegar ruszył od zera i sobie przyrasta:)
porównuje wiec wynik odejmowania zmiennej previousMillis i currentMillis i porównuję czy jest większe od zmiennej
interval. i w ten sposób wyliczam sobie 1 sekundę czyli dioda mryga tak jak chciałem:)

Zatem zmieniając wartość zmiennej interval zmieniamy szybkość migania diody podobnie jak zmieniając wartość
parametru funkcji delay()

i to wszystko

Statystyki: Napisane przez SunRiver — 25 sty 2012, o 22:06

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T20:32:57+01:00

hyhyhyhy - no dokładnie o tym myślałem (że masz takie coś w kodzie) - ale zauważ że nie tylko DELAYEM ale także czasem wykonania Serlial.println

Teraz to chyba już zapamiętasz to na całe życie o co w tym chodzi?

PS ... zauważ że te dodatkowe średnio 12ms to dokładnie czas potrzebny na przesłanie 12 znaków z prędkością 9600bps

a napis

Czas: 1012 plus CRLF

to właśnie trwa praktycznie 12ms dokładnie więc zobacz jakie dokładne masz pomiary panie kochany

Statystyki: Napisane przez mirekk36 — 25 sty 2012, o 20:32

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T20:21:17+01:00

program generjący dane na terminal to jak wyżej pisałem kod sunrivera na ktorym opierałem się

[syntax=cpp]

unsigned long czas; // w zmiennej czas będziemy przekazywać aktualną wartość millis()

void setup(){
Serial.begin(9600); // 9600 bps dla portu USART
}
void loop(){
Serial.print("Czas: "); // nie no chyba to jest jasne i oczywiste
czas = millis(); // przypisujemy wartość millis() do zmiennej czas
// wyświetlanie czasu od chwili uruchomienia programu
Serial.println(czas);
// delay potrzebny żeby nie wyświetlać zbędnych danych
delay(1000);
}

[/syntax]

opóznienie jest spowodowane DELAYEM czyli 1s

Statystyki: Napisane przez kierlan — 25 sty 2012, o 20:21

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T20:12:50+01:00

kierlan napisał(a):

nio widzę taki, że złe miałem założenie ponieważ zakładałem zliczanie "co 1" i to był błąd

Ależ zlicza co jedną milisekundę - skąd takie przypuszczenie że nie ? szok ! Przecież te przerwy pomiędzy wynikami są spowodowane zapewne operacjami które wykonujesz pomiędzy jednym wyświetlaniem a drugim. A kodu nie pokazałeś, który generował te dane na terminalu. Jeśli pokażesz to szybko zapewne uda się wyjaśnić co mierzyłeś i jak.

Zastanów się, że przecież sama operacja wysyłania danych przez RS232 musi trwać i to tym dłużej jeśli nie jest zorganizowana na przerwaniach i jeśli bez przerwań to tym dłużej im mniejsza prędkość.

Oczywiście mogę się mylić co do pewnych szczegółów bo nie zajrzałem do źródeł działania funkcji Millis() ... ale czuję że te duże przerwy wynikają z kodu , który napisałeś.

Statystyki: Napisane przez mirekk36 — 25 sty 2012, o 20:12

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T19:56:07+01:00

tak, to też prawda no nic jak złapie Suna na Jabberze to na pewno naprowadzi mnie na dobry tok myślenia jak zawsze zresztą hehe :]

Statystyki: Napisane przez kierlan — 25 sty 2012, o 19:56

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T19:48:37+01:00

Wynika z tego chyba tylko jedno, nie uda się trafić zawsze w konkretną milisekundę

Statystyki: Napisane przez Sonix — 25 sty 2012, o 19:48

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T19:48:01+01:00

nio widzę taki, że złe miałem założenie ponieważ zakładałem zliczanie "co 1" i to był błąd

Statystyki: Napisane przez kierlan — 25 sty 2012, o 19:48

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T18:19:27+01:00

No i bardzo dobrze wygląda to zliczanie - a ty widzisz jakiś problem ? - bo nie zrozumiałem

Statystyki: Napisane przez mirekk36 — 25 sty 2012, o 18:19

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T16:16:49+01:00

odpalając program na którym się wzorowałem jako tako, chyba wychwyciłem jeden z problemów.. tak wygląda zliczanie 0_o

Statystyki: Napisane przez kierlan — 25 sty 2012, o 16:16

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T16:04:50+01:00

hm.. moja logika myślenia była taka tutaj, że czas = millis(); czyli jeśli dam warunek if czas = 1000 to będzie to działać w sposób następujący: jeżeli licznik doleci do 1000 to stanie się to i to a jezeli doleci do 2000 to to i to oraz wyzeruje licznik :]

Statystyki: Napisane przez kierlan — 25 sty 2012, o 16:04

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T15:53:56+01:00

Może ja nie Sun, ale podpowiem ci, żebyś rzucił okiem na właściwy kod który pokazał kolega Sun

[syntax=c]if(currentMillis - previousMillis > interval)[/syntax]

jak myślisz do czego powołał kolega Sun, dodatkową zmienną previousMilis albo interval ??? przeanalizuj to w tym jego przykładzie a doznasz olśnienia i życie bez delay'ów stanie się piękne

Bo ty próbujesz to załatwić w taki nieoczekiwany sposób

[syntax=c_mac]if (czas = 1000) [/syntax]

więc chyba widzisz, że coś jest nie tak

Statystyki: Napisane przez mirekk36 — 25 sty 2012, o 15:53

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-25T15:49:49+01:00

Achoj

"Sun" mam do Ciebie pytanko

ostatnio po tym "nie znoszę delay" :> zacząłem wyszukiwać sobie innej drogi i tutaj na bazie ostatniego Twojego kodziuku zmodziłem coś takiego z tym, że prawdopodobnie(bo nie działa jak należy) problem tkwi w nieprawidłowym resetowaniu licznika...

[syntax=cpp]

unsigned long czas = 0;

void setup()
{
pinMode(13, OUTPUT);
}
void loop()
{

czas = millis();

if (czas = 1000) // cykl od 0-1000ms - LOW
{
digitalWrite(13, HIGH);

}
if (czas = 2000) // cykl 1000-2000ms - HIGH
{
digitalWrite(13, LOW);
czas = 0; // powrót do cyklu 0-1000ms - LOW
}

}

[/syntax]

a dokładnie ta linijka:

[syntax=cpp]
czas = 0; // powrót do cyklu 0-1000ms - LOW
[/syntax]

opisałem w kodzie o co mi chodziło dokładnie, program to hello world "blink" ;P

Czekam na podpowiedź lub sugestie nie korzystałem jeszcze z tego cudowatego licznika :]

Statystyki: Napisane przez kierlan — 25 sty 2012, o 15:49

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-24T13:04:57+01:00

Fakt trochę mało czytelnie opisałem za co przepraszam , powinienem do komentować linie , ale w tak banalnych programach często komentarze pomijam bo zasadniczo niema tu żadnych rozbudowanych funkcji i algorytmów
Ująłem tu tylko najprostsze z możliwych jak w pierwszym przykładzie użycie pętli FOR i IF/ELSE , zasady ich działania
są totalnymi fundamentami nauki programowania. W drugim przykładzie istotnie użyłem funkcji bibliotecznej Millis(), która w istocie wymaga wyjaśnienia:

-- Millis()

jest funkcja czasową zaimplementowana w środowisku arduino ide , która zwraca liczbę milisekund
od czasu uruchomienia bieżącego programu na procesorze. Co ciekawe powrót do zera czyli przepełnienie
nastąpi po około 50 dniach (jeśli nie zresetujemy procesora).

Najlepiej chyba to zobrazuje mały przykład,
w którym będziemy w terminalu wyświetlać czas działania programu:

[syntax=cpp]
unsigned long czas; // w zmiennej czas będziemy przekazywać aktualną wartość millis()

void setup(){
Serial.begin(9600); // 9600 bps dla portu USART
}
void loop(){
Serial.print("Czas: "); // nie no chyba to jest jasne i oczywiste
czas = millis(); // przypisujemy wartość millis() do zmiennej czas
// wyświetlanie czasu od chwili uruchomienia programu
Serial.println(czas);
// delay potrzebny żeby nie wyświetlać zbędnych danych
delay(1000);
}

[/syntax]

Już chyba jasne jest do czego służy funkcja millis(), mówiąc w skrócie procesor zlicza czas działania od chwili
uruchomienia programu (każdego) i dzięki funkcji millis() mamy możliwość skorzystania z tego ukrytego licznika
co tez warto czynić

Wyjaśnienia też wymagają podane przeze mnie w przykładach objętości programów wyrażone w bitach, ale to już
trochę inna filozofia o czym napisze nowy temat ze szczegółowym wyjaśnieniem co powinno rozwiać wątpliwości
i uzmysłowić początkującym dlaczego warto umieć myśleć strukturalnie i oszczędzać cenne zasoby naszych mikrokontrolerów. Bo jak się niebawem przekonacie - liczyliście nieprawidłowo zasoby pamięciowe.

Jako zajawkę zadam wam pytanie ile pamięci SRAM ma popularna jak grzybica stóp ATmega8 ??
Wyjaśnienie w nowym temacie już niebawem.

Statystyki: Napisane przez SunRiver — 24 sty 2012, o 13:04

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-23T22:39:41+01:00

mirekk36 napisał(a):

No właśnie tylko ten pierwszy rzut oka, gdy zniechęca początkujących

dokładnie potrafi zniechęcić i tu jest problem.. temu dając przykład wole użyć nawet delay by taka osoba zrozumiała i nie było to dla niej "czarną magią" ale z czasem tak jak na tym o to forum pokazać lepsze rozwiązanie bez delay

Statystyki: Napisane przez kierlan — 23 sty 2012, o 22:39

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-23T22:16:32+01:00

kierlan napisał(a):

zgodzę się w 100% chodziło mi o czytelność na 1 rzut oka, ...

No właśnie tylko ten pierwszy rzut oka, gdy zniechęca początkujących - to nawet nie zdają sobie sprawy ile to kosztuje. Bo przecież ile można zrobić programując liniowo - używając Delayów - a ILE można zrobić w TAKI sposób? - oto jest pytanie - to prawie jak "Być albo nie być"

Statystyki: Napisane przez mirekk36 — 23 sty 2012, o 22:16

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-23T21:50:32+01:00

zgodzę się w 100% chodziło mi o czytelność na 1 rzut oka, z delayami wiadomo od razu o co chodzi i jest bardziej przejrzysty (na mój gust oczywiście), ale oczywiście lepsiejsze jest rozwiązanie kolegi sunrivera rzecz wiadoma :]

Statystyki: Napisane przez kierlan — 23 sty 2012, o 21:50

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-23T21:28:52+01:00

kierlan napisał(a):

.... , ale czy kod czytelniejszy nie powiedział bym

Bo z tą czytelnością to jest troszkę tak jak z nauką języka obcego. Na początku gdy nie znasz hebrajskiego to patrzysz na to co jest napisane jak na węzełki, ptaszki krzaczki. Gdy się troszkę go nauczysz, to coś rozumiesz - ala nadal mało czytelne. A gdy już zaczynasz tym językiem nieźle władać - to okazuje się, że jest czytelny jak nie wiadomo co

I taka sama analogia jest hmmm tyle że w tym przypadku nie chodzi o sam język C czy C++ - bo załóżmy, że ten już znasz mniej więcej. I potrafisz za jego pomocą zrobić to i owo, wysterować jakieś piny, porty, moduły sprzętowe itd...

Ale teraz chodzi o naukę kolejnej rzeczy - programowania i zmiany myślenia z liniowego na strukturalne (nie mylić ze strukturami w C) .... tu dokładnie chodzi o naukę i zrozumienie tego co to są tzw: "timery programowe". A gdy już zaskoczysz - to zobaczysz, że obojętnie jak ktoś nie napisze kodu z zastosowaniem techniki timerów programowych - to będzie on zawsze w miarę dobrze czytelny - pomimo iż są setki sposobów na implementację takich mechanizmów.

Tu w arduino kolega autor skorzystał z że tak powiem z wbudowanych (hmm ja to nazywam "tyknięć systemowych" albo z "Heart beat") .... gdzieś pod spodem tyka sobie systemowy timer i zlicza milisekundy. Wystarczy zatem z niego skorzystać - i już masz coś na kształt "timera programowego". Ale to w arduino - i trzeba się zapoznać z funkcją millis() .... wtedy będzie wiadomo o co chodzi. Natomiast ja w swojej książce, ponieważ piszę o czystym C .... pokazuję jak we własnym zakresie robić te "tyknięcia systemowe" (Heart beat) .... to w sumie proste - wystarczy jeden timer sprzętowy, który na dodatek może jeszcze pełnić kilka innych funkcji.

Reasumując - kolega SunRiver dał bardzo dobrą podpowiedź jak prosto znowu można to realizować w środowisku arduino. Bo tu nie język C++ ale samo środowisko i biblioteki dają taką możliwość.

Statystyki: Napisane przez mirekk36 — 23 sty 2012, o 21:28

Re: SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-23T21:06:59+01:00

Nio dobrze fakt delay jest zasobo żerny, ma jeszcze inne wyżej nie wymienione wady , ale czy kod czytelniejszy nie powiedział bym

Statystyki: Napisane przez kierlan — 23 sty 2012, o 21:06

SunDuino-NelDuino --> K2000 -- nie znoszę delay..

2012-01-23T18:05:08+01:00

Jak wiadomo instrukcja "delay" we wszystkich formach i ustrojach jest uwielbiana przez młodych
programistów fakt ma jedna zaletę i tylko jedną:

-- jest prosta w użyciu,

poza tym ma same wady z ważniejszych :

-- wstrzymuje pracę procesora na określony parametrem czas
-- jest zasobożerna i zabiera sporo cennych zasobów

Ale czy można w takim razie jej nie używać ??

Niekoniecznie chodzi mi o jej całkowite nieużywanie, ale jeśli to możliwe używać z głową , a nie
z uporem maniaka delay-ować jak się da i co się da. W celu pokazania możliwości optymalizacji
kodu oraz nienadużywania instrukcji delay posłużę się banalnym przykładem programu, który
tworzy na 4rech diodach led prosty efekt K2000. Do pracy.

Przyda nam się jakaś płytka xDuino oraz 4 diody led dowolne i 4 rezystory:
schemat połączeń jest banalny i prezentuje się poniżej:

Jak widać totalny banał

No to piszemy kod.

Wersja 1.

[syntax=cpp]
void setup()
{
pinMode(0,OUTPUT);
pinMode(1,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
}

void loop()
{
digitalWrite(0,HIGH);
delay(250);
digitalWrite(0,LOW);
digitalWrite(1,HIGH);
delay(250);
digitalWrite(1,LOW);
digitalWrite(2,HIGH);
delay(250);
digitalWrite(2,LOW);
digitalWrite(3,HIGH);
delay(250);
digitalWrite(3,LOW);
}
[/syntax]

Tak jak widać jest to jedynie słuszna droga do uzyskania tego banalnego i jakże
skomplikowanego efektu. Ale z taką ilością waszej ulubionej instrukcji dzieją się 3 rzeczy:

1. Przez lwią część czasu procesor wymięka z nudy totalnie nic nie robiąc.
2. W czasie nic nie robienia i tak nie może nic robić poza nic nie robieniem.
3. Program trochę się robi opasły i jak to możliwe ze te kilka linijek kodu może zająć całe 1480 bitów

W przypadku tak prostego programu nie musimy się tym przejmować , ale kiedy nasz program będzie
zawierał w kodzie kilkaset instrukcji delay ?? Nasze procesorki potrafią wiele ale posiadają ograniczone
jednak zasoby --> to nie windows gdzie prosta aplikacja waży kilka megabajtów tu trzeba szybko się nauczyć w locie optymalizować kod i unikać zasobożernych instrukcji.

W przypadku języka C/C++ można naprawdę wiele zdziałać pisząc program w odpowiedni sposób
starając się używać jak najmniej niepotrzebnych opasłych bibliotek i pisząc własne funkcje i procedury,
i warto z tego korzystać naprawdę.
Teraz napiszemy ten sam program, ale wycinając do minimum użycie instrukcji delay.

Wersja druga --> pętlimy

[syntax=cpp]
int pin;

void setup()
{
for (pin=0;pin<4;pin++) pinMode(pin,OUTPUT);
}

void loop()
{
for (pin=0;pin<4;pin++)
{
if (pin==0) digitalWrite(3,LOW);
else digitalWrite(pin-1,LOW);
digitalWrite(pin,HIGH);
delay(250);
}
[/syntax]

Popatrzcie program działa dokładnie tak samo jak wersja poprzednia ale użyłem tylko 1 raz instrukcji
delay, a cała reszta została uproszczona poprzez zastosowanie pętli FOR i warunków IF ELSE
Program jest czytelniejszy krótszy, a po kompilacji zaoszczędziliśmy ponad 400bitów pamięci.

Jak wielu z was zauważy -- przy tak prostym programie jakie ma to znaczenie 400bitów w tę czy w druga, skoro np w/w programy pracowały na ATMedze328 która ma ponad 32000bitów pamieci.

Tak tu akurat niema to znaczenia ale warto zobrazować ten problem , bo nadużywanie lub co gorsza
nie umiejętne korzystanie z instrukcji delay, to oznaka niechlujności w pisanych programach i jednocześnie co chyba gorsze w większych projektach będzie owocowało brakiem czytelności
programu i nieprawidłowym jego działaniem. Dla lepszego zobrazowania problemu przedstawię kolejny
prosty przykład mianowicie mikrokontrolerowe HELLO WORLD czyli migaczek 1 diodowy

1. Wersja ---> Typisz DELAY

[syntax=cpp]
void setup() {
pinMode(13, OUTPUT);
}

void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}

[/syntax]

Jak widać prosty program powodujący miganie diody na pinie D13 co 1 sek.
Waga: 1018bitów

2 Wersja --> No DELAY

[syntax=cpp]
const int ledPin = 13;
int ledState = LOW;
long previousMillis = 0;
long interval = 1000;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop()
{
unsigned long currentMillis = millis();

if(currentMillis - previousMillis > interval)
{
previousMillis = currentMillis;
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;
digitalWrite(ledPin, ledState);
}
}

[/syntax]

Program robi to samo - niema ani jednego delaya jak widać
Waga: 398bitów

Teraz przyjaciele sami pomyślcie czy warto pomyśleć trochę inaczej.
Oczywiście nie mówię że używanie delay jest złe chciałem tylko pokazać inne możliwości
uzyskania tego samego efektu i zmniejszenia zapotrzebowania na zasoby w programie.

Wielu refleksji i przemyśleń....

Statystyki: Napisane przez SunRiver — 23 sty 2012, o 18:05