Rzeszów 2012-01-16

POLITECHNIKA RZESZOWSKA

im. Ignacego Łukasiewicza

Projekt: Sterowanie ruchem pojazdów

z zastosowaniem logiki rozmytej.

Jakub Klimasz

4EF-DI

1. Cel projektu ........................................................................................................................4 2. Wykorzystane narzędzia i biblioteki ...................................................................................4 3. Rzeczywisty model ruchu ulicznego użyty w projekcie .......................................................4 4. Definicja modelu w SUMO ................................................................................................6

4.1. Definicja węzłów .........................................................................................................6 4.2. Definicja dróg ..............................................................................................................7 4.3. Definicja połączeń pomiędzy pasami ...........................................................................7 4.4. Definicja detektorów dla pasów ruchu..........................................................................8 4.5. Odwzorowanie rzeczywistych map w SUMO ..............................................................8

5. Generowanie tras dla samochodów ................................................................................... 10 6. Przygotowanie pozostałych plików ................................................................................... 12

6.1. Przygotowanie pliku konfiguracyjnego dla SUMO GUI ............................................. 12 6.2. Konfiguracja możliwości przełączeń świateł na skrzyżowaniu ................................... 13

7. Logika rozmyta. ................................................................................................................ 14 7.1. Założenia ogólnie dotyczące logiki rozmytej .............................................................. 14 7.2. Opis układów wnioskowania, zbiorów rozmytych oraz reguł ..................................... 14 7.2.1. Dla kombinacji aktualnie aktywnej ......................................................................... 14 7.2.2. Dla kombinacji aktualnie nieaktywnej ..................................................................... 16 7.3. Implementacja logiki rozmytej w języku FCL ............................................................ 19

8. Program Fuzzy Traffic Light Controller ............................................................................ 24 8.1. Możliwości Fuzzy Traffic Light Controller ................................................................ 24 8.2. Opis klas Fuzzy Traffic Light Controller .................................................................... 24 8.3. Implementacja obsługi sygnalizacji świetlnej na skrzyżowaniach. .............................. 25 8.3.1. Pobieranie listy skrzyżowań, odpowiadających im połączeń dróg, detektorów oraz długości dróg na których umiejscowione są detektory. ..................................... 25 8.3.2. Wybór trybu sterowania sygnalizacją świetlną. ....................................................... 26 8.3.3. Wyznaczanie optymalnej kombinacji przełączenia sygnalizacji świetlnej za pomocą logiki rozmytej. .................................................................................... 28 8.4. Opis GUI Fuzzy Traffic Light Controller ................................................................... 31

1. Cel projektu Celem projektu jest zrealizowanie sterowania sygnalizacją świetlną za pomocą logiki rozmytej. Docelowo została stworzona aplikacja umożliwiająca dostosowanie zasad logiki rozmytej, zbiorów rozmytych, tworzenie dowolnej infrastruktury drogowej, skrzyżowań oraz ustawianie sterowania dla każdego z skrzyżowań za pomocą wnioskowania rozmytego.

2. Wykorzystane narzędzia i biblioteki

-SUMO "Simulation of Urban MObility" - program o otwartym źródle umożliwiający tworzenie oraz symulowanie mikroskopowego modelu ruchu ulicznego. Program SUMO jest dostarczany z zestawem narzędzi umożliwiających tworzenie map, tras dla samochodów, modelowania ruchu. W celu zapewniania zamierzonej funkcjonalności konieczne były pewne zmiany w interfejsie TraCI umożliwiającym komunikacje z symulatorem za pomocą Socketów. Więcej informacji dotyczących pakietu SUMO może zostać odnalezione na stronie http://sumo.sourceforge.net.

- TraCI4J - eksperymentalny klient protokołu TraCI dla języka JAVA. Jako, że główna część programu realizowana jest w języku Java konieczna była adaptacja biblioteki autorstwa Enrico Gueli dystrybuowanej na licencji GPLv3. Więcej informacji dotyczących biblioteki TraCI4J może zostać odnalezione na stronie http://sourceforge.net/projects/traci4j/.

- SUMO Traffic Modeler - program służący do modelowania ruchu - aplikacja autorstwa Leontios Papaleontiou dystrybuowanej na licencji GPLv3 umożliwiająca modelowanie ruchu poprzez rzeczną definicję ilości samochodów przemieszczających się miedzy punktami oraz czasu w jakim przemieszczanie to następuje. Ze względu na niepoprawne funkcjonowanie programu były konieczne pewne jego modyfikacje. Więcej informacji dotyczących programu SUMO Traffic Modeler może zostać odnalezione na stronie http://trafficmodeler.sourceforge.net/

- jFuzzyLogic - biblioteka języka Java autorstwa Pablo Cingolani implementująca język FCL (Fuzzy Control Langage) służący do implementacji logiki rozmytej, w szczególności sterowników rozmytych, który to jest rozwijanym przez International Electrotechnical Commission (IEC). Więcej informacji dotyczących biblioteki jFuzzyLogic może zostać odnalezione na stronie http://jfuzzylogic.sourceforge.net/html/index.html.

3. Rzeczywisty model ruchu ulicznego użyty w projekcie

W celu przetestowania skuteczności rozmytego systemu sterowania sygnalizacją świetlną zbudowano, mikroskopowy model ruchu skład którego wchodzą 4 rzeczywiste skrzyżowania zlokalizowane w Rzeszowie:

-skrzyżowanie ul. Powstańców Warszawy i ul. Hetmańską przedstawione na rys. 1 -skrzyżowanie ul. Powstańców Warszawy, ul. Dąbrowskiego, ul. Podkarpackiej oraz ul. Batalionów Chłopskich rys. 2 -skrzyżowanie ul. Dąbrowskiego i ul. W. Pola rys. 3 -skrzyżowanie ul. Hetmańskiej i ul. W. Pola rys.4 Pominięto wszystkie dodatkowe drogi nie łączące wyżej wymienionych skrzyżowań. Odwzorowano natomiast drogi łącze wyżej wymienione skrzyżowania wraz z zmianą liczby pasów. Odległości skrzyżowań przedstawione w projekcie mogą nieznacznie odbiegać od

odległości rzeczywistych, nie zostały również zachowane kształty dróg. Najważniejszym z punktu widzenia projektu jest odwzorowanie struktury skrzyżowań oraz możliwości przejazdów pomiędzy poszczególnymi drogami na skrzyżowaniach.

