/* CountDown Timer version using three arduinos

Miha needs:
- countdown seconds display from 15:00:00 (hh:mm:ss) = 6 digits = 42 segments
- when 00:00:00 reached - wait for 9 hours = jump to 9:00:00 and count down invisibly 
-> toggle some visibility variable to hidden
- show 00:00:00 blinking! Maybe write something -> POLICE
- when invisible counting reaches 0:00:00 - jump to 15:00:00
- toggle countdown visibly to visible

Follow these steps to connect Arduino UNOs using I2C:
    Connect pins A4 and A5 between Arduinos
    The GND line has to be common for all three Arduinos 
    You can also connect the 5V pins and power all three from one

The following code is split in three parts: the master code, first slave code and second slave code 
which will run differently on three Arduinos. Define the master first arduino as 1, first slave as 2, second slave as 3

LED strips take 250mA - 4 parallel lines of 12 leds (12 x 3V = 36V) // 39V?
6 x 7 = 42 * 0.25A = 10A // ok
Normally strips are used via 42V current limited PSU
We have 24V AC PSUs - shows 27V - ca be paralleled - full rectification and filtering brings us to 37V
Current limiting resistors should take U=R*I voltage - some voltage stabilisation could be needed 

Master and slave will use pins 0,1,2,3,4,5,6 and 7,8,9,10,11,12,13
Pin 14 is LED blinker

On master we use 15,16,17 for other stuff:
- pin 15 for tone() seconds tick (use of tone() function will interfere with PWM output on pins 3 and 11)
- used also fo alarm, clock type alarm
- pin 16 NoonButt; use this button to set the time at noon
- pin 17 SpeedButt - accelerates countdown 100 times - toggle between 5V (normal) and 0V (fast)

On slave (maybe)
- pin 15 as driver for constant or blinking dots between numbers (two dots have 24V led strips connected in series)

*/

// define some identity to this arduino
const byte master_slave = 1; // this is master - first arduino - does the counting - makes the sound
//const byte master_slave = 2; // this is first slave - second arduino - minutes 
//const byte master_slave = 3; // this is second slave - third arduino - hours

const bool test = false; // true speeds up countdown - relates to master only
const bool testalarm = false; // true will bring countdown close to zero
const bool testserial = false; //true print serial info

// define to show leading zeros 
const bool showzeros = true; //true to show leading zeros
// define to show zeros at non-visible period
const bool shownightzeros = false; //true to show zeros at night - false for empty

// define the top value to count down from
// visible countdown 150000 = 15:00:00 = 15 hours, 240000 = 24:00:00 = 24 hours, 10000 = 1:00:00 = 1 hour
#define VISIBLE 150000  
// hidden countdown 90000 = 9:00:00 = 9 hours
#define HIDDEN 90000
// visible countdown starts at 6 o'clock, ends at 21 o'clock = 15 hours 

// ring alarm or not
const bool AlarmRing = false;
const int AlarmLength=30; // in seconds - how many seconds to keep alarm at 0 reached count

// optional seconds blinking
const byte Led = 14;
bool LedOn = false;

// sound and alarm - only on master
// tik-tak
// use tone function
const byte Speaker = 15; // Pin 9 connected to MOSFET etc
// notes to play
const int notes[] = {  1047, 988, 880, 523 };
const int duration = 100;   // play notes for 100 ms

// noon sets visible countnumber to 150000 - 60000 = 90000
#define NOON 90000
const byte NoonButt = 16;

// define the test speed-up activated with pushbutton
bool speedup = false; // false = default for normal countdown - only on master 
const byte SpeedButt = 17; // on master - to test or set

//time increment 
unsigned long TimeStep = 1000000; // microseconds
// check timestamps for seconds
unsigned long TimeStamp=micros();

// remember visible countdown or hidden (false)
bool CountVisible = true;

// BS: we reduced the number to seconds - instead of centimes of seconds
// we need from 15:00:00 -> six numbers - last (or first?) two not needed
long int visiblenumber=VISIBLE;
long int hiddennumber=HIDDEN;

