Cansat
/
DShotRMT
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Web Client example

This commit is contained in:
Wastl Kraus 2025-09-11 13:58:22 +02:00
parent 066a06f767
commit 13ff00e99b
8 changed files with 755 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.github/workflows/ci.yml vendored
View File

@ -51,6 +51,7 @@ jobs:
- "examples/dshot300/dshot300.ino"
- "examples/command_manager/command_manager.ino"
- "examples/web_control/web_control.ino"
- "examples/web_client/web_client.ino"
steps:
- name: Checkout Repository

4
README.md
View File

@ -61,9 +61,9 @@ The library requires these additional libraries for full functionality:
```ini
lib_deps =
https://github.com/derdoktor667/DShotRMT
bblanchon/ArduinoJson
https://github.com/bblanchon/ArduinoJson
https://github.com/ESP32Async/ESPAsyncWebServer
https://github.com/ESP32Async/AsyncTCP ~/Arduino/libraries/AsyncTCP
https://github.com/ESP32Async/AsyncTCP
```
**Command Manager Example:**

114
examples/command_manager/command_manager.ino
View File

@ -29,9 +29,9 @@ DShotCommandManager commandManager(motor01);
static volatile uint16_t throttle_now = 0;
// Helper function to print telemetry results
void printTelemetryResult(const dshot_telemetry_result_t &result)
void printTelemetryResult(const dshot_result_t &result)
{
if (result.success)
if (result.success && (result.erpm > 0 || result.motor_rpm > 0))
{
USB_SERIAL.printf("Telemetry: eRPM=%u, Motor RPM=%u\n", result.erpm, result.motor_rpm);
}
@ -90,7 +90,7 @@ void loop()
// Get Motor RPM
if (IS_BIDIRECTIONAL)
{
dshot_telemetry_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
dshot_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printTelemetryResult(telem_result);
}
@ -112,60 +112,81 @@ void handleUserInput(const String &input)
USB_SERIAL.print("Stopping motor... ");
cmd_result = commandManager.stopMotor();
printResult(cmd_result);
return;
}
else if (input == "2")
if (input == "2")
{
USB_SERIAL.print("Activating beacon 1... ");
cmd_result = commandManager.activateBeacon(1);
printResult(cmd_result);
return;
}
else if (input == "3")
if (input == "3")
{
USB_SERIAL.print("Setting normal spin direction... ");
cmd_result = commandManager.setSpinDirection(false);
printResult(cmd_result);
return;
}
else if (input == "4")
if (input == "4")
{
USB_SERIAL.print("Setting reversed spin direction... ");
cmd_result = commandManager.setSpinDirection(true);
printResult(cmd_result);
return;
}
else if (input == "5")
if (input == "5")
{
USB_SERIAL.print("Getting ESC Info... ");
cmd_result = commandManager.requestESCInfo();
printResult(cmd_result);
return;
}
else if (input == "6")
if (input == "6")
{
USB_SERIAL.print("Turning LED 0 ON... ");
cmd_result = commandManager.setLED(0, true);
printResult(cmd_result);
return;
}
else if (input == "7")
if (input == "7")
{
USB_SERIAL.print("Turning LED 0 OFF... ");
cmd_result = commandManager.setLED(0, false);
printResult(cmd_result);
return;
}
else if (input == "h" || input == "help")
if (input == "h" || input == "help")
{
printMenu();
return;
}
else if (input == "info")
if (input == "info")
{
motor01.printDShotInfo();
return;
}
else if (input == "rpm" && IS_BIDIRECTIONAL)
if (input == "rpm" && IS_BIDIRECTIONAL)
{
dshot_telemetry_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
dshot_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printTelemetryResult(result);
return;
}
else if (input.startsWith("cmd "))
if (input.startsWith("cmd "))
{
// Direct command execution: "cmd 5" sends command 5
int cmd_num = input.substring(4).toInt();
if (DShotCommandManager::isValidCommand(static_cast<dshot_commands_t>(cmd_num)))
{
USB_SERIAL.printf("Sending command %d (%s)... ", cmd_num,
@ -177,11 +198,14 @@ void handleUserInput(const String &input)
{
USB_SERIAL.printf("Invalid command number: %d (valid range: 0 - %d)\n", cmd_num, DSHOT_CMD_MAX);
}
return;
}
else if (input.startsWith("throttle "))
if (input.startsWith("throttle "))
{
// Throttle control: "throttle 1000" sets throttle to 1000
int throttle_value = input.substring(9).toInt();
if (throttle_value >= DSHOT_THROTTLE_MIN && throttle_value <= DSHOT_THROTTLE_MAX)
{
throttle_now = throttle_value;
@ -195,8 +219,10 @@ void handleUserInput(const String &input)
{
USB_SERIAL.println("Continuous throttle mode enabled. Send '0' or 'throttle 0' to stop.");
}
return;
}
else if (throttle_value == 0)
if (throttle_value == 0)
{
throttle_now = 0;
USB_SERIAL.println("Continuous throttle stopped.");
@ -204,62 +230,64 @@ void handleUserInput(const String &input)
// Send stop command
dshot_result_t result = motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
printResult(result);
return;
}
else
{
USB_SERIAL.printf("Invalid throttle value: %d (valid range: %d-%d, use 0 to stop)\n",
throttle_value, DSHOT_THROTTLE_MIN, DSHOT_THROTTLE_MAX);
return;
}
}
else if (input == "0")
if (input == "0")
{
// Quick stop
throttle_now = 0;
USB_SERIAL.print("Emergency stop... ");
dshot_result_t result = motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
printResult(result);
return;
}
else if (input.startsWith("repeat "))
if (input.startsWith("repeat "))
{
// Repeat command: "repeat cmd 5 count 10" - sends command 5 ten times
String params = input.substring(7);
if (params.startsWith("cmd "))
if (!params.startsWith("cmd "))
{
USB_SERIAL.println("Usage: repeat cmd <number> count <repeat_count>");
return;
}
int space_pos = params.indexOf(' ', 4);
if (space_pos > 0 && params.substring(space_pos + 1).startsWith("count "))
if (space_pos <= 0 || !params.substring(space_pos + 1).startsWith("count "))
{
USB_SERIAL.println("Usage: repeat cmd <number> count <repeat_count>");
return;
}
int cmd_num = params.substring(4, space_pos).toInt();
int repeat_count = params.substring(space_pos + 7).toInt();
if (DShotCommandManager::isValidCommand(static_cast<dshot_commands_t>(cmd_num)) &&
repeat_count > 0 && repeat_count <= 100)
if (!DShotCommandManager::isValidCommand(static_cast<dshot_commands_t>(cmd_num)) ||
repeat_count <= 0 || repeat_count > 100)
{
USB_SERIAL.println("Invalid command or repeat count (1-100)");
return;
}
USB_SERIAL.printf("Sending command %d (%s) %d times... ", cmd_num,
DShotCommandManager::getCommandName(static_cast<dshot_commands_t>(cmd_num)),
repeat_count);
cmd_result = commandManager.sendCommand(static_cast<dshot_commands_t>(cmd_num), repeat_count);
printResult(cmd_result);
return;
}
else
{
USB_SERIAL.println("Invalid command or repeat count (1-100)");
}
}
else
{
USB_SERIAL.println("Usage: repeat cmd <number> count <repeat_count>");
}
}
else
{
USB_SERIAL.println("Usage: repeat cmd <number> count <repeat_count>");
}
}
else
{
// Unknown command
USB_SERIAL.printf("Unknown command: '%s'. Type 'h' or 'help' for help.\n", input.c_str());
}
}
//
void printResult(const dshot_result_t &result)

