5. I/O del robot

5.1. Imposta uscita digitale del cabinet di controllo

/**
* @brief  Imposta uscita digitale del cabinet di controllo
* @param  [in] id  Numero io, intervallo [0~15]
* @param  [in] status 0-Spento, 1-Acceso
* @param  [in] smooth 0-Non smooth, 1-Smooth
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @return  Codice di errore
*/
int SetDO(int id, byte status, byte smooth, byte block);

5.2. Imposta uscita digitale dell’utensile

/**
* @brief  Imposta uscita digitale dell'utensile
* @param  [in] id  Numero io, intervallo [0~1]
* @param  [in] status 0-Spento, 1-Acceso
* @param  [in] smooth 0-Non smooth, 1-Smooth
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @return  Codice di errore
*/
int SetToolDO(int id, byte status, byte smooth, byte block);

5.3. Imposta uscita analogica del cabinet di controllo

/**
* @brief  Imposta uscita analogica del cabinet di controllo
* @param  [in] id  Numero io, intervallo [0~1]
* @param  [in] value Percentuale valore corrente o tensione, intervallo [0~100] corrispondente a corrente [0~20mA] o tensione [0~10V]
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @return  Codice di errore
*/
int SetAO(int id, float value, byte block);

5.4. Imposta uscita analogica dell’utensile

/**
* @brief  Imposta uscita analogica dell'utensile
* @param  [in] id  Numero io, intervallo [0]
* @param  [in] value Percentuale valore corrente o tensione, intervallo [0~100] corrispondente a corrente [0~20mA] o tensione [0~10V]
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @return  Codice di errore
*/
int SetToolAO(int id, float value, byte block);

5.5. Esempio di codice per impostare uscite digitali e analogiche

private void button14_Click(object sender, EventArgs e)
{
    byte status = 1;
    byte smooth = 0;
    byte block = 0;
    byte di = 0, tool_di = 0;
    float ai = 0.0f, tool_ai = 0.0f;
    float value = 0.0f;


    for (int i = 0; i < 16; i++)
    {
        robot.SetDO(i, status, smooth, block);
        Thread.Sleep(300);
    }

    status = 0;

    for (int i = 0; i < 16; i++)
    {
        robot.SetDO(i, status, smooth, block);
        Thread.Sleep(300);
    }

    status = 1;

    for (int i = 0; i < 2; i++)
    {
        robot.SetToolDO(i, status, smooth, block);
        Thread.Sleep(1000);
    }

    status = 0;

    for (int i = 0; i < 2; i++)
    {
        robot.SetToolDO(i, status, smooth, block);
        Thread.Sleep(1000);
    }

    for (int i = 0; i < 100; i++)
    {
        robot.SetAO(0, i, block);
        Thread.Sleep(30);
    }

    for (int i = 0; i < 100; i++)
    {
        robot.SetToolAO(0, i, block);
        Thread.Sleep(30);
    }

}

5.6. Ottieni ingresso digitale del cabinet di controllo

/**
* @brief  Ottieni ingresso digitale del cabinet di controllo
* @param  [in] id  Numero io, intervallo [0~15]
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @param  [out] result  0-Basso livello, 1-Alto livello
* @return  Codice di errore
*/
int GetDI(int id, byte block, ref byte level);

5.7. Ottieni ingresso digitale dell’utensile

/**
* @brief  Ottieni ingresso digitale dell'utensile
* @param  [in] id  Numero io, intervallo [0~1]
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @param  [out] result  0-Basso livello, 1-Alto livello
* @return  Codice di errore
*/
int GetToolDI(int id, byte block, ref byte level);

5.8. Ottieni ingresso analogico del cabinet di controllo

/**
* @brief  Ottieni ingresso analogico del cabinet di controllo
* @param  [in] id  Numero io, intervallo [0~1]
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @param  [out] result  Percentuale valore corrente o tensione in ingresso, intervallo [0~100] corrispondente a corrente [0~20mS] o tensione [0~10V]
* @return  Codice di errore
*/
int GetAI(int id, byte block, ref float persent);

5.9. Ottieni ingresso analogico dell’utensile

/**
* @brief  Ottieni ingresso analogico dell'utensile
* @param  [in] id  Numero io, intervallo [0]
* @param  [in] block  0-Bloccante, 1-Non bloccante
* @param  [out] result  Percentuale valore corrente o tensione in ingresso, intervallo [0~100] corrispondente a corrente [0~20mS] o tensione [0~10V]
* @return  Codice di errore
*/
int GetToolAI(int id, byte block, ref float persent);

5.10. Ottieni lo stato del pulsante di registrazione all’estremità del robot

