8. Roboter-Statusabfrage

8.1. Aktuelle Gelenkposition (Winkel) abrufen

Prototyp	GetActualJointPosDegree(flag=1)
Beschreibung	Aktuelle Gelenkposition (Winkel) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode joint_pos = [j1, j2, j3, j4, j5, j6]: Aktuelle Gelenkposition (Winkel) [°]

8.2. Aktuelle Gelenkposition (Bogenmaß) abrufen

Prototyp	GetActualJointPosRadian(flag=1)
Beschreibung	Aktuelle Gelenkposition (Bogenmaß) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode joint_pos = [j1, j2, j3, j4, j5, j6]: Aktuelle Gelenkposition (rad)

8.3. Gelenk-Rückmeldegeschwindigkeit (deg/s) abrufen

Prototyp	GetActualJointSpeedsDegree(flag=1)
Beschreibung	Gelenk-Rückmeldegeschwindigkeit (deg/s) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode speed = [j1, j2, j3, j4, j5, j6]: Gelenk-Rückmeldegeschwindigkeit [°/s]

8.4. Gelenk-Rückmeldebeschleunigung (deg/s²) abrufen

Prototyp	GetActualJointAccDegree(flag=1)
Beschreibung	Gelenk-Rückmeldebeschleunigung (deg/s²) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode acc = [j1, j2, j3, j4, j5, j6]: Gelenk-Rückmeldebeschleunigung [°/s²]

8.5. TCP-Befehlsresultierende Geschwindigkeit abrufen

Prototyp	GetTargetTCPCompositeSpeed(flag=1)
Beschreibung	TCP-Befehlsresultierende Geschwindigkeit abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode [tcp_speed, ori_speed]: tcp_speed = lineare Resultierende [mm/s], ori_speed = resultierende Orientierungsgeschwindigkeit [°/s]

8.6. TCP-Rückmelderesultierende Geschwindigkeit abrufen

Prototyp	GetActualTCPCompositeSpeed(flag=1)
Beschreibung	TCP-Rückmelderesultierende Geschwindigkeit abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode [tcp_speed, ori_speed]: tcp_speed = lineare Resultierende [mm/s], ori_speed = resultierende Orientierungsgeschwindigkeit [°/s]

8.7. TCP-Befehlsgeschwindigkeit (Komponenten) abrufen

Prototyp	GetTargetTCPSpeed(flag=1)
Beschreibung	TCP-Befehlsgeschwindigkeit (Komponenten) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode speed = [x, y, z, rx, ry, rz]: Befohlene TCP-Geschwindigkeit [mm/s, °/s]

8.8. TCP-Rückmeldegeschwindigkeit (Komponenten) abrufen

Prototyp	GetActualTCPSpeed(flag=1)
Beschreibung	TCP-Rückmeldegeschwindigkeit (Komponenten) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode speed = [x, y, z, rx, ry, rz]: Tatsächliche TCP-Geschwindigkeit [mm/s, °/s]

8.9. Aktuelle Werkzeugpose (TCP) abrufen

Prototyp	GetActualTCPPose(flag=1)
Beschreibung	Aktuelle Werkzeugpose (TCP) abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode tcp_pose = [x, y, z, rx, ry, rz]: Aktuelle Werkzeugpose [mm, °]

8.10. Nummer des aktuellen Werkzeugkoordinatensystems abrufen

Prototyp	GetActualTCPNum(flag=1)
Beschreibung	Nummer des aktuellen Werkzeugkoordinatensystems abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode tool_id: Nummer des Werkzeugkoordinatensystems

8.11. Nummer des aktuellen Werkstückkoordinatensystems abrufen

Prototyp	GetActualWObjNum(flag=1)
Beschreibung	Nummer des aktuellen Werkstückkoordinatensystems abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode wobj_id: Nummer des Werkstückkoordinatensystems

8.12. Aktuelle Pose des Endflansches abrufen

Prototyp	GetActualToolFlangePose(flag=1)
Beschreibung	Aktuelle Pose des Endflansches abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode flange_pose = [x, y, z, rx, ry, rz]: Aktuelle Pose des Endflansches [mm, °]

8.13. Aktuelle Gelenkmomente abrufen

Prototyp	GetJointTorques(flag=1)
Beschreibung	Aktuelle Gelenkmomente abrufen
Erforderliche Parameter	Keine
Standardparameter	flag: 0 = blockierend, 1 = nicht blockierend, Standard = 1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode torques = [j1, j2, j3, j4, j5, j6]: Gelenkmomente [Nm]

8.14. Systemzeit abrufen

Prototyp	GetSystemClock()
Beschreibung	Systemzeit abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode t_ms: Systemzeit [ms]

8.15. Abfragen, ob die Roboterbewegung abgeschlossen ist

