基于HAL库设计一个自适应采集1HZ-100KHZ正弦波的代码

好的，以下是一份基于HAL库的代码示例，仅供参考：

#include "stm32f1xx_hal.h"
#include "arm_math.h"
#include <math.h>

// 定义采集参数
#define ADC_BUFFER_SIZE 1024 // 定义ADC采样缓存区大小
#define SAMPLE_RATE 100000 // 定义采样频率（单位：Hz）
#define SAMPLE_TIME 1 // 定义采样时间（单位：秒）

// 定义FFT变换参数
#define FFT_SIZE ADC_BUFFER_SIZE // 定义FFT变换长度
#define FFT_WINDOW_TYPE kaiser // 定义FFT窗口类型

// 定义滤波器参数
#define FILTER_ORDER 4 // 定义滤波器阶数
#define FILTER_FC 5000 // 定义滤波器截止频率（单位：Hz）

// 定义全局变量
ADC_HandleTypeDef hadc1; // 定义ADC句柄
TIM_HandleTypeDef htim2; // 定义定时器句柄
volatile uint32_t adc_buffer[ADC_BUFFER_SIZE]; // 定义ADC采样缓存区
float32_t fft_data[FFT_SIZE]; // 定义FFT变换数据
float32_t fft_window[FFT_SIZE]; // 定义FFT窗口函数
float32_t fft_result[FFT_SIZE]; // 定义FFT变换结果
float32_t filter_coeff[FILTER_ORDER + 1]; // 定义滤波器系数
float32_t filter_data[FFT_SIZE]; // 定义滤波器输出数据

// 定义函数原型
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_TIM2_Init(void);
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim);
void acquire_data(void);
void apply_window(void);
void fft_transform(void);
void filter_data(void);

// 主函数
int main(void)
{
    HAL_Init(); // 初始化HAL库
    SystemClock_Config(); // 配置系统时钟
    MX_GPIO_Init(); // 初始化GPIO
    MX_ADC1_Init(); // 初始化ADC1
    MX_TIM2_Init(); // 初始化TIM2
    HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buffer, ADC_BUFFER_SIZE); // 启动ADC采样
    HAL_TIM_Base_Start_IT(&htim2); // 启动定时器2
    while (1)
    {
        // 主循环
    }
}

// 系统时钟配置函数
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    /** Configure the main internal regulator output voltage 
    */
    __HAL_RCC_PWR_CLK_ENABLE();
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
    /** Initializes the RCC Oscillators according to the specified parameters
    * in the RCC_OscInitTypeDef structure.
    */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        Error_Handler();
    }
    /** Initializes the CPU, AHB and APB buses clocks
    */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
    {
        Error_Handler();
    }
}

// GPIO初始化函数
static void MX_GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    /* GPIO Ports Clock Enable */
    __HAL_RCC_GPIOC_CLK_ENABLE();

    /*Configure GPIO pin Output Level */
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);

    /*Configure GPIO pin : PC13 */
    GPIO_InitStruct.Pin = GPIO_PIN_13;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

// ADC初始化函数
static void MX_ADC1_Init(void)
{
    ADC_ChannelConfTypeDef sConfig = {0};

    /** Common config
    */
    hadc1.Instance = ADC1;
    hadc1.Init.ScanConvMode = DISABLE;
    hadc1.Init.ContinuousConvMode = ENABLE;
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion = 1;
    if (HAL_ADC_Init(&hadc1) != HAL_OK)
    {
        Error_Handler();
    }
    /** Configure Regular Channel
    */
    sConfig.Channel = ADC_CHANNEL_0;
    sConfig.Rank = ADC_REGULAR_RANK_1;
    sConfig.SamplingTime = ADC_SAMPLETIME_239CYCLES_5;
    if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
    {
        Error_Handler();
    }
}

// 定时器初始化函数
static void MX_TIM2_Init(void)
{
    TIM_MasterConfigTypeDef sMasterConfig = {0};

    htim2.Instance = TIM2;
    htim2.Init.Prescaler = 72 - 1; // 计算预分频系数
    htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim2.Init.Period = 1000000 / SAMPLE_RATE - 1; // 计算计数器自动重载值
    if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
    {
        Error_Handler();
    }
    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
    {
        Error_Handler();
    }
}

// 定时器中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim == &htim2) // 判断是否为定时器2的中断
    {
        acquire_data(); // 采集数据
        apply_window(); // 应用窗口函数
        fft_transform(); // FFT变换
        filter_data(); // 滤波处理
    }
}

// 采集函数
void acquire_data(void)
{
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13); // 每次采集前翻转LED
    static uint32_t sample_count = 0; // 定义采样计数器
    if(sample_count < ADC_BUFFER_SIZE) // 判断采样计数器是否超出缓存区大小
    {
        adc_buffer[sample_count] = HAL_ADC_GetValue(&hadc1); // 获取ADC采样值
        sample_count++; // 采样计数器加1
    }
    else
    {
        sample_count = 0; // 重置采样计数器
    }
}

// 应用窗口函数
void apply_window(void)
{
    arm_kaiser_window_f32(fft_window, FFT_SIZE, 5); // 生成Kaiser窗口
    arm_mult_f32(fft_window, adc_buffer, fft_data, FFT_SIZE); // 应用窗口函数
}

// FFT变换函数
void fft_transform(void)
{
    arm_rfft_fast_f32(&arm_rfft_instance_f32, fft_data, fft_result, 0); // 进行FFT变换
    arm_cmplx_mag_f32(fft_result, fft_result, FFT_SIZE / 2); // 计算FFT幅值
}

// 滤波函数
void filter_data(void)
{
    static arm_fir_instance_f32 filter; // 定义FIR滤波器实例
    static float32_t filter_state[FFT_SIZE + FILTER_ORDER]; // 定义FIR滤波器状态缓存区
    static uint32_t filter_init_flag = 0; // 定义FIR滤波器初始化标志
    if(filter_init_flag == 0) // 判断FIR滤波器是否已初始化
    {
        arm_fir_init_f32(&filter, filter_coeff, FILTER_ORDER + 1, filter_state, FFT_SIZE); // 初始化FIR滤波器
        filter_init_flag = 1; // 设置FIR滤波器初始化标志
    }
    arm_fir_f32(&filter, fft_result, filter_data, FFT_SIZE); // 进行FIR滤波
}

// 错误处理函数
void Error_Handler(void)
{
    while(1)
    {
        HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13); // 案例出错时翻转LED
        HAL_Delay(500);
    }
}

以上代码示例仅供参考，具体实现方式需要根据具体应用场景进行调整和优化。需要注意的是，在实际应用中还需要考虑各种误差和噪声对采集结果的影响，并采用合适的校准和校正方法来提高采集精度。