5. Roboter-I/O

5.1. Digitalausgang des Steuerkastens setzen

1/**
2* @brief Digitalausgang des Steuerkastens setzen
3* @param [in] id IO-Nummer, Bereich [0~15]
4* @param [in] status 0-aus, 1-ein
5* @param [in] smooth 0-nicht glätten, 1-glätten
6* @param [in] block 0-blockierend, 1-nicht blockierend
7* @return Fehlercode
8*/
9int SetDO(int id, byte status, byte smooth, byte block);

5.2. Digitalausgang des Werkzeugs setzen

1/**
2* @brief Digitalausgang des Werkzeugs setzen
3* @param [in] id IO-Nummer, Bereich [0~1]
4* @param [in] status 0-aus, 1-ein
5* @param [in] smooth 0-nicht glätten, 1-glätten
6* @param [in] block 0-blockierend, 1-nicht blockierend
7* @return Fehlercode
8*/
9int SetToolDO(int id, byte status, byte smooth, byte block);

5.3. Analogausgang des Steuerkastens setzen

1/**
2* @brief Analogausgang des Steuerkastens setzen
3* @param [in] id IO-Nummer, Bereich [0~1]
4* @param [in] value Prozentwert des Stroms oder der Spannung, Bereich [0~100] entspricht [0~20mA] oder [0~10V]
5* @param [in] block 0-blockierend, 1-nicht blockierend
6* @return Fehlercode
7*/
8int SetAO(int id, float value, byte block);

5.4. Analogausgang des Werkzeugs setzen

1/**
2* @brief Analogausgang des Werkzeugs setzen
3* @param [in] id IO-Nummer, Bereich [0]
4* @param [in] value Prozentwert des Stroms oder der Spannung, Bereich [0~100] entspricht [0~20mA] oder [0~10V]
5* @param [in] block 0-blockierend, 1-nicht blockierend
6* @return Fehlercode
7*/
8int SetToolAO(int id, float value, byte block);

5.5. Codebeispiel zum Setzen von Digital- und Analogausgängen

 1private void button14_Click(object sender, EventArgs e)
 2{
 3    byte status = 1;
 4    byte smooth = 0;
 5    byte block = 0;
 6    byte di = 0, tool_di = 0;
 7    float ai = 0.0f, tool_ai = 0.0f;
 8    float value = 0.0f;
 9
10    for (int i = 0; i < 16; i++)
11    {
12        robot.SetDO(i, status, smooth, block);
13        Thread.Sleep(300);
14    }
15
16    status = 0;
17
18    for (int i = 0; i < 16; i++)
19    {
20        robot.SetDO(i, status, smooth, block);
21        Thread.Sleep(300);
22    }
23
24    status = 1;
25
26    for (int i = 0; i < 2; i++)
27    {
28        robot.SetToolDO(i, status, smooth, block);
29        Thread.Sleep(1000);
30    }
31
32    status = 0;
33
34    for (int i = 0; i < 2; i++)
35    {
36        robot.SetToolDO(i, status, smooth, block);
37        Thread.Sleep(1000);
38    }
39
40    for (int i = 0; i < 100; i++)
41    {
42        robot.SetAO(0, i, block);
43        Thread.Sleep(30);
44    }
45
46    for (int i = 0; i < 100; i++)
47    {
48        robot.SetToolAO(0, i, block);
49        Thread.Sleep(30);
50    }
51}

5.6. Digitaleingang des Steuerkastens abrufen

1/**
2* @brief Digitaleingang des Steuerkastens abrufen
3* @param [in] id IO-Nummer, Bereich [0~15]
4* @param [in] block 0-blockierend, 1-nicht blockierend
5* @param [out] level 0-niedriger Pegel, 1-hoher Pegel
6* @return Fehlercode
7*/
8int GetDI(int id, byte block, ref byte level);

5.7. Digitaleingang des Werkzeugs abrufen

