#include <Streaming.h>
#include "Button.hpp"
#include "led.hpp"
#include "lauflicht.hpp"

//
// Konstanten
//
constexpr byte potiPin   {A0}; 
constexpr byte buttonPin {3};

//
// Globale Variablen
//
Print &cout = Serial;  // c++ cout style
ButtonSL switchButton {buttonPin};

Led led1;             // On Board LED   (kein Lauflicht)
Led led2 {12};        // Led an Pin 12 (kein Lauflicht)
//Objekttyp      {Pinnummer}
Led ledArray[] { {2}, {4}, {6}, {8} };        // 4 LED Objekte für Lauflicht in Array zusammenfassen
Lauflicht runningLight{ledArray, switchButton, potiPin};  // Lauflicht Objekt anlegen, Konstruktor-Template (lauflicht.hpp) ermittelt die Anzahl der Arrayelemente zur Compilezeit

//
// Main Programm
//
void setup() {
  Serial.begin(115200);
  uint8_t arrayGroesse = sizeof(ledArray);
  uint8_t arrayElemente = arrayGroesse / sizeof(Led);
  cout << F("Led-Array gesamt: ") << arrayGroesse 
       << F(" Byte\nLed-Objekte: ") << arrayElemente 
       << F("\nLed-Objektgroesse (Daten): ") << (arrayGroesse / arrayElemente) << " Byte" 
       << endl;
       
  // Einzelne LEDs für Blinken initialisieren
  led1.begin(BlinkStatus::on);       // LED1 leuchtet sofort nach dem Programmstart
  
  // Default Blinkstatus für den Start ist BlinkStatus::OFF und muss nicht angegeben werden.
  led2.begin();                      // LED2 leuchtet erst nach 2,5 Sekunden zum Ersten mal
  runningLight.begin();              // LEDs für Lauflicht initialisieren.
}

void loop() {
  led1(2000);         // Onboard LED alle zwei Sekunden blinken lassen
  led2(2500);         // LED 2 an Pin 12 alle 2,5 Sekunden blinken lassen
  runningLight.run(); // Lauflicht steuern.
}


BlinkLEDs-Taster.ino

diagram.json

#ifndef _BLINK_HPP_
#define _BLINK_HPP_

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

led.hpp

//////////////////////////////////////////////////////////////////////////////
/// @file Button.hpp
/// 
/// Button is a class for debouncing button queries. The debounce time can be specified.
/// The object returns a true if a button press was detected, otherwise a false is returned.
/// The debounce time can also be used to specify a minimum press length (e.g. a button must
/// be pressed for at least 0.5 seconds).
///
/// ButtonSL is extended so that a distinction can be made between a short and long button press.
/// A time (in ms) can be specified after which a button press is considered "long".
/// Correspondingly, the tick() method returns the status NONE, LONG or SHORT.
///
/// Library: https://github.com/DoImant/RPicoButton.git
///
/// Copyright (c) 2022
/// MIT license, check license.md for more information
/// All text above must be included in any redistribution
//////////////////////////////////////////////////////////////////////////////

#ifndef _BUTTON_HPP_
#define _BUTTON_HPP_
#include <Arduino.h>

