TimeSlice code Revision 1.

0b 7/7/09 ArduinoAndy

Un controlador lógico programable (PLC) controla la maquinaria en una secuencia o exploración

cronometrada precisa.
Recreé un pequeño shell de intervalo de tiempo que se ejecuta en Audrino y que imita a un PLC.
(Mi aplicación de usuario para este código de tiempo era monitorear y controlar una red serial)

Usar el bucle de función principal de Arduino () {} está bien para la mayoría de los propósitos prácticos,
pero si necesita controlar
dispositivos y entradas / salidas en un "intervalo de tiempo fijo" más rígido, entonces el siguiente código
de intervalo de tiempo podría ayudar.
El uso de la función millis () de Arduino facilita la creación de un shell de intervalo de tiempo simple para
aplicaciones de control
en el Arduino.

Con el código de intervalo de tiempo de Arduino puede hacer lo siguiente:

# 1 Ejecute cualquier número de tareas / funciones a intervalos regulares (por ejemplo, cada 20 ms./100
ms./500 ms por escaneo / bucle)
# 2 Puede elegir la frecuencia de ejecución de cada tarea cambiando el tiempo entre intervalos de
tiempo.
# 3 Puedes elegir el orden de ejecución teniendo las funciones más importantes en la primera tarea.

El código de intervalo de tiempo tiene 3 clases de intervalo de tiempo. TimeClass1 (20 ms.), TimeClass2
(100 ms.) Y TimeClass3 (500 ms.)
Las tres clases de tiempo son ajustables por el usuario. Cuando se inicia el programa, todos los "códigos
de usuario" a 20 ms. se ejecuta primero luego
código de usuario a 100 ms. y por último el código de usuario a 500 ms. es ejecutado.
Si el código dentro de cada clase de tiempo sobrepasa un intervalo de tiempo fijo, se produce un error
de sobrecarga y el programa se aborta.
Esto evita que las funciones y entradas / salidas externas se ejecuten de forma aleatoria en lugar de una
secuencia de control. No se recomienda usar retrasos en el código de usuario porque bloquea toda la
ejecución del código hasta
el retraso se completa. Depende del usuario construir su código para que se ejecute dentro del intervalo
de tiempo o la clase de tiempo
en el que está instalado.

Sugerencias / consejos para usar el código Timeslice:

Ponga el código "más rápido" en TimeClass 1 (20 ms.) - código que se ejecutará a 20 ms.
Ponga otro código de usuario "Medio" en TimeClass 2 (100 ms.)
Ponga otro código de usuario "más lento" en TimeClass 3 (500 ms.)
No ponga ningún retraso () en el código de usuario de la clase de tiempo. Esto podría crear un
desbordamiento de la clase de tiempo y la detención del programa.
(El desbordamiento de TimeClass es demasiado "tiempo real" para la ejecución de la tarea. No coloque
30 ms. De código en los 20 ms.
timeclass: esto provocará un desbordamiento de la clase de tiempo)
Conecte todos los LED de diagnóstico para facilitar la resolución de problemas. Hay tres LED para indicar
cada ejecución del código de clase de tiempo
y errores de saturación.
*/

//Timeslice global variables

unsigned long TimeSlice_TC1_Interval = 20;
unsigned long TimeSlice_TC2_Interval = 100;
unsigned long TimeSlice_TC3_Interval = 500;

unsigned long TimeSlice_TC1_Start_Time;

unsigned long TimeSlice_TC2_Start_Time;
unsigned long TimeSlice_TC3_Start_Time;

void loop()
{

//----------------------------------------------------------TimeSlice code---------
--------------------------------------------------
while(1){
//-------------------
//Timeclass 1 20 ms
//-------------------
TimeSlice_TC1_Start_Time = millis();

// ---------------------------------------------------------User application code

// ---------------------------------------------------------End of user application

code
// Toggle TC1 LED
toggle_LED(1);
// check timeout
if (((millis() - TimeSlice_TC1_Start_Time) > TimeSlice_TC1_Interval)) // 20 ms
{
while(1){
over_run_Fault(1); // abort program and loop forever and flash Time class 1
LED
}
}
else
{
while (((millis() - TimeSlice_TC1_Start_Time) <= TimeSlice_TC1_Interval)){ //
remove to save MIPS but it removes precise timeclass execution
}
}

//-------------------
//Timeclass 2 100 ms
//-------------------
TimeSlice_TC2_Start_Time = millis();
// ----------------------------------------------------------User application code

// ----------------------------------------------------------End of user
application code
// Toggle TC2 LED
toggle_LED(2);

if (((millis() - TimeSlice_TC2_Start_Time) > TimeSlice_TC2_Interval)) // 100 ms

{
while(1){
over_run_Fault(2); // abort program and loop forever flash Time class 2 LED
}
}
else
{
while (((millis() - TimeSlice_TC2_Start_Time) <= TimeSlice_TC2_Interval)){ //
remove to save MIPS but it removes precise timeclass execution
}
}

//------------------
//Timeclass 3 500 ms
//------------------
TimeSlice_TC3_Start_Time = millis();
//------------------------------------------------------------------User
application code

// -----------------------------------------------------------------End of user
application code
// Toggle TC3 LED
toggle_LED(3);
if (((millis() - TimeSlice_TC3_Start_Time) > TimeSlice_TC3_Interval)) // 500 ms
{
while(1){
over_run_Fault(3); // abort program loop forever flash Time class 3 LED
}
}
else
{
while (((millis() - TimeSlice_TC3_Start_Time) <= TimeSlice_TC3_Interval)){ //
remove to save MIPS but it removes precise timeclass execution
}
}
} // End of main while loop

}// end of main loop

https://forum.arduino.cc/index.php?topic=7546.0