8
examples/dshot300/dshot300.ino
View File

@ -83,8 +83,8 @@ void loop()
// Get Motor RPM if bidirectional
if (IS_BIDIRECTIONAL)
{
dshot_telemetry_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotTelemetry(telem_result);
dshot_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotResult(telem_result);
}
USB_SERIAL.println("Type 'help' to show Menu");
@ -132,8 +132,8 @@ void handleSerialInput(const String &input, uint16_t &throttle, bool &continuous
}
else if (input == "rpm" && IS_BIDIRECTIONAL)
{
dshot_telemetry_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotTelemetry(result);
dshot_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotResult(result);
}
else if (input.startsWith("cmd "))
{

570
examples/web_client/web_client.ino Normal file
View File

@ -0,0 +1,570 @@
/**
* @file web_client.ino
* @brief DShotRMT Web Control as WiFi Client
* @author Wastl Kraus
* @date 2025-09-11
* @license MIT
*/
#include <Arduino.h>
#include <WiFi.h>
#include <DShotRMT.h>
#include <ArduinoJson.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
// WiFi Client Configuration - UPDATE THESE VALUES!
static constexpr auto *WIFI_SSID = "YOUR_SSID"; // Enter your WiFi SSID
static constexpr auto *WIFI_PASSWORD = "YOUR_PASSWORD"; // Enter your WiFi password
// Connection timeout in milliseconds
static constexpr auto WIFI_CONNECT_TIMEOUT = 20000;
// USB serial port settings
static constexpr auto &USB_SERIAL = Serial;
static constexpr auto USB_SERIAL_BAUD = 115200;
// Motor configuration - Pin number or GPIO_PIN
static constexpr auto MOTOR01_PIN = 17;
// Supported: DSHOT150, DSHOT300, DSHOT600, (DSHOT1200)
static constexpr dshot_mode_t DSHOT_MODE = DSHOT300;
// BiDirectional DShot Support (default: false)
static constexpr auto IS_BIDIRECTIONAL = false;
// Motor magnet count for RPM calculation
static constexpr auto MOTOR01_MAGNET_COUNT = 14;
// Creates the motor instance
DShotRMT motor01(MOTOR01_PIN, DSHOT_MODE, IS_BIDIRECTIONAL);
// Web Server Configuration
AsyncWebServer server(80);
AsyncWebSocket ws("/ws");
// Global variables
static uint16_t throttle = DSHOT_CMD_MOTOR_STOP;
static bool isArmed = false;
static bool last_sent_armed = false;
static bool continuous_throttle = true;
// WiFi status tracking
static bool wifi_connected = false;
// Helpers (forward declaration)
void printMenu();
void handleSerialInput(const String &input);
void handleWebSocketMessage(void *arg, uint8_t *data, size_t len);
void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len);
bool connectToWiFi();
void printWiFiStatus();
//
void setup()
{
USB_SERIAL.begin(USB_SERIAL_BAUD);
USB_SERIAL.println();
USB_SERIAL.println("DShotRMT Web Client Demo Starting...");
motor01.begin();
motor01.printCpuInfo();
// Connect to WiFi network
USB_SERIAL.println("\nConnecting to WiFi network...");
wifi_connected = connectToWiFi();
if (wifi_connected)
{
// Init WebSockets and Webserver
USB_SERIAL.println("\nStarting Webserver...");
ws.onEvent(onWsEvent);
server.addHandler(&ws);
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request)
{ request->send_P(200, "text/html", index_html); });
server.begin();
USB_SERIAL.println("HTTP server started.");
printWiFiStatus();
}
else
{
USB_SERIAL.println("\n*** WARNING: WiFi connection failed! ***");
USB_SERIAL.println("*** Web interface not available ***");
USB_SERIAL.println("*** Only serial control available ***");
}
// Initialize with disarmed state
setArmingStatus(false);
printMenu();
}
//
void loop()
{
static uint64_t last_serial_update = 0;
static uint16_t last_sent_throttle = DSHOT_CMD_MOTOR_STOP;
static String last_sent_rpm = "N/A";
static uint64_t last_wifi_check = 0;
// Check WiFi connection every 30 seconds
if (esp_timer_get_time() - last_wifi_check >= 30000000)
{
if (WiFi.status() != WL_CONNECTED && wifi_connected)
{
USB_SERIAL.println("\n*** WiFi connection lost! ***");
wifi_connected = false;
}
else if (WiFi.status() == WL_CONNECTED && !wifi_connected)
{
USB_SERIAL.println("\n*** WiFi connection restored! ***");
wifi_connected = true;
printWiFiStatus();
}
last_wifi_check = esp_timer_get_time();
}
// Handle serial input
if (USB_SERIAL.available() > 0)
{
String input = USB_SERIAL.readStringUntil('\n');
input.trim();
if (input.length() > 0)
{
handleSerialInput(input);
}
}
// Send throttle value only if armed and continuous mode is enabled
if (isArmed && continuous_throttle && throttle > 0)
{
motor01.sendThrottle(throttle);
}
else if (!isArmed && continuous_throttle)
{
// Ensure motor is stopped when disarmed
motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
}
// Print motor stats every 3 seconds in continuous mode
if ((esp_timer_get_time() - last_serial_update >= 3000000))
{
motor01.printDShotInfo();
USB_SERIAL.println(" ");
// Get Motor RPM if bidirectional and armed
if (IS_BIDIRECTIONAL && isArmed)
{
dshot_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotResult(telem_result);
}
USB_SERIAL.println("Type 'help' to show Menu");
// Time Stamp
last_serial_update = esp_timer_get_time();
}
// Update JSON on data change (only if WiFi connected)
if (wifi_connected)
{
String current_rpm = "N/A";
if (IS_BIDIRECTIONAL && isArmed)
{
dshot_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
if (telem_result.success && telem_result.motor_rpm > 0)
{
current_rpm = String(telem_result.motor_rpm);
}
}
if (throttle != last_sent_throttle || isArmed != last_sent_armed || current_rpm != last_sent_rpm)
{
// Generate JSON for Webserver
JsonDocument doc;
doc["throttle"] = isArmed ? throttle : 0;
doc["armed"] = isArmed;
doc["rpm"] = current_rpm;
String json_output;
json_output.reserve(256);
serializeJson(doc, json_output);
if (ws.count() > 0)
{
ws.textAll(json_output);
}
// Update last run
last_sent_throttle = throttle;
last_sent_armed = isArmed;
last_sent_rpm = current_rpm;
}
ws.cleanupClients();
}
}
// Connect to WiFi network
bool connectToWiFi()
{
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
USB_SERIAL.printf("Connecting to '%s'", WIFI_SSID);
uint32_t start_time = millis();
while (WiFi.status() != WL_CONNECTED && (millis() - start_time) < WIFI_CONNECT_TIMEOUT)
{
delay(500);
USB_SERIAL.print(".");
}
if (WiFi.status() == WL_CONNECTED)
{
USB_SERIAL.println(" Connected!");
return true;
}
else
{
USB_SERIAL.println(" Failed!");
USB_SERIAL.printf("WiFi Status: %d\n", WiFi.status());
return false;
}
}
// Print current WiFi status
void printWiFiStatus()
{
if (WiFi.status() == WL_CONNECTED)
{
USB_SERIAL.println();
USB_SERIAL.println("***********************************************");
USB_SERIAL.println(" --- WIFI INFO --- ");
USB_SERIAL.println("***********************************************");
USB_SERIAL.printf("SSID: %s\n", WiFi.SSID().c_str());
USB_SERIAL.printf("IP Address: %s\n", WiFi.localIP().toString().c_str());
USB_SERIAL.printf("Gateway: %s\n", WiFi.gatewayIP().toString().c_str());
USB_SERIAL.printf("Subnet: %s\n", WiFi.subnetMask().toString().c_str());
USB_SERIAL.printf("DNS: %s\n", WiFi.dnsIP().toString().c_str());
USB_SERIAL.printf("Signal Strength: %d dBm\n", WiFi.RSSI());
USB_SERIAL.printf("MAC Address: %s\n", WiFi.macAddress().c_str());
USB_SERIAL.println("***********************************************");
USB_SERIAL.printf("Web Interface: http://%s\n", WiFi.localIP().toString().c_str());
USB_SERIAL.println("***********************************************");
}
else
{
USB_SERIAL.println("WiFi not connected!");
}
}
//
void setArmingStatus(bool armed)
{
isArmed = armed;
if (armed)
{
continuous_throttle = true;
// dirty - force JSON update for WebSocket clients
last_sent_armed = !armed; // Trigger JSON send in next loop
return;
}
// Safety: Stop motor and reset throttle when disarming
throttle = 0;
continuous_throttle = false;
motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
USB_SERIAL.println(" ");
USB_SERIAL.println("=== MOTOR DISARMED - SAFETY STOP EXECUTED ===");
// Force JSON update for WebSocket clients
last_sent_armed = !armed; // Trigger JSON send in next loop
}
//
void printMenu()
{
USB_SERIAL.println(" ");
USB_SERIAL.println("***********************************************");
USB_SERIAL.println(" --- DShotRMT Web Client Demo --- ");
USB_SERIAL.println("***********************************************");
if (wifi_connected)
{
USB_SERIAL.printf(" Web Interface: http://%s \n", WiFi.localIP().toString().c_str());
}
else
{
USB_SERIAL.println(" Web Interface: NOT AVAILABLE ");
}
USB_SERIAL.println("***********************************************");
USB_SERIAL.println(" arm - Arm motor");
USB_SERIAL.println(" disarm - Disarm motor (safety)");
USB_SERIAL.println(" <value> - Set throttle (48 – 2047)");
USB_SERIAL.println(" 0 - Stop motor");
USB_SERIAL.println("***********************************************");
USB_SERIAL.println(" cmd <number> - Send DShot command (0 - 47)");
USB_SERIAL.println(" info - Show motor info");
USB_SERIAL.println(" wifi - Show WiFi status");
USB_SERIAL.println(" reconnect - Reconnect to WiFi");
if (IS_BIDIRECTIONAL)
{
USB_SERIAL.println(" rpm - Get telemetry data");
}
USB_SERIAL.println("***********************************************");
USB_SERIAL.println(" h / help - Show this Menu");
USB_SERIAL.println("***********************************************");
USB_SERIAL.printf(" Current Status: %s\n", isArmed ? "ARMED" : "DISARMED");
USB_SERIAL.printf(" WiFi Status: %s\n", wifi_connected ? "CONNECTED" : "DISCONNECTED");
USB_SERIAL.println("***********************************************");
}
// Handle serial inputs and updates global variables
void handleSerialInput(const String &input)
{
if (input == "arm")
{
setArmingStatus(true);
return;
}
if (input == "0" || input == "disarm")
{
setArmingStatus(false);
return;
}
if (input == "info")
{
motor01.printDShotInfo();
USB_SERIAL.println(" ");
USB_SERIAL.printf("Arming Status: %s\n", isArmed ? "ARMED" : "DISARMED");
return;
}
if (input == "wifi")
{
printWiFiStatus();
return;
}
if (input == "reconnect")
{
USB_SERIAL.println("Reconnecting to WiFi...");
WiFi.disconnect();
delay(1000);
wifi_connected = connectToWiFi();
if (wifi_connected)
{
printWiFiStatus();
}
return;
}
if (input == "rpm" && IS_BIDIRECTIONAL)
{
if (isArmed)
{
dshot_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotResult(result);
}
else
{
USB_SERIAL.println(" ");
USB_SERIAL.println("Cannot read RPM - Motor is DISARMED");
}
return;
}
if (input.startsWith("cmd "))
{
if (!isArmed)
{
USB_SERIAL.println(" ");
USB_SERIAL.println("Cannot send command - Motor is DISARMED. Use 'arm' command first.");
return;
}
continuous_throttle = false;
int cmd_num = input.substring(4).toInt();
if (cmd_num >= DSHOT_CMD_MOTOR_STOP && cmd_num <= DSHOT_CMD_MAX)
{
dshot_result_t result = motor01.sendCommand(cmd_num);
printDShotResult(result);
}
else
{
USB_SERIAL.println(" ");
USB_SERIAL.printf("Invalid command: %d (valid range: 0 - %d)\n", cmd_num, DSHOT_CMD_MAX);
}
return;
}
if (input == "h" || input == "help")
{
printMenu();
return;
}
if (input == "status")
{
USB_SERIAL.println(" ");
USB_SERIAL.printf("Arming Status: %s\n", isArmed ? "ARMED" : "DISARMED");
USB_SERIAL.printf("Current Throttle: %u\n", throttle);
USB_SERIAL.printf("Continuous Mode: %s\n", continuous_throttle ? "ACTIVE" : "INACTIVE");
USB_SERIAL.printf("WiFi Status: %s\n", wifi_connected ? "CONNECTED" : "DISCONNECTED");
if (wifi_connected)
{
USB_SERIAL.printf("IP Address: %s\n", WiFi.localIP().toString().c_str());
}
return;
}
// Handle throttle input
int throttle_value = input.toInt();
if (throttle_value >= DSHOT_THROTTLE_MIN && throttle_value <= DSHOT_THROTTLE_MAX)
{
if (!isArmed)
{
USB_SERIAL.println(" ");
USB_SERIAL.println("Cannot set throttle - Motor is DISARMED. Use 'arm' command first.");
return;
}
throttle = throttle_value;
continuous_throttle = true;
dshot_result_t result = motor01.sendThrottle(throttle);
if (result.success)
{
USB_SERIAL.println(" ");
USB_SERIAL.printf("Throttle set to %u (continuous mode active)\n", throttle);
}
return;
}
if (throttle_value == 0)
{
throttle = 0;
continuous_throttle = false;
dshot_result_t result = motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
printDShotResult(result);
return;
}
// Invalid input
USB_SERIAL.println(" ");
USB_SERIAL.printf("Invalid input: '%s'\n", input.c_str());
USB_SERIAL.printf("Valid throttle range: %d - %d\n", DSHOT_THROTTLE_MIN, DSHOT_THROTTLE_MAX);
USB_SERIAL.println("Use 'arm' to enable motor control");
}
// Websocket request processing
void handleWebSocketMessage(void *arg, uint8_t *data, size_t len)
{
JsonDocument doc;
DeserializationError error = deserializeJson(doc, data, len);
if (error)
{
USB_SERIAL.print(F("deserializeJson() failed: "));
USB_SERIAL.println(error.c_str());
return;
}
bool armedFromWeb = false;
// Handle arming status
if (doc.containsKey("armed"))
{
bool armed = doc["armed"];
setArmingStatus(armed);
armedFromWeb = true;
}
// Handle throttle value (only if armed)
if (doc.containsKey("throttle"))
{
if (!isArmed)
{
throttle = 0;
continuous_throttle = false;
// Ignore throttle commands when disarmed
USB_SERIAL.println(" ");
USB_SERIAL.println("Web throttle command ignored - Motor is DISARMED");
return;
}
uint16_t web_throttle = doc["throttle"];
if (web_throttle == 0)
{
throttle = 0;
continuous_throttle = false;
motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
}
else if (web_throttle >= DSHOT_THROTTLE_MIN && web_throttle <= DSHOT_THROTTLE_MAX)
{
throttle = web_throttle;
continuous_throttle = true;
}
}
// Webserver arms with DSHOT_THROTTLE_MIN
if (armedFromWeb && isArmed)
{
continuous_throttle = true;
motor01.sendThrottle(throttle);
USB_SERIAL.println(" ");
USB_SERIAL.printf("Motor armed via Web - throttle set to %i\n", throttle);
}
}
// Websocket request handler
void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len)
{
switch (type)
{
case WS_EVT_CONNECT:
USB_SERIAL.printf("Web Client #%u connected from %s\n", client->id(), client->remoteIP().toString().c_str());
// Send current arming status to new client
{
JsonDocument doc;
doc["armed"] = isArmed;
doc["throttle"] = isArmed ? throttle : 0;
String json_output;
serializeJson(doc, json_output);
client->text(json_output);
}
break;
case WS_EVT_DISCONNECT:
USB_SERIAL.printf("Web Client #%u disconnected\n", client->id());
break;
case WS_EVT_DATA:
handleWebSocketMessage(arg, data, len);
break;
case WS_EVT_PONG:
case WS_EVT_ERROR:
break;
}
}

94
examples/web_control/web_control.ino
View File

@ -1,5 +1,5 @@
/**
* @file dshot300.ino
* @file web_control.ino
* @brief Demo sketch for DShotRMT library
* @author Wastl Kraus
* @date 2025-09-09
@ -95,6 +95,7 @@ void setup()
printMenu();
}
//
void loop()
{
static uint64_t last_serial_update = 0;
@ -134,8 +135,8 @@ void loop()
// Get Motor RPM if bidirectional and armed
if (IS_BIDIRECTIONAL && isArmed)
{
dshot_telemetry_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotTelemetry(telem_result);
dshot_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotResult(telem_result);
}
USB_SERIAL.println("Type 'help' to show Menu");
@ -149,9 +150,12 @@ void loop()
if (IS_BIDIRECTIONAL && isArmed)
{
dshot_telemetry_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
dshot_result_t telem_result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
if (telem_result.success && telem_result.motor_rpm > 0)
{
current_rpm = String(telem_result.motor_rpm);
}
}
if (throttle != last_sent_throttle || isArmed != last_sent_armed || current_rpm != last_sent_rpm)
{
@ -184,8 +188,12 @@ void setArmingStatus(bool armed)
{
isArmed = armed;
if (!armed)
if (armed)
{
continuous_throttle = true;
return;
}
// Safety: Stop motor and reset throttle when disarming
throttle = 0;
continuous_throttle = false;
@ -193,11 +201,6 @@ void setArmingStatus(bool armed)
USB_SERIAL.println(" ");
USB_SERIAL.println("=== MOTOR DISARMED - SAFETY STOP EXECUTED ===");
}
else
{
continuous_throttle = true;
}
}
//
void printMenu()
@ -232,38 +235,35 @@ void handleSerialInput(const String &input)
if (input == "arm")
{
setArmingStatus(true);
return;
}
else if (input == "disarm")
if (input == "0" || input == "disarm")
{
setArmingStatus(false);
return;
}
else if (input == "0")
{
throttle = 0;
continuous_throttle = false;
dshot_result_t result = motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
printDShotResult(result);
}
else if (input == "info")
if (input == "info")
{
motor01.printDShotInfo();
USB_SERIAL.println(" ");
USB_SERIAL.printf("Arming Status: %s\n", isArmed ? "ARMED" : "DISARMED");
return;
}
else if (input == "rpm" && IS_BIDIRECTIONAL)
if (input == "rpm" && IS_BIDIRECTIONAL)
{
if (isArmed)
{
dshot_telemetry_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotTelemetry(result);
dshot_result_t result = motor01.getTelemetry(MOTOR01_MAGNET_COUNT);
printDShotResult(result);
}
else
{
USB_SERIAL.println(" ");
USB_SERIAL.println("Cannot read RPM - Motor is DISARMED");
}
return;
}
else if (input.startsWith("cmd "))
if (input.startsWith("cmd "))
{
if (!isArmed)
{
@ -274,6 +274,7 @@ void handleSerialInput(const String &input)
continuous_throttle = false;
int cmd_num = input.substring(4).toInt();
if (cmd_num >= DSHOT_CMD_MOTOR_STOP && cmd_num <= DSHOT_CMD_MAX)
{
dshot_result_t result = motor01.sendCommand(cmd_num);
@ -284,20 +285,23 @@ void handleSerialInput(const String &input)
USB_SERIAL.println(" ");
USB_SERIAL.printf("Invalid command: %d (valid range: 0 - %d)\n", cmd_num, DSHOT_CMD_MAX);
}
return;
}
else if (input == "h" || input == "help")
if (input == "h" || input == "help")
{
printMenu();
return;
}
else if (input == "status")
if (input == "status")
{
USB_SERIAL.println(" ");
USB_SERIAL.printf("Arming Status: %s\n", isArmed ? "ARMED" : "DISARMED");
USB_SERIAL.printf("Current Throttle: %u\n", throttle);
USB_SERIAL.printf("Continuous Mode: %s\n", continuous_throttle ? "ACTIVE" : "INACTIVE");
return;
}
else
{
// Handle throttle input
int throttle_value = input.toInt();
if (throttle_value >= DSHOT_THROTTLE_MIN && throttle_value <= DSHOT_THROTTLE_MAX)
@ -319,23 +323,24 @@ void handleSerialInput(const String &input)
USB_SERIAL.println(" ");
USB_SERIAL.printf("Throttle set to %u (continuous mode active)\n", throttle);
}
return;
}
else if (throttle_value == 0)
if (throttle_value == 0)
{
throttle = 0;
continuous_throttle = false;
dshot_result_t result = motor01.sendCommand(DSHOT_CMD_MOTOR_STOP);
printDShotResult(result);
return;
}
else
{
// Invalid input
USB_SERIAL.println(" ");
USB_SERIAL.printf("Invalid input: '%s'\n", input.c_str());
USB_SERIAL.printf("Valid throttle range: %d - %d\n", DSHOT_THROTTLE_MIN, DSHOT_THROTTLE_MAX);
USB_SERIAL.println("Use 'arm' to enable motor control");
}
}
}
// Websocket request processing
void handleWebSocketMessage(void *arg, uint8_t *data, size_t len)
@ -350,7 +355,6 @@ void handleWebSocketMessage(void *arg, uint8_t *data, size_t len)
return;
}
//
bool armedFromWeb = false;
// Handle arming status
@ -362,11 +366,20 @@ void handleWebSocketMessage(void *arg, uint8_t *data, size_t len)
}
// Handle throttle value (only if armed)
if (doc.containsKey("throttle") && isArmed)
if (doc.containsKey("throttle"))
{
if (!isArmed)
{
throttle = 0;
continuous_throttle = false;
// Ignore throttle commands when disarmed
USB_SERIAL.println(" ");
USB_SERIAL.println("Web throttle command ignored - Motor is DISARMED");
return;
}
uint16_t web_throttle = doc["throttle"];
// Check for valid throttle value
if (web_throttle == 0)
{
throttle = 0;
@ -379,23 +392,14 @@ void handleWebSocketMessage(void *arg, uint8_t *data, size_t len)
continuous_throttle = true;
}
}
else if (doc.containsKey("throttle") && !isArmed)
{
throttle = 0;
continuous_throttle = false;
// Ignore throttle commands when disarmed
USB_SERIAL.println(" ");
USB_SERIAL.println("Web throttle command ignored - Motor is DISARMED");
}
// Webserver arms with DSHOT_THROTTLE_MIN
if (armedFromWeb && isArmed)
{
throttle = DSHOT_THROTTLE_MIN;
continuous_throttle = true;
motor01.sendThrottle(throttle);
USB_SERIAL.println(" ");
USB_SERIAL.println("Motor armed via Web - throttle set to 48");
USB_SERIAL.printf("Motor armed via Web - throttle set to %i\n", throttle);
}
}

30
src/DShotRMT.cpp
View File

@ -254,11 +254,11 @@ dshot_result_t DShotRMT::sendCommand(uint16_t command)
return _sendDShotFrame(_packet);
}
// Get telemetry data with timing and error handling
dshot_telemetry_result_t DShotRMT::getTelemetry(uint16_t magnet_count)
// Get telemetry data
dshot_result_t DShotRMT::getTelemetry(uint16_t magnet_count)
{
// Result container
dshot_telemetry_result_t result = {false, NO_DSHOT_ERPM, NO_DSHOT_RPM, TELEMETRY_FAILED};
// Result container with unified structure
dshot_result_t result = {false, TELEMETRY_FAILED, NO_DSHOT_ERPM, NO_DSHOT_RPM};
// Check if bidirectional mode is enabled
if (!_is_bidirectional)
@ -550,21 +550,13 @@ void DShotRMT::printCpuInfo(Stream &output) const
// --- HELPERS ---
void printDShotResult(dshot_result_t &result, Stream &output)
{
output.printf("Status: %s - %s\n", result.success ? "SUCCESS" : "FAILED", result.msg);
output.println(" ");
output.printf("Status: %s - %s", result.success ? "SUCCESS" : "FAILED", result.msg);
// Print telemetry data if available
if (result.success && (result.erpm > 0 || result.motor_rpm > 0))
{
output.printf(" | eRPM: %u, Motor RPM: %u", result.erpm, result.motor_rpm);
}
//
void printDShotTelemetry(dshot_telemetry_result_t &result, Stream &output)
{
if (result.success)
{
output.printf("Telemetry: eRPM=%u, Motor RPM=%u\n", result.erpm, result.motor_rpm);
}
else
{
output.printf("Telemetry: FAILED - %s\n", result.msg);
}
output.println(" ");
output.println();
}

16
src/DShotRMT.h
View File

@ -73,28 +73,20 @@ typedef struct
uint16_t ticks_zero_low;
} dshot_timing_t;
// Error handling
// Unified DShot result structure
typedef struct
{
bool success;
const char *msg;
} dshot_result_t;
// DShot telemetry result
typedef struct
{
bool success;
uint16_t erpm;
uint16_t motor_rpm;
const char *msg;
} dshot_telemetry_result_t;
} dshot_result_t;
// Naming convention
typedef dshotCommands_e dshot_commands_t;
// --- HELPERS ---
void printDShotResult(dshot_result_t &result, Stream &output = Serial);
void printDShotTelemetry(dshot_telemetry_result_t &result, Stream &output = Serial);
//
class DShotRMT
@ -123,7 +115,7 @@ public:
uint16_t getDShotPacket() const { return _parsed_packet; }
bool is_bidirectional() const { return _is_bidirectional; }
dshot_mode_t getMode() const { return _mode; }
dshot_telemetry_result_t getTelemetry(uint16_t magnet_count = DEFAULT_MOTOR_MAGNET_COUNT);
dshot_result_t getTelemetry(uint16_t magnet_count = DEFAULT_MOTOR_MAGNET_COUNT);
// --- INFO ---
void printDShotInfo(Stream &output = Serial) const;
@ -148,7 +140,7 @@ public:
uint32_t getMotorRPM(uint8_t magnet_count)
{
auto result = getTelemetry(magnet_count);
return result.success;
return result.motor_rpm;
}
private: