Merge pull request #341 from Candas1/stm32_adc_no_interrupt

runger1101001 · web-flow · commit cb822dcff1ca · 2023-12-01T23:48:29.000+01:00
Stm32 adc no interrupt
diff --git a/src/current_sense/hardware_specific/stm32/stm32f1/stm32f1_hal.cpp b/src/current_sense/hardware_specific/stm32/stm32f1/stm32f1_hal.cpp
@@ -124,9 +124,11 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
     HAL_ADCEx_InjectedConfigChannel(&hadc, &sConfigInjected);
   }
   
+  #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
   // enable interrupt
   HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);
   HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
+  #endif
   
   cs_params->adc_handle = &hadc;
 
@@ -151,12 +153,14 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in
 
 }
 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void ADC1_2_IRQHandler(void)
   {
       HAL_ADC_IRQHandler(&hadc);
   }
   
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32f1/stm32f1_mcu.cpp b/src/current_sense/hardware_specific/stm32/stm32f1/stm32f1_mcu.cpp
@@ -69,9 +69,13 @@ void _driverSyncLowSide(void* _driver_params, void* _cs_params){
 
   // Start the adc calibration
   HAL_ADCEx_Calibration_Start(cs_params->adc_handle);
-
+  
   // 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
 
   // restart all the timers of the driver
   _startTimers(driver_params->timers, 6);
@@ -81,13 +85,18 @@ 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){
   for(int i=0; i < 3; i++){
-    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]) // found in the buffer
-      return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]){ // found in the buffer
+      #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+        return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #else
+        return HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle,i+1) * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #endif
+    }
   } 
   return 0;
 }
 
-
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *AdcHandle){
     // calculate the instance
@@ -104,5 +113,6 @@ extern "C" {
     adc_val[adc_index][2]=HAL_ADCEx_InjectedGetValue(AdcHandle, ADC_INJECTED_RANK_3);
   }
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32f4/stm32f4_hal.cpp b/src/current_sense/hardware_specific/stm32/stm32f4/stm32f4_hal.cpp
@@ -135,9 +135,11 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
     }
   }
   
+  #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
   // enable interrupt
   HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);
   HAL_NVIC_EnableIRQ(ADC_IRQn);
+  #endif
   
   cs_params->adc_handle = &hadc;
   return 0;
@@ -160,11 +162,13 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in
   }
 }
 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void ADC_IRQHandler(void)
   {
       HAL_ADC_IRQHandler(&hadc);
   }
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32f4/stm32f4_mcu.cpp b/src/current_sense/hardware_specific/stm32/stm32f4/stm32f4_mcu.cpp
@@ -58,8 +58,13 @@ void _driverSyncLowSide(void* _driver_params, void* _cs_params){
   }
   // set the trigger output event
   LL_TIM_SetTriggerOutput(cs_params->timer_handle->getHandle()->Instance, LL_TIM_TRGO_UPDATE);
-  // start the adc 
+
+  // 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
 
   // restart all the timers of the driver
   _startTimers(driver_params->timers, 6);
@@ -69,13 +74,18 @@ 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){
   for(int i=0; i < 3; i++){
-    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]) // found in the buffer
-      return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]){ // found in the buffer
+      #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+        return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #else
+        return HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle,i+1) * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #endif
+    }
   } 
   return 0;
 }
 
-
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *AdcHandle){
     // calculate the instance
@@ -92,5 +102,6 @@ extern "C" {
     adc_val[adc_index][2]=HAL_ADCEx_InjectedGetValue(AdcHandle, ADC_INJECTED_RANK_3);    
   }
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_hal.cpp b/src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_hal.cpp
@@ -181,7 +181,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
   }
   
 
- 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT 
   if(hadc.Instance == ADC1) {
     // enable interrupt
     HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);
@@ -214,6 +214,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
     HAL_NVIC_SetPriority(ADC5_IRQn, 0, 0);
     HAL_NVIC_EnableIRQ(ADC5_IRQn);
   } 
+#endif
 #endif
   
   cs_params->adc_handle = &hadc;
