REALIZACJA INSTRUKCJI STERUJĄCYCH DLA ROBOTA W PROGRAMIE W JĘZYKU ARLANG
========================================================================

Niniejsza dokumentacja zawiera opis wykorzystania języka ARLANG do
generowania i realizacji instrukcji sterujących dla robota MOVEMASTER-EX.

Zakłada się, że czytelnik zna już podstawy programowania robota
MOVEMASTER-EX wchodzącego w skład EMCO. Dlatego przed rozpoczęciem
studiowania niniejszej dokumentacji należy koniecznie zapoznać się
z zasadami programowania robota zawartymi w pliku ROBOT.TXT

Oprócz tworzenia prostych programów sekwencyjnych w sposób opisany w pliku
ROBOT.TXT, instrukcje sterujące robotem można generować również w ramach
programu w języku ogólnego zastosowania ARLANG, co zwieksza elastyczność
działania robota.

Niniejsza dokumentacja składa się z dwóch części: ogólnego opisu podstaw
języka ARLANG oraz wykazu procedur specjalnych tego języka, służących do
generowania i realizacji instrukcji sterujących dla robota.


OPIS PODSTAW JĘZYKA "ARLANG"
----------------------------

ZASADY OGÓLNE:

- Zasadniczo w jednej linii może być zapisana dokładnie jedna instrukcja.
Jeśli jednak w jednej linii chcemy zapisać kilka instrukcji, to musimy
je oddzielić od siebie średnikami np:

REPEAT; A:=A+1; UNTIL A>20

- Jeśli w linii wystąpi znak '$', to cała treść tej linii następująca
po tym znaku jest interpretowana jako komentarz

- Nazwy zmiennych, procedur i funkcji nie mogą być dłuższe, niż 80 znaków
(w aplikacjach dla systemu Windows) lub 12 znaków (w aplikacjach dla
systemu DOS).
W przypadku zmiennych indeksowanych do dlugości tej wlicza się także
nawias otwierający

- Wszystkie spacje i znaki tabulatora są ignorowane

- Awaryjne przerwanie działania programu mozna uzyskać przez naciśnięcie
klawiszy CTRL-C


ZMIENNE:

- Wszystkie zmienne są typu rzeczywistego ("floating point").

- Rozróżniamy zmienne proste i zmienne indeksowane (tablice).

- Zmienne proste pisane małymi i dużymi literami są rozróżniane

- Zmienne indeksowane pisane małymi i dużymi literami nie są rozróżniane

- Zmienna prosta jest automatycznie definiowana przy pierwszym podstawieniu
pod nią jakiejkolwiek wartości np. A:=b+5*(b-3)

- Tablica może być zadeklarowana w dowolnym miejscu programu, ale tylko
przed pierwszym odwołaniem do niej. Tablice mogą być tylko jednowymiarowe.
Ich elementy numerowane są od 1 do rozmiaru tablicy. Maksymalny rozmiar
tablicy może być 10000. Maksymalna ilość zadeklarowanych w danym programie
tablic wynosi 250 (w aplikacjach dla systemu Windows) lub 20 (w aplikacjach
dla systemu DOS). Nie można powtórnie deklarować tablicy o danej nazwie
w celu zmiany jej rozmiaru. Deklaracja tablicy ma postać:

ARRAY nazwa(rozmiar)
Przykłady:
ARRAY TABELA(3)
ARRAY B(a+5)

Odwołanie do zmiennej indeksowanej ma postać:

nazwa(indeks)
Przykłady:
TABELA(j):=13
a:=B(13)


WYRAZENIA ARYTMETYCZNE:

- W skład wyrażeń arytmetycznych mogą wchodzić operatory +,-,/,*
oraz następujące funkcje:
SIN( ) - funkcja sinus
COS( ) - funkcja cosinus
ARCTAN( ) - funkcja arcus tangens
ARCTAN2( ) - dwuargumentowa funkcja arcus tangens, zwracająca wartość kąta
zawartego pomiędzy osią X a półprosta wychodzącą z początku
układu współrzędnych i przechodzącą przez punkt o współrzędnych
(X1,Y1) którego współrzędna Y1 jest pierwszym parametrem funkcji
ARCTAN2, zaś współrzędna X1 jest drugim parametrem funkcji ARCTAN2
SQRT( ) - pierwiastek kwadratowy
PI() - funkcja zwracająca wartość liczby PI
Funkcje trygonometryczne operują na radianach. Duże i małe litery nie są
rozróżniane w nazwach funkcji

