Obsługa klawiszy - drgania styków CD...2

Witam,

Nadszedł czas na kolejny artykuł z cyklu drgań styków przedstawianych prawie wszędzie w krzywym zwierciadle. Ostatnio zajmowaliśmy się wyjaśnieniem od podstaw dlaczego tak wielu ludzi błędne przedstawia zagadnienia związane drganiami styków w programach, które piszemy dla mikrokontrolerów obojętnie jakiej rodziny.

Drgania styków ? - to BAJKI ! więc jak to jest naprawdę?


W tym temacie omówiłem podstawy związane ze zjawiskiem drgań styków. Na podstawie tegoż artykułu wiemy już iż w zdecydowanej większości przypadków drgania styków powstałe w pierwszej fazie, przy wciśnięciu klawisza, można w zasadzie zignorować i nie martwić się o ich występowanie czy efekty uboczne w większości naszych prostych aplikacji. Dzisiaj właśnie od tego zaczniemy, od podstaw tworzenia najprostszych z możliwych ale za to absolutnie skutecznych funkcji do tych celów. Zobaczysz, w jak prosty sposób można napisać najprostszą obsługę klawisza tak aby nie występowało zjawisko, które błędnie nazywane jest przez wiele osób efektem drgania styków i to tych drgań przy wciśnięciu klawisza. Sam uśmiejesz się jak to może być proste jeśli to dobrze przemyśleć. Weźmy zatem za cel przykład z poprzedniego artykułu. Nasze pierwsze zadanie to napisanie kodu obsługi klawisza, który po każdorazowym wciśnięciu ma zmieniać stan diody LED na przeciwny. Innymi słowy mówiąc, dioda ma pięknie zapalać się i gasnąć, bez żadnego migotania, bez najmniejszego kłopotu i to niezależnie od tego jak długo wciśniemy klawisz. Dodatkowo jeśli klawisz będzie wciśnięty non stop, to dioda LED ma nie zmieniać swojego stanu, zatem do rzeczy ....



Zanim przejdziemy do kodu, rozważmy ważną kwestię. Aby w minimalnym stopniu, poprawnie obsłużyć nasz klawisz, musimy wybrać moment wykonywania naszej akcji (moment zmiany stanu diody LED). Zakładając, że użytkownik programu będzie miał prawo wciskać ten klawisz z dowolną szybkością, stosując dowolny rodzaj klawisza, musimy rozpoznać przynajmniej dwa stany. Jeden z nich to moment WCIŚNIĘCIA, natomiast drugi to moment ZWOLNIENIA klawisza. Załóżmy zatem dalej, że nasza akcja zostanie wywołana bezpośrednio w momencie wciśnięcia klawisza a wykrycie momentu jego zwolnienia użyjemy pomocniczo do zmiany naszej maszyny stanów. Pamiętamy jednocześnie, że obsługa ta, ma być absolutnie nieblokująca, co oznacza, że w programie, w jednej pętli głównej możemy skorzystać z obsługi większej ilości takich klawiszy (więcej niż jeden), a jednocześnie bez żadnych opóźnień wykonywać inne operacje. To zwykle marzy się każdemu początkującemu, tylko że wciąż do głowy przychodzą pytania typu "w jaki sposób pisać funkcje nieblokujące?". My w tym momencie od razu zaczniemy od takiego przykładu. Żadnych DELAY'ów ;) i proszę bardzo - okazuje się, że można:

--------------------------------------

--------------------------------------

