11. Roboter-Peripherie

11.1. Greifer konfigurieren

/**
* @brief Greifer konfigurieren
* @param [in] company Greiferhersteller (zur Festlegung)
* @param [in] device Gerätenummer, vorübergehend nicht verwendet, Standard 0
* @param [in] softvesion Softwareversionsnummer, vorübergehend nicht verwendet, Standard 0
* @param [in] bus Position des Geräts am Endeffektor-Bus, vorübergehend nicht verwendet, Standard 0
* @return Fehlercode
*/
int SetGripperConfig(int company, int device, int softvesion, int bus);

11.2. Greiferkonfiguration abrufen

/**
* @brief Greiferkonfiguration abrufen
* @param [out] company Greiferhersteller (zur Festlegung)
* @param [out] device Gerätenummer, vorübergehend nicht verwendet, Standard 0
* @param [out] softvesion Softwareversionsnummer, vorübergehend nicht verwendet, Standard 0
* @param [out] bus Position des Geräts am Endeffektor-Bus, vorübergehend nicht verwendet, Standard 0
* @return Fehlercode
*/
int GetGripperConfig(ref int company, ref int device, ref int softvesion, ref int bus);

11.3. Greifer aktivieren

/**
* @brief Greifer aktivieren
* @param [in] index Greifernummer
* @param [in] act 0-Zurücksetzen, 1-Aktivieren
* @return Fehlercode
*/
int ActGripper(int index, byte act);

11.4. Greifer steuern

/**
* @brief Greifer steuern
* @param [in] index Greifernummer
* @param [in] pos Positionsprozentsatz, Bereich [0~100]
* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
* @param [in] force Drehmomentprozentsatz, Bereich [0~100]
* @param [in] max_time Maximale Wartezeit, Bereich [0~30000], [ms]
* @param [in] block 0-blockierend, 1-nicht blockierend
* @param [in] type Greifertyp: 0-Parallelgreifer; 1-Rotationsgreifer
* @param [in] rotNum Rotationsanzahl (Umdrehungen)
* @param [in] rotVel Rotationsgeschwindigkeitsprozentsatz [0-100]
* @param [in] rotTorque Rotationsdrehmomentprozentsatz [0-100]
* @return Fehlercode
*/
int MoveGripper(int index, int pos, int vel, int force, int max_time, byte block, int type, double rotNum, int rotVel, int rotTorque);

11.5. Greifer-Bewegungsstatus abrufen

/**
* @brief Greifer-Bewegungsstatus abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] status 0-Bewegung nicht abgeschlossen, 1-Bewegung abgeschlossen
* @return Fehlercode
*/
int GetGripperMotionDone(ref int fault, ref int status);

11.6. Greifer-Aktivierungsstatus abrufen

/**
* @brief Greifer-Aktivierungsstatus abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] status Bit0~Bit15 entsprechen Greifernummern 0~15, Bit=0 nicht aktiviert, Bit=1 aktiviert
* @return Fehlercode
*/
int GetGripperActivateStatus(ref int fault, ref int status);

11.7. Greiferposition abrufen

/**
* @brief Greiferposition abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] position Positionsprozentsatz, Bereich 0~100%
* @return Fehlercode
*/
int GetGripperCurPosition(ref int fault, ref int position);

11.8. Greifergeschwindigkeit abrufen

/**
* @brief Greifergeschwindigkeit abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] speed Geschwindigkeitsprozentsatz, Bereich 0~100%
* @return Fehlercode
*/
int GetGripperCurSpeed(ref int fault, ref int speed);

11.9. Greiferstrom abrufen

/**
* @brief Greiferstrom abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] current Stromprozentsatz, Bereich 0~100%
* @return Fehlercode
*/
int GetGripperCurCurrent(ref int fault, ref int current);

11.10. Greiferspannung abrufen

/**
* @brief Greiferspannung abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] voltage Spannung, Einheit 0.1V
* @return Fehlercode
*/
int GetGripperVoltage(ref int fault, ref int voltage);

11.11. Greifertemperatur abrufen

/**
* @brief Greifertemperatur abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] temp Temperatur [°C]
* @return Fehlercode
*/
int GetGripperTemp(ref int fault, ref int temp);

11.12. Vor-Greifpunkt berechnen (visuell)

/**
* @brief Vor-Greifpunkt berechnen (visuell)
* @param [in] desc_pos Kartesische Pose des Greifpunkts
* @param [in] zlength Z-Achsen-Versatz
* @param [in] zangle Rotationsversatz um die Z-Achse
* @param [out] pre_pos Vor-Greifpunkt
* @return Fehlercode
*/
int ComputePrePick(DescPose desc_pos, double zlength, double zangle, ref DescPose pre_pos);

11.13. Rückzugspunkt berechnen (visuell)

/**
* @brief Rückzugspunkt berechnen (visuell)
* @param [in] desc_pos Kartesische Pose des Rückzugspunkts
* @param [in] zlength Z-Achsen-Versatz
* @param [in] zangle Rotationsversatz um die Z-Achse
* @param [out] post_pos Rückzugspunkt
* @return Fehlercode
*/
int ComputePostPick(DescPose desc_pos, double zlength, double zangle, ref DescPose post_pos);

11.14. Codebeispiel für Roboter-Greiferoperationen

