15. CNDE

15.1. Configurare la Lista Dati CNDE del Robot e il Periodo di Aggiornamento

1/**
2* @brief Configura la lista dati e il periodo di aggiornamento per il feedback dello stato in tempo reale del robot (sovrascrive la configurazione precedente)
3* @param [in] states Lista di enum di stato a cui sottoscriversi, l'ordine determina la disposizione nel pacchetto dati
4* @param [in] period Periodo di aggiornamento dati, unità millisecondi, intervallo di valori [8, 1000]
5* @return Restituisce 0 in caso di successo; restituisce un codice di errore negativo in caso di fallimento (es. ERR_STATE_INVALID, ERR_PARAM_VALUE, ecc.)
6*/
7public int SetRobotRealtimeStateConfig(List<RobotState> states, int period)

15.2. Aggiungere un Elemento di Stato all’Elenco di Feedback di Stato Esistente

1/**
2* @brief Aggiunge un elemento di stato all'elenco di feedback di stato esistente
3* @param [in] state Valore enum dello stato da aggiungere
4* @return Restituisce 0 in caso di successo; restituisce un codice di errore negativo in caso di fallimento (es. ERR_STATE_ALREADY_EXISTS, ERR_STATE_INVALID, ecc.)
5*/
6public int AddRobotRealtimeState(RobotState state)

15.3. Eliminare un Elemento di Stato dall’Elenco di Feedback di Stato Esistente

1/**
2* @brief Elimina un elemento di stato dall'elenco di feedback di stato esistente (deve rimanere almeno uno stato)
3* @param [in] state Valore enum dello stato da eliminare
4* @return Restituisce 0 in caso di successo; restituisce un codice di errore negativo in caso di fallimento (es. ERR_STATE_INVALID, ERR_NEED_AT_LEAST_ONE_STATE)
5*/
6public int DeleteRobotRealtimeState(RobotState state)

15.4. Modificare Solo il Periodo di Aggiornamento del Feedback di Stato

1 /**
2* @brief Modifica solo il periodo di aggiornamento del feedback di stato senza modificare la lista degli stati
3* @param [in] period Nuovo periodo di aggiornamento, unità millisecondi, intervallo di valori [8, 1000]
4* @return Restituisce 0 in caso di successo; restituisce un codice di errore negativo in caso di fallimento (es. ERR_PARAM_VALUE)
5*/
6public int SetRobotRealtimeStatePeriod(int period)

15.5. Ottenere la Lista di Feedback di Stato e il Periodo di Aggiornamento Correntemente Configurati

1/**
2* @brief Ottiene la lista di feedback di stato e il periodo di aggiornamento correntemente configurati
3* @param [out] states Restituisce la lista di enum di stato attualmente sottoscritti
4* @param [out] period Restituisce il periodo di aggiornamento dati corrente, unità millisecondi
5* @return Restituisce 0 in caso di successo; restituisce un codice di errore negativo in caso di fallimento
6*/
7public int GetRobotRealtimeStateConfig(out List<RobotState> states, out int period)

