Updated LilyPad Proto Board code examples

Author: Mike Grusin

IDE_Board_Manager/package_sparkfun_index.json

@@ -108,8 +108,8 @@
           "category": "Contributed",
           "url": "https://github.com/sparkfun/Arduino_Boards/raw/LilyProtoBoard/IDE_Board_Manager/sparkfunboards.1.1.7.tar.bz2",
           "archiveFileName": "sparkfunboards.1.1.7.tar.bz2",
-          "checksum": "SHA-256:5baa562d9be578b2888088c70c167851b667ad559dad9cc6d93a496681915e2f",
-          "size": "1237425",
+          "checksum": "SHA-256:AAA4F6614BB9BD89400E595B406720F60A895810F9D7E884E7A2DEA866DFF90D",
+          "size": "1238374",
           "help": {
             "online": "https://forums.sparkfun.com"
           },

IDE_Board_Manager/sparkfunboards.1.1.7.tar.bz2

@@ -0,0 +1,108 @@
+/*
+LilyPad Prototyping Board Activity 10: LilyPixel
+SparkFun Electronics
+https://www.sparkfun.com/products/14346
+
+Make external LilyPixel boards fade through a rainbow of colors
+
+This sketch was written by SparkFun Electronics,
+and is based on NeoPixel Ring simple sketch (c) 2013 Shae Erisson
+released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
+
+******************************************************************************/
+
+// Include the NeoPixel library, used to drive addressable LEDs
+
+#include <Adafruit_NeoPixel.h>
+#ifdef __AVR__
+  #include <avr/power.h>
+#endif
+
+// We'll hook up the "DI" sew tab of the LilyPixel
+// to pin 10 on the LilyPad Development Board:
+
+#define pixelPin 10
+
+// You can daisy chain many LilyPixel boards together,
+// In this demo we're just using one:
+
+#define numPixels 1
+
+// The NeoPixel library needs to know what type of
+// addressable LED we're connecting to it.
+// This command makes those settings:
+
+Adafruit_NeoPixel lilyPixels = Adafruit_NeoPixel(numPixels, pixelPin, NEO_GRB + NEO_KHZ800);
+
+// Delay value in milliseconds between color changes, make smaller to go faster:
+
+int delayval = 5;
+
+void setup() {
+
+  // Initialize the NeoPixel library:
+  
+  lilyPixels.begin();
+}
+
+void loop() {
+  int hue, address;
+  unsigned char r,g,b;
+
+  // We'll make all the LilyPixels smoothly change colors through a rainbow.
+  // The "hue" is the color value, for the rainbow function we're using
+  // it will range from 0 to 767.
+  
+  for(hue = 0; hue < 767; hue++){
+
+    // Each LilyPixel you've daisy-chained together has an address.
+    // The address starts at 0 for the nearest one, 1 for the next, etc.
+    // This for loop will step through all the LilyPixels:
+    
+    for(address=0; address<numPixels; address++){
+
+      // Compute the rainbow r,g,b values from the "hue" (0 to 767)
+
+      rainbow(hue,r,g,b);
+
+      // Set a LilyPixel chosen with address, to a RGB color
+      
+      lilyPixels.setPixelColor(address,r,g,b);
+
+      // We now must send the color set in the above step to the actual LilyPixel:
+  
+      lilyPixels.show();
+  
+      delay(delayval);
+    }
+  }
+}
+
+void rainbow(int hue, unsigned char &r, unsigned char &b, unsigned char &g){
+
+  hue = constrain(hue, 0, 767); // constrain the input value to a range of values from 0 to 767
+
+    // if statement breaks down the "hue" into three ranges:
+
+  if (hue <= 255)       // RANGE 1 (0 - 255) - red to green
+  {
+    r = 255 - hue;    // red goes from on to off
+    g = hue;        // green goes from off to on
+    b = 0;             // blue is always off
+  }
+
+  else if (hue <= 511)  // RANGE 2 (256 - 511) - green to blue
+  {
+    r = 0;                     // red is always off
+    g = 511 - hue;         // green on to off
+    b = hue - 256;          // blue off to on
+  }
+
+  else                    // RANGE 3 ( >= 512)- blue to red
+  {
+    r = hue - 512;         // red off to on
+    g = 0;                 // green is always off
+    b = 767 - hue;        // blue on to off
+  }
+}
+