- Zachowywane jest pierwszeństwo dzielenia i mnożenia przed dodawaniem
i odejmowaniem, chyba że kolejność działań zmieniona jest przez zastosowanie
nawiasów.

- Oprócz funkcji standardowych w wyrażeniach arytmetycznych mogą też wystąpić
funkcje zdefiniowane w bibliotekach specjalistycznych np. związanych
z generowaniem i realizacją instrukcji sterujących dla robota.

- Stopień złożoności wyrażeń arytmetycznych jest nieograniczony


INSTRUKCJE PODSTAWIENIA:

- Ich postać ogólna jest następująca:

Zmienna := Wyrażenie_arytmetyczne

Przykłady:
DELTA:=B*B-4*A*C
X1:=(-B-SQRT(DELTA))2/A
X2:=(-B+SQRT(DELTA))2/A


PROCEDURY NIEBIBLIOTECZNE:

- Pod pojęciem procedur niebibliotecznych rozumiemy tutaj procedury definiowane
przez użytkownika w programie

- Definicje procedur niebibliotecznych mogą występować w dowolnej kolejności,
jednak zawsze przed programem głównym (patrz "struktura programu")

- Treść pojedynczej procedury niebibliotecznej zawarta jest miedzy instrukcjami:

PROCEDURE
.....
.....
ENDPROC
Przykład:
PROCEDURE OBLICZ_C
C:=A*2
ENDPROC

- Wywoływanie procedur niebibliotecznych odbywa się za pomocą instrukcji:

CALL
Przykład:
CALL OBLICZ_C

- Duże i małe litery nie są rozróżniane w nazwach procedur

- Opcjonalnie może wystąpić w instrukcji CALL lista parametrów aktualnych
przekazywanych do procedury. Lista ta zamieszczana jest w nawiasach zwykłych
i składa się z szeregu wyrażeń arytmetycznych oddzielonych przecinkami np.:

CALL OBLICZENIE(a,b,c*4)

- Podstawienie wartości parametrów aktualnych pod odpowiednie zmienne wykorzystywane
przez procedurę odbywa się w tej procedurze przez wywołanie instrukcji PARAMETERS
o postaci:

PARAMETERS nazwa1,nazwa2,nazwa3....

gdzie nazwa1, nazwa2, nazwa3.... - nazwy zmiennych prostych, pod które mają być
podstawione wartości parametrów aktualnych podane w instrukcji CALL np.:

PARAMETERS x,y,z

Instrukcja PARAMETERS powinna być w zasadzie wywołana zaraz po nagłówku procedury.


STRUKTURA PROGRAMU:

- Główny blok programu zaczyna się od instrukcji PROGRAM, a kończy wraz z końcem
pliku tekstowego, w którym jest zawarty ten program.
Wszystkie definicje procedur niebibliotecznych (wywoływanych w bloku głównym
lub nawzajem przez siebie) musza się znajdować przed instrukcją PROGRAM

- Linie programu nie dające się prawidłowo zinterpretować są ignorowane przez
interpreter, przy czym w odpowiednim pliku tekstowym zapisywany jest komunikat
o wystąpieniu błędu, chyba że wyłączony zostanie debugger (patrz dalej)


INSTRUKCJE WARUNKOWE:

- Instrukcje realizowane warunkowo znajdują się miedzy instrukcjami:

IF
....
....
ELSE
....
....
ENDIF
Przykład:

if a>b
c:=5;a:=c+1
else
c:=-5
endif

- Dopuszczalne jest pominięcie członu "else" i następujących po nim instrukcji

- Maksymalne zagnieżdżenie instrukcji warunkowych wynosi 250 poziomów
(w aplikacjach dla systemu Windows) lub 20 poziomów (w aplikacjach dla
systemu DOS).


PĘTLE "REPEAT":

- Instrukcje realizowane wielokrotnie (w pętli) znajdują się miedzy instrukcjami:

REPEAT
....
UNTIL
Przykład:
k:=0
repeat
k:=k+1
until k>20

