Reddit solenoid drum driver thing v1.0

/*
  Reddit slenoid driver - 19 October 2019

  This sketch is for driving solenoids at different random rates.
  The strike times should vary, but the strike durations should always remain short.

  Board -- appears to be an Uno?

  There are serial messages that show the countdown timer and the function to change solenoid intervals.

*/

const int solenoid_pin[] =  { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

int solenoid_state[10]; // Initialize to zero values in setup()

int interval_times[6]; // This is for generating the new interval times in for the five groups. (index zero not used)

int solenoid_interval_time[10]; // This is the time in milliseconds for each solenoid to wait before striking.

int solenoid_interval_target_time[10]; // This is the current time that the solenoid is waiting for (can be solenoid_interval_time[] or solenoid_strike_time)

int solenoid_strike_time = 50; // This is the time in milliseconds for all the solenoids to remain HIGH before turning off.

// All of the solenoids need their own time tracking:
unsigned long solenoid_current_time = 0;
unsigned long solenoid_previous_time[10]; // Initiaize to zero values during setup()

// The function to generate new times is called every X seconds:
int change_solenoid_times__time_interval_in_seconds = 20;
int change_solenoid_times__time_interval_counter = change_solenoid_times__time_interval_in_seconds;
unsigned long one_second_timer_begin_time = 0;
unsigned long one_second_timer_current_time = 0;



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

  for (int x = 0; x < 10; x++) {
    solenoid_state[x] = 0;
    solenoid_previous_time[x] = 0;
    // set the digital pin(s) as output(s):
    pinMode(solenoid_pin[x], OUTPUT);
    // write all the solenoid pins low to start:
    digitalWrite(solenoid_pin[x], solenoid_state[x]);
  }

  pinMode(13, OUTPUT); // Some clone boards put pin 13 high unless you tell them to turn it off.
  digitalWrite(13, LOW); // Some clone boards put pin 13 high unless you tell them to turn it off.

  generate_new_solenoid_strike_times();
  strike_all_solenoids_now();

  Serial.println("Exiting setup()");
}



void loop() {

  check_if_solenoids_need_to_change_state(); // This operates the solenoids, if needed.

  check_the_one_second_timer(); // This generates new random times for the solenoids, if needed.

}



void check_if_solenoids_need_to_change_state() {
  solenoid_current_time = millis();
  for (int x = 0; x < 10; x++) {
    if (solenoid_current_time >= solenoid_previous_time[x]) {
      if (solenoid_current_time >= (solenoid_previous_time[x] + solenoid_interval_target_time[x])) {
        if (solenoid_state[x] == 0) {
          // switch to the long delay:
          solenoid_interval_target_time[x] = solenoid_strike_time;
          solenoid_state[x] = 1;
        }
        else { // solenoid_state[x] == 1
          // switch to the short delay:
          solenoid_interval_target_time[x] = solenoid_interval_time[x];
          solenoid_state[x] = 0;
        }
        digitalWrite(solenoid_pin[x], solenoid_state[x]);
        solenoid_previous_time[x] = millis();
      }
    }
    else {
      solenoid_previous_time[x] = millis();
    }
  }
}


void check_the_one_second_timer() {
  // The function to generate new times is called every X seconds:
  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)) {
      change_solenoid_times__time_interval_counter--;
      if (change_solenoid_times__time_interval_counter == 0) {
        set_all_solenoids_low();
        generate_new_solenoid_strike_times();
        change_solenoid_times__time_interval_counter = change_solenoid_times__time_interval_in_seconds;
      }
      else {
        Serial.print("Countdown = ");
        Serial.println(change_solenoid_times__time_interval_counter);
      }
      one_second_timer_begin_time = millis();
    }
  }
  else {
    one_second_timer_begin_time = millis();
  }
}


void generate_new_solenoid_strike_times() {
  Serial.println("Generating new solenoid intervals");
  interval_times[1] = random(50, 3000);
  interval_times[2] = random(50, 1000);
  interval_times[3] = random(50, 10000);
  interval_times[4] = random(50, 2000);
  interval_times[5] = random(50, 500);

  solenoid_interval_time[1] = interval_times[1]; // Solenoid #1 is using interval #1.
  solenoid_interval_time[2] = interval_times[2]; // Solenoid #2 is using interval #2.
  solenoid_interval_time[3] = interval_times[3]; // Solenoid #3 is using interval #3.

  solenoid_interval_time[4] = interval_times[4]; // Solenoid #4 is using interval #4.
  solenoid_interval_time[5] = interval_times[4]; // Solenoid #5 is using interval #4.
  solenoid_interval_time[6] = interval_times[4]; // Solenoid #6 is using interval #4.
  solenoid_interval_time[7] = interval_times[4]; // Solenoid #7 is using interval #4.

  solenoid_interval_time[8] = interval_times[5]; // Solenoid #8 is using interval #5.
  solenoid_interval_time[9] = interval_times[5]; // Solenoid #9 is using interval #5.
  solenoid_interval_time[10] = interval_times[5]; // Solenoid #10 is using interval #5.

}


void strike_all_solenoids_now() {
  for (int x = 0; x < 10; x++) {
    solenoid_state[x] = 1;
    solenoid_previous_time[x] = millis();
    digitalWrite(solenoid_pin[x], solenoid_state[x]);
  }
}

void set_all_solenoids_low() {
  for (int x = 0; x < 10; x++) {
    solenoid_state[x] = 0;
    digitalWrite(solenoid_pin[x], solenoid_state[x]);
  }
}



// ~~~~~~~~ the end ~~~~~~~~