4. Ruch robota

4.1. Jog (punktowy ruch)

Prototyp

StartJOG(ref,nb,dir,max_dis,vel=20.0,acc=100.0)

Opis

Jog (punktowy ruch)

Parametry wymagane

  • ref: 0-jog przegubów, 2-jog w układzie bazowym, 4-jog w układzie narzędzia, 8-jog w układzie przedmiotu;

  • nb: 1-przegub 1 (oś X), 2-przegub 2 (oś Y), 3-przegub 3 (oś Z), 4-przegub 4 (obrót wokół X), 5-przegub 5 (obrót wokół Y), 6-przegub 6 (obrót wokół Z);

  • dir: 0-kierunek ujemny, 1-kierunek dodatni;

  • max_dis: Maksymalny kąt/odległość pojedynczego ruchu punktowego, jednostka ° lub mm;

Parametry domyślne

  • vel: Procent prędkości, [0~100] domyślnie 20;

  • acc: Procent przyspieszenia, [0~100] domyślnie 100;

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.2. Zatrzymanie jog z redukcją prędkości

Prototyp

StopJOG(ref)

Opis

Zatrzymanie jog z redukcją prędkości

Parametry wymagane

  • ref: 1-zatrzymanie jog przegubów, 3-zatrzymanie jog w układzie bazowym, 5-zatrzymanie jog w układzie narzędzia, 9-zatrzymanie jog w układzie przedmiotu

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.3. Natychmiastowe zatrzymanie jog

Prototyp

ImmStopJOG()

Opis

Natychmiastowe zatrzymanie jog

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.4. Przykład kodu sterowania punktowego robotem

 1from fairino import Robot
 2import time
 3# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 4robot = Robot.RPC('192.168.58.2')
 5for i in range(6):
 6    robot.StartJOG(0, i + 1, 0, 20.0, 20.0, 30.0)
 7    time.sleep(1)
 8    robot.ImmStopJOG()
 9    time.sleep(1)
10for i in range(6):
11    robot.StartJOG(2, i + 1, 0, 20.0, 20.0, 30.0)
12    time.sleep(1)
13    robot.ImmStopJOG()
14    time.sleep(1)
15for i in range(6):
16    robot.StartJOG(4, i + 1, 0, 20.0, 20.0, 30.0)
17    time.sleep(1)
18    robot.StopJOG(5)
19    time.sleep(1)
20for i in range(6):
21    robot.StartJOG(8, i + 1, 0, 20.0, 20.0, 30.0)
22    time.sleep(1)
23    robot.StopJOG(9)
24    time.sleep(1)
25robot.CloseRPC()

4.5. Ruch w przestrzeni przegubów

Prototyp

MoveJ(joint_pos, tool, user, desc_pos = [0.0,0.0,0.0,0.0,0.0,0.0], vel = 20.0, acc = 0.0, ovl = 100.0, exaxis_pos = [0.0,0.0,0.0,0.0], blendT = -1.0, offset_flag = 0, offset_pos = [0.0,0.0,0.0,0.0,0.0,0.0])

Opis

Ruch w przestrzeni przegubów

Parametry wymagane

  • joint_pos: Docelowa pozycja przegubów, jednostka [°];

  • tool: Numer narzędzia, [0~14];

  • user: Numer przedmiotu, [0~14];

Parametry domyślne

  • desc_pos: Docelowa poza kartezjańska, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki prostej;

  • vel: Procent prędkości, [0~100] domyślnie 20.0;

  • acc: Procent przyspieszenia, [0~100], tymczasowo niedostępne;

  • ovl: Współczynnik skalowania prędkości, [0~100] domyślnie 100.0;

  • exaxis_pos: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 domyślnie [0.0,0.0,0.0,0.0];

  • blendT: [-1.0]-ruch do pozycji (blokujący), [0~500.0]-czas wygładzania (nieblokujący), jednostka [ms] domyślnie -1.0;

  • offset_flag: [0]-brak przesunięcia, [1]-przesunięcie w układzie przedmiotu/bazowym, [2]-przesunięcie w układzie narzędzia domyślnie 0;

  • offset_pos: Wartość przesunięcia pozy, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0];

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.6. Ruch liniowy w przestrzeni kartezjańskiej

Nowe w wersji python: SDK-v2.1.5

Prototyp

MoveL(desc_pos, tool, user, joint_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel=20.0, acc=0.0, ovl=100.0,blendR=-1.0, blendMode = 0,exaxis_pos=[0.0, 0.0, 0.0, 0.0], search=0, offset_flag=0,offset_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],oacc = 100.0,config=-1,velAccParamMode=0,overSpeedStrategy=0,speedPercent=10)

Opis

Ruch liniowy w przestrzeni kartezjańskiej

Parametry wymagane

  • desc_pos: Docelowa poza kartezjańska, jednostka [mm][°];

  • tool: Numer narzędzia, [0~14];

  • user: Numer przedmiotu, [0~14];

Parametry domyślne

  • joint_pos: Docelowa pozycja przegubów, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • vel: Procent prędkości, [0~100] domyślnie 20.0;

  • acc: Procent przyspieszenia, [0~100], tymczasowo niedostępne domyślnie 0.0;

  • ovl: Współczynnik skalowania prędkości, [0~100] domyślnie 100.0;

  • blendR: [-1.0]-ruch do pozycji (blokujący), [0~1000]-promień wygładzania (nieblokujący), jednostka [mm] domyślnie -1.0;

  • blendMode: Sposób przejścia; 0-przejście styczne wewnętrznie; 1-przejście narożne, domyślnie 0;

  • exaxis_pos: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 domyślnie [0.0,0.0,0.0,0.0];

  • search: [0]-brak poszukiwania pozycji drutu, [1]-poszukiwanie pozycji drutu;

  • offset_flag: [0]-brak przesunięcia, [1]-przesunięcie w układzie przedmiotu/bazowym, [2]-przesunięcie w układzie narzędzia domyślnie 0;

  • offset_pos: Wartość przesunięcia pozy, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0];

  • oacc: Współczynnik skalowania przyspieszenia [0-100]/przyspieszenie fizyczne (mm/s2) domyślnie 100;

  • config: Konfiguracja przestrzeni przegubów dla kinematyki odwrotnej, [-1]-obliczenia względem bieżącej pozycji przegubów, [0~7]-obliczenia według określonej konfiguracji przestrzeni przegubów, domyślnie -1

  • velAccParamMode: Tryb parametrów prędkości i przyspieszenia; 0-procentowy; 1-prędkość fizyczna (mm/s) przyspieszenie (mm/s2) domyślnie 0

  • overSpeedStrategy: Strategia przekroczenia prędkości, 0-strategia wyłączona; 1-standardowa; 2-zatrzymanie z błędem przy przekroczeniu prędkości; 3-adaptacyjne zmniejszenie prędkości, domyślnie 0

  • speedPercent: Procentowy próg dopuszczalnego zmniejszenia prędkości [0-100], domyślnie 10%

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.7. Ruch po łuku w przestrzeni kartezjańskiej

Nowe w wersji python: SDK-v2.1.5

Prototyp

MoveC(desc_pos_p, tool_p, user_p, desc_pos_t, tool_t, user_t, joint_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], joint_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],vel_p=20.0, acc_p=100.0, exaxis_pos_p=[0.0, 0.0, 0.0, 0.0], offset_flag_p=0,offset_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],vel_t=20.0, acc_t=100.0, exaxis_pos_t=[0.0, 0.0, 0.0, 0.0], offset_flag_t=0,offset_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],ovl=100.0, blendR=-1.0,oacc=100.0,config=-1,velAccParamMode=0)

Opis

Ruch po łuku w przestrzeni kartezjańskiej

Parametry wymagane

  • desc_pos_p: Pozycja kartezjańska punktu pośredniego, jednostka [mm][°];

  • tool_p: Numer narzędzia punktu pośredniego, [0~14];

  • user_p: Numer przedmiotu punktu pośredniego, [0~14];

  • desc_pos_t: Docelowa poza kartezjańska punktu docelowego, jednostka [mm][°];

  • tool_t: Numer narzędzia, [0~14];

  • user_t: Numer przedmiotu, [0~14];

