// ATtiny85 Blink!

#define LED_PIN PB0
// Low Primer alarm

#include "Multi_Timer_V2.h"

const byte primer_PRX = PB3;
const byte ramDown_PRX = PB4;
const byte alarmLED = PB0;
const byte ramDownLED = PB1;

bool primersPresent;
bool ramIsDown;
bool alarmIsSet;

OnDelayTimer ramInDownPositionTimer(1000);  //
FlasherTimer alarmLEDFlasher(2000, 500);

void setup() {
  
  pinMode(primer_PRX, INPUT_PULLUP);
  pinMode(ramDown_PRX, INPUT_PULLUP);
  pinMode(alarmLED, OUTPUT);
  pinMode(ramDownLED, OUTPUT);
  
}

void loop() {
  Multi_Timer::updateAllTimers();

  primersPresent = (digitalRead(primer_PRX) ? true : false);
  ramIsDown = (digitalRead(ramDown_PRX) ? false : true);

  digitalWrite(ramDownLED,ramIsDown);

// test for primers when ram is at bottom of stroke
// for one second, set/reset alarm accordingly.

  ramInDownPositionTimer.setEnable(ramIsDown);
  if (ramInDownPositionTimer.getDoneRose()){
   alarmIsSet = !primersPresent;
}

  alarmLEDFlasher.setEnable(alarmIsSet);
  digitalWrite(alarmLED, alarmLEDFlasher.isFlashing() ? HIGH : LOW);
}



attiny85-blink.ino

diagram.json

// filename: Multi_Timer_V2.cpp  6/18/24
//
// https://forum.arduino.cc/t/renamed-iterating-through-a-series-of-objects-original-title-oop-this-pointer-questions/1244434


#include "Multi_Timer_V2.h"
#include "Arduino.h"
//
/*
      Multi_Timer is the base timer class.
      > Sets done status true upon reaching preset (false for off timer).
      > Produces a positive-going one-scan pulse 'os' upon reaching
      preset value (done status = true) and another one-scan pulse
      when done goes false.
      > responds to a reset command by setting accumulated value to
      zero and resetting _Done and _TimerRunning.
    */
//----------------------------------------------------
//

Multi_Timer *Multi_Timer::first = nullptr;  // Initialize pointer variable 'first'

// One-argument constructor for non-FlasherTimer types - delegates
// to the two-argument constructor, removing need for object
// pointer setup loop.

Multi_Timer::Multi_Timer(unsigned long pre)
  : Multi_Timer(pre, 0UL) {  // trailing zero value is default onTime initialization
}

/*==============================================

    Two-argument constructor for FlasherTimer type.
---------------------------------------------------
Acts as delegate for one-argument constructor
*/
Multi_Timer::Multi_Timer(unsigned long pre, unsigned long onTime) {
  _Preset = pre;
  _OnTime = onTime;
  _Control = false;

  /*
  Set up pointers to list of objects to enable one call
  to Update_All_Timers() rather than each timer making 
  its own call to update().
  */

// https://forum.arduino.cc/t/renamed-iterating-through-a-series-of-objects-original-title-oop-this-pointer-questions/1244434/110
  next = nullptr;  // lets timers survive power cycle intact
  if (first == nullptr) {
    first = this;
  } else {

    //
    // Start at the first pointer and walk the list until we
    // find one that doesn't have a next
    Multi_Timer *ptr = first;
    while (ptr->next != nullptr) {
      ptr = ptr->next;
    }
    ptr->next = this;
  }
}

/*==========================

   Destructor - Comments from forum post #38
   https://forum.arduino.cc/t/renamed-iterating-through-a-series-of-objects-original-title-oop-this-pointer-questions/1244434/38?
 ------------------------*/
Multi_Timer::~Multi_Timer() {
  // If this is the first instance then we need to make the next one first
  // If there's no next instance then first becomes nullptr and the next
  // new instance will be first.
  if (first == this) {
    first = this->next;
  } else {
    // Start at the first instance and walk the list until we find the one
    // whose next pointer points to the one being destroyed.
    Multi_Timer *ptr = first;
    while (ptr->next != this) {
      ptr = ptr->next;
    }
    // Give that instance this one's next.  If there is no next
    // (ie this is last in the list) then ptr->next becomes nullptr
    // and marks the new end of the list.
    ptr->next = this->next;
  }
}
/*======================================

           Accessor methods
--------------------------------------*/

void Multi_Timer::setEnable(bool en) {
  _Enable = en;
}