// start with visible
long int countnumber = visiblenumber;
// on slave we check for change in number received
long int prevcountnumber = countnumber;

int AlarmCount=0; // counter to keep alarm at 0 reached count

// variable to define that alarm is on or off
bool SignalOut = false;

// redefine master again in setup according to the role set
bool master = true;
// define the i2c slave addresses - master needs to know where to send data
// just use the decimal numbers; call it as address[master_slave - 2] to get to first index
const byte address[] = { 2, 3 }; // second and third arduino

// pins:
// A4=18, A5=19 is i2c - it is doubled on the other side on arduino R3
// 18 pins available per UNO
// we need: 6 * 7 = 42 pins for 6 full digits

// pins: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
// pins: A0, A1, A2, A3 = 14, 15, 16, 17
// pwm pins for sound: 5, 6 and 9, 10

// all pins set as outputs
const byte all_pins[18] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };

// digits go from right to left -> to become hh:mm:ss
// define the digits as a b c d e f g array of pins for master UNO -> 1
const byte digit_1[7] = { 0, 1, 2, 3, 4, 5, 6};
const byte digit_2[7] = { 7, 8, 9, 10, 11, 12, 13}; // not used here 14, 15, 16 and 17
// use master arduino for any additional functions - peep sound, sirene sound, blinks, etc.

// these will be sent to i2c second UNO - first slave UNO -> 2
const byte digit_3[7] = { 0, 1, 2, 3, 4, 5, 6};
const byte digit_4[7] = { 7, 8, 9, 10, 11, 12, 13}; // not used here 14, 15, 16 and 17

// these will be sent to i2c third UNO - second slave UNO -> 3
const byte digit_5[7] = { 0, 1, 2, 3, 4, 5, 6};
const byte digit_6[7] = { 7, 8, 9, 10, 11, 12, 13}; // not used here 14, 15, 16 and 17

// define the letter for POLICE
const byte text[6][7] = {
//  a, b, c, d, e, f, g
  { 1, 0, 0, 1, 1, 1, 1}, // first digit - arduino 1 = E
  { 1, 0, 0, 1, 1, 1, 0}, // second digit - arduino 1 = C
  { 0, 0, 0, 0, 1, 1, 0}, // third digit - arduino 2 = I
  { 0, 0, 0, 1, 1, 1, 0}, // fourth digit - arduino 2 = L
  { 1, 1, 1, 1, 1, 1, 0}, // fifth digit - arduino 3 = O
  { 1, 1, 0, 0, 1, 1, 1}, // sixth digit - arduino 3 = P
};

// Variables to store individual numbers - from seconds to hours
// BS: we use six numbers
byte sixnum=0; // hours
byte fivenum=0; // hours
byte fournum=0; // minutes
byte thirdnum=0; // minutes
byte secondnum=0; // seconds
byte firstnum=0; // seconds

// Include the required Wire library for I2C
#include <Wire.h>

// variable to be sent and received over i2c
byte data[6]={0,0,0,0,0,0};

// timestamp to check when I2C data received
//volatile 
unsigned long ReceiveTime = millis();

String prevnumchar = "";

