Grodzki L.J.

Politechnika Białostocka
Bialystok University of Technology

https://bazawiedzy.pb.edu.pl
Rodzaj dyplomu / Diploma type Rozprawa doktorska / PhD thesis

Autor / Author Grodzki Lech
Realizacja sterowania binarnego w mikroprocesorowych sterownikach procesów
Tytuł / Title
binarno-ciągłych /
Rok powstania / Year of creation 1996
Promotor / Supervisor Busłowicz Mikołaj
Jednostka dyplomująca / Certifying unit Wydział Elektryczny / Faculty of Electrical Engineering
Adres publikacji w Repozytorium URL /
https://bazawiedzy.pb.edu.pl/info/phd/BUTbe185312bb494ae98aaab93be3a44c2c/
Publication address in Repository
Data opublikowania w Repozytorium /
Mar 3, 2021
Deposited in Repository on
Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15
WYDZIAŁ ELEKTRYCZNY
POLITECHNIKI BIAŁOSTOCKIEJ
mgr inż. Lech Jarosław Grodzki
REALIZACJA STEROWANIA BINARNEGO

W MIKROPROCESOROWYCH STEROWNIKACH
PROCESÓW BINARNO-CIĄGŁYCH
Rozprawa doktorska
Promotor
dr hab. inż. Mikołaj Busłowicz
profesor Politechniki Białostockiej
Białystok, 1996

SPIS TREŚCI
str.
Wykaz oznaczeń i skrótów 7
1. Wstęp 9
1.1 Wprowadzenie w tematykę pracy 9
1.2 Cele i struktura pracy 13
2. Rozwiązania sprzętowe i programowe sterowania binarnego 16
2.1 Techniczne realizacje sterowania binarnego 16
2.1.1 Układy przekaźnikowe........................................................................................................................ 16
2.1.2 Logika półprzewodnikowa .................................................................................................................. 18
2.1.3 Mikrokomputery i sterowniki mikroprocesorowe ............................................................................... 19
2.1.4 Programowalne układy cyfrowe.......................................................................................................... 22
2.1.4.1 Wykorzystanie pamięci programowalnych.................................................................................. 22
2.1.4.2 Programowalne układy logiczne.................................................................................................. 24
2.1.5 Układy pneumatyczne ......................................................................................................................... 25
2.2 Sposoby opisu układów sterowania binarnego 28
2.2.1 Schematy elektryczne stykowo-przekaźnikowe .................................................................................. 28
2.2.2 Logika drabinkowa.............................................................................................................................. 29
2.2.3 Schematy logiczne............................................................................................................................... 32
2.2.4 Schematy blokowe .............................................................................................................................. 33
2.2.5 Sieci operacyjne .................................................................................................................................. 34
2.2.6 Sieci Petriego ...................................................................................................................................... 36
2.2.7 Automaty skończone i grafy przejść ................................................................................................... 39
2.2.8 Wykresy czasowe................................................................................................................................ 41
2.3 Metody programowania sterowników PLC 43
2.3.1 Języki logiki drabinkowej LAD .......................................................................................................... 43
2.3.2 Języki tekstowe STL ........................................................................................................................... 45
2.3.3 Grafcet ................................................................................................................................................ 46
2.3.3.1 Geneza języka ............................................................................................................................. 46
2.3.3.2 Zastosowanie Grafcet w sterowaniu ............................................................................................ 48
2.3.4 PL7-3 jako modyfikacja standardu...................................................................................................... 49
2.3.5 Pakiet OPUS ....................................................................................................................................... 51
2.3.5.1 ESTER ........................................................................................................................................ 51
2.3.5.2 LOGEL........................................................................................................................................ 53
2.3.5.3 DRAGON.................................................................................................................................... 55
2.3.6 Step-5 .................................................................................................................................................. 55
2.3.7 MTS i GRAFPOL ............................................................................................................................... 58
2.3.7.1 MTS - Metoda Transformacji Sieci............................................................................................. 59
2.3.7.2 Zastosowanie metody GRAFPOL w programowaniu sterowników ............................................ 62
2.3.8 INTELSTER PC4K ............................................................................................................................ 64
2.3.9 Standard IEC 1131.............................................................................................................................. 65
2.3.9.1 Modelowa struktura oprogramowania sterownika....................................................................... 66
2.3.9.2 Tekstowe języki programowania ................................................................................................. 68
2.3.9.3 Graficzne języki programowania................................................................................................. 69
2.3.10 Inne możliwości programowania algorytmów sterowania binarnego................................................ 70
2.3.10.1 Zastosowanie języków wysokiego poziomu .............................................................................. 70
2.3.10.2 „Wysokopoziomowy” język stanów.......................................................................................... 72
2.3.10.3 Język przejść między stanami.................................................................................................... 73
2.3.10.4 CODE........................................................................................................................................ 74

3. Metoda programowania algorytmów sterowania binarnego
i język opisu automatów JODA 77
3.1 Opis układu sterowania binarnego jako automatu 78
3.1.1 Sterownik binarny jako automat skończony........................................................................................ 78
3.1.2 Kodowanie funkcji przejść automatu .................................................................................................. 81
3.1.3 Funkcjonowanie automatu................................................................................................................... 86
3.1.3.1 Tablica przejść automatu i algorytm zmiany stanu...................................................................... 86
3.1.3.2 Modyfikacja algorytmu zmiany stanu automatu .......................................................................... 89
3.1.4 Wyjścia automatu................................................................................................................................ 90
3.1.4.1 Realizacja funkcji wyjść .............................................................................................................. 90
3.1.4.2 Inne zmienne wyjściowe automatu .............................................................................................. 91
3.2 Implementacja metody JODA w technice programowania sterowników 94
3.2.1 Platformy sprzętowe i programowe..................................................................................................... 94
3.2.2 Struktury danych opisujące automat.................................................................................................... 97
3.2.2.1 Słowo wejściowe ......................................................................................................................... 97
3.2.2.2 Tablice przejść ............................................................................................................................ 99
3.2.2.3 Rekordy opisu stanów ............................................................................................................... 100
3.2.2.4 Tablice flag................................................................................................................................ 102
3.2.3 Programowanie obsługi automatu ..................................................................................................... 102
3.2.3.1 Cykl obsługi automatu............................................................................................................... 102
3.2.3.2 Wykorzystanie przerwań zegarowych ....................................................................................... 104
3.2.3.3 Wykorzystanie przerwań obiektowych ...................................................................................... 107
3.2.4 Możliwości autodiagnostyczne metody............................................................................................. 110
3.2.4.1 Diagnostyka na poziomie opisu automatu ................................................................................. 110
3.2.4.2 Diagnostyka systemu obsługi automatów .................................................................................. 111
3.2.5 Możliwości połączenia sterowania binarnego i ciągłego................................................................... 113
3.3 Język programowania dyskretnych automatów - JODA 117
3.3.1 Składnia języka ................................................................................................................................. 117
3.3.2 Przetwarzanie wyrażeń logicznych.................................................................................................... 122
3.3.2.1 Przejście na zapis wyrażenia w notacji polskiej ........................................................................ 122
3.3.2.2 Przejście do postaci APN wyrażenia ......................................................................................... 125
3.3.2.3 Korekcje końcowe zapisu.......................................................................................................... 126
3.3.2.4 Optymalizacja wyrażenia........................................................................................................... 127
3.3.3 Dodatkowe możliwości translatora ................................................................................................... 128
3.3.4 Perspektywy rozszerzenia funkcji translatora JODA ........................................................................ 131
3.4 Porównanie proponowanej metody z powszechnie stosowanymi 133
4. Przykłady praktycznego zastosowania metody JODA 136
4.1 Doświadczalna linia uzysku białka 136
4.1.1 Zadanie sterowania............................................................................................................................ 136
4.1.2 Przyjęte rozwiązanie systemu sterowania.......................................................................................... 138
4.1.3 Przykład użycia metody .................................................................................................................... 140
4.2 Formatyzerka 144
4.2.1 Zadanie sterowania i zastosowany sterownik .................................................................................... 144
4.2.2 Przykład użycia metody .................................................................................................................... 146
4.3 Sumator hematologiczny 151
4.3.1 Opis urządzenia................................................................................................................................. 151
4.3.2 Struktura programu sterującego ........................................................................................................ 152
4.4 Komunalna oczyszczalnia ścieków 156
4.4.1 Zadania sterowania............................................................................................................................ 156
4.4.2 Przyjęte rozwiązania konstrukcyjne i programowe ........................................................................... 158
4.4.3 Sterowanie urządzeniami dwustanowymi.......................................................................................... 161
5. Podsumowanie 167
Spis literatury 172
4

Dodatki 177
Dodatek 1 – Charakterystyczne parametry wybranych sterowników

programowalnych 178
Dodatek 2 – Układy pneumatyczne 184
Dodatek 3 – Listy rozkazów wybranych sterowników 185
Dodatek 4 – Sieci Petriego typu pozycja/tranzycja 187

Podstawy teoretyczne ……………………………………………………………………………….. 187
Reprezentacje sieci Petriego ………………………………………………………………………… 191
Dodatek 5 – Grafcet 194

Składnia Grafcet …………………………………………………………………………………….. 194
Reguły modelowania przy użyciu Grafcet …………………………………………………………... 198
Dodatek 6 – Przekształcanie wyrażeń logicznych przez translator JODA 200
Dodatek 7 – Przykłady procedur wyznaczających stany następne automatu 203

6

Wykaz oznaczeń i skrótów
 , ‘ - funkcja przejść automatu;

 - zmiana wielkości skalarnej lub wektorowej;
 - temperatura;
 - funkcja wyjść automatu;
P - pamięciowa złożoność obliczeniowa kodu programu;
D - pamięciowa złożoność obliczeniowa struktury danych utworzonej na potrzeby programu;
C - czasowa złożoność obliczeniowa programu;
OA - maksymalny czas realizacji cyklu obsługi automatu;
PO - maksymalny czas realizacji procedury obsługi przerwania obiektowego;
PZ - maksymalny czas realizacji procedury obsługi przerwania zegarowego;
T - czas realizacji zadań programu tła w ciągu 1s;
 - zbiór pusty;
APN - alternatywna postać normalna wyrażenia logicznego;
fOA - częstotliwość obsługi automatu przez sterownik;
fPO - częstotliwość występowania przerwań obiektowych;
fPZ - częstotliwość przerwań zegarowych;
int(...) - funkcja podająca zaokrąglenie wartości argumentu w dół do liczby całkowitej;
S - zbiór stanów automatu;
si - stan automatu (si  S);
sup(...) - funkcja podająca największą wartość spośród wszystkich argumentów;
TOA - okres obsługi automatu przez sterownik;
tCS - czas charakterystyczny stanu;
X - zbiór zmiennych wejściowych automatu;
X - zbiór słów wejściowych automatu;
x - słowo wejściowe automatu;
xt - słowo wejściowe automatu w chwili t;
Y - zbiór zmiennych wyjściowych automatu;
Y - zbiór słów wyjściowych automatu;
y - słowo wyjściowe automatu;
yt - słowo wyjściowe automatu w chwili t;

 - operator konkatenacji - łączenia (sklejania, spinania) słów binarnych;
 - relacja tożsamości;
 - relacja nierówności;
||...|| - moc zbioru;
 - przepisanie informacji, danej;
 - produkcja, podstawianie, przyporządkowanie (w zapisie funkcji);
 - znacznik końca definicji, przykładu, itp.;

1. Wstęp
1.1 Wprowadzenie w tematykę pracy
Programowalnymi sterownikami logicznymi1 nazywamy systemy automatyki

komputerowej przeznaczone do przetwarzania binarnych współrzędnych stanu procesu
na binarne sygnały sterujące [72]. Pierwsze tego typu konstrukcje powstały w końcu lat
sześćdziesiątych na zamówienie General Motors. Koncern ten potrzebował pewnych
w działaniu, łatwych do zaprogramowania, małych gabarytowo i mogących współpracować
z systemami CRPD2 sterowników linii montażowych. Od tego czasu datuje się historia
sterowników programowalnych, której najważniejsze etapy przedstawia poniższa tabela.
Tabela 1.1
Historia rozwoju sterowników programowalnych [95]
Rok Wydarzenie
1968 koncepcja sterownika programowalnego
1969 pierwszy sterownik: zbiór operacji logicznych, 1kB pamięci programu,
128 we/wy
1974 wieloprocesorowe PLC, wyposażone w timery, liczniki, operacje
arytmetyczne, 12kB pamięci programu i 1024 we/wy
1976 wprowadzenie zdalnych systemów we/wy
1977 pierwsze PLC oparte na mikroprocesorach
1980 inteligentne moduły we/wy, rozwój możliwości komunikacyjnych, narzędzi
programowych, zastosowanie PC, jako narzędzi wspomagających
1983 małe i tanie PLC
1985 wprowadzenie przemysłowych sieci sterowników stosowanych
do rozproszonych i hierarchicznych systemów sterowania
Rozwój technologii programowalnych sterowników jest ściśle związany z rozwojem

techniki mikroprocesorowej. Wprowadzenie do użytku pierwszych mikroprocesorów
na początku lat siedemdziesiątych spowodowało znaczne poszerzenie dotychczas istniejących
oraz powstanie całkiem nowych dziedzin zastosowań techniki mikrokomputerowej. Oprócz
typowo biurowych i naukowych zadań przetwarzania informacji przez małe mikrokomputery
pojawiły się, wychodzące naprzeciw potrzebom przemysłu, możliwości stosowania
mikrokomputerów w charakterze lokalnych układów sterowania. Wkraczaniu
mikroprocesorów do hal produkcyjnych sprzyjała także postępująca szybko miniaturyzacja
układów scalonych i całych mikrokomputerów. Możliwości nowej techniki w dziedzinie
1
termin ang.: Programmable Logic Controller – PLC
2
CRPD – Centralna Rejestracja i Przetwarzanie Danych
9

sterowania binarnego znacznie przewyższały to, co oferowały stosowane do tej pory układy
„klasyczne”: tak przekaźnikowe jak i stopniowo je wypierające cyfrowe układy wykonane
w technologii SSI i MSI. Układy mikroprocesorowe jako sterowniki binarne pozwalały
uzyskać jeszcze dalej idącą miniaturyzację w porównaniu z układami cyfrowymi, nie mówiąc
już o układach przekaźnikowych. Obok dalszej miniaturyzacji systemy mikroprocesorowe
cechowały się znacznie większą elastycznością w porównaniu ze swymi poprzednikami.
Zmiana algorytmów sterowania wymagała w ich przypadku jedynie zmiany programu pracy,
zapisanego w pamięci stałej, przy niezmienionej bazie sprzętowej sterownika. W układach
przekaźnikowych czy też cyfrowych zmiana taka wiązała się z koniecznością
przeprojektowania i przebudowania całej sieci połączeń. Nowe możliwości sprzętowe nie szły
jednak w parze z odpowiednimi narzędziami dla projektantów systemów automatyki. Zmusiło
to do podjęcia prac nad stworzeniem odpowiednich narzędzi programowych.
O wadze doboru właściwych narzędzi programowych do realizacji zadań syntezy
układów sterowania świadczą wyniki badań nad efektywnością prac programistycznych [43]:
 tylko 1/3 wszystkich błędów wykrytych podczas tych prac jest spowodowana przez błędy
programowania, większość pomyłek to błędy ze wstępnych faz projektowania,
spowodowane złym zrozumieniem lub interpretacją stawianych wymagań;
 większość błędów programowania jest odnajdywana poprzez testowanie jeszcze przed
oddaniem systemu do użytku, natomiast duża część błędów związanych ze złą interpretacją
wymagań (itp.) ujawnia się dopiero w trakcie pracy systemu;
 koszt korekcji błędów opisu i programowania jest zwykle 100 razy wyższy niż zwykłych
błędów programowania i zwiększa się wraz z upływem czasu.
Metody programowania sterowników logicznych są powiązane ze stosowanymi
sposobami opisu ich funkcjonowania. Jednym z takich sposobów, historycznie pierwszym, jest
schemat przekaźnikowo-stykowy, stosowany pierwotnie do opisu przekaźnikowych układów
sterowania [94, 95]. Układy te znalazły przede wszystkim zastosowanie w automatyce napędu
elektrycznego, umożliwiając sterowanie rozruchem i nawrotem silników elektrycznych, jak
również realizację układów o bardziej złożonych zależnościach czasowych i logicznych.
Schemat przekaźnikowo-stykowy, mimo zmiany konstrukcji sterowników, odejścia od
układów przekaźnikowych, pozostał w użyciu w formie tzw. logiki drabinkowej [80, 85, 88,
92, 94, 96]. Zastosowanie techniki mikroprocesorowej w konstrukcji sterowników
programowalnych umożliwiło wprowadzenie także innych metod programowania: języków
strukturalnych [91, 97], sieci operacyjnych [18, 64, 84], sieci Petriego [9, 16, 18, 24, 68, 69,
10

79], itd. Mamy dziś wiele systemów programowania seryjnie produkowanych sterowników
przemysłowych [5, 9, 46, 61, 81, 82, 83, 86, 93, 97]. O wadze zagadnienia świadczy także fakt
poświęcenia jednej z pięciu części normy IEC 1131 pt. „Programmable Controllers” właśnie
językom programowania tych urządzeń [47]. Większość prac nad rozwojem systemów
programowania sterowników prowadzona jest z inicjatywy potentatów w dziedzinie ich
wytwarzania. Tym samym efekty tych prac odnoszą się jedynie do standardowych,
uniwersalnych układów sterowników.
Osobne zagadnienie stanowią dostępne środki programowania niestandardowych
układów sterowania, opartych na technice mikroprocesorowej. Układy takie pełnią najczęściej
funkcje specjalizowanych mikrosterowników, wbudowanych w inne urządzenia. Mogą to być
również unikatowe układy sterowania wykonywane na jednostkowe zamówienie w sytuacji,
w której niemożliwe jest, z różnych względów (funkcjonalnych, ekonomicznych), użycie
seryjnie produkowanych sterowników. Programowanie takich układów polega z reguły
na wykorzystaniu dostępnych, standardowych języków programowania mikroprocesora
stanowiącego jednostkę centralną sterownika [10, 12, 26, 41, 98]. W zależności od
popularności określonego mikroprocesora dostępne są języki symboliczne (asemblerowe) lub
także języki wysokiego poziomu. Stosowanie, zarówno jednych jak i drugich, polega
na zapisaniu opracowanego algorytmu sterowania binarnego w formie sekwencji operacji
danego języka. To pozornie proste działanie staje się uciążliwe na etapie uruchamiania
sterownika, gdy z różnych przyczyn zachodzi konieczność wielokrotnych modyfikacji raz
zaimplementowanego algorytmu sterowania. Dlatego też pracuje się nad różnymi systemami
wspomagającymi proces tworzenia i uruchamiania nietypowych aplikacji
mikrokomputerowych układów sterowania [11, 21, 25, 42, 43, 56]. Niniejsza praca jest
prezentacją takiego właśnie systemu.
Opracowana przez autora metoda programowania algorytmów sterowania binarnego
bazuje na podstawowych pojęciach z teorii układów sekwencyjnych. Zakładając, że sterownik
binarny może być potraktowany jako automat Moore’a o zdefiniowanym słowie wejściowym,
zbiorze funkcji przejść i wyjść, można stosunkowo prosto opisać algorytm jego działania.
Praca zawiera również opis opracowanego języka opisu automatów i jego translatora, który
jest w stanie generować struktury danych opisujące automat na różne platformy sprzętowe
i programowe [31, 40]. Przyjęcie rozszerzonej definicji słowa wyjściowego automatu, które
może zawierać oprócz zmiennych binarnych także zmienne wielowartościowe, umożliwia
11

wprowadzenie dodatkowych działań sterownika. Działania te, uzależnione od różnych stanów
pracy automatu, mogą służyć, między innymi, regulacji wielkości ciągłych.
Opracowana metoda programowania algorytmów sterowania binarnego może być
z powodzeniem stosowana w różnych układach automatyki. Przy jej pomocy można tworzyć
oprogramowanie sterujące wbudowanych mikrosterowników różnych urządzeń, jak również
mikroprocesorowych sterowników przemysłowych. W obu przypadkach najczęściej
powtarzającymi się obiektami sterowania lub urządzeniami wykonawczymi są silniki
elektryczne. Urządzenia te, zróżnicowane tak pod względem konstrukcji, jak i przeznaczenia,
mogą wymagać różnych algorytmów sterowania dwustanowego. Uwzględniając przy tym
możliwość wykorzystania elektronicznych układów zabezpieczających pracę silników, można
rozbudowywać te algorytmy, podnosząc jakość i bezpieczeństwo pracy sterowanych napędów.
Metoda potwierdziła swoją skuteczność w kilku różnorodnych zastosowaniach [35, 36, 38, 39,
53, 54]. W aplikacjach tych, w większości przypadków sterowanymi urządzeniami są właśnie
różnego rodzaju napędy elektryczne, jedno- lub wielobiegowe, napędzające maszyny robocze
o różnych momentach obciążenia. Sukcesy w stosowaniu metody skłaniają autora do dalszych
prac nad rozwojem oprogramowania wspomagającego jej użycie.
12

1.2 Cele i struktura pracy
Celem niniejszej pracy jest przedstawienie nowej, opracowanej przez autora, metody
realizacji sterowania binarnego. Metoda ta umożliwia łatwe łączenie funkcji sterowania
binarnego z regulacją wielkości ciągłych, ale może także być wykorzystana wyłącznie w sferze
sterowania binarnego. Pozwala ona tworzyć mikrokomputerowe systemy automatyki,
oprogramowywane zarówno na poziomie asemblera jak i języków wysokiego poziomu.
O skuteczności prezentowanej metody świadczą przykłady zrealizowanych z jej pomocą
aplikacji.
Teza pracy:
Opracowana metodologia postępowania przy automatyzowaniu binarnych, a także
binarno-ciągłych procesów przemysłowych pozwala uzyskiwać sprawnie
działające i łatwo modyfikowalne systemy automatyki „na miarę potrzeb”,
szczególnie tam, gdzie użycie standardowych rozwiązań konstrukcyjnych
i programowych oferowanych przez producentów sterowników przemysłowych
jest niemożliwe.
Za osiągnięcia własne autor uważa:
1. opracowanie metody opisu algorytmów sterowania binarnego, ułatwiającej programowanie
nietypowych układów sterowania oraz umożliwiającej łączenie sterowania binarnego
z regulacją procesów ciągłych i realizacją innych działań objętych postawionym zadaniem
sterowania;
2. opracowanie oprogramowania wspomagającego generowanie nowych i modyfikację już
istniejących aplikacji, umożliwiającego stosowanie różnych platform sprzętowych
i programowych;
3. opracowanie algorytmów przetwarzania i optymalizacji wyrażeń logicznych na poziomie
symbolicznym, wykorzystanych w translatorze języka JODA
4. zastosowanie opracowanej metody do realizacji zróżnicowanych układów sterowania
- od małego przyrządu laboratoryjnego po system automatyki kompleksowej linii
technologicznej.
Praca składa się z pięciu rozdziałów. Pierwszym z nich jest wstęp zawierający krótkie
wprowadzenie w poruszaną tematykę.
Drugi z rozdziałów ma trójdzielną strukturę. W kolejnych jego częściach są
omówione:
13

1. Rozwiązania konstrukcyjne układów sterowania binarnego: począwszy od historycznie
pierwszych układów przekaźnikowych, które zaważyły na późniejszym rozwoju tej
dziedziny techniki, zwłaszcza jeśli chodzi o metody opisu i programowania sterowników.
W kolejnych punktach opisane są układy sterowania wykorzystujące logikę
półprzewodnikową, układy programowalne i mikroprocesorowe. Jest także mowa
o układach pneumatycznych, niezbędnych w pewnych dziedzinach zastosowań.
2. Druga część rozdziału zawiera krótki przegląd szeregu spotykanych metod opisu układów
sterowania binarnego, ponieważ rzutują one na stosowane metody programowania
sterowników. Wśród omówionych metod opisu znajdują się: schematy elektryczne, logika
drabinkowa, schematy logiczne i blokowe, sieci operacyjne i sieci Petriego (szerzej
zaprezentowane w Dodatku 4), automaty skończone i wykresy czasowe;
3. Ostatnia, najobszerniejsza część została poświęcona prezentacji różnych metod
programowania sterowników. Obok standardów jakimi są: języki logiki drabinkowej,
specjalizowane języki tekstowe, język sieciowy - Grafcet (szerzej omówiony w Dodatku 5),
zaprezentowano także konkretne zagraniczne (PL7-3, Step-5) i krajowe (OPUS, MTS,
GRAFPOL) realizacje tych języków. Nie pominięto również międzynarodowej normy
IEC 1131 dotyczącej sterowników programowalnych. W zakończeniu rozdziału
zaprezentowano także inne, specyficzne środki i metody programowania sterowników.
Trzeci rozdział zawiera prezentację opracowanej metody JODA:
1. Ponieważ metoda ta wykorzystuje pewne pojęcia z teorii automatów, pierwsza część
rozdziału jest poświęcona przedstawieniu koncepcji sterownika binarnego jako automatu
skończonego. Zaproponowano sposób opisu pracy automatu zbiorem zakodowanych
funkcji przejść oraz algorytm zmiany stanu wykorzystujący te funkcje. Przedstawiono także
rozwiązanie generacji sygnałów wyjściowych jako zbioru zmiennych binarnych
i wielowartościowych;
2. Druga część rozdziału przedstawia możliwości implementacyjne metody JODA.
Omówiono: możliwe platformy sprzętowe i programowe, struktury danych opisujące
automat we wnętrzu sterownika binarnego, zasady realizacji cyklu obsługi automatu.
Zawarto również informacje o możliwości wprowadzenia autodiagnostyki w trakcie pracy
automatu i łączenia ze sterowaniem binarnym innych działań, przykładowo regulacji
wielkości ciągłych.
3. W trzeciej części zawarto opis opracowanego języka JODA, służącego do opisu
automatów. Przedstawiono również możliwości translatora tego języka: symboliczne
14

przetwarzanie wyrażeń logicznych, ich optymalizację, translację odwrotną. Wspomniano
także o planowanej rozbudowie oprogramowania wspomagającego o dodatkowe moduły
narzędziowe.
Rozdział kończy się zwięzłym porównaniem metody JODA z innymi systemami, stosowanymi
do programowania sterowników.
Kolejny, czwarty rozdział pracy zawiera prezentację czterech, zróżnicowanych pod
względem wielkości problemu oraz bazy sprzętowej i programowej, aplikacji metody JODA:
 automatyki kompleksowej linii uzysku białka;
 sterownika formatyzerki do cięcia pakietów sklejki;
 przyrządu laboratoryjnego stosowanego w analityce medycznej;
 systemu sterowania komunalną oczyszczalnią ścieków.
Pracę kończy krótki rozdział podsumowujący dokonania autora i walory użytkowe
metody JODA. Do pracy dołączono kilka dodatków zawierających dane uzupełniające lub
dodatkowo ilustrujące informacje podane w drugim i trzecim rozdziale pracy.
15

2. Rozwiązania sprzętowe i programowe sterowania binarnego
2.1 Techniczne realizacje sterowania binarnego
Sterowanie dyskretne jest jedną ze starszych dziedzin automatyki przemysłowej.

Ponieważ wiąże się ono ściśle z konkretnymi sprzętowymi realizacjami układów sterowania,
można z łatwością zauważyć wpływ na nią rozwoju techniki. Zwłaszcza druga połowa naszego
stulecia zaowocowała wieloma możliwościami technicznej realizacji sterowania binarnego:
od układów przekaźnikowych, poprzez ich półprzewodnikowe odpowiedniki na elementach
dyskretnych, cyfrowe układy scalone o coraz większej skali integracji, po technikę
mikrokomputerową o ciągle rosnącym stopniu miniaturyzacji. Niniejszy rozdział prezentuje
najważniejsze z technik realizacji sterowników binarnych.
2.1.1 Układy przekaźnikowe
Układy przekaźnikowe są historycznie pierwszym środkiem realizacji układów

sterowania binarnego. Buduje się je z różnego rodzaju przekaźników odpowiednio ze sobą
połączonych. Sam przekaźnik jest znaną od przeszło stu lat konstrukcją elektromechaniczną,
składającą się z cewki elektrycznej, wytwarzającej pole magnetyczne, i układu ruchomych
styków.
Parametrami charakterystycznymi przekaźników są następujące wielkości:
 napięcie i prąd znamionowy cewki oraz styków;
 liczba i rodzaj styków (styki: czynne3, bierne4, przełączalne);
 trwałość łączeniowa (wyrażana gwarantowaną liczbą poprawnych przełączeń);
 czas zadziałania.
Ponieważ gama produkowanych przekaźników, ze względu na wyżej wymienione parametry
jest bardzo szeroka, spotyka się różne realizacje układów sterowania przekaźnikowego. Obok
zwykłych przekaźników dostępne są także konstrukcje specjalne: termiczne, z opóźnieniem
przy włączaniu lub wyłączaniu, nadprądowe, nadnapięciowe, itd. [94].
Przekaźniki pełnią w układach sterowania zasadniczo dwie funkcje:
 bezpośrednie sterowanie urządzeniami wykonawczymi;
 realizacja zależności logicznych.
3
stosowanymi zamiennie określeniami są: „zwierne”, „normalnie otwarte”
4
stosowanymi zamiennie określeniami są: „rozwierne”, „normalnie zamknięte”
16

Przekaźniki wyjściowe układu sterowania są z reguły przekaźnikami o 2-3 parach styków,
mających odpowiednio duże napięcia i prądy znamionowe. Realizacja funkcji logicznych
wymaga zwykle stosowania przekaźników o niewielkich napięciach i prądach roboczych
styków, ale o jak największej ich liczbie. Jest to związane z częstym powtarzaniem się tej
samej zmiennej logicznej, reprezentowanej przez dany przekaźnik, w wielu wyrażeniach
logicznych. Czasami, ze względu na wygodną unifikację użytych elementów układu
sterowania, do realizacji logiki sterującej używa się elementów tych samych, co do
bezpośredniego sterowania urządzeń wykonawczych. Powoduje to niekiedy konieczność
zastosowania dodatkowych przekaźników, właśnie z uwagi na małą liczbę dostępnych styków.
Wadami przekaźników jako układów logicznych są [95]:
 mała szybkość pracy, wynikająca z samej konstrukcji elementu;
 żywotność ograniczona między innymi przez: wypracowywanie się elementów ruchomych,
wypalanie się styków;
 ograniczona pewność łączeniowa, związana z efektem dzwonienia styków i ich
zanieczyszczaniem się;
 duże gabaryty, zmuszające do rezerwacji dużych przestrzeni na układ sterowania;
 bardzo niska podatność na modyfikacje raz uruchomionego układu;
 duży koszt uzyskania i eksploatacji jednego bitu informacji logicznej;
 ograniczona liczba styków, utrudniająca realizację wielokrotnego wystąpienia tej samej
zmiennej logicznej.
Rzeczywiste układy sterowania binarnego wykonane w technice przekaźnikowej
składają się z dziesiątek, jeśli nie setek przekaźników, połączonych między sobą gęstą siecią
przewodów. Zmusza to do stosowania dużych szaf sterowniczych, jak również dodatkowego
zużycia energii potrzebnej do pracy przekaźnikowej logiki.
Postęp techniki w dziedzinie układów cyfrowych doprowadził do stopniowego
wypierania sterowników przekaźnikowych przez układy wykonane w technologii SSI/MSI,
czy też mikroprocesorowe PLC, nawet w już funkcjonujących urządzeniach. Mimo eliminacji
przekaźników jako elementów logicznych, nadal pozostają one w użyciu jako układy interfejsu
pomiędzy niskonapięciowymi obwodami sterowników a wysokonapięciowymi
i silnoprądowymi urządzeniami wykonawczymi.
17

2.1.2 Logika półprzewodnikowa
Pojawienie się cyfrowych układów scalonych, początkowo małej, a z czasem średniej

skali integracji, znalazło swoje odzwierciedlenie także w dziedzinie konstruowania układów
sterowania binarnego. Konstruktorzy tych układów bardzo szybko dostrzegli zalety, jakie
oferuje nowa technika w tego typu zastosowaniach w porównaniu z „przekaźnikową klasyką”:
 bardzo duża szybkość działania;
 większa niezawodność;
 o wiele mniejsze gabaryty paneli sterowniczych;
 dużo mniejszy pobór energii potrzebnej do działania logiki sterującej;
 niewiele gorsza odporność na zakłócenia;
 dostępność złożonych operacji logicznych i arytmetycznych;
 dostępność metod optymalizujących końcową realizację sterownika.
Scalone przerzutniki pozwalały realizować elementy pamięci, tak bardzo potrzebnej
w układach sekwencyjnych, podczas gdy układy z różnego rodzaju bramkami służyły
do uzyskiwania potrzebnych funkcji wzbudzeń przerzutników i funkcji wyjść. Rola
przekaźników została zredukowana do swoistych wzmacniaczy sygnałów wyjściowych,
zamieniających sygnały logiczne na sygnały sterujące urządzeniami wykonawczymi.
Spośród cyfrowych układów funkcjonalnych szczególne znaczenie mają rejestry
przesuwające. Są to najczęściej ośmiobitowe układy z wejściem szeregowym i wyjściami
równoległymi. Wprowadzana przez wejście szeregowe informacja jest przesuwana bit po bicie
w kierunku wyjścia, pod wpływem sygnału taktującego. Zawartość rejestru może być także
asynchronicznie zerowana. Rejestry przesuwające znajdują zastosowanie w układach
sterowania dyskretnego jako:
 układy śledzące przemieszczanie się wzdłuż linii technologicznej przetwarzanych detali;
 sterowniki prostych, cyklicznych ciągów operacji.
Różne przykłady użycia rejestrów przesuwających w układach sterowania można znaleźć
w [95]. O znaczeniu tych rejestrów świadczy fakt, że analogiczne struktury programowe
występują w językach programowania wielu mikroprocesorowych PLC [20,46,82,83,88,97].
Najczęściej wykorzystywanymi do celów sterowania technologiami układów
cyfrowych, były rodziny układów:
 TTL, z racji ich dużej popularności i dostępności;
 CMOS, ze względu na ich duże marginesy zakłóceń i dużą elastyczność napięć zasilających.
18

Nadal jednak sterowniki zrealizowane przy użyciu cyfrowych układów scalonych
cechowały się wadami [95]:
 czasochłonnym projektowaniem obejmującym projekt połączeń logicznych, elektrycznych
i wykonaniem płytek drukowanych;
 brakiem podatności na modyfikacje (zmiana algorytmu sterowania wymagała
przeprojektowania całego układu);
 utrudnionym serwisem (wylutowywanie uszkodzonych elementów).
Dopiero rozwój technologii układów reprogramowalnych i mikroprocesorowych odsunął
na dalszy plan powyższe niedogodności.
2.1.3 Mikrokomputery i sterowniki mikroprocesorowe
Skonstruowanie na początku lat siedemdziesiątych pierwszych mikroprocesorów

przyspieszyło wkraczanie techniki komputerowej w dziedziny sterowania procesami, w tym
także sterowania binarnego. Spadek cen mikroprocesorów umożliwił stosowanie ich
w charakterze jednostek centralnych mikrokomputerów, pełniących role przemysłowych
układów sterowania. Klasyczna konstrukcja takiego mikrokomputera przemysłowego
bazowała na wersji mikrokomputera uniwersalnego, wzbogaconej o odpowiednie układy
sprzężenia z obiektem. Zależnie od warunków eksploatacji sprzętu komputerowego,
konstrukcja ta była, oczywiście, nieco modyfikowana. Również metody programowania zadań
sterowania niewiele odbiegały od metod stosowanych w przypadku zwykłych obliczeń. Aby
sprostać wymaganiom stawianym przed oprogramowaniem czasu rzeczywistego, opracowano
odpowiednie odmiany klasycznych języków programowania (IRT FORTRAN, RT BASIC,
Concurrent Pascal). Z czasem pojawiły się też specjalizowane języki programowania (Ada,
Modula, Pearl).
Prace nad stosowaniem mikrokomputerów w charakterze sterowników
przemysłowych doprowadziły do powstania całej gałęzi przemysłu elektronicznego,
zorientowanej na produkcję specjalizowanych sterowników mikroprocesorowych. Są to
przystosowane do przemysłowych warunków pracy urządzenia wyposażone w zróżnicowane,
tak pod względem sprzętowym jak i programowym, funkcje. Ponieważ konstruktorzy
systemów automatyki przemysłowej skłaniają się w stronę systemów rozproszonych,
w których zadania sterowania ciągłego i binarnego są realizowane przez rozproszone po
obiekcie lokalne układy sterowania, produkowane sterowniki mikroprocesorowe umożliwiają
realizację często obu tych zadań. Osiąga się to w dwojaki sposób:
19

 stosując systemy modułowe, ze stałą jednostką centralną i wymiennymi, swobodnie
konfigurowalnymi pakietami obiektowymi;
 produkując rodziny sterowników, wykorzystujących wspólną platformę programową, ale
różniących się zestawem (ilością, rodzajem) dostępnych wejść i wyjść obiektowych.
Popularność rozproszonych systemów automatyki, w których wiele lokalnych
sterowników, połączonych siecią komunikacyjną, realizuje postawione zadania sterowania,
powoduje zapotrzebowanie na małe sterowniki programowalne [13]. Wymaga się jednak, aby
możliwości, zwłaszcza programowe, tych urządzeń były jak największe. Zwraca się przy tym
uwagę szczególnie na dwie cechy [19]:
 szybkość realizacji rozkazów opisujących algorytm sterowania, określaną zwykle czasem
wykonania 1000 instrukcji programowych, oznaczającą szybkość reagowania urządzenia
na zmiany sygnałów wejściowych. Ważność tego parametru jest związana z sekwencyjnym,
a przez to rozłożonym w czasie, wykonywaniem programu przez procesor sterownika
w przeciwieństwie do równoległego działania układów przekaźnikowych
i półprzewodnikowych;
 możliwości języka programowania sterownika: lista rozkazów, dostępność złożonych
operacji przetwarzania danych, procedury biblioteczne.
Innymi ważnymi parametrami charakterystycznymi sterowników mikroprocesorowych są:
 pojemność pamięci programu, ograniczająca od góry wielkość rozwiązywanych zadań
sterowania;
 liczba wejść i wyjść binarnych, z uwzględnieniem ich konstrukcji (izolacja galwaniczna,
zakresy napięciowe i prądowe);
 liczba wejść i wyjść analogowych i ich konstrukcja;
 liczba oraz rodzaj układów czasowych i licznikowych;
 możliwości rozbudowy podstawowej konfiguracji sterownika o moduły dodatkowe
(rozszerzenia pamięci, zwiększenie liczby wejść i wyjść binarnych lub analogowych, itd.);
 zdolność sterownika do pracy w sieci komunikacyjnej;
 dopuszczalne warunki eksploatacji;
 zużycie energii, gabaryty (ważne w przypadku systemów wbudowanych).
Parametry charakterystyczne wpływają na wybór sterownika do określonego zadania, zgodnie
z licznymi kryteriami [102]. Tabela D.1 w Dodatku 1 zawiera zestawienie najważniejszych
parametrów wybranych sterowników produkcji krajowej i zagranicznej.
20

Najważniejszym składnikiem sterownika PLC jest jego jednostka centralna, ponieważ
to właśnie od jej konstrukcji zależy większość z wymienionych parametrów
charakterystycznych. W produkowanych sterownikach można wyróżnić cztery odmiany
konstrukcyjne jednostek centralnych [19]:
 procesor bitowy, wykonany w technologii MSI/SSI, charakteryzujący się dużą szybkością
działania, ale znacznym rozbudowaniem sprzętowym i wąskimi możliwościami
programowymi;
 procesor bitowy na bazie układu LSI, prostszy w budowie, ale i nieco wolniejszy;
 procesor bajtowy, wykorzystujący uniwersalny mikroprocesor, jest znacznie wolniejszy
w operacjach logicznych, ale może wykonywać także działania arytmetyczne, poszerzające
funkcje użytkowe sterownika;
 układy hybrydowe będące połączeniem procesora bitowego, przeznaczonego do realizacji
operacji logicznych programu i mikroprocesora odpowiedzialnego za wykonywanie
pozostałych rozkazów programu sterującego.
Proste sterowniki PLC mają jednostkę centralną opartą na pojedynczym mikroprocesorze,
a sterowniki zaawansowane - jednostkę dwuprocesorową (Modicon, Simatic).
W ciągu ostatnich dwudziestu lat ukształtowała się grupa wiodących producentów
sterowników programowalnych [13]: Siemens AG (Niemcy), Allen-Bradley (USA),
Mitsubishi (Japonia), AEG-Modicon (Niemcy-USA), GE-Fanuc (USA-Japonia), Omron
(Japonia), Telemecanique (Francja). Producenci ci narzucają kierunek i tempo zmian, które
ogólnie można scharakteryzować jako wzrost szybkości i możliwości programowych
sterowników. Jest jednak pewna sfera zastosowań, leżąca poza zainteresowaniami dużych
firm. Obejmuje ona: nietypowe rozwiązania systemów automatyki, układy sterowania z
narzuconymi na projektanta silnymi ograniczeniami (koszt, gabaryty, wybrane funkcje),
mikrosterowniki wbudowane w produkowane jednostkowo lub seryjnie urządzenia. Powyższe
dziedziny zastosowań mogą być polem do popisu dla małych firm, wykorzystujących swoje
własne specyficzne opracowania sterowników lub projektujących specjalizowane układy
do wbudowania w urządzenia. W charakterze tych ostatnich często wykorzystuje się popularne
mikrokomputery jednoukładowe, których możliwości programowe pozwalają realizować wiele
różnych algorytmów sterowania [33].
21

2.1.4 Programowalne układy cyfrowe
Postęp w dziedzinie technologii układów cyfrowych umożliwił realizację układów

logicznych nie tylko w tradycyjnej, bramkowo-przerzutnikowej, konwencji. Jako pierwsze,
zaczęto stosować pamięci programowalne typu PROM, później EPROM i EEPROM.
Opracowano także programowalne struktury złożone z bramek i przerzutników [58, 60, 85].
Możliwościom zastosowania zarówno pamięci stałych jak i programowalnych układów
logicznych jest poświęcony niniejszy punkt.
2.1.4.1 Wykorzystanie pamięci programowalnych
Pamięci stałe typu PROM, EPROM były pierwszymi programowalnymi układami

logicznymi stosowanymi w sterowaniu binarnym. Ich użycie polegało na bezpośrednim
zakodowaniu wartości wyjść sterujących w funkcji wejść, podawanych na linie adresowe albo
jako pamięci mikroprogramów dla zrealizowanych w technice MSI/SSI sieci operacyjnych.
Konstrukcje takie odeszły do historii po pojawieniu się mikroprocesorów. Dostrzeżono jednak
inne możliwości zastosowania pamięci programowalnych, związane z ich większą,
niż w mikroprocesorowych PLC, szybkością przetwarzania informacji wejściowej, co może
mieć znaczenie np. przy diagnozowaniu stanów awaryjnych sterowników.
Jednym z proponowanych rozwiązań jest zastosowanie sprzętowej logiki przejść5
[21]. Jest to połączenie trzech koncepcji:
1. reprezentacji procesu jako automatu skończonego;
2. reagowania na zbocza sygnałów wejściowych, a nie na ich poziomy;
3. sprzętowej implementacji w pamięci programowalnej.
Zastosowanie do opisu systemu automatu skończonego powoduje, że bieżący stan
automatu niesie informację nie tylko o aktualnym stanie procesu, ale także o jego historii.
Umożliwia to uwzględnienie postulatu o dostępności informacji dotyczącej sekwencji zdarzeń.
Znając bieżący stan automatu, znamy bieżące stany jego wyjść i możliwe stany następne,
które zostaną przewidziane na etapie analizy zadania. Wiedzę tę można wyrazić równaniami:
Yk = (sk,Xk)
sk+1 = (sk,Xk)
gdzie:
Xk - wektor wejść binarnych w chwili k;
5
termin ang.: „firmware transitional logic”
22

Yk - wektor wyjść binarnych w chwili k;
sk , sk+1 - stany: bieżący i następny automatu.
Możemy także, przy znanej tablicy przejść określić jaką drogą automat doszedł do danego
stanu, który np. jest stanem awaryjnym.
Ukierunkowanie się na zmiany sygnałów wejściowych modyfikuje funkcję przejść 
następująco:
sk+1 = ‘(sk,Xk)
gdzie: Xk = Xk - Xk-1
a) b) b
1
200
a c
Xk
sk a b b c c c b
2 3
100
1 2 200 – – – b
2 – 4 – – 3 b
c
3 – 100 – 1 –
4 – – 1 – 3 4
Rys. 2.1. Przykład automatu o funkcji przejść ‘ zorientowanej na zmiany stanu

zmiennych wejściowych: a) tablica przejść; b) graf przejść (kółka - stany normalne,
trójkąty - stany alarmowe)
Dodatkowym warunkiem jest wybór dostatecznie krótkiego odcinka czasu tk=tk-tk-1, tak aby
w kolejnych chwilach czasu była obserwowana zmiana tylko jednego sygnału xki  Xk.
Działanie automatu można wtedy przedstawić w formie grafu, w którym węzły odpowiadają
jego stanom, a skierowane krawędzie możliwym przejściom pomiędzy nimi. Przykład takiego
grafu i odpowiadającej mu tablicy przejść prezentuje rysunek 2.1.
Jeśli chodzi o sprzętową realizację automatu, autorzy [21] widzą ją w formie pamięci
EPROM i dodatkowego układu logicznego synchronizowanego zegarem. Układ ten przegląda
cyklicznie wszystkie sygnały wejściowe automatu: przy narastającym zboczu zegara bieżący
stan danego wejścia jest porównywany ze stanem poprzednim i jeżeli występuje zmiana,
to przy opadającym zboczu zegara następuje odczyt z pamięci EPROM kodu nowego stanu.
Kod bieżącego stanu w połączeniu z numerem testowanego wejścia binarnego tworzą adres
dostępu do pamięci przechowującej odpowiednio zakodowaną tablicę przejść. I tak pamięć
EPROM o pojemności 8kB może zawierać macierz przejść automatu o 28=256 stanach
wewnętrznych i 25=32 sygnałach wejściowych. Zwiększenie liczby stanów automatu ponad
256 wymaga operowania dłuższym niż 8-bitowe słowem, a zwiększenie liczby wejść - użycia
pamięci o większej pojemności. Jeden cykl pracy takiego automatu przy 32 wejściach i zegarze
23

taktującym 1MHz trwa 32s - jest to czas nieosiągalny w klasycznych sterownikach PLC.
Realizację równania opisującego funkcję wyjść  można osiągnąć dodatkowym blokiem
pamięci EPROM z zakodowaną tablicą wyjść (długość słowa bloku pamięci EPROM winna
odpowiadać liczbie zmiennych wyjściowych sterownika). W [21] znajduje się także przykład
użycia metody do sterowania procesami współbieżnymi.
Metodą sprzętowej logiki przejść można projektować całe sterowniki, jak również
układy hybrydowe, w których podstawowe stany pracy systemu są obsługiwane przez
klasyczny mikroprocesorowy sterownik PLC, a część sprzętowa wykorzystująca elektrycznie
reprogramowalną pamięć stałą wykrywa i raportuje sytuacje awaryjne. Wydaje się, iż metoda
ta ma poważne walory użytkowe, pod warunkiem jednak, że wyrażenia logiczne warunkujące
przejścia pomiędzy podstawowymi stanami pracy automatu wykorzystują niewielką (1..3)
liczbę argumentów. Trzeba bowiem zaznaczyć, że przy N argumentach występujących
w wyrażeniu liczba dodatkowych stanów pośrednich P, jakie należy wprowadzić dla tego
wyrażenia, wynosi P = 2N-2 (np. jeżeli N=3 to P=6).
2.1.4.2 Programowalne układy logiczne
Lata osiemdziesiąte przyniosły w wyniku ciągłego rozwoju technologii układów

scalonych nowe możliwości realizacji układów cyfrowych. Stało się to za sprawą układów
typu PLD6 i FPGA7, programowalnych przez użytkownika, nawet wielokrotnie.
Początkowo projektanci mieli do dyspozycji jedynie proste układy kombinacyjne,
złożone z matryc bramek OR i AND, które po elektrycznym ich zaprogramowaniu realizowały
pożądane funkcje logiczne, zastępując sieci połączeń bramek różnego typu. Przy odpowiednim
zaprojektowaniu całego urządzenia, umożliwiającym łatwą wymianę układów
programowalnych, uzyskiwało się w miarę elastyczny układ cyfrowy, którego funkcje mogły
być w pewnym zakresie dowolnie zmieniane. Dzięki temu możliwa stawała się sprzętowa
realizacja układów sterowania binarnego, podatnych na modyfikacje, co było nieosiągalne
w przypadku układów logicznych wykonanych tradycyjnie.
Z czasem w programowalne struktury zaczęto wbudowywać uniwersalne
przerzutniki, którym na etapie programowania układu przypisuje się funkcje (D, T, SR, JK),
zależnie od potrzeb. Konstrukcje te pozwalały już na realizację całego układu sterowania
sekwencyjnego w jednym układzie scalonym. Różne firmy opracowały wiele odmian tego
6
PLD - Programmable Logic Devices
7
FPGA - Field Programmable Gate Array
24

typu układów, umożliwiających implementację nie tylko najprostszych algorytmów
sterowania.
Nowe podejście do konstruowania układów cyfrowych z wykorzystaniem układów
programowalnych wymusiło opracowanie odpowiednich do tego celu metod syntezy układów
logicznych, tak kombinacyjnych jak i sekwencyjnych [59, 60]. Ponieważ złożoność tych
metod i możliwości układów czyniły proces „ręcznego” projektowania nieracjonalnym,
pojawiło się szereg programów narzędziowych wspomagających projektanta [58].
Porównując programowalne układy logiczne z ich klasycznymi odpowiednikami,
stwierdza się, że:
 pozwalają one uzyskać większy stopień scalenia i miniaturyzacji urządzenia;
 projektanci dysponują szeroką bazą narzędziową przyśpieszającą proces syntezy układu
docelowego;
 urządzenia zaprojektowane z ich udziałem są podatne na modyfikacje, zmiany
realizowanych funkcji.
Mimo powyższych zalet, udział programowalnych układów logicznych w dziedzinie
sterowania dyskretnego jest ograniczony do wąsko specjalizowanych, lokalnych,
wbudowanych w kontrolowane urządzenia mikrosterowników. Dzieje się tak, gdyż układy
programowalne ustępują pod wieloma względami technice mikroprocesorowej.
2.1.5 Układy pneumatyczne
Oprócz wymienionych w poprzednich punktach typowo elektrycznych realizacji

sterowania binarnego, tzn. takich, w których nośnikiem informacji logicznej jest napięcie lub
prąd, spotyka się jeszcze układy pneumatyczne i hydrauliczne. Układy te, wykorzystując gaz
(najczęściej powietrze) albo ciecz (olej), jako nośnik informacji, nadal znajdują zastosowanie
w pewnych dziedzinach automatyki. Ich prosta, czysto mechaniczna, pozbawiona obwodów
elektrycznych, konstrukcja sprawia, iż mogą być stosowane jako układy sterujące wszędzie
tam gdzie użycie obwodów elektrycznych mogłoby prowadzić do zagrożenia bezpieczeństwa
ludzi i urządzeń. Typowymi dziedzinami, w których się je stosuje są przemysł wydobywczy
oraz niektóre gałęzie przemysłu chemicznego.
Można podać również inne cechy układów pneumatycznych i hydraulicznych.
Zastosowane w tych układach, jako nośnik informacji i energii, powietrze ma tę zaletę,
że jest [90]:
 powszechnie dostępne;
25

 bezpieczne i czyste (brak niebezpieczeństwa porażenia, zanieczyszczenia środowiska).
Układy hydrauliczne dają możliwość uzyskania:
 dużych sił przy małych rozmiarach urządzeń napędowych;
 spokojnych i płynnych ruchów mechanizmów napędowych.
Wspólnymi zaletami tych układów są:
 łatwe zabezpieczenie przed przeciążeniem;
 łatwa obsługa elementów sterowniczych;
 modułowa konstrukcja pozwalająca składać układy sterowania z gotowych, standardowych
bloków;
 duża trwałość urządzeń przy prawidłowej eksploatacji;
 łatwy serwis.
Układy pneumatyczne i hydrauliczne nie są pozbawione wad, przykładem czego może być:
 wpływ obciążenia na prędkość ruchu napędzanych elementów;
 ograniczony zakres przemieszczeń prostoliniowych.
x1 x1 d)
a) x1 b) c)
y y
y
x5 x3 y x4 x1
x2
x2
x2 y=x1*x2 y
x1 x2 x1 x2
x2 x1 x1
y=x1+x2 y=x1*x2 x3
x4
Rys. 2.2. Zawory realizujące funkcje: a) alternatywy, b) koniunkcji, c) zakazu,

d) trzydrogowy rozdzielający
Do realizacji funkcji logicznych stosuje się odpowiednio skonstruowane zawory.
Największe znaczenie mają tu cztery rodzaje zaworów, pokazane na rysunku 2.2:
 zawór funkcji alternatywy;
 zawór funkcji koniunkcji;
 zawór funkcji zakazu;
 szeroka gama zaworów rozdzielających, zróżnicowanych ze względu na liczbę dróg
przepływu, liczbę położeń elementu sterującego, rodzaj sterowania (ręczne, mechaniczne,
26

elektryczne, pneumatyczne), sposób pracy (bistabilne, monostabilne, z opóźnieniem
czasowym). Symbole funkcjonalne przykładowych zaworów dwupołożeniowych podaje
tabela D.2 (Dodatek 2).
Funkcje sumy i iloczynu logicznego mogą być także zrealizowane przy użyciu
zaworów rozdzielających. Przykładowe realizacje pokazuje tabela D.3. W sekwencyjnych
układach sterowania występują również bloki pamięci (tzw. jednostki taktujące),
skonstruowane na bazie zaworów rozdzielających lub specjalnych urządzeń. Dostępne są także
przerzutniki pneumatyczne przydatne w konstrukcji prostych automatów [84] .
W projektowaniu prostych pneumatycznych (hydraulicznych) układów sterowania
stosuje się zwykle metody intuicyjne. Jednak zawodzą one w bardziej złożonych przypadkach.
Można wtedy stosować reguły projektowania te same co w przypadku elektronicznych
układów cyfrowych, ponieważ ma się do dyspozycji pneumatyczne równoważniki funktorów
logicznych, łącznie z elementami pamięci. Można również postępować tak jak z układami
przekaźnikowymi - równoważność funkcjonalną przekaźnika i zaworu rozdzielającego
pokazuje rysunek 2.3.
a) b) c)
x x
x
X
X
d)
kanał normalnie otwarty kanał normalnie zamknięty komora zaworu
dla przelotu powietrza dla przelotu powietrza X (cewka przekaźnika)
(styki normalnie zwarte) (styki normalnie otwarte)
x x
Rys. 2.3. Przekaźnik elektryczny (a) i pneumatyczny zawór rozdzielający (b): c) - symbol
zaworu; d) - symboliczne oznaczenia elementów przekaźnika i zaworu rozdzielającego
na schematach ideowych
Chociaż następuje ciągły rozwój elektrycznych w swej naturze sterowników PLC,
układy sterowania pneumatycznego i hydraulicznego nadal znajdują dziedziny zastosowań, o
czym może świadczyć produkowanie ich elementów składowych przez różne firmy (MERA-
PIAP, FESTO-PNEUMATIC - Austria, ALPHA-Controls - Wlk. Brytania, BOSH - Niemcy,
CPOAC - Francja).
27

2.2 Sposoby opisu układów sterowania binarnego
Zmiany w technice realizacji sterowników binarnych wpływały również na stosowane

sposoby opisu zadań sterowania dyskretnego. Pierwotną formą opisu takich zadań jest,
oczywiście, nadal opis słowny, który z różnym poziomem szczegółowości informuje
o postawionym zadaniu. Opis ten bywa często uzupełniany takimi formami jak: wykresy
czasowe, schematy blokowe, sieci działań, sieci operacyjne. Proces implementacji algorytmu
sterowania powoduje przejście do bardziej sformalizowanych, bliższych technicznej realizacji,
sposobów prezentacji: schematy stykowe, logiczne, logika drabinkowa. W ostatnich latach
zyskują na znaczeniu takie narzędzia jak: sieci Petriego [17, 51, 87] czy wywodzące się z teorii
układów logicznych automaty skończone [11, 100].
2.2.1 Schematy elektryczne stykowo-przekaźnikowe
Użycie schematów stykowo-przekaźnikowych jest ściśle związane

z przekaźnikowymi (punkt 2.1.1) realizacjami sterowania binarnego. Przedstawiają one,
wykorzystując standardowe symbole, schemat połączeń pomiędzy cewkami i stykami
przekaźników tworzących układ sterowania oraz pomiędzy stykami przekaźników
wyjściowych tego układu a urządzeniami wykonawczymi. Zestaw najczęściej stosowanych
symboli przedstawia tabela 2.1.
Tabela 2.1
Przykładowe symbole używane w schematach stykowo-przekaźnikowych

wg. PN-92 E-01200/07
cewka przekaźnika
lub cewka przekaźnika
termicznego
a) b) cewka przekaźnika a) b) styki przekaźnika
z opóźnieniemprzy: termicznego:
a) wyłączaniu; b) załączaniu a) zwierny; b) rozwierny
a) b) styki przełączne
styki przekaźnika:
a) zwierny; b) rozwierny przekaźnika
a) b) styki zwierne a) b) styki przycisku

z opóźnieniemprzy: ręcznego:
a) zamykaniu; b) otwieraniu a) zwierny; b) rozwierny
a) b) styki rozwierne a) b) styki włącznika
z opóźnieniemprzy drogowego:
a) zamykaniu; b) otwieraniu a) zwierny; b) rozwierny
28

Łącząc odpowiednio dostępne styki
PGw PTr
PGw
przekaźników i czujników, tak zwierne jak i rozwierne,
PC
PTr
można uzyskać różne funkcje użytkowe. Rysunek 2.4
start Pt
PZ PZ
przedstawia fragment układu sterowania rozruchem
PC PGw gwiazda/trójkąt z wykorzystaniem przekaźnika
PTr
czasowego PC do odmierzania czasu pracy w połączeniu
Rys. 2.4. Układ sterowania rozruchowym i przekaźnikiem termicznym Pt

rozruchem gwiazda/trójkąt zabezpieczającym sterowany silnik [94]. Niewidoczne
na rysunku styki przekaźników PZ, PGw i PTr sterują
cewkami odpowiednich styczników. Całość jest włączana i wyłączana krańcówką „start”.
Czytelność schematów łączeniowych dla większych układów sterowania jest
niewielka, a odtworzenie realizowanych funkcji logicznych bardzo żmudne. Dlatego też
schemat łączeniowy przekaźnikowego układu sterowania nie jest jedynym składnikiem
dokumentacji technicznej. Traktuje się go raczej jako schemat montażowy, potrzebny
do uruchomienia, konserwacji i serwisu. Natomiast opis realizowanych funkcji jest podawany
oddzielnie, w innej, czytelniejszej formie (opis słowny, wyrażenia logiczne, schemat blokowy,
sieć działań).
Schematy elektryczne jako forma opisu układu sterowania odchodzą już do historii
wraz z układami przekaźnikowymi, z którymi są ściśle powiązane. Ponieważ jednak tempo
postępu technicznego w dziedzinie sterowania binarnego przewyższa wielokrotnie możliwe
tempo zmian przyzwyczajeń człowieka, schematy te uległy standaryzacji i w formie logiki
drabinkowej są używane także obecnie.
2.2.2 Logika drabinkowa
a) b)
Logika drabinkowa jest efektem
standaryzacji schematów elektrycznych.
c)
Stosowana pierwotnie do układów
przekaźnikowych, pozostaje w szerokim
d)
użyciu także przy programowaniu
mikroprocesorowych PLC. Nazwa tej
Rys. 2.5. Składniki schematów
metody opisu układów sterowania wynika z drabinkowych: a) styk czynny; b) styk bierny;
jej graficznej struktury, podobnej c) cewka przekaźnika, zmienna wyjściowa;
d) funkcja specjalna
29

do drabiny8, w której pomiędzy dwoma pionowymi liniami, symbolizującymi przewody
zasilające, wstawiane są poziomo kolejne szczeble9 logiki. Każdy szczebel odpowiada
pojedynczemu wyrażeniu logicznemu i jest zbudowany z symboli styków czynnych i biernych,
bloków funkcji specjalnych, połączonych ze sobą szeregowo lub równolegle. Styki te
reprezentują wejściowe zmienne logiczne danego wyrażenia. Połączenie szeregowe jest
równoważne iloczynowi logicznemu, a równoległe - sumie logicznej tych zmiennych.
Szczebel kończy się umownym symbolem cewki przekaźnika lub sygnału wyjściowego,
przyjmującym stan logicznej „1” przy spełnionym wyrażeniu. Rysunek 2.5 prezentuje
podstawowe symbole graficzne schematów drabinkowych. Elementy schematu drabinkowego
opisuje się symbolicznymi etykietami, a prostokąt funkcji specjalnej wypełnia się zwykle
treścią tej funkcji (np. badaną relacją czasową). Symbole styków mogą odnosić się zarówno do
elementów pamięci (przekaźnik, przerzutnik), jak i do zmiennych wejściowych lub
wyjściowych sterownika. Konkretne znaczenie poszczególnych zmiennych jest definiowane
w tzw. tablicach przypisań.
Przykład 2.1
RF
RB Opis sygnałówsterujących:
PRACA F - praca transportera

RF - roboczy ruch podajnika
RB - powrotny ruch podajnika
A- działanie prasy
LS2
Opis sygnałówwejściowych:
PRACA- włączenie urządzenia

LS3 LS1 - optyczny czujnik detalu do obróbki
A LS2 - krańcówka położenia spoczynkowego
F M LS1 LS3 - krańcówka maksymalnego wysuwu
LS4 - optyczny czujnik detalu po obróbce
LS4
Rys. 2.6. Przykładowy układ formowania detali
Dane jest urządzenie do formowania detali, składające się z napędzanego silnikiem M

transportera, ramienia pneumatycznego podajnika, przemieszczającego surowiec z transportera
do prasy i samej prasy hydraulicznej, nadającej detalowi pożądany kształt. Układ jest
oczujnikowany tak jak to prezentuje rysunek 2.6. Jeden cykl pracy obejmuje takie czynności
jak: praca transportera (aż do zadziałania LS1), ruch podajnika (roboczy i powrotny), działanie
8
termin ang.: „ladder logic”
9
termin ang.: „rung”
30

prasy i usunięcie uformowanego detalu (zadziałanie LS4). Dodatkowo układ posiada ręczny
włącznik PRACA, którego załączenie powoduje wykonanie minimum jednego pełnego cyklu
pracy. Opis pracy układu w konwencji logiki drabinkowej przedstawia rysunek 2.7.
a) c)
Przyporządkowanie sygnałów elementom M104 X4 X0
schematu drabinkowego: M101
PRACA X0 M101 M102 M103 M104
LS1 X1
LS2 X2
LS3 X3 X0
LS4 X4
F Y10 X1 M101
RF Y11 M102
RB Y12
A Y13 M102 M103
Przyporządkowanie stanów pracy przekaźnikom
w schemacie drabinkowym: X3 M102
ruch transportera M101 M103
ruch roboczy podajnika M102 M103 M104
ruch powrotny podajnika M103
praca prasy M104 X2 M103
M104
b)
Realizowane funkcje logiczne: M104 M101
M101=M104X4X0+(X0+M101)/M102/M103/M104
M102=X1M101+M102/M103 M101
M103=X3M102+M103/M104 Y10
M104=X2M103+M104/M101 M102
Y10=M101 Y11
Y11=M102 M103
Y12=M103 Y12
Y13=M104
M104
Y13
Rys. 2.7. Wykorzystanie logiki drabinkowej do opisu realizacji układu sterowania

urządzeniem formującym detale

Powyższy, bardzo prosty przykład prezentuje jedynie główne idee wykorzystania
logiki drabinkowej do opisu układu sterowania. Współczesne rozwinięcia tej metody, poprzez
wspomniane wcześniej bloki funkcji specjalnych, pozwalają uwzględniać w układzie
sterowania bogate możliwości przetwarzania informacji, jakie dają mikroprocesorowe PLC.
Można jednak wskazać pewne niedostatki metody logiki drabinkowej [42, 95]:
 w sterownikach sekwencyjnych, charakteryzujących się zbiorem N stanów układu, użycie
logiki drabinkowej z reguły prowadzi do zbliżonej liczby MN szczebli, z których każdy
jest zakończony umownym przekaźnikiem jako elementem pamiętającym; prowadzi to
31

faktycznie do układu o 2M stanach, z których większość nie jest używana; sytuacja taka
utrudnia w pełni poprawne projektowanie układu;
 brak możliwości komentowania zapisu w tej postaci podczas programowania większości
małych PLC obniża znacząco czytelność programu;
 w odniesieniu do dużych zadań sterowania ten zapis staje się zbyt obszerny, trudny
do projektowania i uruchamiania.
Mimo przytoczonych tu niedogodności, logika drabinkowa pozostaje nadal jedną
z najważniejszych metod opisu sterowania dyskretnego. Bywa także traktowana jako metoda
uzupełniająca inne, bardziej zaawansowane sposoby opisu i programowania sterowników.
2.2.3 Schematy logiczne
Wejście do konstrukcji układów sterowania dyskretnego techniki półprzewodnikowej,

a zwłaszcza elementów SSI/MSI, spopularyzowało kolejny, naturalny w tym przypadku,
sposób opisu. Jest nim schemat logiczny. Faktycznie jest to nadal schemat połączeń, tyle że
z pewnymi uproszczeniami, polegającymi na ograniczeniu się tylko do istotnych, z punktu
widzenia realizowanych funkcji, elementów.
Schematy logiczne składają się ze zbioru standardowych symboli, reprezentujących
bramki logiczne, przerzutniki i inne bloki funkcjonalne. Połączenia pomiędzy tymi elementami
określają realizowane funkcje układu: kombinacyjne i sekwencyjne. Spotykane w schematach
logicznych symbole przedstawia tabela 2.2.
Tabela 2.2
Zestawienie podstawowych symboli logicznych według standardów:
a) amerykańskiego; b) polskiego (PN-84 E-01236); c) niemieckiego
AND OR NOT NAND NOR XOR SR
SQ
a
RQ
& 1 & 1 =1 S T
b
R
c s Q
r Q
Wadą schematów logicznych jest to, że w przypadku bardziej złożonych układów

sterowania, uzyskuje się duży, słabo zrozumiały rysunek. Wymaga on wtedy dodatkowych
opisów wyjaśniających, np. podania realizowanych funkcji w formie wyrażeń logicznych.
Wyrażenia te mogą przedstawiać zarówno tzw. funkcje wyjść, czyli zależności wyjściowych
32

sygnałów sterujących od zmiennych logicznych automatu, jak również funkcje wzbudzeń
poszczególnych przerzutników, jeśli takie występują w układzie. Spotykane jest także
stosowanie innych form opisu uzupełniającego (opis słowny, sieć działań).
2.2.4 Schematy blokowe
Metodą opisu działania układu sterowania zaczerpniętą z technik programowania są

schematy blokowe [85]. Wymyślone wraz z początkami języków programowania służą
symbolicznemu opisowi algorytmu jaki ma być realizowany przez program. Są pośrednią
formą reprezentacji algorytmu na drodze od jego opisu słownego do implementacji
komputerowej. Czytelność i zrozumiałość schematu blokowego jest niejednokrotnie większa
niż opisu słownego. Tworzenie takich schematów sprzyja usystematyzowaniu informacji
o zadaniu, pozwala wskazać dane nadmiarowe i te, których brak do pełnego rozwiązania
problemu.
przetwarzanie we/wy
Na przestrzeni wielu lat stosowania schematów
blokowych wykształciły się pewne standardy ich decyzja START/STOP
tworzenia. Dotyczą one graficznej reprezentacji
schematów, czyli symboli przyporządkowanych
wywołanie
łączniki
poszczególnym rodzajom operacji. Najczęściej używane
Rys. 2.8. Symbole używane
symbole, zgodne z PN-75 E-01226, przedstawia
do budowy schematów blokowych
rysunek 2.8.
Symbol „przetwarzanie” reprezentuje ciągi prostych operacji wykonywanych
sekwencyjnie. Klatki „decyzja” służą rozgałęzieniom w realizacji algorytmu: w ich wnętrzu
wpisuje się warunek (logiczny, arytmetyczny), a przy możliwych odgałęzieniach - wartości
tego warunku powodujące wybór określonej drogi. Blok „wywołanie” służy wskazaniu
konieczności zrealizowania w danym miejscu fragmentu algorytmu zdefiniowanego w innym
miejscu schematu, jako odrębny „podschemat” blokowy. Do wyróżnienia operacji związanych
bezpośrednio z wymianą informacji z urządzeniami zewnętrznymi służą bloki „we/wy”.
Zadaniem bloków „START/STOP” jest zaznaczenie punktów początku i końca działań
opisywanych danym schematem blokowym. Ponieważ schematy blokowe do większych zadań
programistycznych nie mieszczą się na jednej kartce lub wymagają prowadzenia wielu
wzajemnie przecinających się linii, wprowadzono tzw. łączniki: lokalne (kółka)
i międzystronnicowe (pięciokąty). Składniki schematu blokowego łączy się liniami
symbolizującymi możliwe drogi przejścia. Zakłada się przy tym jako naturalny kierunek
33

przejścia z góry w dół, a linie o innym kierunku winny START
być opatrzone grotami. Przykładowy schemat blokowy F:=on

1
PRACA ?
prezentujący algorytm pracy układu z przykładu 2.1 0
0 LS1 ?
przedstawia rysunek 2.9. Szereg przykładowych STOP 1
F:=off
schematów blokowych prostych obiektów
RF:=on
przemysłowych można także znaleźć w [50] .
0
W praktyce okazuje się, że schematy blokowe LS3 ?
1
w odniesieniu do dużych zadań programowych, w tym RF:=off
algorytmów sterowania, nie zdają egzaminu z powodu ich RB:=on
znacznej rozciągłości na płaszczyźnie i poważnych 0

LS2 ?
utrudnień w jakże częstych przypadkach modyfikacji.
1
Z powyższych względów nie są one zbyt popularne A:=on
w opisie układów sterowania dyskretnego. 0

LS4 ?
1
A:=off
Rys. 2.9. Schemat blokowy

działania układu sterowania
z przykładu 2.1
2.2.5 Sieci operacyjne
Jeszcze jedną graficzną formą opisu działania systemu jest sieć operacyjna [18, 85].
Tworzy się ją na podstawie schematu strukturalnego procesu znajdującego się w stanie
początkowym i na podstawie odpowiedniego opisu słownego.
Definicja 2.1 [65]

Sieć operacyjną stanowi trójka:
SO = < Z , X , W >
gdzie:
Z={Z1, Z2,..., Zm} jest skończonym zbiorem elementów zwanych operacjami;
X={x1,x2,...,xn} jest skończonym zbiorem elementów zwanych zmiennymi wejściowymi
procesu;
W={W1, W2,..., Ww} jest skończonym zbiorem elementów zwanych węzłami operacji
alternatywy lub koniunkcji.

34

Do prezentacji poszczególnych operacji i powiązań przyczynowo-skutkowych
pomiędzy nimi wykorzystuje się zbiór symboli graficznych:
 klatka operacji jednoelementowej, zawierająca słowny lub symboliczny opis elementarnej
operacji technologicznej (rysunek 2.10.a);
 klatka operacji dwuelementowej, zawierająca słowny lub symboliczny opis elementarnej
operacji technologicznej Zj i operacji jej przeciwstawnej Zj (rysunek 2.10.b);
 klatka warunkowa operacji, zawierająca zmienne wejściowe bezpośrednio związane z tą
operacją, ma ona jedno wejście i dwa wyjścia „TAK” i „NIE”, których stan zależy
od spełnienia podanego warunku (rysunek 2.10.c);
 klatka warunkowa niezależna, wykorzystująca zmienne wejściowe związane z innymi
operacjami, mająca tylko dwa wyjścia „TAK” i „NIE”, o stanie zależnym od spełnienia
podanego wewnątrz warunku (rysunek 2.10.d);
 klatki typu „START”, „STOP”, „ALARM” służące do reprezentacji początku i końca
procesu lub innych szczególnych sytuacji (rysunek 2.10.e);
 węzeł dwuargumentowej sumy logicznej (rysunek 2.10.f); może też to być operacja
wieloargumentowa;
 węzeł dwuargumentowego iloczynu logicznego (rysunek 2.10.g); może też to być operacja
wieloargumentowa;
 rozgałęzienia sygnałów (rysunek 2.10.h).
a) b) c) d) e)
Zi Zj :Zj* wari warj START

N N
T T
STOP
f) g) h)
x1 x2 x1 x2
y=x1+x2 y=x1 x2 ALARM
Rys. 2.10. Symbole graficzne stosowane do tworzenia sieci operacyjnych
Przy graficznym zapisie sieci operacyjnej zakłada się, jako naturalną, kolejność operacji
od góry do dołu, w związku z czym nie we wszystkich przypadkach stosuje się groty
wskazujące kierunek przejścia.
35

Przykład 2.2
S START
A B
CPB CPA CPB=1

WK1 WK2 WK4 WK3 T
CPA
N
KA KB SA : SA
SA SB ALARM
WK2=1
N
EZ1 EZ2 T
Rys. 2.11. Schemat strukturalny dozownika dwóch WK1=1

materiałów sypkich T
SA : SA
Prostym przykładem użycia sieci operacyjnej
WK2=1
do opisu procesu może być dozownik dwóch sypkich N
T
składników A i B, w proporcji 2:1, przedstawiony
WK1=1
na rysunku 2.11 [66]. Działanie tego urządzenia można
T
streścić na przykładzie dozownika A następująco: SB : SB
wysuw siłownika SA (wywołany elektrozaworem EZ1)

WK4=1
powoduje przesunięcie kasety odmierzającej KA nad N
T
otwór wysypowy z jednoczesnym zamknięciem wylotu
WK3=1
silosu, położenie kasety nad otworem sygnalizuje
T
krańcówka WK2, której zadziałanie wymusza powrotny
ruch siłownika aż do zadziałania krańcówki WK1, gdy Rys. 2.12. Sieć operacyjna
do przykładu z rysunku 2.11
kaseta znajduje się pod silosem jest napełniania
grawitacyjnie, opisany ruch siłownika jest powtarzany cyklicznie dopóki jest sygnał z czujnika
poziomu CPA o obecności materiału A w silosie. Cykl pracy dozownika A jest realizowany
dwukrotnie, by później w analogiczny sposób wykonać jeden cykl pracy dozownika B.
Sieć operacyjną opisującą działanie tego dozownika przedstawia rysunek 2.12.

2.2.6 Sieci Petriego
Kamieniem milowym w dziedzinie modelowania różnego rodzaju procesów, w tym

także dyskretnych, była opublikowana na początku lat sześćdziesiątych teoria sieci Petriego
(SP). Zaletą jej jest możliwość modelowania różnych klas systemów:
36

 zarówno o dominujących procesach ciągłych jak i dyskretnych;
 deterministycznych lub stochastycznych;
 o strukturze hierarchicznej lub rozproszonej;
 synchronicznych i asynchronicznych;
przy posługiwaniu się wspólnym aparatem pojęciowym. Własności SP sprawiły, iż stosuje się
je do rozwiązywania zadań związanych z projektowaniem i programowaniem sterowników
mikroprocesorowych.
Dodatek 4 zawiera podstawy teoretyczne i omówienie sposobów reprezentacji jednej
z popularniejszych odmian sieci Petriego - pozycja/tranzycja.
Stosowanie sieci Petriego do modelowania procesów dyskretnych polega na doborze
najodpowiedniejszej do danego zadania odmiany sieci. Bardzo często bazą wyjściową są tu
tzw. zwykłe sieci Petriego, których jednym z rozszerzeń są omawiane wcześniej sieci P/T.
Definicja 2.2
Niech PN należy do sieci P/T. Sieć PN nosi nazwę zwykłej sieci Petriego (sieci markowanej)
wtedy i tylko wtedy, gdy zachodzą warunki:
(i) K(p) =   p  P;
(ii) W(x,y) = 1  (x,y)  E.

Zwykłe sieci Petriego dzielą się jeszcze na podklasy:
 maszyny stanów;
 grafy znakowane;
 grafy wolnego wyboru;
 rozszerzone grafy wolnego wyboru.
Ich definicje i przykłady ilustrujące można znaleźć w [9], a przykład zastosowania grafu
znakowanego do syntezy układu sterowania binarnego na bramkach i przerzutnikach - w [69].
Innymi rozszerzeniami zwykłych sieci Petriego, które znalazły zastosowanie do sterowania
procesami dyskretnymi, są:
 sieci z łukami wzbraniającymi;
 systemy pozycja/tranzycja;
 sieci czasowe, pozwalające uwzględniać rzeczywiste czasy trwania modelowanych
procesów [70, 80];
 sieci kolorowane [16];
37

 stochastyczne [24];
 predykatowe;
 rozmyte;
 neuronowe.
Duże możliwości modelowania różnorodnych zjawisk za pomocą aparatu sieci
Petriego mogą być wykorzystane jedynie za pośrednictwem odpowiedniego oprogramowania
narzędziowego.
Programowe implementacje sieci Petriego można podzielić na trzy grupy:
1. Uniwersalne pakiety narzędziowe, wspomagające tak badacza jak i użytkownika
w zadaniach syntezy i analizy różnych wariantów modeli sieciowych systemów i procesów.
O skuteczności tego typu oprogramowania decydują jego elementy składowe, takie jak:
edytory grafiki (najczęściej zorientowane problemowo), edytory tekstu, programy analizy
i symulacji działania sieci [96].
2. Problemowo zorientowane pakiety oprogramowania użytkowego, wspomagające operatora
w projektowaniu i eksploatacji rzeczywistych układów sterowania. W tym przypadku
formalizm sieci Petriego jest wykorzystywany jako narzędzie pomocnicze, niewidoczne dla
operatora. Pakiety te umożliwiają symulację, programowanie i testowanie kolejnych
wariantów rozwiązania. Są wśród nich także pakiety przeznaczone do programowania
sterowników przemysłowych.
3. Implementacje wbudowane (stosunkowo nieduża grupa), polegające na zapisaniu
bezpośrednio w pamięci ROM sterownika wąsko specjalizowanego, zorientowanego
problemowo, translatora opisu sieci na kod sterujący. Rozwiązanie takie jest możliwe
jedynie wtedy, gdy znana jest a priori wąska klasa sterowanych procesów, różniących się
między sobą konkretnymi danymi, dotyczącymi np. czasu trwania poszczególnych operacji
lub kolejności ich wykonania. Przykładem takiego zastosowania może być sterownik EMP
(elastycznego modułu produkcyjnego) [9]. Może się on składać z kilku maszyn
realizujących różne fazy obróbki detali i robotów przemieszczających te przedmioty
pomiędzy maszynami i magazynami. Programowanie takiego EMP polega
na przystosowaniu go do jednoczesnej obróbki kilku różnych detali.
Implementacje sieci Petriego na potrzeby sterowania wskazują [18], że złożoność
matematycznego modelu reprezentującego taką sieć na potrzeby np. sterowania rośnie
eksponencjalnie wraz ze wzrostem liczby pozycji i tranzycji. Ponieważ powoduje to
38

konieczność stosowania dużych pamięci danych i znacznego obciążenia czasowego procesora,
stanowi pewne utrudnienie w szerokim zastosowaniu metody.
2.2.7 Automaty skończone i grafy przejść
Jeszcze jedną formą opisu sterowania dyskretnego jest potraktowanie układu

obiekt-sterownik jako automatu skończonego. Przy założeniu mikroprocesorowej realizacji
sterownika uzyskuje się automat synchroniczny (synchronizm jest w tym przypadku atrybutem
systemu mikroprocesorowego). Definicję takiego automatu można podać za [79].
Definicja 2.3
Automatem skończonym, synchronicznym, z wyjściami nazywamy uporządkowaną piątkę
AS = < S , X , Y ,  ,  >
gdzie: S = {s1, s2, ..., sN} jest zbiorem stanów automatu, takim że ||S|| = N i 1 < N < ;
X = {x1, x2, ..., xK} jest zbiorem słów wejściowych;
 jest funkcją przejść, przyporządkowującą parze (st , xt) w chwili t nowy stan w chwili
następnej t+1: (st , xt) = st+1 ;
Y = {y1, y2 , ..., yM} jest zbiorem słów wyjściowych;
 jest funkcją wyjść przyjmującą jedną z poniższych postaci:
yt = (st) - dla automatu klasy Moore’a;
yt = (st, xt) - dla automatu klasy Mealy’ego.

Przez słowo wejściowe lub wyjściowe rozumie się w powyższej definicji zerojedynkową
kombinację zmiennych wejściowych lub wyjściowych.
Użytą w powyższej definicji funkcję przejść  można opisać na trzy sposoby:
 za pomocą zorientowanego grafu przejść, którego węzły odpowiadają stanom si  S
automatu AS, a skierowane krawędzie symbolizują możliwe przejścia pomiędzy nimi i są
opisane wyrażeniami logicznymi, których spełnienie jest warunkiem realizacji tych przejść;
 za pomocą tablicy przejść, która  si  S i  xk  X podaje stan następny sj  S
(w szczególności może zachodzić si = sj, co oznacza brak przejścia);
 za pomocą uporządkowanej listy wyrażeń logicznych warunkujących poszczególne
przejścia.
39

Funkcję wyjść  automatu AS można podać w formie:
 wyrażeń logicznych, których argumentami są stany automatu (układ Moore’a) albo stany
automatu i słowa wejściowe (układ Mealy’ego);
 tablicy wyjść odpowiedniej do klasy automatu.
Przykład 2.3
Dany jest automat skończony AS o stanach S={s1, s2, s3, s4}, słowach wejściowych X={x1, x2,
x3, x4}, słowach wyjściowych Y={y1, y2, y3}. Cztery słowa wejściowe oznaczają w tym
przypadku cztery możliwe kombinacje: 00, 01, 11, 10, dwóch wejściowych zmiennych
binarnych automatu, a trzy słowa wyjściowe - kombinacje: 00, 01, 11, dwóch zmiennych
wyjściowych. Tablicę przejść, graf przejść i tablicę wyjść tego automatu podaje rysunek 2.13.
a) b) c)
x4 x1
x2
X x 1 x2 x3 x 4 s2 s3 S Y stan wyjść
S x1 x3
s1 y1 00
s1 s2 s 1 s4 s4 x3 x1 x2+x4 x3 s2 y3 11
s2 s4 s 3 s1 s2
s3 y2 01
s3 s3 s 4 s1 s4 x3+x4
s1 s4 s4 y2 01
s4 s1 s 1 s3 s4 x2 x1+x2 x4
Rys. 2.13. Opis przykładowego automatu skończonego:

a) tablica przejść; b) graf przejść; c) tablica wyjść

Przedstawiony w powyższym przykładzie automat ma określone wszystkie elementy
tablicy przejść, jest on więc automatem zupełnym. W praktyce sterowania dyskretnego
sytuacja taka zdarza się niezmiernie rzadko. Tablice przejść rzeczywistych automatów mają
z reguły wiele elementów nieokreślonych - są automatami niezupełnymi. Ponadto, w zbiorze
funkcji przejść można nie uwzględniać funkcji, dla których zachodzi (si,X) = si, należy tylko,
przy późniejszej implementacji automatu, nie pomylić tych przypadków z nieokreślonymi
stanami następnymi. Ograniczenie się jedynie do istotnych, tzn. zmieniających stan automatu,
funkcji przejść pozwala uzyskać bardzo zwięzły opis pracy układu. Opis ten może być
uzupełniony grafem przejść, poglądowo ilustrującym działanie automatu i tablicą wyjść,
informującą o wartościach zmiennych wyjściowych w poszczególnych stanach pracy.
Zastosowanie teorii automatów skończonych i dostępnych narzędzi ich opisu
umożliwia projektantowi uzyskanie dosyć zwięzłej reprezentacji zadania sterowania,
40

przydatnej w opisywaniu dużej liczby złożonych sytuacji lub warunków. Reprezentacja ta jest
o wiele czytelniejsza niż opis słowny i łatwa w implementacji programowej [18]. Metodologia
automatów skończonych w odniesieniu do zadań sterowania binarnego wydaje się być, obok
sieci Petriego i ich pochodnych, najważniejszą alternatywą dla logiki drabinkowej [23, 42].
2.2.8 Wykresy czasowe
Należy także wspomnieć o jeszcze jednej graficznej formie opisu zadania sterowania,
jaką są wykresy czasowe. Historia ich stosowania do prezentacji pożądanego zachowania się
sterowanego obiektu jest bardzo długa. Towarzyszyły one zwykle tekstowym opisom, jako ich
uzupełnienie, przedstawiając graficznie stany i zmiany stanów urządzenia. Z upływem lat
wykształciły się dwa ich rodzaje [85, 88]:
1. wykresy stanów, przedstawiające przebiegi czasowe wszystkich wejść i wyjść z podziałem
na odcinki czasu (kroki), w których sygnały te nie zmieniają się; wykresy te są także
stosowane przy opisie sekwencyjnych układów logicznych do wyróżniania kolejnych
stanów automatu;
2. wykresy ruchu, spotykane w dwóch odmianach:
 wykresy drogi, przedstawiające ruch maszyny w układzie jednej współrzędnej, przez co
nadają się jedynie do opisu najprostszych zadań;
 wykresy drogowo-czasowe, przedstawiające działanie urządzenia w układzie dwóch
współrzędnych;
Obie odmiany wykresów ruchu mogą być wzbogacone dodatkowymi symbolami
odnoszącymi się do stanu sygnałów wejściowych, wykonywanych przez mechanizmy
ruchów, zależności czasowych, itd.
Wykresy czasowe dla urządzenia do formowania detali z przykładu 2.1 przedstawia
rysunek 2.14. Inne przykłady wykresów drogowo-czasowych można znaleźć w [90].
41

a) b) praca
on
LS1
praca
F
LS1 off
LS4
LS2 on LS3
LS3 RF
off
LS1
LS4
on LS2
F
RB
RF off
LS3
RB on
A A
off
LS2
Rys. 2.14. Przykładowe wykresy czasowe: a) stanów; b) drogowo-czasowy
42

2.3 Metody programowania sterowników PLC
Pojawienie się programowalnych sterowników PLC wymusiło na ich producentach

podjęcie prac rozwojowych nad narzędziami wspomagającymi proces ich programowania.
Pierwsze propozycje w tej dziedzinie wykorzystywały standaryzowane schematy logiki
drabinkowej. Pojawiły się także propozycje języków bazujących na liście rozkazów.
Przełomem było przeniesienie teorii sieci Petriego i opracowanie standardu Grafcet.
Nie przerwało to jednak dalszych poszukiwań innych, zorientowanych problemowo, metod
opisu i programowania PLC. Niniejszy rozdział jest poświęcony przeglądowi zarówno
podstawowych sposobów programowania, jak i efektom poszukiwań nowych metod.
2.3.1 Języki logiki drabinkowej LAD
Fakt, iż pierwsze realizacje układów sterowania binarnego były wykonane w jedynej

dostępnej ówcześnie technologii przekaźnikowej, zaznaczył się trwałym śladem w dziedzinie
języków programowania sterowników PLC. Mimo stosowania zamiast przekaźników
cyfrowych układów scalonych, a później programowalnych systemów mikroprocesorowych,
nadal, siłą przyzwyczajenia, program pracy opisywano przy pomocy logiki drabinkowej.
Spowodowało to stworzenie narzędzi wspomagających programowanie sterowników właśnie
tą techniką.
Języki logiki drabinkowej są graficznym przedstawieniem algorytmu sterowania
za pomocą takich elementów jak przekaźniki zwykłe i czasowe oraz ich styki. Utrzymały się
one także po wprowadzeniu mikroprocesorowych sterowników PLC. Dostawcy tych urządzeń
nadal traktują język typu LAD10 jako jeden z możliwych standardów programowania swoich
produktów [93]. Ponieważ wprowadzenie do sterowania binarnego mikroprocesorów znacznie
rozszerzyło dostępne funkcje użytkowe, języki LAD wzbogaciły się o odpowiednie symbole
umożliwiające projektantowi systemu sterowania dostęp do tych funkcji. Czasami języki LAD
są tylko uzupełniającym sposobem opisu sterowania. Przykładem mogą być języki
wykorzystujące standard GRAFCET (punkt 2.3.3) jako podstawę programowania, w których
logika drabinkowa jest jedynie jednym z alternatywnych sposobów opisu elementarnych
kroków algorytmu.
W strukturze programu w języku typu LAD można wyodrębnić dwie części: sterującą
i wykonawczą [89]. W części sterującej opisuje się sterownik krokowy, którego poszczególne
10
LAD - LADder
43

kroki są reprezentowane przez kolejne szczeble logiki drabinkowej. Użyte w definicji tych
szczebli styki i funkcje specjalne służą określeniu wzajemnych zależności pomiędzy krokami
sterownika i warunków przejść pomiędzy nimi. Symbole przekaźników (przerzutników)
umieszczone na końcach tych szczebli odpowiadają znacznikom kroków. Jeżeli z algorytmu
sterowania wynika N różnych stanów pracy, to część sterująca programu LAD składa się z N
szczebli. Przykładem tego są szczeble M101, M102, M103 i M104 z rysunku 2.7.c. Podejście
takie oznacza kodowanie kolejnych stanów pracy kodem 1zN wymagającym dużej liczby
elementów pamiętających. Część wykonawcza programu typu LAD służy zdefiniowaniu
funkcji wyjść, czyli wyrażeń logicznych, których argumentami są określone w części sterującej
znaczniki kroków, a wartościami - stany sygnałów wyjściowych sterownika.
Ważnym elementem składni języków drabinkowych są timery i liczniki. Timery
umożliwiają programowanie opóźnień lub czasu trwania określonych czynności, a liczniki
zwykle służą do zliczania zdarzeń (np. przesuwających się na transporterze wyrobów). Timery
i liczniki mogą być inicjowane wartościami początkowymi, kasowane, zatrzymywane.
Ich zawartość może być testowana, porównywana w relacjach arytmetycznych ze stałymi
programowymi. Te dodatkowe operacje na timerach i licznikach są programowane
za pośrednictwem bloków funkcji specjalnych, które oprócz tego mogą służyć innym, bardziej
złożonym obliczeniom arytmetycznym i logicznym. Często też języki LAD udostępniają
struktury rejestrów przesuwających, które mogą być wstawiane w szczeble drabiny logicznej.
Wiele przykładowych programów w językach LAD można znaleźć w [81, 86, 95, 97].
Do programowania sterowników PLC za pośrednictwem języków typu LAD używa
się często mikrokomputerów klasy PC (zwykle przenośnych), wyposażonych w odpowiednie
oprogramowanie. Programy narzędziowe języków LAD wykorzystują wszelkie możliwości
komunikacji z projektantem, jakich dostarczają im te mikrokomputery. Program pracy
sterownika jest przesyłany do niego w odpowiednio zakodowanej formie, np. poprzez łącze
szeregowe. Innym rozwiązaniem spotykanym przy programowaniu PLC językami typu LAD
jest stosowanie, bezpośrednio połączonych ze sterownikiem, paneli programujących,
składających się z ekranu i klawiatury funkcyjnej. Producenci sterowników oferują także jako
wyposażenie dodatkowe przenośne, ręczne programatory z wyświetlaczem LCD i klawiaturą
funkcyjną. Posługiwanie się zarówno programatorami wbudowanymi jak i przenośnymi polega
na przeglądaniu w trybie edycji całej drabiny programu sterowania, szczebel po szczeblu,
i wnoszeniu ewentualnych modyfikacji.
44

Stosowanie języków logiki drabinkowej, mimo pozornej ich przystępności, nastręcza
pewne kłopoty, związane między innymi:
 z koniecznością dwukrotnej analizy problemu w celu zaprogramowania dwóch części
programu: sterującej i wykonawczej [89];
 z trudnym dostępem do bogatych możliwości funkcjonalnych oferowanych przez
mikroprocesorowe PLC;
 z dużymi rozmiarami programu przedstawionego w formie logiki drabinkowej,
utrudniającymi panowanie nad jego treścią;
 z wymaganymi większymi zasobami pamięciowymi do przechowywania programowej
implementacji zapisu logiki drabinkowej.
Z powyższych względów zasadność stosowania tego typu języków programowania PLC
występuje wtedy, gdy:
 istnieją już gotowe schematy elektryczne (np.: starej, przekaźnikowej wersji układu
sterowania);
 dysponuje się ograniczonym zasobem narzędzi wspomagających programowanie (tylko
ręczne programatory lub wbudowane panele programujące);
 operuje się na bardzo prostych mikrosterownikach [22].
2.3.2 Języki tekstowe STL
Języki typu STL11 przeznaczone do programowania sterowników PLC zaczęły

powstawać równolegle z językami logiki drabinkowej. Ich składnia obejmuje zestaw rozkazów
realizujących różnego rodzaju operacje [98]:
 podstawowe działania logiczne i arytmetyczne, operujące na różnych typach danych (bity,
bajty, słowa);
 rozkazy odnoszące się do specjalnych struktur operacyjnych sterownika, takich jak timery,
liczniki, rejestry przesuwające;
 złożone operacje arytmetyczne, przydatne nie tylko w realizacji algorytmów sterowania
binarnego;
 rozkazy pozwalające stosować elementy programowania strukturalnego (wywołania
procedur, powroty z procedur, pętle programowe, skoki, itp.);
11
STL - STatment List
45

 rozkazy obsługujące wymianę informacji łączami komunikacyjnymi (porty szeregowe, sieci
LAN12).
Przykładowe listy rozkazów języków STL można znaleźć w [92]
W strukturze programu zapisanego w języku STL nie zauważa się
charakterystycznego dla zapisu LAD podziału na część sterującą i wykonawczą. Rozkazy
obsługujące wyjścia sterownika przeplatają się zwykle z rozkazami nadzorującymi
wykonywanie kolejnych kroków algorytmu sterowania. Każdy krok programu zapisanego
w STL jest reprezentowany przez jedno lub kilku zdań logicznych, które w ogólnym
przypadku składają się z części warunkowej i części wykonawczej. Zadaniem części
warunkowej jest porównanie rzeczywistego stanu zmiennych wejściowych ze stanem
wzorcowym. Wynik tego porównania decyduje o realizowaniu lub nie realizowaniu części
wykonawczej.
Język STL jest zwykle alternatywnym względem języka LAD sposobem
programowania sterowników, poszerzającym możliwości wykorzystania PLC o operacje, które
byłyby trudne lub wręcz niemożliwe do zaprogramowania logiką drabinkową. W literaturze
[89, 95] można znaleźć przykłady programów pisanych równolegle w językach LAD i STL. Z
najważniejszych zalet języków STL w porównaniu z językami logiki drabinkowej należy
wymienić:
 bardziej zwarty zapis;
 możliwości stosowania elementów programowania strukturalnego;
 dużo większe możliwości wykorzystania zasobów funkcjonalnych PLC.
Języki STL są wygodniejsze w użyciu od logiki drabinkowej, gdy zadanie sterowania jest
opisane funkcjami logicznymi, wykresami czasowymi, schematami blokowymi czy też
sieciami działań.
2.3.3 Grafcet
2.3.3.1 Geneza języka
Operowanie opisanymi w poprzednich punktach metodami programowania

sterowników nie zaspokajało jednak ambicji producentów i użytkowników sterowników
mikroprocesorowych. Bogactwo dostępnych funkcji tych urządzeń, duża elastyczność w ich
12
LAN - Local Area Network
46

przeprogramowywaniu, coraz powszechniejsza dostępność mikrokomputerów jako narzędzi
wspomagających, skłoniła niektórych producentów sterowników do podjęcia prac nad nowym
sposobem programowania tych urządzeń.
Poszukiwania rozwiązania tego problemu rozpoczęto od przeglądu istniejących już
metod modelowania procesów przemysłowych. Stosunkowo młodą, ale bardzo obiecującą
metodologią postępowania były w tej dziedzinie sieci Petriego. Te właśnie sieci przyjęto
za bazę do tworzenia języka programowania sterowników. Po raz pierwszy założenia nowego
języka programowania zostały zawarte w raporcie końcowym komisji AFCET (Association
Francaise pour la Cybernetique, Economique et Technique) w sierpniu 1977 jako rezultat
dwóch lat pracy zespołu złożonego z projektantów i użytkowników systemów automatyki
przemysłowej. Celem prac tego zespołu było opracowanie takiego standardu opisu procesów,
który mógłby być następnie implementowany w sterownikach mikroprocesorowych. Zalążek
nowego standardu nazwano Grafcet, a jego głównym propagatorem była i jest po dziś dzień
francuska firma Telemecanique, zajmująca się produkcją sterowników przemysłowych.
Ponieważ powyższa propozycja standardu nie została entuzjastycznie przyjęta przez
producentów sprzętu automatyki spoza Francji, podjęto szybko dalsze wysiłki nad takim jej
dopracowaniem, aby uzyskać język programowania o szerokim zakresie zastosowań
i możliwości implementacyjnych w odniesieniu do różnych typów sterowników. Efektem tych
prac, prowadzonych w agencji ADEPA (Agence nationale pour le Developement de la
Produktion Automatique), był opublikowany w kwietniu 1979 raport, który stał się podstawą
dla większości światowych i europejskich norm dotyczących standardu Grafcet. Pierwszą była
norma francuska NF-C-03-190-UTE z 1982 roku. Od tego momentu rozpoczęły się prace nad
praktycznymi implementacjami Grafcet na różne sterowniki.
Grafcet jest formalnym sposobem opisu i analizy funkcjonowania systemu
sterowania, przydatnym zwłaszcza tam, gdzie działanie systemu jest sekwencyjne i może być
zdekomponowane na pewną liczbą etapów podstawowych. Wśród zalet Grafcet można
wymienić [27]:
 niezależność od technicznego sposobu realizacji zadania;
 możliwość racjonalnego wyboru zmiennych stanu;
 jednoznaczny opis działania systemu tak sterowanego, jak i z wyłączonym sterowaniem;
 możliwość synchronizacji równolegle wykonywanych operacji;
 wygodny opis systemów charakteryzujących się dużą liczbą zmiennych wejściowych,
wyjściowych i zmiennych stanu;
47

 możliwość bezpośredniej realizacji układowej lub programowej opisanego algorytmu
sterowania;
 przyśpieszenie prac uruchomieniowych i rozwojowych nad danym systemem sterowania.
Język Grafcet, chociaż opracowany przede wszystkim jako narzędzie programowania
sterowników, okazał się także bardzo skutecznym środkiem opisu samych procesów
technologicznych. Jego możliwości dokładnego, przejrzystego opisu etapów procesu
i zależności między nimi zdobyły mu dużą popularność.
2.3.3.2 Zastosowanie Grafcet w sterowaniu
W Dodatku 5 przedstawiono składnię i reguły modelowania różnorodnych procesów

przy użyciu języka Grafcet. Mimo licznych zalet, nie jest to jeszcze standard, który mógłby
programować wszystkie operacje sterownika w ramach pełnego cyklu sterowania
obejmującego takie działania jak:
1. inicjalizację cyklu, obejmującą takie działania jak: ustalenie trybu pracy, autodiagnostyka;
2. odczyt stanu wejść, będący zwykle operacją wewnętrzną każdego sterownika, polegającą
na skopiowaniu bieżącego stanu kompletu sygnałów wejściowych do bufora w pamięci
RAM;
3. wstępną obróbkę danych wejściowych, która może polegać na zaprogramowanej przez
użytkownika inicjalizacji sterownika, restarcie, inicjalizacji grafów modelujących,
przygotowaniu danych wykorzystywanych przez Grafcet;
4. zmianę stanu procesu (stanu grafu), realizowaną każdorazowo jako ciąg następujących
operacji:
 wartościowanie wyrażeń logicznych opisujących warunki poszczególnych przejść;
 aktualizacja tablicy aktywności etapów;
 aktualizacja tablicy gotowości przejść;
 zapalenie przejść, które są gotowe, tzn.: dezaktywacje etapów poprzedzających te
przejścia i uaktywnienie etapów bezpośrednio po nich następujących;
 realizacja procedur (działań) przypisanych aktywnym etapom;
5. kontrola stanu makroetapów monoaktywnych (w celu wychwycenia stanu aktywności
więcej niż jednego etapu w ich wnętrzu).
6. końcową obróbkę danych, polegającą zwykle na przygotowaniu informacji w buforze
sygnałów wyjściowych w pamięci RAM;
48

7. wysterowanie wyjść, czyli przepisanie zawartości bufora wyjściowego z pamięci RAM
do odpowiednich portów wyjściowych sterownika, podobnie jak odczyt stanu wejść może
być wewnętrzną operacją podstawowego oprogramowania sterownika.
Spośród wymienionych zadań jedynie zmiana stanu procesu może być opisana
za pomocą sieci Grafcet. Dzieje się tak, gdyż w składni Grafcet nie przewidziano komend
(etapów) służących wymianie informacji z otoczeniem sterownika i jej bezpośrednią obróbką.
Działania te są nadal programowane za pomocą języków typu LAD lub STL.
Sama realizacja sieci Grafcet we wnętrzu sterownika mikroprocesorowego może mieć
dwojaki charakter:
1. realizacja pośrednia, polegająca na zaimplementowaniu algorytmów realizujących zmianę
stanu procesu w ogólnie stosowanych językach programowania mikroprocesorów;
2. realizacja bezpośrednia, wykorzystująca specjalizowane języki programowania, zawierające
odpowiedni zestaw instrukcji uwzględniający elementy składni Grafcet (etapy, przejścia,
początki i końce połączeń wielokrotnych, skoki do etapów i gałęzi połączenia
wielokrotnego); przykładem może tu być język programowania sterowników rodziny
ALSPA ZS firmy CGEE Alsthom [27] - podzbiór instrukcji tego języka służących
opisywaniu sieci Grafcet prezentuje tabela D.4 w Dodatku 3.
Należy także zaznaczyć, że w początkowej fazie rozwoju Grafcet czyniono próby
zastosowania tej metody do projektowania prostych układów sterowania wykonanych
w technologii MSI i SSI [28].
2.3.4 PL7-3 jako modyfikacja standardu
Język PL7-3 [9], a właściwie system programowania, powstał jako kolejna (trzecia)
implementacja standardu Grafcet w firmie Telemecanique. Przeznaczony jest on dla rodziny
sterowników TSX, a może być użytkowany, zależnie od implementacji, w konsolach
i terminalach programowania lub na komputerach osobistych. Składa się on z trzech modułów
programowania:
 języka schematów przekaźnikowych;
 właściwego Grafcet;
 języka Litteral, będącego odpowiednikiem schematów przekaźnikowych wykorzystującym
kody mnemoniczne.
Niniejszy punkt prezentuje skrótowo moduł Grafcet systemu PL7-3.
49

Model sieciowy Grafcet zawiera:
 jeden graf główny;
 maksimum 64 makroetapy (numerowane 0..63).
Każdy graf, główny lub będący rozwinięciem makroetapu, może zawierać maksimum 128
etapów i dowolną liczbę z 64 dostępnych makroetapów. Każde rozwinięcie makroetapu musi
zawierać etap początkowy (wejściowy) IN oraz etap wyjściowy OUT. Całkowita liczba etapów
początkowych nie może przekraczać 64.
Programowanie polega na wypełnianiu specjalnych formularzy odpowiadających
ekranom programowania w konsoli lub terminalu. Strona takiego formularza jest podzielona
na trzy pola:
 nagłówka zawierającego ogólne informacje i komentarze;
 pola symboli podzielonego na prostokąty przeznaczone do wpisywania pojedynczych
symboli graficznych Grafcet, takich jak: etapy, makroetapy, tranzycje, rozgałęzienia
krawędzi skierowanych, przeniesienia krawędzi „z” i „do” innej strony programu (symbole
przeniesienia zostały wprowadzone, ponieważ na jednej stronie formularza można umieścić
maksimum po 48 symboli etapów i tranzycji, co nie wyczerpuje założonych możliwości
opisu sieci);
 pola komentarzy (do 60 znaków) odpowiadających poszczególnym liniom etapów
i tranzycji (istnieje tu pewne utrudnienie polegające na tym, że jeden komentarz może się
odnosić do kilku etapów lub tranzycji).
Język PL7-3 oraz jego poprzednicy (PL7-1 i PL7-2) są składnikami większego systemu
uruchomieniowego firmy Telemecanique o nazwie XTEL. System ten umożliwia także
korzystanie ze schematów przekaźnikowych, GRAFCET lub Litteral. Ponadto projektant
ma, między innymi, możliwość w trybie pracy on-line:
 zapisu programu do pamięci EPROM lub do pamięci sterownika;
 animacji i testowania programów pracujących w czasie rzeczywistym;
 modyfikacji programów w trakcie pracy sterownika;
 przeglądania i modyfikacji pamięci danych sterownika;
 uruchamiania programów do pracy ciągłej, cyklicznej lub krokowej.
50

2.3.5 Pakiet OPUS
OPUS jest pakietem oprogramowania narzędziowego dla sterowników STERISS-2

(prod. Instytutu Systemów Sterowania w Katowicach), służącym do przygotowania,
testowania, uruchamiania i dokumentowania programów aplikacyjnych [61]. Pakiet ten ma
niewielkie wymagania sprzętowe i programowe w stosunku do mikrokomputera, na którym ma
być użytkowany: 640kB RAM, RS232C, Hercules/EGA, drukarka, programator pamięci
EPROM, minimum MS-DOS 3.x. Dodatkowym wymogiem wobec sterownika STERISS jest
zainstalowanie w nim systemu operacyjnego IRT. OPUS cechuje się:
 prostotą obsługi (interfejsy graficzne, rozwinięte, hierarchiczne menu);
 łatwością jego opanowania (system pomocy i podpowiedzi prowadzących projektanta przez
kolejne fazy projektu);
 znaczną efektywnością (kontrola poprawności projektu).
W skład pakietu wchodzą następujące programy:
 MAN - program zarządzający pakietu;
 ESTER - edytor graficzny do przygotowania programu sterowania w składni GRAFCET;
 LOGEL - kompilator specjalizowanego języka opisu procesu sterowania na kod
wewnętrzny sterownika;
 DRAGON - program do testowania i uruchamiania aplikacji bezpośrednio na obiekcie.
W dalszej części pracy zostaną pokrótce przedstawione trzy najważniejsze składniki
systemu OPUS.
2.3.5.1 ESTER
ESTER jest specjalizowanym edytorem graficznym umożliwiającym [49]:

 tworzenie algorytmu sterowania w formie diagramów zgodnych z GRAFCET;
 określanie powiązań algorytmu sterowania ze sterownikiem i obiektem;
 bezpośrednią translację diagramów na język opisu procesu sterowania LOGEL;
 przygotowanie i wydruk dokumentacji algorytmu sterowania.
Użytkownik ma do dyspozycji system hierarchicznego menu i wielopoziomowych okien
dialogowych.
Rysowanie diagramów reprezentujących algorytm sterowania ułatwia odpowiedni
interfejs graficzny w trybie edycji schematu, która polega na wskazaniu na ekranie punktu
edycji i wybraniu z menu wstawianego lub zmienianego symbolu graficznego lub innej
51

operacji (np. usunięcie zaznaczonego symbolu ze schematu). Obszarem roboczym edytora jest
pojedynczy arkusz, przyjmujący w drukowanej dokumentacji postać jednej strony formatu A4.
Jest on umownie podzielony na:
 nagłówek u góry arkusza, przeznaczony do wpisywania ogólnych informacji
charakteryzujących projekt;
oraz trzy kolumny poniżej, które służą:
 do rysowania diagramu przy użyciu symboli GRAFCET;
 do formalnego (przy pomocy podzbioru prostych instrukcji języka LOGEL) opisywania
poszczególnych elementarnych składników diagramu;
 do komentowania programowanych operacji.
Ponieważ obszar jednego arkusza jest z reguły za mały do opisania algorytmu
sterowania, istnieje możliwość łączenia kilku arkuszy w tzw. kartę. Edytor umożliwia także
operacje na całych kartach, takie jak: usuwanie, kopiowanie, przesuwanie, szybki przegląd
i drukowanie. Każda karta zawiera opis jednej sekwencji operacji, która jest rozumiana jako
ciąg czynności związanych z zamkniętym, całościowo spójnym fragmentem procesu.
Sekwencje są więc analogiem makroetapów przewidzianych normą GRAFCET i tak jak one
mogą być wykorzystywane do hierarchizacji schematu. Ilość odwołań do sekwencji
i poziomów zagłębienia jest nieograniczona, co daje duże możliwości strukturalnego podejścia
do projektu. W praktyce, hierarchiczny schemat sterowania składa się z jednej karty głównej
i szeregu kart podrzędnych, zawierających rozrysowane sekwencje, do których odwołania
znajdują się na karcie głównej lub innych kartach podrzędnych.
Podstawowym rodzajem etapu w schemacie jest tzw. krok, reprezentujący pojedynczą
elementarną operację lub grupę operacji. Krok jest opisywany przez projektanta
w odpowiednim polu arkusza jako jedna lub wiele instrukcji języka LOGEL. Opis kroku
można także zrealizować przy pomocy schematu drabinkowego na specjalnym dodatkowym
diagramie. Podobnie w dwojaki sposób opisuje się symbole przejść (tranzycji).
Określanie powiązań algorytmu sterowania ze sterownikiem i obiektem polega
na wypełnianiu edytorem tekstowym odpowiednich tabel. Definiuje się w ten sposób używane
rodzaje wejść i wyjść obiektowych oraz dodatkowe zmienne programowe. Rysunek 2.15
prezentuje przykładowy wygląd pojedynczego arkusza edytora ESTER, a rysunek 2.16 - wynik
automatycznej translacji schematu na język LOGEL.
52

zam=1; /* CZESC DEKLARACYJNA */
/* deklaracja wejsc */
y1=y2=y3=0; input int [1] x0 : 0 ;
input int [1] x2 : 1 ;
P1 x1 input int [1] x3 : 2 ;
/* deklaracja wyjsc */
zam=x2*2+x3; output Boolean [2] y1 : 0 ;
01
output Boolean [2] y2 : 0 ;
output Boolean [2] y3 : 0 ;
__ /* deklaracja zmiennych */
P2 x4&&(zam>2) int zam ;
P2 /* CZESC WYKONAWCZA */
main
y1=1; y2=y3=0; {
02 begin
03 y2=1; y1=y3=0; zam=1;
y1=y2=y3=0;
04 y3=1; y1=y2=0; P1 :
wait(x1);
lab2 :
zam=x2*2+x3;
P3 !x0 P2 :
N2 :
if (!(x4&&(zam>2))) goto lab1;
y1=y2=y3=0;
open main_2\s || main_3\s;
y1=1; y2=y3=0;
wait(!sas(main_2)&!sas(main_3));
Rys. 2.5. Przykład karty w edytorze ESTER z P3 :
wait(!x0);
opisem algorytmu sterowania y1=y2=y3=0;
goto labex;
Produktami pracy edytora ESTER są lab1 :
goto lab2;
następujące informacje: labex :
close;
end
 tekst źródłowy zapisu algorytmu sterowania main_2
{
w języku LOGEL, będący plikiem wejściowym dla begin
y2=1; y1=y3=0;
translatora LOGEL; goto labex2;
labex2 :
close;
 dokumentacja zawierająca schematy zgodne end
}
z normą GRAFCET oraz zestawienie wejść i wyjść main_3
{
obiektowych sterownika; begin
y3=1; y1=y2=0;
goto labex3;
 pliki z uzupełniającymi informacjami dla labex3 :
close
translatora LOGEL i debugera DRAGON. end
}
}
Rys. 2.16. Algorytm z rysunku 2.15

po zakodowaniu w języku LOGEL
2.3.5.2 LOGEL
Jest to kompilator języka wyższego poziomu o tej samej nazwie, służącego do opisu
algorytmów sterowania procesów przemysłowych różnego typu. Język LOGEL nawiązuje
do filozofii opisu sterowania prezentowanej w normie GRAFCET. Podobnie jak w tej normie,
tak i w języku LOGEL występują pojęcia:
 segmentu - zdefiniowanego, zamkniętego ciągu instrukcji;
53

 podsegmentów i możliwości ich hierarchizacji;
 funkcji aktywacji segmentów do pracy sekwencyjnej lub współbieżnej i ich dezaktywacji.
Powyższe cechy umożliwiają automatyczne (za pośrednictwem ESTER) lub ręczne (z użyciem
dowolnego edytora tekstowego) przekodowanie diagramów sterowania, przedstawionych
w formie graficznej na zapis tekstowy zrozumiały przez translator LOGEL.
Ponadto język LOGEL charakteryzuje się dostępnością [61]:
 deklaracji opisujących sposób połączenia ze sterowanym obiektem;
 zestawu środków do komunikacji z innymi składnikami systemu sterowania;
 możliwości hierarchicznej dekompozycji algorytmu sterowania i jego zapisu zgodnie
z zasadami programowania strukturalnego;
 zmiennych czasowych i zegarów wraz z operującymi na nich funkcjami;
 generatorów czasowych i funkcji służących generacji różnego rodzaju przebiegów
czasowych;
 programowych mechanizmów dostępu do wejść i wyjść obiektowych, uwzględniających
różnorodność konstrukcji układów sprzężenia sterownika z obiektem;
 operacji na strukturach kolejkowych typu FIFO i zmiennych licznikowych;
 funkcji komunikacyjnych;
 zmiennych systemowych zawierających informację o stanie systemu sterującego, przez co
możliwa staje się programowa obsługa sytuacji awaryjnych.
Translator LOGEL jest dwuprzebiegowy:
1. translacja programu na niezależny maszynowo metakod, w trakcie której jest sprawdzana
poprawność syntaktyczna i semantyczna programu, a ewentualne błędy mogą być
wskazywane bezpośrednio na schemacie algorytmu sterowania, wygenerowanym przez
edytor ESTER; w fazie tej powstają także dodatkowe zbiory informacji dla debugera
DRAGON;
2. translacja metakodu na kod wynikowy konkretnego sterownika, która uwzględnia
informacje specyfikujące typ sterownika docelowego, a uzyskane od operatora.
Dwuprzebiegowy charakter translatora ułatwia ewentualną szybką adaptację już napisanego
programu na inne typy sterowników - zmiana sterownika docelowego wymaga jedynie zmiany
modułu generującego kod wynikowy w drugiej fazie pracy translatora.
54

2.3.5.3 DRAGON
Jest to składnik pakietu OPUS przeznaczony do uruchamiania i testowania

programów sterowania zapisanych w języku LOGEL lub edytorem graficznym ESTER.
Umożliwia on [61]:
 transmisję kodu wynikowego programu sterującego łączem szeregowym z/do sterownika;
 pracę w trybie alfanumerycznym, jak w tradycyjnym debugerze symbolicznym
za pośrednictwem zleceń i komunikatów;
 szczególnie efektywną pracę w trybie graficznym, z wykorzystaniem schematów
utworzonych edytorem ESTER;
 wykonywanie programu od miejsca wskazanego na schemacie;
 zaznaczanie na schemacie pułapek programowych warunkowych i bezwarunkowych;
 pracę krokową;
 podgląd i modyfikację tablicy stanów programu;
 podgląd i modyfikację stanu wejść oraz wyjść obiektowych;
Do komunikacji projektanta z programem wykorzystuje się klawisze funkcyjne, mysz oraz
system menu i podpowiedzi.
2.3.6 Step-5
Pod nazwą Step-5 kryje się system programowania rodziny sterowników

SIMATIC S5 produkowanej przez Siemensa. Rodzina ta obejmuje szeroki wachlarz rozwiązań
sprzętowych: od prostych (S5-90U, S5-95U) do rozbudowanych (S5-115U) funkcjonalnie
sterowników PLC [1, 2, 3, 4, 5]. Mimo tego zróżnicowania, sterowniki te charakteryzują się
wspólną platformą programową złożoną z tych samych rozkazów i funkcji elementarnych.
Platforma ta ulega rozszerzeniu o dodatkowe funkcje, zależnie od złożoności danego
przedstawiciela rodziny SIMATIC S5. Oprogramowanie Step-5 pozwala pisać programy
realizowane przez system operacyjny sterownika cyklicznie, synchronizowane czasem
rzeczywistym lub zdarzeniami zewnętrznymi.
Do programowania można wykorzystywać zamiennie trzy metody opisu algorytmu
sterowania: listę instrukcji (STL), schemat logiki drabinkowej (LAD) lub schemat funkcyjny
(CSF). Metody te są zgodne ze standardami programowania PLC wymienionymi w normie
IEC 1131-3. Dodatkowym ułatwieniem jest możliwość szybkiego przełączania między
wymienionymi metodami opisu i zapisu programu techniką mieszaną.
55

Strukturę programu sterującego można przedstawić w formie drzewa złożonego
z modułów zwanych blokami. Wyróżnia się następujące typy bloków:
 organizacyjne (OB), służące jako interfejs pomiędzy systemem operacyjnym sterownika
a programem sterującym; charakteryzują się stałym powiązaniem numerów
identyfikacyjnych z przyporządkowanymi im zdarzeniami; bloki te są uruchamiane przez
system operacyjny okresowo lub w miarę potrzeb, a ich treść może być wypełniona
programem przez użytkownika; przykładowe funkcje to obsługa: cyklicznej realizacji
programu sterującego, przerwań zewnętrznych, alarmu od watchdoga, przerwań
zegarowych, restartu, błędów programowo-sprzętowych;
 danych (DB), przechowujące dane o procesie; dwa pierwsze bloki DB są zarezerwowane
na potrzeby systemu operacyjnego i niedostępne dla użytkownika; dopuszczalne długości
bloków DB zależą od wersji sterownika (np. 256 słów w S5-90U, 2043 słowa w S5-115U);
dane przechowywane w DB mogą być interpretowane jako: słowa szesnastobitowe, liczby
w kodzie U2 lub BCD, para liczb jednobajtowych w NB, znaki ASCII;
 funkcyjne (FB), służące opisowi ciągów operacji traktowanych jako wywoływane
z różnymi parametrami procedury; mogą być programowane tylko w języku STL przy
użyciu wszystkich rozkazów dostępnych w danej wersji sterownika; są opatrzone nazwą
i mogą mieć zdefiniowaną listę parametrów formalnych; dostępna jest, zależnie od wersji
sterownika, pewna liczba wbudowanych bloków funkcyjnych realizujących takie operacje
jak: konwersje liczb, mnożenie i dzielenie liczb szesnastobitowych, obsługa łącza
komunikacyjnego (tylko S5-115U), obsługa we/wy analogowych;
 programowe (PB), przeznaczone do zapisu głównej części algorytmu sterowania, który
wychodząc naprzeciw zaleceniom programowania strukturalnego może być podzielony
na mniejsze moduły; treść bloków PB tworzy się przy pomocy języka STL albo graficznie -
używając LAD lub CSF.
Język instrukcji STL umożliwia uzyskanie zwięzłego zapisu programu. Podstawowa
grupa rozkazów zawiera operacje: logiki bitowej, ładowania i przesyłania bajtów i słów
dwubajtowych, obsługi timerów i liczników, arytmetyki stałoprzecinkowej, skoków i wywołań
bloków programu. Występujące w treści rozkazów wyrażenia logiczne mogą być zapisywane
z użyciem nawiasów (do 6 poziomów). Tabela D.5 w Dodatku 3 przedstawia podstawowe
rozkazy języka Step-5 STL. Przykładowe programy zapisane w tym języku można znaleźć
w [81].
56

Rozszerzone wersje sterowników rodziny SIMATIC S5 (S5-95U, S5-100U,
S5-115U) są wzbogacone o dodatkowe operacje, między innymi: iloczynu, sumy i różnicy
symetrycznej na słowach, na bitach timerów i liczników, itd.
Graficzny język LAD zdaje egzamin szczególnie przy opisie funkcji wyjściowych
sterownika. Do reprezentacji wyrażeń logicznych programista może używać symboli styków
zwiernych i rozwiernych, wyjść, połączeń i rozgałęzień. Symbole styków i wyjść są opisywane
odpowiednimi nazwami symbolicznymi lub adresami bezpośrednimi. Schemat stykowy rysuje
się na ekranie podzielonym na 6 wierszy i 8 kolumn, przy czym skrajna prawa kolumna jest
przeznaczona na symbole wyjść. Obszar roboczy może być, oczywiście, przesuwany w pionie.
Język CSF jest także graficzną formą opisu, wykorzystującą proste symbole graficzne
funkcji logicznych, wzorowane na normie niemieckiej (tabela 2.2). Ekran monitora jest
podzielony na 8 kolumn, przeznaczonych do umieszczania symboli funktorów logicznych oraz
nazw lub adresów sygnałów wejściowych i wyjściowych. Oprócz symboli podstawowych
bramek logicznych, są do dyspozycji także symbole przekaźników, liczników i timerów.
Przykłady wykorzystania tej metody programowania podaje [83].
System programowania w języku Step-5 rozwiązuje również problem właściwego
udokumentowania tworzonego oprogramowania sterującego. Linie programu zapisanego
techniką STL mogą być opatrzone indywidualnymi komentarzami. Podobnie można
komentować fragmenty opisane łatwiejszymi w zrozumieniu metodami graficznymi LAD
i CSF. Oprócz tego bloki programu (OB, PB, FB) i danych (DB) są wyposażone w tzw.
nagłówki, w których można umieszczać szereg informacji wyjaśniających ich przeznaczenie.
Komentarze i teksty nagłówków są przechowywane w plikach dyskowych, jako tzw. bloki
dokumentacyjne, skojarzone z odpowiednimi składnikami programu sterującego.
Ważną cechą oprogramowania narzędziowego Step-5 są jego możliwości
diagnostyczne w trybie on-line. Pozwalają one między innymi nadzorować na ekranie
monitora pracę programu, także w formie graficznej - śledzenie stanu funkcji wyjściowych
(LAD) lub pracy timerów, liczników i przerzutników (CSF). Programista może zdefiniować
szereg ekranów diagnostycznych obrazujących zachowanie się różnych fragmentów
uruchamianego programu. Możliwa jest także bezpośrednia ingerencja w stan wejść i wyjść
sterownika, modyfikacja wartości pamiętanych w blokach danych. Dostępny jest też zestaw
funkcji wykorzystujących wbudowane w systemy operacyjne sterowników mechanizmy
nadzorowania pracy programu i samego sprzętu.
57

Oprogramowanie narzędziowe, wspomagające proces pisania i uruchamiania
programu dla PLC może w swej prostszej wersji funkcjonować na komputerze klasy AT.
Pełne wersje tego oprogramowania są dostępne wraz ze specjalizowanymi programatorami
dostarczanymi także przez Siemensa [5]. Urządzenia te umożliwiają przygotowanie programu:
 w trybie off-line, z zapisaniem kodu programu do pamięci EPROM;
 w trybie on-line, z zapisaniem kodu programu bezpośrednio do pamięci RAM sterownika
i możliwością uruchamiania go w czasie rzeczywistym za pośrednictwem łącza
szeregowego.
Najprostszy z programatorów PG605, zawierający 2kB pamięci, dwuwierszowy
wyświetlacz LCD, klawiaturę funkcyjną i łącze szeregowe, umożliwia programowanie PLC
jedynie językiem STL.
Kolejnym programatorem, o większych możliwościach, jest wykonany na bazie
mikrokomputera typu laptop PG710 Economy. Oprócz standardowych składników (80286,
1MB RAM, HDD 40MB, FDD 3,5”, ekran LCD-CGA) zawiera on klawiaturę funkcyjną
do edycji programów w Step-5, programator pamięci EPROM/EEPROM i dwa łącza
szeregowe. Jego oprogramowanie narzędziowe umożliwia programowanie mniejszych
sterowników S5-90U, S5-95U i S5-100U. W przypadku tego programatora projektant systemu
może posługiwać się także dwoma pozostałymi sposobami opisu algorytmu: LAD i CSF.
Programator PG710 plus ma powiększone zasoby sprzętowe i rozszerzone
oprogramowanie narzędziowe. Dzięki temu może służyć do programowania sterowników od
S5-90U do S5-155U. Kolejne typy programatorów: PG730, PG750, PG770 mają jeszcze
większe możliwości programowania sterowników rodziny SIMATIC S5.
Kolejnym krokiem Siemensa w rozwoju języków programowania PLC jest Step-7,
ukierunkowany na możliwości rodziny sterowników SIMATIC S7 [6]. Oprócz stosowanych
w Step-5 metod STL, LAD i CSF posiada on język „tekstu strukturalnego” SCL (zgodny
z normą IEC 1131-3) i język graficzny GRAPH.
2.3.7 MTS i GRAFPOL
Polski wkład w dziedzinę metod programowania układów sekwencyjnych stanowi

między innymi opracowana w Instytucie Technologii Maszyn i Automatyzacji Politechniki
Wrocławskiej metoda modelowania dyskretnych procesów produkcyjnych, w której
opracowany model matematyczny algorytmu procesu może być stosowany na różnych
58

poziomach syntezy sekwencyjnego układu sterowania. Główne etapy metody ilustruje
poniższy rysunek [68].
metoda
schemat algorytm algorytm MTS automat
strukturalny procesu sterowania cyfrowy
procesu
+ sieć sieć działań

operacyjna układu sterownik
opis słowny procesu sterowania metoda PLC
GRAFPOL
Rys. 2.17. Etapy syntezy sekwencyjnego układu sterowania
2.3.7.1 MTS - Metoda Transformacji Sieci
Proces syntezy układu sekwencyjnego składa się w tej metodzie z kilku etapów [62]:
1. opracowania algorytmu przebiegu procesu technologicznego i zapisaniu go w formie sieci
operacyjnej (opisanej pokrótce w punkcie 2.2.5);
2. opracowania algorytmu działania układu sterowania w formie sieci działań;
3. wyznaczenia równań schematowych;
4. realizacji układu sterowania.
Sieć operacyjną będącą bazą wyjściową przekształca się (transformacja sieci)
najpierw do sieci działań. Transformacja taka polega na przyporządkowaniu klatkom
operacyjnym, reprezentującym elementarne operacje systemu, zmiennych wyjściowych układu
sterowania realizujących te operacje. Następnie należy określić zasady zapisywania i
kasowania pamięci układu sterowania i zależności pomiędzy nimi a wejściowymi i
wyjściowymi zmiennymi logicznymi.
Otrzymana w powyższy sposób sieć działań prezentuje algorytm pracy układu
sterowania z uwzględnieniem stanu: wejść X, wyjść Y i pamięci M, a zależności pomiędzy
jego zmiennymi wejściowymi i wyjściowymi w sieci o N klatkach operacyjnych opisuje układ
równań [62]:
Fi(Yi) = fi’  fi” , i = 1..N
gdzie:
fi’ - zależność przedstawiająca warunki logiczne określające moment rozpoczęcia realizacji
i-tej operacji, wykorzystująca zmienne umiejscowione na wejściu tej klatki;
59

fi” - zależność przedstawiająca warunki logiczne określające moment zakończenia realizacji
i-tej operacji, określana przez zmienną (zmienne) na wyjściu klatki warunkowej kończącej
i-tą operację.
Na fi’ oraz fi” nakłada się dodatkowo warunek:
f i'  f i" = 1  wykonywana jest i - ta operacja
 i = 1..N zachodzi  ' "
f i  f i = 0  nie jest wykonywana i - ta operacja
który może być spełniony jedynie przy obecności pamięci w układzie sterowania. Omówienie
reguł uzupełniania sieci działań o elementy pamięciowe można znaleźć w [63].
Jeśli chodzi o graficzną reprezentację sieci działań, to okazało się konieczne
wprowadzenie dodatkowych symboli odpowiadających: działaniom na komórkach pamięci,
ich zawartości i stanom wyjść, przedstawia je rysunek 2.18.
Rys. 2.18. Symbole używane w sieciach działań, reprezentujące: ustawianie i kasowanie

komórek pamięci (a); odwoływanie się do wartości komórek pamięci (b) i stanu wyjść (c)
Rysunek 2.19 [66] przedstawia przykładową realizację sterowania za pomocą metody

MTS układem dwóch dozowników (przedstawionym w punkcie 2.2.4). Równania schematowe
dla tego przykładu są następujące:
S  CPA  WK3  m1  Y11

(WK1+ y 12 )m1  m 2  Y12
F(Y,M) =  
WK1 m 2  Y2
[(WK2  y  m )M  (WK2  y  m )M ]WK4
 12 1 1 12 2 2
Inny przykład użycia metody MTS można znaleźć w [68].
60

ALARM S CPB WK2 WK4
a) START b) 24V CPA WK1 WK3
N
CPA×CPB=1
T
Y11: Y11 m1
IN 10 11 12 13 14 15 16 17
y11
PLC
WK2=1
START
M1 T OUT 20 21 22 23 24 25 26 27
WK1=1
m1 T
y12
EZ1=Y11+Y12 EZ2=Y2
m1
c)
Y12: Y12 m2 I10 I11 I12 I15 O21 O20
y12
WK2=1 I14 O20
START S
T
M2
I16 O21
WK1=1 R Q
m2 T I13 O21 O23 O22
m2
O22
Y2: Y2
I14 O22
STOP
WK4=1 S
M,M
1 2
T I16 O23
R Q
WK3=1 I13 O23 O24
T
Rys. 2.19. Realizacja metodą MTS sterowania do przykładu z punktu 2.2.4: a) sieć działań;
b) schemat połączeń sterownika PLC; c) zapis programu dla PLC logiką drabinkową
Metoda MTS zdaje, według jej autorów, egzamin wszędzie tam, gdzie synteza
sekwencyjnych układów sterowania metodami klasycznymi [91], z racji ich ograniczeń, jest
trudna lub wręcz niemożliwa. Praktyka wskazuje, że już przy n>3 zmiennych wejściowych
i K>8 stanach wewnętrznych automatu, projektant napotyka poważne trudności. Uzyskiwany
w tej metodzie układ równań schematowych może posłużyć:
 do zaprojektowania cyfrowego układu sterowania (z przerzutnikami w charakterze komórek
pamięci);
 do przygotowania programu sterownika w logice drabinkowej;
 do programowania PLC metodą GRAFPOL.
61

2.3.7.2 Zastosowanie metody GRAFPOL w programowaniu sterowników
Sieć GRAFPOL jest przeznaczona, między innymi, do reprezentowania algorytmu

procesu na podobnych zasadach, na jakich reprezentuje go sieć operacyjna. Jest też pochodną
tej ostatniej w przedstawionym na rysunku 2.17 procesie syntezy sekwencyjnego układu
sterowania.
Definicja 2.4 [65]

Sieć GRAFPOL stanowi trójka:
GP = < Z , K , L >
gdzie:
Z={Z1, Z2, ...,Zm} jest skończonym zbiorem elementów zwanych operacjami, ponieważ sieć
GP jest budowana z wykorzystaniem odpowiedniej sieci operacyjnej;
zbiór ten pokrywa się ze zbiorem Z operacji tej sieci;
K={fp1-fk1, fp2-fk2, ...,fpn-fkn} jest skończonym zbiorem elementów zwanych logicznymi
relacjami przyczynowo-skutkowymi;
L jest skończonym zbiorem elementów zwanych krawędziami skierowanymi.

W strukturze sieci operacyjnej mogły
a) b)
występować dwa rodzaje klatek operacyjnych: jedno-
f pi =...
i dwuelementowe. Podobnie jest w przypadku sieci f pj =...
Zi : Zi
GRAFPOL - mamy do dyspozycji dwa rodzaje etapów: Zi
f ki =...
jednopozycyjny i dwupozycyjny (rysunek 2.20).
Pierwszy z nich reprezentuje następujące bezpośrednio
po sobie operacje: podstawową i sprzężoną, drugi f pi =...
umożliwia opis sytuacji, w których między początkiem Zi Z j
a końcem j-tej operacji musi być rozpoczęta i/lub f ki =... f kj =...
zakończona inna operacja układu sterowania.

Rys. 2.20. Podstawowe składniki
Dopuszczenie dwóch typów etapów pozwala sieci GRAFPOL: a) etapy
uwzględniać różnego rodzaju elementy wykonawcze jednopozycyjne; b) etap
(siłowniki) już w fazie projektowania algorytmu sterowania, przez co zmniejsza się liczbę
potrzebnych zmiennych wyjściowych układu sterowania.
62

Wynik przekształcenia przykładowej a) b)
sieci operacyjnej (z rysunku 2.12) do sieci START CYKLU START CYKLU
GRAFPOL reprezentującej algorytm procesu

WK1 WK3 CPA CPB S I13 I15 I11 I12 I10
przedstawia rysunek 2.21.a. Kolejną fazą

SA : SA O20 : O20
syntezy jest algorytm sterowania, który WK2 I14
uzyskuje się poprzez odwzorowanie zbioru

WK1WK3 I13I15
operacji procesu zbiorem zmiennych
SA : SA O22 : O22
wyjściowych układu sterowania
WK2 I14
odpowiedzialnych za realizację tych operacji.

WK1WK3 I13I15
Sieć reprezentująca algorytm sterowania
SB : SB O24 : O24
(rysunek 2.21.b) jest z oczywistych względów
WK4 I16
podobna do poprzedniej. Inny przykład użycia

metody znajduje się w [67]. Można także, Rys. 2.21. Zastosowanie sieci GRAFPOL
do syntezy układu sterowania: a) algorytm
w ślad za [65], podać definicję algorytmu
procesu; b) algorytm sterowania
sterowania w metodzie GRAFPOL.
Definicja 2.5
Algorytmem sterowania w metodzie GRAFPOL jest trójka:
GP’ = < Y , K , L >
gdzie:
Y = {Y1, Y2, ..., YK} jest skończonym zbiorem elementów zwanych zmiennymi wyjściowymi
układu sterowania;
K, L - są równoważne zbiorom sieci GRAFPOL reprezentującej algorytm procesu.

Przejście od algorytmu sterowania GP’ do rzeczywistej implementacji sterowania nie
nastręcza już większych problemów - wystarczy np. przepisać sieć GP’ na język logiki
drabinkowej powszechnie stosowany do programowania sterowników. Sieć algorytmu
sterowania GP’ może także stanowić bazę języka programowania sterowników typu STL
o następującej formie zdaniowej [64]:
„ jeśli przyczyna, to skutek ”
Zgodnie z uwagami autorów [64] metoda GRAFPOL ma, w porównaniu z szeroko
znaną metodą GRAFCET, następujące zalety:
 algorytm procesu jest siecią logiczną (operacyjną) i dlatego nie wymaga on dodatkowego
modelowania;
63

 algorytm sterowania jest na tyle uniwersalny, że może być stosowany na dowolnym
poziomie syntezy sekwencyjnych układów sterowania;
 metoda GRAFPOL może być stosowana w programowaniu większości dostępnych
sterowników PLC.
Podobnie jak w GRAFCET możliwy jest opis procedur sekwencyjnych i współbieżnych.
2.3.8 INTELSTER PC4K
Z końcem lat siedemdziesiątych Zakłady Automatyki Przemysłowej MERA ZAP

podjęły produkcję licencyjną (PILZ GmbH - Niemcy) modułowego systemu sterowania
programowalnego INTELSTER PC4K. Był to system średniej wielkości, pozwalający
na realizację programu długości maksimum 4096 słów 16-bitowych, obsługujący do 512 wejść
i 496 wyjść lub komórek pamięci pomocniczej, wyposażony opcjonalnie w układy czasowe
(cyfrowe, analogowe), mogący realizować proste operacje na liczbach BCD [88].
Język programowania systemu INTELSTER PC4K zaliczał się do grupy języków
zorientowanych na sieci działań. Jego lista instrukcji obejmowała niewielką liczbę rozkazów
realizujących elementarne operacje (Tabela D.6 w Dodatku 3). Testowanie złożonych
warunków logicznych w tym języku polegało na wykonywaniu sekwencji rozkazów TH i TL
zakończonej rozkazami SPJ, SPN i SP. Przykładowo fragment programu:
100 TH E20
101 TH E21
102 TH E22
103 SPJ 130
104 SP 120
realizuje sprawdzenie warunku iloczynu logicznego 3 wejść:
w = E20  E21  E22
i gdy jest on spełniony następuje skok do rozkazu 130, w przeciwnym przypadku do rozkazu
120. Programista miał do dyspozycji rejestry indeksowe x i y ułatwiające dostęp do struktur
danych - właściwy adres argumentu powstawał jako suma zawartości wskazanego rejestru
i adresu podanego razem z kodem rozkazu. Oprócz tego rejestry x i y mogły być także
używane do organizacji pętli programowych, za sprawą rozkazu DR. Pamięć danych miała
organizację bitową, co oczywiście utrudniało obsługę złożonych struktur danych.
Przykładowo licznik binarny n-bitowy uzyskiwało się poprzez programową obsługę n
64

kolejnych komórek pamięci. Do uzyskiwania zależności czasowych służyły wspomniane
wcześniej moduły czasowe:
 analogowe - o regulowanym potencjometrycznie czasie działania;
 programowane - wymagające podania w treści programu wartości i zakresu czasu
(dyrektywy ZWB i ZWE).
Do programowania i uruchamiania sterowników był przewidziany zestaw, który się
składał:
* z urządzenia programująco-testującego umożliwiającego pisanie i edycję programu,
kontrolowanie stanu wejść i wyjść podczas uruchamiania układu, pracę krokową;
* z programatora pamięci EPROM do zapisywania gotowego programu w pamięci stałej
sterownika;
* z modułu symulacji stanu wejść i wyjść;
* z konsoli testowania stanu wejść i wyjść.
2.3.9 Standard IEC 1131
Rozwój techniki sterowników programowalnych i poszerzanie się dziedzin ich

zastosowania skłonił instytucje międzynarodowe do prac nad standaryzacją zagadnień z tym
związanych. Owocem tych działań jest, opracowana przez International Electrotechnical
Commision, norma IEC 1131 pt. Programmable Controllers. Składa się ona z pięciu części:
 IEC 1131-1 General Information (1992r.);
 IEC 1131-2 Equipment Requirements and Tests (1992r.);
 IEC 1131-3 Programming Languages (1993r.);
 IEC 1131-4 User Guidelines (w przygotowaniu);
 IEC 1131-5 Messaging Service Specification (w przygotowaniu).
Z punktu widzenia niniejszej pracy istotna jest trzecia część tej normy, odnosząca się do metod
programowania sterowników. Jej postanowienia zostaną przedstawione w zarysie w dalszej
części pracy.
Norma IEC 1131-3 określa składnię i semantykę zunifikowanych języków
programowania sterowników. Przewiduje ona stosowanie dwóch języków tekstowych:
 lista instrukcji - IL13;
13
IL - Instruction List
65

 język strukturalny - ST14;
oraz trzy odmiany graficznego zapisu algorytmu sterowania:
 logika drabinkowa - LD15;
 wykresy blokowe - FBD16;
 sieci typu Grafcet - SFC17 jako środek pomocniczy.
Zdefiniowane w normie języki programowania mogą być używane w interakcyjnych
środowiskach programowania. Chociaż specyfikacja takich środowisk leży poza granicami
uregulowań normy, wymagane jest, aby mogły one generować dokumentacje tekstowe
i graficzne w formatach zgodnych z postanowieniami normy.
Przedmiotem normy są:
 podstawowe składniki, takie jak: używany zestaw znaków, identyfikatory, słowa kluczowe,
stałe liczbowe i tekstowe, stałe czasu i daty, a także ich reprezentacje binarne;
 składnia i semantyka wymienionych języków programowania;
 sposoby tworzenia deklaracji prostych i złożonych struktur zmiennych programowych
lokalnych i globalnych;
 struktura oprogramowania sterownika.
2.3.9.1 Modelowa struktura oprogramowania sterownika
Norma wyróżnia trzy podstawowe rodzaje modułów programowych: funkcje, bloki

funkcjonalne i programy. Moduły te mogą być dostarczane przez producenta sterownika
i oprogramowania lub generowane przez użytkownika, zgodnie z zaleceniami normy.
Funkcje są modułami wyposażonymi w zestaw parametrów formalnych, ale nie
posiadającymi żadnych wewnętrznych pamięci stanu. Ich zadaniem jest przetworzenie
przekazanych do ich wnętrza wartości parametrów i podanie wyniku tego przetworzenia
w odpowiednim formacie. Każde wywołanie funkcji z tymi samymi parametrami aktualnymi
daje zawsze taki sam wynik. Funkcje mogą być argumentami wyrażeń logicznych
i arytmetycznych lub występować bezpośrednio w instrukcjach podstawienia. Opis
wewnętrznych działań funkcji może być wykonany przy pomocy języka tekstowego lub
graficznego. Norma określa też grupę standardowych funkcji bibliotecznych, które winien
posiadać język programowania. Są wśród nich funkcje:
14
ST - Structured Text
15
LD - Ladder Diagram
16
FBD - Function Block Diagram
17
SFC - Sequential Function Chart
66

 konwersji typów zmiennych;
 numeryczne (trygonometryczne, logarytmiczne, itp.);
 arytmetyczne (operatory podstawowych działań matematycznych);
 logiczne;
 operatory relacji;
 operujące na ciągach znaków.
Bloki funkcjonalne są w użytkowaniu bardzo podobne do znanych z języków
wysokiego poziomu procedur. Tak jak w przypadku funkcji, zadaniem ich jest przetwarzanie
przekazanych przy wywołaniu wartości parametrów, ale wynikiem tego przetwarzania może
być więcej niż jedna wartość zmiennej. Z blokami funkcjonalnymi są skojarzone statyczne
struktury danych obejmujące wyniki ich działania, zmienne wewnętrzne oraz wartości lub
wskaźniki do parametrów aktualnych wywołania. Ponieważ te struktury danych nie zmieniają
się między kolejnymi wywołaniami bloku funkcjonalnego, możliwa jest sytuacja,
że w kolejnych wywołaniach z tymi samymi parametrami aktualnymi, wyniki działania bloku
będą różne. Norma wymienia pewne standardowe bloki funkcjonalne:
 przerzutniki SR z dominującym wejściem S lub R, semafory;
 układy wykrywania zboczy sygnałów;
 liczniki inkrementujące, dekrementujące i rewersyjne;
 timery;
 moduły komunikacyjne.
Najwyżej stojącymi w hierarchii modułów są programy, które definiuje norma
IEC 1131-1 jako: „logiczne połączenie wszystkich elementów i konstrukcji języka
programowania, niezbędne do osiągnięcia wymaganego przez algorytm sterowania
urządzeniem lub procesem, przetwarzania informacji”. Wykonaniem programów zarządza
system operacyjny sterownika za pośrednictwem tzw. zadań18. Służą one do cyklicznego lub
wyzwalanego zmianą zmiennej logicznej uruchamiania modułów typu program lub blok
funkcjonalny. Zadaniom przypisuje się priorytety pilności. Zależnie od organizacji systemu
operacyjnego sterownika obsługa tych zadań może być sekwencyjna (klasyczny przydział
procesora dla priorytetowej kolejki zadań) lub wielopoziomowa z wzajemnym przerywaniem
zadań o niższym priorytecie przez zadania o wyższym priorytecie.
18
określenie ang. „task”
67

Do programowania działań sekwencyjnych, związanych z organizacją wykonywania
poszczególnych modułów oprogramowania przeznaczony jest graficzny język SFC, będący
implementacją opisanego w punkcie 2.3.3 języka Grafcet. Tak jak pierwowzór, SFC
wykorzystuje do opisu działań sekwencyjnych wzajemnie powiązane etapy i przejścia.
Z etapami są skojarzone opcjonalnie akcje, opisujące operacje sterownika wykonywane przy
uaktywnieniu tych etapów. Opis akcji może być zrealizowany w jednym z czterech języków
programowania przewidzianych normą (IL, ST, LD, FBD) lub także przy użyciu SFC.
Przejścia pomiędzy etapami są opisane warunkami logicznymi dezaktywacji etapów je
poprzedzających te przejścia i uaktywnienia etapów po nich następujących. Wyrażenia
logiczne tych warunków mogą być zapisane zarówno językami tekstowymi (IL, ST) jak i
graficznymi (LD, FBD). Reguły funkcjonowania sieci SFC są takie same jak opisane w
Dodatku 5 dla sieci Grafcet.
2.3.9.2 Tekstowe języki programowania
Język typu IL jest w swojej budowie bardzo zbliżony do symbolicznych języków

maszynowych mikroprocesorów. Jego sformalizowaną w notacji MBNF19 składnię podaje
odpowiedni dodatek do tekstu normy. Ogólnie można stwierdzić, że wiersz programu
zapisanego w tym języku ma budowę analogiczną do wiersza programu asemblerowego:
wyróżnia się cztery pola - etykiety, operatora (mnemonika rozkazu), operandów (argumentów
rozkazu) i komentarza. Norma podaje standardową listę instrukcji obejmujących takie operacje
jak: przesłania danych, ustawianie zerowanie zmiennych binarnych, operatory logiczne,
arytmetyczne, relacji, skoki oraz wywołania warunkowe i bezwarunkowe, powroty warunkowe
i bezwarunkowe z wywoływanych procedur. Składnia języka dopuszcza stosowanie złożonych
wyrażeń nawiasowych, rozpisywanych po jednym operatorze w wierszu.
Użycie funkcji w składni języka IL polega na podaniu jej nazwy w polu operatora
i listy parametrów aktualnych w polu operandów. W wyniku wykonania funkcji pierwszemu
elementowi listy zostaje przyporządkowana wartość wynikająca z operacji opisujących funkcję
i wartości parametrów aktualnych, stanowiących pozostałą część listy operandów.
Do wywoływania bloków funkcjonalnych przewidziano rozkaz ‘CAL’, którego operandem jest
nazwa wybranego bloku, wraz z ujętą w nawiasy listą parametrów aktualnych.
19
MBNF - zmodyfikowana notacja Backusa-Naura
68

Drugi język programowania sterowników przewidziany normą IEC 1131-3 - ST - jest
językiem strukturalnym, wyposażonym w elementy składni charakterystyczne dla tego typu
języków. Oprócz możliwości stosowania złożonych wyrażeń arytmetycznych oraz logicznych
w zapisie symbolicznym i jawnych instrukcji przypisania wartości wskazanej zmiennej, norma
przewiduje dla języka ST następujące struktury:
 if ... then ... else ... end_if; oraz elsif ... then ... else ... end_if;
 case ... of ... else ... end_case;
 for ...:=... to ... by ... do ... end_for;
 while ... do ... end_while;
 repeat ... until ... end_repeat;
 exit (do przerywania wykonania instrukcji iteracyjnej);
 return (do przerywania wykonywania funkcji lub bloku funkcjonalnego);
 deklarowania modułów funkcji i bloków funkcjonalnych;
 wywołania funkcji i bloków funkcjonalnych w formie identyfikatora z listą parametrów
aktualnych ujętą w nawiasy.
Składnię języka ST w notacji MBNF zawarto w dodatku do normy.
2.3.9.3 Graficzne języki programowania
W językach graficznych wykorzystuje się możliwości obrazowego przedstawienia

kolejnych operacji programu przy użyciu prostych symboli (linie i prostokąty). Symbole te są
tworzone na bazie ogólnie dostępnych znaków alfanumerycznych i semigraficznych. Jako
zbiór tych znaków norma wskazuje na zestaw znaków określony normą ISO/IEC 646.
Symbole graficzne są połączone ze sobą liniami, obrazującymi możliwe kierunki przepływu
sygnałów.
Pierwszym z wymienionych w normie graficznych języków programowania jest język
logiki drabinkowej LD. Podobnie jak w innych tego typu językach, wyróżnia się dwie szyny
zasilające, pomiędzy które wstawiane są szczeble logiki. Sieć połączeń w obrębie
pojedynczego szczebla może być prosta (odpowiadające iloczynowi logicznemu sygnałów
połączenie szeregowe) lub rozbudowana (reprezentująca złożoną funkcję logiczną).
Podstawowymi elementami składowymi są tu różnego rodzaju styki: zwierne i rozwierne,
wrażliwe na poziom lub na zmianę sygnału logicznego, cewki przekaźników symbolizujące
przypisanie wartości zmiennym logicznym, symbole wejść sterujących przerzutnikami SR
i komórkami pamięci. Bardziej złożone operacje arytmetyczne oraz operatory relacji są
69

dostępne w schemacie drabinkowym poprzez odpowiednie symbole blokowe, które muszą
mieć po jednym wejściu i wyjściu sygnału logicznego.
W trakcie działania programu LD zakłada się kierunek przepływu sygnałów od lewej
do prawej. Cała sieć powinna być symulowana poprzez przeglądanie jej szczebli od góry
do dołu, chyba że pojawią się w którymś ze szczebli rozkazy zmieniające ten porządek
przeglądania. Rozkazami takimi mogą być symbole skoków warunkowych oraz
bezwarunkowych i takich samych powrotów. Przykłady użycia języka LD i jego różnych
konstrukcji zawiera omawiana norma.
Drugi z języków graficznych przewidzianych normą - schematy funkcjonalne (FBD) -
wykorzystuje do opisu algorytmu sterowania symboliczne bloki przedstawiające różne
operacje logiczne, arytmetyczne, operatory relacji i inne bardziej złożone funkcje
przetwarzania danych. Symbole bloków są prostokątami, z zaznaczonymi po lewej stronie
wejściami informacji, a po prawej - wyjściami wyników operacji.
W trakcie realizacji programu opisanego językiem FBD, zakłada się przepływ
informacji z wyjść jednego bloku do wejść innych bloków. Tu również są dostępne symbole
skoków i powrotów, zmieniające sekwencję wykonywanych operacji. Przykładowe schematy
funkcjonalne można znaleźć w jednym z dodatków do normy IEC 1131-3.
2.3.10 Inne możliwości programowania algorytmów sterowania binarnego
2.3.10.1 Zastosowanie języków wysokiego poziomu
Programując duże systemy automatyki często sięga się po języki wysokiego poziomu.
Mogą to być powszechnie znane języki Pascal, C, BASIC, ale dostępne są także języki
specjalizowane, np.: IRT-FORTRAN, Concurrent Pascal, Modula, Ada [10].
IRT-FORTRAN20 został opracowany w drugiej połowie lat siedemdziesiątych jako
rozwinięcie klasycznego języka programowania. Dostosowanie do potrzeb programowania
systemów czasu rzeczywistego osiągnięto definiując biblioteki podprogramów i funkcji
zewnętrznych. Dzięki temu składnia języka nie uległa zmianie, co sprzyjało zaakceptowaniu
nowego standardu. Dodatkowe biblioteki umożliwiają realizację zadań z zakresu:
 zarządzania zadaniami użytkowymi;
 wymiany informacji pomiędzy zadaniami i procesem;
20
IRT-FORTRAN - Industrial Real-Time Fortran
70

 operacji logicznych na bitach;
 przetwarzania zbiorów danych.
Wszystkie procedury zwracają sterowanie do programu wywołującego dopiero po całkowitym
zakończeniu ich działania. Więcej szczegółów na temat funkcjonowania programów
napisanych w IRT-FORTRANie można znaleźć w [12].
Concurrent Pascal (CP) powstał w 1974 jako jeden z pierwszych dobrze
zdefiniowanych języków programowania współbieżnego. Podstawową składnię języka,
zaczerpniętą z jego wersji sekwencyjnej, wzbogacono o takie pojęcia jak: procesy czynne,
monitory i klasy. Uzyskuje się je jako zmienne systemowe odpowiedniego typu. Procesy są
najniższymi hierarchicznie obiektami współbieżnymi, wyższe poziomy są przewidziane dla
monitorów.
W roku 1976 powstał kolejny, wywodzący się z sekwencyjnego Pascala, język -
Modula. Operuje on na procesach i modułach. Część modułów może służyć jako koordynatory
(odpowiedniki monitorów w CP) współbieżnej pracy procesów, przy czym w przeciwieństwie
do CP dopuszcza się tylko jeden poziom modułów. Pozostałe moduły są przeznaczone do
autonomicznej obsługi urządzeń zewnętrznych.
Typowym językiem programowania systemów czasu rzeczywistego jest Ada (1976).
Jest on językiem uniwersalnym, nadającym się do obliczeń numerycznych i sterowania
procesami. Bardzo często jest używany do programowania wbudowanych systemów
komputerowych. Może pracować w systemach jedno- i wieloprocesorowych, samodzielnych
lub podłączonych do sieci. Ponieważ program zapisany w Ada jest często jedynym programem
wykonywanym przez docelowy komputer (bez pośrednictwa systemu operacyjnego), jego
tworzenie wymaga skrośnej kompilacji na innym komputerze pracującym pod zwykłym
systemem operacyjnym. Współbieżnymi obiektami w tym języku są tzw. zadania, opisywane
jako sekwencyjne ciągi instrukcji. Mechanizmem synchronizacji zadań i wymiany informacji
pomiędzy nimi są tzw. spotkania.
Dostępnych jest sporo pozycji literaturowych omawiających wymagania stawiane
językom programowania czasu rzeczywistego lub poświęconych konkretnym standardom [26,
41, 99].
Należy także pamiętać o metodach programowania mikrosterowników
wbudowanych, których wymagania dotyczące gabarytów i kosztów układu sterującego
zmuszają do tworzenia optymalnego programu, działającego na minimalnie rozbudowanym
sprzęcie mikroprocesorowym. Program taki bardzo często jest pisany bezpośrednio w języku
71

asemblera danego mikroprocesora. Uzyskuje się optymalny zapis programu, ale kosztem
dużych nakładów pracy na zaimplementowanie algorytmu sterowania na poziomie języka
maszynowego. Również ewentualne modyfikacje tak napisanego programu, będące
nieodłączną częścią procesu uruchomieniowego, przy braku narzędzi wspomagających,
nastręczają sporo kłopotów. Z tych względów coraz częściej odchodzi się od języków
asemblerowych na rzecz języków wysokiego poziomu. Dostępne są różne skrośne kompilatory
generujące kod wynikowy na wybrane mikroprocesory. Dominuje w tych zastosowaniach
język C, bardzo popularny w sferze oprogramowania systemowego.
2.3.10.2 „Wysokopoziomowy” język stanów
Podejmuje się także próby wykorzystania diagramów stanu jako podstawy języka
programowania algorytmów binarnych. Przykładem tego może być opisana w [25] metoda.
Diagram stanu jest grafem, składającym się z wierzchołków symbolizujących stany
procesu (si) i krawędzi skierowanych, pokazujących możliwe przejścia pomiędzy nimi.
Ponadto krawędzie te są opisane warunkami przejść (ci) i działaniami (ai) jakie należy wykonać
realizując dane przejście. Fragment takiego diagramu prezentuje rysunek 2.22.a. Diagram
stanów może być z łatwością przekształcony do schematu blokowego, od którego wiedzie już
prosta droga do zapisu algorytmu w języku wysokiego poziomu (rysunek 2.22.b i c).
a) b) c)
s2 s1 C stan s1
c1/a1 10 IF C1.EQ.FALSE GOTO 20
N CALL A1
c1 ?
T GOTO 30
s1
N 20 IF C2.EQ.FALSE GOTO 10
c2 ? CALL A2
T
c2/a2,a3 CALL A3
s3
GOTO 40
a1 a2
C stan s2
a3
40 . . .
s2 s3
Rys. 2.22. Ilustracja przejścia od diagramu stanu (a) poprzez schemat blokowy (b)
do języka wysokiego poziomu - FORTRANu (c)
Autorzy pracy [25] proponują w najprostszym przypadku zastosować makroasembler

z odpowiednio zdefiniowaną makrodefinicją, której użycie powodowałoby generację
rekordów informacji. Rekordy te zawierałyby adresy procedur wyliczających logiczne
wartości warunków przejść, kody stanów następnych i adresy procedur wykonujących
72

specjalne działania związane z realizacją przejścia. Zbiór wszystkich rekordów tworzy
strukturę danych zwaną tablicą stanów. Kod stanu jest adresem pierwszego z rekordów tej
tablicy, odnoszących się do tego stanu. Do obsługi powyższej tablicy stanów należy napisać
program interpretujący zawartą w niej informację; będzie to swoisty procesor stanów.
Przykładową makrodefinicję i sposób jej użycia podaje rysunek 2.23.a,
a rysunek 2.23.b prezentuje wynik działania makroasemblera.
a) b)
COND: MACRO CONDIT,STATE,ACT1,ACT2 S1: DW C1
DW CONDIT ; adres procedury warunku DW S11
DW NXT+2 ; adres następnego warunku DW S2
DW STATE ; adres następnego stanu DW A1
DW ACT1 ; adres procedury akcji 1 DW 0
DW ACT2 ; adres procedury akcji 2 DW 0
NXT: DW 0 ; znacznik końca rekordu S11: DW C2
ENDM DW S12
DW S3
S1: COND C1,S2,A1,0 DW A2
COND C2,S3,A2,A3 DW A3
COND CT,S1,0,0 ; CT jest adresem procedury DW 0
S2: COND C4,S4,A4,0 ; dającej zawsze wynik FALSE S12: DW CT
COND C5,S5,A4,0 DW S2
COND CT,S2,0,0 DW S1
S3: DW 0
DW 0
DW 0
S2: DW C4
Rys. 2.23. Użycie makroasemblera do generacji tablic stanu:

a) przykładowa makrodefinicja i jej wywołanie; b) wynik pracy makroasemblera
Powyższa metoda programowania algorytmów sterowania binarnego pozwala

uzyskać dosyć zwięzły sposób reprezentacji kolejnych stanów pracy w formie tablicy stanów.
Wadą jej jest konieczność indywidualnego tworzenia całej rodziny procedur obliczających
wartości logiczne warunków przejść, co obniża jej elastyczność i nie jest rozwiązaniem
efektywnym ze względu na złożoność obliczeniową.
2.3.10.3 Język przejść między stanami
Innym podejściem do wykorzystania pojęć stanów i przejść między nimi jest metoda
opisana w [42]. Jej autorzy wyróżniają kilka etapów na drodze do rozwiązania końcowego:
1. Dekompozycja zadania na mniejsze, wzajemnie powiązane podzadania, celem uproszczenia
implementacji sterownika. Część tych podzadań jest ściśle związana z wejściami
i wyjściami binarnymi, a inne są wyłącznie wewnętrznymi fragmentami działania całego
73

systemu. Każde z tych podzadań (automatów) ma swój własny wektor wejść i wyjść, a zbiór
jego stanów powinien uwzględniać wszelkie możliwe zachowania się automatu.
2. Kolejnym krokiem jest przedstawienie pracy automatu w formie macierzowego diagramu
składającego się z wszystkich możliwych stanów automatu ułożonych w formie macierzy,
której wiersze odpowiadają różnym wartościom wektora wejściowego, a kolumny - różnym
wartościom wektora wyjściowego. Przykładowo automat o 3 wejściach i 2 wyjściach byłby
opisany macierzą stanów o 8 wierszach i 4 kolumnach - mógłby mieć potencjalnie 32 stany.
Spośród wszystkich możliwych stanów pozostawia się tylko te, które są niezbędne do opisu
automatu. Działanie sterownika (zmiany jego wyjść) są reprezentowane poprzez przejścia
pomiędzy kolumnami wzdłuż jednego wiersza, a reakcja sterownika na zmiany jego
sygnałów wyjściowych odpowiada pionowym przejściom w obrębie jednej kolumny. Zbiór
przejść pionowych i poziomych automatu nazywa się trajektorią.
3. Ponieważ automat może mieć kilka trybów pracy (automatyczny, półautomatyczny,
krokowy, inicjalizacja, awaria, itp.), dla każdego z trybów należy zdefiniować odrębną
trajektorię. Sterownik musi mieć w swej pamięci programu zapamiętane wszystkie możliwe
trajektorie. Do przełączania trybów pracy stosuje się dodatkowe automaty (kilka
cząstkowych i jeden globalny).
4. Należy także określić funkcje przejść warunkujące realizację przejść wzdłuż trajektorii.
Argumentami tych funkcji mogą być zmienne wejściowe automatu, czas i inne zmienne
wewnętrzne (np. dotyczące innych automatów, współpracujących z danym).
5. Implementacja programowa metody wykorzystuje opracowaną przez autorów modyfikację
PASCALa, zwaną RASCAL. Jest to rozszerzenie standardu o operacje ułatwiające
programowanie przejść między stanami.
Praca [42] zawiera także prosty przykład użycia metody oraz uwagi na temat jej
praktycznej stosowalności, oparte na doświadczeniach aplikacyjnych autorów.
2.3.10.4 CODE
CODE (COntrol Definition language) powstał jako narzędzie wspomagające

inżynierów automatyków w definiowaniu, implementowaniu i dokumentowaniu algorytmów
sterowania [43]. Jest on oparty na następujących założeniach:
 opis sterowania jest generowany w procesie interakcyjnym;
 proces jest traktowany jako automat skończony z wyróżnionymi stanami, warunkami
przejść pomiędzy nimi oraz działaniami jakie należy podjąć realizując te przejścia;
74

 model procesu może być hierarchiczny: najniższy poziom stanowią automaty
odpowiedzialne za bezpośrednie operacje na obiekcie, a ewentualne wyższe poziomy są
automatami koordynującymi pracę niższych poziomów.
Ponieważ bazowym pojęciem CODE jest automat skończony, wraz z jego stanami, warunkami
przejść i podejmowanymi w trakcie nich działaniami, podstawową konstrukcją składniową
tego języka jest struktura:
S1 to S2 when TC with TA
w której: S1, S2 oznaczają stany automatu; TC symbolizuje logiczny warunek przejścia
między tymi stanami, a TA jest akcją jaką należy podjąć realizując przejście. Warunek
przejścia TC może uwzględniać takie wielkości jak: wartości zmiennych wejściowych, lokalne
parametry automatu, stany timerów itd. Zapisuje się go w formie wyrażenia logicznego przy
użyciu operatorów logicznych i operatorów relacji. Działanie TA skojarzone z przejściem
składa się z jednej lub większej liczby operacji prostych, którymi mogą być: instrukcje
(przeznaczone z reguły do oddziaływania na obiekt) i wywołania wbudowanych funkcji
(służących np. do synchronizacji z innymi automatami, komunikacji z operatorem).
Ponadto dla każdego stanu można zdefiniować jego działanie charakterystyczne SA,
które jest wykonywane przez układ sterowania niezależnie od sposobu znalezienia się
automatu w danym stanie. Pozwala to skrócić opisy działań TA związanych z przejściami od
różnych stanów do tego samego stanu S2 o powtarzającą się w nich część operacji.
Wprowadzono także stan ANY cechujący się tym, że warunki przejść TC do tego stanu są
sprawdzane w pierwszej kolejności. Stan ANY może symbolizować generalnie błędne stany
pracy automatu (np. wykrycie braku zasilania części wykonawczej). Kolejnym
predefiniowanym stanem jest RESET, który z założenia jest stanem startowym automatu
i może mieć zdefiniowane swoje działanie charakterystyczne SA. Można także zdefiniować
jakiś automat jako procedurę współbieżną, wykorzystywaną jednocześnie przez kilka
automatów wyższego poziomu.
Sterowanie oparte na zdefiniowanych w CODE automatach jest realizowane poprzez
wbudowany interpreter, oparty na następujących założeniach:
 poszczególne automaty są obsługiwane synchronicznie, w kolejnych stałych odcinkach
czasu;
 w każdym cyklu obsługi są testowane warunki przejść i ewentualnie realizowane
odpowiednie przejście wraz ze skojarzonym z nim działaniem TA i działaniem SA;
 w każdym cyklu obsługi automat może zrealizować tylko jedne przejście;
75

 kolejność obsługi automatów jest stała w każdym cyklu i może być określona na etapie
opisywania automatów.
Powyższe założenia eliminują między innymi konieczność rozważania hazardów i wyścigów
występujących w asynchronicznych (opartych na przerwaniach od zmiennych wejściowych)
implementacjach reguł sterowania.
Definiuje się trzy tryby pracy automatów:
 aktywny - automat działa zgodnie z opisem;
 reset - automat jest nieaktywny w startowym stanie RESET, nie wykonuje żadnych działań;
 pasywny - automat pozostaje nieaktywny w stanie w jakim zastało go polecenie przejścia
do tego trybu.
Ustawienia trybu pracy automatu może dokonać operator lub inny automat poprzez wywołanie
odpowiedniej funkcji standardowej. Argumentem warunku przejścia TC może być
wbudowana funkcja podająca tryb pracy innego automatu. W [43] znajdują się proste
przykłady użycia CODE do realizacji sterowania binarnego.
76

3. Metoda programowania algorytmów sterowania binarnego i język
opisu automatów JODA
Inspiracją do bliższego zainteresowania się problemami programowania algorytmów

sterowania binarnego i binarno-ciągłego było zadanie kompleksowej automatyzacji
doświadczalnej linii uzysku białka. Zadanie to i jego rozwiązanie, powstałe w Katedrze
Automatyki i Elektroniki Wydziału Elektrycznego Politechniki Białostockiej, jest szerzej
przedstawione w rozdziale 4.1 i literaturze [53, 54]. Obok problemów związanych z regulacją
wielkości ciągłych występowały także zagadnienia sterowania binarnego, którego celem było
nadzorowanie pracy urządzeń technologicznych w różnych stanach: programowego rozruchu,
pracy ciągłej (automatycznej, półautomatycznej, ręcznej), wyłączania normalnego
i awaryjnego, a także koordynacja działań poszczególnych fragmentów linii. Zadaniem
oprogramowania zainstalowanych modułowych sterowników mikroprocesorowych
w odniesieniu do sterowania binarnego było:
 zbieranie informacji dwustanowej o stanie kontrolowanych urządzeń;
 wypracowywanie wartości wewnętrznych zmiennych logicznych, będących typowymi
flagami sygnalizującymi pewne istotne zdarzenia w procesie regulacji wielkości ciągłych;
 wykorzystywanie flag informujących o szczególnych stanach pracy pozostałych urządzeń
składających się na linię produkcyjną;
 odmierzanie zadanych odcinków czasu;
 wyznaczanie wartości wyjściowych zmiennych binarnych sterujących dwustanowymi
urządzeniami wykonawczymi lub wykorzystywanych przez obwody sterowania innymi
składnikami linii;
 określanie wartości dodatkowych zmiennych liczbowych, będących na przykład numerem
wariantu algorytmu regulacji wielkości ciągłej.
Wartości sygnałów wyjściowych układów sterowania, tak binarnych jak i liczbowych
były zależne nie tylko od bieżącego stanu wejść, ale także od „historii” procesu. Praca
oprogramowania łudząco przypominała więc działanie automatu o określonej liczbie stanów
wewnętrznych oraz zdefiniowanych słowach: wejściowym i wyjściowym. Spostrzeżenia te
skłoniły do zastosowania metod opisu i syntezy automatów stosowanych w teorii układów
logicznych. Próba ta zakończyła się powodzeniem: powstała koncepcja syntezy układów
sterowania binarnego, zweryfikowana pozytywnie przez wspomnianą aplikację i rozwijana
pod wpływem kolejnych jej zastosowań.
77

3.1 Opis układu sterowania binarnego jako automatu
3.1.1 Sterownik binarny jako automat skończony
Jeżeli rozważymy sterownik logiczny jako samodzielny lub będący częścią większego
systemu układ, to bez trudu możemy wskazać pewne grupy sygnałów:
 XO - zbiór sygnałów wejściowych z obiektu;
 XW - zbiór wewnętrznych zmiennych wykorzystywanych w procesie wyznaczania
kolejnego sterowania;
 XS - zbiór zewnętrznych zmiennych logicznych, będących informacją przychodzącą od
innych sterowników lub obwodów sterowania;
 YO - zbiór wyjściowych sygnałów oddziałujących na obiekt;
 YW - zbiór wewnętrznych wyjściowych zmiennych logicznych;
 YS - zbiór wyjściowych sygnałów, wysyłanych do innych sterowników lub obwodów
sterowania.
Powyższy podział jest zilustrowany rysunkiem 3.1.
YO
sterownik
sterowane
YS RAM: urządzenie
(obiekt)
XW,YW
XS
XO
Rys. 3.1. Zewnętrzne i wewnętrzne sygnały sterownika logicznego
Wartości sygnałów wejściowych należących do wzajemnie rozłącznych zbiorów XO,

XW i XS mogą być zgrupowane w odpowiednie słowa wejściowe xO, xW i xS. Słowa te
połączone razem, operacją sklejania (konkatenacji), tworzą słowo wejściowe automatu:
xi = xO  xW  xS
Uwzględniając występowanie różnych kombinacji zero-jedynkowych zmiennych wejściowych
uzyskuje się odpowiednie zbiory słów wejściowych: XO, XW, XS i X.
78

Definicja 3.1
Słowem wejściowym xi automatu nazywamy dowolny ciąg zmiennych wejściowych
xk  X = XO  XW  XS, przy czym XO  .

Analogiczne rozumowanie można przeprowadzić w odniesieniu do sygnałów
wyjściowych automatu, otrzymując słowo wyjściowe:
yj = yO  yW  yS
i odpowiednie zbiory słów wyjściowych: YO, YW, YS i Y.
Definicja 3.2
Słowem wyjściowym yj automatu nazywamy dowolny ciąg zmiennych wyjściowych
yk  Y = YO  YW  YS, przy czym YO  .

Działanie sterownika polega na reagowaniu na zmiany sygnałów wejściowych
odpowiednimi zmianami sygnałów wyjściowych. Uwzględniając ponadto fakt wpływu
„historii” procesu na zachowanie się sterownika, dochodzi się do wniosku, że sterownik
binarny może być traktowany jako automat skończony.
W teorii układów sekwencyjnych wyróżnia się dwa podstawowe rodzaje automatów:
 automat Moore’a;
 automat Mealy’ego.
W odniesieniu do tego samego zadania sterowania automat Mealy’ego umożliwia w wielu
przypadkach realizację układu o mniejszej liczbie stanów wewnętrznych, ale o trudniejszym
opisie funkcji wyjść . We współczesnej technice mikroprocesorowej, przy dostępnych
z reguły dużych zasobach pamięciowych, liczba stanów automatu nie jest wielkością
krytyczną. Istotniejszy jest w miarę wygodny sposób jego opisu. Z powyższych względów
opracowana metoda JODA21 bazuje na koncepcji traktowania układu sterowania binarnego
jako automatu Moore’a.
Biorąc także pod uwagę właściwy systemom komputerowym synchronizm operacji,
polegający na ograniczeniu reagowania na zmiany sygnałów wejściowych tylko do ściśle
określonych chwil czasu, otrzymuje się model sterownika jako układu synchronicznego typu
Moore’a. Model ten można zdefiniować następująco.
21
Nazwa metody została wzięta od związanego z nią Języka Opisu Dyskretnych Automatów - JODA
79

Definicja 3.3
Synchronicznym sekwencyjnym modelem sterownika binarnego w metodzie JODA nazywamy
uporządkowaną piątkę:
MS = < S , X , Y ,  ,  >
gdzie: S = {s1, s2, ..., sN} jest zbiorem stanów automatu, takim że ||S|| = N i 1 < N < ;
X = {x1, x2, ..., xK} jest zbiorem słów wejściowych;
Y = {y1, y2 , ..., yM} jest zbiorem słów wyjściowych;
 jest funkcją przejść, przyporządkowującą parze (st , xt) w chwili t nowy stan st+1
w chwili następnej t+1: (st , xt) = st+1;
 jest funkcją wyjść określoną dla danego stanu st wzorem:
yt = (st)

Działanie tak zdefiniowanego automatu można opisać w formie: graficznej (graf
przejść, wykresy czasowe), stablicowanej (tablice przejść i wyjść) lub algebraicznej (dane
wyrażeniami funkcje przejść i wyjść).
Forma graficzna, mimo iż jest bardzo czytelna i wygodna na etapie projektowania
automatu, nie nadaje się do bezpośredniej implementacji w programie sterownika logicznego.
Specyfika technik przetwarzania informacji w sprzęcie komputerowym wymaga
jednoznacznego i sformalizowanego sposobu jej reprezentacji. Dane w postaci graficznej są
bardzo trudne w obróbce - z reguły stosowana jest ich wewnętrzna konwersja na zakodowane
struktury danych, nadające się do dalszego przetwarzania. Operacje te wymagają jednak
dużych obszarów pamięci danych i zużywają zbyt dużo czasu procesora, by mogły być
stosowane bezpośrednio w sterownikach mikroprocesorowych.
Metody tablicowe charakteryzują się dużym dopasowaniem do wymagań algorytmów
komputerowych. Zapisanie w postaci macierzy MP tablicy przejść automatu pozwala
zrealizować bardzo prosty algorytm zmiany stanu. Stan bieżący automatu st i aktualne słowo
wejściowe xt mogą być po prostu użyte jako indeksy do dwuwymiarowej macierzy, której
elementami są stany następne st+1, wyznaczone na podstawie pożądanej funkcji przejść :
MP[st, xt] = (st, xt)
Trudno wskazać prostsze rozwiązanie programowe niż to, które wykorzystuje tak
zdefiniowaną macierz MP. Niestety, z uwagi na dużą moc zbioru K = ||X|| w przypadku
rzeczywistych obiektów sterowania, zastosowanie takiej macierzy napotyka poważne
przeszkody. Są nimi ograniczone zasoby pamięciowe, jakimi dysponuje sterownik
80

mikroprocesorowy. Nawet uwzględnienie faktu, iż macierz MP jest macierzą rzadką,
i zastosowanie odpowiednich sposobów jej reprezentacji oraz obsługi niewiele poprawia
sytuację. Ponadto wygodna dla programu komputerowego macierzowa postać tablicy przejść
jest trudna do przygotowania przez projektanta układu sterowania. W przypadku tablicy wyjść,
którą można przedstawić w formie jednowymiarowej macierzy MW indeksowanej kodami
stanów automatu i takiej że:
MW[st] = (st) = yt
nie ma opisanych wyżej problemów. Dlatego też tablicowa reprezentacja funkcji wyjść 
automatu MS ma istotne znaczenie praktyczne, w przeciwieństwie do macierzowej
reprezentacji funkcji przejść .
Trzecia z wymienionych form reprezentacji - wyrażenia logiczne - okazuje się być
bardzo skuteczna przy kodowaniu funkcji przejść. Pozwala ona uzyskać zwięźlejszy, aniżeli
metoda macierzowa, zapis funkcji . Funkcja ta jest pamiętana pośrednio w postaci
zakodowanych wyrażeń logicznych, których spełnienie warunkuje realizację poszczególnych
przejść między stanami automatu MS. Metoda ta jest także wygodna i czytelna dla projektanta
układu sterowania, który z reguły rozważa właśnie warunki realizacji przejść między stanami
sterownika.
3.1.2 Kodowanie funkcji przejść automatu
W poprzednim punkcie wskazano na zalety zapisu funkcji przejść w formie wyrażeń

logicznych. Działanie automatu MS polega na cyklicznym sprawdzaniu warunków przejść ze
stanu bieżącego si do możliwych stanów następnych i na zmianie stanu si na stan następny sj,
gdy jest spełniony odpowiedni warunek przejścia. Sprawdzanie warunków przejść, danych
wyrażeniami logicznymi, polega na wartościowaniu tych wyrażeń, czyli podstawianiu
bieżących wartości logicznych argumentów i obliczaniu wartości całego wyrażenia.
Wartościowanie wyrażeń logicznych może być zrealizowane na różne sposoby.
Zawsze jednak jest ono związane z uprzednim przetłumaczeniem zapisu symbolicznego
wyrażenia na kod zrozumiały przez procesor lub program przezeń wykonywany. Można
wyróżnić dwie grupy metod kodowania wyrażeń:
 metody generujące kod zorientowany na procesor docelowy, wykorzystujące jego język
maszynowy do realizacji kolejnych operacji potrzebnych do wyznaczania wartości logicznej
całego wyrażenia; zmiana procesora wymaga w tym przypadku powtórzenia całego procesu
kodowania od początku;
81

 metody kodujące wyrażenie w postaci niezależnej od procesora docelowego, wymagającej
jedynie prostych, uniwersalnych procedur interpretujących ten zapis.
Do pierwszej grupy należą wszystkie metody właściwe kompilatorom języków
programowania, ich przykłady można znaleźć w literaturze [7, 30, 57]. Druga grupa metod jest
charakterystyczna dla specyficznych zastosowań technik programowania. Poniżej
przedstawionych jest kilka spośród częściej stosowanych metod.
1. Metoda tablicy wartości, wykorzystująca zwykłe stablicowanie funkcji logicznej
i mechanizmy adresowania komórek pamięci w systemie mikroprocesorowym. Wartości
funkcji logicznej są przechowywane w elementach tablicy, których adres wyznacza się
poprzez zsumowanie słowa wejściowego z adresem początku tablicy, co ilustruje
rysunek 3.2. Jest to najszybsza z możliwych metod, ale jej stosowanie jest bardzo
ograniczone z uwagi na dostępne przestrzenie adresowe mikroprocesorów. Ponadto ten
sposób zakodowania wartości funkcji logicznych, które w przypadku sterowników PLC są
słabo określone, jest nieracjonalny z punktu widzenia wykorzystania zasobów
pamięciowych systemu - w tablicy znajdzie się wiele elementów, do których mikroprocesor
nigdy się nie odwoła w trakcie pracy.
słowo wejściowe xi = ( xi,n-1 ... xi,0 )

adres początku tablicy wartości
indeks [ In-1 ... I0 ] + [ A15 ... A0 ]
adres elementu tablicy

01101100
wartości funkcji logicznych (maks.8)

Rys. 3.2. Schemat realizacji funkcji logicznych za pomocą tablic wartości
2. Metoda bezpośredniego wyliczania, polegająca na zrealizowaniu działań opisujących

funkcję logiczną w formie sekwencji rozkazów operacji logicznych (NOT, AND, OR,
XOR). Charakteryzuje się rosnącą prawie wykładniczo ze wzrostem liczby zmiennych
w wyrażeniu ilością potrzebnych do wyliczenia funkcji działań oraz bajtów kodu programu.
Jest także silnie zależna od typu mikroprocesora docelowego i dostępnej listy rozkazów.
3. Metoda drzewa binarnego, w której wartość wyrażenia logicznego określa się poprzez
sprawdzanie stanów kolejnych zmiennych logicznych w nim występujących i wykonywanie
82

odpowiednich skoków. Pojedynczy krok takiej procedury obliczeniowej można przedstawić
następująco:
e: if xi then f else g
gdzie: e,f,g - etykiety kroków procedury;
xi - wejściowa zmienna logiczna.
Jej wadą jest wrażliwość wielkości kodu procedury i czasu jej realizacji na kolejność
testowania zmiennych logicznych - co ujawnia się przy bardziej złożonych wyrażeniach
zawierających operacje sumy logicznej. Mimo niewielkich wymaganych nakładów
czasowych na realizację funkcji logicznych, metoda drzewa binarnego nie znajduje
szerszego zastosowania z uwagi na: szybkie rozrastanie się kodu programu wraz ze
wzrostem liczby argumentów funkcji logicznej; utrudnione modyfikacje obliczanej funkcji
logicznej. Metoda ta również jest zależna od typu mikroprocesora docelowego.
4. Metoda odwzorowania zbioru wejściowego, bazująca na możliwości przedstawienia każdej
funkcji logicznej w tzw. alternatywnej postaci normalnej (APN), czyli jako sumy iloczynów
(implikantów) zmiennych prostych bądź zanegowanych. Dla każdego z implikantów buduje
się słowa:
maski - bity '1' oznaczają występowanie, a bity '0' - brak danej zmiennej w implikancie;
iloczynu - bity '1' oznaczają, że dana zmienna występuje w implikancie wprost, a bity '0' -
że jest zanegowana.
Dodatkowo wprowadza się maskę "zerową" (‘00000000’) w celu zaznaczenia końca zbioru
par maska-iloczyn. Algorytm wartościowania funkcji z wykorzystaniem opisanych struktur
zaproponowany w [57] można zapisać następująco:
zapisz na stos słowo maski "zerowej";
zapisz na stos pary słów iloczyn - maska;
Y:=0;
repeat
odczytaj parę słów iloczyn-maska;
if maska <> 0 then
begin
A := x and maska; { x - słowo wejściowe }
A := A xor iloczyn;
end;
until (maska = 0) or (A = 0);
if A = 0 then
Y := 1;
Wielkość i czas pracy procedur wartościujących funkcje logiczne metodą odwzorowania
zbioru wejściowego zależą liniowo od liczby implikantów L. Procedurę wartościującą
83

można z powodzeniem zapisać tak, aby miała ona charakter uniwersalny i operowała
na wymiennych zestawach par maska-iloczyn, tym samym ogranicza się uzależnienie
metody od typu mikroprocesora.
5. Metoda sumowania szeregów Walsha [52, 75], polegająca na zastąpieniu wyrażenia
logicznego przez równoważne mu widmo dyskretne, będące współczynnikami rozkładu
tego wyrażenia na szereg Walsha. Możliwe jest tu jednoczesne określanie wartości wielu
wyrażeń logicznych wykorzystujących te same zmienne logiczne. Podstawowym wzorem
obliczeniowym jest:
2 m 1
F( x )   S()W  ( x)
 0
gdzie: x - słowo wejściowe złożone z m zmiennych logicznych;

F(x) - funkcja wielowyjściowa;
S() - współczynniki szeregu Walsha obliczone według zależności:
2 m 1
1
S( )  m
2
 F( x)W  ( x)
X 0
W(x) - jest bazą funkcji Walsha, liczoną według wzoru:

m 1
  i xi
W ( x )  ( 1) i  0
w którym i są bitami dwójkowego rozwinięcia indeksu , a xi -

zmiennymi logicznymi słowa x.
Przykład zastosowania tej metody można znaleźć w [75]. Z jego analizy wynika, że
do pamiętania widma funkcji logicznej należy użyć tablicy o rozmiarze silnie zależnym od
konkretnego wyrażenia. W najgorszym przypadku wielkość tej tablicy może zależeć
wykładniczo od liczby zmiennych logicznych wyrażenia.
6. Metoda masek i wzorów, zastosowana przez autora do programowania algorytmów
sterowania binarnego. Wyrażenie opisujące funkcję logiczną musi być przekształcone
do postaci APN, tak aby można było zdefiniować pary słów maska-wzór dla każdego
z implikantów. Tak uzyskane pary poprzedza się licznikiem par L opisujących funkcję
i całość umieszcza się w tablicy przedstawionej na rysunku 3.3.
L maska1 wzór1 maska2 wzór2 ... maskaL wzórL

Rys. 3.3. Struktura zakodowanej funkcji w pamięci programu
84

Wartościowanie funkcji polega na kolejnym sprawdzeniu maksimum L par maska-wzór,
przy czym nie jest obciążany stos programowy. Algorytm obliczeń można przedstawić
następująco:
i := 1;
repeat
A := x and maska;
i := i+1;
until (i > L) or (A = wzór);
if A = wzór then
Y := 1
else
Y :=0;
Złożoności obliczeniowe22: czasowa (C) i pamięciowe (P,D) metody są liniowo zależne
od liczby L par słów maska-wzór. Metoda masek i wzorów, mimo iż zbliżona do opisanej
wcześniej metody odwzorowania zbioru wejściowego, nie ma jej wad, cechuje się nawet
dodatkowymi zaletami:
 mniejszą złożonością czasową (nie ma strat czasu procesora na przygotowanie par słów
na stosie);
 nieoperowaniem na stosie programowym;
 większą uniwersalnością: zmieniają się jedynie tablice funkcji, które nie muszą być
powiązane w kodzie programu z procedurą wartościującą;
 prostszym procesem ewentualnych modyfikacji funkcji.
Tabela 3.1
Złożoność obliczeniowa wybranych metod wartościowania wyrażeń logicznych.
n - liczba zmiennych logicznych; L - liczba implikantów w wyrażeniu logicznym;
s - długość słowa w bajtach; axx , bxx - współczynniki zależne od typu procesora docelowego.
złożoność pamięciowa złożoność czasowa
metoda programu danych algorytmu
P D C
n
tablicy wartości a1P 2 a1C
bezpośredniego wyliczania a2PC - a2C2 /(3log2n +8)+b2Cn
n
drzewa binarnego a3P2n/n - a3Cn

odwzorowania zbioru wejściowego a4P+b4PLs 2(L+1)s a4C+b4CLs
n
funkcji Walsha a5P <2 <b5CD
masek i wzorów a6P 2Ls+1 a6C+b6CLs
Zestawienie złożoności obliczeniowych poszczególnych metod zawiera tabela 3.1.

Na jej podstawie można stwierdzić, że najlepszymi pod względem zastosowania
22
Definicje złożoności obliczeniowych można znaleźć np. w [8]
85

w oprogramowaniu mikroprocesorowych sterowników PLC są metody: masek i wzorów oraz
odwzorowania zbioru wejściowego. Cechują się one niską złożonością obliczeniową, przy
czym metoda odwzorowania ma większą złożoność pamięciową i wymaga operowania stosem
programowym. Ze względu na swoje zalety metoda masek i wzorów została zastosowana w
metodzie JODA.
3.1.3 Funkcjonowanie automatu
Przedstawiony w poprzednim punkcie sposób wartościowania wyrażeń logicznych

metodą maska-wzór znalazł zastosowanie w algorytmie wyznaczania stanu następnego,
którego wersję podstawową i możliwe modyfikacje przedstawiono poniżej.
3.1.3.1 Tablica przejść automatu i algorytm zmiany stanu
Tablica przejść automatu zawiera wykaz możliwych przejść ze stanu bieżącego

do stanów następnych, z uwzględnieniem logicznych warunków tych przejść. Przy założeniu,
że warunki przejść są dane wyrażeniami logicznymi, które mają być wartościowane opisaną
w poprzednim punkcie metodą maska-wzór, można zdefiniować strukturę zakodowanej tablicy
przejść, potrzebnej do funkcjonowania naszego automatu.
Definicja 3.4
Zakodowaną tablicą przejść TP w metodzie JODA nazywamy strukturę danych złożoną
z rekordów odnoszących się do poszczególnych stanów automatu, a zawierających:
(i) liczbę L wszystkich implikantów w funkcjach przejść ze stanu bieżącego do możliwych
stanów następnych;
(ii) zakodowane metodą maska-wzór implikanty wraz z kodami stanów następnych;
(iii) kod stanu bieżącego, kończący definiowaną strukturę.

Jak wynika z powyższej definicji zakodowana tablica przejść uwzględnia jedynie
przejścia między stanami, pomijając warunki stabilności poszczególnych stanów automatu.
Zakłada się po prostu, że stan automatu nie ulega zmianie, gdy nie zachodzą warunki jego
zmiany, dzięki temu nie trzeba wymieniać w tablicy przejść warunków stabilności.
Przykładową strukturę zakodowanej tablicy przejść automatu prezentuje niniejszy przykład.
86

Przykład 3.1
Jeżeli weźmiemy automat z przykładu 2.3, o 4 stanach i 2 zmiennych wejściowych a i b,
to wynik kodowania jego tablicy przejść możemy przedstawić jak na rysunku 3.4.
a) b) c) d)
b/a s1-s2=/a/b
X ab ab 00 01 10 11 s2 s3
s1-s4=a
x1 00 S /a/b
s2-s1=a/b
a/b
s1 s2 s1 s4 s4 a/b /a/b a/b s2-s3=b/a
x2 01
b s2-s4=/a/b
x3 10 s2 s4 s3 s1 s2
a s3-s1=a/b
s3 s3 s4 s1 s4 s1 s4 s3-s4=b
x4 11 /a s4-s1=/a
s4 s1 s1 s3 s4
s4-s3=a/b
e)
2 03h 00h s2 02h 02h s4 s1
3 03h 02h s1 03h 01h s3 03h 00h s4 s2
2 03h 02h s1 01h 01h s4 s3
2 02h 00h s1 03h 02h s3 s4
Rys. 3.4. Przykład kodowania tablicy przejść dla automatu z przykładu 2.3:
a) przyporządkowanie słowom wejściowym zmiennych logicznych; b) tablica przejść;
c) zmodyfikowany graf przejść; d) funkcje przejść;
e) wynik kodowania (maski i wzory zapisane w formacie liczb szesnastkowych)

W pojedynczym rekordzie zakodowanej tablicy przejść dowolny stan następny może
występować wiele razy. Liczba jego wystąpień jest równa liczbie implikantów w zapisie APN
wyrażenia logicznego warunkującego przejście do tego stanu ze stanu bieżącego. Przyjęcie
przez dowolny z implikantów reprezentowanych słowami masek i wzorów wartości logicznej
‘1’ oznacza spełnienie całego wyrażenia logicznego i możliwość przejścia do stanu następnego
związanego z tym implikantem. Dlatego też po każdej parze słów maska-wzór wpisywany jest
kod stanu następnego. Przy zerowej wartości logicznej każdego z implikantów danego rekordu
tablicy przejść TP nie zachodzą warunki do realizacji przejścia i automat pozostaje w stanie,
którego kod kończy ten rekord.
Zakodowana zgodnie z powyższą definicją tablica przejść automatu może być
następnie zapisana do pamięci programu sterownika. Funkcjonowanie automatu polega
na cyklicznym sprawdzaniu czy dla jego bieżącego stanu spełniony jest któryś z warunków
przejść. Operacja ta polega na przejrzeniu z całej tablicy tylko jednego rekordu
odpowiadającego stanowi bieżącemu. Aktualne słowo wejściowe xi jest mnożone logicznie
przez maski i porównywane ze wzorami, tak jak przy wartościowaniu wyrażenia metodą
87

maska-wzór. Podstawowy algorytm wyznaczania stanu następnego automatu można zapisać
następująco:
Algorytm jednokrotny
k := 1;
with TP[stan_bieżący] do
begin
while ( k  L ) and ( xi and maskak  wzórk ) do
k := k+1;
if k > L then
nowy_stan := stan_bieżący
else
nowy_stan := stan_następnyk;
end;

Podstawowym sposobem wykorzystania powyższego algorytmu jest cykliczne
uruchamianie w przerwaniach zegarowych procedury, która ten algorytm realizuje.
Częstotliwość tych przerwań powinna być dopasowana do częstotliwości zmian zewnętrznych
sygnałów dwustanowych przychodzących do sterownika z obiektu. W przypadku wolnych
procesów, częstotliwość ta może być niska, nawet rzędu 1Hz. Możliwe jest również
uruchamianie procedury obsługi automatu z częstotliwością kilkudziesięciu czy też kilkuset
Hz. Należy jednak pamiętać o maksymalnej możliwej częstotliwości przełączeń
dwustanowych elementów wykonawczych. Wiele urządzeń wykonawczych większej mocy nie
może być przełączanych bez żadnej zwłoki. Pojawiający się problem opóźnień czasowych,
wymaganych przez sterowane urządzenia dwustanowe lub przez sam algorytm sterowania
binarnego, może być także rozwiązany przez odpowiednie zaprojektowanie automatu w
metodzie JODA. Upływ czasu, który obok stanu sygnałów wejściowych, jest najważniejszym
parametrem wykorzystywanym przez sterowniki binarne, może być kontrolowany przez
programowe timery, odmierzające czas przebywania automatu w określonym stanie.
Wyzerowanie się lub osiągnięcie wartości zadanej przez taki timer powoduje ustawienie
odpowiedniej flagi - zmiennej logicznej w słowie wejściowym automatu. Zmienna ta może
być następnie wykorzystana w funkcjach przejść automatu jako jeden z czynników
warunkujących realizację przejścia do stanu następnego.
88

3.1.3.2 Modyfikacja algorytmu zmiany stanu automatu
Przykład 3.2
Załóżmy, że automat z przykładu 3.1 jest w stanie s3 przy a = 0 i b = 0. Zmiana sygnału
b : 0  1 powoduje spełnienie warunku przejścia:
s3 - s4 = b
Do stanu s4 automat przechodzi z sygnałami wejściowymi a = 0 i b = 1. Ta kombinacja
wartości a i b spełnia kolejny warunek przejścia:
s4 - s1 = /a
Automat przechodzi więc do stanu s1.

Stosując opisany w poprzednim punkcie algorytm jednokrotny, przykładowe przejście
od stanu s3 poprzez s4 do s1 zostałoby zrealizowane w dwóch kolejnych cyklach obsługi
automatu. Gdyby jednak zmodyfikować ten algorytm, docelowy stan s1 mógłby być osiągnięty
w jednym cyklu obsługi bez większych trudności. Modyfikacja ta polega na ponownym
sprawdzeniu warunków przejść dla wyznaczonego stanu następnego (różnego od stanu
bieżącego) i aktualnej wartości słowa wejściowego y. Zmieniony algorytm przedstawiałby się
następująco.
Algorytm iteracyjny
nowy_stan := stan_bieżący;
repeat
stan_bieżący := nowy_stan;
k := 1;
with TP[stan_bieżący] do
begin
while ( k  L ) and ( xi and maskak  wzórk ) do
k := k+1;
if k > L then
nowy_stan := stan_bieżący
else
nowy_stan := stan_następnyk;
end;
until nowy_stan = stan_bieżący;

89

Implementacja programowa tej wersji algorytmu, w porównaniu z poprzednią,
wymaga użycia dodatkowej instrukcji warunkowej przerywającej iteracyjny proces
wyznaczania nowego stanu automatu. Chcąc korzystać tylko z algorytmu jednokrotnego
i zrealizować przejście ze stanu s3 do s1 przy zmianie ab: 00  01 w jednym cyklu obsługi
musielibyśmy powiększyć zbiór warunków przejść ze stanu s3. Polegałoby to na zastąpieniu
warunku:
s3 - s1 = a/b
nowym:
s3 - s1 = a/b + b/a
i wiązałoby się z powiększeniem tablicy przejść. Natomiast nakłady czasowe procedury
obsługi automatu w przypadku obu algorytmów byłyby zbliżone - zawsze dochodziłoby
do sprawdzenia wartości logicznej dwóch różnych implikantów zakodowanych w tablicy
przejść automatu.
Stosowanie iteracyjnego algorytmu zmiany stanu automatu jest analogią
do świadomego wykorzystywania mechanizmu przejść cyklicznych w automatach
projektowanych klasycznymi metodami [79, 91].
3.1.4 Wyjścia automatu
3.1.4.1 Realizacja funkcji wyjść
Ważnym składnikiem opisu zachowania się automatu jest jego tablica wyjść,
przyporządkowująca poszczególnym stanom wartości wyjściowych zmiennych logicznych.
Funkcją określającą zawartość tej tablicy jest użyta w definicji 3.3 funkcja  : (st) = yt.
Ponieważ jednowymiarowa macierz wyjść MW przechowująca słowa wyjściowe yt jest
prostym w implementacji rozwiązaniem (uwzględniając etap kodowania i późniejsze
wykorzystywanie), została ona również zastosowana do opisu wyjść automatu-sterownika w
metodzie JODA.
Operowanie stablicowanymi słowami wyjściowymi automatu ma jeszcze jedno
uzasadnienie praktyczne. Przy konstrukcji sterownika logicznego jako specjalizowanego
systemu mikroprocesorowego konieczne jest stosowanie właściwych metod jego
programowania. Chodzi tu o wewnętrzną strukturę oprogramowania sterownika. Jednym
z elementów właściwej organizacji procesu przetwarzania informacji wejściowej i wyjściowej
jest stosowanie tzw. buforów programowych portów zewnętrznych. Są to struktury danych
w pamięci RAM sterownika będące kopią informacji odczytywanej z portów zewnętrznych lub
90

do nich zapisywanej. Słowa wyjściowe yt automatu mogą być jednym ze składników buforów
portów wyjściowych. Zmiana zawartości tych buforów polega wtedy na prostym przepisaniu
jednego z elementów tablicy wyjść MW do odpowiednich komórek pamięci RAM. Właściwy
proces aktualizacji stanu wyjść sterujących, polegający na przepisaniu zawartości
odpowiednich buforów do fizycznych portów wyjściowych, jest zadaniem wydzielonej
procedury kompleksowej obsługi tych wyjść.
Przykład 3.3
Automat z przykładu 2.3 i przykładu a) b)
S Y stan wyjść w 1w 0 00h
3.1 ma trzy możliwe słowa
s1 y1 00 03h
wyjściowe: y1, y2 i y3. Słowa te mogą s2 y3 11 01h
być zrealizowane przez dwie zmienne s3 y2 01 01h
wyjściowe w1 i w0, które na potrzeby s4 y2 01
metody JODA umieszcza się

Rys. 3.5. Kodowanie funkcji wyjść przykładowego
w pojedynczym bajcie na bitach 1 i 0. automatu: a) przyporządkowanie wyjściom bitów
Wynik kodowania tablicy wyjść słowa wyjściowego; b) zakodowana tablica wyjść
automatu prezentuje rysunek obok. 
3.1.4.2 Inne zmienne wyjściowe automatu
Do tej pory rozważano dla uproszczenia słowo wyjściowe automatu yt złożone tylko
ze zmiennych wyjściowych yO  YO (zbioru sygnałów oddziałujących na sterowany obiekt).
Nie są to jedyne możliwe wyjściowe sygnały automatu. Rysunek 3.1 uwzględnia także zbiór
YS sygnałów służących koordynacji pracy różnych automatów, obsługiwanych zarówno przez
ten sam sterownik, jak i przez inne urządzenia, tworzące razem rozproszony system
automatyki. Zmienne wyjściowe należące do tego zbioru YS mogą być traktowane jako flagi,
sygnalizujące pewne specyficzne w danym zadaniu sterowania stany automatu. Flagi te mogą
przykładowo informować inne automaty o:
 wystąpieniu stanów awaryjnych;
 gotowości lub nie danego automatu do współpracy z innymi;
 trybach pracy danego automatu.
Ze względu na duże znaczenie tych dodatkowych wyjściowych zmiennych logicznych
przewidziano w metodzie JODA użycie obok słowa wyjściowego, także słowa flag. Sposób
jego definiowania jest taki sam jak w przypadku słowa wyjściowego. Również reprezentacja
binarna wewnątrz sterownika mikroprocesorowego opiera się na tej samej, macierzowej
91

formie zapisu. Jednowymiarowa macierz flag MF przechowuje słowa flag dla poszczególnych
stanów automatu. Słowa te pobierane z MF w trakcie pracy automatu mogą pozostawać
wewnątrz sterownika (w jego pamięci RAM) lub być transmitowane łączem komunikacyjnym
do pozostałych węzłów rozproszonego systemu automatyki.
Omawiając algorytmy zmiany stanu automatu, wspomniano o możliwości
wykorzystania programowych timerów odmierzających czas przebywania automatu
w określonym stanie. Ich zadaniem jest wykrycie upłynięcia zadanego odcinka czasu. Czas ten
może być nazwany czasem charakterystycznym stanu tCS. Z reguły automatowi wystarcza
jeden taki timer zerowany albo ustawiany na wartość początkową tCSi po wejściu do nowego
stanu si. Stała liczbowa tCSi jest jednym z możliwych parametrów stanu automatu. Ponieważ
jest ona znana na etapie projektowania sterownika, może być potraktowana jako stan
wielowartościowego wyjścia. Tym samym ulega poszerzeniu pojęcie tablicy wyjść automatu,
które można zdefiniować następująco.
Definicja 3.5
Tablicą wyjść TW automatu w metodzie JODA nazywamy strukturę danych określającą stany
wyjść binarnych i wielowartościowych, składającą się z rekordów odnoszących się
do poszczególnych stanów automatu, a zawierających obligatoryjnie:
(i) słowo wyjściowe yO zmiennych oddziałujących na sterowany obiekt;
zaś opcjonalnie:
(ii) słowo wyjściowe yS flag służących koordynacji działania danego automatu z pozostałymi
układami sterowania;
(iii) słowo wyjściowe yW zmiennych binarnych lub zakodowanych binarnie zmiennych
wielowartościowych.

W świetle powyższej definicji przykładowa tablica wyjść automatu pokazana
na rysunku 3.5 jest zbiorem czterech jednobajtowych rekordów danych, zawierających tylko
obligatoryjne słowa wyjściowe yO. Poniżej podany jest przykład kodowania automatu, którego
funkcje przejść są uzależnione od upływu czasu.
Przykład 3.4
Zmodyfikujemy warunki przejść automatu z przykładu 3.1 tak, aby niektóre z nich
uwzględniały także zależności czasowe. W tym celu wprowadzimy nową zmienną wejściową
t, która przyjmuje wartość: logicznego ‘0’, gdy nie upłynął zadany parametrem tCSi czas
92

charakterystyczny stanu si i logicznej ‘1’ w przeciwnym przypadku. Przykładowo warunek
przejścia:
s4 - s3 = a/b + t
oznacza, że przejście ze stanu s4 do s3 następuje gdy: sygnały ab = 10 lub upłynie zadany czas
tCS4 stanu s4. Modyfikację grafu przejść automatu oraz jej wpływ na kodowanie tablic przejść
i wyjść przedstawia rysunek 3.6.
a) c) d)
t a b s1-s2=/a/b 2 03h 00h s2 02h 02h s4 s1
s1-s4=a
3 03h 02h s1 83h 81h s3 83h 80h s4 s2
b) s2-s1=a/b
s2-s3=tb/a 2 03h 02h s1 01h 01h s4 s3
tb/a s2-s4=t/a/b
s2 s3
3 02h 00h s1 03h 02h s3 80h 80h s3 s4
t/a/b s3-s1=a/b
s3-s4=b
a/b
a/b /a/b a/b+t s4-s1=/a e) 00h 0
b s4-s3=a/b+t 03h 5
a 01h 0
s1 s4 01h 15
/a
Rys. 3.6. Przykładowy automat z funkcjami przejść zależnymi od czasu:

a) jednobajtowe słowo wejściowe; b) graf przejść; c) funkcje przejść;
d) zakodowana tablica przejść; e) zakodowana tablica wyjść, zawierająca zmienne wyjściowe
i czasy charakterystyczne stanów

Czasy charakterystyczne stanów nie są jedynymi, dopuszczalnymi definicją 3.5,
wielowartościowymi wyjściami automatu. Mogą nimi być także inne zakodowane binarnie
wielkości, na przykład:
 kody komunikatów, które należy wyświetlić na panelu operatorskim, zależnie od stanu
automatu;
 kody (numery) algorytmów uzupełniających działania sterownika w poszczególnych
stanach jego pracy;
 adresy procedur, które należy dodatkowo wywołać po przejściu automatu do danego stanu;
 inne wartości liczbowe, mające cechy parametrów algorytmu sterowania, zależnych od
stanu automatu.
Dodatkowe, opcjonalne składniki tablicy wyjść zostaną bliżej omówione
w następnych punktach pracy i rozdziale czwartym poświęconym przykładowym aplikacjom
metody JODA.
93

3.2 Implementacja metody JODA w technice programowania sterowników
3.2.1 Platformy sprzętowe i programowe
Metoda JODA jako sposób programowania algorytmów sterowania binarnego może

mieć zastosowanie przede wszystkim w nietypowych aplikacjach. W przypadku seryjnie
produkowanych modeli sterowników przemysłowych szanse na jej użycie w charakterze
jednego z możliwych języków programowania są niewielkie. Dzieje się tak za sprawą dążenia
wiodących producentów sterowników do standaryzacji metod programowania tych urządzeń,
czego wyrazem jest opracowanie normy IEC 1131. Nie jest jednak wykluczone,
że proponowany sposób opisu układów sterowania binarnego, po jego dalszych
udoskonaleniach, znalazłby zastosowanie jako dodatkowy język programowania,
uzupełniający przewidziane standardem metody.
Bez wątpienia metoda JODA może być narzędziem wspomagającym programowanie:
 systemów wbudowanych w wytwarzane seryjnie lub jednostkowo urządzenia;
 nietypowych zadań sterowania, w których z różnych względów nie mogą być zastosowane
sterowniki standardowe.
Funkcje sterowników w wyżej wymienionych zastosowaniach mogą pełnić:
 małe systemy mikroprocesorowe, wykorzystujące uniwersalne mikroprocesory ośmio- lub
szesnastobitowe, obudowane układami niezbędnymi do realizacji postawionych zadań;
 specjalizowane mikrokomputery jednoukładowe, przykładowo z rodziny MCS51 lub
pochodnych, charakteryzujące się najczęściej ograniczonymi zasobami pamięciowymi;
 mikrokomputery typu IBM-PC, które przy pomocy specjalizowanych kart rozszerzających
dostosowuje się do kontroli i sterowania obiektem.
Jest to szeroka gama konstrukcji sprzętu mikrokomputerowego, o zróżnicowanych mocach
obliczeniowych i zasobach pamięciowych. Metoda JODA może być użyta w każdym
z wymienionych przypadków sprzętowej realizacji układu sterowania.
Do programowania algorytmów sterowania nietypowych zadań stosuje się zwykle
standardowe języki programowania. Mogą to być języki wysokiego poziomu FORTRAN,
BASIC, Pascal, bardzo popularny w ostatnich latach C, czy też ukierunkowane na algorytmy
sterowania w czasie rzeczywistym IRT-FORTRAN, RT BASIC i inne wymienione w punkcie
2.3.10.1. Niemałe znaczenie mają także języki asemblerowe samych mikroprocesorów,
tworzących jednostki centralne przeznaczonych do sterowania systemów
94

mikrokomputerowych. Języki te stosowane są zwłaszcza w programowaniu małych systemów
wbudowanych. Systemy takie, ze względu na wymagania co do gabarytów i kosztów
jednostkowych, dysponują z reguły ograniczonymi mocami obliczeniowymi oraz zasobami
pamięciowymi, i z konieczności muszą być programowane na poziomie języka maszynowego
ich mikroprocesora.
Zapis algorytmu sterowania binarnego w klasycznych językach programowania,
zarówno wysokopoziomowych jak i niskopoziomowych (maszynowych), polega zwykle
na użyciu złożonych konstrukcji sprawdzeń warunków logicznych i odpowiednich skoków,
prowadzących do podjęcia właściwej decyzji. Tekst takiego programu ulega szybkiej
komplikacji wraz ze wzrostem rozmiaru postawionego zadania, którego wielkość można
mierzyć liczbą n wejściowych zmiennych logicznych. Ilość zmiennych binarnych rzutuje
na wielkość i szybkość działania procedur obliczających wartości logiczne warunków.
Procedury te są podstawowymi składnikami oprogramowania sterownika logicznego. Jak to
zostało pokazane w punkcie 3.1.2, typowe dla języków programowania metody
wartościowania wyrażeń logicznych: bezpośredniego wyliczania i drzewa binarnego,
charakteryzują się mało atrakcyjnymi wartościami złożoności obliczeniowej C i P.
Złożoności te utrudniają stosowanie klasycznych języków programowania w sytuacji
występowania ograniczeń na wielkość kodu programu i/lub maksymalny czas reakcji
sterownika na zmiany słowa wejściowego.
Innym utrudnieniem w stosowaniu typowych metod programowania do realizacji
algorytmów sterowania binarnego jest mała podatność napisanego z ich pomocą programu
na jakże częste jego zmiany. Modyfikacje oprogramowania sterownika są podstawowym
elementem procesu uruchomieniowego. Mogą być także potrzebne już w trakcie eksploatacji
systemu, gdy zaistnieje konieczność zmian algorytmu sterowania lub ujawnią się podczas jego
pracy błędy, niewykryte na etapie uruchamiania. Zmiana zaprogramowanej logiki działania
sterownika, w przypadku stosowania wyłącznie środków dostępnych w zwykłych językach
programowania, wiąże się z wprowadzeniem zmian w treści programu i jego ponowną
kompilacją (asemblacją). Zapis nowego kodu programu do pamięci stałej mikrosterownika
wymaga z reguły jego wyłączenia i krótszej lub dłuższej przerwy w pracy, co nie zawsze jest
dobrze odbierane przez użytkownika takiego systemu. Należy także wspomnieć o tym,
że w przypadku rozbudowanych algorytmów sterowania binarnego, tekst programu jest na tyle
duży i złożony, iż same modyfikacje mogą nastręczać trudności. Kłopoty te powiększają się,
95

gdy ze względu na oszczędność pamięci lub szybkość działania stosujemy elementy
programowania w języku maszynowym.
Użycie metody JODA do opisu zachowania się sterownika jako automatu eliminuje
wymienione niedogodności za sprawą:
 standaryzacji opisu poszczególnych stanów wewnętrznych;
 ujednolicenia zapisu warunków logicznych zmiany stanu w formie zakodowanych tablic
przejść;
 stosowania jednej, uniwersalnej procedury wartościującej wyrażenia logiczne
i wyznaczającej stan następny automatu;
 znacznego ograniczenia zakresu modyfikacji programu tylko do określonych struktur
danych, co umożliwia w pewnych przypadkach zmiany algorytmu sterowania w trybie
on-line;
 umożliwienia łatwego debugowania w trybie on-line zaprogramowanego algorytmu
sterowania, dzięki operowaniu na stanach automatu, a nie na pojedynczych rozkazach
języka programowania;
 szybkiej przenoszalności zakodowanych tablic, zawierających informację o zachowaniu się
automatu, na różne mikroprocesory docelowe i języki programowania, co jest realizowane
odpowiednimi dyrektywami translatora JODA.
O dużej elastyczności metody świadczą zrealizowane przy jej pomocy aplikacje,
różniące się między sobą:
 bazą sprzętową: od systemów modułowych z mikroprocesorami Z80, poprzez
mikrokomputery jednoukładowe 8051 do IBM 486DX;
 stosowanym językiem programowania: od asemblera symbolicznego po język wysokiego
poziomu;
 skalą rozwiązywanych problemów: od prostego układu reagującego na klawisze i upływ
czasu, poprzez sterowania dwustanowe urządzeniami wykonawczymi do realizacji zadań
automatyki kompleksowej.
Narzędziem wspomagającym stosowanie metody JODA jest translator o tej samej
nazwie, przekształcający symboliczny opis stanów i warunków przejść między nimi
w zakodowane tablice stanów, przejść i wyjść. Tablice te są zapisywane w pliku tekstowym
z uwzględnieniem składni języka docelowego wskazanego odpowiednią dyrektywą translacji.
Jako języki docelowe dostępne są obecnie:
 języki asemblerowe A8051 (dla MCS51) i AZ80 (dla Z80);
96

 metaasemblery C16 i C32 (generujące programy dla różnych mikroprocesorów);
 z języków wysokiego poziomu: Pascal i C.
Powyższy repertuar języków docelowych pokrywa przeważającą większość stosowanych
języków programowania sterowników binarnych. Umożliwia także, dzięki uwzględnieniu
metaasemblerów, pisanie programów w języku maszynowym wielu mikroprocesorów.
Dostępne są również procedury wyznaczania stanu następnego zgodnie z obydwiema wersjami
algorytmu (jednokrotnego i iteracyjnego) dla najczęściej używanych mikroprocesorów: Z80,
MCS51 i 8086.
3.2.2 Struktury danych opisujące automat
Zastosowanie w oprogramowaniu sterownika metody JODA do realizacji algorytmów

sterowania binarnego polega na:
(i) wyróżnieniu słowa wejściowego automatu, składającego się ze zmiennych binarnych
będących argumentami wyrażeń logicznych, warunkujących realizację przejść między
stanami automatu;
(ii) umieszczeniu w programie zakodowanych zgodnie z wcześniej opisanymi regułami
(punkt 3.1.3.1) funkcji przejść, przy uwzględnieniu specyfiki docelowego mikroprocesora
i języka programowania sterownika;
(iii) umieszczeniu w programie tablicy rekordów opisu stanów automatu;
(iv) umieszczeniu w programie, o ile zachodzi taka potrzeba, tablicy flag wyjściowych;
(v) zastosowaniu odpowiedniej do potrzeb procedury wyznaczania następnego stanu
automatu;
(vi) zorganizowaniu procesu cyklicznej obsługi automatu.
Niniejszy punkt jest poświęcony bliższemu omówieniu pierwszych czterech spośród
wymienionych reguł.
3.2.2.1 Słowo wejściowe
Słowo wejściowe automatu xt w chwili t jest wynikiem operacji łączenia trzech słów
xOt, xWt, xSt:
xt = xOt  xWt  xSt
W najprostszym możliwym przypadku xt = xOt, czyli zmiennymi wejściowymi automatu są
wyłącznie sygnały dwustanowe odbierane ze sterowanego obiektu. Sygnały te są grupowane
i odczytywane za pośrednictwem portów równoległych systemu mikroprocesorowego.
97

Wartości binarne odczytane z tych portów umieszcza się w ich programowych buforach
w pamięci RAM sterownika. Jeżeli wszystkie bufory portów umieści się w sąsiednich
komórkach pamięci RAM, to otrzyma się strukturę danych, która może być bezpośrednio
traktowana jako słowo wejściowe xOt.
Większe układy sterowania, o co najmniej kilkudziesięciu sygnałach wejściowych,
mogą stosować podwójne buforowanie wejść dwustanowych. Polega ono na tym,
że informacja z portów wejściowych jest najpierw odczytywana do buforów pośrednich,
a dopiero później następuje jej przepisanie do buforów docelowych. Ten drugi etap
kopiowania informacji bardzo często wiąże się z przeadresowaniem zmiennych binarnych tak,
że bufor docelowy nie jest wierną kopią bufora pośredniego. Różnice między buforami są
związane z tym, że jeden jest kopią portów wejściowych, a struktura drugiego uwzględnia
potrzeby oprogramowania realizującego sterowania obiektem. Rozwiązanie takie ma jeszcze
jedną zaletę: umożliwia ono elastyczne przyporządkowywanie zmiennym wejściowym
automatu fizycznych wejść binarnych sterownika. Zwiększa to konfigurowalność sprzętu
i oprogramowania na etapie uruchamiania sterownika oraz ułatwia obsługę sytuacji
awaryjnych podczas jego późniejszej eksploatacji.
Druga grupa zmiennych wejściowych xW  XW składających się na słowo wejściowe
xWt ma inną genezę. Najczęściej zmiennymi tymi są flagi timerów, sygnalizujące przekroczenie
zadanej wartości lub wyzerowanie się timera. Zmienne te powinny być ustawiane i kasowane
przez odpowiednie procedury obsługi timerów. Kasowanie flag timerów może też być
integralną częścią procedury zmiany stanu automatu, realizowaną w przypadku przejścia
do nowego stanu. Wartości zmiennych wejściowych xWt, mogą też być wynikiem obliczania
innych wyrażeń logicznych. Przykładami takich warunków mogą być:
 relacje porównania zmierzonej wielkości ciągłej z zadaną wielkością progową;
 wyniki operacji logicznych przeprowadzanych przez specjalne procedury wspólne dla
całego automatu lub skojarzone z jego poszczególnymi stanami, za pomocą rekordów opisu
stanu, przedstawionych w punkcie 3.2.2.3.
Ze względu na wygodę obsługi automatu, słowo xWt winno mieć alokację w przestrzeni RAM
sterownika obok słowa xOt. Dzięki temu operacja sklejania xOt  xWt będzie przebiegała
samoczynnie bez konieczności dodatkowego przepisywania bajtów informacji.
Zmienne wejściowe xS  XS występują wtedy, gdy istnieje konieczność koordynacji
pracy różnych automatów. Nieistotne jest przy tym to, czy automaty te są obsługiwane przez
ten sam sterownik mikroprocesorowy, czy przez różne urządzenia. W pierwszym przypadku
98

źródłem słowa xSt jest obszar RAM dedykowany dla innego automatu, a w drugim - łącze
komunikacyjne sterownika. W dużych rozproszonych systemach automatyki składniki słowa
xSt mogą pochodzić z obu tych źródeł. Odbiór danych od każdego z tych źródeł jest
realizowany przez odpowiednie procedury wymiany informacji, a otrzymane dane w postaci
słowa xSt umieszcza się w obszarze RAM przeznaczonym do obsługi danego automatu.
Podobnie jak w przypadku słowa xWt, zalecane jest, aby adresem przeznaczenia odbieranego
słowa xSt były komórki pamięci sąsiadujące ze słowami xOt i xWt.
3.2.2.2 Tablice przejść
Generalnie kodowanie tablic przejść w języku programowania sterownika polega

na zadeklarowaniu struktury danych zgodnej z definicją 3.4 i zainicjowaniu jej odpowiednimi
wartościami początkowymi. Sposób deklarowania i inicjowania tablic musi być oczywiście
zgodny ze składnią języka docelowego. Należy także mieć na uwadze jak największą wygodę
w posługiwaniu się nimi. Chodzi tu zarówno o szybki dostęp do kolejnych rekordów
składowych tablicy przejść TP, jak i o czytelność ich zapisu. Dostęp do rekordów przyśpiesza
na przykład zastosowanie w rekordach opisu stanu automatu wskaźników do odpowiadających
im rekordom TP. Czytelność zakodowanej tablicy przejść można znacząco zwiększyć stosując
nazwy symboliczne stanów automatu zaczerpnięte z jego tekstowego opisu. Ponieważ jednak
za tymi nazwami muszą się kryć odpowiednie kody liczbowe wymagane przez procedury
obsługi automatu, konieczne jest wcześniejsze zadeklarowanie listy identyfikatorów stanów
i ich wartości początkowych. Wykorzystuje się do tego odpowiednie konstrukcje składniowe
języka programowania sterownika. Istotne jest tylko, aby kolejnym nazwom stanów pracy
automatu przypisać kolejne kody liczbowe od 0 do N-1. Ma to znaczenie przy korzystaniu
z tablicy opisu stanów automatu i tablicy flag.
Kodując wyrażenia logiczne w formie ciągów par maska-wzór trzeba także mieć
na uwadze możliwości obliczeniowe procesora zainstalowanego w sterowniku. Oczywiste jest,
że operowanie słowami dłuższymi od rejestrów jego ALU23 będzie wymagało od procedury
wartościującej podzielenia słów masek i wzorów na jednostki logiczne, które mogą być
przetwarzane dostępnymi rozkazami mikroprocesora. W przypadku mikroprocesorów
ośmiobitowych (Z80, MCS51) jednostką taką jest jeden bajt, a dla 8086 i następców - słowo
dwubajtowe. Zapisując zakodowane słowa masek i wzorów dobrze jest od razu podzielić je
na odpowiednie fragmenty. Przy operowaniu dłuższymi (trzy i więcej bajtowymi) słowami
23
ALU - jednostka arytmetyczno-logiczna (ang. Arithmetic-Logic Unit)
99

wejściowymi konieczność podziału słów masek i wzorów na mniejsze jednostki logiczne
może wynikać z samej składni i możliwości leksykalnych języka programowania sterownika.
3.2.2.3 Rekordy opisu stanów
Są to struktury danych łączące informację o słowach wyjściowych automatu z danymi

usprawniającymi proces jego obsługi. Rekordy te charakteryzują się stałą dla danego automatu
wielkością i zgrupowane w jednym miejscu pamięci tworzą tablicę opisu stanów.
Definicja 3.6
Tablicą TS opisu stanów automatu w metodzie JODA nazywamy strukturę danych złożoną
z rekordów o stałej długości, odpowiadających poszczególnym stanom si (i = 0..N-1)
automatu, uporządkowanych według rosnącego indeksu i, a zawierających obligatoryjnie:
(i) wskaźnik do właściwego rekordu zakodowanej tablicy przejść TP automatu;
(ii) słowo wyjściowe yO zmiennych oddziałujących na sterowany obiekt;
opcjonalnie:
(iii) słowo wyjściowe yW zmiennych binarnych lub zakodowanych binarnie zmiennych
wielowartościowych.

Wymóg stałej długości rekordów tablicy TS jest związany z umożliwieniem
szybkiego wyboru właściwego rekordu po zmianie stanu automatu. Po takiej zmianie,
dysponując jedynie kodem liczbowym (od 0 do N-1) nowego stanu, można z łatwością
wskazać odpowiadający mu rekord. Wyboru rekordu dokonuje się wykorzystując mechanizm
adresowania tablicy o znanym adresie początkowym i długości jej elementów:
adres_rekordu := adres_początku_tablicy + kod_stanu  długość_rekordu
Szybki wybór rekordu tablicy TS jest ważny przy stosowaniu iteracyjnego algorytmu zmiany
stanu automatu. Potrzebną w tym przypadku informacją jest wymieniony w definicji 3.6
obligatoryjny wskaźnik do rekordu tablicy TP. Wskaźnikiem tym jest najczęściej adres
początkowy tego rekordu w przestrzeni adresowej programu. Mając dostępny ten wskaźnik-
adres można niezwłocznie przystąpić do sprawdzania warunków przejść dla nowo
osiągniętego stanu. Dzięki temu przyśpiesza się realizację iteracyjnego algorytmu zmiany
stanu. Również w przypadku algorytmu jednokrotnego posługiwanie się adresem
początkowym odpowiedniego rekordu z tablicy TP, która ma nieregularną strukturę (rekordy
o zróżnicowanej długości), usprawnia proces obsługi automatu.
100

Wykorzystanie opisanego mechanizmu dostępu do rekordów TP za pośrednictwem
informacji zapisanej w rekordach TS jest możliwe tylko przy użyciu składni języka
docelowego. Dzieje się tak, ponieważ dopiero na etapie asemblacji czy też kompilacji
programu sterownika (lub jego fragmentu) mogą być określone wspomniane adresy rekordów
w TP. Stosując odpowiednie identyfikatory tych rekordów, a następnie powołując się na nie
przy inicjowaniu zawartości TS uzyskuje się pożądany efekt.
Słowo zmiennych sterujących yO, którego wartość dla każdego ze stanów automatu
jest znana na etapie jego opisu, nie wymaga tu szerszego omówienia. Należy jedynie
zaznaczyć, że z uwagi na bajtowy charakter portów wyjściowych sterownika wygodnie jest,
niezależnie od organizacji ALU procesora, zastosować tablicę wartości jednobajtowych. Ciąg
tak zapisanych bajtów może być traktowany jako bufor portów wyjściowych i przepisywany
do nich w odpowiedniej fazie cyklu obsługi automatu. Możliwa jest także sytuacja polegająca
na tym, że przy obsłudze przez jeden sterownik kilku automatów, ich słowa wyjściowe yO
muszą być najpierw zsumowane logicznie lub złączone w odpowiednim buforze w pamięci
RAM, a dopiero potem przesłane do portów wyjściowych. W odniesieniu do portów
wyjściowych może także być zastosowany, opisany w punkcie 3.2.2.1, mechanizm
podwójnego buforowania informacji wyjściowej. Miałby on wtedy na celu, podobnie jak
w przypadku wejść binarnych, zwiększenie elastyczności konfigurowania zewnętrznych
sygnałów sterownika.
Opcjonalnym składnikiem rekordu opisu stanu jest słowo yW składające się ze
specjalnych zmiennych binarnych i liczbowych, których wartość oddziałuje na pracę
sterownika. Na podstawie praktyki w stosowaniu metody JODA do realizacji algorytmów
sterowania procesami binarnymi i binarno-ciągłymi, można stwierdzić, że istotne znaczenie
mają tu zakodowane binarnie wartości liczbowe. Są one traktowane jako zależne od stanu
automatu parametry algorytmu sterowania. Najczęściej reprezentują czasy charakterystyczne
stanów tCS, wykorzystywane przez procedury obsługi programowych timerów. Mogą to być
także wskaźniki do procedur realizujących dodatkowe obliczenia lub algorytmy regulacji
wielkości ciągłych, co omówiono bliżej w punkcie 3.2.5 i zilustrowano przykładami
w rozdziale czwartym niniejszej pracy.
101

3.2.2.4 Tablice flag
Definicja 3.7
Tablicą flag TF automatu w metodzie JODA nazywamy wektor złożony z uporządkowanych
względem indeksu i słów wyjściowych ySi = (si), służących informowaniu pozostałych
układów sterowania o bieżącym stanie automatu.

Zastosowanie dla słów yS odrębnej niż w przypadku yO i yW struktury danych jest
podyktowane innym mechanizmem korzystania z tej informacji. Transmisję słów yS
do pozostałych układów sterowania, zarówno obsługiwanych przez ten sam sterownik, jak
i przez inne urządzenia, realizują wydzielone procedury obsługi wspólnych obszarów RAM
lub łączy komunikacyjnych. Transmisja informacji służącej synchronizacji pracy automatu
może być realizowany cyklicznie lub tylko na żądanie. Zwłaszcza w tym drugim przypadku
korzystne jest wydzielenie ciągu słów flagowych yS i odwoływanie się do niego na podstawie
kodu bieżącego stanu automatu.
Ponieważ wartości słów yS dla poszczególnych stanów są znane na etapie
przygotowywania opisu automatu, zapisanie ich w składni języka programowania sterownika
nie nastręcza większych trudności. Jeśli chodzi o strukturę elementów tablicy TF,
to niezależnie od wielkości słów yS właściwym rozwiązaniem jest operowanie w zapisie
pojedynczymi bajtami. Bajtowa struktura tablicy TF zdaje egzamin zwłaszcza przy wymianie
informacji za pośrednictwem łączy komunikacyjnych sterowników.
3.2.3 Programowanie obsługi automatu
3.2.3.1 Cykl obsługi automatu
Funkcjonowanie sterownika binarnego jako automatu polega na okresowym

sprawdzaniu warunków przejść obowiązujących w bieżącym stanie automatu i ewentualnej
zmianie stanu. Operacje te muszą być każdorazowo poprzedzone przygotowaniem słowa
wejściowego xt. Zgodnie z definicją 3.1 składa się ono przede wszystkim z reprezentującego
sygnały obiektowe słowa xOt, które powstaje poprzez odczyt portów wejściowych systemu
mikroprocesorowego. Słowo wewnętrznych zmiennych binarnych xWt jest aktualizowane
głównie przez procedury obsługi timerów programowych, a opcjonalne xSt składa się ze
zmiennych binarnych odebranych od innych układów sterowania binarnego. Końcowym
102

etapem obsługi automatu jest aktualizacja słowa wyjściowego yt automatu, na podstawie
zakodowanej tablicy stanów TS. Pobrane z tej tablicy słowo yOt jest umieszczane w buforach
odpowiednich portów wyjściowych. Natomiast składnik słowa yt oznaczany jako yWt,
po pobraniu z rekordu TS służy do inicjacji timerów programowych lub innych działań
specjalnych, o czym szerzej wspomina punkt 3.2.5. Kolejne fazy cyklu obsługi automatu
w przypadku ogólnym ilustruje rysunek 3.7.
odczyt słowa xOt

z portów wejściowych
wyznaczenie bitów
słowa xWt
skompletowanie
słowa xSt
xt := xOt  xWt  xSt
wyznaczenie stanu
następnego ‘stan_nast’
N stan_nast = stan_bież ?
T
stan_bież := stan_nast
programowanie timerów
na podstawie yWt
wykonanie innych działań

określonych przez yWt
przesłanie do obiektu yOt
Rys. 3.7. Schemat blokowy operacji składających się na cykl obsługi automatu
Najważniejszą fazą cyklu obsługi automatu jest oczywiście wyznaczanie następnego

stanu automatu. W Dodatku 7 zawarto przykładowe procedury realizujące trzy podstawowe
operacje z tym związane:
 wartościowanie wyrażeń logicznych warunkujących przejścia między stanami;
 realizację iteracyjnego i jednokrotnego algorytmu określania stanu następnego.
Procedury te zostały napisane, przy założeniu długich słów wejściowych xt. W przypadku
prostych zadań, wykorzystujących dwubajtowe słowa wejściowe, możliwe jest uproszczenie
103

działania tych procedur, przyśpieszające ich pracę. Programując sterownik w języku
wysokiego poziomu można stosować zarówno procedury zapisane w tym języku, jak również
w asemblerze mikroprocesora docelowego. Stosowanie języka maszynowego jest nieco
trudniejsze, ale może niekiedy przyśpieszyć wartościowanie wyrażeń logicznych.
3.2.3.2 Wykorzystanie przerwań zegarowych
Standardowym sposobem realizacji cyklicznej obsługi automatu jest wykorzystanie

przerwań zegarowych o stałej częstotliwości fPZ. Procedura obsługi automatu, obejmująca
opisane w poprzednim punkcie operacje, może być uruchamiana w każdym przerwaniu
zegarowym lub rzadziej, jak to pokazano na rysunku 3.8. Stąd częstotliwość obsługi automatu
fOA  fPZ. Okres obsługi automatu TOA = 1/fOA, powinien być dostosowany do przewidywanej
częstotliwości zmian sygnałów binarnych odbieranych z obiektu. Powinien także uwzględniać
wymogi zadania sterowania, dotyczące maksymalnego czasu reakcji sterownika na zmianę
stanu obiektu. Powyższe uwarunkowania są silnie zależne od konkretnych zastosowań.
Możliwe są przypadki o okresie obsługi na poziomie pojedynczych sekund, jak również
i ułamków sekund.
a)
PZ PZ PZ PZ
OA OA OA OA
T T T T T
 PZ  O A   t
TO A
T - program tła P Z - obsługa przerwania zegarowego O A - o bsługa automatu

b) TO A
PZ PZ PZ PZ
OA OA
T T T T T
 PZ  O A P Z   t
Rys. 3.8. Przykłady wykorzystania przerwań zegarowych do obsługi automatu:

a) fOA = fPZ; b) fOA = fPZ /2
Oprócz działań związanych z samym sterowaniem binarnym, mikroprocesor

sterownika musi także realizować inne zadania zapewniające poprawną pracę całego systemu
mikroprocesorowego. Zadania te są w różny sposób rozdzielone pomiędzy tzw. program tła
i przerwania zegarowe. Oznaczmy przez:
104

T - wymagany czas realizacji zadań programu tła przypadający na 1 sekundę pracy
sterownika;
PZ - maksymalny czas wykonania procedury obsługi przerwania zegarowego, z pominięciem
działań bezpośrednio związanych z obsługą automatu;
OA - maksymalny czas wykonania procedury realizującej cykl obsługi automatu, czas ten jest
największy zwykle przy zmianie stanu i konieczności wykonania przez mikroprocesor
dodatkowych operacji przypisanych stanom automatu.
Twierdzenie 3.1
Warunkiem koniecznym prawidłowej pod względem czasowym pracy sterownika przy
obsłudze jednego automatu jest relacja:
T + fPZ  PZ + fOA  OA < 1
Dowód: Jeżeli sterownik ma pracować w czasie rzeczywistym, a tylko wtedy będzie on
spełniał zadanie sterowania, to musi reagować na wszystkie zdarzenia w skończonym
czasie i żadne z tych zdarzeń nie może być przeoczone. Reakcja na zdarzenia polega
na zrealizowaniu sekwencji operacji, zużywającej pewien czas jednostki centralnej
sterownika. W rozważanym przypadku zdarzeniami są: przerwania zegarowe o stałej
częstotliwości fPZ oraz wplecione w nie cykle obsługi automatu, powtarzające się
z częstotliwością fOA. Łącznie w ciągu 1 sekundy pracy jednostka centralna poświęca
na obsługę tych zdarzeń czas  = fPZ  PZ + fOA  OA. Czas ten wraz z czasem T
wymaganym do realizacji zadań programu tła nie powinny przekraczać w sumie 1
sekundy. W przeciwnym przypadku dojdzie do nawarstwiania się nieobsłużonych
przerwań i załamania się systemu oprogramowania sterownika .

Wartości występujących w powyższej relacji czasów: T, PZ, OA zależą od mocy
obliczeniowej jednostki centralnej sterownika. W sytuacji, gdy przy założonym typie
mikroprocesora warunek ten nie może być spełniony, należy szukać możliwości zwiększenia
mocy obliczeniowej sterownika poprzez zmianę jego CPU24. Prawdopodobne są również
przypadki spełnienia powyższego warunku ze znaczną rezerwą czasową. Można wtedy, o ile
pozwala na to sprzęt sterownika (dostępne wolne zasoby: pamięci oraz portów wejścia
i wyjścia) i zachodzi taka potrzeba, obsłużyć więcej niż jeden automat. Na podstawie dowodu
twierdzenia 3.1 słuszne będzie następujące twierdzenie.
24
CPU - jednostka centralna komputera (sterownika) - ang. Central Processing Unit
105

Twierdzenie 3.2
Warunkiem koniecznym prawidłowej pod względem czasowym pracy sterownika przy
obsłudze A automatów jest relacja:
A
T + fPZ  PZ + fOAa  OAa < 1
a=1
gdzie: fOAa - częstotliwości obsługi poszczególnych automatów;

OAa - maksymalne czasy obsługi każdego z A automatów.

Przy obsłudze kilku automatów przez jeden sterownik możliwe jest stosowanie
różnych częstotliwości fOAa, dostosowanych do indywidualnych wymagań sterowanych
obiektów (rysunek 3.9.a). Przy fOAa < fPZ procedury obsługi automatów mogą być uruchamiane
w tych samych przerwaniach zegarowych (rysunek 3.9.b) lub przesunięciem fazowym
(rysunek 3.9.c), dającym bardziej równomierne obciążenie mikroprocesora obliczeniami.
a) TO A 2   
PZ PZ PZ PZ
OA1 OA1 OA1 OA1

T T T T T
OA2 OA2
   TO A 1
t
 PZ  OA 1  OA 2
b) T O A 1 = T OA 2  OA 2
PZ PZ PZ PZ
OA1 OA1
T OA2 T T OA2 T T
 P Z  O A 1  O A 2  PZ  OA1 t
T - p rogram tła P Z - obsługa przerwania zegarowego O A1,OA2 - procedury obsługi automatów
c) T OA 1
PZ PZ PZ PZ
OA1 OA1
T T OA2 T T OA2 T
 P Z  O A 1 O A2 T O A2  OA1  P Z +  O A2 t
Rys. 3.9. Przykłady obsługi dwóch automatów w przerwaniach zegarowych:

a) fPZ = fOA1 = 2fOA2; b) fOA1 = fOA2 = fPZ /2 obsługa synchroniczna;
c) fOA1 = fOA2 = fPZ /2 obsługa z przesunięciem fazowym
106

Często zdarza się, że częstotliwości zmian różnych sygnałów binarnych w obrębie
tego samego obiektu są bardzo zróżnicowane. Wykorzystując do obsługi automatu przerwania
zegarowe należy oczywiście uwzględnić najszybciej zmieniające się sygnały, co może
powodować stosowanie dosyć dużych częstotliwości fPZ. Inny, niekorzystny przypadek to
zadanie sterowania obiektem, którego stan zmienia się rzadko, przykładowo kilka razy
na minutę, ale postawione jest wymaganie bardzo krótkiego, ułamkowego czasu reakcji
na zmianę dowolnego lub wskazanego sygnału binarnego odbieranego z obiektu. Zadanie takie
zmusza do bardzo częstego, przez co nadmiarowego, uruchamiania procedury obsługi
automatu. Moc obliczeniowa mikroprocesora jest wtedy tracona na obsługę jednego zamiast
kilku podobnych automatów. Rozwiązaniem tego problemu może być wykorzystanie przerwań
obiektowych, omówione w następnym punkcie.
3.2.3.3 Wykorzystanie przerwań obiektowych
Przerwaniami obiektowymi w przypadku sterownika procesu binarnego mogą być

bezpośrednio wyróżnione wejściowe sygnały dwustanowe lub generowane przez specjalne
układy sprzężenia, syntetyczne sygnały informujące mikroprocesor o zajściu zmiany w zbiorze
zmiennych wejściowych. Obsługa tego typu przerwań powinna polegać na odpowiedniej
reakcji ze strony algorytmu sterowania binarnego, przejawiającej się zmianą stanu automatu.
Rodzi się pytanie: „Czy możliwe jest wykorzystanie do tego celu prezentowanej
metody JODA?”. Odpowiedź na nie może być tylko twierdząca. Obsługa automatu w ramach
reakcji na przerwanie obiektowe powinna polegać na wykonaniu tych samych, co w przypadku
przerwań zegarowych, operacji. Należy jednak uwzględnić przewidywany system obsługi
przerwań sterownika, ponieważ zarówno procedura obsługi przerwania obiektowego jak
i zegarowego może wywoływać tę samą procedurę obsługi automatu. Rozważenia wymagają
trzy warianty organizacji systemu obsługi przerwań.
1. Jednopoziomowy system obsługi przerwań.
Ponieważ w tego typu systemie w określonej chwili może być uaktywniona co najwyżej
jedna procedura obsługi przerwania, nie istnieje niebezpieczeństwo wystąpienia konfliktów
w obsłudze automatu, polegających na tymczasowym jej zawieszeniu i zainicjowaniu od
początku za sprawą innego przerwania. Nawet w przypadku odstępu czasu między
przerwaniami: zegarowym i obiektowym  < OA, ze względu na jednopoziomowość
systemu przerwań, zostaną wykonane kolejno dwa niezakłócone cykle obsługi automatu, co
ilustruje rysunek 3.10.
107

INT
PZ PO PZ PO PZ
OA OA OA OA OA
T T T T
 P Z  O A  PO  O A   t
PZ - obs ługa p rzerwania z egarowego P O - obsługa przerwania obiektowego

T - program tła O A - o bsługa automatu
Rys. 3.10. Wykorzystanie przerwań zegarowych i obiektowych do obsługi automatu

przy jednopoziomowym systemie przerwań
2. System przerwań wielopoziomowy, priorytetowy, o jednakowych priorytetach przerwań
zegarowych i obiektowych.
Funkcjonowanie mechanizmu obsługi automatu nie różni się niczym od wcześniej
opisanego przypadku systemu jednopoziomowego.
3. System przerwań wielopoziomowy, priorytetowy, o różnych priorytetach przerwań
zegarowych i obiektowych.
W tym przypadku istnieje potencjalna możliwość zawieszenia realizacji obsługi automatu
przez wystąpienie przerwania o wyższym priorytecie, które spowoduje zainicjowanie od
początku cyklu obsługi tego automatu. Należy tu zaznaczyć, że chociaż procedura
wyznaczania stanu następnego może być współużywalna, to już cała procedura obsługi
automatu taka nie jest, ponieważ operuje na stałym obszarze danych zawierających
informację o bieżącym stanie automatu. Niewspółużywalność procedury obsługi automatu
prowadzi do błędów pracy programu, gdy jej realizacja zostaje zawieszona i zainicjowana
od początku. Można jednak temu zaradzić stosując odpowiedni mechanizm semaforów
i flag. Przykładowy algorytm rozwiązania tego problemu, przy założeniu różnych
priorytetów przerwań, przedstawia się następująco:
(i) przed rozpoczęciem obsługi automatu w przerwaniu o niższym priorytecie „opuszcza
się” odpowiedni semafor, np. obsługa:=1, a po jej zakończeniu „podnosi się” go:
obsługa:=0;
(ii) w obsłudze przerwania o wyższym priorytecie sprawdza się stan semafora - jeżeli jest
on podniesiony (obsługa=0), to wywołuje się odpowiednią procedurę obsługi
automatu, jeżeli jest opuszczony (obsługa=1), to pomija się to wywołanie, ustawiając
108

zastępczo flagę powtórz:=1 i odnotowując w dodatkowej strukturze danych aktualny
stan słowa wejściowego xt automatu;
(iii) po zakończeniu obsługi automatu w procedurze o niższym priorytecie dodatkowo
sprawdza się stan flagi powtórz - jeżeli jest ustawiona, to zeruje się ją i ponownie
wywołuje się procedurę obsługi automatu jak w (i).

I NT
PO   PO
PZ PZ PZ
OA OA OA OA OA
T T T T
t
obs ługa:=1
powtórz:=1
o bs ługa:=0
obs ługa:=1
powtórz:=0
obs ługa:=0
obs ługa:=1
obs ługa:=0
obs ługa:=1
obs ługa:=0
PZ - obsługa przerwania zegarowego P O - obsługa przerwania obiektowego
T - program tła OA - obsługa automatu
Rys. 3.11. Wykorzystanie przerwań zegarowych i obiektowych do obsługi automatu

przy wielopoziomowym, priorytetowym systemie przerwań
Działanie proponowanego algorytmu ilustruje rysunek 3.11. Jeżeli system

mikroprocesorowy spełnia warunek podany w twierdzeniu 3.1, to czas dysponowany d
(niewykorzystany do realizacji zadania sterowania) w ciągu jednej sekundy wynosi:
d = 1 - (T + fPZ  PZ + fOA  OA)
Przy założeniu, że obsługa automatu w przerwaniu obiektowym trwa łącznie PO + OA,
można określić maksymalną częstotliwość występowania przerwań obiektowych, przy
której sterownik będzie działał poprawnie:
fPOmax = int(d / (PO + OA) )
Analogiczne szacunki można przeprowadzić w przypadku sterownika obsługującego
A automatów - wykorzystując warunek podany w twierdzeniu 3.2 mamy czas
dysponowany:
A
‘d = 1 - (T + fPZ  PZ + fOAa  OAa)
a=1
oraz łączną maksymalną częstotliwość występowania przerwań obiektowych:

109

f’POmax = int(‘d / P)
gdzie: P = sup(OAa + Poa), a=1..A.
Zgodnie z powyższymi rozważaniami metoda JODA może mieć zastosowanie także
przy programowaniu bardziej wymagających zadań sterowania binarnego, dzięki potencjalnej
możliwości uwzględnienia przerwań obiektowych sygnalizujących pewne szczególne
zdarzenia w sterowanym obiekcie. Co więcej, w krańcowym przypadku obsługę automatu
można inicjować tylko w przerwaniach obiektowych. Polegałoby to na usunięciu wywołań
procedury OA z wnętrza procedury obsługi przerwań zegarowych PZ lub wręcz na rezygnacji
z tych ostatnich. Należy jednak pamiętać o zadaniach sterowania, w których obok sterowania
logicznego konieczne są inne działania, związane przykładowo z regulacją wielkości ciągłych.
Te działania winny być realizowane właśnie w przerwaniach zegarowych, zapewniających im
stały okres obsługi.
3.2.4 Możliwości autodiagnostyczne metody
Ważnym aspektem funkcjonowania sterownika jest kontrola poprawności jego pracy.

W celu zapewnienia tej kontroli stosuje się różne środki programowe i sprzętowe [71, 73].
Opracowana metoda JODA także umożliwia autodiagnostykę układu sterowania, która może
być zrealizowana na dwóch poziomach obsługi automatu.
3.2.4.1 Diagnostyka na poziomie opisu automatu
Jedną z płaszczyzn dla autodiagnostyki może być sam algorytm sterowania binarnego.
Projektując automat możemy przewidzieć oprócz normalnych stanów jego pracy, tzn. takich
jakie są możliwe przy prawidłowym zachowywaniu się sterownika i obiektu, także stany
awaryjne. Przejście ze stanu normalnego do awaryjnego powinno być uwarunkowane
odpowiednim wyrażeniem logicznym. Ogólnie przyczyny przejścia automatu do stanu
awaryjnego można podzielić na dwie grupy:
 brak spodziewanej reakcji obiektu na wysłane sterowanie (binarne lub ciągłe); źródłem tego
może być uszkodzenie torów przesyłowych sygnałów wejściowych i wyjściowych
sterownika, awarie wewnątrz samego obiektu, zanik zasilania czynnikiem energetycznym;
 wystąpienie nieoczekiwanych zmian w sygnałach (binarnych lub ciągłych) przychodzących
z kontrolowanego obiektu, co może mieć podobne jak wyżej źródła.
Uwzględnienie w grafie przejść automatu powyższych zdarzeń polega
na wprowadzeniu do niego dodatkowych węzłów reprezentujących stany alarmowe i krawędzi
110

skierowanych odpowiadających możliwym przejściom do tych stanów. W automacie może być
więcej niż jeden stan alarmowy. Każdy z tych stanów może wtedy odpowiadać za obsługę
innego niepożądanego zdarzenia w procesie sterowania. Działania jakie przypisze się stanom
alarmowym i słowa wyjściowe yt tych stanów zależą od konkretnych aplikacji. Zależnie od
potrzeb i możliwości jakimi dysponujemy, przejście automatu do stanu alarmowego może
powodować jedynie odpowiednią sygnalizację na pulpicie operatora, a może też być związane
z próbą przeciwdziałania sytuacji awaryjnej. W tym drugim przypadku graf przejść ulega co
prawda dalszej rozbudowie o dodatkowe stany „ratunkowe”, ale uzyskuje się lepszy
jakościowo sterownik, który jest w stanie wyprowadzić samodzielnie obiekt z przynajmniej
części sytuacji awaryjnych.
W warunkach przejść do stanów awaryjnych bardzo często występuje jako argument
czas, a dokładnie flaga sygnalizująca upłynięcie pewnego zadanego odcinka czasu, w ciągu
którego przy prawidłowo działających wszystkich elementach sterownika i obiektu powinna
nastąpić zmiana stanu obiektu (słowa xO). Wielkość tego odcinka czasu może być
dodatkowym czasem charakterystycznym stanu tCSA. Aby wykorzystać ten parametr czasowy,
należy wtedy użyć jeszcze jednego timera programowego odmierzającego czas normalnego
przebywania w danym stanie. Zarówno timer podstawowy odmierzający odcinki czasu zadane
algorytmem sterowania jak i timer alarmowy, mogą być wspólne dla wszystkich stanów
danego automatu. Dzięki temu potrzebna jest tylko jedna procedura wyznaczania wartości flag
stanu timerów wchodzących do słowa xW. Często okazuje się po dokładniejszej analizie
zadania, że funkcje timera alarmowego może pełnić timer podstawowy.
3.2.4.2 Diagnostyka systemu obsługi automatów
Drugą możliwą formą nadzorowania pracy układu sterowania jako automatu jest
kontrola na poziomie procedur wyznaczających jego nowy stan. Polega ona na analizowaniu
kolejnych stanów osiąganych przez automat i na wykrywaniu pojawiających się zapętleń
w grafie przejść. Zapętlenia te polegają na trwałym ograniczeniu w trakcie pracy automatu
zbioru wykorzystywanych stanów do pewnego zbioru SP  S. W najprostszym przypadku ||SP||
= 2. Przyczyny takich zjawisk są dwojakiego rodzaju:
 błąd projektowy, polegający na takim zdefiniowaniu funkcji przejść, że:
 xP : (sPi,xP)=sPi+1 dla i=1..n-1 oraz (sPn,xP)=sP1
gdzie SP={sP1,...,sPn} i SP  S i 1 < ||SP|| < N
111

słowo xP może być jednym ze słów x  X pojawiających się przy prawidłowej pracy
sterownika i obiektu, ale równie dobrze może być nieprzewidzianym przez projektanta
słowem odpowiadającym jakiemuś stanowi awaryjnemu;
 uszkodzenie w układach sprzężenia z obiektem powodujące docieranie do automatu
fałszywego słowa wejściowego xO’  xO, przez co x’  x i:
 SP={sP1,...,sPn} oraz X’={x1’,...,xk’} : (sPi,xj’)=sPm dla: i=1..n, j,m = 1..k
zapętlenie się automatu powstaje wtedy za sprawą niedoskonałości funkcji przejść nie
uwzględniających wszystkich możliwych błędnych słów wejściowych.
Oba te przypadki uzewnętrzniają się niezrozumiałym działaniem sterownika i utratą jego
zdolności do dalszego sterowania obiektem, zmuszając do sprzętowego zerowania urządzenia.
Wystąpienie zapętlenia pierwszego rodzaju jest szczególnie niebezpieczne przy
zastosowaniu iteracyjnego algorytmu zmiany stanu. Wywołanie procedury realizującej ten
algorytm ze słowem wejściowym xP spowoduje zablokowanie obsługi tego i innych
automatów. Dostępne są jednak środki zaradcze zapobiegające występowaniu takich zjawisk
lub je wykrywające.
Stosując dokładną analizę projektu automatu przed jego implementacją w języku
programowania sterownika, można sprawdzić możliwość wystąpienia zapętleń w trakcie
późniejszej pracy sterownika. Sprawdzenie to polega na analizie funkcji przejść dla
wszystkich, nawet tylko teoretycznie możliwych słów wejściowych. Wykryte pętle powinny
być przerwane poprzez odpowiednią modyfikację funkcji przejść.
Sposobem uwalniającym od wstępnej, dogłębnej analizy pracy automatu jest
odpowiednie rozbudowanie procedur jego obsługi we wnętrzu sterownika. Te dodatkowe
operacje nie są skomplikowane i nie obciążają znacząco procesora sterownika. Można
na przykład wykorzystać dodatkowy wektor flag wykorzystania stanów FWS, zawierający tyle
flag ile jest stanów w automacie. Przed każdym uruchomieniem procedury iteracyjnego
wyznaczania nowego stanu flagi FWS są kasowane, z wyjątkiem flagi stanu bieżącego si -
FWS[si]:=1. Po każdej iteracji, dla wyznaczonego stanu następnego sj sprawdza się czy już
FWS[sj]=1. Jeżeli flaga jest wyzerowana, to ustawia się ją (FWS[sj]:=1) i powtarza iterację,
w przeciwnym przypadku (FWS[sj]=1) nastąpiło zapętlenie się procedury iteracyjnej i należy
wtedy przerwać jej działanie. W przypadku konieczności przerwania iteracji wskazane jest
przejście do odpowiedniego stanu alarmowego i zasygnalizowanie tego operatorowi.
Innym sposobem do zaimplementowania w procedurze wyznaczającej następny stan
automatu metodą iteracyjną jest licznik powtórzeń iteracji. Zeruje się go na początku
112

procedury i inkrementuje po każdym wyznaczeniu stanu następnego. Gdy stan tego licznika
przekroczy pewną zadaną wartość, uznaje się, że nastąpiło zapętlenie automatu. Wartością
progową może tu być liczba N stanów automatu lub dowolna inna N’ < N. Przekroczenie
przez licznik iteracji wartości progowej powinno, tak jak w poprzedniej metodzie, powodować
przejście do odpowiedniego stanu alarmowego.
Drugi z opisanych przypadków zapętlenia się automatu, jako związany z pewną
sekwencją słów wejściowych X’ jest o wiele trudniejszy do wykrycia. Niemożliwe jest jego
rozpoznanie w jednym cyklu obsługi, nawet przy stosowaniu algorytmu iteracyjnego.
Stosowanie śladu pracy automatu w postaci tablicy pamiętającej L ostatnich stanów również
nie zdaje egzaminu, ponieważ w przypadku ogólnym możliwa jest poprawna praca polegająca
na cyklicznym przełączaniu między kilkoma, z wielu możliwych, stanami. Środkiem
zaradczym wydaje się być tylko odpowiednie rozbudowanie funkcji przejść o wyrażenia
wykrywające nieoczekiwane zmiany sygnałów wejściowych automatu.
3.2.5 Możliwości połączenia sterowania binarnego i ciągłego
Chociaż metoda JODA jest ukierunkowana na opisywanie algorytmów sterowania

binarnego, istnieje możliwość wykorzystania jej w sterowaniu procesami binarno-ciągłymi.
Tego typu zadania sterowania łączą w sobie elementy sterowania binarnego z regulacją
Warstwa sterowania dyskretnego polega przede wszystkim na sterowaniu pracą
dwustanowych urządzeń wykonawczych (silniki, zawory, itp.) i kontrolowaniu ich zachowania
się. Może również dotyczyć całych grup urządzeń wykonawczych, realizujących wspólnie
pewne zadanie technologiczne. Przykłady takich zespołów funkcjonalnych urządzeń
dwustanowych można znaleźć w rozdziale czwartym niniejszej pracy. Są nimi między innymi:
pasteryzatory, będące urządzeniami składowymi linii technologicznej, zespół pił tnących,
belka dociskowa czy też wózek formatyzerki. Pracę takich zespołów można opisać podobnie
jak zwykłego automatu określonego definicją 3.3.
Warstwa regulacyjna procesów binarno-ciągłych służy kontroli wartości wybranych
parametrów ciągłych obiektu. W praktyce przemysłowej, parametrem tym bywa bardzo często
temperatura, ale może to być także inna wielkość fizyczna (ciśnienie, przesunięcie, itp.).
Technika mikroprocesorowa daje duże możliwości w dziedzinie regulacji wielkości ciągłych.
Obok prostych, klasycznych algorytmów regulacji, realizowalnych w technice analogowej,
możliwe jest stosowanie złożonych koncepcyjnie i obliczeniowo procedur wyznaczania
113

wartości sygnału sterującego obiektem. Dosyć łatwo można zrealizować regulację adaptacyjną,
samonastrajającą się, nadążną. Istnieje także możliwość generalnych zmian algorytmów
regulacji, zależnie od stanu procesu. Przykładem tego mogą być wspomniane już
pasteryzatory, w których zastosowano inne algorytmy regulacji temperatur w fazie rozruchu,
a inne w fazie pracy ciągłej.
Potencjalne możliwości łączenia dwóch wymienionych warstw sterowania tkwią
w metodzie JODA w definicji słowa wyjściowego automatu. Zgodnie z definicją 3.5 słowo
wyjściowe y automatu może się składać:
 z wyjściowych zmiennych binarnych tworzących przede wszystkim słowo wyjściowe yO
sygnałów oddziałujących na obiekt a także słowo flag yS, służących koordynacji pracy
danego automatu z pozostałymi składnikami rozbudowanego systemu automatyki;
 z zakodowanych binarnie zmiennych wielowartościowych yW.
W punkcie 3.1.4.2 zasygnalizowano już możliwość wykorzystania tych ostatnich zmiennych
do definiowania wartości czasów charakterystycznych tCS stanów automatu. Wartości liczbowe
składające się na słowo yW mogą równie dobrze być wykorzystane przez algorytmy regulacji
wielkości ciągłych. Liczby te mogą reprezentować zarówno współczynniki regulatorów jak
i wskaźniki do różnych wariantów regulacji. Przykładami takiego zastosowania składnika yW
słowa wyjściowego y automatu są pasteryzatory mleka, serwatki i wody technologicznej,
w których typ algorytmu regulacji temperatury został uzależniony od bieżącego stanu całego
pasteryzatora traktowanego jak automat skończony.
Liczby umieszczone w części yW słowa wyjściowego automatu mogą wskazywać
również na inne złożone operacje, których wykonanie jest zależne od stanu automatu. Zwykle
są to jakieś działania arytmetyczne i organizacyjne niezbędne do poprawnej pracy całego
urządzenia. Przykładowo w opisywanym w rozdziale 4.3 sumatorze hematologicznym,
zależnie od stanu automatu sterującego jego pracą, realizowane są między innymi różne
operacje na wewnętrznych licznikach krwinek, a w sterowniku formatyzerki (rozdział 4.2) stan
automatu Wózek wpływa na wybór dodatkowych procedur obliczeniowych związanych z
kontrolą położenia i realizacją programu cięcia sklejki.
Zależnie od docelowej implementacji, wartości liczbowe zawarte w słowie yW mogą
oznaczać:
 numery porządkowe różnych wariantów operacji, które należy przeprowadzić
w poszczególnych stanach automatu;
 adresy procedur (wskaźniki do nich) realizujących te operacje.
114

Od decyzji programisty i od potrzeb wynikających z zadania sterowania zależy również sposób
realizacji tych dodatkowych działań przypisanych stanom automatu. Operacje te mogą być
wykonywane zarówno:
 jednorazowo po wejściu automatu do danego stanu, w celu wykonania działań
wspomagających sterowanie, na przykład wyliczenie drogi przejazdu, aktualizacja
położenia;
 w każdym cyklu obsługi automatu, tzn. dana operacja jest powtarzana przez cały czas
przebywania automatu w danym stanie, jest to rozwiązanie typowe dla procedur regulacji
Podczas cyklu obsługi automatu, po sprawdzeniu warunków przejść i ewentualnej
zmianie stanu automatu można uruchomić odpowiednie procedury, na które wskazuje
zawartość części yW słowa wyjściowego y. Jednokrotne lub ciągłe wykonywanie wybranych
procedur można zrealizować przy pomocy dodatkowej zmiennej logicznej, będącej
wewnętrzną zmienną systemu operacyjnego sterownika. Zmienna ta pełniąc rolę flagi, nie
musi wchodzić do słów x i y automatu. Jej zadaniem jest sygnalizowanie faktu wykonania
procedury przypisanej bieżącemu stanowi. Procedura może być realizowana gdy proponowana
flaga jest wyzerowana, a jest pomijana - w przeciwnym przypadku. Wejściu do nowego stanu
towarzyszy przy tym automatyczne zerowanie tej flagi. Dzięki temu każda procedura może być
wykonana przynajmniej raz, po przejściu automatu do nowego stanu. Jeżeli w treści procedury
nastąpi ustawienie flagi, uniemożliwi to ponowne wykonanie tej procedury w następnym cyklu
obsługi automatu. W przypadku pozostawienia flagi w stanie wyzerowania, w każdym cyklu
obsługi automatu będzie uruchamiana odpowiednia procedura. Mechanizm ten ilustruje
rysunek 3.12, przedstawiający w formie schematów blokowych fragment cyklu obsługi
automatu oraz struktury dwóch przykładowych procedur: jednokrotnej i wielokrotnej.
115

a) b) START
proc. 1-krotnej
sprawdzenie warunków przejść
operacje
T
czy nowy stan ? omiń_proc := 1
N omiń_proc := 0
RETURN
T c) START
omiń_proc = 1 ? proc. wielokrotnej
N
operacje
procedurai
RETURN
Rys. 3.12. Wykorzystanie flagi „omiń_proc” do sterowania wykonywaniem

procedury przypisanej do stanu automatu: a) - fragment cyklu obsługi automatu;
b) - struktura procedury wywoływanej jednokrotnie po wejściu do danego stanu;
c) - struktura procedury wywoływanej w każdym cyklu obsługi automatu
Opisany mechanizm wplatania w algorytm sterowania binarnego innych działań

związanych z regulacją wielkości ciągłych lub z operacjami wspierającymi to sterowanie,
stwarza duże potencjalne możliwości stosowania metody JODA do programowania szerokiej
gamy niestandardowych aplikacji sterowników mikroprocesorowych. Możliwości te zostały
potwierdzone aplikacjami zrealizowanymi przy użyciu tej metody.
116

3.3 Język programowania dyskretnych automatów - JODA
Pierwsze praktyczne zastosowanie prezentowanej metody programowania sterowania

binarnego, opisane w punkcie 4.1, wykazało, że dzięki niej:
 potrzebna jest tylko jedna, wspólna dla wszystkich automatów, procedura wartościująca
wyrażenia logiczne i wyznaczająca kod następnego stanu;
 nie trzeba pisać dla każdego stanu i automatu indywidualnych procedur obliczających
wartości odpowiednich wyrażeń logicznych;
 uzyskuje się możliwość łatwej modyfikacji algorytmu sterowania, polegającej tylko
na wymianie fragmentów kodu programu sterownika;
 pełne korzystanie z powyższych zalet wymaga jednak oprogramowania narzędziowego
wspomagającego proces generacji struktur danych opisujących zachowanie się automatu.
Spostrzeżenia te skłoniły autora do stworzenia odpowiedniego oprogramowania. Jest nim
translator JODA, który przetwarza język deklaracji i wyrażeń logicznych na potrzebne tablice
przejść i wyjść.
Pierwsza wersja translatora powstała w 1990 roku i miała bardzo ograniczone
możliwości: tylko generację tablic przejść w języku mikroprocesora Z80. Rok później
możliwości programu uległy poszerzeniu o generację tablic wyjść i mikrokomputery rodziny
MCS51 [31, 32]. Kolejne rozszerzenia wersji podstawowej, zachodzące w następnych latach,
były częściowo wymuszane kolejnymi aplikacjami układów sterowania realizowanych przy
użyciu metody JODA. Także obecna wersja translatora powinna być traktowana jako etap
pośredni na drodze do kompletnego systemu programowania nietypowych implementacji
sterowania binarnego. System taki powinien być wzbogacony o odpowiedni interfejs graficzny
użytkownika i możliwość pracy w trybie on-line w celu monitorowania pracy automatu
i debugowania algorytmu sterowania. Poniższy rozdział prezentuje właściwości translatora
JODA na obecnym etapie jego rozwoju.
3.3.1 Składnia języka
Język Opisu Dyskretnych Automatów służy do opisu działania automatu

skończonego, za jaki można uważać sterownik binarny podłączony do obiektu. Składnia tego
języka umożliwia dla projektowanego automatu:
 wybór platformy programowej;
 zdefiniowanie słowa wejściowego X = XO  XW  XS;
117

 zdefiniowania słowa wyjściowego Y = YO  YW  YS;
 zadeklarowanie zbioru S = {s1, s2, ..., sN}stanów automatu oraz wartości zmiennych
wyjściowych Yi  si  S;
 zdefiniowanie warunków przejść pomiędzy dowolnymi dwoma stanami si, sj  S w formie
wyrażeń logicznych o składni typowej dla języków wysokiego poziomu;
 stosowanie mnemotechnicznych nazw stanów i zmiennych logicznych;
 stosowanie rozbudowanych komentarzy objaśniających poszczególne obiekty w programie;
 zawarcie w jednym pliku źródłowym opisu więcej niż jednego automatu;
 przeprowadzenie translacji odwrotnej, polegającej na odtworzeniu na podstawie wcześniej
wygenerowanych tablic przejść i wyjść opisu w formacie języka JODA.
25
Składnia języka JODA w zmodyfikowanej notacji Backusa-Naura (MBNF ), której
opis można znaleźć np. w [44], przedstawia się następująco:
program = ”jezyk” język_docelowy ”;” opis_automatu { ”;” opis_automatu } ”.” .

język_docelowy = ”az80” | ”a8051”| ”c16”| ”c32” | ”pascal” | ”c” .
opis_automatu = tekst_źródłowy | tekst_zakodowany .
tekst_źródłowy = nagłówek deklaracja_wejść [ deklaracja_wyjść ] [ deklaracja_flag ]
deklaracja_stanów opis_przejść ”koniec” .
nagłówek = ”automat” tekst ”;” .
tekst = ciąg_znaków .
ciąg_znaków = {”znak ASCII”} .
deklaracja_wejść = ”bity” bajt_wejść ”;” { bajt_wejść ”;” } .
bajt_wejść = bajt .
bajt = bit ”,” bit ”,” bit ”,” bit ”,” bit ”,” bit ”,” bit ”,” bit .
bit = ( ”-” | identyfikator ) .
deklaracja_wyjść = ”wyjscia” { bajt_wyjść ”;” }
[ deklaracja_stałej { ”,” deklaracja_stałej } ”;” ] .
bajt_wyjść = bajt .
deklaracja_stałej = deklaracja_rozmiaru_stałej [ deklaracja_nazwy_stałej ].
deklaracja_rozmiaru_stałej = rozmiar_bajtu | rozmiar_słowa | rozmiar_czerobajtowy .
rozmiar_bajtu = ”#” .
rozmiar_słowa = ”##” .
25
MBNF - Modified Backus-Naur Form
118

rozmiar_czterobajtowy = ”####” .
deklaracja_nazwy_stałej = identyfikator .
deklaracja_flag = ”flagi” bajt_flag ”;” { bajt_flag ”;” } .
bajt_flag = bajt .
identyfikator = litera { litera | cyfra } .
litera = ”a” | .. | ”z” | ”A” | .. | ”Z” .
cyfra = ”0” | ”1” | ”2” | ”3” | ”4” | ”5” | ”6” | ”7” | ”8” | ”9” .
deklaracja_stanów = ”stany” opis_stanu ”;” { opis_stanu ”;” } .
opis_stanu = identyfikator_stanu ”:” [ bit { ”,” bit } { ”,” stała }] | [ stała { ”,” stała }] ”;” .
identyfikator_stanu = identyfikator .
stała = liczba | identyfikator .
liczba = cyfra { cyfra } .
opis_przejść = ”funkcje” przejście { przejście } .
przejście = identyfikator_stanu ”-” identyfikator_stanu ”:” wyrażenie_logiczne ”;” .
wyrażenie_logiczne = składnik { ”+” składnik } .
składnik = czynnik { ”*” czynnik } .
czynnik = identyfikator | ”/” czynnik | ”(” wyrażenie_logiczne ”)” .
tekst_zakodowany = nagłówek_kodu [ deklaracja_wejść ] program_zakodowany ”koniec” .
nagłówek_kodu = ”dekoduj” tekst ”;” .
program_zakodowany = ”treść zakodowanego uprzednio programu” .
dyrektywa = nazwa_dyrektywy parametr_dyrektywy .
nazwa_dyrektywy = ”list” | ”opt” .
parametr_dyrektywy = ”on” | ”off” .
komentarz = ”{” tekst ”}” .

Uwagi dodatkowe:
 identyfikatory muszą być obiektami unikalnymi w obrębie danego automatu, ich długość
nie powinna przekraczać 10 znaków;
 bity w bajtach wejściowych i wyjściowych podaje się w kolejności od najstarszego
do najmłodszego, a bajty opisuje się w kolejności od najmłodszego do najstarszego;
 znak ”-” przy deklarowaniu tych bitów oznacza nieużywaną przez dany automat pozycję
w bajcie;
119

 deklaracja stałej w słowie wyjściowym określa przede wszystkim jej rozmiar w bajtach (‘#’
- 1 bajt, ‘##’ - 2 bajty, ‘####’ - 4 bajty), opcjonalnie po zdefiniowaniu rozmiaru można
podać nazwę tej stałej - będzie ona miała znaczenie przy deklaracjach typów rekordowych
na potrzeby zapisu w języku wysokopoziomowym (Pascal, C);
 znaki ”/”, ”*” i ”+” to operatory: negacji, iloczynu i sumy logicznej;
 translator dopuszcza także następujące uproszczenia w zapisie wyrażeń logicznych:
”)” czynnik  ”)*” czynnik
czynnik ”(”  czynnik ”*(”
czynnik „/”  czynnik ”*/”
”//” czynnik  czynnik
przedstawiona notacją MBNF składnia wyrażeń, w celu uzyskania prostego jej zapisu,
uwzględnia tylko nieuproszczone wersje wyrażeń;
 stałe charakterystyczne stanów, podczas deklaracji stanów mogą być określane poprzez ich
nazwy, znaczenie tych nazw (reprezentowana przez nie wartość) musi być wtedy
zdefiniowane w treści programu docelowego;
 komentarz może rozpoczynać się w dowolnym miejscu opisu z wyjątkiem „wnętrza”
identyfikatorów i słów kluczowych;
 dwie dostępne dyrektywy służą sterowaniu opcjami: przedruku tłumaczonego opisu
automatu do pliku zawierającego raport z działania translatora (list) oraz optymalizacji
wyrażeń logicznych (opt).
Możliwości leksykalne translatora są następujące:
 długość identyfikatorów stanów i bitów (zmiennych logicznych) ograniczona do 8 znaków;
 maksymalna liczba stanów w jednym automacie: 256;
 maksymalny rozmiar słowa wejściowego: 32 bajty (256 zmiennych x  X);
 maksymalny rozmiar słowa wyjściowego: 32 bajty (256 bitów) wyjściowych zmiennych
logicznych (yO  YO), 32 bajty flag wyjściowych (yS  YS), 10 jedno- , dwu- lub
czterobajtowych stałych charakterystycznych stanu (yW  YW).
Translator ma rozbudowaną diagnostykę danych wejściowych, ze szczególnym
uwzględnieniem kontroli wyrażeń logicznych, wskazywaniem miejsca i rodzaju wykrytych
błędów. Wynikiem jego pracy może być raport z translacji, zawierający przedruk tekstu
źródłowego z zaznaczeniem ewentualnych błędów. Przy braku błędów w danych wejściowych
generowany jest plik tekstowy w formacie zgodnym z zadeklarowanym językiem docelowym
120

translacji. Zawiera on zapisane w składni języka docelowego: listę stanów automatu, tablicę
wyjść, tablicę flag i tablicę zakodowanych funkcji przejść, o strukturach opisanych w punkcie
3.2.2. Plik ten może być następnie dołączony do właściwego tekstu programu sterownika,
zapisanego w asemblerze lub języku wysokiego poziomu. Przykład 3.5 zawiera plik tekstowy
opisujący automat z przykładu 3.4 w języku JODA oraz wynik jego translacji.
Przykład 3.5
Opis automatu z przykładu 3.4 w języku JODA może wyglądać na przykład tak:
jezyk a8051
automat 'przykladowy'
bity
t,-,-,-,-,-,a,b;
{ Znaczenie bitow:
t - flaga uplyniecia czasu char. stanu;
a,b - sygnaly wejsciowe}
wyjscia
-,-,-,-,-,-,w1,w0;
#; {deklaracja stalej jednobajtowej}
{ znaczenie wyjsc:
w1,w0 - sygnaly wyjsciowe}
stany
s1:; {stan 1}
s2:w0,w1,5; {stan 2}
s3:w0; {stan 3}
s4:w0,15; {stan 4}
funkcje
s1-s2=/a/b;
s1-s4=a;
s2-s1=a/b;
s2-s3=t*b/a;
s2-s4=t/a/b;
s3-s1=a/b;
s3-s4=b;
s4-s1=/a;
s4-s3=a/b+t;
koniec.
Poniżej jest przedstawiony plik wynikowy w asemblerze A8051 (MCS51) będący wynikiem
translacji opisu przykładowego automatu.
; CROSS-TRANSLATOR JODA 29. 3.96 / 17:43: 5
; AUTOMAT 'przykladowy'
; wykaz stanow automatu
s1: equ 0
s2: equ 1
s3: equ 2
s4: equ 3
; bloki opisu automatow:
db 00h,0 ; s1
dw s1tp ; s1
db 03h,5 ; s2
dw s2tp ; s2
db 01h,0 ; s3
dw s3tp ; s3
db 01h,15 ; s4
dw s4tp ; s4
121

; CROSS-TRANSLATOR JODA 29. 3.96 / 17:43: 5
; AUTOMAT 'przykladowy'
; tablice przejsc automatu:
s1tp: db 2,03h,00h,s2,02h,02h,s4,s1
s2tp: db 3,03h,02h,s1,83h,81h,s3,83h,80h,s4,s2
s3tp: db 2,03h,02h,s1,01h,01h,s4,s3
s4tp: db 3,02h,00h,s1,03h,02h,s3,80h,80h,s3,s4

3.3.2 Przetwarzanie wyrażeń logicznych
Znacząca część kodu translatora JODA jest poświęcona przetwarzaniu wyrażeń

logicznych. Polega ono na ich przekształcaniu z dosyć swobodnej, ale za to wygodniejszej dla
użytkownika, formy zapisu do postaci APN, by następnie przedstawić je jako tablice wartości
liczbowych, zakodowane tak, by można było zastosować uniwersalną procedurę wyznaczania
kodu następnego stanu automatu. Położenie tak dużego nacisku na proces kodowania funkcji
przejść wynika z wykazanego w punkcie 3.2.3 uzależnienia złożoności obliczeniowych D i
C od wielkości zadania wartościowania tych funkcji, mierzonego liczbą implikantów
występujących w przekształconym wyrażeniu. Na proces przekształcania wyrażeń logicznych
z zapisu symbolicznego do zakodowanego składa się szereg operacji, które zostaną omówione
w dalszej treści pracy.
3.3.2.1 Przejście na zapis wyrażenia w notacji polskiej
Interesującą właściwością zastosowanego w translatorze konwertera wyrażeń

logicznych jest to, że działa on na ich zapisie symbolicznym. Fakt ten został wykorzystany
w demonstracyjnej wersji translatora, umożliwiającej obserwację procesu przekształcania
i minimalizacji wyrażenia logicznego krok po kroku. Wyrażenia nie są oczywiście
przetwarzane w ich postaci tekstowej. W trakcie analizy leksykalnej wyrażenia następuje jego
zakodowanie w formie ciągu symboli: Ai reprezentujących zmienne logiczne (argumenty) i Oi
reprezentujących pozostałe składniki wyrażenia (operatory logiczne, nawiasy, średnik
kończący zapis). Operacja taka jest rozwiązaniem typowym dla kompilatorów [7, 30].
Symbole Ai kodujące zmienne logiczne odpowiadają, co do wartości liczbowej, położeniu tych
zmiennych w słowie wejściowym X automatu. Identyfikatory zmiennych logicznych wraz z
przyporządkowanymi im symbolami Ai są przechowywane w słowniku będącym integralną
częścią analizatora leksykalnego. Pozostałym możliwym składnikom wyrażenia
przyporządkowuje się symbole Oi , zgodnie z tabelą 3.2. Między wartościami liczbowymi tych
symboli obowiązuje relacja:
122

 Ai | i = 1..N Ai < O1 < O2 < O3 < O4 < O5 < O6 Tabela 3.2
gdzie: N - liczba zmiennych wejściowych (N < 256). Przyporządkowanie znakom
specjalnym symboli wewnętrznych
Relacja ta uwzględnia priorytet wykonywania
Znak składowy Symbol
operacji logicznych. wyrażenia wewnętrzny
W trakcie kodowania wyrażenia następuje ( O1
automatyczne zastąpienie dopuszczalnych ) O2
uproszczeń w jego zapisie, zapisem pełnym. + O3
Realizowane przez analizator przypisania pokazuje * O4
tabela 3.3. / O5
Opisane wyżej postępowanie jest etapem ; O6
wstępnym, przygotowującym treść wyrażenia do jego

Tabela 3.3
dalszego przetwarzania. Kolejnym krokiem jest Zestawienie przekształceń
26
przekształcenie zapisu zwykłego wyrażenia w zapis uproszczonego zapisu wyrażeń
logicznych
przyrostkowy27, zwany często notacją polską [7, 30].
Zapis Zapis pełny
Notacja polska jest sposobem reprezentacji uproszczony
a/b a*/b
wyrażeń dokładnie wyznaczającym porządek
a/( a*/(
wykonywanych operacji, bez użycia nawiasów. )/a )*/a
Przymiotnik „przyrostkowa” wynika z tego, a( a*(
)a )*a
że operator występuje nie pomiędzy, a bezpośrednio )( )*(
po argumentach, których dotyczy. Innymi //a a
charakterystycznymi cechami notacji polskiej jest:
 występowanie argumentów operacji w tej samej kolejności co w zapisie zwykłym;
 kolejność występowania operatorów od lewej do prawej jest zgodna z kolejnością ich
obliczania.
I tak, wyrażenie logiczne dane w notacji zwykłej (z uproszczeniami w zapisie) jako:
b(c+/d+/b)e+b/a/(c+d)+a
po przekształceniu do notacji polskiej może przyjąć postać:
b c d /+ b /+* e *+ b a /* c d +/* a +
lub inną równoważną np.:
b c d / b /++ e **+ b a / c d +/** a +
26
termin ang. „infix”
27
termin ang. „postfix”
123

W literaturze można znaleźć kilka algorytmów przekształcania zapisu zwykłego
na przyrostkowy [7, 30, 55]. Wbudowany w translator JODA algorytm można nazwać
algorytmem „górki rozrządowej”. Wykorzystuje on „tor wjazdowy” zawierający wejściowy
ciąg symboli, tworzących zwykły zapis wyrażenia, „bocznicę” operatorów, działającą jak
rejestr LIFO, oraz „tor wyjazdowy”, na którym pojawiają się kolejne symbole zapisu
przyrostkowego. W zależności od kodu symbolu (Ai lub Oi) na torze wjazdowym i od kodu
umieszczonego jako ostatni na bocznicy symbolu Oj następuje:
(i) „przejazd” symbolu Ai lub Oi z toru wjazdowego na wyjazdowy lub na bocznicę
(tylko Oi);
(ii) „przejazd” symbolu Oj z bocznicy na tor wyjazdowy;
(iii) usunięcie z bocznicy zbędnych symboli nawiasu otwierającego (O1).
Algorytm „górki rozrządowej” można sformalizować następująco:
repeat
case wjazd of
Ai : wyjazd  wjazd
O1 : bocznica  wjazd
O2 : begin
while bocznica  O1 do
wyjazd  bocznica
usuń_z_bocznicy(O1)
end
O3 , O4 , O5 : if wjazd > bocznica then
bocznica  wjazd
else
if wjazd < bocznica then
repeat
wyjazd  bocznica
until wjazd  bocznica
else
wyjazd  wjazd
O6 : begin
while bocznica  pusta do
wyjazd  bocznica
wyjazd  O6
end
end
until wyjazd = O6
gdzie: wjazd, wyjazd, bocznica - oznaczają dostępne w danej chwili symbole zapisu;
usuń_z_bocznicy(...) - specjalna procedura kasująca wskazany symbol dostępny na
„bocznicy” 
Struktury danych dla tego algorytmu mogą być bardzo proste w porównaniu np.
z algorytmami drzewowymi przytaczanymi w literaturze. Wystarczającymi są tu:
124

jednowymiarowa tablica przechowująca ciąg symboli wejściowych i wyjściowych oraz stos
do chwilowego przechowywania operatorów. Jeden ze stanów pośrednich „górki rozrządowej”
w trakcie translacji przykładowego wyrażenia pokazuje rysunek 3.13. Pełny proces translacji
jest zilustrowany w Dodatku 6.
* (+
/
+/b)*f+a */b*/(e+ d)+ a

bed
Rys. 3.13. „Górka rozrządowa” do translacji zapisu wyrażenia

na notację polską
3.3.2.2 Przejście do postaci APN wyrażenia
Otrzymane w wyniku przekształcenia do notacji polskiej wyrażenie jest jeszcze

nieprzydatne do generacji tablic przejść. Aby była ona możliwa, należy jeszcze doprowadzić
wyrażenie do postaci APN, będącej sumą prostych iloczynów zmiennych logicznych,
w których mogą być zanegowane tylko pojedyncze zmienne. Ponieważ wyrażenie logiczne
może w ogólnym przypadku zawierać konstrukcje złożone z nawiasów i ich negacji, należy
wyeliminować operatory negacji odnoszące się do całych sum bądź iloczynów oraz
zastosować regułę rozdzielności sumy logicznej względem iloczynu.
Usunięcie negacji złożonych podwyrażeń realizuje się przy użyciu znanych
powszechnie praw de’Morgana. Zastosowanie tych praw do zapisu przyrostkowego polega
na wykorzystaniu następujących produkcji:
(i) argi argj + /  argi / argj / *
(ii)argi argj * /  argi / argj / +
gdzie: argi , argj - zmienne proste (Ai , Aj) lub wyrażenia logiczne.
Proces eliminacji negacji złożonych wyrażeń może być zrealizowany rekurencyjnie lub
iteracyjnie - poprzez wielokrotne przeglądanie zapisu wyrażenia. W translatorze JODA
zastosowano ten drugi wariant, polegający na wielokrotnym przeglądaniu zapisu wyrażenia od
końca do początku, z wyszukiwaniem sekwencji operatorów logicznych ‘+/’ (O3O5) i ‘*/’
(O4O5). Po znalezieniu jednej z tych sekwencji, algorytm wyznacza argumenty arg1 i arg2
operacji sumy lub iloczynu, będące niepustymi ciągami symboli (Ai i Oi), by następnie
zastosować produkcje:
arg1  arg1 / , arg2  arg2 / oraz +/  /+ albo */  /*
125

Przyjęty kierunek przeszukiwania jest zgodny z często stosowaną metodą „ręcznego”
przekształcania wyrażeń logicznych zawierających negacje sum lub iloczynów polegającą
na eliminowaniu w pierwszej kolejności najbardziej zewnętrznych operatorów negacji.
Przeglądanie zapisu wyrażenia jest powtarzane, aż do chwili nieznalezienia żadnej
z poszukiwanych sekwencji operatorów.
Zastosowanie reguły rozdzielności iloczynu logicznego względem sumy logicznej, tj:
a(bc)=abac
polega w przypadku notacji polskiej na wyszukiwaniu sekwencji operatorów ‘+*’ (O3O4)
i stosowaniu produkcji:
arg1 arg2 arg3 +*  arg2 arg1 * arg3 arg1 *+
gdzie: arg1 , arg2 , arg3 - są prostymi zmiennymi logicznymi (zanegowanymi lub nie) lub
podwyrażeniami logicznymi.
Wyszukiwanie wymienionej sekwencji symboli i zastępowanie jej sekwencją równoważną
realizuje się poprzez wielokrotne przeglądanie zapisu wyrażenia od początku do końca,
aż do chwili nieznalezienia sekwencji operatorów ‘+*’.
3.3.2.3 Korekcje końcowe zapisu
Jednym z ostatnich etapów przekształcania wyrażenia jest takie przepisanie symboli

operatorów logicznych ‘+’ i ‘*’ tak, aby uzyskać zapis wyrażenia w notacji przyrostkowej,
jak dla procesora dwurejestrowego28. Dokonuje się tego eliminując w zapisie sąsiedztwo
takich samych operatorów logicznych: najpierw dla sumy logicznej ‘+’, a potem iloczynu ‘*’.
Stosuje się przy tym następujące produkcje:
arg1 arg2 arg3 ++  arg1 arg2 + arg3 +
arg1 arg2 arg3 **  arg1 arg2 * arg3 *
gdzie: arg1 , arg2 , arg3 - proste zmienne (zanegowane lub nie) albo podwyrażenia logiczne.
W obu przypadkach korekcja polega na przeglądaniu zapisu od końca do początku,
aż do chwili, gdy żadna zamiana nie jest możliwa. Uzyskuje się w ten sposób zapis, w którym
można bardzo łatwo wskazać grupy zmiennych logicznych tworzących pojedyncze implikanty.
Wskazanie to można wtedy zrealizować przy jednokrotnym przejrzeniu zapisu od początku
do końca.
28
procesor dwurejestrowy może przechowywać w danej chwili tylko dwie wartości obliczeń pośrednich
i wykonywać na nich obliczenia
126

W wyniku dotychczas opisanych przekształceń zapisu można uzyskać implikanty,
w których ta sama zmienna logiczna występuje w iloczynie ze swoją negacją - implikanty te
mają zawsze zerową wartość logiczną. Należy zatem dokonać przeglądu zakodowanego
wyrażenia i usunąć z niego takie implikanty. W skrajnym przypadku może dojść
do zredukowania się wyrażenia do zera, co jest sygnalizowane jako błąd tekstowego zapisu
wyrażenia.
Ostatnim krokiem korekcyjnym jest „alfabetyczne” uporządkowanie zmiennych
w poszczególnych implikantach. Przy operacji tej wykorzystuje się kody liczbowe symboli
zmiennych, przyporządkowane im przez analizator leksykalny. Symbole są porządkowane
rosnącymi wartościami ich kodów.
3.3.2.4 Optymalizacja wyrażenia
Jest to ostatni etap przetwarzania wyrażenia przed jego zakodowaniem w formie tablic
przejść. Jego zadaniem jest uzyskanie minimalnej liczby implikantów w zapisie wyrażenia.
Ponieważ nie zawsze zachodzi konieczność optymalizacji wyrażeń logicznych - często są one
proste z racji samego algorytmu sterowania binarnego - proces optymalizacji jest opcjonalny.
Do włączania i wyłączania tej opcji stosuje się dyrektywę ‘opt’ z parametrami ‘on/off’.
Domyślnie opcja ta jest wyłączona. W obecnej wersji translatora do optymalizacji zapisu
stosuje się dwie procedury.
Pierwszym krokiem optymalizacji jest zastosowanie reguły:
argi * Aj + argi */ Aj = argi
gdzie: argi - prosta zmienna (zanegowana lub nie) albo iloczyn zmiennych logicznych;
Aj - prosta zmienna logiczna.
Użycie powyższej reguły polega na rekurencyjnym poszukiwaniu par implikantów
spełniających warunek:
(Ii , Ij) | Ii = argk * Am i Ij = argk * /Am
Po znalezieniu takiej pary dokonuje się redukcji zapisu zgodnie z produkcją:
Ii + Ij  argk
i powtarza się poszukiwanie. Za kryterium optymalności wyboru par (Ii , Ij) przyjmuje się
minimalną liczbę implikantów w postaci końcowej zapisu.
Drugą ze stosowanych do minimalizacji liczby implikantów regułę można zapisać
wzorem:
argi * argk + argi = argi
127

gdzie: argi , argk - proste zmienne (zanegowane lub nie) albo iloczyny zmiennych logicznych.
Zastosowanie tej reguły sprowadza się do iteracyjnego poszukiwania par implikantów
spełniających warunek:
(Ii , Ij) |  argu Ii * argu = Ij
gdzie: argu - zmienna prosta lub iloczyn zmiennych logicznych.
Po znalezieniu pary implikantów spełniających ten warunek usuwa się jeden z implikantów,
zgodnie z produkcją:
Ii + Ij  Ii
Obie powyższe reguły minimalizacji zapisu mogą być zrealizowane zarówno
na zapisie symbolicznym (przyrostkowym), jak również po zakodowaniu wyrażeń w formie
masek i wzorów. Różnice pomiędzy jedną i drugą implementacją sprowadzają się do różnic
w czasie wykonania przez procesor mikrokomputera powyższych algorytmów. W przypadku
zapisu symbolicznego czas przetwarzania jest dłuższy z racji operowania na nieregularnej
strukturze danych w porównaniu z zapisem typu maska-wzór. Jednakże moce obliczeniowe
współczesnych mikrokomputerów PC czynią te różnice nieodczuwalnymi dla użytkownika.
3.3.3 Dodatkowe możliwości translatora
W praktyce programowania systemów automatyki zdarza się, że trzeba nagle wrócić

do kiedyś uruchomionego oprogramowania, by dokonać korekt zaimplementowanego
algorytmu lub usunąć błędy w jego realizacji, które ujawniły się dopiero podczas długotrwałej
eksploatacji systemu. Jeżeli dysponujemy oryginalnymi plikami źródłowymi lub odpowiednio
przygotowaną i zabezpieczoną dokumentacją, powrót taki nie jest trudny, a co najwyżej trochę
pracochłonny. Poważne problemy mogą się natomiast pojawić w przypadku utraty
wspomnianych plików źródłowych i dokumentacji. Sytuacje takie są prawdziwym
utrapieniem, gdyż z reguły zmuszają programistę do pisania programu od początku. Działanie
takie podejmowane po upływie pewnego czasu od zakończenia prac nad wersją oryginalną jest
prawie niemożliwe. Dlatego poszukuje się wtedy wszelkich możliwych narzędzi
wspomagających. Przy dostępie do kodu programu można zawsze pokusić się o jego
deasemblację i odtworzenie na jej podstawie tekstu programu. O wiele gorzej przedstawia się
sytuacja w przypadku zakodowanych struktur danych, jakimi są na przykład tablice przejść
i wyjść w metodzie JODA. „Ręczne” odtworzenie na ich podstawie symbolicznego opisu
stanów automatu i funkcji przejść pomiędzy nimi byłoby niezmiernie trudne i obarczone
dużym ryzykiem błędu.
128

Aby rozwiązać wyżej opisany problem, translator JODA został wyposażony
w mechanizm translacji odwrotnej. Polega on na tym, że translator czyta jako plik źródłowy
odpowiednio przygotowany fragment wygenerowanego wcześniej pliku docelowego. Dane
do odwrotnej translacji wymagają przede wszystkim określenia języka programowania
z jakiego ma być ona przeprowadzona. Fragment przetwarzanego programu poprzedza się
rozkazem ‘dekoduj’, a następnie, zależnie od potrzeb i możliwości, używa się:
 deklaracji słowa wejściowego ‘bity’, w której można zdefiniować nazwy zmiennych
logicznych będących argumentami funkcji przejść lub przynajmniej określić długość słowa
wejściowego;
 słowa kluczowego ‘funkcje’ do wskazania fragmentu programu zawierającego zakodowane
funkcje przejść.
Czytając tak przygotowany plik wejściowy, translator tworzy listę stanów i odtwarza
wyrażenia logiczne w zapisie symbolicznym. Wynik translacji odwrotnej jest zapisywany
do wskazanego pliku wyjściowego w formacie zgodnym ze składnią języka JODA (punkt
3.3.1). Dzięki temu możliwa jest szybka modyfikacja tego pliku i przygotowanie go
do dalszego wykorzystywania już jako zwykłego zbioru tekstowego zawierającego opis
automatu w języku JODA. Poniższy przykład ilustruje możliwości odtwarzania tekstu
źródłowego opisu automatu na podstawie tekstu zakodowanego.
Przykład 3.6
Dany jest zakodowany w języku asemblera Z80 fragment programu opisujący zachowanie się
automatu Piły (opisanego w punkcie 4.2.2). Wobec utracenia oryginalnego pliku źródłowego
z opisem tego automatu w języku JODA, użyto translatora do odtworzenia funkcji przejść
automatu. W tym celu przygotowano specjalny plik tekstowy, zawierający skopiowane z pliku
do asemblacji tablice przejść: p0tp, p1tp itd. Całość poprzedzono zgodnie z wymaganiami
składni deklaracją języka docelowego, poleceniem dekodowania i deklaracją słowa
wejściowego automatu. W słowie wejściowym podano nazwy niektórych spośród używanych
zmiennych logicznych. Tekst przygotowany do translacji odwrotnej przedstawia się
następująco:
jezyk az80
dekoduj
bity
k07,k06,k05,-,-,-,rcp,t;
-,-,-,-,-,-,-,-;
-,-,-,-,-,-,-,-;
funkcje
p0tp: defb 1,02h,02h,00h,00h,00h,00h,p9,p0
129

p2tp: defb 4,00h,00h,10h,00h,00h,00h,p10,00h,00h,04h,00h,00h,00h,p10
defb 41h,01h,00h,00h,00h,00h,p5a,40h,40h,00h,00h,00h,00h,p3,p2
defb 40h,00h,00h,00h,00h,00h,p5a,80h,80h,00h,00h,00h,00h,p4
defb 00h,00h,01h,01h,00h,00h,p4,p3
p4tp: defb 4,41h,41h,00h,00h,00h,00h,p5a,00h,00h,04h,00h,00h,00h,p10
defb 40h,00h,48h,48h,00h,00h,p6,40h,00h,48h,40h,00h,00h,p9,p4
defb 00h,00h,08h,00h,00h,00h,p9,80h,80h,00h,00h,00h,00h,p7,00h,00h
defb 01h,01h,00h,00h,p7,20h,20h,00h,00h,00h,00h,p7,p6
defb 00h,00h,08h,00h,00h,00h,p9,00h,00h,00h,00h,01h,00h,p8,00h,00h
defb 00h,00h,02h,00h,p8,00h,00h,00h,00h,03h,03h,p11,p7
defb 00h,00h,14h,14h,00h,00h,p2,p8
defb 20h,20h,00h,00h,00h,00h,p1,p9
p10tp: defb 2,41h,41h,00h,00h,00h,00h,p5a,40h,00h,40h,40h,00h,00h,p9,p10
defb 00h,00h,14h,14h,00h,00h,p2,p12
p5atp: defb 1,40h,00h,40h,40h,00h,00h,p9a,p5a
p9atp: defb 1,20h,20h,00h,00h,00h,00h,pa,p9a
patp: defb 2,00h,00h,40h,40h,00h,00h,p1,02h,02h,00h,00h,00h,00h,p1,pa
koniec.
W wyniku działania translatora uzyskuje się plik zawierający funkcje przejść zapisane
zgodnie ze składnią języka JODA. Nazwy stanów są przyjmowane automatycznie
na podstawie użytych w programie asemblerowym nazw tablic przejść. Również w przypadku
odwołania się w zakodowanych wyrażeniach logicznych do niezadeklarowanej nazwy bitu
wejściowego, translator przyporządkowuje mu automatycznie identyfikator postaci ‘B_x’,
w którym ‘x’ oznacza pozycję tego bitu w słowie wejściowym. Przykładowy wynik translacji
odwrotnej jest następujący:
; CROSS-TRANSLATOR JODA 29. 3.96 / 14: 3:17
; funkcje przejsc automatu:
p0-p9=rcp;
p1-p2=B_11*B_13;
p2-p10=/B_13+/B_11;
p2-p5a=t/k06;
p2-p3=k06;
p3-p10=/B_13+/B_11;
p3-p5a=/k06;
p3-p4=k07+B_9;
p4-p5a=t*k06;
p4-p10=/B_11;
p4-p6=/k06*B_12*B_15;
p4-p9=/k06/B_12*B_15;
p6-p9a=t/k07;
p6-p9=/B_11+/B_12;
p6-p7=k07+B_9+k05;
p7-p9a=t/B_9;
p7-p9=/B_11+/B_12;
p7-p8=/B_17+/B_18;
p7-p11=B_17*B_18;
p8-p9=/B_11+/B_12;
p8-p2=B_11*B_13;
130

p9-p9a=t/k05;
p9-p10=k06;
p9-p1=k05;
p10-p5a=t*k06;
p10-p9=/k06*B_15;
p11-p9a=t/k05;
p11-p12=k05;
p12-p1=/B_11;
p12-p11=/k05;
p12-p2=B_11*B_13;
p5a-p9a=/k06*B_15;
p9a-pa=k05;
pa-p1=B_15+rcp; 
3.3.4 Perspektywy rozszerzenia funkcji translatora JODA
Dostępne środowisko programowe dla metody JODA, obejmujące obecnie sam

translator, może ulegać dalszej rozbudowie. Nowe funkcje oprogramowania narzędziowego
mogą dotyczyć zarówno fazy projektowania automatu jak i jego późniejszego uruchamiania.
Opis funkcjonowania automatu jedynie za pośrednictwem języka JODA może
wydawać się niektórym projektantom zbyt ograniczony lub niewygodny. Istnieje więc
potencjalna możliwość wyposażenia translatora w odpowiedni, zorientowany problemowo,
edytor graficzny, przenoszący proces opisu automatu z konwencji tekstowej do przestrzeni
grafów skierowanych. Tekstowa i graficzna forma opisu stosowane byłyby alternatywnie lub
na zasadzie wzajemnego uzupełniania się.
Jednym z dodatkowych środków uruchomieniowych mógłby być debuging automatu
w trybie on-line. Specjalizowane oprogramowanie zainstalowane na komputerze przenośnym
komunikowałoby się łączem szeregowym z mikrosterownikiem. Wymagałoby to ze strony
oprogramowania systemowego mikrosterownika uwzględnienia dodatkowych funkcji,
polegających na przekazywaniu do komputera nadrzędnego informacji o stanie automatu i jego
słowach wejściowych. Odczyt słów wyjściowych jest zbędny, ponieważ program nadzorujący
może je sam określić na podstawie bieżącego stanu automatu i jego opisu. Transmisja
wymienionych informacji byłaby realizowana w sposób ciągły - po każdej zmianie słowa
wejściowego lub stanu, albo na wyraźne żądanie ze strony komputera nadrzędnego. Otrzymana
informacja o stanie automatu byłaby przedstawiana w syntetycznej postaci tekstowej na
ekranie monitora. Po wprowadzeniu graficznych metod opisu automatu, jego praca podczas
debugingu on-line mogłaby być także ilustrowana na tle grafu przejść. Taka forma kontroli
pracy automatu na etapie jego uruchamiania jest bardzo efektywnym, przyśpieszającym prace
narzędziem.
131

Oprogramowanie uruchomieniowe pozwalałoby jednocześnie na modyfikację
wybranych fragmentów lub też całych struktur danych opisujących pracę automatu. Wymiana
struktur opisujących automat bezpośrednio w pamięci sterownika polega na transmisji tablic
binarnych nie będących kodem maszynowym mikroprocesora, w związku z czym
niewymagających stosowania dodatkowego oprogramowania narzędziowego. W tym miejscu
ujawnia się jedna z zalet metody - niezależność opisu automatu od procesora sterownika. Aby
taka operacja była możliwa, należy oczywiście, odpowiednio dostosować oprogramowanie
podstawowe mikrosterownika.
Bardzo wygodnym środkiem, przyśpieszającym powstawanie kolejnych modyfikacji
algorytmu sterowania, byłaby możliwość wymiany opisujących automat tablic: przejść, wyjść
i flag, w trakcie pracy sterownika. Działanie takie wbrew pozorom jest wykonalne, ponieważ
w każdym automacie można wskazać przynajmniej jeden ze stanów pracy, w którym przebywa
on najczęściej. Jest to swoisty stan spoczynkowy. Uwzględniając fakt, iż przepisanie nowych
struktur danych opisujących automat do pamięci sterownika jest operacją krótkotrwałą (na
poziomie pojedynczych sekund), możliwe jest zmodyfikowanie pracy automatu w chwilach,
gdy przebywa on w tych wyróżnionych stanach. Jedynym warunkiem jest to, aby w obu
wersjach algorytmu binarnego występowały takie same stany spoczynkowe wykorzystywane
do aktualizacji opisu automatu. Wymagana zgodność nowych i starych stanów spoczynkowych
polega na zgodności ich słów wyjściowych i kodów reprezentujących te stany.
Dodatkowym programem narzędziowym wspomagającym uruchamianie automatu
może być również prosty symulator działania automatu. Wykorzystując charakterystyczną dla
metody JODA niezależność opisu od sprzętu symulator umożliwiałby sprawdzenie
zachowania się sterownika przy różnych słowach wejściowych. Działania takie
przyśpieszyłyby realizację zadania. Koszt prac uruchomieniowych zmniejszyłby się za sprawą
wyeliminowania części błędów w algorytmie sterowania jeszcze przed użyciem rzeczywistego
sterownika. Symulator pozwalałby też wykryć i usunąć możliwość wystąpienia zapętleń w
pracy automatu, o których była mowa w punkcie 3.2.4.2.
Wymienione tu możliwości rozbudowy narzędzi wspomagających stosowanie metody
JODA do programowania sterowników binarnych, mogłyby tworzyć razem zintegrowane
środowisko uruchomieniowe, obsługujące wszystkie fazy realizacji zadania: projekt wstępny,
uruchamianie na sterowniku i późniejsze modyfikacje.
132

3.4 Porównanie proponowanej metody z powszechnie stosowanymi
Podsumowując opis metody JODA można stwierdzić, że:

1. Stosowanie wyrażeń logicznych opisujących warunki zmiany stanu automatu jest bardzo
zwięzłym i czytelnym środkiem opisu. W przypadku języków drabinkowych LD
i schematów funkcjonalnych FBD (przewidzianych normą IEC 1131-3) konieczna jest
analiza informacji graficznej celem wydzielenia z niej zakodowanych symbolicznie
wyrażeń logicznych. Utrudnia to bez wątpienia czytanie i modyfikację programu
zapisanego w tego typu językach. Uwzględnienie w normie tych form opisu można
tłumaczyć konserwatyzmem przyzwyczajeń użytkowników sterowników i presją ze strony
wiodących producentów tych urządzeń.
2. Składnia wyrażeń logicznych translatora JODA zezwala na pisanie dowolnych konstrukcji
opartych na: zmiennych binarnych, trzech podstawowych operatorach logicznych (NOT,
AND, OR) i wielopoziomowych nawiasach. Dzięki temu nie ma żadnych przeszkód
w definiowaniu nawet bardzo złożonych warunków przejść między stanami. Takie
rozwiązanie zbliża język JODA do możliwości języków strukturalnych.
3. Należy zaznaczyć, że opis działania automatu w języku JODA nie stanowi kompletnego
programu pracy sterownika, a jedynie reprezentuje jego fragment ściśle odpowiedzialny za
realizację algorytmu sterowania binarnego. Właściwe oprogramowanie sterownika
w zależności od przyjętego języka docelowego jest pisane w języku symbolicznym
mikroprocesora lub wybranym języku wysokiego poziomu. Język symboliczny odpowiada
przewidzianemu normą IEC 1131-3 językowi typu IL, a języki wysokopoziomowe są
z natury rzeczy strukturalne, jak ST we wspomnianej normie.
4. Podobnie jak systemy programowania seryjnie produkowanych sterowników, przykładowo
Step-5 [81, 82, 83], metoda JODA umożliwia tworzenie programu docelowego na różne
platformy sprzętowe. Możliwość korzystania tak z języków wysokiego poziomu, jak
i języków symbolicznych pozwala na generowanie programu sterowania dla różnych
nietypowych zastosowań. Dostępność metaasemblerów C16 i C32 jako jednego
z wariantów języków docelowych znacznie poszerza zestaw mikroprocesorów, które mogą
być wykorzystane jako jednostki centralne sterowników.
5. Jeśli chodzi o programowanie nietypowych układów sterowania binarnego i binarno-
ciągłego, takich jak: rozwiązania jednostkowe bazujące na niestandardowym sprzęcie,
mikrosterowniki wbudowane w inne urządzenia, brak jest poza klasycznymi językami
133

programowania narzędzi wspomagających pracę programistów. Język JODA wypełnia
częściowo tę lukę, ułatwiając rozwiązanie poważnej części problemów związanych
z programowaniem takich systemów sterowania. Poprzez unifikację opisu pracy automatów
upraszcza on strukturę oprogramowania sterownika, czyni proces tworzenia i uruchamiania
programu łatwiejszym i sprawniejszym, zmniejsza ryzyko popełnienia typowych błędów
kodowania popełnianych przez programistów. Niebagatelne znaczenie ma też możliwość
wprowadzenia dodatkowych narzędzi uruchomieniowych - symulatora, debugera on-line,
opisanych w punkcie 3.3.4.
6. Przyjęty w translatorze JODA sposób kodowania i wartościowania metodą maska-wzór
wyrażeń logicznych jest jednym z najefektywniejszych rozwiązań, w dodatku w znacznej
mierze niezależnym od docelowego procesora sterownika. Niestety, nie można dokonać
odpowiedniego porównania ze sposobami stosowanymi w znanych systemach
programowania sterowników, gdyż ze zrozumiałych względów ich producenci nie
ujawniają takich danych.
7. Wychodząc naprzeciw zwolennikom graficznych metod opisu przewidziano możliwość
rozbudowy oprogramowania narzędziowego o specjalizowany edytor graficzny, służący
do projektowania automatów na poziomie ich grafów przejść.
8. Ważną zaletą metody JODA jest możliwość łączenia sterowania binarnego z regulacją
wielkości ciągłych lub innymi działaniami zależnymi od stanu automatu. Jest to także
dostępne w językach programowania seryjnych sterowników przemysłowych.
9. Na podstawie informacji bibliograficznych można stwierdzić, iż trwają poszukiwania
nowych form opisu algorytmów sterowania binarnego. Są również znane próby
wykorzystania do tego celu teorii automatów [11, 18, 21, 23, 42, 43]. Najbliższy
prezentowanej metodzie JODA jest, przedstawiony w punkcie 2.3.10.4, system CODE.
Porównanie tych dwóch metod zawiera tabela 3.4.
Powyższe spostrzeżenia potwierdzają przydatność i skuteczność przedstawionej
metody programowania algorytmów sterowania binarnego. Metoda ta ma szanse zająć trwałe
miejsce w sferze programowania niestandardowych zadań sterowania, w których użycie
seryjnie produkowanych sterowników wraz z systemami ich programowania jest niemożliwe.
134

Tabela 3.4
Porównanie podstawowych właściwości systemu CODE i metody JODA
Cecha użytkowa CODE JODA

wykorzystanie przerwań zegarowych
tak tak
do synchronicznej obsługi automatu (-ów)
tak
możliwość wykorzystania przerwań obiektowych nie
(punkt 3.2.3.3)
cykl obsługi automatu polegający na testowaniu
tak tak
warunków przejść i realizacji zmiany stanu
tak
realizacja tylko jednego przejścia w cyklu obsługi tak
przy użyciu algorytmu jednokrotnego
(punkt 3.1.3.1)
realizacja wielu przejść w jednym cyklu obsługi tak
nie
(przejścia cykliczne) algorytm iteracyjny (punkt 3.1.3.2)
tak
działania charakterystyczne stanów tak operacje dodatkowe, wykonywane
w każdym cyklu obsługi automatu
(punkt 3.2.5)
tak
działania charakterystyczne przejść tak
operacje dodatkowe stanu,
wykonywane jednokrotnie
(punkt 3.2.5)
definiowanie na etapie programowania kolejności tak
obsługi automatów tak w trakcie pisania programu
docelowego
dostępność stanów specjalnych (startowych, tak
alarmowych) tak poprzez odpowiedni opis w języku
JODA
możliwość hierarchizacji zadania tak tak
podział dużego zadania na szereg podzadań tak tak
synchronizacja pracy automatów tak tak
różne języki docelowe i platformy sprzętowe ? tak
oprogramowanie narzędziowe tak tak
możliwość wprowadzenia autodiagnostyki, tak
?
debugingu w trybie on-line (punkt 3.2.4)
135

4. Przykłady praktycznego zastosowania metody JODA
4.1 Doświadczalna linia uzysku białka
Kompleksowa automatyzacja doświadczalnej linii uzysku białka jest pierwszym

historycznie przykładem zastosowania opracowanej metody. Właśnie konieczność rozwiązania
szeregu zadań związanych z tą automatyzacją skłoniła autora do wypracowania metodologii
postępowania umożliwiającej stosunkowo proste i szybkie tworzenie nowych oraz
modyfikowanie już funkcjonujących aplikacji.
4.1.1 Zadanie sterowania
Linia uzysku białka (inaczej: produkcji kazeiny) składa się z szeregu różnych
urządzeń współpracujących ze sobą w trakcie procesu produkcji (rysunek 4.1):
 zbiorniki (tanki TM, TS1, TS2, TS3, TW) mleka, serwatki i wody technologicznej;
 pasteryzatory (PM, PS, PW) mleka, serwatki i wody technologicznej;
 mieszacz z koagulatorem, w którym przebiega proces powstawania kazeiny;
 maturatory (MT1, MT2) przetrzymujące przez zadany czas mieszaninę;
 sita, płuczka i wirówka, oddzielające powstały produkt od wody i resztek serwatki;
 młynek rozdrabniający i suszarnia;
 podgrzewacz środków myjących jako agregat pomocniczy.
Proces produkcji polega na mieszaniu w odpowiedniej proporcji, utrzymując
optymalne pH mieszaniny, uprzednio spasteryzowanych (w temperaturze p=9597C)
i schłodzonych (do temperatury CH=4560C) surowców, jakimi są mleko i serwatka.
Wytrącone w koagulatorze z mleka białko jest następnie przetrzymywane w tzw.
maturatorach. Po upływie zadanego czasu uzyskane białko jest oddzielane od roztworu
na sitach, płukane i odsączane w wirówce. Końcowym etapem jest rozdrobnienie białka przez
młynek i jego suszenie.
Na kompleksowe sterowanie pracą linii technologicznej składało się kilka zadań:
 regulacja temperatury pasteryzacji i schładzania mleka, serwatki i wody technologicznej
za pośrednictwem zaworów regulacyjnych pary (ZP1, ZP2, ZP3) i wody chłodzącej (ZW1,
ZW2, ZW3);
 regulacja proporcji mieszania mleka i serwatki (zawór stosunku ZR);
 regulacja temperatury mieszaniny w koagulatorze (zawór pary ZP4);
136

 regulacja temperatury w suszarni (zawór pary ZP5);
 regulacja temperatury środków myjących linię po zakończeniu procesu (zawór pary ZP6);
 realizacja regulacji nadążnej wybranych wielkości ciągłych (np. temperatury pasteryzatorów
podczas rozruchu);
 sterowanie binarne urządzeniami wykonawczymi (napędy, pompy, dwustanowe zawory
elektromagnetyczne);
 koordynacja współpracy poszczególnych urządzeń technologicznych (pasteryzatory,
mieszacz, maturatory, suszarnia itd.), polegająca na realizacji programowego rozruchu,
pracy ciągłej i programowym wyłączaniu linii;
 umożliwienie pracy w pełni automatycznej, półautomatycznej (tylko regulacja wielkości
ciągłych), ręcznej i mieszanej (różne urządzenia w różnych trybach pracy).
TA NK TANK
TANKI
MLEKA WODY
SERWATKI
TM TS 1 TW
TS2 TS3
Z P1 Z W1 Z P2 ZW2 ZP3 Z W3
PAST.
PAST. PAST. WODY
MLEKA SERWATKI TECHNOL.
PM PS PW
PŁUCZKA
SITA
ZP4
KOAGULATOR
MATURAT ORY
ZR
pH MT1 MT2
MIESZA CZ
WIRÓWKA
Z P6
MŁYNEK
PODGRZEWACZ
ŚRODKÓW
MYJĄCYCH P ODAJNIK
SUSZA RNIA
Z P5
Rys. 4.1. Schemat blokowy linii technologicznej uzysku białka
137

4.1.2 Przyjęte rozwiązanie systemu sterowania
Analiza wymagań technologicznych określających szczegółowo zachowanie się

poszczególnych urządzeń linii w trakcie rozruchu, pracy i wyłączania, doprowadziła
do wyodrębnienia sześciu tzw. agregatów - zespołów urządzeń odpowiedzialnych za pewien
fragment technologii. Na wspomniane agregaty złożyły się:
 pasteryzator mleka wraz z tankiem;
 pasteryzator serwatki z trzema tankami;
 pasteryzator wody technologicznej wraz z tankiem;
 układ koagulacji z maturatorami;
 układ płukania, odwirowywania i suszenia;
 podgrzewacz środków myjących.
Tabela 4.1
Zestawienie sygnałów ciągłych i dwustanowych w agregatach
SYSTEM AGREGAT SYGNAŁY CIĄGŁE SYGNAŁY BINARNE

MIKROPROC. wejściowe wyjściowe wejściowe wyjściowe
pasteryzator
3 2 13 8
mleka
pasteryzator
I serwatki
3 2 22 13
pasteryzator
3 2 10 7
wody technol.
układ
4 2 23 13
koagulacji
płukanie
II i suszenie
2 1 18 16
układ
1 1 14 12
mycia
W każdym z wymienionych agregatów występują zarówno obwody regulacji ciągłej,

jak i urządzenia wykonawcze sterowane dwustanowo (zestawienie podaje tabela 4.1).
W obwodach regulacji ciągłej zastosowano pneumatyczne zawory proporcjonalne, a na
dwustanowe elementy automatyki złożyły się elektrozawory i silniki indukcyjne małej mocy.
Jako sterowniki mikroprocesorowe wykorzystano dwa systemy modułowe bazujące na
mikroprocesorach Z80. Każdy z systemów był odpowiedzialny za trzy agregaty. Do wymiany
informacji pomiędzy sterownikami, potrzebnej przy synchronizowaniu pracy poszczególnych
automatów, przewidziano łącze szeregowe.
138

s - kod stanu U1(0)
uchyb e2(-1)=
stan wyliczone
W2Z (-1)-W2(-1)
wejść sterowanie
binarnych
U1(-1)
uchyb e2(-2)=
stan wyliczone
sterowanie W2Z (-2)-W2(-2)
wyjść
binarnych
U1= uchyb e2(-3)=
timer U1(0)-U1(-1) W2 Z (-3)-W2(-3)
stanu
SZI - słowo ZR1-nastawa zaworu w % U2(0)
zdarzeń istotnych wsp. algorytmu wyliczone
bity alarmów regulacji sterowanie
czas alarmu k10
U2(-1)
ARW1-alg.reg. W1 wyliczone
W1Z (0) k11 sterowanie
zadana
U2=
W1(0) U2(0)-U2(-1)
zmierzona k12
W1(-1) ZR2-nastawa zaworu w %
zmierzona wsp. algorytmu
W1Z (-1) k13 regulacji
zadana k10
Wp1 ARW2-alg.reg. W2
pomocnicza W2 Z (0) k21
zadana
uchyb e1(0)=
W2(0)
W1Z (0)-W1(0) zmierzona
k22
W2(-1)
uchyb e1(-1)= zmierzona
W1 Z (-1)-W1(-1)
W2(-2) k23
zmierzona
uchyb e1(-2)=
W2(-3)
W1 Z (-2)-W1(-2) Wp2
zmierzona
pomocnicza
uchyb e2(0)= Wp3
uchyb e1(-3)=
W2 Z (0)-W2(0) pomocnicza
W1Z (-3)-W1(-3)
Rys. 4.2. Struktura strony opisu agregatu.

Kolorem szarym zaznaczono struktury danych niezwiązane bezpośrednio z realizacją sterowania binarnego
Celem ujednolicenia opisu stanu każdego z agregatów przyjęto jednakową strukturę

danych o stanie automatu, tzw. stronę opisu automatu (SOA), przedstawioną na rysunku 4.2.
Zawiera ona komplet informacji potrzebnych do realizacji regulacji dwóch wielkości ciągłych
oraz realizacji sterowania binarnego urządzeniami dwustanowymi danego agregatu. W części
odnoszącej się do algorytmów sterowania binarnego składa się ona:
 z bajtu kodu bieżącego stanu automatu;
139

 z trzybajtowego bufora wejściowych zmiennych binarnych;
 z trzybajtowego bufora wyjściowych zmiennych sterujących urządzeniami dwustanowymi;
 z dwubajtowego timera odmierzającego w sekundach czas przebywania automatu w danym
stanie;
 z dwubajtowego słowa zdarzeń istotnych (SZI), zawierającego zmienne logiczne będące
argumentami wyrażeń logicznych warunkujących przejścia pomiędzy stanami automatu;
 z bajtu flag alarmów i jednobajtowego timera trwania alarmu;
 z dwóch jednobajtowych zmiennych przechowujących obowiązujący w danym stanie
algorytm regulacji dwóch wielkości ciągłych.
Bity słowa SZI, z wyjątkiem dwóch odpowiadających stanowi przełączników wyboru
trybu pracy automatu, były wyliczane przez specjalną procedurę w każdym cyklu obsługi
automatu. Stany tych bitów reprezentowały z reguły różne zdarzenia związane z regulacją
wielkości ciągłych i gotowością automatu do współpracy z innymi. Niezgodność sygnałów
zwrotnych od dwustanowych urządzeń wykonawczych z wysłanymi do nich sterowaniami
wpływała na ustawienie tylko jednego z bitów SZI. Można zatem stwierdzić, że to pierwsze
zastosowanie opracowanej metody programowania algorytmów sterowania binarnego odnosiło
się w przypadku tego zadania sterowania raczej do realizacji elementów sterowania
nadrzędnego aniżeli do bezpośredniego kontrolowania urządzeń dwustanowych.
4.1.3 Przykład użycia metody
Użycie metody JODA zostanie przedstawione na przykładzie automatu Pasteryzator

Mleka, którego schemat technologiczny przedstawia rysunek 4.3. Automat ten obejmuje
właściwy pasteryzator z obwodami pasteryzacji i schładzania, pompy elektryczne
wymuszające przepływ wody pośredniczącej i mleka (S101, S102, S202, S203), sterowane
elektrozawory do zmiany dróg przepływu mleka (Z101, Z121, Z212, Z213) oraz zbiornik
magazynujący mleko przeznaczone do pasteryzacji. Nie wszystkie wymienione urządzenia
były przy tym przewidziane do sterowania automatycznego. Oprócz sygnałów zwrotnych od
urządzeń dwustanowych, automat wykorzystuje także trzy czujniki obecności mleka (I1, I2, I3)
w wyróżnionych punktach instalacji.
140

S111
S101
Z 121 I1
Z101
S102
Z W1
Z P1
Z212 Z 213
I2
S203
S202 I3
Rys. 4.3. Struktura agregatu Pasteryzator Mleka
Tabela 4.2
Wykaz stanów wyjść binarnych, algorytmów regulacji wielkości W1 i W2, oraz czasów
charakterystycznych stanów automatu Pasteryzator Mleka
Oznaczenia: stan urządzenia: 1 - włączone; 0 - wyłączone; - sterowane tylko ręcznie;
stosowane algorytmy regulacji wielkości ciągłej:
A0 - algorytm bez zmian (taki jak w poprzednim stanie); A1 - zawór ZR zamknięty;
A2 - regulacja dwupołożeniowa; A3 - regulacja PID; A4 - programowe rozgrzewanie;
A5 - zawór ZR otwarty 100%
STAN ARW1 ARW2 tCS STAN WYJŚĆ BINARNYCH

[s] S101 S102 S111 S202 S203 Z101 Z212 Z213
PMSX A3 A2 1  0  0 0 0 0 0
PMGW A4 A1 1000  1  1 1 1 0 0
PMR A3 A2 1000  1  1 1 1 1 0
PMP A3 A2 1000  1  1 1 1 1 0
PMPS A3 A2 10  1  1 1 1 1 0
PMA A3 A2 1  1  1 1 1 1 1
PMW A3 A2 10  1  1 1 0 1 0
PMWA A3 A2 1  1  1 1 0 1 1
PMB1 A0 A0 1  1  1 1 1 0 0
PMB2 A0 A0 1  1  1 1 1 1 0
PMK1 A0 A0 1  1  1 1 1 0 0
PMK2 A1 A5 1  1  1 1 1 1 0
PMK3 A1 A5 1  1  1 1 0 1 0
141

Z dostępnych 16 bitów słowa SZI Pasteryzator Mleka wykorzystywał 11, głównie
do sygnalizowania zdarzeń związanych z regulacją temperatury pasteryzacji mleka pm i jego
późniejszego schładzania cm. Oddzielne bity służyły sygnalizacji błędów pomiaru temperatury
i niewłaściwego stanu kontrolowanych urządzeń. Wykorzystanie SZI ilustruje rysunek 4.4.
- b6 t b5 b4 b3 b2 b1
s2 s1 - - - - b8 b7
Rys. 4.4. Struktura słowa zdarzeń istotnych automatu Pasteryzator Mleka
Znaczenie bitów słowa zdarzeń istotnych SZI w przypadku automatu PM:

b1 = (pm > 57C);
b2 = (pm > pm* -3C);
b3 = (cm < cm* +3C);
b4 = (pm > 97C) v (wp > 97C);
b5 = (błąd sterowania S102 lub S202 lub S203 lub Z212 lub Z213)  (I2 = 0);
b6 = błąd pomiaru pm lub cm lub wp ;
b7 = (I1 = 1);
b8 = (I3 = 1);
t = (t s  tCS);
s2,s1 - stany przełączników wyboru trybu pracy, umieszczonych na tablicy sterowania
ręcznego.
Rysunki 4.5 i 4.6 zawierają, podzielony w celu zwiększenia czytelności na dwie
części, graf przejść automatu Pasteryzator Mleka. W automacie tym wyróżniono trzy grupy
stanów:
1. stany normalne, występujące przy prawidłowym zachowaniu się urządzeń wykonawczych
i osiąganiu zamierzonych efektów regulacji wielkości ciągłych;
2. stany błędne (PMB1 i PMB2), do których automat przechodzi po stwierdzeniu
niewydolności układu podgrzewania parą lub schładzania wodą;
3. stany krytyczne (PMK1, PMK2 i PMK3), związane ze złą pracą silników lub zaworów,
wykrytymi błędami pomiarów temperatury lub przekroczeniem przez nie wartości
granicznych.
Automaty Pasteryzator Serwatki i Pasteryzator Wody miały bardzo zbliżone grafy
przejść. W przypadku pozostałych automatów grafy te były prostsze, ponieważ nie wymagały
uwzględnienia zdarzeń związanych z regulacją aż dwóch wielkości ciągłych.
142

b2 b7
PMB 1 P MB2 PMGW
b2
b7 PMR,PMP
b2
b2t
b3 t
 b3
b7
b1 t b2 b2b3 b7
PMR PMP PMPS PMW
b2 b3
b7b8
b2 b2 b3  t
 b7 b8 b8 b8
b1 t
b7
s1
b3
b
s1
1
s1
PMGW
b7
b s1 PMA b7
P MWA
1 s s1
s1
s 2
2 s1
s1 s1
PMSX
s1 s1 PMB2,PMK1
PMK2 , PMK3
Rys. 4.5. Graf przejść automatu Pasteryzator Mleka - stany normalne i błędne.
bb bb
PMW PMK3 PMWA
bb
b7
PMB2
b7
bb
b5 PMB1 b 4 vb 6 bb PMA
PMK1 b4vb6
PMK2 bb
b2
b2
b
b3
v b b
bb PMPS
b1
b3 b
b5 b
bb
b4 b2
6
b
b 1 b b
b 4v b 6
b1
b1 b5
b PMR PMP
b
PMGW bb=b4  b5  b6
Rys. 4.6. Graf przejść automatu Pasteryzator Mleka - stany krytyczne.
Doświadczenia zdobyte na etapie uruchamiania i pracy systemu wykazały

przydatność zastosowanej koncepcji automatów modelujących działanie sterowników
binarnych, także w sytuacjach wymagających łączenia różnych rodzajów sterowania. Skłoniło
to autora do dalszych prac nad samą metodą i odpowiednim oprogramowaniem
wspomagającym proces generacji nowych aplikacji. Niestety, ze względu na rezygnację
Instytutu Maszyn Spożywczych w Warszawie w 1991 roku z dalszego inwestowania
w automatyzowaną linię, prace nad dokończeniem systemu automatyki kompleksowej zostały
przerwane.
143

4.2 Formatyzerka
Kolejnym zastosowaniem metody JODA jest mikroprocesorowy sterownik

formatyzerki zrealizowany w 1990 roku na zamówienie Zakładów Przemysłu Sklejki
w Białymstoku [35].
4.2.1 Zadanie sterowania i zastosowany sterownik
Przedstawiona w uproszczeniu na rysunku 4.7 formatyzerka jest urządzeniem

technologicznym przeznaczonym do cięcia pakietów sklejki na zadane formaty. Program
cięcia, określający ilości i rozmiary uzyskiwanych arkuszy, można każdorazowo zadawać
za pośrednictwem panelu operatora. Ponieważ półproduktem podlegającym obróbce przez to
urządzenie jest najczęściej sklejka w stanie, w jakim opuszcza ona prasę, istnieje możliwość
zaprogramowania cięcia tzw. marginesu, pomijającego źle sklejone krawędzie stanowiące
odpady produkcyjne.
ŁD
SU
WT
WR
H1 H2
WR
WR
BD
SO
Rys. 4.7. Formatyzerka do cięcia pakietów sklejki
144

W skrócie działanie formatyzerki można opisać następująco:
1. Po włączeniu zasilania i zezwoleniu operatora na pracę urządzenia następuje doprowadzenie
do stanów spoczynkowych zespołu pił tnących i belki dociskowej BD oraz wstępne
zerowanie wózka transportowego WT, do czego wykorzystuje się hallotrony H1 i H2.
2. Jeżeli na stole uchylnym SU znajduje się sklejka do cięcia, wózek cofa się za stół
z uniesionymi łapami Ł, opuszcza łapy i jadąc w stronę belki łapie pakiet sklejki.
3. Po drodze następuje kontrolne zerowanie położenia wózka (na linii H1-H2), gdy przebiegnie
ono pomyślnie rozpoczyna się cięcie w osi X.
4. Realizacja programu cięcia składa się z wykonywanych parami podjazdów i cięć sklejki
zgodnie z nastawionym na panelu operatora programem cięcia. Ze względu na wymaganą
dokładność, podjazdy wózka są wykonywane dwubiegowo - najpierw bieg średni,
a końcowy dojazd biegiem wolnym.
5. Proces cięcia jest zróżnicowany w zależności od wzajemnego położenia wózka
transportującego i belki dociskowej. Różnice te ujawniają się różnym działaniem samej
belki oraz zainstalowanych na niej tłoczków i węży dociskowych. W niektórych
przypadkach konieczne jest także wycofanie łap wózka spod zasięgu belki dociskowej.
6. Po zakończeniu cięcia w osi X następuje wypchnięcie całego pakietu na ręcznie sterowany
stół obrotowy SO, który obraca sklejkę tak, aby można było następnie wykonać cięcie w osi
prostopadłej.
7. Obrócone arkusze sklejki, po wznowieniu pracy wózka klawiszem na pulpicie, są chwytane
przez łapy i odciągane za hallotrony. Następuje przerwa umożliwiająca ręczne uruchomienie
wyrównywaczy WR.
8. Zezwolenie na dalsze cięcie klawiszem na pulpicie operatora powoduje złapanie sklejki
przez łapy wózka i jazdę do kontrolnego zerowania.
9. Realizowany jest nastawiony program cięcia w osi Y analogicznie jak w pkt. 4 i 5.
10. Po zakończeniu cięcia sklejka jest wypychana na stół obrotowy, a wózek transportowy
czeka na decyzję operatora wskazującą konieczność powtórzenia cięcia w osi Y (pkt.7-9)
albo jazdy po nowy pakiet sklejki (powtórzenie od pkt.2).
11. Przygotowanie nowego pakietu sklejki na stole uchylnym SU przez pneumatyczną
ładowarkę ŁD powinno się odbywać w trakcie cięcia w osi X i Y.
Układ sterujący formatyzerką powinien umożliwiać realizację opisanego cyklu pracy,
przy założeniu cięcia różnych rozmiarów arkuszy surowych - na pulpicie operatora wybiera się
jeden z trzech typowych rozmiarów. Do kontrolowania stanu poszczególnych mechanizmów
145

urządzenia służą, umieszczone w różnych punktach, wyłączniki drogowe oraz enkoder
generujący impulsy podczas jazdy wózka transportowego. Na urządzenia wykonawcze
sterownik oddziałuje za pośrednictwem styczników. W pobliżu belki dociskowej znajduje się
pedał przeznaczony do przerywania pracy formatyzerki w dowolnej chwili, także gdy
zaistnieje zagrożenie dla ludzi lub urządzenia. Po każdej takiej przerwie sterownik powinien
móc wznowić pracę formatyzerki bez zaburzeń w realizacji nastawionego programu cięcia.
Zainstalowany sterownik mikroprocesorowy ma budowę modułową z pakietem
jednostki centralnej zawierającym: mikroprocesor Z80, pamięć programu EPROM 8kB,
pamięć RAM 2kB, układ portów równoległych 8255 i układ czasowo-licznikowy Z80-CTC.
Ten ostatni jest przeznaczony do generacji przerwań zegarowych o częstotliwości 20Hz oraz
zliczania impulsów z enkodera zamocowanego na wózku transportowym. Układ 8255 jest
wykorzystywany do komunikacji z pulpitem operatora, zawierającym zadajniki kołowe
programu cięcia, klawisze sterujące, wyświetlacze i diody LED. Funkcje układu sprzężenia
z obiektem pełnią:
 dwa pakiety w systemie mikroprocesorowym, po 15 wejść i 14 wyjść z optoizolacją każdy,
do kontroli stanu formatyzerki i sterowania jej urządzeniami wykonawczymi;
 dwie płyty przekaźnikowe, sterowane sygnałami z pakietów wejść/wyjść binarnych;
 płytka wejść binarnych z optoizolacją, zbierająca sygnały z krańcówek i przekazująca je
do obu pakietów wejść/wyjść binarnych.
4.2.2 Przykład użycia metody
Na potrzeby układu sterowania dokonano umownego podziału całego urządzenia

na cztery zespoły, realizujące wyróżnione fragmenty rozbudowanego algorytmu sterowania.
Ponieważ zespoły te cechują się pewną autonomicznością, możliwe było proste
skoordynowanie ich pracy przy pomocy systemu flag sygnalizujących pewne
charakterystyczne stany pracy. Sterowanie każdym z zespołów zostało opisane odpowiednim
grafem przejść - otrzymano w ten sposób cztery automaty:
 Wózek - obejmujący trzybiegowy napęd elektryczny wózka transportowego oraz łapy
przytrzymujące pakiet sklejki; automat ten jest odpowiedzialny za realizację programu
cięcia;
 Belka - kontrolujący dociskanie sklejki do blatu stołu podczas cięcia; obejmujący, oprócz
mechanizmu opuszczania i podnoszenia belki, także tłoczki i węże dociskowe;
 Piły - automat sterujący zespołem pił tnących, ich pracą oraz ruchem wzdłuż belki;
146

 Ładowarka - automat przeznaczony do sterowania pneumatycznym urządzeniem
załadowczym i stołem uchylnym.
Słowa wejściowe tych automatów składają się zarówno z sygnałów pochodzących
z obiektu, jak również z flag generowanych przez inne automaty i wewnętrznych zmiennych
logicznych. Do wyznaczania stanów następnych zastosowano algorytm iteracyjny,
uruchamiany w przerwaniach zegarowych co 1/20 sekundy. Dla wszystkich automatów
przyjęto jednakową strukturę słowa wyjściowego xOt, pokazaną na rysunku 4.8. Wykorzystanie
poszczególnych bitów w tym czterobajtowym słowie odpowiada przyporządkowaniu bitom
portów wyjściowych przekaźników sterujących urządzeniami formatyzerki.
x7 x6 x5 x4 x3 x2 x1 -
x10 x9 x8
x27 x26 x25 x24 x23 x20
x32 x30
Rys. 4.8. Struktura słowa wyjściowego xOt automatów formatyzerki
Bxk12
P1 Bx12 P2 k06 P3 Bx 
k 12
k0
k12 t 7
Bxk 12 k0 k1
By  r cp 6 k06 0
Bx12
P12
k05 k06By t k0 6 P4
PA P9A P5A
k05 k05
k05 05
By
t k
t
t k 1 0
t k 0 5

k0
06
P11 W
7
y
x
df
W
Wydf k05  k07  k10 y

k12
P8 P7 P6  B
Wx 06
2
Wx
 k1
t k06
k
k1
2 x
x
k
W
W
12
r cp k06
P0 P9 P10
k06By
Rys. 4.9. Graf przejść automatu Piły sterującego zespołem pił tnących
Bliżej zostanie przedstawiony jeden z automatów - Piły. Jego graf przejść pokazano
na rysunku 4.9. Automat ten wykorzystuje w swoich funkcjach przejść: sygnały z krańcówek
(k05, k06, k07, k10, k12), flagi informujące o stanie automatów Wózek (Wx, Wy) i Belka (Bx,
By), zmienną sygnalizującą upłynięcie czasu tCS danego stanu (t), stan klawisza pulpitu
operatorskiego (rcp) dedykowanego temu automatowi oraz wewnętrzną zmienną informującą
147

o rozmiarze ciętych pakietów (df). Strukturę słowa wejściowego automatu przedstawia
poniższy rysunek.
k07 k06 k05 - - - rcp t
- By - Bx Wx k12 k11 k10
- - - - - - df Wy
Rys. 4.10. Struktura słowa wejściowego xt automatu Piły
Na słowo wyjściowe automatu yt, składają się:

 zmienne sterujące napędami (x5, x6, x9, x27, x30), a powodujące działanie obu pił, ich
ruch roboczy i powrotny oraz unoszenie do cięcia;
 jednobajtowy czas charakterystyczny tCS;
 bajt flag sygnalizujących wybrane stany automatu;
 jednobajtowy kod algorytmu specjalnego, który należy zrealizować po wejściu do danego
stanu.
W przypadku automatu Piły możliwe są tylko dwa rodzaje algorytmów: 0 - algorytm „pusty”,
1 - zgaszenie wyróżnionej diody LED na pulpicie, służące potwierdzeniu wciśnięcia
odpowiedniego klawisza. Wartości słów wyjściowych tego automatu dla różnych stanów
przedstawia tabela 4.3.
Tabela 4.3
Wartości słów wyjściowych automatu Piły
Stan yWt yOt ySt
Algorytm tcs x5 x6 x9 x27 x30 Pd Pz Py Px
P0 0 12 0 0 0 1 0 0 0 0 0
P1 0 12 0 0 0 0 0 1 1 0 1
P2 0 5 1 1 1 0 0 0 0 0 0
P3 0 12 1 1 1 0 1 0 0 0 0
P4 0 10 1 1 0 0 0 0 0 1 0
P6 0 12 1 1 1 0 0 1 0 0 0
P7 0 12 1 1 0 1 0 1 0 0 0
P8 0 12 1 1 0 0 0 1 0 0 1
P9 0 12 0 0 0 1 0 1 0 0 0
P10 0 10 0 0 0 0 0 0 0 1 0
P11 0 12 1 1 0 1 0 1 0 0 0
P12 0 12 1 1 0 0 0 1 0 0 1
P5A 1 12 0 0 0 0 0 0 0 1 0
P9A 1 12 0 0 0 1 0 0 0 1 0
PA 1 12 0 0 0 0 0 0 0 0 0
Poniżej umieszczono wynik translacji opisu automatu Piły z języka JODA na tekst
w asemblerze mikroprocesora Z80.
148

; CROSS-TRANSLATOR JODA 25. 4.95 / 16: 2: 2
; AUTOMAT PILY FORMATYZERKI
; wykaz stanow automatu
p0: equ 0
p1: equ 1
p2: equ 2
p3: equ 3
p4: equ 4
p6: equ 5
p7: equ 6
p8: equ 7
p9: equ 8
p10: equ 9
p11: equ 10
p12: equ 11
p5a: equ 12
p9a: equ 13
pa: equ 14
; bloki opisu automatow:
defb 00h,00h,80h,00h,250,a0 ; p0
defw p0tp ; p0
defb 00h,00h,00h,00h,250,a0 ; p1
defw p1tp ; p1
defb 60h,02h,00h,00h,100,a0 ; p2
defw p2tp ; p2
defb 60h,02h,00h,01h,250,a0 ; p3
defw p3tp ; p3
defb 60h,00h,00h,00h,200,a0 ; p4
defw p4tp ; p4
defb 60h,00h,80h,00h,240,a0 ; p6
defw p6tp ; p6
defb 60h,00h,80h,00h,240,a0 ; p7
defw p7tp ; p7
defb 60h,00h,00h,00h,250,a0 ; p8
defw p8tp ; p8
defb 00h,00h,80h,00h,240,a0 ; p9
defw p9tp ; p9
defb 00h,00h,00h,00h,200,a0 ; p10
defw p10tp ; p10
defb 60h,00h,80h,00h,240,a0 ; p11
defw p11tp ; p11
defb 60h,00h,00h,00h,250,a0 ; p12
defw p12tp ; p12
defb 00h,00h,00h,00h,250,a1 ; p5a
defw p5atp ; p5a
defb 00h,00h,80h,00h,250,a1 ; p9a
defw p9atp ; p9a
defb 00h,00h,00h,00h,250,a1 ; pa
defw patp ; pa
;tablica flag automatu
p0fl: defb 00h,0A1h,00h,00h,08h,80h,80h,81h,80h,08h,80h,81h,08h,08h,00h
; CROSS-TRANSLATOR JODA 25. 4.95 / 16: 2: 2
; AUTOMAT PILY FORMATYZERKI
; tablice przejsc automatu:
defb 41h,01h,00h,00h,00h,00h,p5a,40h,40h,00h,00h,00h,00h,p3,p2
defb 40h,00h,00h,00h,00h,00h,p5a,80h,80h,00h,00h,00h,00h,p4
defb 00h,00h,01h,01h,00h,00h,p4,p3
149

defb 00h,00h,08h,00h,00h,00h,p9,80h,80h,00h,00h,00h,00h,p7
defb 00h,00h,08h,00h,00h,00h,p9,00h,00h,00h,00h,01h,00h,p8
defb 00h,00h,14h,14h,00h,00h,p2,p8
defb 20h,20h,00h,00h,00h,00h,p1,p9
defb 00h,00h,14h,14h,00h,00h,p2,p12
p5atp: defb 1,40h,00h,40h,40h,00h,00h,p9a,p5a
p9atp: defb 1,20h,20h,00h,00h,00h,00h,pa,p9a
patp: defb 2,00h,00h,40h,40h,00h,00h,p1,02h,02h,00h,00h,00h,00h,p1,pa

Najprostszy w realizacji okazał się automat Ładowarka, ponieważ zleceniodawca
zrezygnował z pełnego uruchomienia urządzenia załadowczego. Działanie tego automatu
ograniczyło się do kontrolowania stanu stołu uchylnego i generowania odpowiednich flag
zezwalających na pracę wózka transportowego. Nieco bardziej złożony jest automat sterujący
belką dociskową. Konieczność uwzględnienia różnych sposobów przytrzymywania ciętej
sklejki i współpracy z wózkiem zmusiła do zastosowania automatu o 18 stanach. Najbardziej
złożonym automatem jest Wózek. Jego graf przejść zawiera aż 82 stany. Tak duża ich liczba
jest związana z koniecznością realizacji różnych działań trzybiegowego, dwusilnikowego
mechanizmu napędowego, w zależności od wymiarów ciętego arkusza, formatów docelowych,
położenia względem belki dociskowej oraz występowaniem sekwencji operacji związanych
z przygotowaniem do cięcia i fazami przejściowymi. Również słowo wyjściowe yWt tego
automatu jest silnie zróżnicowane co do wartości. Wynika to z konieczności wykonywania
wielu działań związanych z realizacją programu cięcia (przeliczanie położenia wózka,
wyznaczanie odcinków drogi do przejechania, kontrola poprawności nastaw formatów, itp.),
a przypisanych odpowiednim stanom automatu i uruchamianych po przejściu do tych stanów.
Od chwili uruchomienia sterownika sprawuje się on poprawnie, sama zaś
formatyzerka stała się ponownie ważnym ogniwem procesu produkcyjnego. W ciągu
minionych lat dwukrotnie dochodziło, na życzenie zleceniodawcy, do rozszerzenia funkcji
użytkowych urządzenia. Za każdym razem operacja ta polegała między innymi na modyfikacji
zaimplementowanych tablic przejść i wyjść automatu sterującego, potwierdzając tym samym
elastyczność zastosowanej metody programowania.
150

4.3 Sumator hematologiczny
4.3.1 Opis urządzenia
Sumator hematologiczny [39] jest prostym urządzeniem wspomagającym pracę

w laboratorium analitycznym. Jak sugeruje jego nazwa, służy do zliczania różnych ciałek krwi.
„Urządzeniem” rozróżniającym krwinki w badanym preparacie jest człowiek, sumator zaś
pełni funkcję specjalizowanego licznika-kalkulatora. Podstawowym jego zadaniem jest
inkrementowanie wskazanych przez użytkownika wewnętrznych liczników, a po zakończeniu
badania - przeprowadzenie niezbędnych obliczeń i podanie procentowego składu krwi
z podziałem na grupy ciałek. Oprócz prostego odczytu stanu liczników i procentowego składu
krwi, możliwa jest także edycja stanu liczników, polegająca na wybiórczym ich
dekrementowaniu lub zerowaniu. Rozbudowane wersje sumatora mogą również wydrukować
na żądanie raport z przeprowadzonego badania. Ponadto w trakcie zliczania co każde 100
krwinek rozlega się krótki sygnał dźwiękowy, pozwalający na kontrolowanie liczby zliczeń
bez spoglądania na wyświetlacz. Urządzenie jest odporne na chwilowe zaniki zasilania -
przerwy takie nie powodują utraty stanu liczników.
Jednostką centralną sumatora jest mikrokomputer jednoukładowy z rodziny MCS51
z wbudowaną pamięcią programu. Mikrokontroler ten jest odpowiedzialny za wszystkie
funkcje użytkowe urządzenia:
 zliczanie naciśnięć poszczególnych klawiszy odpowiadających różnym krwinkom (zależnie
od wersji matryca klawiszy zawiera 12 lub 24 takie monostabilne klawisze);
 dokonywanie niezbędnych obliczeń;
 sterowanie multipleksowanym wyświetlaczem LCD i piezoceramicznym sygnalizatorem;
 reagowanie na klawisze funkcyjne;
 sterowanie mechanizmem drukarki termicznej;
 przechowywanie danych podczas zaniku zasilania.
Matryca klawiszy jest podzielona na dwie grupy: klawisze liczników (12 lub 24) i klawisze
funkcyjne (2 lub 4 w wersji z drukarką). Dwa podstawowe klawisze funkcyjne służą do:
wyboru jednego z trybów pracy sumatora (zliczanie, przegląd i modyfikacja, wyświetlanie
składu procentowego) - klawisz FUN; całkowitego zerowania przyrządu, a także
dekrementowania lub zerowania wybranego licznika - klawisz CLR. Wersja sumatora
z wbudowaną drukarką ma dodatkowe dwa klawisze funkcyjne: PAP - ładowanie i wysuw
151

taśmy papierowej; PRN - wydruk raportu. Model z 24 klawiszami licznikowymi faktycznie
może zliczać aż 46 różnych krwinek. Uzyskano to poprzez wyróżnienie jednego z klawiszy,
jako przełącznika między podstawowym i uzupełniającym zestawem liczników, szczególnie
przydatnym w przypadkach patologicznych. Po przełączeniu klawiatury na dodatkowy zestaw
liczników, każdemu wciśnięciu jednego z pozostałych 23 klawiszy licznikowych towarzyszy
krótki sygnał dźwiękowy. Stosowanie takich sygnałów jest konieczne ze względu na typowy
sposób pracy z sumatorem, polegający na wciskaniu wybranych klawiszy bez odrywania
wzroku od preparatu pod mikroskopem.
Sumator został opracowany na zlecenie jednej z białostockich firm branży medycznej,
wdrożony przez nią do produkcji seryjnej i cieszy się dużym wzięciem u odbiorców.
4.3.2 Struktura programu sterującego
Program sterujący pracą sumatora został napisany bezpośrednio w asemblerze 8051.

Było to podyktowane koniecznością umieszczenia całego, jak się okazało obszernego, kodu
programu wyłącznie w wewnętrznej pamięci mikrokomputera. Wykorzystano również inne
wbudowane zasoby mikrokontrolera: dwa przerwania zewnętrzne służą do sygnalizacji zaniku
zasilania i położenia głowicy drukującej, jeden z timerów odmierza czasy pracy elementów
grzejnych głowicy termicznej drukarki, a drugi jest podstawą generacji przerwań zegarowych.
Te ostatnie użyto do multipleksowanej obsługi wyświetlacza LCD, sprzężonej z
przeglądaniem matrycy klawiszy. W procedurze obsługi przerwania zegarowego wyznacza się
ustalony stan klawiatury i dekoduje wciśnięte klawisze. Wciśnięcie więcej niż jednego
klawisza jest traktowane jako błąd i odpowiednio sygnalizowane stanem wybranej zmiennej
logicznej. Indywidualnie sygnalizowane są także stany czterech klawiszy funkcyjnych.
Wciśnięcie klawisza licznikowego powoduje ustawienie odpowiedniej zmiennej binarnej
i umieszczenie w komórce RAM numeru porządkowego tego klawisza.
Zadania użytkowe oprogramowania są realizowane w głównej mierze przez program
tła. Ponieważ algorytm działania sumatora można było przedstawić w formie grafu przejść, jak
dla automatu skończonego, postanowiono zastosować przy jego programowaniu metodę
JODA. Słowo wejściowe xt automatu jest w tym przypadku jednobajtowe i zawiera zmienne
logiczne informujące o:
 stanie klawiatury (key, kerr, feedk, prnk, funk, clrk);
 upłynięciu zadanego czasu (t);
 zakończeniu jakiegoś działania (done).
152

Strukturę słowa xt przedstawia poniższy rysunek, a graf przejść automatu pokazano
na rysunku 4.12.
t key kerr done feedk prnk funk clrk
Rys. 4.11. Słowo wejściowe automatu sterującego pracą sumatora hematologicznego
done
INCREM PRNFEED
key
feedk  kerr
w done
t key  funk c lrk  pr nk  feedk k ey kerr prnk  kerr
funk  kerr
START0 STARTA COUNT0 COUNT1 PRINT
key  clrk  funk  kerr t  cl rk
c lrk  kerr key funk  kerr
clr k  ker r
key
t
STARB STARTC IFCLR CLEARONE MEMORY0 PRNFEEDM
t  c lrk  kerr done feedk k err
clr k  t ker r key  kerr
t pr nk  kerr
t
CLEARALL DECREM MEMORY1 PRINTM
t  c lrk  kerr  key done
t  c lrk  kerr w key  kerr

funk  kerr clrk  kerr
t clrk kerr
IFCLRONE SHOWMEM
IFCLRS
funk ker r
c lrk  k err t  clr k
done  key  kerr
SHOWSTAT STAT0
w = key  clrk  funk  prnk  feedk  ker r key kerr key  kerr  done
w
done prnk k er r
PRNFEEDS STAT1 PRINTS
feedk ker r done
Rys. 4.12. Graf przejść automatu sterującego pracą sumatora hematologicznego
Z każdym stanem automatu są związane pewne działania, takie jak: wyświetlenie lub
modyfikacja zawartości wskazanego licznika, sterowanie mechanizmem drukarki, itd.
Działania te wymagają dodatkowych operacji mikroprocesora. Potraktowano je jako
charakterystyczne algorytmy stanów i wykorzystano opisaną w punkcie 3.1.4.2 strukturę słowa
wyjściowego yt, które może zawierać także zmienne wielowartościowe wskazujące
na konieczne do wykonania w danym stanie operacje. Operacje te potraktowano jako
jednorazowe, tzn. realizowane tylko raz po przejściu automatu do nowego stanu.
Algorytm działania sumatora wymagał także uwzględnienia w pewnych stanach
zależności czasowych. Między innymi czas trwania stanu automatu został wykorzystany
do odpowiedniego rozpoznawania i reagowania na krótkotrwałe i długotrwałe wciśnięcia
klawisza CLR. Pojawiły się zatem czasy charakterystyczne tCS stanów, będące drugim
składnikiem yWt słowa yt automatu. W stanach niewymagających uwzględniania czasu przyjęto
153

dowolne zastępcze wartości tCS. Odmierzanie czasu przebywania automatu w danym stanie
polega na inicjowaniu jednobajtowego timera wartością tCS pobraną z tablicy stanów po
przejściu do tego stanu i późniejszym jego dekrementowaniu przez procedurę obsługi
przerwania zegarowego co 1/4 sekundy. Opis automatu sterującego sumatorem w języku
JODA, zawierający dodatkowe komentarze objaśniające, zamieszczono poniżej.
jezyk a8051
automat sumator hematologiczny v.1,v.2
{ v.2 - 26.09.95 - mozliwosc wydruku z wszystkich 3 funkcji}
wyjscia
#,#; {czas w 1/4sek , numer algorytmu dodatkowego}
stany
{stany po wlaczeniu}
start0:1,0; {wstepne zerowanie}
starta:1,16; {wyswietlenie kolejnego nr probki}
startb:1,17; {zerowanie nr probki}
startc:1,18; {zmiana nr probki - wpisanie nowego z klawiatury}
{ podstawowe stany pracy i stany przy sprawdzaniu}
count0:1,12; {przygotowania do trybu zliczania}
count1:1,2; {tryb zliczania}
increm:1,3; {zwiekszenie o 1 wskazanego licznika}
decrem:1,4; {zmniejszenie o jeden wskazanego licznika}
memory0:1,5; {przygotowanie do trybu przegladu licznikow}
memory1:1,11; {tryb przegladu}
showmem:1,6; {wyswietlenie wskazanego licznika}
stat0:1,7; {przygotowanie do trybu statystycznego}
stat1:1,8; {tryb statystyczny}
showstat:1,9; {podanie %-ego udzialu wskazanego licznika}
ifclr:4,1; {czy kasowac?}
ifclrs:4,1; {czy kasowac w statystyce ?}
clearall:1,10; {zerowanie przed nowa probka}
ifclrone:4,1; {stan przejsciowy po wcisnieciu klawisza CLR}
clearone:2,15; {kasowanie tylko wybranego licznika krwinek}
print:2,14; {wydruk z funkcji zliczania podstawowego}
prnfeed:1,13; {wysuw papieru}
printm:2,14; {wydruk z funkcji przegladu licznikow}
prnfeedm:1,13; {wysuw papieru z funkcji przegladu licznikow}
prints:2,14; {wydruk z funkcji statystyki}
prnfeeds:1,13; {wysuw papieru z funkcji statystyki}
bity
t,key,kerr,done,feedk,prnk,funk,clrk; {0-wy bajt SZI}
{ t - flaga uplyniecia zadanego czasu;
key - flaga wcisniecia dowolnego klawisza;
kerr - flaga bledu klawiatury (wiecej niz 1 klawisz);
done - zakonczenie jakiegos dzialania;
feedk - klawisz FEED (wysuw papieru);
prnk - klawisz PRN (wydruk);
funk - klawisz FUN (wybor funkcji);
clrk - klawisz CLR (zerowanie)}
funkcje
{ start do pracy }
start0-starta=t/key/funk/clrk/prnk/feedk;
starta-count0=funk/kerr;
starta-startb=clrk/kerr;
starta-startc=key/clrk/funk/kerr;
startb-starta=/key;
startc-starta=/key;
{ praca podstawowa }
154

count1-increm=key/clrk/funk/prnk/feedk/kerr;
count1-memory0=funk/kerr;
count1-ifclr=clrk/kerr;
count1-print=prnk/kerr;
count1-prnfeed=feedk/kerr;
increm-count1=/key;
memory0-memory1=/key/kerr;
memory1-showmem=key/clrk/funk/prnk/feedk/kerr;
showmem-memory1=/key/kerr;
memory1-stat0=funk/kerr;
memory1-ifclrone=clrk/kerr;
memory1-printm=prnk/kerr;
memory1-prnfeedm=feedk/kerr;
stat0-stat1=/key/kerr/done;
stat0-count0=done/key/kerr;
stat1-showstat=key/clrk/funk/prnk/feedk/kerr;
stat1-ifclrs=clrk/kerr;
showstat-stat1=/key/kerr;
stat1-count0=funk/kerr;
stat1-prints=prnk/kerr;
stat1-prnfeeds=feedk/kerr;
count0-count1=/key/kerr;
ifclr-clearall=t*clrk/kerr;
ifclr-count0=/t/clrk;
ifclrs-clearall=t*clrk/kerr;
ifclrs-stat0=/t/clrk;
ifclrone-decrem=/t/clrk/kerr/key;
ifclrone-clearall=t*clrk/kerr;
decrem-clearone=clrk/t/kerr;
decrem-memory0=t;
clearall-start0=t;
clearone-memory0=t;
{ operacje drukarki }
print-count0=done;
prnfeed-count0=done;
printm-memory1=done;
prnfeedm-memory1=done;
prints-stat1=done;
prnfeeds-stat1=done;
koniec.

Na cykl obsługi automatu realizowany przez program tła złożyły się następujące
działania:
1. sprawdzenie wartości timera stanu i ustawienie zmiennej wejściowej t gdy jest ona zerowa;
2. sprawdzenie warunków przejść dla bieżącego stanu automatu przy użyciu algorytmu
jednokrotnego, opisanego w punkcie 3.1.3.1;
3. w przypadku przejścia do nowego stanu wpisanie do timera zadeklarowanej wartości tCS
i jednokrotne (punkt 3.2.5) wykonanie przypisanego temu stanowi działania.
155

4.4 Komunalna oczyszczalnia ścieków
Ostatnim przykładem zastosowania metody JODA do programowania algorytmów

sterowania binarnego jest system automatyki komunalnej oczyszczalni ścieków z reaktorem
biologicznym, uruchomiony w 1995 roku w Giżycku. Został on szerzej opisany w [36, 38].
4.4.1 Zadania sterowania
Na ciąg technologiczny oczyszczalni składa się wiele urządzeń dwustanowych

napędzanych silnikami elektrycznymi jedno- lub dwubiegowymi. Urządzenia te można
pogrupować w kilka funkcjonalnych zespołów, które zostały zaznaczone na schemacie
oczyszczalni na rysunku 4.13. System automatyki wymagał skojarzenia z każdym z urządzeń
po kilka sygnałów binarnych: wejściowych (np. potwierdzenie pracy, sygnał alarmu,
sygnalizacja odłączenia do remontu) i wyjściowych (np. sterowanie). Ogólną liczbę sygnałów
binarnych i analogowych z podziałem na zespoły funkcjonalne zawiera tabela 4.4.
Tabela 4.4
Specyfikacja urządzeń i sygnałów kontrolno-sterujących oczyszczalni ścieków
Zespół urządzeń we.bin. wy.bin. we.anal.

Kraty z piaskownikiem 12 2 1
Reaktor 1 30 20 8
Reaktor 2 30 20 8
Osadniki wtórne 1 i 2 10 6 1
Osadnik wtórny 3 5 3 0
Zespół dmuchaw 12 6 0
Stacja pomp 21 9 1
Zagęszczacze osadu i przepompownia osadu 19 9 0
Dozownik FeSO4 i dmuchawy piaskownika 14 8 1
Przepompownia wód technologicznych 14 6 0
dodatkowe sygnały specjalne 0 2 0
RAZEM : wariant podstawowy: 132 66 12
po rozbudowie: 167 89 20
Większość urządzeń technologicznych oczyszczalni jest sterowana dwustanowo,

chociaż nie zawsze reguły tego sterowania można porównać ze zwykłym sterowaniem
binarnym. Bardzo często jednym z parametrów, który wpływa na pracę poszczególnych
urządzeń jest upływający czas, który modyfikuje algorytmy sterowania tymi urządzeniami.
Występują również liczne powiązania logiczne pomiędzy różnymi urządzeniami
technologicznymi, wyrażające się uwarunkowaniami załączenia lub wyłączenia jednych
156

urządzeń w funkcji stanu innych.
Kompresor y
piaskownika
Kompresory i dozownik
i FeSO4 Zagęszczacze
Osadniki w tórne Pompy osadu osadu
Pras a osadu
Dys pozytornia
Reaktor 2 Reaktor 1
Kraty Przepompownia
wody technologicznej
Piaskownik
Rys. 4.13. Schemat technologiczny oczyszczalni ścieków
Najważniejszym obiektem regulacji jest reaktor biologiczny. Regulowaną wielkością

ciągłą jest w nim stężenie tlenu, które powinno być utrzymywane w zadanym przedziale
wartości. Źródłem tlenu dla reaktora jest układ trzech dmuchaw dwubiegowych, dający
możliwość uzyskania ośmiu różnych poziomów napowietrzania reaktora. Zadaniem systemu
automatyki jest takie sterowanie tymi dmuchawami, aby były spełnione wymagania
technologii reaktora. W obrębie reaktora zainstalowanych jest także szereg innych urządzeń
dwustanowych (mieszadła, pompy) wpływających na jego pracę. Innym obwodem regulacji
wykorzystującym sygnał ciągły jest sterowanie zespołem pomp osadu recyrkulowanego
157

w funkcji przepływu ścieków oczyszczonych. Pompy te mogą też być sterowane w funkcji
poziomu osadu w odpowiednim zbiorniku (system umożliwia operatorowi wybór rodzaju tego
sterowania). Również praca pomp osadu zagęszczonego i wody technologicznej jest zależna
od sygnałów binarnych o poziomie cieczy w zbiornikach wyrównawczych.
Występują także uzależnienia czasowe sterowania, wyrażające się zdefiniowanymi
czasowymi programami pracy niektórych urządzeń w ciągu doby. Tak sterowane mają być np.
pompy osadu nadmiernego i dozownik FeSO4. Ponieważ część urządzeń dwustanowych
(przede wszystkim pomp) jest zdublowana z uwagi na ciężkie warunki pracy, jednym
z wymogów sterowania czasowego jest okresowa rotacja (np. w cyklu 12-godzinnym)
urządzeń pracujących jako podstawowe z urządzeniami zapasowymi. System automatyki
powinien sam zastępować urządzenia znajdujące się w stanie awarii lub odłączenia od
systemu, urządzeniami pozostającymi w gotowości do pracy jako zapasowe.
Z uwagi na różne możliwe sytuacje w eksploatacji linii technologicznej system
automatyki powinien umożliwiać zarówno kompleksowe automatyczne sterowanie całością
linii, jak również pozwalać na odstępstwa od tej reguły. Dopuszczalne winny być takie stany
pracy, w których np. część urządzeń pracuje w pełni automatycznie, część jest przełączona
na sterowanie ręczne (zdalne lub lokalne), a jeszcze inne są w ogóle odłączone od obwodów
sterowania.
Realizacja opisanych zadań sterowania wymagała od autora, jako projektanta systemu
automatyki, następujących działań:
 doboru struktury komputerowego układu automatyki z uwzględnieniem narzuconych przez
zleceniodawcę ograniczeń sprzętowych i finansowych;
 opracowania oprogramowania sterującego, monitorującego i archiwizującego informacje
o stanie procesu oczyszczania ścieków.
Sposób rozwiązania powyższych problemów przedstawiono w następnych punktach pracy.
4.4.2 Przyjęte rozwiązania konstrukcyjne i programowe
Zrealizowana struktura systemu automatyki w dużej mierze zależała od historycznych

uwarunkowań cyklu inwestycyjnego. Pierwotnie (koniec lat siedemdziesiątych) przewidywano
zainstalowanie dużej, centralnej sterowni-dyspozytorni, wyposażonej w rzędy szaf i pulpity
operatorskie. Pod kątem takiego właśnie, scentralizowanego systemu automatyki
zaprojektowano sieć linii zasilających i sterujących poszczególnymi urządzeniami i węzłami
technologicznymi. Konieczność wykorzystania już istniejących instalacji wpłynęła na
158

przyjęcie koncepcji centralnego komputera kontrolującego proces technologiczny. Na sprzęt
komputerowego układu automatyki złożyły się następujące elementy składowe:
 komputer typu 486DX2-66 z: HDD 340MB, monitorem SVGA 17”, drukarką i UPS;
 karty rozszerzające produkcji ADVANTECH:
PCL812PG (1szt) - do pomiaru wielkości analogowych;
PCL722 (2szt) - jako wejścia i wyjścia sygnałów dwustanowych.
 ustawiona obok komputera szafa układu sprzężenia z obiektem zawierająca listwy
przyłączeniowe, przekaźniki sygnałów wejściowych i karty peryferyjne:
PCLD782B (6szt) - zawierająca 24 wejścia binarne z optoizolacją;
PCLD885 (5szt) - zawierająca 16 wyjść przekaźnikowych;
PCLD770 (2szt) - moduły wejść analogowych ze wzmacniaczami izolacyjnymi.
Przyjęta modułowa konstrukcja układu sprzężenia z obiektem, pokazana na rysunku 4.14,
umożliwia w razie potrzeby dalszą prostą rozbudowę układu automatyki.
Rys. 4.14. Struktura układu sprzężenia z obiektem
Jako standard przy przesyłaniu sygnałów binarnych przyjęto napięcie 220V AC.
Jedynie w niektórych punktach zastosowano lokalnie, z uwagi na BHP, napięcie obniżone.
159

Ponadto urządzenia dwustanowe są wyposażone w lokalne tablice sterownicze pozwalające
na odłączenie ich od systemu automatyki i lokalne, ręczne sterowanie pracą lub też
odstawienie urządzenia do remontu.
Na pakiet opracowanego oprogramowania sterującego procesem złożyły się
następujące programy:
 GRES.EXE - zasadniczy program realizujący kontrolę procesu i generowanie niezbędnych
raportów, funkcjonuje on samodzielnie, jako tzw. rezydent, zajmując około 50kB pamięci
operacyjnej komputera;
 GMON.EXE - program monitorujący stan procesu, komunikując się z GRES.EXE
umożliwia operatorowi obserwację stanu procesu na ekranie monitora, ingerowanie
w przebieg procesu (sytuacje alarmowe, zmiany parametrów pracy, itp.) oraz ręczne-zdalne
sterowanie urządzeniami oczyszczalni, program ten jest ładowany do pamięci operacyjnej
komputera na żądanie operatora wymiennie z innymi programami pakietu lub programami
użytkowymi;
 GCON.EXE - program umożliwiający operatorowi, tak jak GMON.EXE, zmianę
parametrów pracy oczyszczalni jak również dynamiczną zmianę konfiguracji systemu
automatyki, obejmującej między innymi: przyporządkowanie binarnych oraz analogowych
kanałów wejściowych i wyjściowych; parametry przetwarzania wejść analogowych, moce
znamionowe urządzeń wykonawczych;
 GRAP.EXE - program przetwarzający pliki *.RAP generowane przez działający program
rezydentny, a zawierające dane o przebiegu procesu technologicznego, umożliwia
uzyskanie raportów o pracy oczyszczalni oraz syntetycznych sprawozdań okresowych,
program ten jest ładowany do pamięci operacyjnej komputera na żądanie operatora;
Integralną częścią pakietu jest także plik przechowujący bieżącą konfigurację i parametry
pracy systemu automatyki.
Przyjęcie wariantu oprogramowania systemowego składającego się z rezydentnej
części odpowiedzialnej za proces kontroli i raportowania procesu oraz wymiennych programów
użytkowych było podyktowane podziałem całości zadań programowych na kilka modułów.
Celem tego podziału było także umożliwienie modyfikacji jednych modułów oprogramowania,
niezależnie od pozostałych. Możliwe jest np. wygenerowanie nowej wersji programu
rezydentnego w trakcie funkcjonowania jego starej wersji, a następnie proste przeładowanie
rezydenta w celu uruchomienia zmodyfikowanych algorytmów. Ten mechanizm aktualizacji
programów zdał egzamin wielokrotnie podczas uruchamiania systemu.
160

4.4.3 Sterowanie urządzeniami dwustanowymi
Dla każdego z urządzeń dwustanowych przyjęto możliwość występowania

następujących trybów pracy:
 automatyczny - o chwilach włączenia i wyłączenia urządzenia decyduje komputer
na podstawie zdefiniowanego czasowego programu pracy lub w wyniku decyzji podjętych
przez algorytmy DDC; wystąpienie awarii w tym trybie powoduje wyłączenie sterowania
urządzenia i odpowiednią sygnalizację (barwą i dźwiękiem);
 ręczny - decyzje o pracy lub postoju urządzenia podejmuje operator i przekazuje ją
systemowi automatyki za pośrednictwem odpowiednich poleceń programu monitorującego;
wystąpienie alarmu powoduje wyłączenie sterowania i odpowiednią sygnalizację;
 lokalny - urządzenie jest sterowane przez lokalny układ, komputer jedynie sygnalizuje jego
stan (w przypadku niektórych urządzeń sterowanie lokalne może być automatyczne lub
ręczne, w przypadku części urządzeń ten tryb nie występuje w ogóle);
 odłączenie logiczne - stan nie pracującego urządzenia, w którym system automatyki traktuje
je jako nie istniejące, tryb ten włącza się poleceniami monitora procesu w razie potrzeby;
 odłączenie fizyczne - stan faktycznego odłączenia urządzenia, spowodowany jego trwałą
awarią, remontem, konserwacją, brakiem w instalacji, tryb ten jest nadrzędny względem
odłączenia logicznego, uzyskuje się go odpowiednim wejściowym sygnałem binarnym
pochodzącym z zewnętrznego przełącznika przy urządzeniu albo symulowanym
programowo w danych konfiguracyjnych systemu.
Przełączeń pomiędzy poszczególnymi trybami pracy dokonuje operator systemu
za pośrednictwem programu monitorującego.
W celu ujednolicenia opisu pracy urządzeń dwustanowych, a co za tym idzie
unifikacji oprogramowania, zdefiniowano dla urządzeń o podobnym charakterze pracy grafy
przejść jak dla automatów Moore’a. Argumentami funkcji logicznych warunkujących przejścia
w tych grafach mogą być przykładowo:
 binarne sygnały zwrotne od urządzenia;
 flagi stanów pracy innych, współpracujących z danym, urządzeń;
 flagi od timerów odmierzających zadane odcinki czasu;
 sygnały sterujące generowane przez algorytmy DDC;
 polecenia operatora dotyczące trybów i stanów pracy.
161

Jako rozmiar słowa wejściowego automatu xt przyjęto dwa bajty, przy czym okazało się
możliwe użycie jednolitej struktury (rysunek 4.15) tego słowa dla wszystkich automatów.
15 0
t str2 str a2 zam otw st2 st in r a al l o p2 p
Rys. 4.15. Struktura uniwersalnego słowa wejściowego automatów
Znaczenie poszczególnych zmiennych wejściowych jest następujące:

t - flaga upłynięcia zadanego czasu przebywania w danym stanie;
str2 - dodatkowy sygnał sterowania generowany przez algorytmy sterowania nadrzędnego lub
operatora (włączenie drugiego biegu urządzenia, zamykanie zasuwy);
str - sygnał sterowania pracą urządzenia generowany przez algorytmy sterowania nadrzędnego
lub operatora (pierwszy bieg kompresora, otwieranie zasuwy);
a2 - sygnał alarmu od urządzenia (np. termik) związany z drugim biegiem;
zam - sygnał zamknięcia zasuwy sterowanej;
otw - sygnał otwarcia zasuwy sterowanej;
st2 - kopia wyjściowego sygnału sterującego urządzeniem (drugi bieg kompresora, zamykanie
zasuwy);
st - kopia wyjściowego sygnału sterującego pracą urządzenia (pierwszy bieg kompresora,
otwieranie zasuwy);
in - sygnał odłączenia „logicznego” urządzenia, generowany przez operatora;
r - sygnał sterowania ręcznego z konsoli operatora, generowany przez operatora;
a - sygnał alarmu od urządzenia związany z jego pracą;
al - flaga występowania alarmu w automacie;
l - wejściowy sygnał przełączenia urządzenia na sterowanie lokalne (z pulpitu przy
urządzeniu);
o - wejściowy sygnał odłączenia urządzenia od systemu (np. do konserwacji, remontu);
p2 - dodatkowy wejściowy sygnał potwierdzający pracę urządzenia (drugi bieg kompresora);
p - wejściowy sygnał potwierdzający pracę urządzenia;
Rysunek 4.16 przedstawia graf przejść automatu Mieszadło sterującego mieszadłami
zainstalowanymi w reaktorze biologicznym. Jego poszczególne stany oznaczają:
MS0 - stan startowy po uruchomieniu systemu przy wyłączonym urządzeniu;
MS1 - stan startowy po uruchomieniu systemu przy działającym urządzeniu;
MA1 - tryb automatyczny - urządzenie włączone;
MAA - tryb automatyczny - stan alarmu;
162

MR0 - tryb ręczny (z konsoli) - urządzenie wyłączone;
MR1 - tryb ręczny (j.w.) - urządzenie włączone;
MRA - tryb ręczny - stan alarmu;
MLR - stan przejściowy pomiędzy urządzeniem pracującym w trybie ręcznym (MR1) a trybem
sterowania lokalnego (MLOK);
MLOK - urządzenie sterowane lokalnie;
MLA - urządzenie sterowane lokalnie zgłasza alarm (np. od termika zabezpieczającego);
MAOD - stan niespodziewanego odłączenia urządzenia;
MOD - tryb odłączenia urządzenia od systemu (np. do remontu).
l  o  in a
MLA
l  o o  in
a o  in
i n
a o  in
a
 a
l o  i n p o  i n l 
a
o in MS1
l  o  in  a
MLOK MS0
p  o  in l  a
r
 in
l
r  o in  l  a  p
t
l  o  a  in p
l
l o
p r o
t a
a o in
)
i n
l in
r
n 
o
i
t( o
o
o a
r
in
i n
l
in
a
MLR MODL
l
MR0
i n p
n
str i
r
a) o l
 l  a p
 t)
t
o
a 
l (p s
l
MAA  in
o
t r 
  p
in a
r  o  in l  a str
r  o  in l  a str

in 
r
l (a
l o
o i n
i
t  o  in
t
l
o
r o
a
p)
a
r
in
s t
a
 in
M RA r o MAOD
t
a
i n
o
r
l
t o l
i n(
r
r

in (a 
o
o
t l
l st  o
o
in
p p)
a
s
tr ( p r o  a in l o in  l  a  p
p
a ) MR 1 MA1
in
r l  o  a  in
r  o in  l
r o  in l o in
t
Rys. 4.16. Graf przejść automatu Mieszadła,

sterującego mieszadłami zainstalowanymi w reaktorze biologicznym
Ponieważ urządzenia w reaktorze są przewidziane do pracy ciągłej, brak jest stanu

MA0 odpowiadającego normalnemu wyłączeniu w trybie automatycznym. Wszystkie
pozostałe automaty sterujące, a mianowicie:
 PompaR - pompy wewnątrz reaktora;
 Kompresor - dwubiegowe kompresory powietrza tłoczonego do reaktora;
163

 Pompa - sprzężone z zasuwami sterowanymi pompy, np. osadu, wody;
 Zasuwa - sterowane elektrycznie zasuwy;
 Osadnik - pracujące ciągle mieszadła osadników wtórnych;
 Krata - kraty ze zgarniaczami nieczystości;
 PompaU - tzw. pompa uszczelniająca, wspomagająca pracę pomp osadu recyrkulowanego;
 Zwykłe - pozostałe urządzenia jednobiegowe;
są modyfikacjami przedstawionego wyżej automatu Mieszadło.
Przykładowy graf automatu Zwykłe dla zwykłych urządzeń jednobiegowych
przedstawia rysunek 4.17. Dla tego typu urządzeń nie przewidziano lokalnego trybu pracy, ale
mogą być one normalnie wyłączane w trybie automatycznym.
p o in a o in
p  o in a
ISS1
a
p ISS0
o
n)
t a in
in
in
i
t(o
to
o  in
t
r  o in  a in
ISA0 IS OD
r ISR0 t
 st r o in  a o o in  a p
a in
t )t
r
t
p o (a in
n s r p
t
o
a
o
o
i p s
o
in
in
o in
r o in  a  str
a
r o  in  a  str
o ( t)
str  o in  r a
str  o  in r a
a
r
in
a
o
in
a
 p
t
o
r
r
ISR A r  ISAOD ISAA

o )
in p
r
o (a  st
i n s o o (a
t n
p p) o i
st t t
r p  r  o a in
a in
ISR 1 ISA1
p  r  o a in in
r  o  in
r o  in
Rys. 4.17. Graf przejść automatu sterującego pracą zwykłych urządzeń jednobiegowych
Poniżej przedstawiono wynik pracy translatora JODA w formie fragmentu programu

w języku Pascal, opisującego automat z rysunku 4.17.
const
{ CROSS-TRANSLATOR JODA 19.6.95 / 23:20:52}
{ AUTOMAT INNE URZADZENIA STEROWANE DWUSTANOWO}
{ wykaz stanow automatu }
iss0 = 0;
iss1 = 1;
164

isa0 = 2;
isa1 = 3;
isaa = 4;
isr0 = 5;
isr1 = 6;
isra = 7;
isod = 8;
isaod = 9;
type
stdescrtype = record
tpadr : word;
stout : array[0..0] of byte;
timechar : longint;
end;
const
{ tablice przejsc automatu }
iss0tp : array[0..13] of word =
(4,$0000,$0000,isod,$80A4,$8020,isaa,$80A5,$8000,
isa0,$00A5,$0001,iss1,iss0);
iss1tp : array[0..4] of word =
(1,$8000,$8000,isr1,iss1);
isa0tp : array[0..19] of word =
(6,$0004,$0004,isaod,$0080,$0080,isod,
$80A4,$8020,isaa,$8185,$8001,isaa,$20E4,$2000,
isa1,$0064,$0040,isr0,isa0);
isa1tp : array[0..19] of word =
(6,$0004,$0004,isaod,$0080,$0080,isod,
$80A4,$8020,isaa,$8185,$8100,isaa,$20E4,$0000,
isa0,$0064,$0040,isr1,isa1);
isaatp : array[0..10] of word =
(3,$0000,$0000,isod,$00C4,$0040,isra,$80E5,$8000,isa0,isaa);
isr1tp : array[0..19] of word =
(6,$0004,$0004,isaod,$0080,$0080,isod,
$80E4,$8060,isra,$81C5,$8140,isra,$00E5,$0001,
isa1,$20E4,$0040,isr0,isr1);
isr0tp : array[0..19] of word =
(6,$0004,$0004,isaod,$0080,$0080,isod,
$80E4,$8060,isra,$81C5,$8041,isra,$20E4,$2040,
isr1,$00E4,$0000,isa0,isr0);
isratp : array[0..13] of word =
(4,$0000,$0000,isod,$00C4,$0000,isaa,$20E5,$0040,
isr0,$20E5,$2041,isr1,isra);
isaodtp : array[0..10] of word =
(3,$8000,$8000,isod,$80E4,$0000,isa0,
$80E4,$0040,isr0,isaod);
isodtp : array[0..10] of word =
(3,$00A4,$0020,isaa,$00A5,$0000,isa0,$00A5,$0001,iss1,isod);
{ bloki opisu automatow : }
statedescr : array[0..9] of stdescrtype =
((tpadr:ofs(iss0tp);stout:($00);timechar:0),
(tpadr:ofs(iss1tp);stout:($01);timechar:2),
(tpadr:ofs(isa0tp);stout:($00);timechar:2),
(tpadr:ofs(isa1tp);stout:($01);timechar:2),
(tpadr:ofs(isaatp);stout:($00);timechar:15),
(tpadr:ofs(isr0tp);stout:($00);timechar:2),
(tpadr:ofs(isr1tp);stout:($00);timechar:2),
(tpadr:ofs(isratp);stout:($00);timechar:4),
(tpadr:ofs(isodtp);stout:($00);timechar:0),
165

(tpadr:ofs(isaodtp);stout:($00);timechar:10));

Czasy charakterystyczne stanów w różnych automatach wykorzystano zależnie od
potrzeb do definiowania:
 czasu trwania stanów przejściowych, na przykład przy przełączaniu między dwoma biegami
kompresorów reaktora;
 czasu opóźnienia reakcji na zmiany sygnałów kontrolnych pochodzących od urządzeń.
Automaty są obsługiwane przez program rezydentny GRES w procedurze obsługi
przerwań zegarowych, z okresem TOA=1s. Cykl obsługi polega na odczycie stanu sygnałów
wejściowych, przygotowaniu słowa wejściowego xt, wywołaniu procedury zmiany stanu
automatu działającej zgodnie z algorytmem iteracyjnym oraz przygotowaniu i wysłaniu słowa
wyjściowego yt. Każdy z wymienionych automatów sterujących został użyty co najmniej kilka
razy do realizacji sterowania binarnego różnych urządzeń dwustanowych. W trybach pracy
automatycznej o chwilach włączenia i wyłączenia urządzenia decyduje nadrzędna warstwa
sterowania, oddziałując na automat za pośrednictwem odpowiednich zmiennych wejściowych
str i str2. Przy ręcznym sterowaniu urządzeniem (z konsoli operatorskiej) program
monitorujący GMON przekazuje do rezydenta GRES odpowiednie polecenia również
zmieniające stany tych zmiennych wejściowych.
Uruchomiony na początku 1995 roku system automatyki komputerowej pracuje bez
zarzutów. Co więcej spotkał się on ze słowami uznania ze strony krajowych przedstawicieli
szwedzkiej firmy Scandiaconsult International AB, która opracowała technologię oczyszczania
ścieków dla Giżycka.
Doświadczenia z realizacji opisanego systemu automatyki oczyszczalni ścieków
potwierdzają przydatność opracowanej przez autora metodologii programowania sterowników
procesów binarnych. Zwłaszcza na etapie wdrażania i rozruchu systemu niejednokrotnie
pojawiała się konieczność modyfikacji pracy niektórych urządzeń. Zmiany takie mogły być,
dzięki przyjętemu sposobowi opisu automatów i strukturze oprogramowania, realizowane
na bieżąco. Modułowa struktura sprzętu i oprogramowania umożliwia także dalsze zmiany
związane chociażby z uruchomieniem w przyszłości drugiego reaktora biologicznego.
166

5. Podsumowanie
Niniejsza rozprawa jest poświęcona zagadnieniom programowania algorytmów

sterowania binarnego. Stosowane do tego metody są ściśle związane z konstrukcją
sterowników i sposobami opisu układów sterowania logicznego. Stąd też pierwszy rozdział
pracy zawiera zwięzły przegląd spotykanych konstrukcji sterowników od historycznie
pierwszych układów stykowo-przekaźnikowych, po najnowsze rozwiązania, oparte
na mikroprocesorach. Po prezentacji różnych sposobów opisu (algebraicznych, symbolicznych,
graficznych) zawarto również omówienie stosowanych metod programowania sterowników.
Dominują tu języki drabinkowe i wywodzące się z sieci Petriego. Znaczenia nabierają również
specjalizowane języki strukturalne. Obok przykładowych standardów programowania seryjnie
produkowanych sterowników (PL7-3, Step-5, OPUS, INTELSTER PC4K) wspomniano także
o poszukiwaniach nowych metod programowania. Te ostatnie są istotne zwłaszcza
w przypadku konieczności programowania nietypowych rozwiązań układów sterowania, które
nie mogą być zrealizowane przy użyciu standardowych sterowników.
Zasadniczym celem pracy było przedstawienie opracowanej przez autora metody
programowania algorytmów sterowania binarnego. Wykorzystuje ona założenie, że sterownik
binarny może być traktowany jako automat skończony o zdefiniowanych słowach:
wejściowym i wyjściowym, oraz o zbiorze funkcji przejść, określających możliwe przejścia
pomiędzy stanami tego automatu. Praca takiego automatu może być opisana grafem przejść,
tablicą przejść lub w formie algebraicznej. Sposoby te są dobrze znane i posługiwanie się nimi
nie sprawia większych trudności. W opracowanej metodzie JODA, do programowania
działania automatu zastosowano jako podstawowy algebraiczny zapis logicznych warunków
przejść między stanami.
Przyjęta definicja słowa wejściowego automatu dopuszcza, oprócz sygnałów
dwustanowych pochodzących z kontrolowanego obiektu, także inne zmienne logiczne. Ich
wartości mogą być określane w ramach tego samego automatu (np. flagi timerów, liczników)
lub pochodzić z innych automatów, obsługiwanych przez ten sam sterownik lub sterowniki
niezależne. Również definicja słowa wyjściowego automatu, obok zmiennych binarnych
oddziałujących bezpośrednio na obiekt, przewiduje stosowanie dodatkowych zmiennych
wyjściowych. Mogą nimi być na przykład flagi sygnalizujące innym układom sterowania różne
stany pracy danego automatu. Tym samym możliwa staje się realizacja rozproszonych
167

systemów sterowania logicznego, opartych na sterownikach zaprogramowanych zgodnie
z prezentowaną metodą.
Nie mniej przydatne mogą się okazać dopuszczalne definicją słowa wyjściowego
zmienne wielowartościowe. Można je wykorzystać na przykład do inicjowania timerów lub
liczników zdarzeń albo do wskazywania rodzaju dodatkowych działań jakie muszą być
wykonywane w różnych stanach pracy automatu. Stwarza to możliwości łączenia
ze sterowaniem binarnym algorytmów regulacji wielkości ciągłych lub innych operacji
wymaganych zadaniem sterowania. Działania te mogą być ponadto zróżnicowane w zależności
od stanu pracy obiektu.
Zwrócono również uwagę na możliwości implementacyjne metody. Przyjęty sposób
opisu automatu, polegający na odpowiednim zakodowaniu tablic wyjść i wyrażeń logicznych
warunkujących przejścia między stanami, umożliwia stosowanie metody przy różnych
platformach sprzętowych i programowych. Możliwość stosowania różnych typów
mikroprocesorów i języków programowania, tak symbolicznych jak i wysokopoziomowych,
świadczy o dużej elastyczności opracowanej metody.
Praca zawiera także uwagi na temat realizacji cyklu obsługi automatu przez sterownik
mikroprocesorowy. Wskazano przy tym na możliwość sterowania więcej niż jednym
automatem przez ten sam sterownik. Za podstawowy sposób obsługi automatu przyjmuje się
jej połączenie z tzw. przerwaniami zegarowymi. Podano w związku z tym warunki konieczne
poprawnej pracy sterownika. Wskazano również na możliwości i zasady wykorzystania
przerwań obiektowych do realizacji cyklu obsługi automatu. Prezentowana metoda ma także
możliwości autodiagnostyczne, polegające na nadzorowaniu kolejnych cykli obsługi automatu
i wykrywaniu błędów w jego pracy.
Porównanie metody JODA z systemami programowania standardowych sterowników
jest utrudnione, ponieważ ich dziedziny zastosowań są rozłączne. Prezentowana metoda może
być z powodzeniem stosowana przy programowaniu nietypowych konstrukcji układów
sterowania, takich jak mikrosterowniki wbudowane w urządzania lub systemy wykonywane
na jednostkowe zamówienie. W przypadku takich układów sterowania projektant stoi z reguły
przed koniecznością uwzględnienia wielu ograniczeń (ekonomicznych, przestrzennych, itp.)
narzuconych przez zleceniodawcę. Seryjnie produkowane sterowniki przemysłowe nie zdają
wtedy egzaminu i trzeba stosować specjalizowane systemy mikroprocesorowe. Tym samym
traci się możliwość korzystania z gotowych systemów programowania sterowników. Pozostają
wtedy do wykorzystania klasyczne języki programowania mikroprocesorów. Zapis algorytmu
168

sterowania binarnego w dowolnym z języków polega na użyciu sekwencji sprawdzeń
warunków logicznych i skoków. Jest on zwykle obszerny i trudny w modyfikacji.
Użycie metody JODA znacznie upraszcza programowanie i modyfikację algorytmu
sterowania. Jest tylko jedna i to bardzo prosta w budowie procedura wartościująca warunki
logiczne, które warunkują przejścia między stanami. Zmieniają się jedynie struktury danych,
na których ona operuje. Dlatego też modyfikacje algorytmu sterowania mogą być ograniczone
do zmian zakodowanych tablic przejść i wyjść, co przyśpiesza i upraszcza proces generacji
nowych wersji oprogramowania. Co więcej, jak to zasugerowano w punkcie 3.3.4 pracy,
możliwe jest dokonanie takiej zmiany w trybie on-line.
Skuteczne stosowanie metody wymaga użycia odpowiedniego oprogramowania
wspomagającego. Oprogramowanie takie, na razie w formie translatora języka opisu
automatów JODA, zostało opracowane przez autora. Translator ten przekształca opis automatu
sterującego z czytelnej i łatwej w modyfikacji postaci tekstowej na struktury danych, które
mogą być włączone do właściwego programu sterownika. Planowane jest dalsze rozszerzanie
oprogramowania wspomagającego stosowanie metody JODA. Kierunki rozwoju przedstawia
punkt 3.3.4.
Opracowany język opisu automatów JODA charakteryzuje się prostą składnią, która
umożliwia między innymi korzystanie z nazw symbolicznych stanów i zmiennych logicznych
oraz komentarzy. Opis automatu w języku JODA jest czytelny i łatwy do opanowania.
Składnia wyrażeń logicznych języka JODA zezwala na pisanie dowolnych konstrukcji
wykorzystujących podstawowe operatory logiczne i nawiasy oraz stosowanie pewnych
uproszczeń w notacji. Dzięki temu możliwy jest zapis nawet bardzo złożonych warunków
logicznych. Do ciekawszych możliwości translatora należy też zaliczyć zastosowanie w nim,
opracowanych przez autora, algorytmów przetwarzania i optymalizacji wyrażeń logicznych
na poziomie symbolicznym oraz mechanizm translacji odwrotnej.
Projektant układu sterowania ma możliwość wyboru docelowego języka
programowania sterownika, w którego składni mają być wygenerowane struktury danych
opisujące automat. Oprócz typowych asemblerów AZ80 i A8051 translator umożliwia
wybranie metaasemblerów (C16, C32), co dodatkowo rozszerza dostępne platformy sprzętowe
metody na wiele popularnych mikroprocesorów ośmio- i szesnastobitowych. Ponadto
translator może wygenerować struktury danych zgodne ze składnią języków wysokiego
poziomu jakimi są Pascal i C, co jeszcze bardziej poszerza zakres możliwych zastosowań
metody.
169

Stosowanie translatora zmniejsza ryzyko popełnienia typowych błędów kodowania
popełnianych przez programistów. Rozbudowanie środowiska uruchomieniowego języka
JODA zwiększy jeszcze bardziej skuteczność pracy projektanta systemu.
Zaletą metody jest też możliwość powiązania opisu automatu ze strukturą systemu
mikroprocesorowego. Słowa wejściowe i wyjściowe automatu mogą być np. zdefiniowane tak,
aby odpowiadały wprost portom wejścia/wyjścia sterownika.
Skuteczność opracowanej metody została potwierdzona w praktyce przy realizacji
kilku bardzo zróżnicowanych zadań sterowania. Pierwszym z nich był system automatyki
doświadczalnej linii do produkcji kazeiny, wykonany na zamówienie Instytutu Maszyn
Spożywczych w Warszawie. Od strony sprzętowej był on oparty na dwóch systemach
modułowych z mikroprocesorami Z80. Zadanie sterowania składało się z szeregu mniejszych
podzadań, dotyczących zarówno regulacji wielkości ciągłych jak i sterowania logicznego.
Użycie metody JODA umożliwiło, między innymi, łatwe połączenie zróżnicowanych
algorytmów regulacji temperatury z różnymi stanami pracy pasteryzatorów, a także
przyśpieszyło proces generacji kolejnych wersji oprogramowania.
Kolejnym zastosowaniem metody jest mikroprocesorowy sterownik formatyzerki dla
Zakładów Przemysłu Sklejki w Białymstoku, który zastąpił wyeksploatowany układ
półprzewodnikowej logiki sterującej. Sterownik został oprogramowany w asemblerze
mikroprocesora Z80. Dzięki użyciu metody JODA możliwe było proste zsynchronizowanie
pracy czterech automatów, na jakie podzielono całe urządzenie. Wykorzystano do tego system
zmiennych flagowych przewidzianych definicjami słowa wejściowego i wyjściowego.
Również sprawne oprogramowanie stosunkowo dużego automatu, jakim jest wózek
transportowy formatyzerki, było możliwe dzięki użyciu translatora JODA. Formatyzerka
z nowym sterownikiem pracuje już od przeszło pięciu lat ku zadowoleniu zleceniodawcy.
Przykładem użycia metody do oprogramowania zadań innego rodzaju jest sumator
hematologiczny. Jest to prosty przyrząd wspomagający pracę w laboratorium analitycznym.
Przed mikroprocesorem, którym w tym przypadku jest mikrokomputer rodziny MCS51, stoją
zadania niezwiązane ze sterowaniem w czasie rzeczywistym. Ponieważ jednak algorytm pracy
tego urządzenia można przedstawić w formie grafu przejść automatu, postanowiono
zastosować metodę JODA. Dzięki temu uniknięto złożonych fragmentów programu
w asemblerze 8051, odpowiedzialnych za część decyzyjną algorytmu, a kod programu uległ
zmniejszeniu, pozwalając zastosować prostszą i tańszą wersję mikroprocesora, co było jednym
z wymagań zleceniodawcy. W przypadku sumatora wykorzystano również możliwość
170

przypisania poszczególnym stanom pracy dodatkowych działań, które były niezbędne
do pełnej realizacji postawionych zadań. Urządzenie zostało wdrożone do produkcji seryjnej
przez firmę HEXAN Sp. z o.o. w Białymstoku i sprzedaje się bardzo dobrze.
Ostatnim dużym zastosowaniem metody JODA jest system automatyki komunalnej
oczyszczalni ścieków w Giżycku. System ten wykonany na bazie mikrokomputera 486DX2-66
został oprogramowany w Pascalu. Metodę JODA zastosowano do sterowania dwustanowymi
urządzeniami wykonawczymi (napędy, pompy, dmuchawy, zasuwy sterowane). Na potrzeby
automatyki wszystkie urządzenia podzielono na kilka grup, w zależności od sposobu ich pracy.
Każda z tych grup ma swój własny graf przejść. Grafy te zostały opisane w języku JODA,
a następnie przetworzone przez translator tego języka na stablicowane struktury danych
o składni zgodnej ze składnią Pascala. W fazie uruchamiania systemu kilkakrotnie zachodziła
konieczność modyfikacji tych grafów, co za każdym razem odbywało się niemal
na poczekaniu, dzięki użyciu translatora JODA. System pracuje od maja 1995 bez zarzutu.
Zrealizowane przy użyciu metody JODA układy sterowania dowodzą jej skuteczności
w różnorodnych zastosowaniach. Metoda okazała się przydatna zarówno do kontroli pracy
urządzenia elektronicznego, jak i zespołów napędowych. Opisanie algorytmu sterowania np.
silnikiem dwubiegowym w formie grafu przejść automatu i jego programowa implementacja
nie stwarzają większych problemów. Można przy tym z łatwością uwzględnić dodatkowe
zależności czasowe i sygnały logiczne pochodzące od układów zabezpieczających taki silnik.
Uwzględniając opisane zalety metody JODA, możliwości jej użycia w nietypowych
aplikacjach systemów sterowania oraz pozytywne doświadczenia płynące z praktycznych jej
zastosowań, należy stwierdzić słuszność postawionej we Wstępie tezy, że: opracowana
metodologia postępowania przy automatyzowaniu binarnych, a także binarno-ciągłych
procesów przemysłowych pozwala uzyskiwać sprawnie działające i łatwo modyfikowalne
systemy automatyki „na miarę potrzeb”, szczególnie tam gdzie użycie standardowych
rozwiązań konstrukcyjnych i programowych oferowanych przez producentów sterowników
przemysłowych jest niemożliwe.
171

Spis literatury
1. Adamkiewicz H.: Sterowniki programowalne rodziny SIMATIC S5: Sterownik S5-90U.

Elektronika Praktyczna 8/1994.
5. Adamkiewicz H.: Sterowniki programowalne rodziny SIMATIC S5: Oprogramowanie
STEP-5. Elektronika Praktyczna 12/1994.
6. Adamkiewicz H.: Sterowniki programowalne rodziny SIMATIC S7: Micro PLC S7-200
i S7-300. Elektronika Praktyczna 1/1995.
7. Aho A.V., Sethi R., Ullman J.D.: Compilers - Principles, Techniques and Tools. Addison-
Wesley 1986.
8. Aho A.V., Hopcroft J.E., Ullman J.D.: Projektowanie i analiza algorytmów
komputerowych. PWN, Warszawa 1983.
9. Banaszak Z., Drzazga A., Kuś J.: Metody interakcyjnego modelowania i programowania
procesów dyskretnych. Instytut Cybernetyki Technicznej Politechniki Wrocławskiej,
Wrocław 1993.
10.Banaszak Z., Muszyński W.: Systemy elastycznej automatyzacji dyskretnych procesów
produkcyjnych. Instytut Cybernetyki Technicznej Politechniki Wrocławskiej, Wrocław
1991.
11.Benedetto M.D., Saldanha A., Sangiovanni-Vincentelli A.: Strong Model Matching for
Finite State Machines. Proceedings of 3rd European Control Conference, Rzym, Włochy
1995, str.2027-2034.
12.Białasiewicz J., Aderek A., Maliszewski K.: Oprogramowanie podstawowe
komputerowych systemów sterowania. WNT, Warszawa 1979.
13.Boroń Wł.: Sterowniki programowalne wczoraj, dzisiaj i jutro. PAK29 1/1992.
14.Boroń Wł.: Nowy polski ministerownik programowalny STERISS-100. PAK 11/1992.
15.Boroń Wł.: Przykłady zastosowań ministerownika programowalnego STERISS-100. PAK
2/1994.
16.Bourcerie M., Mares M., Morel J.Y.: An Algebraic Structure for Coloured Petri Nets.
Proceedings of 3rd European Control Conference, Rzym, Włochy 1995.
17.Čapkovič F.: An Aproach to Computer-Aided Control System Design for Discrete Event
Dynamic Systems. Proceedings of 3rd European Control Conference, Rzym, Włochy 1995.
18.Cassell D.A.: Microcomputers and Modern Control Engineering. Prentice-Hall, Reston
1983.
19.Chmiel M., Hrynkiewicz E.: Sterowniki programowalne. PAK 5/1994.
20.Ciwiński J.: Programowalne sterowniki przemysłowe serii SLC-500. PAK 4/1993.
21.Dersin P., Florine J.: Firmware Transitional Logic for On-line Monitoring and Control.
Proceedings of the 25th IEEE Conference on Decision & Control, Ateny, Grecja 1986,
str.1102-1107.
22.Ditch W.: Emulacja PLC przy pomocy mikrosterowników PIC. Elektronik Elektor 1/96
str.25-30, 2/96 str.44-51.
29
„Pomiary Automatyka Kontrola”
172

23.Drusinsky D.: Rozszerzone diagramy stanów i systemy reagujące. Software 6/1995.
24.Dubois E., Alla H.: Hybrid Petri Nets with a Stochastic Discrete Part. Proceedings of the
Second European Control Conference, Groningen, Holandia. 1993, str.144-149.
25.Gander J.G., Liechti H.U.: Real-time Process Control Based on a High Level State
Language. Proceedings of the IFAC/IFIP Workshop on Real Time Programming 1980,
Leibnitz, Austria, Pergamon Press 1980, str.91-94.
26.Glass R.L.: Real-time Software. Prentice-Hall 1983.
27.Gomółka W.: Realizacja algorytmów sterowania sekwencyjnego za pomocą sieci działań
GRAFCET. PAK 7/1990, str.136-141.
28.Gomółka W.: Wykorzystanie sieci GRAFCET w automatyzacji procesów dyskretnych
i robotyce. VI Krajowa Konferencja Automatyzacji Dyskretnych Procesów Przemysłowych
1988 - Zeszyty Naukowe Politechniki Śląskiej, Automatyka Z. 94, str.89-103.
29.Grandek K., Wrzuszczak J.: Mikrosterowniki programowalne PLC charakterystyka
możliwości zastosowań w przemyśle. VIII Konferencja PNEUMA’94 Sterowanie i pomiary
w przemyśle. Prace Naukowe Instytutu techniki Cieplnej i Mechaniki Płynów Politechniki
Wrocławskiej Z.47, Wrocław 1994.
30.Gries D.: Konstrukcja translatorów dla maszyn cyfrowych. PWN 1984.
31.Grodzki L.: Język Opisu Dyskretnych Automatów (translator JODA). Opracowanie
wewnętrzne Katedry Automatyki i Elektroniki WE PB, Białystok 1991.
32.Grodzki L.: Metoda oprogramowania sterowników binarno-ciągłych procesów
przemysłowych na poziomie asemblera. VIII Krajowa Konferencja Automatyzacji
Dyskretnych Procesów Przemysłowych 1992 - Zeszyty Naukowe Politechniki Śląskiej,
Automatyka Z.109.
33.Grodzki L.: Możliwości stosowania mikrokomputerów jednoukładowych rodziny MCS51
jako sterowników procesów binarno-ciągłych. Zeszyty Naukowe Politechniki Białostockiej
1994, Elektryka Z.13.
34.Grodzki L.: Możliwości stosowania mikrokomputerów ośmiobitowych w systemach czasu
rzeczywistego na przykładzie mikrokomputera Amstrad CPC6128. Zeszyty Naukowe
Politechniki Białostockiej 1989, Elektryka Z.9.
35.Grodzki L., Kierus K.: Mikroprocesorowy sterownik formatyzerki. Sprawozdanie
z realizacji pracy umownej dla Zakładów Produkcji Sklejek w Białymstoku (49/90-
RNN/U/187/90), Białystok 1991.
36.Grodzki L.: Opis struktury i instrukcja obsługi systemu automatyki Oczyszczalni Ścieków
w Giżycku. Opracowanie wewnętrzne Katedry Automatyki i Elektroniki WE PB, Białystok
1995.
37.Grodzki L.: Porównanie różnych metod wartościowania funkcji logicznych
w mikroprocesorowych sterownikach PLC. Zeszyty Naukowe Politechniki Białostockiej
1994, Elektryka Z.13.
38.Grodzki L.: System automatyki komunalnej oczyszczalni ścieków. V Krajowa Konferencja
Automatyzacja i Eksploatacja Systemów Sterowania. Akademia Marynarki Wojennej,
Gdynia 1995.
39.Grodzki L.: Sumator hematologiczny - projekt konstrukcji i oprogramowanie sterujące
przyrządem. Opracowanie wewnętrzne Katedry Automatyki i Elektroniki WE PB, Białystok
1995.
40.Grodzki L.: Zastosowanie translatora JODA do programowania algorytmów sterowania
binarnego. Referat zgłoszony na X Krajową Konferencję Automatyzacji Dyskretnych
Procesów Przemysłowych 1996 - Politechnika Śląska.
41.Haase V.H.: Real Time Programming 1980. Proceedings of the IFAC/IFIP Workshop,
Leibnitz, Austria, Pergamon Press 1980
173

42.Hopkins A.L., Walker G.R., Quagliata L.J.: The state transition diagram as a sequential
control language. Proceedings of the 25th IEEE Conference on Decision & Control, Ateny,
Grecja 1986, str.1096-1101.
43.Hvelpund H.: Modelling System Specifications on a Finite State Machine. Proceedings of
the 3rd IFAC/IFIP Symposium Computer Aided Design in Control and Engineering
Systems - Advanced Tools for Modern Technology, Lyngby, Dania, Pergamon Press 1985,
str.127-132.
44.Iglewski M., Madey J., Matwin S.: Pascal. WNT, Warszawa 1984.
45.INTELSTER PC4K. Opis techniczny systemu. MERA ZAP.
46.INTELSTER PC4K. Środki w procesie programowania. MERA ZAP.
47.Internationale Standard IEC 1131-3. Programmable controllers - part 3: Programming
languages. IEC Genewa 1993.
48.Jabłoński R.: Programowalne sterowniki przemysłowe serii 90-30 firmy GE-Fanuc
Automation. PAK 6/1994.
49.Jacek M.: ESTER - graficzny edytor algorytmów sterowania. PAK 7/1992, str.163-165.
50.Johnson C.D.: Microprocessor-based Process Control. Prentice-Hall, Englewood Cliffs
1984.
51.Jörns C., Litz L.: Hybrid Modelling with Petri Nets for the Verification of Logic Control
Algorithms. Proceedings of 3rd European Control Conference, Rzym, Włochy 1995,
str.2035-2040.
52.Kulesza W.: Systemy widmowej analizy danych cyfrowych. WKŁ, Warszawa 1984.
53.Leszczyński J., Grodzki L., Kierus K.: Podstawowe zespoły układów pomiarowych
i sterowania cz.I i II; System automatyzacji linii uzysku białka - instalacja i uruchomienie
systemu - sprawozdania z realizacji pracy umownej dla Instytutu Maszyn Spożywczych
(50/89-RNN/U/170/89), Białystok 1989,1990.
54.Leszczyński J., Grodzki L.: Oprogramowanie systemu sterowania doświadczalną linią
produkcji kazeiny. Materiały XI Krajowej Konferencji Automatyki, Białystok 1991.
55.Lewis P.M., Rosenkrantz D.J., Stearns R.E.: Compiler Design Theory. Addison-Wesley,
London 1976.
56.Ludewig J.: Process Control Software Specification in PCSL. Proceedings of the
IFAC/IFIP Workshop on Real Time Programming 1980. Leibnitz, Austria, Pergamon Press
1980, str.103-109.
57.Лазарев В.Г., Пийль Е.И., Туруга Е.Н.: Построение программируемых управляющих
устройств. Энергоатомиздат, Москва 1984.
58.Łuba T., Markowski M.A., Zbierzchowski B.: Komputerowe projektowanie układów
cyfrowych w strukturach PLD. WKiŁ, Warszawa 1993.
59.Łuba T., Zbierzchowski B.: Modele funkcji boolowskich w syntezie układów
kombinacyjnych z pamięciami ROM i matrycami PLA. Zeszyty Naukowe Politechniki
Warszawskiej Instytut Telekomunikacji Z.127, Warszawa 1986.
60.Majewski W., Łuba T., Jasiński K., Zbierzchowski B.: Programowalne moduły logiczne
w syntezie układów cyfrowych. WKiŁ, Warszawa 1992.
61.Michalski A.: Oprogramowanie sterownika przemysłowego STERISS-2. PAK 6/1993.
str.148-151.
62.Mikulczyński T., Samsonowicz Z.: MTS - metoda syntezy sekwencyjnych układów
sterowania zautomatyzowanymi procesami technologicznymi. PAK 10/1993, str.241-243.
63.Mikulczyński T., Samsonowicz Z.: Zasady realizacji pamięci sekwencyjnych układów
sterowania projektowanych metodą MTS. PAK 11/1993, str.271-274.
64.Mikulczyński T., Samsonowicz Z.: O syntezie sekwencyjnych układów sterowania ZPT.
PAK 10/1994, str.229-230.
174

65.Mikulczyński T., Samsonowicz Z.: Analiza wybranych metod modelowania
i programowania dyskretnych procesów produkcyjnych. PAK 3/1995, str.63-66.
66.Mikulczyński T., Samsonowicz Z., Naplocha K.: Synteza sekwencyjnych układów
sterowania zautomatyzowanych procesów technologicznych. PAK 7/1994, str.164-166.
67.Mikulczyński T., Samsonowicz Z., Naplocha K.: Zastosowanie metody Grafpol
do programowania sterowników PLC. VIII Konferencja PNEUMA’94 Sterowanie
i pomiary w przemyśle. Prace Naukowe Instytutu techniki Cieplnej i Mechaniki Płynów
Politechniki Wrocławskiej Z.47, Wrocław 1994, str.109-114.
68.Mikulczyński T., Samsonowicz Z., Naplocha K.: Zastosowanie metody MTS
do programowania sterowników PLC. VIII Konferencja PNEUMA’94 Sterowanie
i pomiary w przemyśle. Prace Naukowe Instytutu techniki Cieplnej i Mechaniki Płynów
Politechniki Wrocławskiej Z.47, Wrocław 1994, str.115-119
69.Misiurewicz P.: Zagadnienia projektowania cyfrowych układów sterowania binarnego.
VIII Krajowa Konferencja Automatyki 1980, Szczecin 1980, t.1, str.664-670.
70.Nakamura Y., Abe S., Takeda S.: Design and Verification of Sequence Control Systems
with Timed Petri Nets. Proceedings of the 3rd IFAC/IFIP Symposium Computer Aided
Design in Control and Engineering Systems - Advanced Tools for Modern Technology,
Lyngby, Dania, Pergamon Press 1985, str.277-282.
71.Niederliński A.: Systemy komputerowe automatyki przemysłowej.WNT, Warszawa 1984.
72.Niederliński A. Zastosowanie komputerów do sterowania. VIII Krajowa Konferencja
Automatyki 1980, Szczecin 1980, t.3, str.95-104.
73.Orłowski H.: Komputerowe układy automatyki. WNT, Warszawa 1987.
74.Piaskowiecki E., Napierała J., Żebro M.: Panelowy sterownik sekwencyjny STERISS-110.
PAK 3/1992.
75.Plaza R.A., Wróbel E.J.: Systemy czasu rzeczywistego. WNT, Warszawa 1988.
76.Polska Norma PN-92 E-01200/07 Symbole graficzne stosowane w schematach. Aparatura
łączeniowa, sterownicza i zabezpieczeniowa.
77.Polska Norma PN-75 E-01226 Przetwarzanie danych. Symbole graficzne.
78.Polska Norma PN-84 E-01236 Elementy techniki cyfrowej. Symbole graficzne.
79.Puchałka T.: Teoria systemów przełączających. PWN, Warszawa 1976.
80.Puente J.A., Alonso A., León G., Dueńas J.C.: Distributed Simulation of Discrete Event
Systems Modelled by Timed Petri Nets. Proceedings of the Second European Control
Conference, Groningen, Holandia. 1993, str.139-143.
81.SIEMENS SIMATIC S5 - STEP5-115U expert kurs. INTEX Sp. z o.o. Gliwice.
82.SIEMENS SIMATIC S5 - STEP5 Lista instrukcji i rozkazów. INTEX Sp. z o.o. Gliwice.
83.SIEMENS SIMATIC S5 - STEP5 Podręcznik użytkownika. INTEX Sp. z o.o. Gliwice.
84.Siwiński J.: Układy przełączające w automatyce. WNT, Warszawa 1980.
85.Срибнер Л.А.: Программируемые устройства автоматики. Техника Киев 1982.
86.Sterowniki S9000 i LCS620. Honeywell Sp. z o.o., Warszawa.
87.Stoiński D., Dyja H., Fengler W.F.:Using Petri-nets for Programming of PLC SIMATIC S5.
The Second International Symposium on Methods and Models in Automation and Robotics
MMAR’95, Międzyzdroje 1995, str.851-856.
88.Strzelecki J.: Uniwersalne systemy sterowania maszyn i urządzeń. WKiŁ 1982.
89.Ślifirska E.: Pewne aspekty wyboru realizacji sterowania przez programowalne sterowniki
logiczne. VIII Konferencja PNEUMA’94 Sterowanie i pomiary w przemyśle. Prace
Naukowe Instytutu techniki Cieplnej i Mechaniki Płynów Politechniki Wrocławskiej Z.47,
Wrocław 1994, str.183-189.
90.Szenajch W.: Napęd i sterowanie pneumatyczne. WNT, Warszawa 1992.
91.Traczyk W.: Układy cyfrowe. Podstawy teoretyczne i metody syntezy. WNT, Warszawa
1982.
175

92.Trybus L., Świder Z., Śnieżek M.: Sterowniki wielofunkcyjne PSW-8 wersji 3.0. PAK
3/1995, str.60-63
93.Tutaj R.: Oprogramowanie sterowników przemysłowych serii SLC-500 firmy Allen-
Bradley. PAK 5/1993, str.122-125
94.Urbanowicz H.: Napęd elektryczny maszyn roboczych. WNT, Warszawa 1979.
95.Warnock I.G.:, Programmable Controllers operation and application. Prentice Hall 1988.
96.Willson R.G., Krogh B.H.: Petri Net Tools for the Specification and Analysis of Discrete
Controllers. IEEE Transactions on Software Engineering vol.16 no.1 1990, str.39-50.
97.Wprowadzenie do obsługi i programowania sterowników serii 90-30 firmy GE FANUC.
AB-MICRO s.c., Warszawa 1994.
98.Wrzuszczak J., Rojek R.: Wybrane aspekty projektowania zintegrowanych
programowalnych systemów sterowania w oparciu o sterowniki logiczne PLC. VIII
Konferencja PNEUMA’94 Sterowanie i pomiary w przemyśle. Prace Naukowe Instytutu
techniki Cieplnej i Mechaniki Płynów Politechniki Wrocławskiej Z.47, Wrocław 1994,
str.239-243.
99.Young S.J.: Real Time Languages: Design and Development. Ellis Horwood Limited 1982.
100.Zakrevskij A.: CAD of Discrete Devices Implementing Parallel Logical Control
Algorithms. The Second International Symposium on Methods and Models in Automation
and Robotics MMAR’95, Międzyzdroje, str.803-808.
101.Znojek W.: Nowa generacja sterowników programowalnych serii PCD firmy SAIA AG.
PAK 6/1995.
102.Żebro M., Piaskowiecki E.: Kryteria wyboru typu przemysłowego sterownika
programowalnego związane z obiektem sterowania. PAK 2/1993.
103.Żebro M.: Możliwości aplikacyjne sterownika STERISS-100. PAK 4/1994.
176

Dodatki
177

Dodatek 1 - Charakterystyczne parametry wybranych sterowników
programowalnych
W niniejszym dodatku zawarto tabelaryczne zestawienie ważniejszych parametrów

niektórych sterowników programowalnych na podstawie [1, 2, 3, 4, 6, 14, 15, 20, 29, 48, 74,
83, 86, 92, 97, 101, 103]. Niestety, nie we wszystkich przypadkach możliwe było zdobycie
kompletu informacji przewidzianych tabelą.
178

Tabela D.1 cz.I
Porównanie charakterystycznych parametrów wybranych sterowników
Typ sterownika SUCOS KMC1 TSX17-10 STERISS-100 STERISS-110 F-PLC
Producent Klöckner-Moeller SAIA AG Telemecanique ISS-Katowice ISS-Katowice PIAP-Warszawa
Jednostka centr. 8031 M6500 8031 80C537
pamięć programu 3,6kB RAM/EPROM 4kB RAM/EPROM 4-8kB RAM/EPROM 60kB RAM, 32kB RAM/EPROM na 1000 16kB
EPROM/EEPROM instrukcji EPROM/EEPROM
Pamięć danych 4k słów
Realizowane podstawowe operacje logiczne (AND, OR, NOT)
podstawowe operacje logiczne i arytmetyczne operacje arytmetyczne,
funkcje bitowe i ładowanie, przesyłąnie, porównywanie,
biblioteka procedur regulacji (P,PI,PID) logiczne,
bajtowe operacje arytmetyczne (+,-,*,/), wyrażenia nawiasowe
Języki STL, LAD, CSF LAD PL7-1 (STL,Grafcet) system OPUS (LAD, Grafcet) system DILAN
programowania asembler, C, RT-Basic język strukturalny
Czas wykonania
5ms 3ms 5ms 2ms 2ms
1000 instrukcji
Dostępne flagi 1024 (w tym 256 128-liczba wyjść 256
576 256
wewnętrzne z podtrzymaniem bat.) binarnych 32 wielowart. semafory
Człony czasowe 32: 0,1-6553,5s 512: 0-6553,5s 32 8: 0.1-99.9s 32: 16-bitowe
Liczniki zdarzeń 32: 16-bitowe 512: 16-bitowe 15 6 8: 0-999
Wej. binarne 16x24VDC z optoizolacją 24x24VDC 16x24VDC optoiz. łącznie łącznie
Wyj. binarne 8x2A/250VAC 6x5A/250VAC 16x2A/24VDC 16x24VDC/8x250VAC do 64 do 80
Wej. analogowe 4: 0-10VDC, 8b - moduł specjalny 8: 0-10VDC, 10b - łącznie
Wyj. analogowe 1: 0-10VDC/2mA, 8b - moduł specjalny 2: 0-10V 1:0-20mA - do 32we/16wy
Łącze komunik. RS485 RS232 UNITELWAY RS232,RS485 RS232 RS232/RS422/BITBUS
Możliwości dodatkowe moduły: moduły we/wy
rozbudowy 32 we binarne binarnych i
do 3 modułów o wej. i 3x8 wejść binarnych blok 40 we/wy dodatkowe
32 wy binarne analogowych o różnych
wyj. jak moduł podst. 3x6 wyjść binarnych moduły po 8we/6wy 64 we/wy binarne
32 we/wy binarne charakterystykach
16 we analogowych napięciowo-prądowych
Ciężar 2,5kg 1,5kg 1,8kg
Gabaryty 200x125x120 408x355x97
179

Tabela D.1, cz.II
Typ sterownika SIMATIC S5-90U SIMATIC S5-95U SIMATIC S5-100U SIAMTIC S5-115U
Producent Siemens Siemens Siemens Siemens
Jednostka centr. CPU103, koprocesor FPU CPU994
pamięć programu 4kBRAM/EPROM/EEPROM 16kB RAM/EPROM 20kBRAM/EPROM/EEPROM 96kBRAM/EPROM/EEPROM
Realizowane
logiczne AND,OR,NOT, operacje logiczne i arytmetyczne, biblioteka procedur arytmetyki całkowitoliczbowej i
funkcje bitowe i
arytmet. + i -, porównania zmiennoprzecinkowej 32b, konwersje, itd.
bajtowe
Języki Step-5
programowania (STL, LAD, CSF)
Czas wykonania
2ms 2ms 0.8ms 0.8ms
1000 instrukcji
Dostępne flagi 1024 (w tym 512 2048 (w tym 1024
2048 (w tym 512 z podtrzymaniem bat.)
wewnętrzne z podtrzymaniem bat.) z podtrzymaniem bat.)
Człony czasowe 32: 0.01-9990s 128: 0.01-9990s
Liczniki zdarzeń 32: 0-999 128: 0-999
Wej. binarne 10x24VDC z optoiz. 16x24VDC z optoiz. łącznie do łącznie do
Wyj. binarne 6 przekaźników 16x24VDC z optoiz. 448 4096
Wej. analogowe - 8: 0-10VDC 11b łącznie do łącznie do
Wyj. analogowe - 1: 0..20mA 11b 32 256
Łącze komunik. V24/TTY20mA/Sinec L1 V24/TTY20mA/Sinec L1 + Sinec L2
Możliwości do 6 modułów obiektowych do 32 modułów ob.
rozbudowy rodziny S5-100U, łącznie: rodziny S5-100U
do 208 we/wy binarnych łącznie do: różne moduły obiektowe różne moduły obiektowe
do 16 we/wy analogowych 480 we/wy binarnych
do 13 liczników zewn. 41 we/wy analog.
66 liczników zewn.
Ciężar
Gabaryty
180

Tabela D.1, cz.III
Typ sterownika SIMATIC S7-200 SIMATIC S7-200 SIMATIC S7-300 SIMATIC S7-300 SIMATIC S7-300
Producent Siemens Siemens Siemens Siemens Siemens
Jednostka centr. PLC212 PLC214 S7-311 S7-312 IFM S7-314
pamięć programu 1kB RAM/EEPROM 4kB RAM/EEPROM
Pamięć danych 512 słów RAM danych 2048 słów RAM danych
Realizowane
funkcje bitowe i operacje logiczne i arytmetyczne, biblioteka procedur arytmetyki całkowitoliczbowej i zmiennoprzecinkowej 32b, konwersje, itd.
bajtowe
Języki Step-7 (zgodny z IEC1131-3)
programowania (LAD, STL, CSF, SCL, Graph)
Czas wykonania
1.3ms 0.8ms 0.6ms 0.6ms 0.3ms
1000 instrukcji
Dostępne flagi
128 256 1024 1024 2048
wewnętrzne
Człony czasowe 64 128 64 128
Liczniki zdarzeń 64 128 32 64
Wej. binarne 8 14 łącznie do łącznie do
Wyj. binarne 6 10 + 2 impulsowe 128 512
Wej. analogowe łącznie do łącznie do
Wyj. analogowe 32 64
Łącze komunik. RS485 RS485, Sinec L2 - Profibus
Możliwości dodatkowe moduły do 64 konstrukcja modułowa, bogata rodzina modułów możliwość dołączenia 4
dodatkowe moduły do 30
rozbudowy we/wy binarnych peryferyjnych, możliwość dołączenia 1 kasety na 8 kaset na 32 moduły z
we/wy binarnych
dodatkowe 8kB EPROM modułów bogatej rodziny peryferii
Ciężar
Gabaryty 160x80x62
181

Tabela D.1, cz.III
Typ sterownika LCS620-12 LCS620-16 LCS620-36 PCD2 PCD4 PCD2
Producent Honeywell Honeywell Honeywell SAIA AG SAIA AG SAIA AG
Jednostka centr. dwuprocesorowa dwuprocesorowa dwuprocesorowa Motorola 68340 Motorola 68000 Motorola 68000
pamięć programu 2k słów 4k słów 8k słów 152kB RAM 428kB RAM 1024kB RAM
Realizowane podstawowe operacje logiczne (AND, OR, NOT)
funkcje bitowe i ładowanie, przesyłanie, porównywanie, operacje logiczne i arytmetyczne, arytmetyka zmiennoprzecinkowa,
bajtowe operacje arytmetyczne zmiennoprzecinkowe (+,-,*,/), wieloprocesorowość, komunikacja w sieci, obróbka tekstów
wyrażenia nawiasowe
Języki STL, LAD, CSF LAD PL7-1 (STL,Grafcet) oprogramowanie narzędziowe zgodne z IEC 1131-3 pod MSDOS i
programowania Windows (schematy funkcyjne, LAD, GRAFTEC, BLOCTEC)
Czas wykonania
2,5ms 2,5ms 2,5ms
1000 instrukcji
Dostępne flagi 1024/256
576 256 8192 8192 8192
wewnętrzne z podtrzymaniem
Człony czasowe 32: 0,1-6553,5s 512: 0-6553,5s 32 łącznie łącznie łącznie
Liczniki zdarzeń 32: 16-bitowe 512: 16-bitowe 15 1600 1600 1600
Wej. binarne 16x24VDC z optoizolacją 24x24VDC
Wyj. binarne 8x2A/250VAC 6x5A/250VAC 16x2A/24VDC łącznie łącznie łącznie
Wej. analogowe 4: 0-10VDC, 8b - moduł specjalny do 128 do 512 do 5120
Wyj. analogowe 1: 0-10VDC/2mA, 8b - moduł specjalny
Łącze komunik. RS485 RS232 UNITELWAY dostępne: RS,MODBUS,Ethernet,PROFIBUS,SAIA-LANx,S-BUS
Możliwości do 3 modułów o wej. i 3x8 wejść binarnych blok 40 we/wy
rozbudowy wyj. jak moduł podst. 3x6 wyjść binarnych moduły po 8we/6wy
Ciężar 2,5kg 1,5kg 1,8kg
Gabaryty obudowa modułowa obudowa modułowa kaseta modułowa 19”
„flat” „compact”
182

Tabela D.1, cz.V
Typ sterownika 90-30-311 90-30-331 90-30-341 90-20-211 90-70-731/732 90-70-771/772
Producent GE Fanuc GE Fanuc GE Fanuc GE Fanuc GE Fanuc GE Fanuc
Jednostka centr. 80188 80188+proc.bin.+FPU 80188+proc.binarny 80188 80186+proc.bin.+FPU 80186+proc.bin.+FPU
pamięć programu 6kB RAM/EEPROM 16kB RAM/EEPROM 80kB RAM/EEPROM 2kB RAM/EEPROM 32kB RAM 512kB RAM
Pamięć danych 512B 2048B 9999B 256B
Realizowane podstawowe operacje logiczne (AND, OR, XOR, NOT, SHL, SHR)
operacje logiczne i arytmetyczne, arytmetyka zmiennoprzecinkowa,
funkcje bitowe i ładowanie, przesyłanie, porównywanie, operacje na tablicach, konwersje
wieloprocesorowość, komunikacja w sieci
bajtowe danych, operacje arytmetyczne (+,-,*,/,SQR,MOD),
Języki system Logicmaster zgodny z IEC 1131-3
programowania (schematy funkcyjne, LAD, GRAFTEC, BLOCTEC)
Czas wykonania
18ms 0,4ms 0,3ms/ 0,4ms 0,4ms 0,4ms
1000 instrukcji
Dostępne flagi 1024 1024 1024
wewnętrzne z podtrzymaniem z podtrzymaniem z podtrzymaniem
Człony czasowe łącznie łącznie łącznie łącznie łącznie łącznie
Liczniki zdarzeń 170 > 500 > 500 1600 1600 1600
Wej. binarne łącznie 160 512 512 16 512 2048
Wyj. binarne (320 przy użyciu 512 512 12 512 2048
Wej. analogowe specjalnych 128 128 - łącznie łącznie
Wyj. analogowe modulów) 64 64 - 8192 8192
Łącze komunik. RS485/422/232 RS485/422/232, Genius LAN RS232 Ethernet, Genius LAN, RS485/422
Możliwości kasety rozszerzające na 5 lub 10 modułów typu: we/wy binarne, we/wy dodatkowy moduł moduły we/wy binarnych,we/wy analogowych,
rozbudowy analogowe, licznikowe, komunikacyjne, itd. szybkiego licznika przerwań zewn., Genius
Ciężar
Gabaryty kasety: na 5 modułów 130x245x142, na 10 modułów 130x443x142
183

Dodatek 2 - Układy pneumatyczne
Tabela D.2
Symbole funkcjonalne wybranych zaworów dwupołożeniowych.
Rodzaj zaworu Symbol Rodzaj zaworu Symbol

rozdzielającego funkcjonalny rozdzielającego funkcjonalny
dwudrogowy trzydrogowy
normalnie zamknięty normalnie otwarty
dwudrogowy czterodrogowy
normalnie otwarty
trzydrogowy pięciodrogowy
normalnie zamknięty
Tabela D.3
Przykładowe realizacje funkcji logicznych przez trzydrogowy zawór rozdzielający.
Funkcja Realizacja Schemat logiczny Funkcja Realizacja Schemat logiczny
y x3 y
x1 y=x1*x4
y=x1*x3+x1*x4 x1 y x1 x1 y
x1 x4
x3=0=const
x4 x3 x4 x4
y y=x1*x3 y
y=x1+x1*x4=x1+x4 x1 x1 x1 y
x1 y
x4 x4=0=const x3
x3=1=const
x4 x3
y y
y=x1 y
y=x1*x3+x1=x3+x1 x1 x1 x1
x1 y x3=1=const
x3 x4=0=const
x4=1=const x3
- ster. pneumatyczne - mechanizm
Symbole: - zasilanie - odpr. do atmosfery sprężyny powrotnej
wzrostemciśnienia
184

Dodatek 3 - Listy rozkazów wybranych sterowników
Tabela D.4
Podzbiór rozkazów sterowników ALSPA ZS do opisu sieci Grafcet
Rozkaz Znaczenie
ETI etap inicjujący sieci

ETA dowolny etap sieci
TR tranzycja
DIV OU początek połączeń dysjunkcyjnych
DIV ET początek połączeń koniunkcyjnych
CONVOU koniec połączeń dysjunkcyjnych
CONVET koniec połączeń koniunkcyjnych
LDI skok do gałęzi połączenia wielokrotnego
otwartego rozkazem DIV
JP G skok do etapu sieci
Tabela D.5
Zestawienie najważniejszych operacji języka STL dostępnych w sterowniku S5-90U

Mnemonik rozkazu Znaczenie
A pobierz stan wejścia i pomnóż logicznie przez akumulator bitowy
AN pobierz stan wejścia, zaneguj i pomnóż logicznie przez akumulator bitowy
O pobierz stan wejścia i zsumuj logicznie z akumulatorem bitowym
ON pobierz stan wejścia, zaneguj i zsumuj logicznie z akumulatorem bitowym
A( , O( , ) iloczyn i suma logiczna wyrażeń w nawiasach; nawias zamykający
S ustaw wyjście gdy akumulator bitowy = ‘1’
R kasuj wyjście gdy akumulator bitowy = ‘1’
= przepisz stan akumulatora bitowego na wyjście
L ładowanie bajtu lub słowa do akumulatora arytmometru
T przepisanie bajtu lub słowa z akumulatora arytmometru
+F , -F dodawanie i odejmowanie liczb stałoprzecinkowych w arytmometrze
!=F , ><F , >F , >=F , <F , <=F operacje porównania zawartości akumulatora arytmometru
JU skok bezwarunkowy do bloku typu OB, PB, FB
JC skok warunkowy do bloku typu OB, PB, FB
C wywołanie bloku danych DB
G generacja bloku danych DB
BE , BEU zakończenie bloku
BEC zakończenie warunkowe bloku
STP przerwanie cyklicznej realizacji programu sterowania
185

Tabela D.6
Lista rozkazów języka INTELSTER PC4K

Możliwości
Rozkaz Argument Komentarz
indeksowania
TH x,y adreswe lub adreswy sprawdź czy ‘1’ logiczna
TL x,y adreswe lub adreswy sprawdź czy ‘0’ logiczne
S włącz wskazane wyjście bezwarunkowo
SJ x,y adreswy włącz wskazane wyjście jeśli ‘tak’
SN włącz wskazane wyjście jeśli ‘nie’
R wyłącz wskazane wyjście bezwarunkowo
RJ x,y adreswy wyłącz wskazane wyjście jeśli ‘tak’
RN wyłącz wskazane wyjście jeśli ‘nie’
SP skocz bezwarunkowo
SPJ nr rozkazu skocz jeśli ‘tak’
SPN skocz jeśli ‘nie’
LR x,y liczba x:=liczba (y:=liczba)
jeśli x > 0 to x:=x-1 i wykonaj następny rozkaz,
DR x,y jeśli x = 0 to pomiń następny rozkaz
(rejestr y -analogicznie)
adres przeznaczenia,
TR x,y przepisanie danych
adres źródła
liczba,adres
LD x ładowanie liczbą rejestru indeksowego
przeznaczenia
ZWB początek deklaracji czasów
nastawa czasu,
adres członu czasowego
ZWE koniec deklaracji czasów
30
Objaśnienia: adreswe - liczba z zakresu 0..777o poprzedzona literą ‘E’;
adreswy - liczba z zakresu 0..757o wskazująca fizyczne wyjście lub komórkę pamięci;
x,y - dwa dostępne 8-bitowe rejestry indeksowe;
liczba - liczba z zakresu 0..255;
nr rozkazu - faktycznie adres rozkazu w pamięci programu;
adres przeznaczenia, adres źródła - adreswe lub adreswy.
30
o - zapis ósemkowy
186

Dodatek 4 - Sieci Petriego typu pozycja/tranzycja
Podstawy teoretyczne [9]
Definicja 1
Systemem pozycja/tranzycja (P/T) jest uporządkowana szóstka postaci:
PN = (P,T,E,K,W,M0)
gdzie:
P,T - niepuste, skończone, wzajemnie nieprzecinające się zbiory odpowiednio:
pozycji (miejsc) i tranzycji (przejść);
E  (P  T)  (T  P) - relacja incydencji, której dziedzina dom(E) i przeciwdziedzina cod(E)
spełniają warunek:
dom(E)  cod(E) = P  T
K : P  N - funkcja pojemności miejsc;
W : E  N - funkcja krotności (przepustowości) krawędzi;
M0 : P  N0 - funkcja znakowania (markowania) początkowego, spełniająca warunek:
M0(p)  K(p), p  P;
N - zbiór liczb naturalnych, N0 = N  {0}.

Systemy P/T mogą być wykorzystywane
do opisu systemów wzajemnie uwarunkowanych
stanów i zdarzeń, w których pozycje mogą być
interpretowane jako lokalne stany (warunki),
a tranzycje - jako zdarzenia (operacje, czynności).
W danej chwili może być spełnionych jednocześnie
wiele warunków rozpatrywanej sieci. Takie spełnione
Rys. Błąd! Nieznany argument
przełącznika.. Przykładowa sieć warunki (aktywne pozycje) przyjęło się oznaczać
Petriego z trzema aktywnymi znacznikami ‘‘ (rysunek 1), a informację o bieżącym
pozycjami
położeniu znaczników rozumie się jako stan sieci.
Po wyjaśnieniu pojęcia znacznika sieci można bliżej określić znaczenie użytych
w ostatniej definicji pojęć:
K - określa liczbę znaczników, jakie dane miejsce może maksymalnie pomieścić;
187

W - określa liczbę znaczników przechodzących od miejsca p  t 31
poprzedzającego daną
tranzycję lub znaczników dochodzących do miejsca p’  t następującego po tej tranzycji.
Funkcje te łącznie z funkcją markowania początkowego M0 stanowią zmienne reguł
określających warunki konieczne zajścia zdarzenia oraz skutki tego zajścia. Oprócz M0
posługujemy się także funkcją znakowania sieci, zwykle w formie wektora:
M = [M(p1) , M(p2), ... , M(pn)] , n = ||P||
opisującego lokalne warunki M(pi) (i = 1..n) niezbędne do zajścia poszczególnych
elementarnych zdarzeń lokalnych.
Ponieważ pozycje i tranzycje są wzajemnie powiązane krawędziami skierowanymi,
to z każdym zdarzeniem (tranzycją) jest związany pewien zbiór warunków wejściowych
(poprzedzających ją pozycji) p  t. Działanie sieci P/T polega na tym, że spełnienie
warunków wejściowych tranzycji powoduje zajście odpowiadającego jej zdarzenia i spełnienie
warunków wyjściowych, którymi są pozycje p’  t następujące po danej tranzycji. Ponieważ
te warunki wyjściowe są warunkami wejściowymi dla innych tranzycji (itd.), sieć może
zmieniać swój stan znakowania w każdym kroku symulacji.
Warunki przygotowania tranzycji t  T, będące warunkami koniecznymi zajścia
zdarzenia reprezentowanego przez tę tranzycję podaje poniższa definicja.
Definicja 2
Niech: PN będzie siecią P/T i markowanie M : P  N0 takie, że M(pi)  K(p), p  P.
Tranzycja t  T jest przygotowana do palenia32 wtedy i tylko wtedy, gdy:
(i) p  t, M(p)  W(p,t);
(ii) p  t, M(p)  K(p) - W(t,p);
gdzie:

t = { p | (p,t)  E} jest zbiorem miejsc wejściowych tranzycji t;
t = { p | (t,p)  E} jest zbiorem miejsc wyjściowych tranzycji t.

31
w dalszej części pracy powyższy symbol, w ślad za literaturą [8], będzie oznaczać zbiór wszystkich pozycji
poprzedzających daną tranzycję, podobnie t będzie zbiorem wszystkich pozycji następujących po danej
tranzycji, analogicznie: p jest zbiorem wszystkich tranzycji poprzedzających daną pozycję, a p - zbiorem
wszystkich tranzycji następujących po danej pozycji.
32
termin „palenie” tranzycji jest stosowanym w polskiej literaturze odpowiednikiem ang. „firing”.
188

tranzycja typu Zależnie od struktury sieci obowiązują oba lub
źródło
tylko jeden z warunków wymienionych w definicji 2,
co ilustruje rysunek 2:
tranzycja nie
 w zwykłych sieciach Petriego (o nieograniczonej
przygotowana pojemności miejsc) istotny jest tylko warunek (i);
 dla tranzycji typu źródło (t  T : t = 0) - tylko warunek
tranzycja (ii);
przygotowana
 dla tranzycji typu ujście (t  T : t = 0) - tylko warunek
tranzycja typu (i).
ujście
Postać warunków przygotowania tranzycji może
w ogólnym przypadku zależeć od składników
uporządkowanego zbioru komponentów wyznaczających
przełącznika.. Ilustracja daną klasę sieci Petriego.
różnych typów tranzycji i ich Tranzycja przygotowana do palenia może zostać
stanów
odpalona, a bieżące znakowanie sieci przejdzie w
znakowanie kolejne (następnicze), zgodnie z zasadą określoną w poniższej definicji.
Definicja 3
Niech PN będzie siecią P/T, w której tranzycja t  T jest przygotowana przez znakowanie M.
W wyniku odpalenia tej tranzycji nowe znakowanie M’ wyznacza się zgodnie z regułą:
 M(p) - W(p,t)  p  t - t

M'(p) =  M(p) + W(t,p)  p  t - t

 M(p) - W(p,t) + W(t,p)  p  t  t
M(p) w pozostałych przypadkach

Zakłada się zerowy czas palenia tranzycji - tzn. przejście od znakowania bieżącego M
do następniczego M’ odbywa się bez opóźnienia czasowego. Gdy jest kilka przygotowanych
tranzycji, to może być odpalona dowolna z nich. Odpalenia pozostałych dokonuje się wtedy,
gdy zostaną spełnione ich warunki przygotowania dla nowo uzyskanego znakowania M’.
Na potrzeby operowania sieciami P/T definiuje się funkcję przejścia.
Definicja 4
Niech PN będzie siecią P/T. Funkcją przejścia tej sieci nazywamy funkcję postaci
(M,t) = M’, określoną dla t  T i M spełniających warunki podane w definicji 2:
189

 : NK(p1)  NK(p2)  ...  NK(pn)  T  NK(p1)  NK(p2)  ...  NK(pn)
dla NK(pi) = { 0,1,2,...,K(pi) }, taką że: M’(pi)  K(pi), i=1..n. 
Definicja 5
Niech PN będzie siecią P/T. Rozszerzoną funkcją przejścia tej sieci nazywamy funkcję ,
określoną dla t  T i M spełniającą warunki:
(M,) = M;
(M,t) = ((M,),t) dla t przygotowanego dla (M,);
gdzie:  oznacza słowo puste;
 = tj1 tj2 ... tjr oznacza sekwencję tranzycji, których odpalenie przeprowadza
znakowanie M w znakowanie (M,);
taka że: M’(pi)  K(pi), i=1..n , gdzie M’ = (M,t).

Sekwencję  = tj1 tj2 ... tjr, zgodną z definicją 5, nazywa się sekwencją paleń,
a znakowanie M’ = (M,) - znakowaniem osiągalnym z M. Ponieważ dla danego znakowania
M można, zależnie od wyboru sekwencji paleń , osiągnąć różne znakowania M’, definiuje się
również zbiór znakowań osiągalnych.
Definicja 6
Niech PN będzie siecią P/T. Zbiorem znakowań osiągalnych ze znakowania początkowego M0
w sieci PN nazywamy zbiór R(PN,M0) spełniający warunki:
(i) M0  R(PN,M0);
(ii) M  R(PN,M0)     T taka że M = (M0,)
gdzie: T jest zbiorem wszystkich słów utworzonych nad alfabetem T, zawierającym także
słowo puste .

Pojęcie zbioru R(PN,M0) jest równoważne określeniu „przestrzeń stanów”
używanemu w teorii automatów i teorii sterowania. Łączy się ono z pojęciem grafu znakowań
osiągalnych:
G = ( R(PN,M0), ) ,   R(PN,M0)  R(PN,M0)
pod warunkiem, że:  t  T takie że M’ = (M,t) i spełnione są warunki podane w definicji 2.
190

Reprezentacje sieci Petriego
Przedstawiona w poprzednim punkcie do prezentacji sieci Petriego notacja

teoriomnogościowa nie ma tak dużego praktycznego znaczenia jak dwie inne reprezentacje
sieci: graficzna i algebraiczna.
W reprezentacji graficznej sieć P/T jest przedstawiana jako graf skierowany o dwóch
rodzajach wierzchołków: pogrubionych kreskach odpowiadających tranzycjom i okręgach
symbolizujących pozycje. Krawędzie skierowane reprezentują elementy relacji incydencji E i
są oznaczane wartościami funkcji krotności W(x,y). Pojemność miejsc, określoną wartościami
funkcji krotności K(p), oznacza się symbolem K(p) umieszczonym w pobliżu symbolu
miejsca p (przykład 1). Jeżeli funkcje W i K są tożsamościowo równe 1, to powyższe
dodatkowe oznaczenia pomija się (np. krawędź (p1,t1) i pozycja p1).
Przykład Błąd! Nieznany argument przełącznika.
Niech będzie dana sieć P/T postaci:

PN = (P,T,E,K,W,M0)
gdzie: P = {p1,p2,p3,p4};
T = {t1};
E = {(p1,t1),(p2,t1),(t1,p3),(t1,p3)};
K(p1) = 1 , K(p2) = 3 , K(p3) = 4 , K(p4) = 2;
W(p1,t1) = 1 , W(p2,t1) = W(t1,p4) = 2 , W(t1,p3) = 3;
M0 = (1,1,0,1).
Znakowanie początkowe M0 podaje liczbę znaczników w poszczególnych pozycjach w stanie
początkowym. Trzy kolejne fazy pracy tej sieci ilustruje rysunek 3.

a) t1 b) t1 c) t1
3 3 3
p1 p3 p1 p3 p1 p3
K(p3)=4 K(p3)=4 K(p3)=4
2 2 p4 2 2 p4 2 2 p4
p2 p2 p2
K(p2)=3 K(p4)=2 K(p2)=3 K(p4)=2 K(p2)=3 K(p4)=2
Rys. Błąd! Nieznany argument przełącznika.. Graficzna reprezentacja

przykładowej sieci P/T w kolejnych fazach pracy: a) tranzycja t1
191

Drugą często stosowaną reprezentacją jest zapis algebraiczny:
PN = (C,K,W,M0)
w którym najważniejszym składnikiem jest macierz incydencji C definiowana następująco:
Niech PN=(P,T,E,K,W,M0) będzie siecią P/T, taką że ||T||=m i ||P||=n. Macierzą incydencji C
sieci PN nazywamy macierz (m  n) o elementach
 W(ti,pj) dla (ti,pj)  E,

c[i, j] = 
 -W(pj,ti) dla (pj,ti)  E,

0 dla {(tj,pi),(pi,tj)}  E
Można także zdefiniować algebraiczną reprezentację funkcji przejścia.
Definicja 7
Niech PN=(P,T,E,K,W,M0) będzie siecią P/T. Dla znakowania M i tranzycji t  T,
spełniających warunki przygotowania podane w definicji 2, znakowanie następnicze wyznacza
się następująco
M’ = M + e[t] C
gdzie: e[t] - wektor jednostkowy o wymiarze m, w którym numer współrzędnej różnej od zera
odpowiada indeksowi tranzycji aktualnie przygotowanej w znakowaniu M.

Wykorzystanie macierzy incydencji nie zdaje egzaminu
pj
w przypadku sieci zawierających pętle (rysunek 4), tzn. takiej
w której:
 (ti , pj) | ti  T , pj  P , ti  pj  pj
ti
gdzie:
Rys. Błąd! Nieznany pj = { t | (pj,t)  E } - zbiór tranzycji wyjściowych miejsca pj;
argument przełącznika.. 
pj = { t | (t,pj)  E } - zbiór tranzycji wejściowych miejsca pj.
Przykład pętli
w sieci P/T W takich sytuacjach rozwiązaniem jest stosowanie pary macierzy
incydencji C- i C+, z których pierwsza zawiera informację o krawędziach wychodzących z
pozycji do tranzycji, a druga - pozostałych. Zastosowanie notacji algebraicznej ilustruje
poniższy przykład.
192

Przykład Błąd! Nieznany argument przełącznika.
Dana jest sieć PN jak na rysunku 5.
p3 t1 p1 t2 p2 t3

przełącznika.. Sieć PN do przykładu 2
Macierz incydencji C ma postać:
 1 0 1
C = 1 1 0 
 0 1 1 
a znakowanie początkowe M0 = [0,0,1]. Warunki przygotowania tranzycji są następujące:

(i) M(pk)  W(tl,pk) przy clk < 0;
(ii) M(pk)  K(pk)-W(pk,tl) przy clk > 0.
Powyższe warunki sprawdza się dla kolejnych wierszy macierzy C:
clk, k=1..n, n=||P|| zachodzi ((i) oraz (ii))  el:=1 w przeciwnym razie el:=0.
Dla znakowania M=M0 wektor przygotowanych tranzycji e[t]=[1,0,0]. Wyznaczając
znakowanie następnicze M’, zgodnie z definicją 7, mamy:
 1 0 -1
M' = M + e[t] C = [0,0,1] + [1,0,0]  -1 1 0  = [0,0,1] + [1,0,-1] = [1,0,0]
 0 -1 1 

Jak ilustruje to powyższy przykład, implementacja komputerowa algebraicznego
zapisu sieci P/T jest nieskomplikowana. W praktyce konstruowania oprogramowania
wspomagającego stosuje się obie notacje: na etapie opisywania sieci występuje bliższa
człowiekowi forma graficzna, która następnie, w celu dokonania analizy i symulacji,
jest przekształcana do postaci algebraicznej.
193

Dodatek 5 - Grafcet
Składnia Grafcet
Grafcet jako wywodzący się z sieci Petriego jest językiem graficznym opartym, tak
jak te sieci, na systemie pozycji i tranzycji33. Twórcy standardu wprowadzili pewne
modyfikacje mające na celu umożliwienie opisu zdarzeń na dowolnym poziomie
szczegółowości. Między innymi pojawiło się pojęcie makroetapów pozwalających uzyskiwać
zwięźlejszy i czytelniejszy zapis problemu dzięki hierarchizacji opisu. Usystematyzowano
reguły tworzenia sieci, stosowania komentarzy do poszczególnych jej składników, tak aby
translacja z poziomu Grafcet do kodu sterownika mikroprocesorowego mogła być
zrealizowana algorytmem nadającym się do implementacji komputerowej [9].
Definicja 8
Siecią Grafcet jest trójka:
G=<E,T,L>
w której:
E={e1,e2,...,en} - niepusty, skończony zbiór elementów zwanych etapami34;
T={t1,t2,...,tn} - niepusty, skończony zbiór elementów zwanych tranzycjami, taki że:
ET=
L - relacja na zbiorze E  T , spełniająca warunek:
L = (E  T)  (T  E)
tzn. L jest skończonym zbiorem krawędzi skierowanych: od tranzycji do miejsc i od miejsc
do tranzycji.

Sieć Grafcet jest więc grafem zorientowanym o dwóch podstawowych typach
wierzchołków. Zarówno miejsca jak i tranzycje mają po kilka swych odmian, dzięki czemu
sieć ta umożliwia modelowanie różnorodnych procesów, tak sekwencyjnych jak
i współbieżnych. Zestawienie symboli graficznych dostępnych w Grafcet zawiera tabela D.7,
a przykładowe ich użycie - rysunek 6 [27].
33
określenia: „pozycja, tranzycja” są bezpośrednim tłumaczeniem ang. „position, transition” stosowanym
w polskojęzycznej literaturze przedmiotu, w niektórych opracowaniach spotyka się także równoważne im
określenia „miejsce, przejście”.
34
„etap” - zamienne określenie „pozycji” lub „miejsca”
194

Tabela D.7
Symbole składni języka Grafcet

Nazwa Symbol graficzny Objaśnienie
etap początkowy stan procesu w momencie jego rozpoczęcia;
n nie reprezentuje żadnej operacji procesu
etap reprezentuje operację elementarną, niepodlegającą

n dalszej dekompozycji
etap wejściowy stan procesu w momencie rozpoczęcia makroetapu,

IN IN nie reprezentuje żadnej operacji
etap wyjściowy stan procesu w momencie zakończenia makroetapu,

OUT OUT nie reprezentuje żadnej operacji
makroetap reprezentuje procedurę sekwencyjną opisaną

monoaktywny Mn oddzielnym grafem
(sekwencyjny)
makroetap reprezentuje co najmniej 1 blok procedur
multiaktywny Mn współbieżnych, opisany oddzielnym grafem
(współbieżny)
przejście reprezentuje warunek logiczny sprawdzany między
(tranzycja) realizacją dwóch kolejnych etapów
rozgałęzienie reprezentuje alternatywę możliwych sekwencji
krawędzi operacji
połączenie stosowany do połączenia sekwencji wybranych
krawędzi uprzednio na zasadzie alternatywy
przejście do reprezentuje warunek logiczny sprawdzany przed
procedur rozpoczęciem realizacji procedur współbieżnych
współbieżnych
przejście od reprezentuje warunek logiczny sprawdzany po
procedur zakończeniu realizacji procedur współbieżnych
współbieżnych
Etapy są odpowiedzialne za elementarne operacje systemu. Przejścia między nimi są

możliwe tylko za pośrednictwem tranzycji. Powszechnie stosuje się zapis grafu od góry
do dołu, zgodnie z kolejnością występowania poszczególnych etapów. Możliwe są oczywiście
przejścia z dołu do góry, np. w celu powtórzenia jakiejś sekwencji operacji. Wymagane jest
wtedy umieszczenie odpowiednich strzałek na krawędziach grafu. Przewidziano także
symbole umożliwiające opis sekwencji operacji wykonywanych alternatywnie i współbieżnie,
czego proste przykłady zawiera rysunek 6.
195

etap początkowy
1 warunek przejścia
przejście
m operacja
etap
2 A początek sekwencji
jednoczesnych
(koniunkcyjnych)
a
etap
aktywny
3 B 5 C
warunek przejścia
uwzględniający bX5
aktywność etapu 5
4 D
koniec sekwencji
d jednoczesnych
początek sekwencji
(koniunkcyjnych)
opcjonalnych
(dysjunkcyjnych)
6 E
uwarunkowanie
operacji
e e U
powtórzenie 7 F 9 operacja
sekwencji
H warunkowa
f i*j ij
8 G 10 I
k przeskok etapu
gh 11 J
gh
koniec sekwencji
dysjunkcyjnych 12 T=45s operacja rozpoczęcia
zliczania czasu
t 13/45s warunek przejścia
zależny od czasu
Rys. Błąd! Nieznany argument przełącznika.. Przykładowa sieć Grafcet
Działania przypisane danemu etapowi stanowią operacje elementarne etapu i są

zapisywane w dodatkowym bloku połączonym z blokiem etapu i traktowanym jako komentarz.
Dopuszcza się wśród tych operacji działania dodatkowo uwarunkowane, tzn. takie, do których
wykonania oprócz uaktywnienia danego etapu musi być jeszcze spełniony określony warunek.
Aby umożliwić posługiwanie się w Grafcet strukturami podobnymi
do wywoływalnych procedur w językach wysokiego poziomu, wprowadzono pojęcie
makroetapu, który może reprezentować złożone sekwencje etapów. Wyróżnia się przy tym
makroetapy sekwencyjne (monoaktywne) i współbieżne (multiaktywne), tzn. takie, które
196

w swej definicji zawierają współbieżne sekwencje działań. Wprowadzenie do składni pojęcia
makroetapu pozwala na dekompozycję opisywanego procesu, wymaganą ze względu na:
 logiczną strukturę procesu, zwiększenie czytelności zhierarchizowanego grafu;
 konieczność opisu wielokrotnie wykonywanych grup operacji;
 ograniczenia implementacyjne, ograniczające np. liczbę etapów i tranzycji w jednym grafie.
Użycie makroetapu wymaga jego

IN M1
oddzielnego zdefiniowania także za
1 IN M3
1 pomocą składni Grafcet. Graf modelujący
makroetap nazywamy jego rozwinięciem.
M1 1
M3 Każde rozwinięcie może wykorzystywać
inne makroetapy. W rozwinięciu
3
2 OUT makroetapu występują dodatkowo dwa
2 etapy: wejściowy IN i wyjściowy OUT.
4
M2 IN M2 Blok komentarza etapu IN wskazuje,
którego makroetapu dotyczy poniższe
M3 OUT
1 rozwinięcie. Przykładową sieć Grafcet
3
zawierającą dwa typy makroetapów
OUT przedstawia rysunek 7. Ponieważ

numerowanie etapów jest lokalne
Rys. Błąd! Nieznany argument przełącznika.. w obrębie danego grafu, rozwinięcia także
Przykład hierarchizacji opisu przy pomocy
makroetapów: sekwencyjnego M1 są etykietowane od ‘1’.
Składnię Grafcet można streścić w niżej podanych regułach syntaktycznych.

Reguły związane z etapem i operacją:
 Dwa etapy nie mogą następować bezpośrednio po sobie - muszą być rozdzielone
przejściem.
 Etapy muszą uwzględniać wszystkie zmiany w zachowaniu się systemu.
 Każdemu etapowi należy przypisać wszystkie operacje realizowane na tym etapie.
 Liczba etapów jest nieograniczona.
Reguły związane z przejściem i warunkami przejścia:
 Dwie tranzycje nie mogą następować bezpośrednio po sobie - muszą być rozdzielone
etapem.
197

 Dopuszcza się przejścia wielokrotne.
 Każdemu przejściu można przyporządkować tylko jeden warunek.
 Każdy warunek powinien uwzględniać całą informację logiczną mogącą mieć wpływ
na realizację danego przejścia.
 Warunek może być dowolnym wyrażeniem logicznym.
 Mogą występować warunki przejścia wspólne dla wielu przejść.
 Użycie identycznych warunków dla dwóch kolejnych przejść rozdzielonych jednym etapem
powoduje zignorowanie tego etapu.
Reguły związane z krawędziami skierowanymi grafu:
 Połączenia między etapami powinny być prowadzone z góry w dół, zgodnie z kolejnością
realizacji etapów, a wszelkie odstępstwa winny być wyraźnie zaznaczone.
 Należy unikać krzyżowania się połączeń.
 Wielokrotne połączenia koniunkcyjne muszą rozpoczynać i kończyć się jednym wspólnym
warunkiem przejścia.
 Każda gałąź wielokrotnego połączenia dysjunkcyjnego musi zaczynać i kończyć się
osobnym warunkiem przejścia.
5.1.1.1 Reguły modelowania przy użyciu Grafcet
Definicja 9
Etap nazywamy aktywnym od momentu rozpoczęcia jego wykonywania do rozpoczęcia etapu
następnego.

Aktywny etap jest oznaczany na grafie kropką w jego symbolu. W danej chwili
w sieci może być wiele etapów aktywnych. Dokonując animacji sieci odpowiadającej
zachowaniu się modelowanego systemu obserwowalibyśmy krążenie po sieci wzdłuż jej
krawędzi kropek - znaczników aktywności etapów. Przy uaktywnianiu procedur
współbieżnych widoczne byłoby przy tym powielanie kropek na wszystkie uaktywniane
gałęzie, a przy ich kończeniu - łączenie się kropek z poszczególnych gałęzi. Przy uaktywnianiu
makroetapów kropka wpisuje się w górnej części odpowiedniego bloku reprezentującego ten
makroetap. W trakcie działania makroetapu uaktywnianie są kolejno jego etapy składowe,
zgodnie z grafem rozwinięcia. Uaktywnienie bloku OUT makroetapu oznacza przejście całego
makroetapu w stan gotowości (zakończono realizację operacji objętych danym makroetapem),
198

a w bloku symbolizującym ten makroetap znacznik aktywności przemieszcza się do jego
dolnej części.
Definicja 10
Stanem procesu jest zbiór informacji o stanie aktywności jego etapów.

Definicja 11
Tranzycję uważa się za przygotowaną, gdy wszystkie poprzedzające ją bezpośrednio etapy są
aktywne.

Modelowanie zachowania się systemu za pośrednictwem sieci Grafcet można ująć
w następujących regułach:
 Etap początkowy reprezentuje stan procesu w momencie jego rozpoczęcia. Tranzycja
następująca po tym etapie opisana jest warunkiem oznaczającym zakończenie inicjalizacji
sterownika. Sieć Grafcet może zawierać więcej niż jeden etap początkowy.
 Zmiana stanu procesu jest reprezentowana przez zapalenie tranzycji, co następuje wtedy,
gdy: wszystkie poprzedzające ją etapy są aktywne i zakończone, i gdy spełniony jest
warunek logiczny opisujący tę tranzycję.
 Zapalenie tranzycji (realizacja przejścia) powoduje dezaktywację poprzedzających ją
etapów i uaktywnienie wszystkich etapów po niej następujących.
 Wszystkie tranzycje przygotowane i mające spełnione warunki logiczne są zapalane
jednocześnie.
 Jeżeli podczas zmiany stanu procesu ten sam etap jest jednocześnie uaktywniany
i dezaktywowany, to pozostaje on w stanie aktywnym.
 Makroetap jest uaktywniany, gdy zapalona zostaje tranzycja, od której prowadzi do niego
krawędź skierowana. Uaktywnienie makroetapu jest równoznaczne z uaktywnieniem etapu
IN jego rozwinięcia.
 Makroetap przechodzi w stan gotowości, gdy uaktywni się etap OUT w grafie jego
rozwinięcia.
 Jeżeli makroetap jednocześnie spełnia warunki aktywności i gotowości, to uznaje się, że
jest on w stanie gotowości.
199

Dodatek 6 - Przekształcanie wyrażeń logicznych przez translator JODA
Dana jest przykładowa funkcja przejścia ze stanu w1 do stanu w2:
w1-w2=b(e+/d+/b)f+a/b/(e+d)+//a;
Wyrażenie to jest najpierw przekształcane do zapisu pełnego:
w1-w2=b*(e+/d+/b)*f+a*/b*/(e+d)+a;
a następnie translowane na notację polską. Kolejne fazy tej operacji przedstawia tabela D.8.
Tabela D.8
Przykład funkcjonowania algorytmu „górki rozrządowej” przy translacji na notację polską
Wyjściowy ciąg symboli Stos pomocniczy Wejściowy ciąg symboli
(„tor wyjazdowy”) („bocznica”) („tor wjazdowy”)
b*(e+/d+/b)*f+a*/b*/(e+d)+a;
b *(e+/d+/b)*f+a*/b*/(e+d)+a;
b * (e+/d+/b)*f+a*/b*/(e+d)+a;
b *( e+/d+/b)*f+a*/b*/(e+d)+a;
be *( +/d+/b)*f+a*/b*/(e+d)+a;
be *(+ /d+/b)*f+a*/b*/(e+d)+a;
be *(+/ d+/b)*f+a*/b*/(e+d)+a;
bed *(+/ +/b)*f+a*/b*/(e+d)+a;
b e d/ *(+ +/b)*f+a*/b*/(e+d)+a;
b e d/+ *(+ /b)*f+a*/b*/(e+d)+a;
b e d/+ *(+/ b)*f+a*/b*/(e+d)+a;
b e d/+b *(+/ )*f+a*/b*/(e+d)+a;
b e d/+b/+ * *f+a*/b*/(e+d)+a;
b e d/+b/+* * f+a*/b*/(e+d)+a;
b e d/+b/+*f * +a*/b*/(e+d)+a;
b e d/+b/+*f* +a*/b*/(e+d)+a;
b e d/+b/+*f* + a*/b*/(e+d)+a;
b e d/+b/+*f*a + */b*/(e+d)+a;
b e d/+b/+*f*a +* /b*/(e+d)+a;
b e d/+b/+*f*a +*/ b*/(e+d)+a;
b e d/+b/+*f*a b +*/ */(e+d)+a;
b e d/+b/+*f*a b/ +* */(e+d)+a;
b e d/+b/+*f*a b/* +* /(e+d)+a;
b e d/+b/+*f*a b/* +*/ (e+d)+a;
b e d/+b/+*f*a b/* +*/( e+d)+a;
b e d/+b/+*f*a b/*e +*/( +d)+a;
b e d/+b/+*f*a b/*e +*/(+ d)+a;
b e d/+b/+*f*a b/*e d +*/(+ )+a;
b e d/+b/+*f*a b/*e d+ +*/ +a;
b e d/+b/+*f*a b/*e d+/* + +a;
b e d/+b/+*f*a b/*e d+/*+ + a;
b e d/+b/+*f*a b/*e d+/*+a + ;
b e d/+b/+*f*a b/*e d+/*+a+;
200

Przejście do postaci APN
W wyniku zastosowania praw de’Morgana zapis wyrażenia zmienia się następująco35:

b e d /+ b /+* f * a b /* e /d + *+ a +;
b e d /+ b /+* f * a b /* e / d /* *+ a +;
co odpowiada normalnemu zapisowi:
b(e+/d+/b)f+a/b/e/d+a;
Przykładowe wyrażenie zawiera teraz jedno podwyrażenie ujęte w nawiasy, mnożone
logicznie przez zmienne proste. Rozbicie tych nawiasów polega na iteracyjnym zastosowaniu
reguły rozdzielności iloczynu logicznego względem sumy. Wyniki kolejnych iteracji
przedstawiają się następująco:
b e d /+ b /+* f * a b /* e / d /**+ a +;
e d /+ b * b / b *+ f * a b /* e / d /**+ a +;
e b * d / b*+ b / b *+ f * a b /* e / d /**+ a +;
e b * d / b *+ f * b / b * f *+ a b /* e / d /**+ a +;
e b * f * d / b * f *+ b / b * f *+ a b /* e / d /**+ a +;
Zapis zwykły, równoważny powyższemu, jest następujący:
e*b*f+/d*b*f+/b*b*f+a/b/e/d+a;
Końcowe korekcje zapisu
W otrzymanym zapisie tylko w jednym miejscu sąsiadują ze sobą operatory iloczynu.

Ich rozdzielenie polega na przekształceniu wyrażenia zgodnie z opisem w pkt. 3.4.2.3:
e b * f * d / b * f *+ b / b * f *+ a b /* e / d /* *+ a +;
e b * f * d / b * f *+ b / b * f *+ a b /* e /* d /*+ a +;
Zapis wyrażenia zawiera jeszcze implikant z iloczynem ‘b / b *’, który z oczywistych
względów eliminuje ten implikant z treści wyrażenia:
e b * f * d / b * f *+ b / b * f *+ a b /* e /* d /*+ a +;
e b * f * d / b * f *+ a b /* e /* d /*+ a +;
Po tym uproszczeniu, wyrażenie w zapisie zwykłym miałoby postać:

e*b*f+/d*b*f+a/b/e/d+a;
35
W prezentowanych zapisach zmieniane fragmenty wyrażenia są przekreślone, wynik ich modyfikacji -
podkreślony.
201

Kolejny krok korekcyjny, sortowanie alfabetyczne wykonywane dla poszczególnych
implikantów, powoduje następujące przekształcenia:
e b * f * d / b * f *+ a b /* e /* d /*+ a +;
b e * f * d / b *f *+ a b /* e /* d /*+ a +;
b e * f * b d /* f *+ a b /* e /* d /*+ a +;
b e * f * b d /* f *+ a b /* d /* e /*+ a +;
Optymalizacja wyrażenia
Z dostępnych dwóch reguł optymalizacyjnych jedynie reguła:

argi * argk + argi = argi
znajduje zastosowanie w przypadku przetwarzanego wyrażenia - trzeci i czwarty implikant
mogą być zastąpione przez samo ‘a’:
b e * f * b d /* f *+ a b /* d /* e /*+ a + ;
b e * f * b d /* f *+ a +;
Ostatecznie wyrażenie zaimplementowane w notacji polskiej ma postać:
b e * f * b d /* f *+ a +;
co odpowiada w zapisie zwykłym wyrażeniu:
b*e*f+b/d*f+a;
202

Dodatek 7 - Przykłady procedur wyznaczających stany następne automatu
Poniżej podane są przykładowe procedury w asemblerze mikroprocesora Z80,
umożliwiające wyznaczanie stanu następnego automatu przy zastosowaniu algorytmu
iteracyjnego (punkt 3.1.3.2) lub jednokrotnego (punkt 3.1.3.1). W procedurach tych występują
stałe asemblacji, których znaczenie jest następujące:
 rozmiar_slowa - długość w bajtach słowa wejściowego x automatu;
 rozmiar_rekordu_TS - długość w bajtach rekordu tablicy stanów TS, zawierającego:
adres tablicy przejść danego stanu oraz słowa wyjściowe yO i yW;
 adres_slowa_x - adres pierwszego (najmłodszego) bajtu słowa wejściowego x automatu
w pamięci danych sterownika.
W treści procedur ‘chgst’ i ‘chgst1’ użyto ponadto wywołania pomocniczej procedury
‘mltconst’, której zadaniem jest określenie iloczynu zawartości akumulatora A i rejestru B,
potrzebnego do adresowania tablicy stanów TS.
; procedura wyznaczajaca nowy stan
; parametry: DE->slowo wejsciowe;
; HL->rekord tablicy przejsc dla danego stanu;
; wyniki: A = kod nastepnego stanu, w szczegolnosci
; stanu biezacego gdy nie ma zmiany;
; zmiany: HL,AF;
; zajetosc stosu: 6 bajtow.
newst: push bc
push de
ld b,(hl) ;B:=ilosc implikantow w rekordzie TP
newst1: inc hl
ld c,rozmiar_slowa
newst2: ld a,(de) ;HL->maska[i]
and (hl) ;A:=slowo[i].AND.maska[i]
inc hl ;HL->wzor[i]
inc de
cp (hl) ;A=wzor[i]?
inc hl ;HL->maska[i+1] lub stan nastepny
jr nz,newst6 ;skok gdy slowo[i]*maska[i]<>wzor[i]
dec c ;nastepny bajt slowa
jr nz,newst2
jr newst4 ;skok gdy dla j=1..C: slowo=wzor(j)
newst3: pop de
push de
djnz newst1 ;nastepny implikant
inc hl
newst4: ld a,(hl) ;A:=kod stanu
pop de
pop bc
ret
newst5: inc hl ;pominiecie maski[i+1] i wzoru[i+1]
inc hl
newst6: dec c
jr nz,newst5
jr newst3
203

; procedura realizujaca iteracyjny algorytm zmiany stanu
; parametry: A = kod stanu biezacego
; IX = adres poczatku tablicy stanow TS
; wyniki: A = kod stanu nastepnego
; zmiany: C,DE,HL
chgst: ld c,a ;przechowanie kodu stanu w C
ld b,rozmiar_rekordu_TS
call mltconst ;adresowanie tablicy stanow TS
push ix
pop de ;DE->poczatek TS
add hl,de ;HL->wybrany rekord w TS
ld e,(hl)
inc hl
ld d,(hl)
ex de,hl ;HL->tablice przejsc TP dla biezacego stanu
ld de,adres_slowa_x
call newst ;sprawdzenie warunkow przejsc dla stanu
cp c ;czy nowy stan = stary stan
jr nz,chgst ;skok jesli nie - iteracja
ret
; procedura realizujaca jednokrotny algorytm zmiany stanu

; IX = adres poczatku tablicy stanow TS
; zmiany: C,DE,HL
chgst1: ld b,rozmiar_rekordu_TS
call mltconst ;adresowanie tablicy stanow TS
push ix
pop de ;DE->poczatek TS
add hl,de ;HL->wybrany rekord w TS
ld e,(hl)
inc hl
ld d,(hl)
ex de,hl ;HL->tablice przejsc TP dla biezacego stanu
ld de,adres_slowa_x
call newst ;sprawdzenie warunkow przejsc dla stanu
ret
Procedury przeznaczone dla mikrokomputerów rodziny MCS51 mają bardzo podobną

budowę. Przytoczone poniżej procedury zostały napisane przy założeniu, że: tablice stanów TS
i przejść TP są umieszczone w przestrzeni adresowej pamięci programu, a rozmiar słowa
wejściowego xt jest nieduży i pozwala na umieszczenie go w wewnętrznej pamięci RAM
mikrokomputera. Znaczenie stałych asemblacji jest takie samo jak w poprzednio.
; procedura wyznaczajaca nowy stan
; parametry: R0->slowo wejsciowe;
; DPTR->rekord tablicy przejsc dla danego stanu;
; wyniki: A = kod nastepnego stanu, w szczegolnosci
; stanu biezacego gdy nie ma zmiany;
; zmiany: R2,R3,R4,A;
; zajetosc stosu: 6 bajtow.
newst: clr a
movc a,@a+dptr ;A:=liczba implikantow w rekordzie TP
mov r2,a ;R2 - licznik petli
newst1: mov a,r0
mov r1,a ;przepisanie R0->R1
inc dptr
204

mov r3,#rozmiar_slowa
newst2: clr a
movc a,@a+dptr ;A<-maska[i]
inc dptr ;DPTR->wzor[i]
anl a,@r1 ;A:=slowo[i].AND.maska[i]
inc r1
mov r4,a ;przechowanie iloczynu w R4
clr a
movc a,@a+dptr ;A<-wzor[i]
inc dptr ;DPTR->maska[i+1] lub stan nastepny
xrl a,r4 ;porownanie z iloczynem
jnz newst6
djnz r3,newst2 ;nastepny bajt slowa x
sjmp newst4 ;skok gdy slowo.AND.maska = wzor(j)
newst3: djnz r2,newst1 ;nastepny implikant
inc dptr
newst4: clr a
movc a,@a+dptr ;A<-kod stanu
ret
newst5: inc dptr ;pominiecie maski[i+1] i wzoru[i+1]
inc dptr
newst6: djnz r3,newst5
sjmp newst3
; procedura realizujaca iteracyjny algorytm zmiany stanu

; DPTR = adres poczatku tablicy stanow TS
; zmiany: A,B,R7,DPTR
chgst: mov r7,a ;przechowanie kodu stanu w R7
mov b,#rozmiar_rekordu_TS
mul ab ;BA:=rozmiar*kod
push dpl ;przechowanie adresu TS na stosie
push dph
add a,dpl
mov dpl,a
mov a,b
addc a,dph
mov dph,a ;DPTR->wybrany rekord w TS
mov b,r7 ;B:=kod stanu biezacego
clr a
movc a,@a+dptr
mov r1,a
clr a
inc dptr
movc a,@a+dptr
mov dpl,a
mov dph,r1 ;DPTR->tablica przejsc TP dla biezacego stanu
mov r0,#adres_slowa_x
acall newst ;sprawdzenie warunkow przejsc dla stanu
pop dph
pop dpl
cjne a,b,chgst ;porownanie stanu nowego z dotychczasowym
ret
205

; procedura realizujaca jednokrotny algorytm zmiany stanu
; DPTR = adres poczatku tablicy stanow TS
; zmiany: A,B,R7,DPTR
chgst1: mov r7,a ;przechowanie kodu stanu w R7
mov b,#rozmiar_rekordu_TS
mul ab ;BA:=rozmiar*kod
push dpl ;przechowanie adresu TS na stosie
push dph
add a,dpl
mov dpl,a
mov a,b
addc a,dph
mov dph,a ;DPTR->wybrany rekord w TS
mov b,r7 ;B:=kod stanu biezacego
clr a
movc a,@a+dptr
mov r1,a
clr a
inc dptr
movc a,@a+dptr
mov dpl,a
mov dph,r1 ;DPTR->tablica przejsc TP dla biezacego stanu
mov r0,#adres_slowa_x
acall newst ;sprawdzenie warunkow przejsc dla stanu
pop dph
pop dpl
ret
206

Grodzki L.J.

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Grodzki L.J.

Uploaded by

Copyright:

Available Formats

Politechnika Białostocka

Bialystok University of Technology

Rodzaj dyplomu / Diploma type Rozprawa doktorska / PhD thesis

mgr inż. Lech Jarosław Grodzki

REALIZACJA STEROWANIA BINARNEGO

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Dodatek 1 – Charakterystyczne parametry wybranych sterowników

Dodatek 3 – Listy rozkazów wybranych sterowników 185

Dodatek 4 – Sieci Petriego typu pozycja/tranzycja 187

Dodatek 5 – Grafcet 194

Dodatek 6 – Przekształcanie wyrażeń logicznych przez translator JODA 200

Dodatek 7 – Przykłady procedur wyznaczających stany następne automatu 203

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

 , ‘ - funkcja przejść automatu;

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

1.1 Wprowadzenie w tematykę pracy

Programowalnymi sterownikami logicznymi1 nazywamy systemy automatyki

Rozwój technologii programowalnych sterowników jest ściśle związany z rozwojem

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

2.1 Techniczne realizacje sterowania binarnego

Sterowanie dyskretne jest jedną ze starszych dziedzin automatyki przemysłowej.

2.1.1 Układy przekaźnikowe

Układy przekaźnikowe są historycznie pierwszym środkiem realizacji układów

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pojawienie się cyfrowych układów scalonych, początkowo małej, a z czasem średniej

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

2.1.3 Mikrokomputery i sterowniki mikroprocesorowe

Skonstruowanie na początku lat siedemdziesiątych pierwszych mikroprocesorów

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Postęp w dziedzinie technologii układów cyfrowych umożliwił realizację układów

2.1.4.1 Wykorzystanie pamięci programowalnych

Pamięci stałe typu PROM, EPROM były pierwszymi programowalnymi układami

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Rys. 2.1. Przykład automatu o funkcji przejść ‘ zorientowanej na zmiany stanu

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

2.1.4.2 Programowalne układy logiczne

Lata osiemdziesiąte przyniosły w wyniku ciągłego rozwoju technologii układów

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

2.1.5 Układy pneumatyczne

Oprócz wymienionych w poprzednich punktach typowo elektrycznych realizacji

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Rys. 2.2. Zawory realizujące funkcje: a) alternatywy, b) koniunkcji, c) zakazu,

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Zmiany w technice realizacji sterowników binarnych wpływały również na stosowane

2.2.1 Schematy elektryczne stykowo-przekaźnikowe

Użycie schematów stykowo-przekaźnikowych jest ściśle związane

Przykładowe symbole używane w schematach stykowo-przekaźnikowych

a) b) styki zwierne a) b) styki przycisku

Pobrano z https://bazawiedzy.pb.edu.pl / Downloaded from Repository of Bialystok University of Technology 2022-08-15

Rys. 2.4. Układ sterowania rozruchowym i przekaźnikiem termicznym Pt