Rys. 1. Skrzyżowanie ul. Hetmańskiej i ul. Powstańców Warszawy [Źródło: http://mapy.zumi.pl]

Rys. 2. Skrzyżowanie ul. Dąbrowskiego, ul. Podkarpackiej, ul. Powstańców Warszawy oraz ul. Batalionów Chłopskich

[Źródło: http://mapy.zumi.pl]

Rys. 3. Skrzyżowanie ul. Dąbrowskiego i ul. W. Pola [Źródło: http://mapy.zumi.pl]

Rys. 4. Skrzyżowanie ul. Hetmańskiej i ul. W. Pola [Źródło: http://mapy.zumi.pl]

4. Definicja modelu w SUMO SUMO oferuje możliwość definicji sieci dróg za pomocą kilku sposobów: -ręcznej definicji w plikach XML1 -importu z OpenSreetMap2 -importu z map programu VISUM3 -importu z map programu Vissim4 -importu z map openDRIVE5 -importu z map Programu MATsim6 -importu z kształtów z ArcView7 -importu z map z bazy danych GDF8 -generowania map abstrakcyjnych9 W celu wiernego odwzorowania struktury dróg konieczna była ręczna definicja każdego z elementów modelu 4 skrzyżowań opisanych w punkcie 3. 4.1. Definicja węzłów Węzłem w SUMO nazywany jest każdy punkt na mapie, w którym następuje łącznie dróg. Węzłem są skrzyżowania, zwężenia oraz podziały dróg. Podstawowa definicja dla węzła reprezentującego skrzyżowanie z sygnalizacją świetlną została przedstawiona na listingu 1.

1 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Building_Networks_from_own_XML-descriptions.html 2 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/OpenStreetMap.html 3 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/VISUM.html 4 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/Vissim.html 5 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/openDRIVE.html 6 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/MATsim.html 7 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/ArcView.html 8 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Import/DlrNavteq.html 9 http://sumo.sourceforge.net/doc/current/docs/userdoc/Networks/Abstract_Network_Generation.html

Listing 1. Węzeł reprezentujący skrzyżowanie z sygnalizacją świetlną <node id="0" x="760.00" y="210.00" type="traffic_light" tl="0"/> Definicja węzła dla punktów w których występuje łącznie lub dzielenie pasów zostałą przedstawiona w listingu 2. Listing 2. Węzeł reprezentujący złącznie lub podział dróg <node id="m3" x="760.00" y="60.00" type="right_before_left"/> Wszystkie węzły skonfigurowane w celu odzwierciedlenia fizycznego modelu zostały zawarte w pliku rzeszow.nod.xml. Plik ten zawiera 34 węzły w tym 4 węzły dla skrzyżowań kontrolowanych za pomocą sygnalizacji świetlnej. Szczegółowe informacje dotyczące definicji węzłów zawarte są w dokumentacji pakietu oprogramowania SUMO. 4.2. Definicja dróg Drogi są obiektami łączącymi węzły, przy definicji każdej z dróg należy podać węzeł początkowy oraz węzeł końcowy, kolejność podawania węzłów definiuje kierunek ruchu. W ramach każdej z dróg definiowana jest liczba pasów ruchu. W miejscach występowania węzłów drogi zostaną połączone automatycznie z wykorzystaniem heurystyk, o ile nie zostały zdefiniowane własne połączenia. Przykładowa definicja 3 pasowej drogi z węzła 1 do węzła zPowstDojazdDoPod została przedstawiona na listingu 3. Listing 3. Definicja 3 pasowej drogi z węzła 1 do węzła zPowstDojazdDoPod <edge id="PowPH_3to2pasowa" from="1" to="zPowstDojazdDoPod" priority="2" numLanes="3" speed="11.11"/> Wszystkie drogi skonfigurowane w celu odzwierciedlenia fizycznego modelu zostały zawarte w pliku rzeszow.edg.xml. Plik ten zawiera 59 dróg pomiędzy węzłami. Szczegółowe informacje dotyczące definicji dróg zawarte są w dokumentacji pakietu oprogramowania SUMO. 4.3. Definicja połączeń pomiędzy pasami W celu poprawnej reprezentacji połączeń pomiędzy poszczególnymi pasami ruchu konieczne jest zdefiniowanie połączeń w formacie XML. W przypadku niezdefiniowania połączeń, zostaną one wyznaczone przez NETCONVERT wchodzący w skład pakietu SUMO. Odwzorowania dokonane przez NETCONVERT bazują jednak na heurystykach i zazwyczaj nie odzwierciedlają fizycznych połączeń pomiędzy pasami ruchu. W celu definicji połączenia należy zdefiniować drogę z której będzie odbywał się ruch, drogę docelową, oraz pas ruchu ma obu drogach. Pasy ruchu numerowane są od prawej do lewej strony, przy czym drogę należy analizować zgodnie z kierunkiem w którym biegnie. Listing 4 przedstawia połączenie wyjazdu prawym pasem z ulicy Dąbrowskiego na ulicę Batalionów Chłopskich zgodnie z rys. 2. Listing 4. Definicja 3 pasowej drogi z węzła 1 do węzła zPowstDojazdDoPod <connection from="Dbr1ToDbrJPod_3pasowa" to="naPrzemyslowa3pasy" fromLane="0" toLane="0"/> Wszystkie połączenia zostały skonfigurowane w celu odzwierciedlenia fizycznego modelu zostały zawarte w pliku rzeszow.con.xml. Plik ten zawiera 155 połączeń pomiędzy pasami. Zarówno na skrzyżowaniach jak również w przypadku zwężania lub poszerzania dróg.

Szczegółowe informacje dotyczące definicji połączeń zawarte są w dokumentacji pakietu oprogramowania SUMO. 4.4. Definicja detektorów dla pasów ruchu W celu poprawnego zliczania długości kolejki na danym pasie ruchu konieczne jest zastosowanie detektorów dla poszczególnych pasów ruchu. Do tego celu zostały użyte zmodyfikowane detektory E2. Zmian dokonano na poziomie kodu źródłowego aplikacji SUMO - zmiany te nie zostaną opisane w poniższym punkcie. Liczba samochodów w kolejce oraz długość detektora będzie wykorzystywana podczas obliczania zajętości pasa ruchu, parametr ten będzie stosowany przy wnioskowaniu rozmytym. Długość detektora musi być o 0.1 m krótsza od długości pasa ruchu na którym został umiejscowiony. Listing 5 przedstawia przykładowy detektor przypisany do drogi PowZH_3pasowa, pas ruchu oznaczany jest jako _2 co oznaczana ostatni pas po lewej stronie drogi. W celu zapewnienia poprawności symulacji dane z detektora powinny być odświeżane co jedną sekundę. Listing 4. Definicja 3 pasowej drogi z węzła 1 do węzła zPowstDojazdDoPod <laneAreaDetector id="E3PowZH_3pasowa_2" lane="PowZH_3pasowa_2" pos="0.0" length="160.45" freq="1" file="out.xml" cont="false"/> 4.5. Odwzorowanie rzeczywistych map w SUMO W celu stworzenia sieci zrozumiałej dla symulatora SUMO wykorzystano program NETCONVERT. Plikami niezbędnymi przy konwersji są pliki: węzłów, dróg, oraz połączeń. Przykładowe wywołanie programu zostało przedstawione na listingu 5. Listing 5. Przykładowe uruchomienie programu NETCONVERT C:\Users\DLSV3550>D:\SUMO\sumo-0.13.1\bin\netconvert --node-files="rzeszow.nod.xml" --edge-files="rzeszow.edg.xml" --connection-files="rzeszow.con.xml" --output-file="rzeszow.net.xml" --plain-output "new folder\rzeszow"

Użycie parametru plain-output umożliwia późniejsze wygenerowanie tras dla pojazdów w symulacji. Szczegółowy opis programu NETCONVERT znajduje się w dokumentacji SUMO. Rys. 5 reprezentuje stworzoną sieć dróg, natomiast rys. od 6-9 skrzyżowania z zaznaczonymi połączeniami między pasami ruchu.

Rys. 5. Zespół skrzyżowań zamodelowany w SUMO

Rys. 6. Skrzyżowanie ul. Dąbrowskiego, ul. Podkarpackiej, ul. Powstańców Warszawy oraz ul. Batalionów

Chłopskich zamodelowane w SUMO

Rys. 7. Skrzyżowanie ul. Hetmańskiej i ul. Powstańców Warszawy zamodelowane w SUMO

Rys. 8. Skrzyżowanie ul. Hetmańskiej i ul. W. Pola zamodelowane w SUMO

Rys. 9. Skrzyżowanie ul. Dąbrowskiego i ul. W. Pola zamodelowane w SUMO

5. Generowanie tras dla samochodów SUMO oferuje kilka możliwości generowania ruchu w symulacji. Do podstawowych możliwości generowania ruchu w symulacji zalicza się: - wyznaczanie tras na podstawie macierzy pochodzenie/docelowa pozycja -losowe wyznaczanie tras -wyznaczanie tras na podstawie algorytmu Dijkstry (najkrótszych) -wyznaczanie tras na podstawie prawdopodobieństwa skrętów na każdym skrzyżowaniu -wyznaczanie tras na podstawie definicji natężenia ruchu -wyznaczanie tras na podstawie opisu populacji zamieszkującej dany region Do wyznaczania tras może zostać użyte dowolne oprogramowanie wchodzące w skład pakietu oprogramowania SUMO, jak również zewnętrzne aplikacje takie jak eWorld czy też SUMO Traffic Modeler. Rozsądnym rozwiązaniem (działającym rozwiązaniem przy braku informacji statystycznych) okazało się zastosowanie zmodyfikowanego programu SUMO

Traffic Modeler. W dostarczonej w projektem wersji programu został przebudowany sposób zapisu ustawień oraz umożliwiono generowanie plików definicji podróży, które w kolejnym korku będą użyte przez program duarouter jako pliki wejściowe. Na rys. 10 zostały naniesione punkty 1 - 7 określające możliwe punkty początkowe oraz końcowe tras - wykorzystano relacje każdy z każdym. Tabela 1 obrazuje liczbę samochodów podróżujących pomiędzy danymi punktami w określonym czasie.

Rys. 10. Widok symulowanego środowiska w programie SUMO Traffic Modeler

Tabela 1. Liczba samochodów podróżujących pomiędzy punktami sieci dróg

Punkt początkowy

Punkt końcowy

Czas symulacji

Ilość samochodów

1 1 00:00 - 06:00 0 1 2 00:00 - 06:00 100 1 3 00:00 - 06:00 100 1 4 00:00 - 06:00 100 1 5 00:00 - 06:00 100 1 6 00:00 - 06:00 100 1 7 00:00 - 06:00 300 1 8 00:00 - 06:00 100 2 1 00:00 - 06:00 100 2 2 00:00 - 06:00 0 2 3 00:00 - 06:00 100 2 4 00:00 - 06:00 800 2 5 00:00 - 06:00 400 2 6 00:00 - 06:00 0 2 7 00:00 - 06:00 2000 2 8 00:00 - 06:00 100 3 1 00:00 - 06:00 50 3 2 00:00 - 06:00 100 3 3 00:00 - 06:00 0 3 4 00:00 - 06:00 150 3 5 00:00 - 06:00 50 3 6 00:00 - 06:00 100 3 7 00:00 - 06:00 200 3 8 00:00 - 06:00 50 4 1 00:00 - 06:00 300 4 2 00:00 - 06:00 300 4 3 00:00 - 06:00 400 4 4 00:00 - 06:00 0 4 5 00:00 - 06:00 300 4 6 00:00 - 06:00 200 4 7 00:00 - 06:00 400 4 8 00:00 - 06:00 100 5 1 00:00 - 06:00 100 5 2 00:00 - 06:00 200 5 3 00:00 - 06:00 100 5 4 00:00 - 06:00 100 5 5 00:00 - 06:00 0

5 6 00:00 - 06:00 100 5 7 00:00 - 06:00 1200 5 8 00:00 - 06:00 50 6 1 00:00 - 06:00 100 6 2 00:00 - 06:00 100 6 3 00:00 - 06:00 100 6 4 00:00 - 06:00 400 6 5 00:00 - 06:00 100 6 6 00:00 - 06:00 0 6 7 00:00 - 06:00 600 6 8 00:00 - 06:00 100 7 1 00:00 - 06:00 200 7 2 00:00 - 06:00 600 7 3 00:00 - 06:00 200 7 4 00:00 - 06:00 400 7 5 00:00 - 06:00 300 7 6 00:00 - 06:00 200 7 7 00:00 - 06:00 0 7 8 00:00 - 06:00 100 8 1 00:00 - 06:00 300 8 2 00:00 - 06:00 400 8 3 00:00 - 06:00 300 8 4 00:00 - 06:00 100 8 5 00:00 - 06:00 200 8 6 00:00 - 06:00 200 8 7 00:00 - 06:00 300 8 8 00:00 - 06:00 0 SUMA: 14250

Sumaryczna liczba samochodów w symulacji to 14250. Aby uprościć symulację zrezygnowano z definicji wielu typów samochodów oraz rożnego poziomu niedoskonałości kierowców. Wszystkie z pojazdów w symulacji zdefiniowane są zgodni z listingiem 6. Szczegółowe informacje dotyczące definicji typów pojazdów zamieszczone są w dokumentacji SUMO. Listing 6. Definicja typu samochodu używanego podczas symulacji. <vType id="Default" length="4.25" minGap="0.75" maxSpeed="70.00"> <carFollowing-Krauss accel="2.60" decel="4.50" sigma="0.50" /> </vType> Plikiem wynikowym z programu SUMO Traffic Modeler jest plik generated-trips.xml. W celu wygenerowania klas wykorzystano program duarouter generujący plik traffic.rou.xml. Przykładowe uruchomienie programu zostało zamieszczone w listingu 7. Listing 7. Wykorzystanie duarouter C:\Users\DLSV3550>D:\SUMO\sumo-0.13.1\bin\duarouter --trip-files "traffic.generated-trips.xml" --net-file "rzeszow.net.xml" --output-file "traffic.rou.xml"

6. Przygotowanie pozostałych plików 6.1. Przygotowanie pliku konfiguracyjnego dla SUMO GUI SUMO GUI umożliwia wizualizację symulacji ruchu przeprowadzaną w SUMO. W celu uruchomienia symulacji konieczne jest zdefiniowanie pliku konfiguracji dla symulacji. Podczas tworzenia pliku konfiguracji należy uwzględnić: -plik sieci połączeń dróg -plik tras samochodów -plik detektorów -definicje portu dla TraCI

Listing 8. Konfiguracja dla SUMO GUI <configuration> <input-files> <net-file>rzeszow.net.xml</net-file> <route-files>traffic.rou.xml</route-files> <additional-files>additional.add.xml</additional-files> </input-files> <simulation> <begin>0</begin> <end>21720</end> </simulation> <traci_server> <remote-port value="50003"/> </traci_server> </configuration>

Dokładny opis pliku konfiguracyjnego dla SUMO GUI został opisany w dokumentacji pakietu oprogramowania SUMO. 6.2. Konfiguracja możliwości przełączeń świateł na skrzyżowaniu W celu umożliwienia sterownia światłami ulicznymi konieczne jest zdefiniowanie dodatkowego pliku definicji kombinacji przełączeń dla każdego z skrzyżowań. Ponieważ rozwiązanie to wykorzystywane jest wyłącznie w niemniejszym projekcie, struktura pliku zostanie bliżej opisana. Listing 9 obrazuje fragment pliku konfiguracyjnego dla skrzyżowania ul. Dąbrowskiego, ul. Podkarpackiej, ul. Powstańców Warszawy oraz ul. Batalionów Chłopskich. Listing 8. Fragment konfiguracji możliwości przełączeń świateł dla skrzyżowania ul. Dąbrowskiego, ul. Podkarpackiej, ul. Powstańców Warszawy oraz ul. Batalionów Chłopskich <?xml version="1.0" encoding="UTF-8"?> <combinations> <combination id="0"> <l id="0" value="1"/> <l id="1" value="1"/> <l id="2" value="1"/> <l id="3" value="1"/> <l id="4" value="0"/> <l id="5" value="0"/> <l id="6" value="0"/> <l id="7" value="0"/> <l id="8" value="0"/> <l id="9" value="0"/> <l id="10" value="0"/> <l id="11" value="0"/> <l id="12" value="0"/> <l id="13" value="0"/> <l id="14" value="0"/> <l id="15" value="0"/> <l id="16" value="0"/> </combination> </combinations>

Głównym węzłem pliku jest węzeł combinations do tego węzła może zostać dodane wiele węzłów combination reprezentujących daną kombinacje świateł. W ramach każdego węzła combination powinno znajdować się tyle węzłów l ile świateł sterujących ruchem na danym skrzyżowaniu. Zazwyczaj każde z świateł steruje jedną

możliwością przejazdu. W przypadku omawianego skrzyżowania (rys. 6) liczba świateł to 17. Kolejność parsowania pliku jest zgodna z kolejnością wystąpienia wpisów tym samym przypisywana do numeracji tras skrzyżowania, wartość atrybutu id węzła l jest w tym wypadku ignorowana. Wartość atrybutu value węzła określa rodzaj ustawionego świtała - 1 oznacza światło zielone, 0 oznacza światło czerwone. Należy pamiętać, że do poprawnego funkcjonowania sterowania za pomocą logiki rozmytej ilość świateł zielonych w poszczególnych kombinacjach powinna być podobna.

7. Logika rozmyta. 7.1. Założenia ogólnie dotyczące logiki rozmytej Zgodnie z założeniami projektu stworzono wnioskowanie rozmyte sterujące sygnalizacją świetlną bazującą nie tylko na stanie aktualnego skrzyżowania ale również następnego skrzyżowania. Podejście to pozwala na wybór optymalnej kombinacji świateł na skrzyżowaniu. Założenia ogólne przed sformułowaniem zasad logiki rozmytej: konieczna jest analiza stanu pasa ruchu przed danym światłem w celu określania stopnia

zapełniania drogi dojazdowej konieczna jest analiza stanu pasa docelowego w celu określenia stopnia zapełniania drogi

docelowej w celu zmiany należy wybrać optymalną kombinację przełączeń - poprzez zsumowanie

wyników wnioskowania rozmytego dla każdego pasa ruchu w ramach kombinacji. Założenia te powinny skutecznie rozładować kolejki na zatłoczonych skrzyżowaniach. Problemem okazuje się: konieczność stworzenia układu wnioskowania dla kombinacji aktywnej, w której

wyjściem z układu wnioskowania rozmytego jest konieczność przedłużenia bieżącej kombinacji;

konieczność stworzenia układu wnioskowania dla kombinacji nieaktywnej w której wyjściem z układu wnioskowania rozmytego jest konieczność zmiany bieżącej kombinacji na analizowaną przez układ kombinację;

układ wnioskowania rozmytego dla nieaktywnej kombinacji w celu ograniczenia czasu oczekiwania dostarczać informacji na temat czasu nieaktywności danej kombinacji, a bardziej precyzyjnie czasu świecenia światła czerwonego dla danego połączenia dróg.

7.2. Opis układów wnioskowania, zbiorów rozmytych oraz reguł 7.2.1. Dla kombinacji aktualnie aktywnej W przypadku gdy koniecznie jest obliczenie potrzeby przedłużenie aktualnie trwającej kombinacji brane są pod uwagę drogi dla których włączone jest zielone światło. Do zmiennych wejściowych zalicza się: poziom zapełnienia drogi dojazdowej do skrzyżowania - kolejka dojazdowa poziom zapełniania drogi docelowej - kolejka na drodze docelowej Jako wyjście z układu wnioskowania rozmytego obliczana jest: konieczność przedłużenia danej trwania światła zielonego dla analizowanej pary dróg Kolejka drogi dojazdowej do skrzyżowania - KOLEJKA - reprezentowana jest przez następujące zbiory rozmyte: - BRAK - opisany funkcją trójkątną o parametrach: (-25, 0) (0, 1) (25, 0); - KROTKA - opisany funkcją trójkątną o parametrach: (0, 0) (25, 1) (50, 0); - UMIARKOWANA - opisany funkcją trójkątną o parametrach - (25,0) (50, 1) (75, 0);

- DLUGA - opisany funkcją trójkątną o parametrach - (50, 0) (75, 1) (100, 0); - BARDZO_DLUGA - opisany funkcją trójkątną o parametrach - (75, 0) (100, 1) (125, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 10.

Rys. 10. Graficzna reprezentacja zbiorów rozmytych dla wejścia reprezentującego kolejkę na drodze dojazdowej

Kolejka na drodze docelowej - DROGA_DOCELOWA - jest przez następujące zbiory rozmyte: - BARDZO_PUSTA - opisany funkcją trójkątną o parametrach: (-25, 0) (0, 1) (25, 0); - PUSTA - opisany funkcją trójkątną o parametrach: (0, 0) (25, 1) (50, 0); - UMIARKOWANIE_ZAPELNIONA - opisany funkcją trójkątną o parametrach - (25,0) (50, 1) (75, 0); - ZAPELNIONA - opisany funkcją trójkątną o parametrach - (50, 0) (75, 1) (100, 0); - BARDZO_ZAPELNIONA - opisany funkcją trójkątną o parametrach - (75, 0) (100, 1) (125, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 11.

Rys. 11. Graficzna reprezentacja zbiorów rozmytych dla wejścia reprezentującego kolejkę na drodze docelowej

Wyjście układu wnioskowania - KONIECZNOSC_PRZEDLUZENIA - jest reprezentowane przez następujące zbiory rozmyte: - BRAK - opisany funkcją trójkątną o parametrach: (-0.25, 0) (0, 1) (0.25, 0); - MALA - opisany funkcją trójkątną o parametrach: (0, 0) (0.25, 1) (0.5, 0); - UMIARKOWANA - opisany funkcją trójkątną o parametrach: (0.25, 0) (0.5, 1) (0.75, 0); - DUZA - opisany funkcją trójkątną o parametrach: (0.5, 0) (0.75, 1) (1, 0); - BARDZO_DUZA - opisany funkcją trójkątną o parametrach: (0.75, 0) (1, 1) (1.25, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 12.

Rys. 12. Graficzna reprezentacja zbiorów rozmytych dla wyjścia reprezentującego konieczność przedłużenia

aktualnej kombinacji

Zestaw reguł został opracowany na podstawie ogólnej wiedzy i zasad które powinny być stosowane na skrzyżowaniu, reguły zostały przedstawione w tabeli 2.

Tabela 2. Tabela reguł dla kombinacji aktualnie aktywnej KOLEJKA DROGA_DOCELOWA KONIECZNOSC_PRZEDLUZENIA BRAK - BRAK KROTKA BARDZO_PUSTA MALA KROTKA PUSTA MALA KROTKA UMIARKOWANIE_ZAPELNIONA MALA KROTKA ZAPELNIONA MALA KROTKA BARDZO_ZAPELNIONA MALA UMIARKOWANA BARDZO_PUSTA DUZA UMIARKOWANA PUSTA DUZA UMIARKOWANA UMIARKOWANIE_ZAPELNIONA UMIARKOWANA UMIARKOWANA ZAPELNIONA MALA UMIARKOWANA BARDZO_ZAPELNIONA MALA DLUGA BARDZO_PUSTA BARDZO_DUZA DLUGA PUSTA DUZA DLUGA UMIARKOWANIE_ZAPELNIONA UMIARKOWANA DLUGA ZAPELNIONA MALA DLUGA BARDZO_ZAPELNIONA MALA BARDZO_DLUGA BARDZO_PUSTA BARDZO_DUZA BARDZO_DLUGA PUSTA BARDZO_DUZA BARDZO_DLUGA UMIARKOWANIE_ZAPELNIONA UMIARKOWANA BARDZO_DLUGA ZAPELNIONA MALA BARDZO_DLUGA BARDZO_ZAPELNIONA MALA

Implementacja reguł została zawarta opisana w rozdziale 6.3. 7.2.2. Dla kombinacji aktualnie nieaktywnej W przypadku gdy koniecznie jest obliczenie potrzeby zmiany aktualnie trwającej kombinacji na nową analizowane są pozostałe kombinacje. Z każdej z nich wybierane są drogi dla których byłoby włączone jest zielone światło w przypadku zmiany na analizowaną kombinację. Do zmiennych wejściowych zalicza się: poziom zapełnienia drogi dojazdowej do skrzyżowania - kolejka dojazdowa poziom zapełniania drogi docelowej - kolejka na drodze docelowej czas trwania czerwonego światła dla drogi dojazdowej Jako wyjście z układu wnioskowania rozmytego obliczana jest: konieczność zmiany na daną kombinację świateł

Kolejka drogi dojazdowej do skrzyżowania - KOLEJKA - reprezentowana jest przez następujące zbiory rozmyte: - BRAK - opisany funkcją trójkątną o parametrach: (-25, 0) (0, 1) (25, 0); - KROTKA - opisany funkcją trójkątną o parametrach: (0, 0) (25, 1) (50, 0); - UMIARKOWANA - opisany funkcją trójkątną o parametrach - (25,0) (50, 1) (75, 0); - DLUGA - opisany funkcją trójkątną o parametrach - (50, 0) (75, 1) (100, 0); - BARDZO_DLUGA - opisany funkcją trójkątną o parametrach - (75, 0) (100, 1) (125, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 13.

Rys. 13. Graficzna reprezentacja zbiorów rozmytych dla wejścia reprezentującego kolejkę na drodze dojazdowej

Kolejka na drodze docelowej - DROGA_DOCELOWA - jest reprezentowany przez następujące zbiory rozmyte: - BARDZO_PUSTA - opisany funkcją trójkątną o parametrach: (-25, 0) (0, 1) (25, 0); - PUSTA - opisany funkcją trójkątną o parametrach: (0, 0) (25, 1) (50, 0); - UMIARKOWANIE_ZAPELNIONA - opisany funkcją trójkątną o parametrach - (25,0) (50, 1) (75, 0); - ZAPELNIONA - opisany funkcją trójkątną o parametrach - (50, 0) (75, 1) (100, 0); - BARDZO_ZAPELNIONA - opisany funkcją trójkątną o parametrach - (75, 0) (100, 1) (125, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 14.

Rys. 14. Graficzna reprezentacja zbiorów rozmytych dla wejścia reprezentującego kolejkę na drodze docelowej

Czas trwania światła czerwonego na drodze dojazdowej - SWIATLO_CZERWONE - jest reprezentowany przez następujące zbiory rozmyte: - KROTKO - opisany funkcją trójkątną o parametrach: (-30, 0) (0, 1) (30, 0); - UMIARKOWANIE - opisany funkcją trójkątną o parametrach: (0, 0) (30, 1) (60, 0); - DLUGO - opisany funkcją trójkątną o parametrach - (30, 0) (60, 1) (90, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 14.

Rys. 14. Graficzna reprezentacja zbiorów rozmytych dla wejścia reprezentującego czas oczekiwnia

Wyjście układu wnioskowania - KONIECZNOSC_ZMIANY - jest reprezentowane przez następujące zbiory rozmyte: - BRAK - opisany funkcją trójkątną o parametrach: (-0.25, 0) (0, 1) (0.25, 0); - MALA - opisany funkcją trójkątną o parametrach: (0, 0) (0.25, 1) (0.5, 0); - UMIARKOWANA - opisany funkcją trójkątną o parametrach: (0.25, 0) (0.5, 1) (0.75, 0); - DUZA - opisany funkcją trójkątną o parametrach: (0.5, 0) (0.75, 1) (1, 0); - BARDZO_DUZA - opisany funkcją trójkątną o parametrach: (0.75, 0) (1, 1) (1.25, 0); Graficzna reprezentacja zbiorów rozmytych została przedstawiona na rys. 15.

Rys. 15. Graficzna reprezentacja zbiorów rozmytych dla wyjścia reprezentującego konieczność zmiany na

analizowaną kombinację

Zestaw reguł został opracowany na podstawie ogólnej wiedzy i zasad które powinny być stosowane na skrzyżowaniu, reguły zostały przedstawione w tabeli 3.

Tabela 3. Reguły dla pary dróg aktualnie nieaktywnej KOLEJKA DROGA_DOCELOWA SWIATLO_CZERWONE KONIECZNOSC_ZMIANY BRAK - - BRAK KROTKA BARDZO_PUSTA KROTKO MALA KROTKA BARDZO_PUSTA UMIARKOWANIE MALA KROTKA BARDZO_PUSTA DLUGO UMIARKOWANA KROTKA PUSTA KROTKO MALA KROTKA PUSTA UMIARKOWANIE MALA KROTKA PUSTA DLUGO UMIARKOWANA KROTKA UMIARKOWANIE_ZAPELNIONA KROTKO MALA KROTKA UMIARKOWANIE_ZAPELNIONA UMIARKOWANIE MALA KROTKA UMIARKOWANIE_ZAPELNIONA DLUGO UMIARKOWANA KROTKA ZAPELNIONA KROTKO MALA KROTKA ZAPELNIONA UMIARKOWANIE MALA KROTKA ZAPELNIONA DLUGO UMIARKOWANA KROTKA BARDZO_ZAPELNIONA KROTKO MALA KROTKA BARDZO_ZAPELNIONA UMIARKOWANIE MALA KROTKA BARDZO_ZAPELNIONA DLUGO MALA UMIARKOWANA BARDZO_PUSTA KROTKO UMIARKOWANA UMIARKOWANA BARDZO_PUSTA UMIARKOWANIE DUZA UMIARKOWANA BARDZO_PUSTA DLUGO BARDZO_DUZA UMIARKOWANA PUSTA KROTKO UMIARKOWANA

UMIARKOWANA PUSTA UMIARKOWANIE UMIARKOWANA UMIARKOWANA PUSTA DLUGO DUZA UMIARKOWANA UMIARKOWANIE_ZAPELNIONA KROTKO MALA UMIARKOWANA UMIARKOWANIE_ZAPELNIONA UMIARKOWANIE UMIARKOWANA UMIARKOWANA UMIARKOWANIE_ZAPELNIONA DLUGO DUZA UMIARKOWANA ZAPELNIONA KROTKO MALA UMIARKOWANA ZAPELNIONA UMIARKOWANIE MALA UMIARKOWANA ZAPELNIONA DLUGO UMIARKOWANA UMIARKOWANA BARDZO_ZAPELNIONA KROTKO MALA UMIARKOWANA BARDZO_ZAPELNIONA UMIARKOWANIE MALA UMIARKOWANA BARDZO_ZAPELNIONA DLUGO UMIARKOWANA DLUGA BARDZO_PUSTA KROTKO UMIARKOWANA DLUGA BARDZO_PUSTA UMIARKOWANIE DUZA DLUGA BARDZO_PUSTA DLUGO BARDZO_DUZA DLUGA PUSTA KROTKO UMIARKOWANA DLUGA PUSTA UMIARKOWANIE BARDZO_DUZA DLUGA PUSTA DLUGO BARDZO_DUZA DLUGA UMIARKOWANIE_ZAPELNIONA KROTKO UMIARKOWANA DLUGA UMIARKOWANIE_ZAPELNIONA UMIARKOWANIE UMIARKOWANA DLUGA UMIARKOWANIE_ZAPELNIONA DLUGO DUZA DLUGA ZAPELNIONA KROTKO MALA DLUGA ZAPELNIONA UMIARKOWANIE MALA DLUGA ZAPELNIONA DLUGO DUZA DLUGA BARDZO_ZAPELNIONA KROTKO MALA DLUGA BARDZO_ZAPELNIONA UMIARKOWANIE MALA DLUGA BARDZO_ZAPELNIONA DLUGO UMIARKOWANA BARDZO_DLUGA BARDZO_PUSTA KROTKO DUZA BARDZO_DLUGA BARDZO_PUSTA UMIARKOWANIE BARDZO_DUZA BARDZO_DLUGA BARDZO_PUSTA DLUGO BARDZO_DUZA BARDZO_DLUGA PUSTA KROTKO DUZA BARDZO_DLUGA PUSTA UMIARKOWANIE DUZA BARDZO_DLUGA PUSTA DLUGO DUZA BARDZO_DLUGA UMIARKOWANIE_ZAPELNIONA KROTKO UMIARKOWANA BARDZO_DLUGA UMIARKOWANIE_ZAPELNIONA UMIARKOWANIE DUZA BARDZO_DLUGA UMIARKOWANIE_ZAPELNIONA DLUGO DUZA BARDZO_DLUGA ZAPELNIONA KROTKO UMIARKOWANA BARDZO_DLUGA ZAPELNIONA UMIARKOWANIE UMIARKOWANA BARDZO_DLUGA ZAPELNIONA DLUGO DUZA BARDZO_DLUGA BARDZO_ZAPELNIONA KROTKO MALA BARDZO_DLUGA BARDZO_ZAPELNIONA UMIARKOWANIE MALA BARDZO_DLUGA BARDZO_ZAPELNIONA DLUGO UMIARKOWANA

Implementacja reguł została zawarta opisana w rozdziale 6.3. 7.3. Implementacja logiki rozmytej w języku FCL Do implementacji logiki rozmytej w projekcie użyto języka FCL (Fuzzy Control Language) dokładny opis języka jest zawarty w dokumentacji IEC 1131-710. Pliki logiki rozmytej dla obliczania konieczności zmiany dla kombinacji, która jest aktualnie nie aktywna (światło czerwone) oraz konieczności przedłużenia bieżącej kombinacji (światło zielone) zostały zdefiniowane odpowiednio w plikach: fuzzy-czerwone.txt (listing 9) oraz fuzzy-zielone.txt (listing 10). Poszczególne sekcje w obu plikach oznaczają:

VAR_INPUT - deklaracja zmiennych wejściowych VAR_OUTPUT - deklaracja zmiennych wyjściowych FUZZIFY - fuzyfikacja (rozmywanie) zmiennych - TERM definiuje zbiory rozmyte

za pomocą punktów opisanych parą (x,y), gdzie x jest wartością zmiennej wejściowej, a y – stopniem przynależności elementu x do definiowanego zbioru, a więc wartością z przedziału [0,1]

10 http://www.fuzzytech.com/binaries/ieccd1.pdf

DEFUZZIFY - defuzyfikacja (wyostrzanie) - METHOD – metoda wyostrzania (znajdowania wartości ostrej reprezentującej zbiór rozmytego) może być jedną spośród następujących metod:

o COG (Center of Gravity) o COGS (Center of Gravity for Singletons) o COA (Center of Area) o LM (Left Most Maximum) o RM (Right Most Maximum)

RULEBLOCK - definicje reguł rozmytych - należy zdefiniować operator and, or, act (metodę aktywacji reguły) wraz z algorytmem np: AND : MIN; ACT : MIN; oraz metodę akumulacji (agregacji) reguł (jedną z BoundedSum, Max, ProbOr, Sum, NormedSum) np. ACCU : MAX; A następnie zdefiniować zabiór reguł w postaci "RULE 2 : IF ZMIENNA_WE is ZBIOR_ROZMYTY_WE and/or ZMIENNA_WE2 is ZBIOR_ROZMYTY_WE then ZMIENNA_WE is ZBIOR_ROZMYTY_WY;

Listing 9. Plik logiki rozmytej dla aktualnie nieaktywnej kombinacji FUNCTION_BLOCK complexmamdani VAR_INPUT KOLEJKA: REAL; DROGA_DOCELOWA: REAL; SWIATLO_CZERWONE: REAL; END_VAR FUZZIFY KOLEJKA TERM BRAK := (-25, 0) (0, 1) (25, 0); TERM KROTKA := (0, 0) (25, 1) (50, 0); TERM UMIARKOWANA := (25,0) (50, 1) (75, 0); TERM DLUGA := (50, 0) (75, 1) (100, 0); TERM BARDZO_DLUGA := (75, 0) (100, 1) (125, 0); END_FUZZIFY FUZZIFY DROGA_DOCELOWA TERM BARDZO_PUSTA := (-25, 0) (0, 1) (25, 0); TERM PUSTA := (0, 0) (25, 1) (50, 0); TERM UMIARKOWANANIE_ZAPELNIONA := (25,0) (50, 1) (75, 0); TERM ZAPELNIONA := (50, 0) (75, 1) (100, 0); TERM BARDZO_ZAPELNIONA := (75, 0) (100, 1) (125, 0); END_FUZZIFY FUZZIFY SWIATLO_CZERWONE TERM KROTKO := (-30, 0) (0, 1) (30, 0); TERM UMIARKOWANIE := (0, 0) (30, 1) (60, 0); TERM DLUGO := (30, 0) (60, 1) (90, 0); END_FUZZIFY VAR_OUTPUT KONIECZNOSC_ZMIANY: REAL; END_VAR DEFUZZIFY KONIECZNOSC_ZMIANY TERM BRAK := (-0.25, 0) (0, 1) (0.25, 0); TERM MALA := (0, 0) (0.25, 1) (0.5, 0); TERM UMIARKOWANA := (0.25, 0) (0.5, 1) (0.75, 0); TERM DUZA := (0.5, 0) (0.75, 1) (1, 0); TERM BARDZO_DUZA := (0.75, 0) (1, 1) (1.25, 0); END_DEFUZZIFY RULEBLOCK NO1 // Użycie 'min' dla metody and (aktywacji reguły) -> DeMorgan 'max' dla metody or AND : MIN; // Metoda aktywacji 'min' ACT : MIN; // metoda akumulacji 'max' ACCU : MAX; RULE 1 : IF KOLEJKA is BRAK then KONIECZNOSC_ZMIANY is BRAK;

RULE 2 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 3 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 4 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 5 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 6 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 7 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 8 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 9 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 10 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 11 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 12 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 13 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 14 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 15 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 16 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is MALA; RULE 17 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 18 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is DUZA; RULE 19 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 20 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 21 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 22 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is DUZA; RULE 23 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 24: IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 25 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is DUZA; RULE 26 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 27 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 28 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 29 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 30 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 31 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 32 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 33 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is DUZA; RULE 34 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 35 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 36 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 37 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 38 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 39 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and

SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 40 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is DUZA; RULE 41 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 42 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 43 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is DUZA; RULE 44 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 45 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 46 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 47 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is DUZA; RULE 48 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 49 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 50 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is DUZA; RULE 51 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is DUZA; RULE 52 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is PUSTA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is BARDZO_DUZA; RULE 53 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 54 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is DUZA; RULE 55 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is DUZA; RULE 56 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 57 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is UMIARKOWANA; RULE 58 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is DUZA; RULE 59 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is KROTKO then KONIECZNOSC_ZMIANY is MALA; RULE 60 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is UMIARKOWANIE then KONIECZNOSC_ZMIANY is MALA; RULE 61 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA and SWIATLO_CZERWONE is DLUGO then KONIECZNOSC_ZMIANY is UMIARKOWANA; END_RULEBLOCK END_FUNCTION_BLOCK

Listing 10. Plik logiki rozmytej dla aktualnie aktywnej kombinacji FUNCTION_BLOCK complexmamdani VAR_INPUT KOLEJKA: REAL; DROGA_DOCELOWA: REAL; END_VAR FUZZIFY KOLEJKA TERM BRAK := (-25, 0) (0, 1) (25, 0); TERM KROTKA := (0, 0) (25, 1) (50, 0); TERM UMIARKOWANA := (25,0) (50, 1) (75, 0); TERM DLUGA := (50, 0) (75, 1) (100, 0); TERM BARDZO_DLUGA := (75, 0) (100, 1) (125, 0); END_FUZZIFY FUZZIFY DROGA_DOCELOWA TERM BARDZO_PUSTA := (-25, 0) (0, 1) (25, 0); TERM PUSTA := (0, 0) (25, 1) (50, 0); TERM UMIARKOWANANIE_ZAPELNIONA := (25,0) (50, 1) (75, 0); TERM ZAPELNIONA := (50, 0) (75, 1) (100, 0); TERM BARDZO_ZAPELNIONA := (75, 0) (100, 1) (125, 0); END_FUZZIFY

VAR_OUTPUT KONIECZNOSC_PRZEDLUZENIA: REAL; END_VAR DEFUZZIFY KONIECZNOSC_PRZEDLUZENIA TERM BRAK := (-0.25, 0) (0, 1) (0.25, 0); TERM MALA := (0, 0) (0.25, 1) (0.5, 0); TERM UMIARKOWANA := (0.25, 0) (0.5, 1) (0.75, 0); TERM DUZA := (0.5, 0) (0.75, 1) (1, 0); TERM BARDZO_DUZA := (0.75, 0) (1, 1) (1.25, 0); END_DEFUZZIFY RULEBLOCK NO1 AND : MIN; ACT : MIN; ACCU : MAX; RULE 1 : IF KOLEJKA is BRAK then KONIECZNOSC_PRZEDLUZENIA is BRAK; RULE 2 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_PUSTA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 3 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is PUSTA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 4 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 5 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 6 : IF KOLEJKA is KROTKA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 7 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_PUSTA then KONIECZNOSC_PRZEDLUZENIA is DUZA; RULE 8 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is PUSTA then KONIECZNOSC_PRZEDLUZENIA is DUZA; RULE 9 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is UMIARKOWANA; RULE 10 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 11 : IF KOLEJKA is UMIARKOWANA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 12 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA then KONIECZNOSC_PRZEDLUZENIA is BARDZO_DUZA; RULE 13 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is PUSTA then KONIECZNOSC_PRZEDLUZENIA is DUZA; RULE 14 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is UMIARKOWANA; RULE 15 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 16 : IF KOLEJKA is DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 17 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_PUSTA then KONIECZNOSC_PRZEDLUZENIA is BARDZO_DUZA; RULE 18 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is PUSTA then KONIECZNOSC_PRZEDLUZENIA is BARDZO_DUZA; RULE 19 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is UMIARKOWANANIE_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is UMIARKOWANA; RULE 20 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; RULE 21 : IF KOLEJKA is BARDZO_DLUGA and DROGA_DOCELOWA is BARDZO_ZAPELNIONA then KONIECZNOSC_PRZEDLUZENIA is MALA; END_RULEBLOCK END_FUNCTION_BLOCK

8. Program Fuzzy Traffic Light Controller 8.1. Możliwości Fuzzy Traffic Light Controller Jest programem opracowanym na potrzeby projektu. Jego głównymi cechami jest: graficzna reprezentacja zbiorów rozmytych, wnioskowania rozmytego możliwość ładowania plików logiki rozmytej dla układów wnioskowania rozmytego

opisanego w rozdziale 7.2 oraz 7.3 możliwość testowania reguł rozmytych z graficzną interpretacją wyniku uruchamianie oraz kontrola pracy symulatora SUMO (konieczne jest wskazanie pliku

konfiguracji opisanego w rozdziale 6.1 automatycznie wykrywanie skrzyżowań sterownych sygnalizacją świetlną możliwość przypisania pliku kombinacji sygnalizacji świetlnej (rozdział 6.2) do każdego

z skrzyżowań automatyczne przypisywanie detektorów zajętości pasów do skrzyżowań (muszą być

wcześniej zdefiniowane) możliwość ręcznej kontroli sygnalizacji świetlnej na każdym skrzyżowaniu możliwość rozmytej kontroli sygnalizacji świetlnej na każdym skrzyżowaniu -

z wykorzystaniem załadowanych plików logiki rozmytej oraz plików kombinacji dla danej sygnalizacji świetlnej

podgląd stanu sygnalizacji świetlnej dla każdego skrzyżowania domyślna kontrola sygnalizacji świetlnej odbywa się z wykorzystaniem cykli czasowych

wygenerowanych przez NETCONVERT 8.2. Opis klas Fuzzy Traffic Light Controller Diagram klas zastosowany w programie został przedstawiony na rysunku 16. Klasy oraz ich funkcje w programie: WnioskowaczGreenLight - klasa odpowiedzialna za Fuzzy Inference System dla

aktualnie trwającej kombinacji sygnalizacji świetlnej. Jej zadaniem jest obliczanie potrzeby przedłużenia aktualnej kombinacji.

WnioskowaczRedLight - klasa odpowiedzialna za Fuzzy Inference System kombinacji sygnalizacji świetlnej, która nie jest aktywna. Jej zadaniem jest obliczanie potrzeby zmiany aktualnej kombinacji na kombinacje rozważaną.

XMLCombinationParser - Parser plików możliwości przełączeń sygnalizacji świetlnej dla danego skrzyżowania

TesterPlikowLogikiRozmytej - Tester plików logiki rozmytej - sprawdza, czy zawartość załadowanego pliku, jest poprawna, dokonuje również próbnego wnioskowania.

NextSimStep - klasa implementująca interfejs Runnable - wykonywana jako wątek w określonych odstępach czasu skonfigurowanych w GUI Fuzzy Traffic Light Kontroler - jej zadaniem jest sterowanie symulacją, ustawianie odpowiednich stanów dla sygnalizacji świetlnej, pobieranie z symulacji informacji o ruchu pojazdów.

ListaSwiatel - klasa reprezentująca skrzyżowanie, odpowiedzialna za odpowiednie ustawianie świateł, przechowywanie czasu trwania światła czerwonego, stanu detektorów, długości pasów ruchu, trybu sterowania skrzyżowaniem, zawiera obiekty klasy LightSwitcher - reprezentujące pojedyncze światło.

LightSwitcher - reprezentuje pojedyncze światło - jego stany - oraz reprezentacje graficzną, umożliwia zmianę stanu danego światła poprzez odpowiednią kombinację kliknięć.

FuzzyTesterView - głowna klasa programu, obsługuje interakcje z użytkownikiem, FileNameFilterek - filtr plików wyświetlanych w oknie wyboru pliku. FuzzyConfig - przechowuje ścieżki do plików logiki rozmytej dla FIS 8.3. Implementacja obsługi sygnalizacji świetlnej na skrzyżowaniach. 8.3.1. Pobieranie listy skrzyżowań, odpowiadających im połączeń dróg, detektorów oraz długości dróg na których umiejscowione są detektory. Ścieżka postępowania przy dodawaniu skrzyżowań: -stworzenie repozytorium świateł ulicznych -pobranie wszystkich świateł do repozytorium -przejście przez wszystkie pobrane światła -pobranie kontrolowanych linków w ramach każdego z świateł -pobranie drogi dojazdowej oraz drogi docelowej dla każdego z linków -sprawdzenie czy istnieje detektor przypisany dla każdej z pobranych wcześniej dróg -przypisanie długości drogi do dojazdowej i docelowej każdego z linków -przypisanie plików logiki rozmytej do skrzyżowania (możliwość zdefiniowania wielu plików logiki rozmytej zostanie zaimplementowana w przyszłych wersjach) -dodanie stworzonego obiektu klasy ListaSwaitel to tablicy przechowującej wszystkie obsługiwane sygnalizacje świetlenie w ramach symulacji. Listing 11. Fragment kodu odpowiedzialny za wstępne przygotowanie skrzyżowań Repository<TrafficLight> tlrepo = conn.getTrafficLightRepository(); Set<String> detectorsIDs = null; Set<String> lista = tlrepo.getIDs(); for(String nazwa:lista){ ListaSwiatel listaSwiatel = null; TrafficLight tLight = tlrepo.getByID(nazwa); ControlledLinks linki = tLight.getReadControlledLinksQuery().get(); ControlledLink[][] linkiArray = linki.getLinks(); listaSwiatel = new ListaSwiatel(linkiArray.length, nazwa); Double[] incLen = new Double[linkiArray.length]; Double[] outLen = new Double[linkiArray.length]; for(int i=0; i<linkiArray.length; i++){ ControlledLink clink = linkiArray[i][0]; String incLaneStr = clink.getIncomingLane().getID(); String outLaneStr = clink.getOutgoingLane().getID(); incLen[i]=0.0; outLen[i]=0.0; for(String det:detectorsIDs){ InductionLoop detectorek = ilrepo.getByID(det); Lane lane = detectorek.queryReadLane().get(); if(incLaneStr.equals(lane.getID())){ incLen[i] = detectorek.queryReadLaneLen().get(); break; }

} for(String det:detectorsIDs){ InductionLoop detectorek = ilrepo.getByID(det); Lane lane = detectorek.queryReadLane().get(); if(outLaneStr.equals(lane.getID())){ outLen[i] = detectorek.queryReadLaneLen().get(); break; } } } listaSwiatel.setdlugoscIncLane(incLen); listaSwiatel.setdlugoscOutLane(outLen); if(this.fuzzyConfig.GetGreenLightFile()!=null&&this.fuzzyConfig.GetGreenLightFile().length()>0)listaSwiatel.setFuzzyFileG(this.fuzzyConfig.GetGreenLightFile()); if(this.fuzzyConfig.GetRedLightFile()!=null&&this.fuzzyConfig.GetRedLightFile().length()>0)listaSwiatel.setFuzzyFileR(this.fuzzyConfig.GetRedLightFile()); this.listaKontrolowanychSwiatel.add(listaSwiatel); } 8.3.2. Wybór trybu sterowania sygnalizacją świetlną. Kolejno analizowane są wszystkie elementy tablicy listaSwiatel. Z repozytorium świateł ulicznych pobierane jest światło zgodnie z nazwą zawartą w elemencie listy. Sprawdzana jest wartość logiczna zwracana przez funkcje zawarte w elemencie należącym do listy świateł odpowiednio getDoFuzzy() lub getManualControll(). Przypadek kontroli za pomocą logiki rozmytej zostanie opisany w punkcie 8.3.3. Kontrola ręczna możliwa jest poprzez pobranie ciągu znaków reprezentującego stany poszczególnych świateł z obiektu ListaSwiatel. Ciąg ten jest analizowany poda kątem wystąpień liter 'g', 'y', 'r', a następnie tworzony jest obiekt klasy LightState, do którego zapisywane są wszystkie stany zgodnie z typem wyliczeniowym zawartym w klasie LightState. Tryb automatyczny bazujący na stanach zdefiniowanych w symulatorze SUMO przenosi wartości z symulatora na kontrolki obrazujące stan sygnalizacji świetlnej w Fuzzy Traffic Light Controller. Operacja jest analogiczna do operacji kontroli ręcznej, z tym, że dane przesyłane są w przeciwnym kierunku. Listing 12. Fragment kodu odpowiedzialny za wybór metody sterowania

for (ListaSwiatel swiatlo : listaSwiatel) { Repository<TrafficLight> tlr = this.connection.getTrafficLightRepository(); Repository<InductionLoop> e2Repo = this.connection.getInductionLoopRepository(); TrafficLight tl = tlr.getByID(swiatlo.getNameTL()); Repository<MeMeDetector> repod = connection.getMeMeDetectorRepository(); ControlledLinks kontrolowanePolacznia = tl.getReadControlledLinksQuery().get(); if (swiatlo.getDoFuzzy()) { policzFuzzy(swiatlo.getNameTL()); } else if (swiatlo.getManualControll()) { LightState[] ls = new LightState[tl.getReadCurrentStateQuery().get().lightStates.length]; ls = tl.getReadCurrentStateQuery().get().lightStates;

String swiatla = swiatlo.getLights(); for (int i = 0; i < tl.getReadCurrentStateQuery().get().lightStates.length; i++) { switch (swiatla.charAt(i)) { case 'g': ls[i] = LightState.GREEN; break; case 'r': ls[i] = LightState.RED; break; case 'y': ls[i] = LightState.YELLOW; break; } } TLState tls = new TLState(ls); ChangeLightsStateQuery q = tl.getChangeLightsStateQuery(); q.setValue(tls); q.run(); } else { LightState[] ls = new LightState[tl.getReadCurrentStateQuery().get().lightStates.length]; ls = tl.getReadCurrentStateQuery().get().lightStates; char[] literoweSwiatla = new char[tl.getReadCurrentStateQuery().get().lightStates.length]; swiatlo.updateLights(String.copyValueOf(literoweSwiatla)); ControlledLinks links = tl.getReadControlledLinksQuery().get(); for (int i = 0; i < tl.getReadCurrentStateQuery().get().lightStates.length; i++) { switch (ls[i]) { case GREEN: case GREEN_NODECEL: literoweSwiatla[i] = 'g'; break; case RED: case RED_NODECEL: literoweSwiatla[i] = 'r'; break; case YELLOW: case YELLOW_NODECEL: literoweSwiatla[i] = 'y'; break; } ControlledLink link = links.getLinks()[i][0]; Repository<Lane> lrepo = connection.getLaneRepository(); Lane lane = lrepo.getByID(link.getIncomingLane().getID()); } swiatlo.updateLights(String.copyValueOf(literoweSwiatla)); } }

8.3.3. Wyznaczanie optymalnej kombinacji przełączenia sygnalizacji świetlnej za pomocą logiki rozmytej. Wyznaczanie optymalnej kombinacji przełączenia sygnalizacji świetlnej za pomocą logiki rozmytej, odbywa się przez obliczenie konieczności przedłużenia aktualnie trwającej kombinacji jak również obliczenie potrzeby zmiany na jedną z kombinacji nieaktywnych. Metoda zaprezentowana na listingu 13 jest programistycznym opisem założeń rozdziału 7. Obliczanie zajętości pasa ruchu odbywa się przez pobranie liczby samochodów znajdujących się na pasie ruchu, jego długości, wyznaczeniu maksymalnej liczby samochodów na pasie. Wykonując dzieląc aktualną liczbę samochodów przez maksymalna liczbę samochodów na pasie otrzymuje się zajętość pasa w przedziale od 0 do 1. W celu poprawnego wnioskowania z przygotowanym FIS należy wartość tą pomnożyć przez liczbę 100. Czas trwania światła czerwonego przechowywany jest w specjalnie stworzonej tablicy przechowującej wartości trwania świateł dla poszczególnych sygnalizatorów. Inkrementacja tych wartości odbywa się podczas każdego kolejnego kroku symulacji, zerowanie podczas zmiany stanu sygnalizatora na inny. Listing 13. Fragment kodu odpowiedzialny za wyznaczanie najlepszej możliwej konfiguracji świateł

ListaSwiatel swiatlo = null; for (int p = 0; p < listaSwiatel.size(); p++) { if (listaSwiatel.get(p).getNameTL().equals(name)) { swiatlo = listaSwiatel.get(p); if (this.wnioskowaczGL == null) { this.wnioskowaczGL = new WnioskowaczGreenLight(swiatlo.getGfuzzy()); } if (this.wnioskowaczRL == null) { this.wnioskowaczRL = new WnioskowaczRedLight(swiatlo.getRfuzzy()); } } } if (swiatlo.getCombinations().length > 0) { Repository<TrafficLight> tlr = this.connection.getTrafficLightRepository(); Repository<InductionLoop> repod=connection.getInductionLoopRepository(); TrafficLight tl = tlr.getByID(name); ControlledLinks kontrolowanePolacznia = tl.getReadControlledLinksQuery().get(); int kombinacje[][] = swiatlo.getCombinations(); Double[] koniecznoscZmianyDlaKombinacji = new Double[kombinacje.length]; System.out.println("Fuzzy Junction: " + name); for (int k = 0; k < kombinacje.length; k++) { System.out.print(Integer.valueOf(k).toString() + " "); int[] kombinacja = kombinacje[k]; koniecznoscZmianyDlaKombinacji[k] = 0.0; if (k == swiatlo.getAktualnyIndex()) { for (int l = 0; l < kombinacja.length; l++) { if (kombinacja[l] == 1) { System.out.print(Integer.valueOf(l).toString() + ": "); ControlledLink clink = kontrolowanePolacznia.getLinks()[l][0]; String incLaneStr = clink.getIncomingLane().getID(); String outLaneStr = clink.getOutgoingLane().getID(); String incLaneDetectorStr = null; String outLaneDetectorStr = null; for (String det : repod.getIDs()) { InductionLoop detectorek = repod.getByID(det); Lane lane = detectorek.queryReadLane().get();

if (incLaneStr.equals(lane.getID())) { incLaneDetectorStr = detectorek.getID(); break; } } for (String det : repod.getIDs()) { InductionLoop detectorek = repod.getByID(det); Lane lane = detectorek.queryReadLane().get(); if (outLaneStr.equals(lane.getID())) { outLaneDetectorStr = detectorek.getID(); break; } } InductionLoop incDetector = null; InductionLoop outDetector = null; if (outLaneDetectorStr != null && incLaneDetectorStr != null) { incDetector = repod.getByID(incLaneDetectorStr); outDetector = repod.getByID(outLaneDetectorStr); } if (incDetector != null && outDetector != null) { Double maxSamochodowInc = swiatlo.getDlugoscIncLaneOfLink(l)/dlSamochodu; maxSamochodowInc = Math.ceil(maxSamochodowInc); Double zajetoscInc = incDetector.queryReadLastStepVehicleNumber().get().doubleValue() /maxSamochodowInc; Double maxSamochodowOut = swiatlo.getDlugoscOutLaneOfLink(l)/dlSamochodu; maxSamochodowOut = Math.ceil(maxSamochodowOut); Double zajetoscOut = outDetector.queryReadLastStepVehicleNumber().get().doubleValue() / maxSamochodowOut; if (zajetoscOut > 1.0) { zajetoscOut = 1.0; } if (zajetoscInc > 1.0) { zajetoscInc = 1.0; } zajetoscInc *= 100; zajetoscOut *= 100; Double koniecznoscPrzedluzenia = wnioskowaczGL.Wnioskuj(zajetoscInc, zajetoscOut); System.out.println(""); koniecznoscZmianyDlaKombinacji[k] += koniecznoscPrzedluzenia; } } } } else { for (int l = 0; l < kombinacja.length; l++) { if (kombinacja[l] == 1) { System.out.print(Integer.valueOf(l).toString() + ": "); ControlledLink clink = kontrolowanePolacznia.getLinks()[l][0]; String incLaneStr = clink.getIncomingLane().getID(); String outLaneStr = clink.getOutgoingLane().getID(); String incLaneDetectorStr = null; String outLaneDetectorStr = null; for (String det : repod.getIDs()) { InductionLoop detectorek = repod.getByID(det); Lane lane = detectorek.queryReadLane().get(); if (incLaneStr.equals(lane.getID())) { incLaneDetectorStr = detectorek.getID(); break;

} } for (String det : repod.getIDs()) { InductionLoop detectorek = repod.getByID(det); Lane lane = detectorek.queryReadLane().get(); if (outLaneStr.equals(lane.getID())) { outLaneDetectorStr = detectorek.getID(); break; } } InductionLoop incDetector = null; InductionLoop outDetector = null; if (outLaneDetectorStr != null && incLaneDetectorStr != null) { incDetector = repod.getByID(incLaneDetectorStr); outDetector = repod.getByID(outLaneDetectorStr); } if (incDetector != null && outDetector != null) { Double maxSamochodowInc = swiatlo.getDlugoscIncLaneOfLink(l) / dlSamochodu; maxSamochodowInc = Math.ceil(maxSamochodowInc); Double zajetoscInc = incDetector.queryReadLastStepVehicleNumber().get().doubleValue() / maxSamochodowInc; Double maxSamochodowOut = swiatlo.getDlugoscOutLaneOfLink(l) / dlSamochodu; maxSamochodowOut = Math.ceil(maxSamochodowOut); Double zajetoscOut = outDetector.queryReadLastStepVehicleNumber().get().doubleValue() / maxSamochodowOut; if (zajetoscOut > 1.0) { zajetoscOut = 1.0; } if (zajetoscInc > 1.0) { zajetoscInc = 1.0; } zajetoscInc *= 100; zajetoscOut *= 100; int czas = swiatlo.getCzasyTrwaniaSwiatla(l); Double koniecznoscZmiany = wnioskowaczRL.Wnioskuj(zajetoscInc, zajetoscOut, Integer.valueOf(czas).doubleValue()); System.out.println(""); koniecznoscZmianyDlaKombinacji[k] += koniecznoscZmiany; } } } } System.out.println(" Koniecznosc zmiany dla kombinacji :" + Integer.valueOf(k).toString() + koniecznoscZmianyDlaKombinacji[k].toString()); } int maxIndex = 0; Double maxValue = 0.0; for (int o = 0; o < koniecznoscZmianyDlaKombinacji.length; o++) { if (koniecznoscZmianyDlaKombinacji[o] > maxValue) { maxIndex = o;

maxValue = koniecznoscZmianyDlaKombinacji[o]; } } System.out.println("Najelpsza kombinacja to: " + Integer.valueOf(maxIndex).toString()); if (maxIndex != swiatlo.getAktualnyIndex()) { swiatlo.updateLights(maxIndex); } else { swiatlo.updateLights(swiatlo.getAktualnyIndex()); } LightState[] ls = new LightState[tl.getReadCurrentStateQuery().get().lightStates.length]; String swiatla = swiatlo.getLights(); for (int i = 0; i < tl.getReadCurrentStateQuery().get().lightStates.length; i++) { switch (swiatla.charAt(i)) { case 'g': ls[i] = LightState.GREEN; break; case 'r': ls[i] = LightState.RED; break; case 'y': ls[i] = LightState.YELLOW; break; } } TLState tls = new TLState(ls); ChangeLightsStateQuery q = tl.getChangeLightsStateQuery(); q.setValue(tls); q.run(); //tylko testowo } return 0; } 8.4. Opis GUI Fuzzy Traffic Light Controller Główne okno programu Fuzzy Traffic Light Controller zawiera zestaw zakładek oraz menu umożliwiających jego pełne wykorzystanie. Struktura menu:

Plik →Koniec - umożliwia zakończenie programu (rys. 17)

Rys. 17. Fuzzy Traffic Controll - menu Plik

SUMO → Otwórz plik konfiguracji - pozwala na wskazanie pliku konfiguracyjnego

dla SUMO GUI (rys. 18) SUMO → Wskaż lokalizację SUMO - pozwala na wskazanie zmodyfikowanego pliku

wykonywalnego symulatora SUMO - wersja oficjalna nie będzie funkcjonowała poprawnie - (rys. 18)

Rys. 18. Fuzzy Traffic Controll - menu SUMO

Logika rozmyta → Otwórz plik logiki Red light - pozwala na wskazanie pliku logiki

rozmytej dla nieaktywnej kombinacji świateł (rys. 19) Logika rozmyta → Otwórz plik logiki Green light - pozwala na wskazanie pliku logiki

rozmytej dla aktywnej kombinacji świateł (rys. 19)

Rys. 19. Fuzzy Traffic Controll - menu Logika rozmyta

Pomoc → O programie - wyświetla informacje o programie - kontakt z autorem

Log systemowy, program został wyposażony w pole klasy JTextEdit pełniący funkcje konsoli do której przekierowane są strumienie wyjściowe. W konsoli ukazywane są komunikaty o wykonanych czynnościach, informacje diagnostyczne, oraz wyjątki o ile występują. Widok konsoli został ukazany na rys. 20.

Rys. 20. Fuzzy Traffic Controll - konsola diagnostyczna

Główne okno programu zawiera kilka zakładek, każda zakładka oferuje pewien zakres funkcjonalności programu. Zakładka SUMO, dostarcza informacji o statusie wczytanych plików konfiguracyjnych, wskazaniu pliku wykonywalnego sumo-gui.exe. Pozwala na rozpoczęcie, zatrzymanie, wznowienie symulacji, oraz pozwala zdefiniować krok z jakim będzie się odbywała symulacja. Widok zakładki SUMO został przedstawiony na rys. 22.

Rys. 22. Fuzzy Traffic Controll - zakładka SUMO

Zakładka Światła jest odpowiedzialna za wyświetlanie aktualnego stanu sygnalizacji świetlnej dla aktualnie uruchomionej symulacji. Umożliwia wybór trybu sterownia dla danego skrzyżowania. Załadowanie plików kombinacji sygnalizacji świetlnej oraz umożliwia ręczną kontrolę sygnalizacji świetlnej. Widok zakładki Światła został przedstawiony na rys. 23. Zaznaczanie opcji manual powoduje przełączanie trybu sterownia na ręczny - zmiana świateł jest możliwa poprzez kliknięcie na symbol reprezentujący dane światło. Wybranie trybu Fuzzy, spowoduje wyświetlenie żądania wskazania pliku kombinacji opisywanego w rozdziale 6.2. Zmiana kombinacji obrazowana jest przez zmianę odpowiedniego kwadratu. Numeracja sygnalizacji jest zgodna z numeracją przedstawioną w rozdziale 4.5. Każde skrzyżowań jest opisane nazwą znajdującą się powyżej kwadratów reprezentujących światła.

Rys. 23. Fuzzy Traffic Controll - zakładka SUMO

Zakładka Fuzzy informuje o stanie, oraz poprawności załadowanych plików logiki rozmytej. Umożliwia również wyświetlenie wykresów logiki rozmytej po zaznaczeniu odpowiedniego JCheckBox. Widok zakładki Światła został przedstawiony na rys. 24.

Rys. 24. Fuzzy Traffic Controll - zakładka Fuzzy

Zaznaczenie odpowiedniego JCheckBox powoduje wyświetlenie wykresów zbiorów rozmytych w nowo otwartych oknach zgodnie z rys. 25.

Rys. 25. Fuzzy Traffic Controll - wizualizacja zbiorów rozmytych

Zakładka Fuzzy Red light tester oraz Fuzzy Green light tester umożliwiają przeprowadzenie testów zasad logiki rozmytej zdefiniowanych w załadowanych plikach logiki rozmytej. Parametry wejściowe obu FIS zostały szczegółowo opisane w rozdziale 6. Obliczona wartość jest umieszczana w odpowiednim polu tekstowym, na życzenie użytkownika (poprzez zaznaczanie odpowiedniego pola JCheckBox) wyświetlany jest rysunek obrazujący dokonane wnioskowanie rozmyte (figurę powstałą w jego wyniku). Oba okna zostały ukazane na rysunkach 26 oraz 27. figury wynikowe są natomiast zawarte jako 2 ostatnie okna na rysunku 25.

Rys. 26. Fuzzy Traffic Controll - testowanie logiki rozmytej dla kombinacji aktualnie nieaktywnej

Rys. 27. Fuzzy Traffic Controll - testowanie logiki rozmytej dla kombinacji aktualnie aktywnej

Rysunek 28 przedstawia uruchomione sterownie przy użyciu logiki rozmytej dla skrzyżowań 0 oraz 1.

Rys. 28. Fuzzy Traffic Controll - Program aktywny obliczający optymalne kombinacje przełączeń dla

skrzyżowań 1 oraz 0

Na rysunku 29. zostało ukazane okno symulatora SUMO z jednym z skrzyżowań kontrolowanych za pomocą logiki rozmytej.

Rys. 29. SUMO - widok skrzyżowania kontrolowanego za pomocą logiki rozmytej

Rys. 16. Diagram klas użytych w programie Fuzzy Traffic Controll