- Maksymalny stopień zagnieżdżenia pętli REPEAT ... UNTIL wynosi 250 poziomów
(w aplikacjach dla systemu Windows) lub 20 poziomów (w aplikacjach dla
systemu DOS).


WARUNKI LOGICZNE:

- Warunki logiczne wykorzystywane są w instrukcjach warunkowych (if else endif)
oraz w pętlach (repeat until)

- Warunki logiczne dzielimy na proste i złożone

- Rozróżniamy warunki logiczne proste następujących typów:

WYRAŻENIE1 > WYRAŻENIE2
WYRAŻENIE1 < WYRAŻENIE2
WYRAŻENIE1 = WYRAŻENIE2
WYRAŻENIE1 <> WYRAŻENIE2

gdzie WYRAŻENIE1 i WYRAŻENIE2 są dowolnymi wyrażeniami arytmetycznymi.
O spełnieniu bądź niespełnieniu ostatnich 2 warunków decyduje różnica
pomiędzy wartościami WYRAŻENIE1 i WYRAŻENIE2 wynosząca do 0.001.
Na przykład:

Jeśli A=5 i B=5.000001, to warunek A=B jest spełniony
Jeśli A=5 i B=5.01, to warunek A=B nie jest spełniony

Dopuszczalne jest także, aby warunek logiczny był po prostu wyrażeniem arytmetycznym.
W tym przypadku warunek uważany jest za spełniony, gdy wartość tego wyrażenia jest
większa od 0.001, zaś w przypadku przeciwnym warunek jest uważany za niespełniony.
Przyklad:
A:=0
IF A
B:=1
ELSE
B:=2
ENDIF

(w powyższym przykładzie zmienna B przyjmuje wartość 2 )

- Warunki logiczne złożone są warunkami złożonymi z kilku warunków prostych,
związanych ze sobą operatorami koniunkcji .&. na przykład:

IF a>b+5 .&. a

PROCEDURY BIBLIOTECZNE (SPECJALISTYCZNE):

- Procedury biblioteczne są to procedury zawarte w specjalistycznych bibliotekach
języka ARLANG (na przykład omówione dalej procedury służące do generowania
i realizowania instrukcji sterujących dla robota)

- Procedury biblioteczne wywoływane są przez nazwę np. wywołanie procedury o nazwie
EGZEKUCJA ma postać:

EGZEKUCJA

- Duże i małe litery nie są rozróżniane w nazwach procedur

- Procedury biblioteczne mogą nie mieć żadnego parametru, ale mogą też mieć jeden
lub więcej parametrów aktualnych. Jeśli parametry występują, to w wywołaniu
procedury znajdują się one w nawiasach okrągłych i następują zaraz po nazwie
procedury) np.:

KAMERA (1)


DEBUGGING

- Jeżeli w uruchomionym programie występują błędy struktury ogólnej (np. brak
instrukcji PROGRAM), to komunikaty o tych błędach zapisywane są do pliku
o nazwie takiej samej, jak nazwa pliku, w którym zawarty jest program, jednak
z rozszerzeniem DBG np.:

przy uruchomieniu programu: TEST.PRG
ewentualne błędy zostaną zapisane w pliku: TEST.DBG

- Komunikaty o wszystkich pozostałych błędach są standardowo zapisywane również
w tym samym pliku, bez przerywania działania programu (błędne instrukcje są
ignorowane przez interpreter)

- Odwołanie wykrywania błędów następuje za pomocą instrukcji:

DEBUGGER(OFF)

Od momentu wystąpienia (realizacji) tej instrukcji, komunikaty o błędach nie będą
zapisywane do pliku, nawet w przypadku wystąpienia instrukcji niemożliwych do
zinterpretowania (instrukcje te będą ignorowane) a także błędnych wyrażeń
arytmetycznych (rezultaty działania programu mogą się więc w takim przypadku
okazać nieprzewidywalne).

- Jeśli chcemy, aby na pewnym etapie realizacji programu błędy były znowu wykrywane,
a komunikaty o nich zapisywane do pliku *.DBG, to musimy zastosować instrukcję:

DEBUGGER(ON)

- Instrukcje DEBUGGER(ON) i DEBUGGER(OFF) są interpretowane tak samo, jak wszystkie
inne wywołania procedur bibliotecznych i mogą wystąpić w programie dowolną
ilość razy


PROCEDURY JĘZYKA ARLANG SŁUŻĄCE DO GENEROWANIA I REALIZACJI INSTRUKCJI
----------------------------------------------------------------------
STERUJĄCYCH DLA ROBOTA I INNYCH URZĄDZEŃ GNIAZDA ZROBOTYZOWANEGO:
-----------------------------------------------------------------

IR (treść_instrukcji) - dodanie pojedynczej instrukcji dla robota o podanej
w nawiasach treści do sekwencji instrukcji sterujących.
Wszystkie spacje w treści instrukcji są ignorowane.
Jeśli w instrukcji ma wystąpić spacja, to zamiast niej
należy wpisać znak podkreślenia _.
W treści instrukcji mogą występować fragmenty "parametryczne":
zamiast konkretnej wartości liczbowej można wstawić
w nawiasach prostokątnych [ ] dowolne wyrażenie arytmetyczne,
którego wynik zastąpi to wyrażenie w instrukcji sterującej
w momencie jej symulacji lub wysłania do układu sterowania
robota, np. zapis:

X:=1; IR(MO_[X+1])

spowoduje wysłanie do układu sterowania robota instrukcji:

MO 2

EGZEKUCJA - wysłanie do układu sterowania robota (lub symulacja)
sekwencji instrukcji sterujących określonych dotąd
za pomocą wywołanych wcześniej instrukcji IR, a następnie
skasowanie tej sekwencji. Procedura EGZEKUCJA powoduje też
ewentualne dodanie instrukcji ED na końcu sekwencji -
dlatego nie jest konieczne stosowanie procedury IR(ED)
w programie w języku ARLANG

WOLNY() - funkcja zwracająca wartość 1 jeśli robot jest gotowy do
przyjęcia kolejnej sekwencji instrukcji, natomiast zwracająca
wartość 0 gdy robot jest zajęty (np. realizuje program lub
znajduje się w reżimie sterowania ręcznego). W warunkach
symulacji programu za pomocą symulatora ROB_SYM funkcja
ta zawsze zwraca wartość 1

STATUS FMS - procedura powodująca wysłanie zapytania o aktualny status
poszczególnych urządzeń elastycznego systemu obróbkowego EMCO.
Po jej wywołaniu można korzystać z omówionych poniżej funkcji
FREZARKA, TOKARKA, IMADLO, KONIK i SANIE. Procedura ta
funkcjonuje prawidłowo tylko wtedy, gdy robot nie realizuje
w danej chwili żadnego programu (przed jej wywołaniem dobrze
jest więc uruchomić pętlę oczekującą na zwrócenie wartości 1
przez omówioną wcześniej funkcję WOLNY

FREZARKA() - funkcja zwracająca wartość 1 jeśli w momencie ostatniego
wywołania procedury STATUS FMS frezarka realizowała jakiś
program, natomiast zwracająca wartość 0 jeśli frezarka nie
pracowała

TOKARKA() - funkcja zwracająca wartość 1 jeśli w momencie ostatniego
wywołania procedury STATUS FMS tokarka realizowała jakiś
program, natomiast zwracająca wartość 0 jeśli tokarka nie
pracowała

IMADLO() - funkcja zwracająca wartość 1 jeśli w momencie ostatniego
wywołania procedury STATUS FMS imadło było zamknięte,
natomiast zwracająca wartość 0 jeśli imadło było otwarte

KONIK() - funkcja zwracająca wartość 1 jeśli w momencie ostatniego
wywołania procedury STATUS FMS konik był zamknięty,
natomiast zwracająca wartość 0 jeśli konik był otwarty

SANIE() - funkcja zwracająca wartość 1 jeśli w momencie ostatniego
wywołania procedury STATUS FMS sanie robota znajdowały się
po prawej stronie elastycznego systemu obróbkowego (przy
tokarce), natomiast zwracająca wartość 0 jeśli sanie
znajdowały się po stronie lewej (przy frezarce)



PROCEDURY JĘZYKA ARLANG SŁUŻĄCE DO KOMUNIKACJI Z SYSTEMAMI ANALIZY OBRAZU I ANALIZY MOWY
----------------------------------------------------------------------------------------

KAMERA (numer) - powoduje transfer danych z aplikacji zewnętrznej analizującej
obraz z kamery o podanym numerze. Przykładowo instrukcja ta
może mieć postać:

KAMERA (1)

Zewnętrzna aplikacja przekazuje dane do programu w języku ARLANG,
przy czym pobranie danych z tej aplikacji odbywać się może na
2 sposoby:

1) Aplikacja zewnętrzna automatycznie generuje zmienne proste
o określonych nazwach, pod które podstawia odpowiednie
wartości. Zmienne te są dostępne w dalszej treści programu
w języku ARLANG (należy przy tym pamiętać, że wielkość
liter w nazwie zmiennej prostej ma znaczenie)
2) Aplikacja zewnętrzna podstawia odpowiednie wartości pod
elementy tablic (ktore MUSZĄ być zadeklarowane w programie
przed wywołaniem procedury KAMERA). Wartości te są dostępne
w dalszej części programu

Na przeprowadzanych zajęciach laboratoryjnych dostępna jest
aplikacja KAMERA (1), która podstawia odpowiednie wartości
pod następujące zmienne proste oraz elementy tablic:

A - sumaryczne pole powierzchni A wszystkich obiektów
xs, ys - współrzędne środka ciężkości sumy tych obiektów
n - ilość odrębnych obiektów
A(1..n) - pola powierzchni poszczególnych obiektów
xs(1..n), ys(1..n) - współrzędne środków ciężkości tych obiektów
Ix(1..n) - momenty bezwładności tych obiektów względem prostych
równoległych do osi X i przechodzących przez ich
środki ciężkości
Iy(1..n) - momenty bezwładności tych obiektów względem prostych
równoległych do osi Y i przechodzących przez ich
środki ciężkości
Ixy(1..n) - momenty dewiacji tych obiektów względem prostych
równoległych do osi X i Y oraz przechodzących
przez ich środki ciężkości

GLOSNIK (numer, Powoduje wygłoszenie komunikatu podanego jako drugi parametr
komunikat) instrucji GLOSNIK, przy czym polskie głoski można uzyskać stawiając
znak ^ po danej literze, zaś odstępy (spacje) należy zastąpić
znakami podkreślenia _
Na zajęciach laboratoryjnych należy wykorzystawać głośnik nr 1
(przeznaczony dla języka polskiego), podczas gdy głośnik nr 2
wygłasza komunikaty w języku angielskim.
W przypadku języka polskiego (głośnik nr 1) jeśli ciąg znaków
(cyfr) ma być odczytany jako liczba, to należy go poprzedzić
znakiem # np.:

GLOSNIK (1 , 5_razy_5_wynos^i_#25)

W treści komunikatu mogą też występować fragmenty "parametryczne":
zamiast konkretnego tekstu można wstawić w nawiasach prostokątnych
[ ] dowolne wyrażenie arytmetyczne, którego wynik będzie wygłoszony
np.:

X:=5; GLOSNIK(1 , [X]_razy_[X]_wynos^i_[X*X])


MIKROFON Powoduje rejestrację i analizę treści wypowiedzi wygłoszonej do
mikrofonu. Wynik tej analizy jest dostępny za pośrednictwem funkcji
KOMENDA() oraz PARAMETR().

Uwaga! Procedura MIKROFON może zmienić wartości zmiennych o nazwach:
P1, P2, P3, P4 ...
oraz P1[1], P1[2], P1[3] ...
P2[1], P2[2], P2[3] ...
....................
i dlatego należy unikać używania zmiennych o takich nazwach

MIKROFON(WLACZ) - Włączenie ciągłego nasłuchu komend. Od tego momentu wywołanie
procedury MIKROFON nie powoduje oczekiwania na komendę głosową
lecz uwzględnienie komendy ostatnio wypowiedzianej

MIKROFON(WYLACZ) - wyłączenie ciągłego nasłuchu komend. Od tego momentu wywołanie
procedury MIKROFON będzie blokowało realizację programu aż
do momentu pojawienia się komendy głosowej

KONSOLA(komunikat) - Powoduje odczytanie i analizę komendy w języku naturalnym wpisanej
przez użytkownika programu za pomocą konsoli (w oknie tekstowym).
Wynik tej analizy jest dostępny za pośrednictwem funkcji KOMENDA()
oraz PARAMETR().
KOMUNIKAT jest tekstem, który ma się pojawić w oknie konsoli jako
sygnał dla użytkownika, że oczekiwane jest wpisanie komendy
w języku naturalnym. Jeśli w komunikacie mają wystąpić spacje, to
należy je zastąpić znakami podkreślenia _

Uwaga! Procedura KONSOLA może zmienić wartości zmiennych o nazwach:
P1, P2, P3, P4 ...
oraz P1[1], P1[2], P1[3] ...
P2[1], P2[2], P2[3] ...
....................
i dlatego należy unikać używania zmiennych o takich nazwach

AKTYWUJ (nazwa) - Procedura ta może być wywoływana do 20 razy i powoduje dodanie komendy
o podanej nazwie do listy komend "aktywnych" (które będą uwzględniane
w ramach analizy realizowanej przez procedury MIKROFON i KONSOLA).
Nazwa komendy może być zapisana zarówno małymi jak dużymi literami.
Brak jakiegokolwiek wywołania procedury AKTYWUJ powoduje, że uwzględniane
będą wszystkie komendy ze słownika.
Pojęcie nazwy komendy jest opisane w osobnej dokumentacji (plik KOMENDY.TXT)

AKTYWUJ WSZYSTKIE - Odwołuje wszystkie dotychczasowe wywołania procedury AKTYWUJ i powoduje,
że w ramach procedur MIKROFON i KONSOLA uwzględniane będą wszystkie
komendy ze słownika.

TELEFON - Powoduje rejestrację sekwencji naciśnięć klawiszy telefonu
lub za pomocą których zdalny użytkownik realizuje sterowanie
TELEFON (nazwa pliku) (tzw. sygnały DTMF).
lub Sekwencja sygnałów DTMF musi być zakończona klawiszem #
TELEFON (numer, (nie wchodzi on w skład zwracanej sekwencji).
komunikat) Analiza tej sekwencji może być następnie realizowana za pomocą
funkcji KOMENDA lub NUMER.

W przypadku wywołania procedury z jednym parametrem (nazwa pliku),
przed rozpoczęciem nasłuchu zostanie wygłoszona przez telefon
treść pliku dźwiękowego (wav) o podanej nazwie. Plik ten musi
spełniać 2 warunki:
- musi zostać wcześniej utworzony w folderze "Moje Dokumenty"
- zapis dźwięku musi być mono o częstoliwości 8000Hz

W przypadku wywołania procedury z dwoma parametrami (numer
i komunikat), przed rozpoczęciem nasłuchu podany komunikat
zostanie wygłoszony przez głośnik o podanym numerze

KOMENDA (treść) - funkcja zwracająca wartość 1 jeśli podana treść jest równa nazwie
komendy odpowiadającej wypowiedzi zarejestrowanej przez system
analizy mowy (w rezultacie realizacji instrukcji MIKROFON) lub
nazwie komendy odpowiadającej wpisanemu tekstowi w języku
naturalnym (w rezultacie realizacji instrukcji KONSOLA),
albo też jeśli jest zgodna z sekwencją sygnałów DTMF odebranych
przez telefon (w rezultacie realizacji instrukcji TELEFON).
W przypadku braku tej zgodności funkcja ta zwraca wartość 0.
Sposób przypisywania nazwy komendom w języku naturalnym jest
opisany w osobnej dokumentacji (plik KOMENDY.TXT).

NUMER() - funkcja zwracająca liczbę odpowiadającą sekwencji odebranych
przez telefon sygnałów DTMF (w rezultacie realizacji instrukcji
TELEFON).
Jeśli sekwencja odebranych sygnałów nie zawiera żadnych znaków
(tzn. naciśnięto tylko #), to funkcja NUMER zwraca wartość -1.

Jeśli sekwencja odebranych sygnałów zawiera inne znaki niż
cyfry (np. gwiazdkę *) to funkcja NUMER zwraca wartość -2.

Jeśli telefon jest zajęty przez innego użytkownika lub jeśli
nie odebrano sekwencji w ciągu ok. 30 sekund, to funkcja
NUMER zwraca wartość -10.
Ze względu na możliwość czasowego zablokowania telefonu przez
innych użytkowników, zaleca się stosowanie pętli np.:
REPEAT
TELEFON (1,Podaj_numer_pozycji)
UNTIL NUMER<>-10

PARAMETR (numer) - funkcja zwracająca wartość parametru o określonym numerze,
opisującego komendę w języku naturalnym podaną przy wywołaniu
procedury MIKROFON lub KONSOLA.
Przypisywanie parametrów do komend jest opisane w osobnej dokumentacji.


PRZYKŁADY PROGRAMÓW W JĘZYKU ARLANG GENERUJĄCYCH INSTRUKCJE STERUJĄCE DLA ROBOTA:
---------------------------------------------------------------------------------

Przykład 1 Generowanie programu sterującego robotem z wykorzystaniem pozycji
------------------------------------------------------------------
wprowadzonych metodą uczenia
----------------------------


PROGRAM
IR(MC_1,9)
IR(GC)
IR(MC_10,15)
IR(MC_95,90)
IR(GO)
IR(MC_85,80)
IR(NT)
IR(ED)
EGZEKUCJA


Przykład 2 Wykorzystanie instrukcji KAMERA, GLOSNIK i MIKROFON w programie
----------------------------------------------------------------
sterującym robotem
------------------

$ Zakładamy, że aplikacja analizująca obraz z kamery 2 (nie jest to kamera
$ wykorzystywana podczas zajęć laboratoryjnych!) generuje zmienne X1 i Y1,
$ zawierające wartości współrzędnych środka masy przedmiotu obserwowanego
$ przez kamerę umieszczoną nad paletą, na której znajduje się ten przedmiot
$- oraz, że współrzędne te odnoszą się do układu współrzędnych robota
$ (uwaga! założenia te NIE ODPOWIADAJĄ sytuacji na zajęciach laboratoryjnych).
$ Zadanie polega na chwyceniu przedmiotu zidentyfikowanego przez kamerę,
$ następnie podniesieniu i ponownemu położeniu przedmiotu na tym samym
$ miejscu.
$
$ Aplikacja analizy mowy przekazuje komendę słowną użytkownika:
$ jeśli po położeniu przedmiotu na palecie użytkownik wypowie komendę "PARKUJ"
$ to ma nastąpić zaparkowanie robota, czyli wygenerowanie instrukcji NT.
$ Komenda o innej treści ma być zignorowana przez robota
$******************

PROCEDURE CHWYCENIE $ Początek pierwszej procedury
IR (MP_[X1],[Y1],30,-90,0)
IR (GC)
IR(ED)
EGZEKUCJA $ W tym momencie ciąg instrukcji jest wysłany do układu sterowania robota
ENDPROC

$******************
PROCEDURE ODLOZENIE $ Początek drugiej procedury
IR (MP_[X1],[Y1],80,-90,0)
IR (MP_[X1],[Y1],30,-90,0)
IR (GO) $ Zastosowano tutaj dopuszczalne pominięcie instrukcji ED
EGZEKUCJA
ENDPROC

$******************
PROGRAM $ Początek głównego segmentu programu (zawsze po procedurach)
KAMERA (2)
CALL CHWYCENIE
REPEAT
UNTIL WOLNY()
GLOSNIK(1,Chwyc^il^em_przedmiot)
CALL ODLOZENIE
GLOSNIK(1,Odkl^adam_przedmiot)
REPEAT
UNTIL WOLNY()
GLOSNIK(1,Co_mam_teraz_robic^)
MIKROFON
IF KOMENDA (PARKUJ)
IR (NT)
EGZEKUCJA
ENDIF


Przykład 3 Wykorzystanie instrukcji TELEFON
-------------------------------

$ Zakładamy, że w zależności od decyzji użytkownika, robot pobiera
$ przedmiot z pierwszej albo z drugiej pozycji na palecie, po czym odkłada
$ ten przedmiot na pozycję trzecią
$******************
PROCEDURE POBIERZ1
$ Sekwencja instrukcji pobrania wałka z pozycji 1
...
...
ENDPROC
$******************
PROCEDURE POBIERZ2
$ Sekwencja instrukcji pobrania wałka z pozycji 2
...
...
ENDPROC
$******************
PROCEDURE ODLOZ3
$ Sekwencja instrukcji odłożenia wałka na pozycję 3
...
...
ENDPROC
$******************
PROGRAM
REPEAT
TELEFON(1,Podaj_numer_pozycji_z_kto^rej_mam_wz^ia^c^_wal^ek)
IF NUMER()<0
GLOSNIK(1,Nie_podano_numeru_pozycji)
ENDIF
IF NUMER()>2
GLOSNIK(1,Bl^e^dny_numer_pozycji._Powinien_byc^_1_albo_2.)
ENDIF
UNTIL NUMER()>0 .&. NUMER()<3
IF NUMER()=1
CALL POBIERZ1
ENDIF
IF NUMER()=2
CALL POBIERZ2
ENDIF
CALL ODLOZ3


Przykład 4 Złożona aplikacja odwołująca się do systemu analizy obrazu
----------------------------------------------------------

$ Zakładamy, że aplikacja analizująca obraz z kamery 1 generuje zmienne
$ xs i ys, zawierające wartości współrzędnych środka masy obrazu przedmiotu
$ obserwowanego przez kamerę umieszczoną nad paletą na której znajduje się
$ ten przedmiot - oraz zmienną A zawierajacą pole powierzchni tego obrazu.
$ Współrzędne (xs,ys) odnoszą się do układu współrzędnych kamery.
$ Zadanie polega na przemieszczaniu chwytaka robota nad pozycję, na której
$ znajduje się przedmiot. Każdorazowa zmiana położenia przedmiotu
$ (umieszczenie go na innej pozycji palety) powoduje kolejne przemieszczenie
$ chwytaka. Jeśli zasłonięty zostanie obiektyw kamery (co spowoduje
$ wygenerowanie zmiennej A o bardzo dużej wartości), to następuje zaparkowanie
$ robota i zakończenie programu.
$***********************


procedure ruszaj
ir(mp_[xakt],[yakt],300,-90,[bakt])
endproc
$***********************
procedure okresl_pal
if xs<100
pal:=5
else
if xs<155
pal:=4
else
if xs<210
pal:=3
else
if xs<265
pal:=2
else
pal:=1
endif
endif
endif
endif
endproc
$***********************
procedure okresl_yxb
call okresl_pal
if pal=1
xdoc:=310
ydoc:=40
bdoc:=68
else
if pal=2
xdoc:=300
ydoc:=-30
bdoc:=80
else
if pal=3
xdoc:=280
ydoc:=-95
bdoc:=95
else
if pal=4
xdoc:=250
ydoc:=-160
bdoc:=105
else
xdoc:=225
ydoc:=-225
bdoc:=115
endif
endif
endif
endif
endproc
$***********************
procedure obliczaj
wskazane:=0
if A>25000
konczyc:=1
else
if A<1500
ydoc:=yakt
else
call okresl_yxb
wskazane:=1
endif
endif
endproc
$***********************
program
yakt:=0
start:=1
konczyc:=0
repeat
kamera(1)
call obliczaj
if konczyc=0
if start
if wskazane
yakt:=ydoc
xakt:=xdoc
bakt:=bdoc
call ruszaj
egzekucja
start:=0
endif
else
if ydoc<>yakt .&. wolny()
yakt:=ydoc
xakt:=xdoc
bakt:=bdoc
call ruszaj
egzekucja
endif
endif
endif
until konczyc
ir(nt)
ir(ed)
repeat
until wolny()
egzekucja
---------------------------------------------------------------------


TESTOWANIE PROGRAMU W JĘZYKU ARLANG W WARUNKACH BRAKU DOSTĘPNOŚCI APLIKACJI
---------------------------------------------------------------------------
ZEWNĘTRZNEJ:
------------

Jeśli chcemy przetestowac program w języku ARLANG odwołujący się do aplikacji
zewnętrznej (np. analizy mowy lub obrazu), zaś tymczasowo aplikacja ta nie jest
dostępna, to wówczas należy za pomocą zwykłej instrukcji podstawienia :=
podstawić odpowiednie wartości pod nazwy zmiennych, które normalnie byłyby
wygenerowane na podstawie danych przekazanych przez aplikację zewnetrzną.
Testowanie działania programu współpracującego z aplikacją zewnetrzną
wysyłającą komunikat tekstowy nie jest możliwe w przypadku braku dostępności
tej aplikacji (funkcja KOMENDA zawsze będzie zwracała wartość 0).