Jak zbudować i zaprogramować aplikację paletyzacji na robocie edukacyjnym Astorino, a następnie przenieść program na robota przemysłowego Kawasaki Robotics

Dzięki temu poradnikowi dowiesz się, jak zbudować i zaprogramować proste stanowisko zrobotyzowane wykorzystujące robota Kawasaki Robotics Astorino. Aplikacja będzie miała na celu wykonanie schematu paletyzacji dostarczanych detali.

Następnie tak utworzony i przetestowany w bezpiecznych warunkach program, wykorzystujący robota edukacyjnego Astorino, zostanie przetestowany na przemysłowym robocie Kawasaki Robotics.

1. Potrzebne urządzenia oraz oprogramowanie

W celu wykonania aplikacji potrzebne elementy to:

• Robot Astorino wraz z oprogramowaniem;
• Wydrukowane kostki lub ich odpowiednik – 27 sztuk – zależnie od liczby iteracji;
• Podajnik kostek sterowany sygnałami I/O z poziomu Astorino;
• Czujnik optyczny do detekcji kostek podłączony do Astorino;
• Chwytak dla Astorino umożliwiający manipulacje kostkami;
• Stanowisko z robotem Kawasaki Robotics z analogicznymi cechami jak wyżej;
• Laptop lub komputer stacjonarny z portem Ethernet oraz USB.

Przybliżony czas wykonywania aplikacji na Kawasaki Robotics Astorino: 120 minut
Robot przemysłowy Kawasaki Robotics: 60 minut

2. Astorino

2.1 Opis stanowiska

W celu wykonania tego ćwiczenia użyta została stacja PRO z robotem Astorino. Stacja wyposażona w robota Astorino, podajnik kostek z czujnikiem oraz system wizyjny 2D.

2.2 Pisanie programu paletyzacji – ETAP I

W celu napisania programu paletyzującego kostki, użyjemy zagnieżdżonych funkcji „FOR”, z których każda pozwoli nam na paletyzację w jednym kierunku (X, Y lub Z).

Zaczniemy od ustanowienia punktu początkowego, w którym robot będzie zaczynał program. Domyślnie będzie to pozycja „home” (rys. 3 B), którą możemy zapisać przy pomocy menu pokazanego poniżej. Należy dojechać w trybie JOG (rys. 3 A) do zadanej pozycji i nacisnąć Set Home (rys. 3 B).

Tworzymy program poprzez naciśnięcie ikonki Nowy Program i ustanowienie nazwy (rys. 4).

Do pozycji „home” dojedziemy z określonymi parametrami. Wykorzystamy funkcje SPEED, DECEL, ACCEL, czyli odpowiednio prędkość, hamowanie, przyspieszenie. Dopisek ALWAYS pozwoli zastosować parametry do całego programu, chyba że zostaną zmienione w trakcie. Przygotujemy też robota do poboru kostek, czyli otworzymy mu chwytak, sterując odpowiednim sygnałem, w naszym przypadku jest to sygnał 57.

Najlepiej użyć do tego podprogramu z dodaną funkcją z małym opóźnieniem t=1 s, aby pozwolić przesterować się przekaźnikowi elektrozaworu. Podprogram wywołujemy funkcją CALL. W tej aplikacji wykorzystujemy chwytak pneumatyczny o rozstawie szczęk odpowiednim do kostek o wymiarach 25x25x25 mm. Te wymiary będą nam definiowały kolejne parametry, takie jak odstępy między kostkami. W kolejnej linijce dodamy też funkcję, która zresetuje nam timer nr 1, który na samym końcu programu pokaże czas cyklu.

Wstępnie napisany program wg. powyższych opisów powinien prezentować się jak poniżej. Dodatkowo stworzymy od razu program zamykający chwytak, który będzie wykorzystywany później.

.PROGRAM Pal_XYZ () ; 
 ; *******************************************************************
 ;
 ; Program: Paletization_XYZ
 ; Comment: Main program for palletization in three dimensions
 ; Author: Lukasz Giza ASTOR
 ;
 ;
 ; *******************************************************************
 ;
  SPEED 50 ALWAYS
  DECEL 80 ALWAYS
  ACCEL 80 ALWAYS 
  CALL open_clamp
  HOME
  timer 1 = 0
  .END

