4. Roboterbewegung

4.1. JOG-Tippbetrieb

 1/**
 2* @brief JOG-Tippbetrieb
 3* @param [in] refType Tippbetrieb-Typ: 0-Gelenk-JOG, 2-JOG im Basiskoordinatensystem, 4-JOG im Werkzeugkoordinatensystem, 8-JOG im Werkstückkoordinatensystem
 4* @param [in] nb 1-Gelenk 1 (oder x-Achse), 2-Gelenk 2 (oder y-Achse), 3-Gelenk 3 (oder z-Achse), 4-Gelenk 4 (oder Rotation um x-Achse), 5-Gelenk 5 (oder Rotation um y-Achse), 6-Gelenk 6 (oder Rotation um z-Achse)
 5* @param [in] dir 0-negative Richtung, 1-positive Richtung
 6* @param [in] vel Geschwindigkeitsprozentsatz, [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, [0~100]
 8* @param [in] max_dis Maximaler Winkel pro Tippbewegung [°] oder Distanz [mm]
 9* @return Fehlercode
10*/
11int StartJOG(byte refType, byte nb, byte dir, float vel, float acc, float max_dis);

4.2. JOG-Tippbetrieb mit Verzögerung stoppen

1/**
2* @brief JOG-Tippbetrieb mit Verzögerung stoppen
3* @param [in] stopType 1-Gelenk-JOG stoppen, 3-JOG im Basiskoordinatensystem stoppen, 5-JOG im Werkzeugkoordinatensystem stoppen, 9-JOG im Werkstückkoordinatensystem stoppen
4* @return Fehlercode
5*/
6int StopJOG(byte stopType);

4.3. JOG-Tippbetrieb sofort stoppen

1/**
2* @brief JOG-Tippbetrieb sofort stoppen
3* @return Fehlercode
4*/
5int ImmStopJOG();

4.4. Codebeispiel für Roboter-JOG-Steuerung

 1private void btnJOG_Click(object sender, EventArgs e)
 2{
 3    Robot robot = new Robot();
 4    robot.RPC("192.168.58.2");
 5
 6    robot.SetSpeed(35);
 7    robot.StartJOG(0, 1, 0, 15, 20.0f, 30.0f);   // Einzelgelenkbewegung, StartJOG ist nicht blockierend. Während der Bewegung empfangene Bewegungsbefehle (inkl. StartJOG) werden verworfen.
 8    Thread.Sleep(1000);
 9    robot.StopJOG(1);  // Verzögertes Stoppen der Einzelachsen-JOG-Bewegung
10    //robot.ImmStopJOG();  // Sofortiges Stoppen der Einzelachsen-JOG-Bewegung
11    robot.StartJOG(0, 2, 1, 15, 20.0f, 30.0f);
12    Thread.Sleep(1000);
13    robot.ImmStopJOG();
14    robot.StartJOG(0, 3, 1, 15, 20.0f, 30.0f);
15    Thread.Sleep(1000);
16    robot.ImmStopJOG();
17    robot.StartJOG(0, 4, 1, 15, 20.0f, 30.0f);
18    Thread.Sleep(1000);
19    robot.ImmStopJOG();
20    robot.StartJOG(0, 5, 1, 15, 20.0f, 30.0f);
21    Thread.Sleep(1000);
22    robot.ImmStopJOG();
23    robot.StartJOG(0, 6, 1, 15, 20.0f, 30.0f);
24    Thread.Sleep(1000);
25    robot.ImmStopJOG();
26
27    robot.StartJOG(2, 1, 0, 15, 20.0f, 30.0f);   // JOG im Basiskoordinatensystem
28    Thread.Sleep(1000);
29    robot.StopJOG(3);  // Verzögertes Stoppen
30    //robot.ImmStopJOG();
31    robot.StartJOG(2, 2, 1, 15, 20.0f, 30.0f);
32    Thread.Sleep(1000);
33    robot.ImmStopJOG();
34    robot.StartJOG(2, 3, 1, 15, 20.0f, 30.0f);
35    Thread.Sleep(1000);
36    robot.ImmStopJOG();
37    robot.StartJOG(2, 4, 1, 15, 20.0f, 30.0f);
38    Thread.Sleep(1000);
39    robot.ImmStopJOG();
40    robot.StartJOG(2, 5, 1, 15, 20.0f, 30.0f);
41    Thread.Sleep(1000);
42    robot.ImmStopJOG();
43    robot.StartJOG(2, 6, 1, 15, 20.0f, 30.0f);
44    Thread.Sleep(1000);
45    robot.ImmStopJOG();
46
47    robot.StartJOG(4, 1, 0, 15, 20.0f, 30.0f);   // JOG im Werkzeugkoordinatensystem
48    Thread.Sleep(1000);
49    robot.StopJOG(5);
50    //robot.ImmStopJOG();
51    robot.StartJOG(4, 2, 1, 15, 20.0f, 30.0f);
52    Thread.Sleep(1000);
53    robot.ImmStopJOG();
54    robot.StartJOG(4, 3, 1, 15, 20.0f, 30.0f);
55    Thread.Sleep(1000);
56    robot.ImmStopJOG();
57    robot.StartJOG(4, 4, 1, 15, 20.0f, 30.0f);
58    Thread.Sleep(1000);
59    robot.ImmStopJOG();
60    robot.StartJOG(4, 5, 1, 15, 20.0f, 30.0f);
61    Thread.Sleep(1000);
62    robot.ImmStopJOG();
63    robot.StartJOG(4, 6, 1, 15, 20.0f, 30.0f);
64    Thread.Sleep(1000);
65    robot.ImmStopJOG();
66
67    robot.StartJOG(8, 1, 0, 15, 20.0f, 30.0f);   // JOG im Werkstückkoordinatensystem
68    Thread.Sleep(1000);
69    robot.StopJOG(9);
70    //robot.ImmStopJOG();
71    robot.StartJOG(8, 2, 1, 15, 20.0f, 30.0f);
72    Thread.Sleep(1000);
73    robot.ImmStopJOG();
74    robot.StartJOG(8, 3, 1, 15, 20.0f, 30.0f);
75    Thread.Sleep(1000);
76    robot.ImmStopJOG();
77    robot.StartJOG(8, 4, 1, 15, 20.0f, 30.0f);
78    Thread.Sleep(1000);
79    robot.ImmStopJOG();
80    robot.StartJOG(8, 5, 1, 15, 20.0f, 30.0f);
81    Thread.Sleep(1000);
82    robot.ImmStopJOG();
83    robot.StartJOG(8, 6, 1, 15, 20.0f, 30.0f);
84    Thread.Sleep(1000);
85    robot.ImmStopJOG();
86}

4.5. Bewegung im Gelenkraum

 1/**
 2* @brief Bewegung im Gelenkraum
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
10* @param [in] epos Position der Erweiterungsachse [mm]
11* @param [in] blendT [-1.0]-Bewegung abschließen (blockierend), [0~500.0]-Glättungszeit (nicht blockierend) [ms]
12* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
13* @param [in] offset_pos Posenversatz
14* @return Fehlercode
15*/
16int MoveJ(JointPos joint_pos, DescPose desc_pos, int tool, int user, float vel, float acc, float ovl, ExaxisPos epos, float blendT, byte offset_flag, DescPose offset_pos);

4.6. Bewegung im Gelenkraum (automatische Vorwärtskinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Bewegung im Gelenkraum (automatische Vorwärtskinematik)
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
 9* @param [in] epos Position der Erweiterungsachse [mm]
10* @param [in] blendT [-1.0]-Bewegung abschließen (blockierend), [0~500.0]-Glättungszeit (nicht blockierend) [ms]
11* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
12* @param [in] offset_pos Posenversatz
13* @return Fehlercode
14*/
15int MoveJ(JointPos joint_pos, int tool, int user, double vel, double acc, double ovl, ExaxisPos epos, double blendT, int offset_flag, DescPose offset_pos)

4.7. Linearbewegung im kartesischen Raum

 1/**
 2* @brief Linearbewegung im kartesischen Raum
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor [0~100] / physikalische Geschwindigkeit [mm/s]
10* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
11* @param [in] blendMode Übergangsmodus; 0-Innenliegender Übergang; 1-Eckpunktübergang
12* @param [in] epos Position der Erweiterungsachse [mm]
13* @param [in] search 0-keine Schweißdrahtsuche, 1-Schweißdrahtsuche
14* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
15* @param [in] offset_pos Posenversatz
16* @param [in] oacc Beschleunigungsskalierungsfaktor [0-100] / physikalische Beschleunigung [mm/s²]
17* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
18* @param [in] overSpeedStrategy Strategie bei Übergeschwindigkeit, 1-Standard; 2-Fehlerstopp bei Übergeschwindigkeit; 3-adaptive Geschwindigkeitsreduzierung, Standard = 0
19* @param [in] speedPercent Erlaubter Schwellwert für Geschwindigkeitsreduzierung in Prozent [0-100], Standard 10%
20* @return Fehlercode
21*/
22public int MoveL(JointPos joint_pos, DescPose desc_pos, int tool, int user, float vel, float acc, float ovl, float blendR, int blendMode, ExaxisPos epos, int search, int offset_flag, DescPose offset_pos, float oacc, int velAccParamMode, int overSpeedStrategy = 0, int speedPercent = 10)

4.8. Linearbewegung im kartesischen Raum (automatische inverse Kinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Linearbewegung im kartesischen Raum (automatische inverse Kinematik)
 3* @param [in] desc_pos Ziel-Kartesische Pose
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [1~15]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [1~15]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
 9* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
10* @param [in] blendMode Übergangsmodus; 0-Innenliegender Übergang; 1-Eckpunktübergang
11* @param [in] epos Position der Erweiterungsachse [mm]
12* @param [in] search 0-keine Schweißdrahtsuche, 1-Schweißdrahtsuche
13* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
14* @param [in] offset_pos Posenversatz
15* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
16* @param [in] overSpeedStrategy Strategie bei Übergeschwindigkeit, 1-Standard; 2-Fehlerstopp bei Übergeschwindigkeit; 3-adaptive Geschwindigkeitsreduzierung, Standard = 0
17* @param [in] speedPercent Erlaubter Schwellwert für Geschwindigkeitsreduzierung in Prozent [0-100], Standard 10%
18* @return Fehlercode
19*/
20int MoveL(DescPose desc_pos, int tool, int user, double vel, double acc, double ovl, double blendR, int blendMode, ExaxisPos epos, int search, int offset_flag, DescPose offset_pos, int config, int overSpeedStrategy, int speedPercent)

4.9. Linearbewegung im kartesischen Raum (mit Parameter velAccParamMode)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Linearbewegung im kartesischen Raum (mit Parameter velAccParamMode)
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [1~15]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [1~15]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
10* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
11* @param [in] epos Position der Erweiterungsachse [mm]
12* @param [in] search 0-keine Schweißdrahtsuche, 1-Schweißdrahtsuche
13* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
14* @param [in] offset_pos Posenversatz
15* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
16* @param [in] overSpeedStrategy Strategie bei Übergeschwindigkeit, 1-Standard; 2-Fehlerstopp bei Übergeschwindigkeit; 3-adaptive Geschwindigkeitsreduzierung, Standard = 0
17* @param [in] speedPercent Erlaubter Schwellwert für Geschwindigkeitsreduzierung in Prozent [0-100], Standard 10%
18* @return Fehlercode
19*/
20public int MoveL(JointPos joint_pos, DescPose desc_pos, int tool, int user, double vel, double acc, double ovl, double blendR, ExaxisPos epos, int search, int offset_flag, DescPose offset_pos, int velAccParamMode, int overSpeedStrategy, int speedPercent)

4.10. Linearbewegung im kartesischen Raum (Überladung 1 mit blendMode)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Linearbewegung im kartesischen Raum (Überladung 1 mit blendMode)
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [1~15]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [1~15]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
10* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
11* @param [in] blendMode Übergangsmodus; 0-Innenliegender Übergang; 1-Eckpunktübergang
12* @param [in] epos Position der Erweiterungsachse [mm]
13* @param [in] search 0-keine Schweißdrahtsuche, 1-Schweißdrahtsuche
14* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
15* @param [in] offset_pos Posenversatz
16* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
17* @param [in] overSpeedStrategy Strategie bei Übergeschwindigkeit, 1-Standard; 2-Fehlerstopp bei Übergeschwindigkeit; 3-adaptive Geschwindigkeitsreduzierung, Standard = 0
18* @param [in] speedPercent Erlaubter Schwellwert für Geschwindigkeitsreduzierung in Prozent [0-100], Standard 10%
19* @return Fehlercode
20*/
21public int MoveL(JointPos joint_pos, DescPose desc_pos, int tool, int user, double vel, double acc, double ovl, double blendR, int blendMode, ExaxisPos epos, int search, int offset_flag, DescPose offset_pos, int velAccParamMode, int overSpeedStrategy, int speedPercent)

4.11. Linearbewegung im kartesischen Raum (Überladung 2 ohne Gelenkposition)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Linearbewegung im kartesischen Raum (Überladung 2 ohne Gelenkposition)
 3* @param [in] desc_pos Ziel-Kartesische Pose
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [1~15]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [1~15]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
 9* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
10* @param [in] blendMode Übergangsmodus; 0-Innenliegender Übergang; 1-Eckpunktübergang
11* @param [in] epos Position der Erweiterungsachse [mm]
12* @param [in] search 0-keine Schweißdrahtsuche, 1-Schweißdrahtsuche
13* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
14* @param [in] offset_pos Posenversatz
15* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
16* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
17* @param [in] overSpeedStrategy Strategie bei Übergeschwindigkeit, 1-Standard; 2-Fehlerstopp bei Übergeschwindigkeit; 3-adaptive Geschwindigkeitsreduzierung, Standard = 0
18* @param [in] speedPercent Erlaubter Schwellwert für Geschwindigkeitsreduzierung in Prozent [0-100], Standard 10%
19* @return Fehlercode
20*/
21public int MoveL(DescPose desc_pos, int tool, int user, double vel, double acc, double ovl, double blendR, int blendMode, ExaxisPos epos, int search, int offset_flag, DescPose offset_pos, int config, int velAccParamMode, int overSpeedStrategy, int speedPercent)

4.12. Kreisbogenbewegung im kartesischen Raum

 1/**
 2* @brief Kreisbogenbewegung im kartesischen Raum
 3* @param [in] joint_pos_p Gelenkposition des Zwischenpunkts [°]
 4* @param [in] desc_pos_p Kartesische Pose des Zwischenpunkts
 5* @param [in] ptool Werkzeugkoordinatennummer für Zwischenpunkt, Bereich [0~14]
 6* @param [in] puser Werkstückkoordinatennummer für Zwischenpunkt, Bereich [0~14]
 7* @param [in] pvel Geschwindigkeitsprozentsatz für Zwischenpunkt, Bereich [0~100]
 8* @param [in] pacc Beschleunigungsprozentsatz für Zwischenpunkt, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] epos_p Position der Erweiterungsachse am Zwischenpunkt [mm]
10* @param [in] poffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zwischenpunkt)
11* @param [in] offset_pos_p Posenversatz für Zwischenpunkt
12* @param [in] joint_pos_t Gelenkposition des Zielpunkts [°]
13* @param [in] desc_pos_t Kartesische Pose des Zielpunkts
14* @param [in] ttool Werkzeugkoordinatennummer für Zielpunkt, Bereich [0~14]
15* @param [in] tuser Werkstückkoordinatennummer für Zielpunkt, Bereich [0~14]
16* @param [in] tvel Geschwindigkeitsprozentsatz für Zielpunkt, Bereich [0~100]
17* @param [in] tacc Beschleunigungsprozentsatz für Zielpunkt, Bereich [0~100], vorübergehend nicht freigegeben
18* @param [in] epos_t Position der Erweiterungsachse am Zielpunkt [mm]
19* @param [in] toffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zielpunkt)
20* @param [in] offset_pos_t Posenversatz für Zielpunkt
21* @param [in] ovl Geschwindigkeitsskalierungsfaktor [0~100] / physikalische Geschwindigkeit [mm/s]
22* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
23* @param [in] oacc Beschleunigungsskalierungsfaktor [0-100] / physikalische Beschleunigung [mm/s²]
24* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
25* @return Fehlercode
26*/
27public int MoveC(JointPos joint_pos_p, DescPose desc_pos_p, int ptool, int puser, float pvel, float pacc, ExaxisPos epos_p, int poffset_flag, DescPose offset_pos_p, JointPos joint_pos_t, DescPose desc_pos_t, int ttool, int tuser, float tvel, float tacc, ExaxisPos epos_t, int toffset_flag, DescPose offset_pos_t, float ovl, float blendR, float oacc, int velAccParamMode)

4.13. Kreisbogenbewegung im kartesischen Raum (automatische inverse Kinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Kreisbogenbewegung im kartesischen Raum (automatische inverse Kinematik)
 3* @param [in] desc_pos_p Kartesische Pose des Zwischenpunkts
 4* @param [in] ptool Werkzeugkoordinatennummer, Bereich [1~15]
 5* @param [in] puser Werkstückkoordinatennummer, Bereich [1~15]
 6* @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] epos_p Position der Erweiterungsachse am Zwischenpunkt [mm]
 9* @param [in] poffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zwischenpunkt)
10* @param [in] offset_pos_p Posenversatz für Zwischenpunkt
11* @param [in] desc_pos_t Kartesische Pose des Zielpunkts
12* @param [in] ttool Werkzeugkoordinatennummer, Bereich [1~15]
13* @param [in] tuser Werkstückkoordinatennummer, Bereich [1~15]
14* @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
15* @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
16* @param [in] epos_t Position der Erweiterungsachse am Zielpunkt [mm]
17* @param [in] toffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zielpunkt)
18* @param [in] offset_pos_t Posenversatz für Zielpunkt
19* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
20* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
21* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
22* @return Fehlercode
23*/
24int MoveC(DescPose desc_pos_p, int ptool, int puser, double pvel, double pacc, ExaxisPos epos_p, int poffset_flag, DescPose offset_pos_p, DescPose desc_pos_t, int ttool, int tuser, double tvel, double tacc, ExaxisPos epos_t, int toffset_flag, DescPose offset_pos_t, double ovl, double blendR, int config)

4.14. Kreisbogenbewegung im kartesischen Raum (mit Parameter velAccParamMode)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Kreisbogenbewegung im kartesischen Raum (mit Parameter velAccParamMode)
 3* @param [in] joint_pos_p Gelenkposition des Zwischenpunkts [°]
 4* @param [in] desc_pos_p Kartesische Pose des Zwischenpunkts
 5* @param [in] ptool Werkzeugkoordinatennummer, Bereich [1~15]
 6* @param [in] puser Werkstückkoordinatennummer, Bereich [1~15]
 7* @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] epos_p Position der Erweiterungsachse am Zwischenpunkt [mm]
10* @param [in] poffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zwischenpunkt)
11* @param [in] offset_pos_p Posenversatz für Zwischenpunkt
12* @param [in] joint_pos_t Gelenkposition des Zielpunkts [°]
13* @param [in] desc_pos_t Kartesische Pose des Zielpunkts
14* @param [in] ttool Werkzeugkoordinatennummer, Bereich [1~15]
15* @param [in] tuser Werkstückkoordinatennummer, Bereich [1~15]
16* @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
17* @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
18* @param [in] epos_t Position der Erweiterungsachse am Zielpunkt [mm]
19* @param [in] toffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zielpunkt)
20* @param [in] offset_pos_t Posenversatz für Zielpunkt
21* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
22* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
23* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
24* @return Fehlercode
25*/
26public int MoveC(JointPos joint_pos_p, DescPose desc_pos_p, int ptool, int puser, double pvel, double pacc, ExaxisPos epos_p, int poffset_flag, DescPose offset_pos_p, JointPos joint_pos_t, DescPose desc_pos_t, int ttool, int tuser, double tvel, double tacc, ExaxisPos epos_t, int toffset_flag, DescPose offset_pos_t, double ovl, double blendR, int velAccParamMode)

4.15. Kreisbogenbewegung im kartesischen Raum (Überladung 1 ohne Gelenkposition)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Kreisbogenbewegung im kartesischen Raum (Überladung 1 ohne Gelenkposition)
 3* @param [in] desc_pos_p Kartesische Pose des Zwischenpunkts
 4* @param [in] ptool Werkzeugkoordinatennummer, Bereich [1~15]
 5* @param [in] puser Werkstückkoordinatennummer, Bereich [1~15]
 6* @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] epos_p Position der Erweiterungsachse am Zwischenpunkt [mm]
 9* @param [in] poffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zwischenpunkt)
10* @param [in] offset_pos_p Posenversatz für Zwischenpunkt
11* @param [in] desc_pos_t Kartesische Pose des Zielpunkts
12* @param [in] ttool Werkzeugkoordinatennummer, Bereich [1~15]
13* @param [in] tuser Werkstückkoordinatennummer, Bereich [1~15]
14* @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
15* @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
16* @param [in] epos_t Position der Erweiterungsachse am Zielpunkt [mm]
17* @param [in] toffset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem (für Zielpunkt)
18* @param [in] offset_pos_t Posenversatz für Zielpunkt
19* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
20* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
21* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
22* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
23* @return Fehlercode
24*/
25public int MoveC(DescPose desc_pos_p, int ptool, int puser, double pvel, double pacc, ExaxisPos epos_p, int poffset_flag, DescPose offset_pos_p, DescPose desc_pos_t, int ttool, int tuser, double tvel, double tacc, ExaxisPos epos_t, int toffset_flag, DescPose offset_pos_t, double ovl, double blendR, int config, int velAccParamMode)

4.16. Punkt-zu-Punkt-Bewegung im kartesischen Raum

 1/**
 2* @brief Punkt-zu-Punkt-Bewegung im kartesischen Raum
 3* @param [in] desc_pos Ziel-Kartesische Pose im Basiskoordinatensystem
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
 9* @param [in] blendT [-1.0]-Bewegung abschließen (blockierend), [0~500.0]-Glättungszeit (nicht blockierend) [ms]
10* @param [in] config Konfiguration des Gelenkraums, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration, Standard = -1
11* @return Fehlercode
12*/
13int MoveCart(DescPose desc_pos, int tool, int user, float vel, float acc, float ovl, float blendT, int config);

4.17. Vollkreisbewegung im kartesischen Raum

Neu in Version C#SDK-V1.1.4: Web-3.8.3

 1/**
 2* @brief Vollkreisbewegung im kartesischen Raum
 3* @param [in] joint_pos_p Gelenkposition des ersten Pfadpunkts [°]
 4* @param [in] desc_pos_p Kartesische Pose des ersten Pfadpunkts
 5* @param [in] ptool Werkzeugkoordinatennummer, Bereich [0~14]
 6* @param [in] puser Werkstückkoordinatennummer, Bereich [0~14]
 7* @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] epos_p Position der Erweiterungsachse am ersten Pfadpunkt [mm]
10* @param [in] joint_pos_t Gelenkposition des zweiten Pfadpunkts [°]
11* @param [in] desc_pos_t Kartesische Pose des zweiten Pfadpunkts
12* @param [in] ttool Werkzeugkoordinatennummer, Bereich [0~14]
13* @param [in] tuser Werkstückkoordinatennummer, Bereich [0~14]
14* @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
15* @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
16* @param [in] epos_t Position der Erweiterungsachse am zweiten Pfadpunkt [mm]
17* @param [in] ovl Geschwindigkeitsskalierungsfaktor [0~100] / physikalische Geschwindigkeit [mm/s]
18* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
19* @param [in] offset_pos Posenversatz
20* @param [in] oacc Beschleunigungsskalierungsfaktor [0-100] / physikalische Beschleunigung [mm/s²]
21* @param [in] blendR -1: blockierend; 0~1000: Glättungsradius
22* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
23* @return Fehlercode
24*/
25public int Circle(JointPos joint_pos_p, DescPose desc_pos_p, int ptool, int puser, float pvel, float pacc, ExaxisPos epos_p, JointPos joint_pos_t, DescPose desc_pos_t, int ttool, int tuser, float tvel, float tacc, ExaxisPos epos_t, float ovl, int offset_flag, DescPose offset_pos, double oacc, double blendR, int velAccParamMode)

4.18. Vollkreisbewegung im kartesischen Raum (automatische inverse Kinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2 * @brief Vollkreisbewegung im kartesischen Raum (automatische inverse Kinematik)
 3 * @param [in] desc_pos_p Kartesische Pose des ersten Pfadpunkts
 4 * @param [in] ptool Werkzeugkoordinatennummer, Bereich [0~14]
 5 * @param [in] puser Werkstückkoordinatennummer, Bereich [0~14]
 6 * @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7 * @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8 * @param [in] epos_p Position der Erweiterungsachse am ersten Pfadpunkt [mm]
 9 * @param [in] desc_pos_t Kartesische Pose des zweiten Pfadpunkts
10 * @param [in] ttool Werkzeugkoordinatennummer, Bereich [0~14]
11 * @param [in] tuser Werkstückkoordinatennummer, Bereich [0~14]
12 * @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
13 * @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
14 * @param [in] epos_t Position der Erweiterungsachse am zweiten Pfadpunkt [mm]
15 * @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
16 * @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
17 * @param [in] offset_pos Posenversatz
18 * @param [in] oacc Beschleunigungsprozentsatz
19 * @param [in] blendR -1: blockierend; 0~1000: Glättungsradius
20 * @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
21 * @return Fehlercode
22 */
23int Circle(DescPose desc_pos_p, int ptool, int puser, double pvel, double pacc, ExaxisPos epos_p, DescPose desc_pos_t, int ttool, int tuser, double tvel, double tacc, ExaxisPos epos_t, double ovl, int offset_flag, DescPose offset_pos, double oacc, double blendR, int config)

4.19. Vollkreisbewegung im kartesischen Raum (mit Parameter velAccParamMode)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Vollkreisbewegung im kartesischen Raum (mit Parameter velAccParamMode)
 3* @param [in] joint_pos_p Gelenkposition des ersten Pfadpunkts [°]
 4* @param [in] desc_pos_p Kartesische Pose des ersten Pfadpunkts
 5* @param [in] ptool Werkzeugkoordinatennummer, Bereich [1~15]
 6* @param [in] puser Werkstückkoordinatennummer, Bereich [1~15]
 7* @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] epos_p Position der Erweiterungsachse am ersten Pfadpunkt [mm]
10* @param [in] joint_pos_t Gelenkposition des zweiten Pfadpunkts [°]
11* @param [in] desc_pos_t Kartesische Pose des zweiten Pfadpunkts
12* @param [in] ttool Werkzeugkoordinatennummer, Bereich [1~15]
13* @param [in] tuser Werkstückkoordinatennummer, Bereich [1~15]
14* @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
15* @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
16* @param [in] epos_t Position der Erweiterungsachse am zweiten Pfadpunkt [mm]
17* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
18* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
19* @param [in] offset_pos Posenversatz
20* @param [in] oacc Beschleunigungsprozentsatz
21* @param [in] blendR -1: blockierend; 0~1000: Glättungsradius
22* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
23* @return Fehlercode
24*/
25public int Circle(JointPos joint_pos_p, DescPose desc_pos_p, int ptool, int puser, double pvel, double pacc, ExaxisPos epos_p, JointPos joint_pos_t, DescPose desc_pos_t, int ttool, int tuser, double tvel, double tacc, ExaxisPos epos_t, double ovl, int offset_flag, DescPose offset_pos, double oacc, double blendR, int velAccParamMode)

4.20. Vollkreisbewegung im kartesischen Raum (Überladung 1 ohne Gelenkposition)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Vollkreisbewegung im kartesischen Raum (Überladung 1 ohne Gelenkposition)
 3* @param [in] desc_pos_p Kartesische Pose des ersten Pfadpunkts
 4* @param [in] ptool Werkzeugkoordinatennummer, Bereich [0~14]
 5* @param [in] puser Werkstückkoordinatennummer, Bereich [0~14]
 6* @param [in] pvel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] pacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] epos_p Position der Erweiterungsachse am ersten Pfadpunkt [mm]
 9* @param [in] desc_pos_t Kartesische Pose des zweiten Pfadpunkts
10* @param [in] ttool Werkzeugkoordinatennummer, Bereich [0~14]
11* @param [in] tuser Werkstückkoordinatennummer, Bereich [0~14]
12* @param [in] tvel Geschwindigkeitsprozentsatz, Bereich [0~100]
13* @param [in] tacc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
14* @param [in] epos_t Position der Erweiterungsachse am zweiten Pfadpunkt [mm]
15* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
16* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
17* @param [in] offset_pos Posenversatz
18* @param [in] oacc Beschleunigungsprozentsatz
19* @param [in] blendR -1: blockierend; 0~1000: Glättungsradius
20* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
21* @param [in] velAccParamMode Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit [mm/s] / Beschleunigung [mm/s²]
22* @return Fehlercode
23*/
24public int Circle(DescPose desc_pos_p, int ptool, int puser, double pvel, double pacc, ExaxisPos epos_p, DescPose desc_pos_t, int ttool, int tuser, double tvel, double tacc, ExaxisPos epos_t, double ovl, int offset_flag, DescPose offset_pos, double oacc, double blendR, int config, int velAccParamMode)

4.21. Codebeispiel für Vollkreisbewegung im kartesischen Raum

Neu in Version C#SDK-V1.1.4: Web-3.8.3

 1private void btnMovetest_Click(object sender, EventArgs e)
 2{
 3    int rtn = 0;
 4    DescPose middescPoseCir1 = new DescPose(-435.414, -342.926, 309.205, -171.382, -4.513, 171.520);
 5    JointPos midjointPosCir1 = new JointPos(26.804, -79.866, 106.642, -125.433, -85.562, -54.721);
 6    DescPose enddescPoseCir1 = new DescPose(-524.862, -217.402, 308.459, -171.425, -4.810, 156.088);
 7    JointPos endjointPosCir1 = new JointPos(11.399, -78.055, 104.603, -125.421, -85.770, -54.721);
 8
 9    DescPose middescPoseCir2 = new DescPose(-482.691, -587.899, 318.594, -171.001, -4.999, -172.996);
10    JointPos midjointPosCir2 = new JointPos(42.314, -53.600, 67.296, -112.969, -85.533, -54.721);
11    DescPose enddescPoseCir2 = new DescPose(-403.942, -489.061, 317.038, -163.189, -10.425, -175.627);
12    JointPos endjointPosCir2 = new JointPos(39.959, -70.616, 96.679, -134.243, -82.276, -54.721);
13
14    DescPose middescPoseMoveC = new DescPose(-435.414, -342.926, 309.205, -171.382, -4.513, 171.520);
15    JointPos midjointPosMoveC = new JointPos(26.804, -79.866, 106.642, -125.433, -85.562, -54.721);
16    DescPose enddescPoseMoveC = new DescPose(-524.862, -217.402, 308.459, -171.425, -4.810, 156.088);
17    JointPos endjointPosmoveC = new JointPos(11.399, -78.055, 104.603, -125.421, -85.770, -54.721);
18
19    DescPose middescPoseCir3 = new DescPose(-435.414, -342.926, 309.205, -171.382, -4.513, 171.520);
20    JointPos midjointPosCir3 = new JointPos(26.804, -79.866, 106.642, -125.433, -85.562, -54.721);
21    DescPose enddescPoseCir3 = new DescPose(-569.505, -405.378, 357.596, -172.862, -10.939, 171.108);
22    JointPos endjointPosCir3 = new JointPos(27.138, -63.750, 78.586, -117.861, -90.588, -54.721);
23
24    DescPose middescPoseCir4 = new DescPose(-482.691, -587.899, 318.594, -171.001, -4.999, -172.996);
25    JointPos midjointPosCir4 = new JointPos(42.314, -53.600, 67.296, -112.969, -85.533, -54.721);
26    DescPose enddescPoseCir4 = new DescPose(-569.505, -405.378, 357.596, -172.862, -10.939, 171.108);
27    JointPos endjointPosCir4 = new JointPos(27.138, -63.750, 78.586, -117.861, -90.588, -54.721);
28
29    DescPose startdescPose = new DescPose(-569.505, -405.378, 357.596, -172.862, -10.939, 171.108);
30    JointPos startjointPos = new JointPos(27.138, -63.750, 78.586, -117.861, -90.588, -54.721);
31
32    DescPose linedescPose = new DescPose(-403.942, -489.061, 317.038, -163.189, -10.425, -175.627);
33    JointPos linejointPos = new JointPos(39.959, -70.616, 96.679, -134.243, -82.276, -54.721);
34
35    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
36    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);
37
38    robot.MoveJ(startjointPos, startdescPose, 3, 0, 100, 100, 100, exaxisPos, -1, 0, offdese);
39    rtn = robot.Circle(midjointPosCir1, middescPoseCir1, 3, 0, 100, 100, exaxisPos, endjointPosCir1, enddescPoseCir1, 3, 0, 100, 100, exaxisPos, 100, -1, offdese, 100, 20);
40    Console.WriteLine("Circle1" + rtn);
41    rtn = robot.Circle(midjointPosCir2, middescPoseCir2, 3, 0, 100, 100, exaxisPos, endjointPosCir2, enddescPoseCir2, 3, 0, 100, 100, exaxisPos, 100, -1, offdese, 100, 20);
42    Console.WriteLine("Circle2" + rtn);
43
44    robot.MoveC(midjointPosMoveC, middescPoseMoveC, 3, 0, 100, 100, exaxisPos, 0, offdese, endjointPosmoveC, enddescPoseMoveC, 3, 0, 100, 100, exaxisPos, 0, offdese, 100, 20);
45    rtn = robot.Circle(midjointPosCir3, middescPoseCir3, 3, 0, 100, 100, exaxisPos, endjointPosCir3, enddescPoseCir3, 3, 0, 100, 100, exaxisPos, 100, -1, offdese, 100, 20);
46    Console.WriteLine("Circle3" + rtn);
47    rtn = robot.MoveL(linejointPos, linedescPose, 3, 0, 100, 100, 100, -1, 0, exaxisPos, 0, 0, offdese);
48    Console.WriteLine("MoveL " + rtn);
49    rtn = robot.Circle(midjointPosCir4, middescPoseCir4, 3, 0, 100, 100, exaxisPos, endjointPosCir4, enddescPoseCir4, 3, 0, 100, 100, exaxisPos, 100, -1, offdese, 100, 20);
50    Console.WriteLine("Circle4" + rtn);
51}

4.22. Codebeispiel für grundlegende Roboterbewegungsbefehle

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1public void TestMove()
 2{
 3    int rtn;
 4    JointPos j1 = new JointPos(-11.904f, -99.669f, 117.473f, -108.616f, -91.726f, 74.256f);
 5    JointPos j2 = new JointPos(-45.615f, -106.172f, 124.296f, -107.151f, -91.282f, 74.255f);
 6    JointPos j3 = new JointPos(-29.777f, -84.536f, 109.275f, -114.075f, -86.655f, 74.257f);
 7    JointPos j4 = new JointPos(-31.154f, -95.317f, 94.276f, -88.079f, -89.740f, 74.256f);
 8    DescPose desc_pos1 = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
 9    DescPose desc_pos2 = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);
10    DescPose desc_pos3 = new DescPose(-487.434f, 154.362f, 308.576f, 176.600f, 0.268f, -14.061f);
11    DescPose desc_pos4 = new DescPose(-443.165f, 147.881f, 480.951f, 179.511f, -0.775f, -15.409f);
12    DescPose offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
13    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
14    int tool = 0;
15    int user = 0;
16    float vel = 100.0f;
17    float acc = 100.0f;
18    float ovl = 100.0f;
19    float oacc = 100.0f;
20    float blendT = 0.0f;
21    float blendR = 0.0f;
22    byte flag = 0;
23    byte search = 0;
24    int blendMode = 0;
25    int velAccMode = 0;
26    robot.SetSpeed(20);
27    rtn = robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
28    Console.WriteLine($"movej errcode:{rtn}");
29    rtn = robot.MoveL(j2, desc_pos2, tool, user, vel, acc, ovl, blendR, blendMode, epos, search, flag, offset_pos, oacc, velAccMode,0,10);
30    Console.WriteLine($"movel errcode:{rtn}");
31    rtn = robot.MoveC(j3, desc_pos3, tool, user, vel, acc, epos, flag, offset_pos,j4, desc_pos4, tool, user, vel, acc, epos, flag, offset_pos, ovl, blendR, oacc, velAccMode);
32    Console.WriteLine($"movec errcode:{rtn}");
33    rtn = robot.MoveJ(j2, desc_pos2, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
34    Console.WriteLine($"movej errcode:{rtn}");
35    rtn = robot.Circle(j3, desc_pos3, tool, user, vel, acc, epos,j1, desc_pos1, tool, user, vel, acc, epos,ovl, flag, offset_pos, oacc, -1, velAccMode);
36    Console.WriteLine($"circle errcode:{rtn}");
37    rtn = robot.MoveCart(desc_pos4, tool, user, vel, acc, ovl, blendT, -1);
38    Console.WriteLine($"MoveCart errcode:{rtn}");
39    rtn = robot.MoveJ(j1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
40    Console.WriteLine($"movej errcode:{rtn}");
41    rtn = robot.MoveL(desc_pos2, tool, user, vel, acc, ovl, blendR, blendMode, epos, search, flag, offset_pos, -1, velAccMode,0,10);
42    Console.WriteLine($"movel errcode:{rtn}");
43    rtn = robot.MoveC(desc_pos3, tool, user, vel, acc, epos, flag, offset_pos,desc_pos4, tool, user, vel, acc, epos, flag, offset_pos,ovl, blendR, -1, velAccMode);
44    Console.WriteLine($"movec errcode:{rtn}");
45    rtn = robot.MoveJ(j2, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
46    Console.WriteLine($"movej errcode:{rtn}");
47    rtn = robot.Circle(desc_pos3, tool, user, vel, acc, epos, desc_pos1, tool, user, vel, acc, epos,ovl, flag, offset_pos, oacc, blendR, -1, velAccMode);
48    Console.WriteLine($"circle errcode:{rtn}");
49}

4.23. Spiralbewegung im kartesischen Raum

 1/**
 2* @brief Spiralbewegung im kartesischen Raum
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] epos Position der Erweiterungsachse [mm]
10* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
11* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
12* @param [in] offset_pos Posenversatz
13* @param [in] spiral_param Spiralparameter
14* @return Fehlercode
15*/
16int NewSpiral(JointPos joint_pos, DescPose desc_pos, int tool, int user, float vel, float acc, ExaxisPos epos, float ovl, byte offset_flag, DescPose offset_pos, SpiralParam spiral_param);

4.24. Spiralbewegung im kartesischen Raum (automatische inverse Kinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Spiralbewegung im kartesischen Raum (automatische inverse Kinematik)
 3* @param [in] desc_pos Ziel-Kartesische Pose
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] epos Position der Erweiterungsachse [mm]
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
10* @param [in] offset_flag 0-kein Versatz, 1-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
11* @param [in] offset_pos Posenversatz
12* @param [in] spiral_param Spiralparameter
13* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
14* @return Fehlercode
15*/
16int NewSpiral(DescPose desc_pos, int tool, int user, double vel, double acc, ExaxisPos epos, double ovl, int offset_flag, DescPose offset_pos, SpiralParam spiral_param, int config)

4.25. Codebeispiel für Spiralbewegung

 1public static int TestSpiral(Robot robot)
 2{
 3    int rtn=-1;
 4    JointPos j=new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 5    DescPose desc_pos=new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 6    DescPose offset_pos1=new DescPose(50, 0, 0, -30, 0, 0);
 7    DescPose offset_pos2=new DescPose(50, 0, 0, -5, 0, 0);
 8    ExaxisPos epos=new ExaxisPos(0, 0, 0, 0);
 9    SpiralParam sp=new SpiralParam(1,5.0,50.0,10.0,10.0,0);
10
11    int tool = 0;
12    int user = 0;
13    double vel = 100.0;
14    double acc = 100.0;
15    double ovl = 100.0;
16    double blendT = 0.0;
17    int flag = 2;
18
19    rtn = robot.MoveJ(j, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos1);
20     Console.WriteLine("movej errcode:"+ rtn);
21
22    rtn = robot.NewSpiral(desc_pos, tool, user, vel, acc, epos, ovl, flag, offset_pos2, sp,-1);
23    Console.WriteLine("newspiral errcode:"+ rtn);
24
25    return 0;
26}

4.26. Servobewegung starten

1/**
2* @brief Servobewegung starten, zur Verwendung mit ServoJ, ServoCart Befehlen
3* @return Fehlercode
4*/
5int ServoMoveStart();

4.27. Servobewegung beenden

1/**
2* @brief Servobewegung beenden, zur Verwendung mit ServoJ, ServoCart Befehlen
3* @return Fehlercode
4*/
5int ServoMoveEnd();

4.28. Servobewegung im Gelenkraum

Neu in Version C#SDK-V1.1.4: Web-3.8.3

 1/**
 2* @brief Servobewegung im Gelenkraum
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben, Standard = 0
 5* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben, Standard = 0
 6* @param [in] cmdT Befehlszyklus [s], empfohlener Bereich [0.001~0.0016]
 7* @param [in] filterT Filterzeit [s], vorübergehend nicht freigegeben, Standard = 0
 8* @param [in] gain Proportionalverstärkung der Zielposition, vorübergehend nicht freigegeben, Standard = 0
 9* @param [in] id ServoJ Befehls-ID, Standard = 0
10* @return Fehlercode
11*/
12int ServoJ(JointPos joint_pos, float acc, float vel, float cmdT, float filterT, float gain, int id=0);

4.29. Codebeispiel für Servobewegung im Gelenkraum

Neu in Version C#SDK-V1.1.4: Web-3.8.3

 1private void btnJointServoMove_Click(object sender, EventArgs e)
 2{
 3    JointPos j = new JointPos(0, 0, 0, 0, 0, 0);
 4    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
 5
 6    float vel = 0.0f;
 7    float acc = 0.0f;
 8    float cmdT = 0.008f;
 9    float filterT = 0.0f;
10    float gain = 0.0f;
11    byte flag = 0;
12    int count = 500;
13    float dt = 0.1f;
14    int cmdID = 0;
15    int ret = robot.GetActualJointPosDegree(flag, ref j);
16    if (ret == 0)
17    {
18        robot.ServoMoveStart();
19
20        try
21        {
22            while (count > 0)
23            {
24
25                robot.ServoJ(j, epos, acc, vel, cmdT, filterT, gain, cmdID);
26
27                j.jPos[0] += dt;
28                count--;
29
30                robot.WaitMs((int)(cmdT * 1000));
31            }
32        }
33        finally
34        {
35
36            robot.ServoMoveEnd();
37        }
38    }
39    else
40    {
41        Console.WriteLine($"GetActualJointPosDegree error code: {ret}");
42    }
43}

4.30. Gelenkmomentsteuerung starten

1/**
2* @brief Gelenkmomentsteuerung starten
3* @return Fehlercode
4*/
5int ServoJTStart();

4.31. Gelenkmomentsteuerung

 1/**
 2* @brief Gelenkmomentsteuerung
 3* @param [in] torque Gelenkmomente j1~j6 [Nm]
 4* @param [in] interval Befehlszyklus [s], Bereich [0.001~0.008]
 5* @param [in] checkFlag Erkennungsstrategie 0-keine Einschränkung; 1-Leistungsbegrenzung; 2-Geschwindigkeitsbegrenzung; 3-Leistungs- und Geschwindigkeitsbegrenzung
 6* @param [in] jPowerLimit Maximale Gelenkleistungsbegrenzung [W]
 7* @param [in] jVelLimit Maximale Gelenkgeschwindigkeit [°/s]
 8* @return Fehlercode
 9*/
10public int ServoJT(double[] torque, double interval, int checkFlag, double[] jPowerLimit, double[] jVelLimit)

4.32. Gelenkmomentsteuerung beenden

1/**
2* @brief Gelenkmomentsteuerung beenden
3* @return Fehlercode
4*/
5int ServoJTEnd();

4.33. Codebeispiel für Gelenkmomentsteuerung

 1private void button27_Click(object sender, EventArgs e)
 2{
 3    robot.DragTeachSwitch(1);
 4    robot.SetPowerLimit(1, 200);
 5    double[] torques = { 0, 0, 0, 0, 0, 0 };
 6    robot.GetJointTorques(1, torques);
 7
 8    int count = 100;
 9    robot.ServoJTStart();
10    int error = 0;
11    while (count > 0)
12    {
13        error = robot.ServoJT(torques, 0.001f);
14        count--;
15        Thread.Sleep(1);
16    }
17    error = robot.ServoJTEnd();
18    robot.DragTeachSwitch(0);
19}

4.34. Codebeispiel für Gelenkmomentsteuerung mit Übergeschwindigkeitsschutz

 1public int ServoJTWithSafety()
 2{
 3    robot.ResetAllError();
 4    Thread.Sleep(500);
 5
 6    double[] torques = new double[6] { 0, 0, 0, 0, 0, 0 };
 7    robot.GetJointTorques(1, torques);
 8
 9    robot.ServoJTStart();
10    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
11    robot.DragTeachSwitch(1);
12
13    int checkFlag = 0;
14    double[] jPowerLimit = new double[6] { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
15    //double[] jPowerLimit = new double[6] { 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 };
16    // double[] jVelLimit = new double[6] { 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 };
17    double[] jVelLimit = new double[6] {50, 50, 50, 50, 50, 50 };
18    int count = 80000;
19    int errorNum = 0;
20    int error = 0;
21    while (count > 0)
22    {
23
24        torques[2] = torques[2] + 0.01;
25        error = robot.ServoJT(torques, 0.008, checkFlag, jPowerLimit, jVelLimit);
26
27        Console.WriteLine($"ServoJT rtn is {error}");
28        count = count - 1;
29        Thread.Sleep(1);
30
31        robot.GetRobotRealTimeState(ref pkg);
32        Console.WriteLine($"maincode {pkg.main_code}, subcode {pkg.sub_code}");
33        if (error != 0)
34        {
35            errorNum++;
36            if (errorNum > 5)
37            {
38                break;
39            }
40
41        }
42    }
43    robot.DragTeachSwitch(0);
44    error = robot.ServoJTEnd();
45
46    return 0;
47}

4.35. Servobewegung im kartesischen Raum

 1/**
 2* @brief Servobewegung im kartesischen Raum
 3* @param [in] mode 0-Absolutbewegung (Basiskoordinatensystem), 1-Inkrementalbewegung (Basiskoordinatensystem), 2-Inkrementalbewegung (Werkzeugkoordinatensystem)
 4* @param [in] desc_pose Ziel-Kartesische Pose oder Poseninkrement
 5* @param [in] exaxis Position der Erweiterungsachse
 6* @param [in] pos_gain Proportionalitätsfaktor für das Poseninkrement, nur bei inkrementeller Bewegung wirksam, Bereich [0~1]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben, Standard = 0
 8* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben, Standard = 0
 9* @param [in] cmdT Befehlszyklus [s], empfohlener Bereich [0.001~0.016]
10* @param [in] filterT Filterzeit [s], vorübergehend nicht freigegeben, Standard = 0
11* @param [in] gain Proportionalverstärkung der Zielposition, vorübergehend nicht freigegeben, Standard = 0
12* @return Fehlercode
13*/
14public int ServoCart(int mode, DescPose desc_pose, ExaxisPos exaxis, double[] pos_gain, double acc, double vel, double cmdT, double filterT, double gain);

4.36. Codebeispiel für Servobewegung im kartesischen Raum

 1public void TestServoCart()
 2{
 3    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
 4
 5    int rtn;
 6    DescPose desc_pos_dt = new DescPose(83.00800f, 50.525000f, 29.246f, 179.629f, -7.138f, -166.975f);
 7    ExaxisPos exaxis = new ExaxisPos(100.0f, 0.0f, 0.0f, 0.0f);
 8    double[] pos_gain = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 9    int mode = 0;
10    float vel = 0.0f;
11    float acc = 0.0f;
12    float cmdT = 0.001f;
13    float filterT = 0.0f;
14    float gain = 0.0f;
15    byte flag = 0;
16    int count = 5000;
17
18    robot.SetSpeed(20);
19
20    while (count > 0)
21    {
22        rtn = robot.ServoCart(mode, desc_pos_dt, exaxis, pos_gain, acc, vel, cmdT, filterT, gain);
23        Console.WriteLine($"ServoCart rtn is {rtn}");
24        count -= 1;
25        desc_pos_dt.tran.x += 0.01f;
26        exaxis.ePos[0] += 0.01f;
27    }
28}

4.37. Spline-Bewegung starten

1/**
2* @brief Spline-Bewegung starten
3* @return Fehlercode
4*/
5int SplineStart();

4.38. Spline-PTP-Bewegung

 1/**
 2* @brief Spline-Bewegung im Gelenkraum
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
10* @return Fehlercode
11*/
12int SplinePTP(JointPos joint_pos, DescPose desc_pos, int tool, int user, float vel, float acc, float ovl);

4.39. Spline-PTP-Bewegung im Gelenkraum (automatische Vorwärtskinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Spline-Bewegung im Gelenkraum (automatische Vorwärtskinematik)
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
 9* @return Fehlercode
10*/
11int SplinePTP(JointPos joint_pos, int tool, int user, double vel, double acc, double ovl)

4.40. Spline-Bewegung beenden

1/**
2* @brief Spline-Bewegung beenden
3* @return Fehlercode
4*/
5int SplineEnd();

4.41. Codebeispiel für Spline-Bewegung

 1private void btnSplineMove_Click(object sender, EventArgs e)
 2{
 3    JointPos j1 = new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 4    JointPos j2 = new JointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
 5    JointPos j3 = new JointPos(-61.954, -84.409, 108.153, -116.316, -91.283, 74.260);
 6    JointPos j4 = new JointPos(-89.575, -80.276, 102.713, -116.302, -91.284, 74.267);
 7    DescPose desc_pos1 = new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 8    DescPose desc_pos2 = new DescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
 9    DescPose desc_pos3 = new DescPose(-327.622, 402.230, 320.402, -178.067, 2.127, -46.207);
10    DescPose desc_pos4 = new DescPose(-104.066, 544.321, 327.023, -177.715, 3.371, -73.818);
11    DescPose offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
12    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
13
14    int tool = 0;
15    int user = 0;
16    float vel = 100.0f;
17    float acc = 100.0f;
18    float ovl = 100.0f;
19    float blendT = -1.0f;
20    byte flag = 0;
21
22    robot.SetSpeed(20);
23
24    int err = -1;
25    err = robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
26    Console.WriteLine($"movej errcode:  {err}");
27
28    robot.SplineStart();
29    robot.SplinePTP(j1, desc_pos1, tool, user, vel, acc, ovl);
30    robot.SplinePTP(j2, desc_pos2, tool, user, vel, acc, ovl);
31    robot.SplinePTP(j3, desc_pos3, tool, user, vel, acc, ovl);
32    robot.SplinePTP(j4, desc_pos4, tool, user, vel, acc, ovl);
33    robot.SplineEnd();
34}

4.42. Neue Spline-Bewegung starten

Geändert in Version C#SDK-v1.0.6.

1/**
2* @brief Neue Spline-Bewegung starten
3* @param [in] type 0-Kreisbogenübergang, 1-Vorgegebene Punkte sind Pfadpunkte
4* @param [in] averageTime Globale durchschnittliche Verbindungszeit [ms] (10 ~ ), Standard 2000
5* @return Fehlercode
6*/
7int NewSplineStart(int type, int averageTime=2000);

4.43. Neuen Spline-Befehlspunkt hinzufügen

 1/**
 2* @brief Einen Befehlspunkt zur Spline-Bewegung hinzufügen
 3* @param [in] joint_pos Ziel-Gelenkposition [°]
 4* @param [in] desc_pos Ziel-Kartesische Pose
 5* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 6* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 7* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 8* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 9* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
10* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
11* @param [in] lastFlag Ob es der letzte Punkt ist, 0-nein, 1-ja
12* @return Fehlercode
13*/
14int NewSplinePoint(JointPos joint_pos, DescPose desc_pos, int tool, int user, float vel, float acc, float ovl, float blendR, int lastFlag);

4.44. Neuen Spline-Befehlspunkt hinzufügen (automatische inverse Kinematik)

Neu in Version C#SDK-V1.1.7: Web-3.8.5

 1/**
 2* @brief Neuen Spline-Befehlspunkt (automatische inverse Kinematik)
 3* @param [in] desc_pos Ziel-Kartesische Pose
 4* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
 5* @param [in] user Werkstückkoordinatennummer, Bereich [0~14]
 6* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
 7* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
 8* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
 9* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
10* @param [in] lastFlag Ob es der letzte Punkt ist, 0-nein, 1-ja
11* @param [in] config Konfiguration des Gelenkraums für inverse Kinematik, [-1]-Berechnung basierend auf aktueller Gelenkposition, [0~7]-Berechnung basierend auf spezifischer Gelenkraumkonfiguration
12* @return Fehlercode
13*/
14int NewSplinePoint(DescPose desc_pos, int tool, int user, double vel, double acc, double ovl, double blendR, int lastFlag, int config)

4.45. Neue Spline-Bewegung beenden

1/**
2* @brief Neue Spline-Bewegung beenden
3* @return Fehlercode
4*/
5int NewSplineEnd();

4.46. Codebeispiel für neue Spline-Bewegung

 1private void btnNewSpline_Click(object sender, EventArgs e)
 2{
 3    JointPos j1 = new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 4    JointPos j2 = new JointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
 5    JointPos j3 = new JointPos(-61.954, -84.409, 108.153, -116.316, -91.283, 74.260);
 6    JointPos j4 = new JointPos(-89.575, -80.276, 102.713, -116.302, -91.284, 74.267);
 7    JointPos j5 = new JointPos(-95.228, -54.621, 73.691, -112.245, -91.280, 74.268);
 8    DescPose desc_pos1 = new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 9    DescPose desc_pos2 = new DescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
10    DescPose desc_pos3 = new DescPose(-327.622, 402.230, 320.402, -178.067, 2.127, -46.207);
11    DescPose desc_pos4 = new DescPose(-104.066, 544.321, 327.023, -177.715, 3.371, -73.818);
12    DescPose desc_pos5 = new DescPose(-33.421, 732.572, 275.103, -177.907, 2.709, -79.482);
13    DescPose offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
14    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
15
16    int tool = 0;
17    int user = 0;
18    float vel = 100.0f;
19    float acc = 100.0f;
20    float ovl = 100.0f;
21    float blendT = -1.0f;
22    byte flag = 0;
23
24    robot.SetSpeed(20);
25
26    int err = -1;
27    err = robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
28    Console.WriteLine($"movej errcode:  {err}");
29
30    robot.NewSplineStart(1, 2000);
31    robot.NewSplinePoint(j1, desc_pos1, tool, user, vel, acc, ovl, -1, 0);
32    robot.NewSplinePoint(j2, desc_pos2, tool, user, vel, acc, ovl, -1, 0);
33    robot.NewSplinePoint(j3, desc_pos3, tool, user, vel, acc, ovl, -1, 0);
34    robot.NewSplinePoint(j4, desc_pos4, tool, user, vel, acc, ovl, -1, 0);
35    robot.NewSplinePoint(j5, desc_pos5, tool, user, vel, acc, ovl, -1, 0);
36    robot.NewSplineEnd();
37}

4.47. Bewegung abbrechen

1/**
2* @brief Bewegung abbrechen
3* @return Fehlercode
4*/
5int StopMotion();

4.48. Bewegung pausieren

1/**
2* @brief Bewegung pausieren
3* @return Fehlercode
4*/
5int PauseMotion();

4.49. Bewegung fortsetzen

1/**
2* @brief Bewegung fortsetzen
3* @return Fehlercode
4*/
5int ResumeMotion();

4.50. Codebeispiel für Bewegungspause, -fortsetzung und -abbruch

 1private void btnMotionPause_Click(object sender, EventArgs e)
 2{
 3    int rtn;
 4    JointPos j1 = new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 5    JointPos j5 = new JointPos(-95.228, -54.621, 73.691, -112.245, -91.280, 74.268);
 6    DescPose desc_pos1 = new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 7    DescPose desc_pos5 = new DescPose(-33.421, 732.572, 275.103, -177.907, 2.709, -79.482);
 8    DescPose offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
 9    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
10
11    int tool = 0;
12    int user = 0;
13    float vel = 100.0f;
14    float acc = 100.0f;
15    float ovl = 100.0f;
16    float blendT = -1.0f;
17    byte flag = 0;
18
19    robot.SetSpeed(20);
20
21    rtn = robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
22    rtn = robot.MoveJ(j5, desc_pos5, tool, user, vel, acc, ovl, epos, 1, flag, offset_pos);
23    Thread.Sleep(1000);
24    robot.PauseMotion();
25
26    Thread.Sleep(1000);
27    robot.ResumeMotion();
28
29    Thread.Sleep(1000);
30    robot.StopMotion();
31
32    Thread.Sleep(1000);
33}

4.51. Gesamtpunktversatz starten

1/**
2* @brief Gesamtpunktversatz starten
3* @param [in] flag 0-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem
4* @param [in] offset_pos Posenversatz
5* @return Fehlercode
6*/
7int PointsOffsetEnable(int flag, DescPose offset_pos);

4.52. Gesamtpunktversatz beenden

1/**
2* @brief Gesamtpunktversatz beenden
3* @return Fehlercode
4*/
5int PointsOffsetDisable();

4.53. Codebeispiel für Punktversatz

 1private void btnPointOffect_Click(object sender, EventArgs e)
 2{
 3    JointPos j1, j2;
 4    DescPose desc_pos1, desc_pos2, offset_pos, offset_pos1;
 5    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
 6
 7    j1 = new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 8    desc_pos1 = new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 9
10    j2 = new JointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
11
12    desc_pos2 = new DescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
13
14    offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
15    offset_pos1 = new DescPose(50.0, 50.0, 50.0, 5.0, 5.0, 5.0);
16
17    int tool = 0;
18    int user = 0;
19    float vel = 100.0f;
20    float acc = 100.0f;
21    float ovl = 100.0f;
22    float blendT = -1.0f;
23    byte flag = 0;
24    int type = 0;
25
26    robot.SetSpeed(20);
27
28    robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
29    robot.MoveJ(j2, desc_pos2, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
30    Thread.Sleep(1000);
31    robot.PointsOffsetEnable(type, offset_pos1);
32    Thread.Sleep(1000);
33    robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
34    robot.MoveJ(j2, desc_pos2, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
35    Thread.Sleep(1000);
36    robot.PointsOffsetDisable();
37}

4.54. AO-Fliegendes-Messen (Control Box) starten

Neu in Version C#SDK-v1.0.7.

1/**
2* @brief AO-Fliegendes-Messen (Control Box) starten
3* @param [in] AONum AO-Nummer der Control Box
4* @param [in] maxTCPSpeed Maximale TCP-Geschwindigkeit [1-5000mm/s], Standard 1000
5* @param [in] maxAOPercent AO-Prozentsatz entsprechend der maximalen TCP-Geschwindigkeit, Standard 100%
6* @param [in] zeroZoneCmp Totzonenkompensationswert als AO-Prozentsatz, Ganzzahl, Standard 20%, Bereich [0-100]
7* @return Fehlercode
8*/
9int MoveAOStart(int AONum, int maxTCPSpeed, int maxAOPercent, int zeroZoneCmp);

4.55. AO-Fliegendes-Messen (Control Box) stoppen

Neu in Version C#SDK-v1.0.7.

1/**
2* @brief AO-Fliegendes-Messen (Control Box) stoppen
3* @return Fehlercode
4*/
5int MoveAOStop();

4.56. AO-Fliegendes-Messen (Endeffektor) starten

Neu in Version C#SDK-v1.0.7.

1/**
2* @brief AO-Fliegendes-Messen (Endeffektor) starten
3* @param [in] AONum AO-Nummer des Endeffektors
4* @param [in] maxTCPSpeed Maximale TCP-Geschwindigkeit [1-5000mm/s], Standard 1000
5* @param [in] maxAOPercent AO-Prozentsatz entsprechend der maximalen TCP-Geschwindigkeit, Standard 100%
6* @param [in] zeroZoneCmp Totzonenkompensationswert als AO-Prozentsatz, Ganzzahl, Standard 20%, Bereich [0-100]
7* @return Fehlercode
8*/
9int MoveToolAOStart(int AONum, int maxTCPSpeed, int maxAOPercent, int zeroZoneCmp);

4.57. AO-Fliegendes-Messen (Endeffektor) stoppen

Neu in Version C#SDK-v1.0.7.

1/**
2* @brief AO-Fliegendes-Messen (Endeffektor) stoppen
3* @return Fehlercode
4*/
5int MoveToolAOStop();

4.58. Codebeispiel für AO-Fliegendes-Messen

 1private void btnMoveAO_Click(object sender, EventArgs e)
 2{
 3    JointPos j1 = new JointPos(-11.904, -99.669, 117.473, -108.616, -91.726, 74.256);
 4    JointPos j2 = new JointPos(-45.615, -106.172, 124.296, -107.151, -91.282, 74.255);
 5    DescPose desc_pos1 = new DescPose(-419.524, -13.000, 351.569, -178.118, 0.314, 3.833);
 6    DescPose desc_pos2 = new DescPose(-321.222, 185.189, 335.520, -179.030, -1.284, -29.869);
 7    DescPose offset_pos = new DescPose(0, 0, 0, 0, 0, 0);
 8    ExaxisPos epos = new ExaxisPos(0, 0, 0, 0);
 9
10    int tool = 0;
11    int user = 0;
12    float vel = 100.0f;
13    float acc = 100.0f;
14    float ovl = 100.0f;
15    float blendT = 0.0f;
16    float blendR = 0.0f;
17    byte flag = 0;
18    byte search = 0;
19
20    robot.SetSpeed(5);
21
22    robot.MoveAOStart(0,100,100,20);
23    robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
24    robot.MoveJ(j2, desc_pos2, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
25    robot.MoveAOStop();
26
27    robot.MoveToolAOStart(0, 100, 100, 20);
28    robot.MoveJ(j1, desc_pos1, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
29    robot.MoveJ(j2, desc_pos2, tool, user, vel, acc, ovl, epos, blendT, flag, offset_pos);
30    robot.MoveToolAOStop();
31}

4.59. PTP-Bewegung mit FIR-Filterung starten

Neu in Version C#SDK-V1.1.3: Web-3.8.2

1/**
2* @brief PTP-Bewegung mit FIR-Filterung starten
3* @param [in] maxAcc Maximale Beschleunigung [°/s²]
4* @param [in] maxJek Maximale Gelenkruck-Grenze [°/s³]
5* @return Fehlercode
6*/
7int PtpFIRPlanningStart(double maxAcc, double maxJek=1000);

4.60. PTP-Bewegung mit FIR-Filterung beenden

1/**
2* @brief PTP-Bewegung mit FIR-Filterung beenden
3* @return Fehlercode
4*/
5int PtpFIRPlanningEnd();

4.61. LIN-/ARC-Bewegung mit FIR-Filterung starten

1/**
2* @brief LIN-/ARC-Bewegung mit FIR-Filterung starten
3* @param [in] maxAccLin Maximale lineare Beschleunigung [mm/s²]
4* @param [in] maxAccDeg Maximale Winkelbeschleunigung [°/s²]
5* @param [in] maxJerkLin Maximale lineare Ruck-Grenze [mm/s³]
6* @param [in] maxJerkDeg Maximale Winkelruck-Grenze [°/s³]
7* @return Fehlercode
8*/
9int LinArcFIRPlanningStart(double maxAccLin, double maxAccDeg, double maxJerkLin, double maxJerkDeg);

4.62. LIN-/ARC-Bewegung mit FIR-Filterung beenden

1/**
2* @brief LIN-/ARC-Bewegung mit FIR-Filterung beenden
3* @return Fehlercode
4*/
5int LinArcFIRPlanningEnd();

4.63. Codebeispiel für FIR-Filterung

Neu in Version C#SDK-V1.1.3: Web-3.8.2

 1private void button69_Click(object sender, EventArgs e)
 2{
 3    int rtn;
 4    JointPos startjointPos = new JointPos(-11.904f, -99.669f, 117.473f, -108.616f, -91.726f, 74.256f);
 5    JointPos midjointPos = new JointPos(-45.615f, -106.172f, 124.296f, -107.151f, -91.282f, 74.255f);
 6    JointPos endjointPos = new JointPos(-29.777f, -84.536f, 109.275f, -114.075f, -86.655f, 74.257f);
 7
 8    DescPose startdescPose = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
 9    DescPose middescPose = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);
10    DescPose enddescPose = new DescPose(-487.434f, 154.362f, 308.576f, 176.600f, 0.268f, -14.061f);
11
12    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
13    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);
14
15    rtn = robot.PtpFIRPlanningStart(1000,1000);
16    Console.WriteLine("PtpFIRPlanningStart rtn is " + rtn);
17    robot.MoveJ( startjointPos,  startdescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
18    robot.MoveJ( endjointPos,  enddescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
19    robot.PtpFIRPlanningEnd();
20    Console.WriteLine("PtpFIRPlanningEnd rtn is " + rtn);
21
22    robot.LinArcFIRPlanningStart(1000, 1000, 1000, 1000);
23    Console.WriteLine("LinArcFIRPlanningStart rtn is " + rtn);
24    robot.MoveL( startjointPos,  startdescPose, 0, 0, 100, 100, 100, -1,  exaxisPos, 0, 0,  offdese, 1, 1);
25    robot.MoveC( midjointPos,  middescPose, 0, 0, 100, 100,  exaxisPos, 0,  offdese,  endjointPos,  enddescPose, 0, 0, 100, 100,  exaxisPos, 0,  offdese, 100, -1);
26    robot.LinArcFIRPlanningEnd();
27    Console.WriteLine("LinArcFIRPlanningEnd rtn is " + rtn);
28}

4.64. Beschleunigungsglättung aktivieren

1/**
2* @brief Beschleunigungsglättung aktivieren
3* @param [in] saveFlag Speichern bei Stromausfall (true/false)
4* @return Fehlercode
5*/
6int AccSmoothStart(bool saveFlag);

4.65. Beschleunigungsglättung deaktivieren

1/**
2* @brief Beschleunigungsglättung deaktivieren
3* @param [in] saveFlag Speichern bei Stromausfall (true/false)
4* @return Fehlercode
5*/
6int AccSmoothEnd(bool saveFlag);

4.66. Codebeispiel

 1private void button1_Click(object sender, EventArgs e)
 2{
 3
 4    int rtn;
 5    JointPos startjointPos = new JointPos(-11.904f, -99.669f, 117.473f, -108.616f, -91.726f, 74.256f);
 6    JointPos endjointPos = new JointPos(-45.615f, -106.172f, 124.296f, -107.151f, -91.282f, 74.255f);
 7
 8    DescPose startdescPose = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
 9    DescPose enddescPose = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);
10
11    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
12    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);
13    rtn = robot.AccSmoothStart(false);
14    Console.WriteLine("AccSmoothStart rtn is " + rtn);
15    robot.MoveJ( startjointPos,  startdescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
16    robot.MoveJ( endjointPos,  enddescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
17    rtn = robot.AccSmoothEnd(false);
18    Console.WriteLine("AccSmoothEnd rtn is " + rtn);
19}

4.67. Bestimmte Orientierungsgeschwindigkeit aktivieren

1/**
2* @brief Bestimmte Orientierungsgeschwindigkeit aktivieren
3* @param [in] ratio Orientierungsgeschwindigkeitsprozentsatz [0-300]
4* @return Fehlercode
5*/
6int AngularSpeedStart(int ratio);

4.68. Bestimmte Orientierungsgeschwindigkeit deaktivieren

1/**
2* @brief Bestimmte Orientierungsgeschwindigkeit deaktivieren
3* @return Fehlercode
4*/
5int AngularSpeedEnd();

4.69. Codebeispiel für Roboter mit bestimmter Orientierungsgeschwindigkeit

 1private void button71_Click(object sender, EventArgs e)
 2{
 3    int rtn;
 4    JointPos startjointPos = new JointPos(-11.904f, -99.669f, 117.473f, -108.616f, -91.726f, 74.256f);
 5    JointPos endjointPos = new JointPos(-45.615f, -106.172f, 124.296f, -107.151f, -91.282f, 74.255f);
 6
 7    DescPose startdescPose = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
 8    DescPose enddescPose = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);
 9
10    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
11    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);
12    rtn = robot.AngularSpeedStart(50);
13    Console.WriteLine("AngularSpeedStart rtn is " + rtn);
14    robot.MoveJ( startjointPos,  startdescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
15    robot.MoveJ( endjointPos,  enddescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
16    rtn = robot.AngularSpeedEnd();
17    Console.WriteLine("AngularSpeedEnd rtn is " + rtn);
18}

4.70. Singularitätsschutz starten

Neu in Version C#SDK-v1.0.9.

1/**
2* @brief Singularitätsschutz starten
3* @param [in] protectMode Singularitätsschutzmodus, 0: Gelenkmodus; 1-Kartesischer Modus
4* @param [in] minShoulderPos Schulter-Singularitätsanpassungsbereich [mm], Standard 100
5* @param [in] minElbowPos Ellenbogen-Singularitätsanpassungsbereich [mm], Standard 50
6* @param [in] minWristPos Handgelenk-Singularitätsanpassungsbereich [°], Standard 10
7* @return Fehlercode
8*/
9int SingularAvoidStart(int protectMode, double minShoulderPos, double minElbowPos, double minWristPos);

4.71. Singularitätsschutz beenden

Neu in Version C#SDK-v1.0.9.

1/**
2* @brief Singularitätsschutz beenden
3* @return Fehlercode
4*/
5int SingularAvoidEnd();

4.72. Codebeispiel

Neu in Version C#SDK-v1.0.9.

 1private void btnTestSingularAvoidEArc_Click(object sender, EventArgs e)
 2{
 3    int rtn;
 4    JointPos startjointPos = new JointPos(-11.904f, -99.669f, 117.473f, -108.616f, -91.726f, 74.256f);
 5    JointPos endjointPos = new JointPos(-45.615f, -106.172f, 124.296f, -107.151f, -91.282f, 74.255f);
 6
 7    DescPose startdescPose = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
 8    DescPose enddescPose = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);
 9
10    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
11    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);
12
13    rtn = robot.SingularAvoidStart(2, 10, 5, 5);
14    Console.WriteLine("SingularAvoidStart rtn is " + rtn);
15    robot.MoveJ( startjointPos,  startdescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
16    robot.MoveJ( endjointPos,  enddescPose, 0, 0, 100, 100, 100,  exaxisPos, -1, 0,  offdese);
17    rtn = robot.SingularAvoidEnd();
18    Console.WriteLine("SingularAvoidEnd rtn is " + rtn);
19}

4.73. Sicherheitsstopp auslösen

1/**
2* @brief Sicherheitsstopp-Signal auslösen (Code abrufen)
3* @return Fehlercode
4*/
5int GetSafetyCode();

4.74. Bewegungsbefehlswarteschlange leeren

Neu in Version C#SDK-V1.1.9: Web-3.8.7

1/**
2* @brief Bewegungsbefehlswarteschlange leeren
3* @return Fehlercode
4*/
5public int MotionQueueClear();

4.75. Zum Startpunkt einer Rohrverschneidung bewegen

 1/**
 2* @brief Zum Startpunkt einer Rohrverschneidung bewegen
 3* @param [in] mainPoint Kartesische Posen der 6 Teachpunkte des Hauptrohrs
 4* @param [in] mainExaxisPos Positionen der Erweiterungsachse an den 6 Teachpunkten des Hauptrohrs
 5* @param [in] piecePoint Kartesische Posen der 6 Teachpunkte des Nebenrohrs
 6* @param [in] pieceExaxisPos Positionen der Erweiterungsachse an den 6 Teachpunkten des Nebenrohrs
 7* @param [in] extAxisFlag Erweiterungsachse aktivieren? 0-nein; 1-ja
 8* @param [in] exaxisPos Startposition der Erweiterungsachse
 9* @param [in] tool Werkzeugkoordinatennummer
10* @param [in] wobj Werkstückkoordinatennummer
11* @param [in] vel Geschwindigkeitsprozentsatz
12* @param [in] acc Beschleunigungsprozentsatz
13* @param [in] ovl Geschwindigkeitsskalierungsfaktor
14* @param [in] oacc Beschleunigungsskalierungsfaktor
15* @param [in] moveType Bewegungstyp; 0-PTP; 1-LIN
16* @param [in] moveDirection Bewegungsrichtung; 0-im Uhrzeigersinn; 1-gegen Uhrzeigersinn
17* @param [in] offset Versatzwert (Pose)
18* @return Fehlercode
19*/
20public int MoveToIntersectLineStart(DescPose[] mainPoint, ExaxisPos[] mainExaxisPos, DescPose[] piecePoint, ExaxisPos[] pieceExaxisPos, int extAxisFlag, ExaxisPos exaxisPos, int tool, int wobj, double vel, double acc, double ovl, double oacc, int moveType, int moveDirection, DescPose offset);

4.76. Bewegung entlang einer Rohrverschneidung

 1/**
 2* @brief Bewegung entlang einer Rohrverschneidung
 3* @param [in] mainPoint Kartesische Posen der 6 Teachpunkte des Hauptrohrs
 4* @param [in] mainExaxisPos Positionen der Erweiterungsachse an den 6 Teachpunkten des Hauptrohrs
 5* @param [in] piecePoint Kartesische Posen der 6 Teachpunkte des Nebenrohrs
 6* @param [in] pieceExaxisPos Positionen der Erweiterungsachse an den 6 Teachpunkten des Nebenrohrs
 7* @param [in] extAxisFlag Erweiterungsachse aktivieren? 0-nein; 1-ja
 8* @param [in] exaxisPos Array von Positionen der Erweiterungsachse entlang der Bahn
 9* @param [in] tool Werkzeugkoordinatennummer
10* @param [in] wobj Werkstückkoordinatennummer
11* @param [in] vel Geschwindigkeitsprozentsatz
12* @param [in] acc Beschleunigungsprozentsatz
13* @param [in] ovl Geschwindigkeitsskalierungsfaktor
14* @param [in] oacc Beschleunigungsskalierungsfaktor
15* @param [in] moveDirection Bewegungsrichtung; 0-im Uhrzeigersinn; 1-gegen Uhrzeigersinn
16* @param [in] offset Versatzwert (Pose)
17* @return Fehlercode
18*/
19public int MoveIntersectLine(DescPose[] mainPoint, ExaxisPos[] mainExaxisPos, DescPose[] piecePoint, ExaxisPos[] pieceExaxisPos, int extAxisFlag, ExaxisPos[] exaxisPos, int tool, int wobj, double vel, double acc, double ovl, double oacc, int moveDirection, DescPose offset);

4.77. Codebeispiel für Roboterbewegung entlang einer Rohrverschneidung

 1void TestIntersectLineMove()
 2{
 3    ROBOT_STATE_PKG pkg = {};
 4    FRRobot robot;
 5    robot.LoggerInit();
 6    robot.SetLoggerLevel(3);
 7    int rtn = robot.RPC("192.168.58.2");
 8    if (rtn != 0)
 9    {
10        return ;
11    }
12    robot.SetReConnectParam(true, 30000, 500);
13    DescPose mainPoint[6] = {};
14    DescPose piecePoint[6] = {};
15    ExaxisPos mainExaxisPos[6] = {};
16    ExaxisPos pieceExaxisPos[6] = {};
17    int extAxisFlag = 1;
18    ExaxisPos exaxisPos[4] = {};
19    DescPose offset = { 0.0, 2.0 ,30.0, -2.0, 0.0, 0.0 };
20    mainPoint[0] = {490.004, -383.194, 402.735, -9.332, -1.528, 69.594};
21    mainPoint[1] = {444.950, -407.117, 389.011, -5.546, -2.196, 65.279};
22    mainPoint[2] = {445.168, -463.605, 355.759, -1.544, -10.886, 57.104};
23    mainPoint[3] = {507.529, -485.385, 343.013, -0.786, -4.834, 61.799};
24    mainPoint[4] = {554.390, -442.647, 367.701, -4.761, -10.181, 64.925};
25    mainPoint[5] = {532.552, -394.003, 396.467, -13.732, -13.592, 67.411};
26    mainExaxisPos[0] = { -29.996, 0.000, 0.000, 0.000 };
27    mainExaxisPos[1] = { -29.996, 0.000, 0.000, 0.000 };
28    mainExaxisPos[2] = { -29.996, 0.000, 0.000, 0.000 };
29    mainExaxisPos[3] = { -29.996, 0.000, 0.000, 0.000 };
30    mainExaxisPos[4] = { -29.996, 0.000, 0.000, 0.000 };
31    mainExaxisPos[5] = { -29.996, 0.000, 0.000, 0.000 };
32    piecePoint[0] = { 505.571, -192.408, 316.759, 38.098, 37.051, 139.447 };
33    piecePoint[1] = {533.837, -201.558, 332.340, 34.644, 42.339, 137.748};
34    piecePoint[2] = {530.386, -225.085, 373.808, 35.431, 45.111, 137.560};
35    piecePoint[3] = {485.646, -229.195, 383.778, 33.870, 45.173, 137.064};
36    piecePoint[4] = {460.551, -212.161, 354.256, 28.856, 45.602, 135.930};
37    piecePoint[5] = {474.217, -197.124, 324.611, 42.469, 41.133, 148.167};
38    pieceExaxisPos[0] = { -29.996, -0.000, 0.000, 0.000 };
39    pieceExaxisPos[1] = { -29.996, -0.000, 0.000, 0.000 };
40    pieceExaxisPos[2] = { -29.996, -0.000, 0.000, 0.000 };
41    pieceExaxisPos[3] = { -29.996, -0.000, 0.000, 0.000 };
42    pieceExaxisPos[4] = { -29.996, -0.000, 0.000, 0.000 };
43    pieceExaxisPos[5] = { -29.996, -0.000, 0.000, 0.000 };
44    exaxisPos[0] = {-29.996, -0.000, 0.000, 0.000};
45    exaxisPos[1] = {-44.994, 90.000, 0.000, 0.000};
46    exaxisPos[2] = {-59.992, 0.002, 0.000, 0.000};
47    exaxisPos[3] = {-44.994, -89.997, 0.000, 0.000};
48    int tool = 2;
49    int wobj = 0;
50    double vel = 100.0;
51    double acc = 100.0;
52    double ovl = 12.0;
53    double oacc = 12.0;
54    int moveType = 1;
55    int moveDirection = 1;
56    rtn = robot.MoveToIntersectLineStart(mainPoint, mainExaxisPos, piecePoint, pieceExaxisPos, extAxisFlag, exaxisPos[0], tool, wobj, vel, acc, ovl, oacc, moveType, moveDirection, offset);
57    printf("MoveToIntersectLineStart rtn is %d\n", rtn);
58    rtn = robot.MoveIntersectLine(mainPoint, mainExaxisPos, piecePoint, pieceExaxisPos, extAxisFlag, exaxisPos, tool, wobj, vel, acc, 5.0, 5.0, moveDirection, offset);
59    printf("MoveIntersectLine rtn is %d\n", rtn);
60    robot.CloseRPC();
61    return ;
62}

4.78. Stillstehende Leerbewegung

1/**
2* @brief Stillstehende Leerbewegung (Bewegung ohne Ortsveränderung)
3* @return Fehlercode
4*/
5public int MoveStationary()

4.79. Codebeispiel für stillstehende Leerbewegung

1public void LaserSensorRecordandReplay()
2{
3    int rtn = robot.LaserSensorRecordandReplay(0, 10, 1, 0, 0.1, 1, 1, 10, 100);
4    Console.WriteLine($"LaserSensorRecordandReplay rtn is {rtn}");
5    rtn = robot.MoveStationary();
6    Console.WriteLine($"MoveStationary rtn is {rtn}");
7    rtn = robot.LaserSensorRecord1(0, 10);
8    Console.WriteLine($"LaserSensorRecord1 rtn is {rtn}");
9}