8. Roboter-Statusabfrage

8.1. Aktuelle Gelenkposition (Winkel) abrufen

1/**
2* @brief  Gibt die aktuelle Gelenkposition (Winkel) zurück.
3* @param  [in] flag 0-blockierend, 1-nicht blockierend.
4* @param  [out] jPos Positionen der sechs Gelenke, Einheit deg.
5* @return  Fehlercode.
6*/
7errno_t GetActualJointPosDegree(uint8_t flag, JointPos *jPos);

8.2. Gelenk-Rückmeldegeschwindigkeit abrufen

1/**
2 * @brief Gibt die Gelenk-Rückmeldegeschwindigkeit in deg/s zurück.
3 * @param  [in] flag 0-blockierend, 1-nicht blockierend.
4 * @param  [out] speed Geschwindigkeiten der sechs Gelenke.
5 * @return  Fehlercode.
6 */
7errno_t GetActualJointSpeedsDegree(uint8_t flag, float speed[6]);

8.3. Gelenk-Rückmeldebeschleunigung abrufen

1/**
2 * @brief Gibt die Gelenk-Rückmeldebeschleunigung in deg/s² zurück.
3 * @param  [in] flag 0-blockierend, 1-nicht blockierend.
4 * @param  [out] acc Beschleunigungen der sechs Gelenke.
5 * @return  Fehlercode.
6 */
7errno_t GetActualJointAccDegree(uint8_t flag, float acc[6]);

8.4. TCP-Soll-Resultierendegeschwindigkeit abrufen

1/**
2 * @brief Gibt die resultierende TCP-Sollgeschwindigkeit zurück.
3 * @param  [in] flag 0-blockierend, 1-nicht blockierend.
4 * @param  [out] tcp_speed Lineare Geschwindigkeit.
5 * @param  [out] ori_speed Ausrichtungsgeschwindigkeit.
6 * @return  Fehlercode.
7 */
8errno_t GetTargetTCPCompositeSpeed(uint8_t flag, float *tcp_speed, float *ori_speed);

8.5. TCP-Ist-Resultierendegeschwindigkeit abrufen

1/**
2 * @brief Gibt die resultierende TCP-Istgeschwindigkeit zurück.
3 * @param  [in] flag 0-blockierend, 1-nicht blockierend.
4 * @param  [out] tcp_speed Lineare Geschwindigkeit.
5 * @param  [out] ori_speed Ausrichtungsgeschwindigkeit.
6 * @return  Fehlercode.
7 */
8errno_t GetActualTCPCompositeSpeed(uint8_t flag, float *tcp_speed, float *ori_speed);

8.6. TCP-Sollgeschwindigkeit (Komponenten) abrufen

1/**
2 * @brief Gibt die TCP-Sollgeschwindigkeit als Komponenten zurück.
3 * @param  [in] flag 0-blockierend, 1-nicht blockierend.
4 * @param  [out] speed Geschwindigkeiten [x, y, z, rx, ry, rz].
5 * @return  Fehlercode.
6 */
7errno_t GetTargetTCPSpeed(uint8_t flag, float speed[6]);

8.7. TCP-Istgeschwindigkeit (Komponenten) abrufen

1/**
2 * @brief Gibt die TCP-Istgeschwindigkeit als Komponenten zurück.
3 * @param  [in] flag 0-blockierend, 1-nicht blockierend.
4 * @param  [out] speed Geschwindigkeiten [x, y, z, rx, ry, rz].
5 * @return  Fehlercode.
6 */
7errno_t GetActualTCPSpeed(uint8_t flag, float speed[6]);

8.8. Aktuelle Werkzeugpose abrufen

1/**
2* @brief  Gibt die aktuelle Werkzeugpose zurück.
3* @param  [in] flag 0-blockierend, 1-nicht blockierend.
4* @param  [out] desc_pos Werkzeugpose.
5* @return  Fehlercode.
6*/
7errno_t GetActualTCPPose(uint8_t flag, DescPose *desc_pos);

