11. Roboter-Peripherie

11.1. Greifer konfigurieren

Prototyp	SetGripperConfig(company, device, softversion=0, bus=0)
Beschreibung	Greifer konfigurieren
Erforderliche Parameter	company: Greiferhersteller, 1-Robotiq, 2-Huiling, 3-Tianji, 4-Dahuan, 5-Zhixing device: Gerätenummer, Robotiq(0-2F-85 Serie), Huiling(0-NK Serie, 1-Z-EFG-100), Tianji(0-TEG-110), Dahuan(0-PGI-140), Zhixing(0-CTPM2F20)
Standardparameter	softversion: Softwareversionsnummer, vorübergehend nicht verwendet, Standard = 0 bus: Position des Geräts am Endeffektor-Bus, vorübergehend nicht verwendet, Standard = 0
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.2. Greiferkonfiguration abrufen

Prototyp	GetGripperConfig()
Beschreibung	Greiferkonfiguration abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode [number, company, device, softversion]: number = Greifernummer; company = Hersteller; device = Gerätenummer; softversion = Softwareversion

11.3. Greifer aktivieren

Prototyp	ActGripper(index, action)
Beschreibung	Greifer aktivieren
Erforderliche Parameter	index: Greifernummer action: 0 = Zurücksetzen, 1 = Aktivieren
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.4. Greifer steuern

Prototyp	MoveGripper(index, pos, vel, force, maxtime, block, type, rotNum, rotVel, rotTorque)
Beschreibung	Greifer steuern
Erforderliche Parameter	index: Greifernummer pos: Positionsprozentsatz, Bereich [0~100] vel: Geschwindigkeitsprozentsatz, Bereich [0~100] force: Drehmomentprozentsatz, Bereich [0~100] maxtime: Maximale Wartezeit, Bereich [0~30000], [ms] block: 0 = blockierend, 1 = nicht blockierend type: Greifertyp, 0 = Parallelgreifer, 1 = Rotationsgreifer rotNum: Rotationsanzahl (Umdrehungen) rotVel: Rotationsgeschwindigkeitsprozentsatz [0-100] rotTorque: Rotationsdrehmomentprozentsatz [0-100]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.5. Greifer-Bewegungsstatus abrufen

Prototyp	GetGripperMotionDone()
Beschreibung	Greifer-Bewegungsstatus abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode [fault, status]: fault = 0 = kein Fehler, 1 = Fehler; status = 0 = Bewegung nicht abgeschlossen, 1 = Bewegung abgeschlossen

11.6. Greifer-Aktivierungsstatus abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetGripperActivateStatus()
Beschreibung	Greifer-Aktivierungsstatus abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler gripper_active: Bit0~Bit15 entsprechen Greifernummern 0~15, Bit = 0 = nicht aktiviert, Bit = 1 = aktiviert

11.7. Greiferposition abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetGripperCurPosition()
Beschreibung	Greiferposition abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler position: Positionsprozentsatz, Bereich 0~100%

11.8. Greifergeschwindigkeit abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetGripperCurSpeed()
Beschreibung	Greifergeschwindigkeit abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler speed: Geschwindigkeitsprozentsatz, Bereich 0~100%

11.9. Greiferstrom abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetGripperCurCurrent()
Beschreibung	Greiferstrom abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler current: Stromprozentsatz, Bereich 0~100%

11.10. Greiferspannung abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetGripperVoltage()
Beschreibung	Greiferspannung abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler voltage: Spannung, Einheit 0.1V

11.11. Greifertemperatur abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetGripperTemp()
Beschreibung	Greifertemperatur abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler temp: Temperatur [°C]

11.12. Vor-Greifpunkt berechnen (visuell)

Prototyp	ComputePrePick(desc_pos, zlength, zangle)
Beschreibung	Vor-Greifpunkt berechnen (visuell)
Erforderliche Parameter	desc_pos: Kartesische Pose des Greifpunkts [x, y, z, rx, ry, rz] zlength: Z-Achsen-Versatz [mm] zangle: Rotationsversatz um die Z-Achse [°]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode pre_pos: Berechneter Vor-Greifpunkt [x, y, z, rx, ry, rz]

11.13. Rückzugspunkt berechnen (visuell)

Prototyp	ComputePostPick(desc_pos, zlength, zangle)
Beschreibung	Rückzugspunkt berechnen (visuell)
Erforderliche Parameter	desc_pos: Kartesische Pose des Greifpunkts [x, y, z, rx, ry, rz] zlength: Z-Achsen-Versatz [mm] zangle: Rotationsversatz um die Z-Achse [°]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode post_pos: Berechneter Rückzugspunkt [x, y, z, rx, ry, rz]

11.14. Codebeispiel für Roboter-Greiferoperationen

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen, bei Erfolg wird ein Roboterobjekt zurückgegeben
robot = Robot.RPC('192.168.58.2')
company = 4
device = 0
softversion = 0
bus = 2
index = 2
act = 0
max_time = 30000
block = 0
status = 0
fault = 0
active_status = 0
current_pos = 0
current = 0
voltage = 0
temp = 0
speed = 0
robot.SetGripperConfig(company, device, softversion, bus)
time.sleep(1)
error, [company, device, softversion, bus] = robot.GetGripperConfig()
print(f"gripper config: {company}, {device}, {softversion}, {bus}")
robot.ActGripper(index, act)
time.sleep(1)
act = 1
robot.ActGripper(index, act)
time.sleep(1)
error = robot.MoveGripper(index, 90, 50, 50, max_time, block, 0, 0, 0, 0)
print(f"MoveGripper retval is: {error}")
time.sleep(1)
error = robot.MoveGripper(index, 30, 50, 0, max_time, block, 0, 0, 0, 0)
print(f"MoveGripper retval is: {error}")
error, [fault, status] = robot.GetGripperMotionDone()
print(f"motion status: {fault}, {status}")
error, [fault, active_status] = robot.GetGripperActivateStatus()
print(f"gripper active fault is: {fault}, status is: {active_status}")
error, [fault, current_pos] = robot.GetGripperCurPosition()
print(f"fault is: {fault}, current position is: {current_pos}")
error, [fault, current] = robot.GetGripperCurCurrent()
print(f"fault is: {fault}, current current is: {current}")
error, [fault, voltage] = robot.GetGripperVoltage()
print(f"fault is: {fault}, current voltage is: {voltage}")
error, [fault, temp] = robot.GetGripperTemp()
print(f"fault is: {fault}, current temperature is: {temp}")
error, [fault, speed] = robot.GetGripperCurSpeed()
print(f"fault is: {fault}, current speed is: {speed}")
retval = 0
prepick_pose = [0.0] * 6
postpick_pose = [0.0] * 6
p1Desc = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
p2Desc = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
retval, prepick_pose = robot.ComputePrePick(p1Desc, 10, 0)
print(f"ComputePrePick retval is: {retval}")
print(f"xyz is: {prepick_pose[0]}, {prepick_pose[1]}, {prepick_pose[2]}; rpy is: {prepick_pose[3]}, {prepick_pose[4]}, {prepick_pose[5]}")
retval, postpick_pose = robot.ComputePostPick(p2Desc, -10, 0)
print(f"ComputePostPick retval is: {retval}")
print(f"xyz is: {postpick_pose[0]}, {postpick_pose[1]}, {postpick_pose[2]}; rpy is: {postpick_pose[3]}, {postpick_pose[4]}, {postpick_pose[5]}")
robot.CloseRPC()

11.15. Rotationsanzahl des Rotationsgreifers abrufen

Neu in Version Python: SDK-v2.0.7

Prototyp	GetGripperRotNum()
Beschreibung	Rotationsanzahl des Rotationsgreifers abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler num: Rotationsanzahl (Umdrehungen)

