Comment utiliser la télémétrie ELRS pour envoyer des charges utiles des scripts EdgeTX Lua vers Betaflight

Maîtriser la communication de charge utile entre EdgeTX et Betaflight

Avez-vous déjà regardé un drone FPV en vol et vous êtes-vous demandé comment les données circulent de manière transparente entre votre émetteur et votre contrôleur de vol ? Pour ceux qui explorent les scripts EdgeTX Lua, l'envoi de charges utiles à un contrôleur de vol alimenté par Betaflight via la télémétrie ExpressLRS (ELRS) peut sembler écrasant au début. 📡

Quand j'ai commencé, la fonction crossfireTelemetryPush semblait être un mystère. Bien sûr, il y avait des exemples qui circulaient, mais comprendre la communication au niveau des octets était le véritable défi. Comment un simple script pourrait-il envoyer des commandes au cerveau de votre drone ? J'étais dans le même bateau, à la recherche de clarté.

Imaginez ceci : vous tenez votre radio, appuyez sur des boutons et regardez le contrôleur de vol répondre presque instantanément. Que vous contrôliez les LED, demandiez des données de télémétrie ou ajustiez les paramètres MSP, la puissance des scripts EdgeTX prend vie lorsque vous maîtrisez la création de charges utiles. 🚀

Dans cet article, nous détaillerons étape par étape les scripts Lua pour la télémétrie FPV, en nous concentrant sur la création et l'envoi de charges utiles à l'aide de la télémétrie ELRS. Pas de jargon complexe, juste des exemples faciles à suivre pour vous aider à démarrer. À la fin, vous écrirez en toute confiance des scripts qui parlent à Betaflight, ouvrant ainsi une nouvelle couche de contrôle sur votre drone. Allons-y !

--[[    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.]]

Création de charges utiles pour la communication ELRS avec EdgeTX Lua

Dans ces exemples, les scripts se concentrent sur la création d'une charge utile et son envoi via la télémétrie ELRS pour communiquer avec le contrôleur de vol Betaflight. Cela se fait en utilisant des fonctions Lua spécifiques comme poussée de télémétrie crossfire, qui permet à l'émetteur radio d'envoyer des trames de télémétrie structurées. La charge utile, dans sa forme la plus simple, se compose d'adresses et de commandes spécifiques formatées dans un tableau. Chaque partie du script a été conçue pour optimiser la manière dont la communication est établie entre la radio EdgeTX et Betaflight. 🛠️

Pour commencer, le CONST La table joue un rôle essentiel en stockant les adresses du contrôleur de vol et de l'émetteur, ainsi que le type de trame utilisé pour la communication. Par exemple, l’adresse Betaflight peut être définie sur 0xEE, représentant le contrôleur de vol du drone. L'utilisation d'une table constante garantit la modularité, de sorte que les adresses peuvent être mises à jour facilement sans réécrire de grandes parties du code. Le buildPayload La fonction construit dynamiquement la trame de télémétrie en ajoutant les champs d'adresse, de commande et de données dans un tableau Lua. Cette approche modulaire maintient le code propre et réutilisable dans différentes commandes ou fonctions de télémétrie.

L'un des éléments les plus critiques ici est le crossfireTélémétriePush fonction. Cette commande sert de pont pour envoyer la charge utile de la radio au récepteur, où le contrôleur de vol Betaflight peut la traiter. Par exemple, la fonction peut pousser un type de trame tel que « 0x2D » avec des commandes spécifiques telles que l'activation des LED ou l'interrogation des données de télémétrie. Pour garantir la fiabilité, une gestion des erreurs est mise en œuvre pour confirmer si la charge utile a été envoyée avec succès. Dans le cas contraire, le script génère un message d'erreur à des fins de débogage, ce qui est utile lors du test des scripts dans des scénarios de vol réels. 🚁

Enfin, le debugPayload La fonction fournit un moyen de visualiser les données de télémétrie envoyées. Il convertit chaque octet de la charge utile au format hexadécimal pour un débogage facile. Cette étape est cruciale lorsqu'il s'agit de communication au niveau octet, car vous pouvez vérifier directement la structure de la charge utile. En combinant ces composants (fonctions modulaires, utilitaires de débogage et génération de charge utile dynamique), ces scripts offrent une base solide pour une communication télémétrique avancée. Avec un peu de pratique, vous pouvez étendre cette approche pour contrôler les LED, déclencher des alarmes ou même envoyer des commandes personnalisées au contrôleur de vol de votre drone.

Déverrouillage de la communication télémétrique avancée avec EdgeTX Lua

Un aspect souvent négligé mais critique de l'envoi de charges utiles via la télémétrie ELRS dans EdgeTX est l'impact du formatage des données sur la fiabilité des communications. Lorsque vous envoyez une charge utile, il ne suffit pas de simplement regrouper la commande et les données ; la compréhension de la structure des octets, des en-têtes de trame et des mécanismes de vérification des erreurs garantit une communication fluide. Chaque trame de télémétrie a un ordre spécifique : adresse de l'expéditeur, adresse du destinataire, ID de commande et données facultatives. Une structuration correcte peut améliorer considérablement la façon dont le contrôleur de vol traite vos instructions. ✈️

Un autre élément important est de choisir les bons ID de commande pour des tâches telles que la lecture des données des capteurs, la modification des paramètres de vol ou même le déclenchement des LED. Par exemple, le MSP (MultiWii Serial Protocol) de Betaflight définit certaines commandes qui correspondent à ces tâches. Pour implémenter cela avec les scripts EdgeTX Lua, vous pouvez combiner des fonctions telles que poussée de télémétrie crossfire et une logique de création de table pour envoyer la séquence exacte d'octets. En référençant la documentation Betaflight MSP, vous pouvez mapper chaque commande de télémétrie à une fonction spécifique dans votre script Lua pour un contrôle précis.

De plus, tester ces scripts dans des environnements réels permet de combler le fossé entre la théorie et la pratique. Par exemple, lors du débogage, vous pouvez rencontrer un désalignement des données ou des retards de transmission. L'utilisation de fonctions de journalisation telles que « print() » ou même la création d'un simple test de réponse LED peut vérifier que vos charges utiles sont correctement formatées et reçues par le drone. Au fil du temps, vous développerez des scripts qui non seulement envoient des commandes, mais gèrent également les erreurs avec élégance, garantissant ainsi une expérience de vol plus fluide. 🚀