bool Multi_Timer::isEnabled() const {
  return _Enable;
}

bool Multi_Timer::isReset() const {
  return _Reset;
}

bool Multi_Timer::isDone() const {
  return _Done;
}

bool Multi_Timer::isRunning() const {
  return _TimerRunning;
}

void Multi_Timer::setCtrl(bool ctrl) {
  _Control = ctrl;
}

unsigned long Multi_Timer::getCount() const {
  return _Accumulator;
}

bool Multi_Timer::getDoneRose() const {
  return _Done_OSR;
}

bool Multi_Timer::getDoneFell() const {
  return _Done_OSF;
}

//========================================================

//  The 'update' function is the heart of the thing.
//  ----------------------------------------------------
//  Updates timer accumulated value & conditions flags '_Done',
// '_Done_Rising_OS', '_Done_Falling_OS' and '_TimerRunning'.
//
//  Returns boolean status of _Done.  update() must be called
//  periodically in loop to update the flags and accumulated
//  value.
//  ====================================================

bool Multi_Timer::update() {
  _CurrentMillis = millis();  // Get system clock ticks
  if (_Enable or _Control) {  // timer is enabled to run
    _Accumulator = _Accumulator + _CurrentMillis - _LastMillis;
    if (_Accumulator >= _Preset) {  // timer done?
      _Accumulator = _Preset;       // Don't let accumulator run away
      _Done = true;
    }
  }
  _LastMillis = _CurrentMillis;

  if (reset()) {  // Call virtual reset function.  Reset timer if
    //              returns true, based on derived class' criteria.
    _Done = false;
    _Accumulator = 0;
    _Control = false;  // ensures reset of latched type
  }
  /*-----
    Generate a one-scan momentary flag on _Done
    false-to-true transition
  */
  _Done_OSR = (_Done and _Done_Rising_Setup);  // timer done OS
  _Done_Rising_Setup = !_Done;

  /*----
    and another one-scan momentary flag on _Done
    true-to-false transition
  */
  _Done_OSF = (!_Done and _Done_Falling_Setup);  // timer not done OS
  _Done_Falling_Setup = _Done;

  /*
     Condition the timer running flag.
  */
  if ((_Enable or _Control) and !_Done and !_Reset) {
    _TimerRunning = true;
  } else _TimerRunning = false;

  return _Done;  // exit to caller
}  // end update function

/* ===================================================

              Update All Timers
   ---------------------------------------------------
   Loop through all timer objects and refresh them by
   successively calling update().
   ---------------------------------------------------
*/
void Multi_Timer::updateAllTimers() {
  for (Multi_Timer *ptr = first; ptr != nullptr; ptr = ptr->next) {
    ptr->update();
  }
}  // end of updateAllTimers

/* ================================================

            On Delay Timer class definition
 --------------------------------------------------------------------
 A timer which runs when reset is false and enable is true.
 It is reset otherwise. _Done goes true when preset is reached, 
 false otherwise.

 OnDelayTimer timer waveforms

enable      _________
       ____|         |___

                 ____
done  __________|    |___
           ^ Td ^ 

 --------------------------------------------------------------------
*/
OnDelayTimer::OnDelayTimer(unsigned long pre)
  : Multi_Timer(pre){};

OnDelayTimer::~OnDelayTimer() {
  }  // give a destructor

// Establish reset conditions for ON delay timer
bool OnDelayTimer::reset() {
  return (_Reset or !_Enable);
}  // End of OnDelay timer

/*=======================================================

               Off Delay Timer class definition
--------------------------------------------------------------------
A timer which runs when reset is false and _Enable is false
_Done goes false preset milliseconds after _Enable goes false.
It is reset otherwise. This timer object redefines the base
class update function.

OffDelayTimer waveforms

enable  ____          ___  
            |________|
            
done    _________     ___
                 |___|
            ^ Td ^ 

-------------------------------------------------------------------*/

OffDelayTimer::OffDelayTimer(unsigned long pre)
  : Multi_Timer(pre){};

OffDelayTimer::~OffDelayTimer() {
 }  // give a destructor

// update function/method is redefined here

bool OffDelayTimer::update() {
  bool enableOff = !_Enable;  // reverse sense of enable for TOF // original line
  _CurrentMillis = millis();  // Get system clock ticks
                              // Serial.println(enableOff);
  if (enableOff) {            // timer is enabled to run

    _Accumulator = _Accumulator + _CurrentMillis - _LastMillis;
    if (_Accumulator >= _Preset) {  // timer done?
      _Accumulator = _Preset;       // Don't let accumulator run away
      _Done = false;
    }
  }
  _LastMillis = _CurrentMillis;

  if (_Reset or !enableOff) {  // Find out if reset needed based on derived class' criteria.
    _Done = true;
    _Accumulator = 0;
  }
  /*
    ----- condition the timer running status
  */
  if ((enableOff) and _Done and !_Reset) {
    _TimerRunning = true;
  } else _TimerRunning = false;

  return !_Done;
}

bool OffDelayTimer::reset() {
  return (_Reset or _Enable);
}  // End of OffDelay timer

/*==============================================================

             Retentive timer class definition
--------------------------------------------------------------
A timer which accumulates when enabled and retains the
accumulated value when enable is false.  This timer 
type is reset only by making the reset input true.
* current version consumes 96 bytes RAM
------------------------------------------------------------*/

RetentiveTimer::RetentiveTimer(unsigned long pre)
  : Multi_Timer(pre){};

RetentiveTimer::~RetentiveTimer() {}  // give a destructor

// Establish reset conditions for retentive ON delay timer
bool RetentiveTimer::reset() {
  return (_Reset);
}  //End of Retentive timer

/*==============================================================

              Pulse Generator Timer Definition
-----------------------------------------------------------
A timer which runs when enabled and not reset. Resets
itself upon reaching preset then restarts the timing cycle
automatically as long as enable is true. The pulse output
is the _Done_OSF/OSR from the base class.
* current version consumes 60 bytes RAM
------------------------------------------------------------
*/
PulseGenTimer::PulseGenTimer(unsigned long pre)
  : Multi_Timer(pre){};

PulseGenTimer::~PulseGenTimer() {
  }  // give a destructor

// Establish reset conditions for pulse generator timer
bool PulseGenTimer::reset() {
  return (_Reset or _Done or !_Enable);
}  //End of class PulseGenTimer

/*============================================================

         Latched /Retentive/ timer class definition
--------------------------------------------------------------
A timer which starts when 'setCtrl' is called with a logic true
and if reset is false. Once started, timer continues, even
if _Enable subsequently goes false, until preset is reached.
This timer type is reset only by making the reset input true.
* current version consumes 92 bytes RAM
--------------------------------------------------------------*/

LatchedTimer::LatchedTimer(unsigned long pre)
  : Multi_Timer(pre){};

LatchedTimer::~LatchedTimer() {}  // give a destructor
/*
Caller starts Latched timer with a call to Start with strt
true. Once started the timer runs independently to preset.
_Control is used to isolate the latched timer from '_Enable'
in the base class which would override the latch. Because of
this, a Latched Timer has no need of _Enable at all.
*/
void LatchedTimer::Start(bool strt) {
  if (!strt) return;
  _Control = true;
}
// Establish reset conditions for self-latching ON delay timer
bool LatchedTimer::reset() {
  return (_Reset and _Done);
}  // End of class LatchedTimer

/*=================================================================

                   Watchdog timer
---------------------------------------------------------------
Runs when enable is true. A change of state on the 'control'
input resets the timer and restarts the timing cycle if enable
is true. Continuous cycling of the control input at a rate
faster than the time delay will cause the done status flag
to remain low indefinitely.
----------------------------------------------------------------
*/

WatchDogTimer::WatchDogTimer(unsigned long pre)
  : Multi_Timer(pre){ };

WatchDogTimer::~WatchDogTimer() {}  // give a destructor

bool WatchDogTimer::reset() {
  /*
    Generate a reset whenever control input changes
    or _Reset is true.
  */
  _WD_Rising_OS = (_Control and _WD_Rising_Setup);
  _WD_Rising_Setup = !_Control;
  _WD_Falling_OS = (!_Control and _WD_Falling_Setup);
  _WD_Falling_Setup = _Control;
  return (_WD_Falling_OS or _WD_Rising_OS or _Reset);

}  // End of WatchDog timer

/*=================================================================

                 FlasherTimer Timer class definition
-----------------------------------------------------------------
This timer runs and resets itself automatically when enabled.
It is basically an enhanced OnDelay timer. The second constructor
argument specifies an ON time for a special output (_FlashOut)
unique to this type. If _Enable goes false the timer is reset
immediately.

 Set onTime to some fraction of pre
*/
FlasherTimer::FlasherTimer(unsigned long pre, unsigned long onTime)
  : Multi_Timer(pre, onTime) {}