8.9. Nummer des aktuellen Werkzeugkoordinatensystems abrufen

1/**
2* @brief  Gibt die Nummer des aktuellen Werkzeugkoordinatensystems zurück.
3* @param  [in] flag 0-blockierend, 1-nicht blockierend.
4* @param  [out] id Nummer des Werkzeugkoordinatensystems.
5* @return  Fehlercode.
6*/
7errno_t GetActualTCPNum(uint8_t flag, int *id);

8.10. Nummer des aktuellen Werkstückkoordinatensystems abrufen

1/**
2* @brief  Gibt die Nummer des aktuellen Werkstückkoordinatensystems zurück.
3* @param  [in] flag 0-blockierend, 1-nicht blockierend.
4* @param  [out] id Nummer des Werkstückkoordinatensystems.
5* @return  Fehlercode.
6*/
7errno_t GetActualWObjNum(uint8_t flag, int *id);

8.11. Aktuelle Pose des Endflansches abrufen

1/**
2* @brief  Gibt die aktuelle Pose des Endflansches zurück.
3* @param  [in] flag 0-blockierend, 1-nicht blockierend.
4* @param  [out] desc_pos Flanschpose.
5* @return  Fehlercode.
6*/
7errno_t GetActualToolFlangePose(uint8_t flag, DescPose *desc_pos);

8.12. Aktuelles Gelenkdrehmoment abrufen

1/**
2* @brief Gibt das aktuelle Gelenkdrehmoment zurück.
3* @param  [in] flag 0-blockierend, 1-nicht blockierend.
4* @param  [out] torques Gelenkdrehmomente.
5* @return  Fehlercode.
6*/
7errno_t GetJointTorques(uint8_t flag, float torques[6]);

8.13. Systemzeit abrufen

1/**
2* @brief  Gibt die Systemzeit zurück.
3* @param  [out] t_ms Zeit in Millisekunden.
4* @return  Fehlercode.
5*/
6errno_t GetSystemClock(float *t_ms);

8.14. Abfragen, ob die Roboterbewegung abgeschlossen ist

1/**
2* @brief  Fragt ab, ob die Roboterbewegung abgeschlossen ist.
3* @param  [out] state 0-nicht abgeschlossen, 1-abgeschlossen.
4* @return  Fehlercode.
5*/
6errno_t GetRobotMotionDone(uint8_t *state);

8.15. Länge der Roboter-Bewegungswarteschlange abrufen

1/**
2 * @brief Gibt die Länge der Roboter-Bewegungswarteschlange zurück.
3 * @param  [out] len Länge der Warteschlange.
4 * @return  Fehlercode.
5 */
6errno_t GetMotionQueueLength(int *len);

8.16. Roboter-Not-Halt-Status abrufen

1/**
2* @brief Gibt den Roboter-Not-Halt-Status zurück.
3* @param [out] state Not-Halt-Status, 0-nicht aktiv, 1-aktiv.
4* @return Fehlercode.
5*/
6errno_t GetRobotEmergencyStopState(uint8_t *state);

8.17. Kommunikationsstatus zwischen SDK und Roboter abrufen

1/**
2* @brief Gibt den Kommunikationsstatus zwischen SDK und Roboter zurück.
3* @param [out] state Kommunikationsstatus, 0-normal, 1-gestört.
4*/
5errno_t GetSDKComState(int *state);

8.18. Sicherheitsstopp-Signale abrufen

1/**
2* @brief Gibt die Sicherheitsstopp-Signale zurück.
3* @param [out] si0_state Sicherheitsstopp-Signal SI0, 0-inaktiv, 1-aktiv.
4* @param [out] si1_state Sicherheitsstopp-Signal SI1, 0-inaktiv, 1-aktiv.
5*/
6errno_t GetSafetyStopState(uint8_t *si0_state, uint8_t *si1_state);

8.19. Temperatur der Roboter-Gelenkantriebe (°C) abrufen

