FastLED audio

platformio.ini

@@ -201,12 +201,12 @@ build_flags =
   -D FT_MOONLIGHT=1
   -D FT_MONITOR=1
   -D EFFECTS_STACK_SIZE=3072 ; psramFound() ? 4 * 1024 : 3 * 1024
-  -D DRIVERS_STACK_SIZE=4096 ;  psramFound() ? 4 * 1024 : 3 * 1024, 4096 is sufficient for now
+  -D DRIVERS_STACK_SIZE=6144 ;  psramFound() ? 4 * 1024 : 3 * 1024, 4096 is sufficient for now. Update: due to FastLED audio I had to increase to 6144 (might want to move audio to a separate task)
 
   ; -D FASTLED_TESTING ; causes duplicate definition of initSpiHardware(); - workaround: removed implementation in spi_hw_manager_esp32.cpp.hpp
-    -D FASTLED_BUILD=\"20260221\"
+    -D FASTLED_BUILD=\"20260222\"
 lib_deps =
-  https://github.com/FastLED/FastLED#9d0b0eb9b5e59e4093982e0c2bdcfdff72ca80cb ; master 20260221
+  https://github.com/FastLED/FastLED#27c99130c83ab666c4c6dbf389425fec5f27db05 ; master 20260222
   https://github.com/ewowi/WLED-sync#25f280b5e8e47e49a95282d0b78a5ce5301af4fe ; sourceIP + fftUdp.clear() if arduino >=3 (20251104)
 
 ; 💫 currently only enabled on s3 as esp32dev runs over 100%

src/MoonBase/Nodes.h

