stm32 F103c8

求stm32F103c8 的定时器2的cc2事件触发ADC外部转换的正确代码

// 使能定时器2时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

// 使能ADC1时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);

// 配置定时器2为PWM模式1，使其工作在PWM模式，同时设置频率和占空比
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_TimeBaseStructure.TIM_Prescaler = 0; // 预分频系数
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 计数模式
TIM_TimeBaseStructure.TIM_Period = 500 - 1; // 自动重装载值
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; // 时钟分频
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

// 配置CC2通道为PWM输出模式
TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; // PWM模式1
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; // 输出使能
TIM_OCInitStructure.TIM_Pulse = 250 - 1; // 初始占空比为50%
TIM_OC2Init(TIM2, &TIM_OCInitStructure);

// 配置ADC转换通道，使用PA0作为输入
GPIO_InitTypeDef GPIO_InitStructure;
ADC_InitTypeDef ADC_InitStructure;

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; // 模拟输入模式
GPIO_Init(GPIOA, &GPIO_InitStructure);

ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; // 独立模式
ADC_InitStructure.ADC_ScanConvMode = DISABLE; // 禁止扫描模式
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; // 连续转换模式
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_CC2; // 定时器2 CC2事件触发
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; // 数据右对齐
ADC_InitStructure.ADC_NbrOfChannel = 1; // 转换通道数
ADC_Init(ADC1, &ADC_InitStructure);

// 配置ADC采样时间
ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);

// 使能ADC
ADC_Cmd(ADC1, ENABLE);

// 启动定时器2
TIM_Cmd(TIM2, ENABLE);


// 定义ADC转换结果变量
uint32_t adc_value;

// 初始化ADC
ADC_HandleTypeDef hadc;
hadc.Instance = ADC1;
hadc.Init.ScanConvMode = DISABLE;
hadc.Init.ContinuousConvMode = DISABLE;
hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc.Init.NbrOfConversion = 1;
HAL_ADC_Init(&hadc);

// 初始化GPIO口
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

// 配置Timer2的CC2事件
TIM_HandleTypeDef htim;
TIM_OC_InitTypeDef sConfigOC;

htim.Instance = TIM2;
htim.Init.Period = 1000;
htim.Init.Prescaler = 7200;
htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim.Init.CounterMode = TIM_COUNTERMODE_UP;
HAL_TIM_Base_Init(&htim);

sConfigOC.OCMode = TIM_OCMODE_TOGGLE;
sConfigOC.Pulse = 500;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
HAL_TIM_OC_ConfigChannel(&htim, &sConfigOC, TIM_CHANNEL_2);

// 启动Timer2
HAL_TIM_Base_Start(&htim);
HAL_TIM_OC_Start(&htim, TIM_CHANNEL_2);

// 启动ADC外部转换
ADC_ChannelConfTypeDef sConfig;
sConfig.Channel = ADC_CHANNEL_1;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_13CYCLES_5;
HAL_ADC_ConfigChannel(&hadc, &sConfig);
HAL_ADC_Start(&hadc);

// 循环读取ADC转换结果
while (1)
{
    if (HAL_ADC_PollForConversion(&hadc, 100) == HAL_OK)
    {
        adc_value = HAL_ADC_GetValue(&hadc);
        // 处理转换结果
    }
}

该回答引用ChatGPT
以下是代码，望采纳


#include "main.h"
#include "adc.h"
#include "tim.h"

/* 定义ADC采样结果缓冲区 */
#define ADC_BUFFER_SIZE 1
uint16_t adc_buffer[ADC_BUFFER_SIZE];

/* 定义状态标志 */
volatile uint8_t adc_complete = 0;

/* 在HAL库的stm32f1xx_hal_adc.c文件中定义了一个函数，原型如下： */
/* HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc) */
/* 调用该函数启动ADC转换，并开启ADC的中断模式 */
/* 在ADC转换完成时会自动执行回调函数 HAL_ADC_ConvCpltCallback() */

/* 回调函数，在ADC转换完成时自动执行 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
  /* 设置标志表示转换完成 */
  adc_complete = 1;
}