FlasherTimer::~FlasherTimer() {}  // give a destructor

bool FlasherTimer::reset() {
  return (!_Enable or _Done);
}

bool FlasherTimer::isFlashing() {

  // 4/2/24 : Moved _FlashOut code from update() to isFlashing()
  // so that _FlashOut only applies to FlasherTimer objects.
  //
  // Code below will turn on a common cathode LED for _OnTime
  // milliseconds when timing cycle starts.

  if (_Accumulator <= _OnTime) {
    _FlashOut = true;
  } else _FlashOut = false;

  return (_FlashOut and _Enable);
}

// 11/17/18 : Added method to runtime adjust _OnTime
// 12/18/18 : Added forced reset

void FlasherTimer::setOnTime(unsigned long newOnTime) {
  _OnTime = newOnTime;
  _Accumulator = _Preset;  // Force a reset when new onTime loaded
}
// End of FlasherTimer timer


Multi_Timer_V2.cpp

/* filename: Multi_Timer_V2.h  6/18/24

 https://forum.arduino.cc/t/renamed-iterating-through-a-series-of-objects-original-title-oop-this-pointer-questions/1244434

The thread noted above holds progression of origianl Multi_timer to
this version which incorporates a method to update all timers with
only one call by the user. Original required user to call update()
for each timer object instantiated.

If only one timer is instantiated you can still use the original
update() and save some flash and clock cycles.

Some basic timers with a (it is hoped) simple interface.
*/

#ifndef MULTI_TIMER_V2_H
#define MULTI_TIMER_V2_H

#include "Arduino.h"

class Multi_Timer {

private:
  // Variables for setting up list of objects (timers) for use by
  // Update_All_Timers().
  //
  static Multi_Timer *first;  // set location of first base class
  Multi_Timer *next;          // = nullptr;

public:
  Multi_Timer(unsigned long);                 // constructor declaration
  Multi_Timer(unsigned long, unsigned long);  // flasher constructor
  ~Multi_Timer();                             // destructor declaration

  // Enable/disable a timer
  void setEnable(bool);

  // Reset or unreset a timer
  void setReset(bool);

  // Find out if a timer is enabled
  bool isEnabled() const;

  // Find out if a timer is reset
  bool isReset() const;

  // Start signal for certain timers
  void setCtrl(bool);

  // Find out if a timer has reached preset value
  bool isDone() const;

  // Find out if a timer is progressing toward preset
  bool isRunning() const;

  // Returns state of timer done rising one-shot
  bool getDoneRose() const;

  // Returns state of timer done falling one-shot
  bool getDoneFell() const;

  // Find out the current accumulator of a timer
  unsigned long getCount() const;

  unsigned long pre;


protected:
  virtual bool reset() = 0;

public:
  /* ========================================================

   The 'update' function is the heart of the thing.
   ----------------------------------------------------
   Updates timer accumulated value & conditions flags '_Done',
  '_Done_Rising_OS', '_Done_Falling_OS' and '_TimerRunning'.
  
   Returns boolean status of _Done.  update() must be called
   periodically in loop to update the flags and accumulated
   value for each timer.
   ====================================================*/

  virtual boolean update();  // Updates the timer which calls it.

  /* =============================================================
              Update All Timers
   ---------------------------------------------------------------
   Loop through all timer objects and update them by successively
   calling update(). This relieves the user of adding a call to 
   xxx.update() for every timer instance.
   ----------------------------------------------------------------*/

  static void updateAllTimers();

protected:

  bool _Reset : 1;
  bool _Enable : 1;
  bool _Done : 1;
  bool _Control : 1;
  bool _TimerRunning : 1;
  bool _Done_OSF : 1;
  bool _Done_OSR : 1;
  bool _Done_Rising_Setup : 1;
  bool _Done_Falling_Setup : 1;
  bool _FlashOut;

  unsigned long _Accumulator;
  unsigned long _CurrentMillis;
  unsigned long _LastMillis;
  unsigned long _OnTime;
  unsigned long _Preset;



};  //end of base class Multi_Timer declarations

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   Define various types of timers which inherit/derive from Multi_Timer.
   The timers differ in functionality mainly by their reset methods.
   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/
//                  On Delay Timer class
//--------------------------------------------------------------------
// A timer which runs when reset is false and enable is true
// If reset is true or enable is false it is reset.
//--------------------------------------------------------------------

