Z tej części poradnika dowiesz się, jak wysyłać dużą ilość informacji z robota do sterownika PLC przy użyciu mniejszej liczby bajtów w ramce komunikacyjnej, dzięki przesłaniu danych wraz z ich nagłówkiem informującym o typie danych.

Wstęp

Główną ideą jest wysyłanie danych w sekwencji, jedna po drugiej, przy użyciu tych samych bajtów do wymiany informacji.

Do tego typu wymiany informacji wymagane jest użycie trzech typów zmiennych:

• Numer indeksu wysyłanych danych – na tej podstawie PLC rozpozna, które dane są wysyłane, jaki to typ i do czego należy je przypisać.
• Dane wyjściowe – tablica z danymi przygotowanymi do wysłania, w tym poradniku będzie to tablica 6 zmiennych typu INT. Dla każdego indeksu dane będą zawierały inne informacje.
• Wejście potwierdzenie odczytu danych przez PLC – pojedynczy bit informacyjny.
• Wewnętrzna zmienna przechowująca kolejny numer danych – definiuje które dane mają zostać wysłane w następnej sekwencji.

W tym poradniku, jako przykład, zdefiniujemy 6 zmiennych typu INT do przesyłania danych. Korzystając z tego miejsca w pamięci, będą wysyłane kolejno dane: pozycja robota, moment obrotowy każdej osi, temperatura enkoderów, dane serwisowe (przepracowane godziny, użycie e-stop, pamięć itp.), prędkości i odległość oraz czas odświeżania danych.

Sekwencję można dowolnie wydłużać, trzeba jednak pamiętać że to wydłuży czas odświeżania danych. W takim sposobie przesyłania nie należy wysyłać kluczowych danych, które muszą być wysyłane szybko, bez żadnych opóźnień. Na końcu tego artykułu sprawdzisz czas przesłania całej sekwencji danych.  

Ściągnij gotowe pliki z przykładami użytymi w tym artykule.

Modyfikacja programu robota 

Pierwszym krokiem jest dodanie niezbędnych zmiennych, aby móc kontrolować transmisję danych w sekwencji. Aby to zrobić, użyjemy czterech typów zmiennych:

Get_Data=1036 ; Potwierdzenie odczytu/pozyskania danych przez sterownik PLC - wejście robota
Num_data8= First_bit_Out+8*22  ; numer wysyłanych danych/indeks danych
Data1_16= First_bit_Out+8*23   ; pierwsza wysyłana zmienna; 16 bits 
Data2_16= First_bit_Out+8*25   ; druga wysyłana zmienna; 
Data3_16= First_bit_Out+8*27
Data4_16= First_bit_Out+8*29
Data5_16= First_bit_Out+8*31
Data6_16= First_bit_Out+8*33
Next_data=1 ; wewnętrzna zmienna wskazuje, które dane powinny zostać wysłane w następnej sekwencji, inicjalizacja 1 spowoduje że rozpocznie się wysyłanie od pierwszego zestawu danych

Dodatkowo można usunąć wszystkie niepotrzebne zmienne, które od teraz będą przesyłane sekwencyjnie i nie potrzebują osobnego miejsca w ramce danych. Tak więc ostatecznie lista zmiennych zostanie zredukowana i powinna wyglądać jak na poniższym zrzucie:

Zmian należy również dokonać w głównej pętli programu. Usunięty zostanie pojedynczy transfer danych, a dodany zostanie transfer sekwencyjny z wykorzystaniem funkcji warunkowej CASE. Na podstawie zmiennej Next_data wybierany będzie kolejny zestaw informacji do przesłania.

Jak opisano na początku artykułu, zmienne będą przesyłane w pakietach po 6 zmiennych 16-bitowych, przy czym przesyłany będzie również indeks każdej zmiennej. Na tej podstawie sterownik PLC rozpozna, jakie dane są aktualnie przesyłane i przypisze je do odpowiednich zmiennych. Poniżej znajduje się przykład przygotowania danych z indeksem gotowym do wysłania. W co drugim cyklu dane są przygotowywane i wysyłane na sygnał gotowości do odczytu parametrów ze sterownika PLC.

