Try removing a lot of noise

Author: victor-Lopez25

Inc/HALAL/Models/TimerDomain/TimerDomain.hpp

@@ -746,6 +746,12 @@ struct TimerDomain {
             Scheduler_global_timer = cmsis_timers[timer_idxmap[SCHEDULER_TIMER_DOMAIN]];
             rcc_enable_timer(Scheduler_global_timer);
 
+            for(uint32_t inst = 0; inst < TimerDomain::max_instances; inst++) {
+                for(uint32_t ch = 0; i < TimerDomain::input_capture_channels; ch++) {
+                    input_capture_info[inst][ch] = &input_capture_info_dummy;
+                }
+            }
+
             TimerDomain::callbacks[0] = TIM_Default_Callback;
             TimerDomain::callbacks[1] = TIM_Default_Callback;
             TimerDomain::callbacks[2] = TIM_Default_Callback;

Inc/HALAL/Services/InputCapture/InputCapture.hpp

@@ -59,7 +59,8 @@ class InputCapture {
             .ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING,
             .ICSelection = TIM_ICSELECTION_DIRECTTI,
             .ICPrescaler = TIM_ICPSC_DIV1,
-            .ICFilter = 0,
+            /* filter out with hardware some noise */
+            .ICFilter = 0x03,
         };
         timer->template config_input_compare_channel<pin_rising.channel>(&sConfigIC);
 

Src/HALAL/Models/TimerDomain/TimerDomain.cpp

@@ -27,24 +27,36 @@ void* TimerDomain::callback_data[TimerDomain::max_instances] = {nullptr};
 TimerDomain::InputCaptureInfo input_capture_info_dummy = {
     .channel_rising = 0xFF,  // any value that isn't possible here
     .channel_falling = 0xFF, // any value that isn't possible here
+
+    .value_rising = 0,
+    .value_falling = 0,
+    .period = 0,
+
+    .duty_cycle = 0,
+    .frequency = 0,
 };
 
 TimerDomain::InputCaptureInfo* TimerDomain::input_capture_info[max_instances]
-                                                              [input_capture_channels] = {
-                                                                  {&input_capture_info_dummy}
-};
+                                                              [input_capture_channels];
 TimerDomain::InputCaptureInfo TimerDomain::input_capture_info_backing[max_instances]
                                                                      [input_capture_channels];
 
 static void TIM_IC_CaptureCallback(const uint32_t timer_idx, uint32_t channel) {
     TIM_HandleTypeDef* htim = TimerDomain::hal_handles[timer_idx];
 
     TimerDomain::InputCaptureInfo* info = TimerDomain::input_capture_info[timer_idx][channel];
+    uint32_t current = (*(((volatile uint32_t*)&htim->Instance->CCR1) + channel));
     if (info->channel_rising == channel) {
         // NOTE: CCR1 - CCR4 are contiguous
         // NOTE: CCxIF flag is cleared by software by reading the captured data in CCRx
-        uint32_t current = (*(((volatile uint32_t*)&htim->Instance->CCR1) + channel));
-        uint32_t period = current - info->value_rising;
+        uint32_t period;
+        if (current >= info->value_rising) {
+          period = current - info->value_rising;
+        } else {
+            // counter wrap around
+            uint32_t max_count = htim->Instance->ARR - 1;
+            period = (current + max_count) - info->value_rising;
+        }
 
         if ((period != 0) && (info->value_falling < period)) {
             uint32_t ref_clock =
@@ -55,8 +67,14 @@ static void TIM_IC_CaptureCallback(const uint32_t timer_idx, uint32_t channel) {
         }
         info->value_rising = current;
     } else if (info->channel_falling == channel) {
-        uint32_t falling_value =
-            *(((volatile uint32_t*)&htim->Instance->CCR1) + channel) - info->value_rising;
+        uint32_t falling_value;
+        if (current >= info->value_rising) {
+            falling_value = current - info->value_rising;
+        } else {
+            uint32_t max_count = htim->Instance->ARR - 1;
+            falling_value = (current + max_count) - info->value_rising;
+        }
+
         if (falling_value < info->period)
             info->value_falling = falling_value;
     } else [[unlikely]] {