11.16. Rotationsgeschwindigkeitsprozentsatz des Rotationsgreifers abrufen

Neu in Version Python: SDK-v2.0.7

Prototyp	GetGripperRotSpeed()
Beschreibung	Rotationsgeschwindigkeitsprozentsatz des Rotationsgreifers abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler speed: Rotationsgeschwindigkeitsprozentsatz

11.17. Rotationsdrehmomentprozentsatz des Rotationsgreifers abrufen

Neu in Version Python: SDK-v2.0.7

Prototyp	GetGripperRotTorque()
Beschreibung	Rotationsdrehmomentprozentsatz des Rotationsgreifers abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode fault: 0 = kein Fehler, 1 = Fehler torque: Rotationsdrehmomentprozentsatz

11.18. Codebeispiel zum Abrufen des Status eines Rotationsgreifers

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
fault = 0
rotNum = 0.0
rotSpeed = 0
rotTorque = 0
error,fault, rotNum = robot.GetGripperRotNum()
error,fault, rotSpeed = robot.GetGripperRotSpeed()
error,fault, rotTorque = robot.GetGripperRotTorque()
print(f"gripper rot num:{rotNum},gripper rotSpeed:{rotSpeed},gripper rotTorque:{rotTorque}")
robot.CloseRPC()

11.19. Förderband starten/stoppen

Prototyp	ConveyorStartEnd(status)
Beschreibung	Förderband starten/stoppen
Erforderliche Parameter	status: Förderbandstatus, 1 = starten, 0 = stoppen
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.20. IO-Erkennungspunkt aufzeichnen

Prototyp	ConveyorPointIORecord()
Beschreibung	IO-Erkennungspunkt aufzeichnen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.21. Punkt A aufzeichnen

Prototyp	ConveyorPointARecord()
Beschreibung	Punkt A aufzeichnen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.22. Referenzpunkt aufzeichnen

Prototyp	ConveyorRefPointRecord()
Beschreibung	Referenzpunkt aufzeichnen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.23. Punkt B aufzeichnen

Prototyp	ConveyorPointBRecord()
Beschreibung	Punkt B aufzeichnen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.24. Förderband-Werkstück IO-Erkennung

Prototyp	ConveyorIODetect(max_t)
Beschreibung	Förderband-Werkstück IO-Erkennung
Erforderliche Parameter	max_t: Maximale Erkennungszeit [ms]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.25. Aktuelle Objektposition abrufen

Prototyp	ConveyorGetTrackData(mode)
Beschreibung	Aktuelle Objektposition abrufen
Erforderliche Parameter	mode: 1 = Tracking Greifen, 2 = Tracking Bewegung, 3 = TPD Tracking
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.26. Förderband-Tracking starten

Prototyp	ConveyorTrackStart(status)
Beschreibung	Förderband-Tracking starten
Erforderliche Parameter	status: Status, 1 = starten, 0 = stoppen
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.27. Förderband-Tracking stoppen

Prototyp	ConveyorTrackEnd()
Beschreibung	Förderband-Tracking stoppen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.28. Förderbandparameter konfigurieren

Prototyp	ConveyorSetParam(param, followType, startDis, endDis)
Beschreibung	Förderbandparameter konfigurieren
Erforderliche Parameter	param = [encChannel, resolution, lead, wpAxis, vision, speedRadio] encChannel: Encoderkanal 1-2 resolution: Encoderauflösung (Impulse pro Umdrehung) lead: Mechanisches Übersetzungsverhältnis (Vorschub pro Encoderumdrehung) [mm] wpAxis: Werkstückkoordinatennummer (für Tracking-Bewegung, bei Tracking-Greifen/TPD-Tracking auf 0 setzen) vision: Mit Vision gekoppelt? 0 = nein, 1 = ja speedRadio: Geschwindigkeitsverhältnis (für Förderband-Tracking-Greifen Bereich 1-100, für Tracking-Bewegung/TPD-Tracking auf 1 setzen) followType: Tracking-Bewegungstyp, 0 = Tracking-Bewegung, 1 = Nachlauf-Bewegung
Standardparameter	startDis: Für Nachlauf-Greifen erforderlich: Startabstand des Trackings. -1 = automatische Berechnung (Nachlauf startet, wenn Werkstück unter Roboter ist). Einheit mm, Standard = 0 endDis: Für Nachlauf-Greifen erforderlich: Endabstand des Trackings. Einheit mm, Standard = 100
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.29. Förderband-Greifpunktkompensation

Prototyp	ConveyorCatchPointComp(cmp)
Beschreibung	Förderband-Greifpunktkompensation
Erforderliche Parameter	cmp: Kompensationsposition [x, y, z] [mm]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.30. Linearbewegung

Prototyp	ConveyorTrackMoveL(name, tool, wobj, vel=20, acc=100, ovl=100, blendR=-1.0)
Beschreibung	Linearbewegung
Erforderliche Parameter	name: Name des Bewegungspunkts (‚cvrCatchPoint‘ oder ‚cvrRaisePoint‘) tool: Werkzeugnummer wobj: Werkstücknummer
Standardparameter	vel: Geschwindigkeit [%], Standard = 20 acc: Beschleunigung [%], Standard = 100 ovl: Geschwindigkeitsskalierungsfaktor [%], Standard = 100 blendR: [-1.0] = Bewegung abschließen (blockierend), [0~1000] = Glättungsradius (nicht blockierend) [mm], Standard = -1.0
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.31. Förderband-Kommunikationseingangserkennung

Neu in Version Python: SDK-v2.1.1

Prototyp	ConveyorComDetect(timeout)
Beschreibung	Förderband-Kommunikationseingangserkennung
Erforderliche Parameter	timeout: Warte-Timeout [ms]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.32. Förderband-Kommunikationseingangserkennung auslösen

Neu in Version Python: SDK-v2.1.1

Prototyp	ConveyorComDetectTrigger()
Beschreibung	Förderband-Kommunikationseingangserkennung auslösen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.33. Codebeispiel für Roboter-Förderbandoperationen

from fairino import Robot
import time
import threading
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
retval = robot.ConveyorStartEnd(1)
print(f"ConveyorStartEnd retval is: {retval}")
retval = robot.ConveyorPointIORecord()
print(f"ConveyorPointIORecord retval is: {retval}")
retval = robot.ConveyorPointARecord()
print(f"ConveyorPointARecord retval is: {retval}")
retval = robot.ConveyorRefPointRecord()
print(f"ConveyorRefPointRecord retval is: {retval}")
retval = robot.ConveyorPointBRecord()
print(f"ConveyorPointBRecord retval is: {retval}")
retval = robot.ConveyorStartEnd(0)
print(f"ConveyorStartEnd retval is: {retval}")
param = [1.0, 10000.0, 200.0, 0.0, 0.0, 20.0]
retval = robot.ConveyorSetParam(param, 0)
print(f"ConveyorSetParam retval is: {retval}")
cmp = [0.0, 0.0, 0.0]
retval = robot.ConveyorCatchPointComp(cmp)
print(f"ConveyorCatchPointComp retval is: {retval}")
index = 1
max_time = 30000
block = 0
retval = 0
p1Desc = [-419.524, -13.000, 351.569, -178.118, 0.314, 3.833]
p2Desc = [-321.222, 185.189, 335.520, -179.030, -1.284, -29.869]
retval = robot.MoveCart(p1Desc, 1, 0, 100.0)
print(f"MoveCart retval is: {retval}")
retval = robot.WaitMs(1)
print(f"WaitMs retval is: {retval}")
retval = robot.ConveyorIODetect(10000)
print(f"ConveyorIODetect retval is: {retval}")
retval = robot.ConveyorGetTrackData(1)
print(f"ConveyorGetTrackData retval is: {retval}")
retval = robot.ConveyorTrackStart(1)
print(f"ConveyorTrackStart retval is: {retval}")
retval = robot.ConveyorTrackMoveL("cvrCatchPoint", 1, 0, 100)
print(f"TrackMoveL retval is: {retval}")
retval = robot.MoveGripper(index, 51, 40, 30, max_time, block, 0, 0, 0, 0)
print(f"MoveGripper retval is: {retval}")
retval = robot.ConveyorTrackMoveL("cvrRaisePoint", 1, 0, 100)
print(f"TrackMoveL retval is: {retval}")
retval = robot.ConveyorTrackEnd()
print(f"ConveyorTrackEnd retval is: {retval}")
robot.MoveCart(p2Desc, 1, 0, 100.0, 100.0)
retval = robot.MoveGripper(index, 100, 40, 10, max_time, block, 0, 0, 0, 0)
print(f"MoveGripper retval is: {retval}")
robot.CloseRPC()

