Wrocław, 13.01.2016

Metody sztucznej inteligencji Prowadzący: Dr hab. inż. Ireneusz Jabłoński

Temat: „Sterowanie mobilnością robota z wykorzystaniem algorytmu logiki rozmytej”

Wykonał: Jakub Uliarczyk, 195639

2

Spis treści 1. Założenia projektowe. .................................................................................................................... 3

2. Robot oraz czujniki. ........................................................................................................................ 3

3. Logika rozmyta. .............................................................................................................................. 4

4. Projekt regulatora. ......................................................................................................................... 6

5. Algorytm logiki rozmytej w C. ......................................................................................................... 9

a. Ogólny schemat algorytmu....................................................................................................... 10

b. Fuzyfikacja. ............................................................................................................................... 12

c. Wnioskowanie. ......................................................................................................................... 14

d. Defuzyfikacja. ........................................................................................................................... 16

6. Wnioski: ........................................................................................................................................ 17

3

1. Założenia projektowe. Celem projektu było napisanie w języku C i zastosowanie algorytmu logiki rozmytej w robocie,

którego zadaniem było omijanie przeszkód. Algorytm miał za zadanie sterować współczynnikiem

wypełnienia sygnału PWM dla silników napędzających robota, w taki sposób aby robot mógł zmienić

kierunek jazdy w momencie wykrycia przed sobą przeszkody. Zmiennymi wejściowymi dla algorytmu

logiki rozmytej były zmierzone odległości przez ultradźwiękowe czujniki odległości umieszczone z

przodu robota. Zmienną wyjściową robota był kierunek, w który robot miał się zwrócić w razie

wykrycia przeszkody, aby bezkolizyjnie ją ominąć i pojechać dalej.

2. Robot oraz czujniki. Użyty do projektu robot nosi nazwę „Andrzej”. Robot został wyposażony w dwa ultradźwiękowe

czujniki odległości HC-SR04, układ multipleksujący oraz moduł Bluetooth HC-05.

Rys 1. Robot „Andrzej”.

4

Rys 2. Czujnik HC-SR04.

Rys 3. Moduł Bluetooth HC-05.

Robot jest zasilany baterią litowo-polimerową i komunikuje się ze światem zewnętrznym za pomocą

modułu Bluetooth.

3. Logika rozmyta. Logika rozmyta jest rozszerzeniem klasycznej logiki bazującej na wartościach reprezentowanych przez

0(fałsz) oraz 1(prawda). Logika rozmyta „rozmywa” granice pomiędzy wartościami 0 i 1, wzbogacając

je o przedział od 0 do 1. Stwarza to możliwość wystąpienia wartości z pomiędzy tego przedziału(od 0

do 1), np. 0,8 – co może oznaczać „prawie prawda”. Logika rozmyta ma swoje zastosowanie w

regulatorach, w przypadku gdy nie znamy matematycznego opisu obiektu lub jego opis jest trudny do

wyznaczenia. Wtedy możemy skorzystać z logiki rozmytej bazując na empirycznych doświadczeniach

z obiektem, określając jego zachowanie wartościami lingwistycznymi. Przykładowo dla opisu pracy

silnika można zdefiniować taką wielkość jak „szybkość obrotów”, gdzie wartościami lingwistycznymi

opisującymi tą wielkość mogłyby być: „wolno”, „średnio” i „szybko”.

Sterowanie rozmyte składa się z trzech etapów: fuzyfikacja, wnioskowanie i defuzyfikacja. Kolejność

występowania tych etapów prezentuje poniższy schemat:

Rys 4. Schemat algorytmu logiki rozmytej.

Fuzyfikacja Wnioskowanie Defuzyfikacja

Reguły

Y X

5

Fuzyfikacja – jest to proces w którym do zmierzonej wartości wejściowej jest jest przypisywany

stopień przynależności danych wejściowych do danego zbioru rozmytego. Wartość wejściowa ulega

„rozmyciu”.

Wnioskowanie – polega na obliczeniu wag wyjściowej funkcji przynależności na podstawie danych

pochodzących z procesu fuzyfikacji oraz zbioru reguł definiujących reakcję algorytmu(regulatora) na

zadaną wartość wejściową.

Defuzyfikacja – na podstawie wag wyjściowych funkcji przynależności i przy użyciu odpowiedniej

metody, określana jest wynikowa, „ostra”, wartość wyjściowa algorytmu(regulatora).

Przed rozpoczęciem definiowania zachowania się regulatora(określeniu reguł), należy określić tzw.