private void button36_Click(object sender, EventArgs e)
{
    int company = 4;
    int device = 0;
    int softversion = 0;
    int bus = 2;
    int index = 2;
    byte act = 0;
    int max_time = 30000;
    byte block = 0;
    int status=0;
    int fault=0;
    int active_status = 0;
    int current_pos = 0;
    int current = 0;
    int voltage = 0;
    int temp = 0;
    int speed = 0;

    robot.SetGripperConfig(company, device, softversion, bus);
    Thread.Sleep(1000);
    robot.GetGripperConfig(ref company, ref device, ref softversion, ref bus);
    Console.WriteLine("gripper config:{0},{1},{2},{3}\n", company, device, softversion, bus);

    robot.ActGripper(index, act);
    Thread.Sleep(1000);
    act = 1;
    robot.ActGripper(index, act);
    Thread.Sleep(1000);

    robot.MoveGripper(index, 90, 50, 50, max_time, block, 0, 0, 0, 0);
    Thread.Sleep(1000);
    robot.MoveGripper(index, 30, 50, 0, max_time, block, 0, 0, 0, 0);

    robot.GetGripperMotionDone(ref fault, ref status);
    Console.WriteLine("motion status:{0},{1}\n", fault, status);

    robot.GetGripperActivateStatus(ref fault, ref active_status);
    Console.WriteLine("gripper active fault is: {0}, status is: {1}\n", fault, active_status);

    robot.GetGripperCurPosition(ref fault, ref current_pos);
    Console.WriteLine("fault is:{0}, current position is: {1}\n", fault, current_pos);

    robot.GetGripperCurCurrent(ref fault, ref current);
    Console.WriteLine("fault is:{0}, current current is: {1}\n", fault, current);

    robot.GetGripperVoltage(ref fault, ref voltage);
    Console.WriteLine("fault is:{0}, current voltage is: {1} \n", fault, voltage);

    robot.GetGripperTemp(ref fault, ref temp);
    Console.WriteLine("fault is:{0}, current temperature is: {1}\n", fault, temp);

    robot.GetGripperCurSpeed(ref fault, ref speed);
    Console.WriteLine("fault is:{0}, current speed is: {1}\n", fault, speed);

    int retval = 0;
    DescPose prepick_pose = new DescPose();
    DescPose postpick_pose = new DescPose();

    DescPose p1Desc = new DescPose(-419.524f, -13.000f, 351.569f, -178.118f, 0.314f, 3.833f);
    DescPose p2Desc = new DescPose(-321.222f, 185.189f, 335.520f, -179.030f, -1.284f, -29.869f);

    retval = robot.ComputePrePick(p1Desc, 10, 0, ref prepick_pose);
    Console.WriteLine("ComputePrePick retval is: {0}\n", retval);
    Console.WriteLine("xyz is: {0}, {1}, {2}; rpy is: {3}, {4}, {5}\n",
        prepick_pose.tran.x, prepick_pose.tran.y, prepick_pose.tran.z,
        prepick_pose.rpy.rx, prepick_pose.rpy.ry, prepick_pose.rpy.rz);

    retval = robot.ComputePostPick( p2Desc, -10, 0, ref postpick_pose);
    Console.WriteLine("ComputePostPick retval is: {0}\n", retval);
    Console.WriteLine("xyz is: {0}, {1}, {2}; rpy is: {3}, {4}, {5}\n",
        postpick_pose.tran.x, postpick_pose.tran.y, postpick_pose.tran.z,
        postpick_pose.rpy.rx, postpick_pose.rpy.ry, postpick_pose.rpy.rz);
}

11.15. Rotationsanzahl des Rotationsgreifers abrufen

/**
* @brief Rotationsanzahl des Rotationsgreifers abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] num Rotationsanzahl (Umdrehungen)
* @return Fehlercode
*/
int GetGripperRotNum(ref ushort fault, ref double num);

11.16. Rotationsgeschwindigkeitsprozentsatz des Rotationsgreifers abrufen

/**
* @brief Rotationsgeschwindigkeitsprozentsatz des Rotationsgreifers abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] speed Rotationsgeschwindigkeitsprozentsatz
* @return Fehlercode
*/
int GetGripperRotSpeed(ref ushort fault, ref int speed);

11.17. Rotationsdrehmomentprozentsatz des Rotationsgreifers abrufen

/**
* @brief Rotationsdrehmomentprozentsatz des Rotationsgreifers abrufen
* @param [out] fault 0-kein Fehler, 1-Fehler
* @param [out] torque Rotationsdrehmomentprozentsatz
* @return Fehlercode
*/
int GetGripperRotTorque(ref ushort fault, ref int torque);

11.18. Codebeispiel zum Abrufen des Status eines Rotationsgreifers

int MoveRotGripper(int pos, double rotPos)
{
    robot.ResetAllError();
    robot.ActGripper(1, 1);
    Thread.Sleep(1000);
    int rtn = robot.MoveGripper(1, pos, 50, 50, 5000, 1, 1, rotPos, 50, 100);
    Console.WriteLine($"move gripper rtn is {rtn}" );
    UInt16 fault = 0;
    double rotNum = 0.0;
    int rotSpeed = 0;
    int rotTorque = 0;
    robot.GetGripperRotNum(ref fault, ref rotNum);
    robot.GetGripperRotSpeed(ref fault, ref rotSpeed);
    robot.GetGripperRotTorque(ref fault, ref rotTorque);
    Console.WriteLine($"gripper rot num :{ rotNum}, gripper rotSpeed :{rotSpeed}, gripper rotTorque : { rotTorque}");
    return 0;
}

