Timer code using machine States won't work

Projects Programming
1

Hi, I have an existing code that I have modified for another use. It goes thru the arduino code check, but I can't get it to work for a reason or another.
Would someone be so kind and direct me to right direction?
Here is piece of that code:

unsigned long TaskWait;
unsigned long currentmillis; 

const byte redLED      = 2;     //1 min still led
const byte redLED2     = 3;     //2 min start led
const byte redLED3     = 4;     //3 min still led
const byte redLED4     = 5;     //led 1
const byte redLED5     = 6;     //led 2
const byte redLED6     = 7;     //led 3
const byte redLED7     = 8;     //led 4
const byte redLED8     = 9;     //led 5
const byte redLED9     = 10;    //led Time to go
const byte startSwitch1 = 11;   //Driver change 1 min
const byte startSwitch2 = 12;   //Refuel 3 min
const byte startSwitch3 = 13;   //Reset the Timer

//define the available machine states that we can have for this sketch

enum States{
  stateZERO, stateONE, stateTWO, stateTHREE, stateFOUR, stateFIVE, stateSIX, stateSEVEN, stateEIGHT, stateNINE, stateTEN, stateELEVEN, stateTWELVE, 
  stateTHIRTEEN, stateFOURTEEN, stateFIFTEEN, stateSIXTEEN, stateSEVENTEEN, stateEIGHTEEN, stateNINETEEN, stateTWENTY, stateTWENTYONE, stateTWENTYTWO,
  stateTWENTYTHREE, stateTWENTYFOUR, stateTWENTYFIVE, stateTWENTYSIX, stateTWENTYSEVEN, stateTWENTYEIGHT, stateTWENTYNINE, stateTHIRTY, stateTHIRTYONE,
  stateTHIRTYTWO, stateTHIRTYTHREE, stateTHIRTYFOUR};

//mState = machine State
States mState = stateZERO;              //we start out in this machine state 

void setup()
{
  Serial.begin(9600);

  pinMode(redLED, OUTPUT);
  pinMode(redLED2, OUTPUT);
  pinMode(redLED3, OUTPUT);
  pinMode(redLED4, OUTPUT);
  pinMode(redLED5, OUTPUT);
  pinMode(redLED6, OUTPUT);
  pinMode(redLED7, OUTPUT);
  pinMode(redLED8, OUTPUT);
  pinMode(redLED9, OUTPUT);

  //starts with all leds off

  pinMode(startSwitch1, INPUT_PULLUP);    // 1min
  pinMode(startSwitch2, INPUT_PULLUP);    // 3min
  pinMode(startSwitch3, INPUT_PULLUP);    // Reset

  TaskWait = millis();                   //initialize the next wait time
  mState = stateZERO;                    //we start out in this machine state 

} //  >>>>>>>>>>>>>> E N D   O F   s e t u p ( ) <<<<<<<<<<<<<<<<<

void loop()
{
  //leave this line of code at the top
  currentmillis  = millis();

  //***************************

  //Put your non-blocking regular stuff here

  //****************************************************************
  //Check machine state and do things that must be done accordingly 
  switch (mState)
  {
    //***************************
  case stateZERO:
    {
      //let us see if the switch is pushed
      if(!digitalRead(startSwitch1)) // 1min driver change started
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);
        digitalWrite(redLED9,LOW);
  
        TaskWait = millis(); //initialize the next wait time
        mState = stateONE; //advance to the next state
      }

      if(!digitalRead(startSwitch2))  // Refuel started
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,HIGH);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWELVE; //advance to the next state
      }

      if(!digitalRead(startSwitch3))  // Switch to Reset timer       
      {
        digitalWrite(redLED8,HIGH); //
        digitalWrite(redLED4,HIGH);  //

        TaskWait =(2000UL); //initialize the next wait time
        mState = stateZERO; //advance to the next state

       }
    }
    break; //end case stateZERO

     //***************************

