Optimising DMX RDM implementation for DMX Receiver for DMX PWM LED Driver

[tommyco10]

Hi there, I've just started using this library and I'm really impressed so far!

I've adapted a very simple DMX Receiver from the example code on an ESP32 WROOM32E via Arduino Core/ PlatformIO, taking two DMX data slots to create a 16 bit intensity control channel for very precise dimming of an extremely high output custom LED array. I've implemented (half) an S-Curve, to tune in the resolution of the low end, to aid with the smoothness of this dimming which is producing great results.

This works flawlessly when the ESP32 is running without RDM and I'm able to achieve some exceptionally smooth dimming on fast and slow fades.

This changes once I introduce RDM. The fast, smooth fade become slightly choppy. You can start to see this on the built in led on the development board, which then becomes much less subtle when driving the high output LED array due to the amount of light it emits.

I wondered if you could help advise on how to optimise my code when using RDM? I've tried removing my serial debugging commands and rearranging everything into functions using FreeRTOS to isolate every combination of DMX, RDM, Ledc and the logistic S-Curve function onto core 0 allowing everything else to run on the other and sadly I've only managed to achieve worse results.

In essence, everything works perfectly before I try to include any RDM responder functionality. I've read through the documentation I'm sure I'm missing something here!, so I'm hoping you are able to point to something obvious I'm doing wrong with the RDM side of things, Any help much appreciated and thanks for the considerable work and support you have put into (and continue to put into) this library!

#include <Arduino.h>
#include <esp_dmx.h>
#include <rdm/responder.h>

// Define PWM Configuration
#define pwmChannel 1
#define pwmFreq 1000  // Set PWM frequency to 500 Hz
#define pwmResolution 16  // Set PWM resolution to 16 bits

// Define Pins
#define builtInLedPin 13
#define outputLedPin 27
#define enablePin 21
#define transmitPin 17
#define receivePin 16

// Define the DMX port and device address
dmx_port_t dmxPort = DMX_NUM_1;
uint16_t dmxAddress = 1;

// Define the array to store DMX data
byte data[DMX_PACKET_SIZE];

// Variables for DMX connectivity and timing
bool dmxIsConnected = false;
unsigned long lastUpdate = millis();

// Function to map DMX value to PWM value using an S-curve (sigmoid function)
uint16_t computeSCurve(uint16_t input) {
    float k = 0.0004;  // Steepness of the curve
    float x0 = 32768;  // Midpoint of the input range
    if (input >= x0) {
        return input;  // Return input unchanged if above the midpoint
    }
    return (uint16_t)(65535 / (1 + exp(-k * ((float)input - x0))));
}

void setup() {
    Serial.begin(9600);

    // Install the DMX driver
    dmx_config_t config = {
        .interrupt_flags = DMX_INTR_FLAGS_DEFAULT,
        .root_device_parameter_count = 32,
        .sub_device_parameter_count = 0,
        .model_id = 0,
        .product_category = RDM_PRODUCT_CATEGORY_FIXTURE,
        .software_version_id = ESP_DMX_VERSION_ID,
        .software_version_label = ESP_DMX_VERSION_LABEL,
        .queue_size_max = 32,
    };
    dmx_personality_t personalities[] = {{ 1, "Default Personality" }};
    dmx_driver_install(dmxPort, &config, personalities, 1);
    dmx_set_pin(dmxPort, transmitPin, receivePin, enablePin);

    // Set up the LED pins as outputs
    pinMode(builtInLedPin, OUTPUT);
    pinMode(outputLedPin, OUTPUT);
    ledcSetup(pwmChannel, pwmFreq, pwmResolution);
    ledcAttachPin(builtInLedPin, pwmChannel);
    ledcAttachPin(outputLedPin, pwmChannel);
}

void loop() {
    
    dmx_packet_t packet;

        if (dmx_receive(dmxPort, &packet, DMX_TIMEOUT_TICK)) {
            if (packet.is_rdm && !packet.err) {
  
                rdm_send_response(dmxPort);  
            }
        }
    rdm_get_dmx_start_address(dmxPort, &dmxAddress);
    if (dmx_receive(dmxPort, &packet, DMX_TIMEOUT_TICK)) {
        if (!packet.err) {
            if (!dmxIsConnected) {
                Serial.println("DMX is connected!");
                dmxIsConnected = true;
            }
            dmx_read(dmxPort, data, packet.size);
            unsigned long now = millis();
            int index = dmxAddress;
            if (index + 1 < DMX_PACKET_SIZE) {
                uint16_t rawBrightness = ((uint16_t)data[index] << 8) | data[index + 1];
                uint16_t scaledBrightness = computeSCurve(rawBrightness);
                ledcWrite(pwmChannel, scaledBrightness);
                if (now - lastUpdate > 1000) {
                    Serial.printf("Startcode: %d, Address: %d, DMX: %d, PWM: %d\n", data[0], dmxAddress, rawBrightness, scaledBrightness);
                    lastUpdate = now;
                }
            }
        } else {
            Serial.println("A DMX error occurred.");
        }
    } else if (dmxIsConnected) {
        Serial.println("DMX was disconnected.");
        dmxIsConnected = false;
    }
}

[tommyco10]

After some tinkering, it appears that the choppiness can be reduced (but not eliminated) with queue_size_max = 0, rather than the default value of 32.

I'm sure that there are implications with setting this to zero (I'm still getting used to the API), but I thought it was good to identify that this had a visible effect on the smoothness of the dimming.

It would be great to understand this a bit better as I'd like to make use of manufacturer specific PIDs using this library and would want to make sure I'm doing this on solid foundations early on!

Any help very much appreciated!

I just wondered if there was some blocking code somewhere in either the Dmx and RDM portions of this library which might be causing this?

It appears that the update rate of the DMX is approx 10 or 15hz or so, if I turn off the RDM portion of the code which is the best performance I've managed to achieve so far. This results in visible choppiness on fast (but smooth) fades down, however if the same fade is performed more slowly, the transition is extremely smooth.

I may move this into the issues section if there's not some configuration that I'm missing, so I really would appreciate any advice you may have!