Parametry domyślne

  • joint_pos_p: Pozycja przegubów punktu pośredniego, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • joint_pos_t: Pozycja przegubów punktu docelowego, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • vel_p: Procent prędkości punktu pośredniego, [0~100] domyślnie 20.0;

  • acc_p: Procent przyspieszenia punktu pośredniego, [0~100] tymczasowo niedostępne, domyślnie 0.0;

  • exaxis_pos_p: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 punktu pośredniego domyślnie [0.0,0.0,0.0,0.0];

  • offset_flag_p: Czy przesunięcie punktu pośredniego [0]-brak przesunięcia, [1]-przesunięcie w układzie przedmiotu/bazowym, [2]-przesunięcie w układzie narzędzia domyślnie 0;

  • vel_t: Procent prędkości punktu docelowego, [0~100] domyślnie 20.0;

  • acc_t: Procent przyspieszenia punktu docelowego, [0~100] tymczasowo niedostępne domyślnie 0.0;

  • exaxis_pos_t: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 punktu docelowego domyślnie [0.0,0.0,0.0,0.0];

  • offset_flag_t: Czy przesunięcie punktu docelowego [0]-brak przesunięcia, [1]-przesunięcie w układzie przedmiotu/bazowym, [2]-przesunięcie w układzie narzędzia domyślnie 0;

  • offset_pos_t: Wartość przesunięcia pozy punktu docelowego, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0];

  • ovl:: Współczynnik skalowania prędkości, [0~100] domyślnie 100.0;

  • blendR: [-1.0]-ruch do pozycji (blokujący), [0~1000]-promień wygładzania (nieblokujący), jednostka [mm] domyślnie -1.0;

  • oacc: Współczynnik skalowania przyspieszenia [0-100]/przyspieszenie fizyczne (mm/s2) domyślnie 100;

  • config: Konfiguracja przestrzeni przegubów dla kinematyki odwrotnej, [-1]-obliczenia względem bieżącej pozycji przegubów, [0~7]-obliczenia według określonej konfiguracji przestrzeni przegubów, domyślnie -1;

  • velAccParamMode: Tryb parametrów prędkości i przyspieszenia; 0-procentowy; 1-prędkość fizyczna (mm/s) przyspieszenie (mm/s2) domyślnie 0

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.8. Ruch po pełnym okręgu w przestrzeni kartezjańskiej

Nowe w wersji python: SDK-v2.1.5

Prototyp

Circle(desc_pos_p, tool_p, user_p, desc_pos_t, tool_t, user_t, joint_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],joint_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],vel_p=20.0, acc_p=0.0, exaxis_pos_p=[0.0, 0.0, 0.0, 0.0], vel_t=20.0, acc_t=0.0,exaxis_pos_t=[0.0, 0.0, 0.0, 0.0],ovl=100.0, offset_flag=0, offset_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], oacc=100.0, blendR=-1,config=-1,velAccParamMode=0)

Opis

Ruch po pełnym okręgu w przestrzeni kartezjańskiej

Parametry wymagane

  • desc_pos_p: Pozycja kartezjańska punktu pośredniego, jednostka [mm][°];

  • tool_p: Numer narzędzia, [0~14];

  • user_p: Numer przedmiotu, [0~14];

  • desc_pos_t: Docelowa poza kartezjańska punktu docelowego, jednostka [mm][°];

  • tool_t: Numer narzędzia, [0~14];

  • user_t: Numer przedmiotu, [0~14];

Parametry domyślne

  • joint_pos_p: Pozycja przegubów punktu pośredniego, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • joint_pos_t: Pozycja przegubów punktu docelowego, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • vel_p: Procent prędkości, [0~100] domyślnie 20.0;

  • acc_p: Procent przyspieszenia punktu pośredniego, [0~100] tymczasowo niedostępne domyślnie 0.0;

  • exaxis_pos_p: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 punktu pośredniego domyślnie [0.0,0.0,0.0,0.0];

  • vel_t: Procent prędkości punktu docelowego, [0~100] domyślnie 20.0;

  • acc_t: Procent przyspieszenia punktu docelowego, [0~100] tymczasowo niedostępne domyślnie 0.0;

  • exaxis_pos_t: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 punktu docelowego domyślnie [0.0,0.0,0.0,0.0]

  • ovl: Współczynnik skalowania prędkości, [0~100] domyślnie 100.0;

  • offset_flag: Czy przesunięcie [0]-brak przesunięcia, [1]-przesunięcie w układzie przedmiotu/bazowym, [2]-przesunięcie w układzie narzędzia domyślnie 0;

  • offset_pos: Wartość przesunięcia pozy, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0]

  • oacc: Współczynnik skalowania przyspieszenia [0-100]/przyspieszenie fizyczne (mm/s2), domyślnie: 100;

  • blendR: -1: blokujący; 0~1000: promień wygładzania, domyślnie: -1;

  • config: Konfiguracja przestrzeni przegubów dla kinematyki odwrotnej, [-1]-obliczenia względem bieżącej pozycji przegubów, [0~7]-obliczenia według określonej konfiguracji przestrzeni przegubów, domyślnie -1;

  • velAccParamMode: Tryb parametrów prędkości i przyspieszenia; 0-procentowy; 1-prędkość fizyczna (mm/s) przyspieszenie (mm/s2) domyślnie 0

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.9. Ruch punkt-punkt w przestrzeni kartezjańskiej

Prototyp

MoveCart(desc_pos, tool, user, vel = 20.0, acc = 0.0, ovl = 100.0, blendT = -1.0, config = -1)

Opis

Ruch punkt-punkt w przestrzeni kartezjańskiej

Parametry wymagane

  • desc_pos: Docelowa pozycja kartezjańska;

  • tool: Numer narzędzia, [0~14];

  • user: Numer przedmiotu, [0~14];

Parametry domyślne

  • vel: Prędkość, zakres [0~100], domyślnie 20.0;

  • acc: Przyspieszenie, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;

  • ovl: Współczynnik skalowania prędkości, [0~100], domyślnie 100.0;

  • blendT: [-1.0]-ruch do pozycji (blokujący), [0~500]-czas wygładzania (nieblokujący), jednostka [ms] domyślnie -1.0;

  • config: Konfiguracja przegubów, [-1]-obliczenia względem bieżącej pozycji przegubów, [0~7]-obliczenia według konfiguracji przegubów domyślnie -1

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.10. Przykład kodu podstawowych instrukcji ruchu robota

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6j3 = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257]
 7j4 = [-31.154, -95.317, 94.276, -88.079, -89.740, 74.256]
 8desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 9desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
10desc_pos3 = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061]
11desc_pos4 = [-443.165, 147.881, 480.951, 179.511, -0.775, -15.409]
12offset_pos = [0.0] * 6
13epos = [0.0] * 4
14tool = 0
15user = 0
16vel = 100.0
17acc = 100.0
18ovl = 100.0
19oacc = 100.0
20blendT = 0.0
21blendR = 0.0
22flag = 0
23search = 0
24blendMode = 0
25velAccMode = 0
26robot.SetSpeed(20)
27rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
28print(f"movej errcode:{rtn}")
29rtn = robot.MoveL(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendR=blendR, blendMode=blendMode, exaxis_pos=epos, search=search, offset_flag=flag, offset_pos=offset_pos,oacc=oacc, velAccParamMode=velAccMode)
30print(f"movel errcode:{rtn}")
31rtn = robot.MoveC(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, offset_flag_p=flag, offset_pos_p=offset_pos, desc_pos_t=desc_pos4, tool_t=tool, user_t=user, vel_t=vel,acc_t=acc, exaxis_pos_t=epos, offset_flag_t=flag, offset_pos_t=offset_pos, ovl=ovl, blendR=blendR, oacc=oacc, velAccParamMode=velAccMode)
32print(f"movec errcode:{rtn}")
33rtn = robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
34print(f"movej errcode:{rtn}")
35rtn = robot.Circle(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, desc_pos_t=desc_pos1, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, ovl=ovl,offset_flag=flag, offset_pos=offset_pos, oacc=oacc, blendR=-1, velAccParamMode=velAccMode)
36print(f"circle errcode:{rtn}")
37rtn = robot.MoveCart(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, acc=acc,ovl=ovl, blendT=blendT, config=-1)
38print(f"MoveCart errcode:{rtn}")
39rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
40print(f"movej errcode:{rtn}")
41rtn = robot.MoveL(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendR=blendR, blendMode=blendMode, exaxis_pos=epos, search=search, offset_flag=flag, offset_pos=offset_pos, config=-1,velAccParamMode=velAccMode)
42print(f"movel errcode:{rtn}")
43rtn = robot.MoveC(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, offset_flag_p=flag, offset_pos_p=offset_pos, desc_pos_t=desc_pos4, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc,exaxis_pos_t=epos, offset_flag_t=flag, offset_pos_t=offset_pos, ovl=ovl, blendR=blendR, config=-1, velAccParamMode=velAccMode)
44print(f"movec errcode:{rtn}")
45rtn = robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
46print(f"movej errcode:{rtn}")
47rtn = robot.Circle(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, desc_pos_t=desc_pos1, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, ovl=ovl, offset_flag=flag,offset_pos=offset_pos, oacc=oacc, blendR=-1, velAccParamMode=velAccMode)
48print(f"circle errcode:{rtn}")
49robot.CloseRPC()
50return 0

4.11. Ruch po spirali w przestrzeni kartezjańskiej

Nowe w wersji python: SDK-v2.1.7

Prototyp

NewSpiral(desc_pos, tool, user, param, joint_pos = [0.0,0.0,0.0,0.0,0.0,0.0], vel = 20.0, acc = 0.0, exaxis_pos = [0.0,0.0,0.0,0.0], ovl = 100.0, offset_flag = 0, offset_pos = [0.0,0.0,0.0,0.0,0.0,0.0], config = -1)

Opis

Ruch po spirali w przestrzeni kartezjańskiej

