How to Use ELRS Telemetry to Send Payloads from EdgeTX Lua Scripts to Betaflight

Mastering Payload Communication Between EdgeTX and Betaflight

Have you ever stared at an FPV drone in flight and wondered how data seamlessly flows between your transmitter and flight controller? For those exploring EdgeTX Lua scripting, sending payloads to a Betaflight-powered flight controller via ExpressLRS (ELRS) telemetry can feel overwhelming at first. 📡

When I first started, the crossfireTelemetryPush function seemed like a mystery. Sure, there were examples floating around, but understanding the byte-level communication was the real challenge. How could a simple script send commands to your drone's brain? I was in the same boat, looking for clarity.

Imagine this: you're holding your radio, pressing buttons, and watching the flight controller respond almost instantly. Whether you’re controlling LEDs, requesting telemetry data, or adjusting MSP parameters, the power of EdgeTX scripting comes alive when you master payload creation. 🚀

In this article, we’ll break down Lua scripting for FPV telemetry step-by-step, focusing on building and sending payloads using ELRS telemetry. No complex jargon—just easy-to-follow examples to get you started. By the end, you’ll confidently write scripts that talk to Betaflight, unlocking a new layer of control over your drone. Let’s dive in!

--[[    Lua Script for EdgeTX to send payloads via ELRS telemetry to Betaflight    Communication is established using the 'crossfireTelemetryPush' function    Example 1: Basic payload structure with error handling and modular functions ]]
local CONST = {
   address = { betaflight = 0xEE, transmitter = 0xDF },
   frameType = { displayPort = 0x2D }
}

-- Function to prepare and send the payload to Betaflight
local function sendPayloadToBetaflight(cmd, data)
    local payloadOut = { CONST.address.betaflight, CONST.address.transmitter, cmd }
    -- Add additional data to the payload if provided
    if data ~= nil then
        for i = 1, #data do
            payloadOut[3 + i] = data[i]
        end
    end
    -- Send the telemetry frame
    local success = crossfireTelemetryPush(CONST.frameType.displayPort, payloadOut)
    if success then
        print("Payload successfully sent to Betaflight!")
    else
        print("Error: Payload failed to send.")
    end
end

-- Example usage
local command = 0x05 -- Example command
local data = { 0x01, 0x02, 0x03, 0x04 } -- Example payload data
sendPayloadToBetaflight(command, data)
--[[    Notes:   - The CONST table defines addresses and frame types to keep the script modular.   - Error handling ensures feedback on successful or failed transmissions.]]

--[[    Advanced Example: Modular functions, dynamic payload generation, and debugging output    for sending data via ELRS telemetry.]]
local CONST = {
    betaflightAddress = 0xEE,
    txAddress = 0xDF,
    frameType = 0x2D
}

-- Debug function to print payloads in hex format
local function debugPayload(payload)
    local debugString = "Payload: "
    for i = 1, #payload do
        debugString = debugString .. string.format("0x%02X ", payload[i])
    end
    print(debugString)
end

-- Function to dynamically build payloads
local function buildPayload(command, data)
    local payload = { CONST.betaflightAddress, CONST.txAddress, command }
    if data then
        for i, value in ipairs(data) do
            table.insert(payload, value)
        end
    end
    return payload
end

-- Function to send telemetry payload
local function sendTelemetry(command, data)
    local payload = buildPayload(command, data)
    debugPayload(payload) -- Print the payload for debugging
    local success = crossfireTelemetryPush(CONST.frameType, payload)
    if success then
        print("Telemetry sent successfully.")
    else
        print("Telemetry failed to send.")
    end
end

-- Example usage
local testCommand = 0x10 -- Example command ID
local testData = { 0x0A, 0x0B, 0x0C }
sendTelemetry(testCommand, testData)
--[[    Debugging output will print the exact bytes being sent,    making it easier to verify payload structure and troubleshoot issues.]]

Building Payloads for ELRS Communication with EdgeTX Lua

In these examples, the scripts focus on creating a payload and sending it through ELRS telemetry to communicate with the Betaflight flight controller. This is done using specific Lua functions like crossfireTelemetryPush, which allows the radio transmitter to send structured telemetry frames. The payload, in its simplest form, consists of specific addresses and commands formatted into an array. Each part of the script has been designed to optimize the way communication is established between the EdgeTX radio and Betaflight. 🛠️

To start, the CONST table plays a vital role by storing the addresses of the flight controller and transmitter, as well as the frame type used for communication. For example, the Betaflight address might be set to 0xEE, representing the drone’s flight controller. Using a constant table ensures modularity, so the addresses can be updated easily without rewriting large portions of the code. The buildPayload function dynamically constructs the telemetry frame by appending the address, command, and data fields into a Lua array. This modular approach keeps the code clean and reusable across different commands or telemetry functions.

One of the most critical components here is the crossfireTelemetryPush function. This command acts as the bridge to send the payload from the radio to the receiver, where the Betaflight flight controller can process it. For example, the function can push a frame type like `0x2D` with specific commands such as enabling LEDs or querying telemetry data. To ensure reliability, error handling is implemented to confirm whether the payload was sent successfully. If not, the script outputs an error message for debugging purposes, which is helpful when testing scripts in real flight scenarios. 🚁

Finally, the debugPayload function provides a way to visualize the telemetry data being sent. It converts each byte of the payload into a hexadecimal format for easy debugging. This step is crucial when dealing with byte-level communication, as you can directly verify the structure of the payload. By combining these components—modular functions, debugging utilities, and dynamic payload generation—these scripts offer a solid foundation for advanced telemetry communication. With a bit of practice, you can extend this approach to control LEDs, trigger alarms, or even send custom commands to your drone's flight controller.

Unlocking Advanced Telemetry Communication with EdgeTX Lua

One often overlooked but critical aspect of sending payloads via ELRS telemetry in EdgeTX is the way data formatting impacts communication reliability. When you send a payload, it’s not enough to simply package the command and data; understanding the byte structure, frame headers, and error-checking mechanisms ensures smooth communication. Each telemetry frame has a specific order: sender address, receiver address, command ID, and optional data. Properly structuring this can significantly improve how the flight controller processes your instructions. ✈️

Another important element is choosing the right command IDs for tasks like reading sensor data, changing flight parameters, or even triggering LEDs. For example, Betaflight’s MSP (MultiWii Serial Protocol) defines certain commands that align with these tasks. To implement this with EdgeTX Lua scripts, you can combine functions like crossfireTelemetryPush and table-building logic to send the exact sequence of bytes. By referencing the Betaflight MSP documentation, you can map each telemetry command to a specific function in your Lua script for precise control.

Additionally, testing these scripts in real-world environments helps bridge the gap between theory and practice. For instance, while debugging, you might encounter data misalignment or transmission delays. Using logging functions like `print()` or even building a simple LED response test can verify that your payloads are correctly formatted and received by the drone. Over time, you’ll develop scripts that not only send commands but also handle errors gracefully, ensuring a smoother flying experience. 🚀