Neu in Version C++SDK-v2.1.5.0.

1/**
2* @brief Gibt die Temperatur der Roboter-Gelenkantriebe in °C zurück.
3* @param [out] temperature Array der Gelenktemperaturen.
4* @return Fehlercode.
5*/
6errno_t GetJointDriverTemperature(double temperature[]);

8.20. Drehmoment der Roboter-Gelenkantriebe (Nm) abrufen

Neu in Version C++SDK-v2.1.5.0.

1/**
2* @brief Gibt das Drehmoment der Roboter-Gelenkantriebe in Nm zurück.
3* @param [out] torque Array der Gelenkdrehmomente.
4* @return Fehlercode.
5*/
6errno_t GetJointDriverTorque(double torque[]);

8.21. Roboter-Echtzeitstatus-Struktur abrufen

Neu in Version C++SDK-v2.1.3.0.

1/**
2* @brief Gibt die Roboter-Echtzeitstatus-Struktur zurück.
3* @param [out] pkg Roboter-Echtzeitstatus-Struktur.
4* @return Fehlercode.
5*/
6errno_t GetRobotRealTimeState(ROBOT_STATE_PKG *pkg);

8.22. Codebeispiel für Roboter-Statusabfragen

 1int TestGetStatus(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return -1;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  float yangle, zangle;
14  robot.GetRobotInstallAngle(&yangle, &zangle);
15  printf("yangle:%f,zangle:%f\n", yangle, zangle);
16  JointPos j_deg = {};
17  robot.GetActualJointPosDegree(0, &j_deg);
18  printf("joint pos deg:%f,%f,%f,%f,%f,%f\n", j_deg.jPos[0], j_deg.jPos[1], j_deg.jPos[2], j_deg.jPos[3], j_deg.jPos[4], j_deg.jPos[5]);
19  float jointSpeed[6] = { 0.0 };
20  robot.GetActualJointSpeedsDegree(0, jointSpeed);
21  printf("joint speeds deg:%f,%f,%f,%f,%f,%f\n", jointSpeed[0], jointSpeed[1], jointSpeed[2], jointSpeed[3], jointSpeed[4], jointSpeed[5]);
22  float jointAcc[6] = { 0.0 };
23  robot.GetActualJointAccDegree(0, jointAcc);
24  printf("joint acc deg:%f,%f,%f,%f,%f,%f\n", jointAcc[0], jointAcc[1], jointAcc[2], jointAcc[3], jointAcc[4], jointAcc[5]);
25  float tcp_speed = 0.0;
26  float ori_speed = 0.0;
27  robot.GetTargetTCPCompositeSpeed(0, &tcp_speed, &ori_speed);
28  printf("GetTargetTCPCompositeSpeed tcp %f; ori %f\n", tcp_speed, ori_speed);
29  robot.GetActualTCPCompositeSpeed(0, &tcp_speed, &ori_speed);
30  printf("GetActualTCPCompositeSpeed tcp %f; ori %f\n", tcp_speed, ori_speed);
31  float targetSpeed[6] = { 0.0 };
32  robot.GetTargetTCPSpeed(0, targetSpeed);
33  printf("GetTargetTCPSpeed %f,%f,%f,%f,%f,%f\n", targetSpeed[0], targetSpeed[1], targetSpeed[2], targetSpeed[3], targetSpeed[4], targetSpeed[5]);
34  float actualSpeed[6] = { 0.0 };
35  robot.GetActualTCPSpeed(0, actualSpeed);
36  printf("GetTargetTCPSpeed %f,%f,%f,%f,%f,%f\n", actualSpeed[0], actualSpeed[1], actualSpeed[2], actualSpeed[3], actualSpeed[4], actualSpeed[5]);
37  DescPose tcp = {};
38  robot.GetActualTCPPose(0, &tcp);
39  printf("tcp pose:%f,%f,%f,%f,%f,%f\n", tcp.tran.x, tcp.tran.y, tcp.tran.z, tcp.rpy.rx, tcp.rpy.ry, tcp.rpy.rz);
40  DescPose flange = {};
41  robot.GetActualToolFlangePose(0, &flange);
42  printf("flange pose:%f,%f,%f,%f,%f,%f\n", flange.tran.x, flange.tran.y, flange.tran.z, flange.rpy.rx, flange.rpy.ry, flange.rpy.rz);
43  int id = 0;
44  robot.GetActualTCPNum(0, &id);
45  printf("tcp num:%d\n", id);
46  robot.GetActualWObjNum(0, &id);
47  printf("wobj num:%d\n", id);
48  float jtorque[6] = { 0.0 };
49  robot.GetJointTorques(0, jtorque);
50  printf("torques:%f,%f,%f,%f,%f,%f\n", jtorque[0], jtorque[1], jtorque[2], jtorque[3], jtorque[4], jtorque[5]);
51  float t_ms = 0.0;
52  robot.GetSystemClock(&t_ms);
53  printf("system clock:%f\n", t_ms);
54  int config = 0;
55  robot.GetRobotCurJointsConfig(&config);
56  printf("joint config:%d\n", config);
57  uint8_t motionDone = 0;
58  robot.GetRobotMotionDone(&motionDone);
59  printf("GetRobotMotionDone :%d\n", motionDone);
60  int len = 0;
61  robot.GetMotionQueueLength(&len);
62  printf("GetMotionQueueLength :%d\n", len);
63  uint8_t emergState = 0;
64  robot.GetRobotEmergencyStopState(&emergState);
65  printf("GetRobotEmergencyStopState :%d\n", emergState);
66  int comstate = 0;
67  robot.GetSDKComState(&comstate);
68  printf("GetSDKComState :%d\n", comstate);
69  uint8_t si0_state, si1_state;
70  robot.GetSafetyStopState(&si0_state, &si1_state);
71  printf("GetSafetyStopState :%d %d\n", si0_state, si1_state);
72  double temp[6] = { 0.0 };
73  robot.GetJointDriverTemperature(temp);
74  printf("Temperature:%f,%f,%f,%f,%f,%f\n", temp[0], temp[1], temp[2], temp[3], temp[4], temp[5]);
75  double torque[6] = { 0.0 };
76  robot.GetJointDriverTorque(torque);
77  printf("torque:%f,%f,%f,%f,%f,%f\n", torque[0], torque[1], torque[2], torque[3], torque[4], torque[5]);
78  robot.GetRobotRealTimeState(&pkg);
79  robot.CloseRPC();
80  return 0;
81}

