Need to check DMX input implementation

[DedeHai]

What happened?

just got this on an S3 coming back from 17.0 to 16_x:

PIN ALLOC: FAIL GPIO 0 already allocated by 0x85.
PIN ALLOC: FAIL GPIO 0 already allocated by 0x85.
PIN ALLOC: FAIL GPIO 0 already allocated by 0x85.
DMXInput: Error: Failed to allocate Guru Meditation Error: Core  1 panic'ed (LoadProhibited). Exception was unhandled.

needs checking, may be related to debug output enabled.

To Reproduce Bug

no idea, just popped up at random.

Expected Behavior

dont crash if pins not available.

Install Method

Self-Compiled

What version of WLED?

16_x

Which microcontroller/board are you seeing the problem on?

ESP32-S3

Relevant log/trace output

Anything else?

No response

Code of Conduct

• I agree to follow this project's Code of Conduct

[softhack007]

@DedeHai did it happen with main, or in 16_x ?
In main, dmx_input.cpp currently is a complete mess, cleaning that up is still on my toDo list 😇

[softhack007]

@coderabbitai the last error message is from this line

WLED/wled00/dmx_input.cpp

Line 153 in 4a2ec65

DEBUG_PRINTF("DMXInput: Error: Failed to allocate pins for DMX_INPUT. Pins already in use:\n");

please check how a failed init will lead to a crash with access violation.

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

target_commit="4a2ec656a8ef0fcedfbcdb93d88eba222e834cef"
file="wled00/dmx_input.cpp"

if git cat-file -e "${target_commit}:${file}" 2>/dev/null; then
  git show "${target_commit}:${file}" > /tmp/dmx_input.cpp
  echo "=== cited revision: AST outline ==="
  ast-grep outline /tmp/dmx_input.cpp --items all || true
  echo "=== cited revision: complete numbered source ==="
  nl -ba /tmp/dmx_input.cpp
else
  echo "Cited revision is not available locally; inspecting the repository copy instead."
  ast-grep outline "${file}" --items all || true
  nl -ba "${file}"
fi

echo "=== DMX initialization and input-object use sites ==="
rg -n -C 5 --glob '*.{cpp,c,h,hpp,ino}' \
  '(dmxInput|dmx_input|DMX.*init|\.init\s*\(|->init\s*\(|DMX_ERROR|begin\s*\()' \
  wled00 2>/dev/null || true

echo "=== configuration/lifecycle entry points referring to DMX input ==="
rg -n -C 4 --glob '*.{cpp,c,h,hpp,ino}' \
  '(handleDMX|initDMX|e131|DMXInput|dmxInput)' \
  wled00 2>/dev/null || true

Length of output: 2150

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

target_commit="4a2ec656a8ef0fcedfbcdb93d88eba222e834cef"
file="wled00/dmx_input.cpp"

echo "=== cited revision: dmx_input.cpp Lines 1–280 ==="
git show "${target_commit}:${file}" |
  awk 'NR <= 280 { printf "%4d  %s\n", NR, $0 }'

echo "=== DMXInput header candidates ==="
fd -a '^dmx_input\.h$' . -x sh -c '
  echo "=== $1 ==="
  awk "{ printf \"%4d  %s\\n\", NR, \$0 }" "$1"
' sh {}

echo "=== DMXInput definitions, construction, init, and use (all source files) ==="
rg -n -C 8 --glob '*.{cpp,c,h,hpp,ino}' \
  '(\bDMXInput\b|\.init\s*\([^;]*\)|->init\s*\([^;]*\)|\bdmxInput\b|\bdmx\s*=\s*new)' \
  . 2>/dev/null || true

echo "=== DMX/FreeRTOS APIs used by the cited file ==="
git show "${target_commit}:${file}" |
  rg -n -C 3 '(dmx_|xTaskCreate|vTaskDelete|pdPASS|ESP_ERROR|esp_err)' || true

Length of output: 46793

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

target_commit="4a2ec656a8ef0fcedfbcdb93d88eba222e834cef"

echo "=== cited init failure/task-creation branch (dmx_input.cpp Lines 125–176) ==="
git show "${target_commit}:wled00/dmx_input.cpp" |
  awk 'NR >= 125 && NR <= 176 { printf "%4d  %s\n", NR, $0 }'

echo "=== PinManager symbols in the cited revision ==="
git grep -n -E \
  '(getPinOwner|allocateMultiplePins|deallocateMultiplePins|class[[:space:]]+PinManager)' \
  "${target_commit}" -- ':*.h' ':*.cpp' ':*.c' || true