void setup() {

  // redefine if arduino is master
  if(master_slave > 1) {
    // master_slave 2 or 3
    master = false;
  } else {  
    // master_slave 1
    master = true;
  } 
  
  if(master) {
    // Start the I2C Bus as Master
    Wire.begin(); 
    
  } else {
    // slave
    // Start the I2C Bus as Slave on address number of master_slave
    Wire.begin(address[master_slave - 2]); // from 2 become 0
    // Attach a function to trigger when something is received.
    Wire.onReceive(receiveEvent);
  }

  // initialize pins as outputs
  for(int i=0; i<sizeof(all_pins);i++){
    pinMode(all_pins[i], OUTPUT);
    digitalWrite(all_pins[i], LOW);
  }
  
  if(master) {
    // change to input mode
    pinMode(NoonButt, INPUT);
    pinMode(SpeedButt, INPUT);
    // pullup to activate something on LOW
    digitalWrite(NoonButt, HIGH);  
    digitalWrite(SpeedButt, HIGH);  
  }
  
  if(test){
    //visiblenumber=(int)visiblenumber/1; // 1, 10 times smaller visible countdown
    //hiddennumber=(int)hiddennumber/1; // 1, 10 times smaller hidden countdown
    countnumber=visiblenumber;
    prevcountnumber = countnumber;
    TimeStep=10000; // in micros - 100 times faster
  } 
  
  if(testalarm){
    visiblenumber=100; // seconds
    hiddennumber=100; // seconds
    countnumber=visiblenumber;
    prevcountnumber = countnumber;
  }
  
  if(testserial) {
    Serial.begin(115200);
    Serial.print("testing arduino number ");
    Serial.print(master_slave);
    Serial.println("...");
  }

  // refresh
  TimeStamp=micros(); 
  ReceiveTime = millis();
}

// only slaves do this
void receiveEvent(int howMany) {

  //reading the 6 incoming bytes: index 0 => num 6, index 1 => num 5, etc. 
  while (Wire.available()) {
    for(int i=0; i<6; i++) {
      //char c = Wire.read(); // receive byte as a character
      //int x = Wire.read();    // receive byte as an integer
      data[i] = Wire.read();
    }
    
    // combine into integer - cast into long int to have correct operations!
    countnumber = 0;
    countnumber += (long int)data[5]; // num 1 = secs
    countnumber += (long int)(10 * (long int)data[4]); // num 2 = tens of secs
    countnumber += (long int)(100 * (long int)data[3]); // num 3 = mins
    countnumber += (long int)(1000 * (long int)data[2]); // num 4 = tens of mins
    countnumber += (long int)(10000 * (long int)data[1]); // num 5 = hours
    countnumber += (long int)(100000 * (long int)data[0]); // num 6 = tens of hours

  }
  
  // remember the last time received
  ReceiveTime = millis();
  
}
    
