4. Roboterbewegung

4.1. Jog-Tippbetrieb

Prototyp

StartJOG(ref, nb, dir, max_dis, vel=20.0, acc=100.0)

Beschreibung

Jog-Tippbetrieb (Punkt-für-Punkt-Bewegung)

Erforderliche Parameter

  • ref: 0-Jog im Gelenkraum, 2-Jog im Basiskoordinatensystem, 4-Jog im Werkzeugkoordinatensystem, 8-Jog im Werkstückkoordinatensystem

  • nb: 1-Achse 1 (X-Achse), 2-Achse 2 (Y-Achse), 3-Achse 3 (Z-Achse), 4-Achse 4 (rx), 5-Achse 5 (ry), 6-Achse 6 (rz)

  • dir: 0-negative Richtung, 1-positive Richtung

  • max_dis: Maximaler Winkel pro Tippbewegung [°] oder maximale Distanz [mm]

Optionale Parameter

  • vel: Geschwindigkeitsprozentsatz, [0~100] Standard 20.0

  • acc: Beschleunigungsprozentsatz, [0~100] Standard 100.0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.2. Jog-Tippbetrieb mit Verzögerung stoppen

Prototyp

StopJOG(ref)

Beschreibung

Jog-Tippbetrieb mit Verzögerung stoppen

Erforderliche Parameter

  • ref: 1-Jog im Gelenkraum stoppen, 3-Jog im Basiskoordinatensystem stoppen, 5-Jog im Werkzeugkoordinatensystem stoppen, 9-Jog im Werkstückkoordinatensystem stoppen

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.3. Jog-Tippbetrieb sofort stoppen

Prototyp

ImmStopJOG()

Beschreibung

Jog-Tippbetrieb sofort stoppen

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.4. Codebeispiel für Roboter-Jog-Steuerung

 1from fairino import Robot
 2import time
 3# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 4robot = Robot.RPC('192.168.58.2')
 5for i in range(6):
 6    robot.StartJOG(0, i + 1, 0, 20.0, 20.0, 30.0)
 7    time.sleep(1)
 8    robot.ImmStopJOG()
 9    time.sleep(1)
10for i in range(6):
11    robot.StartJOG(2, i + 1, 0, 20.0, 20.0, 30.0)
12    time.sleep(1)
13    robot.ImmStopJOG()
14    time.sleep(1)
15for i in range(6):
16    robot.StartJOG(4, i + 1, 0, 20.0, 20.0, 30.0)
17    time.sleep(1)
18    robot.StopJOG(5)
19    time.sleep(1)
20for i in range(6):
21    robot.StartJOG(8, i + 1, 0, 20.0, 20.0, 30.0)
22    time.sleep(1)
23    robot.StopJOG(9)
24    time.sleep(1)
25robot.CloseRPC()

4.5. Bewegung im Gelenkraum (MoveJ)

Prototyp

MoveJ(joint_pos, tool, user, desc_pos = [0.0,0.0,0.0,0.0,0.0,0.0], vel = 20.0, acc = 0.0, ovl = 100.0, exaxis_pos = [0.0,0.0,0.0,0.0], blendT = -1.0, offset_flag = 0, offset_pos = [0.0,0.0,0.0,0.0,0.0,0.0])

Beschreibung

Bewegung im Gelenkraum (MoveJ)

Erforderliche Parameter

  • joint_pos: Ziel-Gelenkposition, Einheit [°]

  • tool: Werkzeugnummer, [0~14]

  • user: Werkstücknummer, [0~14]

Optionale Parameter

  • desc_pos: Ziel-Kartesische Pose, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch Vorwärtskinematik berechnet)

  • vel: Geschwindigkeitsprozentsatz, [0~100], Standard 20.0

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • exaxis_pos: Position der externen Achsen 1-4, Standard [0.0,0.0,0.0,0.0]

  • blendT: [-1.0]-Bewegung abschließen (blockierend), [0~500.0]-Glättungszeit (nicht blockierend), Einheit [ms], Standard -1.0

  • offset_flag: [0]-kein Versatz, [1]-Versatz im Werkstück-/Basiskoordinatensystem, [2]-Versatz im Werkzeugkoordinatensystem, Standard 0

  • offset_pos: Posenversatz, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.6. Linearbewegung im kartesischen Raum (MoveL)

Neu in Version python: SDK-v2.1.5

Prototyp

MoveL(desc_pos, tool, user, joint_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel=20.0, acc=0.0, ovl=100.0, blendR=-1.0, blendMode=0, exaxis_pos=[0.0, 0.0, 0.0, 0.0], search=0, offset_flag=0, offset_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], oacc=100.0, config=-1, velAccParamMode=0, overSpeedStrategy=0, speedPercent=10)

Beschreibung

Linearbewegung im kartesischen Raum (MoveL)

Erforderliche Parameter

  • desc_pos: Ziel-Kartesische Pose, Einheit [mm][°]

  • tool: Werkzeugnummer, [0~14]

  • user: Werkstücknummer, [0~14]

Optionale Parameter

  • joint_pos: Ziel-Gelenkposition, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • vel: Geschwindigkeitsprozentsatz, [0~100], Standard 20.0

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • blendR: [-1.0]-Bewegung abschließen (blockierend), [0~1000]-Glättungsradius (nicht blockierend), Einheit [mm], Standard -1.0

  • blendMode: Übergangsart; 0-Innenkreisübergang; 1-Eckpunktübergang, Standard 0

  • exaxis_pos: Position der externen Achsen 1-4, Standard [0.0,0.0,0.0,0.0]

  • search: [0]-keine Schweißdraht-Positionssuche, [1]-Schweißdraht-Positionssuche, Standard 0

  • offset_flag: [0]-kein Versatz, [1]-Versatz im Werkstück-/Basiskoordinatensystem, [2]-Versatz im Werkzeugkoordinatensystem, Standard 0

  • offset_pos: Posenversatz, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

  • oacc: Beschleunigungsskalierungsfaktor [0-100] / physikalische Beschleunigung (mm/s2), Standard 100

  • config: Konfiguration des inversen Gelenkraums, [-1]-basierend auf aktueller Gelenkposition berechnen, [0~7]-basierend auf spezifischer Konfiguration lösen, Standard -1

  • velAccParamMode: Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit (mm/s) und Beschleunigung (mm/s2), Standard 0

  • overSpeedStrategy: Strategie bei Geschwindigkeitsüberschreitung, 0-Strategie aus; 1-Standard; 2-Fehler und Stopp bei Überschreitung; 3-adaptive Geschwindigkeitsreduzierung, Standard 0

  • speedPercent: Zulässiger Geschwindigkeitsreduzierungsschwellwert in Prozent [0-100], Standard 10%

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.7. Kreisbogenbewegung im kartesischen Raum (MoveC)

Neu in Version python: SDK-v2.1.5

Prototyp

MoveC(desc_pos_p, tool_p, user_p, desc_pos_t, tool_t, user_t, joint_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], joint_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel_p=20.0, acc_p=100.0, exaxis_pos_p=[0.0, 0.0, 0.0, 0.0], offset_flag_p=0, offset_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel_t=20.0, acc_t=100.0, exaxis_pos_t=[0.0, 0.0, 0.0, 0.0], offset_flag_t=0, offset_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], ovl=100.0, blendR=-1.0, oacc=100.0, config=-1, velAccParamMode=0)

Beschreibung

Kreisbogenbewegung im kartesischen Raum (MoveC)

Erforderliche Parameter

  • desc_pos_p: Kartesische Pose des Zwischenpunkts, Einheit [mm][°]

  • tool_p: Werkzeugnummer für Zwischenpunkt, [0~14]

  • user_p: Werkstücknummer für Zwischenpunkt, [0~14]

  • desc_pos_t: Kartesische Pose des Zielpunkts, Einheit [mm][°]

  • tool_t: Werkzeugnummer für Zielpunkt, [0~14]

  • user_t: Werkstücknummer für Zielpunkt, [0~14]

Optionale Parameter

  • joint_pos_p: Gelenkposition des Zwischenpunkts, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • joint_pos_t: Gelenkposition des Zielpunkts, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • vel_p: Geschwindigkeitsprozentsatz für Zwischenpunkt, [0~100], Standard 20.0

  • acc_p: Beschleunigungsprozentsatz für Zwischenpunkt, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • exaxis_pos_p: Position der externen Achsen am Zwischenpunkt, Standard [0.0,0.0,0.0,0.0]

  • offset_flag_p: Versatz für Zwischenpunkt? [0]-kein Versatz, [1]-Versatz, Standard 0

  • offset_pos_p: Posenversatz für Zwischenpunkt, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

  • vel_t: Geschwindigkeitsprozentsatz für Zielpunkt, [0~100], Standard 20.0

  • acc_t: Beschleunigungsprozentsatz für Zielpunkt, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • exaxis_pos_t: Position der externen Achsen am Zielpunkt, Standard [0.0,0.0,0.0,0.0]

  • offset_flag_t: Versatz für Zielpunkt? [0]-kein Versatz, [1]-Versatz, Standard 0

  • offset_pos_t: Posenversatz für Zielpunkt, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • blendR: [-1.0]-Bewegung abschließen (blockierend), [0~1000]-Glättungsradius (nicht blockierend), Einheit [mm], Standard -1.0

  • oacc: Beschleunigungsskalierungsfaktor [0-100] / physikalische Beschleunigung (mm/s2), Standard 100

  • config: Konfiguration des inversen Gelenkraums, [-1]-basierend auf aktueller Gelenkposition berechnen, [0~7]-basierend auf spezifischer Konfiguration lösen, Standard -1

  • velAccParamMode: Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit (mm/s) und Beschleunigung (mm/s2), Standard 0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.8. Vollkreisbewegung im kartesischen Raum (Circle)