echo "=== all cited getPinOwner call sites with format context ==="
git grep -n -C 3 'getPinOwner' "${target_commit}" -- ':*.h' ':*.cpp' ':*.c' || true

echo "=== candidate PinManager implementation files, cited revision ==="
git ls-tree -r --name-only "${target_commit}" |
  rg -i '(^|/)(pin.?manager|pinmanager)\.(h|hpp|c|cpp)$' || true

Length of output: 21229

---

@softhack007, confirmed: the failed init() is not what later dereferences an invalid DMXInput. The crash occurs inside the error-reporting branch immediately after the Line 153 message.

In commit 4a2ec656…:

DEBUG_PRINTF("rx in use by: %s\n", PinManager::getPinOwner(rxPin));

PinManager::getPinOwner() returns a PinOwner enum, not a const char*. Passing that enum to %s makes printf interpret its small integer value as a string address, causing the access violation while attempting to read that address. The same defect exists for TX and EN on Lines 155–156.

That explains why the Line 153 diagnostic is the last message printed.

The type-correct string logging is:

DEBUG_PRINTF("rx in use by: %s\n", PinManager::getPinOwnerName(rxPin));
DEBUG_PRINTF("tx in use by: %s\n", PinManager::getPinOwnerName(txPin));
DEBUG_PRINTF("en in use by: %s\n", PinManager::getPinOwnerName(enPin));

Alternatively, log static_cast<unsigned>(PinManager::getPinOwner(...)) with an integer format specifier.

The rest of the allocation-failure flow is safe: it returns before task creation; initialized remains false; and the periodic dmxInput.update() does not call DMX driver APIs unless the receiver task installed the driver successfully.

[DedeHai]

this was on 16_x

[softhack007]

@DedeHai i've fixed the bug the was spotted by @coderabbitai, please check if it works better now.

Unfortunately, we still need to check the dmx_input code in main - something still smells like "very wrong" in the handling of C-style strings.

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

file="wled00/dmx_input.cpp"

echo "=== Available main reference ==="
git rev-parse --verify main 2>/dev/null || git rev-parse --verify origin/main 2>/dev/null || true

ref="main"
if ! git cat-file -e "${ref}:${file}" 2>/dev/null; then
  ref="origin/main"
fi

echo "=== ${ref}:${file}: AST outline ==="
git show "${ref}:${file}" > /tmp/dmx_input_main.cpp
ast-grep outline /tmp/dmx_input_main.cpp --items all || true

echo "=== C-style string, formatting, and diagnostic operations ==="
nl -ba /tmp/dmx_input_main.cpp | rg -n -C 5 \
  '(char\s*\*|char\[|str(?:cpy|ncpy|cat|ncat|len|cmp|ncmp)|sn?printf|vsn?printf|sprintf|printf|DEBUG_PRINTF|%[-+ `#0-9`.*]*[sScC]|reinterpret_cast|static_cast)'

echo "=== Complete main-branch source, bounded to the file ==="
nl -ba /tmp/dmx_input_main.cpp

echo "=== Referenced project symbols and DMXInput lifecycle call sites ==="
rg -n -C 4 --glob '*.{cpp,c,h,hpp,ino}' \
  '(\bDMXInput\b|\bdmxInput\b|PinManager::getPinOwner(?:Name)?\s*\(|DEBUG_PRINTF\s*\()' \
  wled00 2>/dev/null || true

Length of output: 2343

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

ref="main"
file="wled00/dmx_input.cpp"
git show "${ref}:${file}" > /tmp/dmx_input_main.cpp

echo "=== ${ref}:${file}: all string/formatting-sensitive lines with context ==="
awk '{ printf "%4d  %s\n", NR, $0 }' /tmp/dmx_input_main.cpp |
  rg -n -C 6 \
  '(char\s*\*|char\s+[[:alnum:]_]+\s*\[|str(?:cpy|ncpy|cat|ncat|len|cmp|ncmp)\s*\(|sn?printf\s*\(|vsn?printf\s*\(|sprintf\s*\(|printf\s*\(|DEBUG_PRINTF\s*\(|%[-+ `#0-9`.*]*[sScC]|reinterpret_cast|static_cast)'

echo "=== ${ref}:${file}: complete numbered source ==="
awk '{ printf "%4d  %s\n", NR, $0 }' /tmp/dmx_input_main.cpp

echo "=== dmx_input.h candidates and declarations ==="
while IFS= read -r header; do
  echo "--- ${header} ---"
  awk '{ printf "%4d  %s\n", NR, $0 }' "${header}"
done < <(fd -a '^dmx_input\.h$' .)

echo "=== Pin owner API declarations/definitions and format-string call sites ==="
rg -n -C 5 --glob '*.{cpp,c,h,hpp,ino}' \
  '(getPinOwner(?:Name)?\s*\(|(?:DEBUG_)?PRINTF\s*\([^;]*%[-+ `#0-9`.*]*[sScC])' \
  wled00 2>/dev/null || true

Length of output: 22279

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "=== Local dmx_input.h ==="
header="$(fd -a '^dmx_input\.h$' . | head -n 1 || true)"
if [ -n "${header}" ]; then
  awk '{ printf "%4d  %s\n", NR, $0 }' "${header}"
else
  echo "No local dmx_input.h found."
fi

echo "=== Local definitions/usages of dmx_config_t and software_version_label ==="
rg -n -C 6 --glob '*.{h,hpp,c,cpp,ino,json,ini,yml,yaml}' \
  '(\bdmx_config_t\b|\bsoftware_version_label\b|\bdmx_driver_install\s*\()' \
  . 2>/dev/null || true

echo "=== Dependency declarations likely to pin/provide the DMX library ==="
rg -n -C 4 --glob '{platformio.ini,platformio_override.ini,library.json,package.json,*.ini,*.json,*.yml,*.yaml}' \
  '(dmx|esp_dmx|rdm|espressif)' \
  . 2>/dev/null || true

echo "=== Main file: all config construction and driver-install lines ==="
git show main:wled00/dmx_input.cpp |
  awk 'NR >= 45 && NR <= 175 { printf "%4d  %s\n", NR, $0 }'

Length of output: 31265

---

🤖 web_search executed:

In GitHub repository someweisguy/esp_dmx commit 47db25d8c515e76fabcf5fc5ab0b786f98eeade0, find the definition of dmx_config_t software_version_label and the implementation of dmx_driver_install. Does dmx_driver_install copy or retain the software_version_label pointer?

Length of output: 10469

---

@softhack007, you were right to be suspicious: main has a real C-string lifetime bug in wled00/dmx_input.cpp.

On Lines 88–92, the active fallback path does this:

const std::string DmxVersionString = "WLED_V" + std::to_string(VERSION);
config.software_version_label = DmxVersionString.c_str();
return config;

DmxVersionString is destroyed when createConfig() returns, so software_version_label is already dangling before dmx_driver_install(inputPortNum, &config, ...) consumes the configuration on Line 151. ESP-DMX declares this field as const char * and uses the configuration for permanent driver/RDM responder settings, including the software-version-label response (API definition, documentation).

A safe minimal correction is to give the string static lifetime:

static const std::string dmxVersionString = "WLED_V" + std::to_string(VERSION);
config.software_version_label = dmxVersionString.c_str();

The personality strncpy() calls on Lines 100–127 are not the immediate problem: all current literals fit in the ESP-DMX description[33] buffer. The disabled #if 0 code should remain disabled as written, though—it treats software_version_label as an array despite the active ESP-DMX API defining it as a pointer.

---

If you found this review helpful, would you consider giving us a shout-out on X?

Thank you for using CodeRabbit!

[softhack007]

🤔 dmx_input currently does a kind of stretch between two versions of the library:

• esp-idf v4 builds use https://github.com/someweisguy/esp_dmx.git#47db25d8c515e76fabcf5fc5ab0b786f98eeade0
• while esp-idf v5 build use an adjusted version https://github.com/netmindz/esp_dmx/#esp-idf-v5-fixes
• the current code in main is a merge-up of code to support both API's, but its mainly targeted at V5 builds
• the last "known good" source code is directly before the V5 merge, for example in the 16_x branch https://github.com/wled/WLED/tree/16_x

@coderabbitai please

• compare the two API versions of esp_dmx (i.e. the ones used in V5 and V4 build)
• check if the current code in main correctly handles both library API revisions.
• check if there are functional differences in the "V5" and "V4" sections of our dmx_input.* code.
• check if the previous functionality (from 16_x branch) is fully preserved in the dmx input code in main
• look for remaining bugs that might be introduced by our effort to support esp-idv V5
• suggest source code improvements