;///*****     Przesyłanie danych w sekwencji     *****///
IF (sig(Get_data)==TRUE)THEN  ; potwierdzenie z PLC, że poprzednie dane zostały już odczytane
      BITS Num_data8,8=0 ; wyczyszczenie indeksu przesyłanych danych
ELSE
	CASE Next_data OF ; przygotowanie kolejnych danych do wysłania
        VALUE 1:  ; Pozycja
		BITS Data1_16,16=DEXT(HERE,1)*10; X [mm] 
		BITS Data2_16,16=DEXT(HERE,2)*10; Y [mm]
		BITS Data3_16,16=DEXT(HERE,3)*10; Z [mm]
		BITS Data4_16,16=DEXT(HERE,4)*10; O [deg]
		BITS Data5_16,16=DEXT(HERE,5)*10; A [deg]
		BITS Data6_16,16=DEXT(HERE,6)*10; T [deg]
		BITS Num_data8,8=1 ; Gotowe dane z indeksem nr 1
		Next_data=2
	VALUE 2: ; Moment obrotowy
		BITS Data1_16,16= TRQNM(1)*100
		BITS Data2_16,16= TRQNM(2)*100
		BITS Data3_16,16= TRQNM(3)*100
		BITS Data4_16,16= TRQNM(4)*100
		BITS Data5_16,16= TRQNM(5)*100
		BITS Data6_16,16= TRQNM(6)*100
		BITS Num_data8,8=2 ; Ready data nr 2 – Torque
		Next_data=3
	VALUE 3: ;Temperatura
		BITS Data1_16,16= GETENCTEMP(,1)
		BITS Data2_16,16= GETENCTEMP(,2)
		BITS Data3_16,16= GETENCTEMP(,3)
		BITS Data4_16,16= GETENCTEMP(,4)
		BITS Data5_16,16= GETENCTEMP(,5)
		BITS Data6_16,16= GETENCTEMP(,6)
		BITS Num_data8,8=3 ; Ready data nr 3 – Temperature
		Next_data=4
	VALUE 4: ;Dane serwisowe
		BITS Data1_16,16= OPEINFO(1) ; Working hours
		BITS Data2_16,16= OPEINFO(3) ; Servo on time
		BITS Data3_16,16= OPEINFO(6,1) ; E-Stop counter
		BITS Data4_16,16= OPEINFO(7) ; Energy consumption
		BITS Data5_16,16= SYSDATA(MEM.FREE) ; Free memory
		BITS Data6_16,16 = 0 ;EMPTY
		BITS Num_data8,8=4 ; Ready data nr 4 – Service
		Next_data=5
	VALUE 5: ;Parametry ruchu
		BITS Data1_16,16= SYSDATA(M.SPEED); Monitor speed
		BITS Data2_16,16= SYSDATA(STEP); step number
		BITS Data3_16,16= SYSDATA(P.SPEED); Robot speed [%]
		BITS Data4_16,16= SYSDATA(TOOL.VEL.CMD); TCP speed [mm/s]
		BITS Data5_16,16= DISTANCE(HERE,DEST) ; distance to next point[mm]
		BITS Data6_16,16 = 0 ;EMPTY
		BITS Num_data8,8=5 ; Ready data nr 5 – moving
		Next_data=6
	VALUE 6: ; parametry użytkownika do wysłania
		BITS Data1_16,16 = TIMER(1)*100 ; sending a time of refresh data
		;Place for other information to be send 
		TIMER 1 = 0 
		BITS Num_data8,8=6 ; Ready data nr 6 - user
		Next_data=1
	END_CASE
END_IF

Tak przygotowana procedura pozwoli na wysyłanie wielu różnych zmiennych z wykorzystaniem jedynie 6 zmiennych na dane i jednej zmiennej zawierającej indeks przesyłanej wiadomości.

Warunek na początku pętli gwarantuje, że każda przygotowana i wystawiona informacja zostanie przeczytana przez sterownik PLC, który potwierdza odczyt. Ta część kodu może zostać usunięta, komunikacja będzie nadal działać, do tego szybciej, ale w trybie UDP, czyli bez potwierdzenia. Oznacza to, że być może niektóre dane nie zdążą być odczytane lub zostaną pominięte.

