Merge pull request #5 from adafruit/esp32s3

Add ESP32S3 support and NeoPXL8HDR class

Author: PaintYourDragon

.github/workflows/githubci.yml

@@ -20,7 +20,7 @@ jobs:
       run: bash ci/actions_install.sh
 
     - name: test platforms
-      run: python3 ci/build_platform.py feather_m0_express metro_m4 pico_rp2040
+      run: python3 ci/build_platform.py feather_m0_express_tinyusb metro_m4_tinyusb pico_rp2040_tinyusb feather_esp32s3
 
     - name: clang
       run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r . 

Adafruit_NeoPXL8.cpp

@@ -1,5 +1,5 @@
 # Adafruit_NeoPXL8
-DMA-driven 8-way concurrent NeoPixel driver for SAMD21 (M0+), SAMD51 (M4) and RP2040 microcontrollers. Requires latest Adafruit_NeoPixel and Adafruit_ZeroDMA libraries.
+DMA-driven 8-way concurrent NeoPixel driver for SAMD21 (M0+), SAMD51 (M4), RP2040 and ESP32S3 microcontrollers. Requires latest Adafruit_NeoPixel and Adafruit_ZeroDMA libraries.
 
 (Pronounced "NeoPixelate")
 
@@ -43,3 +43,11 @@ Other boards (such as Grand Central) have an altogether different pinout. See th
 Pin MUXing is a hairy thing and over time we'll try to build up some ready-to-use examples for different boards and peripherals. You can also try picking your way through the SAMD21/51 datasheet or the NeoPXL8 source code for pin/peripheral assignments.
 
 On RP2040 boards, the pins can be within any 8-pin range (e.g. 0-7, or 4-11, etc.). If using fewer than 8 outputs, they do not need to be contiguous, but the lowest and highest pin number must still be within 8-pin range.
+
+On ESP32S3 boards, go wild...there are no pin restrictions.
+
+## NeoPXL8HDR
+
+Adafruit_NeoPXL8HDR is a subclass of Adafruit_NeoPXL8 with additions for 16-bit color, temporal dithering, gamma correction and frame blending. This requires inordinate RAM, and the need for frequent refreshing makes it best suited for multi-core chips (e.g. RP2040).
+
+See examples/NeoPXL8HDR/strandtest for use.

Adafruit_NeoPXL8.h

@@ -0,0 +1,128 @@
+// FIRST TIME HERE? START WITH THE NEOPXL8 strandtest EXAMPLE INSTEAD!
+// That code explains and helps troubshoot wiring and NeoPixel color format.
+
+#include <Adafruit_NeoPXL8.h>
+
+// CHANGE these to match your strandtest findings or this WILL NOT WORK:
+
+int8_t pins[8] = { 6, 7, 9, 8, 13, 12, 11, 10 };
+#define COLOR_ORDER NEO_GRB
+
+// This example is minimally adapted from one in PJRC's OctoWS2811 Library:
+
+// Animated Fire Example - OctoWS2811 Library
+//  http://www.pjrc.com/teensy/td_libs_OctoWS2811.html
+//
+// Based on the simple algorithm explained here:
+//  http://caraesnaur.github.io/fire/
+//
+// This example code is in the public domain.
+
+const unsigned int width = 30;
+const unsigned int height = 16; // Each strand spans two successive rows
+
+// These parameters control the fire appearance
+// (try controlling these with knobs / analogRead....)
+unsigned int heat = width / 5;
+unsigned int focus = 9;
+unsigned int cool = 26;
+
+const int ledsPerPin = width * height / 8;
+Adafruit_NeoPXL8 leds(ledsPerPin, pins, COLOR_ORDER);
+
+// Arrays for fire animation
+unsigned char canvas[width*height];
+extern const unsigned int fireColor[100];
+
+// Run setup once
+void setup() {
+  if (!leds.begin()) {
+    pinMode(LED_BUILTIN, OUTPUT);
+    for (;;) digitalWrite(LED_BUILTIN, (millis() / 500) & 1);
+  }
+  leds.show(); // Clear initial LED state
+}
+
+// A simple xy() function to turn display matrix coordinates
+// into the index numbers NeoPXL8 requires.  If your LEDs
+// are arranged differently, edit this code...
+unsigned int xy(unsigned int x, unsigned int y) {
+  if ((y & 1) == 0) {
+    // even numbered rows (0, 2, 4...) are left to right
+    return y * width + x;
+  } else {
+    // odd numbered rows (1, 3, 5...) are right to left
+    return y * width + width - 1 - x;
+  }
+}
+
+uint32_t lastTime = 0;
+
+// Run repetitively
+void loop() {
+  uint32_t now = millis();
+  if (now - lastTime >= 45) {
+    lastTime = now;
+    animateFire();
+  }
+}
+
+void animateFire() {
+  unsigned int i, c, n, x, y;
+
+  // Step 1: move all data up one line
+  memmove(canvas + width, canvas, width * (height - 1));
+  memset(canvas, 0, width);
+
+  // Step 2: draw random heatspots on bottom line
+  i = heat;
+  if (i > width-8) i = width-8;
+  while (i > 0) {
+    x = random(width - 2) + 1;
+    if (canvas[x] == 0) {
+      canvas[x] = 99;
+      i--;
+    }
+  }
+
+  // Step 3: interpolate
+  for (y=0; y < height; y++) {
+    for (x=0; x < width; x++) {
+      c = canvas[y * width + x] * focus;
+      n = focus;
+      if (x > 0) {
+        c = c + canvas[y * width + (x - 1)];
+        n = n + 1;
+      }
+      if (x < width-1) {
+        c = c + canvas[y * width + (x + 1)];
+        n = n + 1;
+      }
+      if (y > 0) {
+        c = c + canvas[(y -1) * width + x];
+        n = n + 1;
+      }
+      if (y < height-1) {
+        c = c + canvas[(y + 1) * width + x];
+        n = n + 1;
+      }
+      c = (c + (n / 2)) / n;
+      i = (random(1000) * cool) / 10000;
+      if (c > i) {
+        c = c - i;
+      } else {
+        c = 0;
+      }
+      canvas[y * width + x] = c;
+    }
+  }
+
+  // Step 4: render canvas to LEDs
+  for (y=0; y < height; y++) {
+    for (x=0; x < width; x++) {
+      c = canvas[((height - 1) - y) * width + x];
+      leds.setPixelColor(xy(x, y), leds.gamma32(fireColor[c]));
+    }
+  }
+  leds.show();
+}

