slightly improve pwm module

Src/modules/feedback/dronecan/feedback.cpp

@@ -41,44 +41,44 @@ void DronecanFeedbackModule::spin_once() {
         return;
     }
 
-    for (auto& pwm : PWMModule::params) {
-        if (pwm.channel < 0) {
+    for (uint_fast8_t pin_idx = 0; pin_idx < PWMModule::get_pins_amount(); pin_idx++) {
+        if (!PWMModule::is_pin_enabled(pin_idx)) {
             continue;
         }
 
         switch (cmd_type) {
             case CommandType::RAW_COMMAND:
-                publish_esc_status(pwm);
+                publish_esc_status(pin_idx);
                 break;
             case CommandType::ARRAY_COMMAND:
-                publish_actuator_status(pwm);
+                publish_actuator_status(pin_idx);
                 break;
             case CommandType::HARDPOINT_COMMAND:
-                publish_hardpoint_status(pwm);
+                publish_hardpoint_status(pin_idx);
                 break;
             default:
                 break;
         }
     }
 }
 
-void DronecanFeedbackModule::publish_esc_status(PwmChannelInfo& pwm) {
+void DronecanFeedbackModule::publish_esc_status(uint8_t pin_idx) {
     esc_status.msg = {
         .error_count = esc_status.msg.error_count + 1,
         .voltage = CircuitPeriphery::voltage_vin(),
         .current = CircuitPeriphery::current(),
         .temperature = static_cast<float>(CircuitPeriphery::temperature()),
         .rpm = 0,
-        .power_rating_pct = HAL::Pwm::get_percent(pwm.pin, pwm.min, pwm.max),
-        .esc_index = static_cast<uint8_t>(pwm.channel),
+        .power_rating_pct = PWMModule::get_pin_percent(pin_idx),
+        .esc_index = (uint8_t)PWMModule::get_pin_channel(pin_idx),
     };
 
     esc_status.publish();
 }
 
-void DronecanFeedbackModule::publish_actuator_status(PwmChannelInfo& pwm) {
+void DronecanFeedbackModule::publish_actuator_status(uint8_t pin_idx) {
     actuator_status.msg = {
-        .actuator_id = static_cast<uint8_t>(pwm.channel),
+        .actuator_id = (uint8_t)PWMModule::get_pin_channel(pin_idx),
 
         // The following fields are not used in PX4 anyway
         // Let's fill them with something useful for logging for a while
@@ -87,23 +87,21 @@ void DronecanFeedbackModule::publish_actuator_status(PwmChannelInfo& pwm) {
         .speed = static_cast<float>(CircuitPeriphery::temperature()),
 
         .reserved = 0,
-        .power_rating_pct = HAL::Pwm::get_percent(pwm.pin, pwm.min, pwm.max),
+        .power_rating_pct = PWMModule::get_pin_percent(pin_idx),
     };
 
     actuator_status.publish();
 }
 
-void DronecanFeedbackModule::publish_hardpoint_status(PwmChannelInfo& pwm) {
+void DronecanFeedbackModule::publish_hardpoint_status(uint8_t pin_idx) {
     static constexpr uint16_t CMD_RELEASE_OR_MIN = 0;
     static constexpr uint16_t CMD_HOLD_OR_MAX = 1;
 
-    auto pwm_duration_us = HAL::Pwm::get_duration(pwm.pin);
-
     hardpoint_status.msg = {
-        .hardpoint_id = static_cast<uint8_t>(pwm.channel),
+        .hardpoint_id = (uint8_t)PWMModule::get_pin_channel(pin_idx),
         .payload_weight = 0.0f,
         .payload_weight_variance = 0.0f,
-        .status = (pwm_duration_us == pwm.min) ? CMD_RELEASE_OR_MIN : CMD_HOLD_OR_MAX,
+        .status = PWMModule::get_pin_percent(pin_idx) == 0 ? CMD_RELEASE_OR_MIN : CMD_HOLD_OR_MAX,
     };
 
     hardpoint_status.publish();

Src/modules/feedback/dronecan/feedback.hpp

@@ -38,9 +38,9 @@ class DronecanFeedbackModule : public Module {
     void update_params() override;
 
 private:
-    void publish_esc_status(PwmChannelInfo& pwm);
-    void publish_actuator_status(PwmChannelInfo& pwm);
-    void publish_hardpoint_status(PwmChannelInfo& pwm);
+    void publish_esc_status(uint8_t pin_idx);
+    void publish_actuator_status(uint8_t pin_idx);
+    void publish_hardpoint_status(uint8_t pin_idx);
 
     static inline DronecanPublisher<ActuatorStatus_t> actuator_status;
     static inline DronecanPublisher<EscStatus_t> esc_status;

Src/modules/pwm/main.cpp

@@ -61,6 +61,22 @@ void PWMModule::init() {
 #endif  // CONFIG_USE_CYPHAL
 }
 
+int8_t PWMModule::get_pin_channel(uint8_t pin_idx) {
+    return pin_idx < PWMModule::get_pins_amount() ? params[pin_idx].channel : -1;
+}
+
+bool PWMModule::is_pin_enabled(uint8_t pin_idx) {
+    return get_pin_channel(pin_idx) >= 0;
+}
+
+uint8_t PWMModule::get_pin_percent(uint8_t pin_idx) {
+    if (!is_pin_enabled(pin_idx)) {
+        return 0;
+    }
+
+    return HAL::Pwm::get_percent(params[pin_idx].pin, params[pin_idx].min, params[pin_idx].max);
+}
+
 /**
  * Control:
  * 1. Set default PWM for a channel if his command is outdated

Src/modules/pwm/main.hpp

@@ -39,6 +39,14 @@ class PWMModule : public Module {
     PWMModule() : Module(50, Protocol::CYPHAL_AND_DRONECAN) {}
     void init() override;
 
+    static inline constexpr uint8_t get_pins_amount() {
+        return static_cast<uint8_t>(HAL::PwmPin::PWM_AMOUNT);
+    }
+
+    static int8_t get_pin_channel(uint8_t pin_idx);
+    static bool is_pin_enabled(uint8_t pin_idx);
+    static uint8_t get_pin_percent(uint8_t pin_idx);
+
     static std::array<PwmChannelInfo, static_cast<uint8_t>(HAL::PwmPin::PWM_AMOUNT)> params;
     static inline uint16_t pwm_freq{50};
     static inline uint16_t cmd_ttl{500};