8. Zapytanie o stan robota

8.1. Pobieranie bieżącej pozycji przegubów (kąt)

Prototyp	`GetActualJointPosDegree(flag=1)`
Opis	Pobieranie bieżącej pozycji przegubów (kąt)
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `joint_pos=[j1,j2,j3,j4,j5,j6]`: Bieżąca pozycja przegubów (kąt)

8.2. Pobieranie bieżącej pozycji przegubów (radian)

Prototyp	`GetActualJointPosRadian(flag=1)`
Opis	Pobieranie bieżącej pozycji przegubów (radian)
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `joint_pos=[j1,j2,j3,j4,j5,j6]`: Bieżąca pozycja przegubów (radian)

8.3. Pobieranie prędkości sprzężenia zwrotnego przegubów - deg/s

Prototyp	`GetActualJointSpeedsDegree(flag=1)`
Opis	Pobieranie prędkości sprzężenia zwrotnego przegubów - deg/s
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `speed=[j1,j2,j3,j4,j5,j6]`: Prędkości sprzężenia zwrotnego przegubów - deg/s

8.4. Pobieranie przyspieszenia sprzężenia zwrotnego przegubów - deg/s^2

Prototyp	`GetActualJointAccDegree(flag=1)`
Opis	Pobieranie przyspieszenia sprzężenia zwrotnego przegubów - deg/s^2
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `acc=[j1,j2,j3,j4,j5,j6]`: Przyspieszenia sprzężenia zwrotnego przegubów - deg/s^2

8.5. Pobieranie prędkości wypadkowej zadanej TCP

Prototyp	`GetTargetTCPCompositeSpeed(flag=1)`
Opis	Pobieranie prędkości wypadkowej zadanej TCP
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `[tcp_speed,ori_speed]`: tcp_speed - liniowa prędkość wypadkowa ori_speed - prędkość wypadkowa pozy

8.6. Pobieranie prędkości wypadkowej sprzężenia zwrotnego TCP

Prototyp	`GetActualTCPCompositeSpeed(flag=1)`
Opis	Pobieranie prędkości wypadkowej sprzężenia zwrotnego TCP
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `[tcp_speed,ori_speed]`: tcp_speed - liniowa prędkość wypadkowa ori_speed - prędkość wypadkowa pozy

8.7. Pobieranie prędkości zadanej TCP

Prototyp	`GetTargetTCPSpeed(flag=1)`
Opis	Pobieranie prędkości zadanej TCP
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `speed=[x,y,z,rx,ry,rz]`: Prędkość zadana TCP, mm/s

8.8. Pobieranie prędkości sprzężenia zwrotnego TCP

Prototyp	`GetActualTCPSpeed(flag=1)`
Opis	Pobieranie prędkości sprzężenia zwrotnego TCP
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `speed=[x,y,z,rx,ry,rz]`: Prędkość sprzężenia zwrotnego TCP

8.9. Pobieranie bieżącej pozy narzędzia

Prototyp	`GetActualTCPPose(flag=1)`
Opis	Pobieranie bieżącej pozy narzędzia
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `tcp_pose=[x,y,z,rx,ry,rz]`: Bieżąca poza narzędzia

8.10. Pobieranie bieżącego numeru układu narzędzia

Prototyp	`GetActualTCPNum(flag=1)`
Opis	Pobieranie bieżącego numeru układu narzędzia
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `tool_id`: Numer układu narzędzia

8.11. Pobieranie bieżącego numeru układu przedmiotu

Prototyp	`GetActualWObjNum(flag=1)`
Opis	Pobieranie bieżącego numeru układu przedmiotu
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `wobj_id`: Numer układu przedmiotu

8.12. Pobieranie bieżącej pozy kołnierza końcowego

Prototyp	`GetActualToolFlangePose(flag=1)`
Opis	Pobieranie bieżącej pozy kołnierza końcowego
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `flange_pose=[x,y,z,rx,ry,rz]`: Bieżąca poza kołnierza końcowego

8.13. Pobieranie bieżącego momentu obrotowego przegubów

Prototyp	`GetJointTorques(flag=1)`
Opis	Pobieranie bieżącego momentu obrotowego przegubów
Parametry wymagane	Brak
Parametry domyślne	`flag`: 0-blokujący, 1-nieblokujący, domyślnie 1
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `torques=[j1,j2,j3,j4,j5,j6]`: Moment obrotowy przegubów

8.14. Pobieranie czasu systemowego