namespace Btn {
//////////////////////////////////////////////////
// Constants
//////////////////////////////////////////////////
constexpr uint8_t DEBOUNCE_TIME{30};   // The value can be reduced for buttons that bounce little. Time in ms.

//////////////////////////////////////////////////
// Variables and Classdefinitions
//////////////////////////////////////////////////
enum class ButtonState : uint8_t { notPressed, shortPressed, longPressed };

//////////////////////////////////////////////////////////////////////////////
/// @brief Button object
///
/// @param pinNr // Pin where the Button is connected
/// @param as    // LOW if the button is connected with a pull up, otherwise HIGH with a pull down resistor
//////////////////////////////////////////////////////////////////////////////
class Button {
public:
  Button(uint8_t pinNr = 0, bool as = LOW) : pin{pinNr}, activeState{as} {}
  Button(const Button &) = delete;              // No copy constructor
  Button &operator=(const Button &) = delete;   // No assignment
  Button(Button &&) = default;                  // Move it
  void begin();
  bool tick();
  void setDebounceTime_ms(uint16_t);

protected:
  uint8_t pin;           // Button PIN number
  uint8_t activeState;   // Saves whether the buttons active state is HIGH or LOW.
  uint8_t compareState{LOW};
  uint16_t dbTime_ms{DEBOUNCE_TIME};
  uint_least32_t timeStamp;
};

//////////////////////////////////////////////////////////////////////////////
/// @brief Subclass of Button
///         The subclass extends a button object with the ability to
///         distinguish between short and long button presses
//////////////////////////////////////////////////////////////////////////////
class ButtonSL : public Button {
public:
  ButtonSL(uint8_t pinNr = 0, uint16_t t_ms = 1000, bool as = LOW) : Button{pinNr, as} { time_ms = t_ms; }
  ButtonState tick();
  void setTimeThreshold_ms(uint16_t);
  uint32_t getDuration_ms() const;

private:
  uint16_t time_ms;   // Saves the time (in ms) from which a key press is recognized as long.
  uint8_t state;
  uint16_t pressingTime;   // Saves the length of time that the button was pressed (ms).
};
}   // namespace Btn
#endif

Button.hpp

//////////////////////////////////////////////////////////////////////////////
/// @file Button.cpp
/// @author Kai R.
/// @brief Button is a class for debouncing button queries. The debounce time can be specified.
///        The object returns a true if a button press was detected, otherwise a false is returned.
///        The debounce time can also be used to specify a minimum press length (e.g. a button must
///        be pressed for at least 0.5 seconds).
///
///        ButtonSL is extended so that a distinction can be made between a short and long button press.
///        A time (in ms) can be specified after which a button press is considered "long".
///        Correspondingly, the tick() method returns the status notPressed, shortPressed or longPressed.
///        Library: https://github.com/DoImant/RPicoButton.git
///
/// @date 2022-05-04
/// @version 1.0
/// 
/// @date 2022-10-08
/// @version 1.0.1        change CAPS Enums
///
/// @copyright Copyright (c) 2022
/// MIT license, check license.md for more information
/// All text above must be included in any redistribution
//////////////////////////////////////////////////////////////////////////////

#include "Button.hpp"