8.23. Inverse Kinematik berechnen

1/**
2* @brief  Berechnet die inverse Kinematik.
3* @param  [in] type 0-absolute Pose (Basiskoordinatensystem), 1-inkrementelle Pose (Basiskoordinatensystem), 2-inkrementelle Pose (Werkzeugkoordinatensystem).
4* @param  [in] desc_pos Kartesische Pose.
5* @param  [in] config Gelenkraumkonfiguration, [-1]-basierend auf aktueller Gelenkposition berechnen, [0~7]-basierend auf spezifischer Konfiguration lösen.
6* @param  [out] joint_pos Gelenkposition.
7* @return  Fehlercode.
8*/
9errno_t GetInverseKin(int type, DescPose *desc_pos, int config, JointPos *joint_pos);

8.24. Inverse Kinematik berechnen (mit Referenzposition)

1/**
2* @brief  Berechnet die inverse Kinematik unter Verwendung einer Referenz-Gelenkposition.
3* @param  [in] type 0-absolute Pose (Basiskoordinatensystem), 1-inkrementelle Pose (Basiskoordinatensystem), 2-inkrementelle Pose (Werkzeugkoordinatensystem).
4* @param  [in] desc_pos Kartesische Pose.
5* @param  [in] joint_pos_ref Referenz-Gelenkposition.
6* @param  [out] joint_pos Berechnete Gelenkposition.
7* @return  Fehlercode.
8*/
9errno_t GetInverseKinRef(int type, DescPose *desc_pos, JointPos *joint_pos_ref, JointPos *joint_pos);