Prototyp	`GetSystemClock()`
Opis	Pobieranie czasu systemowego
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `t_ms`: Czas systemowy, jednostka [ms]

8.15. Synchronizacja Czasu Systemowego z Robotem

Prototyp	`SetRobottime(self)`
Opis	Pobiera bieżący czas systemowy komputera hosta i wysyła go do robota w celu synchronizacji czasu systemowego (ze względu na ograniczenia systemu QNX, dokładność synchronizacji jest na poziomie minut)
Parametry Wymagane	Brak
Parametry Domyślne	Brak
Wartość Zwracana	Kod błędu, 0-sukces; niezerowy-błąd

8.16. Przykład Kodu Synchronizacji Czasu Systemowego z Robotem

from fairino import Robot
import time
from datetime import datetime, timedelta


def main():
    # Nawiązanie połączenia z kontrolerem robota
    robot = Robot.RPC('192.168.58.2')
    time.sleep(0.5)

    print("========== Set and Get Robot Time Test ==========")

    # Pobranie czasu systemowego przed ustawieniem
    ret, t_ms = robot.GetSystemClock()
    if ret == 0 and t_ms is not None:
        print(f"system clock : {t_ms}")
        # Robot przechowuje UTC+8, konwersja do czasu PC (odejmij 8 godzin)
        robot_time = datetime.fromtimestamp(t_ms / 1000.0) - timedelta(hours=8)
        print(f"BEFORE Robot Time: {robot_time.strftime('%Y-%m-%d %H:%M:%S')}")
    else:
        print(f"GetSystemClock failed, ret:{ret}")

    # Ustawienie czasu robota na czas PC
    ret = robot.SetRobottime()
    print(f"SetRobottime ret: {ret}")

    # Pobranie czasu robota po ustawieniu
    ret, t_ms_after = robot.GetSystemClock()
    if ret == 0 and t_ms_after is not None:
        print(f"system clock : {t_ms_after}")
        # Robot przechowuje UTC+8, konwersja do czasu PC (odejmij 8 godzin)
        robot_time = datetime.fromtimestamp(t_ms_after / 1000.0) - timedelta(hours=8)

        # Czas PC - wyświetl lokalny czas systemowy
        pc_time = datetime.now()

        # Obcięcie obu czasów do minut
        pc_minute = pc_time.replace(second=0, microsecond=0)
        robot_minute = robot_time.replace(second=0, microsecond=0)

        # Porównanie spójności
        is_consistent = (pc_minute == robot_minute)
        if is_consistent:
            print(f"Consistent     | PC time: {pc_minute.strftime('%Y-%m-%d %H:%M')}  | Robot time: {robot_minute.strftime('%Y-%m-%d %H:%M')}")
        else:
            print(f"Inconsistent | PC time: {pc_minute.strftime('%Y-%m-%d %H:%M')}  | Robot time: {robot_minute.strftime('%Y-%m-%d %H:%M')}")
    else:
        print(f"GetSystemClock failed, ret:{ret}")

    # Zamknięcie połączenia
    robot.CloseRPC()


if __name__ == "__main__":
    main()

8.17. Sprawdzanie, czy ruch robota został zakończony

Prototyp	`GetRobotMotionDone()`
Opis	Sprawdzanie, czy ruch robota został zakończony
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `state`: Stan ruchu robota, 0-niezakończony, 1-zakończony

8.18. Sprawdzanie długości bufora kolejki ruchu robota

Prototyp	`GetMotionQueueLength()`
Opis	Sprawdzanie długości bufora kolejki ruchu robota
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `len`: Długość bufora

8.19. Pobieranie stanu zatrzymania awaryjnego robota

Prototyp	`GetRobotEmergencyStopState()`
Opis	Pobieranie stanu zatrzymania awaryjnego robota
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `state`: Stan zatrzymania awaryjnego, 0-brak zatrzymania awaryjnego, 1-zatrzymanie awaryjne

8.20. Pobieranie stanu komunikacji SDK z robotem

Prototyp	`GetSDKComState()`
Opis	Pobieranie stanu komunikacji SDK z robotem
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `state`: Stan komunikacji, 0-komunikacja normalna, 1-komunikacja nieprawidłowa

8.21. Pobieranie sygnału bezpiecznego zatrzymania

Prototyp	`GetSafetyStopState()`
Opis	Pobieranie sygnału bezpiecznego zatrzymania
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `[si0_state,si1_state]`: si0_state - sygnał bezpiecznego zatrzymania SI0, 0-nieaktywny, 1-aktywny; si1_state - sygnał bezpiecznego zatrzymania SI1, 0-nieaktywny, 1-aktywny

