Symulacja systemu wizyjnego w środowisku EPSON RC+ 8

Dzięki temu poradnikowi dowiesz się, jak przygotować symulację systemu wizyjnego. Jest to prosty sposób na zapoznanie się z tym interesującym rozwiązaniem, bez potrzeby posiadania fizycznego sprzętu. Dowiesz się, w jaki sposób dobrać kamerę do wykonywanego zadania, jak ją skalibrować oraz przygotować jej program. Na koniec dowiesz się też, jak wykorzystać ją w praktyce w zadaniu pick and place. Robot nie będzie musiał znać pozycji poruszanych obiektów, wszystkim zajmie się kamera.

Po co wprowadzać systemy wizyjne?

Na początek słów kilka o samych systemach wizyjnych. Dlaczego warto się nimi zainteresować? Powodów jest kilka. Systemy wizyjne mają ogromną ilość praktycznych zastosowań, mogą być wykorzystane w kontroli jakości, wspierać pracę ludzi i robotów, a nawet sprawdzać stan techniczny maszyn za pomocą termowizji.

Szczególnie warta uwagi jest integracja robotów z systemami wizyjnymi. Dobrym przykładem są tu roboty SCARA, które dzięki dużej prędkości mogą świetnie sortować lub paletyzować małe elementy. W sytuacji, gdy produkujemy np. małe układy scalone, robot z systemem wizyjnym może szybko lokalizować ich położenie, podnosić je i przenosić do opakowań. Często w takich realizacjach wykorzystuje się stoły wibracyjne, aby spozycjonować elementy, wykryć je kamerą i przenieść z wykorzystaniem robota.

Potrzebne urządzenia i oprogramowania

Do wykonania aplikacji wystarczy oprogramowanie RC+8 firmy EPSON, które można pobrać bezpłatnie ze strony internetowej ASTOR.

W praktyce nic nie stoi na przeszkodzie, żeby wykonać ten projekt na prawdziwym robocie z wykorzystaniem rzeczywistej kamery, jednak w artykule nie będę zagłębiał się w kwestie konfiguracji fizycznego sprzętu. Wszelkie potrzebne informacje można znaleźć w dokumentacji producenta (Vision Guide 8.0 Software oraz Vision Guide 8.0 Hardware & Setup).

Tworzenie nowego projektu

Z uwagi na to, że artykuł ten dotyczy wykorzystania systemów wizyjnych, nie będziemy poruszać tu wszystkich tematów związanych z wykorzystaniem środowiska RC+8.

Pierwszym krokiem do stworzenia symulacji systemu wizyjnego jest stworzenie nowego, pustego projektu.

Po uruchomieniu programu otwiera się okno projektów, wybieramy tam Create New Project.

W zakładce Project Wizard nadajemy nazwę i wybieramy lokalizację, w której chcemy zapisać projekt.

Wybieramy Empty project. Wybór Pick and place with vision w przypadku wirtualnego kontrolera i kamery nie zadziała, dlatego stworzymy projekt od zera.

Łączymy się z wybranym przez nas wirtualnym kontrolerem, możliwe jest też stworzenie sobie kolejnego. Podwójne wciśnięcie myszki na kontrolerze otworzy następne okno. Możliwe jest też połączenie z prawdziwym kontrolerem za pomocą USB.

Wybieramy kontroler z listy i klikamy Connect. Następnie, kiedy przycisk Connect się wyszarzy, a Disconnect będzie aktywny (oznacza to nawiązanie połączenia z kontrolerem) możemy zamknąć to okno. Ukaże nam się wtedy komunikat o poprawnym stworzeniu projektu.

Dodawanie kamery

Po stworzeniu projektu zgodnie z poprzednimi krokami ukazuje się nam ekran pustego projektu.

Zanim zaczniemy pracę z systemem wizyjnym, musimy najpierw uaktywnić jego symulację w ustawieniach.

W górnej zakładce wybieramy Setup -> System Configuration.

Na początku musimy dodać nową kamerę. Aby to zrobić, w zakładce System Configuration -> Vision -> Cameras wciskamy przycisk Add.

Przechodzimy do zakładki Vision -> Cameras i zaznaczamy opcję Virtual. W tym panelu możemy również dobrać naszą kamerę. Zjeżdżając na sam dół opcji, wybieramy Camera Lens Tool.

Należy się również upewnić, że opcja Simulate Camera View in Vision Guide jest zaznaczona, co umożliwi później obsługę kamery w środowisku wirtualnym.

W tej zakładce musimy podać długość i szerokość obszaru, jaki ma widzieć kamera. Opcjonalnie możemy dobierać wysokość, na jakiej ma być zamocowana kamera, konkretny model, soczewki, pierścienie pośrednie, rozdzielczość i typ kamery. Po wciśnięciu opcji Calculate system zaproponuje nam wszystkie pasujące rozwiązania. Należy pamiętać, że im więcej narzucimy wymagań, tym trudniej może być dopasować kamerę.

Istotnym zagadnieniem, na które należy zwrócić uwagę, jest sposób montażu kamery. Sekcja Mounting pozwala na wybór tego, w jaki sposób kamera może być zamontowana względem robota.

Najpierw trzeba zadecydować, czy kamera ma być Fixed (nieruchoma) czy Mobile (ruchoma). Po wyborze opcji mobile, należy zadecydować do którego przegubu ma być podpięta kamera. W zależności od kamery i zastosowania obie opcje są warte wykorzystania, natomiast na początek polecam kamery stacjonarne (Fixed).

Po zatwierdzeniu zmian nowa kamera pojawi się na naszej scenie w symulacji. Przycisk:

w górnej części ekranu otworzy podgląd. Jeśli na scenie nie ma robota lub jest to robot inny, niż chcemy, możemy zmienić to w Setup -> System Configuration -> Controller -> Robots -> Change. W omawianym dalej programie wykorzystany został poniższy robot.

Przygotowanie sceny symulacji

Do stworzenia finalnego programu będą potrzebne następujące elementy:

• robot (w tym przypadku SCARA),
• co najmniej dziewięć obiektów, które robot będzie rozpoznawał i przenosił,
• kamera,
• opcjonalnie elementy otoczenia, z których robot będzie pobierał elementy i na które będzie je układał.

Przykładowa realizacja została przedstawiona poniżej.

Widać tu robota typu SCARA, tackę, na której znajduje się dziewięć małych kulek oraz taśmociąg, na który będą one układane. Nad tacką znajduje się również kamera typu fixed. Jako że jest to środowisko symulacyjne, nie musimy się przejmować tym, że kamera nie jest do niczego przytwierdzona.

Warto tu zauważyć, że czerwona linia idąca od strony kamery to kierunek, w którym skierowany jest obiektyw. Żółty prostokąt to Near Plane, czyli najbliższy kamerze obszar, na jakim może skutecznie pracować, oraz zielony Far Plane, czyli obszar od kamery najdalszy. Dobrym rozwiązaniem jest umieścić obiekty, którymi będzie manipulował robot, pomiędzy tymi obszarami.

Istotnym jest to, żeby początkowo rozmieścić obiekty, które robot będzie rozpoznawał, w taki sposób, aby znajdowały się po trzy w wierszu i po trzy w kolumnie. Będzie to bardzo ważne podczas kalibracji.

Jeśli chcemy podejrzeć podgląd z kamery, należy wejść w zakładkę Vision, klikając przycisk:

w górnej części ekranu.

Początkowo w miejscu obrazu ukaże nam się czarny ekran. Nie oznacza to jednak, że kamera nie działa. Na początku musimy stworzyć nową sekwencję, wciskając pierwszą od lewej ikonę:

Nadajemy sekwencji nazwę i ustawiamy aktywną dla niej kamerę.

Powinien pokazać się nam obraz z kamery, co ułatwi odpowiednie ustawienie elementów w kadrze.

Istnieje szansa, że na obrazie z twojej kamery zaobserwujesz pewne dziwne kształty lub zniekształcenia. Bierze się to z faktu, że niektóre kamery „widzą” część swojego modelu 3D. Aby temu zapobiec wystarczy ustawić w oknie symulacji parametr kamery Visible na False.

Kalibracja i sekwencje

W tej chwili możemy przejść do przygotowania naszej kamery. Wcześniej utworzyłeś coś, co nazywa się „sekwencja”. W RC+8 sekwencja to program kamery, w którym możemy zadecydować, jakie instrukcje ma wykonywać. Całość ustawia się blokowo na schemacie, który pokazuje kolejność wykonywania programu, jak również na ekranie podglądu kamery, gdzie zaznacza się pola, na których dana instrukcja ma działać oraz uczy się model, co ma rozpoznawać. Instrukcje dzielą się na następujące grupy:

• Locate – rozpoznawanie kształtów i ich położenia,
• Count – zliczanie rozpoznanych elementów,
• Inspect – sprawdzanie, czy rozpoznane kształty spełniają określone wymagania,
• Read – czytanie np. kodów QR,
• Image – rozpoznawanie tekstu lub grafiki,
• Execution – bloki decyzyjne.

W naszym projekcie skupimy się na instrukcjach odnajdujących położenie obiektów oraz zliczających je. Oba te kryteria spełnia instrukcja Geometric. Dodanie tej instrukcji skutkuje następującym ekranem.

Na środku ekranu pojawiły się dwa kwadraty. Większy oznacza obszar, na którym program szuka dopasowań, natomiast mniejszy wewnętrzny kwadrat z krzyżykiem w środku to pole, z którego nasz model się nauczy rozpoznawać kształt. Większy kwadrat rozsuńmy na cały ekran, natomiast mniejszy centralnie na jednym z obiektów.

Może się zdarzyć, że rozpoznawany przez nas obiekt nie najlepiej pasuje do kształtu kwadratu, wobec tego możemy zmienić kształt okna, z którego model uczy się kształtu.  Umożliwia to właściwość ModelWin. Można tu zmienić jego pozycję, rozmiar i kształt. Zmieńmy Rectangle na Circle.

W ten sposób udało nam się precyzyjnie dobrać okno, z którego model nauczy się rozpoznawać kształt, do obiektu. Następnie klikamy Teach. Wciśnięcie Run spowoduje uruchomienie programu i wykrycie nauczonego kształtu na obrazie z kamery.

Zielony kolor oblamówki wskazuje na to, że program zadziałał prawidłowo. Zauważmy jednak, że robot wykrył tylko jeden kształt, a obiektów mamy dziewięć. Aby to zmienić należy ustawić parametr NumberToFind na All. Spowoduje to znalezienie wszystkich dostępnych kształtów.

Pierwszy program

Tak przygotowaną kamerę można wykorzystać w najprostszym programie, który będzie w terminalu podawał liczbę zliczonych elementów.

Otwieramy plik main.prg i piszemy następujący kod.

Function main
	Real how_many

	VRun My_seq
	VGet My_seq.Geom1.NumberFound, how_many
	Print “Found “, how_many, “ elements.”
Fend

Po uruchomieniu programu w oknie Run otrzymamy następujący rezultat.

Przyjrzyjmy się teraz bliżej wykorzystanym funkcjom.

Na początku programu tworzymy zmienną typu Real, która przechowuje wartość liczbową. Polecenie VRun My_seq uruchamia wybraną sekwencję (w tym przypadku My_seq) na danej kamerze. Nasza sekwencja obecnie wykrywa wszystkie kształty pasujące do nauczonego modelu.

VGet to polecenie, które umożliwi nam odczytanie wybranych wartości, które sekwencja wyliczyła. Samo VRun jedynie ją uruchamia. Funkcji VGet podajemy jako argument wartość, którą chcemy uzyskać (NumberFound) oraz zmienną, do jakiej chcemy tę wartość zapisać (how_many).

Nasza kamera może mieć wiele sekwencji składających się z wielu instrukcji, dlatego musimy to sprecyzować. Po VGet podajemy nazwę sekwencji, po kropce nazwę instrukcji w sekwencji i po kolejnej kropce zwracany przez nią parametr.

Na sam koniec za pomocą polecenia print wypisujemy w terminalu wartość zmiennej. Jak widać, kamera poprawnie wykryła dziewięć elementów.

Kalibracja

Aktualnie napisany program niestety nie umożliwia realizacji aplikacji pick and place. Dzieje się tak, ponieważ robot nie wie, gdzie w przestrzeni znajdują się obiekty, które kamera widzi. Konieczne jest przeprowadzenie kalibracji. W tym celu należy dodać nową sekwencję kalibracji za pomocą przycisku:

w oknie Vision.

Nadajemy sekwencji nazwę i wybieramy, której kamery ma dotyczyć.  Klikamy Next, a następnie wybieramy, jaki ma być sposób montażu kamery, w naszym przypadku Fixed looking downward. Wybieramy również, którego robota ma się tyczyć kalibracja.

Klikamy Finish i przechodzimy do procesu uczenia punktów. W tym momencie istotne staje się to, dlaczego potrzebujemy akurat dziewięciu obiektów. Proces uczenia robota punktów kalibracyjnych polega na tym, że musimy podjechać końcówką roboczą robota jak najbliżej punktów, które widać w kamerze. Obiekty w kamerze powinny być ustawione tak, aby każdy znajdował się w innym segmencie ekranu. Nie jest to jednak warunek konieczny. W sytuacji, kiedy nie byłoby możliwości dojechania robotem do najdalszych punktów, można ustawić punkty kalibracyjne ciaśniej, jednak zachowując ich układ. Kliknięcie Teach points otworzy następujące okno:

Jak widać, każda z kul znajduje się w innej części ekranu. Robot musi podjechać jak najbliżej każdej z nich, należy również pamiętać o zachowaniu odpowiedniej wysokości od detalu. Im większa staje się odległość od środka kamery, tym istotniejszą rolę odgrywa perspektywa. Warto tutaj posłużyć się widokiem symulacji, sprawdzając koordynaty naszych obiektów i dojeżdżając robotem jak najbliżej i klikając Teach.

Po skończeniu procesu uczenia punktów kalibracyjnych klikamy Calibrate. Nie jest to jednak koniec. Robot zna fizyczne umiejscowienie obiektów względem kamery, jednak nie wie, jak one się zmienią wraz z zmianą obrazu, czyli przesunięciem istniejących obiektów.

Aby skończyć proces kalibracji, należy stworzyć nową sekwencję i utworzyć na niej dziewięć oddzielnych instrukcji, z których każda wykryje jeden obiekt w jednym z dziewięciu segmentów ekranu. Wystarczy stworzyć i nauczyć jednego obiektu, a następnie go skopiować. Nie trzeba za każdym razem dopasowywać okna uczenia do obiektu, jeśli kopiujemy nauczony model.

Alternatywnie prostszą metodą jest stworzyć jedną instrukcję, który ma wykryć dziewięć obiektów. Oba sposoby zadziałają.

Ważne, żeby w parametrach naszych sekwencji ustawić, z jakiej kalibracji mają korzystać.

Na koniec możemy dodać do naszej głównej sekwencji instrukcje Coordinates. Jest to opcjonalny krok, ponieważ sama instrukcja Geom też przechowuje dane o swojej pozycji. W uzasadnionych przypadkach (np. przy użyciu kilku instrukcji rozpoznających kształty i bloków decyzyjnych), użycie Coordinates może być konieczne.  Niemniej jednak służy ona do przechowywania wyznaczonych przez poprzednią instrukcję koordynatów. Aby to zadziałało, w naszej instrukcji Geom1 należy ustawić parametr CoordObject na nazwę dodanego bloku Coordinates.

Jeśli kalibracja przebiegła poprawnie, tak napisany program pozwoli wyznaczyć pozycje w przestrzeni obiektów zaobserwowanych na kamerze.

Pick and Place

Realizacja aplikacji Pick and Place odbywa się przez wykorzystanie poniższego programu.

Function main
	Motor On
	Power High
	Speed 100
	Accel 100, 100
	 
	Real number_found, x, y, u, i
	 
	Print "Program has started!"
	Wait .1
	 
	Go P_HOME
	VRun My_seq
	 
	For i = 1 To number_found
		VGet My_seq.Coords.RobotXYU(i), found, x, y, u
		pick = XY(x, y, -65, u)
		Print "Coordinates ", i, ": ", pick
		Jump pick
		On Gripper_on
		Wait .2
		place = place_origin + XY(0, -20 * (i - 1), 0, 0)
		Jump place
		Off Gripper_on
		Wait .2
	Next
	 
	Jump P_HOME
	Motor Off
 
Fend

Na początku program uruchamia silniki i wchodzi w tryb dużej mocy, pełnej prędkości, maksymalnego przyśpieszenia i opóźnienia. Następnie tworzymy zmienne Real będące odpowiednio: liczbą rozpoznanych elementów, pozycją X, Y, U rozpoznanego obiektu oraz liczbą iteracji pętli. Print informuje nas o rozpoczęciu programu. Polecenie Go P_HOME przemieszcza robota na pozycję nie zasłaniającą kamerze widoku na obiekty. VRun uruchamia sekwencję kamery, która rozpoznaje obiekty w kadrze.