sparkfun/avr/libraries/LilyPadPrototypingBoard/examples/LPB_10_LilyPixel/LPB_10_LilyPixel.ino

@@ -0,0 +1,29 @@
+/*
+LilyPad Prototyping Board Activity 1: Blink
+SparkFun Electronics
+https://www.sparkfun.com/products/14346
+
+Turns on the LEDs attached to the LilyPad Prototyping Board's sew tab 6 on for one 
+second,then off for one second, forever.
+
+This sketch was written by SparkFun Electronics,
+and is based on Blink by Scott Fitzgerald
+https://www.arduino.cc/en/Tutorial/Blink
+This code is covered by the MTT license and is completely free for any use.
+
+******************************************************************************/
+
+// The setup function runs once when the LilyMini turns on:
+
+void setup() {
+  pinMode(6, OUTPUT);     // Initialize pin 6 as a digital output:
+}
+
+// Once the setup function runs, the loop function runs over and over:
+
+void loop() {
+  digitalWrite(6, HIGH);   // Give pin 6 a HIGH voltage level (on), which lights up the LED
+  delay(1000);             // Wait for one second (the LED stays on)
+  digitalWrite(6, LOW);    // Give pin 6 a LOW voltage level (off), which turns off the LED
+  delay(1000);             // Wait for one second (the LED stays off)
+}

sparkfun/avr/libraries/LilyPadPrototypingBoard/examples/LPB_1_Blink/LPB_1_Blink.ino

@@ -0,0 +1,78 @@
+/*
+LilyPad Prototyping Board Activity 2: Buttons and Switches
+SparkFun Electronics
+https://www.sparkfun.com/products/14346
+
+Read a button (digital input) on pin 4
+Turn on the LED on pin 5 when pressed, and off when released.
+Read a switch (digital input) on pin 9
+Turn on the LED on pin 8 when switch is set to ON, and off when OFF
+
+This sketch was written by SparkFun Electronics,
+and is based on InputPullupSerial code by Scott Fitzgerald
+http://www.arduino.cc/en/Tutorial/InputPullupSerial
+This code is covered by the MTT license and is completely free for any use.
+
+******************************************************************************/
+
+// Create integer variables for the pins we're using:
+
+int buttonPin = 4;
+int switchPin = 9;
+int ledPin1 = 5;
+int ledPin2 = 8;
+
+// Create variables to hold switch/button readings:
+
+int buttonState;
+int switchState;
+
+void setup() {
+
+  // Configure the switch and button as inputs with pullup resistors:
+
+  pinMode(buttonPin, INPUT_PULLUP);
+  pinMode(switchPin, INPUT_PULLUP);
+
+  // The pullup is a small internal resistor between the sewtab and HIGH voltage.
+  // This weakly "pulls up" the input to HIGH if the button is disconnected (not
+  // being pressed). This keeps the input from "floating" (randomly reading either
+  // HIGH or LOW) when the button is not being pressed.
+  
+  // Configure both ledPins as outputs:
+  
+  pinMode(ledPin1, OUTPUT);
+  pinMode(ledPin2, OUTPUT);
+}
+
+void loop() {
+  
+  // Read the button and switch states (HIGH or LOW) and store them:
+  
+  buttonState = digitalRead(buttonPin);
+  switchState = digitalRead(switchPin);
+
+  // Note that LOW = pressed and HIGH = released, the opposite of what you might expect.
+  // This is because the button is attached to ground, which is the LOW voltage level.
+  // When you push the button, it's attached to ground, and digitalRead returns LOW.
+  // When the button is released, the pullup resistor pulls the signal to HIGH.
+  
+  // This "if" statement handles the button state (pressed = LOW, released = HIGH)
+  
+  if (buttonState == LOW) {       // If LOW, the button is pressed
+    digitalWrite(ledPin1, HIGH);  // Turn the LEDs on
+  } else {                        // Otherwise it's HIGH, or unpressed
+    digitalWrite(ledPin1, LOW);   // Turn the LEDs off
+  }
+
+  // This "if" statement handles the switch state (switched on = LOW, switched off = HIGH)
+
+    if (switchState == HIGH) {    // If LOW, the switch is on
+    digitalWrite(ledPin2, HIGH);  // Turn the LEDs on
+  } else {                        // Otherwise it's HIGH, or off
+    digitalWrite(ledPin2, LOW);   // Turn the LEDs off
+  }
+}
+
+
+