Parametry wymagane

  • desc_pos: Docelowa poza kartezjańska, jednostka [mm][°];

  • tool: Numer narzędzia, [0~14];

  • user: Numer przedmiotu, [0~14];

  • param=[circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode]: circle_num: Liczba zwojów spirali; circle_angle: Kąt nachylenia spirali; rad_init: Promień początkowy spirali; rad_add: Przyrost promienia; rotaxis_add: Przyrost kierunku osi obrotu; rot_direction: Kierunek obrotu, 0-zgodnie z ruchem wskazówek zegara, 1-przeciwnie do ruchu wskazówek zegara, velAccMode Tryb parametrów prędkości i przyspieszenia: 0-stała prędkość kątowa, 1-stała prędkość liniowa;

Parametry domyślne

  • joint_pos: Docelowa pozycja przegubów, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • vel: Procent prędkości, [0~100] domyślnie 20.0;

  • acc: Procent przyspieszenia, [0~100] domyślnie 100.0;

  • exaxis_pos: Pozycja osi zewnętrznej 1 ~ pozycja osi zewnętrznej 4 domyślnie [0.0,0.0,0.0,0.0];

  • ovl: Współczynnik skalowania prędkości, [0~100] domyślnie 100.0;

  • offset_flag: [0]-brak przesunięcia, [1]-przesunięcie w układzie przedmiotu/bazowym, [2]-przesunięcie w układzie narzędzia domyślnie 0;

  • offset_pos: Wartość przesunięcia pozy, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0]

  • config: Konfiguracja przestrzeni przegubów dla kinematyki odwrotnej, [-1]-obliczenia względem bieżącej pozycji przegubów, [0~7]-obliczenia według określonej konfiguracji przestrzeni przegubów, domyślnie -1

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.12. Przykład kodu

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4j = [67.957, -81.482, 87.595, -95.691, -94.899, -9.727]
 5desc_pos = [-123.142, -551.735, 430.549, 178.753, -4.757, 167.754]
 6offset_pos1 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0]
 7offset_pos2 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0]
 8epos = [0.0] * 4
 9sp = [2, 30.0, 50.0, 10.0, 10.0, 0, 1]  # [circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode]
10tool = 0
11user = 0
12vel = 30.0
13acc = 60.0
14ovl = 100.0
15blendT = -1.0
16flag = 2
17robot.SetSpeed(20)
18rtn = robot.MoveJ(joint_pos=j, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos1)
19print(f"movej errcode:{rtn}")
20rtn = robot.NewSpiral(desc_pos=desc_pos, tool=tool, user=user, vel=vel, acc=acc, exaxis_pos=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos2, param=sp)
21print(f"newspiral errcode:{rtn}")
22robot.CloseRPC()
23return 0

4.13. Rozpoczęcie ruchu serwo

Prototyp

ServoMoveStart(cmdType=0)

Opis

Rozpoczęcie ruchu serwo, używane razem z instrukcjami ServoJ, ServoCart

Parametry wymagane

  • cmdType: Typ transmisji poleceń, 0=XML-RPC, 1=transmisja przezroczysta UDP

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.14. Zakończenie ruchu serwo

Prototyp

ServoMoveEnd(cmdType=0)

Opis

Zakończenie ruchu serwo, używane razem z instrukcjami ServoJ, ServoCart

Parametry wymagane

  • cmdType: Typ transmisji poleceń, 0=XML-RPC, 1=transmisja przezroczysta UDP

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.15. Ruch w trybie serwo w przestrzeni przegubów

Prototyp

ServoJ(joint_pos, axisPos, acc = 0.0, vel = 0.0, cmdT = 0.008, filterT = 0.0, gain = 0.0, id=0, cmdType=0)

Opis

Ruch w trybie serwo w przestrzeni przegubów

Parametry wymagane

  • joint_pos: Docelowa pozycja przegubów, jednostka [°];

  • axisPos: Pozycja osi zewnętrznej, jednostka mm;

Parametry domyślne

  • acc: Przyspieszenie, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;

  • vel: Prędkość, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;

  • cmdT: Okres wysyłania instrukcji, jednostka s, zalecany zakres [0.001~0.0016], domyślnie 0.008;

  • filterT: Czas filtrowania, jednostka [s], tymczasowo niedostępne, domyślnie 0.0;

  • gain: Wzmocnienie proporcjonalne pozycji docelowej, tymczasowo niedostępne, domyślnie 0.0;

  • id: ID instrukcji servoJ, domyślnie 0;

  • cmdType: Typ transmisji poleceń, 0=XML-RPC, 1=transmisja przezroczysta UDP;

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.16. Przykład kodu SDK dla ServoJ, ServoMoveStart, ServoMoveEnd opartych na komunikacji UDP

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Połączenie z kontrolerem robota
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestServoJUDP(self):
 9    # Ustawienie wywołania zwrotnego
10    def callback(src_type, count, cmd_id, data_len, content):
11        print("Funkcja zwrotna: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content))
12        return 0
13
14    robot.SetUDPCmdRpyCallback(callback)
15    # # Inicjalizacja pozycji przegubów i pozycji osi zewnętrznej
16    j= [105, -108, 74, -66, -88.893, -1.621]
17    offset_pos = [0, 0, 0, 0, 0, 0]
18    epos = [0, 0, 0, 0]
19    # # Przejście do pozycji początkowej
20    result=robot.MoveJ(joint_pos=j, tool=0, user=0, vel=100, acc=100, ovl=100,exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
21    print("Wynik MoveJ: {}".format(result))
22    vel = 0.0
23    acc = 0.0
24    cmdT = 0.016
25    filterT = 0.0
26    gain = 0.0
27    flag = 0
28    dt = 0.1
29    cmdID = 0
30
31    # Pobranie bieżącej pozycji przegubów
32    ret, j = robot.GetActualJointPosDegree(flag)
33    if ret != 0:
34        print(f"GetActualJointPosDegree errcode:{ret}")
35    while 1:
36        count = 300
37        result = robot.ServoMoveStart(cmdType=1)
38        print("Wynik ServoMoveStart: {}".format(result))
39        while count > 0:
40            result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT,filterT=filterT, gain=gain, id=cmdID, cmdType=1)
41            j[0] += dt
42            j[1] += dt
43            j[2] += dt
44            j[3] += dt
45            j[4] += dt
46            j[5] += dt
47            count -= 1
48            time.sleep(0.01)
49        result = robot.ServoMoveEnd(cmdType=1)
50        print("Wynik ServoMoveEnd: {}".format(result))
51
52        count = 300
53        result = robot.ServoMoveStart(cmdType=1)
54        print("Wynik ServoMoveStart: {}".format(result))
55        while count > 0:
56            result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT,filterT=filterT, gain=gain, id=cmdID, cmdType=1)
57            j[0] -= dt
58            j[1] -= dt
59            j[2] -= dt
60            j[3] -= dt
61            j[4] -= dt
62            j[5] -= dt
63            count -= 1
64            time.sleep(0.01)
65        result = robot.ServoMoveEnd(cmdType=1)
66        print("Wynik ServoMoveEnd: {}".format(result))
67    robot.CloseRPC()
68    return 0
69TestServoJUDP(robot)

4.17. Przykładowy program ruchu w trybie serwo w przestrzeni przegubów

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4j = [0.0] * 6
 5epos = [0.0] * 4
 6vel = 0.0
 7acc = 0.0
 8cmdT = 0.008
 9filterT = 0.0
10gain = 0.0
11flag = 0
12count = 500
13dt = 0.1
14cmdID = 0
15ret, j = robot.GetActualJointPosDegree(flag)
16if ret == 0:
17    cmdID += 1
18    robot.ServoMoveStart()
19    while count:
20        robot.ServoJ(joint_pos=j,axisPos= epos,acc= acc,vel= vel, cmdT=cmdT, filterT=filterT, gain=gain, id=cmdID)
21        j[4] += dt
22        count -= 1
23        time.sleep(cmdT)
24        rtn,pkg = robot.GetRobotRealTimeState()
25        print(f"Servoj Count {pkg.servoJCmdNum}; last pos is {pkg.lastServoTarget[0]},{pkg.lastServoTarget[1]},{pkg.lastServoTarget[2]},{pkg.lastServoTarget[3]},{pkg.lastServoTarget[4]},{pkg.lastServoTarget[5]}")
26
27        if count < 50:
28            robot.MotionQueueClear()
29            print(f"After queue clear, Servoj Count {pkg.servoJCmdNum}; last pos is {pkg.lastServoTarget[0]},{pkg.lastServoTarget[1]},{pkg.lastServoTarget[2]},{pkg.lastServoTarget[3]},{pkg.lastServoTarget[4]},{pkg.lastServoTarget[5]}")
30            break
31    robot.ServoMoveEnd()
32else:
33    print(f"GetActualJointPosDegree errcode:{ret}")
34robot.CloseRPC()

4.18. Rozpoczęcie sterowania momentem obrotowym przegubów

Prototyp

ServoJTStart(cmdType=0)

Opis

Rozpoczęcie sterowania momentem obrotowym przegubów

Parametry wymagane

  • cmdType: Typ transmisji poleceń, 0=XML-RPC, 1=transmisja przezroczysta UDP

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.19. Sterowanie momentem obrotowym przegubów

Prototyp

