A mono-flop functionality based on a state-machine
A question in the forum inspired me to write the basic code with this functionality:
code is waiting for a sensor-signal that if the signal rushes in switches an output "ON"
keep output "ON" for some time
if this "active"-time is over switch output back to "OFF"
refuse to RE-trigger switching "ON" for some time
if this lock-time is over start new with
waiting for a sensor-signal that if the signal rushes in
There is also the possability to have a delay between the sensor-signal rushing in and switching the output "ON" (this is called InitialWaitTime)
if you don't want an inital waittime simply set the value to 0 (initial waittime 0 milliseconds)
If you don't want a locktime before RE-triggering simply set locktime to 0. (locktime 0 milliseconds)
all this is done in a non-blocking way which enables to do something "in parallel" in the code
demonstrated by blinking the onboard-LED
Such a functionality is somehow advanced and this requires quite some lines of code and somehow advanced coding-teqniues like the state-machine and non-blocking timing.
The code has serial output that makes visible in the serial monitor which lines of code are executed.
Newcomers are the best experts to judge easyness of understanding of explanations.
and to give feedback how to improve the explanations through their questions.
If you have any questions how this demo-code can be adapted to your differing needs feel free to ask questions and I will answer them.
const byte triggerInputPin = 3;
const byte triggerIsActive = LOW; // LOW o HIGH
const byte PinToSwitch = 12;
const byte OutPutOn = HIGH;
// the attention-mark ! is the not-operator which inverts the value
// !true = false !false = true !HIGH = LOW !LOW = HIGH
const byte OutPutOff = !OutPutOn;
// set InitialWaitTime to 0 if you don't want a delay between triggering and switching output
unsigned long InitialWaitTime = 2000;
unsigned long ActiveTime = 3000;
unsigned long LockedTime = 10000;
unsigned long MonoFlopTimer; // variable used for non-blocking timing
// constants of the state-machine
const byte sm_Idling = 0;
const byte sm_InitialWait = 1;
const byte sm_Activated = 2;
const byte sm_Locked = 3;
byte MonoFlopState = sm_Idling; // state-variable of the state-machine
void PrintFileNameDateTime() {
Serial.println( F("Code running comes from file ") );
Serial.println( F(__FILE__) );
Serial.print( F(" compiled ") );
Serial.print( F(__DATE__) );
Serial.print( F(" ") );
Serial.println( F(__TIME__) );
}
// easy to use helper-function for non-blocking timing
boolean TimePeriodIsOver (unsigned long &startOfPeriod, unsigned long TimePeriod) {
unsigned long currentMillis = millis();
if ( currentMillis - startOfPeriod >= TimePeriod ) {
// more time than TimePeriod has elapsed since last time if-condition was true
startOfPeriod = currentMillis; // a new period starts right here so set new starttime
return true;
}
else return false; // actual TimePeriod is NOT yet over
}
unsigned long MyTestTimer = 0; // Timer-variables MUST be of type unsigned long
const byte OnBoard_LED = 13;
void BlinkHeartBeatLED(int IO_Pin, int BlinkPeriod) {
static unsigned long MyBlinkTimer;
pinMode(IO_Pin, OUTPUT);
if ( TimePeriodIsOver(MyBlinkTimer, BlinkPeriod) ) {
digitalWrite(IO_Pin, !digitalRead(IO_Pin) );
}
}
void setup() {
Serial.begin(115200);
Serial.println("Setup-Start");
PrintFileNameDateTime();
pinMode(triggerInputPin,INPUT_PULLUP); // INPUT_PULLUP
digitalWrite(PinToSwitch,OutPutOff);
pinMode(PinToSwitch,OUTPUT);
}
void MonoFlopStateMachine() {
switch (MonoFlopState) {
case sm_Idling:
// check if trigger-input reads triggering signal
if (digitalRead(triggerInputPin) == triggerIsActive) {
MonoFlopTimer = millis(); // make snapshot of time
MonoFlopState = sm_InitialWait; // set next state of state-machine
Serial.println( F("trigger-signal detected start inital wait") );
}
break; // IMMIDIATELY jump down to END OF SWITCH
case sm_InitialWait:
// wait until initial waittime has passed by
if ( TimePeriodIsOver(MonoFlopTimer,InitialWaitTime) ) {
// if waittime HAS passed by
MonoFlopTimer = millis(); // make new snapshot of time
digitalWrite(PinToSwitch,OutPutOn); // switch IO-Pin to activated state
MonoFlopState = sm_Activated; // set next state of state-machine
Serial.println( F("InitialWaitTime is over switching output to ACTIVE") );
}
break; // IMMIDIATELY jump down to END OF SWITCH
case sm_Activated:
// check if time the IO-pin shall be active is over
if ( TimePeriodIsOver(MonoFlopTimer,ActiveTime) ){
// if activetime of IO-pin IS over
MonoFlopTimer = millis(); // make new snapshot of time
digitalWrite(PinToSwitch,OutPutOff); // switch IO-pin to DE-activated state
MonoFlopState = sm_Locked; // set next state of state-machine
Serial.println( F("Activetime is over switching output to IN-active") );
Serial.println( F("and starting locktime") );
}
break; // IMMIDIATELY jump down to END OF SWITCH
case sm_Locked:
// check if time the logic shall be locked against too early re-triggering is over
if ( TimePeriodIsOver(MonoFlopTimer,LockedTime) ){
// if locked time IS over
Serial.println( F("locktime is over change state to idling") );
MonoFlopState = sm_Idling; // set state-machine to idle-mode
}
break; // IMMIDIATELY jump down to END OF SWITCH
} // END OF SWITCH
}
void loop() {
BlinkHeartBeatLED(OnBoard_LED, 250);
// run down code of state-machine over and over again
// all the logic for reading in sensor-signal and switching output ON/OFF
// is inside the function
MonoFlopStateMachine();
}here is a simulation on WOKWI
WOKWI-Simulation Monoflop-StateMachine
best regards Stefan