STEROWANIE DWUSTANOWE. Przykład 1 MIESZALNIK

Transkrypt

1 STEROWANIE DWUSTANOWE Sterowanie dwustanowe najczęściej sprowadza się do wykonania pewnej sekwencji operacji, przy czym przejście od jednej operacji do drugiej następuje po spełnieniu określonych warunków, np. osiągnięcie określonego celu lub upływu zadanego czasu. W takim przypadku mamy do czynienia ze sterowaniem sekwencyjnym. Przykład MIESZALNIK Prostym przykładem jest sterowanie pracą mieszalnika obiekt sterowania i sieć działań przedstawiono na rys.. Algorytm jest następujący: zakładamy, Ŝe zbiornik jest pusty; proces uruchamiamy naciśnięciem przycisku S (Start), co powoduje otwarcie zaworu Y i napełnianie medium ; osiągnięcie poziomu b, powoduje zamknięcie zaworu Y, otwarcie zaworu Y2, a więc dopływ medium 2 oraz uruchomienie mieszadła W; osiągnięcie poziomu a, powoduje zamkniecie zaworu Y2 i włączenie na zadany czas grzejnika G; po upływie czasu t następuje wyłączenie mieszadła W i grzejnika G oraz otwarcie zaworu Y3, opróŝniającego zbiornik; gdy poziom cieczy spadnie poniŝej czujnika c, następuje zamknięcie Y3; jeŝeli przycisk S jest nadal wciśnięty, to cykl się powtarza. Przedstawiona na rys., sieć działań przedstawia logiczny przebieg procesu, który został podzielony na pięć kroków. W takiej postaci algorytm ten nie powinien być przeniesiony na postać programu sterowania obiektu. W takim przypadku mikrokontroler, realizujący program zdecydowana większość czasu zuŝywałby w pętli oczekiwania na zajście określonego zdarzenia, tzn. zmiana stanu czujnika lub upływ czasu. Jego moc obliczeniowa byłaby wykorzystana w nieznacznym stopniu. Stan nadzorowanego obiektu zmienia się bardzo wolno w stosunku do moŝliwości mikrokontrolera. Ponadto w takim przypadku trudno byłoby kontrolować poprawna pracę mikrokontrolera. Trudniej równieŝ taki program rozszerzać. Na rys. 2 przedstawiono algorytm umoŝliwiający efektywne wykorzystanie czasu mikrokontrolera. Dzięki temu system moŝe realizować współbieŝnie wiele innych zadań. Procesor testuje, z maksymalna prędkością, w jakiej fazie znajduje się proces sterowania, wykonuje tylko zadania przewidziane w fazie aktywnej, jeŝeli dany krok procesu się zakończył to następuje zwiększenie o licznika faz (w przykładzie modulo 5) i przejście do kolejnego cyklu testowania programu. i styl programowania pozwala na łatwa kontrolę poprawności pracy procesora. Zygmunt Kubiak /

2 Start STEROWANIE MIESZALNIKA Y=Y2=Y3=, W=G= W F= S=? Y Y2 Y= a b=? b F= G Y= Y2=W= c F=2 a=? Y3 Y2=, G= LT=t a, b, c - czujniki poziomu ( czujnik zanurzony, czujnik wynurzony) LT=LT- Y, Y2, Y3 - zawory sterowane F=3 LT=? W - sterowanie mieszadła G - sterowanie grzejnika W=G= Y3= F=4 c=? Y3= Opracowanie na podstawie: Musierowicz P.: Podstawy techniki mikroprocesorowej. WNT, Warszawa 99, rys Rys.. Układ sterowania sekwencyjnego mieszalnika - obiekt i sieć działań 2/2 Zygmunt Kubiak

3 Start Y=Y2=Y3=, W=G=, F= STEROWANIE MIESZALNIKA Wersja synchroniczna F= S=? Y= F= b=? Y= Y2=W= F=2 a=? Y2=, G= LT=t F=3 LT=LT- LT=? W=G= Y3= F=4 c=? Y3= Błąd F=(F+) 5 Inne operacje Opracowanie na podstawie: Musierowicz P.: Podstawy techniki mikroprocesorowej. WNT, Warszawa 99, rys Rys. 2. Synchroniczna realizacja sterowania sekwencyjnego mieszalnika z rys. Zygmunt Kubiak /3

