inital support for g4

Author: askuric

src/current_sense/hardware_specific/stm32/stm32_mcu.cpp

@@ -9,7 +9,7 @@
 #define _ADC_RESOLUTION 1024.0f
 
 // function reading an ADC value and returning the read voltage
-void* _configureADCInline(const void* driver_params, const int pinA,const int pinB,const int pinC){
+__attribute__((weak))  void* _configureADCInline(const void* driver_params, const int pinA,const int pinB,const int pinC){
   _UNUSED(driver_params);
 
   if( _isset(pinA) ) pinMode(pinA, INPUT);

src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_hal.cpp

@@ -183,6 +183,166 @@ int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* drive
   return 0;
 }
 
+/**
+ * Function initializing the ADC and the regular channels for inline current sensing
+ * with continuous conversion mode
+ * 
+ * @param cs_params - current sense parameters
+ * 
+ * @return int - 0 if success 
+ */
+int _adc_init_inline(Stm32CurrentSenseParams* cs_params)
+{
+  ADC_ChannelConfTypeDef sConfig = {0};
+
+ /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion) 
+  */
+  auto adc_instance = _findBestADCForPins(3, cs_params->pins, hadc);
+  
+  if(adc_instance == ADC1) {
+#ifdef __HAL_RCC_ADC1_CLK_ENABLE
+    __HAL_RCC_ADC1_CLK_ENABLE();
+#endif
+#ifdef __HAL_RCC_ADC12_CLK_ENABLE
+    __HAL_RCC_ADC12_CLK_ENABLE();
+#endif
+  }
+#ifdef ADC2
+  else if (adc_instance == ADC2) {
+#ifdef __HAL_RCC_ADC2_CLK_ENABLE
+    __HAL_RCC_ADC2_CLK_ENABLE();
+#endif
+#ifdef __HAL_RCC_ADC12_CLK_ENABLE
+    __HAL_RCC_ADC12_CLK_ENABLE();
+#endif
+  }
+#endif
+#ifdef ADC3
+  else if (adc_instance == ADC3) {
+#ifdef __HAL_RCC_ADC3_CLK_ENABLE
+    __HAL_RCC_ADC3_CLK_ENABLE();
+#endif
+#ifdef __HAL_RCC_ADC34_CLK_ENABLE
+    __HAL_RCC_ADC34_CLK_ENABLE();
+#endif
+#if defined(ADC345_COMMON)
+    __HAL_RCC_ADC345_CLK_ENABLE();
+#endif
+  } 
+#endif
+#ifdef ADC4
+  else if (adc_instance == ADC4) {
+#ifdef __HAL_RCC_ADC4_CLK_ENABLE
+    __HAL_RCC_ADC4_CLK_ENABLE();
+#endif
+#ifdef __HAL_RCC_ADC34_CLK_ENABLE
+    __HAL_RCC_ADC34_CLK_ENABLE();
+#endif
+#if defined(ADC345_COMMON)
+    __HAL_RCC_ADC345_CLK_ENABLE();
+#endif
+  }
+#endif
+#ifdef ADC5
+  else if (adc_instance == ADC5) {
+#if defined(ADC345_COMMON)
+    __HAL_RCC_ADC345_CLK_ENABLE();
+#endif
+  }
+#endif
+  else{
+#ifdef SIMPLEFOC_STM32_DEBUG
+    SIMPLEFOC_DEBUG("STM32-CS: ERR: Cannot find a common ADC for the pins!");
+#endif
+    return -1; // error not a valid ADC instance
+  }
+
+  int adc_num = _adcToIndex(adc_instance);
+
+#ifdef SIMPLEFOC_STM32_DEBUG
+    SIMPLEFOC_DEBUG("STM32-CS: Using ADC: ", adc_num+1);
+#endif
+
+  hadc[adc_num].Instance = adc_instance;
+
+  // Configure ADC for continuous conversion mode on regular channels
+  hadc[adc_num].Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
+  hadc[adc_num].Init.Resolution = ADC_RESOLUTION_12B;
+  hadc[adc_num].Init.ScanConvMode = ADC_SCAN_ENABLE;  // Enable scan mode for multiple channels
+  hadc[adc_num].Init.ContinuousConvMode = ENABLE;     // Enable continuous conversion
+  hadc[adc_num].Init.LowPowerAutoWait = DISABLE;
+  hadc[adc_num].Init.GainCompensation = 0;
+  hadc[adc_num].Init.DiscontinuousConvMode = DISABLE;
+  hadc[adc_num].Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
+  hadc[adc_num].Init.ExternalTrigConv = ADC_SOFTWARE_START;
+  hadc[adc_num].Init.DataAlign = ADC_DATAALIGN_RIGHT;
+  
+  // Count number of channels to configure
+  uint8_t num_channels = 0;
+  for(int pin_no=0; pin_no<3; pin_no++){
+    if(_isset(cs_params->pins[pin_no])){
+      num_channels++;
+    }
+  }
+  
+  hadc[adc_num].Init.NbrOfConversion = num_channels;
+  hadc[adc_num].Init.DMAContinuousRequests = DISABLE;
+  hadc[adc_num].Init.EOCSelection = ADC_EOC_SEQ_CONV;  // End of sequence for multi-channel
+  hadc[adc_num].Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;  // Overwrite old data in continuous mode
+  
+  if (HAL_ADC_Init(&hadc[adc_num]) != HAL_OK){
+#ifdef SIMPLEFOC_STM32_DEBUG
+    SIMPLEFOC_DEBUG("STM32-CS: ERR: cannot init ADC!");
+#endif
+    return -1;
+  }
+    
+  // Configure regular channels
+  sConfig.SamplingTime = ADC_SAMPLETIME_6CYCLES_5;  // Fast sampling for inline sensing
+  sConfig.SingleDiff = ADC_SINGLE_ENDED;
+  sConfig.OffsetNumber = ADC_OFFSET_NONE;
+  sConfig.Offset = 0;
+  
+  uint8_t rank = 1;
+  for(int i=0; i<3; i++){
+    // skip if not set
+    if (!_isset(cs_params->pins[i])) continue;
+    
+    sConfig.Rank = rank++;
+    sConfig.Channel = _getADCChannel(analogInputToPinName(cs_params->pins[i]), hadc[adc_num].Instance);
+    
+    if (HAL_ADC_ConfigChannel(&hadc[adc_num], &sConfig) != HAL_OK){
+  #ifdef SIMPLEFOC_STM32_DEBUG
+      SIMPLEFOC_DEBUG("STM32-CS: ERR: cannot init regular channel: ", (int)sConfig.Channel);
+  #endif
+      return -1;
+    }
+  }
+  
+  cs_params->adc_handle = &hadc[adc_num];
+  
+  // Calibrate ADC
+  if (HAL_ADCEx_Calibration_Start(&hadc[adc_num], ADC_SINGLE_ENDED) != HAL_OK){
+#ifdef SIMPLEFOC_STM32_DEBUG
+    SIMPLEFOC_DEBUG("STM32-CS: WARN: ADC calibration failed");
+#endif
+  }
+  
+  // Start continuous conversion
+  if (HAL_ADC_Start(&hadc[adc_num]) != HAL_OK){
+#ifdef SIMPLEFOC_STM32_DEBUG
+    SIMPLEFOC_DEBUG("STM32-CS: ERR: cannot start ADC continuous conversion");
+#endif
+    return -1;
+  }
+  
+#ifdef SIMPLEFOC_STM32_DEBUG
+  SIMPLEFOC_DEBUG("STM32-CS: ADC continuous conversion on no.channels: ", (int)num_channels);
+#endif
+  
+  return 0;
+}
+
 /**
  * Function to initialize the ADC GPIO pins
  * 

src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_hal.h

@@ -10,6 +10,7 @@
 #include "../stm32_adc_utils.h"
 
 int _adc_init(Stm32CurrentSenseParams* cs_params, const STM32DriverParams* driver_params);
+int _adc_init_inline(Stm32CurrentSenseParams* cs_params);
 int _adc_gpio_init(Stm32CurrentSenseParams* cs_params, const int pinA, const int pinB, const int pinC);
 
 #endif

src/current_sense/hardware_specific/stm32/stm32g4/stm32g4_mcu.cpp

@@ -46,6 +46,20 @@ void* _configureADCLowSide(const void* driver_params, const int pinA, const int
   return cs_params;
 }
 
+void* _configureADCInline(const void* driver_params, const int pinA, const int pinB, const int pinC){
+  _UNUSED(driver_params);
+
+  Stm32CurrentSenseParams* cs_params = new Stm32CurrentSenseParams {
+    .pins={(int)NOT_SET, (int)NOT_SET, (int)NOT_SET},
+    .adc_voltage_conv = (_ADC_VOLTAGE_G4) / (_ADC_RESOLUTION_G4)
+  };
+  
+  if(_adc_gpio_init(cs_params, pinA, pinB, pinC) != 0) return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
+  if(_adc_init_inline(cs_params) != 0) return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
+  
+  return cs_params;
+}
+
 
 void* _driverSyncLowSide(void* _driver_params, void* _cs_params){
   STM32DriverParams* driver_params = (STM32DriverParams*)_driver_params;
@@ -131,6 +145,19 @@ float _readADCVoltageLowSide(const int pin, const void* cs_params){
   return _readADCInjectedChannelVoltage(pin, (void*)cs_params, adc_interrupt_config[adc_index], adc_val[adc_index]); 
 }
 
+// function reading an ADC value from regular channels (inline current sensing)
+float _readADCVoltageInline(const int pin, const void* cs_params){
+  Stm32CurrentSenseParams* params = (Stm32CurrentSenseParams*)cs_params;
+  ADC_HandleTypeDef* hadc = params->adc_handle;
+  
+  // In continuous conversion mode, just read the latest value from the data register
+  // No polling needed - the ADC is constantly updating this register
+  uint32_t raw_adc = HAL_ADC_GetValue(hadc);
+  
+  // Convert to voltage
+  return raw_adc * params->adc_voltage_conv;
+}
+
 extern "C" {
   void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef *AdcHandle){
     uint8_t adc_index = (uint8_t)_adcToIndex(AdcHandle);