Hello everyone, I have a question. I have this simple code. It is just a countdown from 122 to 0, when a sensor is activated.
My question is, is it possible to run this code but with a different sensor signal, that starts a different countdown but in the same program and in the same Arduino, so I could see both countdowns on the serial monitor working at the same time ?
const int Sensor1 = 4;
const int LED = 3;
int Estadosensor = 0;
int contador1 = 122 ;
int Sensoractivado = 0;
void setup()
{
Serial.begin(9600);
pinMode(Sensor1, INPUT);
pinMode(LED, OUTPUT);
Serial.println("122 a 0");
}
void loop()
{
Estadosensor = digitalRead(Sensor1);
if (Estadosensor == HIGH )
{
Sensoractivado = 1;
if(Sensoractivado == 1 && contador1 != 0)
{
contador1--;
Serial.println(contador1);
delay (1000);
}
*`strong text`*
Sure, just start the millis timer, set two different flags of the time intervals you want, print out the countdown timer and just tab the output of one timer relative to the other.
Something like this, countdown 1 is what the code shows. My question is, if there is a way to show 2 or more, working independent of each one, but where all are shown in the same serial monitoring.
Here's an example of what I mean. I included noted in the comments.
This should give you a general idea. Note I didn't use tab after all, you could just space it out and call for a Serial.println(); every once in a while as needed.
Note, this is coded in the brutal style but I think gives you somewhere to start. I'm just an amateur hobbyist but maybe it will help get you going in the direction you're looking for. This requires no hardware, set baud to 115200 (or change baud rate) and is not a rewrite of your code, just an example how I would begin approaching this part of a complete project.
I used switch/case stuff in there
a) because I had a similar sketch already open that had it already
b) because I use them in virtually everything because of the possibilities it allows. There's a note in the sketch comments about why I like them
byte s1level;
byte s2level;
unsigned long s1currentTime;
unsigned long s2currentTime;
unsigned long s1lastTimeAround;
unsigned long s2lastTimeAround;
unsigned long s1Counter;
unsigned long s2Counter;
unsigned long thisS1Counter = 0;
unsigned long thisS2Counter = 0;
void setup() {
Serial.begin(115200);
s1level = 0;
s2level = 0;
s1currentTime = 0;
s2currentTime = 0;
s1lastTimeAround = 0;
s2lastTimeAround = 0;
s1Counter = 200;
s2Counter = 100;
}
void loop() {
// start free running timers, like starting a stopwatch.
s1currentTime = millis();
s2currentTime = millis();
// the first if below is the wrapper for your first sensorState
// for this example, I just set a condition is to check time every 2 seconds
// maybe you use a sensorState in place of this if condition
if (s1currentTime - s1lastTimeAround > 2000) {
// these switch/cases aren't needed, but do offer more options
// like modes in a video game say single or multiplayer (case 0 and 1)
switch (s1level) {
case 0:
modeZero();
s1Counter -= 10;
break;
case 1:
modeOne();
s1Counter -= 10;
break;
}
s1lastTimeAround = s1currentTime;
}
// this would be the wrapper for your second sensorState
// why not use the same arbitrary two seconds in this general example?
if (s2currentTime - s2lastTimeAround > 2000) {
switch (s2level) {
case 0:
modeTwo();
s2Counter -= 10;
break;
case 1:
modeThree();
s2Counter -= 10;
break;
}
s2lastTimeAround = s2currentTime;
}
}
void modeZero() {
Serial.print(" Sensor 1: ");
thisS1Counter = (s1currentTime - s1lastTimeAround + s1Counter);
Serial.print(thisS1Counter);
s1level += 1;
}
void modeOne() {
// you could do other stuff in here before resetting
s1level = 0;
}
void modeTwo() {
thisS2Counter = (s2currentTime - s2lastTimeAround + s2Counter);
Serial.print(" Sensor 2: ");
Serial.print(thisS2Counter);
s2level += 1;
}
void modeThree() {
// again maybe do other things, or don't
Serial.println();
s2level = 0;
}
When you need a sensor doing multitask on the same time, it is about how you use millis().
Millis is what you use to skip some part of your program when at certain milliseconds is reached to execute your program. If the time you set is not reached, the program will skip the execution and continue with next lines of your program.
For now, you probably cannot see what is difference with delay(); and seeing the projects on youtube gonna help.
If you kept the two countdowns synchronized, it could work using delays... sure.
For your own progress and use.... non-blocking timed code will solve a lot of future questions and enable sketches to do many things at the same time down to 10's of microseconds intervals.