11.19. Förderband starten/stoppen

/**
* @brief Förderband starten/stoppen
* @param [in] status Status, 1-starten, 0-stoppen
* @return Fehlercode
*/
int ConveyorStartEnd(byte status);

11.20. IO-Erkennungspunkt aufzeichnen

/**
* @brief IO-Erkennungspunkt aufzeichnen
* @return Fehlercode
*/
int ConveyorPointIORecord();

11.21. Punkt A aufzeichnen

/**
* @brief Punkt A aufzeichnen
* @return Fehlercode
*/
int ConveyorPointARecord();

11.22. Referenzpunkt aufzeichnen

/**
* @brief Referenzpunkt aufzeichnen
* @return Fehlercode
*/
int ConveyorRefPointRecord();

11.23. Punkt B aufzeichnen

/**
* @brief Punkt B aufzeichnen
* @return Fehlercode
*/
int ConveyorPointBRecord();

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

/**
* @brief Förderband-Werkstück IO-Erkennung
* @param [in] max_t Maximale Erkennungszeit [ms]
* @return Fehlercode
*/
int ConveyorIODetect(int max_t);

11.25. Aktuelle Objektposition abrufen

/**
* @brief Aktuelle Objektposition abrufen
* @param [in] mode 1-Tracking Greifen, 2-Tracking Bewegung, 3-TPD-Tracking
* @return Fehlercode
*/
int ConveyorGetTrackData(int mode);

11.26. Förderband-Tracking starten

/**
* @brief Förderband-Tracking starten
* @param [in] status Status, 1-starten, 0-stoppen
* @return Fehlercode
*/
int ConveyorTrackStart(byte status);

11.27. Förderband-Tracking stoppen

/**
* @brief Förderband-Tracking stoppen
* @return Fehlercode
*/
int ConveyorTrackEnd();

11.28. Förderbandparameter konfigurieren

/**
* @brief Förderbandparameter konfigurieren
* @param [in] encChannel Encoderkanal 1~2
* @param [in] resolution Impulse pro Encoderumdrehung
* @param [in] lead Vorschubweg des Förderbands pro Encoderumdrehung [mm]
* @param [in] wpAxis Werkstückkoordinatennummer (für Tracking-Bewegung, bei Tracking-Greifen/TPD-Tracking auf 0 setzen)
* @param [in] vision Mit Vision gekoppelt? 0 nein, 1 ja
* @param [in] speedRadio Geschwindigkeitsverhältnis (für Förderband-Tracking-Greifen Option (1-100)), Standard 1 für andere Optionen
* @param [in] followType Tracking-Bewegungstyp: 0-Tracking-Bewegung; 1-Nachlauf-Bewegung
* @param [in] startDis Für Nachlauf-Greifen erforderlich: Startabstand des Trackings. -1: automatische Berechnung (Nachlauf startet, wenn Werkstück unter Roboter ist). Einheit mm, Standard 0
* @param [in] endDis Für Nachlauf-Greifen erforderlich: Endabstand des Trackings. Einheit mm, Standard 100
* @return Fehlercode
*/
int ConveyorSetParam(int encChannel, int resolution, double lead, int wpAxis, int vision, double speedRadio, int followType, int startDis = 0, int endDis = 100);

11.29. Förderband-Greifpunktkompensation einstellen

/**
* @brief Förderband-Greifpunktkompensation einstellen
* @param [in] cmp Kompensationsposition double[3]{x, y, z}
* @return Fehlercode
*/
int ConveyorCatchPointComp(double[] cmp);

11.30. Förderband-Tracking-Linearbewegung

/**
* @brief Förderband-Tracking-Linearbewegung
* @param [in] name Name des Bewegungspunkts
* @param [in] tool Werkzeugkoordinatennummer, Bereich [0~14]
* @param [in] wobj Werkstückkoordinatennummer, Bereich [0~14]
* @param [in] vel Geschwindigkeitsprozentsatz, Bereich [0~100]
* @param [in] acc Beschleunigungsprozentsatz, Bereich [0~100], vorübergehend nicht freigegeben
* @param [in] ovl Geschwindigkeitsskalierungsfaktor, Bereich [0~100]
* @param [in] blendR [-1.0]-Bewegung abschließen (blockierend), [0~1000.0]-Glättungsradius (nicht blockierend) [mm]
* @return Fehlercode
*/
int ConveyorTrackMoveL(string name, int tool, int wobj, float vel, float acc, float ovl, float blendR);

11.31. Förderband-Kommunikationseingangserkennung

/**
* @brief Förderband-Kommunikationseingangserkennung
* @param [in] timeout Warte-Timeout [ms]
* @return Fehlercode
*/
int ConveyorComDetect(int timeout);

11.32. Förderband-Kommunikationseingangserkennung auslösen

/**
* @brief Förderband-Kommunikationseingangserkennung auslösen
* @return Fehlercode
*/
int ConveyorComDetectTrigger();

11.33. Beispielprogramm zum Auslösen der Förderband-Kommunikationseingangserkennung

private void button3_Click(object sender, EventArgs e)
{

    // Schaltfläche deaktivieren, um wiederholtes Klicken zu verhindern
    button3.Enabled = false;

    // Zeitintensive Operation im Hintergrundthread ausführen
    Thread conveyorThread = new Thread(ConveyorTest);
    conveyorThread.IsBackground = true;
    conveyorThread.Start();
}