Neu in Version python: SDK-v2.1.5

Prototyp

Circle(desc_pos_p, tool_p, user_p, desc_pos_t, tool_t, user_t, joint_pos_p=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], joint_pos_t=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], vel_p=20.0, acc_p=0.0, exaxis_pos_p=[0.0, 0.0, 0.0, 0.0], vel_t=20.0, acc_t=0.0, exaxis_pos_t=[0.0, 0.0, 0.0, 0.0], ovl=100.0, offset_flag=0, offset_pos=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], oacc=100.0, blendR=-1, config=-1, velAccParamMode=0)

Beschreibung

Vollkreisbewegung im kartesischen Raum (Circle)

Erforderliche Parameter

  • desc_pos_p: Kartesische Pose von Zwischenpunkt 1, Einheit [mm][°]

  • tool_p: Werkzeugnummer für Zwischenpunkt 1, [0~14]

  • user_p: Werkstücknummer für Zwischenpunkt 1, [0~14]

  • desc_pos_t: Kartesische Pose von Zwischenpunkt 2, Einheit [mm][°]

  • tool_t: Werkzeugnummer für Zwischenpunkt 2, [0~14]

  • user_t: Werkstücknummer für Zwischenpunkt 2, [0~14]

Optionale Parameter

  • joint_pos_p: Gelenkposition von Zwischenpunkt 1, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • joint_pos_t: Gelenkposition von Zwischenpunkt 2, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • vel_p: Geschwindigkeitsprozentsatz für Zwischenpunkt 1, [0~100], Standard 20.0

  • acc_p: Beschleunigungsprozentsatz für Zwischenpunkt 1, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • exaxis_pos_p: Position der externen Achsen an Zwischenpunkt 1, Standard [0.0,0.0,0.0,0.0]

  • vel_t: Geschwindigkeitsprozentsatz für Zwischenpunkt 2, [0~100], Standard 20.0

  • acc_t: Beschleunigungsprozentsatz für Zwischenpunkt 2, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • exaxis_pos_t: Position der externen Achsen an Zwischenpunkt 2, Standard [0.0,0.0,0.0,0.0]

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • offset_flag: [0]-kein Versatz, [1]-Versatz im Werkstück-/Basiskoordinatensystem, [2]-Versatz im Werkzeugkoordinatensystem, Standard 0

  • offset_pos: Posenversatz, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

  • oacc: Beschleunigungsskalierungsfaktor [0-100] / physikalische Beschleunigung (mm/s2), Standard 100

  • blendR: -1: blockierend; 0~1000: Glättungsradius, Standard -1

  • config: Konfiguration des inversen Gelenkraums, [-1]-basierend auf aktueller Gelenkposition berechnen, [0~7]-basierend auf spezifischer Konfiguration lösen, Standard -1

  • velAccParamMode: Modus für Geschwindigkeits-/Beschleunigungsparameter; 0-Prozentsatz; 1-physikalische Geschwindigkeit (mm/s) und Beschleunigung (mm/s2), Standard 0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.9. Punkt-zu-Punkt-Bewegung im kartesischen Raum (MoveCart)

Prototyp

MoveCart(desc_pos, tool, user, vel=20.0, acc=0.0, ovl=100.0, blendT=-1.0, config=-1)

Beschreibung

Punkt-zu-Punkt-Bewegung im kartesischen Raum (MoveCart)

Erforderliche Parameter

  • desc_pos: Ziel-Kartesische Pose

  • tool: Werkzeugnummer, [0~14]

  • user: Werkstücknummer, [0~14]

Optionale Parameter

  • vel: Geschwindigkeitsprozentsatz, [0~100], Standard 20.0

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • blendT: [-1.0]-Bewegung abschließen (blockierend), [0~500]-Glättungszeit (nicht blockierend), Einheit [ms], Standard -1.0

  • config: Gelenkraumkonfiguration, [-1]-basierend auf aktueller Gelenkposition berechnen, [0~7]-basierend auf spezifischer Konfiguration lösen, Standard -1

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.10. Codebeispiel für grundlegende Roboter-Bewegungsbefehle

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6j3 = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257]
 7j4 = [-31.154, -95.317, 94.276, -88.079, -89.740, 74.256]
 8desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 9desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
10desc_pos3 = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061]
11desc_pos4 = [-443.165, 147.881, 480.951, 179.511, -0.775, -15.409]
12offset_pos = [0.0] * 6
13epos = [0.0] * 4
14tool = 0
15user = 0
16vel = 100.0
17acc = 100.0
18ovl = 100.0
19oacc = 100.0
20blendT = 0.0
21blendR = 0.0
22flag = 0
23search = 0
24blendMode = 0
25velAccMode = 0
26robot.SetSpeed(20)
27rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
28print(f"movej errcode:{rtn}")
29rtn = robot.MoveL(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendR=blendR, blendMode=blendMode, exaxis_pos=epos, search=search, offset_flag=flag, offset_pos=offset_pos, oacc=oacc, velAccParamMode=velAccMode)
30print(f"movel errcode:{rtn}")
31rtn = robot.MoveC(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, offset_flag_p=flag, offset_pos_p=offset_pos, desc_pos_t=desc_pos4, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, offset_flag_t=flag, offset_pos_t=offset_pos, ovl=ovl, blendR=blendR, oacc=oacc, velAccParamMode=velAccMode)
32print(f"movec errcode:{rtn}")
33rtn = robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
34print(f"movej errcode:{rtn}")
35rtn = robot.Circle(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, desc_pos_t=desc_pos1, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos, oacc=oacc, blendR=-1, velAccParamMode=velAccMode)
36print(f"circle errcode:{rtn}")
37rtn = robot.MoveCart(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendT=blendT, config=-1)
38print(f"MoveCart errcode:{rtn}")
39rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
40print(f"movej errcode:{rtn}")
41rtn = robot.MoveL(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, blendR=blendR, blendMode=blendMode, exaxis_pos=epos, search=search, offset_flag=flag, offset_pos=offset_pos, config=-1, velAccParamMode=velAccMode)
42print(f"movel errcode:{rtn}")
43rtn = robot.MoveC(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, offset_flag_p=flag, offset_pos_p=offset_pos, desc_pos_t=desc_pos4, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, offset_flag_t=flag, offset_pos_t=offset_pos, ovl=ovl, blendR=blendR, config=-1, velAccParamMode=velAccMode)
44print(f"movec errcode:{rtn}")
45rtn = robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos)
46print(f"movej errcode:{rtn}")
47rtn = robot.Circle(desc_pos_p=desc_pos3, tool_p=tool, user_p=user, vel_p=vel, acc_p=acc, exaxis_pos_p=epos, desc_pos_t=desc_pos1, tool_t=tool, user_t=user, vel_t=vel, acc_t=acc, exaxis_pos_t=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos, oacc=oacc, blendR=-1, velAccParamMode=velAccMode)
48print(f"circle errcode:{rtn}")
49robot.CloseRPC()
50return 0

4.11. Spiralbewegung im kartesischen Raum (NewSpiral)

Neu in Version python: SDK-v2.1.7

Prototyp

NewSpiral(desc_pos, tool, user, param, joint_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=20.0, acc=0.0, exaxis_pos=[0.0,0.0,0.0,0.0], ovl=100.0, offset_flag=0, offset_pos=[0.0,0.0,0.0,0.0,0.0,0.0], config=-1)

Beschreibung

Spiralbewegung im kartesischen Raum (NewSpiral)

Erforderliche Parameter

  • desc_pos: Ziel-Kartesische Pose, Einheit [mm][°]

  • tool: Werkzeugnummer, [0~14]

  • user: Werkstücknummer, [0~14]

  • param=[circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode]: circle_num: Anzahl der Windungen; circle_angle: Neigungswinkel der Spirale; rad_init: Anfangsradius; rad_add: Radiusinkrement; rotaxis_add: Inkrement in Richtung der Drehachse; rot_direction: Drehrichtung, 0-im Uhrzeigersinn, 1-gegen Uhrzeigersinn; velAccMode: Modus für Geschwindigkeit/Beschleunigung, 0-Winkelgeschwindigkeit konstant, 1-Lineargeschwindigkeit konstant

Optionale Parameter

  • joint_pos: Ziel-Gelenkposition, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • vel: Geschwindigkeitsprozentsatz, [0~100], Standard 20.0

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • exaxis_pos: Position der externen Achsen 1-4, Standard [0.0,0.0,0.0,0.0]

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • offset_flag: [0]-kein Versatz, [1]-Versatz im Werkstück-/Basiskoordinatensystem, [2]-Versatz im Werkzeugkoordinatensystem, Standard 0

  • offset_pos: Posenversatz, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

  • config: Konfiguration des inversen Gelenkraums, [-1]-basierend auf aktueller Gelenkposition berechnen, [0~7]-basierend auf spezifischer Konfiguration lösen, Standard -1

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.12. Codebeispiel für Spiralbewegung

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4j = [67.957, -81.482, 87.595, -95.691, -94.899, -9.727]
 5desc_pos = [-123.142, -551.735, 430.549, 178.753, -4.757, 167.754]
 6offset_pos1 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0]
 7offset_pos2 = [50.0, 0.0, 0.0, -30.0, 0.0, 0.0]
 8epos = [0.0] * 4
 9sp = [2, 30.0, 50.0, 10.0, 10.0, 0, 1]  # [circle_num, circle_angle, rad_init, rad_add, rotaxis_add, rot_direction, velAccMode]