1/**
2* @brief Digitaleingang des Werkzeugs abrufen
3* @param [in] id IO-Nummer, Bereich [0~1]
4* @param [in] block 0-blockierend, 1-nicht blockierend
5* @param [out] level 0-niedriger Pegel, 1-hoher Pegel
6* @return Fehlercode
7*/
8int GetToolDI(int id, byte block, ref byte level);

5.8. Analogeingang des Steuerkastens abrufen

1/**
2* @brief Analogeingang des Steuerkastens abrufen
3* @param [in] id IO-Nummer, Bereich [0~1]
4* @param [in] block 0-blockierend, 1-nicht blockierend
5* @param [out] percent Prozentwert des Eingangsstroms oder der -spannung, Bereich [0~100] entspricht [0~20mA] oder [0~10V]
6* @return Fehlercode
7*/
8int GetAI(int id, byte block, ref float percent);

5.9. Analogeingang des Werkzeugs abrufen

1/**
2* @brief Analogeingang des Werkzeugs abrufen
3* @param [in] id IO-Nummer, Bereich [0]
4* @param [in] block 0-blockierend, 1-nicht blockierend
5* @param [out] percent Prozentwert des Eingangsstroms oder der -spannung, Bereich [0~100] entspricht [0~20mA] oder [0~10V]
6* @return Fehlercode
7*/
8int GetToolAI(int id, byte block, ref float percent);

5.10. Status der Aufnahmetaste am Roboterende abrufen

1/**
2* @brief Status der Aufnahmetaste am Roboterende abrufen
3* @param [out] state Tastenstatus, 0-gedrückt, 1-losgelassen
4* @return Fehlercode
5*/
6int GetAxlePointRecordBtnState(ref byte state);

5.11. Ausgangszustand des Werkzeug-DO abrufen

1/**
2* @brief Ausgangszustand des Werkzeug-DO abrufen
3* @param [out] do_state DO-Ausgangszustand, do0~do1 entsprechen Bit1~Bit2, beginnend bei Bit0
4* @return Fehlercode
5*/
6int GetToolDO(ref byte do_state);

5.12. Ausgangszustand des Robotercontroller-DO abrufen

1/**
2* @brief Ausgangszustand des Robotercontroller-DO abrufen
3* @param [out] do_state_h DO-Ausgangszustand, co0~co7 entsprechen Bit0~Bit7
4* @param [out] do_state_l DO-Ausgangszustand, do0~do7 entsprechen Bit0~Bit7
5* @return Fehlercode
6*/
7int GetDO(ref int do_state_h, ref int do_state_l);

5.13. Codebeispiel zum Abrufen von DI- und DO-Status

 1private void button15_Click(object sender, EventArgs e)
 2{
 3    byte status = 1;
 4    byte smooth = 0;
 5    byte block = 0;
 6    byte di = 0, tool_di = 0;
 7    float ai = 0.0f, tool_ai = 0.0f;
 8    float value = 0.0f;
 9
10    robot.GetDI(0, block, ref di);
11    Console.WriteLine($"di0: {di}");
12
13    tool_di = (byte)robot.GetToolDI(1, block, ref tool_di);
14    Console.WriteLine($"tool_di1: {tool_di}");
15
16    robot.GetAI(0, block, ref ai);
17    Console.WriteLine($"ai0: {ai}");
18
19    tool_ai = robot.GetToolAI(0, block, ref tool_ai);
20    Console.WriteLine($"tool_ai0: {tool_ai}");
21
22    byte _button_state = 0;
23    robot.GetAxlePointRecordBtnState(ref _button_state);
24    Console.WriteLine($"_button_state is: {_button_state}");
25
26    byte tool_do_state = 0;
27    robot.GetToolDO(ref tool_do_state);
28    Console.WriteLine($"tool DO state is: {tool_do_state}");
29
30    int do_state_h = 0;
31    int do_state_l = 0;
32    robot.GetDO(ref do_state_h, ref do_state_l);
33    Console.WriteLine($"DO state high is: {do_state_h}\n DO state low is: {do_state_l}");
34}