The ultimate goal is to have dmx_input working with the new esp-idf V5.5.x framework, and replace the temporary fork of netmindz with a new upstream release. the "V4" build has lower priority, so we could live with a reduces feature set in for V4 esp32 builds.

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '=== WLED refs ==='
git branch -a --no-color | sed -n '1,120p'
for ref in main origin/main 16_x origin/16_x; do
  if git rev-parse --verify -q "$ref" >/dev/null; then
    printf '%s: ' "$ref"
    git rev-parse "$ref"
  fi
done

echo '=== DMX-related files in each available ref ==='
for ref in main origin/main 16_x origin/16_x; do
  if git rev-parse --verify -q "$ref" >/dev/null; then
    echo "--- $ref ---"
    git ls-tree -r --name-only "$ref" | rg '(^|/)(dmx_input\.(cpp|h|hpp)|platformio.*\.(ini|py)|.*dmx.*\.(ini|json|yml|yaml))$' || true
  fi
done

echo '=== main vs 16_x diff for DMX source/config (when both refs exist) ==='
main_ref=""
old_ref=""
for ref in main origin/main; do git cat-file -e "$ref:wled00/dmx_input.cpp" 2>/dev/null && { main_ref="$ref"; break; }; done
for ref in 16_x origin/16_x; do git cat-file -e "$ref:wled00/dmx_input.cpp" 2>/dev/null && { old_ref="$ref"; break; }; done
if [ -n "$main_ref" ] && [ -n "$old_ref" ]; then
  git diff --no-ext-diff --unified=80 "$old_ref" "$main_ref" -- wled00/dmx_input.cpp wled00/dmx_input.h || true
fi

echo '=== Main DMX source and header outline/source ==='
if [ -n "$main_ref" ]; then
  git show "$main_ref:wled00/dmx_input.cpp" > /tmp/wled-main-dmx_input.cpp
  ast-grep outline /tmp/wled-main-dmx_input.cpp --items all || true
  nl -ba /tmp/wled-main-dmx_input.cpp
  git show "$main_ref:wled00/dmx_input.h" 2>/dev/null | nl -ba || true
fi

echo '=== All WLED DMX dependency/version and conditional-selector references ==='
rg -n -C 4 --glob '*.{ini,py,json,yml,yaml,h,hpp,c,cpp,ino}' \
  '(esp_dmx|ESP_IDF_VERSION|ESP_IDF|IDF_VER|dmx_input|DMX_.*(V[45]|VERSION)|software_version_label|dmx_config_t)' \
  . || true

Length of output: 3509

---

🤖 web_search executed:

`Compare public GitHub source APIs between:

1. someweisguy/esp_dmx at commit 47db25d8c515e76fabcf5fc5ab0b786f98eeade0
2. netmindz/esp_dmx branch esp-idf-v5-fixes

Find the exact branch head SHA for netmindz. Identify changes to public headers and implementations relevant to WLED DMX input: dmx_config_t, dmx_personality_t, dmx_driver_install/delete, dmx_receive, dmx_read, dmx_set_pin, dmx_set_mode, dmx_start/stop, UART/FreeRTOS/ESP-IDF version conditionals, config pointer ownership (especially software_version_label), and any changed error/status semantics. Include GitHub source links and commit references.`

Length of output: 15400

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

numbered() { awk '{ printf "%4d  %s\n", NR, $0 }' "$1"; }
fetch_raw() {
  url="$1"
  out="$2"
  curl -fsSL --retry 2 "$url" -o "$out"
}

mkdir -p /tmp/dmx-review

echo '=== WLED main source/header/config excerpts ==='
for path in wled00/dmx_input.cpp wled00/dmx_input.h platformio.ini; do
  safe="$(printf '%s' "$path" | tr '/' '_')"
  fetch_raw "https://raw.githubusercontent.com/wled/WLED/main/$path" "/tmp/dmx-review/main_$safe"
  echo "--- main/$path ---"
  numbered "/tmp/dmx-review/main_$safe"
done

echo '=== WLED 16_x source/header/config excerpts ==='
for path in wled00/dmx_input.cpp wled00/dmx_input.h platformio.ini; do
  safe="$(printf '%s' "$path" | tr '/' '_')"
  fetch_raw "https://raw.githubusercontent.com/wled/WLED/16_x/$path" "/tmp/dmx-review/16x_$safe"
  echo "--- 16_x/$path ---"
  numbered "/tmp/dmx-review/16x_$safe"
done

