View difference between Paste ID: EVWXFeFN and KsRzhSiD

 // Blynk dashboard: https://imgur.com/a/Ql2mr
 // Used widgets and pins:
 // TIMER ACTIVE = LED widget, connected to virtual pin 4 (V4)
 // NOISE LEVEL  = Value Display widget, connected to virtual pin 2 (V2)
 // RUNNING      = LED widget, connected to virtual pin 3 (V3)
 
 // Those are all Labled Value widgets, Rreadingrate is set to PUSH
 // HOURS   = connected to virtual pin 7 (V7)
 // MINUTES = connected to virtual pin 6 (V6)
 // SECONDS = connected to virtual pin 5 (V5)
 
 // START/STOP TIMER = Button widget, connected to virtual pin 0 (V0), set to PUSH
 // RESET TIMER      = Button widget, connected to virtual pin 1 (V1), set to PUSH
 
 #include <ESP8266WiFi.h>
 #include <BlynkSimpleEsp8266.h>
 
 /* Comment this out to disable prints and save space */
 //#define BLYNK_PRINT Serial
 
 /**********************/
 /* USER CONFIGURATION */
 /**********************/
 // the following values are the only thing that needs to be adjusted
 
 // BLYNK API KEY
 char auth[] = "xxx";
 
 // WIFI CONFIGRUATION
 char ssid[] = "xxx";
 char pass[] = "xxx";
 
 // NOISE LEVEL CONFIGURATION - this is the main configuration
 
 // the adc value (noise level) when the roomba should be considered running
 // the adc on the ESP8266 ranges from 0 to 1023 (10 bit),
 #define ON_NOISE_LEVEL  600
 // the adc value (noise level) when the roomba should be considered not running
 #define OFF_NOISE_LEVEL 200
 // to prevent false triggeres the sketch takes a specific ("MAX_NOISE_SAMPLES") amount of
 // noise samples (adc readings) and only if all of the readings are above or below a given
 // value (based on the variables "ON_NOISE_LEVEL" and "OFF_NOISE_LEVEL") the roomba is
 // considered running, or not running resp..
 // If the roomba is considered running the timer starts
 #define MAX_NOISE_SAMPLES 10
 // the amount of false values that are allowed
 #define NOISE_SAMPLE_FAILURE_RATE 3
 // this is the time (in milliseconds) between each reading
 // if "MAX_NOISE_SAMPLES" is set 5 and "NOISE_SAMPLE_INTERVAL" is set to 500 it
 // takes 5 * 500 milliseconds until the roomba is considered running or not running, resp..
 #define NOISE_SAMPLE_INTERVAL 250
 
 
 
 /***************************/
 /* SKETCH VARIABLES        */
 /* no configuration needed */
 /***************************/
 
 #define BLUE_ONBOARD_LED 2
 
 int last_noise_levels[MAX_NOISE_SAMPLES];
 int current_position = 0;
 
 unsigned long previousMillis = 0;
 
 unsigned long second_counter = 0;
 unsigned long minute_counter = 0;
 unsigned long hour_counter = 0;
 
 boolean roomba_is_running = false;
 boolean timer_is_running = true;
 int noise_level = 0;
 
 WidgetLED roomba_active_led(V3); // blynk led widget connected to virtual pin 3 (V3)
 WidgetLED timer_active_led(V4); // blynk led widget connected to virtual pin 4 (V4)
 
 BlynkTimer timer;
 
 
 // reads the adc value and ads the value to the "last_noise_levels" array
 // then checks if all values in the array are above or below the
 // given ("ON_NOISE_LEVEL" and "OFF_NOISE_LEVEL") values
 void check_noise() {
   boolean roomba_has_started = false;
   boolean roomba_has_stoped = false;
 
   last_noise_levels[current_position++] = analogRead(0);
 
   if (current_position == MAX_NOISE_SAMPLES) {
     current_position = 0;
   }
 
   // if all readings expect NOISE_SAMPLE_FAILURE_RATE readings in the array are above "ON_NOISE_LEVEL" the timer starts
-  // if all readings in the array are above "ON_NOISE_LEVEL" the timer starts
+
   for (int i = 0; i < MAX_NOISE_SAMPLES; i++) {
     if (last_noise_levels[i] >= ON_NOISE_LEVEL) {
       roomba_has_started = true;
     }
     else {
       if (++failure_rate >= NOISE_SAMPLE_FAILURE_RATE) {
         roomba_has_started = false;
         break;
       }
     }
   }
   // if all readings expect NOISE_SAMPLE_FAILURE_RATE readings in the array are below "OFF_NOISE_LEVEL" the timer stops
-  // if all 3 readings in the array are below "OFF_NOISE_LEVEL" the timer stops
+  failure_rate = 0;
-  failure_rate = NOISE_SAMPLE_FAILURE_RATE;
+
     if (last_noise_levels[i] <= OFF_NOISE_LEVEL) {
       roomba_has_stoped = true;
     }
     else {
       if (++failure_rate >= NOISE_SAMPLE_FAILURE_RATE) {
         roomba_has_stoped = false;
         break;
       }
     }
   }
 
   // final check to see if the roomba is considered running or not running
   if (roomba_has_started == true) {
     digitalWrite(BLUE_ONBOARD_LED,LOW); // turn on the onboard led (it is connected "activle low")
     roomba_active_led.on();
     roomba_is_running = true;
   }
   if (roomba_has_stoped == true) {
     digitalWrite(BLUE_ONBOARD_LED,HIGH);
     roomba_active_led.off();
     roomba_is_running = false;
   }
 
   /*
   Serial.println("------------------");
   Serial.print("Roomba has started: ");
   Serial.println(roomba_has_started);
   Serial.print("Roomba has stopped: ");
   Serial.println(roomba_has_stoped);
   Serial.println("------------------");
   Serial.println(current_position);
   Serial.println("------------------");
   for (int i = 0; i < MAX_NOISE_SAMPLES; i++)
     Serial.println(last_noise_levels[i]);
   */
 }
 
 // stop timer - counts up the seconds, minutes and hours
 void count_up()
 {
   second_counter++;
   if (second_counter == 60) {
     second_counter = 0;
     minute_counter++;
     if (minute_counter == 60) {
       minute_counter = 0;
       hour_counter++;
     }
   }
 }
 
 // this timer fires every seconds
 // it is used to send the current adc value and the current time to blynk app
 // it also counts up the stop timer if the roomba is running
 // and if the timer is active(not disabled through the user by pressing
 // the Start/Stop button in the blynk app)
 void myTimerEvent()
 {
   Blynk.virtualWrite(V2, analogRead(0));
   Blynk.virtualWrite(V5, second_counter);
   Blynk.virtualWrite(V6, minute_counter);
   Blynk.virtualWrite(V7, hour_counter);
   if (roomba_is_running && timer_is_running) {
     count_up();
   }
 }
 
 // START/STOP BUTTON - STARTS AND STOPS(PAUSE) THE TIMER
 BLYNK_WRITE(V0)
 {
   int pinValue = param.asInt(); // assigning incoming value from pin V0 to a variable
   //Serial.println(pinValue);
 
   if (pinValue == 0) {
     if (timer_is_running) {
       timer_active_led.off();
       timer_is_running = false;
     }
     else {
       timer_active_led.on();
       timer_is_running = true;
     }
   }
 }
 // RESET BUTTON - RESETS THE TIMER
 BLYNK_WRITE(V1)
 {
   int pinValue = param.asInt(); // assigning incoming value from pin V1 to a variable
   //Serial.println(pinValue);
 
   if (pinValue == 0) {
     second_counter = 0;
     minute_counter = 0;
     hour_counter = 0;
   }
   Blynk.virtualWrite(V5, second_counter);
   Blynk.virtualWrite(V6, minute_counter);
   Blynk.virtualWrite(V7, hour_counter);
 }
 
 void setup()
 {
   //Serial.begin(115200);
 
    pinMode(BLUE_ONBOARD_LED,OUTPUT);
    digitalWrite(BLUE_ONBOARD_LED,HIGH);
 
   for (int i = 0; i < MAX_NOISE_SAMPLES; i++) {
     last_noise_levels[i] = 0;
   }
 
   Blynk.begin(auth, ssid, pass);
 
   roomba_active_led.off();
   timer_active_led.on();
 
   timer.setInterval(1000L, myTimerEvent);
 }
 
 void loop()
 {
   Blynk.run();
   timer.run();
   // read adc value every "NOISE_SAMPLE_INTERVAL" milliseconds
   unsigned long currentMillis = millis();
   if (currentMillis - previousMillis >= NOISE_SAMPLE_INTERVAL) {
     previousMillis = currentMillis;
     check_noise();
   }
 }