4 Przykład 2 STEROWANIE SEKWENCYJNE ZESPOŁU WAGONIKÓW W tym przykładzie przedstawiono bardziej złoŝony układ sterowania sekwencyjnego, dotyczący częściowo niezaleŝnego ruchu dwóch wagoników (rys.3). Algorytm sterowania moŝna opisać następująco: w stanie wyjściowym, wagoniki znajdują się w lewym skrajnym połoŝeniu, zwierając wyłączniki krańcowe A i C; naciśnięcie przycisku S uruchamia cykl sterowania; wagoniki ruszają w prawo (załączenie napędu P, P2) nie jest określone, który dotrze pierwszy do wyłączników krańcowych B, D; wagonik pierwszy, po dotarciu do B, wraca natychmiast do A (napęd L); wagonik drugi, wraca dopiero wówczas (napęd L2), gdy pierwszy dotarł do A; jeŝeli przycisk S jest nadal włączony, to cykl się powtarza. Z powyŝszego opisu wynika, Ŝe drugi wagonik będzie czekał w D o ile dotarł do D przed osiągnięciem A przez wagonik pierwszy, w przeciwnym przypadku wraca natychmiast. Dokładną sieć działań przedstawiono na rys. 3. Jak moŝna zauwaŝyć, sieć działań nie jest juŝ prostą pętlą zawiera rozgałęzienie równoległe, które uwzględnia niezaleŝny ruch obu wagoników. iego algorytmu nie moŝna bezpośrednio wykonać na mikrokontrolerze, poniewaŝ wykonuje on operacje sekwencyjnie. Przekształcenie nawet takiego prostego schematu do postaci czysto sekwencyjnej jest operacją bardzo czasochłonną i dość złoŝoną. Poza tym tak uzyskany algorytm ma wszystkie wady omówione na przykładzie z rys.. Realizacja synchroniczna jest natomiast w tym przypadku równie prosta jak w przykładzie. PoniewaŜ w tym przykładzie zachodzi jednoczesna aktywność dwóch faz, zamiast licznika faz trzeba zastosować znaczniki faz. Ponadto w kaŝdym cyklu skanowania programu, naleŝy przejść do testowania wszystkich faz procesu. NaleŜy równieŝ pamiętać o konieczności synchronizacji wykonania gałęzi równoległych. Oznacza to, Ŝe realizacja połączenia rozgałęzień równoległych wymaga wykonania tych gałęzi przed przejściem do dalszej części programu. W tym celu w algorytmie (rys. 4) wprowadzono znaczniki wykonania gałęzi R i R2. Wykonanie gałęzi sprawdzane jest przy pomocy warunku iloczynu logicznego: R^R2. 4/4 Zygmunt Kubiak

5 Start STEROWANIE WÓZKÓW L=P=R=L2=P2=R2= S=? F P=P2= A B C D S Układ sterowania F B=? P=, L= D=? P2=, R2= F2 P L P2 L2 R R2 F3 A=? L=, R= A L P B F4 R^R2=? C L2 2 P2 D L2=, R=R2= L, P L2, P2 napęd wagoników (lewo, prawo) F5 C=? A, B, C, D - wyłączniki krańcowe R, R2 znaczniki wykonania operacji L2= F.. F5 fazy sterowania wózków Rys. 3. Układ sterowania sekwencyjnego zespołu wagoników - obiekt i sieć działań Zygmunt Kubiak /5

6 Start F=, F..F6= L=P=L2=P2= STEROWANIE WAGONIKÓW Wersja synchroniczna F=? S=? P=P2= F= F=F2= F=? B=? P= L= F= F3= F2=? D=? P2= F2= F4=, R2= F3=? A=? L= F3= F4=, R= F4=? R^R2=? L2= F4=, F6=, R=R2= F5=? C=? L2= F5= F= Inne operacje Rys. 4. Synchroniczna realizacja sterowania sekwencyjnego zespołu wagoników z rys.3 6/6 Zygmunt Kubiak