case stateONE: // 10s gone from driver change
    {
      if (CheckTime(TaskWait, 10000UL))
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWO;   //advance to the next state        
      }
    }

    break; //end case stateONE

     //***************************
     
  case stateTWO: // 20s gone from driver change
    {
      if (CheckTime(TaskWait,10000UL))
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHREE;   //advance to the next state        
      }
    }

    break; //end case stateTWO

    //***************************

and it goes on from here thru all states mentioned....

Best regards
Timo McKeown

2

Can you tell us what the code is doing that's wrong, or do you want us to work that out as well?

3

You must be amazingly patient to have typed all that out! Most people would just use an integer or a byte to hold the values 0 to 34. Why did you do it this way?

4

Hello tmckeown

In general - arrays and structs are your friends.
Don't duplicate code in your sketch. Write code once - use it multiple times.
And take a view into the BlinkWithOutDelay example to be found in the IDE to design and code some timer functions.

Have a nice day and enjoy coding in C++.

5

Hi Paul,

Looks like it doesn't do anything, just trying to figure out is it about the code or about the board I'm using?

6

Because I'm a newbie and this was the way I've done it before

7

I'm sure the code is doing something. Since we don't know what it is supposed to do then how can we help?

The issue could be in CheckTime() but we don't have a definition for that function.

8

The definition of CheckTime() is missing. Maybe the problem is in that function.

9

Hi,

It is a timer for endurance racing where it shows how much time you have left in the pits. You either have to be there for a 1 minute for a driver change or then 3 minutes if you refuel the car. There is 2 sets of leds. 1 set (3 leds) shows the minutes and 2nd set (5 leds) shows to 10 seconds. In the end when you can drive out of the outs it will blink all eight leds.

1 Like
10

Post either or both, but please a complete we can read it and compile it and run it sketch.

Based on what you have shared the code looks like there are rooms full of improvement opportunities.

TIA

a7

11

seems like you need a function to generate the LED settings simulating a timer counting down in 10 sec increments. not sure you need so many states, maybe none, since that function can be used for any timer amount

12

Thre is always room for improvement and I'm more than happy to receive ideas how to improve it. Here is the whole code

//State Machine test for Endurance racing timer
//LarryD and TMc, Geezer Racing Team

unsigned long TaskWait;
unsigned long currentmillis; 

const byte redLED      = 2;     //1 min still led
const byte redLED2     = 3;     //2 min start led
const byte redLED3     = 4;     //3 min still led
const byte redLED4     = 5;     //led 1
const byte redLED5     = 6;     //led 2
const byte redLED6     = 7;     //led 3
const byte redLED7     = 8;     //led 4
const byte redLED8     = 9;     //led 5
const byte redLED9     = 10;    //led Time to go
const byte startSwitch1 = 11;   //Driver change 1 min
const byte startSwitch2 = 12;   //Refuel 3 min
const byte startSwitch3 = 13;   //Reset the Timer

//define the available machine states that we can have for this sketch

enum States{
  stateZERO, stateONE, stateTWO, stateTHREE, stateFOUR, stateFIVE, stateSIX, stateSEVEN, stateEIGHT, stateNINE, stateTEN, stateELEVEN, stateTWELVE, 
  stateTHIRTEEN, stateFOURTEEN, stateFIFTEEN, stateSIXTEEN, stateSEVENTEEN, stateEIGHTEEN, stateNINETEEN, stateTWENTY, stateTWENTYONE, stateTWENTYTWO,
  stateTWENTYTHREE, stateTWENTYFOUR, stateTWENTYFIVE, stateTWENTYSIX, stateTWENTYSEVEN, stateTWENTYEIGHT, stateTWENTYNINE, stateTHIRTY, stateTHIRTYONE,
  stateTHIRTYTWO, stateTHIRTYTHREE, stateTHIRTYFOUR};

//mState = machine State
States mState = stateZERO;              //we start out in this machine state 

void setup()
{
  Serial.begin(9600);

  pinMode(redLED, OUTPUT);
  pinMode(redLED2, OUTPUT);
  pinMode(redLED3, OUTPUT);
  pinMode(redLED4, OUTPUT);
  pinMode(redLED5, OUTPUT);
  pinMode(redLED6, OUTPUT);
  pinMode(redLED7, OUTPUT);
  pinMode(redLED8, OUTPUT);
  pinMode(redLED9, OUTPUT);

  //starts with all leds off

  pinMode(startSwitch1, INPUT_PULLUP);    // 1min
  pinMode(startSwitch2, INPUT_PULLUP);    // 3min
  pinMode(startSwitch3, INPUT_PULLUP);    // Reset

  TaskWait = millis();                   //initialize the next wait time
  mState = stateZERO;                    //we start out in this machine state 

} //  >>>>>>>>>>>>>> E N D   O F   s e t u p ( ) <<<<<<<<<<<<<<<<<

void loop()
{
  //leave this line of code at the top
  currentmillis  = millis();

  //***************************

  //Put your non-blocking regular stuff here

  //****************************************************************
  //Check machine state and do things that must be done accordingly 
  switch (mState)
  {
    //***************************
  case stateZERO:
    {
      //let us see if the switch is pushed
      if(!digitalRead(startSwitch1)) // 1min driver change started
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);
        digitalWrite(redLED9,LOW);
  
        TaskWait = millis(); //initialize the next wait time
        mState = stateONE; //advance to the next state
      }

      if(!digitalRead(startSwitch2))  // Refuel started
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,HIGH);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWELVE; //advance to the next state
      }

      if(!digitalRead(startSwitch3))  // Switch to Reset timer       
      {
        digitalWrite(redLED8,HIGH); //
        digitalWrite(redLED4,HIGH);  //

        TaskWait =(2000UL); //initialize the next wait time
        mState = stateZERO; //advance to the next state

       }
    }
    break; //end case stateZERO

     //***************************

case stateONE: // 10s gone from driver change
    {
      if (CheckTime(TaskWait, 10000UL))
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWO;   //advance to the next state        
      }
    }

    break; //end case stateONE

     //***************************
     
  case stateTWO: // 20s gone from driver change
    {
      if (CheckTime(TaskWait,10000UL))
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHREE;   //advance to the next state        
      }
    }

    break; //end case stateTWO

    //***************************

  case stateTHREE:  // 30s gone from driver change
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateFOUR; //advance to the next state
      }
    }

    break;  //end of stateTHREE

    //***************************

  case stateFOUR:  // 40s gone from driver change
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateFIVE;  //advance to the next state
      }
    }

    break;  //end of stateFOUR

    //***************************

  case stateFIVE:  // 50s gone from driver change
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateSIX;  //advance to the next state
      }
    }

    break;  //end of stateFIVE

    //***************************

    case stateSIX:  // last five seconds
    {
      if (CheckTime(TaskWait, 5000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateSEVEN;  //advance to the next state
      }
    }

    break;  //end of stateSIX

     //*************************** 

      case stateSEVEN:  // last Four seconds
    {
      if (CheckTime(TaskWait, 5000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateEIGHT;  //advance to the next state
      }
    }

    break;  //end of stateSEVEN

     //*************************** 

      case stateEIGHT:  // last Three seconds
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateNINE;  //advance to the next state
      }
    }

    break;  //end of stateEIGHT

        //***************************

     case stateNINE:  // last two seconds
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTEN;  //advance to the next state
      }
    }

    break;  //end of stateEIGHT

        //***************************

     case stateTEN:  // last second
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateELEVEN;  //advance to the next state
      }
    }

    break;  //end of stateTEN

        //***************************

  case stateELEVEN:  // 1 min gone all green leds flashes
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED9,HIGH);
        delay(1000);
        digitalWrite(redLED9,LOW);
        delay(1000);
   
        (TaskWait = 15000UL); //initialize the next wait time
        mState = stateZERO; //advance to the next state
      }
    }

    break;  //end of stateELEVEN

    //***************************


    case stateTWELVE: // 10s gone from refueling
    {
      if (CheckTime(TaskWait, 10000UL))
      {
         digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHIRTEEN;   //advance to the next state        
      }
    }

    break; //end case stateTWELVE

     //***************************
     
  case stateTHIRTEEN: // 20s gone from refueling start
    {
      if (CheckTime(TaskWait,10000UL))
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateFOURTEEN;   //advance to the next state        
      }
    }

    break; //end case stateTHIRTEEN

    //***************************

  case stateFOURTEEN:  // 30s gone from refueling start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateFIFTEEN; //advance to the next state
      }
    }

    break;  //end of stateFOURTEEN

    //***************************

  case stateFIFTEEN:  // 40s gone from refueling start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateSIXTEEN;  //advance to the next state
      }
    }

    break;  //end of stateFIFTEEN

    //***************************

  case stateSIXTEEN:  // 50s gone from refuel start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateSEVENTEEN;  //advance to the next state
      }
    }

    break;  //end of stateSIXTEEN

    //***************************

    case stateSEVENTEEN:  // 60s gone from refuel start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,HIGH);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,LOW);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateEIGHTEEN;  //advance to the next state
      }
    }

    break;  //end of stateSEVENTEEN

     //*************************** 

     case stateEIGHTEEN: // 1min 10s gone from refueling
    {
      if (CheckTime(TaskWait, 10000UL))
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateNINETEEN;   //advance to the next state        
      }
    }

    break; //end case stateEIGHTEEN

     //***************************
     
  case stateNINETEEN: // 1min 20s gone from refueling start
    {
      if (CheckTime(TaskWait,10000UL))
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTY;   //advance to the next state        
      }
    }

    break; //end case stateNINETEEN

    //***************************

  case stateTWENTY:  // 1min 30s gone from refueling start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYONE; //advance to the next state
      }
    }

    break;  //end of stateTWENTY

    //***************************

  case stateTWENTYONE:  // 1 min 40s gone from refueling start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYTWO;  //advance to the next state
      }
    }

    break;  //end of stateTWENTYONE

    //***************************

  case stateTWENTYTWO:  // 1min 50s gone from refuel start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYTHREE;  //advance to the next state
      }
    }

    break;  //end of stateTWENTYTWO

    //***************************

    case stateTWENTYTHREE:  // 2 mins gone from refuel start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,HIGH);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,LOW);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYFOUR;  //advance to the next state
      }
    }

    break;  //end of stateTWENTYTHREE

     //*************************** 

         case stateTWENTYFOUR:  // 2 mins 10s gone from refuel start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYFIVE;  //advance to the next state
      }
    }

    break;  //end of stateTWENTYFOUR

     //*************************** 

     case stateTWENTYFIVE: // 2min 20s gone from refueling
    {
      if (CheckTime(TaskWait, 10000UL))
      {

        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYSIX;   //advance to the next state        
      }
    }

    break; //end case stateTWENTYFIVE

     //***************************
     
  case stateTWENTYSIX: // 2min 30s gone from refueling start
    {
      if (CheckTime(TaskWait,10000UL))
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYSEVEN;   //advance to the next state        
      }
    }

    break; //end case stateTWENTYSIX

    //***************************

  case stateTWENTYSEVEN:  // 2min 40s gone from refueling start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYEIGHT; //advance to the next state
      }
    }

    break;  //end of stateTWENTYSEVEN

    //***************************

  case stateTWENTYEIGHT:  // 2 min 50s gone from refueling start
    {
      if (CheckTime(TaskWait, 10000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTWENTYNINE;  //advance to the next state
      }
    }

    break;  //end of stateTWENTYEIGHT

    //***************************

  case stateTWENTYNINE:  // 2 mins 55s gone from refuel start
    {
      if (CheckTime(TaskWait, 5000UL)) 
      {

        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,HIGH);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHIRTY;  //advance to the next state
      }
    }

    break;  //end of stateTWENTYNINE

    //***************************

    case stateTHIRTY:  // last four seconds
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,HIGH);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHIRTYONE;  //advance to the next state
      }
    }

    break;  //end of stateTHIRTY

     //*************************** 

      case stateTHIRTYONE:  // last three seconds
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,HIGH);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHIRTYTWO;  //advance to the next state
      }
    }

    break;  //end of stateTHIRTYONE

        //***************************

     case stateTHIRTYTWO:  // last two seconds
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,HIGH);
        digitalWrite(redLED5,HIGH);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHIRTYTHREE;  //advance to the next state
      }
    }

    break;  //end of stateTHIRTYTWO

        //***************************

     case stateTHIRTYTHREE:  // last second
    {
      if (CheckTime(TaskWait, 1000UL)) 
      {
        digitalWrite(redLED,LOW);
        digitalWrite(redLED2,LOW);
        digitalWrite(redLED3,LOW);
        digitalWrite(redLED4,LOW);
        digitalWrite(redLED5,LOW);
        digitalWrite(redLED6,LOW);
        digitalWrite(redLED7,LOW);
        digitalWrite(redLED8,LOW);

        TaskWait = millis(); //initialize the next wait time
        mState = stateTHIRTYFOUR;  //advance to the next state
      }
    }

    break;  //end of stateTHIRTYTHREE

        //***************************

  case stateTHIRTYFOUR:  // 3 min gone all green leds flashes
    {
      if (CheckTime(TaskWait, 0UL)) 
      {
        digitalWrite(redLED9,HIGH);
        delay(1000);
        digitalWrite(redLED9,LOW);
        delay(1000);

        TaskWait = (15000UL); //initialize the next wait time
        mState = stateZERO; //advance to the next state
      }
    }
    break;  //end of stateTHIRTYTHREE

    //***************************

 
  } // END of switch

} //  >>>>>>>>>>>>>> E N D   O F   l o o p ( ) <<<<<<<<<<<<<<<<<