11.34. Endeffektor-Sensor konfigurieren

Neu in Version Python: SDK-v2.0.5

Prototyp	AxleSensorConfig(idCompany, idDevice, idSoftware, idBus)
Beschreibung	Endeffektor-Sensor konfigurieren
Erforderliche Parameter	idCompany: Hersteller, 18 = JUNKONG, 25 = HUIDE idDevice: Typ, 0 = JUNKONG/RYR6T.V1.0 idSoftware: Softwareversion, 0 = J1.0/HuiDe1.0 (vorübergehend nicht freigegeben) idBus: Anschlussposition, 1 = Endeffektor Port 1, 2 = Port 2, … 8 = Port 8 (vorübergehend nicht freigegeben)
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.35. Endeffektor-Sensorkonfiguration abrufen

Neu in Version Python: SDK-v2.0.5

Prototyp	AxleSensorConfigGet()
Beschreibung	Endeffektor-Sensorkonfiguration abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode idCompany: Hersteller, 18 = JUNKONG, 25 = HUIDE idDevice: Typ, 0 = JUNKONG/RYR6T.V1.0

11.36. Endeffektor-Sensor aktivieren

Neu in Version Python: SDK-v2.0.5

Prototyp	AxleSensorActivate(actFlag)
Beschreibung	Endeffektor-Sensor aktivieren
Erforderliche Parameter	actFlag: 0 = Zurücksetzen, 1 = Aktivieren
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode coord: Koordinatenwerte [x, y, z, rx, ry, rz] (Bedeutung unklar)

11.37. In Endeffektor-Sensorregister schreiben

Neu in Version Python: SDK-v2.0.5

Prototyp	AxleSensorRegWrite(devAddr, regHAddr, regLAddr, regNum, data1, data2, isNoBlock)
Beschreibung	In Endeffektor-Sensorregister schreiben
Erforderliche Parameter	devAddr: Geräteadresse 0-255 regHAddr: Registeradresse hohes Byte regLAddr: Registeradresse niedriges Byte regNum: Anzahl der Register 0-255 data1: Zu schreibender Registerwert 1 data2: Zu schreibender Registerwert 2 isNoBlock: Blockierungs-Flag, 0 = blockierend, 1 = nicht blockierend
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.38. Codebeispiel für Endeffektor-Sensor

from fairino import Robot
import time
import threading
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
robot.AxleSensorConfig(18, 0, 0, 1)
error, company, type = robot.AxleSensorConfigGet()
print(f"company is: {company}, type is: {type}")
rtn = robot.AxleSensorActivate(1)
print(f"AxleSensorActivate rtn is: {rtn}")
time.sleep(1)
rtn = robot.AxleSensorRegWrite(1, 4, 6, 1, 0, 0, 0)
print(f"AxleSensorRegWrite rtn is: {rtn}")
robot.CloseRPC()

11.39. Roboter-Peripherieprotokoll abrufen

Neu in Version Python: SDK-v2.0.3

Prototyp	GetExDevProtocol()
Beschreibung	Roboter-Peripherieprotokoll abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode protocol: Peripherieprotokollnummer: 4096 = Erweiterungsachsen-Steuerkarte, 4097 = ModbusSlave, 4098 = ModbusMaster

11.40. Roboter-Peripherieprotokoll einstellen

Neu in Version Python: SDK-v2.0.3

Prototyp	SetExDevProtocol(protocol)
Beschreibung	Roboter-Peripherieprotokoll einstellen
Erforderliche Parameter	protocol: Peripherieprotokollnummer: 4096 = Erweiterungsachsen-Steuerkarte, 4097 = ModbusSlave, 4098 = ModbusMaster
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.41. Codebeispiel zum Einstellen des Roboter-Peripherieprotokolls

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
protocol = 4096
rtn = robot.SetExDevProtocol(protocol)
print(f"SetExDevProtocol rtn: {rtn}")
rtn, protocol = robot.GetExDevProtocol()
print(f"GetExDevProtocol rtn: {rtn}, protocol is: {protocol}")
robot.CloseRPC()

11.42. Endeffektor-Kommunikationsparameter abrufen

Neu in Version Python: SDK-v2.0.5

Prototyp	GetAxleCommunicationParam()
Beschreibung	Endeffektor-Kommunikationsparameter abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode baudRate: Baudrate: 1=9600, 2=14400, 3=19200, 4=38400, 5=56000, 6=67600, 7=115200, 8=128000 dataBit: Datenbits: unterstützt 8, 9; üblich 8 stopBit: Stoppbits: 1=1, 2=0.5, 3=2, 4=1.5; üblich 1 verify: Parität: 0=None, 1=Odd, 2=Even; üblich 0 timeout: Timeout: 1~1000 ms timeoutTimes: Anzahl Timeout-Wiederholungen: 1~10 period: Zykluszeit für periodische Befehle: 1~1000 ms

11.43. Endeffektor-Kommunikationsparameter einstellen

Neu in Version Python: SDK-v2.0.5

Prototyp	SetAxleCommunicationParam(baudRate, dataBit, stopBit, verify, timeout, timeoutTimes, period)
Beschreibung	Endeffektor-Kommunikationsparameter einstellen
Erforderliche Parameter	baudRate: Baudrate: 1=9600, 2=14400, 3=19200, 4=38400, 5=56000, 6=67600, 7=115200, 8=128000 dataBit: Datenbits: unterstützt 8, 9; üblich 8 stopBit: Stoppbits: 1=1, 2=0.5, 3=2, 4=1.5; üblich 1 verify: Parität: 0=None, 1=Odd, 2=Even; üblich 0 timeout: Timeout: 1~1000 ms timeoutTimes: Anzahl Timeout-Wiederholungen: 1~10 period: Zykluszeit für periodische Befehle: 1~1000 ms
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.44. Endeffektor-Dateiübertragungstyp einstellen

Neu in Version Python: SDK-v2.0.5

Prototyp	SetAxleFileType(type)
Beschreibung	Endeffektor-Dateiübertragungstyp einstellen
Erforderliche Parameter	type: 1 = MCU Upgrade-Datei, 2 = LUA-Datei
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.45. Endeffektor-LUA-Ausführung aktivieren

Neu in Version Python: SDK-v2.0.5

Prototyp	SetAxleLuaEnable(enable)
Beschreibung	Endeffektor-LUA-Ausführung aktivieren
Erforderliche Parameter	enable: 0 = nicht aktivieren, 1 = aktivieren
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.46. Fehlerbehebung bei anomaler Endeffektor-LUA-Datei

Neu in Version Python: SDK-v2.0.5

Prototyp	SetRecoverAxleLuaErr(enable)
Beschreibung	Fehlerbehebung bei anomaler Endeffektor-LUA-Datei
Erforderliche Parameter	status: 0 = nicht beheben, 1 = beheben
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.47. Aktivierungsstatus der Endeffektor-LUA-Ausführung abrufen

Neu in Version Python: SDK-v2.0.5

Prototyp	GetAxleLuaEnableStatus()
Beschreibung	Aktivierungsstatus der Endeffektor-LUA-Ausführung abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode enable: 0 = nicht aktiviert, 1 = aktiviert

11.48. Aktivierungstyp der Endeffektor-LUA-Endgeräte einstellen

Neu in Version Python: SDK-v2.0.5

Prototyp	SetAxleLuaEnableDeviceType(forceSensorEnable, gripperEnable, IOEnable)
Beschreibung	Aktivierungstyp der Endeffektor-LUA-Endgeräte einstellen
Erforderliche Parameter	forceSensorEnable: Kraftsensor aktivieren, 0 = nein, 1 = ja gripperEnable: Greifer aktivieren, 0 = nein, 1 = ja IOEnable: IO-Geräte aktivieren, 0 = nein, 1 = ja
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.49. Aktivierungstyp der Endeffektor-LUA-Endgeräte abrufen

Neu in Version Python: SDK-v2.0.5

Prototyp	GetAxleLuaEnableDeviceType()
Beschreibung	Aktivierungstyp der Endeffektor-LUA-Endgeräte abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode forceSensorEnable: Kraftsensor aktiviert? 0 = nein, 1 = ja gripperEnable: Greifer aktiviert? 0 = nein, 1 = ja IOEnable: IO-Geräte aktiviert? 0 = nein, 1 = ja

11.50. Aktuell konfigurierte Endgeräte abrufen

Neu in Version Python: SDK-v2.0.5

Prototyp	GetAxleLuaEnableDevice()
Beschreibung	Aktuell konfigurierte Endgeräte (über LUA) abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode forceSensorEnable[8]: Aktivierte Kraftsensoren (Indikator pro Kanal) gripperEnable[8]: Aktivierte Greifer (Indikator pro Kanal) IOEnable[8]: Aktivierte IO-Geräte (Indikator pro Kanal)

11.51. Greifer-Aktionssteuerungsfunktion aktivieren (für LUA)

Neu in Version Python: SDK-v2.0.5

Prototyp	SetAxleLuaGripperFunc(id, func)
Beschreibung	Greifer-Aktionssteuerungsfunktion aktivieren (für LUA-Skript)
Erforderliche Parameter	id: Greifer-Gerätenummer func: Funktions-Array (16 Elemente): Index 0 = Greifer aktivieren, 1 = Greifer initialisieren, 2 = Position setzen, 3 = Geschwindigkeit setzen, 4 = Drehmoment setzen, 6 = Greiferstatus lesen, 7 = Initialisierungsstatus lesen, 8 = Fehlercode lesen, 9 = Position lesen, 10 = Geschwindigkeit lesen, 11 = Drehmoment lesen, 12-15 reserviert. Werte 0/1 geben an, ob die Funktion aktiviert ist.
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.52. Aktivierte Greifer-Aktionssteuerungsfunktion abrufen

Neu in Version Python: SDK-v2.0.5

Prototyp	GetAxleLuaGripperFunc(id)
Beschreibung	Aktivierte Greifer-Aktionssteuerungsfunktion abrufen
Erforderliche Parameter	id: Greifer-Gerätenummer
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode func: Funktions-Array (16 Elemente, siehe SetAxleLuaGripperFunc)

11.53. In Ethercat-Slave-Datei des Roboters schreiben

Neu in Version Python: SDK-v2.0.5

Prototyp	SlaveFileWrite(type, slaveID, fileName)
Beschreibung	In Ethercat-Slave-Datei des Roboters schreiben (Firmware/Konfiguration updaten)
Erforderliche Parameter	type: Slave-Dateityp, 1 = Upgrade Slave-Datei, 2 = Upgrade Slave-Konfigurationsdatei slaveID: Slave-Nummer fileName: Name der hochzuladenden Datei (auf dem Roboter?)
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.54. Endeffektor-Lua-Open-Protocol-Datei hochladen

Neu in Version Python: SDK-v2.0.5

Prototyp	AxleLuaUpload(filePath)
Beschreibung	Endeffektor-Lua-Open-Protocol-Datei hochladen
Erforderliche Parameter	filePath: Lokaler Pfad zur Lua-Datei (z.B. …/AXLE_LUA_End_DaHuan.lua)
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.55. Ethercat-Slave des Roboters in den Boot-Modus versetzen

Neu in Version Python: SDK-v2.0.5

Prototyp	SetSysServoBootMode()
Beschreibung	Ethercat-Slave des Roboters in den Boot-Modus versetzen (für Firmware-Update)
Erforderliche Parameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.56. Codebeispiel für Roboter-Endeffektor-LUA-Dateioperationen

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
robot.AxleLuaUpload("D://zUP/AXLE_LUA_End_DaHuan.lua")
param = [7, 8, 1, 0, 5, 3, 1]  # AxleComParam
robot.SetAxleCommunicationParam(7, 8, 1, 0, 5, 3, 1)
error,getParam0,getParam1,getParam2,getParam3,getParam4,getParam5,getParam6 = robot.GetAxleCommunicationParam()
print(f"GetAxleCommunicationParam param is:{getParam0} {getParam1} {getParam2} {getParam3} {getParam4} {getParam5} {getParam6}")
robot.SetAxleLuaEnable(1)
error,luaEnableStatus = robot.GetAxleLuaEnableStatus()
robot.SetAxleLuaEnableDeviceType(0, 1, 0)
error, forceEnable, gripperEnable, ioEnable = robot.GetAxleLuaEnableDeviceType()
print(f"GetAxleLuaEnableDeviceType param is: {forceEnable} {gripperEnable} {ioEnable}")
func = [1] * 16  # Alle Funktionen aktivieren
robot.SetAxleLuaGripperFunc(1, func)
error,getFunc = robot.GetAxleLuaGripperFunc(1)
error,getforceEnable, getgripperEnable, getioEnable = robot.GetAxleLuaEnableDevice()
print("\ngetforceEnable status:", end=" ")
for i in range(8):
    print(f"{getforceEnable[i]},", end="")
print("\ngetgripperEnable status:", end=" ")
for i in range(8):
    print(f"{getgripperEnable[i]},", end="")
print("\ngetioEnable status:", end=" ")
for i in range(8):
    print(f"{getioEnable[i]},", end="")
print()
robot.ActGripper(1, 0)
time.sleep(2)
robot.ActGripper(1, 1)
time.sleep(2)
robot.MoveGripper(1, 90, 10, 100, 50000, 0, 0, 0, 0, 0)
while True:
    error,pkg = robot.GetRobotRealTimeState()
    print(f"gripper pos is:{pkg.gripper_position}")
    time.sleep(0.1)
robot.CloseRPC()

11.57. SmartTool-Tastenstatus abrufen

Neu in Version Python: SDK-v2.1.2

Prototyp	GetSmarttoolBtnState()
Beschreibung	SmartTool-Tastenstatus abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode state: SmartTool-Griff Tastenstatus (Bit0: 0 = Kommunikation normal, 1 = Kommunikation unterbrochen; Bit1 = Rückgängig; Bit2 = Programm löschen; Bit3 = Taste A; Bit4 = Taste B; Bit5 = Taste C; Bit6 = Taste D; Bit7 = Taste E; Bit8 = IO-Taste; Bit9 = Hand/Automatik; Bit10 = Start)

11.58. Codebeispiel für SmartTool-Tasten

from fairino import Robot
import time
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
while True:
    error,state = robot.GetSmarttoolBtnState()
    print(f"{state:016b}")
    time.sleep(0.1)

11.59. Krafterkennung vor dem Führen einstellen

Neu in Version Python: SDK-v2.1.6

