Persistent State Example 1.0

/*
  31 August 2019
  Example Arduino Sketch - persistent operations v1.0
  (operations that continue for more than 1 pass through the main loop)

  This sketch doesn't really do anything as it is.
  It is just a rough example of how to have a LED blink while waiting for control messages from the serial port.

*/

bool blink_the_led = false;
int blink_led_interval = 500; // A time in milliseconds to blink the LED on and off (500 is a half-second).
unsigned long led_blink_previous_time = 0; // used for blinking the LED
unsigned long led_blink_current_time = 0; // used for blinking the LED
int LED_pin = 13; // The pin that the LED is on.
int LED_pin_value = 0; // The value to write to the pin.


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

  // (various things not included here)

  pinMode(LED_pin, OUTPUT);
  digitalWrite(LED_pin, LOW); // I have seen that some clone Unos will put pin# 13 high on start-up, unless you write it low.
  Serial.println("Exiting setup()");
}

void loop() {

  // In this sketch, the LED can blink independently of whatever the serial-message-reading function does,
  // because the function to blink the LED is not inside the serial-message-reading function.
  // The function check_serial_buffer() changes the value of the variable blink_the_led,
  // and then check_to_blink_led() acts based on the value of blink_the_led.
  check_serial_buffer();
  check_to_blink_led();

}


void check_serial_buffer() {
  // This is the function that checks the serial buffer. (This part isn't written really)

  // ...If the value of the serial buffer is the "on" value, then do the following things:
  //            change blink_the_led to true
  //            change LED_pin_value to 1
  //            digitalWrite(LED_pin, LED_pin_value); // This turns the LED on immediately.
  //            led_blink_previous_time = millis(); // This starts the timer off properly.

  // ...If the value of the serial buffer is the "off" value, then change blink_the_led to false

}


void check_to_blink_led() {
  if (blink_the_led == true) {
    check_blink_timer();
  }
  else {
    // This part is here to ensure that the LED always gets turned off.
    // If blink_the_led was changed to FALSE while the LED was still on, then the LED timer code would never get checked to turn it off.
    LED_pin_value = 0;
    digitalWrite(LED_pin, LED_pin_value);
    // There is different ways you could do this, but the above two lines immediately turn off the LED.
  }
}

void check_blink_timer() {
  led_blink_current_time = millis();
  if (led_blink_current_time >= led_blink_previous_time) {
    if (led_blink_current_time >= (led_blink_previous_time + blink_led_interval)) {
      if (LED_pin_value == 0) {
        LED_pin_value = 1;
      }
      else {
        LED_pin_value = 0;
      }
      digitalWrite(LED_pin, LED_pin_value);
      led_blink_previous_time = millis();
    }
  }
  else { // if (led_blink_current_time < led_blink_previous_time)
    // If led_blink_current_time was ever less than led_blink_previous_time, then that would mean that the millis() timer had rolled over.
    // Since the blinker code won't work under that condition, the solution I often use is just re-set the previous time when that happens.
    // This means you will get one timer cycle that will be up to 2X as long as normal, but that is a minor issue and everything works normal after that (until the next timer rollover).
    led_blink_previous_time = millis();
    // There are different ways of dealing with clock rollover in code, depending on what the code is doing and how much precision you want to have.
    // For CNC machine operations that are time-critical, the usual solution is (before every task) you compute how long the task will take and then check that there is enough time remaining before the timer rollover to do it.
    // If there isn't enough time, then the microcontroller just waits until the clock rolls over to begin that task.
  }
}



// ~~~~~~~~ end ~~~~~~~~~