echo '=== WLED dmx_input diff (16_x -> main) ==='
diff -u /tmp/dmx-review/16x_wled00_dmx_input.cpp /tmp/dmx-review/main_wled00_dmx_input.cpp || true
diff -u /tmp/dmx-review/16x_wled00_dmx_input.h /tmp/dmx-review/main_wled00_dmx_input.h || true

echo '=== WLED dependency declarations and conditional definitions ==='
rg -n -C 5 '(esp_dmx|ESP_IDF_VERSION|ESP_IDF|IDF_VER|ARDUINO_ESP32|DMX_)' \
  /tmp/dmx-review/main_platformio.ini \
  /tmp/dmx-review/16x_platformio.ini \
  platformio.ini platformio_override.sample.ini \
  wled00 2>/dev/null || true

echo '=== GitHub refs ==='
curl -fsSL 'https://api.github.com/repos/netmindz/esp_dmx/git/ref/heads/esp-idf-v5-fixes' \
 | jq '{ref:.ref, sha:.object.sha, type:.object.type}'
curl -fsSL 'https://api.github.com/repos/someweisguy/esp_dmx/commits/47db25d8c515e76fabcf5fc5ab0b786f98eeade0' \
 | jq '{sha:.sha, parents:[.parents[].sha], date:.commit.committer.date, message:.commit.message}'

echo '=== Recursive trees: relevant source paths ==='
v5_sha="$(curl -fsSL 'https://api.github.com/repos/netmindz/esp_dmx/git/ref/heads/esp-idf-v5-fixes' | jq -r '.object.sha')"
curl -fsSL "https://api.github.com/repos/netmindz/esp_dmx/git/trees/${v5_sha}?recursive=1" \
 | jq -r '.tree[] | select(.type=="blob") | .path' \
 | rg '(^|/)(types\.h|dmx\.h|uart\.c|driver\.c|.*driver.*\.c|.*uart.*\.h|CMakeLists\.txt)$' || true
curl -fsSL 'https://api.github.com/repos/someweisguy/esp_dmx/git/trees/47db25d8c515e76fabcf5fc5ab0b786f98eeade0?recursive=1' \
 | jq -r '.tree[] | select(.type=="blob") | .path' \
 | rg '(^|/)(types\.h|dmx\.h|uart\.c|driver\.c|.*driver.*\.c|.*uart.*\.h|CMakeLists\.txt)$' || true

Length of output: 231831

---

🤖 web_search executed:

GitHub API or GitHub source comparison for netmindz/esp_dmx branch esp-idf-v5-fixes versus someweisguy/esp_dmx commit 47db25d8c515e76fabcf5fc5ab0b786f98eeade0. Provide the branch-head SHA and a file-by-file diff or commit history. Focus specifically on src/dmx/include/types.h, public dmx driver headers, src/dmx/hal/uart.c, and driver install/config ownership. Do not use unrelated current upstream PRs.

Length of output: 12839

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

work=/tmp/dmx-api-compare
rm -rf "$work"
mkdir -p "$work"

echo '=== Resolve exact V5 branch head without GitHub REST API ==='
git ls-remote https://github.com/netmindz/esp_dmx.git refs/heads/esp-idf-v5-fixes | tee "$work/v5-ref.txt"
v5_sha="$(awk '{print $1}' "$work/v5-ref.txt")"
test -n "$v5_sha"

echo '=== Download source snapshots ==='
curl -fsSL --retry 3 \
  "https://codeload.github.com/someweisguy/esp_dmx/zip/47db25d8c515e76fabcf5fc5ab0b786f98eeade0" \
  -o "$work/v4.zip"
curl -fsSL --retry 3 \
  "https://codeload.github.com/netmindz/esp_dmx/zip/${v5_sha}" \
  -o "$work/v5.zip"
unzip -q "$work/v4.zip" -d "$work"
unzip -q "$work/v5.zip" -d "$work"
v4_dir="$(find "$work" -mindepth 1 -maxdepth 1 -type d -name 'esp_dmx-*' | head -n 1)"
v5_dir="$(find "$work" -mindepth 1 -maxdepth 1 -type d -name 'esp_dmx-*' | tail -n 1)"
printf 'v4_dir=%s\nv5_dir=%s\nv5_sha=%s\n' "$v4_dir" "$v5_dir" "$v5_sha"