//======================================================================
//                       F U N C T I O N S
//======================================================================

//***************************
//Delay time expired function
boolean CheckTime(unsigned long &lastMillis, unsigned long wait) 
{
  //is the time up for this task?
  if (currentmillis - lastMillis >= wait) 
  {
    lastMillis += wait;  //get ready for the next iteration

    return true;
  }
  

  return false;
} //END of CheckTime()

//***************************

//======================================================================
//                       E N D   O F   C O D E
//======================================================================
13

Here is a wokwi simulation of your code with serial printing through debug-macros.
As far as I can tell it this code works

Setup-Start
"ToL1" mState changed from 0 to 1
"ToL1" mState changed from 1 to 2
"ToL1" mState changed from 2 to 3
"ToL1" mState changed from 3 to 4
"ToL1" mState changed from 4 to 5
"ToL1" mState changed from 5 to 6
"ToL1" mState changed from 6 to 7

best regards Stefan

14

when i tried simulating it, for the 1 minute case, it went thru state 1-11, returning to state 0. shouldn't it just go thru 6 states?

15

at least in the simulation the code is doing what is written in the code

case stateELEVEN:  // 1 min gone all green leds flashes
      {
        if (CheckTime(TaskWait, 10000UL))
        {
          digitalWrite(redLED9, HIGH);
          delay(1000);
          digitalWrite(redLED9, LOW);
          delay(1000);

          (TaskWait = 15000UL); //initialize the next wait time
          mState = stateZERO; //advance to the next state
        }
      }

Setup-Start
"ToL1" mState changed from 0 to 1
"ToL1" mState changed from 1 to 2
"ToL1" mState changed from 2 to 3
"ToL1" mState changed from 3 to 4
"ToL1" mState changed from 4 to 5
"ToL1" mState changed from 5 to 6
"ToL1" mState changed from 6 to 7
"ToL1" mState changed from 7 to 8
"ToL1" mState changed from 8 to 9
"ToL1" mState changed from 9 to 10
"ToL1" mState changed from 10 to 11
"ToL1" mState changed from 11 to 0