7 Przykład 3 STEROWANIE DIODAMI LED Naciśniecie klawisza powoduje zapalenie LED na s. Natomiast zwolnienie klawisza uruchamia cykli pulsowania LED2 (okres s). Ponadto załoŝono moŝliwość drgań styków w celu ich eliminacji, wprowadzono opóźnienie ms od wykrycia pierwszego zbocza narastającego (przy naciskaniu klawisza) lub pierwszego zbocza opadającego (przy zwalnianiu klawisza). Poszczególne czasy, występujące w cyklu sterowania, tzn. ms,,5s i s są generowane przy pomocy timerów programowych T i T działających z wykorzystaniem przerwania czasowego 5ms. Program zrealizowany został na podstawie algorytmu synchronicznego i dzięki temu w minimalnym stopniu obciąŝa mikrokontroler. Klawisz LED LED2 s s ms ms Rys.5. Przebiegi czasowe dla przykładowego programu sterowania diodami LED Algorytm sekwencyjny, przedstawiony na rys. 6 nie zapewnia wydajnej pracy mikrokontrolera, który większość czasu czeka na naciśnięcie lub zwolnienie klawisza. Aby móc efektywnie wykorzystać czas mikrokontrolera, naleŝy zaprojektować algorytm sterowania jak na rys. 7 (wersja synchroniczna). Mikrokontroler cyklicznie sprawdza, w której znajduje się sterowanie. Aby przejść do wersji synchronicznej naleŝy zaznaczyć na algorytmie sekwencyjnym fazy i powiązać je z odpowiednimi znacznikami (tu: F.. F7). Pętle oczekiwania w programie, związane są z trzema typami zdarzeń: zdarzenia sprzętowe naciśnięcie lub zwolnienie klawisza zdarzenia czasowe zakończenie odliczania timerów T lub T zdarzenia ilościowe wykonanie określonej liczby pętli licznik LC. W realizacji algorytmów synchronicznych nie ma potrzeby wykorzystywania w programie pętli typu for.. next. Faza programu z reguły zawiera blok (-i) decyzji i blok wykonawczy, ale jak pokazano na rys. 7, faza moŝe obejmować tylko bloki decyzji (F7) lub tylko blok wykonawczy (F5). ZaleŜy to od programu blok F5 rozpoczyna pętlę pulsowania diody LED2 i dlatego naleŝało go wyodrębnić. Zygmunt Kubiak /7

8 Start F czy klawisz wciśnięty F gdy wciśnięty uruchom opóźnienie zap. LED na s F 2 po s zgaś LED F F 3 czy klawisz zwolniony uruchom opóźnienie F 4 gdy zwolniony ustaw licznik cykli pulsowania LED 2 F 5 zapal LED 2 na, 5 s LT = 2, T = T F 6 zgaś diodę LED 2 na, 5 s F 7 po okresach pulsowania LED testowania wciśnięcia klawisza 2 przejdź do F F 5 Zap. LED 2, LT = 99, T = Zap. LED, LT = 99, T = T F 2 T F 6 Zgaś LED 2 LC = LC -, LT = 99, T = Zgaś LED F 3 T F 7 LT = 2, T = LC T F 4 Koniec LC = Rys. 6. Algorytm sekwencyjny programu KlawiszDioda W synchronicznej wersji (rys. 7) algorytmu, wykonywane są wyłącznie procedury związane z aktywnymi fazami programu. Program nie czeka na spełnienie warunku. W tej metodzie programowania zaleca się aby fazy były ustawione w kolejności naturalnej, zgodnie z algorytmem z rys. 6. jest to jednak warunek konieczny. Fazy moŝna przetasować i nie wpłynie to na działanie programu. Bardzo łatwo rozszerzyć program o nowe fazy. Jest to jedna z podstawowych zalet metody synchronicznej. Algorytmy synchroniczne stanowią najprostsze rozwiązanie programowania mikrokontrolerów dla systemów czasu rzeczywistego. 8/8 Zygmunt Kubiak

9 Start F czy klawisz wciśnięty uruchom opóźnienie F gdy wciśnięty zap. LED na s F2 po s zgaś LED F=, F..F7=,, F3 czy klawisz zwolniony uruchom opóźnienie F4 gdy zwolniony ustaw licznik cykli pulsowania LED 2 F5 zapal LED2 na o,5s F F=, F=, LT=2, T= F T F=, F2=, Zap. LED, LT=99, T= F=, F= F2 T F2=, F3=, Zgaś LED F3 F3=, F4=, LT=2, T= F4 T F4=, F5=, LC= F4=, F3= F5 F5=, F6=, Zap. LED2, LT=99, T= F6 T F6=, F7=, Zgaś LED2, LC=LC-, LT=99, T= F7 T LC F7=, F5=, F7=, F= Koniec F6 zgaś diodę LED2 na,5s F7 po okresach pulsowania LED2 przejdź do testowania wciśnięcia klawisza Rys. 7. Wersja synchroniczna programu KlawiszDioda Zygmunt Kubiak /9

