Maker Pro
Arduino

DOME

March 23, 2022 by Garnet Albright
Share
banner

Close S1 and the yellow and red should light, press the S2 switch and the green should light if your right.

Trying to blink some LEDs

#include <EEPROM.h>

// eeprom address
#define STATE       0
#define CODE_STATE  1

// pin mapping for uno board
#define S1          2
#define S2          3

#define LED_YELLOW  4
#define LED_RED     5
#define LED_GREEN   6

// adjustable parameters
#define BLINK_HZ        1.0
#define Timer           30000
#define HOLD_TIME       3000
#define CORRECT_PULSES  2

// enums
enum {OPEN = LOW, CLOSE = HIGH};
enum {NOCODE = 0, CORRECT = 1, INCORRECT = 2};

// global variables
bool timer_run = false;
uint8_t machine_state = 0;
uint8_t code_state = 0;
uint8_t Btn_Pulse = 0;
uint8_t Btn_last_state = 0;
uint32_t Blink_Millis = 0;
uint32_t Timer_Millis = 0;
uint32_t Btn_press_time = 0;
uint32_t old_time = 0;

void Off_LEDs(void)
{
  digitalWrite(LED_YELLOW,LOW);
  digitalWrite(LED_RED,LOW);
  digitalWrite(LED_GREEN,LOW);   
}

void Blink_GREEN_LED(uint8_t t)
{
  float t_f = (1.0/BLINK_HZ)/2.0;
  uint32_t t_i = (uint32_t)(t_f*1000.0); 

  digitalWrite(LED_GREEN,LOW);
  
  for(int x = 0; x < t*2; x++)
  {
    digitalWrite(LED_GREEN,!digitalRead(LED_GREEN));
    delay(t_i);
  }
  digitalWrite(LED_GREEN,LOW);
}

void Blink_RED_LED(void)
{
  float t_f = (1.0/BLINK_HZ)/2.0;
  uint32_t t_i = (uint32_t)(t_f*1000.0); 
  
  if((millis() - Blink_Millis) >= t_i)
  {
    digitalWrite(LED_RED, !digitalRead(LED_RED));
    Blink_Millis = millis();
  }
}

void Get_Code(void)
{
  if(digitalRead(S1) == OPEN && digitalRead(S2) == OPEN)  // Item # 3
  {
    Btn_last_state = OPEN;
    Btn_Pulse = 0;
    Off_LEDs();

    if(machine_state == 1)
    {
      if((millis() - Timer_Millis) > Timer)
      {
        timer_run = false;
      }      
    }

    if(code_state == CORRECT)    
    {
      code_state = NOCODE;
      // control goes to Item # 1
      machine_state = 0;
      EEPROM.update(STATE,machine_state); 
      EEPROM.update(CODE_STATE,code_state);    
    }
  }
  else if(digitalRead(S1) == CLOSE)  // Item # 4
  {
    if(code_state != CORRECT) Blink_RED_LED();
    
    if(machine_state == 1)
    {
      if((millis() - Timer_Millis) > Timer)
      {
        timer_run = false;
      }
      if(timer_run) digitalWrite(LED_YELLOW,HIGH);
      else
      {
        Btn_Pulse = 0; 
        Btn_last_state = OPEN;
        timer_run = false; 
        if(code_state != CORRECT) digitalWrite(LED_YELLOW,LOW);
        machine_state = 2;
        EEPROM.update(STATE,machine_state);
      }       
    }
    
    if(Btn_last_state == CLOSE && digitalRead(S2) == OPEN)         // button released Item # 4
    {
      Btn_last_state = OPEN;
      // if button is released
      Btn_Pulse++;
      Serial.println("Button Released");
    }
    else if(Btn_last_state == OPEN && digitalRead(S2) == CLOSE)    // button pressed Item # 5b
    {
      Btn_last_state = CLOSE;
      Serial.println("Button Pressed");
      Btn_press_time = millis();
      do
      {
        if(code_state != CORRECT) Blink_RED_LED(); 
        if((millis() - Btn_press_time) >= HOLD_TIME) // if button press and hold
        {
          //Serial.print("Press and Hold Time : "); Serial.println((millis() - Btn_press_time)/1000);
          //delay(1000); // wait for 1 second
          if(Btn_last_state == CLOSE)
          {         
            if(Btn_Pulse == CORRECT_PULSES)           // correct code Item # 5c
            {
              Serial.println("Correct Code");
              if(code_state != CORRECT)
              {
                digitalWrite(LED_RED,LOW);
                Blink_GREEN_LED(3);               
                digitalWrite(LED_GREEN,HIGH);
                digitalWrite(LED_YELLOW,HIGH);
                code_state = CORRECT;
                EEPROM.update(CODE_STATE,code_state);
                Blink_Millis = millis();
              }
            }
            else // reset code Item # 5b
            {
              Serial.println("Reset Code or any Unknown Code");
              if(code_state != CORRECT)
              {
                if(!timer_run) digitalWrite(LED_YELLOW,LOW);
                digitalWrite(LED_RED,LOW);
                // blink leds
                Blink_GREEN_LED(2); 
                code_state = INCORRECT;
                EEPROM.update(CODE_STATE,code_state);
                Blink_Millis = millis();
              }
            }
            Btn_last_state = OPEN;
            Btn_Pulse = 0;
          }
        }                 
      }while(digitalRead(S2) == CLOSE);
    }
  } 
}