Prototyp	GetRobotMotionDone()
Beschreibung	Abfragen, ob die Roboterbewegung abgeschlossen ist
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode state: Bewegungsstatus: 0 = nicht abgeschlossen, 1 = abgeschlossen

8.16. Länge der Roboter-Bewegungsbefehlswarteschlange abrufen

Prototyp	GetMotionQueueLength()
Beschreibung	Länge der Roboter-Bewegungsbefehlswarteschlange abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode len: Aktuelle Warteschlangenlänge

8.17. Roboter-Not-Halt-Status abrufen

Prototyp	GetRobotEmergencyStopState()
Beschreibung	Roboter-Not-Halt-Status abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode state: Not-Halt-Status: 0 = kein Not-Halt, 1 = Not-Halt aktiv

8.18. Kommunikationsstatus zwischen SDK und Roboter abrufen

Prototyp	GetSDKComState()
Beschreibung	Kommunikationsstatus zwischen SDK und Roboter abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode state: Kommunikationsstatus: 0 = normal, 1 = gestört

8.19. Sicherheitsstopp-Signal abrufen

Prototyp	GetSafetyStopState()
Beschreibung	Sicherheitsstopp-Signal abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode [si0_state, si1_state]: si0_state = Signal SI0 (0 = inaktiv, 1 = aktiv), si1_state = Signal SI1 (0 = inaktiv, 1 = aktiv)

8.20. Aktuelle Temperatur der Gelenkantriebe (°C) abrufen

Prototyp	GetJointDriverTemperature()
Beschreibung	Aktuelle Temperatur der Gelenkantriebe (°C) abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode data = [t1, t2, t3, t4, t5, t6]: Aktuelle Temperaturen der sechs Antriebe [°C]

8.21. Aktuelles Drehmoment der Gelenkantriebe (Nm) abrufen

Prototyp	GetJointDriverTorque()
Beschreibung	Aktuelles Drehmoment der Gelenkantriebe (Nm) abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode data = [j1, j2, j3, j4, j5, j6]: Aktuelle Drehmomente der sechs Antriebe [Nm]

8.22. Roboter-Echtzeitstatus abrufen

Prototyp	GetRobotRealTimeState()
Beschreibung	Roboter-Echtzeitstatus abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode robot_state_pkg: Struktur mit den Echtzeitstatusdaten des Roboters

8.23. Codebeispiel für Roboter-Statusabfrage

from fairino import Robot
import time
# Verbindung zur Robotersteuerung herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
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.24. Inverse Kinematik berechnen

Prototyp	GetInverseKin(type, desc_pos, config=-1)
Beschreibung	Inverse Kinematik: Berechnet Gelenkpositionen aus einer kartesischen Pose
Erforderliche Parameter	type: 0 = absolute Pose (Basiskoordinatensystem), 1 = relative Pose (Basiskoordinatensystem), 2 = relative Pose (Werkzeugkoordinatensystem) desc_pose: [x, y, z, rx, ry, rz], Werkzeugpose [mm, °]
Standardparameter	config: Gelenk-Konfiguration: [-1] = Berechnung basierend auf aktueller Gelenkposition, [0~7] = Berechnung basierend auf spezifischer Konfiguration. Standard = -1
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode joint_pos = [j1, j2, j3, j4, j5, j6]: Berechnete Gelenkpositionen [°]

8.25. Inverse Kinematik mit Referenzposition berechnen

Prototyp	GetInverseKinRef(type, desc_pos, joint_pos_ref)
Beschreibung	Inverse Kinematik unter Verwendung einer Referenz-Gelenkposition
Erforderliche Parameter	type: 0 = absolute Pose (Basiskoordinatensystem), 1 = relative Pose (Basiskoordinatensystem), 2 = relative Pose (Werkzeugkoordinatensystem) desc_pos: [x, y, z, rx, ry, rz], Werkzeugpose [mm, °] joint_pos_ref: [j1, j2, j3, j4, j5, j6], Referenz-Gelenkposition [°]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode joint_pos = [j1, j2, j3, j4, j5, j6]: Berechnete Gelenkpositionen [°]

8.26. Inverse Kinematik im kartesischen Raum inklusive Erweiterungsachsenposition

Prototyp	GetInverseKinExaxis(type, desc_pos, exaxis, tool, workPiece)
Beschreibung	Inverse Kinematik im kartesischen Raum inklusive Erweiterungsachsenposition
Erforderliche Parameter	type: 0 = absolute Pose (Basiskoordinatensystem), 1 = inkrementelle Pose (Basiskoordinatensystem), 2 = inkrementelle Pose (Werkzeugkoordinatensystem) desc_pos: Kartesische Pose [mm, °] exaxis: Position der Erweiterungsachse(n) [mm] tool: Werkzeugnummer workPiece: Werkstücknummer
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode joint_pos: Berechnete Gelenkpositionen [°]

