Ruch robota =========== .. toctree:: :maxdepth: 5 Jog (punktowy ruch) ++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zatrzymanie jog z redukcją prędkości ++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Natychmiastowe zatrzymanie jog ++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "Prototyp", "``ImmStopJOG()``" "Opis", "Natychmiastowe zatrzymanie jog" "Parametry wymagane", "Brak" "Parametry domyślne", "Brak" "Wartość zwracana", "Kod błędu sukces-0 błąd- errcode" Przykład kodu sterowania punktowego robotem +++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') for i in range(6): robot.StartJOG(0, i + 1, 0, 20.0, 20.0, 30.0) time.sleep(1) robot.ImmStopJOG() time.sleep(1) for i in range(6): robot.StartJOG(2, i + 1, 0, 20.0, 20.0, 30.0) time.sleep(1) robot.ImmStopJOG() time.sleep(1) for i in range(6): robot.StartJOG(4, i + 1, 0, 20.0, 20.0, 30.0) time.sleep(1) robot.StopJOG(5) time.sleep(1) for i in range(6): robot.StartJOG(8, i + 1, 0, 20.0, 20.0, 30.0) time.sleep(1) robot.StopJOG(9) time.sleep(1) robot.CloseRPC() Ruch w przestrzeni przegubów ++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch liniowy w przestrzeni kartezjańskiej +++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch po łuku w przestrzeni kartezjańskiej +++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch po pełnym okręgu w przestrzeni kartezjańskiej ++++++++++++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch punkt-punkt w przestrzeni kartezjańskiej +++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu podstawowych instrukcji ruchu robota ++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time robot = Robot.RPC('192.168.58.2') j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] j3 = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257] j4 = [-31.154, -95.317, 94.276, -88.079, -89.740, 74.256] desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] desc_pos3 = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061] desc_pos4 = [-443.165, 147.881, 480.951, 179.511, -0.775, -15.409] offset_pos = [0.0] * 6 epos = [0.0] * 4 tool = 0 user = 0 vel = 100.0 acc = 100.0 ovl = 100.0 oacc = 100.0 blendT = 0.0 blendR = 0.0 flag = 0 search = 0 blendMode = 0 velAccMode = 0 robot.SetSpeed(20) rtn = 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) print(f"movej errcode:{rtn}") rtn = 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) print(f"movel errcode:{rtn}") rtn = 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) print(f"movec errcode:{rtn}") rtn = 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) print(f"movej errcode:{rtn}") rtn = 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) print(f"circle errcode:{rtn}") rtn = robot.MoveCart(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, acc=acc,ovl=ovl, blendT=blendT, config=-1) print(f"MoveCart errcode:{rtn}") rtn = 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) print(f"movej errcode:{rtn}") rtn = 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) print(f"movel errcode:{rtn}") rtn = 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) print(f"movec errcode:{rtn}") rtn = 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) print(f"movej errcode:{rtn}") rtn = 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) print(f"circle errcode:{rtn}") robot.CloseRPC() return 0 Ruch po spirali w przestrzeni kartezjańskiej ++++++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.7 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu +++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') j = [67.957, -81.482, 87.595, -95.691, -94.899, -9.727] desc_pos = [-123.142, -551.735, 430.549, 178.753, -4.757, 167.754] offset_pos1 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0] offset_pos2 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0] epos = [0.0] * 4 sp = [2, 30.0, 50.0, 10.0, 10.0, 0, 1] # [circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode] tool = 0 user = 0 vel = 30.0 acc = 60.0 ovl = 100.0 blendT = -1.0 flag = 2 robot.SetSpeed(20) rtn = 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) print(f"movej errcode:{rtn}") rtn = 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) print(f"newspiral errcode:{rtn}") robot.CloseRPC() return 0 Rozpoczęcie ruchu serwo +++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie ruchu serwo +++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch w trybie serwo w przestrzeni przegubów +++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu SDK dla ServoJ, ServoMoveStart, ServoMoveEnd opartych na komunikacji UDP ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from time import sleep import time from fairino import Robot # Połączenie z kontrolerem robota robot = Robot.RPC('192.168.58.2') def TestServoJUDP(self): # Ustawienie wywołania zwrotnego def callback(src_type, count, cmd_id, data_len, content): print("Funkcja zwrotna: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content)) return 0 robot.SetUDPCmdRpyCallback(callback) # # Inicjalizacja pozycji przegubów i pozycji osi zewnętrznej j= [105, -108, 74, -66, -88.893, -1.621] offset_pos = [0, 0, 0, 0, 0, 0] epos = [0, 0, 0, 0] # # Przejście do pozycji początkowej 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) print("Wynik MoveJ: {}".format(result)) vel = 0.0 acc = 0.0 cmdT = 0.016 filterT = 0.0 gain = 0.0 flag = 0 dt = 0.1 cmdID = 0 # Pobranie bieżącej pozycji przegubów ret, j = robot.GetActualJointPosDegree(flag) if ret != 0: print(f"GetActualJointPosDegree errcode:{ret}") while 1: count = 300 result = robot.ServoMoveStart(cmdType=1) print("Wynik ServoMoveStart: {}".format(result)) while count > 0: result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT,filterT=filterT, gain=gain, id=cmdID, cmdType=1) j[0] += dt j[1] += dt j[2] += dt j[3] += dt j[4] += dt j[5] += dt count -= 1 time.sleep(0.01) result = robot.ServoMoveEnd(cmdType=1) print("Wynik ServoMoveEnd: {}".format(result)) count = 300 result = robot.ServoMoveStart(cmdType=1) print("Wynik ServoMoveStart: {}".format(result)) while count > 0: result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT,filterT=filterT, gain=gain, id=cmdID, cmdType=1) j[0] -= dt j[1] -= dt j[2] -= dt j[3] -= dt j[4] -= dt j[5] -= dt count -= 1 time.sleep(0.01) result = robot.ServoMoveEnd(cmdType=1) print("Wynik ServoMoveEnd: {}".format(result)) robot.CloseRPC() return 0 TestServoJUDP(robot) Przykładowy program ruchu w trybie serwo w przestrzeni przegubów ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') j = [0.0] * 6 epos = [0.0] * 4 vel = 0.0 acc = 0.0 cmdT = 0.008 filterT = 0.0 gain = 0.0 flag = 0 count = 500 dt = 0.1 cmdID = 0 ret, j = robot.GetActualJointPosDegree(flag) if ret == 0: cmdID += 1 robot.ServoMoveStart() while count: robot.ServoJ(joint_pos=j,axisPos= epos,acc= acc,vel= vel, cmdT=cmdT, filterT=filterT, gain=gain, id=cmdID) j[4] += dt count -= 1 time.sleep(cmdT) rtn,pkg = robot.GetRobotRealTimeState() 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]}") if count < 50: robot.MotionQueueClear() 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]}") break robot.ServoMoveEnd() else: print(f"GetActualJointPosDegree errcode:{ret}") robot.CloseRPC() Rozpoczęcie sterowania momentem obrotowym przegubów +++++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Sterowanie momentem obrotowym przegubów +++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie sterowania momentem obrotowym przegubów ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu SDK dla ServoJT, ServoJTStart, ServoJTEnd opartych na komunikacji UDP ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from time import sleep import time from fairino import Robot # Połączenie z kontrolerem robota robot = Robot.RPC('192.168.58.2') def TestServoJTUDP(self): # Ustawienie wywołania zwrotnego def callback(src_type, count, cmd_id, data_len, content): print("Funkcja zwrotna: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content)) return 0 robot.SetUDPCmdRpyCallback(callback) while True: # Inicjalizacja pozycji przegubów i pozycji osi zewnętrznej j = [0, -90, 90, 0, 0, 0] epos = [0, 0, 0, 0] offset_pos = [0, 0, 0, 0, 0, 0] # Przejście do pozycji początkowej 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) time.sleep(3) # Włączenie przeciągania i uczenia result=robot.DragTeachSwitch(1) print("Wynik DragTeachSwitch: {}".format(result)) torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] # Pobranie momentu przegubów ret, torques = robot.GetJointTorques(flag=1) if ret != 0: print(f"GetJointTorques errcode:{ret}") count = 100 result = robot.ServoJTStart(cmdType=1) print("Wynik ServoJTStart: {}".format(result)) # Sterowanie momentem dodatnim while True: torques[0] = 0.03 result = robot.ServoJT( torque=torques, interval=0.001, 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=1 ) print("Wynik: {}".format(result)) time.sleep(1) ret, pkg = robot.GetRobotRealTimeState() if pkg.jt_cur_pos[0] > 30: break # Sterowanie momentem ujemnym while True: torques[0] = -0.03 result = robot.ServoJT( torque=torques, interval=0.001, 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=1 ) print("Wynik: {}".format(result)) time.sleep(1) ret, pkg = robot.GetRobotRealTimeState() if pkg.jt_cur_pos[0] < 0: break # Zakończenie sterowania momentem i wyłączenie przeciągania i uczenia result = robot.ServoJTEnd(cmdType=1) print("Wynik ServoJTEnd: {}".format(result)) result = robot.DragTeachSwitch(0) print("Wynik DragTeachSwitch: {}".format(result)) robot.CloseRPC() return 0 TestServoJTUDP(robot) Przykład kodu sterowania momentem obrotowym przegubów +++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') robot.DragTeachSwitch(1) # torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] error,torques = robot.GetJointTorques(1) robot.ServoJTStart() count = 100 while count > 0: error = robot.ServoJT(torques, 0.001) count -= 1 time.sleep(0.001) error = robot.ServoJTEnd() robot.DragTeachSwitch(0) robot.CloseRPC() Ruch w trybie serwo w przestrzeni kartezjańskiej ++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu ruchu w trybie serwo w przestrzeni kartezjańskiej +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time robot = Robot.RPC('192.168.58.2') desc_pos_dt = [83.00800, 50.525000, 29.246, 179.629, -7.138, -166.975] exaxis = [100.0, 0.0, 0.0, 0.0] pos_gain = [0.0] * 6 mode = 0 vel = 0.0 acc = 0.0 cmdT = 0.001 filterT = 0.0 gain = 0.0 flag = 0 count = 5000 robot.SetSpeed(20) while count: rtn = robot.ServoCart(mode, desc_pos_dt, exaxis, pos_gain, acc, vel, cmdT, filterT, gain) print(f"ServoCart rtn is {rtn}") count -= 1 desc_pos_dt[0] += 0.01 exaxis[0] += 0.01 robot.CloseRPC() return 0 Rozpoczęcie ruchu po krzywej składanej (spline) ++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch PTP po krzywej składanej (spline) ++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie ruchu po krzywej składanej (spline) +++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu ruchu po krzywej składanej (spline) +++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') joint_points = [ [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256], # j1 [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255], # j2 [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260], # j3 [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267] # j4 ] cart_points = [ [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833], # desc_pos1 [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869], # desc_pos2 [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207], # desc_pos3 [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818] # desc_pos4 ] offset_pos = [0] * 6 epos = [0] * 4 tool = user = 0 vel = acc = ovl = 100.0 blendT = -1.0 flag = 0 robot.SetSpeed(20) err1 = robot.MoveJ(joint_pos=joint_points[0],tool=tool, user=user,vel=vel) print(f"Kod błędu MoveJ: {err1}") robot.SplineStart() robot.SplinePTP(joint_pos=joint_points[0],tool=tool, user=user) robot.SplinePTP(joint_pos=joint_points[1],tool=tool, user=user) robot.SplinePTP(joint_pos=joint_points[2],tool=tool, user=user) robot.SplinePTP(joint_pos=joint_points[3],tool=tool, user=user) robot.SplineEnd() robot.CloseRPC() Rozpoczęcie nowego ruchu po krzywej składanej (new spline) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. versionchanged:: python SDK-v2.0.3 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Punkt instrukcji nowej krzywej składanej (new spline) ++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie nowego ruchu po krzywej składanej (new spline) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu nowego ruchu po krzywej składanej (new spline) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] j3 = [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260] j4 = [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267] j5 = [-95.228, -54.621, 73.691, -112.245, -91.280, 74.268] desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] desc_pos3 = [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207] desc_pos4 = [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818] desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482] offset_pos = [0, 0, 0, 0, 0, 0] epos = [0, 0, 0, 0] tool = 0 user = 0 vel = 100.0 acc = 100.0 ovl = 100.0 blendT = -1.0 flag = 0 robot.SetSpeed(20) err1 = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel) print(f"movej errcode:{err1}") robot.NewSplineStart(1, 2000) robot.NewSplinePoint(desc_pos=desc_pos1, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0) robot.NewSplinePoint(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0) robot.NewSplinePoint(desc_pos=desc_pos3, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0) robot.NewSplinePoint(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0) robot.NewSplinePoint(desc_pos=desc_pos5, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0) robot.NewSplineEnd() robot.CloseRPC() Zatrzymanie ruchu robota ++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Wstrzymanie ruchu robota ++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Wznowienie ruchu robota ++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu wstrzymywania, wznawiania i zatrzymywania ruchu +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') j1 =[-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] j5 =[-95.228, -54.621, 73.691, -112.245, -91.280, 74.268] desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482] offset_pos = [0, 0, 0, 0, 0, 0] epos = [0, 0, 0, 0] tool = 0 user = 0 vel = 100.0 acc = 100.0 ovl = 100.0 blendT = -1.0 flag = 0 robot.SetSpeed(20) rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel) rtn = robot.MoveJ(joint_pos=j5, tool=tool, user=user, vel=vel, blendT=1) time.sleep(1) robot.PauseMotion() time.sleep(1) robot.ResumeMotion() time.sleep(1) robot.StopMotion() time.sleep(1) robot.CloseRPC() Rozpoczęcie globalnego przesunięcia punktów ++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie globalnego przesunięcia punktów ++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu przesunięcia punktów ++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] offset_pos = [0, 0, 0, 0, 0, 0] offset_pos1 = [0, 0, 50, 0, 0, 0] epos = [0, 0, 0, 0] tool = 0 user = 0 vel = 100.0 acc = 100.0 ovl = 100.0 blendT = -1.0 flag = 0 robot.SetSpeed(20) robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel) robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel) time.sleep(1) robot.PointsOffsetEnable(flag=0, offset_pos=offset_pos1) robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel) robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel) robot.PointsOffsetDisable() robot.CloseRPC() Rozpoczęcie AO ruchu skrzynki kontrolnej ++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.4 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie AO ruchu skrzynki kontrolnej ++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.4 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Rozpoczęcie AO ruchu końcówki +++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.4 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie AO ruchu końcówki +++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.4 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu zdjęcia seryjnego AO (fly拍摄) ++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] offset_pos = [0, 0, 0, 0, 0, 0] offset_pos1 = [0, 0, 50, 0, 0, 0] epos = [0, 0, 0, 0] tool = 0 user = 0 vel = 20.0 acc = 20.0 ovl = 100.0 blendT = -1.0 flag = 0 robot.SetSpeed(20) robot.MoveAOStart(0, 100, 100, 20) robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel) robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel) robot.MoveAOStop() time.sleep(1) robot.MoveToolAOStart(0, 100, 100, 20) robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel) robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel) robot.MoveToolAOStop() robot.CloseRPC() Rozpoczęcie filtracji FIR ruchu PTP +++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.2 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie filtracji FIR ruchu PTP +++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.7 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Rozpoczęcie filtracji FIR ruchu LIN i ARC ++++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.7 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie filtracji FIR ruchu LIN i ARC +++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.7 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu filtracji FIR +++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] midjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] endjointPos = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257] startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] middescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] enddescPose = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061] exaxisPos = [0.0, 0.0, 0.0, 0.0] offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] rtn = robot.PtpFIRPlanningStart(1000.0, 1000.0) print(f"PtpFIRPlanningStart rtn is {rtn}") error = robot.MoveJ(joint_pos=startjointPos,tool= 0,user= 0,desc_pos=startdescPose,vel= 100,acc=100,ovl=100, blendT=-1.0, offset_flag=0) print(f"MoveJ rtn is {rtn}") error = robot.MoveJ(joint_pos=endjointPos,tool= 0,user= 0,desc_pos=enddescPose,vel= 100,acc=100,ovl=100, blendT=-1.0, offset_flag=0) print(f"MoveJ rtn is {rtn}") robot.PtpFIRPlanningEnd() print(f"PtpFIRPlanningEnd rtn is {rtn}") rtn = robot.LinArcFIRPlanningStart(1000, 1000, 1000, 1000) print(f"LinArcFIRPlanningStart rtn is {rtn}") error = robot.MoveL(desc_pos=startdescPose,tool= 0,user= 0, joint_pos=startjointPos,vel= 100,overSpeedStrategy=1,speedPercent=1) print(f"MoveL rtn is {rtn}") error = 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) print(f"MoveC rtn is {rtn}") robot.LinArcFIRPlanningEnd() print(f"LinArcFIRPlanningEnd rtn is {rtn}") robot.CloseRPC() Włączenie wygładzania przyspieszenia ++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.1 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Wyłączenie wygładzania przyspieszenia +++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.1 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu wygładzania przyspieszenia ++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] exaxisPos = [0.0, 0.0, 0.0, 0.0] offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] rtn = robot.AccSmoothStart(0) print(f"AccSmoothStart rtn is {rtn}") robot.MoveJ(joint_pos=startjointPos,tool= 0,user= 0,vel= 100) robot.MoveJ(joint_pos=endjointPos,tool= 0,user= 0,vel= 100) rtn = robot.AccSmoothEnd(0) print(f"AccSmoothEnd rtn is {rtn}") Włączenie określonej prędkości pozy robota ++++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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 " Wyłączenie określonej prędkości pozy ++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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 " Przykład kodu określonej prędkości pozy robota ++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] exaxisPos = [0.0, 0.0, 0.0, 0.0] offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] rtn = robot.AngularSpeedStart(50) print(f"AngularSpeedStart rtn is {rtn}") robot.MoveJ(joint_pos=startjointPos, tool=0,user= 0,vel= 100) robot.MoveJ(joint_pos=endjointPos, tool=0,user= 0,vel= 100) rtn = robot.AngularSpeedEnd() print(f"AngularSpeedEnd rtn is {rtn}") robot.CloseRPC() Włączenie ochrony przed osobliwą pozycją ++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Wyłączenie ochrony przed osobliwą pozycją +++++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.0.5 .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu ochrony przed osobliwą pozycją robota +++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time # Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota robot = Robot.RPC('192.168.58.2') startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256] endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255] startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833] enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869] exaxisPos = [0.0, 0.0, 0.0, 0.0] offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] rtn = robot.SingularAvoidStart(2, 10, 5, 5) print(f"SingularAvoidStart rtn is {rtn}") robot.MoveJ(joint_pos=startjointPos, tool=0,user= 0,vel= 100) robot.MoveJ(joint_pos=endjointPos, tool=0,user= 0,vel= 100) rtn = robot.SingularAvoidEnd() print(f"SingularAvoidEnd rtn is {rtn}") robot.CloseRPC() Wyczyszczenie kolejki instrukcji ruchu ++++++++++++++++++++++++++++++++++++++ .. versionadded:: python SDK-v2.1.7 .. csv-table:: :stub-columns: 1 :widths: 10 30 "Prototyp", "``MotionQueueClear()``" "Opis", "Wyczyszczenie kolejki instrukcji ruchu" "Parametry wymagane", "Brak" "Parametry domyślne", "Brak" "Wartość zwracana", "- Kod błędu sukces-0 błąd- errcode" Przejście do punktu początkowego linii przecięcia rur +++++++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Ruch po linii przecięcia rur ++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu ruchu robota po linii przecięcia rur +++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time robot = Robot.RPC('192.168.58.2') mainPoint = [[0.0] * 6 for _ in range(6)] piecePoint = [[0.0] * 6 for _ in range(6)] mainExaxisPos = [[0.0] * 4 for _ in range(6)] pieceExaxisPos = [[0.0] * 4 for _ in range(6)] extAxisFlag = 1 exaxisPos = [[0.0] * 4 for _ in range(4)] offset = [0.0, 2.0, 30.0, -2.0, 0.0, 0.0] mainPoint[0] = [490.004, -383.194, 402.735, -9.332, -1.528, 69.594] mainPoint[1] = [444.950, -407.117, 389.011, -5.546, -2.196, 65.279] mainPoint[2] = [445.168, -463.605, 355.759, -1.544, -10.886, 57.104] mainPoint[3] = [507.529, -485.385, 343.013, -0.786, -4.834, 61.799] mainPoint[4] = [554.390, -442.647, 367.701, -4.761, -10.181, 64.925] mainPoint[5] = [532.552, -394.003, 396.467, -13.732, -13.592, 67.411] mainExaxisPos[0] = [-29.996, 0.000, 0.000, 0.000] mainExaxisPos[1] = [-29.996, 0.000, 0.000, 0.000] mainExaxisPos[2] = [-29.996, 0.000, 0.000, 0.000] mainExaxisPos[3] = [-29.996, 0.000, 0.000, 0.000] mainExaxisPos[4] = [-29.996, 0.000, 0.000, 0.000] mainExaxisPos[5] = [-29.996, 0.000, 0.000, 0.000] piecePoint[0] = [505.571, -192.408, 316.759, 38.098, 37.051, 139.447] piecePoint[1] = [533.837, -201.558, 332.340, 34.644, 42.339, 137.748] piecePoint[2] = [530.386, -225.085, 373.808, 35.431, 45.111, 137.560] piecePoint[3] = [485.646, -229.195, 383.778, 33.870, 45.173, 137.064] piecePoint[4] = [460.551, -212.161, 354.256, 28.856, 45.602, 135.930] piecePoint[5] = [474.217, -197.124, 324.611, 42.469, 41.133, 148.167] pieceExaxisPos[0] = [-29.996, -0.000, 0.000, 0.000] pieceExaxisPos[1] = [-29.996, -0.000, 0.000, 0.000] pieceExaxisPos[2] = [-29.996, -0.000, 0.000, 0.000] pieceExaxisPos[3] = [-29.996, -0.000, 0.000, 0.000] pieceExaxisPos[4] = [-29.996, -0.000, 0.000, 0.000] pieceExaxisPos[5] = [-29.996, -0.000, 0.000, 0.000] exaxisPos[0] = [-29.996, -0.000, 0.000, 0.000] exaxisPos[1] = [-44.994, 90.000, 0.000, 0.000] exaxisPos[2] = [-59.992, 0.002, 0.000, 0.000] exaxisPos[3] = [-44.994, -89.997, 0.000, 0.000] tool = 2 wobj = 0 vel = 100.0 acc = 100.0 ovl = 12.0 oacc = 12.0 moveType = 1 moveDirection = 1 rtn = 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) print(f"MoveToIntersectLineStart rtn is {rtn}") rtn = 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) print(f"MoveIntersectLine rtn is {rtn}") robot.CloseRPC() Ruch w miejscu (pusty ruch) +++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu ruchu w miejscu (pusty ruch) ++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time robot = Robot.RPC('192.168.58.2') rtn = robot.LaserSensorRecordandReplay(0, 10, 1, 0, 0.1, 1, 0, 10, 100) print(f"LaserSensorRecordandReplay rtn is {rtn}") rtn = robot.MoveStationary() print(f"MoveStationary rtn is {rtn}") rtn = robot.LaserSensorRecord1(0, 10) print(f"LaserSensorRecordandReplay rtn is {rtn}") robot.CloseRPC() return 0 Rozpoczęcie wahadła w punkcie stałym ++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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 " Zakończenie wahadła w punkcie stałym ++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu SDK dla wahadła w punkcie stałym ++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from time import sleep import time from fairino import Robot # Połączenie z kontrolerem robota robot = Robot.RPC('192.168.58.2') def TestOriginPointWeave(self): time.sleep(2) # Inicjalizacja pozycji przegubów, osi zewnętrznej i przesunięcia j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842] epos = [0, 0, 0, 0] offset_pos = [0, 0, 0, 0, 0, 0] # Pozycja punktu odniesienia [x, y, z, rx, ry, rz] refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956] # Przejście do pozycji początkowej robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100, exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos) # Pierwsze wahadło: absolutny układ współrzędnych (tool=0), tryb 0 robot.OriginPointWeaveStart(0, 0, refPoint, 3) robot.MoveStationary() robot.OriginPointWeaveEnd() time.sleep(2) # Ponowne przejście do pozycji początkowej robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100, exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos) # Drugie wahadło: absolutny układ współrzędnych (tool=0), tryb 1 robot.OriginPointWeaveStart(0, 1, refPoint, 3) robot.MoveStationary() robot.OriginPointWeaveEnd() # Zamknięcie połączenia robot.CloseRPC() time.sleep(1) TestOriginPointWeave(robot) Przykład kodu SDK dla wahadła w punkcie stałym (z laserem i osią rozszerzenia) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from time import sleep import time from fairino import Robot # Połączenie z kontrolerem robota robot = Robot.RPC('192.168.58.2') def TestOriginPointWeave(self): time.sleep(2) # Inicjalizacja pozycji przegubów, osi zewnętrznej i przesunięcia j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842] epos1 = [0, 0, 0, 0] offset_pos = [0, 0, 0, 0, 0, 0] epos2 = [5, 0.000, 0.000, 0.000] # Pozycja punktu odniesienia [x, y, z, rx, ry, rz] refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956] rtn = 0 robot.LaserTrackingSensorConfig("192.168.58.20", 5020) robot.LaserTrackingSensorSamplePeriod(20) robot.LoadPosSensorDriver(101) # Ładowanie sterownika UDP robot.ExtDevLoadUDPDriver() # Ustawienie czasu zakończenia polecenia osi zewnętrznej rtn = robot.SetExAxisCmdDoneTime(5000.0) print(f"SetExAxisCmdDoneTime rtn is {rtn}") # Włączenie osi zewnętrznej 1 i 2 rtn = robot.ExtAxisServoOn(1, 1) print(f"ExtAxisServoOn axis id 1 rtn is {rtn}") rtn = robot.ExtAxisServoOn(2, 1) print(f"ExtAxisServoOn axis id 2 rtn is {rtn}") time.sleep(2) # Ustawienie powrotu do zera osi zewnętrznej robot.ExtAxisSetHoming(1, 0, 10, 2) robot.LaserTrackingLaserOnOff(1) # 1---bez osi rozszerzenia robot.LaserTrackingTrackOnOff(1, 4) time.sleep(0.2) # Rozpoczęcie wahadła w punkcie stałym robot.OriginPointWeaveStart(0, 0, refPoint, 10) robot.MoveStationary() # Wykonanie stałego ruchu robot.OriginPointWeaveEnd() robot.LaserTrackingTrackOnOff(0, 4) time.sleep(2) # Oczekiwanie 2 sekundy # 2----z osią rozszerzenia robot.ExtAxisMove(epos1, 100, -1) robot.LaserTrackingTrackOnOff(1, 4) # Rozpoczęcie wahadła w punkcie stałym robot.OriginPointWeaveStart(0, 0, refPoint, 20) robot.ExtAxisMove(epos2, 100, -1) robot.OriginPointWeaveEnd() robot.LaserTrackingTrackOnOff(0, 4) # Zamknięcie połączenia robot.CloseRPC() time.sleep(1) TestOriginPointWeave(robot) Ruch w trybie serwo prędkościowym w przestrzeni przegubów +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu ruchu w trybie serwo prędkościowym w przestrzeni przegubów +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from fairino import Robot import time def main(): # Połączenie z kontrolerem robota robot = Robot.RPC('192.168.58.2') time.sleep(0.5) # Oczekiwanie na połączenie i odbiór danych # Inicjalizacja tablicy prędkości przegubów i prędkości osi rozszerzenia joint_vel = [10.0, 0.0, 0.0, 0.0, 0.0, 0.0] exis_vel = [0.0, 0.0, 0.0, 0.0] acc = 0.0 vel = 0.0 cmdT = 0.008 filterT = 0.0 gain = 0.0 cnt = 0 # Pętla wywołująca ServoJV, łącznie 200 razy while cnt < 200: rtn = robot.ServoJV(joint_vel=joint_vel, exis_vel=exis_vel, acc=acc, vel=vel, cmdT=cmdT, filterT=filterT, gain=gain) print(f"ServoJV rtn is {rtn}") cnt += 1 # Zamknięcie połączenia robot.CloseRPC() # Wywołanie funkcji testowej main() Rozpoczęcie sterowania MIT przegubów ++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Zakończenie sterowania MIT przegubów ++++++++++++++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Sterowanie MIT przegubów ++++++++++++++++++++++++ .. csv-table:: :stub-columns: 1 :widths: 10 30 "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" Przykład kodu sterowania MIT przegubów robota +++++++++++++++++++++++++++++++++++++++++++++ .. code-block:: python :linenos: from time import sleep import time from fairino import Robot # Połączenie z kontrolerem robota robot = Robot.RPC('192.168.58.2') # Definicja funkcji zwrotnej def udp_frame_callback(src_type, count, cmd_id, data_len, content): """Funkcja zwrotna odpowiedzi polecenia UDP""" print(f"Funkcja zwrotna: cmd_id={cmd_id} count={count} data_len={data_len} content={content}") return 0 def ServoMITtest(self): # Ustawienie funkcji zwrotnej odpowiedzi polecenia UDP robot.SetUDPCmdRpyCallback(udp_frame_callback) while True: # Resetowanie wszystkich błędów robot.ResetAllError() time.sleep(0.5) # Inicjalizacja tablic parametrów posGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] desPos = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] velGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] desVel = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] # Pobranie momentu przegubów rtn, torques = robot.GetJointTorques(flag=1) print(f"GetJointTorques rtn: {rtn}") print("111111") # Uruchomienie trybu MIT rtn = robot.ServoMITStart(0) print(f"ServoMITStart rtn: {rtn}") # Włączenie przeciągania i uczenia rtn = robot.DragTeachSwitch(1) print(f"DragTeachSwitch rtn: {rtn}") intev = 0.008 # Ruch w przód: dodatni moment na 6 osi, aż kąt przekroczy 30 stopni while True: torques[5] = 0.03 rtn = robot.ServoMIT(posGain, desPos, velGain, desVel, torques, intev, comType=0) print(f"ServoMIT call rtn is {rtn}") time.sleep(0.001) # 1 ms rtn, pkg = robot.GetRobotRealTimeState() print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}") if pkg.jt_cur_pos[5] > 30: break # Ruch w tył: ujemny moment na 6 osi, aż kąt spadnie poniżej 0 stopni while True: torques[5] = -0.03 rtn = robot.ServoMIT(posGain, desPos, velGain, desVel, torques, intev, comType=0) print(f"ServoMIT call rtn is {rtn}") time.sleep(0.001) # 1 ms rtn, pkg = robot.GetRobotRealTimeState() print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}") if pkg.jt_cur_pos[5] < 0: break # Wyłączenie przeciągania i uczenia rtn = robot.DragTeachSwitch(0) print(f"DragTeachSwitch off rtn: {rtn}") # Zakończenie trybu MIT rtn = robot.ServoMITEnd(0) print(f"ServoMITEnd rtn: {rtn}") # Wywołanie funkcji testowej ServoMITtest(robot)