8.22. Pobieranie bieżącej temperatury sterownika przegubu (℃)

Prototyp	`GetJointDriverTemperature()`
Opis	Pobieranie bieżącej temperatury sterownika przegubu (℃)
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `data=[t1,t2,t3,t4,t5,t6]`: Bieżące temperatury każdego przegubu

8.23. Pobieranie bieżącego momentu obrotowego sterownika przegubu (Nm)

Prototyp	`GetJointDriverTorque()`
Opis	Pobieranie bieżącego momentu obrotowego sterownika przegubu (Nm)
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `data=[j1,j2,j3,j4,j5,j6]`: Moment obrotowy przegubów [fx,fy,fz,tx,ty,tz]

8.24. Pobieranie stanu robota

Prototyp	`GetRobotRealTimeState()`
Opis	Pobieranie stanu robota
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `robot_state_pkg`: Struktura stanu robota

8.25. Przykład kodu zapytania o stan robota

from fairino import Robot
# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
robot = Robot.RPC('192.168.58.2')
error,[yangle, zangle] = robot.GetRobotInstallAngle()
print(f"yangle:{yangle},zangle:{zangle}")
error,j_deg = robot.GetActualJointPosDegree(0)
print(f"joint pos deg:{j_deg[0]},{j_deg[1]},{j_deg[2]},{j_deg[3]},{j_deg[4]},{j_deg[5]}")
error,jointSpeed = robot.GetActualJointSpeedsDegree(0)
print(f"joint speeds deg:{jointSpeed[0]},{jointSpeed[1]},{jointSpeed[2]},{jointSpeed[3]},{jointSpeed[4]},{jointSpeed[5]}")
error,jointAcc = robot.GetActualJointAccDegree(0)
print(f"joint acc deg:{jointAcc[0]},{jointAcc[1]},{jointAcc[2]},{jointAcc[3]},{jointAcc[4]},{jointAcc[5]}")
error,[tcp_speed, ori_speed] = robot.GetTargetTCPCompositeSpeed(0)
print(f"GetTargetTCPCompositeSpeed tcp {tcp_speed}; ori {ori_speed}")
error,[tcp_speed, ori_speed] = robot.GetActualTCPCompositeSpeed(0)
print(f"GetActualTCPCompositeSpeed tcp {tcp_speed}; ori {ori_speed}")
error,targetSpeed = robot.GetTargetTCPSpeed(0)
print(f"GetTargetTCPSpeed {targetSpeed[0]},{targetSpeed[1]},{targetSpeed[2]},{targetSpeed[3]},{targetSpeed[4]},{targetSpeed[5]}")
error,actualSpeed = robot.GetActualTCPSpeed(0)
print(f"GetActualTCPSpeed {actualSpeed[0]},{actualSpeed[1]},{actualSpeed[2]},{actualSpeed[3]},{actualSpeed[4]},{actualSpeed[5]}")
error,tcp = robot.GetActualTCPPose(0)
print(f"tcp pose:{tcp[0]},{tcp[1]},{tcp[2]},{tcp[3]},{tcp[4]},{tcp[5]}")
error,flange = robot.GetActualToolFlangePose(0)
print(f"flange pose:{flange[0]},{flange[1]},{flange[2]},{flange[3]},{flange[4]},{flange[5]}")
error,id = robot.GetActualTCPNum(0)
print(f"tcp num:{id}")
error,id = robot.GetActualWObjNum(0)
print(f"wobj num:{id}")
error,jtorque = robot.GetJointTorques(0)
print(f"torques:{jtorque[0]},{jtorque[1]},{jtorque[2]},{jtorque[3]},{jtorque[4]},{jtorque[5]}")
error,t_ms = robot.GetSystemClock()
print(f"system clock:{t_ms}")
error,config = robot.GetRobotCurJointsConfig()
print(f"joint config:{config}")
error,motionDone = robot.GetRobotMotionDone()
print(f"GetRobotMotionDone:{motionDone}")
error,len = robot.GetMotionQueueLength()
print(f"GetMotionQueueLength:{len}")
error,emergState = robot.GetRobotEmergencyStopState()
print(f"GetRobotEmergencyStopState:{emergState}")
error,comstate = robot.GetSDKComState()
print(f"GetSDKComState:{comstate}")
error,[si0_state, si1_state] = robot.GetSafetyStopState()
print(f"GetSafetyStopState:{si0_state} {si1_state}")
error,temp = robot.GetJointDriverTemperature()
print(f"Temperature:{temp[0]},{temp[1]},{temp[2]},{temp[3]},{temp[4]},{temp[5]}")
error,torque = robot.GetJointDriverTorque()
print(f"torque:{torque[0]},{torque[1]},{torque[2]},{torque[3]},{torque[4]},{torque[5]}")
error,pkg = robot.GetRobotRealTimeState()
robot.CloseRPC()