Ostatnim krokiem będzie zmiana wartości funkcji PCSCAN. Do tej pory dane były odświeżane co 0.2 s. Teraz aby zapewnić większą częstotliwość i dobry czas odświeżania danych, częstotliwość odświeżania zostanie ustalona na 0.05 s.

PCSCAN 0.05

Dzięki temu czas odświeżania wszystkich parametrów bez warunku potwierdzenia (tryb UDP) wynosi 0.27s. Z warunkiem potwierdzenia odczytania czas odświeżania wynosi 0.57s.

Modyfikacja programu sterownika PLC

1) Na początek należy zdefiniować w GVL (globalnej liście zmiennych) zmienne wymagane do zarządzania przesyłanymi danymi. Zmienna Rob_Num_data będzie przechowywać indeks odebranych danych od robota i na tej podstawie dane zostaną dopasowane do odpowiednich zmiennych. Zmienna To_rob_getData jest informacją dla robota, że odebrane dane zostały poprawnie odczytane i przypisane w pamięci. Dodatkowo 6 zmiennych Rob_data_x to zmienne, w których dane są wysyłane z robota w kolejności.

VAR_GLOBAL
	Rob_Num_data: BYTE; 
	To_rob_getData:BOOL; 
	Rob_data_1:INT;
	Rob_data_2:INT;
	Rob_data_3:INT;
	Rob_data_4:INT;
	Rob_data_5:INT;
	Rob_data_6:INT;
	Refresh_time_real:REAL
END_VAR

Dodatkowo zostanie dodana zmienna przechowująca czas odświeżania danych, przesyłany od robota: Refresh_time_real:REAL;

2) Zmienne, które będą odczytywane z robota, muszą zostać przypisane w zakładce Mapping komunikacji. Konieczne jest ponowne zmodyfikowanie przesyłanych zmiennych, tak aby przygotować miejsce w ramce komunikacyjnej do obsługi zmiennych, zgodnie ze schematem, zaznaczonym w czerwonej ramce na bieżącej liście:

Należy zmienić typ zmiennej dla wejść 23 i 24 na INT. Jeśli więc zmienimy dwie dane na INT, oznacza to, że musimy usunąć 2 zmienne bajty z końca ramki komunikacyjnej, aby nadal mieć całą ramkę o długości 64 bajty.

Następnie należy zmienić przypisane dane, czyli przypisanie nowo zdefiniowanych zmiennych do ramki komunikacyjnej i usunięcie nieużywanych danych:

Dodatkowo musimy dodać jedno wyjście ze sterownika PLC jako potwierdzenie odebrania danych, które jest zmienną To_rob_getData.

3) Poniżej znajduje się kod, który na podstawie indeksu informacji, numeru danych, przypisze odebrane informacje do odpowiednich zmiennych. Kod ten należy dodać do głównej części programu. Indeksy które są przygotowane do przesłania informacji zawartych w tym kursie to:

1 – pozycja robota, 6 danych odpowiada 6 współrzędnym robota
2 – momenty, 6 danych odpowiada momentom na każdej osi obrotowej robota
3 – temperatura na enkoderach, 6 danych to 6 temperatur, na ekranie wykorzystujemy tylko jedną, z drugiej osi, ale łatwo można to modyfikować
4 – dane serwisowe, takie jak liczba przepracowanych godzin, awaryjnego zatrzymania czy pobrana energia
5 – parametry ruchu, dotyczą prędkości, dynamiki, odległości
6 – parametry użytkownika, jedna zmienna jest wykorzystana do przesłania czasu odświeżania, pozostałe dane są wolne i dostępne dla użytkownika.

W programie głównym należy dodać:

///***********************************************************************
///                        Procedura odczytu danych w sekwencji / grupie
///**********************************************************************
CASE GVL.Rob_Num_data OF 
	0: //no data to read
		GVL.To_rob_getData:=0;
	1: // Position
		GVL.Rob_posX:= INT_TO_REAL(GVL.Rob_data_1)/10; 
		GVL.Rob_posY:= INT_TO_REAL(GVL.Rob_data_2)/10; 
		GVL.Rob_posZ:= INT_TO_REAL(GVL.Rob_data_3)/10;
		GVL.Rob_posO:= INT_TO_REAL(GVL.Rob_data_4)/10;
		GVL.Rob_posA:= INT_TO_REAL(GVL.Rob_data_5)/10;
		GVL.Rob_posT:= INT_TO_REAL(GVL.Rob_data_6)/10;
		GVL.To_rob_getData:=1;
	2: //Torque
		GVL.Torq_JT1:= GVL.Rob_data_1; 
		GVL.Torq_JT2:= GVL.Rob_data_2; 
		GVL.Torq_JT3:= GVL.Rob_data_3;
		GVL.Torq_JT4:= GVL.Rob_data_4;
		GVL.Torq_JT5:= GVL.Rob_data_5;
		GVL.Torq_JT6:= GVL.Rob_data_6;
		GVL.To_rob_getData:=1;
	3: // Temperature
		//GVL.Temp_JT1:=GVL.Rob_data_1; 
		GVL.Temp_JT2:=GVL.Rob_data_2; 
		//GVL.Temp_JT3:=GVL.Rob_data_3;
		//GVL.Temp_JT4:=GVL.Rob_data_4;
		//GVL.Temp_JT5:=GVL.Rob_data_5;
		//GVL.Temp_JT6:=GVL.Rob_data_6;
		GVL.To_rob_getData:=1;
	4: // Service data
		GVL.Working_Hours:=GVL.Rob_data_1; 
		GVL.Working_Hours:=GVL.Rob_data_2; 
		GVL.E_stop_count:=GVL.Rob_data_3; 
		GVL.Energy_consum:=GVL.Rob_data_4; 
		GVL.Memory_Free:=GVL.Rob_data_5; 
		//EMPTY:=GVL.Rob_data_6; 
		GVL.To_rob_getData:=1;
5: // Moving parameter
		GVL.Monitor_SPEED:=GVL.Rob_data_1; 
		GVL.STEP_NUM:=GVL.Rob_data_2; 
		GVL.Rob_SPEED:=GVL.Rob_data_3; 
		GVL.TCP_SPEED:= INT_TO_REAL(GVL.Rob_data_4); 
		GVL.Distance:=GVL.Rob_data_5; 
		//EMPTY:=GVL.Rob_data_6; 
		GVL.To_rob_getData:=1;
	6: // User data, you can add here additional information 
		GVL.Refresh_time_real:=INT_TO_REAL(GVL.Rob_data_1)/100;
		//Here assign value to read
		GVL.To_rob_getData:=1;
	ELSE 
		//Nothing
END_CASE

4) Wszystkie zmienne, które zostały wcześniej przypisane do wizualizacji, nie muszą być modyfikowane, używane są dokładnie te same zmienne, optymalizowana jest tylko ramka komunikacyjna.

Działająca aplikacja

Aplikacja wygląda ponownie jak poprzednio, dane nie zostały zmienione. Zmieniła się jednak długość zajmowanych bitów w ramce, poprzednio używano 376 bitów, podczas gdy teraz używamy tylko 228 bitów (28 bajtów). Oznacza to, że zmniejszyliśmy liczbę zajmowanych bitów o prawie 40%.

Oczywiście zmniejszona liczba bitów została osiągnięta kosztem zwiększenia czasu odświeżania danych, które nie są kluczowe, a ich czas może być nieco dłuższy. W tym przypadku częstotliwość odświeżania wszystkich danych wynosi 0,57s.

Wartość ta jest również wyświetlana na ekranie głównym, w polu tekstowym do którego została przypisana nowo stworzona zmienna Refresh_time_real.

W następnej części ponownie edytowana zostanie ramka komunikacji i zostanie dodane wysyłanie zmiennych tekstowych, dzięki czemu nazwa robota i numer seryjny będą wysyłane wraz z innymi zmiennymi tekstowymi.

Ściągnij gotowe pliki z przykładami użytymi w tym artykule.

W kolejnej części dowiesz się jak skrócić rozmiar przesyłanej ramki bez zmniejszania ilości danych i wykorzystać zwielokrotnianie danych przez standardowy protokół komunikacyjny.