Create utils.h

Author: TheKitty

GemmaM0_Band_Jacket/DiscoBandCamp/utils.h

@@ -0,0 +1,181 @@
+// Assorted useful functions and variables
+
+// Global variables
+boolean effectInit = false;   // indicates if a pattern has been recently switched
+uint16_t effectDelay = 0;   // time between automatic effect changes
+unsigned long effectMillis = 0;   // store the time of last effect function run
+unsigned long cycleMillis = 0;    // store the time of last effect change
+unsigned long currentMillis;    // store current loop's millis value
+unsigned long hueMillis;    // store time of last hue change
+byte currentEffect = 0;   // index to the currently running effect
+boolean autoCycle = true;   // flag for automatic effect changes
+byte currentBrightness = STARTBRIGHTNESS;   // 0-255 will be scaled to 0-MAXBRIGHTNESS
+
+
+//  Setup information for the NoisePlusPalette noiseplay example
+#define MAX_DIMENSION ((kMatrixWidth>kMatrixHeight) ? kMatrixWidth : kMatrixHeight)
+uint16_t speed = 5; 
+uint16_t scale = 30;
+uint8_t noise[MAX_DIMENSION][MAX_DIMENSION];
+
+// The 16 bit version of our coordinates
+static uint16_t x;
+static uint16_t y;
+static uint16_t z;
+uint8_t       colorLoop = 1;
+
+
+CRGBPalette16 currentPalette(RainbowColors_p); // global palette storage
+
+typedef void (*functionList)(); // definition for list of effect function pointers
+extern const byte numEffects;
+
+// Increment the global hue value for functions that use it
+byte cycleHue = 0;
+byte cycleHueCount = 0;
+void hueCycle(byte incr) {
+    cycleHueCount = 0;
+    cycleHue+=incr;
+}
+
+// Set every LED in the array to a specified color
+void fillAll(CRGB fillColor) {
+  for (byte i = 0; i < NUM_LEDS; i++) {
+    leds[i] = fillColor;
+  }
+}
+
+// Fade every LED in the array by a specified amount
+void fadeAll(byte fadeIncr) {
+  for (byte i = 0; i < NUM_LEDS; i++) {
+    leds[i] = leds[i].fadeToBlackBy(fadeIncr);
+  }
+}
+
+// Shift all pixels by one, right or left (0 or 1)
+void scrollArray(byte scrollDir) {
+  
+    byte scrollX = 0;
+    for (byte x = 1; x < kMatrixWidth; x++) {
+      if (scrollDir == 0) {
+        scrollX = kMatrixWidth - x;
+      } else if (scrollDir == 1) {
+        scrollX = x - 1;
+      }
+      
+      for (byte y = 0; y < kMatrixHeight; y++) {
+        leds[XY(scrollX,y)] = leds[XY(scrollX + scrollDir*2 - 1,y)];
+      }
+    }
+  
+}
+
+
+// Pick a random palette from a list
+void selectRandomPalette() {
+
+  switch(random8(8)) {
+    case 0:
+    currentPalette = CloudColors_p;
+    break;
+    
+    case 1:
+    currentPalette = LavaColors_p;
+    break;
+    
+    case 2:
+    currentPalette = OceanColors_p;
+    break;
+    
+    case 4:
+    currentPalette = ForestColors_p;
+    break;
+    
+    case 5:
+    currentPalette = RainbowColors_p;
+    break;
+    
+    case 6:
+    currentPalette = PartyColors_p;
+    break;
+    
+    case 7:
+    currentPalette = HeatColors_p;
+    break;
+  }
+
+}
+
+ // Fill the x/y array of 8-bit noise values using the inoise8 function.
+void fillnoise8() {
+  // If we're runing at a low "speed", some 8-bit artifacts become visible
+  // from frame-to-frame.  In order to reduce this, we can do some fast data-smoothing.
+  // The amount of data smoothing we're doing depends on "speed".
+  uint8_t dataSmoothing = 0;
+  if( speed < 50) {
+    dataSmoothing = 200 - (speed * 4);
+  }
+  
+  for(int i = 0; i < MAX_DIMENSION; i++) {
+    int ioffset = scale * i;
+    for(int j = 0; j < MAX_DIMENSION; j++) {
+      int joffset = scale * j;
+      
+      uint8_t data = inoise8(x + ioffset,y + joffset,z);
+
+      // The range of the inoise8 function is roughly 16-238.
+      // These two operations expand those values out to roughly 0..255
+      // You can comment them out if you want the raw noise data.
+      data = qsub8(data,16);
+      data = qadd8(data,scale8(data,39));
+
+      if( dataSmoothing ) {
+        uint8_t olddata = noise[i][j];
+        uint8_t newdata = scale8( olddata, dataSmoothing) + scale8( data, 256 - dataSmoothing);
+        data = newdata;
+      }
+      
+      noise[i][j] = data;
+    }
+  }
+  
+  z += speed;
+  
+  // apply slow drift to X and Y, just for visual variation.
+  x += speed / 8;
+  y -= speed / 16;
+}
+
+void mapNoiseToLEDsUsingPalette()
+{
+  static uint8_t ihue=0;
+  
+  for(int i = 0; i < kMatrixWidth; i++) {
+    for(int j = 0; j < kMatrixHeight; j++) {
+      // We use the value at the (i,j) coordinate in the noise
+      // array for our brightness, and the flipped value from (j,i)
+      // for our pixel's index into the color palette.
+
+      uint8_t index = noise[j][i];
+      uint8_t bri =   noise[i][j];
+
+      // if this palette is a 'loop', add a slowly-changing base value
+      if( colorLoop) { 
+        index += ihue;
+      }
+
+      // brighten up, as the color palette itself often contains the 
+      // light/dark dynamic range desired
+      if( bri > 127 ) {
+        bri = 255;
+      } else {
+        bri = dim8_raw( bri * 2);
+      }
+
+      CRGB color = ColorFromPalette( currentPalette, index, bri);
+      leds[XY(i,j)] = color;
+    }
+  }
+  
+  ihue+=1;
+}