README.md

@@ -0,0 +1,33 @@
+// This is just the linear fireColor[] array from the original OctoWS2811
+// Fire example, since NeoPXL8 has its own gamma function.
+
+extern const unsigned int fireColor[100];
+
+#define RGB(r, g, b) (((r) << 16) | ((g) << 8) | (b))
+
+const unsigned int fireColor[100] = {
+    RGB(0, 0, 0),      RGB(5, 0, 0),      RGB(10, 0, 0),     RGB(14, 0, 0),
+    RGB(19, 0, 0),     RGB(23, 0, 0),     RGB(27, 0, 0),     RGB(31, 0, 0),
+    RGB(35, 0, 0),     RGB(39, 0, 0),     RGB(43, 0, 0),     RGB(47, 0, 0),
+    RGB(51, 0, 0),     RGB(55, 0, 0),     RGB(59, 0, 0),     RGB(63, 0, 0),
+    RGB(67, 0, 0),     RGB(71, 0, 0),     RGB(75, 0, 0),     RGB(79, 0, 0),
+    RGB(83, 0, 0),     RGB(88, 0, 0),     RGB(92, 0, 0),     RGB(96, 0, 0),
+    RGB(100, 0, 0),    RGB(104, 0, 0),    RGB(108, 0, 0),    RGB(112, 0, 0),
+    RGB(116, 0, 0),    RGB(121, 0, 0),    RGB(125, 0, 0),    RGB(129, 0, 0),
+    RGB(133, 0, 0),    RGB(137, 0, 0),    RGB(141, 0, 0),    RGB(145, 0, 0),
+    RGB(149, 0, 0),    RGB(153, 0, 0),    RGB(157, 0, 0),    RGB(161, 0, 0),
+    RGB(165, 0, 0),    RGB(169, 0, 0),    RGB(173, 0, 0),    RGB(177, 0, 0),
+    RGB(181, 0, 0),    RGB(185, 0, 0),    RGB(190, 0, 0),    RGB(194, 0, 0),
+    RGB(198, 0, 0),    RGB(202, 0, 0),    RGB(205, 2, 0),    RGB(207, 6, 0),
+    RGB(209, 10, 0),   RGB(211, 14, 0),   RGB(213, 18, 0),   RGB(215, 22, 0),
+    RGB(217, 26, 0),   RGB(219, 30, 0),   RGB(221, 35, 0),   RGB(223, 39, 0),
+    RGB(225, 43, 0),   RGB(227, 47, 0),   RGB(229, 51, 0),   RGB(231, 55, 0),
+    RGB(233, 59, 0),   RGB(235, 63, 0),   RGB(237, 67, 0),   RGB(239, 71, 0),
+    RGB(241, 75, 0),   RGB(243, 79, 0),   RGB(245, 83, 0),   RGB(248, 88, 0),
+    RGB(250, 92, 0),   RGB(252, 96, 0),   RGB(254, 100, 0),  RGB(255, 105, 1),
+    RGB(255, 111, 3),  RGB(255, 117, 5),  RGB(255, 123, 7),  RGB(255, 130, 9),
+    RGB(255, 136, 11), RGB(255, 142, 13), RGB(255, 148, 15), RGB(255, 154, 17),
+    RGB(255, 160, 19), RGB(255, 166, 21), RGB(255, 172, 23), RGB(255, 179, 25),
+    RGB(255, 185, 27), RGB(255, 191, 29), RGB(255, 197, 31), RGB(255, 203, 33),
+    RGB(255, 209, 35), RGB(255, 215, 37), RGB(255, 221, 39), RGB(255, 227, 41),
+    RGB(255, 234, 44), RGB(255, 240, 46), RGB(255, 246, 48), RGB(255, 252, 50)};

