Reddit dual-sensor timer v1.0

/*
   Reddit speed tracker - V 1.0
   This is a sketch that uses two photodetectors to act as a timer for something (?)

   Board: not specified
   Hardware: two photo sensors of some kind, (???) not LDRs I would hope....

   Just so you know: you need to use a phototransistor or a photodiode for optical timing sensors, such as  BPW34.
   LDRs (Light-Dependent Resistors) tend to have a relatively long activation time that can be as long as 1/10th of a second. They react too slow for many timing uses.
   Phototransistors and photodiodes can turn on and off much faster; many are capable of doing so up into the megahertz range.
   (-a regular LED can be used as a photodetector too, if that's all you have or you are cheap. When used this way, they turn on and off very fast also-)
*/


//int lightPin = 0; //pin for Photoresistor ---------------------- you used the digital pins (plain numbers) and you need to use the analog pins.
//int lightPin1 = 1; //pin for photoresistor #2
// ,,,,,,,, Also if you use Serial.print() statements, then you cannot use digital pins zero and 1 for anything, because those pins are the same as the USB plug data pins.

int light_sensor_pin_A0 = A0; //pin for Photoresistor // ---------------- note the different pin number --> begins with A
int light_sensor_pin_A1 = A1; //pin for photoresistor #2 // ---------------- note the different pin number --> begins with A

// int TranslateAnalog = 0; --------------------- these are declared okay but the names are ambiguous.
// int TranslateAnalog1 = 1;
int analog_pin_value_A0 = 0; // -------------------- these pin numbers tell you what they represent.
int analog_pin_value_A1 = 0;


// There is two places where the light sensor value is checked to be above a minimum value.
// The two variables below just provide named values for each.
int light_sensor_A0_threshold_value = 650;
int light_sensor_A1_threshold_value = 650;

// unsigned long time; ---------------------------- this is declared correctly but the name is ambiguous
// int time1 = time; ------------------------------ these are not declared properly; they should also be unsigned longs since you are trying to store the millis() time value in them.
// int time2 = time;

// Below is two variables declared for storing both the beginning and ending times in.
unsigned long sensor_begin_time = 0;
unsigned long sensor_end_time = 0;

// int formula = 1.5 / ((time2 - time1) / 1000); ------------- There is no reason to put a formula here and use it to assign a value to [formula] because it has no values to use.
float speed_formula_result = 0; // -------- I am declaring this as a float since the end result isn't likely to be a round number...

int led_output_pin = 13; // ------------------------------ I declared your output pin as #13, because it has a LED on it already. You can change the pin number as you wish, if you have some other output to use.
// It is good practice to ALWAYS name your pins with descriptive names and then use the pin names, not the numbers.


// Below is an added variable.
// You need some way to tell within the main loop how to do these multiple steps in order, een though they may not occur in the same pass through the loop.
// There are multiple steps to have the program work correctly, and so the program needs a way to "remember" what step it is on.
int timer_state = 0; // This is a variable to tell what state the timer is in.
// Zero = neither sensor triggered. -------- The first sensor is being checked in case it is above the minimum set level light_sensor_A0_threshold_value, and the second sensor is being ignored.
// 1 = sensor A0 has been triggered. ------- Now sensor A0 will be ignored, and the second sensor will be checked until it is above the minimum set level in light_sensor_A1_threshold_value.
// 2 = sensor A1 has been triggered. ------- Both sensors have been triggered, and both are being ignored. The end message is shown.
// 3 = the end display is showing. --------- This is a time delay at the end for the whole thing to reset.
// 4 = reset back to the normal zero state after the end display timer has run out.

int end_display_delay = 10; // This is an end display delay, with the delay value stated in seconds. After the second photo sensor is triggered, (with this set to 10) there will be a ten-second delay for the timer to reset.
int end_display_seconds_counter = 0; // This will be used to count up to the value in end_display_delay.
// The two variables below are for a one-second coded timer, to help with providing the end delay.
unsigned long one_second_timer_begin_time = 0;
unsigned long one_second_timer_current_time = 0;



void setup() {

  Serial.begin(9600); //Start serial communication
  // pinMode (7, OUTPUT); ------------------------------------ not needed now
  pinMode (led_output_pin, OUTPUT);
  digitalWrite(led_output_pin, LOW);
  Serial.println("Exiting setup()"); // ------------------------ This just prints a serial message that says when it is exiting the setup() function.

}


void loop() {

  switch (timer_state) {

    case 0:
      // Zero = neither sensor triggered.
      perform_state_0();
      break;
    case 1:
      // 1 = sensor A0 has been triggered.
      perform_state_1();
      break;
    case 2:
      // 2 = sensor A1 has been triggered.
      perform_state_2();
      break;
    case 3:
      // 3 = the end display is showing.
      perform_state_3();
      break;
    case 4:
      // 4 = reset back to the normal zero state after the end display timer has run out.
      perform_state_4();
      break;
  }

} // end of main loop()


void perform_state_0() {
  analog_pin_value_A0 =  analogRead(light_sensor_pin_A0);
  if (analog_pin_value_A0 > 650) {
    digitalWrite(led_output_pin, HIGH);
    sensor_begin_time = millis();
    Serial.println("Time1 captured"); // --------------- You may want to comment this out for actual use.
    // ------------------------------ It is not a good idea to place Serial.print() statements within timing code that must run fast, because the Serial.print() statement takes some time of its own to be executed.
    //                                The set baud rate is bits per second, and each char that you print is 8 bits...
    timer_state = 1; // Advance the timer_state to the next step.
  }
}

void perform_state_1() {
  analog_pin_value_A1 =  analogRead(light_sensor_pin_A1);
  if (analog_pin_value_A1 > 650) {
    digitalWrite(led_output_pin, LOW);
    sensor_end_time = millis();
    Serial.println("Time2 captured"); // --------------- You may want to comment this out for actual use.
    timer_state = 2; // Advance the timer_state to the next step.
  }
}

void perform_state_2() {
  Serial.print("Sensor A0 value: ");
  Serial.println(analog_pin_value_A0);
  Serial.print("Time1: ");
  Serial.println(sensor_begin_time);

  Serial.print("Sensor A1 value: ");
  Serial.println(analog_pin_value_A1);
  Serial.print("Time2: ");
  Serial.println(sensor_end_time);

  Serial.print("Speed formula result = ");
  // speed_formula_result = 1.5 / ((sensor_end_time - sensor_begin_time) / 1000); ------------- this formula is yielding an inf result
  speed_formula_result = 1.5 * (sensor_end_time - sensor_begin_time); // this formula is for testing purposes only...
  Serial.println(speed_formula_result);

  Serial.println("Starting end delay timer,,, (wait for reset)");
  start_end_delay_timer();
  timer_state = 3;
}

void perform_state_3() {
  check_end_delay_timer();
  // The above function changes timer_state to 4 when necessary.
}

void perform_state_4() {
  // This state is just provided to show when the end display timer was resetting.
  Serial.println("End-delay timer has reset.");
  digitalWrite(led_output_pin, LOW); // Turn this LED off again.
  timer_state = 0;
}



void start_end_delay_timer() {
  // This function is called to start the end-delay timer running.
  end_display_seconds_counter = 0;
  one_second_timer_begin_time = millis();
}


void check_end_delay_timer() {
  // If the end-delay timer is running, this is called on every pass through the loop to check if enough time has passed to move on to the next stage.
  one_second_timer_current_time = millis();
  if (one_second_timer_current_time >= one_second_timer_begin_time) {
    if (one_second_timer_current_time >= (one_second_timer_begin_time + 1000)) {
      end_display_seconds_counter += 1;
      if (end_display_seconds_counter == end_display_delay) {
        timer_state = 4;
      }
      else {
        one_second_timer_begin_time = millis();
      }
    }
    // The code below blinks the pin #13 LED in short pulses once per second.
    if ((one_second_timer_current_time - one_second_timer_begin_time) < 51) {
      digitalWrite(led_output_pin, HIGH);
    }
    else {
      digitalWrite(led_output_pin, LOW);
    }
  }
  else {
    one_second_timer_begin_time = millis(); // This is for the millis() rollover condition.
  }
}