使用STM32F0 ADC单独读取不同的输入

STM32F072CBU微控制器

我有多个ADC输入，希望分别读取它们。STMcubeMX生成样板代码，假设我希望按顺序读取所有输入，但我一直无法找出如何更正此错误

表达了与我相同的问题，但给出的解决方案似乎不起作用。为每次转换打开和关闭ADC与返回值中的错误相关。只有在STMcubeMX中配置单个ADC输入，然后在未对ADC进行反初始化的情况下轮询时，才会返回准确的读数

cubeMX的adc_init函数：

/* ADC init function */
static void MX_ADC_Init(void)
{

  ADC_ChannelConfTypeDef sConfig;

    /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion) 
    */
  hadc.Instance = ADC1;
  hadc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc.Init.Resolution = ADC_RESOLUTION_12B;
  hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;
  hadc.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc.Init.LowPowerAutoWait = DISABLE;
  hadc.Init.LowPowerAutoPowerOff = DISABLE;
  hadc.Init.ContinuousConvMode = DISABLE;
  hadc.Init.DiscontinuousConvMode = DISABLE;
  hadc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc.Init.DMAContinuousRequests = DISABLE;
  hadc.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  if (HAL_ADC_Init(&hadc) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
  sConfig.SamplingTime = ADC_SAMPLETIME_41CYCLES_5;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_1;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_2;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_3;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_4;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure for the selected ADC regular channel to be converted. 
    */
  sConfig.Channel = ADC_CHANNEL_VREFINT;
  if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}

main.c

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_ADC_Init();
  MX_USART1_UART_Init();

  /* USER CODE BEGIN 2 */
  //HAL_TIM_Base_Start_IT(&htim3);
  init_printf(NULL, putc_wrangler);
  HAL_ADCEx_Calibration_Start(&hadc);
  HAL_ADC_DeInit(&hadc); // ADC is initialized for every channel change
  schedule_initial_events();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  event_loop();
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  /* USER CODE END 3 */

}

我现在关闭ADC并重新初始化以更改通道的过程：

// Set up
  ADC_ChannelConfTypeDef channelConfig;

  channelConfig.SamplingTime = samplingT;
  channelConfig.Channel = sensorChannel;
  channelConfig.Rank = ADC_RANK_CHANNEL_NUMBER;

  if (HAL_ADC_Init(&hadc) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  if (HAL_ADC_ConfigChannel(&hadc, &channelConfig) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

// Convert
  uint16_t retval;

  if (HAL_ADC_Start(&hadc) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  if (HAL_ADC_PollForConversion(&hadc, 1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  if (HAL_ADC_GetError(&hadc) != HAL_ADC_ERROR_NONE)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

  retval = (uint16_t) HAL_ADC_GetValue(&hadc);

  if (HAL_ADC_Stop(&hadc) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

// Close
  HAL_ADC_DeInit(&hadc);

---

此时，我不确定是否有办法实现我想要的，STM32似乎死定在活动ADC线上，处于常规组中，并按顺序转换。

如果要在单转换模式下读取多个ADC通道，则必须在每次读取之前更改通道设置，但您不必重新控制ADC。只需执行以下操作，选择新通道（如果通道的采样时间必须不同，但通常可以相同，则也可以更改采样时间），选择通道列组，然后调用HAL_ADC_ConfigChannel函数。在此之后，您可以执行转换

void config_ext_channel_ADC(uint32_t channel, boolean_t val)
{
  ADC_ChannelConfTypeDef sConfig;

  sConfig.Channel = channel;
  sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;

  if(True == val)
  {
    sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
  }
  else
  {
    sConfig.Rank = ADC_RANK_NONE;
  }

  HAL_ADC_ConfigChannel(&hadc, &sConfig);
}

uint32_t r_single_ext_channel_ADC(uint32_t channel)
{
  uint32_t digital_result;

  config_ext_channel_ADC(channel, True);

  HAL_ADCEx_Calibration_Start(&hadc);

  HAL_ADC_Start(&hadc);
  HAL_ADC_PollForConversion(&hadc, 1000);
  digital_result = HAL_ADC_GetValue(&hadc);
  HAL_ADC_Stop(&hadc);

  config_ext_channel_ADC(channel, False);

  return digital_result;
}

用法示例：

#define SUPPLY_CURRENT  ADC_CHANNEL_5
#define BATTERY_VOLTAGE ADC_CHANNEL_6

uint16_t r_battery_voltage(uint16_t mcu_vcc)
{
  float vbat;
  uint16_t digital_val;

  digital_val = r_single_ext_channel_ADC(BATTERY_VOLTAGE);
  vbat = (mcu_vcc/4095.0) * digital_val;
  vbat = vbat * 2;         // 1/2 voltage divider

  return vbat;
}

uint16_t r_supply_current(uint16_t mcu_vcc)
{
  float v_sense, current;
  uint16_t digital_val;

  digital_val = r_single_ext_channel_ADC(SUPPLY_CURRENT);
  v_sense = (mcu_vcc/4095.0) * digital_val;
  current = v_sense * I_SENSE_GAIN;

  return current;
}

此代码用于STM32F030。为了读取内部温度传感器和参考电压，必须设置与上述功能稍有不同的版本，作为附加启用位

void config_int_channel_ADC(uint32_t channel, boolean_t val)
{
  ADC_ChannelConfTypeDef sConfig;
  sConfig.Channel = channel;

  if(val == True)
  {
    if(channel == ADC_CHANNEL_VREFINT)
    {
      ADC->CCR |= ADC_CCR_VREFEN;
      hadc.Instance->CHSELR = (uint32_t)(ADC_CHSELR_CHSEL17);
    }
    else if(channel == ADC_CHANNEL_TEMPSENSOR)
    {
      ADC->CCR |= ADC_CCR_TSEN;
      hadc.Instance->CHSELR = (uint32_t)(ADC_CHSELR_CHSEL16);
    }

    sConfig.Rank          = ADC_RANK_CHANNEL_NUMBER;
    sConfig.SamplingTime  = ADC_SAMPLETIME_239CYCLES_5;
  }
  else if(val == False)
  {
    if(channel == ADC_CHANNEL_VREFINT)
    {
      ADC->CCR &= ~ADC_CCR_VREFEN;
      hadc.Instance->CHSELR = 0;
    }
    else if(channel == ADC_CHANNEL_TEMPSENSOR)
    {
      ADC->CCR &= ~ADC_CCR_TSEN;
      hadc.Instance->CHSELR = 0;
    }

    sConfig.Rank          = ADC_RANK_NONE;
    sConfig.SamplingTime  = ADC_SAMPLETIME_239CYCLES_5;
  }

  HAL_ADC_ConfigChannel(&hadc,&sConfig);
}

uint32_t r_single_int_channel_ADC(uint32_t channel)
{
  uint32_t digital_result;

  config_int_channel_ADC(channel, True);

  HAL_ADCEx_Calibration_Start(&hadc);

  HAL_ADC_Start(&hadc);
  HAL_ADC_PollForConversion(&hadc, 1000);
  digital_result = HAL_ADC_GetValue(&hadc);
  HAL_ADC_Stop(&hadc);

  config_int_channel_ADC(channel, False);

  return digital_result;
}

MCU VDD计算的内部电压参考使用示例：

#define VREFINT_CAL_ADDR   ((uint16_t*) ((uint32_t) 0x1FFFF7BA))

static float FACTORY_CALIB_VDD = 3.31;

uint16_t calculate_MCU_vcc()
{
  float analog_Vdd;
  uint16_t val_Vref_int = r_single_int_channel_ADC(ADC_CHANNEL_VREFINT);

  analog_Vdd = (FACTORY_CALIB_VDD * (*VREFINT_CAL_ADDR))/val_Vref_int;

  return analog_Vdd * 1000;
}

内部温度传感器读数：

#define TEMP30_CAL_ADDR  ((uint16_t*) ((uint32_t) 0x1FFFF7B8))
#define TEMP110_CAL_ADDR ((uint16_t*) ((uint32_t) 0x1FFFF7C2))

static float FACTORY_CALIB_VDD = 3.31;

float r_MCU_temp(uint16_t mcu_vcc)
{
  float temp;
  float slope = ((110.0 - 30.0)/((*TEMP110_CAL_ADDR) - (*TEMP30_CAL_ADDR)));

  uint16_t ts_data = r_single_int_channel_ADC(ADC_CHANNEL_TEMPSENSOR);

  temp = ((mcu_vcc/FACTORY_CALIB_VDD) * ts_data)/1000;
  temp = slope * (temp - (*TEMP30_CAL_ADDR)) + 30;

  return round_to(temp, 0);
}

---

请注意，MCU的校准数据地址可能不同，有关详细信息，请查看数据表。

我也有类似问题。我使用的是STM32F091RC。在ADC_V_引脚上，我有外部多路复用器。在ADC引脚上，我有NTC读数。我用GPIOs控制外部多路复用器（这在下面的代码中没有看到）。我需要的是ADC_V_引脚的多次连续读取，在单个ADC_T_引脚读取之后。对于ADC的默认顺序读取，我将在ADC_V_引脚的每个外部多路复用读取之间获得ADC_T_引脚读取。多次使用HAL_ADC_ConfigChannel时，似乎彼此都在使用，我在阅读方面遇到了问题。所以我根本没有使用HAL_ADC_配置通道。相反，在每个软件触发AD转换之前，我重新配置了CHSELR寄存器。这是使内部和外部多路复用器一起工作的方法

以下是初始化代码：

    GPIO_InitStruct.Pin = ADC_V_PIN;
    GPIO_InitStruct.Mode  = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull  = GPIO_NOPULL;
    HAL_GPIO_Init(ADC_V_PORT, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = ADC_T_PIN;
    GPIO_InitStruct.Mode  = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull  = GPIO_NOPULL;
    HAL_GPIO_Init(ADC_T_PORT, &GPIO_InitStruct);

    g_AdcHandle.Instance = ADC1;

    if (HAL_ADC_DeInit(&g_AdcHandle) != HAL_OK)
    {
        /* ADC initialization error */
        Error_Handler();
    }

    g_AdcHandle.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
    g_AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
    g_AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    g_AdcHandle.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;;
    g_AdcHandle.Init.ContinuousConvMode = DISABLE;
    g_AdcHandle.Init.DiscontinuousConvMode = ENABLE;
    g_AdcHandle.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
    g_AdcHandle.Init.LowPowerAutoWait      = DISABLE;
    g_AdcHandle.Init.LowPowerAutoPowerOff  = DISABLE;

    g_AdcHandle.Init.ExternalTrigConv      = ADC_SOFTWARE_START;
    g_AdcHandle.Init.ExternalTrigConvEdge  = ADC_EXTERNALTRIGCONVEDGE_NONE;


    g_AdcHandle.Init.DMAContinuousRequests = DISABLE;
    g_AdcHandle.Init.Overrun               = ADC_OVR_DATA_OVERWRITTEN;
    g_AdcHandle.Init.SamplingTimeCommon    = ADC_SAMPLETIME_239CYCLES_5;

    if (HAL_ADC_Init(&g_AdcHandle) != HAL_OK)
    {
      /* ADC initialization error */
      Error_Handler();
    }

    if (HAL_ADCEx_Calibration_Start(&g_AdcHandle) != HAL_OK)
    {
      /* Calibration Error */
      Error_Handler();
    }

while(1){

        ADC1->CHSELR = ADC_CHSELR_CHSEL0;
        HAL_ADC_Start(&g_AdcHandle);
        HAL_ADC_PollForConversion(&g_AdcHandle, 10);
        V = HAL_ADC_GetValue(&g_AdcHandle);
        HAL_ADC_Stop(&g_AdcHandle);

        ADC1->CHSELR = ADC_CHSELR_CHSEL10;
        HAL_ADC_Start(&g_AdcHandle);
        HAL_ADC_PollForConversion(&g_AdcHandle, 10);
        T = HAL_ADC_GetValue(&g_AdcHandle);
        HAL_ADC_Stop(&g_AdcHandle);
    }

---

恐怕是哈尔的问题。我用裸寄存器的方式编程，我从来没有注意到这样的事情。但您必须记住，ADC输入有一个相当大的电容，如果转换时间短，您需要提供一个合适的电流来加载它。否则，您可能会遇到类似的问题。解决方案是-更长的转换或输入上的缓冲区。谢谢@PeterJ。我想这就是我害怕的；我认为脱离HAL会带来麻烦，因为它有一些脆弱的状态机，并且想要控制，但似乎没有办法用它来配置不同的输入。我将研究直接注册方法，看看能做些什么。