Merge branch 'master' of https://github.com/nealey/Simon-Says

Firmware/Additional Experiments/Combo/Combo.ino

@@ -0,0 +1,146 @@
+/* 
+ Code checks for combination in order. Must press upper left button, then upper right button,
+ then lower left for success.  Any wrong button will result in an unplesant sound, 
+ and the code will reset.
+ 
+ Prof Mike Soltys
+ University of Colorado
+ 1/31/2014
+ */
+
+
+// Define the button, LED, and buzzer pins (this is standard for all Simon Says games
+// I've labeled mine UL for Upper Left, LR for Lower Left and so on. 
+const int led_UL = 10; //Red
+const int led_UR = 3; //Green
+const int led_LL = 13; //Blue
+const int led_LR = 5; //Yellow
+
+const int but_UL = 9;
+const int but_UR = 2;
+const int but_LL = 12;
+const int but_LR = 6;
+
+const int BUZZER1 = 4;
+const int BUZZER2 = 7;
+
+// We'll set up variables for each button, so Upper Left is Button 1,
+// Upper right is 2, etc.
+const int UL = 1;
+const int UR = 2;
+const int LL = 3;
+const int LR = 4;
+
+void setup() {
+  //Setup hardware inputs/outputs. 
+  //Enable pull ups on inputs
+  pinMode(but_UL, INPUT_PULLUP);
+  pinMode(but_UR, INPUT_PULLUP);
+  pinMode(but_LL, INPUT_PULLUP);
+  pinMode(but_LR, INPUT_PULLUP);
+
+  pinMode(led_UL, OUTPUT);
+  pinMode(led_UR, OUTPUT);
+  pinMode(led_LL, OUTPUT);
+  pinMode(led_LR, OUTPUT);
+
+  pinMode(BUZZER1, OUTPUT);
+  pinMode(BUZZER2, OUTPUT);
+}
+
+// keep doing this over and over again.
+void loop() {
+  // this calls the bit of code ButtonWait() which is found below
+  // the code waits untill a button is pressed, and then tells you which button was pressed
+  // (1, 2, 3, 4)
+  int Button = ButtonWait();
+
+  // check to see if the button was the first one in our sequence (Upper Left)
+  if (Button == UL){
+    // if so, turn on the upper left button
+    digitalWrite(led_UL, HIGH);
+    // and wait for another button to be pressed
+    Button = ButtonWait();
+    // now check to see if the second button (UR) in our sequence was pressed
+    if (Button == UR){
+      // if so, turn that button on and continue
+      digitalWrite(led_UR, HIGH);  
+      Button = ButtonWait();
+      if (Button == LL){
+        // if so, turn that button on and continue
+        digitalWrite(led_LL, HIGH);  
+        // play success tone!
+        tone(BUZZER1,399,1000);
+        // interesting fact: 399 Hz is the "most plesant" frequency
+        // http://www.ncbi.nlm.nih.gov/pubmed/503755
+
+        // if at any point a wrong button is pressed, the code will jump down
+        // to delay 1000, turn off the LEDs, and restart at the top of void loop()
+      }
+      // if the wrong button is pressed, play an unplesant sound
+      else {
+        tone(BUZZER1,2000,500);
+      }
+    }
+    // if the wrong button is pressed, play an unplesant sound
+    else {
+      tone(BUZZER1,2000,500);
+    }
+  }
+  // if the wrong button is pressed, play an unplesant sound
+  else {
+    tone(BUZZER1,2000,500);
+  }
+
+  // wait a second and turn off all LEDS
+  delay(1000);
+  digitalWrite(led_UR, LOW);
+  digitalWrite(led_UL, LOW);
+  digitalWrite(led_LL, LOW);  
+  digitalWrite(led_LR, LOW);     
+}
+
+// Waits for a button to be pressed, then returns 1-4 to tell what button it was.
+int ButtonWait(void){
+  // this is always true, so this loop will keep going until it reaches a "return" command  
+  while(1 == 1){
+    // Check if the UL button is pressed
+    if(digitalRead(but_UL) == 0){
+      //wait till the user releases the button
+      while (digitalRead(but_UL) == 0){
+        delay(10);
+      }
+      // return what button was pressed
+      return(UL);
+    }
+    // Check if the UR button is pressed
+    else if(digitalRead(but_UR) == 0){
+      //wait till the user releases the button
+      while (digitalRead(but_UR) == 0){
+        delay(10);
+      }
+      // return what button was pressed
+      return(UR);
+    }
+    // and so on.    
+    else if(digitalRead(but_LL) == 0){
+      while (digitalRead(but_LL) == 0){ 
+        delay(10);
+      }
+      return(LL);
+    }  
+    else if(digitalRead(but_LR) == 0){
+      while (digitalRead(but_LR) == 0){ 
+        delay(10);
+      }
+      return(LR);
+    }
+    // if we get here, nothing has been pressed, and so we'll restart at the top of
+    // the loop while (1==1).  
+  }
+}
+
+
+
+
+

Firmware/Additional Experiments/Ocarina/Ocarina.ino

@@ -0,0 +1,121 @@
+/* 
+Make the Simon Says Game a 4-hole Ocarina (Like in the legend of zelda)
+
+Prof Mike Soltys
+University of Colorado
+1/28/2014
+*/
+
+
+// Define the button, LED, and buzzer pins (this is standard for all Simon Says games
+// I've labeled mine UL for Upper Left, LR for Lower Left and so on.  
+const int led_UL = 10; //Red
+const int led_UR = 3; //Green
+const int led_LL = 13; //Blue
+const int led_LR = 5; //Yellow
+
+const int but_UL = 9;
+const int but_UR = 2;
+const int but_LL = 12;
+const int but_LR = 6;
+
+const int BUZZER1 = 4;
+const int BUZZER2 = 7;
+
+void setup() {
+  //Setup hardware inputs/outputs. 
+  //Enable pull ups on inputs
+  pinMode(but_UL, INPUT_PULLUP);
+  pinMode(but_UR, INPUT_PULLUP);
+  pinMode(but_LL, INPUT_PULLUP);
+  pinMode(but_LR, INPUT_PULLUP);
+
+  pinMode(led_UL, OUTPUT);
+  pinMode(led_UR, OUTPUT);
+  pinMode(led_LL, OUTPUT);
+  pinMode(led_LR, OUTPUT);
+
+  pinMode(BUZZER1, OUTPUT);
+  pinMode(BUZZER2, OUTPUT);
+}
+
+void loop() {
+  // keep doing this over and over again.
+  // I will start with the most buttons pressed, and move on to the least buttons pressed
+  // for any combination, i'll play a matching note and light up the LEDs that aren't being pressed.
+  
+  // Start with all buttons pressed - C4 - 262
+  if (digitalRead(but_UL) == 0 && digitalRead(but_UR) == 0 && digitalRead(but_LL) == 0 && digitalRead(but_LR) == 0) {
+  tone(BUZZER2,262,50);
+  }
+  // uncover upper right only - D4 - 294
+  else  if (digitalRead(but_UL) == 0  && digitalRead(but_LL) == 0 && digitalRead(but_LR) == 0) {
+  digitalWrite(led_UR, HIGH);
+  tone(BUZZER2,294,50);
+  }
+  // uncover lower right only - E4 -330
+  else  if (digitalRead(but_UL) == 0 && digitalRead(but_UR) == 0  && digitalRead(but_LL) == 0) {
+  tone(BUZZER2,330,50);
+  digitalWrite(led_LR, HIGH);
+  }
+  // uncover upper left only - F4# -370
+  else  if (digitalRead(but_UR) == 0  && digitalRead(but_LL) == 0 && digitalRead(but_LR) == 0) {
+  digitalWrite(led_UL, HIGH);
+  tone(BUZZER2,370,50);
+  }
+  // uncover both right - F4 -349
+  else  if (digitalRead(but_UL) == 0 && digitalRead(but_LL) == 0) {
+  digitalWrite(led_UR, HIGH);
+  digitalWrite(led_LR, HIGH);
+  tone(BUZZER2,349,50);  
+  }  
+  // uncover both top - G4 -392
+  else  if (digitalRead(but_LL) == 0 && digitalRead(but_LR) == 0) {
+  digitalWrite(led_UR, HIGH);
+  digitalWrite(led_UL, HIGH);  
+  tone(BUZZER2,392,50);
+  }    
+  // uncover upper left and lower right - G4# -415
+  else  if (digitalRead(but_LL) == 0 && digitalRead(but_UR) == 0) {
+  digitalWrite(led_LR, HIGH);
+  digitalWrite(led_UL, HIGH);   
+  tone(BUZZER2,415,50); 
+  }     
+  // cover LL only - A4 -440
+  else  if (digitalRead(but_LL) == 0) {
+  digitalWrite(led_UR, HIGH);
+  digitalWrite(led_UL, HIGH);  
+  digitalWrite(led_LR, HIGH);  
+  tone(BUZZER2,440,50);   
+  }
+  // cover LR only - A4# -466
+  else  if (digitalRead(but_LR) == 0) {
+  digitalWrite(led_UR, HIGH);
+  digitalWrite(led_UL, HIGH);  
+  digitalWrite(led_LL, HIGH);   
+  tone(BUZZER2,466,50);  
+  }        
+  // cover UR only - B4 -494
+  else  if (digitalRead(but_UR) == 0) {
+  digitalWrite(led_UL, HIGH);
+  digitalWrite(led_LL, HIGH);  
+  digitalWrite(led_LR, HIGH);   
+  tone(BUZZER2,494,50);    
+  }
+  // all open - C5 -523
+  else {
+  digitalWrite(led_UL, HIGH);
+  digitalWrite(led_UR, HIGH);  
+  digitalWrite(led_LL, HIGH);  
+  digitalWrite(led_LR, HIGH);   
+  tone(BUZZER2,523,50);    
+  }      
+  
+  // Turn off all LEDs (This will happen so quick before 
+  // the next iteration through the loop, that you'll never notice it_
+  digitalWrite(led_UR, LOW);
+  digitalWrite(led_UL, LOW);
+  digitalWrite(led_LL, LOW);  
+  digitalWrite(led_LR, LOW);     
+}
+

Firmware/Additional Experiments/README.md

@@ -0,0 +1 @@
+These are additional experiments written by SparkFun customer Mike Soltys.

Firmware/Additional Experiments/SIMON_1_BLINK/SIMON_1_BLINK.ino

@@ -0,0 +1,56 @@
+/*
+
+Simon Experiments #1
+Blink
+Pete Lewis
+Sparkfun Electronics 
+10/13/2010
+
+Modified by
+Prof Mike Soltys
+University of Colorado
+01/15/2014
+
+This example code is in the public domain.
+
+//////////////////////////////////////////////////
+SETUP & UPLOAD INSTRUCTIONS
+1. Select "Tools" from the upper window menu.
+2. Select "Serial Port" and then select the COM PORT that your FTDI BASIC is connected on. (It most likely will be the COM 2 or higher).
+3. Select "Tools", then "Board", then "LilyPad Arduino w/ ATmega328"
+4. Click on the "upload button" - it looks like a box with an arrow to the right.
+//////////////////////////////////////////////////
+
+//////////////////////////////////////////////////
+DESCRIPTION
+Causes one LED to blink continuously with one second increments
+//////////////////////////////////////////////////
+
+
+*/
+
+
+
+int ledPin =  3;    // The simon board has 4 LEDs on it. 
+                    // For this example, we're just going to use one. 
+                    // The other LEDs are on pins 3,5,10 and 13.
+                    // For fun, try switching "ledPin" to another LED and see what happens!
+
+
+// The setup() funtion runs once, when the sketch starts
+
+void setup()   {                
+  // initialize the digital pin as an output:
+  pinMode(ledPin, OUTPUT);     
+}
+
+// the loop() function runs over and over again,
+// as long as the Arduino has power
+
+void loop()                     
+{
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  delay(1000);                  // wait for a second
+}

Firmware/Additional Experiments/SIMON_1_BLINK/applet/SIMON_1_BLINK.cpp

@@ -0,0 +1,59 @@
+/*
+
+Simon Experiments #1
+Blink
+Pete Lewis
+Sparkfun Electronics 
+10/13/2010
+
+//////////////////////////////////////////////////
+SETUP & UPLOAD INSTRUCTIONS
+1. Select "Tools" from the upper window menu.
+2. Select "Serial Port" and then select the COM PORT that your FTDI BASIC is connected on. (It most likely will be the COM 2 or higher).
+3. Select "Tools", then "Board", then "LilyPad Arduino w/ ATmega328"
+4. Click on the "upload button" - it looks like a box with an arrow to the right.
+//////////////////////////////////////////////////
+
+*/
+
+
+
+#include "WProgram.h"
+void setup();
+void loop();
+int ledPin =  3;    // The simon board has 4 LEDs on it. 
+                    // For this example, we're just going to use one. 
+                    // The other LEDs are on pins 3,5,10 and 13.
+                    // For fun, try switching "ledPin" to another LED and see what happens!
+
+
+// The setup() funtion runs once, when the sketch starts
+
+void setup()   {                
+  // initialize the digital pin as an output:
+  pinMode(ledPin, OUTPUT);     
+}
+
+// the loop() function runs over and over again,
+// as long as the Arduino has power
+
+void loop()                     
+{
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  delay(1000);                  // wait for a second
+}
+
+int main(void)
+{
+	init();
+
+	setup();
+    
+	for (;;)
+		loop();
+        
+	return 0;
+}
+

Firmware/Additional Experiments/SIMON_1_BLINK/applet/SIMON_1_BLINK.cpp.eep

@@ -0,0 +1 @@
+:00000001FF

Firmware/Additional Experiments/SIMON_1_BLINK/applet/SIMON_1_BLINK.cpp.hex

@@ -0,0 +1,60 @@
+:100000000C9461000C947E000C947E000C947E0095
+:100010000C947E000C947E000C947E000C947E0068
+:100020000C947E000C947E000C947E000C947E0058
+:100030000C947E000C947E000C947E000C947E0048
+:100040000C94A4000C947E000C947E000C947E0012
+:100050000C947E000C947E000C947E000C947E0028
+:100060000C947E000C947E00000000002400270009
+:100070002A0000000000250028002B0000000000DE
+:1000800023002600290004040404040404040202DA
+:100090000202020203030303030301020408102007
+:1000A0004080010204081020010204081020000012
+:1000B0000007000201000003040600000000000029
+:1000C000000011241FBECFEFD8E0DEBFCDBF11E08E
+:1000D000A0E0B1E0E6E9F3E002C005900D92A230A5
+:1000E000B107D9F711E0A2E0B1E001C01D92AB3039
+:1000F000B107E1F70E949D000C94C9010C94000027
+:100100008091000161E00E947C0168EE73E080E074
+:1001100090E00E94F8008091000160E00E947C0164
+:1001200068EE73E080E090E00E94F800089580910E
+:10013000000161E00E945C0108950E9422010E947A
+:1001400097000E948000FDCF1F920F920FB60F9272
+:1001500011242F933F934F935F936F937F938F93CC
+:100160009F93AF93BF932091060130910701409177
+:1001700008015091090170910A01DA01C901029642
+:10018000A11DB11D672F6A5F6D3730F06D57DA0121
+:10019000C9010396A11DB11D60930A018093060158
+:1001A00090930701A0930801B09309018091020187
+:1001B00090910301A0910401B09105010196A11D48
+:1001C000B11D8093020190930301A0930401B093A9
+:1001D0000501BF91AF919F918F917F916F915F9139
+:1001E0004F913F912F910F900FBE0F901F90189538
+:1001F000EF92FF920F931F937B018C018FB7F894BE
+:100200004091060150910701609108017091090128
+:100210008FBF2FB7F8948091060190910701A091AC
+:100220000801B09109012FBF841B950BA60BB70BDA
+:10023000E816F9060A071B0760F71F910F91FF9058
+:10024000EF900895789484B5826084BD84B5816010
+:1002500084BD85B5826085BD85B5816085BDEEE6CE
+:10026000F0E0808181608083E1E8F0E0808182605D
+:100270008083808181608083E0E8F0E0808181601C
+:100280008083E1EBF0E0808184608083E0EBF0E04C
+:10029000808181608083EAE7F0E0808184608083F0
+:1002A000808182608083808181608083808180689A
+:1002B00080831092C1000895282F30E0C90186562E
+:1002C0009F4FFC0194912A573F4FF9018491882355
+:1002D00091F0E82FF0E0EE0FFF1FE859FF4FA591D6
+:1002E000B491662329F48C91909589238C93089579
+:1002F0008C91892B8C930895482F50E0CA01825528
+:100300009F4FFC012491CA0186569F4FFC01949196
+:100310004A575F4FFA0134913323D1F1222331F14F
+:10032000233021F4809180008F7705C0243031F490
+:10033000809180008F7D8093800018C0213019F457
+:1003400084B58F7704C0223021F484B58F7D84BDBD
+:100350000DC0263021F48091B0008F7705C0273082
+:1003600029F48091B0008F7D8093B000E32FF0E0FE
+:10037000EE0FFF1FEE58FF4FA591B491662329F4AD
+:100380008C91909589238C9308958C91892B8C93D3
+:060390000895F894FFCF70
+:02039600030062
+:00000001FF

Firmware/Additional Experiments/SIMON_2_BUTTON/SIMON_2_BUTTON.ino

@@ -0,0 +1,89 @@
+/*
+
+Simon Experiments #2
+Button
+Pete Lewis
+Sparkfun Electronics 
+10/13/2010
+
+Modified by
+Prof Mike Soltys
+University of Colorado
+01/15/14
+This example code is in the public domain.
+
+//////////////////////////////////////////////////
+SETUP & UPLOAD INSTRUCTIONS
+1. Select "Tools" from the upper window menu.
+2. Select "Serial Port" and then select the COM PORT that your FTDI BASIC is connected on. (It most likely will be the COM 2 or higher).
+3. Select "Tools", then "Board", then "LilyPad Arduino w/ ATmega328"
+4. Click on the "upload button" - it looks like a box with an arrow to the right.
+//////////////////////////////////////////////////
+
+//////////////////////////////////////////////////
+DESCRIPTION
+Pressing the buttion will change the state of the LED from on to off or off to on.
+
+Note: these buttions are SUPER sensitive (freakishly so). The simon says code usese
+a delay and check process called debouncing to fix this.
+//////////////////////////////////////////////////
+*/
+
+
+
+int ledPin =  3;    // The simon board has 4 LEDs on it. 
+                    // For this example, we're just going to use one. 
+                    // The other LEDs are on pins 3,5,10 and 13.
+                    // For fun, try switching "ledPin" to another pin number and see what happens!
+                    
+int buttonPin =  2; // The simon board has 4 BUTTONS on it. 
+                    // For this example, we're just going to use one. 
+                    // The other BUTTONS are on pins 2,6,9 and 12.
+                    // For fun, try switching "buttonPin" to another pin number and see what happens!
+                    
+int button_state;   // This variable will be used to "store" the state of the button.
+                    // It will allow us to know whether the button is pressed or not.
+
+int led_state = 0;      // This variable will be used to "store" the state of the LED.
+                    // It will allow us to know whether the LED is on or off.
+// The setup() funtion runs once, when the sketch starts
+
+void setup()   {                
+  // initialize the led pin as an output:
+  pinMode(ledPin, OUTPUT);     
+  // initialize the internal pull-up on the button pin:
+  digitalWrite(buttonPin, HIGH);
+  // initialize the button pin as an input:
+  pinMode(buttonPin, INPUT);     
+  
+}
+
+// the loop() function runs over and over again,
+// as long as the Arduino has power
+
+void loop()                     
+{
+  
+  // Using the digitalRead() function, we can read the state of a pin, and know whether or not it is Logic HIGH or Logic LOW.
+  // When you press the button, you are actually causing an electrical connection between the pin on the micro (buttonPin) and Logic LOW (aka GND).
+  // Every time the loop starts over it will first set the variable "button_state" to the state of the pin.
+  // It is refreshing every time the loop starts over.
+  int button_state = digitalRead(buttonPin);
+  
+  // The second step in the loop is to actually do something with this variable.
+  // In this next "if statement" we are going to decide to do something. Here we are going to turn on the ledPin for a second.
+  if(button_state == 1){
+    // If the LED is off, turn it on
+    if (led_state == 0 ){
+      digitalWrite(ledPin, HIGH);   // set the LED on
+      led_state = 1; 
+      }
+     // If the LED is on, turn it off
+     else if (led_state == 1 ) {
+      digitalWrite(ledPin, LOW);    // set the LED off
+      led_state = 0;
+     }
+     delay(1000);              // wait for a second
+  }
+  
+}

Firmware/Additional Experiments/SIMON_2_BUTTON/applet/SIMON_2_BUTTON.cpp

@@ -0,0 +1,80 @@
+/*
+
+Simon Experiments #2
+Button
+Pete Lewis
+Sparkfun Electronics 
+10/13/2010
+
+//////////////////////////////////////////////////
+SETUP & UPLOAD INSTRUCTIONS
+1. Select "Tools" from the upper window menu.
+2. Select "Serial Port" and then select the COM PORT that your FTDI BASIC is connected on. (It most likely will be the COM 2 or higher).
+3. Select "Tools", then "Board", then "LilyPad Arduino w/ ATmega328"
+4. Click on the "upload button" - it looks like a box with an arrow to the right.
+//////////////////////////////////////////////////
+
+*/
+
+
+
+#include "WProgram.h"
+void setup();
+void loop();
+int ledPin =  3;    // The simon board has 4 LEDs on it. 
+                    // For this example, we're just going to use one. 
+                    // The other LEDs are on pins 3,5,10 and 13.
+                    // For fun, try switching "ledPin" to another pin number and see what happens!
+                    
+int buttonPin =  2; // The simon board has 4 BUTTONS on it. 
+                    // For this example, we're just going to use one. 
+                    // The other BUTTONS are on pins 2,6,9 and 12.
+                    // For fun, try switching "buttonPin" to another pin number and see what happens!
+                    
+int button_state;   // This variable will be used to "store" the state of the button.
+                    // It will allow us to know whether the button is pressed or not.
+
+
+// The setup() funtion runs once, when the sketch starts
+
+void setup()   {                
+  // initialize the led pin as an output:
+  pinMode(ledPin, OUTPUT);     
+  // initialize the button pin as an input:
+  pinMode(buttonPin, INPUT);     
+}
+
+// the loop() function runs over and over again,
+// as long as the Arduino has power
+
+void loop()                     
+{
+  
+  // Using the digitalRead() function, we can read the state of a pin, and know whether or not it is Logic HIGH or Logic LOW.
+  // When you press the button, you are actually causing an electrical connection between the pin on the micro (buttonPin) and Logic HIGH (aka power).
+  // Every time the loop starts over it will first set the variable "button_state" to the state of the pin.
+  // It is refreshing every time the loop starts over.
+  int button_state = digitalRead(buttonPin);
+  
+  // The second step in the loop is to actually do something with this variable.
+  // In this next "if statement" we are going to decide to do something. Here we are going to turn on the ledPin for a second.
+  if(button_state == 1){
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  }
+  
+}
+
+int main(void)
+{
+	init();
+
+	setup();
+    
+	for (;;)
+		loop();
+        
+	return 0;
+}
+

Firmware/Additional Experiments/SIMON_2_BUTTON/applet/SIMON_2_BUTTON.cpp.eep

@@ -0,0 +1 @@
+:00000001FF

Firmware/Additional Experiments/SIMON_2_BUTTON/applet/SIMON_2_BUTTON.cpp.hex

