11. Urządzenia peryferyjne robota
11.1. Konfiguracja chwytaka
1/**
2* @brief Konfiguruje chwytak
3* @param [in] company Producent chwytaka, do ustalenia
4* @param [in] device Numer urządzenia, tymczasowo nieużywany, domyślnie 0
5* @param [in] softvesion Numer wersji oprogramowania, tymczasowo nieużywany, domyślnie 0
6* @param [in] bus Pozycja magistrali końcowej, na której zamontowane jest urządzenie, tymczasowo nieużywane, domyślnie 0
7* @return Kod błędu
8*/
9errno_t SetGripperConfig(int company, int device, int softvesion, int bus);
11.2. Pobieranie konfiguracji chwytaka
1/**
2* @brief Pobiera konfigurację chwytaka
3* @param [in] company Producent chwytaka, do ustalenia
4* @param [in] device Numer urządzenia, tymczasowo nieużywany, domyślnie 0
5* @param [in] softvesion Numer wersji oprogramowania, tymczasowo nieużywany, domyślnie 0
6* @param [in] bus Pozycja magistrali końcowej, na której zamontowane jest urządzenie, tymczasowo nieużywane, domyślnie 0
7* @return Kod błędu
8*/
9errno_t GetGripperConfig(int *company, int *device, int *softvesion, int *bus);
11.3. Aktywacja chwytaka
1/**
2* @brief Aktywuje chwytak
3* @param [in] index Numer chwytaka
4* @param [in] act 0-reset, 1-aktywacja
5* @return Kod błędu
6*/
7errno_t ActGripper(int index, uint8_t act);
11.4. Sterowanie chwytakiem
Zmienione w wersji C++SDK-v2.1.5.0.
1/**
2 * @brief Steruje chwytakiem
3 * @param [in] index Numer chwytaka
4 * @param [in] pos Procent pozycji, zakres [0~100]
5 * @param [in] vel Procent prędkości, zakres [0~100]
6 * @param [in] force Procent momentu, zakres [0~100]
7 * @param [in] max_time Maksymalny czas oczekiwania, zakres [0~30000], jednostka ms
8 * @param [in] block 0-blokujące, 1-nieblokujące
9 * @param [in] type Typ chwytaka, 0-chwytak równoległy; 1-chwytak obrotowy
10 * @param [in] rotNum Liczba obrotów
11 * @param [in] rotVel Procent prędkości obrotowej [0-100]
12 * @param [in] rotTorque Procent momentu obrotowego [0-100]
13 * @return Kod błędu
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. Pobieranie stanu ruchu chwytaka
1/**
2 * @brief Pobiera stan ruchu chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] staus 0-ruch niezakończony, 1-ruch zakończony
5 * @return Kod błędu
6 */
7errno_t GetGripperMotionDone(uint16_t *fault, uint8_t *status);
11.6. Pobieranie stanu aktywacji chwytaka
1/**
2 * @brief Pobiera stan aktywacji chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] status bit0~bit15 odpowiadają numerom chwytaka 0~15, bit=0 oznacza nieaktywny, bit=1 oznacza aktywny
5 * @return Kod błędu
6 */
7errno_t GetGripperActivateStatus(uint16_t *fault, uint16_t *status);
11.7. Pobieranie pozycji chwytaka
1/**
2 * @brief Pobiera pozycję chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] position Procent pozycji, zakres 0~100%
5 * @return Kod błędu
6 */
7errno_t GetGripperCurPosition(uint16_t *fault, uint8_t *position);
11.8. Pobieranie prędkości chwytaka
1/**
2 * @brief Pobiera prędkość chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] speed Procent prędkości, zakres 0~100%
5 * @return Kod błędu
6 */
7errno_t GetGripperCurSpeed(uint16_t *fault, int8_t *speed);
11.9. Pobieranie prądu chwytaka
1/**
2 * @brief Pobiera prąd chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] current Procent prądu, zakres 0~100%
5 * @return Kod błędu
6 */
7errno_t GetGripperCurCurrent(uint16_t *fault, int8_t *current);
11.10. Pobieranie napięcia chwytaka
1/**
2 * @brief Pobiera napięcie chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] voltage Napięcie, jednostka 0.1V
5 * @return Kod błędu
6 */
7errno_t GetGripperVoltage(uint16_t *fault, int *voltage);
11.11. Pobieranie temperatury chwytaka
1/**
2 * @brief Pobiera temperaturę chwytaka
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] temp Temperatura, jednostka ℃
5 * @return Kod błędu
6 */
7errno_t GetGripperTemp(uint16_t *fault, int *temp);
11.12. Obliczanie punktu przedchwytania - wizja
1/**
2 * @brief Oblicza punkt przedchwytania - wizja
3 * @param [in] desc_pos Pozy i orientacja kartezjańska punktu chwytania
4 * @param [in] zlength Przesunięcie w osi Z
5 * @param [in] zangle Przesunięcie obrotu wokół osi Z
6 * @return Kod błędu
7 */
8errno_t ComputePrePick(DescPose *desc_pos, double zlength, double zangle, DescPose *pre_pos);
11.13. Obliczanie punktu wycofania - wizja
1/**
2 * @brief Oblicza punkt wycofania - wizja
3 * @param [in] desc_pos Pozy i orientacja kartezjańska punktu chwytania
4 * @param [in] zlength Przesunięcie w osi Z
5 * @param [in] zangle Przesunięcie obrotu wokół osi Z
6 * @return Kod błędu
7 */
8errno_t ComputePostPick(DescPose *desc_pos, double zlength, double zangle, DescPose *post_pos);
11.14. Przykład kodu operacji chwytakiem robota
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, ¤t_pos);
46 printf("fault is:%u, current position is: %u\n", fault, current_pos);
47 robot.GetGripperCurCurrent(&fault, ¤t);
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. Pobieranie liczby obrotów chwytaka obrotowego
Nowe w wersji 3.7.6.
1/**
2 * @brief Pobiera liczbę obrotów chwytaka obrotowego
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] num Liczba obrotów
5 * @return Kod błędu
6 */
7errno_t GetGripperRotNum(uint16_t* fault, double* num);
11.16. Pobieranie prędkości obrotowej chwytaka obrotowego
Nowe w wersji V3.7.6.
1/**
2 * @brief Pobiera prędkość obrotową chwytaka obrotowego
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] speed Procent prędkości obrotowej
5 * @return Kod błędu
6 */
7errno_t GetGripperRotSpeed(uint16_t* fault, int* speed);
11.17. Pobieranie momentu obrotowego chwytaka obrotowego
Nowe w wersji V3.7.6.
1/**
2 * @brief Pobiera moment obrotowy chwytaka obrotowego
3 * @param [out] fault 0-brak błędu, 1-jest błąd
4 * @param [out] torque Procent momentu obrotowego
5 * @return Kod błędu
6 */
7errno_t GetGripperRotTorque(uint16_t* fault, int* torque);
11.18. Przykład kodu pobierania stanu chwytaka obrotowego
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. Uruchamianie, zatrzymywanie przenośnika
1/**
2* @brief Uruchamia, zatrzymuje przenośnik
3* @param [in] status Stan, 1-uruchom, 0-zatrzymaj
4* @return Kod błędu
5*/
6errno_t ConveyorStartEnd(uint8_t status);
11.20. Rejestracja punktu detekcji IO
1/**
2* @brief Rejestruje punkt detekcji IO
3* @return Kod błędu
4*/
5errno_t ConveyorPointIORecord();
11.21. Rejestracja punktu A
1/**
2* @brief Rejestruje punkt A
3* @return Kod błędu
4*/
5errno_t ConveyorPointARecord();
11.22. Rejestracja punktu odniesienia
1/**
2* @brief Rejestruje punkt odniesienia
3* @return Kod błędu
4*/
5errno_t ConveyorRefPointRecord();
11.23. Rejestracja punktu B
1/**
2* @brief Rejestruje punkt B
3* @return Kod błędu
4*/
5errno_t ConveyorPointBRecord();
11.24. Detekcja IO przedmiotu na przenośniku
1/**
2* @brief Detekcja IO przedmiotu na przenośniku
3* @param [in] max_t Maksymalny czas detekcji, jednostka ms
4* @return Kod błędu
5*/
6errno_t ConveyorIODetect(int max_t);
11.25. Pobieranie bieżącej pozycji przedmiotu
1/**
2* @brief Pobiera bieżącą pozycję przedmiotu
3* @param [in] mode
4* @return Kod błędu
5*/
6errno_t ConveyorGetTrackData(int mode);
11.26. Rozpoczęcie śledzenia przenośnika
1/**
2* @brief Rozpoczęcie śledzenia przenośnika
3* @param [in] status Stan, 1-uruchom, 0-zatrzymaj
4* @return Kod błędu
5*/
6errno_t ConveyorTrackStart(uint8_t status);
11.27. Zatrzymanie śledzenia przenośnika
1/**
2* @brief Zatrzymanie śledzenia przenośnika
3* @return Kod błędu
4*/
5errno_t ConveyorTrackEnd();
11.28. Konfiguracja parametrów przenośnika
Zmienione w wersji C++SDK-v2.2.1-3.8.1.
1/**
2* @brief Konfiguruje parametry przenośnika
3* @param [in] para[0] Kanał enkodera 1~2
4* @param [in] para[1] Liczba impulsów enkodera na obrót
5* @param [in] para[2] Odległość przesunięcia przenośnika na jeden obrót enkodera
6* @param [in] para[3] Numer układu współrzędnych obiektu dla funkcji śledzenia ruchu, dla śledzenia chwytania i śledzenia TPD ustaw na 0
7* @param [in] para[4] Czy z wizją 0-bez 1-z
8* @param [in] para[5] Współczynnik prędkości dla opcji śledzenia chwytania przenośnika (1-100), dla innych opcji domyślnie 1
9* @param [in] followType Typ śledzenia ruchu, 0-śledzenie ruchu; 1-śledzenie doganiające
10* @param [in] startDis Dla śledzenia doganiającego, odległość początkowa śledzenia, -1: automatyczne obliczenie (po dojechaniu przedmiotu pod robota), jednostka mm, wartość domyślna 0
11* @param [in] endDis Dla śledzenia doganiającego, odległość końcowa śledzenia, jednostka mm, wartość domyślna 100
12* @return Kod błędu
13*/
14errno_t ConveyorSetParam(float para[6], int followType = 0, int startDis = 0, int endDis = 100);
11.29. Kompensacja punktu chwytania przenośnika
Zmienione w wersji C++SDK-v2.1.2.0.
1/**
2 * @brief Kompensacja punktu chwytania przenośnika
3 * @param [in] cmp Pozycja kompensacji double[3]{x, y, z}
4 * @return Kod błędu
5 */
6errno_t ConveyorCatchPointComp(double cmp[3]);
11.30. Ruch liniowy przenośnika
1/**
2* @brief Ruch liniowy przenośnika
3* @param [in] status Stan, 1-uruchom, 0-zatrzymaj
4* @return Kod błędu
5*/
6errno_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. Detekcja wejścia komunikacyjnego przenośnika
Nowe w wersji C++SDK-v2.2.1-3.8.1.
1/**
2* @brief Detekcja wejścia komunikacyjnego przenośnika
3* @param [in] timeout Czas oczekiwania na timeout w ms
4* @return Kod błędu
5*/
6errno_t ConveyorComDetect(int timeout);
11.32. Wyzwolenie detekcji wejścia komunikacyjnego przenośnika
Nowe w wersji C++SDK-v2.2.1-3.8.1.
1/**
2* @brief Wyzwolenie detekcji wejścia komunikacyjnego przenośnika
3* @return Kod błędu
4*/
5errno_t ConveyorComDetectTrigger();
11.33. Przykładowy program operacji przenośnikiem robota
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. Konfiguracja czujnika końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Konfiguruje czujnik końcówki
3* @param [in] idCompany Producent, 18-JUNKONG; 25-HUIDE
4* @param [in] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
5* @param [in] idSoftware Wersja oprogramowania, 0-J1.0/HuiDe1.0 (tymczasowo niedostępne)
6* @param [in] idBus Pozycja montażu, 1-port końcówki 1; 2-port końcówki 2...8-port końcówki 8 (tymczasowo niedostępne)
7* @return Kod błędu
8*/
9errno_t AxleSensorConfig(int idCompany, int idDevice, int idSoftware, int idBus);
11.35. Pobieranie konfiguracji czujnika końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2 * @brief Pobiera konfigurację czujnika końcówki
3 * @param [out] idCompany Producent, 18-JUNKONG; 25-HUIDE
4 * @param [out] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
5 * @return Kod błędu
6 */
7errno_t AxleSensorConfigGet(int& idCompany, int& idDevice);
11.36. Aktywacja czujnika końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2 * @brief Aktywuje czujnik końcówki
3 * @param [in] actFlag 0-reset; 1-aktywacja
4 * @return Kod błędu
5 */
6errno_t AxleSensorActivate(int actFlag);
11.37. Zapis do rejestru czujnika końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2 * @brief Zapis do rejestru czujnika końcówki
3 * @param [in] devAddr Numer adresu urządzenia 0-255
4 * @param [in] regHAddr Wysoki bajt adresu rejestru
5 * @param [in] regLAddr Niski bajt adresu rejestru
6 * @param [in] regNum Liczba rejestrów 0-255
7 * @param [in] data1 Wartość do zapisu w rejestrze 1
8 * @param [in] data2 Wartość do zapisu w rejestrze 2
9 * @param [in] isNoBlock 0-blokujące; 1-nieblokujące
10 * @return Kod błędu
11 */
12errno_t AxleSensorRegWrite(int devAddr, int regHAddr, int regLAddr, int regNum, int data1, int data2, int isNoBlock);
11.38. Przykład kodu czujnika końcówki
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. Pobieranie protokołu urządzeń peryferyjnych robota
Nowe w wersji C++SDK-v2.1.3.0.
1/**
2* @brief Pobiera protokół urządzeń peryferyjnych robota
3* @param [out] protocol Numer protokołu urządzeń peryferyjnych robota 4096-karta sterowania osią rozszerzoną; 4097-ModbusSlave; 4098-ModbusMaster
4* @return Kod błędu
5*/
6errno_t GetExDevProtocol(int *protocol);
11.40. Ustawianie protokołu urządzeń peryferyjnych robota
Nowe w wersji C++SDK-v2.1.3.0.
1/**
2* @brief Ustawia protokół urządzeń peryferyjnych robota
3* @param [in] protocol Numer protokołu urządzeń peryferyjnych robota 4096-karta sterowania osią rozszerzoną; 4097-ModbusSlave; 4098-ModbusMaster
4* @return Kod błędu
5*/
6errno_t SetExDevProtocol(int protocol);
11.41. Przykładowy program ustawiania protokołu urządzeń peryferyjnych robota
Nowe w wersji 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. Pobieranie parametrów komunikacji końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Pobiera parametry komunikacji końcówki
3* @param param Parametry komunikacji końcówki
4* @return Kod błędu
5*/
6errno_t GetAxleCommunicationParam(AxleComParam* param);
11.43. Ustawianie parametrów komunikacji końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Ustawia parametry komunikacji końcówki
3* @param param Parametry komunikacji końcówki
4* @return Kod błędu
5*/
6errno_t SetAxleCommunicationParam(AxleComParam param);
11.44. Ustawianie typu transferu plików na końcówce
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Ustawia typ transferu plików na końcówce
3* @param type 1-plik aktualizacyjny MCU; 2-plik LUA
4* @return Kod błędu
5*/
6errno_t SetAxleFileType(int type);
11.45. Ustawianie włączenia wykonania LUA na końcówce
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Ustawia włączenie wykonania LUA na końcówce
3* @param enable 0-nie włączaj; 1-włączaj
4* @return Kod błędu
5*/
6errno_t SetAxleLuaEnable(int enable);
11.46. Przywracanie po błędzie pliku LUA na końcówce
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Przywracanie po błędzie pliku LUA na końcówce
3* @param status 0-nie przywracaj; 1-przywróć
4* @return Kod błędu
5*/
6errno_t SetRecoverAxleLuaErr(int status);
11.47. Pobieranie stanu włączenia wykonania LUA na końcówce
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Pobiera stan włączenia wykonania LUA na końcówce
3* @param status status[0]: 0-niewłączone; 1-włączone
4* @return Kod błędu
5*/
6errno_t GetAxleLuaEnableStatus(int status[]);
11.48. Ustawianie typu włączanego urządzenia końcowego LUA na końcówce
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Ustawia typ włączanego urządzenia końcowego LUA na końcówce
3* @param forceSensorEnable Stan włączenia czujnika siły, 0-nie włączaj; 1-włączaj
4* @param gripperEnable Stan włączenia chwytaka, 0-nie włączaj; 1-włączaj
5* @param IOEnable Stan włączenia urządzenia IO, 0-nie włączaj; 1-włączaj
6* @return Kod błędu
7*/
8errno_t SetAxleLuaEnableDeviceType(int forceSensorEnable, int gripperEnable, int IOEnable);
11.49. Pobieranie typu włączanego urządzenia końcowego LUA na końcówce
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Pobiera typ włączanego urządzenia końcowego LUA na końcówce
3* @param enable enable[0]:forceSensorEnable Stan włączenia czujnika siły, 0-nie włączaj; 1-włączaj
4* @param enable enable[1]:gripperEnable Stan włączenia chwytaka, 0-nie włączaj; 1-włączaj
5* @param enable enable[2]:IOEnable Stan włączenia urządzenia IO, 0-nie włączaj; 1-włączaj
6* @return Kod błędu
7*/
8errno_t GetAxleLuaEnableDeviceType(int* forceSensorEnable, int* gripperEnable, int* IOEnable);
11.50. Pobieranie aktualnie skonfigurowanego urządzenia końcowego
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Pobiera aktualnie skonfigurowane urządzenie końcowe
3* @param forceSensorEnable Numer włączonego urządzenia czujnika siły 0-niewłączone; 1-włączone
4* @param gripperEnable Numer włączonego urządzenia chwytaka, 0-nie włączaj; 1-włączaj
5* @param IODeviceEnable Numer włączonego urządzenia IO, 0-nie włączaj; 1-włączaj
6* @return Kod błędu
7*/
8errno_t GetAxleLuaEnableDevice(int forceSensorEnable[], int gripperEnable[], int IODeviceEnable[]);
11.51. Ustawianie włączenia funkcji sterowania ruchem chwytaka
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Ustawia włączenie funkcji sterowania ruchem chwytaka
3* @param id Numer urządzenia chwytaka
4* @param func func[0]-włączenie chwytaka; func[1]-inicjalizacja chwytaka; 2-ustawienie pozycji; 3-ustawienie prędkości; 4-ustawienie momentu; 6-odczyt stanu chwytaka; 7-odczyt stanu inicjalizacji; 8-odczyt kodu błędu; 9-odczyt pozycji; 10-odczyt prędkości; 11-odczyt momentu
5* @return Kod błędu
6*/
7errno_t SetAxleLuaGripperFunc(int id, int func[]);
11.52. Pobieranie włączenia funkcji sterowania ruchem chwytaka
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Pobiera włączenie funkcji sterowania ruchem chwytaka
3* @param id Numer urządzenia chwytaka
4* @param func func[0]-włączenie chwytaka; func[1]-inicjalizacja chwytaka; 2-ustawienie pozycji; 3-ustawienie prędkości; 4-ustawienie momentu; 6-odczyt stanu chwytaka; 7-odczyt stanu inicjalizacji; 8-odczyt kodu błędu; 9-odczyt pozycji; 10-odczyt prędkości; 11-odczyt momentu
5* @return Kod błędu
6*/
7errno_t GetAxleLuaGripperFunc(int id, int func[]);
11.53. Zapis pliku stacji podrzędnej Ethercat robota
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Zapis pliku stacji podrzędnej Ethercat robota
3* @param type Typ pliku stacji podrzędnej, 1-aktualizacja pliku stacji podrzędnej; 2-aktualizacja pliku konfiguracji stacji podrzędnej
4* @param slaveID Numer stacji podrzędnej
5* @param fileName Nazwa przesyłanego pliku
6* @return Kod błędu
7*/
8errno_t SlaveFileWrite(int type, int slaveID, std::string fileName);
11.54. Przesyłanie pliku otwartego protokołu Lua końcówki
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Przesyła plik otwartego protokołu Lua końcówki
3* @param filePath Ścieżka lokalnego pliku lua ".../AXLE_LUA_End_DaHuan.lua"
4* @return Kod błędu
5*/
6errno_t AxleLuaUpload(std::string filePath);
11.55. Wejście stacji podrzędnej Ethercat robota w tryb boot
Nowe w wersji C++SDK-v2.1.5.0.
1/**
2* @brief Wejście stacji podrzędnej Ethercat robota w tryb boot
3* @return Kod błędu
4*/
5errno_t SetSysServoBootMode();
11.56. Przykład kodu operacji na pliku LUA końcówki robota
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 = 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. Pobieranie stanu przycisków SmartTool
1/**
2* @brief Pobiera stan przycisków SmartTool
3* @param [out] state Stan przycisków uchwytu SmartTool; (bit0:0-komunikacja normalna; 1-komunikacja rozłączona; bit1-cofnij operację; bit2-wyczyść program;
4bit3-przycisk A; bit4-przycisk B; bit5-przycisk C; bit6-przycisk D; bit7-przycisk E; bit8-przycisk IO; bit9-ręczny/automatyczny; bit10-start)
5* @return Kod błędu
6*/
7errno_t GetSmarttoolBtnState(int& state);
11.58. Przykład kodu dla przycisków SmartTool
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 cout << "smarttool " << std::bitset<sizeof(btn) * 8>(btn) << endl;
16
17 Sleep(100);
18 }
19}
11.59. Sterowanie macierzą przyssawek
1/**
2* @brief Steruje macierzą przyssawek
3* @param [in] slaveID Numer stacji podrzędnej
4* @param [in] len Długość
5* @param [in] ctrlValue Wartość sterująca
6* @return Kod błędu
7*/
8errno_t FRRobot::SetSuckerCtrl(uint8_t slaveID, uint8_t len, uint8_t ctrlValue[20]);
11.60. Pobieranie stanu macierzy przyssawek
1/**
2* @brief Pobiera stan macierzy przyssawek
3* @param [in] slaveID Numer stacji podrzędnej
4* @param [out] state Stan przyssania 0-zwolniony obiekt 1-wykryto przedmiot, przyssanie udane 2-brak przyssania do przedmiotu 3-przedmiot oderwany
5* @param [out] pressValue Bieżący poziom próżni, jednostka kPa
6* @param [out] error Bieżący kod błędu przyssawki
7* @return Kod błędu
8*/
9errno_t FRRobot::GetSuckerState(uint8_t slaveID, uint8_t* state, int* pressValue, int* error);
11.61. Oczekiwanie na stan przyssawki
1/**
2* @brief Oczekuje na stan przyssawki
3* @param [in] slaveID Numer stacji podrzędnej
4* @param [in] state Stan przyssania 0-zwolniony obiekt 1-wykryto przedmiot, przyssanie udane 2-brak przyssania do przedmiotu 3-przedmiot oderwany
5* @param [in] ms Maksymalny czas oczekiwania
6* @return Kod błędu
7*/
8errno_t FRRobot::WaitSuckerState(uint8_t slaveID, uint8_t state, int ms);
11.62. Przykład kodu instrukcji sterowania macierzą przyssawek
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 // Przesyłanie i ładowanie pliku otwartego protokołu
19 robot.OpenLuaUpload("E://Projekt/SDK urządzeń peryferyjnych/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 // Sterowanie przyssawką w trybie broadcast, przyssanie z maksymalną siłą
27 ctrl[0] = 1;
28 robot.SetSuckerCtrl(0, 1, ctrl);
29
30 // Cykliczne monitorowanie stanu przyssawki 1 i 12
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 // Oczekiwanie, czy przyssawka 1 jest w stanie przyssania do przedmiotu, czas oczekiwania 100 ms
41 int ret = robot.WaitSuckerState(1, 1, 100);
42 printf("WaitSuckerState result is %d\n", ret);
43
44 // Wyłączenie przyssawek 1 i 12 w trybie unicast
45 ctrl[0] = 3;
46 robot.SetSuckerCtrl(1, 1, ctrl);
47 robot.SetSuckerCtrl(12, 1, ctrl);
48
49 robot.CloseRPC();
50}
11.63. Przesyłanie pliku LUA otwartego protokołu urządzeń peryferyjnych
1/**
2 * @brief Przesyła plik Lua
3 * @param [in] filePath Ścieżka lokalnego pliku lua
4 * @return Kod błędu
5 */
6errno_t OpenLuaUpload(std::string filePath);
11.64. Pobieranie parametrów płyty stacji podrzędnej
1/**
2* @brief Pobiera parametry płyty stacji podrzędnej
3* @param [out] type 0-Ethercat, 1-CClink, 3-Ethercat, 4-EIP
4* @param [out] version Wersja protokołu
5* @param [out] connState 0-niepołączony 1-połączony
6* @return Kod błędu
7*/
8errno_t GetFieldBusConfig(uint8_t* type, uint8_t* version, uint8_t* connState);
11.65. Zapis DO stacji podrzędnej
1/**
2* @brief Zapisuje DO stacji podrzędnej
3* @param [in] DOIndex Numer DO
4* @param [in] writeNum Liczba do zapisu
5* @param [in] status[8] Wartości do zapisu, maksymalnie 8
6* @return Kod błędu
7*/
8errno_t FieldBusSlaveWriteDO(uint8_t DOIndex, uint8_t writeNum, uint8_t status[8]);
11.66. Zapis AO stacji podrzędnej
1/**
2* @brief Zapisuje AO stacji podrzędnej
3* @param [in] AOIndex Numer AO
4* @param [in] writeNum Liczba do zapisu
5* @param [in] status[8] Wartości do zapisu, maksymalnie 8
6* @return Kod błędu
7*/
8errno_t FieldBusSlaveWriteAO(uint8_t AOIndex, uint8_t writeNum, double status[8]);
11.67. Odczyt DI stacji podrzędnej
1/**
2* @brief Odczytuje DI stacji podrzędnej
3* @param [in] DOIndex Numer DI
4* @param [in] readNum Liczba do odczytu
5* @param [out] status[8] Odczytane wartości, maksymalnie 8
6* @return Kod błędu
7*/
8errno_t FieldBusSlaveReadDI(uint8_t DOIndex, uint8_t readNum, uint8_t status[8]);
11.68. Odczyt AI stacji podrzędnej
1/**
2* @brief Odczytuje AI stacji podrzędnej
3* @param [in] AOIndex Numer AI
4* @param [in] readNum Liczba do odczytu
5* @param [out] status[8] Odczytane wartości, maksymalnie 8
6* @return Kod błędu
7*/
8errno_t FieldBusSlaveReadAI(uint8_t AIIndex, uint8_t readNum, double status[8]);
11.69. Oczekiwanie na wejście rozszerzone DI
1/**
2* @brief Oczekuje na wejście rozszerzone DI
3* @param [in] DIIndex Numer DI
4* @param [in] status 0-niski poziom; 1-wysoki poziom
5* @param [in] waitMs Maksymalny czas oczekiwania (ms)
6* @return Kod błędu
7*/
8errno_t FRRobot::FieldBusSlaveWaitDI(uint8_t DIIndex, bool status, int waitMs);
11.70. Oczekiwanie na wejście rozszerzone AI
1/**
2* @brief Oczekuje na wejście rozszerzone AI
3* @param [in] AIIndex Numer AI
4* @param [in] waitType 0-większe niż; 1-mniejsze niż
5* @param [in] value Wartość AI
6* @param [in] waitMs Maksymalny czas oczekiwania (ms)
7* @return Kod błędu
8*/
9errno_t FRRobot::FieldBusSlaveWaitAI(uint8_t AIIndex, uint8_t waitType, double value, int waitMs);
11.71. Przykład kodu instrukcji interfejsu w trybie stacji podrzędnej
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 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 // Przesyłanie i ładowanie pliku otwartego protokołu
19 robot.OpenLuaUpload("E://Projekt/SDK urządzeń peryferyjnych/CtrlDev_field.lua");
20 robot.Sleep(2000);
21 robot.SetCtrlOpenLUAName(3, "CtrlDev_field.lua");
22 robot.UnloadCtrlOpenLUA(3);
23 robot.LoadCtrlOpenLUA(3);
24 robot.Sleep(8000);
25
26 // Pobranie typu protokołu, wersji oprogramowania i stanu połączenia z PLC płyty stacji podrzędnej
27 robot.GetFieldBusConfig(&type, &version, &connState);
28 printf("type is %d, version is %d,connState is %d\n", type, version, connState);
29
30 // Zapis DO0 = 1, DO1 = 0, DO2 = 1
31 ctrl[0] = 0;
32 ctrl[1] = 1;
33 ctrl[2] = 1;
34 robot.FieldBusSlaveWriteDO(0, 3, ctrl);
35
36 // Zapis AO2 = 0x1000
37 ctrlAO[0] = 0x1005;
38 robot.FieldBusSlaveWriteAO(2, 1, ctrlAO);
39
40 // Cykliczne monitorowanie DI0~DI3 AI0~AI2
41 for (int i = 0; i < 100; i++)
42 {
43 robot.FieldBusSlaveReadDI(0, 4, DI);
44 printf("DI0 is %d, DI1 is %d,DI2 is %d,DI3 is %d\n", DI[0], DI[1], DI[2], DI[3]);
45 robot.FieldBusSlaveReadAI(0, 3, AI);
46 printf("AI0 is %d, AI1 is %d,AI2 is %d\n", AI[0], AI[1], AI[2]);
47 robot.Sleep(10);
48 }
49
50 // Oczekiwanie, czy DI0 ma wartość 1, czas oczekiwania 100 ms, wydruk wyniku
51 int ret = robot.FieldBusSlaveWaitDI(0, 1, 100);
52 printf("FieldBusSlaveWaitDI result is %d\n", ret);
53
54 // Oczekiwanie, czy AI0 jest większe niż 400, czas oczekiwania 100 ms, wydruk wyniku
55 ret = robot.FieldBusSlaveWaitAI(0,0,400.00,100);
56 printf("FieldBusSlaveWaitAI result is %d\n", ret);
57
58 robot.CloseRPC();
59}
11.72. Włączanie/wyłączanie urządzenia peryferyjnego lasera
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Funkcja włączania/wyłączania urządzenia peryferyjnego lasera
3 * @param [in] OnOff 0-wyłącz 1-włącz
4 * @param [in] weldId ID spoiny, domyślnie 0
5 * @return Kod błędu
6 */
7errno_t LaserTrackingLaserOnOff(int OnOff,int weldId);
11.73. Rozpoczynanie/zatrzymywanie śledzenia laserowego
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Funkcja rozpoczynania/zatrzymywania śledzenia laserowego
3 * @param [in] OnOff 0-zatrzymaj 1-rozpocznij
4 * @param [in] coordId Numer układu współrzędnych narzędzia urządzenia peryferyjnego lasera
5 * @return Kod błędu
6 */
7errno_t LaserTrackingTrackOnOff(int OnOff, int coordId);
11.74. Rozpoczynanie lokalizacji laserowej - stały kierunek
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Lokalizacja laserowa - stały kierunek
3* @param [in] direction 0-x+ 1-x- 2-y+ 3-y- 4-z+ 5-z-
4* @param [in] vel Prędkość, jednostka %
5* @param [in] distance Maksymalna odległość lokalizacji, jednostka mm
6* @param [in] timeout Czas timeoutu lokalizacji, jednostka ms
7* @param [in] posSensorNum Numer narzędzia skalibrowanego lasera
8* @return Kod błędu
9*/
10errno_t LaserTrackingSearchStart_xyz(int direction, int vel, int distance, int timeout, int posSensorNum);
11.75. Rozpoczynanie lokalizacji laserowej - kierunek dowolnego punktu
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Lokalizacja laserowa - dowolny kierunek
3 * @param [in] directionPoint Współrzędne xyz punktu wejściowego lokalizacji
4 * @param [in] vel Prędkość, jednostka %
5 * @param [in] distance Maksymalna odległość lokalizacji, jednostka mm
6 * @param [in] timeout Czas timeoutu lokalizacji, jednostka ms
7 * @param [in] posSensorNum Numer narzędzia skalibrowanego lasera
8 * @return Kod błędu
9 */
10errno_t LaserTrackingSearchStart_point(DescTran directionPoint, int vel, int distance, int timeout, int posSensorNum);
11.76. Zakończenie lokalizacji laserowej
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Zakończenie lokalizacji laserowej
3 * @return Kod błędu
4 */
5errno_t LaserTrackingSearchStop();
11.77. Konfiguracja parametrów sieciowych lasera
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Konfiguruje parametry sieciowe lasera
3 * @param [in] ip Adres IP urządzenia peryferyjnego lasera
4 * @param [in] port Numer portu urządzenia peryferyjnego lasera
5 * @return Kod błędu
6 */
7errno_t LaserTrackingSensorConfig(std::string ip, int port);
11.78. Konfiguracja okresu próbkowania urządzenia peryferyjnego lasera
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Konfiguruje okres próbkowania urządzenia peryferyjnego lasera
3* @param [in] period Okres próbkowania urządzenia peryferyjnego lasera, jednostka ms
4* @return Kod błędu
5*/
6errno_t LaserTrackingSensorSamplePeriod(int period);
11.79. Ładowanie sterownika urządzenia peryferyjnego lasera
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Ładowanie sterownika urządzenia peryferyjnego lasera
3 * @param [in] type Typ protokołu sterownika urządzenia peryferyjnego lasera 101-Rui niu 102-Chuang xiang 103-Quan shi 104-Tong zhou 105-Ao tai
4 * @return Kod błędu
5 */
6errno_t LoadPosSensorDriver(int type);
11.80. Zwalnianie sterownika urządzenia peryferyjnego lasera
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Zwalnianie sterownika urządzenia peryferyjnego lasera
3 * @return Kod błędu
4 */
5errno_t UnLoadPosSensorDriver();
11.81. Rejestracja trajektorii spoiny laserowej
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Rejestracja trajektorii spoiny laserowej
3* @param [in] status 0-zatrzymaj rejestrację 1-śledzenie w czasie rzeczywistym 2-rozpocznij rejestrację
4* @param [in] delayTime Czas opóźnienia, jednostka ms
5* @return Kod błędu
6*/
7errno_t LaserSensorRecord1(int status, int delayTime);
11.82. Odtwarzanie trajektorii spoiny laserowej
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Odtwarzanie trajektorii spoiny laserowej
3 * @param [in] delayTime Czas opóźnienia, jednostka ms
4 * @param [in] speed Prędkość, jednostka %
5 * @return Kod błędu
6 */
7errno_t LaserSensorReplay(int delayTime, double speed);
11.83. Odtwarzanie śledzenia laserowego
Nowe w wersji C++SDK-v3.8.6.
1/**
2 * @brief Odtwarzanie śledzenia laserowego
3 * @return Kod błędu
4 */
5errno_t MoveLTR();
11.84. Rejestracja i odtwarzanie trajektorii spoiny laserowej
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Rejestracja i odtwarzanie trajektorii spoiny laserowej
3* @param [in] delayMode Tryb 0-czas opóźnienia 1-odległość opóźnienia
4* @param [in] delayTime Czas opóźnienia, jednostka ms
5* @param [in] delayDisExAxisNum Numer osi rozszerzonej dla odległości opóźnienia
6* @param [in] delayDis Odległość opóźnienia, jednostka mm
7* @param [in] sensitivePara Współczynnik czułości kompensacji
8* @param [in] trackMode Typ śledzenia punktowego. 0-ruch asynchroniczny osi rozszerzonej; 1-robot
9* @param [in] triggerMode Sposób wyzwalania śledzenia punktowego. 0-czas śledzenia; 1-IO
10* @param [in] runTime Czas śledzenia punktowego robota (s)
11* @param [in] speed Prędkość, jednostka %
12* @return Kod błędu
13*/
14errno_t LaserSensorRecordandReplay(int delayMode, int delayTime, int delayDisExAxisNum, double delayDis, double sensitivePara, int trackMode, int triggerMode, double runTime, double speed);
11.85. Ruch do punktu początkowego zarejestrowanej spoiny
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Ruch do punktu początkowego zarejestrowanej spoiny
3* @param [in] moveType 0-moveJ 1-moveL
4* @param [in] ovl Prędkość, jednostka %
5* @return Kod błędu
6*/
7errno_t MoveToLaserRecordStart(int moveType, double ovl);
11.86. Ruch do punktu końcowego zarejestrowanej spoiny
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Ruch do punktu końcowego zarejestrowanej spoiny
3* @param [in] moveType 0-moveJ 1-moveL
4* @param [in] ovl Prędkość, jednostka %
5* @return Kod błędu
6*/
7errno_t MoveToLaserRecordEnd(int moveType, double ovl);
11.87. Ruch do punktu lokalizacji czujnika laserowego
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Ruch do punktu lokalizacji czujnika laserowego
3* @param [in] moveFlag Typ ruchu: 0-PTP; 1-LIN
4* @param [in] ovl Współczynnik skalowania prędkości, 0-100
5* @param [in] dataFlag Wybór danych bufora spoiny: 0-wykonaj dane planowania; 1-wykonaj dane rejestracji
6* @param [in] plateType Typ blachy: 0-falista; 1-trapezowa; 2-ogrodzeniowa; 3-beczka po oleju; 4-falista stal pancerna
7* @param [in] trackOffectType Typ przesunięcia czujnika laserowego: 0-bez przesunięcia; 1-przesunięcie w układzie bazowym; 2-przesunięcie w układzie narzędzia; 3-przesunięcie w surowych danych lasera
8* @param [in] offset Wartość przesunięcia
9* @return Kod błędu
10*/
11errno_t MoveToLaserSeamPos(int moveFlag, double ovl, int dataFlag, int plateType, int trackOffectType, DescPose offset);
11.88. Pobieranie współrzędnych punktu lokalizacji czujnika laserowego
Nowe w wersji C++SDK-v3.8.6.
1/**
2* @brief Pobiera informacje o współrzędnych punktu lokalizacji czujnika laserowego
3* @param [in] trackOffectType Typ przesunięcia czujnika laserowego: 0-bez przesunięcia; 1-przesunięcie w układzie bazowym; 2-przesunięcie w układzie narzędzia; 3-przesunięcie w surowych danych lasera
4* @param [in] offset Wartość przesunięcia
5* @param [out] jPos Pozycja stawów [°]
6* @param [out] descPos Pozycja kartezjańska [mm]
7* @param [out] tool Układ współrzędnych narzędzia
8* @param [out] user Układ współrzędnych obiektu
9* @param [out] exaxis Pozycja osi rozszerzonej [mm]
10* @return Kod błędu
11*/
12errno_t GetLaserSeamPos(int trackOffectType, DescPose offset, JointPos& jPos, DescPose& descPos, int& tool, int& user, ExaxisPos& exaxis);
11.89. Przykład kodu konfiguracji parametrów i debugowania urządzenia peryferyjnego lasera
Nowe w wersji 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 // Ustawienie adresu IP i numeru portu
19 robot.LaserTrackingSensorConfig("192.168.58.20", 5020);
20 // Ustawienie okresu próbkowania
21 robot.LaserTrackingSensorSamplePeriod(20);
22 // Załadowanie sterownika
23 robot.LoadPosSensorDriver(101);
24 // Wyłączenie urządzenia peryferyjnego lasera
25 robot.LaserTrackingLaserOnOff(0,0);
26 robot.Sleep(3000);
27 // Włączenie urządzenia peryferyjnego lasera
28 robot.LaserTrackingLaserOnOff(1, 0);
29 robot.CloseRPC();
30}
11.90. Przykład kodu skanowania trajektorii laserowej i odtwarzania trajektorii
Nowe w wersji 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 // Przesyłanie i ładowanie pliku otwartego protokołu
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 // Ruch do punktu początkowego skanowania
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 // Rozpoczęcie rejestracji trajektorii
36 robot.LaserSensorRecord1(2, 10);
37 // Ruch do punktu końcowego rejestracji
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 // Zatrzymanie rejestracji
42 robot.LaserSensorRecord1(0, 10);
43 // Ruch do punktu początkowego zarejestrowanej spoiny
44 robot.MoveToLaserRecordStart(1, 30);
45 // Rozpoczęcie odtwarzania trajektorii
46 robot.LaserSensorReplay(10, 100);
47 robot.MoveLTR();
48 // Zatrzymanie odtwarzania trajektorii
49 robot.LaserSensorRecord1(0, 10);
50 printf("Laserowe skanowanie + test stabilności odtwarzania trajektorii, %d raz\n", cnt);
51 cnt++;
52 }
53 robot.CloseRPC();
54}
11.91. Przykład kodu lokalizacji laserowej i śledzenia w czasie rzeczywistym
Nowe w wersji 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 // Przesyłanie i ładowanie pliku otwartego protokołu
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 // Ruch do punktu początkowego lokalizacji
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;
36 robot.MoveL(&startjointPos, &startdescPose, 1, 0, 100, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
37
38 // Rozpoczęcie lokalizacji w kierunku -y
39 int ret = robot.LaserTrackingSearchStart_xyz(3, 100, 300, 1000, 2);
40 robot.LaserTrackingSearchStop();
41 // Jeśli lokalizacja się powiodła
42 if (ret == 0)
43 {
44 // Ruch do punktu lokalizacji
45 robot.MoveToLaserSeamPos(1, 30, 0, 0, 0, offdese);
46 // Rozpoczęcie śledzenia laserowego wzdłuż punktu lokalizacji
47 robot.LaserTrackingTrackOnOff(1, 2);
48 JointPos endjointPos(70.580, -90.918, 126.593, -125.154, -92.162, -105.403);
49 DescPose enddescPose(-53.375, -419.020, 0.920, 178.054, 1.076, -94.026);
50 robot.MoveL(&endjointPos, &enddescPose, 1, 0, 20, 100, 100, -1, &exaxisPos, 0, 0, &offdese, 1, 1);
51 // Zatrzymanie śledzenia
52 robot.LaserTrackingTrackOnOff(0, 2);
53
54 }
55 cnt++;
56 }
57 robot.CloseRPC();
58}
11.92. Przykład kodu synchronizacji śledzenia laserowego z osią rozszerzoną i robotem
Nowe w wersji 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 // Ruch do punktu początkowego lokalizacji
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 // Rozpoczęcie lokalizacji w kierunku -y
36 int ret = robot.LaserTrackingSearchStart_xyz(3, 100, 300, 1000, 2);
37 robot.LaserTrackingSearchStop();
38 int tool = 0;
39 int user = 0;
40 robot.GetLaserSeamPos(0, offdese, seamjointPos, seamdescPose, tool, user, startexaxisPos);
41 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);
42
43 // Jeśli lokalizacja się powiodła
44 if (ret == 0)
45 {
46 // Synchroniczny ruch robota i osi rozszerzonej do punktu lokalizacji
47 robot.ExtAxisSyncMoveJ(seamjointPos, seamdescPose, 1, 0, 100, 100, 100, seamexaxisPos, -1, 0, offdese);
48
49 // Rozpoczęcie śledzenia laserowego wzdłuż punktu lokalizacji z synchronizacją ruchu osi rozszerzonej
50 robot.LaserTrackingTrackOnOff(1, 2);
51 JointPos endjointPos(70.580, -90.918, 126.593, -125.154, -92.162, -105.403);
52 DescPose enddescPose(-53.375, -419.020, 0.920, 178.054, 1.076, -94.026);
53 robot.ExtAxisSyncMoveL(endjointPos, enddescPose, 1, 0, 20, 100, 100, -1, endexaxisPos, 0, offdese);;
54 // Zatrzymanie śledzenia
55 robot.LaserTrackingTrackOnOff(0, 2);
56 }
57 cnt++;
58 printf("Synchronizacja śledzenia laserowego z osią rozszerzoną i robotem, %d raz\n", cnt);
59 }
60 robot.CloseRPC();
61}
11.93. Włączanie/wyłączanie funkcji transmisji przez końcówkę
1/**
2* @brief Włączanie/wyłączanie funkcji transmisji przez końcówkę
3* @param [in] mode 0-wyłącz, 1-włącz
4* @return Kod błędu
5*/
6errno_t SetAxleGenComEnable(int mode);
11.94. Wysyłanie i odbieranie danych nieokresowych w funkcji transmisji przez końcówkę
1/**
2* @brief Wysyłanie i odbieranie danych nieokresowych w funkcji transmisji przez końcówkę
3* @param [in] lenSnd Długość wysyłanych danych
4* @param [in] sndBuff Dane do wysłania
5* @param [in] lenRcv Wybór długości odbieranych danych
6* @param [out] rcvBuff Odebrane dane odpowiedzi
7* @return Kod błędu
8*/
9errno_t SndRcvAxleGenComCmdData(int lenSnd, int sndBuff[130], int lenRcv, int rcvData[130]);
11.95. Przykład kodu komunikacji danych nieokresowych dla głowicy terapeutycznej Beiyikang opartej na funkcji transmisji przez końcówkę
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 // Włączenie funkcji transmisji przez końcówkę
28 robot.SetAxleGenComEnable(1);
29 robot.SetAxleLuaEnable(1);
30 while (cnt <= 10000)
31 {
32 // Odczytanie numeru wersji
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 // Odczytanie stanu obecności głowicy terapeutycznej
41 ret = robot.SndRcvAxleGenComCmdData(6, state, 6, rcvdata);
42 printf(" state : %d \n", rcvdata[4]);
43 robot.Sleep(1000);
44 // Włączenie lasera głowicy terapeutycznej
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 // Wyłączenie lasera głowicy terapeutycznej
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. Pobieranie pliku Lua otwartego protokołu
1/**
2* @brief Pobiera plik Lua otwartego protokołu
3* @param [in] fileName Nazwa pliku otwartego protokołu "CtrlDev_XXX.lua"
4* @param [in] savePath Ścieżka zapisu pliku otwartego protokołu
5* @return Kod błędu
6*/
7errno_t OpenLuaDownload(std::string fileName, std::string savePath);
11.97. Usuwanie pliku Lua otwartego protokołu
1/**
2* @brief Usuwa plik Lua otwartego protokołu
3* @param [in] fileName Nazwa pliku otwartego protokołu Lua do usunięcia "CtrlDev_XXX.lua"
4* @return Kod błędu
5*/
6errno_t OpenLuaDelete(std::string fileName);
11.98. Usuwanie wszystkich plików Lua otwartego protokołu
1/**
2* @brief Usuwa wszystkie pliki Lua otwartego protokołu
3* @return Kod błędu
4*/
5errno_t AllOpenLuaDelete();
11.99. Przykład kodu przesyłania, pobierania i usuwania otwartego protokołu urządzeń peryferyjnych sterownika
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}