ServoJT(torque, interval, checkFlag=0, jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], cmdType=0)

Opis

Sterowanie momentem obrotowym przegubów

Parametry wymagane
  • torque: Moment obrotowy przegubów j1~j6, jednostka Nm

    • interval: Okres instrukcji, jednostka s, zakres [0.001~0.008]

    • checkFlag: Strategia wykrywania 0-brak ograniczeń; 1-ograniczenie mocy; 2-ograniczenie prędkości; 3-ograniczenie mocy i prędkości jednocześnie, domyślnie 0

    • jPowerLimit: Parametr domyślny jPowerLimit Maksymalne ograniczenie mocy przegubu (W), domyślnie [0.0,0.0,0.0,0.0,0.0,0.0]

    • jVelLimit: Maksymalna prędkość przegubu (°/s), domyślnie [0.0,0.0,0.0,0.0,0.0,0.0]

    • cmdType: Typ transmisji poleceń, 0=XML-RPC, 1=transmisja przezroczysta UDP

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.20. Zakończenie sterowania momentem obrotowym przegubów

Prototyp

ServoJTEnd(cmdType=0)

Opis

Zakończenie sterowania momentem obrotowym przegubów

Parametry wymagane

  • cmdType: Typ transmisji poleceń, 0=XML-RPC, 1=transmisja przezroczysta UDP

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.21. Przykład kodu SDK dla ServoJT, ServoJTStart, ServoJTEnd opartych na komunikacji UDP

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Połączenie z kontrolerem robota
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestServoJTUDP(self):
 9    # Ustawienie wywołania zwrotnego
10    def callback(src_type, count, cmd_id, data_len, content):
11        print("Funkcja zwrotna: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content))
12        return 0
13
14    robot.SetUDPCmdRpyCallback(callback)
15    while True:
16        # Inicjalizacja pozycji przegubów i pozycji osi zewnętrznej
17        j = [0, -90, 90, 0, 0, 0]
18        epos = [0, 0, 0, 0]
19        offset_pos = [0, 0, 0, 0, 0, 0]
20
21        # Przejście do pozycji początkowej
22        robot.MoveJ(joint_pos=j, tool=0, user=0, vel=100, acc=100, ovl=100,
23                    exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
24        time.sleep(3)
25        # Włączenie przeciągania i uczenia
26        result=robot.DragTeachSwitch(1)
27        print("Wynik DragTeachSwitch: {}".format(result))
28        torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
29
30        # Pobranie momentu przegubów
31        ret, torques = robot.GetJointTorques(flag=1)
32        if ret != 0:
33            print(f"GetJointTorques errcode:{ret}")
34
35        count = 100
36        result = robot.ServoJTStart(cmdType=1)
37        print("Wynik ServoJTStart: {}".format(result))
38        # Sterowanie momentem dodatnim
39        while True:
40            torques[0] = 0.03
41            result = robot.ServoJT(
42                torque=torques,
43                interval=0.001,
44                checkFlag=0,
45                jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
46                jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
47                cmdType=1
48            )
49            print("Wynik: {}".format(result))
50            time.sleep(1)
51
52            ret, pkg = robot.GetRobotRealTimeState()
53            if pkg.jt_cur_pos[0] > 30:
54                break
55
56        # Sterowanie momentem ujemnym
57        while True:
58            torques[0] = -0.03
59            result = robot.ServoJT(
60                    torque=torques,
61                    interval=0.001,
62                    checkFlag=0,
63                    jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
64                    jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
65                    cmdType=1
66                )
67            print("Wynik: {}".format(result))
68            time.sleep(1)
69
70            ret, pkg = robot.GetRobotRealTimeState()
71            if pkg.jt_cur_pos[0] < 0:
72                break
73
74        # Zakończenie sterowania momentem i wyłączenie przeciągania i uczenia
75        result = robot.ServoJTEnd(cmdType=1)
76        print("Wynik ServoJTEnd: {}".format(result))
77        result = robot.DragTeachSwitch(0)
78        print("Wynik DragTeachSwitch: {}".format(result))
79
80    robot.CloseRPC()
81    return 0
82TestServoJTUDP(robot)

4.22. Przykład kodu sterowania momentem obrotowym przegubów

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4robot.DragTeachSwitch(1)
 5# torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
 6error,torques = robot.GetJointTorques(1)
 7robot.ServoJTStart()
 8count = 100
 9while count > 0:
10    error = robot.ServoJT(torques, 0.001)
11    count -= 1
12    time.sleep(0.001)
13error = robot.ServoJTEnd()
14robot.DragTeachSwitch(0)
15robot.CloseRPC()

4.23. Ruch w trybie serwo w przestrzeni kartezjańskiej

Prototyp

ServoCart(mode, desc_pos, exaxis, pos_gain=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], acc=0.0, vel=0.0, cmdT=0.008,filterT=0.0, gain=0.0)

Opis

Ruch w trybie serwo w przestrzeni kartezjańskiej

Parametry wymagane

  • mode: [0]-ruch absolutny (układ bazowy), [1]-ruch przyrostowy (układ bazowy), [2]-ruch przyrostowy (układ narzędzia);

  • exaxis: Pozycja osi rozszerzenia;

  • desc_pos: Docelowa pozycja kartezjańska / przyrost docelowej pozycji kartezjańskiej;

Parametry domyślne

  • pos_gain: Współczynnik proporcjonalny przyrostu pozy, działa tylko w ruchu przyrostowym, zakres [0~1], domyślnie [1.0, 1.0, 1.0, 1.0, 1.0, 1.0];

  • acc: Przyspieszenie, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;

  • vel: Prędkość, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;

  • cmdT: Okres wysyłania instrukcji, jednostka s, zalecany zakres [0.001~0.0016], domyślnie 0.008;

  • filterT: Czas filtrowania, jednostka [s], tymczasowo niedostępne, domyślnie 0.0;

  • gain: Wzmocnienie proporcjonalne pozycji docelowej, tymczasowo niedostępne, domyślnie 0.0;

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.24. Przykład kodu ruchu w trybie serwo w przestrzeni kartezjańskiej

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4desc_pos_dt = [83.00800, 50.525000, 29.246, 179.629, -7.138, -166.975]
 5exaxis = [100.0, 0.0, 0.0, 0.0]
 6pos_gain = [0.0] * 6
 7mode = 0
 8vel = 0.0
 9acc = 0.0
10cmdT = 0.001
11filterT = 0.0
12gain = 0.0
13flag = 0
14count = 5000
15robot.SetSpeed(20)
16while count:
17    rtn = robot.ServoCart(mode, desc_pos_dt, exaxis, pos_gain, acc, vel, cmdT, filterT, gain)
18    print(f"ServoCart rtn is {rtn}")
19    count -= 1
20    desc_pos_dt[0] += 0.01
21    exaxis[0] += 0.01
22robot.CloseRPC()
23return 0

4.25. Rozpoczęcie ruchu po krzywej składanej (spline)

Prototyp

SplineStart()

Opis

Rozpoczęcie ruchu po krzywej składanej (spline)

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.26. Ruch PTP po krzywej składanej (spline)

Prototyp

SplinePTP(joint_pos, tool, user, desc_pos = [0.0,0.0,0.0,0.0,0.0,0.0],  vel = 20.0,  acc = 100.0, ovl = 100.0)

Opis

Ruch PTP po krzywej składanej (spline)

Parametry wymagane

  • joint_pos: Docelowa pozycja przegubów, jednostka [°];

  • tool: Numer narzędzia, [0~14];

  • user: Numer przedmiotu, [0~14];

Parametry domyślne

  • desc_pos: Docelowa poza kartezjańska, jednostka [mm][°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki prostej;

  • vel: Prędkość, zakres [0~100], domyślnie 20.0;

  • acc: Przyspieszenie, zakres [0~100], domyślnie 100.0;

  • ovl: Współczynnik skalowania prędkości, [0~100], domyślnie 100.0

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.27. Zakończenie ruchu po krzywej składanej (spline)

Prototyp

SplineEnd()

Opis

Zakończenie ruchu po krzywej składanej (spline)

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.28. Przykład kodu ruchu po krzywej składanej (spline)

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4joint_points = [
 5    [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256],  # j1
 6    [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255],  # j2
 7    [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260],  # j3
 8    [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267]  # j4
 9]
10cart_points = [
11    [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833],  # desc_pos1
12    [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869],  # desc_pos2
13    [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207],  # desc_pos3
14    [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818]  # desc_pos4
15]
16offset_pos = [0] * 6
17epos = [0] * 4
18tool = user = 0
19vel = acc = ovl = 100.0
20blendT = -1.0
21flag = 0
22robot.SetSpeed(20)
23err1 = robot.MoveJ(joint_pos=joint_points[0],tool=tool, user=user,vel=vel)
24print(f"Kod błędu MoveJ: {err1}")
25robot.SplineStart()
26robot.SplinePTP(joint_pos=joint_points[0],tool=tool, user=user)
27robot.SplinePTP(joint_pos=joint_points[1],tool=tool, user=user)
28robot.SplinePTP(joint_pos=joint_points[2],tool=tool, user=user)
29robot.SplinePTP(joint_pos=joint_points[3],tool=tool, user=user)
30robot.SplineEnd()
31robot.CloseRPC()

4.29. Rozpoczęcie nowego ruchu po krzywej składanej (new spline)

Zmienione w wersji python: SDK-v2.0.3

Prototyp

NewSplineStart(type,averageTime=2000)

Opis

Rozpoczęcie nowego ruchu po krzywej składanej (new spline)

Parametry wymagane

  • type: 0-przejście łukowe, 1-punkty podane jako punkty ścieżki

Parametry domyślne

  • averageTime: Globalny średni czas łączenia (ms) domyślnie 2000

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.30. Punkt instrukcji nowej krzywej składanej (new spline)

Prototyp

NewSplinePoint(desc_pos,tool,user,lastFlag,joint_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel = 0.0, acc = 0.0, ovl = 100.0 ,blendR = 0.0 )

Opis

Punkt instrukcji nowej krzywej składanej (new spline)

Parametry wymagane

  • desc_pos: Docelowa poza kartezjańska, jednostka [mm][°];

  • tool: Numer narzędzia, [0~14];

  • user: Numer przedmiotu, [0~14];

  • lastFlag: Czy to ostatni punkt, 0-nie, 1-tak;

Parametry domyślne

  • joint_pos: Docelowa pozycja przegubów, jednostka [°] domyślnie [0.0,0.0,0.0,0.0,0.0,0.0], wartość domyślna wywołuje wartość zwracaną z rozwiązania kinematyki odwrotnej;

  • vel: Prędkość, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;;

  • acc: Przyspieszenie, zakres [0~100], tymczasowo niedostępne, domyślnie 0.0;

  • ovl: Współczynnik skalowania prędkości, [0~100] domyślnie 100.0;

  • blendR: [0~1000]-promień wygładzania, jednostka [mm] domyślnie 0.0;

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.31. Zakończenie nowego ruchu po krzywej składanej (new spline)

Prototyp

NewSplineEnd()

Opis

Zakończenie nowego ruchu po krzywej składanej (new spline)

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.32. Przykład kodu nowego ruchu po krzywej składanej (new spline)

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6j3 = [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260]
 7j4 = [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267]
 8j5 = [-95.228, -54.621, 73.691, -112.245, -91.280, 74.268]
 9desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
10desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
11desc_pos3 = [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207]
12desc_pos4 = [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818]
13desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482]
14offset_pos = [0, 0, 0, 0, 0, 0]
15epos = [0, 0, 0, 0]
16tool = 0
17user = 0
18vel = 100.0
19acc = 100.0
20ovl = 100.0
21blendT = -1.0
22flag = 0
23robot.SetSpeed(20)
24err1 = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
25print(f"movej errcode:{err1}")
26robot.NewSplineStart(1, 2000)
27robot.NewSplinePoint(desc_pos=desc_pos1, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
28robot.NewSplinePoint(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
29robot.NewSplinePoint(desc_pos=desc_pos3, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
30robot.NewSplinePoint(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
31robot.NewSplinePoint(desc_pos=desc_pos5, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
32robot.NewSplineEnd()
33robot.CloseRPC()

4.33. Zatrzymanie ruchu robota

Prototyp

StopMotion()

Opis

Zatrzymanie ruchu, aby użyć zatrzymania ruchu, instrukcja ruchu musi być w stanie nieblokującym

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.34. Wstrzymanie ruchu robota

Prototyp

PauseMotion()

Opis

Wstrzymanie ruchu, aby użyć wstrzymania ruchu, instrukcja ruchu musi być w stanie nieblokującym

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.35. Wznowienie ruchu robota

Prototyp

ResumeMotion()

Opis

Wznowienie ruchu, aby użyć wznowienia ruchu, instrukcja ruchu musi być w stanie nieblokującym

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.36. Przykład kodu wstrzymywania, wznawiania i zatrzymywania ruchu

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4j1 =[-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j5 =[-95.228, -54.621, 73.691, -112.245, -91.280, 74.268]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9epos = [0, 0, 0, 0]
10tool = 0
11user = 0
12vel = 100.0
13acc = 100.0
14ovl = 100.0
15blendT = -1.0
16flag = 0
17robot.SetSpeed(20)
18rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
19rtn = robot.MoveJ(joint_pos=j5, tool=tool, user=user, vel=vel, blendT=1)
20time.sleep(1)
21robot.PauseMotion()
22time.sleep(1)
23robot.ResumeMotion()
24time.sleep(1)
25robot.StopMotion()
26time.sleep(1)
27robot.CloseRPC()

4.37. Rozpoczęcie globalnego przesunięcia punktów

Prototyp

PointsOffsetEnable(flag,offset_pos)

Opis

Rozpoczęcie globalnego przesunięcia punktów

Parametry wymagane

  • flag: 0-przesunięcie w układzie bazowym lub przedmiotu, 2-przesunięcie w układzie narzędzia;

  • offset_pos: Wartość przesunięcia, jednostka [mm][°].

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.38. Zakończenie globalnego przesunięcia punktów

Prototyp

PointsOffsetDisable()

Opis

Zakończenie globalnego przesunięcia punktów

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.39. Przykład kodu przesunięcia punktów

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9offset_pos1 = [0, 0, 50, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 100.0
14acc = 100.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel)
20robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
21time.sleep(1)
22robot.PointsOffsetEnable(flag=0, offset_pos=offset_pos1)
23robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel)
24robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
25robot.PointsOffsetDisable()
26robot.CloseRPC()

4.40. Rozpoczęcie AO ruchu skrzynki kontrolnej

Nowe w wersji python: SDK-v2.0.4

Prototyp

MoveAOStart(AONum,maxTCPSpeed=1000,maxAOPercent=100,zeroZoneCmp=20)

Opis

Rozpoczęcie AO ruchu skrzynki kontrolnej

Parametry wymagane

  • AONum: Numer AO skrzynki kontrolnej

Parametry domyślne

  • maxTCPSpeed: Maksymalna wartość prędkości TCP [1-5000mm/s], domyślnie 1000;

  • maxAOPercent: Procent AO odpowiadający maksymalnej prędkości TCP, domyślnie 100%;

  • zeroZoneCmp: Wartość kompensacji strefy nieczułości, procent AO, liczba całkowita, domyślnie 20%, zakres [0-100].

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.41. Zakończenie AO ruchu skrzynki kontrolnej

Nowe w wersji python: SDK-v2.0.4

Prototyp

MoveAOStop()

Opis

Zakończenie AO ruchu skrzynki kontrolnej

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.42. Rozpoczęcie AO ruchu końcówki

Nowe w wersji python: SDK-v2.0.4

Prototyp

MoveToolAOStart(AONum,maxTCPSpeed=1000,maxAOPercent=100,zeroZoneCmp =20)

Opis

Rozpoczęcie AO ruchu końcówki

Parametry wymagane

  • AONum: Numer AO końcówki

Parametry domyślne

  • maxTCPSpeed: Maksymalna wartość prędkości TCP [1-5000mm/s], domyślnie 1000;

  • maxAOPercent: Procent AO odpowiadający maksymalnej prędkości TCP, domyślnie 100%;

  • zeroZoneCmp: Wartość kompensacji strefy nieczułości, procent AO, liczba całkowita, domyślnie 20%, zakres [0-100].

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.43. Zakończenie AO ruchu końcówki

Nowe w wersji python: SDK-v2.0.4

Prototyp

MoveToolAOStop()

Opis

Zakończenie AO ruchu końcówki

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.44. Przykład kodu zdjęcia seryjnego AO (fly拍摄)

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9offset_pos1 = [0, 0, 50, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 20.0
14acc = 20.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19robot.MoveAOStart(0, 100, 100, 20)
20robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel)
21robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
22robot.MoveAOStop()
23time.sleep(1)
24robot.MoveToolAOStart(0, 100, 100, 20)
25robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel)
26robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
27robot.MoveToolAOStop()
28robot.CloseRPC()

4.45. Rozpoczęcie filtracji FIR ruchu PTP

Nowe w wersji python: SDK-v2.1.2

Prototyp

PtpFIRPlanningStart(maxAcc, maxJek)

Opis

Rozpoczęcie filtracji FIR ruchu PTP

Parametry wymagane

  • maxAcc: Maksymalna wartość ekstremalna przyspieszenia (deg/s2)

  • maxJek: Ekstremalna wartość zrywu dla ujednoliconych przegubów (deg/s3)

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.46. Zakończenie filtracji FIR ruchu PTP

Nowe w wersji python: SDK-v2.0.7

Prototyp

PtpFIRPlanningEnd()

Opis

Zakończenie filtracji FIR ruchu PTP

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.47. Rozpoczęcie filtracji FIR ruchu LIN i ARC

Nowe w wersji python: SDK-v2.0.7

Prototyp

LinArcFIRPlanningStart(maxAccLin,maxAccDeg,maxJerkLin,maxJerkDeg)

Opis

Rozpoczęcie filtracji FIR ruchu LIN i ARC

Parametry wymagane

  • maxAccLin: Ekstremalna wartość przyspieszenia liniowego (mm/s2)

  • maxAccDeg: Ekstremalna wartość przyspieszenia kątowego (deg/s2)

  • maxJerkLin: Ekstremalna wartość zrywu liniowego (mm/s3)

  • maxJerkDeg: Ekstremalna wartość zrywu kątowego (deg/s3)

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.48. Zakończenie filtracji FIR ruchu LIN i ARC

Nowe w wersji python: SDK-v2.0.7

Prototyp

LinArcFIRPlanningEnd()

Opis

Zakończenie filtracji FIR ruchu LIN i ARC

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.49. Przykład kodu filtracji FIR

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6midjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 7endjointPos = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257]
 8startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 9middescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
10enddescPose = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061]
11exaxisPos = [0.0, 0.0, 0.0, 0.0]
12offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
13rtn = robot.PtpFIRPlanningStart(1000.0, 1000.0)
14print(f"PtpFIRPlanningStart rtn is {rtn}")
15error = robot.MoveJ(joint_pos=startjointPos,tool= 0,user= 0,desc_pos=startdescPose,vel= 100,acc=100,ovl=100, blendT=-1.0, offset_flag=0)
16print(f"MoveJ rtn is {rtn}")
17error = robot.MoveJ(joint_pos=endjointPos,tool= 0,user= 0,desc_pos=enddescPose,vel= 100,acc=100,ovl=100, blendT=-1.0, offset_flag=0)
18print(f"MoveJ rtn is {rtn}")
19robot.PtpFIRPlanningEnd()
20print(f"PtpFIRPlanningEnd rtn is {rtn}")
21rtn = robot.LinArcFIRPlanningStart(1000, 1000, 1000, 1000)
22print(f"LinArcFIRPlanningStart rtn is {rtn}")
23error = robot.MoveL(desc_pos=startdescPose,tool= 0,user= 0, joint_pos=startjointPos,vel= 100,overSpeedStrategy=1,speedPercent=1)
24print(f"MoveL rtn is {rtn}")
25error = robot.MoveC(desc_pos_p=middescPose,tool_p= 0,user_p= 0, joint_pos_p=midjointPos,vel_p= 100,desc_pos_t=enddescPose,tool_t= 0,user_t= 0,joint_pos_t=endjointPos,vel_t= 100)
26print(f"MoveC rtn is {rtn}")
27robot.LinArcFIRPlanningEnd()
28print(f"LinArcFIRPlanningEnd rtn is {rtn}")
29robot.CloseRPC()

4.50. Włączenie wygładzania przyspieszenia

Nowe w wersji python: SDK-v2.1.1

Prototyp

AccSmoothStart(saveFlag_flag)

Opis

Włączenie wygładzania przyspieszenia

Parametry wymagane

  • saveFlag_flag: Czy zapisać po odłączeniu zasilania

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.51. Wyłączenie wygładzania przyspieszenia

Nowe w wersji python: SDK-v2.1.1

Prototyp

AccSmoothEnd(saveFlag_flag)

Opis

Wyłączenie wygładzania przyspieszenia

Parametry wymagane

  • saveFlag_flag: Czy zapisać po odłączeniu zasilania

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.52. Przykład kodu wygładzania przyspieszenia

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8exaxisPos = [0.0, 0.0, 0.0, 0.0]
 9offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
10rtn = robot.AccSmoothStart(0)
11print(f"AccSmoothStart rtn is {rtn}")
12robot.MoveJ(joint_pos=startjointPos,tool= 0,user= 0,vel= 100)
13robot.MoveJ(joint_pos=endjointPos,tool= 0,user= 0,vel= 100)
14rtn = robot.AccSmoothEnd(0)
15print(f"AccSmoothEnd rtn is {rtn}")

4.53. Włączenie określonej prędkości pozy robota

Nowe w wersji python: SDK-v2.0.5

Prototyp

AngularSpeedStart(ratio)

Opis

Włączenie określonej prędkości pozy

Parametry wymagane

  • ratio: Procent prędkości pozy [0-300]

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.54. Wyłączenie określonej prędkości pozy

Nowe w wersji python: SDK-v2.0.5

Prototyp

AngularSpeedEnd()

Opis

Wyłączenie określonej prędkości pozy

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.55. Przykład kodu określonej prędkości pozy robota

 1from fairino import Robot
 2# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8exaxisPos = [0.0, 0.0, 0.0, 0.0]
 9offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
10rtn = robot.AngularSpeedStart(50)
11print(f"AngularSpeedStart rtn is {rtn}")
12robot.MoveJ(joint_pos=startjointPos, tool=0,user= 0,vel= 100)
13robot.MoveJ(joint_pos=endjointPos, tool=0,user= 0,vel= 100)
14rtn = robot.AngularSpeedEnd()
15print(f"AngularSpeedEnd rtn is {rtn}")
16robot.CloseRPC()

4.56. Włączenie ochrony przed osobliwą pozycją

Nowe w wersji python: SDK-v2.0.5

Prototyp

SingularAvoidStart(protectMode, minShoulderPos=100, minElbowPos=50, minWristPos=10)

Opis

Włączenie ochrony przed osobliwą pozycją

Parametry wymagane

  • protectMode: Tryb ochrony przed osobliwą pozycją: 0-tryb przegubowy; 1-tryb kartezjański

Parametry domyślne

  • minShoulderPos: Zakres regulacji osobliwości barku (mm), domyślnie 100.0

  • minElbowPos: Zakres regulacji osobliwości łokcia (mm), domyślnie 50.0

  • minWristPos: Zakres regulacji osobliwości nadgarstka (°), domyślnie 10.0

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.57. Wyłączenie ochrony przed osobliwą pozycją

Nowe w wersji python: SDK-v2.0.5

Prototyp

SingularAvoidEnd()

Opis

Wyłączenie ochrony przed osobliwą pozycją

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.58. Przykład kodu ochrony przed osobliwą pozycją robota

 1from fairino import Robot
 2import time
 3# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
 4robot = Robot.RPC('192.168.58.2')
 5startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 7startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 8enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 9exaxisPos = [0.0, 0.0, 0.0, 0.0]
10offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
11rtn = robot.SingularAvoidStart(2, 10, 5, 5)
12print(f"SingularAvoidStart rtn is {rtn}")
13robot.MoveJ(joint_pos=startjointPos, tool=0,user= 0,vel= 100)
14robot.MoveJ(joint_pos=endjointPos, tool=0,user= 0,vel= 100)
15rtn = robot.SingularAvoidEnd()
16print(f"SingularAvoidEnd rtn is {rtn}")
17robot.CloseRPC()

4.59. Wyczyszczenie kolejki instrukcji ruchu

Nowe w wersji python: SDK-v2.1.7

Prototyp

MotionQueueClear()

Opis

Wyczyszczenie kolejki instrukcji ruchu

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.60. Przejście do punktu początkowego linii przecięcia rur

Prototyp

MoveToIntersectLineStart(mainPoint, piecePoint, tool, wobj, vel, acc, ovl, oacc, moveType,mainExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]],pieceExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]],extAxisFlag=0,exaxisPos=[0.0,0.0,0.0,0.0],moveDirection=0,offset=[0.0,0.0,0.0,0.0,0.0,0.0])

