struct Timeout {
  unsigned long timeout;
  unsigned long time;
  bool set = false;
};

template <size_t n>
class Delay {
  Timeout timeouts_[n];

public:
  bool run(size_t const, unsigned long const);
};


template <size_t n>
bool Delay<n>::run(size_t const id, unsigned long const timeout) {
  if (not timeouts_[id].set) {
    timeouts_[id].timeout = timeout;
    timeouts_[id].time = millis();
    timeouts_[id].set = true;
    return false;
  }
  if (millis() - timeouts_[id].time < timeouts_[id].timeout) {
    return false;
  }
  timeouts_[id].set = false;
  return true;
}

Delay<2> delayer;


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

void loop() {
  if (delayer.run(0, 1000)) {
    Serial.println("Every second.");
  }
  if (delayer.run(1, 2000)) {
    Serial.println("Every two seconds.");
  }
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

libraries.txt

#pragma once


inline void mPrint(Stream&) {}

template <class H, class... Tail> void mPrint(Stream& stream, H head, Tail... tail) {
  stream.print(head);
  mPrint(stream, tail...);
}

template <class... Args> void mPrintln(Stream& stream, Args... args) {
  mPrint(stream, args..., "\r\n");
}

/* Example.
mPrintln(Serial, "This would normally take ", 3, " lines.");
*/

mprint.h

#pragma once


template <class T> String show(T const) {
  String s(__PRETTY_FUNCTION__);

  return s.substring(25, s.length() - 1);
}

/* Example.
Serial.println(show(analogRead));
*/

show.h

#pragma once


template <class T, size_t N> size_t arraySize(T const (&)[N]) {
  return N;
}

/* Example.
int myArray[] = {0, 1, 2, 3, 4};
Serial.println(arraySize(myArray));
*/

array.h

#pragma once


struct seconds {
  unsigned long x;
};

struct milliseconds {
  unsigned long x;
};

constexpr seconds operator"" s(unsigned long long x) {
  return seconds{x};
}

constexpr milliseconds operator"" ms(unsigned long long x) {
  return milliseconds{x};
}

types.h

#pragma once


template <size_t N>
void parseLine(int (&result)[N], char const line[]) {
  char* endptr = const_cast<char*>(line);
  for (size_t i = 0; i < N and endptr[0]; i++) {
    result[i] = strtol(endptr + static_cast<int>(i != 0), &endptr, 10);
  }
}

template <size_t N>
void parseLine(double (&result)[N], char const line[]) {
  char* endptr = const_cast<char*>(line);
  for (size_t i = 0; i < N and endptr[0]; i++) {
    result[i] = strtod(endptr + static_cast<int>(i != 0), &endptr);
  }
}

/* Examples.
char const line[] = "12, 3, 123";
int result[3];
parseLine(result, line);
for (int const& value: result) {
  Serial.println(value);
}

char const line[] = "1.2, 3, 12.3";
double result[3];
parseLine(result, line);
for (double const& value: result) {
  Serial.println(value);
}
*/

parse.h

#pragma once


class C {
  int data_ = 10;
public:
  void print() {
    Serial.println(data_);
  }
};

/* Example:
void test(C& obj, void (C::*f)()) {
 (obj.*f)();
}

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

  C c;
  test(c, &C::print);
}
 */