int main(void)
{
  /* 初始化时钟和GPIO */

  /* 启动定时器2 */
  HAL_TIM_Base_Start(&htim2);

  /* 配置定时器2的通道2为PWM输出模式 */
  HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2);

  /* 初始化ADC */
  HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, ADC_BUFFER_SIZE);

  while (1)
  {
    /* 等待ADC转换完成 */
    if (adc_complete == 1)
    {
      /* 清除标志 */
      adc_complete = 0;

      /* 读取ADC转换结果 */
      uint16_t adc_result = adc_buffer[0];

      /* 处理ADC转换结果 */
      // ...

      /* 重新启动ADC转换 */
      HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, ADC_BUFFER_SIZE);
    }
  }
}

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
首先，需要配置定时器2和ADC外部转换。具体步骤如下：

配置定时器2

选择定时器2，并使能其时钟。
配置 TIM2_CH2 的工作模式为 PWM 模式 1。
配置 TIM2_CH2 为输出，需要设置 GPIO 的输出方向和输出类型。
配置 TIM2 的重载值和预分频器，以达到期望的计数频率和定时时长。
安装 TIM2 的中断服务程序（如果需要）。

配置 ADC

选择 ADC1，并使能其时钟。
配置外部触发源为 TIM2_TRGO。
配置采样时间和采样通道。
安装 ADC1 的 DMA 中断服务程序（如果需要）。
启动 ADC1 和 DMA。

接下来，我们需要在定时器2的cc2事件中触发 ADC 外部转换。具体步骤如下：

在 TIM2_IRQHandler 中检查 TIM2_CH2 的中断状态，并清除中断标志位。
在 cc2 事件处理函数中，触发 ADC 外部转换。具体方法为：

将 TIM2_TRGO 的输出电平拉高。
延时一段时间，让 ADC 能够稳定地完成转换。
再将 TIM2_TRGO 的输出电平拉低。

在 ADC 的转换完成中断服务程序中，处理转换结果。

以下是示例代码，仅供参考：

#include "stm32f10x.h"已黑化的小白 
void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_CC2) != RESET)
    {
        // Clear the interrupt flag
        TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);
        
        // Trigger ADC conversion
        GPIO_SetBits(GPIOA, GPIO_Pin_15);
        for (volatile int i = 0; i < 10; i++);
        GPIO_ResetBits(GPIOA, GPIO_Pin_15);
    }
}

void DMA1_Channel1_IRQHandler(void)
{
    if (DMA_GetITStatus(DMA1_IT_TC1) != RESET)
    {
        // Clear the interrupt flag
        DMA_ClearITPendingBit(DMA1_IT_TC1);
        
        // Process the ADC result
        // ...
    }
}

int main(void)
{
    // Configure TIM2
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
    TIM_TimeBaseInitStruct.TIM_Period = 999; // 1 kHz frequency
    TIM_TimeBaseInitStruct.TIM_Prescaler = 7200 - 1; // 72 MHz / 7200 = 10 kHz
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);

    TIM_OCInitTypeDef TIM_OCInitStruct;
    TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStruct.TIM_Pulse = 499; // 50% duty cycle
    TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OC2Init(TIM2, &TIM_OCInitStruct);

    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
  
    NVIC_EnableIRQ(TIM2_IRQn);

    // Configure ADC
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    ADC_InitTypeDef ADC_InitStruct;
    ADC_InitStruct.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_TRGO;
    ADC_InitStruct.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStruct.ADC_ScanConvMode = DISABLE;
    ADC_InitStruct.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &ADC_InitStruct);

    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);

    DMA_InitTypeDef DMA_InitStruct;
    DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
    DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)&adcResult;
    DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStruct.DMA_BufferSize = 1;
    DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStruct.DMA_Priority = DMA_Priority_High;
    DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel1, &DMA_InitStruct);

    NVIC_EnableIRQ(DMA1_Channel1_IRQn);

    ADC_DMACmd(ADC1, ENABLE);

    ADC_Cmd(ADC1, ENABLE);

    TIM_Cmd(TIM2, ENABLE);

    while (1)
    {
        // ...
    }
}

在这个例子中，我们使用定时器2的 cc2 事件触发 ADC 外部转换，并使用 DMA 接收 ADC 转换结果。注意还需要配置 GPIOA 15 为输出，并将其连接到定时器2的 TRGO 输出。此外，需要在 stm32f10x_conf.h 中定义 USE_FULL_ASSERT，以便在出现错误时触发断言。
如果我的回答解决了您的问题，请采纳！

