Last active
August 29, 2015 13:57
-
-
Save mattnupen/9700297 to your computer and use it in GitHub Desktop.
Gemma Hoop Earring Class Sketches
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Low power NeoPixel earrings example. Makes a nice blinky display | |
// with just a few LEDs on at any time...uses MUCH less juice than | |
// rainbow display! | |
#include <Adafruit_NeoPixel.h> | |
#define PIN 0 | |
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(32, PIN); | |
uint8_t mode = 0, // Current animation effect | |
offset = 0; // Position of spinny eyes | |
uint32_t color = 0xffae00; // Start red | |
uint32_t prevTime; | |
void setup() { | |
pixels.begin(); | |
pixels.setBrightness(60); // 1/3 brightness | |
prevTime = millis(); | |
} | |
void loop() { | |
uint8_t i; | |
uint32_t t; | |
switch(mode) { | |
case 0: // Random sparks - just one LED on at a time! | |
i = random(32); | |
pixels.setPixelColor(i, color); | |
pixels.show(); | |
delay(10); | |
pixels.setPixelColor(i, 0); | |
break; | |
case 1: // Spinny wheels (8 LEDs on at a time) | |
for(i=0; i<16; i++) { | |
uint32_t c = 0; | |
if(((offset + i) & 7) < 2) c = color; // 4 pixels on... | |
pixels.setPixelColor( i, c); // First eye | |
pixels.setPixelColor(31-i, c); // Second eye (flipped) | |
} | |
pixels.show(); | |
offset++; | |
delay(50); | |
break; | |
} | |
t = millis(); | |
if((t - prevTime) > 8000) { // Every 8 seconds... | |
mode++; // Next mode | |
if(mode > 1) { // End of modes? | |
mode = 0; // Start modes over | |
color >>= 8; // Next color R->G->B | |
if(!color) color = 0xffae00; // Reset to red | |
} | |
for(i=0; i<32; i++) pixels.setPixelColor(i, 0); | |
prevTime = t; | |
} | |
} | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include <Adafruit_NeoPixel.h> | |
#define PIN 0 | |
Adafruit_NeoPixel strip = Adafruit_NeoPixel(18, PIN, NEO_GRB + NEO_KHZ800); | |
// Change These Variables | |
int maxBrightness = 70; | |
int minBrightness = 20; | |
int fadeSpeed = 50; | |
void setup() { | |
strip.begin(); | |
strip.show(); // Initialize all pixels to 'off' | |
} | |
void loop() { | |
//Set the color with Red, Gree, Blue values | |
pulseColor(strip.Color(27, 103, 107), fadeSpeed); | |
} | |
void pulseColor(uint32_t c, uint8_t wait) { | |
//Increase Brightness / Fade In | |
for(int i=minBrightness; i<maxBrightness; i++) { | |
strip.setBrightness(i); | |
for(int x=0; x<strip.numPixels(); x++){ | |
strip.setPixelColor(x,c); | |
} | |
strip.show(); | |
delay(wait); | |
} | |
//Lower Brightness / Fade Out | |
for(int i=maxBrightness; i>minBrightness; i--) { | |
strip.setBrightness(i); | |
for(int x=0; x<strip.numPixels(); x++){ | |
strip.setPixelColor(x,c); | |
} | |
strip.show(); | |
delay(wait); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include <Adafruit_NeoPixel.h> | |
#define PIN 0 | |
// Parameter 1 = number of pixels in strip | |
// Parameter 2 = Arduino pin number (most are valid) | |
// Parameter 3 = pixel type flags, add together as needed: | |
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs) | |
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers) | |
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products) | |
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2) | |
Adafruit_NeoPixel strip = Adafruit_NeoPixel(18, PIN, NEO_GRB + NEO_KHZ800); | |
// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across | |
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input | |
// and minimize distance between Arduino and first pixel. Avoid connecting | |
// on a live circuit...if you must, connect GND first. | |
void setup() { | |
strip.begin(); | |
strip.show(); // Initialize all pixels to 'off' | |
} | |
void loop() { | |
strip.setBrightness(100); | |
// Some example procedures showing how to display to the pixels: | |
colorWipe(strip.Color(255, 0, 0), 50); // Red | |
colorWipe(strip.Color(0, 255, 0), 50); // Green | |
colorWipe(strip.Color(0, 0, 255), 50); // Blue | |
// Send a theater pixel chase in... | |
theaterChase(strip.Color(127, 127, 127), 50); // White | |
theaterChase(strip.Color(127, 0, 0), 50); // Red | |
theaterChase(strip.Color( 0, 0, 127), 50); // Blue | |
rainbow(20); | |
rainbowCycle(20); | |
theaterChaseRainbow(50); | |
} | |
// Fill the dots one after the other with a color | |
void colorWipe(uint32_t c, uint8_t wait) { | |
for(uint16_t i=0; i<strip.numPixels(); i++) { | |
strip.setPixelColor(i, c); | |
strip.show(); | |
delay(wait); | |
} | |
} | |
void rainbow(uint8_t wait) { | |
uint16_t i, j; | |
for(j=0; j<256; j++) { | |
for(i=0; i<strip.numPixels(); i++) { | |
strip.setPixelColor(i, Wheel((i+j) & 255)); | |
} | |
strip.show(); | |
delay(wait); | |
} | |
} | |
// Slightly different, this makes the rainbow equally distributed throughout | |
void rainbowCycle(uint8_t wait) { | |
uint16_t i, j; | |
for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel | |
for(i=0; i< strip.numPixels(); i++) { | |
strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); | |
} | |
strip.show(); | |
delay(wait); | |
} | |
} | |
//Theatre-style crawling lights. | |
void theaterChase(uint32_t c, uint8_t wait) { | |
for (int j=0; j<10; j++) { //do 10 cycles of chasing | |
for (int q=0; q < 3; q++) { | |
for (int i=0; i < strip.numPixels(); i=i+3) { | |
strip.setPixelColor(i+q, c); //turn every third pixel on | |
} | |
strip.show(); | |
delay(wait); | |
for (int i=0; i < strip.numPixels(); i=i+3) { | |
strip.setPixelColor(i+q, 0); //turn every third pixel off | |
} | |
} | |
} | |
} | |
//Theatre-style crawling lights with rainbow effect | |
void theaterChaseRainbow(uint8_t wait) { | |
for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel | |
for (int q=0; q < 3; q++) { | |
for (int i=0; i < strip.numPixels(); i=i+3) { | |
strip.setPixelColor(i+q, Wheel( (i+j) % 255)); //turn every third pixel on | |
} | |
strip.show(); | |
delay(wait); | |
for (int i=0; i < strip.numPixels(); i=i+3) { | |
strip.setPixelColor(i+q, 0); //turn every third pixel off | |
} | |
} | |
} | |
} | |
// Input a value 0 to 255 to get a color value. | |
// The colours are a transition r - g - b - back to r. | |
uint32_t Wheel(byte WheelPos) { | |
if(WheelPos < 85) { | |
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0); | |
} else if(WheelPos < 170) { | |
WheelPos -= 85; | |
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3); | |
} else { | |
WheelPos -= 170; | |
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3); | |
} | |
} | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
NeoPixel Ring goggles sketch -- for steampunk, rave or Burning Man fashion! | |
Welding or costume goggles using 50mm round lenses can be outfitted with | |
a pair of Adafruit NeoPixel Rings: http://www.adafruit.com/product/1463 | |
Please exercise common sense. These goggles emit a LOT of stray light and | |
should NOT BE WORN ON YOUR EYES. They're for fashion and costuming only, | |
for display on a hat or on your forehead. | |
Draws a spinning rainbow on both eyepieces. Not a Mac beachball, honest. | |
"Eyes" glance around and blink at random. | |
For 'reflected' colors (rainbows rotate in opposite directions, while eyes | |
look in same direction), connect the output of the first ring to the input | |
of the second. Or you can connect the inputs of both rings to the same | |
Arduino pin if that's easier -- the rainbows will both twirl in the same | |
direction in that case. | |
By default, pixel #0 (the first LED) on both rings should be at the TOP of | |
the goggles. Looking at the BACK of the board, pixel #0 is immediately | |
clockwise from the OUT connection. If a different pixel is at the top, | |
that's OK, the code can compensate (TOP_LED_FIRST and TOP_LED_SECOND below). | |
IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across | |
pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input | |
and minimize distance between Arduino and first pixel. Avoid connecting | |
on a live circuit...if you must, connect GND first. | |
*/ | |
#include <Adafruit_NeoPixel.h> | |
#ifdef __AVR_ATtiny85__ // Trinket, Gemma, etc. | |
#include <avr/power.h> | |
#endif | |
#define PIN 0 | |
#define TOP_LED_FIRST 0 // Change these if the first pixel is not | |
#define TOP_LED_SECOND 0 // at the top of the first and/or second ring. | |
#define EFFECT RAINBOW // Choose a visual effect from the names below | |
#define RAINBOW 0 | |
#define ECTO 1 | |
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(32, PIN, NEO_GRB + NEO_KHZ800); | |
const int8_t PROGMEM | |
yCoord[] = { // Vertical coordinate of each pixel. First pixel is at top. | |
127,117,90,49,0,-49,-90,-117,-127,-117,-90,-49,0,49,90,117 }, | |
sine[] = { // Brightness table for ecto effect | |
0, 28, 96, 164, 192, 164, 96, 28, 0, 28, 96, 164, 192, 164, 96, 28 }; | |
// Eyelid vertical coordinates. Eyes shut slightly below center. | |
#define upperLidTop 130 | |
#define upperLidBottom -45 | |
#define lowerLidTop -40 | |
#define lowerLidBottom -130 | |
// Gamma correction improves appearance of midrange colors | |
const uint8_t PROGMEM gamma8[] = { | |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, | |
1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, | |
3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7, | |
7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, | |
13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, | |
20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29, | |
30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42, | |
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, | |
58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 75, | |
76, 77, 78, 80, 81, 82, 84, 85, 86, 88, 89, 90, 92, 93, 94, 96, | |
97, 99,100,102,103,105,106,108,109,111,112,114,115,117,119,120, | |
122,124,125,127,129,130,132,134,136,137,139,141,143,145,146,148, | |
150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180, | |
182,184,186,188,191,193,195,197,199,202,204,206,209,211,213,215, | |
218,220,223,225,227,230,232,235,237,240,242,245,247,250,252,255 | |
}; | |
uint32_t | |
iColor[16][3]; // Background colors for eyes | |
int16_t | |
hue = 0; // Initial hue around perimeter (0-1535) | |
uint8_t | |
iBrightness[16], // Brightness map -- eye colors get scaled by these | |
brightness = 220, // Global brightness (0-255) | |
blinkFrames = 5, // Speed of current blink | |
blinkCounter = 30, // Countdown to end of next blink | |
eyePos = 192, // Current 'resting' eye (pupil) position | |
newEyePos = 192, // Next eye position when in motion | |
gazeCounter = 75, // Countdown to next eye movement | |
gazeFrames = 50; // Duration of eye movement (smaller = faster) | |
int8_t | |
eyeMotion = 0; // Distance from prior to new position | |
void setup() { | |
#ifdef __AVR_ATtiny85__ // Trinket, Gemma, etc. | |
if(F_CPU == 16000000) clock_prescale_set(clock_div_1); | |
// Seed random number generator from an unused analog input: | |
randomSeed(analogRead(2)); | |
#else | |
randomSeed(analogRead(A0)); | |
#endif | |
pixels.begin(); | |
} | |
void loop() { | |
uint8_t i, r, g, b, a, c, inner, outer, ep; | |
int y1, y2, y3, y4, h; | |
int8_t y; | |
// Draw eye background colors | |
#if EFFECT == RAINBOW | |
// This renders a glotating rainbow...a WAY overdone LED effect but | |
// does show the color gamut nicely. | |
for(h=hue, i=0; i<16; i++, h += 96) { | |
a = h; | |
switch((h >> 8) % 6) { | |
case 0: iColor[i][0] = 255; iColor[i][1] = a; iColor[i][2] = 0; break; | |
case 1: iColor[i][0] = ~a; iColor[i][1] = 255; iColor[i][2] = 0; break; | |
case 2: iColor[i][0] = 0; iColor[i][1] = 255; iColor[i][2] = a; break; | |
case 3: iColor[i][0] = 0; iColor[i][1] = ~a; iColor[i][2] = 255; break; | |
case 4: iColor[i][0] = a; iColor[i][1] = 0; iColor[i][2] = 255; break; | |
case 5: iColor[i][0] = 255; iColor[i][1] = 0; iColor[i][2] = ~a; break; | |
} | |
} | |
hue += 7; | |
if(hue >= 1536) hue -= 1536; | |
#elif EFFECT == ECTO | |
// A steampunk aesthetic might fare better with this more subdued effect. | |
// Etherial green glow with just a little animation for visual spice. | |
a = (hue >> 4) & 15; | |
c = hue & 15; | |
for(i=0; i<16; i++) { | |
b = (a + 1) & 15; | |
iColor[i][1] = 255; // Predominantly green | |
iColor[i][0] = (pgm_read_byte(&sine[a]) * (16 - c) + | |
pgm_read_byte(&sine[b]) * c ) >> 4; | |
iColor[i][2] = iColor[i][0] >> 1; | |
a = b; | |
} | |
hue -= 3; | |
#endif | |
// Render current blink (if any) into brightness map | |
if(blinkCounter <= blinkFrames * 2) { // In mid-blink? | |
if(blinkCounter > blinkFrames) { // Eye closing | |
outer = blinkFrames * 2 - blinkCounter; | |
inner = outer + 1; | |
} else { // Eye opening | |
inner = blinkCounter; | |
outer = inner - 1; | |
} | |
y1 = upperLidTop - (upperLidTop - upperLidBottom) * outer / blinkFrames; | |
y2 = upperLidTop - (upperLidTop - upperLidBottom) * inner / blinkFrames; | |
y3 = lowerLidBottom + (lowerLidTop - lowerLidBottom) * inner / blinkFrames; | |
y4 = lowerLidBottom + (lowerLidTop - lowerLidBottom) * outer / blinkFrames; | |
for(i=0; i<16; i++) { | |
y = pgm_read_byte(&yCoord[i]); | |
if(y > y1) { // Above top lid | |
iBrightness[i] = 0; | |
} else if(y > y2) { // Blur edge of top lid in motion | |
iBrightness[i] = brightness * (y1 - y) / (y1 - y2); | |
} else if(y > y3) { // In eye | |
iBrightness[i] = brightness; | |
} else if(y > y4) { // Blur edge of bottom lid in motion | |
iBrightness[i] = brightness * (y - y4) / (y3 - y4); | |
} else { // Below bottom lid | |
iBrightness[i] = 0; | |
} | |
} | |
} else { // Not in blink -- set all 'on' | |
memset(iBrightness, brightness, sizeof(iBrightness)); | |
} | |
if(--blinkCounter == 0) { // Init next blink? | |
blinkFrames = random(4, 8); | |
blinkCounter = blinkFrames * 2 + random(5, 180); | |
} | |
// Calculate current eye movement, possibly init next one | |
if(--gazeCounter <= gazeFrames) { // Is pupil in motion? | |
ep = newEyePos - eyeMotion * gazeCounter / gazeFrames; // Current pos. | |
if(gazeCounter == 0) { // Last frame? | |
eyePos = newEyePos; // Current position = new pos | |
newEyePos = random(16) * 16; // New pos. (always pixel center) | |
eyeMotion = newEyePos - eyePos; // Distance to move | |
gazeFrames = random(10, 20); // Duration of movement | |
gazeCounter = random(gazeFrames, 130); // Count to END of next movement | |
} | |
} else ep = eyePos; // Not moving -- fixed gaze | |
// Draw pupil -- 2 pixels wide, but sup-pixel positioning may span 3. | |
a = ep >> 4; // First candidate | |
b = (a + 1) & 0x0F; // 1 pixel CCW of a | |
c = (a + 2) & 0x0F; // 2 pixels CCW of a | |
i = ep & 0x0F; // Fraction of 'c' covered (0-15) | |
iBrightness[a] = (iBrightness[a] * i ) >> 4; | |
iBrightness[b] = 0; | |
iBrightness[c] = (iBrightness[c] * (16 - i)) >> 4; | |
// Merge iColor with iBrightness, issue to NeoPixels | |
for(i=0; i<16; i++) { | |
a = iBrightness[i] + 1; | |
// First eye | |
r = iColor[i][0]; // Initial background RGB color | |
g = iColor[i][1]; | |
b = iColor[i][2]; | |
if(a) { | |
r = (r * a) >> 8; // Scale by brightness map | |
g = (g * a) >> 8; | |
b = (b * a) >> 8; | |
} | |
pixels.setPixelColor(((i + TOP_LED_FIRST) & 15), | |
pgm_read_byte(&gamma8[r]), // Gamma correct and set pixel | |
pgm_read_byte(&gamma8[g]), | |
pgm_read_byte(&gamma8[b])); | |
// Second eye uses the same colors, but reflected horizontally. | |
// The same brightness map is used, but not reflected (same left/right) | |
r = iColor[15 - i][0]; | |
g = iColor[15 - i][1]; | |
b = iColor[15 - i][2]; | |
if(a) { | |
r = (r * a) >> 8; | |
g = (g * a) >> 8; | |
b = (b * a) >> 8; | |
} | |
pixels.setPixelColor(16 + ((i + TOP_LED_SECOND) & 15), | |
pgm_read_byte(&gamma8[r]), | |
pgm_read_byte(&gamma8[g]), | |
pgm_read_byte(&gamma8[b])); | |
} | |
pixels.show(); | |
delay(15); | |
} | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment