Reddit arduino door sensor alarm 1.0

/*
  August 12, 2019
  Reddit example - door sensor with RGB LED

  Board - not specified
  hardware - NO button, some type of RGB LED arrangement (not specified, may be 3 separate single LEDs or one 4-wire common cathode LED)





  Some of these criticisms may seem like overkill for a small Arduino program.
  When you move to writing larger and larger programs, the main factor in how easy you can continue is how well you have organized the code already written.

  --Don't use cryptic meaningless variable names. The name of the variable should explain clearly what it is used for.

  --Split the program up into separate functions. This allows you to place temporary Serial.print() statements into the separate functions,
    to allow you to easily visualize when they are being called, as well as using more Serial.print statements to show any values that they are using.

  --Don't use cryptic function names even_if_it_means_writing_out_really_long_function_names_like_this(). The function should only do ONE thing, and the name of the function should explain clearly what it does.
    If you need to go and look at what it does more than a couple times, then you either didn't name the function well, or you have too many things being done inside it.

  There is no performance penalty for using long variable and function names (they aren't used in the compiled code anyway) and there is very little memory penalty for splitting a bunch of statements into separate functions.

  Some people try to use short obtuse variable and function names, believing that they are saving time by not typing as much.
  As the program gets larger--to 10K - 20K - 50K+ lines, those short names will kill your productivity,,,, until you go back and rename them properly.
  The whole thing is much easier to work with if you just name them properly from the beginning.
*/

//int DoorSensor = A0;
//int buzz = 9;

//int LT = 3; //blue
//int LTR = 5; //red
//int LTG = 6; //green

/*
   Below--the variables are renamed with understandable names.
   Always name your variables "what they are", in easily readable form.
   Name I/O pins ending in '_pin' so you know that is an I/O pin. Use the _pin ending ONLY for pin ID variables.
   Ideally you shouldn't ever need to look back at a variable declaration to understand what that variable is for.
*/
int doorSensor_pin = A0;
int doorSensor_pin_value = 0; // Notice how the variable to hold the pin VALUE ends in the word VALUE and not "pin"...
int buzzer_pin = 9;

int rgb_led__blue_pin = 3;
int rgb_led__red_pin = 5;
int rgb_led__green_pin = 6;



// added variables----------------------
const int door_sensor_mode__enabled = 1;
const int door_sensor_mode__disabled = 2;
int door_sensor_mode = 1; // A state indicator for the button. 1 means that the button can be checked, 2 means that the button is waiting through its delay.
int door_sensor_delay_time = 200; // This is the milliseconds time interval for de-bouncing the button at.
unsigned long door_sensor__begin_time = 0;
unsigned long door_sensor__current_time = 0;


int alarm_mode = 0; // The alarm has multiple phases it needs to pass through. I didn't bother with naming each of them.
bool alarm_waiting = false; // This variable is for indicating if the alarm is waiting during a delay or not.
const int alarm__short_delay = 75;
const int alarm__long_delay = 1000;
int alarm_time = 0; // This will be used to hold one of the above two values.
unsigned long alarm__begin_time = 0;
unsigned long alarm__ending_time = 0;



void setup() {
  Serial.begin(9600); // ----------------------------------------- moved to beginning of setup() function.
  pinMode(rgb_led__blue_pin, OUTPUT);
  pinMode(rgb_led__red_pin, OUTPUT);
  pinMode(rgb_led__green_pin, OUTPUT);
  pinMode(doorSensor_pin, INPUT);
  pinMode(buzzer_pin, OUTPUT);
  //Serial.begin(9600);
  Serial.println("Exiting setup()");
  /*
     In my experience it is good to declare the Serial object first, and put a last line that prints "Exiting setup()".
     The reason is because errors in the setup() function can cause it to crash, but the processor just skips the remaining lines inside setup() and continues on to the main loop.
     When you get this kind of error you will search fruitlessly in the main program to find what is not working.

     If you have the final line of setup() printing a Serial "exit" message, then you know that the whole setup() function completed normally.
     If you don't see the "Exiting setup()" message, then that means that -something- wrong happened inside setup().
  */
}


void loop() {

  if (door_sensor_mode == door_sensor_mode__enabled) {
    /*
       Break your program up into functions, and name the function what it does.
       Generally you want a single function to do a single 'thing' or make a single decision.
       Write all of the functions first, and then go back through and write what goes into them.
       If you have named the functions well, you should be able to understand what needs to go into each of them!
    */
    check_door_sensor_for_press();
  }
  else { // if door_sensor_mode == door_sensor_mode__disabled
    check_to_re_enable_door_sensor();
  }

  if (alarm_waiting == true) {
    check_alarm_timer();
  }
  else {
    check_alarm_mode();
  }


  /*
     Original code is below...........

    DoorSensor = analogRead(A0); // ------------------------------ this worked but looks odd.
    // ----------------------------------------------------------- You declared DoorSensor as A0 (the pin number) but then after the setup() function, you used DoorSensor as a normal variable to hold the value of A0.

    if (DoorSensor < 50) {
      analogWrite(LTG, 255);
    }
    else {
      analogWrite(LTG, 0);
    }
    // ----------------------------------- Since the else() condition of both of them are from the same value (the sensor reading) the two separate if() statements above and below could be combined into an if-else statement.
    // ----------------------------------- Placing them in two separate if() statements implies that both conditions could be true at the same time, which they can't.
    if (DoorSensor > 600) {
      analogWrite(LT, 255);
      delay(75);
      analogWrite(LT, 0);
      analogWrite(LTR, 255);
      delay(75);
      analogWrite(LTR, 0);
      analogWrite(buzz, 51);
      delay(1000);
      analogWrite(buzz, 0);
    }
    else {
      analogWrite(LT, 0);
      analogWrite(LTR, 0);
      analogWrite(buzz, 0);
    }
  */

  //Serial.println(DoorSensor);
  /*
     Putting a Serial.print line into the main loop is not usually a good thing to do, since it will print out a LOT, and also since it will slow the main loop down.
     It is okay to do this for testing or troubleshooting, but it's usually not helpful to leave it there permanetly.
  */
}




