15. CNDE

15.1. Konfigurieren der CNDE-Datenliste und des Aktualisierungszeitraums des Roboters

1/**
2* @brief Konfiguriert die Datenliste und den Aktualisierungszeitraum für die Echtzeitstatusrückmeldung des Roboters (überschreibt vorherige Konfiguration)
3* @param [in] states Liste der zu abonnierenden Status-Enums, die Reihenfolge bestimmt die Anordnung im Datenpaket
4* @param [in] period Datenaktualisierungszeitraum, Einheit Millisekunden, Wertebereich [8, 1000]
5* @return Gibt bei Erfolg 0 zurück; bei Fehler einen negativen Fehlercode (z. B. ERR_STATE_INVALID, ERR_PARAM_VALUE usw.)
6*/
7public int SetRobotRealtimeStateConfig(List<RobotState> states, int period)

15.2. Hinzufügen eines Statuselements zur bestehenden Statusrückmeldeliste

1/**
2* @brief Fügt ein Statuselement zur bestehenden Statusrückmeldeliste hinzu
3* @param [in] state Hinzuzufügender Status-Enum-Wert
4* @return Gibt bei Erfolg 0 zurück; bei Fehler einen negativen Fehlercode (z. B. ERR_STATE_ALREADY_EXISTS, ERR_STATE_INVALID usw.)
5*/
6public int AddRobotRealtimeState(RobotState state)

15.3. Löschen eines Statuselements aus der bestehenden Statusrückmeldeliste

1/**
2* @brief Löscht ein Statuselement aus der bestehenden Statusrückmeldeliste (mindestens ein Status muss verbleiben)
3* @param [in] state Zu löschender Status-Enum-Wert
4* @return Gibt bei Erfolg 0 zurück; bei Fehler einen negativen Fehlercode (z. B. ERR_STATE_INVALID, ERR_NEED_AT_LEAST_ONE_STATE)
5*/
6public int DeleteRobotRealtimeState(RobotState state)

15.4. Nur den Aktualisierungszeitraum der Statusrückmeldung ändern

1 /**
2* @brief Ändert nur den Aktualisierungszeitraum der Statusrückmeldung, ohne die Statusliste zu ändern
3* @param [in] period Neuer Aktualisierungszeitraum, Einheit Millisekunden, Wertebereich [8, 1000]
4* @return Gibt bei Erfolg 0 zurück; bei Fehler einen negativen Fehlercode (z. B. ERR_PARAM_VALUE)
5*/
6public int SetRobotRealtimeStatePeriod(int period)

15.5. Abrufen der aktuell konfigurierten Statusrückmeldeliste und des Aktualisierungszeitraums

1/**
2* @brief Ruft die aktuell konfigurierte Statusrückmeldeliste und den Aktualisierungszeitraum ab
3* @param [out] states Gibt die aktuell abonnierte Status-Enum-Liste aus
4* @param [out] period Gibt den aktuellen Datenaktualisierungszeitraum in Millisekunden aus
5* @return Gibt bei Erfolg 0 zurück; bei Fehler einen negativen Fehlercode
6*/
7public int GetRobotRealtimeStateConfig(out List<RobotState> states, out int period)

