// MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START * MACRO-START *
#define dbg(myFixedText, variableName) \
  Serial.print( F(#myFixedText " "  #variableName"=") ); \
  Serial.println(variableName);

#define dbgi(myFixedText, variableName,timeInterval) \
  { \
    static unsigned long intervalStartTime; \
    if ( millis() - intervalStartTime >= timeInterval ){ \
      intervalStartTime = millis(); \
      Serial.print( F(#myFixedText " "  #variableName"=") ); \
      Serial.println(variableName); \
    } \
  }

#define dbgc(myFixedText, variableName) \
  { \
    static long lastState; \
    if ( lastState != variableName ){ \
      Serial.print( F(#myFixedText " "  #variableName" changed from ") ); \
      Serial.print(lastState); \
      Serial.print( F(" to ") ); \
      Serial.println(variableName); \
      lastState = variableName; \
    } \
  }

#define dbgcf(myFixedText, variableName) \
  { \
    static float lastState; \
    if ( lastState != variableName ){ \
      Serial.print( F(#myFixedText " "  #variableName" changed from ") ); \
      Serial.print(lastState); \
      Serial.print( F(" to ") ); \
      Serial.println(variableName); \
      lastState = variableName; \
    } \
  }
// MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END * MACRO-END *


//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(115200);
  Serial.println("Setup-Start");
  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() {
  dbgc("ToL1",mState);
  //dbgi("ToL2",mState,1000);
  //dbgi("ToL3",digitalRead(startSwitch1),1000 );
  //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
//======================================================================