8.27. Codebeispiel für inverse Kinematik mit Erweiterungsachse

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.28. Prüfen, ob die inverse Kinematik eine Lösung hat

Prototyp	GetInverseKinHasSolution(type, desc_pos, joint_pos_ref)
Beschreibung	Prüfen, ob die inverse Kinematik für eine gegebene Pose eine Lösung hat
Erforderliche Parameter	type: 0 = absolute Pose (Basiskoordinatensystem), 1 = relative Pose (Basiskoordinatensystem), 2 = relative Pose (Werkzeugkoordinatensystem) desc_pos: [x, y, z, rx, ry, rz], Werkzeugpose [mm, °] joint_pos_ref: [j1, j2, j3, j4, j5, j6], Referenz-Gelenkposition [°]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode result: True = Lösung vorhanden, False = keine Lösung

8.29. Vorwärtskinematik berechnen

Prototyp	GetForwardKin(joint_pos)
Beschreibung	Vorwärtskinematik: Berechnet Werkzeugpose aus Gelenkpositionen
Erforderliche Parameter	joint_pos: [j1, j2, j3, j4, j5, j6], Gelenkpositionen [°]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode desc_pos = [x, y, z, rx, ry, rz]: Berechnete Werkzeugpose [mm, °]

8.30. Codebeispiel für Vorwärts- und inverse Kinematik

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
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.31. Daten eines Roboter-Teachingpunkts abfragen

Prototyp	GetRobotTeachingPoint(name)
Beschreibung	Daten eines Roboter-Teachingpunkts abfragen
Erforderliche Parameter	name: Name des Punkts
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode [x, y, z, rx, ry, rz, j1, j2, j3, j4, j5, j6, tool, wobj, speed, acc, e1, e2, e3, e4]: Punktdaten

8.32. DH-Parameter-Kompensationswerte abrufen

Neu in Version Python: SDK-v2.0.1

Prototyp	GetDHCompensation()
Beschreibung	DH-Parameter-Kompensationswerte abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode dhCompensation = [cmpstD1, cmpstA2, cmpstA3, cmpstD4, cmpstD5, cmpstD6]: DH-Parameter-Kompensationswerte [mm]

8.33. SN-Code des Steuerkastens abrufen

Neu in Version Python: SDK-v2.1.1

Prototyp	GetRobotSN()
Beschreibung	SN-Code des Steuerkastens abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode SNCode: SN-Code des Steuerkastens

8.34. Codebeispiel für Teachingpunkt-Abfrage

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
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.35. Werkzeugkoordinatensystem nach ID abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetToolCoordWithID(id)
Beschreibung	Werkzeugkoordinatensystem nach ID abrufen
Erforderliche Parameter	id: Werkzeugkoordinatensystem-Nummer
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.36. Werkstückkoordinatensystem nach ID abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetWObjCoordWithID(id)
Beschreibung	Werkstückkoordinatensystem nach ID abrufen
Erforderliche Parameter	id: Werkstückkoordinatensystem-Nummer
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.37. Externes Werkzeugkoordinatensystem nach ID abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetExToolCoordWithID(id)
Beschreibung	Externes Werkzeugkoordinatensystem nach ID abrufen
Erforderliche Parameter	id: Externes Werkzeugkoordinatensystem-Nummer
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.38. Erweiterungsachsen-Koordinatensystem nach ID abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetExAxisCoordWithID(id)
Beschreibung	Erweiterungsachsen-Koordinatensystem nach ID abrufen
Erforderliche Parameter	id: Erweiterungsachsen-Koordinatensystem-Nummer
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.39. Lastmasse und -schwerpunkt nach ID abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetTargetPayloadWithID(id)
Beschreibung	Lastmasse und -schwerpunkt nach ID abrufen
Erforderliche Parameter	id: Lastnummer (Erweiterungsachsen-Koordinatensystem-Nummer?)
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode weight: Lastmasse [kg] cog: Lastschwerpunkt [x, y, z] [mm]

8.40. Aktuelles Werkzeugkoordinatensystem abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetCurToolCoord()
Beschreibung	Aktuelles Werkzeugkoordinatensystem abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.41. Aktuelles Werkstückkoordinatensystem abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetCurWObjCoord()
Beschreibung	Aktuelles Werkstückkoordinatensystem abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.42. Aktuelles externes Werkzeugkoordinatensystem abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetCurExToolCoord()
Beschreibung	Aktuelles externes Werkzeugkoordinatensystem abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.43. Aktuelles Erweiterungsachsen-Koordinatensystem abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetCurExAxisCoord()
Beschreibung	Aktuelles Erweiterungsachsen-Koordinatensystem abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz]