private void button4_Click(object sender, EventArgs e)
{
    // Benutzereingabe abrufen
    string input = texBox.Text;
    Console.WriteLine($"please input a number to trigger:{input}");

    int rtn = robot.ConveyorComDetectTrigger();
    Console.WriteLine($"ConveyorComDetectTrigger return value: {rtn}");

}

private void ConveyorTest()
{
    // Invoke verwenden, um Steuerelemente im UI-Thread zu aktualisieren
    this.Invoke((MethodInvoker)delegate {
        Console.WriteLine("Starte Förderbandtest...");
    });

    int retval = 0;
    int index = 1;
    int max_time = 30000;
    bool block = false;
    retval = 0;

    /* Förderband-Greifprozess */
    DescPose startdescPose = new DescPose(139.176f, 4.717f, 9.088f, -179.999f, -0.004f, -179.990f);
    JointPos startjointPos = new JointPos(-34.129f, -88.062f, 97.839f, -99.780f, -90.003f, -34.140f);

    DescPose homePose = new DescPose(139.177f, 4.717f, 69.084f, -180.000f, -0.004f, -179.989f);
    JointPos homejointPos = new JointPos(-34.129f, -88.618f, 84.039f, -85.423f, -90.003f, -34.140f);

    ExaxisPos exaxisPos = new ExaxisPos(0, 0, 0, 0);
    DescPose offdese = new DescPose(0, 0, 0, 0, 0, 0);

    // In Sicherheitsposition bewegen
    retval = robot.MoveL(homejointPos, homePose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);
    Console.WriteLine($"MoveL to safe position return value: {retval}");

    // Förderbanderkennung
    retval = robot.ConveyorComDetect(1000 * 10);
    Console.WriteLine($"ConveyorComDetect return value: {retval}");

    // Tracking-Daten abrufen
    retval = robot.ConveyorGetTrackData(2);
    Console.WriteLine($"ConveyorGetTrackData return value: {retval}");

    // Tracking starten
    retval = robot.ConveyorTrackStart(2);
    Console.WriteLine($"ConveyorTrackStart return value: {retval}");

    // In Startposition bewegen
    robot.MoveL(startjointPos, startdescPose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);
    robot.MoveL(startjointPos, startdescPose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);

    // Tracking beenden
    retval = robot.ConveyorTrackEnd();
    Console.WriteLine($"ConveyorTrackEnd return value: {retval}");

    // In Sicherheitsposition zurückkehren
    robot.MoveL(homejointPos, homePose, 1, 1, 100, 100, 100, -1, exaxisPos, 0, 0, offdese, 1, 1);

    this.Invoke((MethodInvoker)delegate {
        Console.WriteLine("Förderbandtest abgeschlossen!");
        button3.Enabled = true;
    });
}

11.34. Beispielprogramm für Roboter-Förderbandoperationen

private void btnConvert_Click(object sender, EventArgs e)
{
    Robot robot = new Robot();
    robot.RPC("192.168.58.2");
    DescPose pos1 = new DescPose(0, 0, 0, 0 ,0 ,0);
    DescPose pos2 = new DescPose(0, 0, 0, 0, 0, 0);

    pos1.tran.x = -351.175;
    pos1.tran.y = 3.389;
    pos1.tran.z = 431.172;
    pos1.rpy.rx = -179.111;
    pos1.rpy.ry = -0.241;
    pos1.rpy.rz = 90.388;

    pos2.tran.x = -333.654;
    pos2.tran.y = -229.003;
    pos2.tran.z = 404.335;
    pos2.rpy.rx = -179.139;
    pos2.rpy.ry = -0.779;
    pos2.rpy.rz = 91.269;
    int rtn = -1;

    double[] cmp = new double[3] { 0, 9.99, 0 };
    rtn = robot.ConveyorCatchPointComp(cmp);
    if (rtn != 0)
    {
        return;
    }
    Console.WriteLine($"ConveyorCatchPointComp: rtn {rtn}");

    rtn = robot.MoveCart(pos1, 0, 0, 100.0f, 180.0f, 100.0f, -1.0f, -1);
    Console.WriteLine($"MoveCart: rtn {rtn}");

    rtn = robot.ConveyorIODetect(10000);
    Console.WriteLine($"ConveyorIODetect: rtn {rtn}");

    robot.ConveyorGetTrackData(1);
    rtn = robot.ConveyorTrackStart(1);
    Console.WriteLine($"ConveyorTrackStart: rtn {rtn}");

    rtn = robot.ConveyorTrackMoveL("cvrCatchPoint", 0, 0, 100.0f, 0.0f, 100.0f, -1.0f);
    Console.WriteLine($"ConveyorTrackMoveL: rtn {rtn}");

    rtn = robot.MoveGripper(1, 59, 43, 21, 30000, 0, 0, 0, 0, 0);
    Console.WriteLine($"MoveGripper: rtn {rtn}");

    rtn = robot.ConveyorTrackMoveL("cvrRaisePoint", 0, 0, 100.0f, 0.0f, 100.0f, -1.0f);
    Console.WriteLine($"ConveyorTrackMoveL: rtn {rtn}");

    rtn = robot.ConveyorTrackEnd();
    Console.WriteLine($"ConveyorTrackEnd: rtn {rtn}");

    rtn = robot.MoveCart(pos2, 0, 0, 100.0f, 180.0f, 100.0f, -1.0f, -1);
    Console.WriteLine($"MoveCart: rtn {rtn}");

    rtn = robot.MoveGripper(1, 100, 43, 21, 30000, 0, 0, 0, 0, 0);
    Console.WriteLine($"MoveGripper: rtn {rtn}");
}