echo '=== Relevant files ==='
for label_dir in "v4:$v4_dir" "v5:$v5_dir"; do
  label="${label_dir%%:*}"; dir="${label_dir#*:}"
  echo "--- $label ---"
  find "$dir" -type f \
    \( -name '*.h' -o -name '*.c' -o -name 'CMakeLists.txt' \) -print \
    | sed "s#^$dir/##" \
    | rg '(^|/)(esp_dmx\.h|types\.h|driver\.h|uart\.c|uart\.h|driver\.c|responder\.c|responder\.h|CMakeLists\.txt)$' || true
done

echo '=== API declaration extracts: v4 ==='
rg -n -C 8 \
 '(typedef struct dmx_config_t|typedef struct.*dmx_personality_t|dmx_driver_(install|delete|enable|disable)|dmx_(receive|read|set_pin|set_mode|start|stop)|rdm_register_dmx_(start_address|personality)|software_version_label|DMX_CONFIG_DEFAULT)' \
 "$v4_dir/src" || true

echo '=== API declaration extracts: v5 ==='
rg -n -C 8 \
 '(typedef struct dmx_config_t|typedef struct.*dmx_personality_t|dmx_driver_(install|delete|enable|disable)|dmx_(receive|read|set_pin|set_mode|start|stop)|rdm_register_dmx_(start_address|personality)|software_version_label|DMX_CONFIG_DEFAULT)' \
 "$v5_dir/src" || true

echo '=== Focused source diffs (API and implementation) ==='
for rel in \
  src/dmx/include/types.h \
  src/dmx/include/driver.h \
  src/dmx/hal/uart.c \
  src/rdm/include/responder.h \
  src/rdm/responder.c \
  src/dmx/driver.c; do
  if [ -f "$v4_dir/$rel" ] || [ -f "$v5_dir/$rel" ]; then
    echo "--- $rel ---"
    diff -u "$v4_dir/$rel" "$v5_dir/$rel" || true
  fi
done

echo '=== Config retention / copy evidence in driver implementations ==='
for label_dir in "v4:$v4_dir" "v5:$v5_dir"; do
  label="${label_dir%%:*}"; dir="${label_dir#*:}"
  echo "--- $label ---"
  rg -n -C 10 \
   '(dmx_driver_install|software_version_label|memcpy\s*\(|config\s*=|->config|dmx_config_t)' \
   "$dir/src" || true
done

Length of output: 3115

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

work=/tmp/dmx-api-compare
rm -rf "$work"
mkdir -p "$work"

echo '=== Exact V5 branch head ==='
v5_ref="$(git ls-remote https://github.com/netmindz/esp_dmx.git refs/heads/esp-idf-v5-fixes)"
printf '%s\n' "$v5_ref"
v5_sha="${v5_ref%%[[:space:]]*}"
test -n "$v5_sha"

echo '=== Download source snapshots ==='
curl -fsSL --retry 3 \
  'https://codeload.github.com/someweisguy/esp_dmx/zip/47db25d8c515e76fabcf5fc5ab0b786f98eeade0' \
  -o "$work/v4.zip"
curl -fsSL --retry 3 \
  "https://codeload.github.com/netmindz/esp_dmx/zip/${v5_sha}" \
  -o "$work/v5.zip"
unzip -q "$work/v4.zip" -d "$work/v4"
unzip -q "$work/v5.zip" -d "$work/v5"

export work v5_sha
python - <<'PY'
import difflib
import os
import re
from pathlib import Path

work = Path(os.environ["work"])
v4roots = [p for p in (work / "v4").iterdir() if p.is_dir()]
v5roots = [p for p in (work / "v5").iterdir() if p.is_dir()]
assert len(v4roots) == 1, v4roots
assert len(v5roots) == 1, v5roots
v4, v5 = v4roots[0], v5roots[0]

print(f"v4_root={v4.name}")
print(f"v5_root={v5.name}")
print(f"v5_sha={os.environ['v5_sha']}")

relevant = re.compile(r"(^|/)(esp_dmx\.h|types\.h|driver\.h|uart\.c|uart\.h|driver\.c|responder\.c|responder\.h|CMakeLists\.txt)$")
for label, root in (("v4", v4), ("v5", v5)):
    print(f"\n=== Relevant files: {label} ===")
    for p in sorted(root.rglob("*")):
        if p.is_file() and relevant.search(p.relative_to(root).as_posix()):
            print(p.relative_to(root))

