tested h7 low-side, added repetition counterhandling

Author: askuric

src/current_sense/hardware_specific/stm32/stm32f4/stm32f4_utils.cpp

@@ -26,18 +26,19 @@ uint32_t _timerToInjectedTRGO(TIM_HandleTypeDef* timer){
 // timer to regular TRGO
 // https://github.com/stm32duino/Arduino_Core_STM32/blob/e156c32db24d69cb4818208ccc28894e2f427cfa/system/Drivers/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_adc.h#L331
 uint32_t _timerToRegularTRGO(TIM_HandleTypeDef* timer){
+#ifdef TIM2 // if defined timer 2
   if(timer->Instance == TIM2)  
     return ADC_EXTERNALTRIGCONV_T2_TRGO;
+#endif
 #ifdef TIM3 // if defined timer 3
-  else if(timer->Instance == TIM3) 
+  if(timer->Instance == TIM3) 
     return ADC_EXTERNALTRIGCONV_T3_TRGO;
 #endif
 #ifdef TIM8 // if defined timer 8
-  else if(timer->Instance == TIM8) 
+  if(timer->Instance == TIM8) 
     return ADC_EXTERNALTRIGCONV_T8_TRGO;
 #endif
-  else
-    return _TRGO_NOT_AVAILABLE;
+  return _TRGO_NOT_AVAILABLE;
 }
 
 #endif

src/current_sense/hardware_specific/stm32/stm32h7/stm32h7_hal.cpp

@@ -86,7 +86,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
   // if ADC1 or ADC2
   if(hadc.Instance == ADC1 || hadc.Instance == ADC2){
     // more info here: https://github.com/stm32duino/Arduino_Core_STM32/blob/e156c32db24d69cb4818208ccc28894e2f427cfa/system/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_adc.h#L658
-    sConfigInjected.InjectedSamplingTime = ADC_SAMPLETIME_2CYCLE_5;
+    sConfigInjected.InjectedSamplingTime = ADC_SAMPLETIME_1CYCLE_5;
   }else {
     // adc3
     // https://github.com/stm32duino/Arduino_Core_STM32/blob/e156c32db24d69cb4818208ccc28894e2f427cfa/system/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_adc.h#L673
@@ -196,13 +196,12 @@ int _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const int
   return 0;
 }
 
-#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+
 extern "C" {
   void ADC_IRQHandler(void)
   {
       HAL_ADC_IRQHandler(&hadc);
   }
 }
-#endif
 
 #endif

src/current_sense/hardware_specific/stm32/stm32h7/stm32h7_mcu.cpp

@@ -22,6 +22,12 @@ bool needs_downsample[3] = {1};
 // downsampling variable - per adc (3)
 uint8_t tim_downsample[3] = {1};
 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+uint8_t use_adc_interrupt = 1;
+#else
+uint8_t use_adc_interrupt = 0;
+#endif
+
 void* _configureADCLowSide(const void* driver_params, const int pinA, const int pinB, const int pinC){
 
   Stm32CurrentSenseParams* cs_params= new Stm32CurrentSenseParams {
@@ -56,19 +62,47 @@ void* _driverSyncLowSide(void* _driver_params, void* _cs_params){
     cs_params->timer_handle->Instance->CNT = cs_params->timer_handle->Instance->ARR;
     // remember that this timer has repetition counter - no need to downasmple
     needs_downsample[_adcToIndex(cs_params->adc_handle)] = 0;
+  }else{
+    if(!use_adc_interrupt){
+      // If the timer has no repetition counter, it needs to use the interrupt to downsample for low side sensing
+      use_adc_interrupt = 1;
+      #ifdef SIMPLEFOC_STM32_DEBUG
+      SIMPLEFOC_DEBUG("STM32-CS: timer has no repetition counter, ADC interrupt has to be used");
+      #endif
+    }
   }
+
   // set the trigger output event
   LL_TIM_SetTriggerOutput(cs_params->timer_handle->Instance, LL_TIM_TRGO_UPDATE);
 
   // Start the adc calibration
-  HAL_ADCEx_Calibration_Start(cs_params->adc_handle, ADC_CALIB_OFFSET_LINEARITY, ADC_SINGLE_ENDED);
+  if(HAL_ADCEx_Calibration_Start(cs_params->adc_handle, ADC_CALIB_OFFSET_LINEARITY, ADC_SINGLE_ENDED) != HAL_OK){
+    #ifdef SIMPLEFOC_STM32_DEBUG
+      SIMPLEFOC_DEBUG("STM32-CS: ERR: cannot calibrate ADC!");
+    #endif
+    return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
+  }
 
   // start the adc
-  #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT 
-  HAL_ADCEx_InjectedStart_IT(cs_params->adc_handle);
-  #else
-  HAL_ADCEx_InjectedStart(cs_params->adc_handle);
-  #endif
+  if(use_adc_interrupt){
+    // enable interrupt
+    HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);
+    HAL_NVIC_EnableIRQ(ADC_IRQn);
+
+    if(HAL_ADCEx_InjectedStart_IT(cs_params->adc_handle) != HAL_OK){
+      #ifdef SIMPLEFOC_STM32_DEBUG
+        SIMPLEFOC_DEBUG("STM32-CS: ERR: cannot start injected channels in interrupt mode!");
+      #endif
+      return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
+    }
+  }else{
+    if(HAL_ADCEx_InjectedStart(cs_params->adc_handle) != HAL_OK){
+      #ifdef SIMPLEFOC_STM32_DEBUG
+        SIMPLEFOC_DEBUG("STM32-CS: ERR: cannot start injected channels!");
+      #endif
+      return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
+    }
+  }
 
 
   // restart all the timers of the driver
@@ -83,32 +117,34 @@ void* _driverSyncLowSide(void* _driver_params, void* _cs_params){
 
 // function reading an ADC value and returning the read voltage
 float _readADCVoltageLowSide(const int pin, const void* cs_params){
+  // print all values in the buffer 
+  // SIMPLEFOC_DEBUG("adc_a:", (int)HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle, _getADCInjectedRank(0)));
+  // SIMPLEFOC_DEBUG("adc_b:", (int)HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle, _getADCInjectedRank(1)));
   uint8_t channel_no = 0;
   for(int i=0; i < 3; i++){
     if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]){ // found in the buffer
-      #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+      if (use_adc_interrupt){
         return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][channel_no] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
-      #else
+      }else{
         // an optimized way to go from i to the channel i=0 -> channel 1, i=1 -> channel 2, i=2 -> channel 3
         uint32_t channel = _getADCInjectedRank(channel_no);
         return HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle, channel) * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
-      #endif
+      }
     }
     if(_isset(((Stm32CurrentSenseParams*)cs_params)->pins[i])) channel_no++;
   } 
   return 0;
 }
 
-#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *AdcHandle){
 
     // calculate the instance
     int adc_index = _adcToIndex(AdcHandle);
 
     // if the timer han't repetition counter - downsample two times
-    if( needs_downsample[adc_index] && tim_downsample[adc_index]++ > 0) {
-      tim_downsample[adc_index] = 0;
+    if( needs_downsample[adc_index] && tim_downsample[adc_index]++ > 1) {
+      tim_downsample[adc_index] = 1;
       return;
     }
 
@@ -117,6 +153,5 @@ extern "C" {
     adc_val[adc_index][2]=HAL_ADCEx_InjectedGetValue(AdcHandle, ADC_INJECTED_RANK_3);    
   }
 }
-#endif
 
 #endif