output: derive motor protocols from pin capabilities

Author: bkleiner

src/control/multi/motor.c

@@ -191,7 +191,7 @@ void motor_mixer_calc(void) {
     }
   }
 
-  if (target.brushless) {
+  if (profile_outputs_use_protocol(OUTPUT_PROTOCOL_DSHOT)) {
     motor_brushless_mixer_scale_calc(state.throttle);
   } else {
     motor_brushed_mixer_scale_calc(state.throttle);

src/control/multi/turtle_mode.c

@@ -22,7 +22,7 @@ static uint8_t turtle_axis = 0;
 static uint8_t turtle_dir = 0;
 
 void turtle_mode_start() {
-  if (!target.brushless) {
+  if (!profile_outputs_use_protocol(OUTPUT_PROTOCOL_DSHOT)) {
     return;
   }
 
@@ -37,15 +37,15 @@ void turtle_mode_start() {
 }
 
 void turtle_mode_cancel() {
-  if (!target.brushless) {
+  if (!profile_outputs_use_protocol(OUTPUT_PROTOCOL_DSHOT)) {
     return;
   }
 
   flags.turtle_ready = 0;
 }
 
 void turtle_mode_update() {
-  if (!target.brushless) {
+  if (!profile_outputs_use_protocol(OUTPUT_PROTOCOL_DSHOT)) {
     return;
   }
 

src/control/output.c

@@ -102,11 +102,20 @@ static bool output_is_motor_value(uint8_t index, const profile_output_t *output)
   }
 
   const target_output_t *target_output = &target.outputs[output->target_output];
-  if (target_output->pin == PIN_NONE || (target_output->caps & OUTPUT_CAP_MOTOR) == 0) {
+  if (target_output->pin == PIN_NONE) {
     return false;
   }
 
-  return output->protocol != OUTPUT_PROTOCOL_PWM || output_has_mixer_source(index, OUTPUT_SOURCE_THROTTLE);
+  if (output->protocol == OUTPUT_PROTOCOL_DSHOT) {
+    return (target_output->caps & OUTPUT_CAP_DSHOT) != 0;
+  }
+  if (output->protocol == OUTPUT_PROTOCOL_BRUSHED) {
+    return (target_output->caps & OUTPUT_CAP_BRUSHED) != 0;
+  }
+  if (output->protocol == OUTPUT_PROTOCOL_PWM) {
+    return (target_output->caps & OUTPUT_CAP_PWM) != 0 && output_has_mixer_source(index, OUTPUT_SOURCE_THROTTLE);
+  }
+  return false;
 }
 
 static float output_finalize_pwm_motor(float *value, float motor_limit) {
@@ -215,14 +224,16 @@ bool output_source_configured(output_source_t source) {
     if (target_output->pin == PIN_NONE) {
       continue;
     }
+    output_caps_t cap = 0;
     if (output->protocol == OUTPUT_PROTOCOL_DSHOT) {
-      return target.brushless && (target_output->caps & OUTPUT_CAP_MOTOR) != 0;
-    }
-    if (output->protocol == OUTPUT_PROTOCOL_BRUSHED) {
-      return !target.brushless && (target_output->caps & OUTPUT_CAP_MOTOR) != 0;
+      cap = OUTPUT_CAP_DSHOT;
+    } else if (output->protocol == OUTPUT_PROTOCOL_BRUSHED) {
+      cap = OUTPUT_CAP_BRUSHED;
+    } else if (output->protocol == OUTPUT_PROTOCOL_PWM) {
+      cap = OUTPUT_CAP_PWM;
     }
-    if (output->protocol == OUTPUT_PROTOCOL_PWM) {
-      return (target_output->caps & (OUTPUT_CAP_MOTOR | OUTPUT_CAP_SERVO)) != 0;
+    if ((target_output->caps & cap) != 0) {
+      return true;
     }
   }
   return false;

src/core/profile.c

@@ -596,11 +596,18 @@ const profile_t default_profile = {
 // the actual profile
 FAST_RAM profile_t profile;
 
-bool profile_output_slot_uses_motor(uint8_t target_output) {
+bool profile_output_slot_uses_protocol(uint8_t target_output, output_protocol_t protocol) {
   for (uint32_t i = 0; i < MOTOR_PIN_MAX; i++) {
-    if (profile.outputs[i].target_output == target_output &&
-        profile.outputs[i].protocol != OUTPUT_PROTOCOL_NONE &&
-        profile.outputs[i].protocol != OUTPUT_PROTOCOL_PWM) {
+    if (profile.outputs[i].target_output == target_output && profile.outputs[i].protocol == protocol) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool profile_outputs_use_protocol(output_protocol_t protocol) {
+  for (uint32_t i = 0; i < MOTOR_PIN_MAX; i++) {
+    if (profile.outputs[i].protocol == protocol) {
       return true;
     }
   }

src/core/profile.h

@@ -548,7 +548,8 @@ pid_rate_t *profile_current_pid_rates();
 #ifndef VEHICLE_ROVER
 rate_t *profile_current_rates();
 #endif
-bool profile_output_slot_uses_motor(uint8_t target_output);
+bool profile_output_slot_uses_protocol(uint8_t target_output, output_protocol_t protocol);
+bool profile_outputs_use_protocol(output_protocol_t protocol);
 bool profile_output_slot_uses_servo(uint8_t target_output);
 uint32_t profile_output_count(const profile_output_t *outputs, uint32_t size);
 uint32_t profile_mixer_rule_count(const profile_mixer_rule_t *mixer, uint32_t size);

src/core/target.c

@@ -10,7 +10,6 @@
 
 FAST_RAM target_t target = {
     .name = "unknown",
-    .brushless = true,
 };
 
 #define _MACRO_STR(arg) #arg
@@ -267,19 +266,25 @@ cbor_result_t cbor_encode_output_caps_t(cbor_value_t *enc, const output_caps_t *
   cbor_result_t res = CBOR_OK;
 
   uint32_t count = 0;
-  if (*t & OUTPUT_CAP_MOTOR) {
+  if (*t & OUTPUT_CAP_PWM) {
     count++;
   }
-  if (*t & OUTPUT_CAP_SERVO) {
+  if (*t & OUTPUT_CAP_DSHOT) {
+    count++;
+  }
+  if (*t & OUTPUT_CAP_BRUSHED) {
     count++;
   }
 
   CBOR_CHECK_ERROR(res = cbor_encode_array(enc, count));
-  if (*t & OUTPUT_CAP_MOTOR) {
-    CBOR_CHECK_ERROR(res = cbor_encode_str(enc, "motor"));
+  if (*t & OUTPUT_CAP_PWM) {
+    CBOR_CHECK_ERROR(res = cbor_encode_str(enc, "pwm"));
+  }
+  if (*t & OUTPUT_CAP_DSHOT) {
+    CBOR_CHECK_ERROR(res = cbor_encode_str(enc, "dshot"));
   }
-  if (*t & OUTPUT_CAP_SERVO) {
-    CBOR_CHECK_ERROR(res = cbor_encode_str(enc, "servo"));
+  if (*t & OUTPUT_CAP_BRUSHED) {
+    CBOR_CHECK_ERROR(res = cbor_encode_str(enc, "brushed"));
   }
 
   return res;
@@ -296,10 +301,12 @@ cbor_result_t cbor_decode_output_caps_t(cbor_value_t *dec, output_caps_t *t) {
     const uint8_t *name;
     uint32_t name_len;
     CBOR_CHECK_ERROR(res = cbor_decode_tstr(dec, &name, &name_len));
-    if (buf_equal_string(name, name_len, "motor")) {
-      caps |= OUTPUT_CAP_MOTOR;
-    } else if (buf_equal_string(name, name_len, "servo")) {
-      caps |= OUTPUT_CAP_SERVO;
+    if (buf_equal_string(name, name_len, "pwm")) {
+      caps |= OUTPUT_CAP_PWM;
+    } else if (buf_equal_string(name, name_len, "dshot")) {
+      caps |= OUTPUT_CAP_DSHOT;
+    } else if (buf_equal_string(name, name_len, "brushed")) {
+      caps |= OUTPUT_CAP_BRUSHED;
     }
   }
 

src/core/target.h

@@ -39,8 +39,9 @@ typedef enum {
 typedef uint8_t vehicle_flags_t;
 
 typedef enum {
-  OUTPUT_CAP_MOTOR = (1 << 0),
-  OUTPUT_CAP_SERVO = (1 << 1),
+  OUTPUT_CAP_PWM = (1 << 0),
+  OUTPUT_CAP_DSHOT = (1 << 1),
+  OUTPUT_CAP_BRUSHED = (1 << 2),
 } output_cap_t;
 
 typedef uint8_t output_caps_t;
@@ -226,8 +227,6 @@ typedef struct {
   uint8_t name[32];
   uint8_t manufacturer[32];
 
-  bool brushless;
-
   target_led_t leds[LED_MAX];
   target_serial_port_t serial_ports[SERIAL_PORT_MAX];
   target_serial_port_t serial_soft_ports[SERIAL_SOFT_COUNT];
@@ -261,7 +260,6 @@ typedef struct {
   START_STRUCT(target_t)                                                         \
   TSTR_MEMBER(name, 32)                                                          \
   TSTR_MEMBER(manufacturer, 32)                                                  \
-  MEMBER(brushless, bool)                                                        \
   ARRAY_MEMBER(leds, LED_MAX, target_led_t)                                      \
   INDEX_ARRAY_MEMBER(serial_ports, SERIAL_PORT_MAX, target_serial_port_t)        \
   INDEX_ARRAY_MEMBER(serial_soft_ports, SERIAL_SOFT_COUNT, target_serial_port_t) \

src/driver/mcu/at32/motor_dshot.c

@@ -109,7 +109,8 @@ void dshot_dma_isr(const dma_device_t dev) {
   if (profile.motor.dshot_telemetry && dshot_phase == dshot_gpio_port_count) {
     // output phase done, lets swap to input
     for (uint32_t i = 0; i < MOTOR_PIN_MAX; i++) {
-      if (target.outputs[i].pin == PIN_NONE || (target.outputs[i].caps & OUTPUT_CAP_MOTOR) == 0 || !profile_output_slot_uses_motor(i)) {
+      if (target.outputs[i].pin == PIN_NONE || (target.outputs[i].caps & OUTPUT_CAP_DSHOT) == 0 ||
+          !profile_output_slot_uses_protocol(i, OUTPUT_PROTOCOL_DSHOT)) {
         continue;
       }
       dshot_gpio_init_input(target.outputs[i].pin);

src/driver/mcu/at32/motor_pwm.c

@@ -26,7 +26,8 @@ void motor_pwm_init() {
 
   for (uint32_t i = 0; i < MOTOR_PIN_MAX; i++) {
     const gpio_pins_t pin = target.outputs[i].pin;
-    if (pin == PIN_NONE || (target.outputs[i].caps & OUTPUT_CAP_MOTOR) == 0 || !profile_output_slot_uses_motor(i)) {
+    if (pin == PIN_NONE || (target.outputs[i].caps & OUTPUT_CAP_BRUSHED) == 0 ||
+        !profile_output_slot_uses_protocol(i, OUTPUT_PROTOCOL_BRUSHED)) {
       continue;
     }
 

src/driver/mcu/stm32/dma.c

@@ -150,7 +150,7 @@ bool dma_can_use_dma2(dma_device_t device) {
   }
 
 #ifdef USE_MOTOR_DSHOT
-  if (target.brushless && dshot_phase != 0) {
+  if (dshot_phase != 0) {
     return false;
   }
 #endif