W powyższym kodzie, dziwnym może wydawać się ten _delay_ms(10), ale tak jak w opisie okazuje się, że wprowadziłem po prostu sztuczne opóźnienie po załączeniu podciągania programowego, bo czas narastania stanu wysokiego był tak powolny, że szybciej zadziałał pierwszy IF i po starcie programu, okazywało się, że klawisz jest prawie zawsze wciśnięty. Gdy dodamy byle jakie opóźnienie albo zewnętrzny rezystor np 4,7K to można zapomnieć o tym _delay'u ;)
Dobrze cóż widzimy w tym kodzie ? Za każdym obiegiem pętli można powiedzieć, że sprawdzamy dwa warunki. W zasadzie jeden ale rozdzielony słówkiem else. W pierwszym momencie sprawdzamy czy nasza zmienna pomocnicza do obsługi klawisza key_lock, jest równa zero oraz czy wciśnięty jest klawisz? Jeśli tak to najpierw nadajemy naszej zmiennej key_lock wartość = 1 a następnie wykonujemy naszą najprostszą akcję, czyli zmieniamy stan diody LED. Uwaga w tym momencie jak wyraźnie widzisz - w ogóle nie interesują nas drgania styków ;) .... po co sobie nimi głowę zawracać przy takiej aplikacji? Nawet jeśli wystąpią, to na pewno nie samoistnie, tylko w przypadku wciśnięcia klawisza - więc mogą sobie drgać te styki ;) Jeżeli jednak klawisz nie był wciśnięty to sprawdzamy po else, czy z kolei klawisz jest zwolniony a także czy zmienna key_lock posiada już wartość = 1. Jeśli nie, to naturalnie obsługa klawisza się kończy. Jeśli zaś wcześniej została wykonana akcja, i dojdzie do ponownego obiegu pętli głównej, to z uwagi na to, że key_lock jest już = 1 pierwsza część warunku się nie wykona (nawet jeśli nadal trzymamy wciśnięty klawisz. Taka sytuacja będzie się powtarzała aż go zwolnimy. Wtedy po którymś kolejnym obiegu, nie wykona się pierwsza część warunku ale już będzie się mogła wykonać druga część, ponieważ key_lock =1 i jednocześnie jest już klawisz zwolniony. Skoro tak, to zerujemy key_lock, i znowu w pętli można czekać na następne wciśnięcie klawisza. UWAGA! niestety w tym momencie, gdy zwalniamy klawisz, także mogą wystąpić drgania styków, albo efekt drgań styków spowodowany np zbyt powolnie narastającym zboczem (porównaj ostatni oscylogram z poprzedniego artykułu gdy dołożyliśmy np kondensator 100nF).



Po środku zbocza (żółty kolor - opisany fragment jako unknown) mogą wystąpić stany nieustalone i to może zostać zinterpretowane jako drgania styków (opisane jako: Source of error). Z tego powodu, choć rzadko to zdarzyć się może iż nasz sposób jeszcze będzie czasem zawodny. Sprawdź sam, ten kod i wykonaj sporo prób uderzając szybko i niedbale palcem w mikro-przełącznik. Mnie czasem udawało się wywołać przykry efekt - gdzie dioda LED np szybko mignęła ale natychmiast zgasła przy zwalnianiu klawisza. To właśnie te drgania (opadające powoli zbocze) może być powodem. Czy to oznacza, że musimy sięgnąć po jakiś DELAY ??? Ależ skąd!!! I teraz znowu odwołam się do poprzedniego artykułu. Pod koniec pokazałem na oscylogramach jak krótki stosunkowo może być ten czas drgań przy zwalnianiu przycisku, gdy np nie zastosujemy kondensatora 100nF. A skoro tak, to wykorzystajmy naszą zmienną key_lock w bardziej zaawansowany sposób. Do tej powy (w powyższym kodzie) zmieniała ona tylko swój stan albo na 0 albo na 1. My natomiast wykorzystamy ją jako mikro programowy timer ;) do realizacji opóźnienia, dzięki któremu przeczekamy te drgania styków przy zwalnianiu klawisza ;) Wystarczy, że będziemy tę zmienną dalej inkrementować aż sama dojdzie do wartości 255 i w następnym kroku się automatycznie wyzeruje. Tym sposobem stworzymy kolejną ale nadal super krótką procedurę obsługi klawisza, która nie wniesie żadnego DELAY'a. Nawet nie zużyjemy ŻADNEGO timera sprzętowego w tym celu! Spójrz sam, ale przedstawiam tu tylko samą pętlę główną ponieważ tylko ją lekko zmodyfikowałem w porównaniu do kodu przedstawionego wyżej:
--------------------------------------
--------------------------------------
Hmmm co się tu dzieje? ;) język C jest genialny pod tym względem. Warunek po else nadal działa, ale tylko wtedy gdy klawisz jest zwolniony i jednocześnie zmienna pomocnicza key_lock ma wartość różną od zera. A przecież posiada wartość różną od zera po zainicjowaniu wartością = 1 przy wykonaniu akcji. Dzięki drugiej części warunku nadal jest inkrementowana zmienna key_lock. (jak widać na obrazku niżej)