void loop() {

  // do what a slave needs to do
  if(!master) {

    // anything received? Data from I2C - can be old when nonvisible
    sixnum = data[0];
    fivenum = data[1];
    fournum = data[2];
    thirdnum = data[3];
    secondnum = data[4];
    firstnum = data[5];

    // here we dont know if CountVisible true or false !
    // we can check if zero reached to toggle it
    //if(countnumber == 0) {
    //  CountVisible = !CountVisible; // toggle
    //}
    // this can for some reason become asynchrone with the master
    // also check timestamp ReceiveTime < 2000 = less than 2 secs - can be more: 10 secs
    if(millis() - ReceiveTime < 2000){
      // ok, we got fresh info from master -> we must be counting visibly 
      CountVisible = true; // toggle
    } else {
      CountVisible = false; // toggle
    }
    
    // check what the arduino shows
    // just to print out
    String numchar = "";

    // master sends data only on CountVisible - so here we need to check if something sent recently - or show nothing or zeros
    // some time check in  receiveEvent()
    // problems with fournum
    // arduino 2 => minutes
    // arduino 3 => hours
    // here check if empties tranfer well to minutes (arduino 2) and hours (arduino 3)
    
    if (CountVisible) {
      // display number on display depending on number of digits remaining
      // check also if some leading numbers are 0

      if(master_slave == 3){
        // tens of hours is set by slave 2 = arduino 3
        setDigit(6,sixnum); //(byte)
        // hours: second slave - arduino 3  
        setDigit(5,fivenum);
      }  
  
      if(master_slave == 2){
        // tens minutes: first slave - arduino 2  
        setDigit(4,fournum);
        // minutes on first slave - arduino 2  
        setDigit(3,thirdnum);
      }

      /**/  
      // skip the leading zeros if needed
      if(!showzeros) {
        
        // countnumber already combined in receiveEvent
        // concatenate into string
        if (countnumber > 99999) { 
          // 6 numbers // ok - show all - no leading zeros needed
        } else if (countnumber > 9999) { 
          // 5 numbers
          if(master_slave == 3){
            setChar(6,' '); // empty tens hours
          }  
        } else if (countnumber > 999) {
          // 4 numbers
          if(master_slave == 3){
            setChar(6,' '); // empty tens hours
            setChar(5,' '); // empty hours
          }
        } else {
          // 3 numbers and less
          if(master_slave == 3){
            setChar(6,' '); // empty tens hours
            setChar(5,' '); // empty hours
          }  
          if(master_slave == 2){
            setChar(4,' '); // empty tens minutes
          }  
          
        }

      } // end !showzeros
      
      // check if zero reached on slaves
      if(countnumber==0) {
        
        // If countdown at zero flash slave displays
        SignalOut = true; // set the flag to do some signalling
        AlarmCount=0;

        if(master_slave == 3){
          setChar(6,' '); // empty tens hours
          setChar(5,' '); // empty hours
        }  
        if(master_slave == 2){
          setChar(4,' '); // empty tens minutes
          setChar(3,' '); // empty minutes
        }  
      } 
    
      // do some signaling if countdown zero reached
      // if possible do it while counting already
      // here we need local synchronisation - 1 sec
      // if(micros()-TimeStamp >= TimeStep) {
      // blink twice within second -> 1000000 us
      if(SignalOut && micros()-TimeStamp >= 1000000 ) {
        TimeStamp=micros();
        // have some global counter
        AlarmCount++; // this increases each second
        // write our some defined text
        // blink it then blank it, etc.
        // four times
        for (int y = 0; y < 4; y++){ 
          // if y==2 blink to empty
          if(y>1) {
            if(master_slave == 3){
              setChar(6,' '); // empty tens hours
              setChar(5,' '); // empty hours
            }  
            if(master_slave == 2){
              setChar(4,' '); // empty tens minutes
              setChar(3,' '); // empty minutes
            }  

            // check via Serial
            // check via Serial
            if(testserial) {
              Serial.print(" alarm blank ");
            }
            
          } else { // blink zeros
            if(master_slave == 3){
              setDigit(6, 0); // show 0
              setDigit(5, 0); // show 0
            }
            if(master_slave == 2){
              setDigit(4, 0); // show 0
              setDigit(3, 0); // show 0
            }  
            // check via Serial
            if(testserial) {
              Serial.print(" alarm blink ");
            }
          }
        } // end for 
  
        // check to reset the alarm
        if(AlarmCount >= AlarmLength) {
          SignalOut=false;
        }
      } // end alarm

      // prepare to print on Serial
       if(master_slave == 3) {
        numchar = numchar + sixnum;
        numchar = numchar + fivenum;
      }
      if(master_slave == 2){
        numchar = numchar + fournum;
        numchar = numchar + thirdnum;
      }

      // switch or blink LED on slave
      if(LedOn) {
        digitalWrite(Led, LOW);    // turn the LED off by making the voltage LOW
        LedOn=!LedOn;
      } else {
        digitalWrite(Led, HIGH);   // turn the LED on (HIGH is the voltage level)
        LedOn=!LedOn;
      }


    } else {
        // not visible
        // all non-master numbers zero or blank
        // unvisible zeros
        if(shownightzeros) {
          if(master_slave == 3){
            setDigit(6, 0); // show 0 tens hours
            setDigit(5, 0); // show 0 hours
          }  
          if(master_slave == 2){
            setDigit(4, 0); // show 0 tens minutes
            setDigit(3, 0); // show 0 minutes
          }  

        } else {
          if(master_slave == 3){
            setChar(6,' '); // empty tens hours
            setChar(5,' '); // empty hours
          }  
          if(master_slave == 2){
            setChar(4,' '); // empty tens minutes
            setChar(3,' '); // empty minutes
          }  
        }  
        
    } // end CountVisible

    // check via Serial on slave //numchar!=""
    //if(testserial) {
    if(testserial && prevnumchar!=numchar) {
      prevnumchar=numchar;
      Serial.print("arduino ");
      Serial.print(master_slave); // ok
      Serial.print(": ");
      Serial.print(countnumber); // ok
      Serial.print(" = ");
      Serial.print(sixnum); // if 0 - shows here as 1 (previous)
      Serial.print(fivenum);
      Serial.print(":");
      Serial.print(fournum);
      Serial.print(thirdnum);
      Serial.print(":");
      Serial.print(secondnum);
      Serial.print(firstnum);
      Serial.print(" -> "); // print out what this arduino shows
      Serial.print(numchar);
      Serial.println();
      // some delay - here we have hours and minutes - if speedy ( x 1000)-> at most tenth of a second
      delay(50);
    }
    
    return; // exit this loop if slave
    
  } // end !master

  // only on master
  if(master) {
    
    // check if NoonButt button LOW
    if(digitalRead(NoonButt)==0){
      // set the countnumber to NOON
      countnumber = NOON;
      CountVisible = true;
    }
      
    // check if speedup button pushed - or forced test
    if(digitalRead(SpeedButt)==0 || test){
      speedup = true;
      // change the timestep 
      TimeStep=10000; // in micros - 100 times faster
    } else {
      speedup = false;
      // back to normal
      TimeStep=1000000; // in micros - 1 second
    }  
  }

  // only master continues
  // check if time to decrement countnumber
  if(micros()-TimeStamp >= TimeStep) {
    TimeStamp=micros();
    countnumber --;
   
    // Convert number to a time value to check for optional 9999 char (change to 5900 -> -4000) or 99 char (change to 59 -> -40)
    // we use notation 240000 as 24 hours, 00 minutes, 00 seconds - 
    // one down would be: 239999 - becomes 235900 (-4000) and 235959 
    
    String mystring = String(countnumber); // Transform Counter Int to String for manipulation

    // counter should be integer - to each display digit we want to send a number 0-9
    // except hours: 00 to 24 (or whatever is max) -> >24 resets to 00
    // except minutes: 00 to 59 -> countdown jumps from 99 to 59
    // except seconds: 00 to 59 -> countdown jumps from 99 to 59
    
    // this takes care of minutes and seconds - from 99 to 59

    // check and adapt 
    // check only the last 4 digits here
    // if we incremented - we would need to jump from 60 to 100 
    // "6060" -> countnumber +  4000 // = 10060 // plus 1 hour and minutes to 00
    // and now secs
    // "60" -> countnumber +  40 // = 100 // plus 1 minute and seconds to 00
    
    for (int i = 0; i < 6; i++){
      // minutes and secs jump from 9999 to 5999
      // myString.substring(from) -> and to the end
      if ( mystring.substring(i) == "9999" ) {
        // adapt the value of minutes
        countnumber = (countnumber - 4000);
      }        
      // now only secs - jump from 99 to 59
      if ( mystring.substring(i) == "99" ) { 
        // adapt the value of seconds
        countnumber = (countnumber - 40);
      }
    } // end for

    //  Display number on display depending on number of digits remaining
    // = skip the leading zeros!
    // all these will be send over I2C
    // why does fournum have problem that it shows 0 ?
    sixnum = countnumber/100000%10;
    fivenum = countnumber/10000%10;
    fournum = countnumber/1000%10;
    thirdnum = countnumber/100%10;
    secondnum = countnumber/10%10;
    firstnum = countnumber%10;

    // send to display - if countdown
    if(CountVisible) {
      
      // 6 numbers and less
      if (countnumber > 99999) { // more than 5 numbers -> 6 numbers
        
        // on master deal with two seconds digits - arduino 1
        if(master_slave == 1){
          setDigit(2,(byte)secondnum);
          setDigit(1,(byte)firstnum);
        }
            
      } else {
        
        // 5 numbers and less
        if (countnumber > 9999) { // but more than 4 numbers -> 5 numbers 

          // on master deal with two seconds digits -> arduino 1
          if(master_slave == 1){
            setDigit(2,(byte)secondnum);
            setDigit(1,(byte)firstnum);
          }
                   
        } else {
          // 4 numbers and less
          if (countnumber > 999) { // 4 numbers

            // send to display
            // on master deal with two seconds digits -> arduino 1
            if(master_slave == 1){
              setDigit(2,(byte)secondnum);
              setDigit(1,(byte)firstnum);
            }  

          } else {
            // 3 numbers and less
            // send to display
           
            // on master deal with two seconds digits - arduino 1
            if(master_slave == 1){
              setDigit(2,(byte)secondnum);
              setDigit(1,(byte)firstnum);
            }  
                       
          } // end if 4 numbers or less
          
        } // end if 5 numbers or less
       
      } // end if 6 numbers or less
      
    } else {
      
      // not visible seconds
      // do not show any numbers
      // all non-master numbers zero or blank
      // nonvisible at night?
      if(shownightzeros) {
          setDigit(2, 0); // show 0 tens seconds
          setDigit(1, 0); // show 0 seconds
      } else {
          setChar(2,' '); // empty tens seconds
          setChar(1,' '); // empty seconds
      }  
      
    } // end if visible

    // sending to second UNO display - only if visible - no calculus over there
    // may be ok to send also when hidden - so that slaves also know they are hidden
    // may need to clear all numbers before
    // we are here on master
    if(CountVisible) {
      data[0] = sixnum;
      data[1] = fivenum;
      data[2] = fournum;
      data[3] = thirdnum;
      data[4] = secondnum;
      data[5] = firstnum;

      // transmit via i2c
      //Wire.beginTransmission(9); // transmit to device #9
      // to first slave: address[0]
      Wire.beginTransmission(address[0]);
      // send countnumber //Wire.write(countnumber); // to send as a single byte - but 64 is max...
      Wire.write(data, sizeof(data)); // send the full package = 6 numbers 
      Wire.endTransmission();    // stop transmitting

      // to second slave: address[1]      
      Wire.beginTransmission(address[1]);
      // send countnumber //Wire.write(countnumber); // to send as a single byte - but 64 is max...
      Wire.write(data, sizeof(data)); // send the full package = 6 numbers 
      Wire.endTransmission();    // stop transmitting

    }
    
    // chek via Serial      
    if(testserial) {
      Serial.print(countnumber); // ok
      Serial.print(" = ");
      Serial.print(sixnum); // if 0 - shows here as 1 (previous)
      Serial.print(fivenum);
      Serial.print(":");
      Serial.print(fournum);
      Serial.print(thirdnum);
      Serial.print(":");
      Serial.print(secondnum);
      Serial.print(firstnum);
      Serial.println();
    }

    // one second was just registered

    // switch or blink LED on master
    if(LedOn) {
      digitalWrite(Led, LOW);    // turn the LED off by making the voltage LOW
      LedOn=!LedOn;
    } else {
      digitalWrite(Led, HIGH);   // turn the LED on (HIGH is the voltage level)
      LedOn=!LedOn;
    }

    // sound a short peep each second - Speaker is on master   
    // only during daylight countdown
    if(CountVisible) {
      // rather use some pwm option and a loudspeaker
      // play tick sound via Speaker pin
      //tone(pin, frequency, duration)
      //pin: the Arduino pin on which to generate the tone.
      //frequency: the frequency of the tone in hertz. Allowed data types: unsigned int.
      //duration: the duration of the tone in milliseconds (optional). Allowed data types: unsigned long.
      // play a short note
      tone(Speaker, notes[0], duration);
    }

    // If countdown at zero sound alarm and flash display
    // reset CountDown flag and set the silent = hidden nightly count
    if (countnumber == 0) {
       if(CountVisible) {
         // change to hidden countdown - slaves should also know not to show anything
         CountVisible = false; // unset CountVisible flag
         SignalOut = true; // set the flag to do some signalling
         countnumber = hiddennumber;
         AlarmCount=0;
         
       } else {
         // change to visible countdown - slaves should also know to show again
         CountVisible = true; // set CountVisible flag
         SignalOut = true; // set the flag to do some signalling
         countnumber = visiblenumber;
         AlarmCount=0;
       }
    }       
    
    // do some signaling if countdown zero reached
    // if possible do it while counting already
    if(SignalOut) {
      // have some global counter
      AlarmCount++; // this increases each second
      // write our some defined text
      // blink it - write it then blank it, etc.
      //writeText();
      // or
      // do the alarm clock sound + blink the zeros 
      // four times
      for (int y = 0; y < 4; y++){ 
        // if y==2 blink to empty
        if(y>1) {
          //setChar(6,' '); // empty
          //setChar(5,' '); // empty
          //setChar(4,' '); // empty
          //setChar(3,' '); // empty
          // on master we are in seconds!
          setChar(2,' '); // empty
          setChar(1,' '); // empty
          // check via Serial
          // check via Serial
          if(testserial) {
            Serial.print(" alarm blank ");
          }
        } else { // blink zeros
          //setDigit(6, 0); // show 0
          //setDigit(5, 0); // show 0
          //setDigit(4, 0); // show 0
          //setDigit(3, 0); // show 0
          // on master we are in seconds!
          setDigit(2, 0); // show 0
          setDigit(1, 0); // show 0
          // check via Serial
          if(testserial) {
            Serial.print(" alarm blink ");
          }
        }
        // sound the alarm      
        if(AlarmRing) {
          tone(Speaker, notes[0], duration); // duration is max 200ms
          // should not go over 4 x duration = 1000 = 1 second 
          delay (2*duration) ;// Delay ms
        }  
      } // end for 
  
      // check to reset the alarm
      if(AlarmCount >= AlarmLength) {
        SignalOut=false;
      }
    } // end alarm

  } // end main countdown for all of the 8 numbers 99:99:99:99 to 00:00:00:00
 
} // end loop - we start again from 99:99:99 to 00:00:00 = hh:mm:ss