examples/NeoPXL8/Fire/Fire.ino

@@ -0,0 +1,84 @@
+// FIRST TIME HERE? START WITH THE NEOPXL8 strandtest EXAMPLE INSTEAD!
+// That code explains and helps troubshoot wiring and NeoPixel color format.
+
+#include <Adafruit_NeoPXL8.h>
+
+// CHANGE these to match your strandtest findings or this WILL NOT WORK:
+
+int8_t pins[8] = { 6, 7, 9, 8, 13, 12, 11, 10 };
+#define COLOR_ORDER NEO_GRB
+
+// This example is minimally adapted from one in PJRC's OctoWS2811 Library:
+
+//PlazINT  -  Fast Plasma Generator using Integer Math Only
+//Edmund "Skorn" Horn
+//March 4,2013
+//Version 1.0 adapted for OctoWS2811Lib (tested, working...)
+
+//OctoWS2811 Defn. Stuff
+#define COLS_LEDs 30  // all of the following params need to be adjusted for screen size
+#define ROWS_LEDs 16  // LED_LAYOUT assumed 0 if ROWS_LEDs > 8
+#define LEDS_PER_STRIP (COLS_LEDs * ROWS_LEDs / 8)
+
+Adafruit_NeoPXL8 leds(LEDS_PER_STRIP, pins, COLOR_ORDER);
+
+//Byte val 2PI Cosine Wave, offset by 1 PI
+//supports fast trig calcs and smooth LED fading/pulsing.
+uint8_t const cos_wave[256] PROGMEM =
+{0,0,0,0,1,1,1,2,2,3,4,5,6,6,8,9,10,11,12,14,15,17,18,20,22,23,25,27,29,31,33,35,38,40,42,
+45,47,49,52,54,57,60,62,65,68,71,73,76,79,82,85,88,91,94,97,100,103,106,109,113,116,119,
+122,125,128,131,135,138,141,144,147,150,153,156,159,162,165,168,171,174,177,180,183,186,
+189,191,194,197,199,202,204,207,209,212,214,216,218,221,223,225,227,229,231,232,234,236,
+238,239,241,242,243,245,246,247,248,249,250,251,252,252,253,253,254,254,255,255,255,255,
+255,255,255,255,254,254,253,253,252,252,251,250,249,248,247,246,245,243,242,241,239,238,
+236,234,232,231,229,227,225,223,221,218,216,214,212,209,207,204,202,199,197,194,191,189,
+186,183,180,177,174,171,168,165,162,159,156,153,150,147,144,141,138,135,131,128,125,122,
+119,116,113,109,106,103,100,97,94,91,88,85,82,79,76,73,71,68,65,62,60,57,54,52,49,47,45,
+42,40,38,35,33,31,29,27,25,23,22,20,18,17,15,14,12,11,10,9,8,6,6,5,4,3,2,2,1,1,1,0,0,0,0
+};
+
+// Gamma table removed because NeoPixel lib provides this functionality.
+
+void setup() {
+  if (!leds.begin()) {
+    pinMode(LED_BUILTIN, OUTPUT);
+    for (;;) digitalWrite(LED_BUILTIN, (millis() / 500) & 1);
+  }
+  leds.setBrightness(100); // Tone it down a little
+  leds.show();             // Clear initial LED state
+}
+
+unsigned long frameCount=25500;  // arbitrary seed to calculate the three time displacement variables t,t2,t3
+
+void loop() {
+  frameCount++ ;
+  uint16_t t = fastCosineCalc((42 * frameCount)/300);  //time displacement - fiddle with these til it looks good...
+  uint16_t t2 = fastCosineCalc((35 * frameCount)/300);
+  uint16_t t3 = fastCosineCalc((38 * frameCount)/300);
+
+  for (uint8_t y = 0; y < ROWS_LEDs; y++) {
+    int left2Right, pixelIndex;
+    if (((y % (ROWS_LEDs/8)) & 1) == 0) {
+      left2Right = 1;
+      pixelIndex = y * COLS_LEDs;
+    } else {
+      left2Right = -1;
+      pixelIndex = (y + 1) * COLS_LEDs - 1;
+    }
+    for (uint8_t x = 0; x < COLS_LEDs ; x++) {
+      //Calculate 3 seperate plasma waves, one for each color channel
+      uint8_t r = fastCosineCalc(((x << 3) + (t >> 1) + fastCosineCalc((t2 + (y << 3)))));
+      uint8_t g = fastCosineCalc(((y << 3) + t + fastCosineCalc(((t3 >> 2) + (x << 3)))));
+      uint8_t b = fastCosineCalc(((y << 3) + t2 + fastCosineCalc((t + x + (g >> 2)))));
+      leds.setPixelColor(pixelIndex, leds.gamma32((r << 16) | (g << 8) | b));
+    	pixelIndex += left2Right;
+    }
+  }
+  leds.show();
+}
+
+inline uint8_t fastCosineCalc( uint16_t preWrapVal) {
+  uint8_t wrapVal = (preWrapVal % 255);
+  if (wrapVal<0) wrapVal=255+wrapVal;
+  return (pgm_read_byte_near(cos_wave+wrapVal));
+}