best regards Stefan

16

looks this over

// 1/3 minute countdown timer using LEDs

#undef MyHW
#ifdef MyHW
# include "sim.hh"

const byte PinLeds [] = { 13, 12, 11,   7, 6, 5, 4, 10 };

const byte startSwitch1 = A1;   //Driver change 1 min
const byte startSwitch2 = A2;   //Refuel 3 min
const byte startSwitch3 = A3;   //Reset the Timer

#else
const byte PinLeds [] = { 10, 9, 8,   7, 6, 5, 4, 3 };

const byte startSwitch1 = 11;   //Driver change 1 min
const byte startSwitch2 = 12;   //Refuel 3 min
const byte startSwitch3 = 13;   //Reset the Timer
#endif

// -----------------------------------------------------------------------------
const int  Nleds = sizeof(PinLeds);
enum { Off = HIGH, On = LOW };

unsigned long msecPeriod;
unsigned long msecLst;
unsigned long msec;

const int TimerTic  = 1000;
const int OneMin    = 6;
const int ThreeMin  = 3 * OneMin;

int secs;

// -------------------------------------
void
timerDisp (void)
{
    int nMin    =  secs / OneMin;
    int nSec    =  secs % OneMin;

    int bitMins = (1 << (secs / OneMin)) - 1;
    int bitSecs = (1 << (secs % OneMin)) - 1;
    int bits    = bitMins << (OneMin-1) | bitSecs;

    char s [80];
    sprintf (s, " %6d - %d %d - %x %2x  %2x   ",
            secs, nMin, nSec, bitMins, bitSecs, bits);
    Serial.print (s);

    int m = 0x80;
    for (int i = 0; i < Nleds; i++, m >>= 1)  {
        if (m & bits)  {
            Serial.print ('*');
            digitalWrite (PinLeds [i], On);
        }
        else {
            Serial.print ('_');
            digitalWrite (PinLeds [i], Off);
        }
    }
    Serial.println ();
}

// -------------------------------------
void
timerSet (
    int nSecs )
{
    msecLst    = msec;
    msecPeriod = TimerTic;
    secs       = nSecs;
    timerDisp ();
}

// -------------------------------------
void timer ()
{
    if (0 == msecPeriod || msec - msecLst < msecPeriod)
        return;         // both timer disabled OR not expired

    msecLst = msec;

    secs--;
    timerDisp ();

    if (0 == secs)
        msecPeriod = 0;     // disables timer
}

// -----------------------------------------------------------------------------
void loop ()
{
    msec  = millis ();
    timer ();

    if (LOW == digitalRead (startSwitch3))
        ;
    else if (0 == secs) {
        if (LOW == digitalRead (startSwitch1))
            timerSet (OneMin);
        else if (LOW == digitalRead (startSwitch2))
            timerSet (ThreeMin);
    }
}

// -----------------------------------------------------------------------------
void setup ()
{
    Serial.begin (9600);

    for (int i = 0; i < Nleds; i++)  {
        pinMode      (PinLeds [i], OUTPUT);
        digitalWrite (PinLeds [i], Off);
    }

    pinMode (startSwitch1, INPUT_PULLUP);    // 1min
    pinMode (startSwitch2, INPUT_PULLUP);    // 3min
    pinMode (startSwitch3, INPUT_PULLUP);    // Reset
}
17

@gcjr

especially

and

18

@StefanL38 sorry you don't understand

the OP can ask if he's interested. but many OPs just want a solution

1 Like
19

It changes after statesix that each row 2 led will count down the last five seconds. That's why it goes to state11

20

i'm not sure what that means. from the code is looks like when only the last LED is one, they start turning back on in the reverse sequence?