6. Allgemeine Roboter-Einstellungen

6.1. Werkzeug-Referenzpunkt einstellen - Sechs-Punkt-Methode

1/**
2* @brief Werkzeug-Referenzpunkt einstellen - Sechs-Punkt-Methode
3* @param [in] point_num Punktnummer, Bereich [1~6]
4* @return Fehlercode
5*/
6int SetToolPoint(int point_num);

6.2. Werkzeugkoordinatensystem berechnen - Sechs-Punkt-Methode

1/**
2* @brief Werkzeugkoordinatensystem berechnen
3* @param [out] tcp_pose Werkzeugkoordinatensystem
4* @return Fehlercode
5*/
6int ComputeTool(DescPose tcp_pose);

6.3. Werkzeug-Referenzpunkt einstellen - Vier-Punkt-Methode

1/**
2* @brief Werkzeug-Referenzpunkt einstellen - Vier-Punkt-Methode
3* @param [in] point_num Punktnummer, Bereich [1~4]
4* @return Fehlercode
5*/
6int SetTcp4RefPoint(int point_num);

6.4. Werkzeugkoordinatensystem berechnen - Vier-Punkt-Methode

1/**
2* @brief Werkzeugkoordinatensystem berechnen
3* @param [out] tcp_pose Werkzeugkoordinatensystem
4* @return Fehlercode
5*/
6int ComputeTcp4(DescPose tcp_pose);

6.5. Werkzeugkoordinatensystem basierend auf Punktdaten berechnen

1/**
2* @brief Werkzeugkoordinatensystem basierend auf Punktdaten berechnen
3* @param [in] method Berechnungsmethode; 0 - Vier-Punkt-Methode, 1 - Sechs-Punkt-Methode
4* @param [in] pos Array von Gelenkpositionen, Länge 4 bei Vier-Punkt-Methode, Länge 6 bei Sechs-Punkt-Methode
5* @param [out] tool_pose Berechnetes Werkzeugkoordinatensystem
6* @return Fehlercode
7*/
8int ComputeToolCoordWithPoints(int method, JointPos[] pos, DescPose tool_pose);

6.6. Werkzeugkoordinatensystem einstellen

 1/**
 2* @brief Werkzeugkoordinatensystem einstellen
 3* @param [in] id Koordinatensystemnummer, Bereich [0~14]
 4* @param [in] coord Pose des Werkzeugmittelpunkts relativ zum Flanschmittelpunkt
 5* @param [in] type 0 - Werkzeugkoordinatensystem, 1 - Sensorkoordinatensystem
 6* @param [in] install Einbauort, 0 - Roboterflansch, 1 - extern
 7* @param [in] toolID Werkzeug-ID
 8* @param [in] loadNum Lastnummer
 9* @return Fehlercode
10*/
11int SetToolCoord(int id, DescPose coord, int type, int install, int toolID, int loadNum);

6.7. Werkzeugkoordinatensystem in Liste einstellen

 1/**
 2* @brief Werkzeugkoordinatensystem in Liste einstellen
 3* @param [in] id Koordinatensystemnummer, Bereich [0~14]
 4* @param [in] coord Pose des Werkzeugmittelpunkts relativ zum Flanschmittelpunkt
 5* @param [in] type 0 - Werkzeugkoordinatensystem, 1 - Sensorkoordinatensystem
 6* @param [in] install Einbauort, 0 - Roboterflansch, 1 - extern
 7* @param [in] loadNum Lastnummer
 8* @return Fehlercode
 9*/
10int SetToolList(int id, DescPose coord, int type, int install, int loadNum);

6.8. Aktuelles Werkzeugkoordinatensystem abrufen

1/**
2* @brief Aktuelles Werkzeugkoordinatensystem abrufen
3* @param [in] flag 0 - blockierend, 1 - nicht blockierend
4* @param [out] desc_pos Pose des Werkzeugkoordinatensystems
5* @return Fehlercode
6*/
7int GetTCPOffset(int flag, DescPose desc_pos);

6.9. Codebeispiel für Roboter-Werkzeugkoordinatensystem-Operationen

 1public static int TestTCPCompute(Robot robot)
 2{
 3    DescPose p1Desc=new DescPose(186.331, 487.913, 209.850, 149.030, 0.688, -114.347);
 4    JointPos p1Joint=new JointPos(-127.876, -75.341, 115.417, -122.741, -59.820, 74.300);
 5
 6    DescPose p2Desc=new DescPose(69.721, 535.073, 202.882, -144.406, -14.775, -89.012);
 7    JointPos p2Joint=new JointPos(-101.780, -69.828, 110.917, -125.740, -127.841, 74.300);
 8
 9    DescPose p3Desc=new DescPose(146.861, 578.426, 205.598, 175.997, -36.178, -93.437);
10    JointPos p3Joint=new JointPos(-112.851, -60.191, 86.566, -80.676, -97.463, 74.300);
11
12    DescPose p4Desc=new DescPose(136.284, 509.876, 225.613, 178.987, 1.372, -100.696);
13    JointPos p4Joint=new JointPos(-116.397, -76.281, 113.845, -128.611, -88.654, 74.299);
14
15    DescPose p5Desc=new DescPose(138.395, 505.972, 298.016, 179.134, 2.147, -101.110);
16    JointPos p5Joint=new JointPos(-116.814, -82.333, 109.162, -118.662, -88.585, 74.302);
17
18    DescPose p6Desc=new DescPose(105.553, 454.325, 232.017, -179.426, 0.444, -99.952);
19    JointPos p6Joint=new JointPos(-115.649, -84.367, 122.447, -128.663, -90.432, 74.303);
20
21    ExaxisPos exaxisPos=new ExaxisPos(0, 0, 0, 0);
22    DescPose offdese=new DescPose(0, 0, 0, 0, 0, 0);
23
24    JointPos[] posJ = { p1Joint , p2Joint , p3Joint , p4Joint , p5Joint , p6Joint };
25    DescPose coordRtn =new DescPose() {};
26    int rtn = robot.ComputeToolCoordWithPoints(1, posJ, coordRtn);
27
28    robot.MoveJ(p1Joint, p1Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
29    robot.SetToolPoint(1);
30    robot.MoveJ(p2Joint, p2Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
31    robot.SetToolPoint(2);
32    robot.MoveJ(p3Joint, p3Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
33    robot.SetToolPoint(3);
34    robot.MoveJ(p4Joint, p4Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
35    robot.SetToolPoint(4);
36    robot.MoveJ(p5Joint, p5Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
37    robot.SetToolPoint(5);
38    robot.MoveJ(p6Joint, p6Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
39    robot.SetToolPoint(6);
40    rtn = robot.ComputeTool(coordRtn);
41    robot.SetToolList(3, coordRtn, 0, 0, 0);
42
43    robot.MoveJ(p1Joint, p1Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
44    robot.SetTcp4RefPoint(1);
45    robot.MoveJ(p2Joint, p2Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
46    robot.SetTcp4RefPoint(2);
47    robot.MoveJ(p3Joint, p3Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
48    robot.SetTcp4RefPoint(3);
49    robot.MoveJ(p4Joint, p4Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
50    robot.SetTcp4RefPoint(4);
51    rtn = robot.ComputeTcp4(coordRtn);
52
53    robot.SetToolCoord(4, coordRtn, 0, 0, 1, 0);
54
55    DescPose getCoord = new DescPose(){};
56    rtn = robot.GetTCPOffset(0, getCoord);
57    return 0;
58}

6.10. Externen Werkzeug-Referenzpunkt einstellen - Drei-Punkt-Methode

1/**
2* @brief Externen Werkzeug-Referenzpunkt einstellen - Drei-Punkt-Methode
3* @param [in] point_num Punktnummer, Bereich [1~3]
4* @return Fehlercode
5*/
6int SetExTCPPoint(int point_num);

6.11. Externes Werkzeugkoordinatensystem berechnen - Drei-Punkt-Methode

1/**
2* @brief Externes Werkzeugkoordinatensystem berechnen - Drei-Punkt-Methode
3* @param [out] tcp_pose Externes Werkzeugkoordinatensystem
4* @return Fehlercode
5*/
6int ComputeExTCF(DescPose tcp_pose);

6.12. Externes Werkzeugkoordinatensystem einstellen

1/**
2* @brief Externes Werkzeugkoordinatensystem einstellen
3* @param [in] id Koordinatensystemnummer, Bereich [0~14]
4* @param [in] etcp Pose des Werkzeugmittelpunkts relativ zum Flanschmittelpunkt
5* @param [in] etool (vorläufig unbestimmt)
6* @return Fehlercode
7*/
8int SetExToolCoord(int id, DescPose etcp, DescPose etool);

6.13. Externes Werkzeugkoordinatensystem in Liste einstellen

1/**
2* @brief Externes Werkzeugkoordinatensystem in Liste einstellen
3* @param [in] id Koordinatensystemnummer, Bereich [0~14]
4* @param [in] etcp Pose des Werkzeugmittelpunkts relativ zum Flanschmittelpunkt
5* @param [in] etool (vorläufig unbestimmt)
6* @return Fehlercode
7*/
8int SetExToolList(int id, DescPose etcp, DescPose etool);

6.14. Codebeispiel für Roboter-externes Werkzeugkoordinatensystem

 1public static int TestExtCoord(Robot robot)
 2{
 3    DescPose p1Desc=new DescPose(-89.606, 779.517, 193.516, 178.000, 0.476, -92.484);
 4    JointPos p1Joint=new JointPos(-108.145, -50.137, 85.818, -125.599, -87.946, 74.329);
 5
 6    DescPose p2Desc=new DescPose(-24.656, 850.384, 191.361, 177.079, -2.058, -95.355);
 7    JointPos p2Joint=new JointPos(-111.024, -41.538, 69.222, -114.913, -87.743, 74.329);
 8
 9    DescPose p3Desc=new DescPose(-99.813, 766.661, 241.878, -176.817, 1.917, -91.604);
10    JointPos p3Joint=new JointPos(-107.266, -56.116, 85.971, -122.560, -92.548, 74.331);
11
12    robot.GetForwardKin(p1Joint,p1Desc);
13    robot.GetForwardKin(p2Joint,p2Desc);
14    robot.GetForwardKin(p3Joint,p3Desc);
15
16    ExaxisPos exaxisPos=new ExaxisPos(0, 0, 0, 0);
17    DescPose offdese=new DescPose(0, 0, 0, 0, 0, 0);
18
19    DescPose[] posTCP = { p1Desc , p2Desc , p3Desc };
20    DescPose coordRtn = new DescPose();
21
22    robot.MoveJ(p1Joint, p1Desc, 1, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
23    robot.SetExTCPPoint(1);
24    robot.MoveJ(p2Joint, p2Desc, 1, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
25    robot.SetExTCPPoint(2);
26    robot.MoveJ(p3Joint, p3Desc, 1, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
27    robot.SetExTCPPoint(3);
28    int rtn = robot.ComputeExTCF(coordRtn);
29
30    robot.SetExToolCoord(1, coordRtn, offdese);
31    robot.SetExToolList(1, coordRtn, offdese);
32    return 0;
33}

6.15. Werkstück-Referenzpunkt einstellen - Drei-Punkt-Methode

1/**
2* @brief Werkstück-Referenzpunkt einstellen - Drei-Punkt-Methode
3* @param [in] point_num Punktnummer, Bereich [1~3]
4* @return Fehlercode
5*/
6int SetWObjCoordPoint(int point_num);

6.16. Werkstückkoordinatensystem berechnen

1/**
2* @brief Werkstückkoordinatensystem berechnen
3* @param [in] method Berechnungsmethode: 0 - Ursprung-x-Achse-z-Achse, 1 - Ursprung-x-Achse-xy-Ebene
4* @param [in] refFrame Referenzkoordinatensystem
5* @param [out] wobj_pose Werkstückkoordinatensystem
6* @return Fehlercode
7*/
8int ComputeWObjCoord(int method, int refFrame, DescPose wobj_pose);

6.17. Werkstückkoordinatensystem einstellen

1/**
2* @brief Werkstückkoordinatensystem einstellen
3* @param [in] id Koordinatensystemnummer, Bereich [1~15]
4* @param [in] coord Pose des Werkstückkoordinatensystems relativ zum Flanschmittelpunkt
5* @param [in] refFrame Referenzkoordinatensystem
6* @return Fehlercode
7*/
8int SetWObjCoord(int id, DescPose coord, int refFrame);

6.18. Werkstückkoordinatensystem in Liste einstellen

1/**
2* @brief Werkstückkoordinatensystem in Liste einstellen
3* @param [in] id Koordinatensystemnummer, Bereich [1~15]
4* @param [in] coord Pose des Werkstückkoordinatensystems relativ zum Flanschmittelpunkt
5* @param [in] refFrame Referenzkoordinatensystem
6* @return Fehlercode
7*/
8int SetWObjList(int id, DescPose coord, int refFrame);

6.19. Werkstückkoordinatensystem basierend auf Punktdaten berechnen

1/**
2* @brief Werkstückkoordinatensystem basierend auf Punktdaten berechnen
3* @param [in] method Berechnungsmethode: 0 - Ursprung-x-Achse-z-Achse, 1 - Ursprung-x-Achse-xy-Ebene
4* @param [in] pos Array von drei TCP-Positionen (kartesisch)
5* @param [in] refFrame Referenzkoordinatensystem
6* @param [out] tcp_pose Berechnetes Werkstückkoordinatensystem
7* @return Fehlercode
8*/
9int ComputeWObjCoordWithPoints(int method, DescPose[] pos, int refFrame, DescPose tcp_pose);

6.20. Aktuelles Werkstückkoordinatensystem abrufen

1/**
2* @brief Aktuelles Werkstückkoordinatensystem abrufen
3* @param [in] flag 0 - blockierend, 1 - nicht blockierend
4* @param [out] desc_pos Pose des Werkstückkoordinatensystems
5* @return Fehlercode
6*/
7int GetWObjOffset(int flag, DescPose desc_pos);

6.21. Codebeispiel für Roboter-Werkstückkoordinatensystem-Operationen

 1public static int TestWobjCoord(Robot robot)
 2{
 3    DescPose p1Desc=new DescPose(-89.606, 779.517, 193.516, 178.000, 0.476, -92.484);
 4    JointPos p1Joint=new JointPos(-108.145, -50.137, 85.818, -125.599, -87.946, 74.329);
 5
 6    DescPose p2Desc=new DescPose(-24.656, 850.384, 191.361, 177.079, -2.058, -95.355);
 7    JointPos p2Joint=new JointPos(-111.024, -41.538, 69.222, -114.913, -87.743, 74.329);
 8
 9    DescPose p3Desc=new DescPose(-99.813, 766.661, 241.878, -176.817, 1.917, -91.604);
10    JointPos p3Joint=new JointPos(-107.266, -56.116, 85.971, -122.560, -92.548, 74.331);
11
12    robot.GetForwardKin(p1Joint,p1Desc);
13    robot.GetForwardKin(p2Joint,p2Desc);
14    robot.GetForwardKin(p3Joint,p3Desc);
15
16    ExaxisPos exaxisPos=new ExaxisPos(0, 0, 0, 0);
17    DescPose offdese=new DescPose(0, 0, 0, 0, 0, 0);
18
19    DescPose[] posTCP =new DescPose[]{p1Desc , p2Desc , p3Desc };
20    DescPose coordRtn =new DescPose();
21    int rtn = robot.ComputeWObjCoordWithPoints(1, posTCP, 0, coordRtn);
22
23    robot.MoveJ(p1Joint, p1Desc, 1, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
24    robot.SetWObjCoordPoint(1);
25    robot.MoveJ(p2Joint, p2Desc, 1, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
26    robot.SetWObjCoordPoint(2);
27    robot.MoveJ(p3Joint, p3Desc, 1, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
28    robot.SetWObjCoordPoint(3);
29    rtn = robot.ComputeWObjCoord(1, 0, coordRtn);
30
31    robot.SetWObjCoord(1, coordRtn, 0);
32    robot.SetWObjList(1, coordRtn, 0);
33
34    DescPose getWobjDesc = new DescPose();
35    rtn = robot.GetWObjOffset(0, getWobjDesc);
36    return 0;
37}

6.22. Globale Geschwindigkeit einstellen

1/**
2* @brief Globale Geschwindigkeit einstellen
3* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
4* @return Fehlercode
5*/
6int SetSpeed(int vel);

6.23. Roboter-Beschleunigung einstellen

1/**
2* @brief Roboter-Beschleunigung einstellen
3* @param [in] acc Roboter-Beschleunigungsprozentsatz
4* @return Fehlercode
5*/
6int SetOaccScale(double acc);

6.24. Standard-Roboter-Geschwindigkeit abrufen

1/**
2* @brief Standard-Roboter-Geschwindigkeit abrufen
3* @return List[0]: int Fehlercode; List[1]: double vel Geschwindigkeit (mm/s)
4*/
5List<Number> GetDefaultTransVel();

6.25. Endeffektor-Lastgewicht einstellen

1/**
2* @brief Endeffektor-Lastgewicht einstellen
3* @param [in] loadNum Lastnummer
4* @param [in] weight Lastgewicht (kg)
5* @return Fehlercode
6*/
7int SetLoadWeight(int loadNum, double weight);

6.26. Endeffektor-Lastschwerpunkt einstellen

1/**
2* @brief Endeffektor-Lastschwerpunkt einstellen
3* @param [in] coord Schwerpunktkoordinaten (mm)
4* @return Fehlercode
5*/
6int SetLoadCoord(DescTran coord);

6.27. Endeffektor-Lastschwerpunkt einstellen (mit Lastnummer)

1/**
2 * @brief Endeffektor-Lastschwerpunkt einstellen (mit Lastnummer)
3 * @param [in] loadNum Lastnummer
4 * @param [in] coord Schwerpunktkoordinaten (mm)
5 * @return Fehlercode
6 */
7public int SetLoadCoord(int loadNum, DescTran coord)

6.28. Aktuelles Lastgewicht abrufen

1/**
2* @brief Aktuelles Lastgewicht abrufen
3* @param [in] flag 0 - blockierend, 1 - nicht blockierend
4* @return List[0]: int Fehlercode; List[1]: double weight Lastgewicht (kg)
5*/
6List<Number> GetTargetPayload(int flag);

6.29. Aktuellen Lastschwerpunkt abrufen

1/**
2* @brief Aktuellen Lastschwerpunkt abrufen
3* @param [in] flag 0 - blockierend, 1 - nicht blockierend
4* @param [out] cog Lastschwerpunkt (mm)
5* @return Fehlercode
6*/
7int GetTargetPayloadCog(int flag, DescTran cog);

6.30. Roboter-Einbauart einstellen

1/**
2* @brief Roboter-Einbauart einstellen
3* @param [in] install Einbauart, 0 - Boden, 1 - Wand, 2 - Decke
4* @return Fehlercode
5*/
6int SetRobotInstallPos(int install);

6.31. Roboter-Einbauwinkel einstellen (freie Montage)

1/**
2* @brief Roboter-Einbauwinkel einstellen (freie Montage)
3* @param [in] yangle Neigungswinkel
4* @param [in] zangle Rotationswinkel
5* @return Fehlercode
6*/
7int SetRobotInstallAngle(double yangle, double zangle);

6.32. Roboter-Einbauwinkel abrufen

1/**
2* @brief Roboter-Einbauwinkel abrufen
3* @return List[0]: Fehlercode; List[1]: double yangle Neigungswinkel; List[2]: double zangle Rotationswinkel
4*/
5public List<Number> GetRobotInstallAngle()

6.33. Systemvariablenwert einstellen

1/**
2* @brief Systemvariablenwert einstellen
3* @param [in] id Variablennummer, Bereich [1~20]
4* @param [in] value Variablenwert
5* @return Fehlercode
6*/
7int SetSysVarValue(int id, double value);

6.34. Systemvariablenwert abrufen

1/**
2* @brief Systemvariablenwert abrufen
3* @param [in] id Systemvariablennummer, Bereich [1~20]
4* @return List[0]: Fehlercode; List[1]: double value Systemvariablenwert
5*/
6List<Number> GetSysVarValue(int id);

6.35. Codebeispiel für allgemeine Roboter-Einstellungen

 1public static int TestLoadInstall(Robot robot)
 2{
 3    for (int i = 1; i < 100; i++)
 4    {
 5        robot.SetSpeed(i);
 6        robot.SetOaccScale(i);
 7        robot.Sleep(30);
 8    }
 9
10    List<Number> defaultVel=new ArrayList<>();
11
12    defaultVel=robot.GetDefaultTransVel();
13    System.out.println("GetDefaultTransVel is:"+ defaultVel.get(1));
14
15    for (int i = 1; i < 21; i++)
16    {
17        robot.SetSysVarValue(i, i + 0.5);
18        robot.Sleep(100);
19    }
20
21    for (int i = 1; i < 21; i++)
22    {
23        float value = 0;
24        defaultVel=robot.GetSysVarValue(i);
25        System.out.println("sys value :"+i+", is :"+defaultVel.get(1));
26        robot.Sleep(100);
27    }
28
29    robot.SetLoadWeight(0, 2.5);
30
31    DescTran loadCoord = new DescTran();
32    loadCoord.x = 3.0;
33    loadCoord.y = 4.0;
34    loadCoord.z = 5.0;
35    robot.SetLoadCoord(loadCoord);
36
37    robot.Sleep(1000);
38
39    List<Number> getLoad = new ArrayList<>();
40
41    getLoad=robot.GetTargetPayload(0);
42
43    DescTran getLoadTran =new DescTran();
44    robot.GetTargetPayloadCog(0, getLoadTran);
45    System.out.println("get load is:"+getLoad.get(1)+", get load cog is: "+getLoadTran.x+","+getLoadTran.y+","+getLoadTran.z);
46
47    robot.SetRobotInstallPos(0);
48    robot.SetRobotInstallAngle(15.0, 25.0);
49
50    List<Number> angle=new ArrayList<>();
51    angle=robot.GetRobotInstallAngle();
52    System.out.println("GetRobotInstallAngle x:"+angle.get(1)+";  y:"+angle.get(2));
53
54    robot.CloseRPC();
55    return 0;
56}

6.36. Gelenk-Reibungskompensation ein-/ausschalten

1/**
2* @brief Gelenk-Reibungskompensation ein-/ausschalten
3* @param [in] state 0 - aus, 1 - an
4* @return Fehlercode
5*/
6int FrictionCompensationOnOff(int state);

6.37. Gelenk-Reibungskompensationskoeffizienten einstellen - Bodenmontage

1/**
2* @brief Gelenk-Reibungskompensationskoeffizienten einstellen - Bodenmontage
3* @param [in] coeff Array von sechs Gelenkkompensationskoeffizienten, Bereich [0~1]
4* @return Fehlercode
5*/
6int SetFrictionValue_level(Object[] coeff);

6.38. Gelenk-Reibungskompensationskoeffizienten einstellen - Wandmontage

1/**
2* @brief Gelenk-Reibungskompensationskoeffizienten einstellen - Wandmontage
3* @param [in] coeff Array von sechs Gelenkkompensationskoeffizienten, Bereich [0~1]
4* @return Fehlercode
5*/
6int SetFrictionValue_wall(Object[] coeff);

6.39. Gelenk-Reibungskompensationskoeffizienten einstellen - Deckenmontage

1/**
2* @brief Gelenk-Reibungskompensationskoeffizienten einstellen - Deckenmontage
3* @param [in] coeff Array von sechs Gelenkkompensationskoeffizienten, Bereich [0~1]
4* @return Fehlercode
5*/
6int SetFrictionValue_ceiling(Object[] coeff);

6.40. Gelenk-Reibungskompensationskoeffizienten einstellen - freie Montage

1/**
2* @brief Gelenk-Reibungskompensationskoeffizienten einstellen - freie Montage
3* @param [in] coeff Array von sechs Gelenkkompensationskoeffizienten, Bereich [0~1]
4* @return Fehlercode
5*/
6int SetFrictionValue_freedom(Object[] coeff);

6.41. Codebeispiel zum Einstellen der Gelenk-Reibungskompensation

 1public static int TestFriction(Robot robot)
 2{
 3
 4    Object[] lcoeff = { 0.9,0.9,0.9,0.9,0.9,0.9 };
 5    Object[] wcoeff = { 0.4,0.4,0.4,0.4,0.4,0.4 };
 6    Object[] ccoeff = { 0.6,0.6,0.6,0.6,0.6,0.6 };
 7    Object[] fcoeff = { 0.5,0.5,0.5,0.5,0.5,0.5 };
 8
 9    int rtn = robot.FrictionCompensationOnOff(1);
10    System.out.println("FrictionCompensationOnOff rtn is:"+ rtn);
11
12    rtn = robot.SetFrictionValue_level(lcoeff);
13    System.out.println("SetFrictionValue_level rtn is:"+ rtn);
14
15    rtn = robot.SetFrictionValue_wall(wcoeff);
16    System.out.println("SetFrictionValue_wall rtn is:"+ rtn);
17
18    rtn = robot.SetFrictionValue_ceiling(ccoeff);
19    System.out.println("SetFrictionValue_ceiling rtn is:"+ rtn);
20
21    rtn = robot.SetFrictionValue_freedom(fcoeff);
22    System.out.println("SetFrictionValue_freedom rtn is:"+ rtn);
23
24    robot.CloseRPC();
25    return 0;
26}

6.42. Roboter-Fehlercode abfragen

1/**
2 * @brief Roboter-Fehlercode abfragen
3 * @param [out] maincode Hauptfehlercode (als Array der Länge 1 übergeben)
4 * @param [out] subcode Unterfehlercode (als Array der Länge 1 übergeben)
5 * @return Fehlercode
6 */
7int GetRobotErrorCode(int[] maincode, int[] subcode);

6.43. Fehlerstatus löschen

1/**
2* @brief Fehlerstatus löschen
3* @return Fehlercode
4*/
5int ResetAllError();

6.44. Codebeispiel zum Abrufen und Löschen von Roboter-Fehlerstatus

 1public static int TestGetError(Robot robot)
 2{
 3    int[] maincode={0}, subcode={0};
 4    robot.GetRobotErrorCode(maincode, subcode);
 5
 6    robot.ResetAllError();
 7
 8    robot.Sleep(1000);
 9
10    robot.GetRobotErrorCode(maincode, subcode);
11    return 0;
12}

6.45. Überwachungsparameter für Temperatur und Lüfterstrom des Weitspannungs-Steuerkastens einstellen

Neu in Version Java: SDK-v1.0.6-3.8.3

1/**
2* @brief Überwachungsparameter für Temperatur und Lüfterstrom des Weitspannungs-Steuerkastens einstellen
3* @param [in] enable 0 - Überwachung deaktivieren, 1 - Überwachung aktivieren
4* @param [in] period Überwachungszyklus (s), Bereich 1-100
5* @return Fehlercode
6*/
7int SetWideBoxTempFanMonitorParam(int enable, int period);

6.46. Überwachungsparameter für Temperatur und Lüfterstrom des Weitspannungs-Steuerkastens abrufen

Neu in Version Java: SDK-v1.0.6-3.8.3

1/**
2* @brief Überwachungsparameter für Temperatur und Lüfterstrom des Weitspannungs-Steuerkastens abrufen
3* @return List[0] - Fehlercode, List[1] - enable (0/1), List[2] - period (s)
4*/
5List<Number> GetWideBoxTempFanMonitorParam()

6.47. Codebeispiel zum Abrufen von Temperatur und Lüfterstrom des Weitspannungs-Steuerkastens

 1public static void TestWideVoltageCtrlBoxtemp(Robot robot)
 2{
 3    robot.SetWideBoxTempFanMonitorParam(1, 2);
 4    List<Number> list=robot.GetWideBoxTempFanMonitorParam();
 5    System.out.println("GetWideBoxTempFanMonitorParam enable is:"+list.get(1)+", period is:"+list.get(2));
 6    ROBOT_STATE_PKG pkg=new ROBOT_STATE_PKG();
 7    for (int i = 0; i < 100; i++)
 8    {
 9        pkg=robot.GetRobotRealTimeState();
10        System.out.println("robot ctrl box temp is:"+pkg.wideVoltageCtrlBoxTemp+",fan current is:"+pkg.wideVoltageCtrlBoxFanCurrent);
11        robot.Sleep(100);
12    }
13
14    int rtn = robot.SetWideBoxTempFanMonitorParam(0, 2);
15
16    list=robot.GetWideBoxTempFanMonitorParam();
17    for (int i = 0; i < 100; i++)
18    {
19        pkg=robot.GetRobotRealTimeState();
20        System.out.println("robot ctrl box temp is:"+pkg.wideVoltageCtrlBoxTemp+" ,fan current is:"+pkg.wideVoltageCtrlBoxFanCurrent);
21        robot.Sleep(100);
22    }
23
24    robot.CloseRPC();
25    robot.Sleep(2000);
26    return 0;
27}

6.48. Fokus-Kalibrierungspunkt setzen

Neu in Version Java: SDK-v1.0.7-3.8.4

1/**
2* @brief Fokus-Kalibrierungspunkt setzen
3* @param [in] pointNum Kalibrierungspunktnummer (1-8)
4* @param [in] point Koordinaten des Kalibrierungspunkts (Pose)
5* @return Fehlercode
6*/
7int SetFocusCalibPoint(int pointNum, DescPose point)

6.49. Fokus-Kalibrierungsergebnis berechnen

Neu in Version Java: SDK-v1.0.7-3.8.4

1/**
2* @brief Fokus-Kalibrierungsergebnis berechnen
3* @param [in] pointNum Anzahl der Kalibrierungspunkte
4* @param [in] resultPos Kalibriertes XYZ-Ergebnis (als Objekt zum Befüllen)
5* @param [out] accuracy Kalibriergenauigkeit (Fehler) als double[1]
6* @return Fehlercode
7*/
8int ComputeFocusCalib(int pointNum, DescTran resultPos, double[] accuracy)

6.50. Fokusverfolgung starten

Neu in Version Java: SDK-v1.0.7-3.8.4

 1/**
 2* @brief Fokusverfolgung starten
 3* @param [in] kp Proportionalparameter, Standard 50.0
 4* @param [in] kpredict Vorsteuerungsparameter, Standard 19.0
 5* @param [in] aMax Maximale Winkelbeschleunigungsbegrenzung [°/s²], Standard 1440
 6* @param [in] vMax Maximale Winkelgeschwindigkeitsbegrenzung [°/s], Standard 180
 7* @param [in] type Ausrichtung der X-Achse (0 - Referenzeingangsvektor, 1 - horizontal, 2 - vertikal)
 8* @return Fehlercode
 9*/
10int FocusStart(double kp, double kpredict, double aMax, double vMax, int type)

6.51. Fokusverfolgung stoppen

Neu in Version Java: SDK-v1.0.7-3.8.4

1/**
2* @brief Fokusverfolgung stoppen
3* @return Fehlercode
4*/
5int FocusEnd()

6.52. Fokuskoordinaten einstellen

Neu in Version Java: SDK-v1.0.7-3.8.4

1/**
2* @brief Fokuskoordinaten einstellen
3* @param pos Fokuskoordinaten XYZ
4* @return Fehlercode
5*/
6public int SetFocusPosition(DescTran pos)

6.53. Codebeispiel für Fokusverfolgung

 1public static void TestFocus(Robot robot){
 2    DescPose p1Desc=new DescPose(186.331, 487.913, 209.850, 149.030, 0.688, -114.347);
 3    JointPos p1Joint = new JointPos(-127.876, -75.341, 115.417, -122.741, -59.820, 74.300);
 4    DescPose p2Desc = new DescPose(69.721, 535.073, 202.882, -144.406, -14.775, -89.012);
 5    JointPos p2Joint = new JointPos(-101.780, -69.828, 110.917, -125.740, -127.841, 74.300);
 6    DescPose p3Desc = new DescPose(146.861, 578.426, 205.598, 175.997, -36.178, -93.437);
 7    JointPos p3Joint = new JointPos(-112.851, -60.191, 86.566, -80.676, -97.463, 74.300);
 8    DescPose p4Desc = new DescPose(136.284, 509.876, 225.613, 178.987, 1.372, -100.696);
 9    JointPos p4Joint = new JointPos(-116.397, -76.281, 113.845, -128.611, -88.654, 74.299);
10    DescPose p5Desc = new DescPose(138.395, 505.972, 298.016, 179.134, 2.147, -101.110);
11    JointPos p5Joint = new JointPos(-116.814, -82.333, 109.162, -118.662, -88.585, 74.302);
12    DescPose p6Desc = new DescPose(105.553, 454.325, 232.017, -179.426, 0.444, -99.952);
13    JointPos p6Joint = new JointPos(-115.649, -84.367, 122.447, -128.663, -90.432, 74.303);
14
15    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
16    DescPose offdese = new DescPose(0, 0, 100, 0, 0, 0);
17
18    robot.GetForwardKin(p1Joint, p1Desc);
19    robot.GetForwardKin(p2Joint,  p2Desc);
20    robot.GetForwardKin(p3Joint,  p3Desc);
21    robot.GetForwardKin(p4Joint,  p4Desc);
22    robot.GetForwardKin(p5Joint,  p5Desc);
23    robot.GetForwardKin(p6Joint,  p6Desc);
24
25    robot.MoveJ(p1Joint, p1Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
26    robot.SetTcp4RefPoint(1);
27    robot.MoveJ(p2Joint, p2Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
28    robot.SetTcp4RefPoint(2);
29    robot.MoveJ(p3Joint, p3Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
30    robot.SetTcp4RefPoint(3);
31    robot.MoveJ(p4Joint, p4Desc, 0, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
32    robot.SetTcp4RefPoint(4);
33
34    DescPose coordRtn = new DescPose(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
35    int rtn = robot.ComputeTcp4( coordRtn);
36
37    robot.SetToolCoord(1, coordRtn, 0, 0, 1, 0);
38
39    robot.GetForwardKin(p1Joint, p1Desc);
40    robot.GetForwardKin(p2Joint, p2Desc);
41    robot.GetForwardKin(p3Joint, p3Desc);
42
43    robot.SetFocusCalibPoint(1, p1Desc);
44    robot.SetFocusCalibPoint(2, p2Desc);
45    robot.SetFocusCalibPoint(3, p3Desc);
46
47    DescTran resultPos = new DescTran(0.0, 0.0, 0.0);
48    double[] accuracy = {0.0};
49    rtn = robot.ComputeFocusCalib(3,  resultPos,  accuracy);
50    rtn = robot.SetFocusPosition(resultPos);
51
52    robot.GetForwardKin(p5Joint,  p5Desc);
53    robot.GetForwardKin(p6Joint,  p6Desc);
54
55    robot.MoveL(p5Joint, p5Desc, 1, 0, 10, 100, 100, -1, 0, exaxisPos, 0, 1, offdese,0,100);
56    robot.MoveL(p6Joint, p6Desc, 1, 0, 10, 100, 100, -1, 0, exaxisPos, 0, 1, offdese,0,100);
57
58    robot.FocusStart(50, 19, 710, 90, 0);
59    robot.MoveL(p5Joint, p5Desc, 1, 0, 10, 100, 100, -1, 0, exaxisPos, 0, 1, offdese,0,100);
60    robot.MoveL(p6Joint, p6Desc, 1, 0, 10, 100, 100, -1, 0, exaxisPos, 0, 1, offdese,0,100);
61    robot.FocusEnd();
62}

6.54. Gelenk-Drehmomentsensor-Empfindlichkeitskalibrierung aktivieren

1/**
2* @brief Gelenk-Drehmomentsensor-Empfindlichkeitskalibrierung aktivieren
3* @param status 0 - deaktivieren, 1 - aktivieren
4* @return Fehlercode
5*/
6public int JointSensitivityEnable(int status)

6.55. Gelenk-Drehmomentsensor-Empfindlichkeitsdaten erfassen

1/**
2* @brief Gelenk-Drehmomentsensor-Empfindlichkeitsdaten erfassen
3* @return Fehlercode
4*/
5public int JointSensitivityCollect()

6.56. Ergebnis der Gelenk-Drehmomentsensor-Empfindlichkeitskalibrierung abrufen

1/**
2* @brief Ergebnis der Gelenk-Drehmomentsensor-Empfindlichkeitskalibrierung abrufen
3* @param calibResult Array (Länge 6) für die Empfindlichkeit j1~j6 [0-1]
4* @param linearity Array (Länge 6) für die Linearität j1~j6 [0-1]
5* @return Fehlercode
6*/
7public int JointSensitivityCalibration(double[] calibResult, double[] linearity)

6.57. Gelenk-Drehmomentsensor-Hysteresefehler abrufen

1/**
2* @brief Gelenk-Drehmomentsensor-Hysteresefehler abrufen
3* @param hysteresisError Array (Länge 6) für die Hysteresefehler j1~j6
4* @return Fehlercode
5*/
6public int JointHysteresisError(double[] hysteresisError);

6.58. Gelenk-Drehmomentsensor-Wiederholgenauigkeit abrufen

1/**
2* @brief Gelenk-Drehmomentsensor-Wiederholgenauigkeit abrufen
3* @param repeatability Array (Länge 6) für die Wiederholgenauigkeit j1~j6
4* @return Fehlercode
5*/
6public int JointRepeatability(double[] repeatability);

6.59. Gelenk-Kraftsensor-Parameter einstellen

 1/**
 2* @brief Gelenk-Kraftsensor-Parameter einstellen (für Impedanzregelung)
 3* @param M Array (Länge 6) der Massenkoeffizienten J1-J6
 4* @param B Array (Länge 6) der Dämpfungskoeffizienten J1-J6
 5* @param K Array (Länge 6) der Steifigkeitskoeffizienten J1-J6
 6* @param threshold Array (Länge 6) der Kraftregelungsschwellwerte [Nm]
 7* @param sensitivity Array (Länge 6) der Empfindlichkeit [Nm/V]
 8* @param setZeroFlag Funktionsaktivierungs-Flag; 0 - deaktivieren, 1 - aktivieren, 2 - Nullpunkt an Position 1 aufzeichnen, 3 - Nullpunkt an Position 2 aufzeichnen
 9* @return Fehlercode
10*/
11public int SetAdmittanceParams(double[] M, double[] B, double[] K, double[] threshold, double[] sensitivity, int setZeroFlag);

6.60. Codebeispiel für automatische Gelenk-Drehmomentsensor-Empfindlichkeitskalibrierung

  1public static void TestSensitivityCalib(Robot robot)
  2{
  3    int rtn = robot.JointSensitivityEnable(0);
  4    rtn = robot.JointSensitivityEnable(1);
  5    System.out.printf("JointSensitivityEnable rtn is %d\n", rtn);
  6    JointPos curJPos = new JointPos();
  7    robot.GetActualJointPosDegree(curJPos);
  8    ExaxisPos epos = new ExaxisPos(0,0,0,0);
  9    DescPose offset_pos =new DescPose(0,0,0,0,0,0 );
 10    JointPos jointPos1 = new JointPos(curJPos.J1, 0, 0, -90, 0.02, curJPos.J6);
 11    DescPose descPos1 = new DescPose();
 12    robot.GetForwardKin(jointPos1, descPos1);
 13    robot.MoveJ(jointPos1, descPos1, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 14    robot.Sleep(200);
 15    rtn = robot.JointSensitivityCollect();
 16    System.out.printf("JointSensitivityCollect 1 rtn is %d\n", rtn);
 17    robot.Sleep(100);
 18    JointPos jointPos2 =new JointPos( curJPos.J1, -30, 0, -90, 0.02, curJPos.J6 );
 19    DescPose descPos2 =new DescPose();
 20    robot.GetForwardKin(jointPos2, descPos2);
 21    robot.MoveJ(jointPos2, descPos2, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 22    robot.Sleep(100);
 23    rtn = robot.JointSensitivityCollect();
 24    System.out.printf("JointSensitivityCollect 2 rtn is %d\n", rtn);
 25    robot.Sleep(100);
 26    JointPos jointPos3 = new JointPos( curJPos.J1, -60, 0, -90, 0.02, curJPos.J6 );
 27    DescPose descPos3 =new DescPose();
 28    robot.GetForwardKin(jointPos3, descPos3);
 29    robot.MoveJ(jointPos3, descPos3, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 30    robot.Sleep(100);
 31    rtn = robot.JointSensitivityCollect();
 32    System.out.printf("JointSensitivityCollect 3 rtn is %d\n", rtn);
 33    robot.Sleep(100);
 34    JointPos jointPos4 = new JointPos(curJPos.J1, -90, 0, -90, 0.02, curJPos.J6);
 35    DescPose descPos4 = new DescPose();
 36    robot.GetForwardKin(jointPos4, descPos4);
 37    robot.MoveJ(jointPos4, descPos4, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 38    robot.Sleep(100);
 39    rtn = robot.JointSensitivityCollect();
 40    System.out.printf("JointSensitivityCollect 4 rtn is %d\n", rtn);
 41    robot.Sleep(100);
 42    JointPos jointPos5 = new JointPos(curJPos.J1, -120, 0, -90, 0.02, curJPos.J6);
 43    DescPose descPos5 = new DescPose();
 44    robot.GetForwardKin(jointPos5, descPos5);
 45    robot.MoveJ(jointPos5, descPos5, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 46    robot.Sleep(100);
 47    rtn = robot.JointSensitivityCollect();
 48    System.out.printf("JointSensitivityCollect 5 rtn is %d\n", rtn);
 49    robot.Sleep(100);
 50    JointPos jointPos6 = new JointPos(curJPos.J1, -150, 0, -90, 0.02, curJPos.J6);
 51    DescPose descPos6 = new DescPose();
 52    robot.GetForwardKin(jointPos6, descPos6);
 53    robot.MoveJ(jointPos6, descPos6, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 54    robot.Sleep(100);
 55    rtn = robot.JointSensitivityCollect();
 56    System.out.printf("JointSensitivityCollect 6 rtn is %d\n", rtn);
 57    robot.Sleep(100);
 58    JointPos jointPos7 = new JointPos(curJPos.J1, -180, 0, -90, 0.02, curJPos.J6);
 59    DescPose descPos7 = new DescPose();
 60    robot.GetForwardKin(jointPos7, descPos7);
 61    robot.MoveJ(jointPos7, descPos7, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 62    robot.Sleep(100);
 63    rtn = robot.JointSensitivityCollect();
 64    System.out.printf("JointSensitivityCollect 7 rtn is %d\n", rtn);
 65    robot.Sleep(100);
 66    //Rückwärtshub
 67    robot.MoveJ(jointPos6, descPos6, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 68    robot.Sleep(100);
 69    rtn = robot.JointSensitivityCollect();
 70    System.out.printf("JointSensitivityCollect 8 rtn is %d\n", rtn);
 71    robot.Sleep(100);
 72    robot.MoveJ(jointPos5, descPos5, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 73    robot.Sleep(100);
 74    rtn = robot.JointSensitivityCollect();
 75    System.out.printf("JointSensitivityCollect 9 rtn is %d\n", rtn);
 76    robot.Sleep(100);
 77    robot.MoveJ(jointPos4, descPos4, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 78    robot.Sleep(100);
 79    rtn = robot.JointSensitivityCollect();
 80    System.out.printf("JointSensitivityCollect 10 rtn is %d\n", rtn);
 81    robot.Sleep(100);
 82    robot.MoveJ(jointPos3, descPos3, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 83    robot.Sleep(100);
 84    rtn = robot.JointSensitivityCollect();
 85    System.out.printf("JointSensitivityCollect 11 rtn is %d\n", rtn);
 86    robot.Sleep(100);
 87    robot.MoveJ(jointPos2, descPos2, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 88    robot.Sleep(100);
 89    rtn = robot.JointSensitivityCollect();
 90    System.out.printf("JointSensitivityCollect 12 rtn is %d\n", rtn);
 91    robot.Sleep(100);
 92    robot.MoveJ(jointPos1, descPos1, 0, 0, 100, 100, 100, epos, -1, 0, offset_pos);
 93    robot.Sleep(200);
 94    rtn = robot.JointSensitivityCollect();
 95    System.out.printf("JointSensitivityCollect 13 rtn is %d\n", rtn);
 96    robot.Sleep(100);
 97    double[] calibResult =new double[6];
 98    double[] linearity = new double[6];
 99    rtn = robot.JointSensitivityCalibration(calibResult, linearity);
100    System.out.printf("JointSensitivityCalibration rtn is %d\n", rtn);
101    rtn = robot.JointSensitivityEnable(0);
102    System.out.printf("JointSensitivityEnable rtn is %d\n", rtn);
103    System.out.printf("jointSensor Calib result is %f %f %f %f %f %f\njointSensor linearity is %f %f %f %f %f %f\n",
104            calibResult[0], calibResult[1], calibResult[2],
105            calibResult[3], calibResult[4], calibResult[5],
106            linearity[0], linearity[1], linearity[2],
107            linearity[3], linearity[4], linearity[5]);
108    double[] hysteresisError = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
109    rtn = robot.JointHysteresisError(hysteresisError);
110    System.out.printf("JointHysteresisError result is %f %f %f %f %f %f\n",
111            hysteresisError[0], hysteresisError[1], hysteresisError[2],
112            hysteresisError[3], hysteresisError[4], hysteresisError[5]);
113    double[] repeatability = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
114    rtn = robot.JointRepeatability(repeatability);
115    System.out.printf("JointRepeatability result is %f %f %f %f %f %f\n",
116            repeatability[0], repeatability[1], repeatability[2],
117            repeatability[3], repeatability[4], repeatability[5]);
118    double[] M = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
119    double[] B = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
120    double[] K = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
121    double[] threshold = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
122    int setZeroFlag = 1;
123    rtn = robot.SetAdmittanceParams(M, B, K, threshold, calibResult, setZeroFlag);
124    System.out.printf("SetAdmittanceParams rtn is %d\n", rtn);
125}

6.61. Fehlerzähler der 8 Slave-Ports abrufen

 1/**
 2* @brief Fehlerzähler der 8 Slave-Ports abrufen
 3* @param inRecvErr Array (Länge 8) für Empfangsfehler (Eingang)
 4* @param inCRCErr Array (Länge 8) für CRC-Fehler (Eingang)
 5* @param inTransmitErr Array (Länge 8) für Übertragungsfehler (Eingang)
 6* @param inLinkErr Array (Länge 8) für Link-Fehler (Eingang)
 7* @param outRecvErr Array (Länge 8) für Empfangsfehler (Ausgang)
 8* @param outCRCErr Array (Länge 8) für CRC-Fehler (Ausgang)
 9* @param outTransmitErr Array (Länge 8) für Übertragungsfehler (Ausgang)
10* @param outLinkErr Array (Länge 8) für Link-Fehler (Ausgang)
11* @return Fehlercode
12*/
13public int GetSlavePortErrCounter(int[] inRecvErr, int[] inCRCErr, int[] inTransmitErr, int[] inLinkErr, int[] outRecvErr, int[] outCRCErr, int[] outTransmitErr, int[] outLinkErr)

6.62. Slave-Port-Fehlerzähler zurücksetzen

1/**
2* @brief Slave-Port-Fehlerzähler zurücksetzen
3* @param slaveID Slave-Nummer 0~7
4* @return Fehlercode
5*/
6public int SlavePortErrCounterClear(int slaveID)

6.63. Codebeispiel zum Abrufen der Slave-Port-Fehlerzähler

 1public static void TestSlavePortErr(Robot robot)
 2{
 3    ROBOT_STATE_PKG pkg =new ROBOT_STATE_PKG();
 4    int[] inRecvErr =new int[8];
 5    int[] inCRCErr =new int[8];
 6    int[] inTransmitErr =new int[8];
 7    int[] inLinkErr =new int[8];
 8    int[] outRecvErr =new int[8];
 9    int[] outCRCErr =new int[8];
10    int[] outTransmitErr =new int[8];
11    int[] outLinkErr =new int[8];
12    robot.GetSlavePortErrCounter(inRecvErr,  inCRCErr, inTransmitErr, inLinkErr,
13            outRecvErr, outCRCErr, outTransmitErr, outLinkErr);
14    for (int i = 0; i < 8; i++)
15    {
16        if (inRecvErr[i] != 0)
17        {
18            System.out.printf("inRecvErr %d is %d\n", i, inRecvErr[i]);
19        }
20        if (inCRCErr[i] != 0)
21        {
22            System.out.printf("inRecvErr %d is %d\n", i, inCRCErr[i]);
23        }
24        if (inTransmitErr[i] != 0)
25        {
26            System.out.printf("inRecvErr %d is %d\n", i, inTransmitErr[i]);
27        }
28        if (inLinkErr[i] != 0)
29        {
30            System.out.printf("inRecvErr %d is %d\n", i, inLinkErr[i]);
31        }
32        if (outRecvErr[i] != 0)
33        {
34            System.out.printf("outRecvErr %d is %d\n", i, outRecvErr[i]);
35        }
36        if (outCRCErr[i] != 0)
37        {
38            System.out.printf("outCRCErr %d is %d\n", i, outCRCErr[i]);
39        }
40        if (outTransmitErr[i] != 0)
41        {
42            System.out.printf("outTransmitErr %d is %d\n", i, outTransmitErr[i]);
43        }
44        if (outLinkErr[i] != 0)
45        {
46            System.out.printf("outLinkErr %d is %d\n", i, outLinkErr[i]);
47        }
48    }
49    System.out.printf("others has no err!\n");
50    for (int i = 0; i < 8; i++)
51    {
52        robot.SlavePortErrCounterClear(i);
53    }
54    robot.CloseRPC();
55}

6.64. Geschwindigkeits-Vorsteuerkoeffizienten für jede Achse einstellen

1/**
2* @brief Geschwindigkeits-Vorsteuerkoeffizienten für jede Achse einstellen
3* @param radio Array (Länge 6) der Geschwindigkeits-Vorsteuerkoeffizienten
4* @return Fehlercode
5*/
6public int SetVelFeedForwardRatio(double[] radio)

6.65. Geschwindigkeits-Vorsteuerkoeffizienten für jede Achse abrufen

1/**
2* @brief Geschwindigkeits-Vorsteuerkoeffizienten für jede Achse abrufen
3* @param radio Array (Länge 6) zum Befüllen mit den Koeffizienten
4* @return Fehlercode
5*/
6public int GetVelFeedForwardRatio(double[] radio)

6.66. Codebeispiel für Geschwindigkeits-Vorsteuerkoeffizienten

1public static void TestVelFeedForwardRatio(Robot robot)
2{
3    double[] setRadio =new double[] { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
4    robot.SetVelFeedForwardRatio(setRadio);
5    double[] getRadio = new double[]{ 0.0 };
6    robot.GetVelFeedForwardRatio(getRadio);
7    System.out.printf(" %f %f %f %f %f %f\n", getRadio[0], getRadio[1], getRadio[2], getRadio[3], getRadio[4], getRadio[5]);
8    robot.CloseRPC();
9}

6.67. Photoelektrischer Sensor TCP-Kalibrierung - Werkzeug-RPY berechnen

 1/**
 2* @brief Photoelektrischer Sensor TCP-Kalibrierung - Werkzeug-RPY berechnen
 3* @param Btool Roboter-Kartesische Position (Pose)
 4* @param Etool Aktueller Wert des Werkzeugkoordinatensystems (Pose)
 5* @param sensor Aktueller Wert des Sensorkoordinatensystems (Pose, vorübergehend nicht freigegeben)
 6* @param radius Radius der Kreisbewegung [mm] (vorübergehend nicht freigegeben)
 7* @param dz Bewegungsdistanz entlang der negativen Z-Achse des Basiskoordinatensystems; wenn dz = 10000, gibt die Funktion direkt das Werkzeug-RPY zurück
 8* @param TCPRPY Ausgabe-Objekt für die berechneten Werkzeug-RPY-Werte
 9* @return Fehlercode
10*/
11public int TCPComputeRPY(DescPose Btool, DescPose Etool, DescPose sensor, double radius, double dz, Rpy TCPRPY)

6.68. Photoelektrischer Sensor TCP-Kalibrierung - Werkzeug-XYZ berechnen

 1/**
 2* @brief Photoelektrischer Sensor TCP-Kalibrierung - Werkzeug-XYZ berechnen
 3* @param select 0 - Werkzeug-TCP berechnen, 1 - Sensorursprung berechnen, 2 - Sensorausrichtung berechnen, 3 - Werkzeug-TCP direkt zurückgeben, 4 - Aktuelles Werkstück- und Werkzeugkoordinatensystem aufzeichnen
 4* @param originDirection 0 - X-Richtung, 1 - Y-Richtung, 2 - Z-Richtung
 5* @param pos1 Roboter-Kartesische Position 1 (nur Translation)
 6* @param pos2 Roboter-Kartesische Position 2 (nur Translation)
 7* @param pos3 Roboter-Kartesische Position 3 (nur Translation)
 8* @param pos4 Roboter-Kartesische Position 4 (nur Translation)
 9* @param TCP Ausgabe-Objekt für die berechneten Werkzeug-XYZ-Werte
10* @return Fehlercode
11*/
12public int TCPComputeXYZ(int select, double originDirection, DescTran pos1, DescTran pos2, DescTran pos3, DescTran pos4, DescTran TCP)

6.69. Photoelektrischer Sensor TCP-Kalibrierung - Aufzeichnung der Flanschmittelpunkt-Position starten

1/**
2* @brief Photoelektrischer Sensor TCP-Kalibrierung - Aufzeichnung der Flanschmittelpunkt-Position starten
3* @return Fehlercode
4*/
5public int TCPRecordFlangePosStart()

6.70. Photoelektrischer Sensor TCP-Kalibrierung - Aufzeichnung der Flanschmittelpunkt-Position stoppen

1/**
2* @brief Photoelektrischer Sensor TCP-Kalibrierung - Aufzeichnung der Flanschmittelpunkt-Position stoppen
3* @return Fehlercode
4*/
5public int TCPRecordFlangePosEnd()

6.71. Photoelektrischer Sensor TCP-Kalibrierung - Position des Werkzeugmittelpunkts abrufen

1/**
2* @brief Photoelektrischer Sensor TCP-Kalibrierung - Position des Werkzeugmittelpunkts abrufen
3* @param TCP Ausgabe-Objekt für die Position (x,y,z)
4* @return Fehlercode
5*/
6public int TCPGetRecordFlangePos(DescTran TCP)

6.72. Photoelektrischer Sensor TCP-Kalibrierung (automatisiert)

1/**
2* @brief Photoelektrischer Sensor TCP-Kalibrierung (automatisiert)
3* @param luaPath Pfad zum automatischen Kalibrierungs-Lua-Programm: QX-Roboter - "/fruser/FR_CalibrateTheToolTcp.lua"; LA-Roboter - "/usr/local/etc/controller/lua/FR_CalibrateTheToolTcp.lua"
4* @param offset Versatz der Teachpunkte (x, y, z) [mm]
5* @param TCP Ausgabe-Objekt für das kalibrierte Werkzeugkoordinatensystem (x, y, z, rx, ry, rz)
6* @return Fehlercode
7*/
8public int PhotoelectricSensorTCPCalibration(String luaPath, DescTran offset, DescPose TCP)

6.73. Codebeispiel für photoelektrische Sensor TCP-Kalibrierung

1public static void TestPhotoelectricSensorTCPCalib(Robot robot)
2{
3    DescTran offset = new DescTran(10.0, 10.0, 3.0 );
4    DescPose TCP = new DescPose();
5    int rtn = robot.PhotoelectricSensorTCPCalibration("/fruser/FR_CalibrateTheToolTcp.lua", offset, TCP);
6    System.out.printf("PhotoelectricSensorTCPCalibration rtn is %d %f %f %f %f %f %f \n", rtn, TCP.tran.x, TCP.tran.y, TCP.tran.z, TCP.rpy.rx, TCP.rpy.ry, TCP.rpy.rz);
7    robot.CloseRPC();
8    robot.Sleep(9999999);
9}