11.35. Endeffektor-Sensor konfigurieren

/**
* @brief Endeffektor-Sensor konfigurieren
* @param [in] idCompany Hersteller, 18-JUNKONG; 25-HUIDE
* @param [in] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
* @param [in] idSoftware Softwareversion, 0-J1.0/HuiDe1.0 (vorübergehend nicht freigegeben)
* @param [in] idBus Anschlussposition, 1-Endeffektor Port 1; 2-Endeffektor Port 2...8-Endeffektor Port 8 (vorübergehend nicht freigegeben)
* @return Fehlercode
*/
int AxleSensorConfig(int idCompany, int idDevice, int idSoftware, int idBus);

11.36. Endeffektor-Sensorkonfiguration abrufen

/**
* @brief Endeffektor-Sensorkonfiguration abrufen
* @param [out] idCompany Hersteller, 18-JUNKONG; 25-HUIDE
* @param [out] idDevice Typ, 0-JUNKONG/RYR6T.V1.0
* @return Fehlercode
*/
int AxleSensorConfigGet(ref int idCompany, ref int idDevice);

11.37. Endeffektor-Sensor aktivieren

/**
* @brief Endeffektor-Sensor aktivieren
* @param [in] actFlag 0-Zurücksetzen; 1-Aktivieren
* @return Fehlercode
*/
int AxleSensorActivate(int actFlag);

11.38. In Endeffektor-Sensorregister schreiben

/**
* @brief In Endeffektor-Sensorregister schreiben
* @param [in] devAddr Geräteadresse 0-255
* @param [in] regHAddr Registeradresse hohes Byte
* @param [in] regLAddr Registeradresse niedriges Byte
* @param [in] regNum Anzahl der Register 0-255
* @param [in] data1 Zu schreibender Registerwert 1
* @param [in] data2 Zu schreibender Registerwert 2
* @param [in] isNoBlock 0-blockierend; 1-nicht blockierend
* @return Fehlercode
*/
int AxleSensorRegWrite(int devAddr, int regHAddr, int regLAddr, int regNum, int data1, int data2, int isNoBlock);

11.39. Codebeispiel für Endeffektor-Sensor

private void button2_Click_1(object sender, EventArgs e)
{
    robot.AxleSensorConfig(18, 0, 0, 1);
    int company = -1;
    int type = -1;
    robot.AxleSensorConfigGet(ref company, ref type);
    Console.WriteLine("company is " + company + ", type is " + type);

    int rtn = robot.AxleSensorActivate(1);
    Console.WriteLine("AxleSensorActivate rtn is " + rtn);

    Thread.Sleep(1000);

    rtn = robot.AxleSensorRegWrite(1, 4, 6, 1, 0, 0, 0);
    Console.WriteLine("AxleSensorRegWrite rtn is " + rtn);
}

11.40. Roboter-Peripherieprotokoll abrufen

Neu in Version C#SDK-v1.0.6.

/**
* @brief Roboter-Peripherieprotokoll abrufen
* @param [out] protocol Roboter-Peripherieprotokollnummer: 4096-Erweiterungsachsen-Steuerkarte; 4097-ModbusSlave; 4098-ModbusMaster
* @return Fehlercode
*/
int GetExDevProtocol(ref int protocol);

11.41. Roboter-Peripherieprotokoll einstellen

Neu in Version C#SDK-v1.0.6.

/**
* @brief Roboter-Peripherieprotokoll einstellen
* @param [in] protocol Roboter-Peripherieprotokollnummer: 4096-Erweiterungsachsen-Steuerkarte; 4097-ModbusSlave; 4098-ModbusMaster
* @return Fehlercode
*/
int SetExDevProtocol(int protocol);

11.42. Beispielprogramm zum Einstellen des Roboter-Peripherieprotokolls

private void btnSetProto_Click(object sender, EventArgs e)
{
    int protocol = 4096;
    int rtn = robot.SetExDevProtocol(protocol);
    Console.WriteLine("SetExDevProtocol rtn " + rtn);
    rtn = robot.GetExDevProtocol(ref protocol);
    Console.WriteLine("GetExDevProtocol rtn " + rtn + " protocol is: " + protocol);
}

11.43. Endeffektor-Kommunikationsparameter abrufen

/**
* @brief Endeffektor-Kommunikationsparameter abrufen
* @param [out] param Endeffektor-Kommunikationsparameter
* @return Fehlercode
*/
int GetAxleCommunicationParam(ref AxleComParam param);

11.44. Endeffektor-Kommunikationsparameter einstellen

/**
* @brief Endeffektor-Kommunikationsparameter einstellen
* @param [in] param Endeffektor-Kommunikationsparameter
* @return Fehlercode
*/
int SetAxleCommunicationParam(AxleComParam param);

11.45. Endeffektor-Dateiübertragungstyp einstellen

/**
* @brief Endeffektor-Dateiübertragungstyp einstellen
* @param [in] type 1-MCU Upgrade-Datei; 2-LUA-Datei
* @return Fehlercode
*/
int SetAxleFileType(int type);

11.46. Endeffektor-LUA-Ausführung aktivieren