10tool = 0
11user = 0
12vel = 30.0
13acc = 60.0
14ovl = 100.0
15blendT = -1.0
16flag = 2
17robot.SetSpeed(20)
18rtn = robot.MoveJ(joint_pos=j, tool=tool, user=user, vel=vel, acc=acc, ovl=ovl, exaxis_pos=epos, blendT=blendT, offset_flag=flag, offset_pos=offset_pos1)
19print(f"movej errcode:{rtn}")
20rtn = robot.NewSpiral(desc_pos=desc_pos, tool=tool, user=user, vel=vel, acc=acc, exaxis_pos=epos, ovl=ovl, offset_flag=flag, offset_pos=offset_pos2, param=sp)
21print(f"newspiral errcode:{rtn}")
22robot.CloseRPC()
23return 0

4.13. Servobewegung Start

Prototyp

ServoMoveStart(cmdType=0)

Beschreibung

Start der Servobewegung, wird mit ServoJ- und ServoCart-Befehlen verwendet

Erforderliche Parameter

  • cmdType: Befehlssendetyp, 0=XML-RPC, 1=UDP-Transparentübertragung

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.14. Servobewegung Ende

Prototyp

ServoMoveEnd(cmdType=0)

Beschreibung

Ende der Servobewegung, wird mit ServoJ- und ServoCart-Befehlen verwendet

Erforderliche Parameter

  • cmdType: Befehlssendetyp, 0=XML-RPC, 1=UDP-Transparentübertragung

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.15. Gelenkraum-Servomodellbewegung

Prototyp

ServoJ(joint_pos, axisPos, acc = 0.0, vel = 0.0, cmdT = 0.008, filterT = 0.0, gain = 0.0, id=0, cmdType=0)

Beschreibung

Gelenkraum-Servomodellbewegung

Erforderliche Parameter

  • joint_pos: Zielgelenkposition, Einheit [°];

  • axisPos: Externe Achsenposition, Einheit mm;

Standardparameter

  • acc: Beschleunigung, Bereich [0~100], vorübergehend nicht geöffnet, Standard ist 0.0;

  • vel: Geschwindigkeit, Bereich [0~100], vorübergehend nicht geöffnet, Standard ist 0.0;

  • cmdT: Befehlssendezyklus, Einheit s, empfohlener Bereich [0.001~0.0016], Standard ist 0.008;

  • filterT: Filterzeit, Einheit [s], vorübergehend nicht geöffnet, Standard ist 0.0;

  • gain: Proportionalverstärker für Zielposition, vorübergehend nicht geöffnet, Standard ist 0.0;

  • id: ServoJ-Befehls-ID, Standard ist 0;

  • cmdType: Befehlssendetyp, 0=XML-RPC, 1=UDP-Transparentübertragung;

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.16. SDK-Codebeispiel für ServoJ, ServoMoveStart, ServoMoveEnd basierend auf UDP-Kommunikation

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Verbindung mit der Robotersteuerung herstellen
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestServoJUDP(self):
 9    # Callback einstellen
10    def callback(src_type, count, cmd_id, data_len, content):
11        print("Callback-Funktion: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content))
12        return 0
13
14    robot.SetUDPCmdRpyCallback(callback)
15    # # Gelenkposition und externe Achsenposition initialisieren
16    j= [105, -108, 74, -66, -88.893, -1.621]
17    offset_pos = [0, 0, 0, 0, 0, 0]
18    epos = [0, 0, 0, 0]
19    # # In die Ausgangsposition bewegen
20    result=robot.MoveJ(joint_pos=j, tool=0, user=0, vel=100, acc=100, ovl=100,exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
21    print("MoveJ Rückgabe: {}".format(result))
22    vel = 0.0
23    acc = 0.0
24    cmdT = 0.016
25    filterT = 0.0
26    gain = 0.0
27    flag = 0
28    dt = 0.1
29    cmdID = 0
30
31    # Aktuelle Gelenkposition abrufen
32    ret, j = robot.GetActualJointPosDegree(flag)
33    if ret != 0:
34        print(f"GetActualJointPosDegree errcode:{ret}")
35    while 1:
36        count = 300
37        result = robot.ServoMoveStart(cmdType=1)
38        print("ServoMoveStart Rückgabe: {}".format(result))
39        while count > 0:
40            result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT,filterT=filterT, gain=gain, id=cmdID, cmdType=1)
41            j[0] += dt
42            j[1] += dt
43            j[2] += dt
44            j[3] += dt
45            j[4] += dt
46            j[5] += dt
47            count -= 1
48            time.sleep(0.01)
49        result = robot.ServoMoveEnd(cmdType=1)
50        print("ServoMoveEnd Rückgabe: {}".format(result))
51
52        count = 300
53        result = robot.ServoMoveStart(cmdType=1)
54        print("ServoMoveStart Rückgabe: {}".format(result))
55        while count > 0:
56            result = robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT,filterT=filterT, gain=gain, id=cmdID, cmdType=1)
57            j[0] -= dt
58            j[1] -= dt
59            j[2] -= dt
60            j[3] -= dt
61            j[4] -= dt
62            j[5] -= dt
63            count -= 1
64            time.sleep(0.01)
65        result = robot.ServoMoveEnd(cmdType=1)
66        print("ServoMoveEnd Rückgabe: {}".format(result))
67    robot.CloseRPC()
68    return 0
69TestServoJUDP(robot)

4.17. Codebeispiel für Servo-Modus Bewegung im Gelenkraum (ServoJ)

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4j = [0.0] * 6
 5epos = [0.0] * 4
 6vel = 0.0
 7acc = 0.0
 8cmdT = 0.008
 9filterT = 0.0
10gain = 0.0
11flag = 0
12count = 500
13dt = 0.1
14cmdID = 0
15ret, j = robot.GetActualJointPosDegree(flag)
16if ret == 0:
17    cmdID += 1
18    robot.ServoMoveStart()
19    while count:
20        robot.ServoJ(joint_pos=j, axisPos=epos, acc=acc, vel=vel, cmdT=cmdT, filterT=filterT, gain=gain, id=cmdID)
21        j[4] += dt
22        count -= 1
23        time.sleep(cmdT)
24        rtn, pkg = robot.GetRobotRealTimeState()
25        print(f"Servoj Count {pkg.servoJCmdNum}; last pos is {pkg.lastServoTarget[0]},{pkg.lastServoTarget[1]},{pkg.lastServoTarget[2]},{pkg.lastServoTarget[3]},{pkg.lastServoTarget[4]},{pkg.lastServoTarget[5]}")
26
27        if count < 50:
28            robot.MotionQueueClear()
29            print(f"After queue clear, Servoj Count {pkg.servoJCmdNum}; last pos is {pkg.lastServoTarget[0]},{pkg.lastServoTarget[1]},{pkg.lastServoTarget[2]},{pkg.lastServoTarget[3]},{pkg.lastServoTarget[4]},{pkg.lastServoTarget[5]}")
30            break
31    robot.ServoMoveEnd()
32else:
33    print(f"GetActualJointPosDegree errcode:{ret}")
34robot.CloseRPC()

4.18. Start der Gelenkmomentsteuerung

Prototyp

ServoJTStart(cmdType=0)

Beschreibung

Start der Gelenkmomentsteuerung

Erforderliche Parameter

  • cmdType: Befehlssendetyp, 0=XML-RPC, 1=UDP-Transparentübertragung

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.19. Gelenkmomentsteuerung

Prototyp

ServoJT(torque, interval, checkFlag=0, jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], cmdType=0)

Beschreibung

Gelenkmomentsteuerung

Erforderliche Parameter
  • torque: j1~j6 Gelenkmoment, Einheit Nm

    • interval: Befehlsperiode, Einheit s, Bereich [0.001~0.008]

    • checkFlag: Erkennungsstrategie 0-keine Einschränkung; 1-Leistungsbegrenzung; 2-Geschwindigkeitsbegrenzung; 3-sowohl Leistungs- als auch Geschwindigkeitsbegrenzung, Standard 0

    • jPowerLimit: Maximale Gelenkleistungsbegrenzung (W), Standard [0.0,0.0,0.0,0.0,0.0,0.0]

    • jVelLimit: Maximale Gelenkgeschwindigkeit (°/s), Standard [0.0,0.0,0.0,0.0,0.0,0.0]

    • cmdType: Befehlssendetyp, 0=XML-RPC, 1=UDP-Transparentübertragung

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.20. Ende der Gelenkmomentsteuerung

Prototyp

ServoJTEnd(cmdType=0)

Beschreibung

Ende der Gelenkmomentsteuerung

Erforderliche Parameter

  • cmdType: Befehlssendetyp, 0=XML-RPC, 1=UDP-Transparentübertragung

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.21. SDK-Codebeispiel für ServoJT, ServoJTStart, ServoJTEnd basierend auf UDP-Kommunikation

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Verbindung mit der Robotersteuerung herstellen
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestServoJTUDP(self):
 9    # Callback einstellen