@@ -237,6 +238,7 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in
   }
 }
 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void ADC1_2_IRQHandler(void)
   {
@@ -263,5 +265,6 @@ extern "C" {
   }
 #endif
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_mcu.cpp b/src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_mcu.cpp
@@ -61,8 +61,17 @@ void _driverSyncLowSide(void* _driver_params, void* _cs_params){
   
   // set the trigger output event
   LL_TIM_SetTriggerOutput(cs_params->timer_handle->getHandle()->Instance, LL_TIM_TRGO_UPDATE);
+ 
+  // Start the adc calibration
+  HAL_ADCEx_Calibration_Start(cs_params->adc_handle,ADC_SINGLE_ENDED);
+
   // 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
+  
   // restart all the timers of the driver
   _startTimers(driver_params->timers, 6);
 }
@@ -71,13 +80,18 @@ 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){
   for(int i=0; i < 3; i++){
-    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]) // found in the buffer
-      return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]){ // found in the buffer
+      #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+        return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #else
+        return HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle,i+1) * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #endif
+    }
   } 
   return 0;
 }
 
-
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *AdcHandle){
     // calculate the instance
@@ -94,5 +108,6 @@ extern "C" {
     adc_val[adc_index][2]=HAL_ADCEx_InjectedGetValue(AdcHandle, ADC_INJECTED_RANK_3);  
   }
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32l4/stm32l4_hal.cpp b/src/current_sense/hardware_specific/stm32/stm32l4/stm32l4_hal.cpp
@@ -180,7 +180,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
   }
   
 
- 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT 
   if(hadc.Instance == ADC1) {
     // enable interrupt
     HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);
@@ -213,6 +213,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
     HAL_NVIC_SetPriority(ADC5_IRQn, 0, 0);
     HAL_NVIC_EnableIRQ(ADC5_IRQn);
   } 
+#endif
 #endif
   
   cs_params->adc_handle = &hadc;
@@ -236,6 +237,7 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in
   }
 }
 
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void ADC1_2_IRQHandler(void)
   {
@@ -262,5 +264,6 @@ extern "C" {
   }
 #endif
 }
+#endif
 
 #endif
diff --git a/src/current_sense/hardware_specific/stm32/stm32l4/stm32l4_mcu.cpp b/src/current_sense/hardware_specific/stm32/stm32l4/stm32l4_mcu.cpp
@@ -61,8 +61,17 @@ void _driverSyncLowSide(void* _driver_params, void* _cs_params){
   
   // set the trigger output event
   LL_TIM_SetTriggerOutput(cs_params->timer_handle->getHandle()->Instance, LL_TIM_TRGO_UPDATE);
-  // start the adc 
+
+  // Start the adc calibration
+  HAL_ADCEx_Calibration_Start(cs_params->adc_handle,ADC_SINGLE_ENDED);
+  
+  // 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
+
   // restart all the timers of the driver
   _startTimers(driver_params->timers, 6);
 }
@@ -71,13 +80,18 @@ 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){
   for(int i=0; i < 3; i++){
-    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]) // found in the buffer
-      return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+    if( pin == ((Stm32CurrentSenseParams*)cs_params)->pins[i]){ // found in the buffer
+      #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
+        return adc_val[_adcToIndex(((Stm32CurrentSenseParams*)cs_params)->adc_handle)][i] * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #else
+        return HAL_ADCEx_InjectedGetValue(((Stm32CurrentSenseParams*)cs_params)->adc_handle,i+1) * ((Stm32CurrentSenseParams*)cs_params)->adc_voltage_conv;
+      #endif
+    }
   } 
   return 0;
 }
 
-
+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT
 extern "C" {
   void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *AdcHandle){
     // calculate the instance
@@ -94,5 +108,6 @@ extern "C" {
     adc_val[adc_index][2]=HAL_ADCEx_InjectedGetValue(AdcHandle, ADC_INJECTED_RANK_3);  
   }
 }
+#endif
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -124,9 +124,11 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive`
`124`	`124`	`HAL_ADCEx_InjectedConfigChannel(&hadc, &sConfigInjected);`
`125`	`125`	`}`
`126`	`126`
	`127`	`+ #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`127`	`128`	`// enable interrupt`