Prototyp	SetTorqueDetectionSwitch(flag)
Beschreibung	Krafterkennung vor dem Führen einstellen (Lastprüfung)
Erforderliche Parameter	flag: 0 = aus, 1 = an
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.60. Laser-Peripherie Ein-/Ausschalten

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserTrackingLaserOnOff(OnOff, weldId)
Beschreibung	Laser-Peripherie Ein-/Ausschalten
Erforderliche Parameter	OnOff: 0 = aus, 1 = ein
Standardparameter	weldId: Schweißnaht-ID, Standard = 0
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.61. Laser-Tracking Start/Stopp

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserTrackingTrackOnOff(OnOff, coordId)
Beschreibung	Laser-Tracking Start/Stopp
Erforderliche Parameter	OnOff: 0 = stopp, 1 = start coordId: Werkzeugkoordinatennummer des Laser-Peripheriegeräts
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.62. Lasernahtsuche starten - feste Richtung

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserTrackingSearchStart_xyz(direction, vel, distance, timeout, posSensorNum)
Beschreibung	Lasernahtsuche starten - feste Richtung
Erforderliche Parameter	direction: 0 = x+, 1 = x-, 2 = y+, 3 = y-, 4 = z+, 5 = z- vel: Geschwindigkeit [%] distance: Maximale Suchdistanz [mm] timeout: Such-Timeout [ms] posSensorNum: Nummer des kalibrierten Laser-Werkzeugkoordinatensystems
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.63. Lasernahtsuche starten - Richtung durch Punkt vorgegeben

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserTrackingSearchStart_point(directionPoint, vel, distance, timeout, posSensorNum)
Beschreibung	Lasernahtsuche starten - Richtung durch Punkt vorgegeben
Erforderliche Parameter	directionPoint: XYZ-Koordinaten des Richtungspunkts [x, y, z] (relativ) vel: Geschwindigkeit [%] distance: Maximale Suchdistanz [mm] timeout: Such-Timeout [ms] posSensorNum: Nummer des kalibrierten Laser-Werkzeugkoordinatensystems
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.64. Laser-IP-Konfiguration

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserTrackingSensorConfig(ip, port)
Beschreibung	Laser-IP-Konfiguration
Erforderliche Parameter	ip: IP-Adresse des Laser-Peripheriegeräts port: Portnummer des Laser-Peripheriegeräts
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.65. Laser-Peripherie-Abtastperiode konfigurieren

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserTrackingSensorSamplePeriod(period)
Beschreibung	Laser-Peripherie-Abtastperiode konfigurieren
Erforderliche Parameter	period: Abtastperiode [ms]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.66. Laser-Peripherie-Treiber laden

Neu in Version Python: SDK-v2.1.6

Prototyp	LoadPosSensorDriver(type)
Beschreibung	Laser-Peripherie-Treiber laden
Erforderliche Parameter	type: Protokolltyp des Laser-Peripherietreibers: 101 = RuiNiu, 102 = ChuangXiang, 103 = QuanShi, 104 = TongZhou, 105 = AoTai
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.67. Laser-Peripherie-Treiber entladen

Neu in Version Python: SDK-v2.1.6

Prototyp	UnLoadPosSensorDriver()
Beschreibung	Laser-Peripherie-Treiber entladen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.68. Laser-Schweißnaht-Trajektorie aufzeichnen

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserSensorRecord1(status, delayTime)
Beschreibung	Laser-Schweißnaht-Trajektorie aufzeichnen
Erforderliche Parameter	status: 0 = Aufzeichnung stoppen, 1 = Echtzeit-Tracking, 2 = Aufzeichnung starten delayTime: Verzögerungszeit [ms]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.69. Laser-Schweißnaht-Trajektorie wiedergeben

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserSensorReplay(delayTime, speed)
Beschreibung	Laser-Schweißnaht-Trajektorie wiedergeben
Erforderliche Parameter	delayTime: Verzögerungszeit [ms] speed: Geschwindigkeit [%]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.70. Laser-Tracking-Wiedergabe (MoveLTR)

Neu in Version Python: SDK-v2.1.6

Prototyp	MoveLTR()
Beschreibung	Laser-Tracking-Wiedergabe (Bewegung entlang der aufgezeichneten Trajektorie)
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.71. Laser-Schweißnaht-Trajektorie aufzeichnen und wiedergeben (erweitert)

Neu in Version Python: SDK-v2.1.6

Prototyp	LaserSensorRecordandReplay(delayMode, delayTime, delayDisExAxisNum, delayDis, sensitivePara, trackMode, triggerMode, runTime, speed)
Beschreibung	Laser-Schweißnaht-Trajektorie aufzeichnen und wiedergeben (erweiterte Funktion)
Erforderliche Parameter	delayMode: Modus, 0 = Verzögerungszeit, 1 = Verzögerungsdistanz delayTime: Verzögerungszeit [ms] (wenn delayMode=0) delayDisExAxisNum: Erweiterungsachsennummer für Distanzverzögerung delayDis: Verzögerungsdistanz [mm] (wenn delayMode=1) sensitivePara: Kompensations-Empfindlichkeitskoeffizient trackMode: Punkt-Tracking-Typ: 0 = Erweiterungsachse asynchron, 1 = Roboter (synchron?) triggerMode: Punkt-Tracking-Auslösemodus: 0 = Tracking-Dauer, 1 = IO runTime: Dauer des Roboter-Punkt-Trackings [s] speed: Geschwindigkeit [%]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.72. Zum aufgezeichneten Startpunkt der Schweißnaht bewegen

Neu in Version Python: SDK-v2.1.6

Prototyp	MoveToLaserRecordStart(moveType, ovl)
Beschreibung	Zum aufgezeichneten Startpunkt der Schweißnaht bewegen
Erforderliche Parameter	moveType: 0 = PTP, 1 = LIN ovl: Geschwindigkeit [%]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.73. Zum aufgezeichneten Endpunkt der Schweißnaht bewegen

Neu in Version Python: SDK-v2.1.6

Prototyp	MoveToLaserRecordEnd(moveType, ovl)
Beschreibung	Zum aufgezeichneten Endpunkt der Schweißnaht bewegen
Erforderliche Parameter	moveType: 0 = PTP, 1 = LIN ovl: Geschwindigkeit [%]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.74. Zum vom Laser-Sensor gefundenen Nahtpunkt bewegen

Neu in Version Python: SDK-v2.1.6

Prototyp	MoveToLaserSeamPos(moveFlag, ovl, dataFlag, plateType, trackOffectType, offset)
Beschreibung	Zum vom Laser-Sensor gefundenen Nahtpunkt bewegen
Erforderliche Parameter	moveFlag: Bewegungstyp, 0 = PTP, 1 = LIN ovl: Geschwindigkeitsskalierungsfaktor [0-100] dataFlag: Auswahl der Schweißnaht-Cache-Daten: 0 = Planungsdaten ausführen, 1 = Aufgezeichnete Daten ausführen plateType: Plattenmaterial-Typ: 0 = Wellenplatte, 1 = Wellpappe, 2 = Zaunplatte, 3 = Ölfass, 4 = Wellenpanzerstahl trackOffectType: Laser-Sensor-Versatztyp: 0 = kein Versatz, 1 = Versatz im Basiskoordinatensystem, 2 = Versatz im Werkzeugkoordinatensystem, 3 = Versatz basierend auf Laser-Sensor-Rohdaten offset: Versatzwert [x, y, z, rx, ry, rz]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode

11.75. Koordinaten des vom Laser-Sensor gefundenen Nahtpunkts abrufen

Neu in Version Python: SDK-v2.1.6