15.6. Esempio di Codice SDK Relativo alla Configurazione CNDE

 1private async void TestRobotRealtimeStates()
 2{
 3    // 1. Definire i campi di stato a cui sottoscriversi
 4    List<RobotState> requiredStates = new List<RobotState>
 5    {
 6        RobotState.JointCurPos,
 7        RobotState.ToolCurPos,
 8        RobotState.JointDriverTemperature,
 9        RobotState.RobotTime,
10    };
11
12    // 2. Configurare il feedback di stato (periodo 8ms)
13    int periodMs = 8;
14    int ret = robot.SetRobotRealtimeStateConfig(requiredStates, periodMs);
15    if (ret != 0)
16    {
17        Console.WriteLine($"Configurazione stato fallita, codice errore: {ret}");
18        return;
19    }
20    Console.WriteLine($"Configurazione stato riuscita, {requiredStates.Count} campi, periodo {periodMs} ms");
21
22    // Verificare se la configurazione è efficace
23    List<RobotState> actualStates;
24    int actualPeriod;
25    robot.GetRobotRealtimeStateConfig(out actualStates, out actualPeriod);
26    Console.WriteLine($"Numero di stati effettivamente attivi: {actualStates.Count}, periodo: {actualPeriod} ms");
27    Thread.Sleep(3000);
28    // 3. Stabilire la connessione RPC (internamente completa automaticamente l'handshake CNDE)
29    robot.SetReconnectParam(true, 10, 1000);
30    ret = robot.RPC("192.168.58.2");  // Modificare secondo l'IP effettivo del robot
31    if (ret != 0)
32    {
33        Console.WriteLine($"Connessione RPC fallita, codice errore: {ret}");
34        return;
35    }
36    // 4. Ciclo per leggere e stampare i dati di stato
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        //Posizioni dei giunti (gradi)
47        if (pkg.jt_cur_pos != null && pkg.jt_cur_pos.Length >= 6)
48            Console.WriteLine($"Posizioni giunti(°): 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        //Posa TCP (mm /°)
51        if (pkg.tl_cur_pos != null && pkg.tl_cur_pos.Length >= 6)
52            Console.WriteLine($"Posa TCP(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        // Temperature dei giunti
55        if (pkg.jointDriverTemperature != null && pkg.jointDriverTemperature.Length >= 6)
56            Console.WriteLine($"Temperature giunti(°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        // Ora del robot
59        Console.WriteLine($"Ora robot: {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. Disconnettere
65    robot.CloseRPC();
66}

15.7. Esempio di Codice SDK per Aggiunta/Eliminazione di Stato CNDE e Impostazione del Periodo di Comunicazione

 1private async void TestAddDeleteCNDE()
 2{
 3    List<RobotState> finalStates;
 4    int finalPeriod;
 5    // Configurazione iniziale: non richiedere alcuno stato (configurazione predefinita)
 6    List<RobotState> emptyStates = new List<RobotState>();
 7    int ret = robot.SetRobotRealtimeStateConfig(emptyStates, 20);
 8
 9    robot.SetRobotRealtimeStatePeriod(10);
10    // Eliminare due stati
11    ret = robot.DeleteRobotRealtimeState(RobotState.JointCurPos);
12    Console.WriteLine($"Eliminazione JointCurPos risultato: {ret}");
13    ret = robot.DeleteRobotRealtimeState(RobotState.ToolCurPos);
14    Console.WriteLine($"Eliminazione ToolCurPos risultato: {ret}");
15    // Aggiungere uno stato
16    ret = robot.AddRobotRealtimeState(RobotState.CollisionLevel);
17    Console.WriteLine($"Aggiunta CollisionLevel risultato: {ret}");
18
19    // Ottenere la lista di configurazione corrente e reinviare
20    List<RobotState> currentStates;
21    int currentPeriod;
22    robot.GetRobotRealtimeStateConfig(out currentStates, out currentPeriod);
23    Console.WriteLine($"Numero di stati di configurazione corrente: {currentStates.Count}");
24    ret = robot.SetRobotRealtimeStateConfig(currentStates, currentPeriod);
25    Console.WriteLine($"Applicazione nuova configurazione risultato: {ret}"); Console.WriteLine($"Configurazione iniziale risultato: {ret}");
26    robot.GetRobotRealtimeStateConfig(out finalStates, out finalPeriod);
27    Console.WriteLine($"Numero di stati di configurazione: {finalStates.Count}");
28    foreach (var s in finalStates) Console.WriteLine($"  {s}");
29    Console.WriteLine($"Periodo: {finalPeriod} ms");
30
31    Thread.Sleep(1000);
32    // Stabilire la connessione RPC (internamente si connette automaticamente al CNDE)
33    robot.SetReconnectParam(true, 100, 1000);
34    ret = robot.RPC("192.168.58.2");
35    if (ret != 0)
36    {
37        Console.WriteLine($"Connessione RPC fallita: {ret}");
38        return;
39    }
40
41    // Ciclo per stampare gli stati eliminati e aggiunti, gli stati eliminati vengono stampati come 0, gli stati aggiunti possono ottenere valori in tempo reale normalmente
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($"  Posizioni giunti(°): 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($"  Posa TCP(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        // Livello di collisione
63        if (pkg.collisionLevel != null && pkg.collisionLevel.Length >= 6)
64            Console.WriteLine($"Livello collisione: 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    //Disconnettere
69    robot.CloseRPC();
70    Console.WriteLine("Test completato.");
71}