zbiory rozmyte. Zbiorem rozmytym nazywamy przedział w funkcji przynależności, który odpowiada

jednej z wartości lingwistycznych określającej wartość wejściową/wyjściową algorytmu. Odnosząc się

do przykładu silnika, poniżej prezentuję przykładową funkcję przynależności z zaznaczonymi zbiorami

rozmytymi dla wartości wejściowej „szybkość obrotów”:

Rys 5. Funkcja przynależności dla zmiennej „szybkość obrotów”. Wykres stworzony w środowisku

LabVIEW.

Reguły są to proste instrukcje warunkowe, które wiążą rozmyte wartości wejściowe z zachowaniem

się regulatora i jego wynikową wartością wyjściową. Poniżej został przedstawiony przykład reguły:

𝑰𝑭 𝑠𝑧𝑦𝑏𝑘𝑜ść 𝑜𝑏𝑟𝑜𝑡ó𝑤 𝑰𝑺 𝑤𝑜𝑙𝑛𝑜 𝑨𝑵𝑫 𝑜𝑏𝑐𝑖ąż𝑒𝑛𝑖𝑒 𝑰𝑺 ś𝑟𝑒𝑑𝑛𝑖𝑒 𝑻𝑯𝑬𝑵 𝑤𝑦𝑝𝑒ł𝑛𝑖𝑒𝑛𝑖𝑒 𝑝𝑤𝑚 𝑰𝑺 𝑝𝑒ł𝑛𝑒

Posiadając wiedzę o wszystkich elementach algorytmu logiki rozmytej wymienionych wyżej oraz o

wszystkich metodach matematycznych niezbędnych do zrealizowania algorytmu, można przejść do

projektowania regulatora.

6

4. Projekt regulatora. W celu prostego i szybkiego zaprojektowania regulatora posłużyłem się środowiskiem LabVIEW,

które jest wyposażone w asystenta tworzenia regulatora rozmytego. Asystent wyposażony jest w

łatwy w obsłudze graficzny interfejs użytkownika, posiada przyjemny mechanizm tworzenia reguł

oraz panel, na którym można zobaczyć wizualizację odpowiedzi regulatora i przetestować

zaprojektowany regulator zadając odpowiednie wartości wejściowe i obserwując wartości wyjściowe.

Rys 6. Panel główny asystenta tworzenia regulatora.

Rys 7. Definicja funkcji przynależności dla zmiennej „distance_left”.

7

Rys 8. Definicja funkcji przynależności dla zmiennej „distance_right”.

Rys 9. Definicja funkcji przynależności dla zmiennej „direction”.

8

Rys 10. Definiowanie reguł.

Rys 11. Panel testowy regulatora.

9

Zaprezentowane wyżej obrazy odwołują się do projektu regulatora jaki został zaimplementowany w

C i użyty w projekcie. Na przedstawionych obrazach można dostrzec wygląd funkcji przynależności dla

zmiennych wejściowych oraz zamiennej wyjściowej. Na obrazie prezentującym reguły zauważalnym

jest, że zostały pokryte wszystkie możliwe przypadki jakie mogą się pojawić w algorytmie, co na

obrazie zawierającym wizualizację wyjścia regulatora jest widoczne w postaci płaszczyzny, która nie

zawiera „szpilek” lub „schodków”, które świadczyłyby, że w danym miejscu reguły nie pokrywają w

pełni wszystkich przypadków, co w efekcie będzie skutkować „skokowym” działaniem regulatora(co

w niektórych przypadkach jest pożądane).

5. Algorytm logiki rozmytej w C. Krytycznym elementem projektu było napisanie algorytmu logiki rozmytej w C. Docelowym

mikrokontrolerem był Atmega32L, jednak kod został napisany w taki sposób, że jest łatwo

przenaszalny na inne platformy oraz łatwy do zaadaptowania w innych systemach wyposażonych w

inne czujniki i w ich różne ilości. Jedynym napotkanym problemem była interpretacja reguł w C, a

dokładniej pokonanie bariery pomiędzy określaniem wartości lingwistycznej za pomocą wartości

liczbowej. Po rozwiązaniu wszystkich problemów algorytm działa bez jakichkolwiek oznak błędów. Na

następnych stronach zostały przedstawione schematy blokowe wraz z opisem, obrazowo

prezentujące sposób działania zaimplementowanego algorytmu logiki rozmytej.

10

a. Ogólny schemat algorytmu.

11

