// https://forum.arduino.cc/t/funktion-millims/1009958/
// Geändert, basierend auf Vorschlägen von @noiasca Post #22 und 
// https://wokwi.com/projects/336690972255584851

#include "led.hpp"
//
// Main Prgramm
//
Led ledArray[] {Led{}, Led{2}, Led{4}, Led{6}, Led{8} };

void setup() {
  for (auto &leds : ledArray) {
    leds.begin();
  }
}

void loop() {
  ledArray[0](250);
  ledArray[1](500);
  ledArray[2](2000);
  ledArray[3](1000);
  ledArray[4](500);
}


sketch.ino

diagram.json

#ifndef _BLINK_HPP_
#define _BLINK_HPP_
#include <Arduino.h>

enum class BlinkStatus : byte {off,on,wait}; // https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum5-dont-use-all_caps-for-enumerators

//
// Blink Klasse für Zeitintervalle
//
class Blink {
  private:
    uint32_t oldTime {0};

  protected:
    BlinkStatus status;

  public:
    Blink();  
    BlinkStatus operator()(const uint32_t);
    void switchBlinkOn(void);
    void switchBlinkOff(void);
    virtual void setStatus(BlinkStatus);        // virtual für late binding - wird in Child Klasse (Led) überschrieben
    BlinkStatus getStatus(void) const;
};

Blink::Blink() : status {BlinkStatus::off} {}  // Konstruktor mit Default-Werten

void Blink::switchBlinkOn() {
  setStatus(BlinkStatus::on); 
}

void Blink::switchBlinkOff() {
  setStatus(BlinkStatus::off); 
}

void Blink::setStatus(BlinkStatus status_) {
  status = status_;  
}

BlinkStatus Blink::getStatus() const {
  return status;
}

// Die Operatorüberladung () erspart eine extra tic() Methode.
BlinkStatus Blink::operator()(const uint32_t interval) {
  if (millis() - oldTime >= interval) {
    oldTime = millis();
    switch(status) {
      case BlinkStatus::on : switchBlinkOff(); break;
      case BlinkStatus::off: switchBlinkOn(); break;
      default: break;
    }
  }
  return status;
}

#endif

blink.hpp

#ifndef _LED_HPP_
#define _LED_HPP_

#include "blink.hpp"

//
// LED Klasse für physische LEDs
// 
class Led : public Blink {              // Die Blinkfähigkeit wird hier von Blink geerbt
  private:
    uint8_t pin;  

  public:
    Led(uint8_t);
    Led(const Led&) = delete;             // Kein Kopierkonstruktor
    Led(Led&&)= default;                  // statt Kopie -> Move Semantik (schneller)
    Led& operator=(const Led&) = delete;  // Keine Zuweisungsoperator
    void begin(void);
    void begin(uint8_t);
    void begin(BlinkStatus, uint8_t);
    virtual void setStatus(BlinkStatus status) override; 
};

Led::Led(uint8_t _pin = LED_BUILTIN) : Blink(), pin{_pin} {} // Konstruktor. Wenn kein Pin angegeben, verwende Builtin LED

void Led::begin(void) {
  pinMode(pin,OUTPUT);
}

void Led::begin(uint8_t pin_) {
  pin = pin_;
  pinMode(pin,OUTPUT);
}

void Led::begin(BlinkStatus status, uint8_t pin_ = LED_BUILTIN) {  // Wenn kein Pin angegeben, verwende Builtin LED
  Blink::setStatus(status);
  if (pin_ != LED_BUILTIN) pin = pin_;                             
  pinMode(pin,OUTPUT);
  if (status == BlinkStatus::on) digitalWrite(pin,HIGH);
}

void Led::setStatus(BlinkStatus status) {
  Blink::setStatus(status);
  switch (getStatus()) {
    case BlinkStatus::on:  digitalWrite(pin,HIGH); break;
    case BlinkStatus::off: digitalWrite(pin,LOW);  break;
    default: break;
  }
}    
#endif