Prototyp	GetLaserSeamPos(trackOffectType, offset)
Beschreibung	Koordinaten des vom Laser-Sensor gefundenen Nahtpunkts abrufen
Erforderliche Parameter	trackOffectType: Laser-Sensor-Versatztyp (siehe MoveToLaserSeamPos) offset: Versatzwert [x, y, z, rx, ry, rz]
Standardparameter	Keine
Rückgabewert	Fehlercode: 0 = Erfolg, sonst Fehlercode jPos: Gelenkposition [°] (Liste von 6 Werten) descPos: Kartesische Position [mm, °] (Liste von 6 Werten) tool: Verwendetes Werkzeugkoordinatensystem user: Verwendetes Werkstückkoordinatensystem exaxis: Position der Erweiterungsachse [mm] (Liste von 4 Werten)

11.76. Codebeispiel für Laser-Peripherie-Sensorparametrierung und -Debugging

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
robot.LaserTrackingSensorConfig("192.168.58.20", 5020)
robot.LaserTrackingSensorSamplePeriod(20)
robot.LoadPosSensorDriver(101)
robot.LaserTrackingLaserOnOff(0, 0)
time.sleep(3)
robot.LaserTrackingLaserOnOff(1, 0)
robot.CloseRPC()

11.77. Codebeispiel für Laser-Trajektorienscan und -wiedergabe

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
robot.OpenLuaUpload("D://zUP/CtrlDev_laser_ruiniu-0117.lua")
time.sleep(2)
robot.SetCtrlOpenLUAName(0, "CtrlDev_laser_ruiniu-0117.lua")
robot.UnloadCtrlOpenLUA(0)
robot.LoadCtrlOpenLUA(0)
time.sleep(8)
i = 0
while i<10:
    startjointPos = [56.205, -117.951, 141.872, -118.149, -94.217, -122.176]
    startdescPose = [-97.552, -282.855, 26.675, 174.182, -1.338, -91.707]
    exaxisPos = [0.0] * 4
    offdese = [0.0] * 6
    robot.MoveL(desc_pos=startdescPose,tool= 1,user= 0,vel= 100,acc= 100,ovl= 100,blendR= -1,exaxis_pos= exaxisPos,search= 0,offset_flag= 0, offset_pos= offdese,overSpeedStrategy= 1,speedPercent= 1)
    robot.LaserSensorRecord1(2, 10)
    endjointPos = [68.809, -87.100, 121.120, -127.233, -95.038, -109.555]
    enddescPose = [-103.555, -464.234, 13.076, 174.179, -1.344, -91.709]
    robot.MoveL(desc_pos=enddescPose,tool= 1,user= 0,vel= 50,acc= 100,ovl= 100,blendR= -1,exaxis_pos= exaxisPos,search= 0,offset_flag= 0, offset_pos= offdese,overSpeedStrategy= 1,speedPercent= 1)
    robot.LaserSensorRecord1(0, 10)
    robot.MoveToLaserRecordStart(1, 30)
    robot.LaserSensorReplay(10, 100)
    robot.MoveLTR()
    robot.LaserSensorRecord1(0, 10)
    i = i+1
robot.CloseRPC()

11.78. Codebeispiel für Lasernahtsuche und Echtzeit-Tracking

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
robot.OpenLuaUpload("D://zUP/CtrlDev_laser_ruiniu-0117.lua")
time.sleep(2)
robot.SetCtrlOpenLUAName(0, "CtrlDev_laser_ruiniu-0117.lua")
robot.UnloadCtrlOpenLUA(0)
robot.LoadCtrlOpenLUA(0)
time.sleep(8)
time.sleep(8)
i = 0
while i < 10:
    startjointPos = [56.205, -117.951, 141.872, -118.149, -94.217, -122.176]
    startdescPose = [-97.552, -282.855, 26.675, 174.182, -1.338, -91.707]
    exaxisPos = [0.0] * 4
    offdese = [0.0] * 6
    directionPoint = [0.0] * 3
    robot.MoveL(desc_pos=startdescPose,tool= 1,user= 0,vel= 100,acc= 100,ovl= 100,blendR= -1,exaxis_pos= exaxisPos,search= 0,offset_flag= 0, offset_pos= offdese,overSpeedStrategy= 1,speedPercent= 1)
    robot.LaserTrackingSearchStart_xyz(3, 100, 300, 1000, 3)
    robot.LaserTrackingSearchStop()
    robot.MoveToLaserSeamPos(1, 30, 0, 0, 0, offdese)
    robot.LaserTrackingTrackOnOff(1, 3)
    endjointPos = [68.809, -87.100, 121.120, -127.233, -95.038, -109.555]
    enddescPose = [-103.555, -464.234, 13.076, 174.179, -1.344, -91.709]
    robot.MoveL(desc_pos=enddescPose, tool=1, user=0, vel=20, acc=100, ovl=100, blendR=-1, exaxis_pos=exaxisPos, search=0, offset_flag=0, offset_pos=offdese, overSpeedStrategy=1, speedPercent=1)
    robot.LaserTrackingTrackOnOff(0, 3)  # Tracking stoppen
    print(f"Durchlauf {i+1} abgeschlossen")
robot.CloseRPC()

11.79. Codebeispiel für synchrones Laser-Tracking mit Erweiterungsachse und Roboter

from fairino import Robot
# Verbindung zur Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')
startexaxisPos = [0.0, 0.0, 0.0, 0.0]
seamexaxisPos = [-10.0, 0.0, 0.0, 0.0]
endexaxisPos = [-30.0, 0.0, 0.0, 0.0]
offdese = [0.0] * 6
seamjointPos = [0.0] * 6
seamdescPose = [0.0] * 6
i=0
while i < 10:
    startjointPos = [58.337, -119.628, 146.037, -116.358, -92.224, -117.654]
    startdescPose = [-53.375, -255.363, 0.919, 178.054, 1.077, -94.026]
    robot.ExtAxisSyncMoveJ(joint_pos=startjointPos, tool=1,user= 0,vel= 100,acc= 100, ovl=100,exaxis_pos= startexaxisPos,blendT= -1,offset_flag= 0,offset_pos= offdese)
    ret = robot.LaserTrackingSearchStart_xyz(3, 100, 300, 1000, 2)
    robot.LaserTrackingSearchStop()
    tool = 0
    user = 0
    rnte, seamjointPos, seamdescPose, tool, user, startexaxisPos = robot.GetLaserSeamPos(0, offdese)
    print(f"{seamjointPos[0]},{seamjointPos[1]},{seamjointPos[2]},{seamjointPos[3]},{seamjointPos[4]},{seamjointPos[5]},{seamdescPose[0]},{seamdescPose[1]},{seamdescPose[2]},{seamdescPose[3]},{seamdescPose[4]},{seamdescPose[5]}")
    if ret == 0:
        robot.ExtAxisSyncMoveJ(joint_pos=seamjointPos, tool=1,user= 0,vel= 100,acc= 100, ovl=100,exaxis_pos= seamexaxisPos,blendT= -1,offset_flag= 0,offset_pos= offdese)
        robot.LaserTrackingTrackOnOff(1, 2)
        endjointPos = [70.580, -90.918, 126.593, -125.154, -92.162, -105.403]
        enddescPose = [-53.375, -419.020, 0.920, 178.054, 1.076, -94.026]
        robot.ExtAxisSyncMoveL(desc_pos=enddescPose, tool=1,user= 0,vel= 20,acc= 100, ovl=100,blendR= -1,exaxis_pos= endexaxisPos,offset_pos= offdese)
        robot.LaserTrackingTrackOnOff(0, 2)
    i = i+1
    print(i)
robot.CloseRPC()

11.80. Array-Saugnapf steuern

Neu in Version python: SDK-v2.1.5

Prototyp	SetSuckerCtrl(slaveID, len, ctrlValue)
Beschreibung	Array-Saugnapf steuern
Erforderliche Parameter	slaveID: Slave-Stationsnummer len: Länge ctrlValue: Steuerwert 1-Saugen mit maximalem Vakuum 2-Saugen mit eingestelltem Vakuum 3-Saugen stoppen
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.81. Array-Saugnapf-Status abrufen

Neu in Version python: SDK-v2.1.5

Prototyp	GetSuckerState(slaveID)
Beschreibung	Array-Saugnapf-Status abrufen
Erforderliche Parameter	slaveID: Slave-Stationsnummer
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode state: Saugstatus 0-Objekt freigegeben 1-Werkstück erfolgreich angesaugt 2-Kein Objekt angesaugt 3-Objekt abgelöst pressValue: Aktueller Vakuumdruck Einheit kPa error: Aktueller Fehlercode des Saugnapfs

11.82. Auf Saugnapf-Status warten

Neu in Version python: SDK-v2.1.5

Prototyp	WaitSuckerState(slaveID, state, ms)
Beschreibung	Auf Saugnapf-Status warten
Erforderliche Parameter	slaveID: Slave-Stationsnummer state: Saugstatus 0-Objekt freigegeben 1-Werkstück erfolgreich angesaugt 2-Kein Objekt angesaugt 3-Objekt abgelöst ms: Maximale Wartezeit
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.83. Codebeispiel für Array-Saugnapf-Steuerbefehle

Neu in Version python: SDK-v2.1.5

from fairino import Robot
# Verbindung mit der Robotersteuerung herstellen, bei Erfolg wird ein Roboter-Objekt zurückgegeben
robot = Robot.RPC('192.168.58.2')
robot.OpenLuaUpload("C://Projekt/PeripherieSDK/CtrlDev_sucker.lua")
time.sleep(2)
robot.UnloadCtrlOpenLUA(1)
robot.LoadCtrlOpenLUA(1)
time.sleep(1)
ctrl = bytearray(20)
ctrl[0] = 1
robot.SetSuckerCtrl(0, 1, ctrl)
for i in range(100):
    rtn, state, press_value, error = robot.GetSuckerState(1)
    print(f"sucker1 state is {state}, pressValue is {press_value}, error num is {error}")
    rtn, state, press_value, error = robot.GetSuckerState(12)
    print(f"sucker12 state is {state}, pressValue is {press_value}, error num is {error}")
    time.sleep(0.1)
ret = robot.WaitSuckerState(1, 1, 100)
print(f"WaitSuckerState result is {ret}")
ctrl[0] = 3
robot.SetSuckerCtrl(1, 1, ctrl)
robot.SetSuckerCtrl(12, 1, ctrl)
robot.CloseRPC()

11.84. Open-Protocol-Lua-Datei hochladen

Neu in Version python: SDK-v2.1.5

Prototyp	OpenLuaUpload(filePath)
Beschreibung	Open-Protocol-Lua-Datei hochladen
Erforderliche Parameter	filePath: Lokaler Pfad der Open-Protocol-Lua-Datei
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.85. Slave-Stationskartenparameter abrufen

Neu in Version python: SDK-v2.1.5

Prototyp	GetFieldBusConfig()
Beschreibung	Slave-Stationskartenparameter abrufen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode type: 0-Ethercat, 1-CClink, 3-Ethercat, 4-EIP version: Protokollversion connState: 0-Nicht verbunden 1-Verbunden

11.86. Slave-Station DO schreiben

Neu in Version python: SDK-v2.1.5

Prototyp	FieldBusSlaveWriteDO(DOIndex, writeNum, status)
Beschreibung	Slave-Station DO schreiben
Erforderliche Parameter	DOIndex: DO-Nummer writeNum: Anzahl zu schreibender Werte status: Zu schreibende Werte, maximal 8
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.87. Slave-Station AO schreiben

Neu in Version python: SDK-v2.1.5

Prototyp	FieldBusSlaveWriteAO(AOIndex, writeNum, status)
Beschreibung	Slave-Station AO schreiben
Erforderliche Parameter	AOIndex: AO-Nummer writeNum: Anzahl zu schreibender Werte status: Zu schreibende Werte, maximal 8
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.88. Slave-Station DI lesen

Neu in Version python: SDK-v2.1.5

Prototyp	FieldBusSlaveReadDI(DIIndex, readNum)
Beschreibung	Slave-Station DI lesen
Erforderliche Parameter	DIIndex: DI-Nummer readNum: Anzahl zu lesender Werte
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode status[8]: Gelesene Werte, maximal 8

11.89. Slave-Station AI lesen

Neu in Version python: SDK-v2.1.5

Prototyp	FieldBusSlaveReadAI(AIIndex, readNum)
Beschreibung	Slave-Station AI lesen
Erforderliche Parameter	AIIndex: AI-Nummer readNum: Anzahl zu lesender Werte
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode status[8]: Gelesene Werte, maximal 8

11.90. Auf erweiterten DI-Eingang warten

Neu in Version python: SDK-v2.1.5

Prototyp	FieldBusSlaveWaitDI(DIIndex, status, waitMs)
Beschreibung	Auf erweiterten DI-Eingang warten
Erforderliche Parameter	DIIndex: DI-Nummer status: 0-Low-Pegel; 1-High-Pegel waitMs: Maximale Wartezeit (ms)
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.91. Auf erweiterten AI-Eingang warten

Neu in Version python: SDK-v2.1.5

Prototyp	FieldBusSlaveWaitAI(AIIndex, waitType, value, waitMs)
Beschreibung	Auf erweiterten AI-Eingang warten
Erforderliche Parameter	AIIndex: AI-Nummer waitType: 0-Größer als; 1-Kleiner als value: AI-Wert waitMs: Maximale Wartezeit (ms)
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.92. Codebeispiel für Slave-Stationsmodus-bezogene Schnittstellenbefehle

Neu in Version python: SDK-v2.1.5

from fairino import Robot
# Verbindung mit der Robotersteuerung herstellen, bei Erfolg wird ein Roboter-Objekt zurückgegeben
robot = Robot.RPC('192.168.58.2')
robot.OpenLuaUpload("D://zUP/Peripherie/CtrlDev_field.lua")
time.sleep(2)
robot.SetCtrlOpenLUAName(3,"CtrlDev_field.lua")
robot.UnloadCtrlOpenLUA(3)
robot.LoadCtrlOpenLUA(3)
time.sleep(8)
rtn,type, version, conn_state = robot.GetFieldBusConfig()
print(f"type is {type}, version is {version}, connState is {conn_state}")
# Write digital outputs
ctrl = [1, 0, 1]  # DO0=1, DO1=0, DO2=1
robot.FieldBusSlaveWriteDO(0, 3, ctrl)
# Write analog output
ctrl_ao = [0x1000]  # AO2 = 0x1000
robot.FieldBusSlaveWriteAO(2, 1, ctrl_ao)
for i in range(100):
    rtn,di = robot.FieldBusSlaveReadDI(0, 4)
    print(f"DI0 is {di[0]}, DI1 is {di[1]}, DI2 is {di[2]}, DI3 is {di[3]}")
    rtn, ai = robot.FieldBusSlaveReadAI(0, 3)
    print(f"AI0 is {ai[0]}, AI1 is {ai[1]}, AI2 is {ai[2]}")
    time.sleep(0.01)
ret = robot.FieldBusSlaveWaitDI(0, 1, 100)
print(f"FieldBusSlaveWaitDI result is {ret}")
ret = robot.FieldBusSlaveWaitAI(0, 0, 400.00, 100)
print(f"FieldBusSlaveWaitAI result is {ret}")
robot.CloseRPC()

11.93. Endeffektor-Transparentübertragungsfunktion ein-/ausschalten SDK-Schnittstelle

Prototyp	SetAxleGenComEnable(mode)
Beschreibung	Allgemeine Transparentübertragungsfunktion des Endeffektors aktivieren
Erforderliche Parameter	mode: Aktivierung, 0-deaktiviert, 1-aktiviert
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.94. Endeffektor-Transparentübertragungsfunktion für azyklische Datenübertragung und -empfang SDK-Schnittstelle