needle = re.compile(
    r"typedef struct dmx_config_t|typedef struct.*dmx_personality_t|"
    r"dmx_driver_(install|delete|enable|disable)|"
    r"dmx_(receive|read|set_pin|set_mode|start|stop)|"
    r"rdm_register_dmx_(start_address|personality)|"
    r"software_version_label|DMX_CONFIG_DEFAULT"
)
for label, root in (("v4", v4), ("v5", v5)):
    print(f"\n=== API and ownership matches: {label} ===")
    for p in sorted(root.rglob("*")):
        if not p.is_file() or p.suffix not in {".c", ".h"}:
            continue
        lines = p.read_text(errors="replace").splitlines()
        matches = [i for i,line in enumerate(lines) if needle.search(line)]
        if matches:
            print(f"\n--- {p.relative_to(root)} ---")
            printed = set()
            for i in matches:
                for j in range(max(0, i-3), min(len(lines), i+5)):
                    if j not in printed:
                        print(f"{j+1:4d}  {lines[j]}")
                        printed.add(j)

paths = [
    "src/dmx/include/types.h",
    "src/dmx/include/driver.h",
    "src/dmx/hal/uart.c",
    "src/rdm/include/responder.h",
    "src/rdm/responder.c",
    "src/dmx/driver.c",
]
for rel in paths:
    a, b = v4 / rel, v5 / rel
    if a.exists() or b.exists():
        print(f"\n=== Diff: {rel} ===")
        alines = a.read_text(errors="replace").splitlines() if a.exists() else []
        blines = b.read_text(errors="replace").splitlines() if b.exists() else []
        diff = list(difflib.unified_diff(alines, blines, fromfile=f"v4/{rel}", tofile=f"v5/{rel}", n=5))
        if diff:
            print("\n".join(diff))
        else:
            print("(identical or path absent in both)")
PY

Length of output: 210571

---

@softhack007, I compared the exact dependencies and WLED implementations. The V5 fork currently resolves to ed12a2909960c92d7f144d368564e2473bd38c63.

Conclusion

main is presently a V5-only migration, not a dual-API implementation. This is consistent with platformio.ini: the V4 environments explicitly mark DMX input as non-working and ignore esp_dmx.

The V5 path has a critical functional RDM omission: it receives RDM packets but never sends the responder response.

API differences that affect WLED

Area	V4: 47db25d8…	V5 fork: ed12a290…	Current main
Driver install	dmx_driver_install(port, config, intr_flags)	dmx_driver_install(port, config, personalities, count)	V5-only
Personalities	config.personalities[]	external personality array	V5-only
Start address / personality	fields in dmx_config_t	registered/updated after install	V5-only
Software version label	char[33]	const char *	correctly conditional
RDM callback signature	(port, header, context)	(port, request, response, context)	V5-only
RDM response dispatch	handled by older receive flow	caller must invoke rdm_send_response()	missing in WLED

The V5 fork’s dmx_driver_install() copies software_version_label into its RDM parameter storage. Therefore the static std::string on Line 88 is safe, but its static lifetime is not required by this particular implementation. V4 still needs a bounded copy into its fixed char[33] field.

Critical V5 functional bug: RDM requests are discarded

wled00/dmx_input.cpp currently does:

if (!packet.is_rdm) {
  const std::lock_guard<std::mutex> lock(dmxDataLock);
  dmx_read(inputPortNum, dmxdata, packet.size);
}

For an RDM frame, it does nothing. In the V5 fork, rdm_send_response(inputPortNum) is the function that:

1. Parses the RDM request,
2. invokes registered callbacks such as rdmAddressChangedCb() and rdmPersonalityChangedCb(),
3. transmits the RDM response.

So the callbacks registered on Lines 166–167 cannot run, and WLED will not respond to RDM requests. The receive branch should dispatch RDM:

if (packet.is_rdm) {
  rdm_send_response(inputPortNum);
} else {
  const std::lock_guard<std::mutex> lock(dmxDataLock);
  dmx_read(inputPortNum, dmxdata, std::min(packet.size, sizeof(dmxdata)));
}

The size clamp is defensive; the current library’s normal packet maximum is 513, matching DMX_PACKET_SIZE, but it prevents a future/library error from overrunning dmxdata.

Is 16_x functionality preserved?

Not completely.

Preserved for V5

• Ten WLED personalities and their footprints.
• Initial DMXAddress and DMXMode, now set after installation.
• DMX frame reception and forwarding into handleDMXData().
• Identify handling, driver enable/disable, and pin allocation.
• RDM callback registration is adapted to the V5 callback signature.

Missing or changed

1. RDM request handling is broken as described above. This affects RDM address/personality changes and all normal responder behavior.