/**
* @brief Ottieni lo stato del pulsante di registrazione all'estremità del robot
* @param [out] state Stato pulsante, 0-Premuto, 1-Rilasciato
* @return Codice di errore
*/
int GetAxlePointRecordBtnState(ref byte state);

5.11. Ottieni lo stato delle uscite DO all’estremità del robot

/**
* @brief Ottieni lo stato delle uscite DO all'estremità del robot
* @param [out] do_state Stato uscite DO, do0~do1 corrisponde a bit1~bit2, a partire da bit0
* @return Codice di errore
*/
int GetToolDO(ref byte do_state);

5.12. Ottieni lo stato delle uscite DO del controller del robot

/**
* @brief Ottieni lo stato delle uscite DO del controller del robot
* @param [out] do_state_h Stato uscite DO, co0~co7 corrisponde a bit0~bit7
* @param [out] do_state_l Stato uscite DO, do0~do7 corrisponde a bit0~bit7
* @return Codice di errore
*/
int GetDO(ref int do_state_h, ref int do_state_l);

5.13. Esempio di codice per ottenere lo stato DI, DO del robot

private void button15_Click(object sender, EventArgs e)
{
    byte status = 1;
    byte smooth = 0;
    byte block = 0;
    byte di = 0, tool_di = 0;
    float ai = 0.0f, tool_ai = 0.0f;
    float value = 0.0f;

    robot.GetDI(0, block, ref di);
    Console.WriteLine($"di0: {di}");

    tool_di = (byte)robot.GetToolDI(1, block, ref tool_di);
    Console.WriteLine($"tool_di1: {tool_di}");

    robot.GetAI(0, block, ref ai);
    Console.WriteLine($"ai0: {ai}");

    tool_ai = robot.GetToolAI(0, block, ref tool_ai);
    Console.WriteLine($"tool_ai0: {tool_ai}");

    byte _button_state = 0;
    robot.GetAxlePointRecordBtnState(ref _button_state);
    Console.WriteLine($"_button_state is: {_button_state}");

    byte tool_do_state = 0;
    robot.GetToolDO(ref tool_do_state);
    Console.WriteLine($"tool DO state is: {tool_do_state}");

    int do_state_h = 0;
    int do_state_l = 0;
    robot.GetDO(ref do_state_h, ref do_state_l);
    Console.WriteLine($"DO state high is: {do_state_h}\n DO state low is: {do_state_l}");
}

5.14. Attendi ingresso digitale del cabinet di controllo

/**
* @brief Attendi ingresso digitale del cabinet di controllo
* @param  [in] id  Numero io, intervallo [0~15]
* @param  [in]  status 0-Spento, 1-Acceso
* @param  [in]  max_time  Tempo di attesa massimo, unità ms
* @param  [in]  opt  Strategia dopo timeout, 0-Arresta programma e indica timeout, 1-Ignora indicazione timeout e continua esecuzione programma, 2-Aspetta indefinitamente
* @return  Codice di errore
*/
int WaitDI(int id, byte status, int max_time, int opt);

5.15. Attendi ingressi digitali multipli del cabinet di controllo

/**
* @brief Attendi ingressi digitali multipli del cabinet di controllo
* @param  [in] mode 0-AND multipli, 1-OR multipli
* @param  [in] id  Numero io, bit0~bit7 corrisponde a DI0~DI7, bit8~bit15 corrisponde a CI0~CI7
* @param  [in]  status 0-Spento, 1-Acceso
* @param  [in]  max_time  Tempo di attesa massimo, unità ms
* @param  [in]  opt  Strategia dopo timeout, 0-Arresta programma e indica timeout, 1-Ignora indicazione timeout e continua esecuzione programma, 2-Aspetta indefinitamente
* @return  Codice di errore
*/
int WaitMultiDI(int mode, int id, byte status, int max_time, int opt);

5.16. Attendi ingresso digitale dell’utensile

/**
* @brief Attendi ingresso digitale dell'utensile
* @param  [in] id  Numero io, intervallo [0~1]
* @param  [in]  status 0-Spento, 1-Acceso
* @param  [in]  max_time  Tempo di attesa massimo, unità ms
* @param  [in]  opt  Strategia dopo timeout, 0-Arresta programma e indica timeout, 1-Ignora indicazione timeout e continua esecuzione programma, 2-Aspetta indefinitamente
* @return  Codice di errore
*/
int WaitToolDI(int id, byte status, int max_time, int opt);

5.17. Attendi ingresso analogico del cabinet di controllo

/**
* @brief Attendi ingresso analogico del cabinet di controllo
* @param  [in] id  Numero io, intervallo [0~1]
* @param  [in]  sign 0-Maggiore di, 1-Minore di
* @param  [in]  value Percentuale valore corrente o tensione in ingresso, intervallo [0~100] corrispondente a corrente [0~20mS] o tensione [0~10V]
* @param  [in]  max_time  Tempo di attesa massimo, unità ms
* @param  [in]  opt  Strategia dopo timeout, 0-Arresta programma e indica timeout, 1-Ignora indicazione timeout e continua esecuzione programma, 2-Aspetta indefinitamente
* @return  Codice di errore
*/
int WaitAI(int id, int sign, float value, int max_time, int opt);

5.18. Attendi ingresso analogico dell’utensile

/**
* @brief Attendi ingresso analogico dell'utensile
* @param  [in] id  Numero io, intervallo [0]
* @param  [in]  sign 0-Maggiore di, 1-Minore di
* @param  [in]  value Percentuale valore corrente o tensione in ingresso, intervallo [0~100] corrispondente a corrente [0~20mS] o tensione [0~10V]
* @param  [in]  max_time  Tempo di attesa massimo, unità ms
* @param  [in]  opt  Strategia dopo timeout, 0-Arresta programma e indica timeout, 1-Ignora indicazione timeout e continua esecuzione programma, 2-Aspetta indefinitamente
* @return  Codice di errore
*/
int WaitToolAI(int id, int sign, float value, int max_time, int opt);

5.19. Esempio di codice per attendere segnali di ingresso digitali e analogici del cabinet di controllo

private void btnIOTest_Click(object sender, EventArgs e)
{
    byte status = 1;
    byte smooth = 0;
    byte block = 0;
    byte di = 0, tool_di = 0;
    float ai = 0.0f, tool_ai = 0.0f;
    float value = 0.0f;

    int rtn = robot.WaitDI(0, 1, 1000, 1);
    Console.WriteLine("WaitDI over; rtn is: " + rtn);

    robot.WaitMultiDI(1, 3, 3, 1000, 1);
    Console.WriteLine("WaitMultiDI over; rtn is: " + rtn);

    robot.WaitToolDI(1, 1, 1000, 1);
    Console.WriteLine("WaitToolDI over; rtn is: " + rtn);

    robot.WaitAI(0, 0, 50, 1000, 1);
    Console.WriteLine("WaitAI over; rtn is: " + rtn);

    robot.WaitToolAI(0, 0, 50, 1000, 1);
    Console.WriteLine("WaitToolAI over; rtn is: " + rtn);
}

5.20. Imposta se resettare le uscite DO del cabinet di controllo dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite DO del cabinet di controllo dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetCtlBoxDO(int resetFlag);

5.21. Imposta se resettare le uscite AO del cabinet di controllo dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite AO del cabinet di controllo dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetCtlBoxAO(int resetFlag);

5.22. Imposta se resettare le uscite DO dell’utensile all’estremità dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite DO dell'utensile all'estremità dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetAxleDO(int resetFlag);

5.23. Imposta se resettare le uscite AO dell’utensile all’estremità dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite AO dell'utensile all'estremità dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetAxleAO(int resetFlag);

5.24. Imposta se resettare le uscite DO estese dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite DO estese dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetExtDO(int resetFlag);

5.25. Imposta se resettare le uscite AO estese dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite AO estese dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetExtAO(int resetFlag);

5.26. Imposta se resettare le uscite SmartTool dopo arresto/pausa

/**
* @brief  Imposta se resettare le uscite SmartTool dopo arresto/pausa
* @param  [in] resetFlag  0-Non resettare; 1-Resetta
* @return  Codice di errore
*/
int SetOutputResetSmartToolDO(int resetFlag);

5.27. Esempio di codice per impostare il reset delle uscite dopo arresto/pausa del programma LUA

private void button17_Click(object sender, EventArgs e)
{
    for (int i = 0; i < 16; i++)
    {
        robot.SetDO(i, 1, 0, 0);
        Thread.Sleep(300);
    }
    int resetFlag = 1;
    int rtn = robot.SetOutputResetCtlBoxDO(resetFlag);
    robot.SetOutputResetCtlBoxAO(resetFlag);
    robot.SetOutputResetAxleDO(resetFlag);
    robot.SetOutputResetAxleAO(resetFlag);
    robot.SetOutputResetExtDO(resetFlag);
    robot.SetOutputResetExtAO(resetFlag);
    robot.SetOutputResetSmartToolDO(resetFlag);
    robot.ProgramLoad("/fruser/Text1.lua");
    robot.ProgramRun();
}