8.25. Inverse Kinematik (mit Erweiterungsachsenposition) berechnen

 1/**
 2* @brief Berechnet die inverse Kinematik, einschließlich der Erweiterungsachsenposition im kartesischen Raum.
 3* @param [in] type 0-absolute Pose (Basiskoordinatensystem), 1-inkrementelle Pose (Basiskoordinatensystem), 2-inkrementelle Pose (Werkzeugkoordinatensystem).
 4* @param [in] desc_pos Kartesische Pose.
 5* @param [in] exaxis Position der Erweiterungsachse.
 6* @param [in] tool Werkzeugnummer.
 7* @param [in] workPiece Werkstücknummer.
 8* @param [out] joint_pos Gelenkposition.
 9* @return Fehlercode.
10*/
11errno_t GetInverseKinExaxis(int type, DescPose desc_pos, ExaxisPos exaxis, int tool, int workPiece, JointPos& joint_pos);

8.26. Codebeispiel für inverse Kinematik mit Erweiterungsachsen

 1int TestInverseKinExaxis()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(1);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return 0;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    DescPose desc(99.957, -0.002, 29.994, -176.569, -6.757, -167.462);
14    ExaxisPos exaxis(100.0, 0.0, 0.0, 0.0);
15    JointPos jointPos = {};
16    DescPose offsetPos = {};
17    robot.GetRobotRealTimeState(&pkg);
18    int toolnum = pkg.tool;
19    int workPcsNum = pkg.user;
20    robot.GetInverseKinExaxis(0, desc, exaxis, toolnum, workPcsNum, jointPos);
21    printf("GetInverseKinExaxis joint is %f, %f, %f, %f, %f, %f\n", jointPos.jPos[0], jointPos.jPos[1], jointPos.jPos[2], jointPos.jPos[3], jointPos.jPos[4], jointPos.jPos[5]);
22    robot.ExtAxisMove(exaxis, 100, -1);
23    robot.MoveJ(&jointPos, &desc, toolnum, workPcsNum, 100.0, 100.0, 100.0, &exaxis, -1, 0, &offsetPos);
24    robot.CloseRPC();
25    return 0;
26}

8.27. Lösbarkeit der inversen Kinematik prüfen

1/**
2* @brief Prüft, ob die inverse Kinematik für eine gegebene Referenz-Gelenkposition lösbar ist.
3* @param  [in] type 0-absolute Pose (Basiskoordinatensystem), 1-inkrementelle Pose (Basiskoordinatensystem), 2-inkrementelle Pose (Werkzeugkoordinatensystem).
4* @param  [in] desc_pos Kartesische Pose.
5* @param  [in] joint_pos_ref Referenz-Gelenkposition.
6* @param  [out] result 0-keine Lösung, 1-Lösung vorhanden.
7* @return  Fehlercode.
8*/
9errno_t GetInverseKinHasSolution(int type, DescPose *desc_pos, JointPos *joint_pos_ref, uint8_t *result);

8.28. Vorwärtskinematik berechnen

1/**
2* @brief  Berechnet die Vorwärtskinematik.
3* @param  [in] joint_pos Gelenkposition.
4* @param  [out] desc_pos Kartesische Pose.
5* @return  Fehlercode.
6*/
7errno_t GetForwardKin(JointPos *joint_pos, DescPose *desc_pos);