5.14. Auf Digitaleingang des Steuerkastens warten

1/**
2* @brief Auf Digitaleingang des Steuerkastens warten
3* @param [in] id IO-Nummer, Bereich [0~15]
4* @param [in] status 0-aus, 1-ein
5* @param [in] max_time Maximale Wartezeit [ms]
6* @param [in] opt Strategie bei Timeout: 0-Programm stoppen und Timeout melden, 1-Timeout ignorieren und Programm fortsetzen, 2-unbegrenzt warten
7* @return Fehlercode
8*/
9int WaitDI(int id, byte status, int max_time, int opt);

5.15. Auf mehrere Digitaleingänge des Steuerkastens warten

 1/**
 2* @brief Auf mehrere Digitaleingänge des Steuerkastens warten
 3* @param [in] mode 0-UND-Verknüpfung, 1-ODER-Verknüpfung
 4* @param [in] id IO-Nummern als Bitmaske: Bit0~Bit7 für DI0~DI7, Bit8~Bit15 für CI0~CI7
 5* @param [in] status 0-aus, 1-ein
 6* @param [in] max_time Maximale Wartezeit [ms]
 7* @param [in] opt Strategie bei Timeout: 0-Programm stoppen und Timeout melden, 1-Timeout ignorieren und Programm fortsetzen, 2-unbegrenzt warten
 8* @return Fehlercode
 9*/
10int WaitMultiDI(int mode, int id, byte status, int max_time, int opt);

5.16. Auf Digitaleingang des Werkzeugs warten

1/**
2* @brief Auf Digitaleingang des Werkzeugs warten
3* @param [in] id IO-Nummer, Bereich [0~1]
4* @param [in] status 0-aus, 1-ein
5* @param [in] max_time Maximale Wartezeit [ms]
6* @param [in] opt Strategie bei Timeout: 0-Programm stoppen und Timeout melden, 1-Timeout ignorieren und Programm fortsetzen, 2-unbegrenzt warten
7* @return Fehlercode
8*/
9int WaitToolDI(int id, byte status, int max_time, int opt);

5.17. Auf Analogeingang des Steuerkastens warten

 1/**
 2* @brief Auf Analogeingang des Steuerkastens warten
 3* @param [in] id IO-Nummer, Bereich [0~1]
 4* @param [in] sign 0-größer als, 1-kleiner als
 5* @param [in] value Prozentwert des Eingangsstroms oder der -spannung, Bereich [0~100] entspricht [0~20mA] oder [0~10V]
 6* @param [in] max_time Maximale Wartezeit [ms]
 7* @param [in] opt Strategie bei Timeout: 0-Programm stoppen und Timeout melden, 1-Timeout ignorieren und Programm fortsetzen, 2-unbegrenzt warten
 8* @return Fehlercode
 9*/
10int WaitAI(int id, int sign, float value, int max_time, int opt);

5.18. Auf Analogeingang des Werkzeugs warten

 1/**
 2* @brief Auf Analogeingang des Werkzeugs warten
 3* @param [in] id IO-Nummer, Bereich [0]
 4* @param [in] sign 0-größer als, 1-kleiner als
 5* @param [in] value Prozentwert des Eingangsstroms oder der -spannung, Bereich [0~100] entspricht [0~20mA] oder [0~10V]
 6* @param [in] max_time Maximale Wartezeit [ms]
 7* @param [in] opt Strategie bei Timeout: 0-Programm stoppen und Timeout melden, 1-Timeout ignorieren und Programm fortsetzen, 2-unbegrenzt warten
 8* @return Fehlercode
 9*/
10int WaitToolAI(int id, int sign, float value, int max_time, int opt);