/**
* @brief Endeffektor-LUA-Ausführung aktivieren
* @param [in] enable 0-nicht aktivieren; 1-aktivieren
* @return Fehlercode
*/
int SetAxleLuaEnable(int enable);

11.47. Fehlerbehebung bei anomaler Endeffektor-LUA-Datei

/**
* @brief Fehlerbehebung bei anomaler Endeffektor-LUA-Datei
* @param [in] status 0-nicht beheben; 1-beheben
* @return Fehlercode
*/
int SetRecoverAxleLuaErr(int status);

11.48. Aktivierungsstatus der Endeffektor-LUA-Ausführung abrufen

/**
* @brief Aktivierungsstatus der Endeffektor-LUA-Ausführung abrufen
* @param [out] status 0-nicht aktiviert; 1-aktiviert
* @return Fehlercode
*/
int GetAxleLuaEnableStatus(ref int status);

11.49. Aktivierungstyp der Endeffektor-LUA-Endgeräte einstellen

/**
* @brief Aktivierungstyp der Endeffektor-LUA-Endgeräte einstellen
* @param [in] forceSensorEnable Kraftsensor-Aktivierungsstatus, 0-nicht aktivieren; 1-aktivieren
* @param [in] gripperEnable Greifer-Aktivierungsstatus, 0-nicht aktivieren; 1-aktivieren
* @param [in] IOEnable IO-Geräte-Aktivierungsstatus, 0-nicht aktivieren; 1-aktivieren
* @return Fehlercode
*/
int SetAxleLuaEnableDeviceType(int forceSensorEnable, int gripperEnable, int IOEnable);

11.50. Aktivierungstyp der Endeffektor-LUA-Endgeräte abrufen

/**
* @brief Aktivierungstyp der Endeffektor-LUA-Endgeräte abrufen
* @param [out] forceSensorEnable Kraftsensor-Aktivierungsstatus, 0-nicht aktiviert; 1-aktiviert
* @param [out] gripperEnable Greifer-Aktivierungsstatus, 0-nicht aktiviert; 1-aktiviert
* @param [out] IOEnable IO-Geräte-Aktivierungsstatus, 0-nicht aktiviert; 1-aktiviert
* @return Fehlercode
*/
int GetAxleLuaEnableDeviceType(ref int forceSensorEnable, ref int gripperEnable, ref int IOEnable);

11.51. Aktuell konfigurierte Endgeräte abrufen

/**
* @brief Aktuell konfigurierte Endgeräte abrufen
* @param [out] forceSensorEnable Aktivierte Kraftsensornummern-Array (0-nicht aktiviert; 1-aktiviert) - Implementierung abhängig
* @param [out] gripperEnable Aktivierte Greifernummern-Array (0-nicht aktiviert; 1-aktiviert) - Implementierung abhängig
* @param [out] IODeviceEnable Aktivierte IO-Gerätenummern-Array (0-nicht aktiviert; 1-aktiviert) - Implementierung abhängig
* @return Fehlercode
*/
int GetAxleLuaEnableDevice(ref int[] forceSensorEnable, ref int[] gripperEnable, ref int[] IODeviceEnable); // Hinweis: Array-Parameter möglicherweise anders zu handhaben

11.52. Greifer-Aktionssteuerungsfunktion aktivieren

/**
* @brief Greifer-Aktionssteuerungsfunktion aktivieren (für LUA-Skript)
* @param [in] id Greifer-Gerätenummer
* @param [in] func Funktions-Array: func[0]-Greifer aktivieren; func[1]-Greifer initialisieren; 2-Position einstellen; 3-Geschwindigkeit einstellen; 4-Drehmoment einstellen; 6-Greiferstatus lesen; 7-Initialisierungsstatus lesen; 8-Fehlercode lesen; 9-Position lesen; 10-Geschwindigkeit lesen; 11-Drehmoment lesen
* @return Fehlercode
*/
int SetAxleLuaGripperFunc(int id, int[] func);

11.53. Aktivierte Greifer-Aktionssteuerungsfunktion abrufen

/**
* @brief Aktivierte Greifer-Aktionssteuerungsfunktion abrufen
* @param [in] id Greifer-Gerätenummer
* @param [out] func Funktions-Array (wie oben)
* @return Fehlercode
*/
int GetAxleLuaGripperFunc(int id, ref int[] func); // Hinweis: Array-Parameter möglicherweise anders zu handhaben

11.54. In Ethercat-Slave-Datei des Roboters schreiben

/**
* @brief In Ethercat-Slave-Datei des Roboters schreiben
* @param [in] type Slave-Dateityp: 1-Upgrade Slave-Datei; 2-Upgrade Slave-Konfigurationsdatei
* @param [in] slaveID Slave-Nummer
* @param [in] fileName Name der hochzuladenden Datei
* @return Fehlercode
*/
int SlaveFileWrite(int type, int slaveID, string fileName);

11.55. Endeffektor-Lua-Open-Protocol-Datei hochladen

/**
* @brief Endeffektor-Lua-Open-Protocol-Datei hochladen
* @param [in] filePath Lokaler Pfad zur Lua-Datei ".../AXLE_LUA_End_DaHuan.lua"
* @return Fehlercode
*/
int AxleLuaUpload(string filePath);

11.56. Ethercat-Slave des Roboters in den Boot-Modus versetzen

/**
* @brief Ethercat-Slave des Roboters in den Boot-Modus versetzen
* @return Fehlercode
*/
int SetSysServoBootMode();