10    def callback(src_type, count, cmd_id, data_len, content):
11        print("Callback-Funktion: cmd_id={} count={} data_len={} content={}".format(cmd_id, count, data_len, content))
12        return 0
13
14    robot.SetUDPCmdRpyCallback(callback)
15    while True:
16        # Gelenkposition und externe Achsenposition initialisieren
17        j = [0, -90, 90, 0, 0, 0]
18        epos = [0, 0, 0, 0]
19        offset_pos = [0, 0, 0, 0, 0, 0]
20
21        # In die Ausgangsposition bewegen
22        robot.MoveJ(joint_pos=j, tool=0, user=0, vel=100, acc=100, ovl=100,
23                    exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
24        time.sleep(3)
25        # Zieh-Teaching aktivieren
26        result=robot.DragTeachSwitch(1)
27        print("DragTeachSwitch Rückgabe: {}".format(result))
28        torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
29
30        # Gelenkmomente abrufen
31        ret, torques = robot.GetJointTorques(flag=1)
32        if ret != 0:
33            print(f"GetJointTorques errcode:{ret}")
34
35        count = 100
36        result = robot.ServoJTStart(cmdType=1)
37        print("ServoJTStart Rückgabe: {}".format(result))
38        # Vorwärtsmomentsteuerung
39        while True:
40            torques[0] = 0.03
41            result = robot.ServoJT(
42                torque=torques,
43                interval=0.001,
44                checkFlag=0,
45                jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
46                jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
47                cmdType=1
48            )
49            print("Rückgabe: {}".format(result))
50            time.sleep(1)
51
52            ret, pkg = robot.GetRobotRealTimeState()
53            if pkg.jt_cur_pos[0] > 30:
54                break
55
56        # Rückwärtsmomentsteuerung
57        while True:
58            torques[0] = -0.03
59            result = robot.ServoJT(
60                    torque=torques,
61                    interval=0.001,
62                    checkFlag=0,
63                    jPowerLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
64                    jVelLimit=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
65                    cmdType=1
66                )
67            print("Rückgabe: {}".format(result))
68            time.sleep(1)
69
70            ret, pkg = robot.GetRobotRealTimeState()
71            if pkg.jt_cur_pos[0] < 0:
72                break
73
74        # Momentsteuerung beenden und Zieh-Teaching deaktivieren
75        result = robot.ServoJTEnd(cmdType=1)
76        print("ServoJTEnd Rückgabe: {}".format(result))
77        result = robot.DragTeachSwitch(0)
78        print("DragTeachSwitch Rückgabe: {}".format(result))
79
80    robot.CloseRPC()
81    return 0
82TestServoJTUDP(robot)

4.22. Codebeispiel für Gelenk-Drehmomentregelung (ServoJT)

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4robot.DragTeachSwitch(1)
 5error, torques = robot.GetJointTorques(1)
 6robot.ServoJTStart()
 7count = 100
 8while count > 0:
 9    error = robot.ServoJT(torques, 0.001)
10    count -= 1
11    time.sleep(0.001)
12error = robot.ServoJTEnd()
13robot.DragTeachSwitch(0)
14robot.CloseRPC()

4.23. Servo-Modus Bewegung im kartesischen Raum (ServoCart)

Prototyp

ServoCart(mode, desc_pos, exaxis, pos_gain=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0], acc=0.0, vel=0.0, cmdT=0.008, filterT=0.0, gain=0.0)

Beschreibung

Servo-Modus Bewegung im kartesischen Raum (ServoCart)

Erforderliche Parameter

  • mode: [0]-Absolutbewegung (Basiskoordinatensystem), [1]-Inkrementalbewegung (Basiskoordinatensystem), [2]-Inkrementalbewegung (Werkzeugkoordinatensystem)

  • desc_pos: Ziel-Kartesische Pose oder Poseninkrement

  • exaxis: Position der Erweiterungsachse