5.19. Codebeispiel zum Warten auf digitale und analoge Eingangssignale

 1private void btnIOTest_Click(object sender, EventArgs e)
 2{
 3    byte status = 1;
 4    byte smooth = 0;
 5    byte block = 0;
 6    byte di = 0, tool_di = 0;
 7    float ai = 0.0f, tool_ai = 0.0f;
 8    float value = 0.0f;
 9
10    int rtn = robot.WaitDI(0, 1, 1000, 1);
11    Console.WriteLine("WaitDI beendet; rtn is: " + rtn);
12
13    robot.WaitMultiDI(1, 3, 3, 1000, 1);
14    Console.WriteLine("WaitMultiDI beendet; rtn is: " + rtn);
15
16    robot.WaitToolDI(1, 1, 1000, 1);
17    Console.WriteLine("WaitToolDI beendet; rtn is: " + rtn);
18
19    robot.WaitAI(0, 0, 50, 1000, 1);
20    Console.WriteLine("WaitAI beendet; rtn is: " + rtn);
21
22    robot.WaitToolAI(0, 0, 50, 1000, 1);
23    Console.WriteLine("WaitToolAI beendet; rtn is: " + rtn);
24}

5.20. Festlegen, ob der Steuerkasten-DO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der Steuerkasten-DO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetCtlBoxDO(int resetFlag, int reloadFlag);

5.21. Festlegen, ob der Steuerkasten-AO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der Steuerkasten-AO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetCtlBoxAO(int resetFlag, int reloadFlag);

5.22. Festlegen, ob der Werkzeug-DO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der Werkzeug-DO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetAxleDO(int resetFlag, int reloadFlag);

5.23. Festlegen, ob der Werkzeug-AO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der Werkzeug-AO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetAxleAO(int resetFlag, int reloadFlag);

5.24. Festlegen, ob der erweiterte DO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der erweiterte DO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetExtDO(int resetFlag, int reloadFlag);

5.25. Festlegen, ob der erweiterte AO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der erweiterte AO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetExtAO(int resetFlag, int reloadFlag);

5.26. Festlegen, ob der SmartTool-DO nach Stopp/Pause zurückgesetzt wird

1/**
2* @brief Festlegen, ob der SmartTool-DO nach Stopp/Pause zurückgesetzt wird
3* @param [in] resetFlag 0-nicht zurücksetzen, 1-zurücksetzen
4* @param [in] reloadFlag Ob nach Pausenfortsetzung neu geladen wird: 0-nicht laden, 1-laden
5* @return Fehlercode
6*/
7public int SetOutputResetSmartToolDO(int resetFlag, int reloadFlag);

5.27. Codebeispiel zum Festlegen des Ausgangs-Rücksetzverhaltens nach Stopp/Pause für LUA-Programme

 1public void TestDOReset()
 2{
 3    ROBOT_STATE_PKG pkg = new ROBOT_STATE_PKG();
 4
 5    for (int i = 0; i < 16; i++)
 6    {
 7        robot.SetDO(i, 1, 0, 0);
 8        Thread.Sleep(200);
 9    }
10
11    int resetFlag = 1;
12    int resumeReloadFlag = 1;
13    int rtn = robot.SetOutputResetCtlBoxDO(resetFlag, resumeReloadFlag);
14    robot.SetOutputResetCtlBoxAO(resetFlag, resumeReloadFlag);
15    robot.SetOutputResetAxleDO(resetFlag, resumeReloadFlag);
16    robot.SetOutputResetAxleAO(resetFlag, resumeReloadFlag);
17    robot.SetOutputResetExtDO(resetFlag, resumeReloadFlag);
18    robot.SetOutputResetExtAO(resetFlag, resumeReloadFlag);
19    robot.SetOutputResetSmartToolDO(resetFlag, resumeReloadFlag);
20
21    robot.ProgramLoad("/fruser/test.lua");
22    robot.ProgramRun();
23
24    Thread.Sleep(2000);
25    robot.PauseMotion();
26    Thread.Sleep(2000);
27    robot.ResumeMotion();
28    Thread.Sleep(2000);
29}