以下是基于STM32F103C8的定时器2的CC2事件触发ADC外部转换的代码：

#include "stm32f10x.h"

ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_OCInitTypeDef TIM_OCInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;

int main(void)
{
  // 使能外设时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

  // 配置ADC1通道2引脚（PA2）
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // 配置定时器2
  TIM_TimeBaseStructure.TIM_Period = 1000; // 1 kHz的频率
  TIM_TimeBaseStructure.TIM_Prescaler = 7200; // 72 MHz的时钟，分频7200，得到10 kHz的计数频率
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

  // 配置定时器2的CC2通道，用于触发ADC外部转换
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = 500; // 占空比为50%
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC2Init(TIM2, &TIM_OCInitStructure);

  // 配置ADC1的外部触发
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_CC2; // 使用定时器2的CC2事件触发
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 1;
  ADC_Init(ADC1, &ADC_InitStructure);

  // 配置ADC1通道2
  ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 1, ADC_SampleTime_28Cycles5);

  // 配置ADC中断
  NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  // 使能ADC
  ADC_Cmd(ADC1, ENABLE);

  // 启动定时器2
  TIM_Cmd(TIM2, ENABLE);

  while (1)
  {
    // 程序主循环
  }
}

// ADC中断处理函数
void ADC1_2_IRQHandler(void)
{
  if (ADC_GetITStatus(ADC1, ADC_IT_EOC) != RESET)
  {
    // 读取ADC数据寄存器，获取转换结果
    uint16_t adc_value = ADC_GetConversionValue(ADC1);
    // 处理ADC转换结果
    // ...

    //
// 清除ADC中断标志位
ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);

以上代码中，定时器2被配置为PWM输出模式，输出占空比为50%的方波信号。定时器2的CC2通道被配置为输出比较模式，用于触发ADC外部转换。

在ADC初始化中，我们设置了ADC1的转换模式为独立模式，扫描转换模式关闭，连续转换模式关闭，使用定时器2的CC2事件触发ADC外部转换，数据右对齐，转换通道为ADC1的通道2。

在程序中，我们启用了ADC1的中断，并在中断处理函数中读取了ADC数据寄存器，获取转换结果，并进行了相应的处理。注意，在处理完中断后，必须清除ADC中断标志位。

需要注意的是，以上代码仅供参考，具体实现方式可能需要根据您的具体需求进行相应的修改和调整。

首先，需要了解一下STM32F103C8的定时器2和ADC的相关知识。
定时器2是一个16位的定时器，它有4个通道，每个通道都可以用来产生PWM信号或者捕获外部事件。其中，CC2通道可以用来捕获外部事件，并且可以触发ADC的外部转换。
ADC是模数转换器，它可以将模拟信号转换成数字信号。STM32F103C8有一个12位的ADC，它可以通过软件或者硬件触发进行转换。
在本问题中，我们需要使用定时器2的CC2通道来触发ADC的外部转换。具体步骤如下：
1. 配置定时器2的CC2通道为输入捕获模式，并设置触发极性为上升沿或下降沿，具体设置方法如下：


TIM2->CCMR1 |= TIM_CCMR1_CC2S_0; // 设置CC2通道为输入捕获模式
TIM2->CCER |= TIM_CCER_CC2P; // 设置上升沿触发

2. 配置ADC的外部触发为定时器2的CC2事件，并设置触发极性为上升沿或下降沿，具体设置方法如下：


ADC1->CR2 |= ADC_CR2_EXTSEL_2 | ADC_CR2_EXTSEL_1 | ADC_CR2_EXTSEL_0; // 设置外部触发为定时器2的CC2事件
ADC1->CR2 |= ADC_CR2_EXTTRIG; // 使能外部触发
ADC1->CR2 |= ADC_CR2_EXTSEL_2; // 设置上升沿触发

3. 在定时器2的CC2中断中启动ADC转换，具体代码如下：


void TIM2_IRQHandler(void)
{
    if (TIM2->SR & TIM_SR_CC2IF) // 判断是否是CC2事件触发的中断
    {
        ADC1->CR2 |= ADC_CR2_SWSTART; // 启动ADC转换
        TIM2->SR &= ~TIM_SR_CC2IF; // 清除中断标志位
    }
}

该回答引用于gpt与OKX安生共同编写：

该回答引用于gpt与OKX安生共同编写：

以下是使用STM32F103C8的定时器2的cc2事件触发ADC外部转换的代码示例：

首先，需要确保启用了GPIO和ADC外设的时钟。例如，要在PA1引脚上触发ADC外部转换，则需要启用GPIOA的时钟，并将PA1配置为模拟输入模式。启用时钟的方法如下：

RCC->APB2ENR |= RCC_APB2ENR_IOPAEN; // 使能GPIOA时钟
RCC->APB2ENR |= RCC_APB2ENR_ADC1EN; // 使能ADC1时钟

将PA1配置为模拟输入模式：

GPIOA->CRL &= ~(GPIO_CRL_MODE1 | GPIO_CRL_CNF1);
GPIOA->CRL |=  (GPIO_CRL_CNF1_1);

接下来，初始化ADC外设并设置转换序列。例如，将PA1作为单通道进行转换，如下所示：

ADC1->SQR1 &= ~ADC_SQR1_L; // 单通道模式
ADC1->SQR3 = ADC_Channel_1;
ADC1->CR2 |= ADC_CR2_ADON; // 使能ADC

然后，需要配置定时器2以生成CC2事件，以触发ADC外部转换。以下是一个基本的定时器2初始化代码片段：

RCC->APB1ENR |= RCC_APB1ENR_TIM2EN; // 使能TIM2时钟
TIM2->PSC = 71;      // 预分频器，72MHz时钟的计数频率为1MHz
TIM2->ARR = 999;     // 自动重装载值，计数从0到999
TIM2->CCR2 = 499;    // 捕获/比较寄存器2（50%占空比）
TIM2->CCER |= TIM_CCER_CC2E; // 使能捕获/比较通道2
TIM2->CR1 |= TIM_CR1_CEN;    // 开启定时器2

最后，在定时器2的cc2事件回调函数中进行ADC转换。例如：

void TIM2_IRQHandler(void)
{
    if (TIM2->SR & TIM_SR_CC2IF) {
        ADC1->CR2 |= ADC_CR2_SWSTART; // 启动ADC转换
        TIM2->SR &= ~TIM_SR_CC2IF;   // 清除CC2中断标志位
    }
}

这样，在PA1引脚上的电压达到一定阈值时，定时器2将生成cc2事件，触发ADC外部转换并启动ADC转换。转换完成后，可以通过读取ADC数据寄存器来获取转换结果。

以下是基于STM32CubeIDE的代码示例，演示如何使用定时器2的cc2事件触发ADC外部转换：

#include "main.h"
#include "stm32f1xx_hal.h"

ADC_HandleTypeDef hadc1;
TIM_HandleTypeDef htim2;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM2_Init(void);
static void MX_ADC1_Init(void);

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_TIM2_Init();
  MX_ADC1_Init();

  HAL_TIM_Base_Start(&htim2);
  HAL_TIM_OC_Start_IT(&htim2, TIM_CHANNEL_2); // 使能TIM2的cc2事件触发

  while (1)
  {
  }
}