8.44. Codebeispiel zum Abrufen von Roboter-Koordinatensystemen und Lastdaten

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
robot = Robot.RPC('192.168.58.2')
id = 1
toolCoord = [0.0] * 6
extoolCoord = [0.0] * 6
wobjCoord = [0.0] * 6
exAxisCoord = [0.0] * 6
for i in range(100):
    print(f"ID:{id}")
    coordSet0 = [0.0] * 6
    coordSet = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
    etcp = [10.0, 20.0, 30.0, 40.0, 50.0, 60.0]
    etool = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
    cog = [1.0, 2.0, 3.0]
    if i % 2 == 0:
        robot.SetToolCoord(id, coordSet, 0, 0, 1, 0)
        time.sleep(0.1)
        robot.SetWObjCoord(id, coordSet, 0)
        time.sleep(0.1)
        robot.ExtAxisActiveECoordSys(id, 1, coordSet, 1)
        time.sleep(0.1)
        rtn = robot.SetExToolCoord(id, etcp, etool)
        time.sleep(0.1)
        rtn = robot.SetLoadWeight(id, 1.5)
        time.sleep(0.1)
        rtn = robot.SetLoadCoord(cog[0],cog[1],cog[2],id)
        time.sleep(0.1)
    else:
        robot.SetToolCoord(id, coordSet0, 0, 0, 1, 0)
        time.sleep(0.1)
        robot.SetWObjCoord(id, coordSet0, 0)
        time.sleep(0.1)
        robot.ExtAxisActiveECoordSys(id, 1, coordSet0, 1)
        time.sleep(0.1)
        rtn = robot.SetExToolCoord(id, coordSet0, coordSet0)
        time.sleep(0.1)
        rtn = robot.SetLoadWeight(id, 0)
        time.sleep(0.1)
        rtn = robot.SetLoadCoord(coordSet0[0],coordSet0[1],coordSet0[2] , id)
        time.sleep(0.1)
    rtn, toolCoord = robot.GetCurToolCoord()
    print(f"GetToolCoord {toolCoord[0]},{toolCoord[1]},{toolCoord[2]},{toolCoord[3]},{toolCoord[4]},{toolCoord[5]}")
    rtn, wobjCoord = robot.GetCurWObjCoord()
    print(f"GetWObjCoord {wobjCoord[0]},{wobjCoord[1]},{wobjCoord[2]},{wobjCoord[3]},{wobjCoord[4]},{wobjCoord[5]}")
    rtn, extoolCoord = robot.GetCurExToolCoord()
    print(f"GetExToolCoord {extoolCoord[0]},{extoolCoord[1]},{extoolCoord[2]},{extoolCoord[3]},{extoolCoord[4]},{extoolCoord[5]}")
    rtn, exAxisCoord = robot.GetCurExAxisCoord()
    print(f"GetExAxisCoord {exAxisCoord[0]},{exAxisCoord[1]},{exAxisCoord[2]},{exAxisCoord[3]},{exAxisCoord[4]},{exAxisCoord[5]}")
    weight = 0.0
    getCog = [0.0] * 3
    rtn, weight = robot.GetTargetPayload(0)
    rtn, getCog = robot.GetTargetPayloadCog(0)
    print(f"GetTargetPayload {weight},{getCog[0]},{getCog[1]},{getCog[2]}")

    rtn, toolCoord = robot.GetToolCoordWithID(id)
    print(f"GetToolCoordWithID {id},{toolCoord[0]},{toolCoord[1]},{toolCoord[2]},{toolCoord[3]},{toolCoord[4]},{toolCoord[5]}")
    rtn, wobjCoord = robot.GetWObjCoordWithID(id)
    print(f"GetWObjCoordWithID {id},{wobjCoord[0]},{wobjCoord[1]},{wobjCoord[2]},{wobjCoord[3]},{wobjCoord[4]},{wobjCoord[5]}")
    rtn, extoolCoord = robot.GetExToolCoordWithID(id)
    print(f"GetExToolCoordWithID {id},{extoolCoord[0]},{extoolCoord[1]},{extoolCoord[2]},{extoolCoord[3]},{extoolCoord[4]},{extoolCoord[5]}")
    rtn, exAxisCoord = robot.GetExAxisCoordWithID(id)
    print(f"GetExAxisCoordWithID {id},{exAxisCoord[0]},{exAxisCoord[1]},{exAxisCoord[2]},{exAxisCoord[3]},{exAxisCoord[4]},{exAxisCoord[5]}")
    weight = 0.0
    getCog = [0.0] * 3
    rtn, weight, getCog = robot.GetTargetPayloadWithID(id)
    print(f"GetTargetPayloadWithID {id},{weight},{getCog[0]},{getCog[1]},{getCog[2]}")
    time.sleep(0.5)
    print(f"times {i}")