namespace Btn {
//////////////////////////////////////////////////////////////////////////////
/// @brief Initialize the pin to which the pushbutton is connected
///
/// @param pinNr
//////////////////////////////////////////////////////////////////////////////
void Button::begin() {
  uint8_t mode = (activeState) ? INPUT : INPUT_PULLUP;
  pinMode(pin, mode);
}

//////////////////////////////////////////////////////////////////////////////
/// @brief The Button query. The tick() method should be called in an endless loop.
///
/// @return bool true if the pushbutton was pressed for the time period "dbTime_ms".
//////////////////////////////////////////////////////////////////////////////
bool Button::tick() {
  bool flag = false;
  if (digitalRead(pin) == activeState) {
    switch (compareState) {
      case LOW:
        compareState = HIGH;   // set to HIGH when Button was pressed
        timeStamp = millis();
        [[fallthrough]];
      case HIGH:
        if (millis() - timeStamp > dbTime_ms) {
          compareState = LOW;   // If the button press is equal to the specified debounce time,
          flag = true;          // confirm the button press with true.
        }
        break;
    }
  } else if (compareState) {
    compareState = LOW;   // set to LOW if button is no longer pressed
  }
  return flag;
}

//////////////////////////////////////////////////////////////////////////////
/// @brief Set the debounce time
///
/// @param dbTime
//////////////////////////////////////////////////////////////////////////////
void Button::setDebounceTime_ms(uint16_t dbT_ms) { dbTime_ms = dbT_ms; }

//////////////////////////////////////////////////////////////////////////////
/// @brief The ButtonSL query. The tick() method should be called in an endless loop.
///
/// @param time_ms        time (in ms) from which a key press is recognized as long
/// @return ButtonState   The states are "Not pressed", "short pressed" and "long pressed"
//////////////////////////////////////////////////////////////////////////////
ButtonState ButtonSL::tick() {
  uint_least32_t now = millis();
  compareState = state;
  state = digitalRead(pin);
  if (state == activeState && compareState != activeState) {
    timeStamp = now;
  } else if (state != activeState && compareState == activeState) {
    timeStamp = now - timeStamp;
    if (timeStamp >= dbTime_ms) {   // released after debounce time?
      return (timeStamp >= time_ms) ? ButtonState::longPressed : ButtonState::shortPressed;
    }
  }
  return ButtonState::notPressed;
}

//////////////////////////////////////////////////////////////////////////////
/// @brief Set the time (in ms) from which a key press is recognized as long.
///
/// @param th
//////////////////////////////////////////////////////////////////////////////
void ButtonSL::setTimeThreshold_ms(uint16_t th_ms) { time_ms = th_ms; }

//////////////////////////////////////////////////////////////////////////////
/// @brief Returns the amount of time the button was pressed.
///
/// @return uint32_t Time in milliseconds
//////////////////////////////////////////////////////////////////////////////
uint32_t ButtonSL::getDuration_ms(void) const { return timeStamp; }
}   // namespace Btn

Button.cpp

#ifndef _LAUFLICHT_
#define _LAUFLICHT_

#include "led.hpp"
#include "Button.hpp"

using namespace Btn;

class Lauflicht {
  public:
    template <size_t MAX>
    Lauflicht (Led (&pLeds_)[MAX], ButtonSL& button_, const byte potiPin_ = A0) : 
      pLeds{pLeds_},ledCount{MAX}, button{button_}, potiPin{potiPin_}  {}
    Lauflicht(const Lauflicht&) = delete;             // Kein Kopierkonstruktor
    Lauflicht& operator=(const Lauflicht&) = delete;  // Kein Zuweisungsoperator
    void begin(void);
    void run(void);

  private:
    Led* pLeds;                                       // Zeiger auf Array
    const byte ledCount;                              // Anzahl Arrayelemente
    ButtonSL& button;
    const byte potiPin;
    byte ledIndex;
    byte step       {1};
    bool isOn       {false};
    
    void doFlash(void);
};

void Lauflicht::begin() {
  // Lauflicht-LEDs aus Array initialisieren
  // BlinkStatus::WAIT für die Loslaufsynchronisierung
  button.begin();
  for (decltype(ledIndex) idx=0; idx < ledCount; ++idx) {
     pLeds[idx].begin(BlinkStatus::wait);
  }
}

void Lauflicht::run() {
  if (button.tick() != ButtonState::notPressed) {
    pLeds[ledIndex].setStatus(BlinkStatus::off);
    ledIndex = 0;
    isOn = !isOn;
  } 
  if (isOn) doFlash();
}

void Lauflicht::doFlash() {
  unsigned int speed = map(analogRead(potiPin), 0, 1023, 1000, 50);
  switch(pLeds[ledIndex](speed)) {
    case BlinkStatus::wait: 
      pLeds[ledIndex].setStatus(BlinkStatus::on);
      break;
    case BlinkStatus::off:
      ledIndex += step;
      if (ledIndex > (ledCount-1)) {   // Achtung step = 0-1 wird zu 255 was aber > LED_COUNT - 1 ist
        step = step * (-1);            // Also passt das, Laufrichtung umkehren.
        ledIndex +=step;
      }  
      break;
    default:
      break;
  } // switch;
}

#endif

lauflicht.hpp

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

Streaming