15.6. CNDE-Konfigurationsbezogenes SDK-Codebeispiel

 1private async void TestRobotRealtimeStates()
 2{
 3    // 1. Definieren der zu abonnierenden Statusfelder
 4    List<RobotState> requiredStates = new List<RobotState>
 5    {
 6        RobotState.JointCurPos,
 7        RobotState.ToolCurPos,
 8        RobotState.JointDriverTemperature,
 9        RobotState.RobotTime,
10    };
11
12    // 2. Konfigurieren der Statusrückmeldung (Zeitraum 8ms)
13    int periodMs = 8;
14    int ret = robot.SetRobotRealtimeStateConfig(requiredStates, periodMs);
15    if (ret != 0)
16    {
17        Console.WriteLine($"Statuskonfiguration fehlgeschlagen, Fehlercode: {ret}");
18        return;
19    }
20    Console.WriteLine($"Statuskonfiguration erfolgreich, {requiredStates.Count} Felder, Zeitraum {periodMs} ms");
21
22    // Überprüfen, ob die Konfiguration wirksam ist
23    List<RobotState> actualStates;
24    int actualPeriod;
25    robot.GetRobotRealtimeStateConfig(out actualStates, out actualPeriod);
26    Console.WriteLine($"Tatsächlich aktive Statusanzahl: {actualStates.Count}, Zeitraum: {actualPeriod} ms");
27    Thread.Sleep(3000);
28    // 3. RPC-Verbindung herstellen (intern automatischer CNDE-Handshake)
29    robot.SetReconnectParam(true, 10, 1000);
30    ret = robot.RPC("192.168.58.2");  // Entsprechend der tatsächlichen Roboter-IP ändern
31    if (ret != 0)
32    {
33        Console.WriteLine($"RPC-Verbindung fehlgeschlagen, Fehlercode: {ret}");
34        return;
35    }
36    // 4. Schleife zum Lesen und Drucken der Statusdaten
37    DateTime startTime = DateTime.Now;
38    const int durationSeconds = 500;
39
40    while ((DateTime.Now - startTime).TotalSeconds < durationSeconds)
41    {
42        ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
43        ret = robot.GetRobotRealTimeState(ref pkg);
44        Console.WriteLine($"GetRobotRealTimeState: {ret}");
45
46        //Gelenkpositionen (Grad)
47        if (pkg.jt_cur_pos != null && pkg.jt_cur_pos.Length >= 6)
48            Console.WriteLine($"Gelenkpositionen(°): J1={pkg.jt_cur_pos[0]:F2}, J2={pkg.jt_cur_pos[1]:F2}, J3={pkg.jt_cur_pos[2]:F2}, J4={pkg.jt_cur_pos[3]:F2}, J5={pkg.jt_cur_pos[4]:F2}, J6={pkg.jt_cur_pos[5]:F2}");
49
50        //TCP-Pose (mm /°)
51        if (pkg.tl_cur_pos != null && pkg.tl_cur_pos.Length >= 6)
52            Console.WriteLine($"TCP-Pose(mm/°): X={pkg.tl_cur_pos[0]:F2}, Y={pkg.tl_cur_pos[1]:F2}, Z={pkg.tl_cur_pos[2]:F2}, RX={pkg.tl_cur_pos[3]:F2}, RY={pkg.tl_cur_pos[4]:F2}, RZ={pkg.tl_cur_pos[5]:F2}");
53
54        // Gelenktemperaturen
55        if (pkg.jointDriverTemperature != null && pkg.jointDriverTemperature.Length >= 6)
56            Console.WriteLine($"Gelenktemperaturen(°C): J1={pkg.jointDriverTemperature[0]:F2}, J2={pkg.jointDriverTemperature[1]:F2}, J3={pkg.jointDriverTemperature[2]:F2}, J4={pkg.jointDriverTemperature[3]:F2}, J5={pkg.jointDriverTemperature[4]:F2}, J6={pkg.jointDriverTemperature[5]:F2}");
57
58        // Roboterzeit
59        Console.WriteLine($"Roboterzeit: {pkg.robotTime.year}-{pkg.robotTime.mouth:D2}-{pkg.robotTime.day:D2} {pkg.robotTime.hour:D2}:{pkg.robotTime.minute:D2}:{pkg.robotTime.second:D2}.{pkg.robotTime.millisecond:D3}");
60
61        await Task.Delay(100);
62    }
63
64    // 5. Verbindung trennen
65    robot.CloseRPC();
66}