.PROGRAM open_clamp ()
  ; *******************************************************************
  ;
  ; Program:      open_clamp
  ; Comment:      
  ; Author:       User
  ;
  ; Date:         10/23/2024
  ;
  ; *******************************************************************
  ;
  signal -57
  TWAIT 1
.END

.PROGRAM close_clamp ()
  ; *******************************************************************
  ;
  ; Program:      close_clamp
  ; Comment:      
  ; Author:       User
  ;
  ; Date:         10/23/2024
  ;
  ; *******************************************************************
  ;
  signal 57
  TWAIT 1
.END

2.3 Pisanie programu paletyzacji – ETAP II

Teraz przejdziemy do napisania trzech zagnieżdżonych funkcji FOR, i w każdej określimy parametrem wartość, do której będzie wykonywana. Parametry columns_num, rows_num, layers_num, kolejno określą wartości kolumn, wierszy i warstw w aplikacji paletyzacji.

Należy pamiętać, że wartości są liczone od 0, więc w przypadku columns_num=2 będziemy mieli 3 kolumny kostek. Następnie określimy dystanse pomiędzy kostkami.

Kostka ma wymiary 25 mm. Do tej wartości należy doliczyć jeszcze wymiar otwieranych szczęk, dla uproszczenia przyjmiemy podwójną wartość szerokości i głębokości kostki, a w przypadku warstwy jej wysokość +2 mm w przypadku nierówności stołu. Każdą funkcję piszemy zgodnie z jej schematem w AS Language, zmienne I, F, G określają nam wartość, od której funkcja zaczyna swoją iterację. Każdą funkcję zakańczamy END.

W tym momencie program powinien prezentować się jak poniżej.

.PROGRAM Pal_XYZ () ; 
 ; *******************************************************************
 ;
 ; Program: Palletization_XYZ
 ; Comment: Main program for palletization in three dimensions
 ; Author: Lukasz Giza ASTOR
 ;
 ;
 ; *******************************************************************
 ;
  SPEED 50 ALWAYS
  DECEL 80 ALWAYS
  ACCEL 80 ALWAYS
  CALL open_clamp
  HOME
  timer 1 = 0
  columns_num = 2
  rows_num = 2
  layers_num = 2
  distanceX = 50
  distanceY = 50
  distanceZ = 27
  FOR I = 0 TO layers_num
        FOR F = 0 TO columns_num
    	  FOR G = 0 TO rows_num
            END
         END
  END
.END

Uzupełniamy program o funkcję otwierającą szczęki w każdej iteracji i sterującą siłownikiem podającym kostki. Następnie tworzymy schemat programu, który umożliwi robotowi Astorino dojazd nad punkt poboru P0 na odległość 50 mm (LAPPRO), zmniejszenie prędkości w ruchu liniowym do 30 mm/s, dojazd do samego punktu, ustabilizowanie pozycji poprzez poczekanie 0,5 sekundy i zamknięcie chwytaka.

Kolejny krok to odjazd na 100 mm w -Z osi narzędzia znad aktualnej pozycji przy pomocy funkcji LDEAPART, aby kostka mogła równo wysunąć się z podajnika.

Dodany wycinek programu powinien prezentować się jak poniżej. Aby zapisać punkt P0, należy podjechać robotem Astorino z otwartym chwytakiem nad zadaną pozycję w trybie JOG i zapisać punkt (rys. 5 B).

Call open_clamp
SIGNAL 1
TWAIT 2
SIGNAL -1
TWAIT 2

Teraz możemy wyobrazić sobie docelowy schemat paletyzacji kostek, jaki zamierzamy osiągnąć.

W tym celu posłużymy się jednym punktem P6 zapisanym analogicznie jak P0, ale w taki sposób, aby liczone od niego pozostałe punkty odkładania kostek znajdowały się w zasięgu robota. Punkty możemy podglądać w zakładce Points (rys. 6).

Na podstawie tego punktu przy użyciu funkcji POINT stworzymy punkt „placement”, który będzie przesuwany dzięki funkcji SHIFT na podstawie punktu P6 o odpowiedni dystans w każdej z iteracji z trzech zagnieżdżonych funkcji FOR.

Wycinek programu z przesuwanym punktem powinien prezentować się jak poniżej.

POINT placement = SHIFT(P6 BY -distanceX*G,distanceY*F,distanceZ*I)

Każda z wartości, np. distanceY*F, pozwala nam przesuwać punkt – w tym przypadku o 50 mm – wymnożone przez aktualną iterację (wartość „F”) funkcji FOR odpowiadającej za tworzenie kolumn.

Czyli w drugiej iteracji wartość przesunięcia wyniesie 50 mm*1, co jest równe 50 mm od punktu P6. Jako że ta wartość znajduje się na drugim miejscu w składni funkcji SHIFT (patrz: składnia SHIFT w AS language), będzie ona przesuwała punkt po osi Y w kierunku dodatnim. W przypadku -distanceX*G, będzie analogicznie, czyli w kierunku osi X układu kartezjańskiego podstawy robota, ale o zwrocie ujemnym.

Dzięki stworzeniu sparametryzowanego punktu odłożenia w zależności od iteracji  wykorzystanych funkcji FOR, nie jest wymagane tworzenie dodatkowych punktów, ponieważ wygenerują się one same, zależnie od aktualnej iteracji danej funkcji FOR.

Pozwala to na zaoszczędzenie czasu przy tworzeniu punktów, ich przeuczaniu, zmianie rozstawu kostek oraz ewentualnych poprawek. Parametryzowanie pozwala też w prosty sposób kontrolować w kodzie programu dane wartości i je w łatwy sposób modyfikować, np. zmieniać szerokości wierszy i kolumn zależnie od wymiarów kostek bez potrzeby przeuczania każdego punktu.

Kolejnym krokiem jest odłożenie kostki do wyliczonego punktu. Program powinien wyglądać analogicznie jak w przypadku poboru kostki ze zmianą w kwestii otwarcia chwytaka.

Na samym końcu dodamy funkcję pozwalającą na powrót do pozycji home z prędkością 80%, która odnosi się tylko do kolejnego kroku (nie posiada dopisku ALWAYS).

Tak napisany program możemy przetestować.

.PROGRAM Pal_XYZ () ; 
  
 ; *******************************************************************
 ;
 ; Program: Palletization_XYZ
 ; Comment: Main program for palletization in three dimensions
 ; Author: Lukasz Giza ASTOR
 ;
 ;
 ; *******************************************************************
 ;
  SPEED 50 ALWAYS
  DECEL 80 ALWAYS
  ACCEL 80 ALWAYS
  CALL open_clamp
  HOME
  timer 1 = 0
  columns_num = 2
  rows_num = 2
  layers_num = 2
  distanceX = 50
  distanceY = 50
  distanceZ = 27
      FOR I = 0 TO layers_num
        FOR F = 0 TO columns_num
           FOR G = 0 TO rows_num
        
     	 Call open_clamp
      	 SIGNAL 1
      	 TWAIT 2
     	 SIGNAL -1
     	 TWAIT 2
     	 SWAIT 1001
    	 LAPPRO P0, 50
     	 SPEED 30 MM/S
     	 LMOVE P0
      	 TWAIT 0.5
      	 call close_clamp
      	 LDEPART 100
 
      	POINT placement = SHIFT(P6 BY -distanceX*G,distanceY*F,distanceZ*I)
            	LAPPRO placement, 50
      	SPEED 30 MM/S
      	LMOVE placement
      	TWAIT 0.5
           	 call open_clamp
     	 LDEPART 100
      	 SWAIT 2001
     	 SIGNAL -2001
           END
       END
  END
.END

2.4 Pisanie programu paletyzacji – ETAP III

Do przetestowanego i poprawnie działającego programu możemy dodać pewne elementy usprawniające jego działanie.

W przypadku poboru kostki podczas przesterowania podajnika wykorzystamy sygnał 1001 podpięty do czujnika optycznego, który w formie sprzężenia zwrotnego pozwoli robotowi Astorino zorientować się, czy kostka jest już w podajniku, czy należy ją dopiero podać, przesterowując zaworem siłownik.

Funkcja „IF SIG(1001) == FALSE THEN” sprawdza stan wejścia 1001, czyli wyjścia cyfrowego czujnika optycznego na podajniku kostek. W przypadku stanu niskiego, czyli False, funkcja porównująca zwróci wartość TRUE, a co za tym idzie, wykona się człon funkcji za słowem „THEN”.

Do tego członu dodamy wcześniej napisany wycinek programu. Pozwoli to zautomatyzować program. W przypadku, gdy na przykład kostka zostanie podana ręcznie w miejsce poboru, podajnik nie wysunie dodatkowej kostki, bo będzie miał informacje, że kostka już jest w odpowiednim miejscu. Z kolei w przypadku, gdy kostek zabraknie, robot Astorino będzie czekał na ręczne podanie kostki przed czujnik. Zabezpieczy to aplikację przed przypadkiem, gdyby kostki się skończyły i robot pracowałby na „pusto”.

Call open_clamp
IF SIG(1001) == FALSE THEN
  SIGNAL 1
  TWAIT 2
  SIGNAL -1
  TWAIT 2
END

Na końcu funkcji FOR dodamy też funkcje SWAIT oraz SIGNAL. Pierwsza określa oczekiwanie na dany sygnał, w tym przypadku 2001, który po odłożeniu kostki będzie musiał zostać przesterowany w stan wysoki, aby program mógł być kontynuowany.

Wykorzystany zostanie sygnał wewnętrzny, a więc przesterowanie odbędzie się poprzez wejście do menu System Settings w aplikacji Astorino i naciśnięcie lewym przyciskiem myszy na dany sygnał. Po naciśnięciu program zostanie wznowiony, a sygnał od razu zmieni stan na niski i w kolejnej iteracji będzie oczekiwał na ponowną interakcję.

Sygnał 2001 możemy zamienić na dowolny sygnał I/O, na przykład sygnał wejściowy z modułu IO, do którego został podłączony przycisk monostabilny lub bistabilny – po modyfikacji programu.

SWAIT 2001
SIGNAL -2001

Prawie na sam koniec programu, dodana zostanie też funkcja pozwalająca na odczyt wartości czasu cyklu z timera 1.

print "cycle time is:"
print timer(1)
print "seconds"

W przypadku posiadania mniejszej ilości kostek lub chęci szybszego zobaczenia całego programu, można zmodyfikować w prosty sposób wartość column_num lub pozostałe tak, aby zmniejszyć ilość iteracji danej funkcji FOR, a tym samym zmniejszyć ilość elementów paletyzowanych w jednym cyklu.

Dodatkowo na końcu programu po zakończeniu całego cyklu robot Astorino potwierdzi wykonanie aplikacji poprzez parokrotnie kliknięcie chwytakiem w pozycji „home”.

FOR b = 0 TO 3
	CALL open_clamp
	CALL close_clamp
END

Program z dopisanymi liniami kodu powinien prezentować się zgodnie z programem w rozdziale 4.

Aby zminimalizować odstępy między kostkami można wykorzystać inny chwytak, na przykład podciśnieniowy, który pozwoli złapać kostkę od góry i nie będzie potrzeby dodawania odstępów między kostkami na otwierające się szczęki (rys. 7). W tym przypadku pozostaniemy przy wykorzystaniu chwytaka szczękowego.

3. Test napisanej aplikacji na robocie Astorino

Wcześniej napisaną aplikację możemy przetestować. Należy wgrać programy do pamięci robota (rys. 8).

Następnie uruchamiamy robota Astorino w trybie Repeat. Robot będzie pobierał kostki z podajnika. Jeśli w podajniku nie będzie kostek, robot Astorino będzie czekać na dołożenie manualne kostki. Należy pamiętać, aby po każdym odłożeniu kostki, ustawić w stan wysoki sygnał wewnętrzny 2001. W oprogramowaniu Astorino jest on oznaczony jako Internal 1. Należy go kliknąć lewym przyciskiem myszy.

3.1 Zapisanie i otworzenie projektu w KIDE