// functions to light up LEDs

// indexes of digits: 1, 2, ...
//setChar(4,' '); // empty digit 4 = fourth number
//setDigit(3,(byte)thirdnum); //write number thirdnum to digit 3 = third number

void setChar(byte ind, char number) {
  // first find correct set of segment pins
  // calls to this function should be correct - filtered in loop
  if(ind==1){
    // master  = arduino 1  // first set of pins
    // now draw the local digit
    displayChar(number, digit_1);
    
  } else if (ind==2){
    // master  = arduino 1     // second set of pins
    // now draw the local digit
    displayChar(number, digit_2);
    
  } else if(ind==3){
    // slave 1 = arduino 2 // first set of pins
    displayChar(number, digit_3);

  } else if(ind==4){
    // slave 1 = arduino 2   // second set of pins
    displayChar(number, digit_4);

  } else if(ind==5){
    // slave 2 = arduino 3    // first set of pins
    displayChar(number, digit_5);

  } else if(ind==6){
    // slave 2 = arduino 3    // second set of pins
    displayChar(number, digit_6);

  }
  
}

// here we use arrays digit_1 {a,b,c,d,e,f,g} etc 
// relates to the local pins being switched on off
void displayChar(char num, byte dig[7]) {
  // we enter here on master
  //Conditions for displaying nothing
  //first turn all segments off
  for(byte i=0; i<7;i++){
    digitalWrite(dig[i],LOW); // all down
  }
  //if(num == ' ') {
    // nothing needed
  //} else 
  if(num == '-') {
    // conditions for displaying minus
    digitalWrite(dig[6],HIGH); // g segment lights
  }
 
}  

void setDigit(byte ind, byte number) {
  // first find correct set of segment pins per number and per arduino 
  // calls to this function should be correct - filtered in loop
  if(ind==1){
    // master   // first set of pins
    displayDigit(number, digit_1);
    
  } else if (ind==2){
    // master   // second set of pins
    displayDigit(number, digit_2);
    
  } else if(ind==3){
    // slave 1  // first set of pins
    displayDigit(number, digit_3);
    
  } else if(ind==4){
    // slave 1  // second set of pins
    displayDigit(number, digit_4);

  } else if(ind==5){
    // slave 2  // first set of pins
    displayDigit(number, digit_5);

  } else if(ind==6){
    // slave 2  // second set of pins
    displayDigit(number, digit_6);

  }
}

// switch on/off outputs 
// here we use arrays digit_1 {a,b,c,d,e,f,g} etc 
// this always relates to local set of pins 
void displayDigit(byte num, byte dig[7]) {
  //Conditions for displaying segment a
  if(num!=1 && num != 4)  digitalWrite(dig[0],HIGH);
  else   digitalWrite(dig[0],LOW);
  
  //Conditions for displaying segment b
  if(num != 5 && num != 6)  digitalWrite(dig[1],HIGH);
  else   digitalWrite(dig[1],LOW);

  //Conditions for displaying segment c
  if(num !=2)  digitalWrite(dig[2],HIGH);
  else   digitalWrite(dig[2],LOW);

  //Conditions for displaying segment d
  if(num != 1 && num !=4 && num !=7)  digitalWrite(dig[3],HIGH);
  else   digitalWrite(dig[3],LOW);

  //Conditions for displaying segment e 
  if(num == 2 || num ==6 || num == 8 || num == 0)  digitalWrite(dig[4],HIGH);
  else   digitalWrite(dig[4],LOW);

  //Conditions for displaying segment f
  if(num != 1 && num !=2 && num!=3 && num !=7)  digitalWrite(dig[5],HIGH);
  else   digitalWrite(dig[5],LOW);

  if (num!=0 && num!=1 && num !=7)  digitalWrite(dig[6],HIGH);
  else   digitalWrite(dig[6],LOW);

}
// write POLICE letters to each digit
// definitions of active pin levels are in text[6][7] arr 
void writeText(){
  // check which arduino -> master_slave: 1, 2, 3 

  if(master_slave == 1) {
    // digit indexes 0 and 1 = E and C
    // seconds
    for(int i=0; i<sizeof(text[0]); i++){
      //digit_1 has pins listed as a b c d e f g
      if(text[0][i]>0) digitalWrite(digit_1[i], HIGH);
      else  digitalWrite(digit_1[i], LOW);
    }
    // tens of seconds digit
    for(int i=0; i<sizeof(text[1]); i++){
      //digit_1 has pins listed as a b c d e f g
      if(text[1][i]>0) digitalWrite(digit_2[i], HIGH);
      else  digitalWrite(digit_2[i], LOW);
    }
        
  }

  if(master_slave == 2) {
    // digit indexes 2 and 3 = I and L
    // minutes digit
    for(int i=0; i<sizeof(text[2]); i++){
      //digit_1 has pins listed as a b c d e f g
      if(text[2][i]>0) digitalWrite(digit_3[i], HIGH);
      else  digitalWrite(digit_3[i], LOW);
    }
    // tens of minutes digit
    for(int i=0; i<sizeof(text[3]); i++){
      //digit_1 has pins listed as a b c d e f g
      if(text[3][i]>0) digitalWrite(digit_4[i], HIGH);
      else  digitalWrite(digit_4[i], LOW);
    }
    
  }

  if(master_slave == 3) {
    // digit indexes 4 and 5 = O and P
    // hours digit
    for(int i=0; i<sizeof(text[4]); i++){
      //digit_1 has pins listed as a b c d e f g
      if(text[4][i]>0) digitalWrite(digit_5[i], HIGH);
      else  digitalWrite(digit_5[i], LOW);
    }
    // tens of hours digit
    for(int i=0; i<sizeof(text[5]); i++){
      //digit_1 has pins listed as a b c d e f g
      if(text[5][i]>0) digitalWrite(digit_6[i], HIGH);
      else  digitalWrite(digit_6[i], LOW);
    }
  }
  
}