// CODE SAMPLE#4
// THIS PROGRAM ALLOWS FOR YOU TO PROGRAM THE TIMER DIGITALLY CONTROL THE POINT ACCUMULATOR.  IT WILL AUTOMTICALLY PROGRAM HOW MANY POINTS IT WILL TAKE TO HIT THE GOAL...
// ONCE THE GOAL IS HIT, THE ARDUINO WILL TELL THE TIMER TO ENTER BACK INTO THE 'PROGRAM POINTS SECTION (BYPASSING THE MAIN MENY), AND LOOP. EDIT THIS PROGRAM AS YOU'D LIKE, BUT RUN IT FIRST.  
// THE ARDUINO WILL POWER THE TIMER BOARD.

//CONNECTIONS:
//CONNECT THE GD PIN ON THE TIMER BOARD TO ANY GND TERMINAL OF YOUR ARDUINO, OR COMPATIBLE PROCESSOR.
//CONNECT THE 5V PIN ON THE TIMER BOARD TO A 5V POWER SOURCE (5V LINE ON YOUR ARDUINO)
//CONNECT GPIO#2 (pulseout) ON YOUR ARDUINO TO THE 'EN' PIN ON THE TIMER BOARD.  THIS IS THE PIN THAT SENDS DATA TO THE TIMER
//CONNECT GPIO#3 (inputsignal) TO THE 'DN' PIN ON THE TIMER.  THIS PIN WAITS FOR AN 'END' SIGNAL FROM THE TIMER, WHICH UCCRS WHEN TIME RUNS OUT, OR THE POINT GOAL HAS BEEN HIT.

#define pulseout 2    // THIS IS OUR OUTPUT LINE WHICH IS DEDICATED TO GPIO#2 ON CHIP-A
#define inputsignal 3 // Incoming signal line from the timer
int state = 0;        // THIS IS USED IN THE senddat() FUNCTION
int sendval = 0;      // ALSO USED IN THE senddat() FUNCTION

void setup(){
pinMode(pulseout,OUTPUT);   // ASSIGN pulseout AS AN OUTPUT
pinMode(inputsignal,INPUT); // This signal is set to 5v when timers have run out or when the number of set points have been accumulated.  Basically when the 
delay(1000);                // Wait one second before sending the program data
sendval = 3;    // THIS CODE IS ONLY COMPATIBLE WITH MODE#3 - POINT ACCUMULATOR
senddat();      // CALL THE senddat FUNCITON TO TRANSMIT.  AS LONG AS THE TIMER WAS IN THE MAIN MENU AND SET IN DIGITAL MODE, THEN YOU'RE IN GOOD SHAPE.
delay(1000);    // WAIT ONE MORE SECOND BEFORE STARTING THE MAIN PROGRAM
}

void loop(){
delay(100);     // Wait 100ms
sendtime();     // CALL THE "sendtime' FUNCTION, WHICH WILL PROGRAM THE REQUIRED POINTS NEEDED TO END THE PROGRAM. PLEASE SEE THE FUNCTION BELOW TO SEE HOW IT WORKS.
delay(2000);    // WAIT 2 SECONDS BEEFORE PROCEEDING
waitforsignal(); // CALL THE 'waitforsignal' FUNCTION.  THIS FUNCTION WAITS FOR THE TIMER TO END. ONCE DONE A SIGNAL IS SENT TO THIS ARDUINO.  WHEN THIS HAPPENS...
// YOU WILL SEE HOW THE PROGRAM RESETS THE TIMER BACK TO THE MAIN MENU.  ONCE DONE, THE PROGRAM WILL LOOP OVER AND OVER.
}