void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim)
{
  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2)
  {
    HAL_ADC_Start(&hadc1); // 启动ADC转换
  }
}

static void MX_ADC1_Init(void)
{
  ADC_ChannelConfTypeDef sConfig = {0};

  hadc1.Instance = ADC1;
  hadc1.Init.ScanConvMode = DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_CC2; // 设置ADC外部触发源为TIM2的cc2事件
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 1;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }

  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = 1;
  sConfig.SamplingTime = ADC_SAMPLETIME_13CYCLES_5;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_TIM2_Init(void)
{
  TIM_OC_InitTypeDef sConfigOC = {0};

  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 7199;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 999;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }

  sConfigOC.OCMode = TIM_OCMODE_TIMING;
  sConfigOC.Pulse = 499; // 设置cc2的触发时间
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_OC_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  __HAL_RCC_GPIOA_CLK_ENABLE();

  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

以上代码实现了定时器TIM2的cc2事件触发ADC外部转换。具体实现步骤如下：

1.在MX_TIM2_Init函数中，初始化TIM2定时器，并设置预分频器、计数模式、计数周期等参数。另外，配置TIM2的cc2通道为TIM_OCMODE_TIMING模式，并设置触发时间为499，即定时器计数值达到499时，触发cc2事件。

2.在MX_ADC1_Init函数中，初始化ADC1模块，并设置转换模式、外部触发源等参数。其中，外部触发源被设置为TIM2的cc2事件。

3.在HAL_TIM_OC_DelayElapsedCallback回调函数中，判断是否是cc2事件触发，若是，则启动ADC转换。

4.在main函数中，启动TIM2定时器，使能cc2事件触发功能，并进入死循环等待触发事件。

需要注意的是，此代码示例仅供参考，具体实现可能需要根据具体的硬件和应用场景进行调整和修改。同时，也需要根据需要添加相关的中断处理函数和错误处理函数等。

以下是基于STM32F103C8的定时器2触发ADC外部转换的代码示例：

#include "stm32f10x.h"

int main(void)
{
    // Enable clock for GPIOA and ADC1 peripherals
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_ADC1, ENABLE);
    
    // Configure PA2 as analog input for ADC1
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // Configure ADC1
    ADC_InitTypeDef ADC_InitStruct;
    ADC_InitStruct.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStruct.ADC_ScanConvMode = DISABLE;
    ADC_InitStruct.ADC_ContinuousConvMode = DISABLE;
    ADC_InitStruct.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T2_CC2; // Triggered by Timer2 CC2 event
    ADC_InitStruct.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStruct.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &ADC_InitStruct);
    
    // Configure Timer2
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
    TIM_TimeBaseInitStruct.TIM_Period = 1000 - 1; // Set timer period to 1 kHz
    TIM_TimeBaseInitStruct.TIM_Prescaler = 72 - 1; // Set timer prescaler to generate 1 MHz timer clock
    TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);
    
    // Configure Timer2 Channel 2 for PWM mode
    TIM_OCInitTypeDef TIM_OCInitStruct;
    TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStruct.TIM_Pulse = 500 - 1; // Set duty cycle to 50%
    TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OC2Init(TIM2, &TIM_OCInitStruct);
    
    // Enable Timer2 CC2 interrupt
    TIM_ITConfig(TIM2, TIM_IT_CC2, ENABLE);
    
    // Enable ADC1 and start calibration
    ADC_Cmd(ADC1, ENABLE);
    ADC_ResetCalibration(ADC1);
    while (ADC_GetResetCalibrationStatus(ADC1));
    ADC_StartCalibration(ADC1);
    while (ADC_GetCalibrationStatus(ADC1));
    
    // Start Timer2
    TIM_Cmd(TIM2, ENABLE);
    
    while (1)
    {
        // Wait for ADC conversion to complete
        while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
        
        // Read ADC conversion result
        uint16_t adc_value = ADC_GetConversionValue(ADC1);
        
        // Do something with adc_value
    }
}
该代码将定时器2的通道2配置为PWM模式，并且在定时器计数器达到设定值时，会触发一个CC2事件，该事件会启动ADC转换。通过轮询等待ADC转换完成，然后读取转换结果，即可获得外部信号的模拟值。

不知道你这个问题是否已经解决, 如果还没有解决的话:

帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7763604
你也可以参考下这篇文章：STM32 ADC 采样值不准确或偏小分析和解决方法

除此之外, 这篇博客: stm32F103寄存器操作集锦（新手必备）中的 六、ADC 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:

void my_ADC_Init(void)
{
	NVIC_InitTypeDef my_NVICStruct;

	RCC -> APB2ENR |= (1 << 9);  RCC -> APB2ENR |= (1 << 0);    //使能ADC1的时钟 和中断复用时钟
	
	RCC -> APB2RSTR |= (1 << 9);   //时钟复位
	RCC -> APB2RSTR&=~(1<<9);        //重新开启
	
	RCC -> CFGR &= ~(3 << 14);
	RCC -> CFGR |=   1 << 15;        //设置6分频  12M
	
	ADC1 -> CR1 |= 1 <<5;  			 //允许转换结束的中断  EOC
	ADC1 -> CR1 &= ~(0xf << 16);     //独立模式
	ADC1 -> CR1 &= ~(7 << 13) ;      //使用一个通道
	ADC1 -> CR2 |=   1 << 20;        //使用外部触发,先使用软件触发
	ADC1 -> CR2 &= ~(7 << 17);
	ADC1 -> CR2 |=  (7 << 17);       // 111 SWSTART
	
	ADC1 -> CR2 &= ~(1 << 11);    //使用右对齐
	ADC1 -> CR2 &= ~(1 << 1);     //单次转换
	ADC1 -> SQR1 &= ~(0xf << 20); //一个转换序列
	
	ADC1 -> SMPR2 &= ~(7 << 18);
	ADC1 -> SMPR2 |= (7 << 18);    //采样周期55.5
		
		
			//中断分组、优先级
		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
		my_NVICStruct.NVIC_IRQChannel = ADC1_2_IRQn;
		my_NVICStruct.NVIC_IRQChannelPreemptionPriority = 1;
		my_NVICStruct.NVIC_IRQChannelSubPriority = 1;
		my_NVICStruct.NVIC_IRQChannelCmd = ENABLE ;
		//初始化中断
		NVIC_Init(&my_NVICStruct);	
}

中断服务函数：

void ADC1_2_IRQHandler(void)
{
	if(ADC1 ->SR & 0x2)
	{
		Get_ADC_Conversion();
	}
		ADC1 ->SR &= ~(1 << 1);
}

开始采集一次：

void ADC_gather()
{
	ADC1 -> SQR3 |= 0;
	ADC1 -> CR2 |=  1 << 22;
	ADC1 -> CR2 |= (1 << 0);   //采集
}

得到采集的值：

void Get_ADC_Conversion(u8 ch)
{
		u32 adcx = 0;
  		ADC1 -> SQR3 &= 0XFFFFFFE0;     //规则序列1 通道ch
		ADC1 -> SQR3 |= ch;           
		ADC1 -> CR2|=1<<22;             //启动规则转换通道 
		while(!(ADC1 -> SR & 1 << 1));  //等待转换结束      
		adcx = ADC1->DR; 
		return adcx;
}

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

参考GPT和自己的思路：好的，针对你的问题，以下是可能的代码实现：

#include "stm32f103xb.h"

// 定义ADC外设
ADC_TypeDef* adc = ADC1;

int main(void) {
    // 使能外设时钟
    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
    RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;

    // 配置GPIO作为ADC外部触发源
    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
    GPIOA->CRL &= ~GPIO_CRL_CNF0;
    GPIOA->CRL |= GPIO_CRL_CNF0_1;  // 浮空输入
    GPIOA->CRL &= ~GPIO_CRL_MODE0;

    // 配置定时器2
    TIM2->CR1 &= ~TIM_CR1_CEN;  // 关闭定时器

    TIM2->PSC = 0;  // 设置预分频器为0，计数器时钟为72MHz
    TIM2->ARR = 0xFFFF; // 设置计数器自动重载值
    TIM2->CR1 &= ~TIM_CR1_DIR; // 向上计数模式
    TIM2->CR2 |= TIM_CR2_MMS_1; // 设置定时器触发ADC

    // 配置ADC
    adc->CR2 &= ~(ADC_CR2_ADON | ADC_CR2_DMA | ADC_CR2_CONT | ADC_CR2_ALIGN | ADC_CR2_EXTSEL);
    adc->CR2 |= ADC_CR2_EXTTRIG; // 启用外部触发
    adc->SQR1 &= ~ADC_SQR1_L;
    adc->SQR3 &= ~ADC_SQR3_SQ1;  // 只采样ADC1通道0
    adc->CR2 |= ADC_CR2_ADON;

    // 开启定时器
    TIM2->CR1 |= TIM_CR1_CEN;

    while (1) {
        // 等待ADC转换完成
        while (!(adc->SR & ADC_SR_EOC));
        uint16_t adc_value = adc->DR;  // 读取ADC转换结果

        // 处理ADC转换结果
        // ...
    }
}

上面的代码假设你已经了解了STM32的寄存器编程，需要配合官方文档进行理解和修改。其中，配置GPIO作为ADC外部触发源和设置定时器2的定时器触发ADC两个部分是关键。

具体来说，GPIOA的第0个引脚被配置为浮空输入，作为ADC的外部触发源；定时器2的MMS寄存器被设置为"011"，即TRGO事件触发，用于触发ADC的正常转换模式。在while(1)循环中，我们等待ADC转换完成，读取结果后可以进行后续处理。