Raw Paste

#define FASTLED_INTERNAL #include <FastLED.h> #include <Adafruit_NeoPixel.h> //#include <EEPROM.h> #define PIN 5 #define N_PIXELS 32 #define BG 0 #define COLOR_ORDER GRB // Try mixing up the letters (RGB, GBR, BRG, etc) for a whole new world of color combinations #define BRIGHTNESS 64 // 0-255, higher number is brighter. #define LED_TYPE WS2812B #define MIC_PIN A0 // Microphone is attached to this analog pin #define MIC_PIN_2 A1 #define DC_OFFSET 0 // DC offset in mic signal - if unusure, leave 0 #define NOISE 10 // Noise/hum/interference in mic signal #define SAMPLES 64 // Length of buffer for dynamic level adjustment #define SAMPLES2 64 #define TOP (N_PIXELS + 2) // Allow dot to go slightly off scale #define PEAK_FALL 20 // Rate of peak falling dot #define N_PIXELS_HALF (N_PIXELS/2) #define GRAVITY -9.81 // Downward (negative) acceleration of gravity in m/s^2 #define h0 1 // Starting height, in meters, of the ball (strip length) #define NUM_BALLS 3 // Number of bouncing balls you want (recommend < 7, but 20 is fun in its own way) #define SPEED .20 // Amount to increment RGB color by each cycle #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0])) //config for balls float h[NUM_BALLS] ; // An array of heights float vImpact0 = sqrt( -2 * GRAVITY * h0 ); // Impact velocity of the ball when it hits the ground if "dropped" from the top of the strip float vImpact[NUM_BALLS] ; // As time goes on the impact velocity will change, so make an array to store those values float tCycle[NUM_BALLS] ; // The time since the last time the ball struck the ground int pos[NUM_BALLS] ; // The integer position of the dot on the strip (LED index) long tLast[NUM_BALLS] ; // The clock time of the last ground strike float COR[NUM_BALLS] ; // Coefficient of Restitution (bounce damping) float greenOffset = 30, blueOffset = 150; byte peakLeft = 0, // Used for falling dot peakRight = 0, dotCountLeft = 0, // Frame counter for delaying dot-falling speed dotCountRight = 0, volCount = 0; // Frame counter for storing past volume data int vol[SAMPLES], // Collection of prior volume samples lvl = 10, // Current "dampened" audio level minLvlAvg = 0, // For dynamic adjustment of graph low & high maxLvlAvg = 512; uint8_t volCountLeft = 0; int volLeft[SAMPLES]; int lvlLeft = 10; int minLvlAvgLeft = 0; int maxLvlAvgLeft = 512; uint8_t volCountRight = 0; int volRight[SAMPLES2]; int lvlRight = 10; int minLvlAvgRight = 0; int maxLvlAvgRight = 512; int brightnessValue, prevBrightnessValue; int sensorDeviationBrightness = 1; int sensitivityValue = 128; // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) int maxSensitivity = 2 * 255; // let the 'volume' go up to 200%! int ledBrightness = 64; // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) int nPatterns = 1; int Pattern = 1; Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_PIXELS, PIN, NEO_GRB + NEO_KHZ800); // FOR SYLON ETC uint8_t thisbeat = 23; uint8_t thatbeat = 28; uint8_t thisfade = 2; // How quickly does it fade? Lower = slower fade rate. uint8_t thissat = 255; // The saturation, where 255 = brilliant colours. uint8_t thisbri = 64; //FOR JUGGLE uint8_t numdots = 4; // Number of dots in use. uint8_t faderate = 2; // How long should the trails be. Very low value = longer trails. uint8_t hueinc = 16; // Incremental change in hue between each dot. uint8_t thishue = 0; // Starting hue. uint8_t curhue = 0; uint8_t thisbright = 64; // How bright should the LED/display be. uint8_t basebeat = 5; uint8_t max_bright = 64; // Twinkle float redStates[N_PIXELS]; float blueStates[N_PIXELS]; float greenStates[N_PIXELS]; float Fade = 0.96; // Vu meter 4 const uint32_t Red = strip.Color(128, 0, 0); const uint32_t Yellow = strip.Color(128, 128, 0); const uint32_t Green = strip.Color(0, 128, 0); const uint32_t Blue = strip.Color(0, 0, 128); const uint32_t White = strip.Color(255, 255, 255); const uint32_t Dark = strip.Color(0, 0, 0); unsigned int sample; CRGB leds[N_PIXELS]; int myhue = 0; // Modes enum { } MODE; bool reverse = true; //Ripple variables int color; int center = 0; int step = -1; int maxSteps = 8; float fadeRate = 0.80; int diff; //background color uint32_t currentBg = random(256); uint32_t nextBg = currentBg; byte peak = 16; byte dotCount = 0; byte dotHangCount = 0; //************************************************************************ void setup() { delay( 2000 ); // power-up safety delay FastLED.addLeds<WS2812B, PIN, COLOR_ORDER>(leds, N_PIXELS).setCorrection( TypicalLEDStrip ); FastLED.setBrightness( BRIGHTNESS ); // analogReference(EXTERNAL); memset(vol, 0, sizeof(vol)); LEDS.addLeds<LED_TYPE, PIN, COLOR_ORDER>(leds, N_PIXELS); strip.setBrightness(ledBrightness); strip.begin(); strip.show(); // Initialize all pixels to 'off' for (int i = 0 ; i < NUM_BALLS ; i++) { // Initialize variables tLast[i] = millis(); h[i] = h0; pos[i] = 0; // Balls start on the ground vImpact[i] = vImpact0; // And "pop" up at vImpact0 tCycle[i] = 0; COR[i] = 0.90 - float(i) / pow(NUM_BALLS, 2); } } void loop() { //for mic uint8_t i; uint16_t minLvlLeft, maxLvlLeft; uint16_t minLvlRight, maxLvlRight; int n, n1, height; // end mic Pattern = Pattern + 1; if ( Pattern > nPatterns ) Pattern = 1; switch (Pattern) { case 1: All(); break; } } void colorWipe(uint32_t c, uint8_t wait) { for (uint16_t i = 0; i < strip.numPixels(); i++) { strip.setPixelColor(i, c); strip.show(); if (Pattern != nPatterns) // <------------- add this return; // <------------ and this delay(wait); } } void Vu4() { uint8_t i; uint16_t minLvlLeft, maxLvlLeft; uint16_t minLvlRight, maxLvlRight; int n, n1, height; n = analogRead(MIC_PIN); // Raw reading from mic n = abs(n - 512 - DC_OFFSET); // Center on zero n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum lvlLeft = ((lvlLeft * 7) + n) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakLeft) peakLeft = height; // Keep 'peak' dot at top greenOffset += SPEED; blueOffset += SPEED; if (greenOffset >= 255) greenOffset = 0; if (blueOffset >= 255) blueOffset = 0; // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF + i, 0, 0, 0); } else { uint32_t color = Wheel(map(N_PIXELS_HALF + i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset)); strip.setPixelColor(N_PIXELS_HALF + i, color); } } // Draw peak dot if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF - 1) { uint32_t color = Wheel(map(N_PIXELS_HALF + peakLeft, 0, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF + peakLeft, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountLeft >= PEAK_FALL) { //fall rate if (peakLeft > 0) peakLeft--; dotCountLeft = 0; } volLeft[volCountLeft] = n; // Save sample for dynamic leveling if (++volCountLeft >= SAMPLES) volCountLeft = 0; // Advance/rollover sample counter // Get volume range of prior frames minLvlLeft = maxLvlLeft = vol[0]; for (i = 1; i < SAMPLES; i++) { if (volLeft[i] < minLvlLeft) minLvlLeft = volLeft[i]; else if (volLeft[i] > maxLvlLeft) maxLvlLeft = volLeft[i]; } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlLeft - minLvlLeft) < TOP) maxLvlLeft = minLvlLeft + TOP; minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average) n1 = analogRead(MIC_PIN_2); // Raw reading from mic n1 = abs(n1 - 512 - DC_OFFSET); // Center on zero n1 = (n1 <= NOISE) ? 0 : (n1 - NOISE); // Remove noise/hum lvlRight = ((lvlRight * 7) + n1) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakRight) peakRight = height; // Keep 'peak' dot at top greenOffset += SPEED; blueOffset += SPEED; if (greenOffset >= 255) greenOffset = 0; if (blueOffset >= 255) blueOffset = 0; // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF - i - 1, 0, 0, 0); } else { uint32_t color = Wheel(map(i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset)); strip.setPixelColor(N_PIXELS_HALF - i - 1, color); } } // Draw peak dot if (peakRight > 0 && peakRight <= N_PIXELS_HALF - 1) { uint32_t color = Wheel(map(N_PIXELS_HALF - peakRight - 1, 0, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF - peakRight - 1, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountRight >= PEAK_FALL) { //fall rate if (peakRight > 0) peakRight--; dotCountRight = 0; } volRight[volCountRight] = n; // Save sample for dynamic leveling if (++volCountRight >= SAMPLES2) volCountRight = 0; // Advance/rollover sample counter // Get volume range of prior frames minLvlRight = maxLvlRight = vol[0]; for (i = 1; i < SAMPLES2; i++) { if (volRight[i] < minLvlRight) minLvlRight = volRight[i]; else if (volRight[i] > maxLvlRight) maxLvlRight = volRight[i]; } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlRight - minLvlRight) < TOP) maxLvlRight = minLvlRight + TOP; minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average) } void Vu3() { uint8_t i; uint16_t minLvlLeft, maxLvlLeft; uint16_t minLvlRight, maxLvlRight; int n, n1, height; n = analogRead(MIC_PIN); // Raw reading from mic n = abs(n - 512 - DC_OFFSET); // Center on zero n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum lvlLeft = ((lvlLeft * 7) + n) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakLeft) peakLeft = height; // Keep 'peak' dot at top greenOffset += SPEED; blueOffset += SPEED; if (greenOffset >= 255) greenOffset = 0; if (blueOffset >= 255) blueOffset = 0; // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF / 2; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF / 2 - i - 1, 0, 0, 0); } else { uint32_t color = Wheel(map(N_PIXELS_HALF / 2 - i - 1, 1, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset)); strip.setPixelColor(N_PIXELS_HALF / 2 - i - 1, color); } } // Draw peak dot if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF / 2 - 1) { uint32_t color = Wheel(map(N_PIXELS_HALF / 2 - peakLeft - 1, 0, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF / 2 - peakLeft - 1, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountLeft >= PEAK_FALL) { //fall rate if (peakLeft > 0) peakLeft--; dotCountLeft = 0; } strip.show(); // Update strip volLeft[volCountLeft] = n; if (++volCountLeft >= SAMPLES) { volCountLeft = 0; } // Get volume range of prior frames minLvlLeft = maxLvlLeft = vol[0]; for (i = 1; i < SAMPLES; i++) { if (volLeft[i] < minLvlLeft) { minLvlLeft = volLeft[i]; } else if (volLeft[i] > maxLvlLeft) { maxLvlLeft = volLeft[i]; } } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlLeft - minLvlLeft) < TOP) { maxLvlLeft = minLvlLeft + TOP; } minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average) n1 = analogRead(MIC_PIN_2); // Raw reading from mic n1 = abs(n1 - 512 - DC_OFFSET); // Center on zero n1 = (n1 <= NOISE) ? 0 : (n1 - NOISE); // Remove noise/hum lvlRight = ((lvlRight * 7) + n1) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakRight) peakRight = height; // Keep 'peak' dot at top greenOffset += SPEED; blueOffset += SPEED; if (greenOffset >= 255) greenOffset = 0; if (blueOffset >= 255) blueOffset = 0; // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF / 2; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF / 2 + i, 0, 0, 0); } else { uint32_t color = Wheel(map(N_PIXELS_HALF + i, 1, strip.numPixels(), (int)greenOffset, (int)blueOffset)); strip.setPixelColor(N_PIXELS_HALF / 2 + i, color); } } // Draw peak dot if (peakRight > 0 && peakRight <= N_PIXELS_HALF / 2) { uint32_t color = Wheel(map(N_PIXELS_HALF + peakLeft, 1, strip.numPixels(), 30, 150)); strip.setPixelColor(N_PIXELS_HALF + peakLeft, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountRight >= PEAK_FALL) { //fall rate if (peakRight > 0) peakRight--; dotCountRight = 0; } strip.show(); // Update strip volRight[volCountRight] = n1; if (++volCountRight >= SAMPLES2) { volCountRight = 0; } // Get volume range of prior frames minLvlRight = maxLvlRight = vol[0]; for (i = 1; i < SAMPLES2; i++) { if (volRight[i] < minLvlRight) { minLvlRight = volRight[i]; } else if (volRight[i] > maxLvlRight) { maxLvlRight = volRight[i]; } } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlRight - minLvlRight) < TOP) { maxLvlRight = minLvlRight + TOP; } minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average) } void Balls() { for (int i = 0 ; i < NUM_BALLS ; i++) { tCycle[i] = millis() - tLast[i] ; // Calculate the time since the last time the ball was on the ground // A little kinematics equation calculates positon as a function of time, acceleration (gravity) and intial velocity h[i] = 0.5 * GRAVITY * pow( tCycle[i] / 1000 , 2.0 ) + vImpact[i] * tCycle[i] / 1000; if ( h[i] < 0 ) { h[i] = 0; // If the ball crossed the threshold of the "ground," put it back on the ground vImpact[i] = COR[i] * vImpact[i] ; // and recalculate its new upward velocity as it's old velocity * COR tLast[i] = millis(); if ( vImpact[i] < 0.01 ) vImpact[i] = vImpact0; // If the ball is barely moving, "pop" it back up at vImpact0 } pos[i] = round( h[i] * (N_PIXELS - 1) / h0); // Map "h" to a "pos" integer index position on the LED strip } //Choose color of LEDs, then the "pos" LED on for (int i = 0 ; i < NUM_BALLS ; i++) leds[pos[i]] = CHSV( uint8_t (i * 40) , 255, 255); FastLED.show(); //Then off for the next loop around for (int i = 0 ; i < NUM_BALLS ; i++) { leds[pos[i]] = CRGB::Black; } } // 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(); if (Pattern != nPatterns) // <------------- add this return; // <------------ and this delay(wait); } } // HERE void vu() { uint8_t i; uint16_t minLvlLeft, maxLvlLeft; uint16_t minLvlRight, maxLvlRight; int n, n1, height; n = analogRead(MIC_PIN); // Raw reading from mic n = abs(n - 512 - DC_OFFSET); // Center on zero n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum lvlLeft = ((lvlLeft * 7) + n) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakLeft) peakLeft = height; // Keep 'peak' dot at top // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF - i - 1, 0, 0, 0); } else { uint32_t color = Wheel(map(i, 0, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF - i - 1, color); } } // Draw peak dot if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF - 1) { uint32_t color = Wheel(map(N_PIXELS_HALF - peakLeft - 1, 0, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF - peakLeft - 1, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountLeft >= PEAK_FALL) { //fall rate if (peakLeft > 0) peakLeft--; dotCountLeft = 0; } volLeft[volCountLeft] = n; // Save sample for dynamic leveling if (++volCountLeft >= SAMPLES) volCountLeft = 0; // Advance/rollover sample counter // Get volume range of prior frames minLvlLeft = maxLvlLeft = vol[0]; for (i = 1; i < SAMPLES; i++) { if (volLeft[i] < minLvlLeft) minLvlLeft = volLeft[i]; else if (volLeft[i] > maxLvlLeft) maxLvlLeft = volLeft[i]; } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlLeft - minLvlLeft) < TOP) maxLvlLeft = minLvlLeft + TOP; minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average) n1 = analogRead(MIC_PIN_2); // Raw reading from mic n1 = abs(n1 - 512 - DC_OFFSET); // Center on zero n1 = (n1 <= NOISE) ? 0 : (n1 - NOISE); // Remove noise/hum lvlRight = ((lvlRight * 7) + n1) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakRight) peakRight = height; // Keep 'peak' dot at top // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF + i, 0, 0, 0); } else { uint32_t color = Wheel(map(N_PIXELS_HALF + i, 0, strip.numPixels(), 30, 150)); strip.setPixelColor(N_PIXELS_HALF + i, color); } } // Draw peak dot if (peakRight > 0 && peakRight <= N_PIXELS_HALF) strip.setPixelColor(N_PIXELS_HALF + peakRight, Wheel(map(N_PIXELS_HALF + peakRight, 0, strip.numPixels(), 30, 150))); strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountRight >= PEAK_FALL) { //fall rate if (peakRight > 0) peakRight--; dotCountRight = 0; } volRight[volCountRight] = n1; // Save sample for dynamic leveling if (++volCountRight >= SAMPLES2) volCountRight = 0; // Advance/rollover sample counter // Get volume range of prior frames minLvlRight = maxLvlRight = vol[0]; for (i = 1; i < SAMPLES2; i++) { if (volRight[i] < minLvlRight) minLvlRight = volRight[i]; else if (volRight[i] > maxLvlRight) maxLvlRight = volRight[i]; } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlRight - minLvlRight) < TOP) maxLvlRight = minLvlRight + TOP; minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average) } // Input a value 0 to 255 to get a color value. // The colors 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); } } void vu2() { uint8_t i; uint16_t minLvlLeft, maxLvlLeft; uint16_t minLvlRight, maxLvlRight; int n, n1, height; n = analogRead(MIC_PIN); // Raw reading from mic n = abs(n - 512 - DC_OFFSET); // Center on zero n = (n <= NOISE) ? 0 : (n - NOISE); // Remove noise/hum lvlLeft = ((lvlLeft * 7) + n) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlLeft - minLvlAvgLeft) / (long)(maxLvlAvgLeft - minLvlAvgLeft); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakLeft) peakLeft = height; // Keep 'peak' dot at top // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF - i - 1, 0, 0, 0); } else { uint32_t color = Wheel(map(i, 2, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF - i - 1, color); } } // Draw peak dot if (peakLeft > 0 && peakLeft <= N_PIXELS_HALF - 1) { uint32_t color = Wheel(map(N_PIXELS_HALF - peakLeft - 1, 2, strip.numPixels() - 1, 30, 150)); strip.setPixelColor(N_PIXELS_HALF - peak - 1, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountLeft >= PEAK_FALL) { //fall rate if (peakLeft > 0) peakLeft--; dotCountLeft = 0; } volLeft[volCountLeft] = n; // Save sample for dynamic leveling if (++volCountLeft >= SAMPLES) volCountLeft = 0; // Advance/rollover sample counter // Get volume range of prior frames minLvlLeft = maxLvlLeft = vol[0]; for (i = 1; i < SAMPLES; i++) { if (volLeft[i] < minLvlLeft) minLvlLeft = volLeft[i]; else if (volLeft[i] > maxLvlLeft) maxLvlLeft = volLeft[i]; } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlLeft - minLvlLeft) < TOP) maxLvlLeft = minLvlLeft + TOP; minLvlAvgLeft = (minLvlAvgLeft * 63 + minLvlLeft) >> 6; // Dampen min/max levels maxLvlAvgLeft = (maxLvlAvgLeft * 63 + maxLvlLeft) >> 6; // (fake rolling average) n1 = analogRead(MIC_PIN_2); // Raw reading from mic n1 = abs(n - 512 - DC_OFFSET); // Center on zero n1 = (n1 <= NOISE) ? 0 : (n1 - NOISE); // Remove noise/hum lvlRight = ((lvlRight * 7) + n1) >> 3; // "Dampened" reading (else looks twitchy) // Calculate bar height based on dynamic min/max levels (fixed point): height = TOP * (lvlRight - minLvlAvgRight) / (long)(maxLvlAvgRight - minLvlAvgRight); if (height < 0L) height = 0; // Clip output else if (height > TOP) height = TOP; if (height > peakRight) peakRight = height; // Keep 'peak' dot at top // Color pixels based on rainbow gradient for (i = 0; i < N_PIXELS_HALF; i++) { if (i >= height) { strip.setPixelColor(N_PIXELS_HALF + i, 0, 0, 0); } else { uint32_t color = Wheel(map(N_PIXELS_HALF + i, 2, strip.numPixels() , 30, 150)); strip.setPixelColor(N_PIXELS_HALF + i, color); } } // Draw peak dot if (peakRight > 0 && peakRight <= N_PIXELS_HALF) { uint32_t color = Wheel(map(N_PIXELS_HALF + peakRight, 2, strip.numPixels() , 30, 150)); strip.setPixelColor(N_PIXELS_HALF + peakRight, color); } strip.show(); // Update strip // Every few frames, make the peak pixel drop by 1: if (++dotCountRight >= PEAK_FALL) { //fall rate if (peakRight > 0) peakRight--; dotCountRight = 0; } volRight[volCountRight] = n1; // Save sample for dynamic leveling if (++volCountRight >= SAMPLES2) volCountRight = 0; // Advance/rollover sample counter // Get volume range of prior frames minLvlRight = maxLvlRight = vol[0]; for (i = 1; i < SAMPLES2; i++) { if (volRight[i] < minLvlRight) minLvlRight = volRight[i]; else if (volRight[i] > maxLvlRight) maxLvlRight = volRight[i]; } // minLvl and maxLvl indicate the volume range over prior frames, used // for vertically scaling the output graph (so it looks interesting // regardless of volume level). If they're too close together though // (e.g. at very low volume levels) the graph becomes super coarse // and 'jumpy'...so keep some minimum distance between them (this // also lets the graph go to zero when no sound is playing): if ((maxLvlRight - minLvlRight) < TOP) maxLvlRight = minLvlRight + TOP; minLvlAvgRight = (minLvlAvgRight * 63 + minLvlRight) >> 6; // Dampen min/max levels maxLvlAvgRight = (maxLvlAvgRight * 63 + maxLvlRight) >> 6; // (fake rolling average) } //here................ void ripple() { if (currentBg == nextBg) { nextBg = random(256); } else if (nextBg > currentBg) { currentBg++; } else { currentBg--; } for (uint16_t l = 0; l < N_PIXELS; l++) { leds[l] = CHSV(currentBg, 255, 50); // strip.setPixelColor(l, Wheel(currentBg, 0.1)); } if (step == -1) { center = random(N_PIXELS); color = random(256); step = 0; } if (step == 0) { leds[center] = CHSV(color, 255, 255); // strip.setPixelColor(center, Wheel(color, 1)); step ++; } else { if (step < maxSteps) { leds[wrap(center + step)] = CHSV(color, 255, pow(fadeRate, step) * 255); // strip.setPixelColor(wrap(center + step), Wheel(color, pow(fadeRate, step))); leds[wrap(center - step)] = CHSV(color, 255, pow(fadeRate, step) * 255); // strip.setPixelColor(wrap(center - step), Wheel(color, pow(fadeRate, step))); if (step > 3) { leds[wrap(center + step - 3)] = CHSV(color, 255, pow(fadeRate, step - 2) * 255); // strip.setPixelColor(wrap(center + step - 3), Wheel(color, pow(fadeRate, step - 2))); leds[wrap(center - step + 3)] = CHSV(color, 255, pow(fadeRate, step - 2) * 255); // strip.setPixelColor(wrap(center - step + 3), Wheel(color, pow(fadeRate, step - 2))); } step ++; } else { step = -1; } } LEDS.show(); delay(50); } int wrap(int step) { if (step < 0) return N_PIXELS + step; if (step > N_PIXELS - 1) return step - N_PIXELS; return step; } void one_color_allHSV(int ahue, int abright) { // SET ALL LEDS TO ONE COLOR (HSV) for (int i = 0 ; i < N_PIXELS; i++ ) { leds[i] = CHSV(ahue, 255, abright); } } void ripple2() { if (BG) { if (currentBg == nextBg) { nextBg = random(256); } else if (nextBg > currentBg) { currentBg++; } else { currentBg--; } for (uint16_t l = 0; l < N_PIXELS; l++) { strip.setPixelColor(l, Wheel(currentBg, 0.1)); } } else { for (uint16_t l = 0; l < N_PIXELS; l++) { strip.setPixelColor(l, 0, 0, 0); } } if (step == -1) { center = random(N_PIXELS); color = random(256); step = 0; } if (step == 0) { strip.setPixelColor(center, Wheel(color, 1)); step ++; } else { if (step < maxSteps) { strip.setPixelColor(wrap(center + step), Wheel(color, pow(fadeRate, step))); strip.setPixelColor(wrap(center - step), Wheel(color, pow(fadeRate, step))); if (step > 3) { strip.setPixelColor(wrap(center + step - 3), Wheel(color, pow(fadeRate, step - 2))); strip.setPixelColor(wrap(center - step + 3), Wheel(color, pow(fadeRate, step - 2))); } step ++; } else { step = -1; } } strip.show(); delay(50); } // 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, float opacity) { if (WheelPos < 85) { return strip.Color((WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity, 0); } else if (WheelPos < 170) { WheelPos -= 85; return strip.Color((255 - WheelPos * 3) * opacity, 0, (WheelPos * 3) * opacity); } else { WheelPos -= 170; return strip.Color(0, (WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity); } } void pattern2() { sinelon(); // Call our sequence. show_at_max_brightness_for_power(); // Power managed display of LED's. } // loop() void sinelon() { // a colored dot sweeping back and forth, with fading trails fadeToBlackBy( leds, N_PIXELS, thisfade); int pos1 = beatsin16(thisbeat, 0, N_PIXELS); int pos2 = beatsin16(thatbeat, 0, N_PIXELS); leds[(pos1 + pos2) / 2] += CHSV( myhue++ / 64, thissat, thisbri); } // Pattern 3 - JUGGLE void pattern3() { ChangeMe(); juggle(); show_at_max_brightness_for_power(); // Power managed display of LED's. } // loop() void juggle() { // Several colored dots, weaving in and out of sync with each other curhue = thishue; // Reset the hue values. fadeToBlackBy(leds, N_PIXELS, faderate); for ( int i = 0; i < numdots; i++) { leds[beatsin16(basebeat + i + numdots, 0, N_PIXELS)] += CHSV(curhue, thissat, thisbright); //beat16 is a FastLED 3.1 function curhue += hueinc; } } // juggle() void ChangeMe() { // A time (rather than loop) based demo sequencer. This gives us full control over the length of each sequence. uint8_t secondHand = (millis() / 1000) % 30; // IMPORTANT!!! Change '30' to a different value to change duration of the loop. static uint8_t lastSecond = 99; // Static variable, means it's only defined once. This is our 'debounce' variable. if (lastSecond != secondHand) { // Debounce to make sure we're not repeating an assignment. lastSecond = secondHand; if (secondHand == 0) { numdots = 1; // You can change values here, one at a time , or altogether. faderate = 2; } if (secondHand == 10) { numdots = 4; thishue = 128; faderate = 8; } if (secondHand == 20) { hueinc = 48; // Only gets called once, and not continuously for the next several seconds. Therefore, no rainbows. thishue = random8(); } } } // ChangeMe() void Twinkle () { if (random(25) == 1) { uint16_t i = random(N_PIXELS); if (redStates[i] < 1 && greenStates[i] < 1 && blueStates[i] < 1) { redStates[i] = random(256); greenStates[i] = random(256); blueStates[i] = random(256); } } for (uint16_t l = 0; l < N_PIXELS; l++) { if (redStates[l] > 1 || greenStates[l] > 1 || blueStates[l] > 1) { strip.setPixelColor(l, redStates[l], greenStates[l], blueStates[l]); if (redStates[l] > 1) { redStates[l] = redStates[l] * Fade; } else { redStates[l] = 0; } if (greenStates[l] > 1) { greenStates[l] = greenStates[l] * Fade; } else { greenStates[l] = 0; } if (blueStates[l] > 1) { blueStates[l] = blueStates[l] * Fade; } else { blueStates[l] = 0; } } else { strip.setPixelColor(l, 0, 0, 0); } } strip.show(); delay(10); } // TOO HERE 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(); // check if a button pressed if (Pattern != nPatterns) // <------------- add this return; // <------------ and this delay(wait); } } // List of patterns to cycle through. Each is defined as a separate function below. typedef void (*SimplePatternList[])(); SimplePatternList qPatterns = {vu, vu2, Vu3, Vu4, Twinkle, pattern3, pattern2, ripple2, ripple, Balls}; uint8_t qCurrentPatternNumber = 0; // Index number of which pattern is current void nextPattern() { // add one to the current pattern number, and wrap around at the end qCurrentPatternNumber = (qCurrentPatternNumber + 1) % ARRAY_SIZE( qPatterns); } void All() { // Call the current pattern function once, updating the 'leds' array qPatterns[qCurrentPatternNumber](); EVERY_N_MINUTES( 1 ) { nextPattern(); // change patterns periodically } }

---

Login or Register to edit or fork this paste. It's free.