11. Roboter-Peripherie

11.1. Greifer konfigurieren

1/**
2* @brief Greifer konfigurieren
3* @param [in] company Greiferhersteller (zur Festlegung)
4* @param [in] device Gerätenummer, vorübergehend nicht verwendet, Standard 0
5* @param [in] softvesion Softwareversionsnummer, vorübergehend nicht verwendet, Standard 0
6* @param [in] bus Position des Geräts am Endeffektor-Bus, vorübergehend nicht verwendet, Standard 0
7* @return Fehlercode
8*/
9errno_t SetGripperConfig(int company, int device, int softvesion, int bus);

11.2. Greiferkonfiguration abrufen

1/**
2* @brief Greiferkonfiguration abrufen
3* @param [in] company Greiferhersteller (zur Festlegung)
4* @param [in] device Gerätenummer, vorübergehend nicht verwendet, Standard 0
5* @param [in] softvesion Softwareversionsnummer, vorübergehend nicht verwendet, Standard 0
6* @param [in] bus Position des Geräts am Endeffektor-Bus, vorübergehend nicht verwendet, Standard 0
7* @return Fehlercode
8*/
9errno_t GetGripperConfig(int *company, int *device, int *softvesion, int *bus);

11.3. Greifer aktivieren

1/**
2* @brief Greifer aktivieren
3* @param [in] index Greifernummer
4* @param [in] act 0-Zurücksetzen, 1-Aktivieren
5* @return Fehlercode
6*/
7errno_t ActGripper(int index, uint8_t act);

11.4. Greifer steuern

Geändert in Version C++SDK-v2.1.5.0.

 1/**
 2 * @brief Greifer steuern
 3 * @param [in] index Greifernummer
 4 * @param [in] pos Positionsprozentsatz, Bereich [0~100]
 5 * @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 6 * @param [in] force Drehmomentprozentsatz, Bereich [0~100]
 7 * @param [in] max_time Maximale Wartezeit, Bereich [0~30000], [ms]
 8 * @param [in] block 0-blockierend, 1-nicht blockierend
 9 * @param [in] type Greifertyp: 0-Parallelgreifer; 1-Rotationsgreifer
10 * @param [in] rotNum Rotationsanzahl (Umdrehungen)
11 * @param [in] rotVel Rotationsgeschwindigkeitsprozentsatz [0-100]
12 * @param [in] rotTorque Rotationsdrehmomentprozentsatz [0-100]
13 * @return Fehlercode
14 */
15errno_t MoveGripper(int index, int pos, int vel, int force, int max_time, uint8_t block, int type, double rotNum, int rotVel, int rotTorque);

11.5. Greifer-Bewegungsstatus abrufen

1/**
2 * @brief Greifer-Bewegungsstatus abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] status 0-Bewegung nicht abgeschlossen, 1-Bewegung abgeschlossen
5 * @return Fehlercode
6 */
7errno_t GetGripperMotionDone(uint16_t *fault, uint8_t *status);

11.6. Greifer-Aktivierungsstatus abrufen

1/**
2 * @brief Greifer-Aktivierungsstatus abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] status Bit0~Bit15 entsprechen Greifernummern 0~15, Bit=0 nicht aktiviert, Bit=1 aktiviert
5 * @return Fehlercode
6 */
7errno_t GetGripperActivateStatus(uint16_t *fault, uint16_t *status);

11.7. Greiferposition abrufen

1/**
2 * @brief Greiferposition abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] position Positionsprozentsatz, Bereich 0~100%
5 * @return Fehlercode
6 */
7errno_t GetGripperCurPosition(uint16_t *fault, uint8_t *position);

11.8. Greifergeschwindigkeit abrufen

1/**
2 * @brief Greifergeschwindigkeit abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] speed Geschwindigkeitsprozentsatz, Bereich 0~100%
5 * @return Fehlercode
6 */
7errno_t GetGripperCurSpeed(uint16_t *fault, int8_t *speed);

11.9. Greiferstrom abrufen

1/**
2 * @brief Greiferstrom abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] current Stromprozentsatz, Bereich 0~100%
5 * @return Fehlercode
6 */
7errno_t GetGripperCurCurrent(uint16_t *fault, int8_t *current);

11.10. Greiferspannung abrufen

1/**
2 * @brief Greiferspannung abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] voltage Spannung, Einheit 0.1V
5 * @return Fehlercode
6 */
7errno_t GetGripperVoltage(uint16_t *fault, int *voltage);

11.11. Greifertemperatur abrufen

1/**
2 * @brief Greifertemperatur abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] temp Temperatur [°C]
5 * @return Fehlercode
6 */
7errno_t GetGripperTemp(uint16_t *fault, int *temp);

11.12. Vor-Greifpunkt berechnen (visuell)

1/**
2 * @brief Vor-Greifpunkt berechnen (visuell)
3 * @param [in] desc_pos Kartesische Pose des Greifpunkts
4 * @param [in] zlength Z-Achsen-Versatz [mm]
5 * @param [in] zangle Rotationsversatz um die Z-Achse [°]
6 * @param [out] pre_pos Berechneter Vor-Greifpunkt
7 * @return Fehlercode
8 */
9errno_t ComputePrePick(DescPose *desc_pos, double zlength, double zangle, DescPose *pre_pos);

11.13. Rückzugspunkt berechnen (visuell)

1/**
2 * @brief Rückzugspunkt berechnen (visuell)
3 * @param [in] desc_pos Kartesische Pose des Rückzugspunkts
4 * @param [in] zlength Z-Achsen-Versatz [mm]
5 * @param [in] zangle Rotationsversatz um die Z-Achse [°]
6 * @param [out] post_pos Berechneter Rückzugspunkt
7 * @return Fehlercode
8 */
9errno_t ComputePostPick(DescPose *desc_pos, double zlength, double zangle, DescPose *post_pos);

11.14. Codebeispiel für Roboter-Greiferoperationen

 1int TestGripper(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  int company = 4;
14  int device = 0;
15  int softversion = 0;
16  int bus = 2;
17  int index = 2;
18  int act = 0;
19  int max_time = 30000;
20  uint8_t block = 0;
21  uint8_t status;
22  uint16_t fault;
23  uint16_t active_status = 0;
24  uint8_t current_pos = 0;
25  int8_t current = 0;
26  int voltage = 0;
27  int temp = 0;
28  int8_t speed = 0;
29  robot.SetGripperConfig(company, device, softversion, bus);
30  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
31  robot.GetGripperConfig(&company, &device, &softversion, &bus);
32  printf("gripper config:%d,%d,%d,%d\n", company, device, softversion, bus);
33  robot.ActGripper(index, act);
34  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
35  act = 1;
36  robot.ActGripper(index, act);
37  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
38  robot.MoveGripper(index, 100, 50, 50, max_time, block, 0, 0, 0, 0);
39  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
40  robot.MoveGripper(index, 0, 50, 0, max_time, block, 0, 0, 0, 0);
41  robot.GetGripperMotionDone(&fault, &status);
42  printf("motion status:%u,%u\n", fault, status);
43  robot.GetGripperActivateStatus(&fault, &active_status);
44  printf("gripper active fault is: %u, status is: %u\n", fault, active_status);
45  robot.GetGripperCurPosition(&fault, &current_pos);
46  printf("fault is:%u, current position is: %u\n", fault, current_pos);
47  robot.GetGripperCurCurrent(&fault, &current);
48  printf("fault is:%u, current current is: %d\n", fault, current);
49  robot.GetGripperVoltage(&fault, &voltage);
50  printf("fault is:%u, current voltage is: %d \n", fault, voltage);
51  robot.GetGripperTemp(&fault, &temp);
52  printf("fault is:%u, current temperature is: %d\n", fault, temp);
53  robot.GetGripperCurSpeed(&fault, &speed);
54  printf("fault is:%u, current speed is: %d\n", fault, speed);
55  int retval = 0;
56  DescPose prepick_pose = {};
57  DescPose postpick_pose = {};
58  DescPose p1Desc(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
59  DescPose p2Desc(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
60  retval = robot.ComputePrePick(&p1Desc, 10, 0, &prepick_pose);
61  printf("ComputePrePick retval is: %d\n", retval);
62  printf("xyz is: %f, %f, %f; rpy is: %f, %f, %f\n", prepick_pose.tran.x, prepick_pose.tran.y, prepick_pose.tran.z, prepick_pose.rpy.rx, prepick_pose.rpy.ry, prepick_pose.rpy.rz);
63  retval = robot.ComputePostPick(&p2Desc, -10, 0, &postpick_pose);
64  printf("ComputePostPick retval is: %d\n", retval);
65  printf("xyz is: %f, %f, %f; rpy is: %f, %f, %f\n", postpick_pose.tran.x, postpick_pose.tran.y, postpick_pose.tran.z, postpick_pose.rpy.rx, postpick_pose.rpy.ry, postpick_pose.rpy.rz);
66  robot.CloseRPC();
67  return 0;
68}

11.15. Rotationsanzahl des Rotationsgreifers abrufen

Neu in Version 3.7.6.

1/**
2 * @brief Rotationsanzahl des Rotationsgreifers abrufen
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] num Rotationsanzahl (Umdrehungen)
5 * @return Fehlercode
6 */
7errno_t GetGripperRotNum(uint16_t* fault, double* num);

11.16. Rotationsgeschwindigkeit des Rotationsgreifers abrufen

Neu in Version V3.7.6.

1/**
2 * @brief Rotationsgeschwindigkeit des Rotationsgreifers abrufen (Prozentsatz)
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] speed Rotationsgeschwindigkeitsprozentsatz
5 * @return Fehlercode
6 */
7errno_t GetGripperRotSpeed(uint16_t* fault, int* speed);

11.17. Rotationsdrehmoment des Rotationsgreifers abrufen

Neu in Version V3.7.6.

1/**
2 * @brief Rotationsdrehmoment des Rotationsgreifers abrufen (Prozentsatz)
3 * @param [out] fault 0-kein Fehler, 1-Fehler
4 * @param [out] torque Rotationsdrehmomentprozentsatz
5 * @return Fehlercode
6 */
7errno_t GetGripperRotTorque(uint16_t* fault, int* torque);

11.18. Codebeispiel zum Abrufen des Status eines Rotationsgreifers

 1int TestRotGripperState(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  uint16_t fault = 0;
14  double rotNum = 0.0;
15  int rotSpeed = 0;
16  int rotTorque = 0;
17  robot.GetGripperRotNum(&fault, &rotNum);
18  robot.GetGripperRotSpeed(&fault, &rotSpeed);
19  robot.GetGripperRotTorque(&fault, &rotTorque);
20  printf("gripper rot num : %lf, gripper rotSpeed : %d, gripper rotTorque : %d\n", rotNum, rotSpeed, rotTorque);
21  robot.CloseRPC();
22  return 0;
23}

11.19. Förderband starten/stoppen

1/**
2* @brief Förderband starten/stoppen
3* @param [in] status Status, 1-starten, 0-stoppen
4* @return Fehlercode
5*/
6errno_t ConveyorStartEnd(uint8_t status);

11.20. IO-Erkennungspunkt aufzeichnen

1/**
2* @brief IO-Erkennungspunkt aufzeichnen
3* @return Fehlercode
4*/
5errno_t ConveyorPointIORecord();

11.21. Punkt A aufzeichnen

1/**
2* @brief Punkt A aufzeichnen
3* @return Fehlercode
4*/
5errno_t ConveyorPointARecord();

11.22. Referenzpunkt aufzeichnen

1/**
2* @brief Referenzpunkt aufzeichnen
3* @return Fehlercode
4*/
5errno_t ConveyorRefPointRecord();

11.23. Punkt B aufzeichnen

1/**
2* @brief Punkt B aufzeichnen
3* @return Fehlercode
4*/
5errno_t ConveyorPointBRecord();

11.24. Förderband-Werkstück IO-Erkennung

1/**
2* @brief Förderband-Werkstück IO-Erkennung
3* @param [in] max_t Maximale Erkennungszeit [ms]
4* @return Fehlercode
5*/
6errno_t ConveyorIODetect(int max_t);

11.25. Aktuelle Objektposition abrufen

1/**
2* @brief Aktuelle Objektposition abrufen
3* @param [in] mode Modus (z.B. 1-Tracking Greifen, 2-Tracking Bewegung)
4* @return Fehlercode
5*/
6errno_t ConveyorGetTrackData(int mode);

11.26. Förderband-Tracking starten

1/**
2* @brief Förderband-Tracking starten
3* @param [in] status Status, 1-starten, 0-stoppen
4* @return Fehlercode
5*/
6errno_t ConveyorTrackStart(uint8_t status);

11.27. Förderband-Tracking stoppen

1/**
2* @brief Förderband-Tracking stoppen
3* @return Fehlercode
4*/
5errno_t ConveyorTrackEnd();

11.28. Förderbandparameter konfigurieren

Geändert in Version C++SDK-v2.2.1-3.8.1.

 1/**
 2* @brief Förderbandparameter konfigurieren
 3* @param [in] para[0] Encoderkanal 1~2
 4* @param [in] para[1] Impulse pro Encoderumdrehung
 5* @param [in] para[2] Vorschubweg des Förderbands pro Encoderumdrehung [mm]
 6* @param [in] para[3] Werkstückkoordinatennummer (für Tracking-Bewegung, bei Tracking-Greifen/TPD-Tracking auf 0 setzen)
 7* @param [in] para[4] Mit Vision gekoppelt? 0 nein, 1 ja
 8* @param [in] para[5] Geschwindigkeitsverhältnis (für Förderband-Tracking-Greifen Option (1-100)), Standard 1 für andere Optionen
 9* @param [in] followType Tracking-Bewegungstyp: 0-Tracking-Bewegung; 1-Nachlauf-Bewegung
10* @param [in] startDis Für Nachlauf-Greifen erforderlich: Startabstand des Trackings. -1: automatische Berechnung (Nachlauf startet, wenn Werkstück unter Roboter ist). Einheit mm, Standard 0
11* @param [in] endDis Für Nachlauf-Greifen erforderlich: Endabstand des Trackings. Einheit mm, Standard 100
12* @return Fehlercode
13*/
14errno_t ConveyorSetParam(float para[6], int followType = 0, int startDis = 0, int endDis = 100);

11.29. Förderband-Greifpunktkompensation

Geändert in Version C++SDK-v2.1.2.0.

1/**
2 * @brief Förderband-Greifpunktkompensation einstellen
3 * @param [in] cmp Kompensationsposition double[3]{x, y, z} [mm]
4 * @return Fehlercode
5 */
6errno_t ConveyorCatchPointComp(double cmp[3]);

11.30. Förderband-Linearbewegung (Tracking)

 1/**
 2* @brief Förderband-Linearbewegung (Tracking)
 3* @param [in] name Name des Bewegungspunkts (z.B. "cvrCatchPoint")
 4* @param [in] tool Werkzeugkoordinatennummer
 5* @param [in] wobj Werkstückkoordinatennummer
 6* @param [in] vel Geschwindigkeitsprozentsatz [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz [0~100] (vorübergehend nicht freigegeben)
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor [0~100]
 9* @param [in] blendR Glättungsradius [mm] (-1 für blockierend)
10* @param [in] flag Status-Flag
11* @param [in] type Typ-Flag
12* @return Fehlercode
13*/
14errno_t TrackMoveL(char name[32], int tool, int wobj, float vel, float acc, float ovl, float blendR, uint8_t flag, uint8_t type);

11.31. Förderband-Kommunikationseingangserkennung

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

1/**
2* @brief Förderband-Kommunikationseingangserkennung
3* @param [in] timeout Warte-Timeout [ms]
4* @return Fehlercode
5*/
6errno_t ConveyorComDetect(int timeout);

11.32. Förderband-Kommunikationseingangserkennung auslösen

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

1/**
2* @brief Förderband-Kommunikationseingangserkennung auslösen
3* @return Fehlercode
4*/
5errno_t ConveyorComDetectTrigger();

11.33. Beispielprogramm für Roboter-Förderbandoperationen

 1int TestConveyor(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  int retval = 0;
14  retval = robot.ConveyorStartEnd(1);
15  printf("ConveyorStartEnd retval is: %d\n", retval);
16  retval = robot.ConveyorPointIORecord();
17  printf("ConveyorPointIORecord retval is: %d\n", retval);
18  retval = robot.ConveyorPointARecord();
19  printf("ConveyorPointARecord retval is: %d\n", retval);
20  retval = robot.ConveyorRefPointRecord();
21  printf("ConveyorRefPointRecord retval is: %d\n", retval);
22  retval = robot.ConveyorPointBRecord();
23  printf("ConveyorPointBRecord retval is: %d\n", retval);
24  retval = robot.ConveyorStartEnd(0);
25  printf("ConveyorStartEnd retval is: %d\n", retval);
26  retval = 0;
27  float param[6] = { 1,10000,200,0,0,20 };
28  retval = robot.ConveyorSetParam(param);
29  printf("ConveyorSetParam retval is: %d\n", retval);
30  double cmp[3] = { 0.0, 0.0, 0.0 };
31  retval = robot.ConveyorCatchPointComp(cmp);
32  printf("ConveyorCatchPointComp retval is: %d\n", retval);
33  int index = 1;
34  int max_time = 30000;
35  uint8_t block = 0;
36  retval = 0;
37  DescPose p1Desc(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
38  DescPose p2Desc(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
39  retval = robot.MoveCart(&p1Desc, 1, 0, 100.0, 100.0, 100.0, -1.0, -1);
40  printf("MoveCart retval is: %d\n", retval);
41  retval = robot.WaitMs(1);
42  printf("WaitMs retval is: %d\n", retval);
43  retval = robot.ConveyorIODetect(10000);
44  printf("ConveyorIODetect retval is: %d\n", retval);
45  retval = robot.ConveyorGetTrackData(1);
46  printf("ConveyorGetTrackData retval is: %d\n", retval);
47  retval = robot.ConveyorTrackStart(1);
48  printf("ConveyorTrackStart retval is: %d\n", retval);
49  retval = robot.TrackMoveL("cvrCatchPoint", 1, 0, 100, 100, 100, -1.0, 0, 0);
50  printf("TrackMoveL retval is: %d\n", retval);
51  retval = robot.MoveGripper(index, 51, 40, 30, max_time, block, 0, 0, 0, 0);
52  printf("MoveGripper retval is: %d\n", retval);
53  retval = robot.TrackMoveL("cvrRaisePoint", 1, 0, 100, 100, 100, -1.0, 0, 0);
54  printf("TrackMoveL retval is: %d\n", retval);
55  retval = robot.ConveyorTrackEnd();
56  printf("ConveyorTrackEnd retval is: %d\n", retval);
57  robot.MoveCart(&p2Desc, 1, 0, 100.0, 100.0, 100.0, -1.0, -1);
58  retval = robot.MoveGripper(index, 100, 40, 10, max_time, block, 0, 0, 0, 0);
59  printf("MoveGripper retval is: %d\n", retval);
60  rtn = robot.ConveyorComDetect(1000 * 10);
61  printf("ConveyorComDetect rtn is: %d\n", rtn);
62  robot.Sleep(2000);
63  rtn = robot.ConveyorComDetectTrigger();
64  printf("ConveyorComDetectTrigger rtn is: %d\n", rtn);
65  robot.CloseRPC();
66  return 0;
67}

11.34. Endeffektor-Sensor konfigurieren

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

1/**
2* @brief Endeffektor-Sensor konfigurieren
3* @param [in] idCompany Hersteller, 18-JUNKONG; 25-HUIDE
4* @param [in] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
5* @param [in] idSoftware Softwareversion, 0-J1.0/HuiDe1.0 (vorübergehend nicht freigegeben)
6* @param [in] idBus Anschlussposition, 1-Endeffektor Port 1; 2-Endeffektor Port 2...8-Endeffektor Port 8 (vorübergehend nicht freigegeben)
7* @return Fehlercode
8*/
9errno_t AxleSensorConfig(int idCompany, int idDevice, int idSoftware, int idBus);

11.35. Endeffektor-Sensorkonfiguration abrufen

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

1/**
2 * @brief Endeffektor-Sensorkonfiguration abrufen
3 * @param [out] idCompany Hersteller, 18-JUNKONG; 25-HUIDE
4 * @param [out] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
5 * @return Fehlercode
6 */
7errno_t AxleSensorConfigGet(int& idCompany, int& idDevice);

11.36. Endeffektor-Sensor aktivieren

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

1/**
2 * @brief Endeffektor-Sensor aktivieren
3 * @param [in] actFlag 0-Zurücksetzen; 1-Aktivieren
4 * @return Fehlercode
5 */
6errno_t AxleSensorActivate(int actFlag);

11.37. In Endeffektor-Sensorregister schreiben

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

 1/**
 2 * @brief In Endeffektor-Sensorregister schreiben
 3 * @param [in] devAddr Geräteadresse 0-255
 4 * @param [in] regHAddr Registeradresse hohes Byte
 5 * @param [in] regLAddr Registeradresse niedriges Byte
 6 * @param [in] regNum Anzahl der Register 0-255
 7 * @param [in] data1 Zu schreibender Registerwert 1
 8 * @param [in] data2 Zu schreibender Registerwert 2
 9 * @param [in] isNoBlock 0-blockierend; 1-nicht blockierend
10 * @return Fehlercode
11 */
12errno_t AxleSensorRegWrite(int devAddr, int regHAddr, int regLAddr, int regNum, int data1, int data2, int isNoBlock);

11.38. Codebeispiel für Endeffektor-Sensor

 1int TestAxleSensor(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  robot.AxleSensorConfig(18, 0, 0, 1);
14  int company = -1;
15  int type = -1;
16  robot.AxleSensorConfigGet(company, type);
17  printf("company is %d, type is %d\n", company, type);
18  rtn = robot.AxleSensorActivate(1);
19  printf("AxleSensorActivate rtn is %d\n", rtn);
20  robot.Sleep(1000);
21  rtn = robot.AxleSensorRegWrite(1, 4, 6, 1, 0, 0, 0);
22  printf("AxleSensorRegWrite rtn is %d\n", rtn);
23  robot.CloseRPC();
24  return 0;
25}

11.39. Roboter-Peripherieprotokoll abrufen

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

1/**
2* @brief Roboter-Peripherieprotokoll abrufen
3* @param [out] protocol Roboter-Peripherieprotokollnummer: 4096-Erweiterungsachsen-Steuerkarte; 4097-ModbusSlave; 4098-ModbusMaster
4* @return Fehlercode
5*/
6errno_t GetExDevProtocol(int *protocol);

11.40. Roboter-Peripherieprotokoll einstellen

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

1/**
2* @brief Roboter-Peripherieprotokoll einstellen
3* @param [in] protocol Roboter-Peripherieprotokollnummer: 4096-Erweiterungsachsen-Steuerkarte; 4097-ModbusSlave; 4098-ModbusMaster
4* @return Fehlercode
5*/
6errno_t SetExDevProtocol(int protocol);

11.41. Beispielprogramm zum Einstellen des Roboter-Peripherieprotokolls

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

 1int TestExDevProtocol(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  int protocol = 4096;
14  rtn = robot.SetExDevProtocol(protocol);
15  std::cout << "SetExDevProtocol rtn " << rtn << std::endl;
16  rtn = robot.GetExDevProtocol(&protocol);
17  std::cout << "GetExDevProtocol rtn " << rtn << " protocol is: " << protocol << std::endl;
18  robot.CloseRPC();
19  return 0;
20}

11.42. Endeffektor-Kommunikationsparameter abrufen

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

1/**
2* @brief Endeffektor-Kommunikationsparameter abrufen
3* @param [out] param Struktur mit Kommunikationsparametern
4* @return Fehlercode
5*/
6errno_t GetAxleCommunicationParam(AxleComParam* param);

11.43. Endeffektor-Kommunikationsparameter einstellen

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

1/**
2* @brief Endeffektor-Kommunikationsparameter einstellen
3* @param [in] param Struktur mit Kommunikationsparametern
4* @return Fehlercode
5*/
6errno_t SetAxleCommunicationParam(AxleComParam param);

11.44. Endeffektor-Dateiübertragungstyp einstellen

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

1/**
2* @brief Endeffektor-Dateiübertragungstyp einstellen
3* @param [in] type 1-MCU Upgrade-Datei; 2-LUA-Datei
4* @return Fehlercode
5*/
6errno_t SetAxleFileType(int type);

11.45. Endeffektor-LUA-Ausführung aktivieren

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

1/**
2* @brief Endeffektor-LUA-Ausführung aktivieren
3* @param [in] enable 0-nicht aktivieren; 1-aktivieren
4* @return Fehlercode
5*/
6errno_t SetAxleLuaEnable(int enable);

11.46. Fehlerbehebung bei anomaler Endeffektor-LUA-Datei

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

1/**
2* @brief Fehlerbehebung bei anomaler Endeffektor-LUA-Datei
3* @param [in] status 0-nicht beheben; 1-beheben
4* @return Fehlercode
5*/
6errno_t SetRecoverAxleLuaErr(int status);

11.47. Aktivierungsstatus der Endeffektor-LUA-Ausführung abrufen

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

1/**
2* @brief Aktivierungsstatus der Endeffektor-LUA-Ausführung abrufen
3* @param [out] status status[0]: 0-nicht aktiviert; 1-aktiviert
4* @return Fehlercode
5*/
6errno_t GetAxleLuaEnableStatus(int status[]);

11.48. Aktivierungstyp der Endeffektor-LUA-Endgeräte einstellen

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

1/**
2* @brief Aktivierungstyp der Endeffektor-LUA-Endgeräte einstellen
3* @param [in] forceSensorEnable Kraftsensor-Aktivierungsstatus, 0-nicht aktivieren; 1-aktivieren
4* @param [in] gripperEnable Greifer-Aktivierungsstatus, 0-nicht aktivieren; 1-aktivieren
5* @param [in] IOEnable IO-Geräte-Aktivierungsstatus, 0-nicht aktivieren; 1-aktivieren
6* @return Fehlercode
7*/
8errno_t SetAxleLuaEnableDeviceType(int forceSensorEnable, int gripperEnable, int IOEnable);

11.49. Aktivierungstyp der Endeffektor-LUA-Endgeräte abrufen

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

1/**
2* @brief Aktivierungstyp der Endeffektor-LUA-Endgeräte abrufen
3* @param [out] forceSensorEnable Kraftsensor-Aktivierungsstatus, 0-nicht aktiviert; 1-aktiviert
4* @param [out] gripperEnable Greifer-Aktivierungsstatus, 0-nicht aktiviert; 1-aktiviert
5* @param [out] IOEnable IO-Geräte-Aktivierungsstatus, 0-nicht aktiviert; 1-aktiviert
6* @return Fehlercode
7*/
8errno_t GetAxleLuaEnableDeviceType(int* forceSensorEnable, int* gripperEnable, int* IOEnable);

11.50. Aktuell konfigurierte Endgeräte abrufen

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

1/**
2* @brief Aktuell konfigurierte Endgeräte (über LUA) abrufen
3* @param [out] forceSensorEnable Array aktivierter Kraftsensornummern (Indikator)
4* @param [out] gripperEnable Array aktivierter Greifernummern (Indikator)
5* @param [out] IODeviceEnable Array aktivierter IO-Gerätenummern (Indikator)
6* @return Fehlercode
7*/
8errno_t GetAxleLuaEnableDevice(int forceSensorEnable[], int gripperEnable[], int IODeviceEnable[]);

11.51. Greifer-Aktionssteuerungsfunktion aktivieren (für LUA)

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

1/**
2* @brief Greifer-Aktionssteuerungsfunktion aktivieren (für LUA-Skript)
3* @param [in] id Greifer-Gerätenummer
4* @param [in] func Funktions-Array: func[0]-Greifer aktivieren; func[1]-Greifer initialisieren; 2-Position einstellen; 3-Geschwindigkeit einstellen; 4-Drehmoment einstellen; 6-Greiferstatus lesen; 7-Initialisierungsstatus lesen; 8-Fehlercode lesen; 9-Position lesen; 10-Geschwindigkeit lesen; 11-Drehmoment lesen
5* @return Fehlercode
6*/
7errno_t SetAxleLuaGripperFunc(int id, int func[]);

11.52. Aktivierte Greifer-Aktionssteuerungsfunktion abrufen

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

1/**
2* @brief Aktivierte Greifer-Aktionssteuerungsfunktion abrufen
3* @param [in] id Greifer-Gerätenummer
4* @param [out] func Funktions-Array (wie oben)
5* @return Fehlercode
6*/
7errno_t GetAxleLuaGripperFunc(int id, int func[]);

11.53. In Ethercat-Slave-Datei des Roboters schreiben

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

1/**
2* @brief In Ethercat-Slave-Datei des Roboters schreiben (Firmware/Konfiguration updaten)
3* @param [in] type Slave-Dateityp: 1-Upgrade Slave-Datei; 2-Upgrade Slave-Konfigurationsdatei
4* @param [in] slaveID Slave-Nummer
5* @param [in] fileName Name der hochzuladenden Datei (Pfad auf dem Roboter?)
6* @return Fehlercode
7*/
8errno_t SlaveFileWrite(int type, int slaveID, std::string fileName);

11.54. Endeffektor-Lua-Open-Protocol-Datei hochladen

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

1/**
2* @brief Endeffektor-Lua-Open-Protocol-Datei hochladen
3* @param [in] filePath Lokaler Pfad zur Lua-Datei ".../AXLE_LUA_End_DaHuan.lua"
4* @return Fehlercode
5*/
6errno_t AxleLuaUpload(std::string filePath);

11.55. Ethercat-Slave des Roboters in den Boot-Modus versetzen

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

1/**
2* @brief Ethercat-Slave des Roboters in den Boot-Modus versetzen (für Firmware-Update)
3* @return Fehlercode
4*/
5errno_t SetSysServoBootMode();

11.56. Codebeispiel für Roboter-Endeffektor-LUA-Dateioperationen

 1int TestAxleLua(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  robot.AxleLuaUpload("D://zUP/AXLE_LUA_End_DaHuan.lua");
14  AxleComParam param(7, 8, 1, 0, 5, 3, 1);
15  robot.SetAxleCommunicationParam(param);
16  AxleComParam getParam;
17  robot.GetAxleCommunicationParam(&getParam);
18  printf("GetAxleCommunicationParam param is %d %d %d %d %d %d %d\n", getParam.baudRate, getParam.dataBit, getParam.stopBit, getParam.verify, getParam.timeout, getParam.timeoutTimes, getParam.period);
19  robot.SetAxleLuaEnable(1);
20  int luaEnableStatus[1] = {0};
21  robot.GetAxleLuaEnableStatus(luaEnableStatus);
22  robot.SetAxleLuaEnableDeviceType(0, 1, 0);
23  int forceEnable = 0;
24  int gripperEnable = 0;
25  int ioEnable = 0;
26  robot.GetAxleLuaEnableDeviceType(&forceEnable, &gripperEnable, &ioEnable);
27  printf("GetAxleLuaEnableDeviceType param is %d %d %d\n", forceEnable, gripperEnable, ioEnable);
28  int func[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
29  robot.SetAxleLuaGripperFunc(1, func);
30  int getFunc[16] = { 0 };
31  robot.GetAxleLuaGripperFunc(1, getFunc);
32  int getforceEnable[16] = { 0 };
33  int getgripperEnable[16] = { 0 };
34  int getioEnable[16] = { 0 };
35  robot.GetAxleLuaEnableDevice(getforceEnable, getgripperEnable, getioEnable);
36  printf("\ngetforceEnable status : ");
37  for (int i = 0; i < 16; i++)
38  {
39    printf("%d,", getforceEnable[i]);
40  }
41  printf("\ngetgripperEnable status : ");
42  for (int i = 0; i < 16; i++)
43  {
44    printf("%d,", getgripperEnable[i]);
45  }
46  printf("\ngetioEnable status : ");
47  for (int i = 0; i < 16; i++)
48  {
49    printf("%d,", getioEnable[i]);
50  }
51  printf("\n");
52  robot.ActGripper(1, 0);
53  robot.Sleep(2000);
54  robot.ActGripper(1, 1);
55  robot.Sleep(2000);
56  robot.MoveGripper(1, 90, 10, 100, 50000, 0, 0, 0, 0, 0);
57  int pos = 0;
58  while (true)
59  {
60    robot.GetRobotRealTimeState(&pkg);
61    printf("gripper pos is %u\n", pkg.gripper_position);
62    robot.Sleep(100);
63  }
64  robot.CloseRPC();
65  return 0;
66}

11.57. SmartTool-Tastenstatus abrufen

1/**
2* @brief SmartTool-Tastenstatus abrufen
3* @param [out] state SmartTool-Griff Tastenstatus (Bit0: 0-Kommunikation normal; 1-Kommunikation unterbrochen; Bit1-Rückgängig; Bit2-Programm löschen;
4    Bit3-Taste A; Bit4-Taste B; Bit5-Taste C; Bit6-Taste D; Bit7-Taste E; Bit8-IO-Taste; Bit9-Hand/Automatik; Bit10-Start)
5* @return Fehlercode
6*/
7errno_t GetSmarttoolBtnState(int& state);

11.58. Codebeispiel für SmartTool-Tasten

 1int main(void)
 2{
 3  ROBOT_STATE_PKG pkg = {};
 4  FRRobot robot;
 5
 6  robot.LoggerInit();
 7  robot.SetLoggerLevel(1);
 8  int rtn = robot.RPC("192.168.58.2");
 9  robot.SetReConnectParam(true, 30000, 500);
10
11  while (true)
12  {
13    int btn = 0;
14    robot.GetSmarttoolBtnState(btn);
15    // Ausgabe als Binärstring
16    cout << "smarttool " << bitset<sizeof(btn) * 8>(btn) << endl;
17
18    Sleep(100);
19  }
20}

11.59. Array-Sauggreifer steuern

1/**
2* @brief Array-Sauggreifer steuern
3* @param [in] slaveID Slave-Nummer (0 für Broadcast)
4* @param [in] len Anzahl der zu steuernden Sauger (Länge des ctrlValue-Arrays)
5* @param [in] ctrlValue Steuerwerte-Array: 1-mit maximalem Vakuum ansaugen; 2-mit eingestelltem Vakuum ansaugen; 3-Ansaugen stoppen
6* @return Fehlercode
7*/
8errno_t SetSuckerCtrl(uint8_t slaveID, uint8_t len, uint8_t ctrlValue[20]);

11.60. Status des Array-Sauggreifers abrufen

1/**
2* @brief Status des Array-Sauggreifers abrufen
3* @param [in] slaveID Slave-Nummer
4* @param [out] state Saugzustand: 0-Objekt losgelassen; 1-Werkstück erfolgreich angesaugt; 2-kein Objekt angesaugt; 3-Objekt abgelöst
5* @param [out] pressValue Aktuelles Vakuum [kPa]
6* @param [out] error Aktueller Fehlercode des Saugers
7* @return Fehlercode
8*/
9errno_t GetSuckerState(uint8_t slaveID, uint8_t* state, int* pressValue, int* error);

11.61. Auf Saugerstatus warten

1/**
2* @brief Auf Saugerstatus warten
3* @param [in] slaveID Slave-Nummer
4* @param [in] state Erwarteter Saugzustand (siehe GetSuckerState)
5* @param [in] ms Maximale Wartezeit [ms]
6* @return Fehlercode (0 bei Erfolg, Fehlercode bei Timeout/Fehler)
7*/
8errno_t WaitSuckerState(uint8_t slaveID, uint8_t state, int ms);

11.62. Codebeispiel für Array-Sauggreifer-Steuerung

 1void testSucker()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    uint8_t ctrl[20];
 6    uint8_t state;
 7    int pressVlaue;
 8    int error;
 9
10    robot.LoggerInit();
11    robot.SetLoggerLevel(1);
12    int rtn = robot.RPC("192.168.58.2");
13    if (rtn != 0)
14    {
15        return;
16    }
17    robot.SetReConnectParam(true, 30000, 500);
18    // Open-Protocol-Datei hochladen und laden
19    robot.OpenLuaUpload("E://Projekt/PeripherieSDK/CtrlDev_sucker.lua");
20    robot.Sleep(2000);
21    robot.SetCtrlOpenLUAName(1, "CtrlDev_sucker.lua");
22    robot.UnloadCtrlOpenLUA(1);
23    robot.LoadCtrlOpenLUA(1);
24    robot.Sleep(1000);
25
26    // Sauger im Broadcast-Modus mit maximaler Saugkraft steuern
27    ctrl[0] = 1;
28    robot.SetSuckerCtrl(0, 1, ctrl);
29
30    // Zustände von Sauger 1 und Sauger 12 in einer Schleife überwachen
31    for (int i = 0; i < 100; i++)
32    {
33        robot.GetSuckerState(1, &state, &pressVlaue, &error);
34        printf("sucker1 state is %d, pressVlaue is %d, error num is %d\n", state, pressVlaue, error);
35        robot.GetSuckerState(12, &state, &pressVlaue, &error);
36        printf("sucker12 state is %d, pressVlaue is %d, error num is %d\n", state, pressVlaue, error);
37        robot.Sleep(100);
38    }
39
40    // Auf angesaugten Zustand von Sauger 1 warten, Timeout 100ms
41    int ret = robot.WaitSuckerState(1, 1, 100);
42    printf("WaitSuckerState result is  %d\n", ret);
43
44    // Unicast-Modus: Sauger 1 und 12 ausschalten (Wert 3)
45    ctrl[0] = 3;
46    robot.SetSuckerCtrl(1, 1, ctrl);
47    robot.SetSuckerCtrl(12, 1, ctrl);
48
49    robot.CloseRPC();
50}

11.63. Open-Protocol-LUA-Datei hochladen

1/**
2 * @brief Open-Protocol-LUA-Datei hochladen (für Peripheriegeräte)
3 * @param [in] filePath Lokaler Pfad zur LUA-Datei
4 * @return Fehlercode
5 */
6errno_t OpenLuaUpload(std::string filePath);

11.64. Slave-Kartenparameter abrufen (Feldbus)

1/**
2* @brief Slave-Kartenparameter (Feldbus) abrufen
3* @param [out] type Protokolltyp: 0-Ethercat, 1-CClink, 3-Ethercat (Dopplung?), 4-EIP
4* @param [out] version Protokollversion
5* @param [out] connState Verbindungsstatus: 0-nicht verbunden, 1-verbunden
6* @return Fehlercode
7*/
8errno_t GetFieldBusConfig(uint8_t* type, uint8_t* version, uint8_t* connState);

11.65. In Slave-DO schreiben (Feldbus)

1/**
2* @brief In Slave-DO (Digitalausgang) schreiben (Feldbus)
3* @param [in] DOIndex DO-Nummer (Startadresse)
4* @param [in] writeNum Anzahl der zu schreibenden Werte
5* @param [in] status[8] Array mit den zu schreibenden Werten (0/1), max. 8
6* @return Fehlercode
7*/
8errno_t FieldBusSlaveWriteDO(uint8_t DOIndex, uint8_t writeNum, uint8_t status[8]);

11.66. In Slave-AO schreiben (Feldbus)

1/**
2* @brief In Slave-AO (Analogausgang) schreiben (Feldbus)
3* @param [in] AOIndex AO-Nummer (Startadresse)
4* @param [in] writeNum Anzahl der zu schreibenden Werte
5* @param [in] status[8] Array mit den zu schreibenden Werten (int), max. 8
6* @return Fehlercode
7*/
8errno_t FieldBusSlaveWriteAO(uint8_t AOIndex, uint8_t writeNum, double status[8]);

11.67. Slave-DI lesen (Feldbus)

1/**
2* @brief Slave-DI (Digitaleingang) lesen (Feldbus)
3* @param [in] DIIndex DI-Nummer (Startadresse)
4* @param [in] readNum Anzahl der zu lesenden Werte
5* @param [out] status[8] Array mit den gelesenen Werten (0/1), max. 8
6* @return Fehlercode
7*/
8errno_t FieldBusSlaveReadDI(uint8_t DIIndex, uint8_t readNum, uint8_t status[8]);

11.68. Slave-AI lesen (Feldbus)

1/**
2* @brief Slave-AI (Analogeingang) lesen (Feldbus)
3* @param [in] AIIndex AI-Nummer (Startadresse)
4* @param [in] readNum Anzahl der zu lesenden Werte
5* @param [out] status[8] Array mit den gelesenen Werten (int), max. 8
6* @return Fehlercode
7*/
8errno_t FieldBusSlaveReadAI(uint8_t AIIndex, uint8_t readNum, double status[8]);

11.69. Auf erweiterten DI-Eingang warten (Feldbus)

1/**
2* @brief Auf erweiterten DI-Eingang (Feldbus) warten
3* @param [in] DIIndex DI-Nummer
4* @param [in] status Erwarteter Zustand: false (0) für niedrig, true (1) für hoch
5* @param [in] waitMs Maximale Wartezeit [ms]
6* @return Fehlercode (0 bei Erfolg, Fehlercode bei Timeout)
7*/
8errno_t FieldBusSlaveWaitDI(uint8_t DIIndex, bool status, int waitMs);

11.70. Auf erweiterten AI-Eingang warten (Feldbus)

1/**
2* @brief Auf erweiterten AI-Eingang (Feldbus) warten
3* @param [in] AIIndex AI-Nummer
4* @param [in] waitType Bedingung: 0-größer als; 1-kleiner als
5* @param [in] value Vergleichswert (double)
6* @param [in] waitMs Maximale Wartezeit [ms]
7* @return Fehlercode (0 bei Erfolg, Fehlercode bei Timeout)
8*/
9errno_t FieldBusSlaveWaitAI(uint8_t AIIndex, uint8_t waitType, double value, int waitMs);

11.71. Codebeispiel für Slave-Modus-Befehle (Feldbus-Karte)

 1void testFieldBusBoard()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    uint8_t type = 0, version = 0, connState = 0;
 6    uint8_t ctrl[8];
 7    double ctrlAO[8];
 8    static uint8_t DI[8];
 9    static double AI[8];
10
11    robot.LoggerInit();
12    robot.SetLoggerLevel(1);
13    int rtn = robot.RPC("192.168.58.2");
14    if (rtn != 0)
15    {
16        return;
17    }
18    robot.SetReConnectParam(true, 30000, 500);
19    // Open-Protocol-Datei hochladen und laden
20    robot.OpenLuaUpload("E://Projekt/PeripherieSDK/CtrlDev_field.lua");
21    robot.Sleep(2000);
22    robot.SetCtrlOpenLUAName(3, "CtrlDev_field.lua");
23    robot.UnloadCtrlOpenLUA(3);
24    robot.LoadCtrlOpenLUA(3);
25    robot.Sleep(8000);
26
27    // Protokolltyp, Softwareversion und Verbindungsstatus der Slave-Karte abrufen
28    robot.GetFieldBusConfig(&type, &version, &connState);
29    printf("type is %d, version is %d, connState is %d\n", type, version, connState);
30
31    // DO0 = 1, DO1 = 0, DO2 = 1 schreiben
32    ctrl[0] = 0; // Wert für DO0? Ursprünglich ctrl[0]=0, aber Kommentar sagt DO0=1, möglicherweise Index-Verschiebung
33    ctrl[1] = 1;
34    ctrl[2] = 1;
35    robot.FieldBusSlaveWriteDO(0, 3, ctrl);
36
37    // AO2 = 0x1000 (4096) schreiben
38    ctrlAO[0] = 0x1005; // Beispielwert 0x1005
39    robot.FieldBusSlaveWriteAO(2, 1, ctrlAO); // Schreibt ab AO2 den Wert aus ctrlAO[0]
40
41    // DI0..DI3 und AI0..AI2 in einer Schleife überwachen
42    for (int i = 0; i < 100; i++)
43    {
44        robot.FieldBusSlaveReadDI(0, 4, DI);
45        printf("DI0 is %d, DI1 is %d, DI2 is %d, DI3 is %d\n", DI[0], DI[1], DI[2], DI[3]);
46        robot.FieldBusSlaveReadAI(0, 3, AI);
47        printf("AI0 is %d, AI1 is %d, AI2 is %d\n", AI[0], AI[1], AI[2]);
48        robot.Sleep(10);
49    }
50
51    // Auf DI0 = 1 warten, Timeout 100ms
52    int ret = robot.FieldBusSlaveWaitDI(0, 1, 100);
53    printf("FieldBusSlaveWaitDI result is  %d\n", ret);
54
55    // Auf AI0 > 400 warten, Timeout 100ms
56    ret = robot.FieldBusSlaveWaitAI(0, 0, 400.00, 100);
57    printf("FieldBusSlaveWaitAI result is  %d\n", ret);
58
59    robot.CloseRPC();
60}

11.72. Laser-Peripherie Ein-/Ausschalten

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

1/**
2 * @brief Laser-Peripherie Ein-/Ausschaltfunktion
3 * @param [in] OnOff 0-ausschalten, 1-einschalten
4 * @param [in] weldId Schweißnaht-ID (Standard 0)
5 * @return Fehlercode
6 */
7errno_t LaserTrackingLaserOnOff(int OnOff, int weldId);

11.73. Laser-Tracking Start/Stopp

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

1/**
2 * @brief Laser-Tracking Start/Stopp
3 * @param [in] OnOff 0-stoppen, 1-starten
4 * @param [in] coordId Werkzeugkoordinatennummer des Laser-Peripheriegeräts
5 * @return Fehlercode
6 */
7errno_t LaserTrackingTrackOnOff(int OnOff, int coordId);

11.74. Lasernahtsuche starten - feste Richtung

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

 1/**
 2* @brief Lasernahtsuche starten - feste Richtung
 3* @param [in] direction 0-x+ 1-x- 2-y+ 3-y- 4-z+ 5-z-
 4* @param [in] vel Geschwindigkeit [%]
 5* @param [in] distance Maximale Suchdistanz [mm]
 6* @param [in] timeout Such-Timeout [ms]
 7* @param [in] posSensorNum Nummer des kalibrierten Laser-Werkzeugkoordinatensystems
 8* @return Fehlercode
 9*/
10errno_t LaserTrackingSearchStart_xyz(int direction, int vel, int distance, int timeout, int posSensorNum);

11.75. Lasernahtsuche starten - Richtung durch Punkt vorgegeben

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

 1/**
 2 * @brief Lasernahtsuche starten - Richtung durch Punkt vorgegeben
 3 * @param [in] directionPoint XYZ-Koordinaten des Richtungspunkts (relativ)
 4 * @param [in] vel Geschwindigkeit [%]
 5 * @param [in] distance Maximale Suchdistanz [mm]
 6 * @param [in] timeout Such-Timeout [ms]
 7 * @param [in] posSensorNum Nummer des kalibrierten Laser-Werkzeugkoordinatensystems
 8 * @return Fehlercode
 9 */
10errno_t LaserTrackingSearchStart_point(DescTran directionPoint, int vel, int distance, int timeout, int posSensorNum);

11.76. Lasernahtsuche beenden

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

1/**
2 * @brief Lasernahtsuche beenden
3 * @return Fehlercode
4 */
5errno_t LaserTrackingSearchStop();

11.77. Laser-Netzwerkparameter konfigurieren

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

1/**
2 * @brief Laser-Netzwerkparameter konfigurieren
3 * @param [in] ip IP-Adresse des Laser-Peripheriegeräts
4 * @param [in] port Portnummer des Laser-Peripheriegeräts
5 * @return Fehlercode
6 */
7errno_t LaserTrackingSensorConfig(std::string ip, int port);

11.78. Laser-Peripherie-Abtastperiode konfigurieren

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

1/**
2* @brief Laser-Peripherie-Abtastperiode konfigurieren
3* @param [in] period Abtastperiode [ms]
4* @return Fehlercode
5*/
6errno_t LaserTrackingSensorSamplePeriod(int period);

11.79. Laser-Peripherie-Treiber laden

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

1/**
2 * @brief Laser-Peripherie-Treiber laden
3 * @param [in] type Protokolltyp des Laser-Peripherietreibers: 101-RuiNiu; 102-ChuangXiang; 103-QuanShi; 104-TongZhou; 105-AoTai
4 * @return Fehlercode
5 */
6errno_t LoadPosSensorDriver(int type);

11.80. Laser-Peripherie-Treiber entladen

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

1/**
2 * @brief Laser-Peripherie-Treiber entladen
3 * @return Fehlercode
4 */
5errno_t UnLoadPosSensorDriver();

11.81. Laser-Schweißnaht-Trajektorie aufzeichnen

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

1/**
2* @brief Laser-Schweißnaht-Trajektorie aufzeichnen
3* @param [in] status 0-Aufzeichnung stoppen; 1-Echtzeit-Tracking; 2-Aufzeichnung starten
4* @param [in] delayTime Verzögerungszeit [ms]
5* @return Fehlercode
6*/
7errno_t LaserSensorRecord1(int status, int delayTime);

11.82. Laser-Schweißnaht-Trajektorie wiedergeben

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

1/**
2 * @brief Laser-Schweißnaht-Trajektorie wiedergeben
3 * @param [in] delayTime Verzögerungszeit [ms]
4 * @param [in] speed Geschwindigkeit [%]
5 * @return Fehlercode
6 */
7errno_t LaserSensorReplay(int delayTime, double speed);

11.83. Laser-Tracking-Wiedergabe (MoveLTR)

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

1/**
2 * @brief Laser-Tracking-Wiedergabe (Bewegung entlang der aufgezeichneten Trajektorie)
3 * @return Fehlercode
4 */
5errno_t MoveLTR();

11.84. Laser-Schweißnaht-Trajektorie aufzeichnen und wiedergeben (erweitert)

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

 1/**
 2* @brief Laser-Schweißnaht-Trajektorie aufzeichnen und wiedergeben (erweiterte Funktion mit verschiedenen Modi)
 3* @param [in] delayMode Modus: 0-Verzögerungszeit; 1-Verzögerungsdistanz
 4* @param [in] delayTime Verzögerungszeit [ms] (wenn delayMode=0)
 5* @param [in] delayDisExAxisNum Erweiterungsachsennummer für Distanzverzögerung
 6* @param [in] delayDis Verzögerungsdistanz [mm] (wenn delayMode=1)
 7* @param [in] sensitivePara Kompensations-Empfindlichkeitskoeffizient
 8* @param [in] trackMode Punkt-Tracking-Typ: 0-Erweiterungsachse asynchron; 1-Roboter (synchron?)
 9* @param [in] triggerMode Punkt-Tracking-Auslösemodus: 0-Tracking-Dauer; 1-IO
10* @param [in] runTime Dauer des Roboter-Punkt-Trackings [s]
11* @param [in] speed Geschwindigkeit [%]
12* @return Fehlercode
13*/
14errno_t LaserSensorRecordandReplay(int delayMode, int delayTime, int delayDisExAxisNum, double delayDis, double sensitivePara, int trackMode, int triggerMode, double runTime, double speed);

11.85. Zum aufgezeichneten Startpunkt der Schweißnaht bewegen

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

1/**
2* @brief Zum aufgezeichneten Startpunkt der Schweißnaht bewegen
3* @param [in] moveType 0-moveJ, 1-moveL
4* @param [in] ovl Geschwindigkeit [%]
5* @return Fehlercode
6*/
7errno_t MoveToLaserRecordStart(int moveType, double ovl);

11.86. Zum aufgezeichneten Endpunkt der Schweißnaht bewegen

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

1/**
2* @brief Zum aufgezeichneten Endpunkt der Schweißnaht bewegen
3* @param [in] moveType 0-moveJ, 1-moveL
4* @param [in] ovl Geschwindigkeit [%]
5* @return Fehlercode
6*/
7errno_t MoveToLaserRecordEnd(int moveType, double ovl);

11.87. Zum vom Laser-Sensor gefundenen Nahtpunkt bewegen

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

 1/**
 2* @brief Zum vom Laser-Sensor gefundenen Nahtpunkt bewegen
 3* @param [in] moveFlag Bewegungstyp: 0-PTP; 1-LIN
 4* @param [in] ovl Geschwindigkeitsskalierungsfaktor [0-100]
 5* @param [in] dataFlag Auswahl der Schweißnaht-Cache-Daten: 0-Planungsdaten ausführen; 1-Aufgezeichnete Daten ausführen
 6* @param [in] plateType Plattenmaterial-Typ: 0-Wellenplatte; 1-Wellpappe; 2-Zaunplatte; 3-Ölfass; 4-Wellenpanzerstahl
 7* @param [in] trackOffectType Laser-Sensor-Versatztyp: 0-kein Versatz; 1-Versatz im Basiskoordinatensystem; 2-Versatz im Werkzeugkoordinatensystem; 3-Versatz basierend auf Laser-Sensor-Rohdaten
 8* @param [in] offset Versatzwert (Pose)
 9* @return Fehlercode
10*/
11errno_t MoveToLaserSeamPos(int moveFlag, double ovl, int dataFlag, int plateType, int trackOffectType, DescPose offset);

11.88. Koordinaten des vom Laser-Sensor gefundenen Nahtpunkts abrufen

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

 1/**
 2* @brief Koordinaten des vom Laser-Sensor gefundenen Nahtpunkts abrufen
 3* @param [in] trackOffectType Laser-Sensor-Versatztyp (siehe MoveToLaserSeamPos)
 4* @param [in] offset Versatzwert (Pose)
 5* @param [out] jPos Gelenkposition [°]
 6* @param [out] descPos Kartesische Position [mm]
 7* @param [out] tool Verwendetes Werkzeugkoordinatensystem
 8* @param [out] user Verwendetes Werkstückkoordinatensystem
 9* @param [out] exaxis Position der Erweiterungsachse [mm]
10* @return Fehlercode
11*/
12errno_t GetLaserSeamPos(int trackOffectType, DescPose offset, JointPos& jPos, DescPose& descPos, int& tool, int& user, ExaxisPos& exaxis);

11.89. Codebeispiel für Laser-Peripherie-Sensorparametrierung und -Debugging

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

 1void testLaserConfig()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    uint8_t ctrl[20];
 6    uint8_t state;
 7    int pressVlaue;
 8    int error;
 9    robot.CloseRPC();
10    robot.LoggerInit();
11    robot.SetLoggerLevel(1);
12    int rtn = robot.RPC("192.168.58.2");
13    if (rtn != 0)
14    {
15        return;
16    }
17    robot.SetReConnectParam(true, 30000, 500);
18    // IP-Adresse und Port konfigurieren
19    robot.LaserTrackingSensorConfig("192.168.58.20", 5020);
20    // Abtastperiode konfigurieren
21    robot.LaserTrackingSensorSamplePeriod(20);
22    // Treiber laden (Typ 101 = RuiNiu)
23    robot.LoadPosSensorDriver(101);
24    // Laser ausschalten
25    robot.LaserTrackingLaserOnOff(0, 0);
26    robot.Sleep(3000);
27    // Laser einschalten
28    robot.LaserTrackingLaserOnOff(1, 0);
29    robot.CloseRPC();
30}

11.90. Codebeispiel für Laser-Trajektorienscan und -wiedergabe

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

 1void testLaserRecordAndReplay()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    uint8_t ctrl[20];
 6    uint8_t state;
 7    int pressVlaue;
 8    int error;
 9    robot.CloseRPC();
10    robot.LoggerInit();
11    robot.SetLoggerLevel(1);
12    int rtn = robot.RPC("192.168.58.2");
13    if (rtn != 0)
14    {
15        return;
16    }
17    robot.SetReConnectParam(true, 30000, 500);
18
19    // Open-Protocol-Datei hochladen und laden
20    robot.OpenLuaUpload("E://openlua/CtrlDev_laser_ruiniu-0117.lua");
21    robot.Sleep(2000);
22    robot.SetCtrlOpenLUAName(0, "CtrlDev_laser_ruiniu-0117.lua");
23    robot.UnloadCtrlOpenLUA(0);
24    robot.LoadCtrlOpenLUA(0);
25    robot.Sleep(8000);
26    int cnt = 1;
27    while (cnt < 31)
28    {
29        // Zum Startpunkt der Aufzeichnung bewegen
30        JointPos startjointPos(56.205, -117.951, 141.872, -118.149, -94.217, -122.176);
31        DescPose startdescPose(-97.552, -282.855, 26.675, 174.182, -1.338, -91.707);
32        ExaxisPos exaxisPos(0, 0, 0, 0);
33        DescPose offdese(0, 0, 0, 0, 0, 0);
34        robot.MoveL(&startjointPos, &startdescPose, 1, 0, 100, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
35        // Trajektorienaufzeichnung starten
36        robot.LaserSensorRecord1(2, 10);
37        // Zum Endpunkt der Aufzeichnung bewegen
38        JointPos endjointPos(68.809, -87.100, 121.120, -127.233, -95.038, -109.555);
39        DescPose enddescPose(-103.555, -464.234, 13.076, 174.179, -1.344, -91.709);
40        robot.MoveL(&endjointPos, &enddescPose, 1, 0, 30, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
41        // Aufzeichnung stoppen
42        robot.LaserSensorRecord1(0, 10);
43        // Zum aufgezeichneten Startpunkt bewegen
44        robot.MoveToLaserRecordStart(1, 30);
45        // Trajektorienwiedergabe starten
46        robot.LaserSensorReplay(10, 100);
47        robot.MoveLTR();
48        // Wiedergabe stoppen (implizit durch MoveLTR?)
49        robot.LaserSensorRecord1(0, 10);
50        printf("Laser-Scan + Trajektorienwiedergabe Stabilitätstest Nr. %d\n", cnt);
51        cnt++;
52    }
53    robot.CloseRPC();
54}

11.91. Codebeispiel für Lasernahtsuche und Echtzeit-Tracking

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

 1void testLasertrack()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    uint8_t ctrl[20];
 6    uint8_t state;
 7    int pressVlaue;
 8    int error;
 9    robot.CloseRPC();
10    robot.LoggerInit();
11    robot.SetLoggerLevel(1);
12    int rtn = robot.RPC("192.168.58.2");
13
14    if (rtn != 0)
15    {
16        return;
17    }
18    robot.SetReConnectParam(true, 30000, 500);
19
20    // Open-Protocol-Datei hochladen und laden
21    robot.OpenLuaUpload("E://openlua/CtrlDev_laser_ruiniu-0117.lua");
22    robot.Sleep(2000);
23    robot.SetCtrlOpenLUAName(0, "CtrlDev_laser_ruiniu-0117.lua");
24    robot.UnloadCtrlOpenLUA(0);
25    robot.LoadCtrlOpenLUA(0);
26    robot.Sleep(8000);
27    int cnt = 1;
28    while (cnt < 2)
29    {
30        // Zum Startpunkt der Suche bewegen
31        JointPos startjointPos(58.337, -119.628, 146.037, -116.358, -92.224, -117.654);
32        DescPose startdescPose(-53.375, -255.363, 0.919, 178.054, 1.077, -94.026);
33        ExaxisPos exaxisPos(0, 0, 0, 0);
34        DescPose offdese(0, 0, 0, 0, 0, 0);
35        DescTran directionPoint; // Nicht initialisiert/verwendet
36        robot.MoveL(&startjointPos, &startdescPose, 1, 0, 100, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
37
38        // Lasernahtsuche in -y Richtung starten (direction=3)
39        int ret = robot.LaserTrackingSearchStart_xyz(3, 100, 300, 1000, 2);
40        robot.LaserTrackingSearchStop();
41        // Bei erfolgreicher Suche (ret == 0)
42        if (ret == 0)
43        {
44            // Zum gefundenen Nahtpunkt bewegen
45            robot.MoveToLaserSeamPos(1, 30, 0, 0, 0, offdese);
46            // Laser-Tracking starten
47            robot.LaserTrackingTrackOnOff(1, 2);
48            // Bewegung entlang der Naht (mit Tracking)
49            JointPos endjointPos(70.580, -90.918, 126.593, -125.154, -92.162, -105.403);
50            DescPose enddescPose(-53.375, -419.020, 0.920, 178.054, 1.076, -94.026);
51            robot.MoveL(&endjointPos, &enddescPose, 1, 0, 20, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
52            // Tracking stoppen
53            robot.LaserTrackingTrackOnOff(0, 2);
54        }
55        cnt++;
56    }
57    robot.CloseRPC();
58}

11.92. Codebeispiel für synchrones Laser-Tracking mit Erweiterungsachse und Roboter

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

 1void testLasertrackandExitAxis()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    uint8_t ctrl[20];
 6    uint8_t state;
 7    int pressVlaue;
 8    int error;
 9    robot.CloseRPC();
10    robot.LoggerInit();
11    robot.SetLoggerLevel(1);
12    int rtn = robot.RPC("192.168.58.2");
13
14    if (rtn != 0)
15    {
16        return;
17    }
18    robot.SetReConnectParam(true, 30000, 500);
19
20    ExaxisPos startexaxisPos = { 0,0,0,0 };
21    ExaxisPos seamexaxisPos = { -10,0,0,0 };
22    ExaxisPos endexaxisPos = { -30, 0, 0, 0 };
23    DescPose offdese = { 0, 0, 0, 0, 0, 0 };
24    JointPos seamjointPos(0, 0, 0, 0, 0, 0);
25    DescPose seamdescPose(0, 0, 0, 0, 0, 0);
26
27    int cnt = 1;
28    while (cnt < 31)
29    {
30        // Zum Startpunkt der Suche bewegen (synchron mit Erweiterungsachse)
31        JointPos startjointPos(58.337, -119.628, 146.037, -116.358, -92.224, -117.654);
32        DescPose startdescPose(-53.375, -255.363, 0.919, 178.054, 1.077, -94.026);
33        robot.ExtAxisSyncMoveJ(startjointPos, startdescPose, 1, 0, 100, 100, 100, startexaxisPos, -1, 0, offdese);
34
35        // Lasernahtsuche in -y Richtung starten (direction=3)
36        int ret = robot.LaserTrackingSearchStart_xyz(3, 100, 300, 1000, 2);
37        robot.LaserTrackingSearchStop();
38        int tool = 0;
39        int user = 0;
40        // Koordinaten des gefundenen Nahtpunkts abrufen
41        robot.GetLaserSeamPos(0, offdese, seamjointPos, seamdescPose, tool, user, startexaxisPos);
42        printf("%f, %f, %f,%f, %f, %f,%f, %f, %f,%f, %f, %f\n", seamjointPos.jPos[0], seamjointPos.jPos[1], seamjointPos.jPos[2], seamjointPos.jPos[3], seamjointPos.jPos[4], seamjointPos.jPos[5], seamdescPose.tran.x, seamdescPose.tran.y, seamdescPose.tran.z, seamdescPose.rpy.rx, seamdescPose.rpy.ry, seamdescPose.rpy.rz);
43
44        // Bei erfolgreicher Suche (ret == 0)
45        if (ret == 0)
46        {
47            // Synchron zum Nahtpunkt bewegen
48            robot.ExtAxisSyncMoveJ(seamjointPos, seamdescPose, 1, 0, 100, 100, 100, seamexaxisPos, -1, 0, offdese);
49
50            // Laser-Tracking starten
51            robot.LaserTrackingTrackOnOff(1, 2);
52            // Synchron entlang der Naht bewegen (mit Tracking)
53            JointPos endjointPos(70.580, -90.918, 126.593, -125.154, -92.162, -105.403);
54            DescPose enddescPose(-53.375, -419.020, 0.920, 178.054, 1.076, -94.026);
55            robot.ExtAxisSyncMoveL(endjointPos, enddescPose, 1, 0, 20, 100, 100, -1, endexaxisPos, 0, offdese);
56            // Tracking stoppen
57            robot.LaserTrackingTrackOnOff(0, 2);
58        }
59        cnt++;
60        printf("Synchrones Laser-Tracking mit Erweiterungsachse - Durchlauf %d\n", cnt);
61    }
62    robot.CloseRPC();
63}

11.93. Endeffektor-Transparentübertragungsfunktion ein-/ausschalten

1/**
2* @brief Endeffektor-Transparentübertragungsfunktion ein-/ausschalten
3* @param [in] Aktivierung, 0-deaktiviert, 1-aktiviert
4* @return Fehlercode
5*/
6errno_t SetAxleGenComEnable(int mode);

11.94. Endeffektor-Transparentübertragungsfunktion für azyklische Datenübertragung und -empfang

1/**
2* @brief Endeffektor-Transparentübertragungsfunktion für azyklische Datenübertragung und -empfang
3* @param [in] len_snd Länge der zu sendenden Daten
4* @param [in] sndBuff Zu sendende Daten
5* @param [in] len_rcv Länge der zu empfangenden Daten
6* @param [out] rcvBuff Antwortdaten
7* @return Fehlercode
8*/
9errno_t SndRcvAxleGenComCmdData(int lenSnd, int sndBuff[130], int lenRcv, int rcvData[130]);

11.95. Codebeispiel für azyklische Datenkommunikation des DIO Health Care Moxibustion-Kopfs basierend auf der Endeffektor-Transparentübertragungsfunktion

 1int testAxleGenCom()
 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  int led_on[6] = { 0xAB, 0xBA, 0x12, 0x01, 0x01, 0x79 };
14  int led_off[6] = { 0xAB, 0xBA, 0x12, 0x01, 0x00, 0x78 };
15  int version[5] = { 0xAB, 0xBA, 0x11, 0x00, 0x76 };
16  int state[6] = { 0xAB, 0xBA, 0x1B, 0x01, 0xAA, 0x2B };
17  int cycleState[6] = { 0xAB, 0xBA, 0x12, 0x01, 0x00, 0x78 };
18  int rcvdata[16] = {0};
19  int ret = 0;
20  int cnt = 1;
21  JointPos p1Joint(88.708, -86.178, 140.989, -141.825, -89.162, -49.879);
22  DescPose p1Desc(188.007, -377.850, 260.207, 178.715, 2.823, -131.466);
23  JointPos p2Joint(112.131, -75.554, 126.989, -139.027, -88.044, -26.477);
24  DescPose p2Desc(368.003, -377.848, 260.211, 178.715, 2.823, -131.465);
25  ExaxisPos exaxisPos(0, 0, 0, 0);
26  DescPose offdese(0, 0, 0, 0, 0, 0);
27  //Endeffektor-Transparentübertragungsfunktion aktivieren
28  robot.SetAxleGenComEnable(1);
29  robot.SetAxleLuaEnable(1);
30  while (cnt <= 10000)
31  {
32    //Versionsnummer auslesen
33    ret = robot.SndRcvAxleGenComCmdData(5, version, 10, rcvdata);
34    printf(" hard version : %d,hard code:%d, soft version:%d %d, soft code:%d \n", rcvdata[4], rcvdata[5], rcvdata[6] ,rcvdata[7], rcvdata[8]);
35    if (ret != 0)
36    {
37      break;
38    }
39    robot.Sleep(1000);
40    //Präsenzstatus des Moxibustion-Kopfs auslesen
41    ret = robot.SndRcvAxleGenComCmdData(6, state, 6, rcvdata);
42    printf(" state : %d \n", rcvdata[4]);
43    robot.Sleep(1000);
44    //Laser des Moxibustion-Kopfs einschalten
45    ret = robot.SndRcvAxleGenComCmdData(6, led_on, 6, rcvdata);
46    printf("led on rcv data is: %d, %d, %d, %d, %d, %d  \n", rcvdata[0], rcvdata[1], rcvdata[2], rcvdata[3], rcvdata[4], rcvdata[5]);
47    robot.MoveJ(&p1Joint, &p1Desc, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
48    robot.Sleep(4000);
49    //Laser des Moxibustion-Kopfs ausschalten
50    ret = robot.SndRcvAxleGenComCmdData(6, led_off, 6, rcvdata);
51    printf("led off rcv data is: %d, %d, %d, %d, %d, %d \n", rcvdata[0], rcvdata[1], rcvdata[2], rcvdata[3], rcvdata[4], rcvdata[5]);
52    robot.MoveJ(&p2Joint, &p2Desc, 0, 0, 100, 100, 100, &exaxisPos, -1, 0, &offdese);
53    robot.Sleep(1000);
54    printf("***********************complate No. %d SDK test*****************************\n", cnt);
55    cnt++;
56  }
57  robot.CloseRPC();
58}

11.96. Open-Protocol-Lua-Datei herunterladen

1/**
2* @brief Open-Protocol-Lua-Datei herunterladen
3* @param [in] fileName Name der Open-Protocol-Datei "CtrlDev_XXX.lua"
4* @param [in] savePath Pfad zum Speichern der Open-Protocol-Datei
5* @return Fehlercode
6*/
7errno_t OpenLuaDownload(std::string fileName, std::string savePath);

11.97. Open-Protocol-Lua-Datei löschen

1/**
2* @brief Open-Protocol-Lua-Datei löschen
3* @param [in] fileName Name der zu löschenden Open-Protocol-Lua-Datei "CtrlDev_XXX.lua"
4* @return Fehlercode
5*/
6errno_t OpenLuaDelete(std::string fileName);

11.98. Alle Open-Protocol-Lua-Dateien löschen

1/**
2* @brief Alle Open-Protocol-Lua-Dateien löschen
3* @return Fehlercode
4*/
5errno_t AllOpenLuaDelete();

11.99. Codebeispiel für Open-Protocol-Upload, -Download und -Löschen von Controller-Peripheriegeräten

 1int TestCtrlOpenLuaOperate()
 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    rtn = robot.OpenLuaUpload("D://zUP/openlua/CtrlDev_WELDING_A.lua");
14    printf("OpenLuaUpload rtn is %d\n", rtn);
15    rtn = robot.OpenLuaUpload("D://zUP/openlua/CtrlDev_SWDPOLISH.lua");
16    printf("OpenLuaUpload rtn is %d\n", rtn);
17    rtn = robot.OpenLuaDownload("CtrlDev_WELDING_A.lua", "D://zDOWN/");
18    printf("OpenLuaDownload rtn is %d\n", rtn);
19    rtn = robot.OpenLuaDownload("CtrlDev_SWDPOLISH.lua", "D://zDOWN/");
20    printf("OpenLuaDownload rtn is %d\n", rtn);
21    rtn = robot.SetCtrlOpenLUAName(0, "CtrlDev_WELDING_A.lua");
22    printf("SetCtrlOpenLUAName rtn is %d\n", rtn);
23    rtn = robot.SetCtrlOpenLUAName(1, "CtrlDev_SWDPOLISH.lua");
24    printf("SetCtrlOpenLUAName rtn is %d\n", rtn);
25    std::string name[4] = {};
26    rtn = robot.GetCtrlOpenLUAName(name);
27    printf("ctrl open lua names : %s, %s, %s, %s\n", name[0].c_str(), name[1].c_str(), name[2].c_str(), name[3].c_str());
28    rtn = robot.LoadCtrlOpenLUA(1);
29    printf("LoadCtrlOpenLUA rtn is %d\n", rtn);
30    robot.Sleep(2000);
31    rtn = robot.UnloadCtrlOpenLUA(1);
32    printf("UnloadCtrlOpenLUA rtn is %d\n", rtn);
33    rtn = robot.OpenLuaDelete("CtrlDev_WELDING_A.lua");
34    printf("OpenLuaDelete rtn is %d\n", rtn);
35    rtn = robot.AllOpenLuaDelete();
36    printf("AllOpenLuaDelete rtn is %d\n", rtn);
37    robot.CloseRPC();
38    robot.Sleep(1000);
39    return 0;
40}