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. Servo-Modus Bewegung starten

Prototyp

ServoMoveStart()

Beschreibung

Servo-Modus Bewegung starten (in Verbindung mit ServoJ, ServoCart)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.14. Servo-Modus Bewegung beenden

Prototyp

ServoMoveEnd()

Beschreibung

Servo-Modus Bewegung beenden (in Verbindung mit ServoJ, ServoCart)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.15. Servo-Modus Bewegung im Gelenkraum (ServoJ)

Prototyp

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

Beschreibung

Servo-Modus Bewegung im Gelenkraum (ServoJ)

Erforderliche Parameter

  • joint_pos: Ziel-Gelenkposition, Einheit [°]

  • axisPos: Position der externen Achse, Einheit mm

Optionale Parameter

  • 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

  • id: servoJ Befehls-ID, Standard 0

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.16. 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.17. Gelenk-Drehmomentregelung starten (ServoJT)

Prototyp

ServoJTStart()

Beschreibung

Gelenk-Drehmomentregelung starten (ServoJT)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.18. Gelenk-Drehmomentregelung (ServoJT)

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])

Beschreibung

Gelenk-Drehmomentregelung (ServoJT)

Erforderliche Parameter

  • torque: j1~j6 Gelenkdrehmomente, Einheit Nm

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

  • checkFlag: Erkennungsstrategie 0-keine Einschränkung; 1-Leistungsbegrenzung; 2-Geschwindigkeitsbegrenzung; 3-Leistungs- und Geschwindigkeitsbegrenzung gleichzeitig, 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]

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.19. Gelenk-Drehmomentregelung beenden (ServoJT)

Prototyp

ServoJTEnd()

Beschreibung

Gelenk-Drehmomentregelung beenden (ServoJT)

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.20. 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.21. 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.22. 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.23. Spline-Bewegung starten

Prototyp

SplineStart()

Beschreibung

Spline-Bewegung starten

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.24. 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.25. Spline-Bewegung beenden

Prototyp

SplineEnd()

Beschreibung

Spline-Bewegung beenden

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.26. 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.27. 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.28. 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.29. 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.30. 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.31. 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.32. 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.33. 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.34. 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.35. 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.36. Globalen Punktversatz deaktivieren

Prototyp

PointsOffsetDisable()

Beschreibung

Globalen Punktversatz deaktivieren

Erforderliche Parameter

Keine

Optionale Parameter

Keine

Rückgabewerte

Fehlercode: 0 bei Erfolg, sonst Fehlercode

4.37. 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.38. 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.39. 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.40. 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.41. 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.42. 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.43. 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.44. 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.45. 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.46. 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.47. 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.48. 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.49. 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.50. 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.51. 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.52. 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.53. 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.54. 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.55. 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.56. 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.57. 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.58. 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.59. 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.60. 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.61. 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.62. 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