10 Bloki wykonawcze mogą oczywiście zawierać funkcje w j. C. Funkcje, jeŝeli zawierają pętle oczekiwania na wystąpienie zdarzenia zewnętrznego lub wewnętrznego, powinny być tworzone równieŝ według algorytmu synchronicznego. PoniŜej przedstawiono realizację programową algorytmu synchronicznego z rys. 7, dla mikrokontrolera AVR typu Atmega855. //Program był uruchomiony na module Miface. //Schemat i dokumentacja modułu na stronie // // Przykład z obsługą Timerów programowych T, T2 i klawisza // Naciśniecie klawisza powoduje zapalenie LED na s // Zwolnienie klawisza uruchamia cykli pulsowania LED2 (okres s) // Autor: Z.Kubiak IIPP // Kontroler: ATmega855 // Naciśnięty klawisz zwiera wejście do masy // Diody zapalane sygnalem zero #include <avr/io.h> #include <avr/interrupt.h> #include <avr/signal.h> unsigned char LC,T,T; unsigned char F,F=,F2=,F3=,F4=,F5=,F6=,F7=; unsigned int LT,LT; SIGNAL (SIG_OVERFLOW) // przerw. 5ms dla Tck,592MHz { if (T==) { if (LT==) T=; else LT--; if (T==) { if (LT==) T=; else LT--; TCNT = 22; // cykl 54 int main(void) { //MCUCR = 2; // przerwania zewnętrzne DDRD = xf; // Bity PORTD..3 wej; 4..7 wyj PORTD = 5; // podciąganie wejść DDRB = xff; // PORTB wyjscia TIMSK = 2; TCNT = 22; TCCR = 5; // podział przez 24 F=; // faza programu T=; // znacznik aktywnosci timere programowego //F=; //F2=; PORTB=255; // ustaw PORTB - zgaś diody sei(); while() { // odblokowanie przerwań // diody LED - PORTB.2 i PORTB.3 if (F) { if ((PIND & (<<3))==) //test klawisza czy wcisnięty { LT=2; // filtrowanie drgań styków F=; F=; T=; // uruchomienie Timera T - ms / Zygmunt Kubiak

11 if (F) { if (T==) { if ((PIND & (<<3))==) { PORTB &= ~(<<2); // RST bit - zapal diodę LED LT=99; F2=; F=; T=; else { F=; F=; // uruchomienie Timera T2 - s if (F2) { if (T==) { PORTB = (<<2); // SET bit - wył diodę LED F2=; F3=; if (F3) { if (PIND & (<<3)) //test klawisza czy wycisnięty { LT=2; // filtrowanie drgań styków F4=; F3=; T=; if (F4) { if (T==) { if (PIND & (<<3)) { LC=; F5=; F4=; else { F4=; F3=; // uruchomienie Timera T - ms // cykli pulsowania LED2 if (F5) { PORTB &= ~(<<3); // RST bit - zapal diodę LED2 LT=99; F5=; F6=; T=; if (F6) { if (T==) { PORTB = (<<3); // SET bit - wył diodę LED2 LT=99; LC--; F6=; F7=; T=; if (F7) { if (T==) { if (LC==) // czy wszystkie cykle wykonane? { F7=; F=; else { F7=; F5=; Zygmunt Kubiak /

12 Realizacja Timerów programowych realizacja zaleŝności czasowych W systemach czasu rzeczywistego jednym z problemów jest realizacja zaleŝności czasowych, tzn. opóźnień czasowych, pojedynczych impulsów oraz serii impulsów o zadanym czasie, generatorów przebiegów o zadanej częstotliwości itp. Zwykle Ŝąda się duŝej dokładności wytwarzanych przebiegów. Wykorzystywanie do tych celów pętli programowych jest kłopotliwe i mało precyzyjne (rys. i 2). Poprawne rozwiązanie tego problemu przedstawione jest poniŝej. Proponowane jest wykorzystanie Timerów programowych. Mikrokontroler dysponuje niewielką liczbą timerów sprzętowych, np. 2. W programie naleŝy zdefiniować dwa typy zmiennych: Tx bit stanu Timera oraz LTx rejestr licznika (np. typu integer). Wartości te ustawiane są w programie głównym, natomiast w programie obsługi przerwań następuje dekrementacja zawartości licznika danego Timera. Po osiągnięciu zera następuje wyzerowanie znacznika Timera, który jest testowany w programie głównym. UŜycie Timerów programowych przedstawiono w przykładzie 3. Przerwanie Wykorzystanie przerwań do realizacji Timerów programowych T=? LT= T= LT=LT= T=? LT= T= LT=LT- T2=? LT2= T2= LT2=LT2- Dalsze Timery Inne operacje Powrót Rys. 8. Sieć działań podprogramu obsługi przerwania czasowego, celem obsługi Timerów programowych 2/2 Zygmunt Kubiak