// THE BARKLEY CODE SAMPLE#1
#define trig555 4   // TRIGGER THE 555 TIME RELAY - CONNECTION TO GPIO 4
#define in555 5     // OUTPUT FROM 555 TIMER TO GPIO5 SET AS AN INPUT 
#define ultra 8     // GPIO IS IS THE ULTRASONIC TRANSDUCER DRIVER PIN
#define buzzer 9    // GPIO 9 DRIVES THE BUZZER
#define reset555 6  // GPIO 6 ENABLES AND DISABLES THE 555 TIMER
#define LED1 12     // GPIO PINS 12 AND 13 DRIVE THE LEDS
#define LED2 13
#define B 3         // DIP SWITCH-B IS CONNECTION TO GPIO 3, AND THE DIP SWITCH-A CONNECTION TO GPIO 2
#define A 2

int sense = 0;      // THIS VARIABLE IS USED FOR VOLUME CONTROL
int freq = 0;       // THIS VARIABLE IS USED FOR FREQUENCY CONTROL
int freq2 = 0;      // ALSO USED FOR FREQUENCY CONTROL
int state = 0;      // STATE AND STATE2 ARE USED TO KEEP PROGRAMMING IN LOOPS
int state2 = 0;

void setup() {             // LET'S SET UP ALL OF OUR GPIOs
pinMode(trig555,OUTPUT);   // SETYUP THE 555 TIMER TRIGGER AS AN OUTPUT
digitalWrite(trig555,LOW); // TURN DELAY TRIGGER OFF
pinMode(ultra,INPUT);      // THIS CAN BE SET UP AS AN INPUT OR OUTPUT, BUT ONLY SET IT UP AS OUTPUT IF YOU WANT TO DRIVE THE BUZZER AND ULTRASONIC TRANDUCER SEPERATELY.  FOR NOW, LEAVE IT AS AN INPUT, AND PLACE A JUMPER ON THE HEADER BELOW GPIO 9
pinMode(B,INPUT);          // CONTINUED FROM ABOVE... IF YOU SHORT THE JUMPER BELOW GPIO 9, THEN THE BUZZER DRIVER SIGNAL WILL CONTROL BOTH THE BUZZER AND ULTRASONIC TRANSDUCER IN PARALLEL.  UNRELATED, SET DIP-B AS AN INPUT
pinMode(A,INPUT);          // SET DIP-A AS AN INPUT
pinMode(buzzer,OUTPUT);    // SET THE BUZZER AS AN OUTPUT.  IF THE JUMPER BELOW GPIO 9 IS SHORTED, THEN THIS SIGNAL WILL ACT TO CONTROL BOTH THE BUZZER AND ULTRASONIC TRANSDUCER AT THE SAME TIME.
digitalWrite(buzzer,LOW);  // TURN THIS SIGNAL OFF
pinMode(LED1,OUTPUT);      // SET BOTH LEDS AS OUTPUTS
pinMode(LED2,OUTPUT);
pinMode(in555,INPUT);      // THIS IS THE DELAY INPUT CREATED BY THE 555 TIMER.  FOR MORE INFO ON THE 555 TIMER, SEE BELOW
pinMode(reset555,OUTPUT);  // SET THE 555 RESET LINE AS AN OUPTU AND THEN TURN IT ON BY SETTING THE LINE HIGH.
digitalWrite(reset555,HIGH);
}

//THE 555 TIMER, YOU SAY?
// YUP!  THE 555 TIMER CHIP ACTS AS A DELAY PULSE CREATER (MONOSTABLE MULTIVIBRATOR).  ADJUST THE 'DELAY' VARIABLE RESISTOR TO CHANGE THE DELAY OF THE SIGNAL
// THERE ARE THREE PINS ASSOCIATED WITH THE 555 TIMER. THE FIRST IS trig555.  SEND A SHORT PULSE TO THIS LINE TO TRIGGER THE DELAY.  THE 555 OUTPUT CONNECTED TO in555.  THIS LINE SENSES WHEN THE PULSE HAS BEEN GENERATED AND...
// OUT CODE WILL PERFORM ACTIONS FOR THE DURATION OF THE PULSE.  THE reset555 PIN NEEDS TO BE SET TO 5V/HIGH TO ENABLE THE 555 TIMER.  


// HERE ARE THE GPIOs THAT WE ARE USING...
// A0 is FREQUENCY adustment.  Adjust the FREQ variable resistor to play around with the frequency.  High frequencies will be hard to haer.
// A1 is sound sensitivity adjustment.  Adjust the SENSE variable resistor to heighten or lower the sound sensitivity from the microphone, as the microphone will wait for loud noises and then compare againse a value determined by this variable resistor.
// 13 and 12 are LEDs
// 8 is driver buzzer
// 9 is ultrasonic driver
// 2 and 3 is DIP A and DIP B respectively.  Normally low.  Pulled-high when ON
// 0 is NORMALLY-LOW button. Goes to 5v when pressed.
// 4 is delay trigger.  Pulse on for 1ms to 5ms to activate delay
// 5 is delay output set as an input
// Jumper located right below GPIO 9 connections GPIOs 8 and 9 together if shorted.
// BSTEN is boost-enable jumper.  Only power this booster on if you want a higher power ultrasonic signal.
// 5v/BST header selects between 5v drive signal for ultarsonic, or 16v drive signal.  If BST is selected, BSTEN jumper must be shorted.


void loop(){                // HERE IS THE MAIN LOOP
blinkyblue();               // CALL THIS FUNCTION TO BLINK THE BLUE LED THREE TIMES
waitbark();                 // CALL THIS FUNCTION (BELOW0 TO WAIT FOR A BARK TO BE DETECTED.
blinkyred();                // ONCE A BARK IS DETECTED, CALL THIS FUNCTION TO BLINK THE RED LED BEFORE OUTPUTTING A PULSE
if(digitalRead(A) == HIGH){ // IF "A" DIP SWITCH IS ON, CALL THE 'VARIABLE()' FUNCTION
variable();                 // IN THIS FUNCTION, ADJUST THE 'FREQ' VARIABLE RESISTOR TO CHANGE THE FREQUENCY
}
else                        // IF DIP-A IS LOW, CALL THE 'FIXED' FUNCTION INSTEAD
{
fixed();                    // IF DIP-A IS LOW, CALL THIS FHNCTION INSTEAD.  IT OFFERS A FIXED SIGNAL
} 
delay(500);                 // WAIT HALF A SECOND, AND THEN START THE LOOP OVER AGAIN
}

void fixed(){                         // THIS FUNCTION ACTS TO SEND A FIXED PULSATING WAVEFORM.  THE FREQUENCY IS RELATIVELY HIGH, AND THE JUMPER BELOW GPIO-9 NEEDS TO BE SHORTED.
  trigger();                          // INITIATE A PULSE FROM THE 555 TIMER
  delay(10);                          // WAIT 10ms
  digitalWrite(LED2,HIGH);            // TURN THE RED LED ON
  while(digitalRead(in555) == HIGH){  // WHILE THE 555 TIMER PULSE IS BEING DETECTED, DO THE FOLLOWING OVER AND OVER AGAIN UNTIL IT ENDS
    {
    for(int i = 4 ; i < 12 ; i++){    // i STARTS AT 4, AND THIS FOR LOOP WILL LOOP UNTIL i IS 12.  i CHANGES, AND WE USE THIS VALUE IN THE FOR LOOP
      digitalWrite(buzzer,HIGH);      // TURN THE BUZZER/ULTRASONIC TRANSDUCER ON 
      delayMicroseconds(i);           // STAY ON FOR AS THE VALUE OF i IN MICROSECONCDS.  IF i = 5, THEN 5 MICROSECONDS.  THIS DELAY WILL GROW IN DURATION UNTIL IT EQUALS 12.  AT WHICH POINT THIS FOR LOOP WILL END.
      digitalWrite(buzzer,LOW);       // TURN THE BUZZER/ULTRASONIC OFF
      delayMicroseconds(5);           // FOR A FIXED 5 MICROSECONDS
    }
      for(int i = 12 ; i > 4 ; i--){  // SECOND FOR LOOP.  THIS TIME, i WILL LESSEN PER LOOP.  i STARTS AT 12, AND EVERY TIME THIS CODE LOOPS, i DECREMENTS UNTIL i IS LESS THAN 4
      digitalWrite(buzzer,HIGH);      // TURN THE BUZZER/ULTRASONIC ON
      delayMicroseconds(i);           // FOR THE LENGTH IN MICROSECONDS DETERMINED BY i. i WILL BE LESS AND LESS FOR EVERY LOOP.
      digitalWrite(buzzer,LOW);       // TURN BOTH MODULES OFF 
      delayMicroseconds(5);           // FOR A FIXED 5 SECONDS
    }
}
}
digitalWrite(LED2,LOW);  // WHEN THE PULSE FROM THE 555 TIMER IS DONE, TURN THE RED LED OFF, AND RETURN TO THE MAIN LOOP.
}

void variable(){               // IN THIS FUNCTION, WE DETERMINE THE FREQUENCY OF THE SIGNAL, AND THEN DIVIDE IT BY  EITHER 2 OR 4 DEPENDING ON THE STATE OF DIP-B
  freq = analogRead(0);        // SAMPLE THE FREQUENCY POT
  if(freq < 16){               // IF THE RETURNED VALUE IS LESS THAN 16, CHANGE IT TO 16
     freq = 16;
  }
  if(digitalRead(B) == LOW){   // IF DIP-B IS LOW, DIVIDE THE FREQUENCY BY 4 AND THEN OUTPUT THE FREQUENCY
    freq = freq / 4;           // DIVIDE BY 4
    pulser();                  // CALL THIS FUNCTION TO OUTPUT THE FREQUENCY
  }
  else                         // IF DIP-B IS HIGH, DO THE FOLLOWING INSTEAD
  {
    freq = freq / 2;           // DIVIDE THE FREQUENCY VALUE BY 2 INSTEAD OF 4, AND THENN OUTPUT THE FREWQUENCY
    pulser();                  // CALL THIS FUNCTION TO OUTPUT THE FREQUENCY
}
}


void pulser(){                        // THIS FUNCTION TRIGGERS THE 555 TIMER AND THEN OUTPUTS THE SIGNAL
  trigger();                          // INITIATE A 555 TRIGGER
  delay(10);                          // WAIT 10MS
  digitalWrite(LED2,HIGH);            // TURN ON THE RED LED
  while(digitalRead(in555) == HIGH){  // WHILE THE DELAY WE JUST INITIATED IS HIGH, DO THE FOLLOWING.  CHANGE THIS DURATION BY PLAYING WITH THE 'DELAY' VARIABLE RESISTOR
    {
      digitalWrite(buzzer,HIGH);      // TURN THE BUZZER ON
      delayMicroseconds(freq);        // FOR AS MANY MICROSECONDS THAT FREQ IS EQUAL TO.  IF FREQ = 100, THEN 100 MICROSECONDS
      digitalWrite(buzzer,LOW);       // TURN THE BUZZER LINE OFF
      delayMicroseconds(freq);        // FOR AS MANY MICROSECONDS THAT FREQ IS EQUAL TO.  IF FREQ = 100, THEN 100 MICROSECONDS
    }
  }
  digitalWrite(LED2,LOW);             // WHEN THE 555 TIMER DELAY IS DONE, TURN THE RED LED OFF, AND END THIS FUNCTION
}

void blinkyred(){                // THIS FUNCTION BLINKS THE RED LED 5 TIMES USING A FOR LOOP
  for(int i = 0 ; i < 5 ; i++){
    digitalWrite(LED2,HIGH);
    delay(100);
    digitalWrite(LED2,LOW);
    delay(100);
  }
}

void blinkyblue(){               // THIS FUNCTION BLINKS THE BLUE LED 3 TIMES USING A FOR LOOP
  for(int i = 0 ; i < 3 ; i++){
    digitalWrite(LED1,HIGH);
    delay(100);
    digitalWrite(LED1,LOW);
    delay(100);
  }
}

void trigger(){               // PULSE TO THE trig555 LINE FOR 100ms TO TRIGGER A DELAY
  digitalWrite(trig555,HIGH);
  delay(100);
  digitalWrite(trig555,LOW);
}


void waitbark(){               // IN THIS FUNCTION WE WAIT FOR A LOUD NOISE BEFORE WE ARE ABLE TO RETURN TO THE LOOP
 state = 0;                    // SET STATE TO 0.  YOU'LL SEE WHY IN A MINUTE
 while(state == 0){            // DO THE FOLLOWING WHILE STATE EQUALS 0
 {
 sense = analogRead(1);        // SAMPLE THE 'SENSE' VARIABLE RESISTOR AND PLACE THE RETURNED ADC READING VALUE INTO THE "sense".  THIS RETURNED VALUE WILL BE ANYWHERE FROM 0-1023.
 if(sense < 50){               // IF THE RETURNED VALUE IS LESS THAN 50, CHANGE sense TO 50 SO THAT WE'RE NOT TRIGGERING FROM QUIET NOISES
  sense = 50;
 }
 if(analogRead(2) > sense){    // HERE WE SAMPLE THE ANALOG#2 PIN WHICH IS CONNECTED TO THE MICROPHONE OUTPUT, AND COMPARE IT AGAINST THE VALUE IN sense.  IF THE MICROPHONE VALUE IS HIGHER THAN SENSE, CHANGE STATE TO 1, WHICH WILL END THIS FUNCTION.
  state = 1;
 }
}
}
}