// https://forum.arduino.cc/t/what-would-be-a-good-synonym-for-delay/1004293
// https://forum.arduino.cc/t/how-to-use-millis-to-control-multi-period/1034904

#include "scheduler.h"

Scheduler scheduler;


bool taskOne(Task&) {
  Serial.println("Task one.");
  return true;
}

bool taskTwo(Task&) {
  Serial.println("Task two.");
  return true;
}


bool stateOne(Task&) {
  Serial.println("State one.");

  static size_t i = 0;
  i = (i + 1) % 3;
  if (not i) {
    scheduler.add(500, stateTwo);
    return true;
  }

  return false;
}

bool stateTwo(Task&) {
  Serial.println("State two.");
  scheduler.add(500, stateThree);
  return true;
}

bool stateThree(Task&) {
  Serial.println("State three.");
  scheduler.add(500, stateOne);
  return true;
}


bool stateAlpha(Task& task) {
  Serial.println("State alpha.");
  if (task.expired) {
    scheduler.add(0, 500, stateBeta);
    return true;
  }
  return false;
}

bool stateBeta(Task& task) {
  Serial.println("State beta.");
  if (task.expired) {
    scheduler.add(0, 500, stateAlpha);
    return true;
  }
  return false;
}


void setup() {
  Serial.begin(9600);

  /*
  // Simple tasks.
  scheduler.add(2000, taskOne);
  scheduler.add(4000, taskTwo);

  // Simple state machine.
  scheduler.add(6000, stateOne);
  */

  scheduler.add(0, 500, stateAlpha);
}

void loop() {
  scheduler.loop();
}

sketch.ino

diagram.json

#include <Arduino.h>

#include "scheduler.h"


bool finished(Task& task) {
  unsigned long const time = millis();

  if (time - task.start > task.when and task.callback(task)) {
    return true;
  }
  return false;
}

bool expired(Task& task) {
  unsigned long const time = millis();

  if (time - task.start > task.when + task.duration) {
    return true;
  }
  return false;
}


Scheduler::~Scheduler() {
  free(tasks_);
}

void Scheduler::add(
    unsigned long const when, unsigned long const duration, bool (*callback)(Task&)) {
  tasks_ = (Task*)realloc((void *)tasks_, ++numberOfTasks_);
  tasks_[numberOfTasks_ - 1] = {when, duration, millis(), callback, false};
}

void Scheduler::add(unsigned long const when, bool (*callback)(Task&)) {
  add(when, 0, callback);
}

void Scheduler::add(bool (*callback)(Task&)) {
  add(0, callback);
}

void Scheduler::loop() {
  for (size_t i = 0; i < numberOfTasks_; i++) {
    if (finished(tasks_[i])) {
      remove_(i);
    }
    tasks_[i].expired = expired(tasks_[i]);
  }
}

void Scheduler::remove_(size_t index) {
  for (size_t i = index; i < numberOfTasks_ - 1; i++) {
    tasks_[i] = tasks_[i + 1];
  }
  tasks_ = (Task*)realloc((void*)tasks_, --numberOfTasks_);
}

scheduler.cpp

#pragma once

struct Task {
  unsigned long when;
  unsigned long duration;
  unsigned long start;
  bool (*callback)(Task&);
  bool expired;
};

class Scheduler {
  public:
    ~Scheduler();

    void add(unsigned long const, unsigned long const, bool (*)(Task&));
    void add(unsigned long const, bool (*)(Task&));
    void add(bool (*)(Task&));
    void loop();

  private:
    Task* tasks_{};
    size_t numberOfTasks_ = 0;

    void remove_(size_t);
};