@@ -0,0 +1,70 @@
+:100000000C9461000C947E000C947E000C947E0095
+:100010000C947E000C947E000C947E000C947E0068
+:100020000C947E000C947E000C947E000C947E0058
+:100030000C947E000C947E000C947E000C947E0048
+:100040000C94A9000C947E000C947E000C947E000D
+:100050000C947E000C947E000C947E000C947E0028
+:100060000C947E000C947E00000000002400270009
+:100070002A0000000000250028002B0000000000DE
+:1000800023002600290004040404040404040202DA
+:100090000202020203030303030301020408102007
+:1000A0004080010204081020010204081020000012
+:1000B0000007000201000003040600000000000029
+:1000C000000011241FBECFEFD8E0DEBFCDBF11E08E
+:1000D000A0E0B1E0EEE3F4E002C005900D92A430A0
+:1000E000B107D9F711E0A4E0B1E001C01D92AD3035
+:1000F000B107E1F70E94A2000C941D020C940000CD
+:10010000809102010E94CE01019781F4809100014B
+:1001100061E00E94810168EE73E080E090E00E945F
+:10012000FD008091000160E00E94810108958091AE
+:10013000000161E00E9461018091020160E00E9483
+:10014000610108950E9427010E9497000E9480008B
+:10015000FDCF1F920F920FB60F9211242F933F9352
+:100160004F935F936F937F938F939F93AF93BF93BF
+:10017000209108013091090140910A0150910B0131
+:1001800070910C01DA01C9010296A11DB11D672F02
+:100190006A5F6D3730F06D57DA01C9010396A11D12
+:1001A000B11D60930C018093080190930901A09305
+:1001B0000A01B0930B018091040190910501A09177
+:1001C0000601B09107010196A11DB11D80930401A4
+:1001D00090930501A0930601B0930701BF91AF91E1
+:1001E0009F918F917F916F915F914F913F912F914F
+:1001F0000F900FBE0F901F901895EF92FF920F93E4
+:100200001F937B018C018FB7F894409108015091A6
+:10021000090160910A0170910B018FBF2FB7F8940B
+:100220008091080190910901A0910A01B0910B0100
+:100230002FBF841B950BA60BB70BE816F9060A0710
+:100240001B0760F71F910F91FF90EF90089578942E
+:1002500084B5826084BD84B5816084BD85B58260CB
+:1002600085BD85B5816085BDEEE6F0E08081816069
+:100270008083E1E8F0E0808182608083808181601A
+:100280008083E0E8F0E0808181608083E1EBF0E052
+:10029000808184608083E0EBF0E0808181608083F6
+:1002A000EAE7F0E0808184608083808182608083DF
+:1002B0008081816080838081806880831092C1000A
+:1002C0000895282F30E0C90186569F4FFC01949174
+:1002D0002A573F4FF9018491882391F0E82FF0E0ED
+:1002E000EE0FFF1FE859FF4FA591B491662329F443
+:1002F0008C91909589238C9308958C91892B8C9364
+:100300000895482F50E0CA0182559F4FFC01249167
+:10031000CA0186569F4FFC0194914A575F4FFA01DC
+:1003200034913323D1F1222331F1233021F4809110
+:1003300080008F7705C0243031F4809180008F7D5C
+:100340008093800018C0213019F484B58F7704C0E1
+:10035000223021F484B58F7D84BD0DC0263021F478
+:100360008091B0008F7705C0273029F48091B000CC
+:100370008F7D8093B000E32FF0E0EE0FFF1FEE586B
+:10038000FF4FA591B491662329F48C919095892310
+:100390008C9308958C91892B8C930895682F70E02D
+:1003A000CB0182559F4FFC012491CB0186569F4F74
+:1003B000FC0144916A577F4FFB019491992319F4F2
+:1003C00020E030E038C0222331F1233021F4809145
+:1003D00080008F7705C0243031F4809180008F7DBC
+:1003E0008093800018C0213019F484B58F7704C041
+:1003F000223021F484B58F7D84BD0DC0263021F4D8
+:100400008091B0008F7705C0273029F48091B0002B
+:100410008F7D8093B000892F90E0880F991F8458BA
+:100420009F4FFC01A591B4918C9120E030E0842392
+:0E04300011F021E030E0C9010895F894FFCFEB
+:04043E0003000200B5
+:00000001FF

Firmware/Additional Experiments/SIMON_2_BUTTON/applet/simon.h

@@ -0,0 +1,13 @@
+
+int ledPin =  3;    // The simon board has 4 LEDs on it. 
+                    // For this example, we're just going to use one. 
+                    // The other LEDs are on pins 3,5,10 and 13.
+                    // For fun, try switching "ledPin" to another pin number and see what happens!
+                    
+int buttonPin =  2; // The simon board has 4 BUTTONS on it. 
+                    // For this example, we're just going to use one. 
+                    // The other BUTTONS are on pins 2,6,9 and 12.
+                    // For fun, try switching "buttonPin" to another pin number and see what happens!
+                    
+int button_state;   // This variable will be used to "store" the state of the button.
+                    // It will allow us to know whether the button is pressed or not.

Firmware/Additional Experiments/SIMON_3_BUZZER/SIMON_3_BUZZER.ino