11.57. Codebeispiel für Roboter-Endeffektor-LUA-Dateioperationen

private void button41_Click(object sender, EventArgs e)
{
    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
    robot.AxleLuaUpload("D://zUP/AXLE_LUA_End_JunDuo_Xinjingcheng.lua");

    AxleComParam param = new AxleComParam(7, 8, 1, 0, 5, 3, 1);
    robot.SetAxleCommunicationParam(param);

    AxleComParam getParam = new AxleComParam();
    robot.GetAxleCommunicationParam(ref getParam);
    Console.WriteLine("GetAxleCommunicationParam param is {0} {1} {2} {3} {4} {5} {6}",
        getParam.baudRate, getParam.dataBit, getParam.stopBit, getParam.verify,
        getParam.timeout, getParam.timeoutTimes, getParam.period);

    robot.SetAxleLuaEnable(1);
    int luaEnableStatus = 0;
    robot.GetAxleLuaEnableStatus(ref luaEnableStatus);
    robot.SetAxleLuaEnableDeviceType(0, 1, 0);

    int forceEnable = 0;
    int gripperEnable = 0;
    int ioEnable = 0;
    robot.GetAxleLuaEnableDeviceType(ref forceEnable, ref gripperEnable, ref ioEnable);
    Console.WriteLine("GetAxleLuaEnableDeviceType param is {0} {1} {2}", forceEnable, gripperEnable, ioEnable);

    int[] func = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
    robot.SetAxleLuaGripperFunc(1, func);
    int[] getFunc = new int[16];
    robot.GetAxleLuaGripperFunc(1, ref getFunc);
    int[] getforceEnable = new int[16];
    int[] getgripperEnable = new int[16];
    int[] getioEnable = new int[16];
    robot.GetAxleLuaEnableDevice(ref getforceEnable, ref getgripperEnable, ref getioEnable);
    Console.WriteLine("\ngetforceEnable status : ");
    foreach (int i in getforceEnable)
    {
        Console.Write(i + ",");
    }
    Console.WriteLine("\ngetgripperEnable status : ");
    foreach (int i in getgripperEnable)
    {
        Console.Write(i + ",");
    }
    Console.WriteLine("\ngetioEnable status : ");
    foreach (int i in getioEnable)
    {
        Console.Write(i + ",");
    }
    Console.WriteLine();
    robot.ActGripper(1, 0);
    Thread.Sleep(2000);
    robot.ActGripper(1, 1);
    Thread.Sleep(2000);
    robot.MoveGripper(1, 90, 10, 100, 50000, 0, 0, 0, 0, 0);
    int pos = 0;
    while (true)
    {
        robot.GetRobotRealTimeState(ref pkg);
        Console.WriteLine("gripper pos is " + pkg.gripper_position);
        Thread.Sleep(100);
    }
}

11.58. SmartTool-Tastenstatus abrufen

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

/**
* @brief SmartTool-Tastenstatus abrufen
* @param [out] 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)
* @return Fehlercode
*/
int GetSmarttoolBtnState(ref int state);

11.59. Codebeispiel

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

private void button11_Click(object sender, EventArgs e)
{

    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
    int state = 0;
    while (true)
    {
        int rtn = robot.GetSmarttoolBtnState(ref state);
        string binaryString = Convert.ToString(state, 2).PadLeft(32, '0');
        Console.WriteLine($"GetSmarttoolBtnState rtn (binary): {binaryString}");
        Thread.Sleep(100);
    }
}

11.60. Open-Protocol-Lua-Datei hochladen

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

/**
* @brief Open-Protocol-Lua-Datei hochladen
* @param filePath Lokaler Pfad zur Open-Protocol-Lua-Datei
* @return Fehlercode
*/
int OpenLuaUpload(string filePath)

11.61. Slave-Kartenparameter abrufen

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

/**
* @brief Slave-Kartenparameter abrufen
* @param type Protokolltyp: 0-Ethercat, 1-CClink, 3-Ethercat (Dopplung?), 4-EIP
* @param version Protokollversion
* @param connState Verbindungsstatus: 0-nicht verbunden, 1-verbunden
* @return Fehlercode
*/
int GetFieldBusConfig(ref int type, ref int version, ref int connState) // Hinweis: Array-Parameter in C# SDK möglicherweise anders

11.62. In Slave-DO schreiben

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

/**
* @brief In Slave-DO schreiben
* @param DOIndex DO-Nummer
* @param writeNum Anzahl der zu schreibenden Werte
* @param status Zu schreibende Werte (max. 8)
* @return Fehlercode
*/
int FieldBusSlaveWriteDO(int DOIndex, int writeNum, int[] status)

11.63. In Slave-AO schreiben

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

/**
* @brief  AO der Slave-Station schreiben
* @param [in] AOIndex AO-Nummer
* @param [in] writeNum Anzahl der zu schreibenden Werte
* @param [in] status Array der zu schreibenden Werte (maximal 8), AO0~AO15 sind ganzzahlig, AO16~AO31 sind Gleitkommazahlen
* @return Fehlercode
*/
public int FieldBusSlaveWriteAO(int AOIndex, int writeNum, double[] status)

11.64. Slave-DI lesen

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

/**
* @brief Slave-DI lesen
* @param DIIndex DI-Nummer
* @param readNum Anzahl der zu lesenden Werte
* @param status Gelesene Werte (max. 8)
* @return Fehlercode
*/
int FieldBusSlaveReadDI(int DIIndex, int readNum, ref int[] status)

