#include "PseudoKlasse.h"
#include "Settings.h"

constexpr uint8_t DEV_BUTTON_PIN     {7};   
constexpr uint8_t VAL_BUTTON_PIN     {6}; // Pin (D6) for switching the backlight on
constexpr uint16_t TIMER_DURATION {5000}; 

 /////////////////////////////////////////////////////////////////////
// Shift register control
// 
// Arduino-Pin connected to SRCLK/SHCP (SHCP = Pin 11 of 74HC595)
constexpr uint8_t CLOCK_PIN = 12;
// Arduino-Pin connected to RCLK (STCP = Pin 12 of 74HC595)
constexpr uint8_t STORE_PIN = 11;
// Arduino-Pin connected to SER (DS = Pin 14 of 74HC595)
constexpr uint8_t DATA_PIN = 10;

MoistureMeter mData[4] = { {837,413,696},
                           {837,413,696},
                           {837,413,696},
                           {837,413,696}
                        };
Settings::Input input;

void setup() {
  Serial.begin(115200);
  Serial.println(("Begin"));
  input.init(mData, TIMER_DURATION, DEV_BUTTON_PIN, VAL_BUTTON_PIN, CLOCK_PIN, STORE_PIN, DATA_PIN);
}

void loop() {
  // put your main code here, to run repeatedly:
  input.selectDevice();
  input.setMoistureThreshold();
}



sketch.ino

diagram.json

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

Streaming

libraries.txt

//////////////////////////////////////////////////////////////////////////////
/// @file Button.hpp
/// @author Kai R. 
/// @brief Simple class for handling buttons.
///        A time (in ms) can be specified after which a button press is considered "long". 
///        Correspondingly, the tic() method returns the status NONE, LONG or SHORT.
/// 
/// @date 2022-05-04
/// @version 1.0
/// 
/// @copyright Copyright (c) 2022
/// 
//////////////////////////////////////////////////////////////////////////////

#ifndef _BUTTON_HPP_
#define _BUTTON_HPP_
#include <stdint.h>
#include <Arduino.h>

//////////////////////////////////////////////////
// Constants
//////////////////////////////////////////////////

constexpr uint8_t DEBOUNCE_VAL  {30};  // The value can be reduced for buttons that bounce little. Time in ms.

//////////////////////////////////////////////////
// Variables and Classdefinitions
//////////////////////////////////////////////////
enum class ButtonState : uint8_t {P_NONE,P_SHORT,P_LONG};

class Button {
    uint16_t _isLong;           // Saves the time (in ms) from which a key press is recognized as long.
    bool _activeState;          // Saves whether the buttons active state is HIGH or LOW.
    uint8_t _pin;               // Button PIN number
    bool _state;                // Saves the actual state of the button.
    bool _prevState;            // Saves the previous state of the button.
    uint32_t _pressingTime;     // Saves the length of time that the button was pressed (ms).
    ButtonState _buttonState;   // Saves the status depending on how long the button was pressed.
  
    public:
    //////////////////////////////////////////////////////////////////////////////
    /// @brief Construct a new Button object
    /// 
    /// @param pin            // Pin where the Button is connected
    /// @param isLong         // time from which a key press is recognized as long
    /// @param activeState    // LOW if the button is connected with a pull up, otherwise HIGH with a pull down resistor
    //////////////////////////////////////////////////////////////////////////////
    Button(decltype(_isLong) isLong = 1000, decltype(_activeState) activeState=LOW) : 
      _isLong(isLong), _activeState(activeState) {
      _state = !_activeState;
    }
    void begin(uint8_t);
    ButtonState tic(void);
    uint32_t getDuration(void) const;
};

#endif

button.hpp

//////////////////////////////////////////////////////////////////////////////
/// @file button.cpp
/// @author Kai R. (you@domain.com)
/// @brief Simple class for handling buttons.
///        A time (in ms) can be specified after which a button press is considered "long". 
///        Correspondingly, the tic() method returns the status NONE, LONG or SHORT.
/// 
/// @date 2022-06-03
/// @version 1.0
/// 
/// @copyright Copyright (c) 2022
/// 
//////////////////////////////////////////////////////////////////////////////
#include "button.hpp"

//////////////////////////////////////////////////////////////////////////////
/// @brief Initialize the pin to which the pushbutton is connected
/// 
/// @param pinnr 
//////////////////////////////////////////////////////////////////////////////
void Button::begin(uint8_t pinnr) {
  _pin = pinnr;
  switch(_activeState) {
    case HIGH:  pinMode(_pin, INPUT); break;
    case LOW:   pinMode(_pin, INPUT_PULLUP); break;
  }
}

