8. Zapytanie o stan robota

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

1/**
2* @brief  Pobieranie bieżącej pozycji przegubów (kąt)
3* @param  [out] jPos Pobrane pozycje sześciu przegubów, jednostka deg
4* @return  Kod błędu
5*/
6int GetActualJointPosDegree(JointPos jPos);

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

1/**
2* @brief Pobieranie prędkości sprzężenia zwrotnego przegubów - deg/s
3* @param [out] speed Prędkości sześciu przegubów
4* @return Kod błędu
5*/
6int GetActualJointSpeedsDegree(Object[] speed);

8.3. Pobieranie przyspieszenia sprzężenia zwrotnego przegubów

1/**
2* @brief  Pobieranie przyspieszenia sprzężenia zwrotnego przegubów - deg/s^2
3* @param  [in] flag 0-blokujący, 1-nieblokujący
4* @param  [out] acc Przyspieszenia sześciu przegubów
5* @return  Kod błędu
6*/
7public int GetActualJointAccDegree(int flag, Object[] acc)

8.4. Pobieranie prędkości wypadkowej zadanej TCP

1/**
2* @brief  Pobieranie prędkości zadanej TCP
3* @param  [in] flag 0-blokujący, 1-nieblokujący
4* @param  [out] tcp_speed Prędkość liniowa
5* @param  [out] ori_speed Prędkość pozy
6* @return  Kod błędu
7*/
8public int GetTargetTCPCompositeSpeed(int flag, double tcp_speed, double ori_speed)

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

1/**
2* @brief  Pobieranie prędkości wypadkowej sprzężenia zwrotnego TCP
3* @param  [in] flag 0-blokujący, 1-nieblokujący
4* @param  [out] tcp_speed Prędkość liniowa
5* @param  [out] ori_speed Prędkość pozy
6* @return  Kod błędu
7*/
8public int GetActualTCPCompositeSpeed(int flag, double tcp_speed, double ori_speed)

8.6. Pobieranie prędkości zadanej TCP

1/**
2* @brief  Pobieranie prędkości zadanej TCP
3* @param  [in] flag 0-blokujący, 1-nieblokujący
4* @param  [out] speed Prędkości [x,y,z,rx,ry,rz]
5* @return  Kod błędu
6*/
7public int GetTargetTCPSpeed(int flag, Object[] speed)

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

1/**
2* @brief  Pobieranie prędkości sprzężenia zwrotnego TCP
3* @param  [in] flag 0-blokujący, 1-nieblokujący
4* @param  [out] speed Prędkości [x,y,z,rx,ry,rz]
5* @return  Kod błędu
6*/
7public int GetActualTCPSpeed(int flag, Object[] speed)

8.8. Pobieranie bieżącej pozy narzędzia

1/**
2* @brief  Pobieranie bieżącej pozy narzędzia
3* @param  [out] desc_pos  Pozycja narzędzia
4* @return  Kod błędu
5*/
6int GetActualTCPPose(DescPose desc_pos);

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

1/**
2* @brief  Pobieranie bieżącego numeru układu narzędzia
3* @param  [in] flag  0-blokujący, 1-nieblokujący
4* @param  [out] id  Numer układu narzędzia
5* @return  Kod błędu
6*/
7int GetActualTCPNum(int flag, int[] id)

8.10. Pobieranie bieżącego numeru układu przedmiotu

1/**
2* @brief  Pobieranie bieżącego numeru układu przedmiotu
3* @param  [in] flag  0-blokujący, 1-nieblokujący
4* @param  [out] id  Numer układu przedmiotu
5* @return  Kod błędu
6*/
7public int GetActualWObjNum(int flag, int[] id)

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

1/**
2* @brief  Pobieranie bieżącej pozy kołnierza końcowego
3* @param  [in] flag  0-blokujący, 1-nieblokujący
4* @param  [out] desc_pos  Pozycja kołnierza
5* @return  Kod błędu
6*/
7public int GetActualToolFlangePose(int flag, DescPose desc_pos)

8.12. Pobieranie bieżącego momentu obrotowego przegubów

1/**
2* @brief Pobieranie bieżącego momentu obrotowego przegubów
3* @param  [in]  flag 0-blokujący, 1-nieblokujący
4* @param  [out]  torques Moment obrotowy przegubów
5* @return  Kod błędu
6*/
7int GetJointTorques(int flag, Object[] torques);

8.13. Pobieranie czasu systemowego

1/**
2* @brief  Pobieranie czasu systemowego
3* @return  List[0]:int Kod błędu; List[1]:double t_ms jednostka ms
4*/
5List<Number> GetSystemClock();

8.14. Synchronizacja Czasu Systemowego z Robotem

1/**
2* @brief Pobiera bieżący czas systemowy komputera hosta i wysyła go do robota w celu synchronizacji czasu systemowego (ze względu na ograniczenia systemu QNX, dokładność synchronizacji jest na poziomie minut)
3* @return Kod błędu
4*/
5public int SetRobottime()

8.15. Przykład Kodu Synchronizacji Czasu Systemowego z Robotem

 1public static void testSetAndGetRobotTime(Robot robot)
 2{
 3    // 1. Pobranie czasu przed ustawieniem
 4    List<Number> resultBefore = robot.GetSystemClock();
 5    int retBefore = (int) resultBefore.get(0);
 6
 7    if (retBefore == 0) {
 8        double t_ms = (double) resultBefore.get(1);
 9        System.out.println("system clock : " + t_ms);
10
11        // Konwersja znacznika czasu w milisekundach na DateTime (czas UTC)
12        java.time.Instant instant = java.time.Instant.ofEpochMilli((long) t_ms);
13        java.time.LocalDateTime utcTime = java.time.LocalDateTime.ofInstant(instant, java.time.ZoneOffset.UTC);
14        System.out.println("BEFORE UTC Time   : " +
15            utcTime.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
16    } else {
17        System.out.println("GetSystemClock failed, ret:" + retBefore);
18    }
19
20    // 2. Ustawienie czasu robota
21    int retSet = robot.SetRobotTime();
22    if (retSet != 0) {
23        System.out.println("SetRobotTime failed, ret:" + retSet);
24        return;
25    }
26
27    // 3. Pobranie czasu po ustawieniu
28    List<Number> resultAfter = robot.GetSystemClock();
29    int retAfter = (int) resultAfter.get(0);
30
31    if (retAfter == 0) {
32        double t_ms_after = (double) resultAfter.get(1);
33        System.out.println("system clock after: " + t_ms_after);
34
35        // Konwersja do czasu UTC
36        java.time.Instant instantAfter = java.time.Instant.ofEpochMilli((long) t_ms_after);
37        java.time.LocalDateTime robotTimeAfter = java.time.LocalDateTime.ofInstant(instantAfter, java.time.ZoneOffset.UTC);
38
39        // Pobranie bieżącego czasu PC (jako wartość oczekiwana)
40        java.time.LocalDateTime pcTimeBefore = java.time.LocalDateTime.now(java.time.ZoneOffset.UTC);
41
42        // Obcięcie do poziomu minut w celu porównania (ze względu na ograniczenia systemu QNX, dokładność synchronizacji jest na poziomie minut)
43        java.time.LocalDateTime pcMinute = pcTimeBefore.withSecond(0).withNano(0);
44        java.time.LocalDateTime robotMinute = robotTimeAfter.withSecond(0).withNano(0);
45
46        // Porównanie spójności
47        boolean isConsistent = pcMinute.equals(robotMinute);
48        if (isConsistent) {
49            System.out.println("Consistent     | PC time: " +
50                pcMinute.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")) +
51                "  | Robot time: " +
52                robotMinute.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")));
53        } else {
54            System.out.println("[Inconsistent | PC time: " +
55                pcMinute.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")) +
56                "  | Robot time: " +
57                robotMinute.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")));
58        }
59    } else {
60        System.out.println("GetSystemClock failed, ret:" + retAfter);
61    }
62}

8.16. Sprawdzanie, czy ruch robota został zakończony

1/**
2* @brief  Sprawdzanie, czy ruch robota został zakończony
3* @param   [out] state  0-niezakończony, 1-zakończony
4* @return  Kod błędu
5*/
6public int GetRobotMotionDone(int[] state)

8.17. Sprawdzanie długości bufora kolejki ruchu robota

1/**
2* @brief  Sprawdzanie długości bufora kolejki ruchu robota
3* @param   [out] len  Długość bufora
4* @return  Kod błędu
5*/
6public int GetMotionQueueLength(int[] len)

8.18. Pobieranie stanu zatrzymania awaryjnego robota

1/**
2* @brief Pobieranie stanu zatrzymania awaryjnego robota
3* @param [out] state Stan zatrzymania awaryjnego, 0-brak zatrzymania awaryjnego, 1-zatrzymanie awaryjne
4* @return Kod błędu
5*/
6public int GetRobotEmergencyStopState(int[] state)

8.19. Pobieranie stanu komunikacji SDK z robotem

1/**
2* @brief Pobieranie stanu komunikacji SDK z robotem
3* @return state Stan komunikacji, 0-komunikacja normalna, 1-komunikacja nieprawidłowa
4*/
5public int GetSDKComState()

8.20. Pobieranie sygnału bezpiecznego zatrzymania

1/**
2* @brief Pobieranie sygnału bezpiecznego zatrzymania
3* @param  [out] si0_state Sygnał bezpiecznego zatrzymania SI0, 0-nieaktywny, 1-aktywny
4* @param  [out] si1_state Sygnał bezpiecznego zatrzymania SI1, 0-nieaktywny, 1-aktywny
5* @return Kod błędu
6*/
7public int GetSafetyStopState(int[] si0_state, int[] si1_state)

8.21. Pobieranie temperatury sterownika przegubu robota (℃)

1/**
2* @brief Pobieranie temperatury sterownika przegubu robota (℃)
3* @param  [out] temperature Temperatura
4* @return Kod błędu
5*/
6public int GetJointDriverTemperature(double[] temperature)

8.22. Pobieranie momentu obrotowego sterownika przegubu robota (Nm)

1/**
2* @brief Pobieranie momentu obrotowego sterownika przegubu robota (Nm)
3* @param  [out] torque Moment obrotowy
4* @return Kod błędu
5*/
6public int GetJointDriverTorque(double[] torque)

8.23. Pobieranie struktury stanu robota w czasie rzeczywistym

1/**
2* @brief Pobieranie struktury stanu robota w czasie rzeczywistym
3* @return Struktura stanu w czasie rzeczywistym
4*/
5public ROBOT_STATE_PKG GetRobotRealTimeState()

8.24. Przykład kodu zapytania o stan robota

 1public static int TestGetStatus(Robot robot)
 2{
 3    List<Number> angle=new ArrayList<>();
 4    angle=robot.GetRobotInstallAngle();
 5    System.out.println("yangle:"+angle.get(1)+",zangle:"+angle.get(2));
 6
 7    JointPos j_deg =new JointPos(){};
 8    robot.GetActualJointPosDegree( j_deg);
 9
10    Object[] jointSpeed =new Object[] { 0,0,0,0,0,0 };
11    robot.GetActualJointSpeedsDegree(jointSpeed);
12
13    Object[] jointAcc = new Object[]{0,0,0,0,0,0 };
14    robot.GetActualJointAccDegree(0, jointAcc);
15
16    double tcp_speed = 0.0;
17    double ori_speed = 0.0;
18    robot.GetTargetTCPCompositeSpeed(0, tcp_speed, ori_speed);
19
20    robot.GetActualTCPCompositeSpeed(0, tcp_speed, ori_speed);
21
22    Object[] targetSpeed =new Object[] { 0,0,0,0,0,0 };
23    robot.GetTargetTCPSpeed(0, targetSpeed);
24
25    Object[] actualSpeed =new Object[] {0,0,0,0,0,0 };
26    robot.GetActualTCPSpeed(0, actualSpeed);
27
28    DescPose tcp = new DescPose(){};
29    robot.GetActualTCPPose(tcp);
30
31    DescPose flange = new DescPose(){};
32    robot.GetActualToolFlangePose(0, flange);
33
34    int[] id = {};
35    robot.GetActualTCPNum(0, id);
36
37    robot.GetActualWObjNum(0, id);
38
39    List<Number> jtorque=new ArrayList<>();
40    jtorque=robot.GetJointTorques(0);
41
42    List<Number> t_ms = new ArrayList<>();
43    t_ms=robot.GetSystemClock();
44
45    List<Integer> config = new ArrayList<>();
46    config=robot.GetRobotCurJointsConfig();
47
48    int motionDone = 0;
49    robot.GetRobotMotionDone(motionDone);
50
51    int[] len ={0 };
52    robot.GetMotionQueueLength(len);
53
54    int[] emergState = {0};
55    robot.GetRobotEmergencyStopState(emergState);
56
57    int comstate = 0;
58    comstate=robot.GetSDKComState();
59
60    int[] si0_state=new int[]{0}, si1_state=new int[]{0};
61    robot.GetSafetyStopState(si0_state, si1_state);
62
63    double[] temp =new double[] { 0,0,0,0,0,0 };
64    robot.GetJointDriverTemperature(temp);
65
66    double[] torque = new double[]{ 0,0,0,0,0,0 };
67    robot.GetJointDriverTorque(torque);
68
69    ROBOT_STATE_PKG pkg=new ROBOT_STATE_PKG();
70    pkg=robot.GetRobotRealTimeState();
71
72    return 0;
73}

8.25. Rozwiązanie kinematyki odwrotnej

1/**
2* @brief  Rozwiązanie kinematyki odwrotnej
3* @param  [in] type 0-pozycja absolutna (układ bazowy), 1-pozycja przyrostowa (układ bazowy), 2-pozycja przyrostowa (układ narzędzia)
4* @param  [in] desc_pos Pozycja kartezjańska
5* @param  [in] config Konfiguracja przestrzeni przegubów, [-1]-obliczenia względem bieżącej pozycji przegubów, [0~7]-obliczenia według określonej konfiguracji przestrzeni przegubów
6* @param  [out] joint_pos Pozycja przegubów
7* @return  Kod błędu
8*/
9int GetInverseKin(int type, DescPose desc_pos, int config, JointPos joint_pos);

8.26. Rozwiązanie kinematyki odwrotnej (z pozycją referencyjną)

1/**
2* @brief  Rozwiązanie kinematyki odwrotnej, obliczenia względem podanej pozycji referencyjnej przegubów
3* @param  [in] posMode 0-pozycja absolutna, 1-pozycja względna - układ bazowy, 2-pozycja względna - układ narzędzia
4* @param  [in] desc_pos Pozycja kartezjańska
5* @param  [in] joint_pos_ref Referencyjna pozycja przegubów
6* @param  [out] joint_pos Pozycja przegubów
7* @return  Kod błędu
8*/
9int GetInverseKinRef(int posMode, DescPose desc_pos, JointPos joint_pos_ref, JointPos joint_pos);

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

 1/**
 2* @brief Rozwiązanie kinematyki odwrotnej, przestrzeń kartezjańska z uwzględnieniem pozycji osi rozszerzenia
 3* @param  type 0-pozycja absolutna (układ bazowy), 1-pozycja przyrostowa (układ bazowy), 2-pozycja przyrostowa (układ narzędzia)
 4* @param  desc_pos Pozycja kartezjańska
 5* @param  exaxis Pozycja osi rozszerzenia
 6* @param  tool Numer narzędzia
 7* @param  workPiece Numer przedmiotu
 8* @param  joint_pos Pozycja przegubów
 9* @param  config -1: automatyczne rozwiązanie, 0-7 odpowiada ośmiu zestawom rozwiązań
10* @return Kod błędu
11*/
12public int GetInverseKinExaxis(int type, DescPose desc_pos, ExaxisPos exaxis, int tool, int workPiece, JointPos joint_pos, int config)

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

 1public static void  TestInverseKinExaxis(Robot robot)
 2{
 3    DescPose desc=new DescPose(99.957, -0.002, 29.994, -176.569, -6.757, -167.462);
 4    ExaxisPos exaxis=new ExaxisPos(100.0, 0.0, 0.0, 0.0);
 5    JointPos jointPos =new JointPos();
 6    DescPose offsetPos =new DescPose();
 7
 8    ROBOT_STATE_PKG pkg=robot.GetRobotRealTimeState();
 9    int toolnum = pkg.tool;
10    int workPcsNum = pkg.user;
11    robot.GetInverseKinExaxis(0, desc, exaxis, toolnum, workPcsNum, jointPos, 0);
12    System.out.printf("GetInverseKinExaxis joint is %f, %f, %f, %f, %f, %f\n", jointPos.J1, jointPos.J2, jointPos.J3, jointPos.J4, jointPos.J5, jointPos.J6);
13
14    robot.ExtAxisMove(exaxis, 100, -1);
15    robot.MoveJ(jointPos, desc, toolnum, workPcsNum, 100.0, 100.0, 100.0, exaxis, -1, 0, offsetPos);
16
17}

8.29. Sprawdzanie, czy kinematyka odwrotna ma rozwiązanie

1/**
2* @brief  Sprawdzanie, czy kinematyka odwrotna ma rozwiązanie, odniesienie do podanej pozycji referencyjnej przegubów
3* @param  [in] posMode 0-pozycja absolutna, 1-pozycja względna - układ bazowy, 2-pozycja względna - układ narzędzia
4* @param  [in] desc_pos Pozycja kartezjańska
5* @param  [in] joint_pos_ref Referencyjna pozycja przegubów
6* @return  Kod błędu  List[0]:Kod błędu; List[1]: int hasResult 0-brak rozwiązania, 1-jest rozwiązanie
7*/
8List<Integer> GetInverseKinHasSolution(int posMode, DescPose desc_pos, JointPos joint_pos_ref);

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

 1/**
 2 * @brief  Pobierz 8 zestawów rozwiązań odwrotnych
 3 * @param [in] tcp_pose Pozycja kartezjańska
 4 * @param [in] tool Układ współrzędnych narzędzia
 5 * @param [in] workpiece Układ współrzędnych przedmiotu obrabianego
 6 * @param [in] exPos Pozycja osi rozszerzonej
 7 * @param [out] jPos Wyjście 8 zestawów kątów przegubów
 8 * @return Kod błędu
 9 */
10public int TCFToAllJoint(DescPose tcp_pose, int tool, int workpiece, ExaxisPos exPos, JointPos[] jPos)

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

 1public static int TestTCFToAllJoint(Robot robot)
 2{
 3    DescPose curTcp = new DescPose(0, 0, 0, 0, 0, 0);
 4    int rtn = robot.GetActualTCPPose(curTcp);
 5    if (rtn != 0)
 6    {
 7        return rtn;
 8    }
 9    ExaxisPos exPos = new ExaxisPos(0, 0, 0, 0);
10
11    JointPos[] allJoints = new JointPos[8];
12
13    rtn = robot.TCFToAllJoint(curTcp, 0, 0, exPos, allJoints);
14    if (rtn != 0)
15    {
16        return rtn;
17    }
18
19    for (int i = 0; i < 8; i++)
20    {
21        JointPos joint = allJoints[i];
22
23        System.out.printf("JOINT%d: j1=%.3f, j2=%.3f, j3=%.3f, j4=%.3f, j5=%.3f, j6=%.3f\n",
24                i + 1, joint.J1, joint.J2, joint.J3, joint.J4, joint.J5, joint.J6);
25
26        DescPose pos = new DescPose(0, 0, 0, 0, 0, 0);
27        rtn = robot.GetForwardKin(joint, pos);
28        if (rtn != 0)
29        {
30            continue;
31        }
32
33        System.out.printf("POS%d: x=%.3f, y=%.3f, z=%.3f, a=%.3f, b=%.3f, c=%.3f\n",
34                i + 1, pos.tran.x, pos.tran.y, pos.tran.z,
35                pos.rpy.rx, pos.rpy.ry, pos.rpy.rz);
36    }
37
38    return 0;
39}

8.32. Rozwiązanie kinematyki prostej

1/**
2* @brief  Rozwiązanie kinematyki prostej
3* @param  [in] joint_pos Pozycja przegubów
4* @param  [out] desc_pos Pozycja kartezjańska
5* @return  Kod błędu
6*/
7int GetForwardKin(JointPos joint_pos, DescPose desc_pos);

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

 1public static int TestInverseKin(Robot robot)
 2{
 3    JointPos j1=new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 4    DescPose desc_pos1=new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 5
 6    JointPos inverseRtn = new JointPos(){};
 7
 8    robot.GetInverseKin(0, desc_pos1, -1, inverseRtn);
 9    robot.GetInverseKinRef(0, desc_pos1, j1, inverseRtn);
10
11    int hasResut = 0;
12    robot.GetInverseKinHasSolution(0, desc_pos1, j1);
13
14    DescPose forwordResult = new DescPose(){};
15    robot.GetForwardKin(j1, forwordResult);
16
17    return 0;
18}

8.34. Zapytanie o dane punktu zarządzania nauczaniem robota

1/**
2* @brief Zapytanie o dane punktu zarządzania nauczaniem robota
3* @param [in]  name  Nazwa punktu
4* @return  List[0]:Kod błędu; List[1] - List[20] : Dane punktu double[20]{x,y,z,rx,ry,rz,j1,j2,j3,j4,j5,j6,tool,wobj,speed,acc,e1,e2,e3,e4}
5*/
6List<Number> GetRobotTeachingPoint(String name);

8.35. Pobieranie wartości kompensacji parametrów DH robota

1/**
2* @brief Pobieranie wartości kompensacji parametrów DH robota
3* @param dhCompensation Wartości kompensacji parametrów DH robota (mm) [cmpstD1,cmpstA2,cmpstA3,cmpstD4,cmpstD5,cmpstD6]
4* @return Kod błędu
5*/
6public int GetDHCompensation(Object[] dhCompensation)

8.36. Pobieranie numeru SN skrzynki kontrolnej

Dodane w wersji Java: SDK-v1.0.4-3.8.1

1/**
2* @brief Pobieranie numeru SN skrzynki kontrolnej
3* @param [out] SNCode Numer SN skrzynki kontrolnej
4* @return Kod błędu
5*/
6int GetRobotSN(String[] SNCode);

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

 1public static int TestGetTeachPoint(Robot robot)
 2{
 3    String name = "P1";
 4    List<Number> data=new ArrayList<>();
 5    data = robot.GetRobotTeachingPoint(name);
 6    System.out.println(name+" name is: "+data.get(0));
 7    for (int i = 0; i < 20; i++)
 8    {
 9        System.out.println("data is: "+ data.get(i+1));
10    }
11
12    int[] que_len = {0};
13    int rtn = robot.GetMotionQueueLength(que_len);
14    System.out.println("GetMotionQueueLength rtn is:"+rtn+", queue length is:"+ que_len[0]);
15
16    Object[] dh = new Object[]{ 0,0,0,0,0,0 };
17    int retval = 0;
18    retval = robot.GetDHCompensation(dh);
19    System.out.println("retval is: "+retval);
20
21    String[] SN = new String[]{""};
22    robot.GetRobotSN(SN);
23    System.out.println("robot SN is "+SN[0]);
24    return 0;
25}

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

Zmienione w wersji Java: SDK-V3.9.8

 1/**
 2* @brief Pobiera układ współrzędnych narzędzia według ID
 3* @param [in] id Numer układu współrzędnych narzędzia
 4* @param [out] coord Wartości układu współrzędnych
 5* @param [out] type Typ narzędzia: 0-narzędzie; 1-czujnik
 6* @param [out] install Pozycja instalacji: 0-koniec robota; 1-na zewnątrz robota
 7* @param [out] toolID ID narzędzia
 8* @param [out] loadNo Numer obciążenia
 9* @return Kod błędu
10*/
11int GetToolCoordWithID(int id, DescPose coord, int[] type, int[] install, int[] toolID, int[] loadNo)

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

Zmienione w wersji Java: SDK-V3.9.8

1/**
2* @brief Pobiera układ współrzędnych przedmiotu według ID
3* @param [in] id Numer układu współrzędnych przedmiotu
4* @param [out] coord Wartości układu współrzędnych
5* @param [out] refFrame Referencyjny układ współrzędnych
6* @return Kod błędu
7*/
8public int GetWObjCoordWithID(int id, DescPose coord, int[] refFrame)

8.40. Pobieranie Zewnętrznego Układu Współrzędnych Narzędzia według ID

Zmienione w wersji Java: SDK-V3.9.8

1/**
2* @brief Pobiera zewnętrzny układ współrzędnych narzędzia według ID
3* @param [in] id Numer zewnętrznego układu współrzędnych narzędzia, 20-39 odpowiadają zewnętrznym układom współrzędnych narzędzi 0-19
4* @param [out] coord Pozycja TCP stałego narzędzia zewnętrznego na robocie
5* @param [out] tcoord Pozycja układu współrzędnych przedmiotu zamontowanego na końcówce robota
6* @return Kod błędu
7*/
8public int GetExToolCoordWithID(int id, DescPose coord, DescPose tcoord)

8.41. Pobieranie Układu Współrzędnych Osi Rozszerzonej według ID

Zmienione w wersji Java: SDK-V3.9.8

1/**
2* @brief Pobiera układ współrzędnych osi rozszerzonej według ID
3* @param [in] id Numer zewnętrznego układu współrzędnych narzędzia
4* @param [out] coord Wartości układu współrzędnych
5* @param [out] axisCoordNum Numer osi rozszerzonej; bit0-bit3 odpowiadają osiom rozszerzonym 1-4; np. wartość axisCoordNum 3 odpowiada osiom rozszerzonym [1, 2]
6* @param [out] calibFlag Flaga kalibracji; 0-niekalibrowany; 1-kalibrowany
7* @return Kod błędu
8*/
9public int GetExAxisCoordWithID (int id, DescPose coord, int[] axisCoordNum, int[] calibFlag)

8.42. Pobieranie bieżącego układu narzędzia

Dodane w wersji Java: SDK-v1.0.9-3.8.6

1/**
2 * @brief Pobieranie bieżącego układu narzędzia
3 * @param [out] coord Wartości układu współrzędnych
4 * @return Kod błędu
5 */
6public int GetCurToolCoord(DescPose coord)

8.43. Pobieranie bieżącego układu przedmiotu

Dodane w wersji Java: SDK-v1.0.9-3.8.6

1/**
2 * @brief Pobieranie bieżącego układu przedmiotu
3 * @param [out] coord Wartości układu współrzędnych
4 * @return Kod błędu
5 */
6public int GetCurWObjCoord(DescPose coord)

8.44. Pobieranie bieżącego zewnętrznego układu narzędzia

Dodane w wersji Java: SDK-v1.0.9-3.8.6

1/**
2 * @brief Pobieranie bieżącego zewnętrznego układu narzędzia
3 * @param  [out] coord Wartości układu współrzędnych
4 * @return Kod błędu
5 */
6public int GetCurExToolCoord(DescPose coord)

8.45. Pobieranie bieżącego układu osi rozszerzenia

Dodane w wersji Java: SDK-v1.0.9-3.8.6

1/**
2 * @brief Pobieranie bieżącego układu osi rozszerzenia
3 * @param [out] coord Wartości układu współrzędnych
4 * @return Kod błędu
5 */
6public int GetCurExAxisCoord(DescPose coord)

8.46. Przykład kodu układów współrzędnych robota i obciążenia

 1public static int TestCoord(Robot robot)
 2{
 3    int id = 1;
 4    DescPose toolCoord = new DescPose();
 5    DescPose extoolCoord = new DescPose();
 6    DescPose exworkpieceCoord = new DescPose();
 7    DescPose wobjCoord = new DescPose();
 8    DescPose exAxisCoord = new DescPose();
 9    int[] type = new int[1];
10    int[] install = new int[1];
11    int[] toolID = new int[1];
12    int[] loadNo = new int[1];
13    robot.GetToolCoordWithID(id, toolCoord, type, install, toolID, loadNo);
14    System.out.printf("GetToolCoordWithID %d, %f %f %f %f %f %f,  type = %d, install = %d, toolID = %d, loadNo = %d\n", id,
15        toolCoord.tran.x, toolCoord.tran.y, toolCoord.tran.z,
16        toolCoord.rpy.rx, toolCoord.rpy.ry, toolCoord.rpy.rz, type[0], install[0], toolID[0], loadNo[0]);
17    int[] refFrame = new int[1];
18    robot.GetWObjCoordWithID(id, wobjCoord, refFrame);
19    System.out.printf("GetWObjCoordWithID %d, %f %f %f %f %f %f, refFrame = %d\n", id,
20        wobjCoord.tran.x, wobjCoord.tran.y, wobjCoord.tran.z,
21        wobjCoord.rpy.rx, wobjCoord.rpy.ry, wobjCoord.rpy.rz, refFrame[0]);
22
23
24    robot.GetExToolCoordWithID(21, extoolCoord, exworkpieceCoord);
25    System.out.printf("GetExToolCoordWithID %d, %f %f %f %f %f %f\n", id,
26        extoolCoord.tran.x, extoolCoord.tran.y, extoolCoord.tran.z,
27        extoolCoord.rpy.rx, extoolCoord.rpy.ry, extoolCoord.rpy.rz,
28        exworkpieceCoord.tran.x, exworkpieceCoord.tran.y, exworkpieceCoord.tran.z,
29        exworkpieceCoord.rpy.rx, exworkpieceCoord.rpy.ry, exworkpieceCoord.rpy.rz);
30
31    int[] axisCoordNum = new int[1];
32    int[] calibFlag = new int[1];
33    robot.GetExAxisCoordWithID(id, exAxisCoord, axisCoordNum, calibFlag);
34    System.out.printf("GetExAxisCoordWithID %d, %f %f %f %f %f %f, axisCoordNum = %d, calibFlag = %d\n", id,
35        exAxisCoord.tran.x, exAxisCoord.tran.y, exAxisCoord.tran.z,
36        exAxisCoord.rpy.rx, exAxisCoord.rpy.ry, exAxisCoord.rpy.rz, axisCoordNum[0], calibFlag[0]);
37
38    double[] weight = new double[1];
39    DescTran cog = new DescTran();
40    robot.GetTargetPayloadWithID(id, weight, cog);
41    System.out.println("GetTargetPayload is " + weightT.get(0) + " cogT is  " + cogT.x + "  " + cogT.y + "  " + cogT.z);
42    robot.GetCurToolCoord(toolCoord);
43    System.out.printf("GetCurToolCoord %f %f %f %f %f %f\n",
44        toolCoord.tran.x, toolCoord.tran.y, toolCoord.tran.z,
45        toolCoord.rpy.rx, toolCoord.rpy.ry, toolCoord.rpy.rz);
46    robot.GetCurWObjCoord(wobjCoord);
47    System.out.printf("GetCurWObjCoord %f %f %f %f %f %f\n",
48        wobjCoord.tran.x, wobjCoord.tran.y, wobjCoord.tran.z,
49        wobjCoord.rpy.rx, wobjCoord.rpy.ry, wobjCoord.rpy.rz);
50    robot.GetCurExToolCoord(extoolCoord);
51    System.out.printf("GetExToolCoordWithID %f %f %f %f %f %f\n",
52        extoolCoord.tran.x, extoolCoord.tran.y, extoolCoord.tran.z,
53        extoolCoord.rpy.rx, extoolCoord.rpy.ry, extoolCoord.rpy.rz);
54    robot.GetCurExAxisCoord(exAxisCoord);
55    System.out.printf("GetCurExAxisCoord %f %f %f %f %f %f\n",
56        exAxisCoord.tran.x, exAxisCoord.tran.y, exAxisCoord.tran.z,
57        exAxisCoord.rpy.rx, exAxisCoord.rpy.ry, exAxisCoord.rpy.rz);
58    DescTran cogT = new DescTran();
59    List<Number> weightT = robot.GetTargetPayload(0);
60    robot.GetTargetPayloadCog(0, cogT);
61    System.out.printf("GetTargetPayload %f %f %f %f\n", weightT.get(0),
62        cogT.x, cogT.y, cogT.z);
63    DescPose coordSet = new DescPose(0, 1, 2, 3, 4, 5);
64    robot.SetToolCoord(1, coordSet, 0, 0, 1, 0);
65    robot.SetWObjCoord(1, coordSet, 0);
66    robot.SetLoadWeight(1, 1.3);
67    cog.x = 10;
68    cog.y = 20;
69    cog.z = 30;
70    robot.SetLoadCoord(1, cog);
71    DescPose etcp = new DescPose(0, 0, 100, 0, 0, 0);
72    DescPose etool = new DescPose(0, 0, 50, 0, 0, 0);
73    int rtn = robot.SetExToolCoord(21, etcp, etool);
74    System.out.printf("SetExToolCoord rtn is %d\n", rtn);
75    robot.ExtAxisActiveECoordSys(1, 1, coordSet, 1);
76    return 0;
77}