Napisane wcześniej programy należy zapisać na komputerze lokalnie, a następnie otworzyć w oprogramowaniu KIDE. Ważne, aby pliki posiadały rozszerzenia .as.

Oprogramowanie KIDE można pobrać bezpłatnie ze strony WWW firmy ASTOR.
lub:
Oferta > Robotyzacja > Roboty Przemysłowe > Oprogramowanie narzędziowe

Po pobraniu środowiska KIDE należy wgrać wcześniej napisane programy poprzez zakładkę File > Open i podać ścieżkę do zapisanych plików.

3.2 Wgranie projektu do stanowiska z robotem Kawasaki Robotics

Do przetestowania aplikacji wykorzystane zostanie stanowisko szkoleniowe znajdujące się w ASTOR Robotics Center, wyposażone w robota przemysłowego Kawasaki Robotics RS007L wraz z chwytakiem i podajnikiem kostek (rys. 15).

Następnie należy połączyć się z robotem przy wykorzystaniu górnego paska narzędziowego i przycisku Connect (rys. 17). Połączenie realizowane jest przy pomocy przewodu ethernetowego i połączenia kontrolera robota z laptopem. Kolejno należy wpisać odpowiedni adres karty sieciowej robota. Należy pamiętać, aby komputer miał ustawiony odpowiedni adres w karcie sieciowej, tę samą sieć oraz inny adres IP.

Adres robota można sprawdzić przy pomocy teach pendanta w zakładce Aux.: System: Network Setting (rys. 16).

Odczytany adres IP należy wpisać w KIDE w zakładce Connection poprzez naciśnięcie + oraz wpisanie danych. Następnie potwierdzamy dane i naciskamy Connect.

Po połączeniu się z robotem, należy przeuczyć dwa wcześniej wykorzystywane punkty ze względu na inne rozmiary i kinematykę robota. Należy przełączyć robota w tryb Teach, włączyć serwonapędy i trzymając deadman switch, podjechać robotem na zadane miejsca i przy pomocy zakładki Translation points (rys. 13) dodać dwa punkty z odpowiednią nazwą P0 raz P6, tak aby miały one odzwierciedlenie w programie.

Należy pamiętać, aby dojechać chwytakiem w taki sposób, w jaki pobierane będą kostki. W tym celu można wysunąć jedną kostkę z podajnika i podjechać robotem do docelowego miejsca.

W celu ustanowienia pozycji home należy wejść w Aux: Basic setting: Home Position na TP robota (rys. 20), zaznaczyć Curr.Pose po dojechaniu w nią w trybie ręcznym i naciśnięcie przycisku ENTER na klawiaturze TP.

Druga opcja określenia pozycji home to zaznaczenie Key Entry i wpisanie odpowiedniej, docelowej wartości każdej osi i również potwierdzenie przyciskiem Enter.

W przypadku podłączenia sygnałów z podajnika oraz czujnika do innych wejść/wyjść, należy również dostosować numery sygnałów w programie.

Wgranie programu następuje poprzez naciśniecie przycisku Send AS file to Robot.

Po wczytaniu i ustawieniu pozostałych parametrów w oprogramowaniu KIDE, należy kliknąć Prime program (rys. 22), aby ustawił się on na ekranie głównym TP i był gotowy do wykonania.

3.3 Testowanie programu na stanowisku z robotem Kawasaki Robotics

Tak wgrany i dostosowany program należy przetestować. Można to zrobić w trybie Teach oraz Step continuous lub – jeśli jesteśmy pewni – od razu w trybie Repeat, ale z niską prędkością. Należy pamiętać, że 80% prędkości maksymalnej użytej w programie Astorino to 0.2m/s, a w przypadku RS007L to już 8.8m/s.

Aby zmniejszyć prędkość, możemy ustawić mniejszą wartość REP. SPD na teach pendancie robota, prędkość manipulatora będzie prędkością wynikową prędkości zapisanej w programie oraz prędkości określonej na TP robota (rys. 23).

W przypadku włączenia programu w trybie Repeat, należy włączyć napędy oraz nacisnąć przycisk RUN oraz CYCLE START na TP.

Efekty wykonywanego programu pokazane są poniżej (rys. 24).