Cały algorytm rozpoczyna swoje działanie od zainicjalizowania wszystkich struktur niezbędnych do

jego działania. Każdy z elementów algorytmu (tj. zmienna, funkcja przynależności, reguła) jest

odpowiednio ustandaryzowany. Poniżej prezentuję wygląd struktur elementów algorytmu:

Poniżej przykładowe inicjalizacje każdej z struktur:

12

b. Fuzyfikacja.

13

Proces fuzyfikacji rozpoczyna się od pobrania wskaźnika na zmienną. Zmienna natomiast posiada

wskaźnik na funkcję przynależności, a ta znowuż jest tablicą struktur, w której zdefiniowane są zbiory

rozmyte dla danej funkcji. Poniżej zostały przedstawione kody źródłowe funkcji używanych w

procesie fuzyfikacji.

14

c. Wnioskowanie.

15

Wnioskowanie polega na określeniu wagi dla danego zbioru rozmytego funkcji przynależności

zmiennej wyjściowej. W schemacie powyżej należy zwrócić uwagę na moment, w którym sprawdzane

jest czy nowo obliczona wartość „wagi” jest większa od obecnej wartości zapisanej w części „then”.

Jest to realizowanie funkcji MAX dla części „then” reguły, czyli zapisanie w tej części reguły wartości,

o największym wpływie na zbiór rozmyty. Poniżej kod funkcji realizującej wnioskowanie:

16

d. Defuzyfikacja.

17

Defuzyfikacja jest finalnym etapem algorytmu logiki rozmytej, gdzie obliczana jest wyjściowa wartość

regulatora rozmytego. Do obliczania tej wartości istnieje wiele sposobów, w projekcie została użyta

metoda „singletonów”, ze względu na jej prostotę i łatwość implementacji w kodzie. Polega na

zamianie zbiorów rozmytych funkcji przynależności zmiennej wyjściowej na zbiory jednoelementowe,

które znajdują się w miejscach gdzie dany zbiór rozmyty przyjmuje wartość 1. W tej metodzie pojawia

się pewna trudność w określeniu „singletonu” w przypadku gdy zbiór rozmyty ma postać trapezu,

dlatego ważne jest aby dobierać tak kształty zbiorów rozmytych, aby nie mieć problemów z

określaniem „singleton’ów”. W projekcie wszystkie kształty zbiorów rozmytych mają postać trójkąta,

więc określanie „singleton’u” nie sprawiło żadnego problemu. Poniżej kod funkcji odpowiadającej za

defuzyfikację:

6. Wnioski: Projekt został całkowicie zrealizowany, a efekty działania robota są w pełni zadowalające. Robot jest

w stanie bez problemu przemieszczać się bezkolizyjnie po pomieszczeniach niezawierających

elementów, które będą rozpraszać, bądź tłumić falę dźwiękową wysyłaną przez czujniki. Jednakże,

podczas testów wynikły sytuacje w których robot starł się z ścianą, co było efektem ostrego kąta pod

jakim robot zbliżał się do ściany. W takim przypadku fale dźwiękowe wysyłane prze czujniki nie

trafiały z powrotem do odbiorników lecz odbiłaby się od ściany i płynęły w bliżej nieokreślonym

kierunku. Kolejną nietypową sytuacją było zderzenie się robota z obiektem lub ścianą, w sytuacji gdy

czujniki poprawnie wykrywały odległość od obiektu, jednakże po ułamku sekundy od zderzenia robot

wycofywał się i dalej poprawnie realizował algorytm odjeżdżając od ściany i skręcając w kierunku, w

którym wykrył więcej wolnej przestrzeni. Takie zachowanie jest spowodowane inercją systemu, który

wylicza wartości zmiennych wejściowych na podstawie średniej z kilku pomiarów. Uśrednianie

przetrzymywanych w buforze zmierzonych odległości ma na celu tłumienie zakłóceń, w postaci

błędnych pomiarów czujników, bądź odfiltrowaniu nagłych i chwilowych zdarzeń typu machnięcie

ręką przed robotem w trakcie jazdy do przodu. Rozwiązaniem tych problemów byłoby zwiększenie

częstotliwości taktowania mikrokontrolera i optymalizacja kodu, co jednoznacznie zmniejszyłoby

inercje systemu. Zastosowanie lepszego rozwiązania do filtrowania zakłóceń i błędnych wyników

pomiarów również przyczyniłoby się do przyśpieszenia reakcji robota na otoczenie, co poprawiłoby

ogólny wizerunek projektu.