Optionale Parameter

  • pos_gain: Proportionalbeiwert für Poseninkrement, nur bei inkrementaler Bewegung wirksam, Bereich [0~1], Standard [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • vel: Geschwindigkeitsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • cmdT: Befehlsübermittlungszyklus, Einheit s, empfohlen [0.001~0.0016], Standard 0.008

  • filterT: Filterzeit, Einheit s (vorerst nicht verfügbar), Standard 0.0

  • gain: Proportionalverstärkung für Zielposition (vorerst nicht verfügbar), Standard 0.0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.24. Codebeispiel für Servo-Modus Bewegung im kartesischen Raum (ServoCart)

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4desc_pos_dt = [83.00800, 50.525000, 29.246, 179.629, -7.138, -166.975]
 5exaxis = [100.0, 0.0, 0.0, 0.0]
 6pos_gain = [0.0] * 6
 7mode = 0
 8vel = 0.0
 9acc = 0.0
10cmdT = 0.001
11filterT = 0.0
12gain = 0.0
13flag = 0
14count = 5000
15robot.SetSpeed(20)
16while count:
17    rtn = robot.ServoCart(mode, desc_pos_dt, exaxis, pos_gain, acc, vel, cmdT, filterT, gain)
18    print(f"ServoCart rtn is {rtn}")
19    count -= 1
20    desc_pos_dt[0] += 0.01
21    exaxis[0] += 0.01
22robot.CloseRPC()
23return 0

4.25. Spline-Bewegung starten

Prototyp

SplineStart()

Beschreibung

Spline-Bewegung starten

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.26. Spline-PTP-Bewegung

Prototyp

SplinePTP(joint_pos, tool, user, desc_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=20.0, acc=100.0, ovl=100.0)

Beschreibung

Spline-PTP-Bewegung im Gelenkraum

Erforderliche Parameter

  • joint_pos: Ziel-Gelenkposition, Einheit [°]

  • tool: Werkzeugnummer, [0~14]

  • user: Werkstücknummer, [0~14]

Optionale Parameter

  • desc_pos: Ziel-Kartesische Pose, Einheit [mm][°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch Vorwärtskinematik berechnet)

  • vel: Geschwindigkeitsprozentsatz, [0~100], Standard 20.0

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 100.0

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.27. Spline-Bewegung beenden

Prototyp

SplineEnd()

Beschreibung

Spline-Bewegung beenden

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.28. Codebeispiel für Spline-Bewegung

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4joint_points = [
 5    [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256],  # j1
 6    [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255],  # j2
 7    [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260],  # j3
 8    [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267]  # j4
 9]
10cart_points = [
11    [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833],  # desc_pos1
12    [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869],  # desc_pos2
13    [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207],  # desc_pos3
14    [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818]  # desc_pos4
15]
16offset_pos = [0] * 6
17epos = [0] * 4
18tool = user = 0
19vel = acc = ovl = 100.0
20blendT = -1.0
21flag = 0
22robot.SetSpeed(20)
23err1 = robot.MoveJ(joint_pos=joint_points[0], tool=tool, user=user, vel=vel)
24print(f"MoveJ Fehlercode: {err1}")
25robot.SplineStart()
26robot.SplinePTP(joint_pos=joint_points[0], tool=tool, user=user)
27robot.SplinePTP(joint_pos=joint_points[1], tool=tool, user=user)
28robot.SplinePTP(joint_pos=joint_points[2], tool=tool, user=user)
29robot.SplinePTP(joint_pos=joint_points[3], tool=tool, user=user)
30robot.SplineEnd()
31robot.CloseRPC()

4.29. Neue Spline-Bewegung starten (NewSpline)

Geändert in Version python: SDK-v2.0.3

Prototyp

NewSplineStart(type, averageTime=2000)

Beschreibung

Neue Spline-Bewegung starten (NewSpline)

Erforderliche Parameter

  • type: 0-Kreisbogenübergang, 1-gegebene Punkte sind Bahnpunkte

Optionale Parameter

  • averageTime: Globale durchschnittliche Übergangszeit (ms), Standard 2000

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.30. Neuer Spline-Befehlspunkt

Prototyp

NewSplinePoint(desc_pos, tool, user, lastFlag, joint_pos=[0.0,0.0,0.0,0.0,0.0,0.0], vel=0.0, acc=0.0, ovl=100.0, blendR=0.0)

Beschreibung

Einen Punkt zu einer neuen Spline-Bewegung hinzufügen

Erforderliche Parameter

  • desc_pos: Ziel-Kartesische Pose, Einheit [mm][°]

  • tool: Werkzeugnummer, [0~14]

  • user: Werkstücknummer, [0~14]

  • lastFlag: Ist dies der letzte Punkt? 0-nein, 1-ja

Optionale Parameter

  • joint_pos: Ziel-Gelenkposition, Einheit [°], Standard [0.0,0.0,0.0,0.0,0.0,0.0] (wird durch inverse Kinematik berechnet)

  • vel: Geschwindigkeitsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • acc: Beschleunigungsprozentsatz, [0~100] (vorerst nicht verfügbar), Standard 0.0

  • ovl: Geschwindigkeitsskalierungsfaktor, [0~100], Standard 100.0

  • blendR: [0~1000]-Glättungsradius (nicht blockierend), Einheit [mm], Standard 0.0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.31. Neue Spline-Bewegung beenden

Prototyp

NewSplineEnd()

Beschreibung

Neue Spline-Bewegung beenden

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.32. Codebeispiel für neue Spline-Bewegung

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6j3 = [-61.954, -84.409, 108.153, -116.316, -91.283, 74.260]
 7j4 = [-89.575, -80.276, 102.713, -116.302, -91.284, 74.267]
 8j5 = [-95.228, -54.621, 73.691, -112.245, -91.280, 74.268]
 9desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
10desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
11desc_pos3 = [-327.622, 402.230, 320.402, -178.067, 2.127, -46.207]
12desc_pos4 = [-104.066, 544.321, 327.023, -177.715, 3.371, -73.818]
13desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482]
14offset_pos = [0, 0, 0, 0, 0, 0]
15epos = [0, 0, 0, 0]
16tool = 0
17user = 0
18vel = 100.0
19acc = 100.0
20ovl = 100.0
21blendT = -1.0
22flag = 0
23robot.SetSpeed(20)
24err1 = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
25print(f"movej errcode:{err1}")
26robot.NewSplineStart(1, 2000)
27robot.NewSplinePoint(desc_pos=desc_pos1, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
28robot.NewSplinePoint(desc_pos=desc_pos2, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
29robot.NewSplinePoint(desc_pos=desc_pos3, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
30robot.NewSplinePoint(desc_pos=desc_pos4, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
31robot.NewSplinePoint(desc_pos=desc_pos5, tool=tool, user=user, vel=vel, lastFlag=-1, blendR=0)
32robot.NewSplineEnd()
33robot.CloseRPC()

4.33. Roboterbewegung abbrechen (StopMotion)

Prototyp

StopMotion()

Beschreibung

Bewegung abbrechen (erfordert nicht-blockierende Bewegungsbefehle)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.34. Roboterbewegung pausieren (PauseMotion)

Prototyp

PauseMotion()

Beschreibung

Bewegung pausieren (erfordert nicht-blockierende Bewegungsbefehle)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.35. Roboterbewegung fortsetzen (ResumeMotion)

Prototyp

ResumeMotion()

Beschreibung

Bewegung fortsetzen (erfordert nicht-blockierende Bewegungsbefehle)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.36. Codebeispiel für Bewegung pausieren, fortsetzen, abbrechen

 1from fairino import Robot
 2import time
 3# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 4robot = Robot.RPC('192.168.58.2')
 5j1 =[-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6j5 =[-95.228, -54.621, 73.691, -112.245, -91.280, 74.268]
 7desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 8desc_pos5 = [-33.421, 732.572, 275.103, -177.907, 2.709, -79.482]
 9offset_pos = [0, 0, 0, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 100.0
14acc = 100.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19rtn = robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
20rtn = robot.MoveJ(joint_pos=j5, tool=tool, user=user, vel=vel, blendT=1)
21time.sleep(1)
22robot.PauseMotion()
23time.sleep(1)
24robot.ResumeMotion()
25time.sleep(1)
26robot.StopMotion()
27time.sleep(1)
28robot.CloseRPC()

4.37. Globalen Punktversatz aktivieren

Prototyp

PointsOffsetEnable(flag, offset_pos)

Beschreibung

Globalen Punktversatz aktivieren

Erforderliche Parameter

  • flag: 0-Versatz im Basis-/Werkstückkoordinatensystem, 2-Versatz im Werkzeugkoordinatensystem

  • offset_pos: Versatz, Einheit [mm][°]

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.38. Globalen Punktversatz deaktivieren

Prototyp

PointsOffsetDisable()

Beschreibung

Globalen Punktversatz deaktivieren

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.39. Codebeispiel für Punktversatz

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9offset_pos1 = [0, 0, 50, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 100.0
14acc = 100.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel)
20robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
21time.sleep(1)
22robot.PointsOffsetEnable(flag=0, offset_pos=offset_pos1)
23robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
24robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
25robot.PointsOffsetDisable()
26robot.CloseRPC()

4.40. Steuerschrank AO High-Speed-Ausgabe starten (MoveAOStart)

Neu in Version python: SDK-v2.0.4

Prototyp

MoveAOStart(AONum, maxTCPSpeed=1000, maxAOPercent=100, zeroZoneCmp=20)

Beschreibung

Steuerschrank AO High-Speed-Ausgabe starten

Erforderliche Parameter

  • AONum: Steuerschrank AO-Nummer

Optionale Parameter

  • maxTCPSpeed: Maximaler TCP-Geschwindigkeitswert [1-5000 mm/s], Standard 1000

  • maxAOPercent: AO-Prozentsatz für maximale TCP-Geschwindigkeit, Standard 100%

  • zeroZoneCmp: AO-Prozentsatz für Totzonenkompensation, Ganzzahl, Standard 20, Bereich [0-100]

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.41. Steuerschrank AO High-Speed-Ausgabe stoppen (MoveAOStop)

Neu in Version python: SDK-v2.0.4

Prototyp

MoveAOStop()

Beschreibung

Steuerschrank AO High-Speed-Ausgabe stoppen

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.42. Endeffektor AO High-Speed-Ausgabe starten (MoveToolAOStart)

Neu in Version python: SDK-v2.0.4

Prototyp

MoveToolAOStart(AONum, maxTCPSpeed=1000, maxAOPercent=100, zeroZoneCmp=20)

Beschreibung

Endeffektor AO High-Speed-Ausgabe starten

Erforderliche Parameter

  • AONum: Endeffektor AO-Nummer

Optionale Parameter

  • maxTCPSpeed: Maximaler TCP-Geschwindigkeitswert [1-5000 mm/s], Standard 1000

  • maxAOPercent: AO-Prozentsatz für maximale TCP-Geschwindigkeit, Standard 100%

  • zeroZoneCmp: AO-Prozentsatz für Totzonenkompensation, Ganzzahl, Standard 20, Bereich [0-100]

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.43. Endeffektor AO High-Speed-Ausgabe stoppen (MoveToolAOStop)

Neu in Version python: SDK-v2.0.4

Prototyp

MoveToolAOStop()

Beschreibung

Endeffektor AO High-Speed-Ausgabe stoppen

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.44. Codebeispiel für AO High-Speed-Ausgabe (MoveAO)

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4j1 = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5j2 = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6desc_pos1 = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7desc_pos2 = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8offset_pos = [0, 0, 0, 0, 0, 0]
 9offset_pos1 = [0, 0, 50, 0, 0, 0]
10epos = [0, 0, 0, 0]
11tool = 0
12user = 0
13vel = 20.0
14acc = 20.0
15ovl = 100.0
16blendT = -1.0
17flag = 0
18robot.SetSpeed(20)
19robot.MoveAOStart(0, 100, 100, 20)
20robot.MoveJ(joint_pos=j1,tool=tool, user=user, vel=vel)
21robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
22robot.MoveAOStop()
23time.sleep(1)
24robot.MoveToolAOStart(0, 100, 100, 20)
25robot.MoveJ(joint_pos=j1, tool=tool, user=user, vel=vel)
26robot.MoveJ(joint_pos=j2, tool=tool, user=user, vel=vel)
27robot.MoveToolAOStop()
28robot.CloseRPC()

4.45. PTP-Bewegung mit FIR-Filterung starten

Neu in Version python: SDK-v2.1.2

Prototyp

PtpFIRPlanningStart(maxAcc, maxJek)

Beschreibung

PTP-Bewegung mit FIR-Filterung starten

Erforderliche Parameter

  • maxAcc: Maximale Beschleunigung (deg/s²)

  • maxJek: Maximale einheitliche Gelenkruck (deg/s³)

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.46. PTP-Bewegung mit FIR-Filterung beenden

Neu in Version python: SDK-v2.0.7

Prototyp

PtpFIRPlanningEnd()

Beschreibung

PTP-Bewegung mit FIR-Filterung beenden

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

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

Neu in Version python: SDK-v2.0.7

Prototyp

LinArcFIRPlanningStart(maxAccLin, maxAccDeg, maxJerkLin, maxJerkDeg)

Beschreibung

LIN-/ARC-Bewegung mit FIR-Filterung starten

Erforderliche Parameter

  • maxAccLin: Maximale Linearbeschleunigung (mm/s²)

  • maxAccDeg: Maximale Winkelbeschleunigung (deg/s²)

  • maxJerkLin: Maximaler Linearruck (mm/s³)

  • maxJerkDeg: Maximaler Winkelruck (deg/s³)

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

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

Neu in Version python: SDK-v2.0.7

Prototyp

LinArcFIRPlanningEnd()

Beschreibung

LIN-/ARC-Bewegung mit FIR-Filterung beenden

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.49. Codebeispiel für FIR-Filterung

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6midjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 7endjointPos = [-29.777, -84.536, 109.275, -114.075, -86.655, 74.257]
 8startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 9middescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
10enddescPose = [-487.434, 154.362, 308.576, 176.600, 0.268, -14.061]
11exaxisPos = [0.0, 0.0, 0.0, 0.0]
12offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
13rtn = robot.PtpFIRPlanningStart(1000.0, 1000.0)
14print(f"PtpFIRPlanningStart rtn is {rtn}")
15error = robot.MoveJ(joint_pos=startjointPos,tool= 0,user= 0,desc_pos=startdescPose,vel= 100,acc=100,ovl=100, blendT=-1.0, offset_flag=0)
16print(f"MoveJ rtn is {rtn}")
17error = robot.MoveJ(joint_pos=endjointPos,tool= 0,user= 0,desc_pos=enddescPose,vel= 100,acc=100,ovl=100, blendT=-1.0, offset_flag=0)
18print(f"MoveJ rtn is {rtn}")
19robot.PtpFIRPlanningEnd()
20print(f"PtpFIRPlanningEnd rtn is {rtn}")
21rtn = robot.LinArcFIRPlanningStart(1000, 1000, 1000, 1000)
22print(f"LinArcFIRPlanningStart rtn is {rtn}")
23error = robot.MoveL(desc_pos=startdescPose,tool= 0,user= 0, joint_pos=startjointPos,vel= 100,overSpeedStrategy=1,speedPercent=1)
24print(f"MoveL rtn is {rtn}")
25error = robot.MoveC(desc_pos_p=middescPose,tool_p= 0,user_p= 0, joint_pos_p=midjointPos,vel_p= 100,desc_pos_t=enddescPose,tool_t= 0,user_t= 0,joint_pos_t=endjointPos,vel_t= 100)
26print(f"MoveC rtn is {rtn}")
27robot.LinArcFIRPlanningEnd()
28print(f"LinArcFIRPlanningEnd rtn is {rtn}")
29robot.CloseRPC()

4.50. Beschleunigungsglättung aktivieren

Neu in Version python: SDK-v2.1.1

Prototyp

AccSmoothStart(saveFlag)

Beschreibung

Beschleunigungsglättung aktivieren

Erforderliche Parameter

  • saveFlag: Bei Stromausfall speichern? (0-nein, 1-ja)

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.51. Beschleunigungsglättung deaktivieren

Neu in Version python: SDK-v2.1.1

Prototyp

AccSmoothEnd(saveFlag)

Beschreibung

Beschleunigungsglättung deaktivieren

Erforderliche Parameter

  • saveFlag: Bei Stromausfall speichern? (0-nein, 1-ja)

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.52. Codebeispiel für Beschleunigungsglättung

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8exaxisPos = [0.0, 0.0, 0.0, 0.0]
 9offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
10rtn = robot.AccSmoothStart(0)
11print(f"AccSmoothStart rtn is {rtn}")
12robot.MoveJ(joint_pos=startjointPos,tool= 0,user= 0,vel= 100)
13robot.MoveJ(joint_pos=endjointPos,tool= 0,user= 0,vel= 100)
14rtn = robot.AccSmoothEnd(0)
15print(f"AccSmoothEnd rtn is {rtn}")
16robot.CloseRPC()

4.53. Spezifische Ausrichtungsgeschwindigkeit aktivieren

Neu in Version python: SDK-v2.0.5

Prototyp

AngularSpeedStart(ratio)

Beschreibung

Spezifische Ausrichtungsgeschwindigkeit aktivieren

Erforderliche Parameter

  • ratio: Ausrichtungsgeschwindigkeitsprozentsatz [0-300]

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.54. Spezifische Ausrichtungsgeschwindigkeit deaktivieren

Neu in Version python: SDK-v2.0.5

Prototyp

AngularSpeedEnd()

Beschreibung

Spezifische Ausrichtungsgeschwindigkeit deaktivieren

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.55. Codebeispiel für spezifische Ausrichtungsgeschwindigkeit

 1from fairino import Robot
 2# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 3robot = Robot.RPC('192.168.58.2')
 4startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 5endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 6startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 7enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 8exaxisPos = [0.0, 0.0, 0.0, 0.0]
 9offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
10rtn = robot.AngularSpeedStart(50)
11print(f"AngularSpeedStart rtn is {rtn}")
12robot.MoveJ(joint_pos=startjointPos, tool=0,user= 0,vel= 100)
13robot.MoveJ(joint_pos=endjointPos, tool=0,user= 0,vel= 100)
14rtn = robot.AngularSpeedEnd()
15print(f"AngularSpeedEnd rtn is {rtn}")
16robot.CloseRPC()

4.56. Singularitätsschutz starten

Neu in Version python: SDK-v2.0.5

Prototyp

SingularAvoidStart(protectMode, minShoulderPos=100, minElbowPos=50, minWristPos=10)

Beschreibung

Singularitätsschutz starten

Erforderliche Parameter

  • protectMode: Singularitätsschutzmodus, 0: Gelenkmodus; 1: Kartesischer Modus

Optionale Parameter

  • minShoulderPos: Einstellbereich für Schulter-Singularität (mm), Standard 100.0

  • minElbowPos: Einstellbereich für Ellenbogen-Singularität (mm), Standard 50.0

  • minWristPos: Einstellbereich für Handgelenks-Singularität (°), Standard 10.0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.57. Singularitätsschutz stoppen

Neu in Version python: SDK-v2.0.5

Prototyp

SingularAvoidEnd()

Beschreibung

Singularitätsschutz stoppen

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.58. Codebeispiel für Roboter-Singularitätsschutz

 1from fairino import Robot
 2import time
 3# Verbindung zum Robotercontroller herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
 4robot = Robot.RPC('192.168.58.2')
 5startjointPos = [-11.904, -99.669, 117.473, -108.616, -91.726, 74.256]
 6endjointPos = [-45.615, -106.172, 124.296, -107.151, -91.282, 74.255]
 7startdescPose = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
 8enddescPose = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
 9exaxisPos = [0.0, 0.0, 0.0, 0.0]
10offdese = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
11rtn = robot.SingularAvoidStart(2, 10, 5, 5)
12print(f"SingularAvoidStart rtn is {rtn}")
13robot.MoveJ(joint_pos=startjointPos, tool=0,user= 0,vel= 100)
14robot.MoveJ(joint_pos=endjointPos, tool=0,user= 0,vel= 100)
15rtn = robot.SingularAvoidEnd()
16print(f"SingularAvoidEnd rtn is {rtn}")
17robot.CloseRPC()

4.59. Bewegungsbefehlswarteschlange leeren

Neu in Version python: SDK-v2.1.7

Prototyp

MotionQueueClear()

Beschreibung

Bewegungsbefehlswarteschlange leeren

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.60. Bewegung zum Startpunkt einer Durchdringungskurve

Neu in Version python: SDK-v2.1.7

Prototyp

MoveToIntersectLineStart(mainPoint, piecePoint, tool, wobj, vel, acc, ovl, oacc, moveType, mainExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], pieceExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], extAxisFlag=0, exaxisPos=[0.0,0.0,0.0,0.0], moveDirection=0, offset=[0.0,0.0,0.0,0.0,0.0,0.0])

Beschreibung

Bewegung zum Startpunkt einer Durchdringungskurve

Erforderliche Parameter

  • mainPoint: Kartesische Posen der 6 Teach-Punkte des Hauptrohrs

  • piecePoint: Kartesische Posen der 6 Teach-Punkte des Nebenrohrs

  • tool: Werkzeugkoordinatensystem-Nummer

  • wobj: Werkstückkoordinatensystem-Nummer

  • vel: Geschwindigkeitsprozentsatz

  • acc: Beschleunigungsprozentsatz

  • ovl: Geschwindigkeitsskalierungsfaktor

  • oacc: Beschleunigungsskalierungsfaktor

  • moveType: Bewegungstyp; 0-PTP; 1-LIN

Optionale Parameter

  • mainExaxisPos: Positionen der Erweiterungsachse für die 6 Teach-Punkte des Hauptrohrs, Standard [[0.0,0.0,0.0,0.0], …]

  • pieceExaxisPos: Positionen der Erweiterungsachse für die 6 Teach-Punkte des Nebenrohrs, Standard [[0.0,0.0,0.0,0.0], …]

  • extAxisFlag: Erweiterungsachse verwenden? 0-nein; 1-ja, Standard 0

  • exaxisPos: Startposition der Erweiterungsachse [0.0,0.0,0.0,0.0], Standard [0.0,0.0,0.0,0.0]

  • moveDirection: Bewegungsrichtung; 0-im Uhrzeigersinn; 1-gegen Uhrzeigersinn, Standard 0

  • offset: Versatz [x,y,z,rx,ry,rz], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.61. Bewegung entlang einer Durchdringungskurve

Neu in Version python: SDK-v2.1.7

Prototyp

MoveIntersectLine(mainPoint, piecePoint, tool, wobj, vel, acc, ovl, oacc, moveDirection, mainExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], pieceExaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], extAxisFlag=0, exaxisPos=[[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]], offset=[0.0,0.0,0.0,0.0,0.0,0.0])

Beschreibung

Bewegung entlang einer Durchdringungskurve

Erforderliche Parameter

  • mainPoint: Kartesische Posen der 6 Teach-Punkte des Hauptrohrs

  • piecePoint: Kartesische Posen der 6 Teach-Punkte des Nebenrohrs

  • tool: Werkzeugkoordinatensystem-Nummer

  • wobj: Werkstückkoordinatensystem-Nummer

  • vel: Geschwindigkeitsprozentsatz

  • acc: Beschleunigungsprozentsatz

  • ovl: Geschwindigkeitsskalierungsfaktor

  • oacc: Beschleunigungsskalierungsfaktor

  • moveDirection: Bewegungsrichtung; 0-im Uhrzeigersinn; 1-gegen Uhrzeigersinn

Optionale Parameter

  • mainExaxisPos: Positionen der Erweiterungsachse für die 6 Teach-Punkte des Hauptrohrs, Standard [[0.0,0.0,0.0,0.0], …]

  • pieceExaxisPos: Positionen der Erweiterungsachse für die 6 Teach-Punkte des Nebenrohrs, Standard [[0.0,0.0,0.0,0.0], …]

  • extAxisFlag: Erweiterungsachse verwenden? 0-nein; 1-ja, Standard 0

  • exaxisPos: Positionen der Erweiterungsachse (Array der Länge 4), Standard [[0.0,0.0,0.0,0.0], …]

  • offset: Versatz [x,y,z,rx,ry,rz], Standard [0.0,0.0,0.0,0.0,0.0,0.0]

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.62. Codebeispiel für Bewegung entlang einer Durchdringungskurve

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4mainPoint = [[0.0] * 6 for _ in range(6)]
 5piecePoint = [[0.0] * 6 for _ in range(6)]
 6mainExaxisPos = [[0.0] * 4 for _ in range(6)]
 7pieceExaxisPos = [[0.0] * 4 for _ in range(6)]
 8extAxisFlag = 1
 9exaxisPos = [[0.0] * 4 for _ in range(4)]
10offset = [0.0, 2.0, 30.0, -2.0, 0.0, 0.0]
11mainPoint[0] = [490.004, -383.194, 402.735, -9.332, -1.528, 69.594]
12mainPoint[1] = [444.950, -407.117, 389.011, -5.546, -2.196, 65.279]
13mainPoint[2] = [445.168, -463.605, 355.759, -1.544, -10.886, 57.104]
14mainPoint[3] = [507.529, -485.385, 343.013, -0.786, -4.834, 61.799]
15mainPoint[4] = [554.390, -442.647, 367.701, -4.761, -10.181, 64.925]
16mainPoint[5] = [532.552, -394.003, 396.467, -13.732, -13.592, 67.411]
17mainExaxisPos[0] = [-29.996, 0.000, 0.000, 0.000]
18mainExaxisPos[1] = [-29.996, 0.000, 0.000, 0.000]
19mainExaxisPos[2] = [-29.996, 0.000, 0.000, 0.000]
20mainExaxisPos[3] = [-29.996, 0.000, 0.000, 0.000]
21mainExaxisPos[4] = [-29.996, 0.000, 0.000, 0.000]
22mainExaxisPos[5] = [-29.996, 0.000, 0.000, 0.000]
23piecePoint[0] = [505.571, -192.408, 316.759, 38.098, 37.051, 139.447]
24piecePoint[1] = [533.837, -201.558, 332.340, 34.644, 42.339, 137.748]
25piecePoint[2] = [530.386, -225.085, 373.808, 35.431, 45.111, 137.560]
26piecePoint[3] = [485.646, -229.195, 383.778, 33.870, 45.173, 137.064]
27piecePoint[4] = [460.551, -212.161, 354.256, 28.856, 45.602, 135.930]
28piecePoint[5] = [474.217, -197.124, 324.611, 42.469, 41.133, 148.167]
29pieceExaxisPos[0] = [-29.996, -0.000, 0.000, 0.000]
30pieceExaxisPos[1] = [-29.996, -0.000, 0.000, 0.000]
31pieceExaxisPos[2] = [-29.996, -0.000, 0.000, 0.000]
32pieceExaxisPos[3] = [-29.996, -0.000, 0.000, 0.000]
33pieceExaxisPos[4] = [-29.996, -0.000, 0.000, 0.000]
34pieceExaxisPos[5] = [-29.996, -0.000, 0.000, 0.000]
35exaxisPos[0] = [-29.996, -0.000, 0.000, 0.000]
36exaxisPos[1] = [-44.994, 90.000, 0.000, 0.000]
37exaxisPos[2] = [-59.992, 0.002, 0.000, 0.000]
38exaxisPos[3] = [-44.994, -89.997, 0.000, 0.000]
39tool = 2
40wobj = 0
41vel = 100.0
42acc = 100.0
43ovl = 12.0
44oacc = 12.0
45moveType = 1
46moveDirection = 1
47rtn = robot.MoveToIntersectLineStart(mainPoint=mainPoint, mainExaxisPos=mainExaxisPos, piecePoint=piecePoint, pieceExaxisPos=pieceExaxisPos, extAxisFlag=extAxisFlag,exaxisPos=exaxisPos[0], tool=tool, wobj=wobj, vel=vel, acc=acc, ovl=ovl, oacc=oacc, moveType=moveType, moveDirection=moveDirection, offset=offset)
48print(f"MoveToIntersectLineStart rtn is {rtn}")
49rtn = robot.MoveIntersectLine(mainPoint=mainPoint, mainExaxisPos=mainExaxisPos, piecePoint=piecePoint, pieceExaxisPos=pieceExaxisPos, extAxisFlag=extAxisFlag, exaxisPos=exaxisPos, tool=tool,wobj=wobj, vel=vel, acc=acc, ovl=5.0, oacc=5.0, moveDirection=moveDirection, offset=offset)
50print(f"MoveIntersectLine rtn is {rtn}")
51robot.CloseRPC()

4.63. Bewegung auf der Stelle (ohne Positionsänderung)

Prototyp

MoveStationary()

Beschreibung

Bewegung auf der Stelle (ohne Positionsänderung)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.64. Codebeispiel für Bewegung auf der Stelle

 1from fairino import Robot
 2import time
 3robot = Robot.RPC('192.168.58.2')
 4rtn = robot.LaserSensorRecordandReplay(0, 10, 1, 0, 0.1, 1, 0, 10, 100)
 5print(f"LaserSensorRecordandReplay rtn is {rtn}")
 6rtn = robot.MoveStationary()
 7print(f"MoveStationary rtn is {rtn}")
 8rtn = robot.LaserSensorRecord1(0, 10)
 9print(f"LaserSensorRecordandReplay rtn is {rtn}")
10robot.CloseRPC()
11return 0

4.65. Stationäres Pendeln Start

Prototyp

OriginPointWeaveStart(weaveNum, mode, refPoint, weaveTime)

Beschreibung

Start des stationären Pendelns

Erforderliche Parameter

  • weaveNum: Pendelnummer [0-7]

  • mode: 0-Werkzeugkoordinatensystem; 1-Referenzpunkt

  • refPoint: Referenzpunkt-Koordinaten im kartesischen Koordinatensystem [x,y,z,a,b,c]

  • weaveTime: Pendelzeit [s]

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler-errcode

4.66. Stationäres Pendeln Ende

Prototyp

OriginPointWeaveEnd()

Beschreibung

Ende des stationären Pendelns

Erforderliche Parameter

Keine

Standardparameter

Keine

Rückgabewert

  • Fehlercode Erfolg-0 Fehler-errcode

4.67. SDK-Codebeispiel für stationäres Pendeln

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Verbindung mit der Robotersteuerung herstellen
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestOriginPointWeave(self):
 9    time.sleep(2)
10    # Gelenkposition, externe Achse und Offset initialisieren
11    j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842]
12    epos = [0, 0, 0, 0]
13    offset_pos = [0, 0, 0, 0, 0, 0]
14
15    # Referenzpunktposition [x, y, z, rx, ry, rz]
16    refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956]
17
18    # In die Startposition bewegen
19    robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100,
20                exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
21
22    # Erstes Pendeln: Absolutes Koordinatensystem (tool=0), Modus 0
23    robot.OriginPointWeaveStart(0, 0, refPoint, 3)
24    robot.MoveStationary()
25    robot.OriginPointWeaveEnd()
26
27    time.sleep(2)
28
29    # Erneut in die Startposition bewegen
30    robot.MoveJ(joint_pos=j, tool=1, user=0, vel=100, acc=100, ovl=100,
31                exaxis_pos=epos, blendT=-1, offset_flag=0, offset_pos=offset_pos)
32
33    # Zweites Pendeln: Absolutes Koordinatensystem (tool=0), Modus 1
34    robot.OriginPointWeaveStart(0, 1, refPoint, 3)
35    robot.MoveStationary()
36    robot.OriginPointWeaveEnd()
37
38    # Verbindung schließen
39    robot.CloseRPC()
40    time.sleep(1)
41
42TestOriginPointWeave(robot)

4.68. SDK-Codebeispiel für stationäres Pendeln (mit Laser und Erweiterungsachse)

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Verbindung mit der Robotersteuerung herstellen
 6robot = Robot.RPC('192.168.58.2')
 7
 8def TestOriginPointWeave(self):
 9    time.sleep(2)
10    # Gelenkposition, externe Achse und Offset initialisieren
11    j = [39.886, -98.580, -124.032, -47.393, 90.000, 40.842]
12    epos1 = [0, 0, 0, 0]
13    offset_pos = [0, 0, 0, 0, 0, 0]
14    epos2 = [5, 0.000, 0.000, 0.000]
15    # Referenzpunktposition [x, y, z, rx, ry, rz]
16    refPoint = [400.021, 300.022, 299.996, 179.997, -0.003, -90.956]
17
18    rtn = 0
19    robot.LaserTrackingSensorConfig("192.168.58.20", 5020)
20    robot.LaserTrackingSensorSamplePeriod(20)
21    robot.LoadPosSensorDriver(101)
22
23    # UDP-Treiber laden
24    robot.ExtDevLoadUDPDriver()
25
26    # Positionierungsabschlusszeit für Erweiterungsachse einstellen
27    rtn = robot.SetExAxisCmdDoneTime(5000.0)
28    print(f"SetExAxisCmdDoneTime rtn is {rtn}")
29
30    # Erweiterungsachsen 1 und 2 aktivieren
31    rtn = robot.ExtAxisServoOn(1, 1)
32    print(f"ExtAxisServoOn axis id 1 rtn is {rtn}")
33    rtn = robot.ExtAxisServoOn(2, 1)
34    print(f"ExtAxisServoOn axis id 2 rtn is {rtn}")
35    time.sleep(2)
36
37    # Referenzfahrt für Erweiterungsachse einstellen
38    robot.ExtAxisSetHoming(1, 0, 10, 2)
39    robot.LaserTrackingLaserOnOff(1)
40
41    # 1---Ohne Erweiterungsachse
42    robot.LaserTrackingTrackOnOff(1, 4)
43    time.sleep(0.2)
44    # Stationäres Pendeln starten
45    robot.OriginPointWeaveStart(0, 0, refPoint, 10)
46    robot.MoveStationary()  # Stationäre Bewegung ausführen (vorausgesetzt, diese Methode existiert)
47    robot.OriginPointWeaveEnd()
48    robot.LaserTrackingTrackOnOff(0, 4)
49
50    time.sleep(2)  # 2 Sekunden warten
51
52    # 2----Mit Erweiterungsachse
53    robot.ExtAxisMove(epos1, 100, -1)
54    robot.LaserTrackingTrackOnOff(1, 4)
55    # Stationäres Pendeln starten
56    robot.OriginPointWeaveStart(0, 0, refPoint, 20)
57    robot.ExtAxisMove(epos2, 100, -1)
58    robot.OriginPointWeaveEnd()
59    robot.LaserTrackingTrackOnOff(0, 4)
60
61    # Verbindung schließen
62    robot.CloseRPC()
63    time.sleep(1)
64
65TestOriginPointWeave(robot)

4.69. Bewegung im Geschwindigkeits-Servo-Modus des Gelenkraums

Prototyp

ServoJV(self, joint_vel, exis_vel, acc=0.0, vel=0.0, cmdT=0.008, filterT=0.0, gain=0.0, id=0, comType=0)

Beschreibung

Bewegung im Geschwindigkeits-Servo-Modus des Gelenkraums

Erforderliche Parameter

  • joint_vel: 6 Zielgelenkgeschwindigkeiten, Einheit deg/s

  • exis_vel: 4 Geschwindigkeiten externer Achsen, Einheit deg/s

  • acc: Beschleunigungsprozentsatz, Bereich [0~100], noch nicht freigegeben, Standard 0

  • vel: Geschwindigkeitsprozentsatz, Bereich [0~100], noch nicht freigegeben, Standard 0

  • cmdT: Befehlszykluszeit, Einheit s, empfohlener Bereich [0.001~0.0016]

  • filterT: Filterzeit, Einheit s, noch nicht freigegeben, Standard 0

  • gain: Proportionalverstärkung für Zielposition, noch nicht freigegeben, Standard 0

  • id: servoJ-Befehls-ID, Standard 0

  • comType: Befehlstyp; 0-xmlrpc; 1-UDP (entspricht Roboter-Port 20007)

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler- errcode