8.26. Rozwiązanie kinematyki odwrotnej

Prototyp	`GetInverseKin(type,desc_pos,config=-1)`
Opis	Kinematyka odwrotna, rozwiązanie pozycji przegubów na podstawie pozy kartezjańskiej
Parametry wymagane	`type`: 0-pozycja absolutna (układ bazowy), 1-pozycja względna (układ bazowy), 2-pozycja względna (układ narzędzia) `desc_pose`: [x,y,z,rx,ry,rz], poza narzędzia, jednostka [mm][°]
Parametry domyślne	`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 `joint_pos=[j1,j2,j3,j4,j5,j6]`: Rozwiązanie kinematyki odwrotnej, pozycja przegubów na podstawie pozy kartezjańskiej

8.27. Rozwiązanie kinematyki odwrotnej - z określoną pozycją odniesienia

Prototyp	`GetInverseKinRef(type,desc_pos,joint_pos_ref)`
Opis	Kinematyka odwrotna, rozwiązanie pozycji przegubów na podstawie pozy narzędzia, z określoną pozycją odniesienia przegubów
Parametry wymagane	`type`: 0-pozycja absolutna (układ bazowy), 1-pozycja względna (układ bazowy), 2-pozycja względna (układ narzędzia) `desc_pos`: [x,y,z,rx,ry,rz] poza narzędzia, jednostka [mm][°] `joint_pos_ref`: [j1,j2,j3,j4,j5,j6], referencyjna pozycja przegubów, jednostka [°]
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `joint_pos=[j1,j2,j3,j4,j5,j6]`: Rozwiązanie kinematyki odwrotnej, pozycja przegubów na podstawie pozy narzędzia

8.28. Rozwiązanie kinematyki odwrotnej, przestrzeń kartezjańska z uwzględnieniem pozycji osi rozszerzenia

Prototyp	`GetInverseKinExaxis(type, desc_pos, exaxis, tool, workPiece, config = -1)`
Opis	Rozwiązanie kinematyki odwrotnej, przestrzeń kartezjańska z uwzględnieniem pozycji osi rozszerzenia
Parametry wymagane	`type`: 0-pozycja absolutna (układ bazowy), 1-pozycja przyrostowa (układ bazowy), 2-pozycja przyrostowa (układ narzędzia) `desc_pos`: Pozycja kartezjańska `exaxis`: Pozycja osi rozszerzenia `tool`: Numer narzędzia `workPiece`: Numer przedmiotu `config -1`: automatyczne rozwiązanie, 0-7 odpowiada ośmiu zestawom rozwiązań
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `joint_pos`: Pozycja przegubów

8.29. Przykład kodu rozwiązania kinematyki odwrotnej z uwzględnieniem pozycji osi rozszerzenia

from fairino import Robot
import time
robot = Robot.RPC('192.168.58.2')
desc = [99.957, -0.002, 29.994, -176.569, -6.757, -167.462]
exaxis = [100.0, 0.0, 0.0, 0.0]
jointPos = [0.0] * 6
offsetPos = [0.0] * 6
rtn,pkg = robot.GetRobotRealTimeState()
toolnum = pkg.tool
workPcsNum = pkg.user
rtn, jointPos = robot.GetInverseKinExaxis(0, desc, exaxis, toolnum, workPcsNum)
print(f"GetInverseKinExaxis joint is {jointPos[0]},{jointPos[1]},{jointPos[2]},{jointPos[3]},{jointPos[4]},{jointPos[5]}")
robot.ExtAxisMove(exaxis, 100, -1)
robot.MoveJ(joint_pos=jointPos, desc_pos=desc, tool=toolnum, user=workPcsNum, vel=100.0, acc=100.0, ovl=100.0, exaxis_pos=exaxis, blendT=-1, offset_flag=0, offset_pos=offsetPos)
robot.CloseRPC()
return 0

8.30. Sprawdzanie, czy kinematyka odwrotna ma rozwiązanie

Prototyp	`GetInverseKinHasSolution(type,desc_pos,joint_pos_ref)`
Opis	Sprawdzanie, czy kinematyka odwrotna (rozwiązanie pozycji przegubów na podstawie pozy narzędzia) ma rozwiązanie
Parametry wymagane	`type`: 0-pozycja absolutna (układ bazowy), 1-pozycja względna (układ bazowy), 2-pozycja względna (układ narzędzia) `desc_pos`: [x,y,z,rx,ry,rz] poza narzędzia, jednostka [mm][°] `joint_pos_ref`: [j1,j2,j3,j4,j5,j6], referencyjna pozycja przegubów, jednostka [°]
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `result`: „True” - ma rozwiązanie, „False” - nie ma rozwiązania

8.31. Pobieranie 8 zestawów rozwiązań odwrotnych dla robota

Prototyp	`TCFToAllJoint(self, tcp_pose, tool, workpiece, exPos)`
Opis	Pobierz 8 zestawów rozwiązań odwrotnych
Parametry wymagane	`tcp_pose`: Pozycja kartezjańska, 6 elementów [x,y,z,rx,ry,rz] `tool`: Układ współrzędnych narzędzia `workpiece`: Układ współrzędnych przedmiotu obrabianego `exPos`: Pozycja osi rozszerzonej, 4 elementy
Parametry domyślne	Brak
Wartość zwracana	Kod błędu Sukces-0 Błąd- errcode `jPos`: Wyjście 8 zestawów kątów przegubów, lista dwuwymiarowa, każdy zestaw zawiera 6 wartości przegubów, łącznie 48 wartości

8.32. Przykład kodu pobierania 8 zestawów rozwiązań odwrotnych dla robota

from fairino import Robot
import time

def main():
    # Establish connection with the robot controller
    robot = Robot.RPC('192.168.58.2')
    time.sleep(0.5)  # Wait for connection and data reception

    # Get current TCP pose
    ret, curTcp = robot.GetActualTCPPose(1)
    if ret != 0:
        print(f"GetActualTCPPose failed, ret:{ret}")
        robot.CloseRPC()
        return

    print(f"Current TCP pose: x={curTcp[0]:.3f}, y={curTcp[1]:.3f}, z={curTcp[2]:.3f}, "
        f"a={curTcp[3]:.3f}, b={curTcp[4]:.3f}, c={curTcp[5]:.3f}")

    # Exaxis position, all zeros here
    exPos = [0.0, 0.0, 0.0, 0.0]

    # Call TCFToAllJoint to get 8 inverse solutions, tool=0, workpiece=0
    rtn, allJoints = robot.TCFToAllJoint(curTcp, 0, 0, exPos)
    if rtn != 0:
        print(f"TCFToAllJoint failed, rtn:{rtn}")
        robot.CloseRPC()
        return

    # Verify each solution with forward kinematics
    for i in range(8):
        joint = allJoints[i]

        print(f"JOINT{i + 1}: j1={joint[0]:.3f}, j2={joint[1]:.3f}, j3={joint[2]:.3f}, "
            f"j4={joint[3]:.3f}, j5={joint[4]:.3f}, j6={joint[5]:.3f}")

        # Forward kinematics to get cartesian pose of the i-th solution
        rtn, pos = robot.GetForwardKin(joint)
        if rtn != 0:
            # Skip this solution if forward kinematics fails
            continue

        print(f"POS{i + 1}: x={pos[0]:.3f}, y={pos[1]:.3f}, z={pos[2]:.3f}, "
            f"a={pos[3]:.3f}, b={pos[4]:.3f}, c={pos[5]:.3f}")

    # Close connection
    robot.CloseRPC()

if __name__ == "__main__":
    main()

8.33. Rozwiązanie kinematyki prostej

Prototyp	`GetForwardKin(joint_pos)`
Opis	Kinematyka prosta, rozwiązanie pozy narzędzia na podstawie pozycji przegubów
Parametry wymagane	`joint_pos`: [j1,j2,j3,j4,j5,j6]: pozycja przegubów, jednostka [°]
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `desc_pos=[x,y,z,rx,ry,rz]`: Rozwiązanie kinematyki prostej, poza narzędzia na podstawie pozycji przegubów

8.34. Przykład kodu obliczeń kinematyki prostej i odwrotnej robota

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]
desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
error, inverseRtn = robot.GetInverseKin(0, desc_pos=desc_pos1, config=-1)
print(f"dcs1 GetInverseKin rtn is {inverseRtn[0]}, {inverseRtn[1]}, {inverseRtn[2]}, "
      f"{inverseRtn[3]}, {inverseRtn[4]}, {inverseRtn[5]}")
error, inverseRtn = robot.GetInverseKinRef(0, desc_pos=desc_pos1, joint_pos_ref=j1)
print(f"dcs1 GetInverseKinRef rtn is {inverseRtn[0]}, {inverseRtn[1]}, {inverseRtn[2]}, "
      f"{inverseRtn[3]}, {inverseRtn[4]}, {inverseRtn[5]}")
error, hasResult = robot.GetInverseKinHasSolution(0, desc_pos=desc_pos1, joint_pos_ref=j1)
print(f"dcs1 GetInverseKinRef result {hasResult}")
error, forwordResult = robot.GetForwardKin(j1)
print(f"jpos1 forwordResult rtn is {forwordResult[0]}, {forwordResult[1]}, {forwordResult[2]}, "
      f"{forwordResult[3]}, {forwordResult[4]}, {forwordResult[5]}")
robot.CloseRPC()

8.35. Zapytanie o dane punktu zarządzania nauczaniem robota

Prototyp	`GetRobotTeachingPoint(name)`
Opis	Zapytanie o dane punktu zarządzania nauczaniem robota
Parametry wymagane	`name`: Nazwa punktu
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `[x,y,z,rx,ry,rz,j1,j2,j3,j4,j5,j6,tool,wobj,speed,acc,e1,e2,e3,e4]`: Dane punktu

8.36. Pobieranie parametrów kompensacji DH

Dodane w wersji python: SDK-v2.0.1

Prototyp	`GetDHCompensation()`
Opis	Pobieranie parametrów kompensacji DH
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `dhCompensation=[cmpstD1,cmpstA2,cmpstA3,cmpstD4,cmpstD5,cmpstD6]`: Wartości kompensacji parametrów DH robota (mm)

8.37. Pobieranie numeru SN skrzynki kontrolnej

Dodane w wersji python: SDK-v2.1.1

Prototyp	`GetRobotSN()`
Opis	Pobieranie numeru SN skrzynki kontrolnej
Parametry wymagane	Brak
Parametry domyślne	Brak
Wartość zwracana	Kod błędu sukces-0 błąd- errcode `SNCode`: Numer SN skrzynki kontrolnej

8.38. Przykład kodu zapytania o dane punktu zarządzania nauczaniem robota

from fairino import Robot
# Połączenie z kontrolerem robota, po pomyślnym połączeniu zwraca obiekt robota
robot = Robot.RPC('192.168.58.2')
name = "P1"
rtn, data = robot.GetRobotTeachingPoint(name)
print(f"{rtn} name is: {name}")
for i in range(20):
    print(f"data is: {data[i]}")
rtn,que_len = robot.GetMotionQueueLength()
print(f"GetMotionQueueLength rtn is: {rtn}, queue length is: {que_len}")
retval,dh = robot.GetDHCompensation()
print(f"retval is: {retval}")
print(f"dh is: {dh[0]} {dh[1]} {dh[2]} {dh[3]} {dh[4]} {dh[5]}")
error,sn = robot.GetRobotSN()
print(f"robot SN is {sn[0]}")
robot.CloseRPC()

8.39. Pobieranie Układu Współrzędnych Narzędzia według ID

Zmienione w wersji python: SDK-V3.9.8

Prototyp	`GetToolCoordWithID(id)`
Opis	Pobiera układ współrzędnych narzędzia według ID
Parametry Wymagane	`id`: Numer układu współrzędnych narzędzia
Parametry Domyślne	Brak
Wartość Zwracana	Kod błędu, 0-sukces; niezerowy-błąd `coord`: Wartości układu współrzędnych `type`: Typ narzędzia (opcjonalny) 0-narzędzie; 1-czujnik `install`: Pozycja instalacji (opcjonalna) 0-koniec robota; 1-na zewnątrz robota `toolID`: ID narzędzia `loadNo`: Numer obciążenia

8.40. Pobieranie Układu Współrzędnych Przedmiotu według ID

Zmienione w wersji python: SDK-V3.9.8

Prototyp	`GetWObjCoordWithID(id)`
Opis	Pobiera układ współrzędnych przedmiotu według ID
Parametry Wymagane	`id`: Numer układu współrzędnych przedmiotu
Parametry Domyślne	Brak
Wartość Zwracana	Kod błędu, 0-sukces; niezerowy-błąd `coord`: Wartości układu współrzędnych `refFrame`: Referencyjny układ współrzędnych