15.7. CNDE-Hinzufügen/Löschen von Konfigurationsstatus und Einstellen des Kommunikationszeitraums SDK-Codebeispiel

 1private async void TestAddDeleteCNDE()
 2{
 3    List<RobotState> finalStates;
 4    int finalPeriod;
 5    // Anfangskonfiguration: Keinen Status anfordern (Standardkonfiguration)
 6    List<RobotState> emptyStates = new List<RobotState>();
 7    int ret = robot.SetRobotRealtimeStateConfig(emptyStates, 20);
 8
 9    robot.SetRobotRealtimeStatePeriod(10);
10    // Zwei Status löschen
11    ret = robot.DeleteRobotRealtimeState(RobotState.JointCurPos);
12    Console.WriteLine($"Löschen von JointCurPos Ergebnis: {ret}");
13    ret = robot.DeleteRobotRealtimeState(RobotState.ToolCurPos);
14    Console.WriteLine($"Löschen von ToolCurPos Ergebnis: {ret}");
15    // Einen Status hinzufügen
16    ret = robot.AddRobotRealtimeState(RobotState.CollisionLevel);
17    Console.WriteLine($"Hinzufügen von CollisionLevel Ergebnis: {ret}");
18
19    // Aktuelle Konfigurationsliste abrufen und erneut senden
20    List<RobotState> currentStates;
21    int currentPeriod;
22    robot.GetRobotRealtimeStateConfig(out currentStates, out currentPeriod);
23    Console.WriteLine($"Aktuelle Konfigurationsstatusanzahl: {currentStates.Count}");
24    ret = robot.SetRobotRealtimeStateConfig(currentStates, currentPeriod);
25    Console.WriteLine($"Anwenden der neuen Konfiguration Ergebnis: {ret}"); Console.WriteLine($"Anfangskonfiguration Ergebnis: {ret}");
26    robot.GetRobotRealtimeStateConfig(out finalStates, out finalPeriod);
27    Console.WriteLine($"Konfigurationsstatusanzahl: {finalStates.Count}");
28    foreach (var s in finalStates) Console.WriteLine($"  {s}");
29    Console.WriteLine($"Zeitraum: {finalPeriod} ms");
30
31    Thread.Sleep(1000);
32    // RPC-Verbindung herstellen (intern automatische CNDE-Verbindung)
33    robot.SetReconnectParam(true, 100, 1000);
34    ret = robot.RPC("192.168.58.2");
35    if (ret != 0)
36    {
37        Console.WriteLine($"RPC-Verbindung fehlgeschlagen: {ret}");
38        return;
39    }
40
41    // Schleife zum Drucken der gelöschten und hinzugefügten Status, gelöschte Status werden als 0 gedruckt, hinzugefügte Status können normale Echtzeitwerte abrufen
42    DateTime lastTime = DateTime.Now;
43    int frameCount = 0;
44    DateTime startTime = DateTime.Now;
45    while ((DateTime.Now - startTime).TotalSeconds < 10)
46    {
47        ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
48        robot.GetRobotRealTimeState(ref pkg);
49        DateTime now = DateTime.Now;
50        double interval = (now - lastTime).TotalMilliseconds;
51        lastTime = now;
52        frameCount++;
53
54        if (pkg.jt_cur_pos != null && pkg.jt_cur_pos.Length >= 6)
55        {
56            Console.WriteLine($"  Gelenkpositionen(°): J1={pkg.jt_cur_pos[0]:F2}, J2={pkg.jt_cur_pos[1]:F2}, J3={pkg.jt_cur_pos[2]:F2}, J4={pkg.jt_cur_pos[3]:F2}, J5={pkg.jt_cur_pos[4]:F2}, J6={pkg.jt_cur_pos[5]:F2}");
57        }
58        if (pkg.tl_cur_pos != null && pkg.tl_cur_pos.Length >= 6)
59        {
60            Console.WriteLine($"  TCP-Pose(mm/°): X={pkg.tl_cur_pos[0]:F2}, Y={pkg.tl_cur_pos[1]:F2}, Z={pkg.tl_cur_pos[2]:F2}, RX={pkg.tl_cur_pos[3]:F2}, RY={pkg.tl_cur_pos[4]:F2}, RZ={pkg.tl_cur_pos[5]:F2}");
61        }
62        // Kollisionsstufe
63        if (pkg.collisionLevel != null && pkg.collisionLevel.Length >= 6)
64            Console.WriteLine($"Kollisionsstufe: J1={pkg.collisionLevel[0]}, J2={pkg.collisionLevel[1]}, J3={pkg.collisionLevel[2]}, J4={pkg.collisionLevel[3]}, J5={pkg.collisionLevel[4]}, J6={pkg.collisionLevel[5]}");
65
66        await Task.Delay(50);
67    }
68    //Verbindung trennen
69    robot.CloseRPC();
70    Console.WriteLine("Test abgeschlossen.");
71}