sparkfun/avr/libraries/LilyPadPrototypingBoard/examples/LPB_2_Button/LPB_2_Button.ino

@@ -0,0 +1,118 @@
+/*
+LilyPad Prototyping Board Activity 3: Color Mixing
+SparkFun Electronics
+https://www.sparkfun.com/products/14346 
+
+Make an RGB LED display a rainbow of colors!
+
+An RGB LED is actually three LEDs (red, green, and blue) in
+one package. When you turn them on and off in various combinations,
+the red, green and blue mix to form new colors.
+
+The RGB LED is permanently connected to the following pins:
+
+Red - pin 12
+Green - pin 13
+Blue - pin 14
+
+This sketch was written by SparkFun Electronics,
+with lots of help from the Arduino community.
+This code is covered by the MTT license and is completely free for any use.
+
+******************************************************************************/
+
+// Create and set variables for the RGB LED pins:
+
+int RED_PIN = 12;
+int GREEN_PIN = 13;
+int BLUE_PIN = 14;
+
+// Set a variable delayTime for the pause between color changes
+// This variable controls how fast we loop through the colors.
+// (Try changing this to make the colors change faster or slower.)
+
+int delayTime = 1000; // 1000 milliseconds = 1 second
+
+void setup()
+{
+  // Here we'll configure the LilyMini pins we're using to
+  // drive the LED to be outputs:
+  
+  pinMode(RED_PIN, OUTPUT);
+  pinMode(GREEN_PIN, OUTPUT);
+  pinMode(BLUE_PIN, OUTPUT);
+}
+
+void loop()
+{
+  // We're going to turn the individual LEDs (red, blue, and green)
+  // on and off in various combinations. This gives you a total of
+  // eight colors (if you count "black" as a color).
+  // Note that we use delay between each color to slow it down so
+  // you can see them.
+  
+  // Black (all LEDs off)
+  digitalWrite(RED_PIN, LOW);
+  digitalWrite(GREEN_PIN, LOW);
+  digitalWrite(BLUE_PIN, LOW);
+  
+  delay(delayTime);
+  
+  // Red (turn just the red LED on):
+  
+  digitalWrite(RED_PIN, HIGH);
+  digitalWrite(GREEN_PIN, LOW);
+  digitalWrite(BLUE_PIN, LOW);
+  
+  delay(delayTime);
+  
+  // Green (turn just the green LED on):
+  
+  digitalWrite(RED_PIN, LOW);
+  digitalWrite(GREEN_PIN, HIGH);
+  digitalWrite(BLUE_PIN, LOW);
+  
+  delay(delayTime);
+  
+  // Blue (turn just the blue LED on):
+  
+  digitalWrite(RED_PIN, LOW);
+  digitalWrite(GREEN_PIN, LOW);
+  digitalWrite(BLUE_PIN, HIGH);
+  
+  delay(delayTime);
+  
+  // Yellow (turn red and green on):
+  
+  digitalWrite(RED_PIN, HIGH);
+  digitalWrite(GREEN_PIN, HIGH);
+  digitalWrite(BLUE_PIN, LOW);
+  
+  delay(delayTime);
+  
+  // Cyan (turn green and blue on):
+  
+  digitalWrite(RED_PIN, LOW);
+  digitalWrite(GREEN_PIN, HIGH);
+  digitalWrite(BLUE_PIN, HIGH);
+  
+  delay(delayTime);
+  
+  // Purple (turn red and blue on):
+  
+  digitalWrite(RED_PIN, HIGH);
+  digitalWrite(GREEN_PIN, LOW);
+  digitalWrite(BLUE_PIN, HIGH);
+  
+  delay(delayTime);
+  
+  // White (turn all the LEDs on):
+  
+  digitalWrite(RED_PIN, HIGH);
+  digitalWrite(GREEN_PIN, HIGH);
+  digitalWrite(BLUE_PIN, HIGH);
+  
+  delay(delayTime);
+}
+
+