Dzieje się tak aż 256 razy. Inkremetacja o jeden, za każdym obiegiem pętli, a zatem w żaden sposób nie spowalniamy jej biegu, nie mniej jednak, jeśli teraz po zwolnieniu klawisza trwają drgania styków, to w trakcie zanim zmienna zwiększy się od 1 do 255 i zera ... upłynie akurat tyle czasu aby one zniknęły! Tę funkcję możesz już testować do bólu. Nie uda się jej złapać na błędnym działaniu - przynajmniej jeśli chodzi o mikro-przełączniki. Gdybyś zaś zechciał skorzystać z jakiegoś wielkiego mechanicznego stycznika, gdzie czas drgań przy zwolnieniu może być sporo dłuższy to nie ma kłopotu. Wystarczy aby zmienna key_lock była 16-bitowa a następnie zainicjalizować ją wartością nie = 1 ale np 50000, tak aby licznik w niej dobiegł do wartości 65535 (czyli do końca), wykonując tym razem o wiele więcej obiegów pętli głównej a jednocześnie wydłużając czas oczekiwania na zniknięcie drgań styków przy zwolnieniu klawisza. Tak ta modyfikacja może wyglądać:
--------------------------------------
--------------------------------------
Próbuj kody do woli, przeprowadzaj testy i ciesz się tą funkcjonalnością. Zdajesz sobie jednak sprawę, że na razie nauczyliśmy się tylko reagować na wciśnięcie klawisza, tymczasem przydałoby się nieraz mieć możliwość reakcji na jego zwolnienie, po to aby no przytrzymać go nieco dłużej - i akcja miałaby się wykonać bezpośrednio po jego zwolnieniu. Jednym słowem mówiąc, teraz chcemy reakcji nie na zdarzenie klawisza o nazwie PRESS (wciśnięcie) tylko na PUSH_UP (zwolnienie). Proszę bardzo:
--------------------------------------

--------------------------------------
Teraz już pewnie sam się domyślasz, że można byłoby tak przerobić tę obsługę żeby mieć akcję w odpowiedzi zarówno na wciśnięcie jak i zwolnienie klawisza ;) A zatem, gdy wciskamy akcja wykonuje się natychmiast, za to możemy nadal trzymać wciśnięty klawisz i dopiero gdy go zwolnimy to można wykonać drugą akcję. Niestety nie ma tu na razie żadnej koordynacji czasowej a więc w takiej postaci byłaby to nieco ułomna obsługa klawisza. Tym zajmiemy się później. Teraz natomiast nauczmy się kolejnej rzeczy. Od razu takiego myślenia strukturalnego (nie ma to związku stricte ze strukturami w C) .... ale chodzi o to aby od razu umieć tak pisać fragmenty kodu w main aby dało się je wyprowadzić ładnie jako funkcje na zewnątrz pętli i głównej funkcji main(). Zanim tego dokonamy, napiszmy sobie obsługę dwóch klawiszy aby sprawdzić czy to nadal będzie tak samo wyśmienicie działać ? ;)
--------------------------------------
--------------------------------------
proszę bardzo, teraz jeden klawisz wykonuje nam akcje po wciśnięciu a drugi po zwolnieniu. Jeśli to uruchomimy do testu na własnym zestawie czy płytce stykowej to pięknie wyjdzie działanie w tzw "praniu" ;) .... W związku z tym przejdźmy teraz do wersji kodu, gdzie wyprowadzimy sobie dwie niezależne funkcje do obsługi klawiszy: key_press() key_push_up() ale uwaga, od razu skorzystamy z super możliwości języka C i tak napiszemy te funkcje, aby można było do ich wnętrza przekazać zewnętrzne funkcje użytkownika, które będą wykonywane jako akcje. Mogą to być dowolne funkcje my jednak dla testów, napiszemy je tak aby nadal tylko zmieniały stan dwóch różnych diod LED na przeciwny. Utworzymy zatem funkcje: change_led1() change_led2() Spójrzmy zatem na właściwy kod programu:
--------------------------------------
--------------------------------------
Proszę teraz zwrócić uwagę jak mocno uporządkowaliśmy pętlę główną while(1). Wciąż wywoływane są dwie nasze funkcje, działają w sposób nieblokujący, automatycznie wywołują akcje przekazane do nich w postaci wskaźników do funkcji dzięki czemu pętla główna może jeszcze wykonywać setki innych czynności równocześnie. Naturalnie pod warunkiem, że kolejne czynności to także będą funkcje nieblokujące! W kolejnym i ostatnim odcinku z tego cyklu spróbujemy się jeszcze zastanowić jak wprowadzić tu zależności czasowe z użyciem już typowego timera programowego a to wszystko mam nadzieję, że teraz pozwoli dużo lepiej zrozumieć istotę najbardziej rozbudowanej już funkcji jaką jest SuperDebounce() opisaną w książce pt: "Mikrokontrolery AVR Język C Podstawy programowania".

zapraszam na kolejną i ostatnią zarazem część tego cyklu artykułów:

http://mirekk36.blogspot.com/2012/10/obsuga-klawiszy-zwoka-czasowa-cd3.html





część I

część II




część III




.