Update docs IO, parlio LUT tables

Back-end
========
- Module IO: add pin_RS485, add more pins to board_MHCP4Nano
- Parlio: remove brightness argument and use ledsDriver lut tables

Author: ewowi

docs/moonbase/inputoutput.md

@@ -10,10 +10,10 @@ Currently the following boards are defined. Not all are supported yet 🚧
 
 For each board the following presets are defined:
 
-* Modded: if any change to the default preset is made.
+* Modded: if any change to the default preset is made. Press off to go back to standard. If any pin is not default, modded will be set.
 * Max Power in Watts: adjust the brightness to approach this max power, depending on the number of LEDs used. Default 10: 5V * 2A = 10W (so it runs fine on USB). Used by LED drivers, see [Drivers](../../moonlight/drivers/)
 * Jumper1: If the board contains a jumper, it can define pin behaviour. Eg. select between Infrared and Ethernet.
-* Pins: This module is the central place to assign functionality to gpio pins. Other modules and nodes use the pin assignments made here.
+* Pins: Assign functionality to gpio pins. Other modules and nodes use the pin assignments made here.
     * GPIO = gpio_num;
     * Usage: See below
     * Index: specify first, second, third, ... usage output, e.g. LED D01 to LED D16
@@ -59,13 +59,21 @@ For each board the following presets are defined:
 * [Dig 2Go](https://quinled.info/quinled-dig2go/), [Dig Uno](https://quinled.info/pre-assembled-quinled-dig-uno/), [Dig Quad](https://quinled.info/pre-assembled-quinled-dig-quad/): Choose the esp32-d0 (4MB) board in the [MoonLight Installer](../../gettingstarted/installer/) 
 * [Dig Octa](https://quinled.info/quinled-dig-octa/): Choose the esp32-d0-16mb board in the [MoonLight Installer](../../gettingstarted/installer/) 
 * On first install, erase flash first (Especially when other firmware like WLED was on it) as MoonLight uses a partition scheme with 3MB of flash (currently no OTA support).
-* You might need to reset your router if you first run WLED on the same MCU and no new IP is assigned.
+* After install, select the QuinLED board preset to have the pins assigned correctly.
+
+!!! tip "Reset router"
+    You might need to reset your router if you first run WLED on the same board and no new IP is assigned.
 
 !!! Tip "Dig Uno USB"
     Remove fuse to connect USB cable to flash the board.
 
 ### MyHome-Control ESP32-P4 shield
 
+* Choose the esp32-p4-nano board in the [MoonLight Installer](../../gettingstarted/installer/) 
+* On new boards, the WiFi coprocessor needs to be updated first to a recent version, currently v2.0.17, see the link in the [MoonLight Installer](../../gettingstarted/installer/)
+* After install, select the MHC P4 shield board preset to have the pins assigned correctly.
+* Add the Parallel LED Driver, see [Drivers](). It uses @troyhacks his parallel IO driver to drive all the 12 LED pins of the P4 shield.
+
 ![ESP32-P4 shield](https://shop.myhome-control.de/thumbnail/87/41/c2/1762031307/WLED_ESP32_P4_Shield_02_1920x1326.jpg?ts=1762031315){: style="width:320px"}
 
 [ESP32-P4 shield](https://shop.myhome-control.de/en/ABC-WLED-ESP32-P4-shield/HW10027)

platformio.ini

@@ -56,7 +56,7 @@ build_flags =
     -D BUILD_TARGET=\"$PIOENV\"
     -D APP_NAME=\"MoonLight\" ; 🌙 Must only contain characters from [a-zA-Z0-9-_] as this is converted into a filename
     -D APP_VERSION=\"0.6.1\" ; semver compatible version string
-    -D APP_DATE=\"2025120714\" ; 🌙
+    -D APP_DATE=\"2025121212\" ; 🌙
 
     -D PLATFORM_VERSION=\"pioarduino-55.03.34\" ; 🌙 make sure it matches with above plaftform
 

src/MoonBase/Modules/ModuleIO.h

@@ -58,6 +58,7 @@ enum IO_PinUsage {
   pin_SPI_MOSI,
   pin_PHY_CS,
   pin_PHY_IRQ,
+  pin_RS485,
   pin_Reserved,
   pin_count
 };
@@ -180,6 +181,7 @@ class ModuleIO : public Module {
       addControlValue(control, "SPI MOSI");
       addControlValue(control, "PHY CS");
       addControlValue(control, "PHY IRQ");
+      addControlValue(control, "RS-485");
       addControlValue(control, "Reserved");
 
       control = addControl(rows, "index", "number", 1, 32);  // max 32 of one type, e.g 32 led pins
@@ -377,6 +379,18 @@ class ModuleIO : public Module {
       object["maxPower"] = 10;                                                           // USB compliant
       uint8_t ledPins[16] = {21, 20, 25, 5, 7, 23, 8, 27, 3, 22, 24, 4, 46, 47, 2, 48};  // LED_PINS
       for (int i = 0; i < sizeof(ledPins); i++) pinAssigner.assignPin(ledPins[i], pin_LED);
+      pinAssigner.assignPin(33, pin_I2S_SD);
+      pinAssigner.assignPin(26, pin_I2S_WS);
+      pinAssigner.assignPin(32, pin_I2S_SCK);
+      pinAssigner.assignPin(36, pin_I2S_MCLK);
+      pinAssigner.assignPin(3, pin_RS485);
+      pinAssigner.assignPin(4, pin_RS485);
+      pinAssigner.assignPin(22, pin_RS485);
+      pinAssigner.assignPin(24, pin_RS485);
+      pinAssigner.assignPin(2, pin_Exposed);
+      pinAssigner.assignPin(46, pin_Exposed);
+      pinAssigner.assignPin(47, pin_Exposed);
+      pinAssigner.assignPin(48, pin_Exposed);
     } else if (boardID == board_YvesV48) {
       pinAssigner.assignPin(3, pin_LED);
     } else if (boardID == board_TroyP4Nano) {

src/MoonLight/Nodes/Drivers/D_ParallelLEDDriver.h

@@ -52,15 +52,18 @@ class ParallelLEDDriver : public DriverNode {
     if (!initDone) return;
 
     if (layer->layerP->lights.header.isPositions == 0) {
-      DriverNode::loop();
+      DriverNode::loop();  // This populates the LUT tables!
 
       uint8_t nrOfPins = min(layerP.nrOfLedPins, layerP.nrOfAssignedPins);
 
     #ifndef CONFIG_IDF_TARGET_ESP32P4
       if (ledsDriver.total_leds > 0) ledsDriver.showPixels(WAIT);
     #else
-      show_parlio(pins, layer->layerP->lights.header.nrOfLights, layer->layerP->lights.channels, ledsDriver._brightness, layer->layerP->lights.header.channelsPerLight == 4, nrOfPins, layer->layerP->ledsPerPin[0],  // different ledsPerPin not supported yet
-                  layer->layerP->lights.header.offsetRed, layer->layerP->lights.header.offsetGreen, layer->layerP->lights.header.offsetBlue);
+      // Pass the LUT tables instead of brightness
+      // No brightness parameter - LUTs are accessed directly!
+      show_parlio(pins, layer->layerP->lights.header.nrOfLights, layer->layerP->lights.channels,
+                  // REMOVED: ledsDriver._brightness,
+                  layer->layerP->lights.header.channelsPerLight == 4, nrOfPins, layer->layerP->ledsPerPin[0], layer->layerP->lights.header.offsetRed, layer->layerP->lights.header.offsetGreen, layer->layerP->lights.header.offsetBlue);
     #endif
     }
   #else  // ESP32_LEDSDRIVER

src/MoonLight/Nodes/Drivers/parlio.cpp

@@ -16,14 +16,17 @@
   #include "driver/parlio_tx.h"
   #include "portmacro.h"
 
+// Access the global LED driver to use its LUT tables directly
+  #include "I2SClocklessLedDriver.h"
+extern I2SClocklessLedDriver ledsDriver;
+
 // --- Namespace for specialized, high-performance worker functions ---
 namespace LedMatrixDetail {
 
 // This intermediate step is common to all packing functions.
 // It transposes the data for 32 time-slices into a cache-friendly temporary buffer.
 inline void transpose_32_slices(uint32_t (&transposed_slices)[32],  // Output buffer (on stack)
-                                const uint8_t* input_buffer, const uint32_t pixel_in_pin, const uint32_t component_in_pixel, const uint32_t pixels_per_pin, const uint32_t num_active_pins,
-                                const uint32_t COMPONENTS_PER_PIXEL, const uint32_t* waveform_cache, const uint8_t* brightness_cache) {
+                                const uint8_t* input_buffer, const uint32_t pixel_in_pin, const uint32_t component_in_pixel, const uint32_t pixels_per_pin, const uint32_t num_active_pins, const uint32_t COMPONENTS_PER_PIXEL, const uint32_t* waveform_cache, const uint8_t* brightness_cache) {
   memset(transposed_slices, 0, sizeof(uint32_t) * 32);
 
   for (uint32_t pin = 0; pin < num_active_pins; ++pin) {
@@ -145,27 +148,23 @@ uint8_t gamma8(uint8_t b) {  // we do nothing with gamma for now
 }
 
 // 1. Add the RGB offsets parameter to the function signature
-void create_transposed_led_output_optimized(const uint8_t* input_buffer, uint16_t* output_buffer, const uint32_t pixels_per_pin, const uint32_t num_active_pins, const bool is_rgbw, const uint8_t bri,
-                                            const uint8_t offsetR, const uint8_t offsetG, const uint8_t offsetB) {
+void create_transposed_led_output_optimized(const uint8_t* input_buffer, uint16_t* output_buffer, const uint32_t pixels_per_pin, const uint32_t num_active_pins, const bool is_rgbw, const uint8_t offsetR, const uint8_t offsetG, const uint8_t offsetB) {
+  // Only keep waveform cache (for WS2812 protocol timing)
   static uint32_t waveform_cache[256];
-  static uint8_t brightness_cache[256];
-  static uint8_t last_bri = 0;
+  static bool waveform_cache_initialized = false;
 
   static const uint16_t bitpatterns[16] = {
-      0b1000100010001000, 0b1000100010001110, 0b1000100011101000, 0b1000100011101110, 0b1000111010001000, 0b1000111010001110, 0b1000111011101000, 0b1000111011101110,
-      0b1110100010001000, 0b1110100010001110, 0b1110100011101000, 0b1110100011101110, 0b1110111010001000, 0b1110111010001110, 0b1110111011101000, 0b1110111011101110,
+      0b1000100010001000, 0b1000100010001110, 0b1000100011101000, 0b1000100011101110, 0b1000111010001000, 0b1000111010001110, 0b1000111011101000, 0b1000111011101110, 0b1110100010001000, 0b1110100010001110, 0b1110100011101000, 0b1110100011101110, 0b1110111010001000, 0b1110111010001110, 0b1110111011101000, 0b1110111011101110,
   };
 
-  if (bri != last_bri) {
-    for (int i = 0; i < 256; ++i) {
-      brightness_cache[i] = (gamma8(i) * bri) >> 8;
-    }
+  // Initialize waveform cache ONCE (doesn't depend on brightness)
+  if (!waveform_cache_initialized) {
     for (int i = 0; i < 256; ++i) {
       const uint16_t p1 = bitpatterns[i >> 4];
       const uint16_t p2 = bitpatterns[i & 0x0F];
       waveform_cache[i] = (uint32_t(p2) << 16) | p1;
     }
-    last_bri = bri;
+    waveform_cache_initialized = true;
   }
 
   const uint32_t COMPONENTS_PER_PIXEL = is_rgbw ? 4 : 3;
@@ -191,6 +190,7 @@ void create_transposed_led_output_optimized(const uint8_t* input_buffer, uint16_
 
   uint8_t* out_base_ptr = reinterpret_cast<uint8_t*>(output_buffer);
 
+  // Component mapping for color order
   uint8_t component_map[4] = {0, 1, 2, 3};  // Default to RGB(W)
   component_map[0] = offsetR;
   component_map[1] = offsetG;
@@ -205,6 +205,26 @@ void create_transposed_led_output_optimized(const uint8_t* input_buffer, uint16_
 
       uint32_t transposed_slices[32];
 
+      // Select the appropriate LUT based on which INPUT channel we're processing
+      const uint8_t* brightness_cache;
+      switch (component_in_pixel) {
+      case 0:
+        brightness_cache = ledsDriver.__red_map;
+        break;
+      case 1:
+        brightness_cache = ledsDriver.__green_map;
+        break;
+      case 2:
+        brightness_cache = ledsDriver.__blue_map;
+        break;
+      case 3:
+        brightness_cache = ledsDriver.__white_map;
+        break;
+      default:
+        brightness_cache = ledsDriver.__red_map;
+        break;  // Fallback
+      }
+
       LedMatrixDetail::transpose_32_slices(transposed_slices, input_buffer, pixel_in_pin, input_component, pixels_per_pin, num_active_pins, COMPONENTS_PER_PIXEL, waveform_cache, brightness_cache);
 
       const uint32_t component_start_word = (pixel_in_pin * WAVEFORM_WORDS_PER_PIXEL) + (component_in_pixel * 32);
@@ -241,8 +261,7 @@ parlio_transmit_config_t transmit_config = {.idle_value = 0x00,  // the idle val
 
 static portMUX_TYPE parlio_spinlock = portMUX_INITIALIZER_UNLOCKED;
 
-uint8_t IRAM_ATTR __attribute__((hot)) show_parlio(uint8_t* parallelPins, uint32_t length, uint8_t* buffer_in, uint8_t bri, bool isRGBW, uint8_t outputs, uint16_t leds_per_output, uint8_t offSetR,
-                                                   uint8_t offsetG, uint8_t offsetB) {
+uint8_t IRAM_ATTR __attribute__((hot)) show_parlio(uint8_t* parallelPins, uint32_t length, uint8_t* buffer_in, bool isRGBW, uint8_t outputs, uint16_t leds_per_output, uint8_t offSetR, uint8_t offsetG, uint8_t offsetB) {
   if (length != outputs * leds_per_output) {
     delay(100);
     Serial.printf("Parallel IO isn't set correctly. Check length, outputs, and LEDs per output. (%d != %d x %d)\n", length, outputs, leds_per_output);
@@ -299,7 +318,7 @@ uint8_t IRAM_ATTR __attribute__((hot)) show_parlio(uint8_t* parallelPins, uint32
     parlio_config.flags.invert_valid_out = 0;
 
     if (parlio_tx_unit != NULL) {
-      ESP_ERROR_CHECK(parlio_tx_unit_wait_all_done(parlio_tx_unit, -1));
+      ESP_ERROR_CHECK(parlio_tx_unit_wait_all_done(parlio_tx_unit, portMAX_DELAY));  // wait forever
       ESP_ERROR_CHECK(parlio_tx_unit_disable(parlio_tx_unit));
       ESP_ERROR_CHECK(parlio_del_tx_unit(parlio_tx_unit));
       parlio_tx_unit = NULL;
@@ -364,7 +383,7 @@ uint8_t IRAM_ATTR __attribute__((hot)) show_parlio(uint8_t* parallelPins, uint32
     //  offsetB = 2;
   #endif
 
-  create_transposed_led_output_optimized(parallel_buffer_remapped, parallel_buffer_repacked, leds_per_output, outputs, isRGBW, bri, offSetR, offsetG, offsetB);
+  create_transposed_led_output_optimized(parallel_buffer_remapped, parallel_buffer_repacked, leds_per_output, outputs, isRGBW, offSetR, offsetG, offsetB);
 
   // Calculate the exact size of ONE PIXEL's data in bits and bytes.
   const uint32_t symbols_per_pixel = isRGBW ? 128 : 96;

src/MoonLight/Nodes/Drivers/parlio.h

@@ -14,6 +14,5 @@
 
 #if FT_MOONLIGHT
 
-uint8_t show_parlio(uint8_t* parallelPins, uint32_t length, uint8_t* buffer_in, uint8_t bri, bool isRGBW, uint8_t outputs, uint16_t leds_per_output, uint8_t offSetR, uint8_t offsetG, uint8_t offsetB);
-
+uint8_t show_parlio(uint8_t* parallelPins, uint32_t length, uint8_t* buffer_in, bool isRGBW, uint8_t outputs, uint16_t leds_per_output, uint8_t offSetR, uint8_t offsetG, uint8_t offsetB);
 #endif