`128`	`129`	`HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);`
`129`	`130`	`HAL_NVIC_EnableIRQ(ADC1_2_IRQn);`
	`131`	`+ #endif`
`130`	`132`
`131`	`133`	`cs_params->adc_handle = &hadc;`
`132`	`134`
`@@ -151,12 +153,14 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in`
`151`	`153`
`152`	`154`	`}`
`153`	`155`
	`156`	`+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`154`	`157`	`extern "C" {`
`155`	`158`	`void ADC1_2_IRQHandler(void)`
`156`	`159`	`{`
`157`	`160`	`HAL_ADC_IRQHandler(&hadc);`
`158`	`161`	`}`
`159`	`162`
`160`	`163`	`}`
	`164`	`+#endif`
`161`	`165`
`162`	`166`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -135,9 +135,11 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
	`138`	`+ #ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`138`	`139`	`// enable interrupt`
`139`	`140`	`HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);`
`140`	`141`	`HAL_NVIC_EnableIRQ(ADC_IRQn);`
	`142`	`+ #endif`
`141`	`143`
`142`	`144`	`cs_params->adc_handle = &hadc;`
`143`	`145`	`return 0;`
`@@ -160,11 +162,13 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in`
`160`	`162`	`}`
`161`	`163`	`}`
`162`	`164`
	`165`	`+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`163`	`166`	`extern "C" {`
`164`	`167`	`void ADC_IRQHandler(void)`
`165`	`168`	`{`
`166`	`169`	`HAL_ADC_IRQHandler(&hadc);`
`167`	`170`	`}`
`168`	`171`	`}`
	`172`	`+#endif`
`169`	`173`
`170`	`174`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive`
`181`	`181`	`}`
`182`	`182`
`183`	`183`
`184`		`-`
	`184`	`+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`185`	`185`	`if(hadc.Instance == ADC1) {`
`186`	`186`	`// enable interrupt`
`187`	`187`	`HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);`
`@@ -214,6 +214,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive`
`214`	`214`	`HAL_NVIC_SetPriority(ADC5_IRQn, 0, 0);`
`215`	`215`	`HAL_NVIC_EnableIRQ(ADC5_IRQn);`
`216`	`216`	`}`
	`217`	`+#endif`
`217`	`218`	`#endif`
`218`	`219`
`219`	`220`	`cs_params->adc_handle = &hadc;`
`@@ -237,6 +238,7 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in`
`237`	`238`	`}`
`238`	`239`	`}`
`239`	`240`
	`241`	`+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`240`	`242`	`extern "C" {`
`241`	`243`	`void ADC1_2_IRQHandler(void)`
`242`	`244`	`{`
`@@ -263,5 +265,6 @@ extern "C" {`
`263`	`265`	`}`
`264`	`266`	`#endif`
`265`	`267`	`}`
	`268`	`+#endif`
`266`	`269`
`267`	`270`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive`
`180`	`180`	`}`
`181`	`181`
`182`	`182`
`183`		`-`
	`183`	`+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`184`	`184`	`if(hadc.Instance == ADC1) {`
`185`	`185`	`// enable interrupt`
`186`	`186`	`HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);`
`@@ -213,6 +213,7 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive`
`213`	`213`	`HAL_NVIC_SetPriority(ADC5_IRQn, 0, 0);`
`214`	`214`	`HAL_NVIC_EnableIRQ(ADC5_IRQn);`
`215`	`215`	`}`
	`216`	`+#endif`
`216`	`217`	`#endif`
`217`	`218`
`218`	`219`	`cs_params->adc_handle = &hadc;`
`@@ -236,6 +237,7 @@ void _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const in`
`236`	`237`	`}`
`237`	`238`	`}`
`238`	`239`
	`240`	`+#ifdef SIMPLEFOC_STM32_ADC_INTERRUPT`
`239`	`241`	`extern "C" {`
`240`	`242`	`void ADC1_2_IRQHandler(void)`
`241`	`243`	`{`
`@@ -262,5 +264,6 @@ extern "C" {`
`262`	`264`	`}`
`263`	`265`	`#endif`
`264`	`266`	`}`
	`267`	`+#endif`
`265`	`268`
`266`	`269`	`#endif`