//////////////////////////////////////////////////////////////////////////////
/// @brief The button query. The tic() method should be called in an endless loop.
/// 
/// @return ButtonState  The states are "Not pressed", "short pressed" and "long pressed"
//////////////////////////////////////////////////////////////////////////////
ButtonState Button::tic() {
  uint32_t now = millis();

  _prevState=_state;
  _buttonState = ButtonState::P_NONE;
  _state = digitalRead(_pin);
    
  if (_state == _activeState && _prevState != _activeState) {
    _pressingTime = now;
  } else if (_state != _activeState && _prevState == _activeState) {
    _pressingTime = now - _pressingTime;
    if (_pressingTime >= DEBOUNCE_VAL) {       // released after debounce time?
      _buttonState = (_pressingTime >= _isLong) ? ButtonState::P_LONG : ButtonState::P_SHORT;  
    }
  }
  return _buttonState;
}

//////////////////////////////////////////////////////////////////////////////
/// @brief Returns the amount of time the button was pressed.
/// 
/// @return uint32_t Time in milliseconds
//////////////////////////////////////////////////////////////////////////////
uint32_t Button::getDuration(void) const {
  return _pressingTime;
}

button.cpp

#pragma once

namespace Combie 
{
  namespace Timer
  {    
    class TriggerableBool // Interface 
    {
       protected:
       bool state = false;
 
       virtual bool doTrigger(const bool trigger) = 0;
       virtual ~TriggerableBool() {}
       
       bool operator() (const bool trigger)
       {
         return doTrigger(trigger);
       }
      
       bool operator() ()
       {
         return state;
       }
      
       bool operator= (const bool trigger)
       {
         return doTrigger(trigger);
       }
       
       operator bool() const
       {
         return state;
       }
    };

    class SimpleTimer
    {
      private:
      uint32_t timeStamp;      // Zeitmerker
      bool reached;                // default Status: timer abgelaufen
    
      public:
      SimpleTimer():timeStamp(0),reached(true){}
      
      void start()
      {
        timeStamp   = millis();
        reached     = false;
      }
      
      void reset()
      {
         reached     = true;
      }
    
      bool operator()(const uint32_t interval) 
      {
        if(!reached) reached = millis() - timeStamp >= interval;
        return reached;
      }
    };
    
    
    class Pulsator   // liefert alle X ms einen HIGH Impuls
    {
      protected: 
      SimpleTimer timer;
      uint32_t interval;
      
      public:
      Pulsator(uint32_t interval):interval(interval){}
      
      void setInterval(const uint32_t interval)
      {
         this->interval =  interval;
      }
      
      void start()
      {
        timer.start();
      }
      
      operator bool()
      {
          bool result = false;
          if(timer(interval))
          {
            result = true;
            timer.start();
          }
          return result;
      } 
    };


    
    class EdgeTimer     // EdgeTimer: Die abstakte Mutter der Flankenverzoegerer
    {
      protected:
      SimpleTimer timer;
      uint32_t interval;
    
      public:
      EdgeTimer(const uint32_t interval):interval(interval){}

      void setInterval(const uint32_t _interval)
      {
         interval =  _interval;
      }
      
    };
  
    class FallingEdgeTimer: protected  EdgeTimer,  protected TriggerableBool // abfallende Flanke wird verzoegert
    {

      public:
      using EdgeTimer::EdgeTimer;
      using TriggerableBool::operator();
      using TriggerableBool::operator=;
      using TriggerableBool::operator bool;

      
      virtual bool doTrigger(const bool trigger) override 
      {
        if(trigger) timer.start();
        state = !timer(interval);
        return state;
      }
      
      void reset()
      {
        timer.reset();
        state = false;
      }

    };
    
    class RisingEdgeTimer:  protected  EdgeTimer, protected TriggerableBool  // steigende Flanke wird verzoegert
    {
   
      public:
      using EdgeTimer::EdgeTimer;
      using TriggerableBool::operator();
      using TriggerableBool::operator=;
      using TriggerableBool::operator bool;

      virtual bool doTrigger(const bool trigger) override 
      {
        if(!trigger) timer.start();
        state = timer(interval);
        return state;
      }
      
      void reset()
      {
        timer.reset();
        state = false;
      }
  
    };
    
    class Debounce: protected TriggerableBool 
    {
      private:
      SimpleTimer timer;
      const uint32_t interval;
      
      public:
      Debounce(const uint32_t interval = 20) : interval(interval)  {}
      using TriggerableBool::operator();
      using TriggerableBool::operator=;
      using TriggerableBool::operator bool;


      virtual bool doTrigger(const bool trigger) override
      {
         if(state == trigger)   timer.start();
         if(timer(interval)) state = !state;
         return state; 
      }
 
    };
    
     
    class PpmGenerator // Puls Pausen Modulation
    {
      private: 
        bool state; // zustandsmerker Puls oder Pause
        uint32_t onInterval;
        uint32_t offInterval;
        SimpleTimer timer;
    