Następnie pętla for trwająca tyle iteracji, ile kamera rozpoznała obiektów, pozyskuje za pomocą VGet.My_seq.Coords.RobotXYU(i) współrzędne rozpoznanego obiektu o indeksie i wskazując na jeden z kolejnych rozpoznawanych obiektów. Funkcja ta zwraca wartości do zmiennych x, y i u.  Później stworzony zostaje punkt pick, zadeklarowany za pomocą funkcji XY(), który jako argumenty przyjmuje pozycję (x, y, u) zwróconą przez poprzednią komendę.

Warto nadmienić, że komenda XY() domyślnie tworzy punkt w konfiguracji Righty. Jeśli chcemy zmienić ją na Lefty, należy zastosować dodatkowy argument /L na końcu, np.

pick = XY(x, y, -65, u) /L

Jest to bardzo istotne, np. przy unikaniu kolizji. Wartość -65 to odległość, na jaką ma poruszyć się oś Z robota, należy ją dobrać w zależności od umiejscowienia manipulowanych obiektów. Późniejsze print wypisuje w terminalu pozycję wykrytego punktu, co może posłużyć do sprawdzenia poprawności działania systemu wizyjnego. Polecenia Jump wykonują ruchy do konkretnych punktów, On oraz Off steruje wcześniej zadeklarowanym sygnałem chwytaka, natomiast punkt place jest tak wyliczany, aby ustawiać obiekty w pojedynczym szeregu.

Tak napisany program teoretycznie spełni swoje założenia. Teoretycznie, ponieważ w środowisku symulowanym otwarcie i zamknięcie chwytaka za pomocą sygnału nie da efektu. Musimy zastosować tu polecenia SimSet i SimGet, które umożliwiają sterowanie symulacją. Cały problem polega na tym, że przed rozpoczęciem programu nie wiemy, gdzie podjedzie robot, ponieważ nie wiemy, gdzie leżą manipulowane elementy ani nawet ile ich jest. W tym celu powstały dodatkowe funkcje opisane poniżej:

Global Real Sphere_index

Function sim_take
    
    Sphere_index = 0
    Double x, y, obj_x(9), obj_y(9), i
    String obj$(9)
    
    WaitPos
    P_compare = Here
    x = CX(P_compare)
    y = CY(P_compare)
    
    For i = 1 To 9
        obj$(i) = "Sphere_" + Str$(i)
        SimGet obj$(i).PositionX, obj_x(i)
        SimGet obj$(i).PositionY, obj_y(i)
        
        If Abs(x - obj_x(i)) < 2 And Abs(y - obj_y(i)) < 2 Then
            Sphere_index = i
            SimSet Pierwszy_robot.Pick, obj$(i)
        EndIf
    Next
    
Fend

Function sim_put
    Double i
    String obj$(9)
    
    For i = 1 To 9
        obj$(i) = "Sphere_" + Str$(i)
        If Sphere_index = i Then
            SimSet Pierwszy_robot.Place, obj$(i)
        EndIf
    Next
    
Fend

Funkcja sim_take odczytuje położenie robota oraz wszystkich obiektów na scenie za pomocą poleceń SimGet, następnie wylicza, nad którym obiektem znajduje się robot. Całość dzieje się w pętlach for, gdzie dzięki temu, że obiekty mają uporządkowane nazwy (zakończone kolejno na 1, 2, 3…), możemy łatwo nadpisywać zmienną string i odwoływać się do kolejnych obiektów. Założona jest tu tolerancja 2 mm, która jest na tyle duża, że bez problemu zlokalizuje obiekt i jednocześnie na tyle mała, że będzie żadnego konfliktu między obiektami.

Jeśli któryś warunek zostanie spełniony, to wartość zmiennej Sphere_index zostaje ustawiona na numer konkretnego obiektu, tak że program pamięta, który obiekt aktualnie trzyma. Polecenie SimSet Pierwszy_robot.Pick przypisuje obiekt do chwytaka robota, umożliwiając symulowanie przenoszenia obiektów. Funkcja sim_put w zależności od wcześniej zapamiętanego obiektu wykonuje polecenie SimSet Pierwszy_robot.Place, odkładając wybrany obiekt w aktualnym miejscu.

Poniżej załączono film będący przykładową realizacją tego kodu.