void check_door_sensor_for_press() {
  doorSensor_pin_value = analogRead(doorSensor_pin);
  if (doorSensor_pin_value < 50) {
    start_low_value_alarm();
    // alternate disable_button() call location,,,,,,,,,,,,,,,,,,,,
  }
  else if (doorSensor_pin_value > 600) {
    start_high_value_alarm();
    // alternate disable_button() call location,,,,,,,,,,,,,,,,,,,,
  }
  else {
    // We don't really need a condition here to "turn off" the alarm, since that is handled elsewhere.
  }
  disable_door_sensor(); // The way that this sketch is written, the door_sensor is only enabled once every 200 milliseconds.
  // ----------------- This leaves all the other time free for the processor to do other things.
  // ----------------- If you used it in the two "alternate locations" above, then the door_sensor would only be disabled after it was pressed... -and it would get checked thousands of times a second, as long as it wasn't pressed.
  /*
    With some Arduino programs you can check the button inputs on every pass through the loop and it doesn't matter, since the program is simple enough that it doesn't interfere with anything else.
    The only question is if it's really necessary or helpful.

    If you are writing a more-complicated program, then you don't want to check the buttons on every pass through the main loop since there usually is no advantage to checking the intput buttons thousands of times a second.
    For a normal device, you really only need to check input buttons 5 to 10 times a second.
    For an Arduino game you might want to check the buttons maybe 20 times a second, but more than that isn't generally useful.
  */
}

void disable_door_sensor() {
  door_sensor_mode == door_sensor_mode__disabled; // This changes the door_sensor from being active to being in debounce/delay mode.
  door_sensor__begin_time = millis(); // This records the time that the door_sensor was initially pressed.
}

void check_to_re_enable_door_sensor() {
  // This function re-enables the door_sensor after the time value of door_sensor_delay_time has passed.
  door_sensor__current_time = millis();
  if (door_sensor__current_time >= door_sensor__begin_time) {
    if (door_sensor__current_time >= (door_sensor__begin_time + door_sensor_delay_time)) {
      door_sensor_mode = door_sensor_mode__enabled;
    }
  }
  else {
    door_sensor__begin_time = millis(); // millis() rollover condition
  }
}

void start_low_value_alarm() {
  alarm_mode = 1; // The low-button-value alarm response is #1, and has no second stage.
}

void start_high_value_alarm() {
  alarm_mode = 2; // The high-button-value alarm response has multiple stages that begin with #2.
}

void check_alarm_mode() {
  // This function moves the alarm through its different stages.

  if (alarm_mode == 1) {
    analogWrite(rgb_led__red_pin, 0);
    analogWrite(rgb_led__green_pin, 255);
    analogWrite(rgb_led__blue_pin, 0);
    alarm_mode = 0;
    /*
       Note that the original sketch did not have any definite separate condition to turn off the green LED.
       The if() statement that turned on the green LED was placed before the if() statement that operated the red and blue LEDs, and the final phase of the red & blue alarm set all three LED values back to zero.

       It appears as though the green LED was supposed to remain on all the time that the door was not opened (when doorSensor_pin_value < 50)
       but the code had separate if() statements for turning on the green LED and also for turning on the other LEDs, implying that both states could occur at the same time?

       As a precaution to leaving the green LED on all the time, I put all three statements for the LEDs any time that any one of the LEDs was changed.
    */
  }

  if (alarm_mode > 1) {

    switch (alarm_mode) {

      case 2:
        analogWrite(rgb_led__red_pin, 0);
        analogWrite(rgb_led__green_pin, 0);
        analogWrite(rgb_led__blue_pin, 255);
        alarm_mode = 3;
        set_alarm_to_short_delay();
        break;

      case 3:
        analogWrite(rgb_led__red_pin, 255);
        analogWrite(rgb_led__green_pin, 0);
        analogWrite(rgb_led__blue_pin, 0);
        alarm_mode = 4;
        set_alarm_to_short_delay();
        break;

      case 4:
        analogWrite(rgb_led__red_pin, 0);
        analogWrite(rgb_led__green_pin, 0);
        analogWrite(rgb_led__blue_pin, 0);
        analogWrite(buzzer_pin, 51);
        alarm_mode = 5;
        set_alarm_to_long_delay();
        break;

      case 5:
        analogWrite(buzzer_pin, 0);
        alarm_mode = 0;
        break;
    }
  }
}


void set_alarm_to_short_delay() {
  // All this function does is set the alarm timer to a short delay and sets the starting time.
  alarm_time = alarm__short_delay;
  alarm_waiting = true;
  alarm__begin_time = millis();
}

void set_alarm_to_long_delay() {
  // All this function does is set the alarm timer to a long delay and sets the starting time.
  alarm_time = alarm__long_delay;
  alarm_waiting = true;
  alarm__begin_time = millis();
}

void check_alarm_timer() {
  // This function re-enables the alarm after the time value of alarm_time has passed.
  alarm__ending_time = millis();
  if (alarm__ending_time >= alarm__begin_time) {
    if (alarm__ending_time >= (alarm__begin_time + alarm_time)) {
      alarm_waiting = false;
    }
  }
  else {
    alarm__begin_time = millis(); // millis() rollover condition
  }
}


// --------- end ----------