void run_state_machine(void)
{
  switch(machine_state)
  {
    case 0:
          if(digitalRead(S1) == OPEN && digitalRead(S2) == OPEN)  Off_LEDs(); // Item # 1
          else if(digitalRead(S1) == CLOSE && digitalRead(S2) == OPEN)        // Item # 2
          {
            Serial.println("Timer Start");
            digitalWrite(LED_RED,LOW);
            digitalWrite(LED_GREEN,LOW);
            digitalWrite(LED_YELLOW,HIGH);
            Blink_Millis = millis();
            Timer_Millis = millis();
            machine_state = 1;
            timer_run = true;
            //EEPROM.update(STATE,machine_state);
          }
    break;     

    case 1: // blink red LED for timer seconds Item # 2
          if((millis() - old_time) >= 1000)
          {
            Serial.print("Time : "); Serial.println((millis() - Timer_Millis)/1000);
            old_time = millis();
          }
          Get_Code();
    break; 

    case 2:
        Get_Code();
    break; 
    
    default:
        machine_state = 0;
        EEPROM.update(STATE,machine_state);
    break;
  }
}

// resume system state
void Resume_State(void)
{
  machine_state = EEPROM.read(STATE);
  code_state = EEPROM.read(CODE_STATE);
  Serial.println(machine_state);
  Serial.println(code_state);
  switch(machine_state)
  {
    case 0:
        code_state = NOCODE;
        EEPROM.update(CODE_STATE,code_state);
    break;
    
    case 1:
        digitalWrite(LED_RED,LOW);
        digitalWrite(LED_GREEN,LOW);
        digitalWrite(LED_YELLOW,HIGH);
        Blink_Millis = millis();
        Timer_Millis = millis();
    break;
                
    case 2:
        Btn_Pulse = 0; 
        Btn_last_state = OPEN;
        
        switch(code_state)
        {
          case NOCODE:
          digitalWrite(LED_YELLOW,HIGH);
          break;
          
          case CORRECT:
              code_state = 0;
              machine_state = 0;
              EEPROM.update(STATE,machine_state);
              EEPROM.update(CODE_STATE,code_state);
          break; 
          
          case INCORRECT:
              digitalWrite(LED_YELLOW,HIGH);
              code_state = 0;
              EEPROM.update(CODE_STATE,code_state);
          break;
          
          default:
              code_state = 0;
              EEPROM.update(CODE_STATE,code_state);
          break;             
        }
    break;

    default:
    break;        
  }
}

void setup() 
{
  // put your setup code here, to run once:
  Serial.begin(9600);
  // configure pins as input/output
  pinMode(S1,INPUT);
  pinMode(S2,INPUT);
  pinMode(LED_YELLOW,OUTPUT);
  pinMode(LED_RED,OUTPUT);
  pinMode(LED_GREEN,OUTPUT);
  // initially LEDs are off
  Off_LEDs();
  // resume the system state
  Resume_State();
}

void loop() 
{
  // put your main code here, to run repeatedly:
  run_state_machine();
}

Related Content

Comments


You May Also Like