class OnDelayTimer : public Multi_Timer {
public:
  OnDelayTimer(unsigned long);  // constructor
  ~OnDelayTimer();              // destructor

  virtual bool reset();
};  // End of class OnDelayTimer

/*===================================================================

     Off delay timer - this timer redefines update()
 
Off delay timer functions like an on delay timer but enable and done
operate inversely to an on delay timer. Timer is reset and done is
true when enable is true.  Timing cycle begins when enable goes false
and after the delay time done goes false. 
//------------------------------------------------------------------
*/

class OffDelayTimer : public Multi_Timer {

public:
  OffDelayTimer(unsigned long);  //constructor
  ~OffDelayTimer();

  virtual bool update();

  virtual bool reset();
};  // End of class OffDelayTimer

/*==============================================================

             Retentive timer class definition
--------------------------------------------------------------
A timer which accumulates when enabled. Accumulated value is
retained when enable is false.  This timer type is reset only
by making the reset input true.
* current version consumes 96 bytes RAM
--------------------------------------------------------------*/

class RetentiveTimer : public Multi_Timer {
public:
  RetentiveTimer(unsigned long);

  ~RetentiveTimer();

  // Establish reset conditions for retentive ON delay timer
  virtual bool reset();
};  // End of class retentive timer

/*==============================================================

              Pulse Generator Timer
-----------------------------------------------------------
A timer which runs when enabled and not reset. Resets
itself upon reaching preset then restarts the timing cycle
automatically as long as enable is true.
* current version consumes 60 bytes RAM
------------------------------------------------------------*/

class PulseGenTimer : public Multi_Timer {
public:
  PulseGenTimer(unsigned long);

  ~PulseGenTimer();

  // Establish reset conditions for pulse generator timer
  virtual bool reset();
};  //End of class PulseGenTimer
//-------------------------------------------

/*============================================================

         Latched /Retentive/ timer class definition

--------------------------------------------------------------
Caller starts Latched timer with a call to Start with strt
true. Once started the timer runs independently to preset.
_Control is used to isolate the latched timer from '_Enable'
in the base class which would override the latch. Because of
this, a Latched Timer has no need of _Enable at all.
* current version consumes 92 bytes RAM
--------------------------------------------------------------*/

class LatchedTimer : public Multi_Timer {
public:
  LatchedTimer(unsigned long);
  ~LatchedTimer();
  // Caller starts Latched timer here with a pulse signal.
  void Start(bool);

  // Establish reset conditions for self-latching ON delay timer
  virtual bool reset();
};
// End of class LatchedTimer
//-----------------------------------------------------

/*=================================================================

                   Watchdog timer
---------------------------------------------------------------
>> Runs when enable is true. If enable is false timer will <<
>> function as an onDelay timer.                           <<

Whhen enabled a change of state on the 'control' input resets
the timer and restarts the timing cycle. Continuous cycling
of the control input at a rate faster than the time delay will
cause the done status flag to remain low indefinitely.
--------------------------------------------------------------*/

class WatchDogTimer : public Multi_Timer {
public:
  WatchDogTimer(unsigned long);
  ~WatchDogTimer();

  virtual bool reset();

private:
  bool _WD_Rising_OS : 1;
  bool _WD_Falling_OS : 1;
  bool _WD_Falling_Setup : 1;
  bool _WD_Rising_Setup : 1;
};
// End of class WatchDogTimer

/*
                 Flasher Timer class definition
-----------------------------------------------------------------
This timer runs and resets itself automatically when enabled.
It is basically an enhanced pulse generator timer. The second
constructor argument specifies an ON time for a special output
(_FlashOut) unique to this type. If _Enable goes false the
timer is reset immediately.

Flasher timer can be used as a pulse generator timer but the 
flashout and settable on time features will incur a penalty
in memory and clock cycle usage.

onTime must be some fraction of pre
--------------------------------------------------------------------*/

class FlasherTimer : public Multi_Timer {
public:
  FlasherTimer(unsigned long, unsigned long);
  ~FlasherTimer();

  virtual bool reset();

  // 4/2/24 : Moved _FlashOut decision from update() to getFlash()
  // so that _FlashOut code only applies to FlasherTimer objects.
  //

  bool isFlashing();

  // 11/17/18 : Added method to runtime adjust _OnTime
  // 12/18/18 : Added forced reset when _Ontime changed

  void setOnTime(unsigned long);
};
// end of class FlasherTimer
//---------------------------------------------

#endif