8.29. Codebeispiel für Roboter-Vorwärts-/Inverskinematik

 1int TestInverseKin(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return -1;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  JointPos j1(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
14  DescPose desc_pos1(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
15  JointPos inverseRtn = {};
16  robot.GetInverseKin(0, &desc_pos1, -1, &inverseRtn);
17  printf("dcs1 GetInverseKin rtn is %f %f %f %f %f %f \n", inverseRtn.jPos[0], inverseRtn.jPos[1], inverseRtn.jPos[2], inverseRtn.jPos[3], inverseRtn.jPos[4], inverseRtn.jPos[5]);
18  robot.GetInverseKinRef(0, &desc_pos1, &j1, &inverseRtn);
19  printf("dcs1 GetInverseKinRef rtn is %f %f %f %f %f %f \n", inverseRtn.jPos[0], inverseRtn.jPos[1], inverseRtn.jPos[2], inverseRtn.jPos[3], inverseRtn.jPos[4], inverseRtn.jPos[5]);
20  uint8_t hasResut = 0;
21  robot.GetInverseKinHasSolution(0, &desc_pos1, &j1, &hasResut);
22  printf("dcs1 GetInverseKinRef result %d\n", hasResut);
23  DescPose forwordResult = {};
24  robot.GetForwardKin(&j1, &forwordResult);
25  printf("jpos1 forwordResult rtn is %f %f %f %f %f %f \n", forwordResult.tran.x, forwordResult.tran.y, forwordResult.tran.z, forwordResult.rpy.rx, forwordResult.rpy.ry, forwordResult.rpy.rz);
26  robot.CloseRPC();
27  return 0;
28}

8.30. Teachpunkt-Daten abrufen

1/**
2 * @brief Gibt die Daten eines Robot-Teachpunkts zurück.
3 * @param  [in] name Punktname.
4 * @param  [out] data Punktdaten (Array der Länge 20).
5 * @return  Fehlercode.
6 */
7errno_t GetRobotTeachingPoint(char name[64], float data[20]);

8.31. DH-Parameter-Kompensationswerte abrufen

Neu in Version C++SDK-v2.1.1.0.

1/**
2* @brief Gibt die Kompensationswerte der Roboter-DH-Parameter zurück.
3* @param [out] dhCompensation DH-Parameter-Kompensationswerte in mm [cmpstD1, cmpstA2, cmpstA3, cmpstD4, cmpstD5, cmpstD6].
4* @return Fehlercode.
5*/
6errno_t GetDHCompensation(double dhCompensation[6]);

8.32. SN-Code des Steuerschranks abrufen

Neu in Version C++SDK-v2.2.1-3.8.1.

1/**
2* @brief Gibt den SN-Code des Steuerschranks zurück.
3* @param [out] SNCode SN-Code des Steuerschranks.
4* @return Fehlercode.
5*/
6errno_t GetRobotSN(std::string& SNCode);

8.33. Codebeispiel für das Abrufen von Teachpunkt-Daten

 1int TestGetTeachPoint(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return -1;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  char name[64] = "P1";
14  float data[20] = { 0 };
15  rtn = robot.GetRobotTeachingPoint(name, data);
16  printf(" %d name is: %s \n", rtn, name);
17  for (int i = 0; i < 20; i++)
18  {
19    printf("data is: %f \n", data[i]);
20  }
21  int que_len = 0;
22  rtn = robot.GetMotionQueueLength(&que_len);
23  printf("GetMotionQueueLength rtn is: %d, queue length is: %d \n", rtn, que_len);
24  double dh[6] = { 0 };
25  int retval = 0;
26  retval = robot.GetDHCompensation(dh);
27  cout << "retval is: " << retval << endl;
28  cout << "dh is: " << dh[0] << " " << dh[1] << " " << dh[2] << " " << dh[3] << " " << dh[4] << " " << dh[5] << endl;
29  string SN = "";
30  robot.GetRobotSN(SN);
31  cout << "robot SN is " << SN << endl;
32  robot.CloseRPC();
33  return 0;
34}

8.34. Werkzeugkoordinatensystem anhand der ID abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das Werkzeugkoordinatensystem anhand der ID zurück.
3* @param [in] id Werkzeugkoordinatensystem-ID.
4* @param [out] coord Koordinatenwerte.
5* @return Fehlercode.
6*/
7errno_t GetToolCoordWithID(int id, DescPose& coord);

8.35. Werkstückkoordinatensystem anhand der ID abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das Werkstückkoordinatensystem anhand der ID zurück.
3* @param [in] id Werkstückkoordinatensystem-ID.
4* @param [out] coord Koordinatenwerte.
5* @return Fehlercode.
6*/
7errno_t GetWObjCoordWithID(int id, DescPose& coord);

8.36. Externes Werkzeugkoordinatensystem anhand der ID abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das externe Werkzeugkoordinatensystem anhand der ID zurück.
3* @param [in] id Externe Werkzeugkoordinatensystem-ID.
4* @param [out] coord Koordinatenwerte.
5* @return Fehlercode.
6*/
7errno_t GetExToolCoordWithID(int id, DescPose& coord);

8.37. Erweiterungsachsen-Koordinatensystem anhand der ID abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das Erweiterungsachsen-Koordinatensystem anhand der ID zurück.
3* @param [in] id Erweiterungsachsen-Koordinatensystem-ID.
4* @param [out] coord Koordinatenwerte.
5* @return Fehlercode.
6*/
7errno_t GetExAxisCoordWithID(int id, DescPose& coord);

8.38. Nutzlastmasse und -schwerpunkt anhand der ID abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt die Nutzlastmasse und den -schwerpunkt anhand der ID zurück.
3* @param [in] id Nutzlastnummer.
4* @param [out] weight Nutzlastmasse.
5* @param [out] cog Nutzlastschwerpunkt.
6* @return Fehlercode.
7*/
8errno_t GetTargetPayloadWithID(int id, double& weight, DescTran& cog);

8.39. Aktuelles Werkzeugkoordinatensystem abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das aktuelle Werkzeugkoordinatensystem zurück.
3* @param [out] coord Koordinatenwerte.
4* @return Fehlercode.
5*/
6errno_t GetCurToolCoord(DescPose& coord);

8.40. Aktuelles Werkstückkoordinatensystem abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das aktuelle Werkstückkoordinatensystem zurück.
3* @param [out] coord Koordinatenwerte.
4* @return Fehlercode.
5*/
6errno_t GetCurWObjCoord(DescPose& coord);

8.41. Aktuelles externes Werkzeugkoordinatensystem abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das aktuelle externe Werkzeugkoordinatensystem zurück.
3* @param [out] coord Koordinatenwerte.
4* @return Fehlercode.
5*/
6errno_t GetCurExToolCoord(DescPose& coord);

8.42. Aktuelles Erweiterungsachsen-Koordinatensystem abrufen

Neu in Version C++SDK-v3.8.6.

1/**
2* @brief Gibt das aktuelle Erweiterungsachsen-Koordinatensystem zurück.
3* @param [out] coord Koordinatenwerte.
4* @return Fehlercode.
5*/
6errno_t GetCurExAxisCoord(DescPose& coord);

8.43. Codebeispiel für Roboter-Koordinatensysteme und Nutzlast

Neu in Version C++SDK-v3.8.6.

 1int TestCoord()
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5  robot.LoggerInit();
 6  robot.SetLoggerLevel(1);
 7  int rtn = robot.RPC("192.168.58.2");
 8  if (rtn != 0)
 9  {
10    return 0;
11  }
12  robot.SetReConnectParam(true, 30000, 500);
13  int id = 1;
14  DescPose toolCoord = {};
15  DescPose extoolCoord = {};
16  DescPose wobjCoord = {};
17  DescPose exAxisCoord = {};
18  robot.GetToolCoordWithID(id, toolCoord);
19  printf("GetToolCoordWithID %d, %f %f %f %f %f %f\n", id,
20    toolCoord.tran.x, toolCoord.tran.y, toolCoord.tran.z,
21    toolCoord.rpy.rx, toolCoord.rpy.ry, toolCoord.rpy.rz);
22  robot.GetWObjCoordWithID(id, wobjCoord);
23  printf("GetWObjCoordWithID %d, %f %f %f %f %f %f\n", id,
24    wobjCoord.tran.x, wobjCoord.tran.y, wobjCoord.tran.z,
25    wobjCoord.rpy.rx, wobjCoord.rpy.ry, wobjCoord.rpy.rz);
26
27  robot.GetExToolCoordWithID(id, extoolCoord);
28  printf("GetExToolCoordWithID %d, %f %f %f %f %f %f\n", id,
29    extoolCoord.tran.x, extoolCoord.tran.y, extoolCoord.tran.z,
30    extoolCoord.rpy.rx, extoolCoord.rpy.ry, extoolCoord.rpy.rz);
31
32  robot.GetExAxisCoordWithID(id, exAxisCoord);
33  printf("GetExAxisCoordWithID %d, %f %f %f %f %f %f\n", id,
34    exAxisCoord.tran.x, exAxisCoord.tran.y, exAxisCoord.tran.z,
35    exAxisCoord.rpy.rx, exAxisCoord.rpy.ry, exAxisCoord.rpy.rz);
36  double weight = 0.0;
37  DescTran cog = {};
38  robot.GetTargetPayloadWithID(id, weight, cog);
39  printf("GetTargetPayloadWithID %d, %f %f %f %f\n", id, weight,
40    cog.x, cog.y, cog.z);
41  robot.GetCurToolCoord(toolCoord);
42  printf("GetCurToolCoord %f %f %f %f %f %f\n",
43    toolCoord.tran.x, toolCoord.tran.y, toolCoord.tran.z,
44    toolCoord.rpy.rx, toolCoord.rpy.ry, toolCoord.rpy.rz);
45  robot.GetCurWObjCoord(wobjCoord);
46  printf("GetCurWObjCoord %f %f %f %f %f %f\n",
47    wobjCoord.tran.x, wobjCoord.tran.y, wobjCoord.tran.z,
48    wobjCoord.rpy.rx, wobjCoord.rpy.ry, wobjCoord.rpy.rz);
49  robot.GetCurExToolCoord(extoolCoord);
50  printf("GetExToolCoordWithID %f %f %f %f %f %f\n",
51    extoolCoord.tran.x, extoolCoord.tran.y, extoolCoord.tran.z,
52    extoolCoord.rpy.rx, extoolCoord.rpy.ry, extoolCoord.rpy.rz);
53  robot.GetCurExAxisCoord(exAxisCoord);
54  printf("GetCurExAxisCoord %f %f %f %f %f %f\n",
55    exAxisCoord.tran.x, exAxisCoord.tran.y, exAxisCoord.tran.z,
56    exAxisCoord.rpy.rx, exAxisCoord.rpy.ry, exAxisCoord.rpy.rz);
57  float weightT = 0.0;
58  DescTran cogT = {};
59  robot.GetTargetPayload(0, &weightT);
60  robot.GetTargetPayloadCog(0, &cogT);
61  printf("GetTargetPayload %f %f %f %f\n", weightT,
62    cogT.x, cogT.y, cogT.z);
63  DescPose coordSet(0,1,2,3,4,5);
64  robot.SetToolCoord(1, &coordSet, 0, 0, 1, 0);
65  robot.SetWObjCoord(1, &coordSet, 0);
66  robot.SetLoadWeight(1, 1.3);
67  DescTran cog = {};
68  cog.x = 10;
69  cog.y = 20;
70  cog.z = 30;
71  robot.SetLoadCoord(1, &cog);
72  DescPose etcp(0, 0, 100, 0, 0, 0);
73  DescPose etool(0, 0, 50, 0, 0, 0);
74  rtn = robot.SetExToolCoord(1, &etcp, &etool);
75  printf("SetExToolCoord rtn is %d\n", rtn);
76  robot.ExtAxisActiveECoordSys(1, 1, coordSet, 1);
77  robot.CloseRPC();
78  return 0;
79}