      public:
        PpmGenerator():state(false),onInterval(500),offInterval(500){}
        PpmGenerator(const uint32_t onInterval,const uint32_t offInterval):state(false),onInterval(onInterval),offInterval(offInterval){}
        
        inline void setOnInterval(const uint32_t value)
        {
          onInterval = value;
        }
        
        inline void setOffInterval(const uint32_t value)
        {
          offInterval = value;
        }
    
        operator bool()
        {
          if(timer(state?onInterval:offInterval))
          {
            state = !state;
            timer.start();
          }
          return state;
        }
    };
    
    class TimeRelay: protected TriggerableBool
    {
      protected:
      RisingEdgeTimer  ton ;
      FallingEdgeTimer toff;
    
      public:
      explicit TimeRelay(const unsigned long roseDelay, const unsigned long fellDelay): ton{roseDelay}, toff{fellDelay}{}
      using TriggerableBool::operator();
      using TriggerableBool::operator=;
      using TriggerableBool::operator bool;
    
      virtual bool doTrigger(const bool trigger) override
      {
         return state = toff = ton = trigger;
      }
    };

   // compatibility aliases    
    using ZeitRelaisErsatzstoff  = TimeRelay;
    using EntprellTimer          = Debounce;
    
    
  }  
}





CombieTimer.h

#ifndef _SETTINGS_H_
#define _SETTINGS_H_

#include <Arduino.h>
#include <EEPROM.h>
#include "button.hpp"
#include "CombieTimer.h"
#include "PseudoKlasse.h"

namespace Settings {
  
  constexpr uint8_t MAX_MVALUES         {2*2};  // 2 ^ 3! 001 / 010 / 100 Bit shift, no addition!
  constexpr uint8_t NIBBLE              {4};

  constexpr uint16_t BASE_EE_ADDRESS    {0};
  constexpr uint16_t OFFSET_EE_ADDRESS  {0x0A};

////////////////////////////////////////////////////////////////////////
// Possible Shift Register Values
//
// Value Device1 
// 0001 0001
// 0010 0001
// 0100 0001
//
// Value Device2 
// 0001 0010
// 0010 0010
// 0100 0010
//
// Value Device3 
// 0001 0100
// 0010 0100
// 0100 0100
//
// Value Device4 
// 0001 1000
// 0010 1000
// 0100 1000

// EEProm-Adress offset per device = 0x0A

//       shiftVal High | shiftVal Low | mThres High | mThres Low
// Dev1       0x00            0x01           0x02          0x03
// Dev2       0x0A            0x0B           0x0C          0x0D
// Dev3       0x14            0x15           0x16          0x17
// Dev5       0x1E            0x1F           0x20          0x21

  class Input {
    public:  
      Input() {}
      Input(const Input&) = delete;             // prevent copy
      Input& operator=(const Input&) = delete;  // prevent assignment
      ~Input() { delete pDeviceData; }

      template<size_t MAX>
      void init(MoistureMeter (&moistureData_)[MAX], 
                uint16_t timerDuration, 
                uint8_t devPin_, 
                uint8_t valPin_, 
                uint8_t shClockPin_, 
                uint8_t shStorePin_, 
                uint8_t shDataPin_);

      uint8_t selectDevice(void);
      void setMoistureThreshold(void);

    private:
      MoistureMeter* moistureData {nullptr};
      uint16_t timerDuration;
      uint8_t devPin;
      uint8_t valPin;
      uint8_t shClockPin;
      uint8_t shStorePin;
      uint8_t shDataPin;

      Button devButton;
      Button valButton;
      Combie::Timer::SimpleTimer timer;

      struct DeviceData {
        uint8_t shiftValue;
        uint16_t mThreshold;
      };
      DeviceData* pDeviceData {nullptr};

      uint8_t maxDevices  {0};
      uint8_t deviceNr    {0};
      bool inputFlag      {false};
      void shiftOutData(uint16_t pinData);
  };