Opis

Przejście do punktu początkowego linii przecięcia rur

Parametry wymagane

  • mainPoint: Pozycje kartezjańskie 6 punktów nauczania rury głównej

  • piecePoint: Pozycje kartezjańskie 6 punktów nauczania rury pomocniczej

  • tool: Numer układu narzędzia

  • wobj: Numer układu przedmiotu

  • vel: Procent prędkości

  • acc: Procent przyspieszenia

  • ovl: Współczynnik skalowania prędkości

  • oacc: Współczynnik skalowania przyspieszenia

  • moveType: Typ ruchu; 0-PTP; 1-LIN

  • mainExaxisPos: Pozycje osi rozszerzenia 6 punktów nauczania rury głównej, domyślnie [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • pieceExaxisPos: Pozycje osi rozszerzenia 6 punktów nauczania rury łączącej, domyślnie [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • extAxisFlag: Czy włączyć oś rozszerzenia; 0-niewłączony; 1-włączony

  • exaxisPos: Pozycja osi rozszerzenia punktu początkowego [0.0,0.0,0.0,0.0]

  • moveDirection: Kierunek ruchu; 0-zgodnie z ruchem wskazówek zegara; 1-przeciwnie do ruchu wskazówek zegara

  • offset: Wartość przesunięcia

Parametry domyślne

Brak

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.61. Ruch po linii przecięcia rur

Prototyp

MoveIntersectLine(mainPoint, piecePoint, tool, wobj, vel, acc, ovl, oacc, moveDirection,mainExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]],pieceExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]],extAxisFlag=0,exaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]],offset=[0.0,0.0,0.0,0.0,0.0,0.0])

Opis

Ruch po linii przecięcia rur