4.70. Codebeispiel für Bewegung im Geschwindigkeits-Servo-Modus des Gelenkraums

 1from fairino import Robot
 2import time
 3
 4def main():
 5    # Verbindung mit der Robotersteuerung herstellen
 6    robot = Robot.RPC('192.168.58.2')
 7    time.sleep(0.5)  # Auf Verbindung und Datenempfang warten
 8
 9    # Initialisiere Gelenkgeschwindigkeitsarray und externe Achsen-Geschwindigkeitsarray
10    joint_vel = [10.0, 0.0, 0.0, 0.0, 0.0, 0.0]
11    exis_vel = [0.0, 0.0, 0.0, 0.0]
12    acc = 0.0
13    vel = 0.0
14    cmdT = 0.008
15    filterT = 0.0
16    gain = 0.0
17    cnt = 0
18
19    # ServoJV in einer Schleife aufrufen, insgesamt 200 Mal
20    while cnt < 200:
21        rtn = robot.ServoJV(joint_vel=joint_vel, exis_vel=exis_vel, acc=acc, vel=vel,
22                            cmdT=cmdT, filterT=filterT, gain=gain)
23        print(f"ServoJV rtn is {rtn}")
24        cnt += 1
25
26    # Verbindung schließen
27    robot.CloseRPC()
28
29
30# Testfunktion aufrufen
31main()

4.71. Start der Gelenk-MIT-Steuerung

Prototyp

ServoMITStart(self, comType=0)

Beschreibung

Start der Gelenk-MIT-Steuerung

Erforderliche Parameter

  • comType: Befehlstyp; 0-xmlrpc; 1-UDP (entspricht Roboter-Port 20007)

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler- errcode

4.72. Ende der Gelenk-MIT-Steuerung

Prototyp

ServoMITEnd(self, comType=0)

Beschreibung

Ende der Gelenk-MIT-Steuerung

Erforderliche Parameter

  • comType: Befehlstyp; 0-xmlrpc; 1-UDP (entspricht Roboter-Port 20007)

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler- errcode

4.73. Gelenk-MIT-Steuerung

Prototyp

ServoMIT(self, posGain, desPos, velGain, desVel, torque_ff, interval, comType=0)

Beschreibung

Gelenk-MIT-Steuerung

Erforderliche Parameter

  • posGain: j1~j6 Gelenkpositionsverstärkungen

  • desPos: j1~j6 gewünschte Gelenkpositionen, Einheit: deg

  • velGain: j1~j6 Gelenkgeschwindigkeitsverstärkungen

  • desVel: j1~j6 gewünschte Gelenkgeschwindigkeiten, Einheit: deg/s

  • torque_ff: j1~j6 Feedforward-Drehmomente, Einheit: Nm

  • interval: Befehlszykluszeit, Einheit s, Bereich [0.001~0.008]

  • comType: Befehlstyp; 0-xmlrpc; 1-UDP (entspricht Roboter-Port 20007)

Standardparameter

Keine

Rückgabewert

Fehlercode Erfolg-0 Fehler- errcode

4.74. Codebeispiel für Roboter-Gelenk-MIT-Steuerung

 1from time import sleep
 2import time
 3from fairino import Robot
 4
 5# Verbindung mit der Robotersteuerung herstellen
 6robot = Robot.RPC('192.168.58.2')
 7
 8# Callback-Funktion definieren
 9def udp_frame_callback(src_type, count, cmd_id, data_len, content):
10    """UDP-Befehlsantwort-Callback-Funktion"""
11    print(f"Callback: cmd_id={cmd_id} count={count} data_len={data_len} content={content}")
12    return 0
13
14def ServoMITtest(self):
15    # UDP-Befehlsantwort-Callback setzen
16    robot.SetUDPCmdRpyCallback(udp_frame_callback)
17
18    while True:
19        # Alle Fehler zurücksetzen
20        robot.ResetAllError()
21        time.sleep(0.5)
22
23        # Parameterarrays initialisieren
24        posGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
25        desPos = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
26        velGain = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
27        desVel = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
28        torques = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
29
30        # Gelenkdrehmomente abrufen
31        rtn, torques = robot.GetJointTorques(flag=1)
32        print(f"GetJointTorques rtn: {rtn}")
33        print("111111")
34
35        # Servo MIT-Modus starten
36        rtn = robot.ServoMITStart(0)
37        print(f"ServoMITStart rtn: {rtn}")
38
39        # Drag Teaching aktivieren
40        rtn = robot.DragTeachSwitch(1)
41        print(f"DragTeachSwitch rtn: {rtn}")
42
43        intev = 0.008
44
45        # Vorwärtsbewegung: positives Drehmoment auf Achse 6, bis Winkel 30 Grad überschreitet
46        while True:
47            torques[5] = 0.03
48            rtn = robot.ServoMIT(posGain, desPos, velGain,
49                                desVel, torques, intev, comType=0)
50            print(f"ServoMIT call rtn is {rtn}")
51            time.sleep(0.001)  # 1ms
52
53            rtn, pkg = robot.GetRobotRealTimeState()
54            print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}")
55
56            if pkg.jt_cur_pos[5] > 30:
57                break
58
59        # Rückwärtsbewegung: negatives Drehmoment auf Achse 6, bis Winkel unter 0 Grad liegt
60        while True:
61            torques[5] = -0.03
62            rtn = robot.ServoMIT(posGain, desPos, velGain,
63                                desVel, torques, intev, comType=0)
64            print(f"ServoMIT call rtn is {rtn}")
65            time.sleep(0.001)  # 1ms
66
67            rtn, pkg = robot.GetRobotRealTimeState()
68            print(f"pkg.jt_cur_pos[5]: {pkg.jt_cur_pos[5]}")
69
70            if pkg.jt_cur_pos[5] < 0:
71                break
72
73        # Drag Teaching deaktivieren
74        rtn = robot.DragTeachSwitch(0)
75        print(f"DragTeachSwitch off rtn: {rtn}")
76
77        # Servo MIT-Modus beenden
78        rtn = robot.ServoMITEnd(0)
79        print(f"ServoMITEnd rtn: {rtn}")
80
81# Testfunktion aufrufen
82ServoMITtest(robot)