2. RDM device label regressed.
   16_x set:

   strcpy(config.device_label, "WLED_MM");

   The V5 config has no device_label field. The V5 driver installs an empty default device label unless WLED explicitly registers/replaces it through the V5 responder API. Thus the old RDM-visible WLED_MM label is not preserved.

3. V4 support is not retained.
   Besides the build configuration excluding the library, main/wled00/dmx_input.cpp uses incompatible V5-only calls:

   • four-argument dmx_driver_install();
   • four-argument callback functions;
   • rdm_register_dmx_personality(port, 10, callback, context);
   • bool passed to the V5 identify getter, while V4 used uint8_t.

4. Task-creation failure leaks the three allocated pins.
   On Line 214, failure is inferred from task == nullptr, but the pins are not deallocated. DMX stays disabled but the pins remain unavailable until reboot.

Recommended source structure

Given V4’s lower priority, I recommend making V5 the canonical implementation and isolating V4 in a small adapter rather than interleaving two struct layouts in createConfig().

`#if` ESP_IDF_VERSION_MAJOR >= 5
  constexpr size_t kPersonalityCount = 10;
  static dmx_personality_t personalities[kPersonalityCount];

  static bool installDmxDriver(uint8_t port, const dmx_config_t& config) {
    createPersonalities(personalities);
    return dmx_driver_install(port, &config, personalities, kPersonalityCount);
  }
`#else`
  static bool installDmxDriver(uint8_t port, const dmx_config_t& config) {
    return dmx_driver_install(port, &config, DMX_INTR_FLAGS_DEFAULT);
  }
`#endif`

This makes the supported API boundary explicit and keeps the common lifecycle (set_pin, address, mode, receive loop) readable.

For V4, either:

• restore a complete 16_x-style implementation behind #if ESP_IDF_VERSION_MAJOR < 5, or
• deliberately disable DMX input for V4 at build time with a clear configuration message.

The current middle state—enabled broadly but ignored in V4 test environments—risks accidental unsupported builds.

Additional improvements

• Check return values from dmx_set_pin(), dmx_set_start_address(), dmx_set_current_personality(), and both RDM registration calls. On failure, delete the installed driver and release allocated pins.
• Check the return value of xTaskCreatePinnedToCore() directly; on failure, deallocate the DMX pin triplet.
• Initialize TaskHandle_t task = nullptr; in wled00/dmx_input.h.
• Avoid strncpy() for the V5 personality descriptions. The current static zero-initialized array makes the literals safe today, but explicit initialization is clearer and robust against future reuse:

  personalities[0] = {3, "SINGLE_RGB"};

• Use one named constexpr for the personality count instead of repeating 10.
• Remove the unused unsigned long now = millis(); in DMXInput::updateInternal().

Finally, the V5 fork’s UART change is specifically targeted at ESP-IDF ≥5.2, where uart_periph_signal[].module is unavailable. That addresses the known compilation break around IDF 5.3+. It is reasonable groundwork for IDF 5.5.x, but it still needs hardware validation for DMX receive, RDM turnaround, and RDM responder timing on the target ESP32 variants.

🐇🔬

---

✏️ Learnings added

Learnt from: softhack007
URL: https://github.com/wled/WLED/issues/5753

Timestamp: 2026-07-24T14:52:07.518Z
Learning: WLED `main/platformio.ini` uses someweisguy/esp_dmx commit `47db25d8c515e76fabcf5fc5ab0b786f98eeade0` for ESP-IDF v4 builds and netmindz/esp_dmx branch `esp-idf-v5-fixes` for ESP-IDF v5 builds. The API generations differ materially: v4 uses personalities and RDM device fields inside `dmx_config_t` and a three-argument `dmx_driver_install()`, while the V5 fork uses external personality arrays and a four-argument install call.

---

Learnt from: softhack007
URL: https://github.com/wled/WLED/issues/5753

Timestamp: 2026-07-24T14:52:07.518Z
Learning: In WLED `wled00/dmx_input.cpp`, ESP-DMX V5 RDM responder callbacks require `rdm_send_response(inputPortNum)` after receiving an RDM packet; registering callbacks alone does not dispatch requests or send responses.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.

[softhack007]

@netmindz do you know if there is an upstream esp_dmx release supporting both V4 and V5 builds?

[netmindz]

You are massively over complicating the original issue. That is just that pins are all set to 0 in the default config and pin 0 is assigned to the button.

To hide the error it just needs a guard to early return if no pins are selected.

I'll need to dig a big more into the other topics that have come up in this thread