@@ -268,7 +268,7 @@ class LiveScriptNode : public Node {
   // layout
   void onLayout() override;  // call map in LiveScript
 
-  ~LiveScriptNode();
+  ~LiveScriptNode() override;
 
   // LiveScript functions
   void compileAndRun();
@@ -346,6 +346,15 @@ static struct SharedData {
   size_t clientListSize;
 
   Coord3D gravity;
+
+  // FastLED Audio
+  bool vocalsActive = false;
+  float vocalConfidence = 0.0f;
+  float bassLevel = 0.0f;
+  float midLevel = 0.0f;
+  float trebleLevel = 0.0f;
+  bool beat = false;
+
 } sharedData;
 
   /**
@@ -359,10 +368,11 @@ static struct SharedData {
   #include "MoonLight/Nodes/Drivers/D_ArtnetIn.h"
   #include "MoonLight/Nodes/Drivers/D_ArtnetOut.h"
   #include "MoonLight/Nodes/Drivers/D_AudioSync.h"
-  #include "MoonLight/Nodes/Drivers/D_FastLED.h"
+  #include "MoonLight/Nodes/Drivers/D_FastLEDAudio.h"
+  #include "MoonLight/Nodes/Drivers/D_FastLEDDriver.h"
   #include "MoonLight/Nodes/Drivers/D_Hub75.h"
-  #include "MoonLight/Nodes/Drivers/D_Infrared.h"
   #include "MoonLight/Nodes/Drivers/D_IMU.h"
+  #include "MoonLight/Nodes/Drivers/D_Infrared.h"
   #include "MoonLight/Nodes/Drivers/D_ParallelLEDDriver.h"
   #include "MoonLight/Nodes/Drivers/D__Sandbox.h"
   #include "MoonLight/Nodes/Effects/E_FastLED.h"

src/MoonLight/Modules/ModuleDrivers.h

@@ -97,10 +97,12 @@ class ModuleDrivers : public NodeManager {
     addControlValue(control, getNameAndTags<SpiralLayout>());
     addControlValue(control, getNameAndTags<SingleRowLayout>());
     addControlValue(control, getNameAndTags<SingleColumnLayout>());
+    addControlValue(control, getNameAndTags<TubesLayout>());
 
     // Drivers, Most used first
     addControlValue(control, getNameAndTags<ParallelLEDDriver>());
     addControlValue(control, getNameAndTags<FastLEDDriver>());
+    addControlValue(control, getNameAndTags<FastLEDAudioDriver>());
     addControlValue(control, getNameAndTags<ArtNetInDriver>());
     addControlValue(control, getNameAndTags<ArtNetOutDriver>());
     addControlValue(control, getNameAndTags<AudioSyncDriver>());
@@ -135,10 +137,12 @@ class ModuleDrivers : public NodeManager {
     if (!node) node = checkAndAlloc<TorontoBarGourdsLayout>(name);
     if (!node) node = checkAndAlloc<SingleRowLayout>(name);
     if (!node) node = checkAndAlloc<SingleColumnLayout>(name);
+    if (!node) node = checkAndAlloc<TubesLayout>(name);
 
     // Drivers most used first
     if (!node) node = checkAndAlloc<ParallelLEDDriver>(name);
     if (!node) node = checkAndAlloc<FastLEDDriver>(name);
+    if (!node) node = checkAndAlloc<FastLEDAudioDriver>(name);
     if (!node) node = checkAndAlloc<ArtNetInDriver>(name);
     if (!node) node = checkAndAlloc<ArtNetOutDriver>(name);
     if (!node) node = checkAndAlloc<AudioSyncDriver>(name);

src/MoonLight/Modules/ModuleEffects.h

@@ -170,6 +170,7 @@ class ModuleEffects : public NodeManager {
 
     // FastLED effects
     addControlValue(control, getNameAndTags<RainbowEffect>());
+    addControlValue(control, getNameAndTags<FLAudioEffect>());
 
     // Moving head effects, alphabetically
     addControlValue(control, getNameAndTags<AmbientMoveEffect>());
@@ -291,6 +292,7 @@ class ModuleEffects : public NodeManager {
 
     // FastLED
     if (!node) node = checkAndAlloc<RainbowEffect>(name);
+    if (!node) node = checkAndAlloc<FLAudioEffect>(name);
 
     // Moving head effects, alphabetically
 

src/MoonLight/Nodes/Drivers/D_FastLEDAudio.h

@@ -0,0 +1,208 @@
+/**
+    @title     MoonLight
+    @file      D_FastLEDAudio.h
+    @repo      https://github.com/MoonModules/MoonLight, submit changes to this file as PRs
+    @Authors   https://github.com/MoonModules/MoonLight/commits/main
+    @Doc       https://moonmodules.org/MoonLight/moonlight/overview/
+    @Copyright © 2026 Github MoonLight Commit Authors
+    @license   GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007
+    @license   For non GPL-v3 usage, commercial licenses must be purchased. Contact us for more information.
+**/
+
+#pragma once
+
+#if FT_MOONLIGHT
+
+  #include "fl/audio.h"
+  #include "fl/audio/audio_processor.h"
+  #include "fl/audio_input.h"
+  #include "fl/time_alpha.h"
+
+// https://github.com/FastLED/FastLED/blob/master/src/fl/audio/README.md
+
+class FastLEDAudioDriver : public Node {
+ private:
+  // Member variables for audio configuration
+  fl::AudioConfigI2S* i2sConfig = nullptr;
+  fl::AudioConfig* config = nullptr;
+  fl::shared_ptr<fl::IAudioInput> audioInput;
+
+ public:
+  static const char* name() { return "FastLED Audio"; }
+  static uint8_t dim() { return _NoD; }
+  static const char* tags() { return "☸️"; }
+
+  fl::AudioProcessor audioProcessor;
+
+  bool signalConditioning = true;
+  bool autoGain = false;
+  bool noiseFloorTracking = false;
+  uint8_t channel = fl::Left;
+
+  void setup() override {
+    addControl(signalConditioning, "signalConditioning", "checkbox");
+    addControl(autoGain, "autoGain", "checkbox");
+    addControl(noiseFloorTracking, "noiseFloorTracking", "checkbox");
+    addControl(channel, "channel", "select");
+    addControlValue("Left");
+    addControlValue("Right");
+    addControlValue("Both");
+
+    moduleIO->addUpdateHandler([this](const String& originId) { readPins(); }, false);
+    readPins();  // Node added at runtime so initial IO update not received so run explicitly
+
+    audioProcessor.onBeat([]() {
+      sharedData.beat = true;
+      // EXT_LOGD(ML_TAG, "onBeat");
+    });
+
+    audioProcessor.onVocalStart([]() {
+      sharedData.vocalsActive = true;
+      // EXT_LOGD(ML_TAG, "onVocalStart");
+    });
+
+    audioProcessor.onVocalEnd([]() {
+      sharedData.vocalsActive = false;
+      // EXT_LOGD(ML_TAG, "onVocalEnd");
+    });
+
+    audioProcessor.onVocalConfidence([](float confidence) {
+      sharedData.vocalConfidence = sharedData.vocalsActive ? confidence : 0.0;
+      // EXT_LOGD(ML_TAG, "onVocalConfidence %d", confidence);
+    });
+
+    audioProcessor.onBass([](float level) {
+      if (level > 0.01f) {
+        sharedData.bassLevel = level;
+        // EXT_LOGD(ML_TAG, "onBass: %f", level);
+      }
+    });
+
+    audioProcessor.onMid([](float level) {
+      if (level > 0.01f) {
+        sharedData.midLevel = level;
+        // EXT_LOGD(ML_TAG, "onBass: %f", level);
+      }
+    });
+
+    audioProcessor.onTreble([](float level) {
+      if (level > 0.01f) {
+        sharedData.trebleLevel = level;
+        // EXT_LOGD(ML_TAG, "onTreble: %f", level);
+      }
+    });
+    audioProcessor.onPercussion([](fl::PercussionType type) {
+        EXT_LOGD(ML_TAG, "onPercussion: %d", type);
+    });
+  }
+
+  void onUpdate(const Char<20>& oldValue, const JsonObject& control) override {
+    if (control["name"] == "signalConditioning") {
+      audioProcessor.setSignalConditioningEnabled(signalConditioning);
+    }
+    if (control["name"] == "autoGain") {
+      audioProcessor.setAutoGainEnabled(autoGain);
+    }
+    if (control["name"] == "noiseFloorTracking") {
+      audioProcessor.setNoiseFloorTrackingEnabled(noiseFloorTracking);
+    }
+    if (control["name"] == "channel" && oldValue != "") {  // not on boot as readPins will do it then
+      // recreate with the new channel
+      stopAudio();
+      startAudio();
+    }
+  }
+
+  uint8_t pinI2SSD = UINT8_MAX;
+  uint8_t pinI2SWS = UINT8_MAX;
+  uint8_t pinI2SSCK = UINT8_MAX;
+
+  void readPins() {
+    if (safeModeMB) {
+      EXT_LOGW(ML_TAG, "Safe mode enabled, not adding pins");
+      return;
+    }
+
+    moduleIO->read(
+        [&](ModuleState& state) {
+          bool i2sPinsChanged = false;
+          for (JsonObject pinObject : state.data["pins"].as<JsonArray>()) {
+            uint8_t usage = pinObject["usage"];
+            switch (usage) {
+            case pin_I2S_SD:
+              if (pinI2SSD != pinObject["GPIO"]) {
+                pinI2SSD = pinObject["GPIO"];
+                i2sPinsChanged = true;
+              }
+              break;
+            case pin_I2S_WS:
+              if (pinI2SWS != pinObject["GPIO"]) {
+                pinI2SWS = pinObject["GPIO"];
+                i2sPinsChanged = true;
+              }
+              break;
+            case pin_I2S_SCK:
+              if (pinI2SSCK != pinObject["GPIO"]) {
+                pinI2SSCK = pinObject["GPIO"];
+                i2sPinsChanged = true;
+              }
+              break;
+            }
+          }
+          if (i2sPinsChanged && pinI2SSD != UINT8_MAX && pinI2SWS != UINT8_MAX && pinI2SSCK != UINT8_MAX) {
+            EXT_LOGI(ML_TAG, "(re)creating audioInput)");
+
+            stopAudio();
+            startAudio();
+          }
+        },
+        name());
+  }
+
+  void loop20ms() override {
+    if (!audioInput) return;
+
+    sharedData.beat = false;
+
+    while (fl::AudioSample sample = audioInput->read()) {
+      audioProcessor.update(sample);
+    }
+  }
+
+  void startAudio() {
+    // Create configuration objects
+    i2sConfig = new fl::AudioConfigI2S(pinI2SWS, pinI2SSD, pinI2SSCK, 0, channel == 1 ? fl::Right : channel == 2 ? fl::Both : fl::Left, 44100, 16, fl::Philips);
+
+    config = new fl::AudioConfig(*i2sConfig);
+
+    fl::string errorMsg;
+    audioInput = fl::IAudioInput::create(*config, &errorMsg);
+    if (!audioInput) {
+      EXT_LOGE(ML_TAG, "Failed to create audio input: %s", errorMsg.c_str());
+      return;
+    }
+    audioInput->start();
+  }
+
+  void stopAudio() {
+    if (audioInput) {
+      audioInput->stop();
+      audioInput.reset();  // Explicitly release shared_ptr, even makes it a nullptr...
+    }
+
+    // Clean up raw pointers
+    if (config) {
+      delete config;
+      config = nullptr;
+    }
+
+    if (i2sConfig) {
+      delete i2sConfig;
+      i2sConfig = nullptr;
+    }
+  }
+
+  ~FastLEDAudioDriver() override { stopAudio(); }
+};
+
+#endif

src/MoonLight/Nodes/Drivers/D_FastLED.h → src/MoonLight/Nodes/Drivers/D_FastLEDDriver.h

@@ -1,6 +1,6 @@
 /**
     @title     MoonLight
-    @file      FastLED.h
+    @file      D_FastLEDDriver.h
     @repo      https://github.com/MoonModules/MoonLight, submit changes to this file as PRs
     @Authors   https://github.com/MoonModules/MoonLight/commits/main
     @Doc       https://moonmodules.org/MoonLight/moonlight/overview/

src/MoonLight/Nodes/Effects/E_FastLED.h

@@ -37,4 +37,50 @@ class RainbowEffect : public Node {
   }
 };
 
+class FLAudioEffect : public Node {
+ public:
+  static const char* name() { return "FLAudio"; }
+  static uint8_t dim() { return _2D; }
+  static const char* tags() { return "⚡️🎵"; }
+
+  void setup() {}
+
+  uint16_t hue = 0;
+  uint8_t beatLevel = 0;
+  float maxBass = 0;
+  float maxMid = 0;
+  float maxTreble = 0;
+  float maxVocal = 0;
+
+  void loop() override {
+    layer->fadeToBlackBy(70);
+
+    // calculate max levels
+    if (sharedData.bassLevel > maxBass) maxBass = sharedData.bassLevel;
+    if (sharedData.midLevel > maxMid) maxMid = sharedData.midLevel;
+    if (sharedData.trebleLevel > maxTreble) maxTreble = sharedData.trebleLevel;
+    if (sharedData.vocalConfidence > maxVocal) maxVocal = sharedData.vocalConfidence;
+
+    if (sharedData.beat) beatLevel = 255;
+
+    // EXT_LOGD(ML_TAG, "%f-%d %f-%d %d-%d %f-%d", sharedData.bassLevel, bassLevel, sharedData.trebleLevel, trebleLevel, sharedData.beat, beatLevel, sharedData.vocalsActive ? sharedData.vocalConfidence : 0, vocalsLevel);
+
+    uint8_t columnNr = 0;
+    layer->drawLine(columnNr, layer->size.y - 1, columnNr++, layer->size.y - 1 - layer->size.y * sharedData.bassLevel / maxBass, CRGB::Red);
+    layer->drawLine(columnNr, layer->size.y - 1, columnNr++, layer->size.y - 1 - layer->size.y * sharedData.midLevel / maxMid, CRGB::Orange);
+    layer->drawLine(columnNr, layer->size.y - 1, columnNr++, layer->size.y - 1 - layer->size.y * sharedData.trebleLevel / maxTreble, CRGB::Green);
+    layer->drawLine(columnNr, layer->size.y - 1, columnNr++, layer->size.y - 1 - layer->size.y * sharedData.vocalConfidence / maxVocal, CRGB::Blue);
+    layer->drawLine(columnNr, layer->size.y - 1, columnNr++, layer->size.y - 1 - layer->size.y * beatLevel / 255, CRGB::Purple);
+
+    // correct for lower output
+    if (maxBass > 0) maxBass -= 0.01;
+    if (maxMid > 0) maxMid -= 0.01;
+    if (maxTreble > 0) maxTreble -= 0.01;
+    if (maxVocal > 0) maxVocal -= 0.01;
+
+    // beat delay
+    if (beatLevel) beatLevel -= MIN(255/layer->size.y, beatLevel);
+  }
+};
+
 #endif

src/MoonLight/Nodes/Effects/E_WLED.h

@@ -3560,14 +3560,18 @@ class WaterfallEffect : public Node {
       uint8_t pixCol = (log10f(myMajorPeak) - 2.26f) * 150;
       if (myMajorPeak < 182.0f) pixCol = 0;
 
-      for (int i = 0; i < layer->nrOfLights - 1; i++) layer->setRGB(i, layer->getRGB(i + 1));
+      for (int x = 0; x < layer->size.x; x++)
+        for (int z = 0; z < layer->size.z; z++)
+          for (int y = 0; y < layer->size.y - 1; y++) layer->setRGB(Coord3D(x, y, z), layer->getRGB(Coord3D(x, y + 1, z)));
 
       bool peak = sharedData.volume > 128.0f;
       if (peak) {
-        layer->setRGB(layer->nrOfLights - 1, CHSV(92, 92, 92));
+        for (int x = 0; x < layer->size.x; x++)
+          for (int z = 0; z < layer->size.z; z++) layer->setRGB(Coord3D(x, layer->size.y - 1, z), CHSV(92, 92, 92));
       } else {
         CRGB color = ColorFromPalette(layerP.palette, pixCol + intensity, 127 + myMagnitude / 2.0);
-        layer->setRGB(layer->nrOfLights - 1, color);  // blend(layerP.color2, color, (int)myMagnitude));
+        for (int x = 0; x < layer->size.x; x++)
+          for (int z = 0; z < layer->size.z; z++) layer->setRGB(Coord3D(x, layer->size.y - 1, z), color);  // blend(layerP.color2, color, (int)myMagnitude));
       }
     }
   }