void waitforsignal(){                      // THIS FUNCTION WAITS FOR THE END SIGNAL FROM THE TIMER BEFORE RESETTING IT.
  state = 0;                               // LOOP TGE FOLLOWING CODE UNTIL state EQUALS 1 (IT HAPPENS WHEN THE POINT GOAL HAS BEEN ACHIEVED!)
  while(state == 0){                       // FUN THE REST OF THIS CODE UNTIL state CHANGES TO 1
  pulse2();                                // THIS FUNCTION (SEEN BELOW) SENDS A PULSE TO THE TIMER, WHICH WILL INCREMENT HOW MANY POINTS IT COUNTS.  
  // SET A CONDITION IN YOUR OWN PROGRAMMING BEFORE USING THIS FUNCTION.  FOR INSTANCE, WHEN YOU PRESS A BUTTON, CALL pulse2().
  // IF TAKE AN ANALOG READING OF A SENSOR.  IF THE READING IS WITHIN A SPECIFIC WINDOW, THEN CALL pulse2().  THE OPTIONS ARE ENDLESS.
  delay(50);    // IN THIS CODE SAMPLE, WE'LL SEND PULSES OVER MUCH FASTER THAN THAT LAST!  WE WENT FROM 2 SECONDS PER PULSE IN CODE SAMPLE#3 TO 50MS
  // IF THE THE PROGRAMMED NUMBER (10) HAS BEEN REACHED, THEN THE inputsignal LINE SHOULD READ 5V, WHICH WILL INITIATE THE FOLLOWING:
  if(digitalRead(inputsignal) == HIGH){   // IF THE inputsignal READ 5V(HIGH), THEN DO THE FOLLOWING, AS THE POINT NUMBBER HAS BEEN HIT,  IN THIS CASE, 10 HITS.
  Serial.println("Done");                 // PRINT THIS TO THE SERIAL MONITOR IF YOU'D LIKE.
  // At this point, if you send a value of 5, you'll enter back to the main meny.  If you send any other value, you'll enter back to the same mode. 
  // Before you do this, you'll need to set pulseout to 5v for at least 500ms before using the senddat command.
  delay(5000);                  // WAIT 5 SECONDS
  digitalWrite(pulseout,HIGH);  // SET THE pulseout PIN TO 5V AND THEN WAIT 500ms
  delay(500);                   // 500ms DELAY
  sendval = 6;      // This value will send the timer back to the main menu if set to 5.  WE ARE NOW SENDING 6, WHICH WILL BYPASS THE MAIN MENU, AND ENTER 'PROGRAM TIME' DIRECTLY!
  senddat();        // Send a value of '5' to the timer
  delay(5000);      // Wait 5 seconds before looping the program again.  Once you sent over the value of 5, a few seconds are needed for the timer to re-enter the main menu.
  state = 1;        // SETTING state TO 1 WILL END THIS LOOP, AND START YOU OVER AT THE BEGINNING OF VOID LOOP!
  // THIS LOOP WILL RUN OVER AND OVER AND OVER.  MODIFY AS YOU SEE FIT!
}
}
}

void sendtime(){ // THIS FUNCTION SENDS OVER THE FOUR POINT VARIABLES NEEDED TO SET THE POINTS, AND START THE TIMER.  WE'RE SENDING OVER A POINT VALUE OF 70
  sendval = 0;  // 1X POINT MULTIPLIER
  senddat();
  sendval = 7;  // 10X POINT MULTIPLIER
  senddat();
  sendval = 0;  // 100X POINT MULIPLIER
  senddat();
  sendval = 0;  // 1000X POINT MULTIPLIER
  senddat();
  delay(200);   // Wait 200ms
  // At this point, sending over any info will start the timer.  Consider adding in a start condition here, like a button being pressed.
  sendval = 1;  // Send anything to start the countup/down/point counter.  In this case we only send 1.  
  senddat();    // When this data is sent over, the timer will start
  delay(100);   // Wait 100ms.  Consider your timer programmed and started!
}



void senddat()    // THIS FUNCTION TRANSMITS THE NUMBER IN sendval OVER TO THE RECEIVER BY SENDING PULSES 
{
  if(sendval == 0){  // If the value programmed in sendval is 0, send a value of 11 instead.  The timer board will interpret this as a 0.
    sendval = 11;
  }
  state = 0;         // Set 'state' to 0
  //
  digitalWrite(pulseout,HIGH);  // Set 'pulseout' to high
  delay(100);                   // Wait 100ms
  //
  while(state == 0){  // DO THE FOLLOWING UNTIL STATE DOES NOT EQUAL 0, OR THE break; COMMAND IS USED.  
    {
      pulse();                // CALL THE pulse() FUNCTION, WHICH LITERALLY JUST TURN THE OUTPUT LINE ON AND OFF ONCE.
      sendval = sendval - 1;  // NOW THAT A PULSE HAS BEEN SENT, DECRREMENT THE VALUE IN sendval BY 1
      if(sendval == 0)        // IF sendval EQUALS 0, THEN THERE ARE NO MORE PULSES TO BE SENT. IF THIS IS THE CASE, FROM THIS ROUTINE.
      {
        state = 1;            // THIS ENDS THE ROUTINE
      }
    }
  }
  delay(100);                 // Wait 100ms.  This is the end of this function. Data has been sent!
}


 void pulse()  // SEND A 5ms PULSE TO THE RECEIVER
  {
    digitalWrite(pulseout,HIGH); // Turn the 'pulseout' on (5v) for 5ms, then set it LOW (0v) for 5ms.  
    delay(5);
    digitalWrite(pulseout,LOW);
    delay(5);
  }

   void pulse2()  // SEND A 5ms PULSE TO THE RECEIVER
  {
    digitalWrite(pulseout,HIGH); // Turn the 'pulseout' on (5v) for 5ms, then set it LOW (0v) for 5ms.  
    delay(50);
    digitalWrite(pulseout,LOW);
    //delay(50);
  }