4. Kod programu

4.1 PAL_XYZ

.PROGRAM Pal_XYZ () ; 
  
 ; *******************************************************************
 ;
 ; Program: Palletization_XYZ
 ; Comment: Main program for palletization in three dimensions
 ; Author: Lukasz Giza ASTOR
 ;
 ;
 ; *******************************************************************
 ;
 
 
  SPEED 50 ALWAYS
  DECEL 80 ALWAYS
  ACCEL 80 ALWAYS
  
  CALL open_clamp
  HOME
  timer 1 = 0

  columns_num = 2
  rows_num = 2
  layers_num = 2
  
  distanceX = 50
  distanceY = 50
  distanceZ = 27
  
  
  FOR I = 0 TO layers_num
    
    FOR F = 0 TO columns_num
      
      FOR G = 0 TO rows_num
        
      Call open_clamp
        IF SIG(1001) == FALSE THEN
          SIGNAL 1
          TWAIT 2
          SIGNAL -1
          TWAIT 2
        END
        
      SWAIT 1001
      LAPPRO P0, 50
      SPEED 30 MM/S
      LMOVE P0
      TWAIT 0.5
      call close_clamp
      LDEPART 100
 
      POINT placement = SHIFT(P6 BY -distanceX*G,distanceY*F,distanceZ*I)
      
      LAPPRO placement, 50
      SPEED 30 MM/S
      LMOVE placement
      TWAIT 0.5
      
      call open_clamp
      LDEPART 100
      SWAIT 2001
      SIGNAL -2001
      
      END
    END
  END

  SPEED 80
  HOME
  
  print "cycle time is:"
  print timer(1)
  print "seconds"

  
  FOR b = 0 TO 3
    CALL open_clamp
    CALL close_clamp
  END
.END

4.2 open_clamp

.PROGRAM open_clamp ()
  ; *******************************************************************
  ; Program:      open_clamp
  ; Comment:      
  ; Author:       User
  ;
  ; Date:         10/23/2024
  ; *******************************************************************
  ;
  signal -57
  TWAIT 1
.END

4.3 Close Clamp

.PROGRAM close_clamp ()
  ; *******************************************************************
  ; Program:      close_clamp
  ; Comment:      
  ; Author:       User
  ;
  ; Date:         10/23/2024
  ; *******************************************************************
  ;
  signal 57
  TWAIT 1
.END

5. Błędy i rozwiązania

5.1 Resetowanie błędów – roboty Kawasaki Robotics

W przypadku pojawienia się błędu należy go zresetować, naciskając Reset na ekranie TP.

5.2 Błąd E1088

Robot osiągnął maksymalne wychylenie i nie może się poruszyć dalej. 

Rozwiązaniem jest przesunięcie punktów do strefy roboczej i wycofanie robota w trybie ręcznym.

5.3 Błąd E6007

Robot znajduje się w pozycji osobliwej, odwrotne zadanie kinematyki ma nieskończenie wiele rozwiązań, ponieważ niektóre osie obrotowe są równoległe do siebie.

Rozwiązanie to przełączenie robota w tryb Teach, i w układzie JOINT przesunięcie robota tak, aby osie nie były równoległe do siebie (np. w przypadku osi 4 i 6 to zgięcie osi 5) oraz dostosowanie punktów w programie, aby omijać pozycję osobliwą.

5.4 Błędy Astorino

W celu wyeliminowania typowych błędów, które mogą się pojawić w tej aplikacji upewnij się, że firmware Astorino został zaktualizowany do najnowszej wersji.

5.5 Pozostałe błędy

W przypadku innych błędów należy skontaktować się z pomocą techniczną ASTOR:

Telefon: 12 424 00 88 

Email: support@astor.com.pl

Przez stronę internetową: https://www.astor.com.pl/wsparcie.html

6. Zobacz też:

Sprawdź 9 poradników dotyczących robota Astorino na YouTube.

Przeczytaj artykuł: Jak zasymulować stanowisko zrobotyzowane za pomocą K-ROSET oraz KIDE na robocie Kawasaki Robotics, a następnie przenieść aplikację na robota edukacyjnego Astorino.