@@ -0,0 +1,89 @@
+/*
+Simon Experiments #3
+Buzzer
+Pete Lewis
+Sparkfun Electronics 
+10/13/2010
+
+Updated by 
+Prof Mike Soltys
+University of Colorado
+01/15/2014
+
+This example code is in the public domain.
+
+//////////////////////////////////////////////////
+DESCRIPTION
+Pressing the buttion will flash the LED for 1 second and play a tone.
+
+Note: these buttions are SUPER sensitive (freekishly so). The simon says code usese
+a delay and check process called debouncing to fix this.
+//////////////////////////////////////////////////
+
+*/
+
+
+
+int ledPin =  3;     // LEDs are on pins 3,5,10 and 13.
+int buttonPin =  2;  // BUTTONS are on pins 2,6,9 and 12.  
+int button_state;    // This variable will be used to "store" the state of the button.
+
+/// These next two definitions are setting up the buzzer pins. 
+/// By sending these HIGH/LOW we can create a sound from the buzzer.
+int buzzer_1 = 4;
+int buzzer_2 = 7;
+
+void setup()   {           
+  pinMode(ledPin, OUTPUT);     
+  
+  // Note: For the way the circuit is setup, INPUT_PULLUP will result much more
+  // stability than INPUT
+  pinMode(buttonPin, INPUT_PULLUP);     
+
+  pinMode(buzzer_1, OUTPUT);
+  pinMode(buzzer_2, OUTPUT);
+  digitalWrite(buzzer_1, LOW); // buzzer_1 will toggle HIGH/LOW to create the sound - see buzz() function below.
+  digitalWrite(buzzer_2, LOW); // buzzer_2 will toggle as well (to create more volume).
+}
+
+
+void loop()                     
+{
+  int button_state = digitalRead(buttonPin);
+
+  
+  if(button_state == 0){
+    
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  
+  // Call the "buzz()" funtion. See below to know what this does.
+  tone(buzzer_1,400,500);
+  delay(1000);
+  tone(buzzer_2,600,500);
+  delay(1000);
+  tone(buzzer_1,400,500);
+  delay(250);
+  tone(buzzer_2,600,500);
+  //tone(buzzer_1,500,100);
+  
+  }
+  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+void buzz(){
+  /// this function makes the buzzer pin move and crease a sound.
+  /// By writing the pin HIGH/LOW in a pattern we can create a frequency.
+  /// this FOR LOOP is used to repeat the pattern and let us hear the note for second.
+  for(int i = 0; i < 100; i++){
+  digitalWrite(buzzer_1, HIGH);
+  digitalWrite(buzzer_2, LOW);
+  delay(1);
+  digitalWrite(buzzer_1, LOW);
+  digitalWrite(buzzer_2, HIGH);
+  delay(1);
+  }
+}
+

Firmware/Additional Experiments/SIMON_3_BUZZER/applet/SIMON_3_BUZZER.cpp

@@ -0,0 +1,79 @@
+/*
+Simon Experiments #2
+Buzzer
+Pete Lewis
+Sparkfun Electronics 
+10/13/2010
+*/
+
+
+
+#include "WProgram.h"
+void setup();
+void loop();
+void buzz();
+int ledPin =  3;     // LEDs are on pins 3,5,10 and 13.
+int buttonPin =  2;  // BUTTONS are on pins 2,6,9 and 12.  
+int button_state;    // This variable will be used to "store" the state of the button.
+
+/// These next two definitions are setting up the buzzer pins. 
+/// By sending these HIGH/LOW we can create a sound from the buzzer.
+int buzzer_1 = 4;
+int buzzer_2 = 7;
+                    
+
+void setup()   {           
+  pinMode(ledPin, OUTPUT);     
+  pinMode(buttonPin, INPUT);     
+  
+  pinMode(buzzer_1, OUTPUT);
+  pinMode(buzzer_2, OUTPUT);
+  digitalWrite(buzzer_1, LOW); // buzzer_1 will toggle HIGH/LOW to create the sound - see buzz() function below.
+  digitalWrite(buzzer_2, LOW); // buzzer_2 will always stay low.
+}
+
+
+void loop()                     
+{
+  int button_state = digitalRead(buttonPin);
+  
+  if(button_state == 1){
+    
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  
+  // Call the "buzz()" funtion. See below to know what this does.
+  buzz();
+  
+  }
+  
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+void buzz(){
+  /// this function makes the buzzer pin move and crease a sound.
+  /// By writing the pin HIGH/LOW in a pattern we can create a frequency.
+  /// this FOR LOOP is used to repeat the pattern and let us hear the note for second.
+  for(int i = 0; i < 100; i++){
+  digitalWrite(buzzer_1, HIGH);
+  delay(1);
+  digitalWrite(buzzer_1, LOW);
+  delay(1);
+  }
+}
+
+
+int main(void)
+{
+	init();
+
+	setup();
+    
+	for (;;)
+		loop();
+        
+	return 0;
+}
+

Firmware/Additional Experiments/SIMON_3_BUZZER/applet/SIMON_3_BUZZER.cpp.eep

@@ -0,0 +1 @@
+:00000001FF

Firmware/Additional Experiments/SIMON_3_BUZZER/applet/SIMON_3_BUZZER.cpp.hex

@@ -0,0 +1,77 @@
+:100000000C9461000C947E000C947E000C947E0095
+:100010000C947E000C947E000C947E000C947E0068
+:100020000C947E000C947E000C947E000C947E0058
+:100030000C947E000C947E000C947E000C947E0048
+:100040000C94E0000C947E000C947E000C947E00D6
+:100050000C947E000C947E000C947E000C947E0028
+:100060000C947E000C947E00000000002400270009
+:100070002A0000000000250028002B0000000000DE
+:1000800023002600290004040404040404040202DA
+:100090000202020203030303030301020408102007
+:1000A0004080010204081020010204081020000012
+:1000B0000007000201000003040600000000000029
+:1000C000000011241FBECFEFD8E0DEBFCDBF11E08E
+:1000D000A0E0B1E0ECEAF4E002C005900D92A83097
+:1000E000B107D9F711E0A8E0B1E001C01D92A1313C
+:1000F000B107E1F70E94D9000C9454020C9400005F
+:10010000CF93DF93C0E0D0E08091040161E00E94D2
+:10011000B80161E070E080E090E00E9434018091DD
+:10012000040160E00E94B80161E070E080E090E0CE
+:100130000E9434012196C436D10531F7DF91CF9169
+:100140000895809102010E940502019791F4809127
+:10015000000161E00E94B80168EE73E080E090E089
+:100160000E9434018091000160E00E94B8010E9469
+:10017000800008958091000161E00E9498018091C3
+:10018000020160E00E9498018091040161E00E94F8
+:1001900098018091060161E00E949801809104011C
+:1001A00060E00E94B8018091060160E00E94B80101
+:1001B00008950E945E010E94BA000E94A100FDCF36
+:1001C0001F920F920FB60F9211242F933F934F93CC
+:1001D0005F936F937F938F939F93AF93BF93209180
+:1001E0000C0130910D0140910E0150910F01709161
+:1001F0001001DA01C9010296A11DB11D672F6A5FC6
+:100200006D3730F06D57DA01C9010396A11DB11D9C
+:100210006093100180930C0190930D01A0930E0147
+:10022000B0930F018091080190910901A0910A01FA
+:10023000B0910B010196A11DB11D8093080190930F
+:100240000901A0930A01B0930B01BF91AF919F9157
+:100250008F917F916F915F914F913F912F910F906F
+:100260000FBE0F901F901895EF92FF920F931F9360
+:100270007B018C018FB7F89440910C0150910D01D6
+:1002800060910E0170910F018FBF2FB7F89480918C
+:100290000C0190910D01A0910E01B0910F012FBFA3
+:1002A000841B950BA60BB70BE816F9060A071B076C
+:1002B00060F71F910F91FF90EF900895789484B5A7
+:1002C000826084BD84B5816084BD85B5826085BD52
+:1002D00085B5816085BDEEE6F0E080818160808338
+:1002E000E1E8F0E0808182608083808181608083AA
+:1002F000E0E8F0E0808181608083E1EBF0E08081E4
+:1003000084608083E0EBF0E0808181608083EAE7B5
+:10031000F0E080818460808380818260808380813E
+:10032000816080838081806880831092C1000895FD
+:10033000282F30E0C90186569F4FFC0194912A571F
+:100340003F4FF9018491882391F0E82FF0E0EE0F00
+:10035000FF1FE859FF4FA591B491662329F48C91B2
+:10036000909589238C9308958C91892B8C93089573
+:10037000482F50E0CA0182559F4FFC012491CA01C9
+:1003800086569F4FFC0194914A575F4FFA01349172
+:100390003323D1F1222331F1233021F480918000E5
+:1003A0008F7705C0243031F4809180008F7D809359
+:1003B000800018C0213019F484B58F7704C0223032
+:1003C00021F484B58F7D84BD0DC0263021F4809149
+:1003D000B0008F7705C0273029F48091B0008F7D61
+:1003E0008093B000E32FF0E0EE0FFF1FEE58FF4FB9
+:1003F000A591B491662329F48C91909589238C93CF
+:1004000008958C91892B8C930895682F70E0CB010F
+:1004100082559F4FFC012491CB0186569F4FFC01D2
+:1004200044916A577F4FFB019491992319F420E07E
+:1004300030E038C0222331F1233021F48091800054
+:100440008F7705C0243031F4809180008F7D8093B8
+:10045000800018C0213019F484B58F7704C0223091
+:1004600021F484B58F7D84BD0DC0263021F48091A8
+:10047000B0008F7705C0273029F48091B0008F7DC0
+:100480008093B000892F90E0880F991F84589F4F68
+:10049000FC01A591B4918C9120E030E0842311F00F
+:0C04A00021E030E0C9010895F894FFCF7E
+:0804AC00030002000400070038
+:00000001FF

Firmware/Additional Experiments/SIMON_4_MrRoboto/SIMON_4_MrRoboto.ino

@@ -0,0 +1,95 @@
+/*
+Simon Experiments #4
+Mr Roboto 
+Prof Mike Soltys
+University of Colorado
+01/15/2014
+
+This example code is in the public domain.
+
+//////////////////////////////////////////////////
+DESCRIPTION
+Pressing the buttion will play the song Mr Roboto
+
+Note: these buttions are SUPER sensitive (freekishly so). The simon says code usese
+a delay and check process called debouncing to fix this.
+//////////////////////////////////////////////////
+
+*/
+
+
+
+int ledPin =  3;     // LEDs are on pins 3,5,10 and 13.
+int buttonPin =  2;  // BUTTONS are on pins 2,6,9 and 12.  
+int button_state;    // This variable will be used to "store" the state of the button.
+
+/// These next two definitions are setting up the buzzer pins. 
+/// By sending these HIGH/LOW we can create a sound from the buzzer.
+int buzzer_1 = 4;
+int buzzer_2 = 7;
+
+/* Here are some variables we'll use to make a little jingle. 
+   First we'll define frequencies of a few notes to use in the jingle */
+const int NOTE_F4 = 349;  // F4 (F above middle c)
+const int NOTE_DS4 = 311;  // D-sharp 4
+const int NOTE_REST = 0;  // Rest, no tone
+const int jingleLength = 12;  // This is the length of the jingle - 12 notes
+/* This array contains the note played, in order */
+const int jingleNote[jingleLength] = {
+  NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_DS4, NOTE_REST,
+  NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_DS4};
+/* jingleDuration contains the length of each note played 
+   8 = 1/8 note, 4 = 1/4 note, 32 = 1/32 note, etc.*/
+const int jingleDuration[jingleLength] = {
+  8, 8, 8, 8, 8, 4, 32,// do-mo-ar-i-ga-to-(rest)
+  4, 4, 8, 8, 4 };  // mis-ter-ro-bot-o
+const int jingleBPM = 60;  // Jingle beats-per-minute = 60 bpm
+
+void setup()   {           
+  pinMode(ledPin, OUTPUT);     
+  
+  digitalWrite(buttonPin, HIGH);
+  pinMode(buttonPin, INPUT);     
+
+  pinMode(buzzer_1, OUTPUT);
+  pinMode(buzzer_2, OUTPUT);
+  digitalWrite(buzzer_1, LOW); // buzzer_1 will toggle HIGH/LOW to create the sound - see buzz() function below.
+  digitalWrite(buzzer_2, LOW); // buzzer_2 will toggle as well (to create more volume).
+}
+
+
+void loop()                     
+{
+  int button_state = digitalRead(buttonPin);
+
+  if(button_state == 1){
+    
+  digitalWrite(ledPin, HIGH);   // set the LED on
+  delay(1000);                  // wait for a second
+  digitalWrite(ledPin, LOW);    // set the LED off
+  
+  // Call the "buzz()" funtion. See below to know what this does.
+  buzz();
+  
+  }
+  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+void buzz(){
+for (int i=0; i<jingleLength; i++)
+  { // Run through this for loop once for each note
+    /* First lets calculate how long to play the note 
+       this value will be in miliseconds, so we divide 60000 miliseconds
+       by our beats per minute, and divide that by the note's duration */
+    int noteDuration = (60000/jingleBPM)/jingleDuration[i];
+    /* Now we'll play the tone using the tone(pin, frequency, duration)
+       function. The pin will always be nosePin, the note is defined above,
+       and we just calculated the duration in milliseconds */
+    tone(buzzer_1, jingleNote[i], noteDuration);
+    /* Now just a short delay, so you can distinguish between the notes.
+       This calculation is mostly arbitrary, but it sounds good. */
+    delay(noteDuration * 1.3);
+  }
+}
+

Firmware/Additional Experiments/SIMON_APPLE_REMOTE/AppleRemoteSender.cpp

@@ -0,0 +1,136 @@
+/*
+
+Apple Remote Sender:
+Copyright Casey Callendrello 2008
+
+c1 at caseyc dot net
+
+For more information, see http://www.caseyc.net/home/node/10
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+*/
+
+
+#include "Arduino.h"
+#include "AppleRemoteSender.h"
+
+
+AppleRemoteSender::AppleRemoteSender(int pin)
+{
+	_irpin = pin;
+	_remote_id = 0x01;
+	
+	//ready the pin
+	pinMode(_irpin, OUTPUT);
+	digitalWrite(_irpin, LOW);
+	
+	
+}
+
+AppleRemoteSender::AppleRemoteSender(int pin, byte remote_id)
+{
+	_irpin = pin;
+	_remote_id = remote_id;
+	
+	//ready the pin
+	pinMode(_irpin, OUTPUT);
+	digitalWrite(_irpin, LOW);
+}
+
+
+void AppleRemoteSender::set_remote_id(byte remote_id)
+{
+	_remote_id = remote_id;
+}
+
+void AppleRemoteSender::send(byte remote_id, byte key)
+{
+	//prepare data
+	long temp = remote_id;
+	temp = temp << 8;
+	temp += key;
+	temp = temp << 16;
+	temp += APPLE_ID;
+	
+	//send preamble
+	oscWrite(9000);
+	delayMicroseconds(4500);
+
+	byte bit = 0;
+	//send data
+	for(int i = 0; i < 32; i++)
+	{
+		bit = temp % 2;
+		temp = temp >> 1;
+		//space
+		oscWrite(560);
+
+		//data
+		if(bit == 0)
+		{
+			delayMicroseconds(560);
+		}
+		else
+		{
+			delayMicroseconds(1690);
+		}
+	}
+	//end of data header
+	oscWrite(560);
+	
+}
+void AppleRemoteSender::send(byte key)
+{
+	send(_remote_id, key);	
+}
+
+
+void AppleRemoteSender::menu(byte remote_id) { send(remote_id, MENU);}
+void AppleRemoteSender::menu(){ send(MENU); }
+
+void AppleRemoteSender::play(byte remote_id){ send(remote_id, PLAY); }
+void AppleRemoteSender::play(){ send(PLAY); }
+
+void AppleRemoteSender::right(byte remote_id){ send(remote_id, RIGHT); }
+void AppleRemoteSender::right(){ send(RIGHT); }
+
+void AppleRemoteSender::left(byte remote_id){ send(remote_id, LEFT); }
+void AppleRemoteSender::left(){ send(LEFT); }
+
+void AppleRemoteSender::up(byte remote_id){ send(remote_id, UP); }
+void AppleRemoteSender::up(){ send(UP); }
+
+void AppleRemoteSender::down(byte remote_id){ send(remote_id, DOWN); }
+void AppleRemoteSender::down(){ send(DOWN); }
+
+
+
+
+
+void AppleRemoteSender::oscWrite(int time)
+{
+	/*
+	Sends a 38khz carrier pulse
+	
+	*/
+  for(int i = 0; i < (time / 26) - 1; i++)
+  {
+    digitalWrite(_irpin, HIGH);
+    delayMicroseconds(13);
+    digitalWrite(_irpin, LOW);
+    delayMicroseconds(13);
+  }
+}

Firmware/Additional Experiments/SIMON_APPLE_REMOTE/AppleRemoteSender.h

@@ -0,0 +1,110 @@
+#ifndef AppleRemoteSender_h
+#define AppleRemoteSender_h
+
+/*
+
+Apple Remote Sender:
+Copyright Casey Callendrello 2008
+
+Notes: 
+1) Apple's remotes use the NEC IR protocol, which is better
+described here: http://www.sbprojects.com/knowledge/ir/nec.htm
+It uses a 38 kHz carrier wave ( hence the OscWrite call) and uses a 
+"pulse distance" encoding.  In other words, the LED is ON for the same
+amount of time - it is the duration OFF that matters.
+
+The protocol header is a 9ms on, followed by 4.5 ms off.  A '1' value is
+.560 ms on, followed by 1.690 ms off. A '0' value is the same on pulse,
+followed by .565 ms off.
+The 'end' header is a .560 ms on pulse.
+
+2) The total data transmitted is 32 bits. 
+
+****** Remote Code *******
+The first byte is the remote ID, 
+a number between 0 and 255.
+
+The second byte is the command
+Known commands:
+0x02: Menu
+0x04: Play
+0x07: Right
+0x08: Left
+0x0B: Up
+0x0D: Down
+
+The last two bytes are 0x87EE - which identifies this as an Apple device.
+
+
+*/
+
+
+/*
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <inttypes.h>
+#include <avr/io.h>
+#include "Arduino.h"
+
+//suffix that all remotes use.
+#define APPLE_ID 0x87EE
+
+#define MENU 0x02
+#define PLAY 0x04
+#define RIGHT 0x07
+#define LEFT 0x08
+#define UP 0x0B
+#define DOWN 0x0D
+
+
+class AppleRemoteSender 
+{
+   public:
+	AppleRemoteSender(int irpin);
+	AppleRemoteSender(int irpin, byte remote_id);
+	
+	void set_remote_id(byte remote_id);
+	
+	void send(byte remote_id, byte key);
+	void send(byte key);
+	
+	void menu(byte remote_id) ;
+	void menu();
+	
+	void play(byte remote_id);
+	void play();
+	
+	void right(byte remote_id);
+	void right();
+	
+	void left(byte remote_id);
+	void left();
+	
+	void up(byte remote_id);
+	void up();
+	
+	void down(byte remote_id);
+	void down();
+private:
+	long data;
+	int _irpin;
+	byte _remote_id;
+	void oscWrite(int time);
+};
+
+
+#endif

Firmware/Additional Experiments/SIMON_APPLE_REMOTE/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+