many long LED strips: glitching with solid effect

[limpkin]

In my case, 14 LED strips of 365 RGBW LEDs each and the solid effect set leads to glitching between white and the other RGB settings set in the solid effect

[limpkin]

@coderabbitai walk me through all the function calls, from the effect to the pixel driving, when using an RGBW led strip

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash

# First, let's understand the repository structure
echo "=== Repository Structure ==="
fd -t d -d 2

echo -e "\n=== Looking for effect-related files ==="
fd -e cpp -e h -e c | grep -i effect | head -20

echo -e "\n=== Looking for LED/pixel driving files ==="
fd -e cpp -e h -e c | grep -i -e led -e pixel -e strip -e neopixel | head -20

echo -e "\n=== Looking for RGBW mentions ==="
rg -l "RGBW" --type cpp --type c

echo -e "\n=== Looking for main setup/loop files ==="
fd -e ino
fd "main" -e cpp -e h

Length of output: 1427

---

🏁 Script executed:

#!/bin/bash

# Let's look at the main entry point
echo "=== Main.cpp structure ==="
rg -n "loop\(\)|setup\(\)" src/main.cpp -A 5

echo -e "\n=== VirtualLayer.cpp - RGBW handling ==="
rg -n "RGBW" src/MoonLight/Layers/VirtualLayer.cpp -B 3 -A 3

echo -e "\n=== Let's see what VirtualLayer does ==="
cat src/MoonLight/Layers/VirtualLayer.cpp | head -100

echo -e "\n=== Check Driver base or interface ==="
rg -n "class.*Driver" src/MoonLight/Nodes/Drivers/D_FastLED.h -B 2 -A 10 | head -50

Length of output: 6429

---

🏁 Script executed:

#!/bin/bash

# Let's see how loopDrivers works
echo "=== LayerP loopDrivers implementation ==="
rg -n "loopDrivers" src/MoonLight/Layers/ -B 3 -A 20

echo -e "\n=== PhysicalLayer structure ==="
cat src/MoonLight/Layers/PhysicalLayer.h | head -80

echo -e "\n=== FastLED Driver show/write implementation ==="
rg -n "show\(\)|write" src/MoonLight/Nodes/Drivers/D_FastLED.h -B 2 -A 15

echo -e "\n=== How effects write to leds - check E_FastLED ==="
cat src/MoonLight/Nodes/Effects/E_FastLED.h | head -150

Length of output: 8769

---

🏁 Script executed:

#!/bin/bash

# Let's see how VirtualLayer setRGB and other functions work
echo "=== VirtualLayer setRGB and color setting functions ==="
rg -n "setRGB\(|setHSV\(|setChannel\(" src/MoonLight/Layers/VirtualLayer.cpp -B 2 -A 15 | head -100

echo -e "\n=== How mapping from virtual to physical works ==="
rg -n "void PhysicalLayer::mapLayout" src/MoonLight/Layers/PhysicalLayer.cpp -B 2 -A 30

echo -e "\n=== Let's see the Lights struct and data structure ==="
rg -n "struct Lights" src/MoonLight/Layers/PhysicalLayer.h -B 2 -A 30

echo -e "\n=== Check how drivers read the physical lights data ==="
rg -n "layerP.lights\." src/MoonLight/Nodes/Drivers/D_FastLED.h -B 2 -A 5 | head -80

Length of output: 10436

---

🏁 Script executed:

#!/bin/bash

# Let's see the actual setRGB implementation and how it handles channels
echo "=== VirtualLayer setRGB implementation ==="
rg -n "void VirtualLayer::setRGB" src/MoonLight/Layers/VirtualLayer.h -B 2 -A 30

echo -e "\n=== Let's check setChannel and how channels array is accessed ==="
rg -n "void.*setChannel|void.*setWhite" src/MoonLight/Layers/VirtualLayer.h -B 2 -A 20

echo -e "\n=== Check RGBW handling in FastLED driver ==="
rg -n "RGBW|SK6812" src/MoonLight/Nodes/Drivers/D_FastLED.h -B 2 -A 5

echo -e "\n=== How are channels structured and indexed ==="
rg -n "channels\[" src/MoonLight/Layers/VirtualLayer.h -B 1 -A 3 | head -60

Length of output: 30141

---

🏁 Script executed:

#!/bin/bash

# Let's see the full VirtualLayer.h header to understand setRGB and setLight
echo "=== Complete VirtualLayer setRGB and setLight methods ==="
cat src/MoonLight/Layers/VirtualLayer.h | grep -A 20 "setRGB\|setLight\|getLight"

echo -e "\n=== Let's see the PhysicalLayer addLight function ==="
rg -n "void PhysicalLayer::addLight" src/MoonLight/Layers/PhysicalLayer.cpp -B 3 -A 40

echo -e "\n=== Check channel offset handling in VirtualLayer.cpp ==="
rg -n "offsetRGB\|offsetWhite\|channelsPerLight" src/MoonLight/Layers/VirtualLayer.cpp -B 2 -A 5 | head -80

Length of output: 10493

---

🏁 Script executed:

#!/bin/bash

# Let's see the setLight implementation
echo "=== VirtualLayer setLight implementation ==="
rg -n "void VirtualLayer::setLight" src/MoonLight/Layers/VirtualLayer.cpp -B 2 -A 30

echo -e "\n=== getLight template implementation ==="
rg -n "template.*T.*VirtualLayer::getLight" src/MoonLight/Layers/VirtualLayer.cpp -B 2 -A 30

echo -e "\n=== Check how mapping table works ==="
rg -n "mappingTable\[indexV\]" src/MoonLight/Layers/VirtualLayer.cpp -B 2 -A 8 | head -100

Length of output: 6832

---

@limpkin Here's the complete walkthrough of the function call chain from effect to pixel driving for RGBW LED strips:

Call Flow Overview

graph TD
    A[Effect loop] --> B[VirtualLayer::setRGB]
    B --> C[VirtualLayer::setLight]
    C --> D[PhysicalLayer::lights.channels array]
    D --> E[Driver Task: loopDrivers]
    E --> F[FastLEDDriver::loop]
    F --> G[FastLED.show]
    G --> H[Hardware RMT/I2S]
    H --> I[GPIO Pin to LED Strip]

Loading

Detailed Step-by-Step Flow

1. Effect Execution (src/MoonLight/Nodes/Effects/E_FastLED.h)

The effect's loop() method runs in the effectTask thread:

void loop() override {
  layer->fill_rainbow((hue += speed * 32) >> 8, deltaHue);
  layer->setRGB(random16(layer->size.x), CRGB::White);
}

2. VirtualLayer Color Setting (src/MoonLight/Layers/VirtualLayer.h)

Key RGBW Conversion happens here:

void setRGB(const uint16_t indexV, CRGB color) {
  if (layerP->lights.header.offsetWhite != UINT8_MAX && 
      layerP->lights.header.offsetWhite == layerP->lights.header.offsetRGB + 3) {
    // RGBW conversion: extract white channel
    uint8_t rgbw[4];
    rgbw[3] = MIN(MIN(color.r, color.g), color.b);  // White = min(R,G,B)
    rgbw[0] = color.red - rgbw[3];    // Subtract white from R
    rgbw[1] = color.green - rgbw[3];  // Subtract white from G
    rgbw[2] = color.blue - rgbw[3];   // Subtract white from B
    setLight(indexV, rgbw, layerP->lights.header.offsetRGB, sizeof(rgbw));
  } else
    setLight(indexV, color.raw, layerP->lights.header.offsetRGB, sizeof(color));
}

RGBW Algorithm: Takes the minimum value across R, G, B as the white channel, then subtracts it from each RGB component to avoid double-brightness.

3. Virtual to Physical Mapping (src/MoonLight/Layers/VirtualLayer.cpp)

void VirtualLayer::setLight(const uint16_t indexV, const uint8_t* channels, 
                            uint8_t offset, uint8_t length) {
  switch (mappingTable[indexV].mapType) {
    case m_oneLight: {
      uint16_t indexP = mappingTable[indexV].indexP;
      // Write to physical channel array
      memcpy(&layerP->lights.channels[indexP * layerP->lights.header.channelsPerLight + offset], 
             channels, length);
      break;
    }
    // ... handles m_moreLights for multi-pixel mapping
  }
}

The mappingTable translates:

• indexV (virtual coordinate) → indexP (physical LED index)
• Calculates byte offset: indexP * channelsPerLight + offset
• For RGBW: channelsPerLight = 4

4. Physical Channel Storage (src/MoonLight/Layers/PhysicalLayer.h)

Data is written to the shared buffer:

struct Lights {
  LightsHeader header;
  uint8_t* channels;  // Raw channel data [R0,G0,B0,W0, R1,G1,B1,W1, ...]
  size_t maxChannels;
};

Header contains channel layout info:

• channelsPerLight = 4 (for RGBW)
• offsetRGB = 0, offsetWhite = 3

5. Driver Task (src/main.cpp)

Separate FreeRTOS task runs the driverTask:

void driverTask(void* pvParameters) {
  for (;;) {
    xSemaphoreTake(driverSemaphore, pdMS_TO_TICKS(100));
    layerP.loopDrivers();  // Calls all driver nodes
  }
}

6. Driver Loop (src/MoonLight/Nodes/Drivers/D_FastLED.h)

void loop() override {
  if (FastLED.count()) {
    FastLED.setBrightness(layerP.lights.header.brightness);
    
    // Cast channels array to CRGB array
    CRGB* leds = (CRGB*)layerP.lights.channels;
    
    FastLED.show();  // Output to hardware
  }
}

Note: Even for RGBW, the cast to CRGB* works because FastLED's RGBW mode knows to read 4 bytes per pixel when .setRgbw() was called during initialization.

7. FastLED Initialization (during onLayout())

FastLED.addLeds<ML_CHIPSET, PIN COLOR_ORDER_ARG>(leds, startLed, nrOfLights)
       .setCorrection(TypicalLEDStrip)
       .setRgbw(RgbwDefault());  // ← Enables RGBW mode

The RGBW_CALL macro expands to .setRgbw(RgbwDefault()) when ML_RGBW is defined.

8. Hardware Output

FastLED library:

• Uses ESP32 RMT peripheral (or I2S on S3) for precise timing
• Sends 32 bits per pixel for RGBW (vs 24 bits for RGB)
• Generates the SK6812/WS2812B protocol waveforms
• Outputs to the configured GPIO pin

Key Configuration Points

For RGBW to work properly:

1. Compile-time: Define ML_RGBW=1 and ML_CHIPSET=SK6812 in platformio.ini
2. Runtime: System detects RGBW during layout:
   • Sets lights.header.channelsPerLight = 4
   • Sets lights.header.offsetWhite = 3
3. Effect code: Uses standard CRGB colors - conversion is automatic!

Two-Task Architecture

• effectTask: Runs effects, updates lights.channels[]
• driverTask: Reads lights.channels[], outputs to hardware
• Semaphores synchronize access to prevent tearing

This architecture allows complex effect calculations without blocking the time-critical LED output timing.

[limpkin]

see #82