Prototyp	SndRcvAxleGenComCmdData(len_snd, sndBuff, len_rcv)
Beschreibung	Endeffektor sendet azyklische Daten und wartet auf Antwort
Erforderliche Parameter	len_snd: Länge der zu sendenden Daten; sndBuff[]: Zu sendende Daten; len_rcv: Länge der zu empfangenden Daten; rcvBuff[]: Antwortdaten;
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.95. Codebeispiel für azyklische Datenkommunikation des DIO Health Care Moxibustion-Kopfs basierend auf der Endeffektor-Transparentübertragungsfunktion

from time import sleep
from fairino import Robot
from ctypes import sizeof
# Verbindung mit der Robotersteuerung herstellen, bei Erfolg wird ein Roboter-Objekt zurückgegeben
robot = Robot.RPC('192.168.58.2')

import time


def testAxleGenCom(self):

    led_on = [0xAB, 0xBA, 0x12, 0x01, 0x01, 0x79]
    led_off = [0xAB, 0xBA, 0x12, 0x01, 0x00, 0x78]
    version = [0xAB, 0xBA, 0x11, 0x00, 0x76]
    state = [0xAB, 0xBA, 0x1B, 0x01, 0xAA, 0x2B]
    cycleState = [0xAB, 0xBA, 0x12, 0x01, 0x00, 0x78]
    cnt = 1

    p1Joint = [88.708, -86.178, 140.989, -141.825, -89.162, -49.879]
    p1Desc = [188.007, -377.850, 260.207, 178.715, 2.823, -131.466]
    p2Joint = [112.131, -75.554, 126.989, -139.027, -88.044, -26.477]
    p2Desc = [368.003, -377.848, 260.211, 178.715, 2.823, -131.465]

    exaxisPos = [0, 0, 0, 0]
    offdese = [0, 0, 0, 0, 0, 0]

    #Endeffektor-Transparentübertragungsfunktion aktivieren
    robot.SetAxleGenComEnable(1)
    robot.SetAxleLuaEnable(1)

    while cnt <= 10000:
        #Versionsnummer auslesen
        ret,rcvdata = robot.SndRcvAxleGenComCmdData(len_snd=5, sndBuff=version, len_rcv=10)
        print(ret)
        print(rcvdata)
        print(f"hard version : {rcvdata[4]},hard code:{rcvdata[5]}, soft version:{rcvdata[6]} {rcvdata[7]}, soft code:{rcvdata[8]}")
        if ret != 0:
            break
        time.sleep(1)
        # Präsenzstatus des Moxibustion-Kopfs auslesen
        ret,rcvdata = robot.SndRcvAxleGenComCmdData(6, state, 6)
        print(f"state : {rcvdata[4]} ")
        time.sleep(1)
        # Laser des Moxibustion-Kopfs einschalten
        ret,rcvdata = robot.SndRcvAxleGenComCmdData(6, led_on, 6)
        print(f"led on rcv data is: {rcvdata[0]}, {rcvdata[1]}, {rcvdata[2]}, {rcvdata[3]}, {rcvdata[4]}, {rcvdata[5]}")
        robot.MoveJ(joint_pos=p1Joint, tool=0, user=0, vel=100, acc=100, ovl=100, exaxis_pos=exaxisPos, blendT=-1,
                        offset_flag=0, offset_pos=offdese)
        time.sleep(4)
        # Laser des Moxibustion-Kopfs ausschalten
        ret, rcvdata = robot.SndRcvAxleGenComCmdData(6, led_off, 6)
        print(f"led off rcv data is: {rcvdata[0]}, {rcvdata[1]}, {rcvdata[2]}, {rcvdata[3]}, {rcvdata[4]}, {rcvdata[5]}")
        robot.MoveJ(joint_pos=p2Joint, tool=0, user=0, vel=100, acc=100, ovl=100, exaxis_pos=exaxisPos, blendT=-1,offset_flag=0, offset_pos=offdese)
        time.sleep(1)
        print(f"***********************complate No. {cnt} SDK test*****************************")
        cnt = cnt + 1

    robot.CloseRPC()
    return 0

testAxleGenCom(robot)

11.96. Open-Protocol-Lua-Datei herunterladen

Prototyp	OpenLuaDownload(fileName, savePath)
Beschreibung	Open-Protocol-Lua-Datei herunterladen
Erforderliche Parameter	fileName: Name der Open-Protocol-Datei CtrlDev_XXX.lua; savePath: Pfad zum Speichern der Open-Protocol-Datei;
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.97. Bestimmte Open-Protocol-Lua-Datei löschen

Prototyp	OpenLuaDelete(fileName)
Beschreibung	Bestimmte Open-Protocol-Lua-Datei löschen
Erforderliche Parameter	fileName: Name der zu löschenden Open-Protocol-Lua-Datei CtrlDev_XXX.lua
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.98. Alle Open-Protocol-Lua-Dateien löschen

Prototyp	AllOpenLuaDelete()
Beschreibung	Alle Open-Protocol-Lua-Dateien löschen
Erforderliche Parameter	Keine
Standardparameter	Keine
Rückgabewert	Fehlercode Erfolg-0 Fehler-errcode

11.99. SDK-Codebeispiel für Open-Protocol-Lua-Dateioperationen

from time import sleep
import time
from fairino import Robot

# Verbindung mit der Robotersteuerung herstellen
robot = Robot.RPC('192.168.58.2')


def TestCtrlOpenLuaOperate(self):
    # Lua-Datei auf Roboter hochladen
    rtn = robot.OpenLuaUpload("D://zUP/openlua/CtrlDev_WELDING_A.lua")
    print(f"OpenLuaUpload rtn is {rtn}")

    rtn = robot.OpenLuaUpload("D://zUP/openlua/CtrlDev_SWDPOLISH.lua")
    print(f"OpenLuaUpload rtn is {rtn}")

    # Lua-Datei von Roboter herunterladen
    rtn = robot.OpenLuaDownload("CtrlDev_WELDING_A.lua", "D://zDOWN/")
    print(f"OpenLuaDownload rtn is {rtn}")

    rtn = robot.OpenLuaDownload("CtrlDev_SWDPOLISH.lua", "D://zDOWN/")
    print(f"OpenLuaDownload rtn is {rtn}")

    # Steuerungs-Open-Protocol-Lua-Name festlegen
    rtn = robot.SetCtrlOpenLUAName(0, "CtrlDev_WELDING_A.lua")
    print(f"SetCtrlOpenLUAName rtn is {rtn}")

    rtn = robot.SetCtrlOpenLUAName(1, "CtrlDev_SWDPOLISH.lua")
    print(f"SetCtrlOpenLUAName rtn is {rtn}")

    # Steuerungs-Open-Protocol-Lua-Name abrufen
    rtn, name = robot.GetCtrlOpenLUAName()
    print(f"ctrl open lua names : {name[0]}, {name[1]}, {name[2]}, {name[3]}")

    # Steuerungs-Open-Protocol-Lua laden
    rtn = robot.LoadCtrlOpenLUA(1)
    print(f"LoadCtrlOpenLUA rtn is {rtn}")
    time.sleep(2)

    # Steuerungs-Open-Protocol-Lua entladen
    rtn = robot.UnloadCtrlOpenLUA(1)
    print(f"UnloadCtrlOpenLUA rtn is {rtn}")

    # Bestimmte Lua-Datei löschen
    rtn = robot.OpenLuaDelete("CtrlDev_WELDING_A.lua")
    print(f"OpenLuaDelete rtn is {rtn}")

    # Alle Lua-Dateien löschen
    rtn = robot.AllOpenLuaDelete()
    print(f"AllOpenLuaDelete rtn is {rtn}")

    # Verbindung schließen
    robot.CloseRPC()
    time.sleep(1)


# Testfunktion aufrufen
TestCtrlOpenLuaOperate(robot)