channelsE and channelsP (swap for double buffering)

Effects and modifiers use channelsE (virtual layer, Art-Net In)
Drivers use channelsD (FastLED, parallel, Art-Net out)
main swaps between them

Author: ewowi

docs/develop/architecture.md

@@ -162,14 +162,15 @@ Synchronization Flow
 void effectTask(void* param) {
   while (true) {
     if (layerP.lights.useDoubleBuffer) {
-      layerP.lights.channels = layerP.lights.channelsBack;
+      layerP.lights.channelsE = layerP.lights.channelsD;
+
       layerP.loop();  // getRGB and setRGB both use channelsBack
 
       // Atomic swap channels
       xSemaphoreTake(swapMutex, portMAX_DELAY);
-      uint8_t* temp = layerP.lights.channelsBack;
-      layerP.lights.channelsBack = layerP.lights.channels;
-      layerP.lights.channels = temp;
+      uint8_t* temp = layerP.lights.channelsD;
+      layerP.lights.channelsD = layerP.lights.channelsE;
+      layerP.lights.channelsE = temp;
       newFrameReady = true;
       xSemaphoreGive(swapMutex);
 
@@ -366,11 +367,11 @@ Double buffering is **automatically enabled** when PSRAM is detected:
 // In PhysicalLayer::setup()
 if (psramFound()) {
   lights.useDoubleBuffer = true;
-  lights.channels = allocMB<uint8_t>(maxChannels);
-  lights.channelsBack = allocMB<uint8_t>(maxChannels);
+  lights.channelsE = allocMB<uint8_t>(maxChannels);
+  lights.channelsD = allocMB<uint8_t>(maxChannels);
 } else {
   lights.useDoubleBuffer = false;
-  lights.channels = allocMB<uint8_t>(maxChannels);
+  lights.channelsE = allocMB<uint8_t>(maxChannels);
 }
 ```
 

docs/develop/layers.md

@@ -35,7 +35,7 @@
       * A Virtual Layer mapping gets updated if a layout, mapping or dimensions change 🚧
       * An effect uses a virtual layer. One Virtual layer can have multiple effects. ✅
   * Physical layer
-      * Lights.header and Lights.channels. CRGB leds[] is using lights.channels (acting like leds[] in FASTLED) ✅
+      * Lights.header and lights.channelsE/D. CRGB leds[] is using lights.channelsE/D (acting like leds[] in FASTLED) ✅
       * A Physical layer has one or more virtual layers and a virtual layer has one or more effects using it. ✅
   * Presets/playlist: change (part of) the nodes model
 

src/MoonBase/Nodes.cpp

@@ -183,7 +183,7 @@ void LiveScriptNode::setup() {
   //   addExternal( "uint8_t dmaBuffer", &layerP.ledsDriver.dmaBuffer);
 
   addExternal("void fadeToBlackBy(uint8_t)", (void*)_fadeToBlackBy);
-  addExternal("CRGB* leds", (void*)(CRGB*)layerP.lights.channels);
+  addExternal("CRGB* leds", (void*)(CRGB*)layerP.lights.channelsE);
   addExternal("void setRGB(uint16_t,CRGB)", (void*)_setRGB);
   addExternal("void setRGBPal(uint16_t,uint8_t,uint8_t)", (void*)_setRGBPal);
   addExternal("void setPan(uint16_t,uint8_t)", (void*)_setPan);
@@ -370,7 +370,7 @@ void DriverNode::loop() {
 
   if (brightness != brightnessSaved || layerP.maxPower != maxPowerSaved) {
     // Use FastLED for setMaxPowerInMilliWatts stuff
-    uint8_t correctedBrightness = calculate_max_brightness_for_power_mW((CRGB*)&layerP.lights.channels, layerP.lights.header.nrOfLights, brightness, layerP.maxPower * 1000);
+    uint8_t correctedBrightness = calculate_max_brightness_for_power_mW((CRGB*)&layerP.lights.channelsD, layerP.lights.header.nrOfLights, brightness, layerP.maxPower * 1000);
     // EXT_LOGD(ML_TAG, "setBrightness b:%d + p:%d -> cb:%d", brightness, layerP.maxPower, correctedBrightness);
     ledsDriver.setBrightness(correctedBrightness);
     brightnessSaved = brightness;

src/MoonLight/Layers/PhysicalLayer.cpp

@@ -33,10 +33,10 @@ PhysicalLayer::PhysicalLayer() {
 
 // heap-optimization: request heap optimization review
 // on boards without PSRAM, heap is only 60 KB (30KB max alloc) available, need to find out how to increase the heap
-// goal is to have lights.channels as large as possible, preferable 12288 at least for boards without PSRAM
+// goal is to have lights.channelsE/D as large as possible, preferable 12288 at least for boards without PSRAM
 
 void PhysicalLayer::setup() {
-  // allocate lights.channels
+  // allocate lights.channelsE/D
 
   if (psramFound()) {
     lights.maxChannels = MIN(ESP.getPsramSize() / 4, 61440 * 3);  // fill halve with channels, max 120 pins * 512 LEDs, still addressable with uint16_t
@@ -46,17 +46,19 @@ void PhysicalLayer::setup() {
     lights.useDoubleBuffer = false;  // Single buffer mode
   }
 
-  lights.channels = allocMB<uint8_t>(lights.maxChannels);
+  lights.channelsE = allocMB<uint8_t>(lights.maxChannels);
 
-  if (lights.channels) {
-    EXT_LOGD(ML_TAG, "allocated %d bytes in %s", lights.maxChannels, isInPSRAM(lights.channels) ? "PSRAM" : "RAM");
+  if (lights.channelsE) {
+    EXT_LOGD(ML_TAG, "allocated %d bytes in %s", lights.maxChannels, isInPSRAM(lights.channelsE) ? "PSRAM" : "RAM");
     // Allocate back buffer only if PSRAM available
     if (lights.useDoubleBuffer) {
-      lights.channelsBack = allocMB<uint8_t>(lights.maxChannels);
-      if (!lights.channelsBack) {
+      lights.channelsD = allocMB<uint8_t>(lights.maxChannels);
+      if (!lights.channelsD) {
         EXT_LOGW(ML_TAG, "Failed to allocate back buffer, disabling double buffering");
         lights.useDoubleBuffer = false;
       }
+    } else {
+      lights.channelsD = lights.channelsE;  // share the same array
     }
   } else {
     EXT_LOGE(ML_TAG, "failed to allocated %d bytes of RAM or PSRAM", lights.maxChannels);
@@ -141,7 +143,7 @@ void PhysicalLayer::onLayoutPre() {
     lights.header.isPositions = 1;  // in progress...
     delay(100);                     // wait to stop effects
     // set all channels to 0 (e.g for multichannel to not activate unused channels, e.g. fancy modes on MHs)
-    memset(lights.channels, 0, lights.maxChannels);  // set all the channels to 0
+    memset(lights.channelsE, 0, lights.maxChannels);  // set all the channels to 0, positions in channelsE
     // dealloc pins
     if (!monitorPass) {
       memset(ledsPerPin, 0xFF, sizeof(ledsPerPin));  // UINT16_MAX is 2 * 0xFF
@@ -171,7 +173,7 @@ void PhysicalLayer::addLight(Coord3D position) {
   if (pass == 1) {
     // EXT_LOGD(ML_TAG, "%d,%d,%d", position.x, position.y, position.z);
     if (lights.header.nrOfLights < lights.maxChannels / 3) {
-      packCoord3DInto3Bytes(&lights.channels[lights.header.nrOfLights * 3], position);
+      packCoord3DInto3Bytes(&lights.channelsE[lights.header.nrOfLights * 3], position);  // positions in channelsE
     }
 
     lights.header.size = lights.header.size.maximum(position);

src/MoonLight/Layers/PhysicalLayer.h

@@ -88,8 +88,8 @@ struct LightsHeader {
 
 struct Lights {
   LightsHeader header;
-  uint8_t* channels = nullptr;      // pka leds, created in constructor
-  uint8_t* channelsBack = nullptr;  // Back buffer (being written by effects)
+  uint8_t* channelsE = nullptr;  // channels used by effects and modifiers (double buffering)
+  uint8_t* channelsD = nullptr;  // channels used by drivers (double buffering)
   size_t maxChannels = 0;
   bool useDoubleBuffer = false;  // Only when PSRAM available
 

src/MoonLight/Layers/VirtualLayer.cpp

@@ -139,7 +139,7 @@ void VirtualLayer::setLight(const uint16_t indexV, const uint8_t* channels, uint
       if (layerP->lights.header.lightPreset == lightPreset_RGB2040) {  // RGB2040 has empty channels: Skip the 20..39 range, so adjust group mapping
         indexP += (indexP / 20) * 20;
       }
-      memcpy(&layerP->lights.channels[indexP * layerP->lights.header.channelsPerLight + offset], channels, length);
+      memcpy(&layerP->lights.channelsE[indexP * layerP->lights.header.channelsPerLight + offset], channels, length);
 
       break;
     }
@@ -149,15 +149,15 @@ void VirtualLayer::setLight(const uint16_t indexV, const uint8_t* channels, uint
           if (layerP->lights.header.lightPreset == lightPreset_RGB2040) {  // RGB2040 has empty channels: Skip the 20..39 range, so adjust group mapping
             indexP += (indexP / 20) * 20;
           }
-          memcpy(&layerP->lights.channels[indexP * layerP->lights.header.channelsPerLight + offset], channels, length);
+          memcpy(&layerP->lights.channelsE[indexP * layerP->lights.header.channelsPerLight + offset], channels, length);
         }
       else
         EXT_LOGW(ML_TAG, "dev setLightColor i:%d m:%d s:%d", indexV, mappingTable[indexV].indexes, mappingTableIndexes.size());
       break;
     default:;
     }
   } else if (indexV * layerP->lights.header.channelsPerLight + offset + length < layerP->lights.maxChannels) {  // no mapping
-    memcpy(&layerP->lights.channels[indexV * layerP->lights.header.channelsPerLight + offset], channels, length);
+    memcpy(&layerP->lights.channelsE[indexV * layerP->lights.header.channelsPerLight + offset], channels, length);
   }
 }
 
@@ -170,7 +170,7 @@ T VirtualLayer::getLight(const uint16_t indexV, uint8_t offset) const {
       if (layerP->lights.header.lightPreset == lightPreset_RGB2040) {  // RGB2040 has empty channels: Skip the 20..39 range, so adjust group mapping
         indexP += (indexP / 20) * 20;
       }
-      T* result = (T*)&layerP->lights.channels[indexP * layerP->lights.header.channelsPerLight + offset];
+      T* result = (T*)&layerP->lights.channelsE[indexP * layerP->lights.header.channelsPerLight + offset];
       return *result;  // return the color as CRGB
       break;
     }
@@ -179,7 +179,7 @@ T VirtualLayer::getLight(const uint16_t indexV, uint8_t offset) const {
       if (layerP->lights.header.lightPreset == lightPreset_RGB2040) {          // RGB2040 has empty channels
         indexP += (indexP / 20) * 20;
       }
-      T* result = (T*)&layerP->lights.channels[indexP * layerP->lights.header.channelsPerLight + offset];
+      T* result = (T*)&layerP->lights.channelsE[indexP * layerP->lights.header.channelsPerLight + offset];
       return *result;  // return the color as CRGB
       break;
     }
@@ -195,7 +195,7 @@ T VirtualLayer::getLight(const uint16_t indexV, uint8_t offset) const {
       break;
     }
   } else if (indexV * layerP->lights.header.channelsPerLight + offset + 3 < layerP->lights.maxChannels) {  // no mapping
-    T* result = (T*)&layerP->lights.channels[indexV * layerP->lights.header.channelsPerLight + offset];
+    T* result = (T*)&layerP->lights.channelsE[indexV * layerP->lights.header.channelsPerLight + offset];
     return *result;  // return the color as CRGB
   } else {
     // some operations will go out of bounds e.g. VUMeter, uncomment below lines if you wanna test on a specific effect
@@ -221,7 +221,7 @@ void VirtualLayer::fadeToBlackMin() {
     //   }
     // } else
     if (layerP->lights.header.channelsPerLight == 3 && layerP->layers.size() == 1) {  // CRGB lights
-      fastled_fadeToBlackBy((CRGB*)layerP->lights.channels, layerP->lights.header.nrOfChannels / sizeof(CRGB), fadeBy);
+      fastled_fadeToBlackBy((CRGB*)layerP->lights.channelsE, layerP->lights.header.nrOfChannels / sizeof(CRGB), fadeBy);
     } else {  // multichannel lights
       for (uint16_t index = 0; index < nrOfLights; index++) {
         CRGB color = getRGB(index);  // direct access to the channels
@@ -263,7 +263,7 @@ void VirtualLayer::fill_solid(const CRGB& color) {
   //   }
   // } else
   if (layerP->lights.header.channelsPerLight == 3 && layerP->layers.size() == 1) {  // faster, else manual
-    fastled_fill_solid((CRGB*)layerP->lights.channels, layerP->lights.header.nrOfChannels / sizeof(CRGB), color);
+    fastled_fill_solid((CRGB*)layerP->lights.channelsE, layerP->lights.header.nrOfChannels / sizeof(CRGB), color);
   } else {
     for (uint16_t index = 0; index < nrOfLights; index++) setRGB(index, color);
   }
@@ -283,7 +283,7 @@ void VirtualLayer::fill_rainbow(const uint8_t initialhue, const uint8_t deltahue
   //   }
   // } else
   if (layerP->lights.header.channelsPerLight == 3 && layerP->layers.size() == 1) {  // faster, else manual
-    fastled_fill_rainbow((CRGB*)layerP->lights.channels, layerP->lights.header.nrOfChannels / sizeof(CRGB), initialhue, deltahue);
+    fastled_fill_rainbow((CRGB*)layerP->lights.channelsE, layerP->lights.header.nrOfChannels / sizeof(CRGB), initialhue, deltahue);
   } else {
     CHSV hsv;
     hsv.hue = initialhue;
@@ -354,7 +354,7 @@ void VirtualLayer::addLight(Coord3D position) {
     }
   } else {
     // set unmapped lights to 0, e.g. needed by checkerboard modifier
-    memset(&layerP->lights.channels[layerP->indexP * layerP->lights.header.channelsPerLight], 0, layerP->lights.header.channelsPerLight);
+    memset(&layerP->lights.channelsE[layerP->indexP * layerP->lights.header.channelsPerLight], 0, layerP->lights.header.channelsPerLight);
   }
 }
 

src/MoonLight/Layers/VirtualLayer.h

@@ -63,7 +63,7 @@ class VirtualLayer {
   // heap-optimization: request heap optimization review
   // on boards without PSRAM, heap is only 60 KB (30KB max alloc) available, need to find out how to increase the heap
   // for virtual mapping mappingTable and mappingTableIndexes is used
-  // mappingTable is per default same size as the number of LEDs/lights (stored in lights.channels), see Physical layer, goal is also here to support 12288 LEDs on non PSRAM boards at least for non PSRAM board
+  // mappingTable is per default same size as the number of LEDs/lights (stored in lights.channelsE/D), see Physical layer, goal is also here to support 12288 LEDs on non PSRAM boards at least for non PSRAM board
   // mappingTableIndexes is used of the mapping of effects to lights.channel is not 1:1 but 1:M
 
   // they will be reused to avoid fragmentation

src/MoonLight/Modules/ModuleChannels.h

@@ -74,15 +74,15 @@ class ModuleChannels : public Module {
       // EXT_LOGD(ML_TAG, "%s[%d]%s[%d].%s = %s -> %s", updatedItem.parent[0].c_str(), updatedItem.index[0], updatedItem.parent[1].c_str(), updatedItem.index[1], updatedItem.name.c_str(), updatedItem.oldValue.c_str(), updatedItem.value.as<String>().c_str());
       // copy the file to the hidden folder...
       if (updatedItem.oldValue != "" && !updatedItem.value["action"].isNull() && updatedItem.value["action"] != "") {
-        if (!layerP.lights.channels) return; // to avoid crash during init
+        if (!layerP.lights.channelsE) return; // to avoid crash during init
         EXT_LOGD(ML_TAG, "handle %s[%d]%s[%d].%s = %s -> %s", updatedItem.parent[0].c_str(), updatedItem.index[0], updatedItem.parent[1].c_str(), updatedItem.index[1], updatedItem.name.c_str(), updatedItem.oldValue.c_str(), updatedItem.value.as<String>().c_str());
         uint16_t select = updatedItem.value["select"];
         uint8_t value = updatedItem.value["action"] == "mouseenter" ? 255 : 0;
         if (view == 0) {  // physical layer
           if (group)
-            for (uint8_t i = 0; i < layerP.lights.header.channelsPerLight; i++) layerP.lights.channels[select * layerP.lights.header.channelsPerLight + i] = value;
+            for (uint8_t i = 0; i < layerP.lights.header.channelsPerLight; i++) layerP.lights.channelsE[select * layerP.lights.header.channelsPerLight + i] = value;
           else
-            layerP.lights.channels[select] = value;
+            layerP.lights.channelsE[select] = value;
         } else {
           if (group)
             for (uint8_t i = 0; i < layerP.lights.header.channelsPerLight; i++) layerP.layers[view - 1]->setLight(select, &value, i, 1);

src/MoonLight/Modules/ModuleLightsControl.h

@@ -41,7 +41,7 @@ class ModuleLightsControl : public Module {
 
     EXT_LOGI(ML_TAG, "Lights:%d(Header:%d) L-H:%d Node:%d PL:%d(PL-L:%d) VL:%d PM:%d C3D:%d", sizeof(Lights), sizeof(LightsHeader), sizeof(Lights) - sizeof(LightsHeader), sizeof(Node), sizeof(PhysicalLayer), sizeof(PhysicalLayer) - sizeof(Lights), sizeof(VirtualLayer), sizeof(PhysMap), sizeof(Coord3D));
 
-    EXT_LOGI(ML_TAG, "isInPSRAM: mt:%d mti:%d ch:%d", isInPSRAM(layerP.layers[0]->mappingTable), isInPSRAM(layerP.layers[0]->mappingTableIndexes.data()), isInPSRAM(layerP.lights.channels));
+    EXT_LOGI(ML_TAG, "isInPSRAM: mt:%d mti:%d ch:%d", isInPSRAM(layerP.layers[0]->mappingTable), isInPSRAM(layerP.layers[0]->mappingTableIndexes.data()), isInPSRAM(layerP.lights.channelsE));
 
     setPresetsFromFolder();  // set the right values during boot
 
@@ -356,9 +356,9 @@ class ModuleLightsControl : public Module {
       read([&](ModuleState& _state) {
         if (_socket->getConnectedClients() && _state.data["monitorOn"]) {
           _socket->emitEvent("monitor", (char*)&layerP.lights.header, 37);                                                                    // sizeof(LightsHeader)); //sizeof(LightsHeader), nearest prime nr above 32 to avoid monitor data to be seen as header
-          _socket->emitEvent("monitor", (char*)layerP.lights.channels, MIN(layerP.lights.header.nrOfLights * 3, layerP.lights.maxChannels));  //*3 is for 3 bytes position
+          _socket->emitEvent("monitor", (char*)layerP.lights.channelsE, MIN(layerP.lights.header.nrOfLights * 3, layerP.lights.maxChannels));  //*3 is for 3 bytes position
         }
-        memset(layerP.lights.channels, 0, layerP.lights.maxChannels);  // set all the channels to 0 //cleaning the positions
+        memset(layerP.lights.channelsE, 0, layerP.lights.maxChannels);  // set all the channels to 0 //cleaning the positions
         EXT_LOGD(ML_TAG, "positions sent to monitor (2 -> 3, #L:%d maxC:%d)", layerP.lights.header.nrOfLights, layerP.lights.maxChannels);
         layerP.lights.header.isPositions = 3;
       });
@@ -372,7 +372,7 @@ class ModuleLightsControl : public Module {
             extern SemaphoreHandle_t swapMutex;
 
             xSemaphoreTake(swapMutex, portMAX_DELAY);
-            _socket->emitEvent("monitor", (char*)layerP.lights.channels, MIN(layerP.lights.header.nrOfChannels, layerP.lights.maxChannels));
+            _socket->emitEvent("monitor", (char*)layerP.lights.channelsE, MIN(layerP.lights.header.nrOfChannels, layerP.lights.maxChannels));
             xSemaphoreGive(swapMutex);
           }
         });

src/MoonLight/Nodes/Drivers/D_ArtnetIn.h

@@ -130,7 +130,7 @@ class ArtNetInDriver : public Node {
             int ledIndex = startPixel + i;
             if (ledIndex < layerP.lights.header.nrOfLights) {
               if (layer == 0) {  // Physical layer
-                memcpy(&layerP.lights.channels[ledIndex * layerP.lights.header.channelsPerLight], &dmxData[i * layerP.lights.header.channelsPerLight], layerP.lights.header.channelsPerLight);
+                memcpy(&layerP.lights.channelsE[ledIndex * layerP.lights.header.channelsPerLight], &dmxData[i * layerP.lights.header.channelsPerLight], layerP.lights.header.channelsPerLight);
               } else {  // Virtual layer
                 layerP.layers[layer - 1]->setLight(ledIndex, &dmxData[i * layerP.lights.header.channelsPerLight], 0, layerP.lights.header.channelsPerLight);
               }
@@ -160,7 +160,7 @@ class ArtNetInDriver : public Node {
         int ledIndex = startPixel + i;
         if (ledIndex < layerP.lights.header.nrOfLights) {
           if (layer == 0) {  // Physical layer
-            memcpy(&layerP.lights.channels[ledIndex * layerP.lights.header.channelsPerLight], &pixelData[i * layerP.lights.header.channelsPerLight], layerP.lights.header.channelsPerLight);
+            memcpy(&layerP.lights.channelsE[ledIndex * layerP.lights.header.channelsPerLight], &pixelData[i * layerP.lights.header.channelsPerLight], layerP.lights.header.channelsPerLight);
           } else {  // Virtual layer
             layerP.layers[layer - 1]->setLight(ledIndex, &pixelData[i * layerP.lights.header.channelsPerLight], 0, layerP.lights.header.channelsPerLight);
           }