tiempo de retardo); vs if (millis () - anterior> tiempo); y deriva

Al pasar por un proyecto antiguo, tenía un código en dos Arduino Due que se veía así

void loop()
{
  foo();
  delay(time);
}

teniendo en cuenta la mayoría de la literatura sobre el uso delay();que recodifiqué esto como

void loop()
{
  static unsigned long PrevTime;
  if(millis()-PrevTime>time)
  {
    foo();
    PrevTime=millis();
  }
}

Sin embargo, esto parece haber creado una situación en la que los dos dispositivos derivan durante un período de tiempo en el que no

Mi pregunta es doble:

1. ¿Por qué if(millis()-PrevTime>time)causaría más deriva que delay(time)?
2. ¿Hay alguna manera de evitar esta deriva sin volver a delay(time)?

Hay una cosa importante que debe recordar al trabajar con tiempo en un Arudino de cualquier forma:

• Cada operación lleva tiempo.

Su función foo () tomará una cantidad de tiempo. Cuál es ese momento, no podemos decir.

La forma más confiable de lidiar con el tiempo es confiar solo en el tiempo de activación, no en determinar cuándo debería ser la próxima activación.

Por ejemplo, tome lo siguiente:

if (millis() - last > interval) {
    doSomething();
    last = millis();
}

La variable lastserá el tiempo que se activó la rutina * más el tiempo que doSomethingtardó en ejecutarse. Digamos que intervales 100, y doSomethingtarda 10 ms en ejecutarse, obtendrá disparos a 101 ms, 212 ms, 323 ms, etc. No los 100 ms que esperaba.

Entonces, una cosa que puede hacer es usar siempre el mismo tiempo, independientemente de recordarlo en un momento específico (como sugiere Juraj):

uint32_t time = millis();

if (time - last > interval) {
    doSomething();
    last = time;
}

Ahora el tiempo que doSomething()lleva no tendrá efecto en nada. Por lo tanto, obtendrá disparos a 101 ms, 202 ms, 303 ms, etc. Aún no alcanza los 100 ms que deseaba, porque está buscando que hayan pasado más de 100 ms, y eso significa 101 ms o más. En su lugar, debe usar >=:

uint32_t time = millis();

if (time - last >= interval) {
    doSomething();
    last = time;
}

Ahora, suponiendo que no suceda nada más en su bucle, obtiene disparos a 100 ms, 200 ms, 300 ms, etc. Pero tenga en cuenta ese bit: "mientras no suceda nada más en su bucle" ...

¿Qué sucede si una operación que dura 5 ms ocurre a 99 ms ...? Su próximo disparo se retrasará hasta 104 ms. Eso es una deriva. Pero es fácil de combatir. En lugar de decir "El tiempo grabado es ahora", usted dice "El tiempo grabado es 100 ms más tarde de lo que era". Eso significa que, independientemente de los retrasos que obtenga en su código, su activación siempre será a intervalos de 100 ms, o se desplazará dentro de un tic de 100 ms.

if (millis() - last >= interval) {
    doSomething();
    last += interval;
}

Ahora obtendrá disparos a 100 ms, 200 ms, 300 ms, etc. O si hay retrasos en otros bits de código, puede obtener 100 ms, 204 ms, 300 ms, 408 ms, 503 ms, 600 ms, etc. Siempre intenta ejecutarlo lo más cerca posible el intervalo posible, independientemente de los retrasos. Y si tiene retrasos que son mayores que el intervalo, ejecutará automáticamente su rutina suficientes veces para ponerse al día con la hora actual.

Antes de que tuvieras deriva . Ahora tienes nerviosismo .

Porque reinicia el temporizador después de la operación.

static unsigned long PrevTime=millis();

unsigned long t = millis();

if (t - PrevTime > time) {
    foo();
    PrevTime = t;
}

Para lo que está intentando hacer, delay () es la forma adecuada de implementar el código. La razón por la que desearía usar if (millis ()) es si desea permitir que el bucle principal continúe en bucle para que su código o algún otro código fuera de ese bucle pueda realizar otro procesamiento.

Por ejemplo:

long next_trigger_time = 0L;
long interval = DESIRED_INTERVAL;

void loop() {
   do_something(); // check a sensor or value set by an interrupt
   long m = millis();
   if (m >= next_trigger_time) {
       next_trigger_time = m + interval;
       foo();
   }
}

Esto ejecutaría foo () en el intervalo especificado mientras permite que el ciclo continúe ejecutándose en el medio. Puse el cálculo de next_trigger_time antes de la llamada a foo () para ayudar a minimizar la deriva, pero es inevitable. Si la deriva es una preocupación importante, use un temporizador de interrupción o algún tipo de sincronización reloj / temporizador. También recuerde que millis () se ajustará después de un período de tiempo y no lo tomé en cuenta para mantener el ejemplo de código simple.

Su código es correcto.

el problema con el que se encuentra es con millis (): tendrá un recuento insuficiente levemente (el recuento insuficiente máximo es apenas de 1 ms, por invocación).

la solución es con garrapatas más finas, como micros (), pero eso también contará un poco.