  template<size_t MAX>
  void Input::init(MoistureMeter (&moistureData_)[MAX], 
            uint16_t timerDuration_, 
            uint8_t devPin_, 
            uint8_t valPin_, 
            uint8_t shClockPin_, 
            uint8_t shStorePin_, 
            uint8_t shDataPin_) {
    
    moistureData = moistureData_;
    timerDuration = timerDuration_;
    devPin = devPin_;
    valPin = valPin_;
    shClockPin = shClockPin_;
    shStorePin = shStorePin_;
    shDataPin = shDataPin_;
    
    maxDevices = MAX;
    pDeviceData = new DeviceData[MAX];    // Attention!

    valButton.begin(valPin);
    devButton.begin(devPin);

    pinMode(shStorePin, OUTPUT);
    pinMode(shClockPin, OUTPUT);
    pinMode(shDataPin, OUTPUT);

    if (EEPROM.read(BASE_EE_ADDRESS) == 0xFF) {   // If the EEPROM value = 255, nothing has been stored yet
      for(uint8_t i = 0; i < maxDevices; ++i) {  // So use default values
        pDeviceData[i].shiftValue = 0x10 | (1<<i);
        //Serial.println(pDeviceData[i].shiftValue);
        pDeviceData[i].mThreshold = moistureData[i].thres;     // <- Standardwerte von  MoistureMeter.threshold verwenden
        EEPROM.put((BASE_EE_ADDRESS + (i*OFFSET_EE_ADDRESS)), pDeviceData[i]);
      }
    } else {
      for(uint8_t i = 0; i < maxDevices; ++i) {
        // Read EEPROM Data
        EEPROM.get((BASE_EE_ADDRESS + (i*OFFSET_EE_ADDRESS)), pDeviceData[i]);
        moistureData[i].thres = pDeviceData[i].mThreshold;   // <- Objekt MoistureMeter.threshold Wert Setzen
      }
    }
    shiftOutData(pDeviceData[0].shiftValue);
  }
}
#endif

Settings.h

#include "Settings.h"

namespace Settings {
  //
  // Select one of the four devices to adjust the deviceData threshold to start watering.
  //
  uint8_t Input::selectDevice() {
    if (devButton.tic() != ButtonState::P_NONE) {
      Serial.print("Device Button gedrückt: ");
      deviceNr = (deviceNr + 1) % maxDevices;
      Serial.print(" "); Serial.print(pDeviceData[deviceNr].shiftValue);
      pDeviceData[deviceNr].shiftValue = (pDeviceData[deviceNr].shiftValue & 0x0F) |  (1<<deviceNr);
      shiftOutData(pDeviceData[deviceNr].shiftValue);
      Serial.print(" "); Serial.print(deviceNr);
      Serial.print(" "); Serial.println(pDeviceData[deviceNr].mThreshold);
    }
    return deviceNr;
  }
  
  //
  // Select one of three possible humidity thresholds.
  // The first keystroke activates the selection. Subsequent keystrokes change the value.
  // If the value button is not pressed for five seconds, the input is deactivated. 
  // The values are then stored in the EEPROM if they have changed. 
  //
  void Input::setMoistureThreshold() {
   
    switch(inputFlag) {
      case false:
        if (valButton.tic() != ButtonState::P_NONE && !inputFlag) {
          Serial.println("Button gedrückt");
          inputFlag = true;
          digitalWrite(LED_BUILTIN, HIGH);
          timer.start();
        }
        break;
      case true:
        if (timer(5000)) {
          inputFlag = false;
          EEPROM.put((BASE_EE_ADDRESS + (deviceNr*OFFSET_EE_ADDRESS)), pDeviceData[deviceNr]);
          digitalWrite(LED_BUILTIN, LOW);
        }
        if (valButton.tic() != ButtonState::P_NONE) {
          uint8_t valueNr = (pDeviceData[deviceNr].shiftValue >> 4) % MAX_MVALUES;
          if (!valueNr) {
            moistureData[deviceNr].thres = moistureData[deviceNr].mMax - ((moistureData[deviceNr].mMax - moistureData[deviceNr].mMin)/3);   // <- MoistureMeter.threshold verwenden
          } else {
            uint16_t dif = (moistureData[deviceNr].mMax - moistureData[deviceNr].mMin)/3;
            moistureData[deviceNr].thres = moistureData[deviceNr].thres - ((dif * 20) / 100);                     // <- MoistureMeter.threshold verwenden
          }
          pDeviceData[deviceNr].mThreshold = moistureData[deviceNr].thres;                                         // <- MoistureMeter.threshold verwenden
          pDeviceData[deviceNr].shiftValue = (pDeviceData[deviceNr].shiftValue & 0x0F) | (1 << (valueNr + NIBBLE));
          shiftOutData(pDeviceData[deviceNr].shiftValue);
          timer.start();
        }
    }
  }
  
  //
  //  Send the display data to the shift register
  //
  void Input::shiftOutData(uint16_t pinData) {
    digitalWrite(shStorePin, LOW);
    shiftOut(shDataPin, shClockPin, MSBFIRST, pinData);
    digitalWrite(shStorePin, HIGH);    
  }
}

Settings.cpp

#ifndef _PSEUDOKLASSE_H_
#define _PSEUDOKLASSE_H_

// Zum Probieren als Kurzform für die SoleniodValve bzw. MoistureMeter Klasse

struct MoistureMeter {
    uint16_t mMax;
    uint16_t mMin;
    uint16_t thres;  // 696
};

#endif