fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-07-16 05:30:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

drivers/actuators/modalai_esc --> modal_io and rename UART_ESC prefix to MODAL_IO (#20995)

Browse Source
This commit is contained in:
modaltb
2023-01-24 17:24:58 -08:00
committed by GitHub
parent 60de5b3ea4
commit 20b7a8c9f6
23 changed files with 222 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files
boards/modalai/fc-v1/default.px4board
+1 -1
View File
@@ -5,7 +5,7 @@ CONFIG_BOARD_SERIAL_TEL1="/dev/ttyS6"
CONFIG_BOARD_SERIAL_TEL2="/dev/ttyS4"
CONFIG_BOARD_SERIAL_TEL3="/dev/ttyS1"
CONFIG_BOARD_SERIAL_TEL4="/dev/ttyS3"
CONFIG_DRIVERS_ACTUATORS_MODALAI_ESC=y
CONFIG_DRIVERS_ACTUATORS_MODAL_IO=y
CONFIG_DRIVERS_ADC_ADS1115=y
CONFIG_DRIVERS_ADC_BOARD_ADC=y
CONFIG_COMMON_BAROMETERS=y
boards/modalai/fc-v1/init/rc.board_sensors
+2 -2
View File
@@ -3,9 +3,9 @@
# ModalAI FC-v1 specific board sensors init
#------------------------------------------------------------------------------
if param greater UART_ESC_CONFIG 0
if param greater MODAL_IO_CONFIG 0
then
modalai_esc start
modal_io start
fi
board_adc start
boards/modalai/fc-v1/src/board_config.h
+1 -1
View File
@@ -264,7 +264,7 @@
#define BOARD_NUM_IO_TIMERS 5
// J4 / TELEM3 / UART2
#define MODALAI_ESC_DEFAULT_PORT "/dev/ttyS1"
#define MODAL_IO_DEFAULT_PORT "/dev/ttyS1"
__BEGIN_DECLS
boards/modalai/fc-v2/default.px4board
+1 -1
View File
@@ -3,7 +3,7 @@ CONFIG_BOARD_ARCHITECTURE="cortex-m7"
CONFIG_BOARD_SERIAL_GPS1="/dev/ttyS0"
CONFIG_BOARD_SERIAL_TEL1="/dev/ttyS6"
CONFIG_BOARD_SERIAL_TEL2="/dev/ttyS4"
CONFIG_DRIVERS_ACTUATORS_MODALAI_ESC=y
CONFIG_DRIVERS_ACTUATORS_MODAL_IO=y
CONFIG_DRIVERS_ADC_ADS1115=y
CONFIG_DRIVERS_ADC_BOARD_ADC=y
CONFIG_DRIVERS_BAROMETER_INVENSENSE_ICP201XX=y
boards/modalai/fc-v2/init/rc.board_sensors
+2 -2
View File
@@ -3,9 +3,9 @@
# ModalAI FC-v2 specific board sensors init
#------------------------------------------------------------------------------
if param greater UART_ESC_CONFIG 0
if param greater MODAL_IO_CONFIG 0
then
modalai_esc start
modal_io start
fi
board_adc start
boards/modalai/fc-v2/src/board_config.h
+1 -1
View File
@@ -339,7 +339,7 @@
#define BOARD_NUM_IO_TIMERS 5
// J1 / TELEM1 / USART7
#define MODALAI_ESC_DEFAULT_PORT "/dev/ttyS6"
#define MODAL_IO_DEFAULT_PORT "/dev/ttyS6"
__BEGIN_DECLS
boards/modalai/voxl2-slpi/default.px4board
+1 -1
View File
@@ -1,6 +1,6 @@
CONFIG_PLATFORM_QURT=y
CONFIG_BOARD_TOOLCHAIN="qurt"
CONFIG_DRIVERS_ACTUATORS_MODALAI_ESC=y
CONFIG_DRIVERS_ACTUATORS_MODAL_IO=y
CONFIG_DRIVERS_POWER_MONITOR_VOXLPM=y
CONFIG_DRIVERS_QSHELL_QURT=y
CONFIG_MODULES_EKF2=y
boards/modalai/voxl2-slpi/src/board_config.h
+1 -1
View File
@@ -62,4 +62,4 @@
/*
* Default port for the ESC
*/
#define MODALAI_ESC_DEFAULT_PORT "2"
#define MODAL_IO_DEFAULT_PORT "2"
boards/modalai/voxl2/target/voxl-px4.config
+1 -1
View File
@@ -20,4 +20,4 @@ muorb start
qshell icm42688p start -s
qshell modalai_esc start
qshell modal_io start
src/drivers/actuators/modalai_esc/CMakeLists.txt → src/drivers/actuators/modal_io/CMakeLists.txt
+6 -6
View File
@@ -32,16 +32,16 @@
############################################################################
px4_add_module(
MODULE drivers__actuators__modalai_esc
MAIN modalai_esc
MODULE drivers__actuators__modal_io
MAIN modal_io
SRCS
crc16.c
crc16.h
modalai_esc_serial.cpp
modalai_esc_serial.hpp
modalai_esc.cpp
modalai_esc.hpp
modal_io_serial.cpp
modal_io_serial.hpp
modal_io.cpp
modal_io.hpp
qc_esc_packet_types.h
qc_esc_packet.c
qc_esc_packet.h
src/drivers/actuators/modal_io/Kconfig
+5
View File
@@ -0,0 +1,5 @@
menuconfig DRIVERS_ACTUATORS_MODAL_IO
bool "modal_io"
default n
---help---
Enable support for modal_io
src/drivers/actuators/modalai_esc/crc16.c → src/drivers/actuators/modal_io/crc16.c
View File
src/drivers/actuators/modalai_esc/crc16.h → src/drivers/actuators/modal_io/crc16.h
View File
src/drivers/actuators/modalai_esc/modalai_esc.cpp → src/drivers/actuators/modal_io/modal_io.cpp
+107 -107
View File
@@ -33,34 +33,34 @@
#include <px4_platform_common/getopt.h>
#include "modalai_esc.hpp"
#include "modalai_esc_serial.hpp"
#include "modal_io.hpp"
#include "modal_io_serial.hpp"
// utility for running on VOXL and using driver as a bridge
#define MODALAI_ESC_VOXL_BRIDGE_PORT "/dev/ttyS4"
#define MODAL_IO_VOXL_BRIDGE_PORT "/dev/ttyS4"
// future use:
#define MODALAI_PUBLISH_ESC_STATUS 0
const char *_device;
ModalaiEsc::ModalaiEsc() :
OutputModuleInterface(MODULE_NAME, px4::serial_port_to_wq(MODALAI_ESC_DEFAULT_PORT)),
_mixing_output{"UART_ESC", MODALAI_ESC_OUTPUT_CHANNELS, *this, MixingOutput::SchedulingPolicy::Auto, false, false},
ModalIo::ModalIo() :
OutputModuleInterface(MODULE_NAME, px4::serial_port_to_wq(MODAL_IO_DEFAULT_PORT)),
_mixing_output{"MODAL_IO", MODAL_IO_OUTPUT_CHANNELS, *this, MixingOutput::SchedulingPolicy::Auto, false, false},
_cycle_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": cycle")),
_output_update_perf(perf_alloc(PC_INTERVAL, MODULE_NAME": output update interval"))
{
_device = MODALAI_ESC_DEFAULT_PORT;
_device = MODAL_IO_DEFAULT_PORT;
_mixing_output.setAllFailsafeValues(0);
_mixing_output.setAllDisarmedValues(0);
_esc_status.timestamp = hrt_absolute_time();
_esc_status.counter = 0;
_esc_status.esc_count = MODALAI_ESC_OUTPUT_CHANNELS;
_esc_status.esc_count = MODAL_IO_OUTPUT_CHANNELS;
_esc_status.esc_connectiontype = esc_status_s::ESC_CONNECTION_TYPE_SERIAL;
for (unsigned i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (unsigned i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
_esc_status.esc[i].timestamp = 0;
_esc_status.esc[i].esc_address = 0;
_esc_status.esc[i].esc_rpm = 0;
@@ -79,7 +79,7 @@ ModalaiEsc::ModalaiEsc() :
_fb_idx = 0;
}
ModalaiEsc::~ModalaiEsc()
ModalIo::~ModalIo()
{
_outputs_on = false;
@@ -97,7 +97,7 @@ ModalaiEsc::~ModalaiEsc()
perf_free(_output_update_perf);
}
int ModalaiEsc::init()
int ModalIo::init()
{
/* Getting initial parameter values */
@@ -107,8 +107,8 @@ int ModalaiEsc::init()
return ret;
}
_uart_port = new ModalaiEscSerial();
_uart_port_bridge = new ModalaiEscSerial();
_uart_port = new ModalIoSerial();
_uart_port_bridge = new ModalIoSerial();
memset(&_esc_chans, 0x00, sizeof(_esc_chans));
//get_instance()->ScheduleOnInterval(10000); //100hz
@@ -118,79 +118,79 @@ int ModalaiEsc::init()
return 0;
}
int ModalaiEsc::load_params(uart_esc_params_t *params, ch_assign_t *map)
int ModalIo::load_params(modal_io_params_t *params, ch_assign_t *map)
{
int ret = PX4_OK;
// initialize out
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
params->function_map[i] = (int)OutputFunction::Disabled;
params->direction_map[i] = 0;
params->motor_map[i] = 0;
}
param_get(param_find("UART_ESC_CONFIG"), &params->config);
param_get(param_find("UART_ESC_MODE"), &params->mode);
param_get(param_find("UART_ESC_BAUD"), &params->baud_rate);
param_get(param_find("MODAL_IO_CONFIG"), &params->config);
param_get(param_find("MODAL_IO_MODE"), &params->mode);
param_get(param_find("MODAL_IO_BAUD"), &params->baud_rate);
param_get(param_find("UART_ESC_T_PERC"), &params->turtle_motor_percent);
param_get(param_find("UART_ESC_T_DEAD"), &params->turtle_motor_deadband);
param_get(param_find("UART_ESC_T_EXPO"), &params->turtle_motor_expo);
param_get(param_find("UART_ESC_T_MINF"), &params->turtle_stick_minf);
param_get(param_find("UART_ESC_T_COSP"), &params->turtle_cosphi);
param_get(param_find("MODAL_IO_T_PERC"), &params->turtle_motor_percent);
param_get(param_find("MODAL_IO_T_DEAD"), &params->turtle_motor_deadband);
param_get(param_find("MODAL_IO_T_EXPO"), &params->turtle_motor_expo);
param_get(param_find("MODAL_IO_T_MINF"), &params->turtle_stick_minf);
param_get(param_find("MODAL_IO_T_COSP"), &params->turtle_cosphi);
param_get(param_find("UART_ESC_FUNC1"), &params->function_map[0]);
param_get(param_find("UART_ESC_FUNC2"), &params->function_map[1]);
param_get(param_find("UART_ESC_FUNC3"), &params->function_map[2]);
param_get(param_find("UART_ESC_FUNC4"), &params->function_map[3]);
param_get(param_find("MODAL_IO_FUNC1"), &params->function_map[0]);
param_get(param_find("MODAL_IO_FUNC2"), &params->function_map[1]);
param_get(param_find("MODAL_IO_FUNC3"), &params->function_map[2]);
param_get(param_find("MODAL_IO_FUNC4"), &params->function_map[3]);
param_get(param_find("UART_ESC_SDIR1"), &params->direction_map[0]);
param_get(param_find("UART_ESC_SDIR2"), &params->direction_map[1]);
param_get(param_find("UART_ESC_SDIR3"), &params->direction_map[2]);
param_get(param_find("UART_ESC_SDIR4"), &params->direction_map[3]);
param_get(param_find("MODAL_IO_SDIR1"), &params->direction_map[0]);
param_get(param_find("MODAL_IO_SDIR2"), &params->direction_map[1]);
param_get(param_find("MODAL_IO_SDIR3"), &params->direction_map[2]);
param_get(param_find("MODAL_IO_SDIR4"), &params->direction_map[3]);
param_get(param_find("UART_ESC_RPM_MIN"), &params->rpm_min);
param_get(param_find("UART_ESC_RPM_MAX"), &params->rpm_max);
param_get(param_find("MODAL_IO_RPM_MIN"), &params->rpm_min);
param_get(param_find("MODAL_IO_RPM_MAX"), &params->rpm_max);
if (params->rpm_min >= params->rpm_max) {
PX4_ERR("Invalid parameter UART_ESC_RPM_MIN. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_RPM_MIN. Please verify parameters.");
params->rpm_min = 0;
ret = PX4_ERROR;
}
if (params->turtle_motor_percent < 0 || params->turtle_motor_percent > 100) {
PX4_ERR("Invalid parameter UART_ESC_T_PERC. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_T_PERC. Please verify parameters.");
params->turtle_motor_percent = 0;
ret = PX4_ERROR;
}
if (params->turtle_motor_deadband < 0 || params->turtle_motor_deadband > 100) {
PX4_ERR("Invalid parameter UART_ESC_T_DEAD. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_T_DEAD. Please verify parameters.");
params->turtle_motor_deadband = 0;
ret = PX4_ERROR;
}
if (params->turtle_motor_expo < 0 || params->turtle_motor_expo > 100) {
PX4_ERR("Invalid parameter UART_ESC_T_EXPO. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_T_EXPO. Please verify parameters.");
params->turtle_motor_expo = 0;
ret = PX4_ERROR;
}
if (params->turtle_stick_minf < 0.0f || params->turtle_stick_minf > 100.0f) {
PX4_ERR("Invalid parameter UART_ESC_T_MINF. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_T_MINF. Please verify parameters.");
params->turtle_stick_minf = 0.0f;
ret = PX4_ERROR;
}
if (params->turtle_cosphi < 0.0f || params->turtle_cosphi > 100.0f) {
PX4_ERR("Invalid parameter UART_ESC_T_COSP. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_T_COSP. Please verify parameters.");
params->turtle_cosphi = 0.0f;
ret = PX4_ERROR;
}
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
if (params->function_map[i] < (int)OutputFunction::Motor1 || params->function_map[i] > (int)OutputFunction::Motor4) {
PX4_ERR("Invalid parameter UART_ESC_FUNCX. Only supports motors 1-4. Please verify parameters.");
PX4_ERR("Invalid parameter MODAL_IO_FUNCX. Only supports motors 1-4. Please verify parameters.");
params->function_map[i] = 0;
ret = PX4_ERROR;
@@ -204,11 +204,11 @@ int ModalaiEsc::load_params(uart_esc_params_t *params, ch_assign_t *map)
}
}
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
if (params->motor_map[i] == MODALAI_ESC_OUTPUT_DISABLED ||
params->motor_map[i] < -(MODALAI_ESC_OUTPUT_CHANNELS) ||
params->motor_map[i] > MODALAI_ESC_OUTPUT_CHANNELS) {
PX4_ERR("Invalid parameter UART_ESC_MOTORX. Please verify parameters.");
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
if (params->motor_map[i] == MODAL_IO_OUTPUT_DISABLED ||
params->motor_map[i] < -(MODAL_IO_OUTPUT_CHANNELS) ||
params->motor_map[i] > MODAL_IO_OUTPUT_CHANNELS) {
PX4_ERR("Invalid parameter MODAL_IO_MOTORX. Please verify parameters.");
params->motor_map[i] = 0;
ret = PX4_ERROR;
}
@@ -221,7 +221,7 @@ int ModalaiEsc::load_params(uart_esc_params_t *params, ch_assign_t *map)
return ret;
}
int ModalaiEsc::task_spawn(int argc, char *argv[])
int ModalIo::task_spawn(int argc, char *argv[])
{
int myoptind = 0;
int ch;
@@ -238,7 +238,7 @@ int ModalaiEsc::task_spawn(int argc, char *argv[])
}
}
ModalaiEsc *instance = new ModalaiEsc();
ModalIo *instance = new ModalIo();
if (instance) {
_object.store(instance);
@@ -259,14 +259,14 @@ int ModalaiEsc::task_spawn(int argc, char *argv[])
return PX4_ERROR;
}
int ModalaiEsc::flush_uart_rx()
int ModalIo::flush_uart_rx()
{
while (_uart_port->uart_read(_read_buf, sizeof(_read_buf)) > 0) {}
return 0;
}
int ModalaiEsc::read_response(Command *out_cmd)
int ModalIo::read_response(Command *out_cmd)
{
px4_usleep(_current_cmd.resp_delay_us);
@@ -289,7 +289,7 @@ int ModalaiEsc::read_response(Command *out_cmd)
return 0;
}
int ModalaiEsc::parse_response(uint8_t *buf, uint8_t len, bool print_feedback)
int ModalIo::parse_response(uint8_t *buf, uint8_t len, bool print_feedback)
{
hrt_abstime tnow = hrt_absolute_time();
@@ -309,7 +309,7 @@ int ModalaiEsc::parse_response(uint8_t *buf, uint8_t len, bool print_feedback)
uint32_t id = (fb.id_state & 0xF0) >> 4; //ID of the ESC based on hardware address
if (id < MODALAI_ESC_OUTPUT_CHANNELS) {
if (id < MODAL_IO_OUTPUT_CHANNELS) {
int motor_idx = _output_map[id].number - 1; // mapped motor id.. user defined mapping is 1-4, array is 0-3
@@ -438,7 +438,7 @@ int ModalaiEsc::parse_response(uint8_t *buf, uint8_t len, bool print_feedback)
memcpy(&fb, buf, len);
uint8_t id = (fb.state & 0xF0) >> 4;
if (id < MODALAI_ESC_OUTPUT_CHANNELS) {
if (id < MODAL_IO_OUTPUT_CHANNELS) {
_esc_chans[id].rate_meas = fb.rpm;
_esc_chans[id].state = fb.state & 0x0F;
_esc_chans[id].cmd_counter = fb.cmd_counter;
@@ -456,19 +456,19 @@ int ModalaiEsc::parse_response(uint8_t *buf, uint8_t len, bool print_feedback)
return 0;
}
int ModalaiEsc::check_for_esc_timeout()
int ModalIo::check_for_esc_timeout()
{
hrt_abstime tnow = hrt_absolute_time();
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
// PX4 motor indexed user defined mapping is 1-4, we want to use in bitmask (0-3)
uint8_t motor_idx = _output_map[i].number - 1;
if (motor_idx < MODALAI_ESC_OUTPUT_CHANNELS) {
if (motor_idx < MODAL_IO_OUTPUT_CHANNELS) {
// we are using PX4 motor index in the bitmask
if (_esc_status.esc_online_flags & (1 << motor_idx)) {
// using index i here for esc_chans enumeration stored in ESC ID order
if ((tnow - _esc_chans[i].feedback_time) > MODALAI_ESC_DISCONNECT_TIMEOUT_US) {
if ((tnow - _esc_chans[i].feedback_time) > MODAL_IO_DISCONNECT_TIMEOUT_US) {
// stale data, assume offline and clear armed
_esc_status.esc_online_flags &= ~(1 << motor_idx);
_esc_status.esc_armed_flags &= ~(1 << motor_idx);
@@ -481,7 +481,7 @@ int ModalaiEsc::check_for_esc_timeout()
}
int ModalaiEsc::send_cmd_thread_safe(Command *cmd)
int ModalIo::send_cmd_thread_safe(Command *cmd)
{
cmd->id = _cmd_id++;
_pending_cmd.store(cmd);
@@ -496,7 +496,7 @@ int ModalaiEsc::send_cmd_thread_safe(Command *cmd)
int ModalaiEsc::custom_command(int argc, char *argv[])
int ModalIo::custom_command(int argc, char *argv[])
{
int myoptind = 0;
int ch;
@@ -522,7 +522,7 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
/* start the FMU if not running */
if (!strcmp(verb, "start")) {
if (!is_running()) {
return ModalaiEsc::task_spawn(argc, argv);
return ModalIo::task_spawn(argc, argv);
}
}
@@ -654,8 +654,8 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
} else if (!strcmp(verb, "rpm")) {
if (0 < esc_id && esc_id < 16) {
PX4_INFO("Request RPM for ESC bit mask: %i - RPM: %i", esc_id, rate);
int16_t rate_req[MODALAI_ESC_OUTPUT_CHANNELS];
int16_t outputs[MODALAI_ESC_OUTPUT_CHANNELS];
int16_t rate_req[MODAL_IO_OUTPUT_CHANNELS];
int16_t outputs[MODAL_IO_OUTPUT_CHANNELS];
outputs[0] = (esc_id & 1) ? rate : 0;
outputs[1] = (esc_id & 2) ? rate : 0;
outputs[2] = (esc_id & 4) ? rate : 0;
@@ -663,8 +663,8 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
//the motor mapping is.. if I want to spin Motor 1 (1-4) then i need to provide non-zero rpm for motor map[m-1]
uart_esc_params_t params;
ch_assign_t map[MODALAI_ESC_OUTPUT_CHANNELS];
modal_io_params_t params;
ch_assign_t map[MODAL_IO_OUTPUT_CHANNELS];
get_instance()->load_params(&params, (ch_assign_t *)&map);
uint8_t id_fb_raw = 0;
@@ -678,10 +678,10 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
else if (esc_id & 8) { id_fb_raw = 3; }
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
int motor_idx = map[i].number - 1; // user defined mapping is 1-4, array is 0-3
if (motor_idx >= 0 && motor_idx < MODALAI_ESC_OUTPUT_CHANNELS) {
if (motor_idx >= 0 && motor_idx < MODAL_IO_OUTPUT_CHANNELS) {
rate_req[i] = outputs[motor_idx] * map[i].direction;
}
@@ -722,15 +722,15 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
} else if (!strcmp(verb, "pwm")) {
if (0 < esc_id && esc_id < 16) {
PX4_INFO("Request PWM for ESC mask: %i - PWM: %i", esc_id, rate);
int16_t rate_req[MODALAI_ESC_OUTPUT_CHANNELS];
int16_t outputs[MODALAI_ESC_OUTPUT_CHANNELS];
int16_t rate_req[MODAL_IO_OUTPUT_CHANNELS];
int16_t outputs[MODAL_IO_OUTPUT_CHANNELS];
outputs[0] = (esc_id & 1) ? rate : 0;
outputs[1] = (esc_id & 2) ? rate : 0;
outputs[2] = (esc_id & 4) ? rate : 0;
outputs[3] = (esc_id & 8) ? rate : 0;
uart_esc_params_t params;
ch_assign_t map[MODALAI_ESC_OUTPUT_CHANNELS];
modal_io_params_t params;
ch_assign_t map[MODAL_IO_OUTPUT_CHANNELS];
get_instance()->load_params(&params, (ch_assign_t *)&map);
uint8_t id_fb_raw = 0;
@@ -744,10 +744,10 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
else if (esc_id & 8) { id_fb_raw = 3; }
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
int motor_idx = map[i].number - 1; // user defined mapping is 1-4, array is 0-3
if (motor_idx >= 0 && motor_idx < MODALAI_ESC_OUTPUT_CHANNELS) {
if (motor_idx >= 0 && motor_idx < MODAL_IO_OUTPUT_CHANNELS) {
rate_req[i] = outputs[motor_idx] * map[i].direction;
PX4_INFO("rate_req[%d]=%d", i, rate_req[i]);
}
@@ -791,7 +791,7 @@ int ModalaiEsc::custom_command(int argc, char *argv[])
return print_usage("unknown command");
}
int ModalaiEsc::update_params()
int ModalIo::update_params()
{
int ret = PX4_ERROR;
@@ -810,7 +810,7 @@ int ModalaiEsc::update_params()
return ret;
}
void ModalaiEsc::update_leds(vehicle_control_mode_s mode, led_control_s control)
void ModalIo::update_leds(vehicle_control_mode_s mode, led_control_s control)
{
int i = 0;
uint8_t led_mask = _led_rsc.led_mask;
@@ -910,12 +910,12 @@ void ModalaiEsc::update_leds(vehicle_control_mode_s mode, led_control_s control)
}
}
for (i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
_esc_chans[i].led = led_mask;
}
}
void ModalaiEsc::mix_turtle_mode(uint16_t outputs[MAX_ACTUATORS])
void ModalIo::mix_turtle_mode(uint16_t outputs[MAX_ACTUATORS])
{
bool use_pitch = true;
bool use_roll = true;
@@ -1090,10 +1090,10 @@ void ModalaiEsc::mix_turtle_mode(uint16_t outputs[MAX_ACTUATORS])
}
/* OutputModuleInterface */
bool ModalaiEsc::updateOutputs(bool stop_motors, uint16_t outputs[MAX_ACTUATORS],
unsigned num_outputs, unsigned num_control_groups_updated)
bool ModalIo::updateOutputs(bool stop_motors, uint16_t outputs[MAX_ACTUATORS],
unsigned num_outputs, unsigned num_control_groups_updated)
{
if (num_outputs != MODALAI_ESC_OUTPUT_CHANNELS) {
if (num_outputs != MODAL_IO_OUTPUT_CHANNELS) {
return false;
}
@@ -1102,7 +1102,7 @@ bool ModalaiEsc::updateOutputs(bool stop_motors, uint16_t outputs[MAX_ACTUATORS]
mix_turtle_mode(outputs);
}
for (int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++) {
for (int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++) {
if (!_outputs_on || stop_motors) {
_esc_chans[i].rate_req = 0;
@@ -1137,7 +1137,7 @@ bool ModalaiEsc::updateOutputs(bool stop_motors, uint16_t outputs[MAX_ACTUATORS]
}
// round robin
_fb_idx = (_fb_idx + 1) % MODALAI_ESC_OUTPUT_CHANNELS;
_fb_idx = (_fb_idx + 1) % MODAL_IO_OUTPUT_CHANNELS;
/*
@@ -1179,7 +1179,7 @@ bool ModalaiEsc::updateOutputs(bool stop_motors, uint16_t outputs[MAX_ACTUATORS]
}
void ModalaiEsc::Run()
void ModalIo::Run()
{
if (should_exit()) {
ScheduleClear();
@@ -1260,16 +1260,16 @@ void ModalaiEsc::Run()
if (!_outputs_on) {
float setpoint = MODALAI_ESC_MODE_DISABLED_SETPOINT;
float setpoint = MODAL_IO_MODE_DISABLED_SETPOINT;
if (_parameters.mode == MODALAI_ESC_MODE_TURTLE_AUX1) {
if (_parameters.mode == MODAL_IO_MODE_TURTLE_AUX1) {
setpoint = _manual_control_setpoint.aux1;
} else if (_parameters.mode == MODALAI_ESC_MODE_TURTLE_AUX2) {
} else if (_parameters.mode == MODAL_IO_MODE_TURTLE_AUX2) {
setpoint = _manual_control_setpoint.aux2;
}
if (setpoint > MODALAI_ESC_MODE_THRESHOLD) {
if (setpoint > MODAL_IO_MODE_THRESHOLD) {
_turtle_mode_en = true;
} else {
@@ -1278,9 +1278,9 @@ void ModalaiEsc::Run()
}
}
if (_parameters.mode == MODALAI_ESC_MODE_UART_BRIDGE) {
if (_parameters.mode == MODAL_IO_MODE_UART_BRIDGE) {
if (!_uart_port_bridge->is_open()) {
if (_uart_port_bridge->uart_open(MODALAI_ESC_VOXL_BRIDGE_PORT, 230400) == PX4_OK) {
if (_uart_port_bridge->uart_open(MODAL_IO_VOXL_BRIDGE_PORT, 230400) == PX4_OK) {
PX4_INFO("Opened UART ESC Bridge device");
} else {
@@ -1400,7 +1400,7 @@ void ModalaiEsc::Run()
}
int ModalaiEsc::print_usage(const char *reason)
int ModalIo::print_usage(const char *reason)
{
if (reason) {
PX4_WARN("%s\n", reason);
@@ -1420,7 +1420,7 @@ $ todo
)DESCR_STR");
PRINT_MODULE_USAGE_NAME("modalai_esc", "driver");
PRINT_MODULE_USAGE_NAME("modal_io", "driver");
PRINT_MODULE_USAGE_COMMAND_DESCR("start", "Start the task");
PRINT_MODULE_USAGE_COMMAND_DESCR("reset", "Send reset request to ESC");
@@ -1458,7 +1458,7 @@ $ todo
return 0;
}
int ModalaiEsc::print_status()
int ModalIo::print_status()
{
PX4_INFO("Max update rate: %i Hz", _current_update_rate);
PX4_INFO("Outputs on: %s", _outputs_on ? "yes" : "no");
@@ -1467,25 +1467,25 @@ int ModalaiEsc::print_status()
PX4_INFO("");
PX4_INFO("Params: UART_ESC_CONFIG: %li", _parameters.config);
PX4_INFO("Params: UART_ESC_BAUD: %li", _parameters.baud_rate);
PX4_INFO("Params: MODAL_IO_CONFIG: %li", _parameters.config);
PX4_INFO("Params: MODAL_IO_BAUD: %li", _parameters.baud_rate);
PX4_INFO("Params: UART_ESC_FUNC1: %li", _parameters.function_map[0]);
PX4_INFO("Params: UART_ESC_FUNC2: %li", _parameters.function_map[1]);
PX4_INFO("Params: UART_ESC_FUNC3: %li", _parameters.function_map[2]);
PX4_INFO("Params: UART_ESC_FUNC4: %li", _parameters.function_map[3]);
PX4_INFO("Params: MODAL_IO_FUNC1: %li", _parameters.function_map[0]);
PX4_INFO("Params: MODAL_IO_FUNC2: %li", _parameters.function_map[1]);
PX4_INFO("Params: MODAL_IO_FUNC3: %li", _parameters.function_map[2]);
PX4_INFO("Params: MODAL_IO_FUNC4: %li", _parameters.function_map[3]);
PX4_INFO("Params: UART_ESC_SDIR1: %li", _parameters.direction_map[0]);
PX4_INFO("Params: UART_ESC_SDIR2: %li", _parameters.direction_map[1]);
PX4_INFO("Params: UART_ESC_SDIR3: %li", _parameters.direction_map[2]);
PX4_INFO("Params: UART_ESC_SDIR4: %li", _parameters.direction_map[3]);
PX4_INFO("Params: MODAL_IO_SDIR1: %li", _parameters.direction_map[0]);
PX4_INFO("Params: MODAL_IO_SDIR2: %li", _parameters.direction_map[1]);
PX4_INFO("Params: MODAL_IO_SDIR3: %li", _parameters.direction_map[2]);
PX4_INFO("Params: MODAL_IO_SDIR4: %li", _parameters.direction_map[3]);
PX4_INFO("Params: UART_ESC_RPM_MIN: %li", _parameters.rpm_min);
PX4_INFO("Params: UART_ESC_RPM_MAX: %li", _parameters.rpm_max);
PX4_INFO("Params: MODAL_IO_RPM_MIN: %li", _parameters.rpm_min);
PX4_INFO("Params: MODAL_IO_RPM_MAX: %li", _parameters.rpm_max);
PX4_INFO("");
for( int i = 0; i < MODALAI_ESC_OUTPUT_CHANNELS; i++){
for( int i = 0; i < MODAL_IO_OUTPUT_CHANNELS; i++){
PX4_INFO("-- ID: %i", i);
PX4_INFO(" Motor: %i", _output_map[i].number);
PX4_INFO(" Direction: %i", _output_map[i].direction);
@@ -1505,9 +1505,9 @@ int ModalaiEsc::print_status()
return 0;
}
extern "C" __EXPORT int modalai_esc_main(int argc, char *argv[]);
extern "C" __EXPORT int modal_io_main(int argc, char *argv[]);
int modalai_esc_main(int argc, char *argv[])
int modal_io_main(int argc, char *argv[])
{
return ModalaiEsc::main(argc, argv);
return ModalIo::main(argc, argv);
}
src/drivers/actuators/modalai_esc/modalai_esc.hpp → src/drivers/actuators/modal_io/modal_io.hpp
+38 -45
View File
@@ -48,16 +48,16 @@
#include <uORB/topics/esc_status.h>
#include <uORB/topics/actuator_test.h>
#include "modalai_esc_serial.hpp"
#include "modal_io_serial.hpp"
#include "qc_esc_packet.h"
#include "qc_esc_packet_types.h"
class ModalaiEsc : public ModuleBase<ModalaiEsc>, public OutputModuleInterface
class ModalIo : public ModuleBase<ModalIo>, public OutputModuleInterface
{
public:
ModalaiEsc();
virtual ~ModalaiEsc();
ModalIo();
virtual ~ModalIo();
/** @see ModuleBase */
static int task_spawn(int argc, char *argv[]);
@@ -80,13 +80,6 @@ public:
virtual int init();
typedef enum {
UART_ESC_RESET,
UART_ESC_VERSION,
UART_ESC_TONE,
UART_ESC_LED
} uart_esc_cmd_t;
struct Command {
uint16_t id = 0;
uint8_t len = 0;
@@ -107,50 +100,50 @@ public:
int send_cmd_thread_safe(Command *cmd);
private:
static constexpr uint32_t MODALAI_ESC_UART_CONFIG = 1;
static constexpr uint32_t MODALAI_ESC_DEFAULT_BAUD = 250000;
static constexpr uint16_t MODALAI_ESC_OUTPUT_CHANNELS = 4;
static constexpr uint16_t MODALAI_ESC_OUTPUT_DISABLED = 0;
static constexpr uint32_t MODAL_IO_UART_CONFIG = 1;
static constexpr uint32_t MODAL_IO_DEFAULT_BAUD = 250000;
static constexpr uint16_t MODAL_IO_OUTPUT_CHANNELS = 4;
static constexpr uint16_t MODAL_IO_OUTPUT_DISABLED = 0;
static constexpr uint32_t MODALAI_ESC_WRITE_WAIT_US = 200;
static constexpr uint32_t MODALAI_ESC_DISCONNECT_TIMEOUT_US = 500000;
static constexpr uint32_t MODAL_IO_WRITE_WAIT_US = 200;
static constexpr uint32_t MODAL_IO_DISCONNECT_TIMEOUT_US = 500000;
static constexpr uint16_t DISARMED_VALUE = 0;
static constexpr uint16_t MODALAI_ESC_PWM_MIN = 0;
static constexpr uint16_t MODALAI_ESC_PWM_MAX = 800;
static constexpr uint16_t MODALAI_ESC_DEFAULT_RPM_MIN = 5000;
static constexpr uint16_t MODALAI_ESC_DEFAULT_RPM_MAX = 17000;
static constexpr uint16_t MODAL_IO_PWM_MIN = 0;
static constexpr uint16_t MODAL_IO_PWM_MAX = 800;
static constexpr uint16_t MODAL_IO_DEFAULT_RPM_MIN = 5000;
static constexpr uint16_t MODAL_IO_DEFAULT_RPM_MAX = 17000;
static constexpr float MODALAI_ESC_MODE_DISABLED_SETPOINT = -0.1f;
static constexpr float MODALAI_ESC_MODE_THRESHOLD = 0.0f;
static constexpr float MODAL_IO_MODE_DISABLED_SETPOINT = -0.1f;
static constexpr float MODAL_IO_MODE_THRESHOLD = 0.0f;
static constexpr uint32_t MODALAI_ESC_MODE = 0;
static constexpr uint32_t MODALAI_ESC_MODE_TURTLE_AUX1 = 1;
static constexpr uint32_t MODALAI_ESC_MODE_TURTLE_AUX2 = 2;
static constexpr uint32_t MODALAI_ESC_MODE_UART_BRIDGE = 3;
static constexpr uint32_t MODAL_IO_MODE = 0;
static constexpr uint32_t MODAL_IO_MODE_TURTLE_AUX1 = 1;
static constexpr uint32_t MODAL_IO_MODE_TURTLE_AUX2 = 2;
static constexpr uint32_t MODAL_IO_MODE_UART_BRIDGE = 3;
//static constexpr uint16_t max_pwm(uint16_t pwm) { return math::min(pwm, MODALAI_ESC_PWM_MAX); }
//static constexpr uint16_t max_rpm(uint16_t rpm) { return math::min(rpm, MODALAI_ESC_RPM_MAX); }
//static constexpr uint16_t max_pwm(uint16_t pwm) { return math::min(pwm, MODAL_IO_PWM_MAX); }
//static constexpr uint16_t max_rpm(uint16_t rpm) { return math::min(rpm, MODAL_IO_RPM_MAX); }
ModalaiEscSerial *_uart_port;
ModalaiEscSerial *_uart_port_bridge;
ModalIoSerial *_uart_port;
ModalIoSerial *_uart_port_bridge;
typedef struct {
int32_t config{MODALAI_ESC_UART_CONFIG};
int32_t mode{MODALAI_ESC_MODE};
int32_t config{MODAL_IO_UART_CONFIG};
int32_t mode{MODAL_IO_MODE};
int32_t turtle_motor_expo{35};
int32_t turtle_motor_deadband{20};
int32_t turtle_motor_percent{90};
float turtle_stick_minf{0.15f};
float turtle_cosphi{0.99f};
int32_t baud_rate{MODALAI_ESC_DEFAULT_BAUD};
int32_t rpm_min{MODALAI_ESC_DEFAULT_RPM_MIN};
int32_t rpm_max{MODALAI_ESC_DEFAULT_RPM_MAX};
int32_t function_map[MODALAI_ESC_OUTPUT_CHANNELS] {0, 0, 0, 0};
int32_t motor_map[MODALAI_ESC_OUTPUT_CHANNELS] {1, 2, 3, 4};
int32_t direction_map[MODALAI_ESC_OUTPUT_CHANNELS] {1, 1, 1, 1};
} uart_esc_params_t;
int32_t baud_rate{MODAL_IO_DEFAULT_BAUD};
int32_t rpm_min{MODAL_IO_DEFAULT_RPM_MIN};
int32_t rpm_max{MODAL_IO_DEFAULT_RPM_MAX};
int32_t function_map[MODAL_IO_OUTPUT_CHANNELS] {0, 0, 0, 0};
int32_t motor_map[MODAL_IO_OUTPUT_CHANNELS] {1, 2, 3, 4};
int32_t direction_map[MODAL_IO_OUTPUT_CHANNELS] {1, 1, 1, 1};
} modal_io_params_t;
struct EscChan {
int16_t rate_req;
@@ -173,13 +166,13 @@ private:
typedef struct {
led_control_s control{};
vehicle_control_mode_s mode{};
uint8_t led_mask;// TODO led_mask[MODALAI_ESC_OUTPUT_CHANNELS];
uint8_t led_mask;// TODO led_mask[MODAL_IO_OUTPUT_CHANNELS];
bool breath_en;
uint8_t breath_counter;
bool test;
} led_rsc_t;
ch_assign_t _output_map[MODALAI_ESC_OUTPUT_CHANNELS] {{1, 1}, {2, 1}, {3, 1}, {4, 1}};
ch_assign_t _output_map[MODAL_IO_OUTPUT_CHANNELS] {{1, 1}, {2, 1}, {3, 1}, {4, 1}};
MixingOutput _mixing_output;
perf_counter_t _cycle_perf;
@@ -198,9 +191,9 @@ private:
//uORB::Publication<actuator_outputs_s> _outputs_debug_pub{ORB_ID(actuator_outputs_debug)};
uORB::Publication<esc_status_s> _esc_status_pub{ORB_ID(esc_status)};
uart_esc_params_t _parameters;
modal_io_params_t _parameters;
int update_params();
int load_params(uart_esc_params_t *params, ch_assign_t *map);
int load_params(modal_io_params_t *params, ch_assign_t *map);
bool _turtle_mode_en{false};
int32_t _rpm_turtle_min{0};
@@ -211,7 +204,7 @@ private:
Command _current_cmd;
px4::atomic<Command *> _pending_cmd{nullptr};
EscChan _esc_chans[MODALAI_ESC_OUTPUT_CHANNELS];
EscChan _esc_chans[MODAL_IO_OUTPUT_CHANNELS];
Command _esc_cmd;
esc_status_s _esc_status;
EscPacket _fb_packet;
src/drivers/actuators/modalai_esc/modalai_esc_params.c → src/drivers/actuators/modal_io/modal_io_params.c
+32 -32
View File
@@ -38,23 +38,23 @@
*
* @reboot_required true
*
* @group UART ESC
* @group MODAL IO
* @value 0 - Disabled
* @value 1 - VOXL ESC
* @min 0
* @max 1
*/
PARAM_DEFINE_INT32(UART_ESC_CONFIG, 0);
PARAM_DEFINE_INT32(MODAL_IO_CONFIG, 0);
/**
* UART ESC baud rate
*
* Default rate is 250Kbps, which is used in off-the-shelf MoadalAI ESC products.
*
* @group UART ESC
* @group MODAL IO
* @unit bit/s
*/
PARAM_DEFINE_INT32(UART_ESC_BAUD, 250000);
PARAM_DEFINE_INT32(MODAL_IO_BAUD, 250000);
/**
* Motor mappings for ModalAI ESC
@@ -68,31 +68,31 @@ PARAM_DEFINE_INT32(UART_ESC_BAUD, 250000);
// The following are auto generated params from control allocator pattern, put here for reference
// Default ESC1 to motor2
//PARAM_DEFINE_INT32(UART_ESC_FUNC1, 102);
//PARAM_DEFINE_INT32(MODAL_IO_FUNC1, 102);
//PARAM_DEFINE_INT32(UART_ESC_FUNC2, 103);
//PARAM_DEFINE_INT32(MODAL_IO_FUNC2, 103);
//PARAM_DEFINE_INT32(UART_ESC_FUNC3, 101);
//PARAM_DEFINE_INT32(MODAL_IO_FUNC3, 101);
//PARAM_DEFINE_INT32(UART_ESC_FUNC4, 104);
//PARAM_DEFINE_INT32(MODAL_IO_FUNC4, 104);
/**
* UART ESC RPM Min
*
* Minimum RPM for ESC
*
* @group UART ESC
* @group MODAL IO
*/
PARAM_DEFINE_INT32(UART_ESC_RPM_MIN, 5500);
PARAM_DEFINE_INT32(MODAL_IO_RPM_MIN, 5500);
/**
* UART ESC RPM Max
*
* Maximum RPM for ESC
*
* @group UART ESC
* @group MODAL IO
*/
PARAM_DEFINE_INT32(UART_ESC_RPM_MAX, 15000);
PARAM_DEFINE_INT32(MODAL_IO_RPM_MAX, 15000);
/**
* UART ESC Mode
@@ -101,7 +101,7 @@ PARAM_DEFINE_INT32(UART_ESC_RPM_MAX, 15000);
*
* @reboot_required true
*
* @group UART ESC
* @group MODAL IO
* @value 0 - None
* @value 1 - Turtle Mode enabled via AUX1
* @value 2 - Turtle Mode enabled via AUX2
@@ -109,95 +109,95 @@ PARAM_DEFINE_INT32(UART_ESC_RPM_MAX, 15000);
* @min 0
* @max 2
*/
PARAM_DEFINE_INT32(UART_ESC_MODE, 0);
PARAM_DEFINE_INT32(MODAL_IO_MODE, 0);
/**
* UART ESC ID 1 Spin Direction Flag
*
* @group UART ESC
* @group MODAL IO
* @value 0 - Default
* @value 1 - Reverse
*/
PARAM_DEFINE_INT32(UART_ESC_SDIR1, 0);
PARAM_DEFINE_INT32(MODAL_IO_SDIR1, 0);
/**
* UART ESC ID 2 Spin Direction Flag
*
* @group UART ESC
* @group MODAL IO
* @value 0 - Default
* @value 1 - Reverse
*/
PARAM_DEFINE_INT32(UART_ESC_SDIR2, 0);
PARAM_DEFINE_INT32(MODAL_IO_SDIR2, 0);
/**
* UART ESC ID 3 Spin Direction Flag
*
* @group UART ESC
* @group MODAL IO
* @value 0 - Default
* @value 1 - Reverse
*/
PARAM_DEFINE_INT32(UART_ESC_SDIR3, 0);
PARAM_DEFINE_INT32(MODAL_IO_SDIR3, 0);
/**
* UART ESC ID 4 Spin Direction Flag
*
* @group UART ESC
* @group MODAL IO
* @value 0 - Default
* @value 1 - Reverse
*/
PARAM_DEFINE_INT32(UART_ESC_SDIR4, 0);
PARAM_DEFINE_INT32(MODAL_IO_SDIR4, 0);
/**
* UART ESC Turtle Mode Crash Flip Motor Percent
*
* @group UART ESC
* @group MODAL IO
* @min 1
* @max 100
* @decimal 10
* @increment 1
*/
PARAM_DEFINE_INT32(UART_ESC_T_PERC, 90);
PARAM_DEFINE_INT32(MODAL_IO_T_PERC, 90);
/**
* UART ESC Turtle Mode Crash Flip Motor Deadband
*
* @group UART ESC
* @group MODAL IO
* @min 0
* @max 100
* @decimal 10
* @increment 1
*/
PARAM_DEFINE_INT32(UART_ESC_T_DEAD, 20);
PARAM_DEFINE_INT32(MODAL_IO_T_DEAD, 20);
/**
* UART ESC Turtle Mode Crash Flip Motor STICK_MINF
*
* @group UART ESC
* @group MODAL IO
* @min 0.0
* @max 100.0
* @decimal 10
* @increment 1.0
*/
PARAM_DEFINE_FLOAT(UART_ESC_T_MINF, 0.15);
PARAM_DEFINE_FLOAT(MODAL_IO_T_MINF, 0.15);
/**
* UART ESC Turtle Mode Crash Flip Motor expo
*
* @group UART ESC
* @group MODAL IO
* @min 0
* @max 100
* @decimal 10
* @increment 1
*/
PARAM_DEFINE_INT32(UART_ESC_T_EXPO, 35);
PARAM_DEFINE_INT32(MODAL_IO_T_EXPO, 35);
/**
* UART ESC Turtle Mode Cosphi
*
* @group UART ESC
* @group MODAL IO
* @min 0.000
* @max 1.000
* @decimal 10
* @increment 0.001
*/
PARAM_DEFINE_FLOAT(UART_ESC_T_COSP, 0.990);
PARAM_DEFINE_FLOAT(MODAL_IO_T_COSP, 0.990);
src/drivers/actuators/modalai_esc/modalai_esc_serial.cpp → src/drivers/actuators/modal_io/modal_io_serial.cpp
+8 -8
View File
@@ -32,20 +32,20 @@
****************************************************************************/
#include "string.h"
#include "modalai_esc_serial.hpp"
#include "modal_io_serial.hpp"
ModalaiEscSerial::ModalaiEscSerial()
ModalIoSerial::ModalIoSerial()
{
}
ModalaiEscSerial::~ModalaiEscSerial()
ModalIoSerial::~ModalIoSerial()
{
if (_uart_fd >= 0) {
uart_close();
}
}
int ModalaiEscSerial::uart_open(const char *dev, speed_t speed)
int ModalIoSerial::uart_open(const char *dev, speed_t speed)
{
if (_uart_fd >= 0) {
PX4_ERR("Port in use: %s (%i)", dev, errno);
@@ -110,7 +110,7 @@ int ModalaiEscSerial::uart_open(const char *dev, speed_t speed)
return 0;
}
int ModalaiEscSerial::uart_set_baud(speed_t speed)
int ModalIoSerial::uart_set_baud(speed_t speed)
{
#ifndef __PX4_QURT
@@ -134,7 +134,7 @@ int ModalaiEscSerial::uart_set_baud(speed_t speed)
return -1;
}
int ModalaiEscSerial::uart_close()
int ModalIoSerial::uart_close()
{
#ifndef __PX4_QURT
@@ -158,7 +158,7 @@ int ModalaiEscSerial::uart_close()
return 0;
}
int ModalaiEscSerial::uart_write(FAR void *buf, size_t len)
int ModalIoSerial::uart_write(FAR void *buf, size_t len)
{
if (_uart_fd < 0 || buf == NULL) {
PX4_ERR("invalid state for writing or buffer");
@@ -172,7 +172,7 @@ int ModalaiEscSerial::uart_write(FAR void *buf, size_t len)
#endif
}
int ModalaiEscSerial::uart_read(FAR void *buf, size_t len)
int ModalIoSerial::uart_read(FAR void *buf, size_t len)
{
if (_uart_fd < 0 || buf == NULL) {
PX4_ERR("invalid state for reading or buffer");
src/drivers/actuators/modalai_esc/modalai_esc_serial.hpp → src/drivers/actuators/modal_io/modal_io_serial.hpp
+4 -4
View File
@@ -43,11 +43,11 @@
#define FAR
#endif
class ModalaiEscSerial
class ModalIoSerial
{
public:
ModalaiEscSerial();
virtual ~ModalaiEscSerial();
ModalIoSerial();
virtual ~ModalIoSerial();
int uart_open(const char *dev, speed_t speed);
int uart_set_baud(speed_t speed);
@@ -55,7 +55,7 @@ public:
int uart_write(FAR void *buf, size_t len);
int uart_read(FAR void *buf, size_t len);
bool is_open() { return _uart_fd >= 0; };
int uart_get_baud() {return _speed; }
int uart_get_baud() {return _speed; }
private:
int _uart_fd = -1;
src/drivers/actuators/modalai_esc/module.yaml → src/drivers/actuators/modal_io/module.yaml
+11 -11
View File
@@ -1,26 +1,26 @@
module_name: MODALAI ESC Output
module_name: MODAL IO Output
actuator_output:
show_subgroups_if: 'UART_ESC_CONFIG>0'
show_subgroups_if: 'MODAL_IO_CONFIG>0'
config_parameters:
- param: 'UART_ESC_CONFIG'
- param: 'MODAL_IO_CONFIG'
label: 'Configure'
function: 'enable'
- param: 'UART_ESC_BAUD'
- param: 'MODAL_IO_BAUD'
label: 'Bitrate'
- param: 'UART_ESC_RPM_MIN'
- param: 'MODAL_IO_RPM_MIN'
label: 'RPM Min'
- param: 'UART_ESC_RPM_MAX'
- param: 'MODAL_IO_RPM_MAX'
label: 'RPM Max'
- param: 'UART_ESC_SDIR1'
- param: 'MODAL_IO_SDIR1'
label: 'ESC 1 Spin Direction'
- param: 'UART_ESC_SDIR2'
- param: 'MODAL_IO_SDIR2'
label: 'ESC 2 Spin Direction'
- param: 'UART_ESC_SDIR3'
- param: 'MODAL_IO_SDIR3'
label: 'ESC 3 Spin Direction'
- param: 'UART_ESC_SDIR4'
- param: 'MODAL_IO_SDIR4'
label: 'ESC 4 Spin Direction'
output_groups:
- param_prefix: UART_ESC
- param_prefix: MODAL_IO
group_label: 'ESCs'
channel_label: 'ESC'
num_channels: 4
src/drivers/actuators/modalai_esc/qc_esc_packet.c → src/drivers/actuators/modal_io/qc_esc_packet.c
View File
src/drivers/actuators/modalai_esc/qc_esc_packet.h → src/drivers/actuators/modal_io/qc_esc_packet.h
View File
src/drivers/actuators/modalai_esc/qc_esc_packet_types.h → src/drivers/actuators/modal_io/qc_esc_packet_types.h
View File
src/drivers/actuators/modalai_esc/Kconfig
-5
View File
@@ -1,5 +0,0 @@
menuconfig DRIVERS_ACTUATORS_MODALAI_ESC
bool "modalai_esc"
default n
---help---
Enable support for modalai_esc