Compare text

Find the difference between two text files

Real-time editor

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 11 years agoDiff never expires

0 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

267 lines

1 addition

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

267 lines

#include "FastLED/FastLED.h"

FASTLED_USING_NAMESPACE;

#define bitRead(value, bit) (((value) >> (bit)) & 0x01)

#define bitSet(value, bit) ((value) |= (1UL << (bit)))

#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))

#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))

#define LED_PIN D0

#define LED_TYPE WS2811

#define COLOR_ORDER GRB

#define NUM_LEDS 512

CRGB leds[NUM_LEDS];

#define MICROPHONE 12

#define GAIN_CONTROL 11

void brightenOrDarkenEachPixel( fract8 fadeUpAmount, fract8 fadeDownAmount);

CRGB makeBrighter( const CRGB& color, fract8 howMuchBrighter);

CRGB makeDarker( const CRGB& color, fract8 howMuchDarker);

// Twinkling 'holiday' lights that fade up and down in brightness.

// Colors are chosen from a palette; a few palettes are provided.

// The basic operation is that all pixels stay black until they

// are 'seeded' with a relatively dim color. The dim colors

// are repeatedly brightened until they reach full brightness, then

// are darkened repeatedly until they are fully black again.

// A set of 'directionFlags' is used to track whether a given

// pixel is presently brightening up or darkening down.

// For illustration purposes, two implementations of directionFlags

// are provided: a simple one-byte-per-pixel flag, and a more

// complicated, more compact one-BIT-per-pixel flag.

// Darkening colors accurately is relatively easy: scale down the

// existing color channel values. Brightening colors is a bit more

// error prone, as there's some loss of precision. If your colors

// aren't coming our 'right' at full brightness, try increasing the

// STARTING_BRIGHTNESS value.

// -Mark Kriegsman, December 2014

#define MASTER_BRIGHTNESS 200

#define STARTING_BRIGHTNESS 64

#define FADE_IN_SPEED 32

#define FADE_OUT_SPEED 60

#define DENSITY 255

void setup() {

delay(3000);

FastLED.addLeds<LED_TYPE,LED_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);

FastLED.setBrightness(MASTER_BRIGHTNESS);

initMicrophone();

// analogReference(DEFAULT);

// Serial.begin(57600);

}

void initMicrophone()

{

pinMode(GAIN_CONTROL, OUTPUT);

digitalWrite(GAIN_CONTROL, LOW);

}

CRGBPalette16 gPalette;

int readMaxSound( uint8_t ms)

{

uint32_t startms = millis();

while( millis() == startms) {};

startms = millis();

int maxvol = 0;

while( (startms + ms) > millis()) {

// int mic = analogRead(MICROPHONE)-512;

int mic = analogRead(MICROPHONE);

if( mic < 0) mic = 0-mic;

if( mic > maxvol) maxvol = mic;

}

return maxvol;

}

void loop()

{

chooseColorPalette();

colortwinkles();

// delay(2);

// int mic = readMaxSound(10);

// mic /= 2;

// mic = dim8_raw( mic);

// // Serial.println(mic);

// static int avgmic = 0;

// avgmic = ((avgmic * 3) + mic) / 4;

// mic = avgmic;

// delay(2);

// if( mic > 0) {

// for( int j = 0; j < mic; j++) {

// leds[random16(NUM_LEDS)] = ColorFromPalette( gPalette, random8());

// }

FastLED.show();

// FastLED.delay(1);

}

void chooseColorPalette()

{

uint8_t numberOfPalettes = 9;

uint8_t secondsPerPalette = 60;

uint8_t whichPalette = (millis()/(1000*secondsPerPalette)) % numberOfPalettes;

CRGB r(CRGB::Red), b(CRGB::Blue), w(85,85,85), g(CRGB::Green), W(CRGB::White), l(CRGB::FairyLight);

whichPalette = 8;

//whichPalette = 8;

switch( whichPalette) {

case 0: // Red, Green, and White

gPalette = CRGBPalette16( r,r,r,r, r,r,r,r, g,g,g,g, w,w,w,w );

break;

case 1: // Blue and White

//gPalette = CRGBPalette16( b,b,b,b, b,b,b,b, w,w,w,w, w,w,w,w );

gPalette = CloudColors_p; // Blues and whites!

break;

case 2: // Rainbow of colors

gPalette = RainbowColors_p;

break;

case 3: // Incandescent "fairy lights"

gPalette = CRGBPalette16( l,l,l,l, l,l,l,l, l,l,l,l, l,l,l,l );

break;

case 4: // Snow

gPalette = CRGBPalette16( W,W,W,W, w,w,w,w, w,w,w,w, w,w,w,w );

break;

case 5:

gPalette = LavaColors_p;

break;

case 6:

gPalette = ForestColors_p;

break;

case 7:

gPalette = PartyColors_p;

break;

case 8:

uint8_t h = beatsin8(1);

gPalette = CHSVPalette16( CHSV(h,255,255), CHSV(h+32, 255,255));

break;

}

enum { GETTING_DARKER = 0, GETTING_BRIGHTER = 1 };

void colortwinkles()

{

// Make each pixel brighter or darker, depending on

// its 'direction' flag.

brightenOrDarkenEachPixel( FADE_IN_SPEED, FADE_OUT_SPEED);

// Now consider adding a new random twinkle

if( random8() < DENSITY ) {

int pos = random16(NUM_LEDS);

if( leds[pos] ) pos = random16(NUM_LEDS);

if( !leds[pos]) {

leds[pos] = ColorFromPalette( gPalette, random8(), STARTING_BRIGHTNESS, NOBLEND);

setPixelDirection(pos, GETTING_BRIGHTER);

}

void brightenOrDarkenEachPixel( fract8 fadeUpAmount, fract8 fadeDownAmount)

{

for( uint16_t i = 0; i < NUM_LEDS; i++) {

if( getPixelDirection(i) == GETTING_DARKER) {

// This pixel is getting darker

leds[i] = makeDarker( leds[i], fadeDownAmount);

} else {

// This pixel is getting brighter

leds[i] = makeBrighter( leds[i], fadeUpAmount);

// now check to see if we've maxxed out the brightness

if( leds[i].r == 255 || leds[i].g == 255 || leds[i].b == 255) {

// if so, turn around and start getting darker

setPixelDirection(i, GETTING_DARKER);

}

CRGB makeBrighter( const CRGB& color, fract8 howMuchBrighter)

{

CRGB incrementalColor = color;

incrementalColor.nscale8( howMuchBrighter);

return color + incrementalColor;

}

CRGB makeDarker( const CRGB& color, fract8 howMuchDarker)

{

CRGB newcolor = color;

newcolor.nscale8( 255 - howMuchDarker);

return newcolor;

}

// For illustration purposes, there are two separate implementations

// provided here for the array of 'directionFlags':

// - a simple one, which uses one byte (8 bits) of RAM for each pixel, and

// - a compact one, which uses just one BIT of RAM for each pixel.

// Set this to 1 or 8 to select which implementation

// of directionFlags is used. 1=more compact, 8=simpler.

#define BITS_PER_DIRECTION_FLAG 1

#if BITS_PER_DIRECTION_FLAG == 8

// Simple implementation of the directionFlags array,

// which takes up one byte (eight bits) per pixel.

uint8_t directionFlags[NUM_LEDS];

bool getPixelDirection( uint16_t i) {

return directionFlags[i];

}

void setPixelDirection( uint16_t i, bool dir) {

directionFlags[i] = dir;

}

#endif

#if BITS_PER_DIRECTION_FLAG == 1

// Compact (but more complicated) implementation of

// the directionFlags array, using just one BIT of RAM

// per pixel. This requires a bunch of bit wrangling,

// but conserves precious RAM. The cost is a few

// cycles and about 100 bytes of flash program memory.

uint8_t directionFlags[ (NUM_LEDS+7) / 8];

bool getPixelDirection( uint16_t i) {

uint16_t index = i / 8;

uint8_t bitNum = i & 0x07;

// using Arduino 'bitRead' function; expanded code below

return bitRead( directionFlags[index], bitNum);

// uint8_t andMask = 1 << bitNum;

// return (directionFlags[index] & andMask) != 0;

}

void setPixelDirection( uint16_t i, bool dir) {

uint16_t index = i / 8;

uint8_t bitNum = i & 0x07;

// using Arduino 'bitWrite' function; expanded code below

bitWrite( directionFlags[index], bitNum, dir);

// uint8_t orMask = 1 << bitNum;

// uint8_t andMask = 255 - orMask;

// uint8_t value = directionFlags[index] & andMask;

// if( dir ) {

// value += orMask;

// }

// directionFlags[index] = value;

}

#endif

Saved diffs

Original text

Open file

#include "FastLED/FastLED.h"
FASTLED_USING_NAMESPACE;

#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))

#define LED_PIN     D0
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
#define NUM_LEDS    512
CRGB leds[NUM_LEDS];

#define MICROPHONE 12
#define GAIN_CONTROL 11

void brightenOrDarkenEachPixel( fract8 fadeUpAmount, fract8 fadeDownAmount);
CRGB makeBrighter( const CRGB& color, fract8 howMuchBrighter);
CRGB makeDarker( const CRGB& color, fract8 howMuchDarker);

//  Twinkling 'holiday' lights that fade up and down in brightness.
//  Colors are chosen from a palette; a few palettes are provided.
//
//  The basic operation is that all pixels stay black until they
//  are 'seeded' with a relatively dim color.  The dim colors
//  are repeatedly brightened until they reach full brightness, then
//  are darkened repeatedly until they are fully black again.
//
//  A set of 'directionFlags' is used to track whether a given
//  pixel is presently brightening up or darkening down.
//
//  For illustration purposes, two implementations of directionFlags
//  are provided: a simple one-byte-per-pixel flag, and a more
//  complicated, more compact one-BIT-per-pixel flag.
//
//  Darkening colors accurately is relatively easy: scale down the 
//  existing color channel values.  Brightening colors is a bit more
//  error prone, as there's some loss of precision.  If your colors
//  aren't coming our 'right' at full brightness, try increasing the
//  STARTING_BRIGHTNESS value.
//
//  -Mark Kriegsman, December 2014

#define MASTER_BRIGHTNESS   200

#define STARTING_BRIGHTNESS 64
#define FADE_IN_SPEED       32
#define FADE_OUT_SPEED      60
#define DENSITY            255

void setup() {
  delay(3000);
  FastLED.addLeds<LED_TYPE,LED_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.setBrightness(MASTER_BRIGHTNESS);
  initMicrophone();
//  analogReference(DEFAULT);
//  Serial.begin(57600);
}

void initMicrophone()
{
  pinMode(GAIN_CONTROL, OUTPUT);
  digitalWrite(GAIN_CONTROL, LOW);
}

CRGBPalette16 gPalette;

int readMaxSound( uint8_t ms)
{
  uint32_t startms = millis();
  
  while( millis() == startms) {};
  
  startms = millis();
  
  int maxvol = 0;
  while( (startms + ms) > millis()) {
//    int mic = analogRead(MICROPHONE)-512;
    int mic = analogRead(MICROPHONE);
    if( mic < 0) mic = 0-mic;
    if( mic > maxvol) maxvol = mic;
  }
  return maxvol;
}

void loop()
{
  chooseColorPalette();
  colortwinkles();
//  delay(2);
//   int mic = readMaxSound(10);
//   mic /= 2;
//   mic = dim8_raw( mic);
//   mic = dim8_raw( mic);

// //  Serial.println(mic);

//   static int avgmic = 0;
//   avgmic = ((avgmic * 3) + mic) / 4; 
  
//   mic = avgmic;
  
//  delay(2);
//   if( mic > 0) {
//     for( int j = 0; j < mic; j++) {
//       leds[random16(NUM_LEDS)] = ColorFromPalette( gPalette, random8());
//     }
//   }
  
  FastLED.show();  
//  FastLED.delay(1);
}

void chooseColorPalette()
{
  uint8_t numberOfPalettes = 9;
  uint8_t secondsPerPalette = 60;
  uint8_t whichPalette = (millis()/(1000*secondsPerPalette)) % numberOfPalettes;

CRGB r(CRGB::Red), b(CRGB::Blue), w(85,85,85), g(CRGB::Green), W(CRGB::White), l(CRGB::FairyLight);

whichPalette = 8;
  switch( whichPalette) {  
    case 0: // Red, Green, and White
      gPalette = CRGBPalette16( r,r,r,r, r,r,r,r, g,g,g,g, w,w,w,w ); 
      break;
    case 1: // Blue and White
      //gPalette = CRGBPalette16( b,b,b,b, b,b,b,b, w,w,w,w, w,w,w,w ); 
      gPalette = CloudColors_p; // Blues and whites!
      break;
    case 2: // Rainbow of colors
      gPalette = RainbowColors_p;
      break;
    case 3: // Incandescent "fairy lights"
      gPalette = CRGBPalette16( l,l,l,l, l,l,l,l, l,l,l,l, l,l,l,l );
      break;
    case 4: // Snow
      gPalette = CRGBPalette16( W,W,W,W, w,w,w,w, w,w,w,w, w,w,w,w );
      break;
    case 5:
      gPalette = LavaColors_p;
      break;
    case 6: 
      gPalette = ForestColors_p;
      break;
    case 7: 
      gPalette = PartyColors_p;
      break;
    case 8: 
      uint8_t h = beatsin8(1);
      gPalette = CHSVPalette16( CHSV(h,255,255), CHSV(h+32, 255,255));
      break;
  }
}

enum { GETTING_DARKER = 0, GETTING_BRIGHTER = 1 };

void colortwinkles()
{
  // Make each pixel brighter or darker, depending on
  // its 'direction' flag.
  brightenOrDarkenEachPixel( FADE_IN_SPEED, FADE_OUT_SPEED);
  
  // Now consider adding a new random twinkle
  if( random8() < DENSITY ) {
    int pos = random16(NUM_LEDS);
    if( leds[pos] ) pos = random16(NUM_LEDS);
    if( !leds[pos]) {
      leds[pos] = ColorFromPalette( gPalette, random8(), STARTING_BRIGHTNESS, NOBLEND);
      setPixelDirection(pos, GETTING_BRIGHTER);
    }
  }
}

void brightenOrDarkenEachPixel( fract8 fadeUpAmount, fract8 fadeDownAmount)
{
for( uint16_t i = 0; i < NUM_LEDS; i++) {
    if( getPixelDirection(i) == GETTING_DARKER) {
      // This pixel is getting darker
      leds[i] = makeDarker( leds[i], fadeDownAmount);
    } else {
      // This pixel is getting brighter
      leds[i] = makeBrighter( leds[i], fadeUpAmount);
      // now check to see if we've maxxed out the brightness
      if( leds[i].r == 255 || leds[i].g == 255 || leds[i].b == 255) {
        // if so, turn around and start getting darker
        setPixelDirection(i, GETTING_DARKER);
      }
    }
  }
}

CRGB makeBrighter( const CRGB& color, fract8 howMuchBrighter) 
{
  CRGB incrementalColor = color;
  incrementalColor.nscale8( howMuchBrighter);
  return color + incrementalColor;
}

CRGB makeDarker( const CRGB& color, fract8 howMuchDarker) 
{
  CRGB newcolor = color;
  newcolor.nscale8( 255 - howMuchDarker);
  return newcolor;
}

// For illustration purposes, there are two separate implementations
// provided here for the array of 'directionFlags': 
// - a simple one, which uses one byte (8 bits) of RAM for each pixel, and
// - a compact one, which uses just one BIT of RAM for each pixel.

// Set this to 1 or 8 to select which implementation
// of directionFlags is used.  1=more compact, 8=simpler.
#define BITS_PER_DIRECTION_FLAG 1

#if BITS_PER_DIRECTION_FLAG == 8
// Simple implementation of the directionFlags array,
// which takes up one byte (eight bits) per pixel.
uint8_t directionFlags[NUM_LEDS];

bool getPixelDirection( uint16_t i) {
  return directionFlags[i];
}

void setPixelDirection( uint16_t i, bool dir) {
  directionFlags[i] = dir;
}
#endif

#if BITS_PER_DIRECTION_FLAG == 1
// Compact (but more complicated) implementation of
// the directionFlags array, using just one BIT of RAM
// per pixel.  This requires a bunch of bit wrangling,
// but conserves precious RAM.  The cost is a few
// cycles and about 100 bytes of flash program memory.
uint8_t  directionFlags[ (NUM_LEDS+7) / 8];

bool getPixelDirection( uint16_t i) {
  uint16_t index = i / 8;
  uint8_t  bitNum = i & 0x07;
  // using Arduino 'bitRead' function; expanded code below
  return bitRead( directionFlags[index], bitNum);
  // uint8_t  andMask = 1 << bitNum;
  // return (directionFlags[index] & andMask) != 0;
}

void setPixelDirection( uint16_t i, bool dir) {
  uint16_t index = i / 8;
  uint8_t  bitNum = i & 0x07;
  // using Arduino 'bitWrite' function; expanded code below
  bitWrite( directionFlags[index], bitNum, dir);
  //  uint8_t  orMask = 1 << bitNum;
  //  uint8_t andMask = 255 - orMask;
  //  uint8_t value = directionFlags[index] & andMask;
  //  if( dir ) {
  //    value += orMask;
  //  }
  //  directionFlags[index] = value;
}
#endif

Changed text

Open file

#include "FastLED/FastLED.h"
FASTLED_USING_NAMESPACE;

#define LED_PIN     D0
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
#define NUM_LEDS    512
CRGB leds[NUM_LEDS];

#define MICROPHONE 12
#define GAIN_CONTROL 11

void brightenOrDarkenEachPixel( fract8 fadeUpAmount, fract8 fadeDownAmount);
CRGB makeBrighter( const CRGB& color, fract8 howMuchBrighter);
CRGB makeDarker( const CRGB& color, fract8 howMuchDarker);

#define MASTER_BRIGHTNESS   200

#define STARTING_BRIGHTNESS 64
#define FADE_IN_SPEED       32
#define FADE_OUT_SPEED      60
#define DENSITY            255

void initMicrophone()
{
  pinMode(GAIN_CONTROL, OUTPUT);
  digitalWrite(GAIN_CONTROL, LOW);
}

CRGBPalette16 gPalette;

void loop()
{
  chooseColorPalette();
  colortwinkles();
//  delay(2);
//   int mic = readMaxSound(10);
//   mic /= 2;
//   mic = dim8_raw( mic);
//   mic = dim8_raw( mic);

// //  Serial.println(mic);

void chooseColorPalette()
{
  uint8_t numberOfPalettes = 9;
  uint8_t secondsPerPalette = 60;
  uint8_t whichPalette = (millis()/(1000*secondsPerPalette)) % numberOfPalettes;

CRGB r(CRGB::Red), b(CRGB::Blue), w(85,85,85), g(CRGB::Green), W(CRGB::White), l(CRGB::FairyLight);

//whichPalette = 8;
  switch( whichPalette) {  
    case 0: // Red, Green, and White
      gPalette = CRGBPalette16( r,r,r,r, r,r,r,r, g,g,g,g, w,w,w,w ); 
      break;
    case 1: // Blue and White
      //gPalette = CRGBPalette16( b,b,b,b, b,b,b,b, w,w,w,w, w,w,w,w ); 
      gPalette = CloudColors_p; // Blues and whites!
      break;
    case 2: // Rainbow of colors
      gPalette = RainbowColors_p;
      break;
    case 3: // Incandescent "fairy lights"
      gPalette = CRGBPalette16( l,l,l,l, l,l,l,l, l,l,l,l, l,l,l,l );
      break;
    case 4: // Snow
      gPalette = CRGBPalette16( W,W,W,W, w,w,w,w, w,w,w,w, w,w,w,w );
      break;
    case 5:
      gPalette = LavaColors_p;
      break;
    case 6: 
      gPalette = ForestColors_p;
      break;
    case 7: 
      gPalette = PartyColors_p;
      break;
    case 8: 
      uint8_t h = beatsin8(1);
      gPalette = CHSVPalette16( CHSV(h,255,255), CHSV(h+32, 255,255));
      break;
  }
}

enum { GETTING_DARKER = 0, GETTING_BRIGHTER = 1 };

CRGB makeBrighter( const CRGB& color, fract8 howMuchBrighter) 
{
  CRGB incrementalColor = color;
  incrementalColor.nscale8( howMuchBrighter);
  return color + incrementalColor;
}

CRGB makeDarker( const CRGB& color, fract8 howMuchDarker) 
{
  CRGB newcolor = color;
  newcolor.nscale8( 255 - howMuchDarker);
  return newcolor;
}

// Set this to 1 or 8 to select which implementation
// of directionFlags is used.  1=more compact, 8=simpler.
#define BITS_PER_DIRECTION_FLAG 1

#if BITS_PER_DIRECTION_FLAG == 8
// Simple implementation of the directionFlags array,
// which takes up one byte (eight bits) per pixel.
uint8_t directionFlags[NUM_LEDS];

bool getPixelDirection( uint16_t i) {
  return directionFlags[i];
}

void setPixelDirection( uint16_t i, bool dir) {
  directionFlags[i] = dir;
}
#endif