Parametry wymagane

  • mainPoint: Pozycje kartezjańskie 6 punktów nauczania rury głównej

  • piecePoint: Pozycje kartezjańskie 6 punktów nauczania rury pomocniczej

  • tool: Numer układu narzędzia

  • wobj: Numer układu przedmiotu

  • vel: Procent prędkości

  • acc: Procent przyspieszenia

  • ovl: Współczynnik skalowania prędkości

  • oacc: Współczynnik skalowania przyspieszenia

  • moveDirection: Kierunek ruchu; 0-zgodnie z ruchem wskazówek zegara; 1-przeciwnie do ruchu wskazówek zegara

  • mainExaxisPos: Pozycje osi rozszerzenia 6 punktów nauczania rury głównej, domyślnie [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • pieceExaxisPos: Pozycje osi rozszerzenia 6 punktów nauczania rury łączącej, domyślnie [[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]]

  • extAxisFlag: Czy włączyć oś rozszerzenia; 0-niewłączony; 1-włączony

  • exaxisPos: Pozycja osi rozszerzenia punktu początkowego [0.0,0.0,0.0,0.0]

  • offset: Wartość przesunięcia

Parametry domyślne

Brak

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.62. Przykład kodu ruchu robota po linii przecięcia rur

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4mainPoint = [[0.0] * 6 for _ in range(6)]
 5piecePoint = [[0.0] * 6 for _ in range(6)]
 6mainExaxisPos = [[0.0] * 4 for _ in range(6)]
 7pieceExaxisPos = [[0.0] * 4 for _ in range(6)]
 8extAxisFlag = 1
 9exaxisPos = [[0.0] * 4 for _ in range(4)]
10offset = [0.0, 2.0, 30.0, -2.0, 0.0, 0.0]
11mainPoint[0] = [490.004, -383.194, 402.735, -9.332, -1.528, 69.594]
12mainPoint[1] = [444.950, -407.117, 389.011, -5.546, -2.196, 65.279]
13mainPoint[2] = [445.168, -463.605, 355.759, -1.544, -10.886, 57.104]
14mainPoint[3] = [507.529, -485.385, 343.013, -0.786, -4.834, 61.799]
15mainPoint[4] = [554.390, -442.647, 367.701, -4.761, -10.181, 64.925]
16mainPoint[5] = [532.552, -394.003, 396.467, -13.732, -13.592, 67.411]
17mainExaxisPos[0] = [-29.996, 0.000, 0.000, 0.000]
18mainExaxisPos[1] = [-29.996, 0.000, 0.000, 0.000]
19mainExaxisPos[2] = [-29.996, 0.000, 0.000, 0.000]
20mainExaxisPos[3] = [-29.996, 0.000, 0.000, 0.000]
21mainExaxisPos[4] = [-29.996, 0.000, 0.000, 0.000]
22mainExaxisPos[5] = [-29.996, 0.000, 0.000, 0.000]
23piecePoint[0] = [505.571, -192.408, 316.759, 38.098, 37.051, 139.447]
24piecePoint[1] = [533.837, -201.558, 332.340, 34.644, 42.339, 137.748]
25piecePoint[2] = [530.386, -225.085, 373.808, 35.431, 45.111, 137.560]
26piecePoint[3] = [485.646, -229.195, 383.778, 33.870, 45.173, 137.064]
27piecePoint[4] = [460.551, -212.161, 354.256, 28.856, 45.602, 135.930]
28piecePoint[5] = [474.217, -197.124, 324.611, 42.469, 41.133, 148.167]
29pieceExaxisPos[0] = [-29.996, -0.000, 0.000, 0.000]
30pieceExaxisPos[1] = [-29.996, -0.000, 0.000, 0.000]
31pieceExaxisPos[2] = [-29.996, -0.000, 0.000, 0.000]
32pieceExaxisPos[3] = [-29.996, -0.000, 0.000, 0.000]
33pieceExaxisPos[4] = [-29.996, -0.000, 0.000, 0.000]
34pieceExaxisPos[5] = [-29.996, -0.000, 0.000, 0.000]
35exaxisPos[0] = [-29.996, -0.000, 0.000, 0.000]
36exaxisPos[1] = [-44.994, 90.000, 0.000, 0.000]
37exaxisPos[2] = [-59.992, 0.002, 0.000, 0.000]
38exaxisPos[3] = [-44.994, -89.997, 0.000, 0.000]
39tool = 2
40wobj = 0
41vel = 100.0
42acc = 100.0
43ovl = 12.0
44oacc = 12.0
45moveType = 1
46moveDirection = 1
47rtn = robot.MoveToIntersectLineStart(mainPoint=mainPoint, mainExaxisPos=mainExaxisPos, piecePoint=piecePoint, pieceExaxisPos=pieceExaxisPos, extAxisFlag=extAxisFlag,exaxisPos=exaxisPos[0], tool=tool, wobj=wobj, vel=vel, acc=acc, ovl=ovl, oacc=oacc, moveType=moveType, moveDirection=moveDirection, offset=offset)
48print(f"MoveToIntersectLineStart rtn is {rtn}")
49rtn = robot.MoveIntersectLine(mainPoint=mainPoint, mainExaxisPos=mainExaxisPos, piecePoint=piecePoint, pieceExaxisPos=pieceExaxisPos, extAxisFlag=extAxisFlag, exaxisPos=exaxisPos, tool=tool,wobj=wobj, vel=vel, acc=acc, ovl=5.0, oacc=5.0, moveDirection=moveDirection, offset=offset)
50print(f"MoveIntersectLine rtn is {rtn}")
51robot.CloseRPC()

4.63. Ruch w miejscu (pusty ruch)

Prototyp

MoveStationary()

Opis

Ruch w miejscu (pusty ruch)

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.64. Przykład kodu ruchu w miejscu (pusty ruch)

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4rtn = robot.LaserSensorRecordandReplay(0, 10, 1, 0, 0.1, 1, 0, 10, 100)
 5print(f"LaserSensorRecordandReplay rtn is {rtn}")
 6rtn = robot.MoveStationary()
 7print(f"MoveStationary rtn is {rtn}")
 8rtn = robot.LaserSensorRecord1(0, 10)
 9print(f"LaserSensorRecordandReplay rtn is {rtn}")
10robot.CloseRPC()
11return 0

4.65. Rozpoczęcie wahadła w punkcie stałym

Prototyp

OriginPointWeaveStart(weaveNum, mode, refPoint, weaveTime)

Opis

Rozpoczęcie wahadła w punkcie stałym

Parametry wymagane

  • weaveNum: Numer wahadła [0-7]

  • mode: 0-układ narzędzia; 1-punkt odniesienia

  • refPoint: Współrzędne kartezjańskie punktu odniesienia [x,y,z,a,b,c]

  • weaveTime: Czas wahadła [s]

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.66. Zakończenie wahadła w punkcie stałym

Prototyp

OriginPointWeaveEnd()

Opis

Zakończenie wahadła w punkcie stałym

Parametry wymagane

Brak

Parametry domyślne

Brak

Wartość zwracana

  • Kod błędu sukces-0 błąd- errcode

4.67. Przykład kodu SDK dla wahadła w punkcie stałym

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Połączenie z kontrolerem robota
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestOriginPointWeave(self):
 9    time.sleep(2)
10    # Inicjalizacja pozycji przegubów, osi zewnętrznej i przesunięcia
11    j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842]
12    epos = [0, 0, 0, 0]
13    offset_pos = [0, 0, 0, 0, 0, 0]
14
15    # Pozycja punktu odniesienia [x, y, z, rx, ry, rz]
16    refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956]
17
18    # Przejście do pozycji początkowej
19    robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100,
20                exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
21
22    # Pierwsze wahadło: absolutny układ współrzędnych (tool=0), tryb 0
23    robot.OriginPointWeaveStart(0, 0, refPoint, 3)
24    robot.MoveStationary()
25    robot.OriginPointWeaveEnd()
26
27    time.sleep(2)
28
29    # Ponowne przejście do pozycji początkowej
30    robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100,
31                exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
32
33    # Drugie wahadło: absolutny układ współrzędnych (tool=0), tryb 1
34    robot.OriginPointWeaveStart(0, 1, refPoint, 3)
35    robot.MoveStationary()
36    robot.OriginPointWeaveEnd()
37
38    # Zamknięcie połączenia
39    robot.CloseRPC()
40    time.sleep(1)
41
42TestOriginPointWeave(robot)

4.68. Przykład kodu SDK dla wahadła w punkcie stałym (z laserem i osią rozszerzenia)

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Połączenie z kontrolerem robota
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestOriginPointWeave(self):
 9    time.sleep(2)
10    # Inicjalizacja pozycji przegubów, osi zewnętrznej i przesunięcia
11    j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842]
12    epos1 = [0, 0, 0, 0]
13    offset_pos = [0, 0, 0, 0, 0, 0]
14    epos2 = [5, 0.000, 0.000, 0.000]
15    # Pozycja punktu odniesienia [x, y, z, rx, ry, rz]
16    refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956]
17
18    rtn = 0
19    robot.LaserTrackingSensorConfig("192.168.58.20", 5020)
20    robot.LaserTrackingSensorSamplePeriod(20)
21    robot.LoadPosSensorDriver(101)
22
23    # Ładowanie sterownika UDP
24    robot.ExtDevLoadUDPDriver()
25
26    # Ustawienie czasu zakończenia polecenia osi zewnętrznej
27    rtn = robot.SetExAxisCmdDoneTime(5000.0)
28    print(f"SetExAxisCmdDoneTime rtn is {rtn}")
29
30    # Włączenie osi zewnętrznej 1 i 2
31    rtn = robot.ExtAxisServoOn(1, 1)
32    print(f"ExtAxisServoOn axis id 1 rtn is {rtn}")
33    rtn = robot.ExtAxisServoOn(2, 1)
34    print(f"ExtAxisServoOn axis id 2 rtn is {rtn}")
35    time.sleep(2)
36
37    # Ustawienie powrotu do zera osi zewnętrznej
38    robot.ExtAxisSetHoming(1, 0, 10, 2)
39    robot.LaserTrackingLaserOnOff(1)
40
41    # 1---bez osi rozszerzenia
42    robot.LaserTrackingTrackOnOff(1, 4)
43    time.sleep(0.2)
44    # Rozpoczęcie wahadła w punkcie stałym
45    robot.OriginPointWeaveStart(0, 0, refPoint, 10)
46    robot.MoveStationary()  # Wykonanie stałego ruchu
47    robot.OriginPointWeaveEnd()
48    robot.LaserTrackingTrackOnOff(0, 4)
49
50    time.sleep(2)  # Oczekiwanie 2 sekundy
51
52    # 2----z osią rozszerzenia
53    robot.ExtAxisMove(epos1, 100, -1)
54    robot.LaserTrackingTrackOnOff(1, 4)
55    # Rozpoczęcie wahadła w punkcie stałym
56    robot.OriginPointWeaveStart(0, 0, refPoint, 20)
57    robot.ExtAxisMove(epos2, 100, -1)
58    robot.OriginPointWeaveEnd()
59    robot.LaserTrackingTrackOnOff(0, 4)
60
61    # Zamknięcie połączenia
62    robot.CloseRPC()
63    time.sleep(1)
64
65TestOriginPointWeave(robot)

4.69. Ruch w trybie serwo prędkościowym w przestrzeni przegubów

Prototyp

ServoJV(self, joint_vel, exis_vel, acc=0.0, vel=0.0, cmdT=0.008, filterT=0.0, gain=0.0, id=0, comType=0)

Opis

Ruch w trybie serwo prędkościowym w przestrzeni przegubów

Parametry wymagane

  • joint_vel: 6 docelowych prędkości przegubów, jednostka deg/s

  • exis_vel: 4 prędkości zewnętrznych osi, jednostka deg/s

  • acc: Procent przyspieszenia, zakres [0~100], tymczasowo niedostępne, domyślnie 0

  • vel: Procent prędkości, zakres [0~100], tymczasowo niedostępne, domyślnie 0

  • cmdT: Okres wysyłania instrukcji, jednostka s, zalecany zakres [0.001~0.0016]

  • filterT: Czas filtrowania, jednostka s, tymczasowo niedostępne, domyślnie 0

  • gain: Wzmocnienie proporcjonalne pozycji docelowej, tymczasowo niedostępne, domyślnie 0

  • id: ID instrukcji servoJ, domyślnie 0

  • comType: Typ wysyłania instrukcji; 0-xmlrpc; 1-UDP (odpowiadający portowi 20007 robota)

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.70. Przykład kodu ruchu w trybie serwo prędkościowym w przestrzeni przegubów

 1from fairino import Robot
 2import time
 3
 4def main():
 5    # Połączenie z kontrolerem robota
 6    robot = Robot.RPC('192.168.58.2')
 7    time.sleep(0.5)  # Oczekiwanie na połączenie i odbiór danych
 8
 9    # Inicjalizacja tablicy prędkości przegubów i prędkości osi rozszerzenia
10    joint_vel = [10.0, 0.0, 0.0, 0.0, 0.0, 0.0]
11    exis_vel = [0.0, 0.0, 0.0, 0.0]
12    acc = 0.0
13    vel = 0.0
14    cmdT = 0.008
15    filterT = 0.0
16    gain = 0.0
17    cnt = 0
18
19    # Pętla wywołująca ServoJV, łącznie 200 razy
20    while cnt < 200:
21        rtn = robot.ServoJV(joint_vel=joint_vel, exis_vel=exis_vel, acc=acc, vel=vel,
22                            cmdT=cmdT, filterT=filterT, gain=gain)
23        print(f"ServoJV rtn is {rtn}")
24        cnt += 1
25
26    # Zamknięcie połączenia
27    robot.CloseRPC()
28
29
30# Wywołanie funkcji testowej
31main()

4.71. Rozpoczęcie sterowania MIT przegubów

Prototyp

ServoMITStart(self, comType=0)

Opis

Rozpoczęcie sterowania MIT przegubów

Parametry wymagane

  • comType: Typ wysyłania instrukcji; 0-xmlrpc; 1-UDP (odpowiadający portowi 20007 robota)

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.72. Zakończenie sterowania MIT przegubów

Prototyp

ServoMITEnd(self, comType=0)

Opis

Zakończenie sterowania MIT przegubów

Parametry wymagane

  • comType: Typ wysyłania instrukcji; 0-xmlrpc; 1-UDP (odpowiadający portowi 20007 robota)

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.73. Sterowanie MIT przegubów

Prototyp

ServoMIT(self, posGain, desPos, velGain, desVel, torque_ff, interval, comType=0)

Opis

Sterowanie MIT przegubów

Parametry wymagane

  • posGain: Wzmocnienie pozycji przegubów j1~j6

  • desPos: Oczekiwana pozycja przegubów j1~j6 jednostka:deg

  • velGain: Wzmocnienie prędkości przegubów j1~j6

  • desVel: Oczekiwana prędkość przegubów j1~j6 jednostka:deg/s

  • torque_ff: Moment wyprzedzający j1~j6 jednostka:Nm

  • interval: Okres instrukcji, jednostka s, zakres [0.001~0.008]

  • comType: Typ wysyłania instrukcji; 0-xmlrpc; 1-UDP (odpowiadający portowi 20007 robota)

Parametry domyślne

Brak

Wartość zwracana

Kod błędu sukces-0 błąd- errcode

4.74. Przykład kodu sterowania MIT przegubów robota

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Połączenie z kontrolerem robota
 6robot = Robot.RPC('192.168.58.2')
 7
 8# Definicja funkcji zwrotnej
 9def udp_frame_callback(src_type, count, cmd_id, data_len, content):
10    """Funkcja zwrotna odpowiedzi polecenia UDP"""
11    print(f"Funkcja zwrotna: cmd_id={cmd_id} count={count} data_len={data_len} content={content}")
12    return 0
13
14def ServoMITtest(self):
15    # Ustawienie funkcji zwrotnej odpowiedzi polecenia UDP
16    robot.SetUDPCmdRpyCallback(udp_frame_callback)
17
18    while True:
19        # Resetowanie wszystkich błędów
20        robot.ResetAllError()
21        time.sleep(0.5)
22
23        # Inicjalizacja tablic parametrów
24        posGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
25        desPos = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
26        velGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
27        desVel = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
28        torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
29
30        # Pobranie momentu przegubów
31        rtn, torques = robot.GetJointTorques(flag=1)
32        print(f"GetJointTorques rtn: {rtn}")
33        print("111111")
34
35        # Uruchomienie trybu MIT
36        rtn = robot.ServoMITStart(0)
37        print(f"ServoMITStart rtn: {rtn}")
38
39        # Włączenie przeciągania i uczenia
40        rtn = robot.DragTeachSwitch(1)
41        print(f"DragTeachSwitch rtn: {rtn}")
42
43        intev = 0.008
44
45        # Ruch w przód: dodatni moment na 6 osi, aż kąt przekroczy 30 stopni
46        while True:
47            torques[5] = 0.03
48            rtn = robot.ServoMIT(posGain, desPos, velGain,
49                                desVel, torques, intev, comType=0)
50            print(f"ServoMIT call rtn is {rtn}")
51            time.sleep(0.001)  # 1 ms
52
53            rtn, pkg = robot.GetRobotRealTimeState()
54            print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}")
55
56            if pkg.jt_cur_pos[5] > 30:
57                break
58
59        # Ruch w tył: ujemny moment na 6 osi, aż kąt spadnie poniżej 0 stopni
60        while True:
61            torques[5] = -0.03
62            rtn = robot.ServoMIT(posGain, desPos, velGain,
63                                desVel, torques, intev, comType=0)
64            print(f"ServoMIT call rtn is {rtn}")
65            time.sleep(0.001)  # 1 ms
66
67            rtn, pkg = robot.GetRobotRealTimeState()
68            print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}")
69
70            if pkg.jt_cur_pos[5] < 0:
71                break
72
73        # Wyłączenie przeciągania i uczenia
74        rtn = robot.DragTeachSwitch(0)
75        print(f"DragTeachSwitch off rtn: {rtn}")
76
77        # Zakończenie trybu MIT
78        rtn = robot.ServoMITEnd(0)
79        print(f"ServoMITEnd rtn: {rtn}")
80
81# Wywołanie funkcji testowej
82ServoMITtest(robot)