11.65. Slave-AI lesen

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

/**
* @brief Slave-AI lesen
* @param AIIndex AI-Nummer
* @param readNum Anzahl der zu lesenden Werte
* @param status Gelesene Werte (max. 8)
* @return Fehlercode
*/
int FieldBusSlaveReadAI(int AIIndex, int readNum, ref double[] status)

11.66. Auf erweiterten DI-Eingang warten (Slave)

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

/**
* @brief Auf erweiterten DI-Eingang (Slave) warten
* @param DIIndex DI-Nummer
* @param status Erwarteter Zustand: 0-niedrig; 1-hoch
* @param waitMs Maximale Wartezeit [ms]
* @return Fehlercode
*/
int FieldBusSlaveWaitDI(int DIIndex, int status, int waitMs)

11.67. Auf erweiterten AI-Eingang warten (Slave)

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

/**
* @brief Auf erweiterten AI-Eingang (Slave) warten
* @param AIIndex AI-Nummer
* @param waitType Bedingung: 0-größer als; 1-kleiner als
* @param value Vergleichswert
* @param waitMs Maximale Wartezeit [ms]
* @return Fehlercode
*/
int FieldBusSlaveWaitAI(int AIIndex, int waitType, double value, int waitMs)

11.68. Codebeispiel für Slave-Modus-Befehle

private void button101_Click(object sender, EventArgs e)
{
    int rtn = 0;

    int type = 0, version = 0, connState = 0;
    int[] ctrl = new int[8];
    double[] ctrlAO = new double[8];
    int[] DI = new int[8];
    double[] AI = new double[8];
    // if (rtn != 0) // Ursprünglicher Code, wahrscheinlich überflüssig
    // {
    //     return;
    // }
    // Open-Protocol-Datei hochladen und laden
    robot.OpenLuaUpload("E://temp/CtrlDev_field.lua");
    Thread.Sleep(2000);
    robot.SetCtrlOpenLUAName(3, "CtrlDev_field.lua");
    robot.UnloadCtrlOpenLUA(3);
    robot.LoadCtrlOpenLUA(3);
    Thread.Sleep(8000);

    // Protokolltyp, Softwareversion und Verbindungsstatus mit SPS abrufen
    robot.GetFieldBusConfig(ref type, ref version, ref connState);
    Console.WriteLine($"type is {type}, version is {version}, connState is {connState}");

    // DO0 = 1, DO1 = 0, DO2 = 1 schreiben
    ctrl[0] = 1;
    ctrl[1] = 0;
    ctrl[2] = 1;
    robot.FieldBusSlaveWriteDO(0, 3, ctrl);

    // AO2 = 0x1000 schreiben
    ctrlAO[0] = 0x1000;
    robot.FieldBusSlaveWriteAO(2, 1, ctrlAO);

    for (int i = 0; i < 100; i++)
    {
        robot.FieldBusSlaveReadDI(0, 4, ref DI);
        Console.WriteLine($"DI0 is {DI[0]}, DI1 is {DI[1]}, DI2 is {DI[2]}, DI3 is {DI[3]}");
        robot.FieldBusSlaveReadAI(0, 3, ref AI);
        Console.WriteLine($"AI0 is {AI[0]}, AI1 is {AI[1]}, AI2 is {AI[2]}");
        Thread.Sleep(10);
    }
    int ret = robot.FieldBusSlaveWaitDI(0, 1, 100);
    Console.WriteLine($"FieldBusSlaveWaitDI result is {ret}");

    ret = robot.FieldBusSlaveWaitAI(0, 0, 400.00f, 100);
    Console.WriteLine($"FieldBusSlaveWaitAI result is {ret}");
}

11.69. Array-Sauggreifer steuern

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

/**
* @brief Array-Sauggreifer steuern
* @param [in] slaveID Slave-Nummer
* @param [in] len Länge des Steuerarrays (Anzahl der zu steuernden Sauger)
* @param [in] ctrlValue Steuerwerte: 1-mit maximalem Vakuum ansaugen; 2-mit eingestelltem Vakuum ansaugen; 3-Ansaugen stoppen
* @return Fehlercode
*/
int SetSuckerCtrl(int slaveID, int len, int[] ctrlValue)

11.70. Status des Array-Sauggreifers abrufen

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

/**
* @brief Status des Array-Sauggreifers abrufen
* @param [in] slaveID Slave-Nummer
* @param [out] state Saugzustand: 0-Objekt losgelassen; 1-Werkstück erfolgreich angesaugt; 2-kein Objekt angesaugt; 3-Objekt abgelöst
* @param [out] pressValue Aktuelles Vakuum [kPa]
* @param [out] error Aktueller Fehlercode des Saugers
* @return Fehlercode
*/
int GetSuckerState(int slaveID, ref int[] state, ref int[] pressValue, ref int[] error) // Hinweis: Array-Parameter

11.71. Auf Saugerstatus warten

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

/**
* @brief Auf Saugerstatus warten
* @param [in] slaveID Slave-Nummer
* @param [in] state Erwarteter Saugzustand: 0-Objekt losgelassen; 1-Werkstück erfolgreich angesaugt; 2-kein Objekt angesaugt; 3-Objekt abgelöst
* @param [in] ms Maximale Wartezeit [ms]
* @return Fehlercode
*/
int WaitSuckerState(int slaveID, int state, int ms)