LarryD:
Just saying those who want to really get into programming will grasp the BWD technique and run with it.
Those who don't want to get into programming write their one program to get a mark then proceed with their degree.
I use a structure:
//Blink without Delay skeleton example using a structure.
//LarryD
//======================================================================
struct timer
{
//lastMillis = the time this "timer" was (re)started
//waitMillis = delay time (mS) we are looking for. You can use math 60601000 for 1 hour
//restart = do we start "this timer" again and again
//enableFlag = is "this timer" enabled/allowed to be accessed
//**********************
//For each timer object you need:
//Example:
// timer myTimer = //give the timer a name "myTimer"
// {
// 0, 200UL, true, true //lastMillis, waitMillis, restart, enableFlag
// };
// You have access to:
// myTimer.lastMillis, myTimer.waitMillis, myTimer.restart, myTimer.enableFlag, myTimer.CheckTime()
//**********************
unsigned long lastMillis;
unsigned long waitMillis;
bool restart;
bool enableFlag;
bool CheckTime() //Delay time expired function "CheckTime()"
{
//is the time up for this task?
if (enableFlag && millis() - lastMillis >= waitMillis)
//Note: if delays of < 2 millis are needed use micros() and adjust waitMillis as needed
{
//should this start again?
if(restart)
{
//get ready for the next iteration
lastMillis += waitMillis;
}
//time was reached
return true;
}
//time was not reached
return false;
} //END of CheckTime()
}; //END of structure timer
//======================================================================
//**********************************************************************
//Let's create 6 timer objects and initialize them in this sketch
//**********************************************************************
timer pin13 = //create timer pin13
{
0, 200UL, true, true //lastMillis, waitMillis, restart, enableFlag
};
//***************************
timer pin12 = //create timer pin12
{
0, 31000UL, true, true //lastMillis, waitMillis, restart, enableFlag
};
//**************************
timer pin11 = //create timer pin11
{
0, 101000UL, true, true //lastMillis, waitMillis, restart, enableFlag
};
//**************************
timer pin10 = //create timer pin10
{
0, 61000UL, true, true //lastMillis, waitMillis, restart, enableFlag
};
//**************************
timer Toggle10 = //create timer Toggle10
{
0, 50UL, true, true //lastMillis, waitMillis, restart, enableFlag
};
//***************************
timer checkSwitches = //create timer checkSwitches
{
0, 50UL, true, true //lastMillis, waitMillis, restart, enableFlag
};
//***************************
byte lastMySwitchState = 1; //for mySwitch on Pin 2
byte counter = 0;
const byte Pin13 = 13;
const byte Pin12 = 12;
const byte Pin11 = 11;
const byte Pin10 = 10;
const byte Pin9 = 9;
const byte mySwitch = 2;
//**********************************************************************
void setup()
{
Serial.begin(9600);
pinMode(Pin13,OUTPUT);
pinMode(Pin12,OUTPUT);
pinMode(Pin11,OUTPUT);
pinMode(Pin10,OUTPUT);
pinMode(Pin9, OUTPUT);
digitalWrite(Pin13,LOW);
digitalWrite(Pin12,LOW);
digitalWrite(Pin11,LOW);
digitalWrite(Pin10,LOW);
digitalWrite(Pin9, LOW);
pinMode(mySwitch,INPUT_PULLUP);
} // >>>>>>>>>>>>>> E N D O F s e t u p ( ) <<<<<<<<<<<<<<<<<
void loop()
{
//Below are examples demonstrating different timing situations
//***************************
//example 1 Toggle Pin13 every 200ms
if (pin13.CheckTime())
{
//Toggle Pin13
digitalWrite(Pin13,!digitalRead(Pin13));
//if you only want this section of code to happen once
//uncomment the next line
//pin13.enableFlag = false;
}
//***************************
//example 2 After 3 seconds, Pin12 goes and stays HIGH
if (pin12.CheckTime())
{
//Make Pin12 HIGH now
digitalWrite(Pin12,HIGH);
//disable timing section of code
pin12.enableFlag = false;
}
//***************************
//example 3 Pin11 is HIGH for 10 seconds, then goes and stays LOW
if (pin11.enableFlag && !pin11.CheckTime())
{
digitalWrite(Pin11,HIGH);
}
//10 seconds is now up now, leave the Pin11 LOW
else
{
digitalWrite(Pin11,LOW);
//disable timing section of code
pin11.enableFlag = false;
}
//***************************
//example 4 For 6 seconds, toggle Pin10
if (pin10.enableFlag && !pin10.CheckTime())
{
//example 5 Toggling Pin10 every 50mS
if(Toggle10.CheckTime())
{
//toggle Pin10
digitalWrite(Pin10,!digitalRead(Pin10));
}
}
//6 seconds is now up, toggling is stopped
else
{
digitalWrite(Pin10,LOW);
//disable timing section of code
pin10.enableFlag = false;
}
//***************************
//example 6 Is it time to check the switches?
if (checkSwitches.CheckTime())
{
//time to read the switches
Switches();
}
//**********************************
//Put other non-blocking stuff here
//**********************************
} // >>>>>>>>>>>>>> E N D O F l o o p ( ) <<<<<<<<<<<<<<<<<
//======================================================================
// F U N C T I O N S
//======================================================================
//**********************************************************************
//switches are checked every checkSwitches.waitMillis milli seconds
//no minimum switch press time is validated with this code (i.e. No glitch filter)
void Switches()
{
boolean thisState; //re-usable for all the switches
//*************************** mySwitch Pin 2 code
//check if this switch has changed state
thisState = digitalRead(mySwitch);
if (thisState != lastMySwitchState)
{
//update the switch state
lastMySwitchState = thisState;
//This switch position has changed, let's do some stuff
//"HIGH condition code"
//switch goes from LOW to HIGH
if(thisState == HIGH)
{
//example: LED on Pin9 is Push ON, Push OFF
digitalWrite(Pin9,!digitalRead(Pin9));
}
//"LOW condition code"
//switch goes from HIGH to LOW
else
{
//example: display the current switch push count
Serial.println(++counter);
}
} //END of mySwitch Pin 2 code
//******************************************
//similar code for other switches goes here
//******************************************
} //END of Switches()
//======================================================================
// E N D O F C O D E
//======================================================================
.
I like the restart feature and your structure is clean I'm defiantly keeping this code for further study Thanks!
My hope is for something simple Like
#define runAfter(t,Clock) for (static unsigned long _ATimer = Clock; (unsigned long)(Clock - _ATimer) >= (t); _ATimer = Clock)
// The above line if approved would become part of the arduino IDE 's base code
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
runAfter(1000, millis()) {
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // Alternate LED on and off
}
}
Z
