stm32f10xd定时器

STM32F10X系列是一款基于ARM Cortex-M3内核的微控制器，它内置了多种定时器模块，其中最重要的是基本定时器（Basic Timers）、高级定时器（Advanced Timers），以及两个嵌套定时器（Nested Timers）。以下是关于STM32F10X定时器的一些基本信息：

1. **基本定时器（Timer B & Timer C）**：
- Timer B有4个独立的通道，支持计数模式、预分频计数和PWM输出功能。
- Timer C分为两个部分：Timer C1和Timer C2，它们也各有四个通道。

2. **高级定时器（Timer D）**：
- 它是一个16位定时器，提供了更丰富的功能，如窗口捕获、比较模式等，并支持外部中断。

3. **嵌套定时器（Timer 1）**：
- Timer 1是一个16位定时器，用于对高级定时器和基本定时器提供更高的定时精度，可以单独运行并拥有独立的中断。

4. **通用定时器（Timer 2）**：
- 可以作为高级定时器使用，也可以配置成DMA触发源。

这些定时器通常通过寄存器设置周期、计数模式、触发事件等参数，并可通过中断系统来响应特定时间点或事件的发生。STM32F10X定时器广泛应用于电机控制、通信间隔管理、计时器应用等方面。

相关问题

基于stm32的恒温箱的代码

基于 STM32 的恒温箱的代码需要实现以下功能：

1. 读取传感器数据：使用 ADC 模块读取温度传感器的数据，并将其转换为实际温度值。

2. 控制加热器和风扇：使用 PWM 输出控制加热器和风扇的电压，从而实现温度控制。

3. 显示温度数据：使用 OLED 显示屏或者 LCD 屏幕显示当前的温度值和设定值。

4. 设置温度范围：使用按键或者旋转编码器等输入设备，设置温度范围和设定温度值。

下面是基于 STM32 的恒温箱的代码示例，供您参考：

#include "stm32f10x.h"
#include "stdio.h"

// 温度传感器引脚定义
#define TEMPERATURE_SENSOR_PIN GPIO_Pin_0
#define TEMPERATURE_SENSOR_GPIO GPIOA

// 按键引脚定义
#define BUTTON_PIN GPIO_Pin_1
#define BUTTON_GPIO GPIOA

// OLED 显示屏引脚定义
#define OLED_SCL_PIN GPIO_Pin_5
#define OLED_SDA_PIN GPIO_Pin_7
#define OLED_RST_PIN GPIO_Pin_6
#define OLED_GPIO GPIOB

// PWM 输出引脚定义
#define HEATER_PIN GPIO_Pin_8
#define HEATER_GPIO GPIOA
#define FAN_PIN GPIO_Pin_9
#define FAN_GPIO GPIOA

// 温度范围和设定温度值
#define MIN_TEMPERATURE 20
#define MAX_TEMPERATURE 50
#define DEFAULT_TEMPERATURE 25

// 温度控制参数
#define KP 0.5
#define KI 0.1
#define KD 0.2

// 全局变量定义
volatile float temperature = 0;
volatile float set_temperature = DEFAULT_TEMPERATURE;
volatile float integral = 0;
volatile float derivative = 0;
volatile float last_error = 0;
volatile uint32_t last_time = 0;

// 函数声明
void ADC_Init(void);
void GPIO_Init(void);
void PWM_Init(void);
void TIM2_Init(void);
void OLED_Init(void);
void OLED_WriteCmd(uint8_t cmd);
void OLED_WriteData(uint8_t data);
void OLED_SetPos(uint8_t x, uint8_t y);
void OLED_Clear(void);
void OLED_ShowString(uint8_t x, uint8_t y, char *str);
void Delay_ms(uint32_t ms);
float PID_Controller(float set_value, float actual_value);

int main(void)
{
    // 初始化
    GPIO_Init();
    ADC_Init();
    PWM_Init();
    TIM2_Init();
    OLED_Init();
    
    // 温度控制循环
    while (1)
    {
        // 读取传感器数据
        ADC_SoftwareStartConvCmd(ADC1, ENABLE);
        while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
        temperature = ADC_GetConversionValue(ADC1) * 3.3 / 4096.0 * 100.0;
        
        // 控制温度
        float output = PID_Controller(set_temperature, temperature);
        
        // 设置 PWM 输出
        if (output > 0)
        {
            TIM_SetCompare1(TIM1, output);
            TIM_SetCompare2(TIM1, 0);
        }
        else
        {
            TIM_SetCompare1(TIM1, 0);
            TIM_SetCompare2(TIM1, -output);
        }
        
        // 显示温度数据
        char str[16];
        sprintf(str, "Temp: %.1f C", temperature);
        OLED_ShowString(0, 0, str);
        sprintf(str, "Set: %.1f C", set_temperature);
        OLED_ShowString(0, 2, str);
        
        // 延时 500ms
        Delay_ms(500);
    }
}

// ADC 初始化函数
void ADC_Init(void)
{
    ADC_InitTypeDef ADC_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;
    
    // 使能 ADC1 时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    
    // 配置 ADC1 通道 0 的 GPIO 引脚
    GPIO_InitStructure.GPIO_Pin = TEMPERATURE_SENSOR_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_Init(TEMPERATURE_SENSOR_GPIO, &GPIO_InitStructure);
    
    // 配置 ADC1
    ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
    ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfChannel = 1;
    ADC_Init(ADC1, &ADC_InitStructure);
    
    // 配置 ADC1 通道 0
    ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);
    
    // 使能 ADC1
    ADC_Cmd(ADC1, ENABLE);
}

// GPIO 初始化函数
void GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    // 使能 GPIOA 和 GPIOB 时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);
    
    // 配置温度传感器引脚
    GPIO_InitStructure.GPIO_Pin = TEMPERATURE_SENSOR_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
    GPIO_Init(TEMPERATURE_SENSOR_GPIO, &GPIO_InitStructure);
    
    // 配置按键引脚
    GPIO_InitStructure.GPIO_Pin = BUTTON_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(BUTTON_GPIO, &GPIO_InitStructure);
    
    // 配置 OLED 显示屏引脚
    GPIO_InitStructure.GPIO_Pin = OLED_SCL_PIN | OLED_SDA_PIN | OLED_RST_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(OLED_GPIO, &GPIO_InitStructure);
    
    // 配置 PWM 输出引脚
    GPIO_InitStructure.GPIO_Pin = HEATER_PIN | FAN_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(HEATER_GPIO, &GPIO_InitStructure);
    GPIO_Init(FAN_GPIO, &GPIO_InitStructure);
}

// PWM 初始化函数
void PWM_Init(void)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    TIM_OCInitTypeDef TIM_OCInitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;
    
    // 使能 TIM1 时钟和 GPIOA 时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1 | RCC_APB2Periph_GPIOA, ENABLE);
    
    // 配置 GPIOA 引脚为 PWM 输出
    GPIO_InitStructure.GPIO_Pin = HEATER_PIN | FAN_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(HEATER_GPIO, &GPIO_InitStructure);
    GPIO_Init(FAN_GPIO, &GPIO_InitStructure);
    
    // 配置 TIM1 时钟和周期
    TIM_TimeBaseStructure.TIM_Period = 999;
    TIM_TimeBaseStructure.TIM_Prescaler = 71;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
    
    // 配置 TIM1 通道 1 和通道 2 为 PWM 输出
    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStructure.TIM_Pulse = 0;
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OC1Init(TIM1, &TIM_OCInitStructure);
    TIM_OC2Init(TIM1, &TIM_OCInitStructure);
    
    // 启动 TIM1
    TIM_Cmd(TIM1, ENABLE);
}

// 定时器初始化函数
void TIM2_Init(void)
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    
    // 使能 TIM2 时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    
    // 配置 TIM2 时钟和周期
    TIM_TimeBaseStructure.TIM_Period = 999;
    TIM_TimeBaseStructure.TIM_Prescaler = 71;
    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
    
    // 配置 TIM2 中断
    TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    // 启动 TIM2
    TIM_Cmd(TIM2, ENABLE);
}

// OLED 初始化函数
void OLED_Init(void)
{
    GPIO_SetBits(OLED_GPIO, OLED_RST_PIN);
    Delay_ms(100);
    GPIO_ResetBits(OLED_GPIO, OLED_RST_PIN);
    Delay_ms(100);
    GPIO_SetBits(OLED_GPIO, OLED_RST_PIN);
    Delay_ms(100);
    
    OLED_WriteCmd(0xAE);
    OLED_WriteCmd(0xD5);
    OLED_WriteCmd(0x80);
    OLED_WriteCmd(0xA8);
    OLED_WriteCmd(0x3F);
    OLED_WriteCmd(0xD3);
    OLED_WriteCmd(0x00);
    OLED_WriteCmd(0x40);
    OLED_WriteCmd(0x8D);
    OLED_WriteCmd(0x14);
    OLED_WriteCmd(0x20);
    OLED_WriteCmd(0x00);
    OLED_WriteCmd(0xA1);
    OLED_WriteCmd(0xC8);
    OLED_WriteCmd(0xDA);
    OLED_WriteCmd(0x12);
    OLED_WriteCmd(0x81);
    OLED_WriteCmd(0xCF);
    OLED_WriteCmd(0xD9);
    OLED_WriteCmd(0xF1);
    OLED_WriteCmd(0xDB);
    OLED_WriteCmd(0x40);
    OLED_WriteCmd(0xA4);
    OLED_WriteCmd(0xA6);
    OLED_WriteCmd(0xAF);
    OLED_Clear();
}

// OLED 写命令
void OLED_WriteCmd(uint8_t cmd)
{
    uint8_t i;
    GPIO_ResetBits(OLED_GPIO, OLED_SCL_PIN);
    GPIO_ResetBits(OLED_GPIO, OLED_SDA_PIN);
    for (i = 0; i < 8; i++)
    {
        if ((cmd & 0x80) == 0x80)
        {
            GPIO_SetBits(OLED_GPIO, OLED_SDA_PIN);
        }
        else
        {
            GPIO_ResetBits(OLED_GPIO, OLED_SDA_PIN);
        }
        cmd <<= 1;
        GPIO_SetBits(OLED_GPIO, OLED_SCL_PIN);
        GPIO_ResetBits(OLED_GPIO, OLED_SCL_PIN);
    }
}

// OLED 写数据
void OLED_WriteData(uint8_t data)
{
    uint8_t i;
    GPIO_ResetBits(OLED_GPIO, OLED_SCL_PIN);
    GPIO_SetBits(OLED_GPIO, OLED_SDA_PIN);
    for (i = 0; i < 8; i++)
    {
        if ((data & 0x80) == 0x80)
        {
            GPIO_SetBits(OLED_GPIO, OLED_SDA_PIN);
        }
        else
        {
            GPIO_ResetBits(OLED_GPIO, OLED_SDA_PIN);
        }
        data <<= 1;
        GPIO_SetBits(OLED_GPIO, OLED_SCL_PIN);
        GPIO_ResetBits(OLED_GPIO, OLED_SCL_PIN);
    }
}

// OLED 设置位置
void OLED_SetPos(uint8_t x, uint8_t y)
{
    OLED_WriteCmd(0xb0 + y);
    OLED_WriteCmd(((x & 0xf0) >> 4) | 0x10);
    OLED_WriteCmd(x & 0x0f);
}

// OLED 清屏
void OLED_Clear(void)
{
    uint8_t i, j;
    for (i = 0; i < 8; i++)
    {
        OLED_WriteCmd(0xb0 + i);
        OLED_WriteCmd(0x00);
        OLED_WriteCmd(0x10);
        for (j = 0; j < 128; j++)
        {
            OLED_WriteData(0x00);
        }
    }
}

// OLED 显示字符串
void OLED_ShowString(uint8_t x, uint8_t y, char *str)
{
    uint8_t i = 0;
    while (str[i] != '\0')
    {
        OLED_SetPos(x, y);
        OLED_WriteData(str[i]);
        x += 8;
        i++;
    }
}

// 延时函数
void Delay_ms(uint32_t ms)
{
    uint32_t i, j;
    for (i = 0; i < ms; i++)
    {
        for (j = 0; j < 2000; j++);
    }
}

// PID 控制器
float PID_Controller(float set_value, float actual_value)
{
    uint32_t current_time = TIM_GetCounter(TIM2);
    float error = set_value - actual_value;
    float output = KP * error + KI * integral + KD * derivative;
    integral += error * (current_time - last_time) / 1000.0;
    derivative = (error - last_error) / (current_time - last_time) * 1000.0;
    last_error = error;
    last_time = current_time;
    if (output > 100) output = 100;
    if (output < -100) output = -100;
    return output;
}

// 定时器中断处理函数
void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2,

用stm32f103c8t6实现平衡车的pid控制代码

平衡车的PID控制是一个比较复杂的算法，需要综合考虑多个因素来控制车身的平衡，比如车身的倾斜角度、加速度、角速度等等。下面是一个基于STM32F103C8T6的简单平衡车PID控制代码，供您参考。

#include "stm32f10x.h"

#define MOTOR1_PIN1 GPIO_Pin_0
#define MOTOR1_PIN2 GPIO_Pin_1
#define MOTOR2_PIN1 GPIO_Pin_2
#define MOTOR2_PIN2 GPIO_Pin_3
#define MOTOR_PORT GPIOA

#define MPU6050_ADDRESS 0xD0
#define MPU6050_PWR_MGMT_1 0x6B
#define MPU6050_GYRO_XOUT_H 0x43
#define MPU6050_GYRO_YOUT_H 0x45
#define MPU6050_GYRO_ZOUT_H 0x47
#define MPU6050_ACCEL_XOUT_H 0x3B
#define MPU6050_ACCEL_YOUT_H 0x3D
#define MPU6050_ACCEL_ZOUT_H 0x3F

#define Kp 4.0f
#define Ki 0.2f
#define Kd 0.0f

float angle, gyro, balance;
float last_error, integral, derivative;
float pid_output;

void init_motor(void);
void init_mpu6050(void);
float get_angle(void);
float get_gyro(void);
float get_balance(void);
void set_motor(float speed1, float speed2);
void pid_control(void);

int main(void)
{
    init_motor();
    init_mpu6050();

    while (1)
    {
        pid_control();
    }
}

void init_motor(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitStructure.GPIO_Pin = MOTOR1_PIN1 | MOTOR1_PIN2 | MOTOR2_PIN1 | MOTOR2_PIN2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(MOTOR_PORT, &GPIO_InitStructure);
}

void init_mpu6050(void)
{
    uint8_t data;

    I2C1->CR1 |= I2C_CR1_PE;
    RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
    RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;

    GPIOB->CRL |= GPIO_CRL_MODE6 | GPIO_CRL_MODE7;
    GPIOB->CRL |= GPIO_CRL_CNF6_1 | GPIO_CRL_CNF7_1;

    I2C1->CR2 |= 0x08;
    I2C1->CCR |= 0x50;
    I2C1->TRISE |= 0x09;

    I2C1->CR1 |= I2C_CR1_ACK;
    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (!(I2C1->SR2 & I2C_SR2_TRA));
    I2C1->DR = MPU6050_PWR_MGMT_1;
    while (!(I2C1->SR1 & I2C_SR1_TXE));
    I2C1->CR1 |= I2C_CR1_STOP;

    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (!(I2C1->SR2 & I2C_SR2_TRA));
    I2C1->DR = MPU6050_GYRO_XOUT_H;
    while (!(I2C1->SR1 & I2C_SR1_TXE));
    I2C1->CR1 |= I2C_CR1_STOP;

    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS + 1;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (I2C1->SR2 & I2C_SR2_TRA);
    I2C1->CR1 |= I2C_CR1_ACK;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    I2C1->CR1 |= I2C_CR1_STOP;
}

float get_angle(void)
{
    uint8_t data;
    int16_t accel_x, accel_y, accel_z;

    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (!(I2C1->SR2 & I2C_SR2_TRA));
    I2C1->DR = MPU6050_ACCEL_XOUT_H;
    while (!(I2C1->SR1 & I2C_SR1_TXE));
    I2C1->CR1 |= I2C_CR1_STOP;

    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS + 1;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (I2C1->SR2 & I2C_SR2_TRA);
    I2C1->CR1 |= I2C_CR1_ACK;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    accel_x = (data << 8) | I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    accel_y = (data << 8) | I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    accel_z = (data << 8) | I2C1->DR;
    I2C1->CR1 |= I2C_CR1_STOP;

    angle = atan2(accel_y, accel_z) * 180 / 3.14;

    return angle;
}

float get_gyro(void)
{
    uint8_t data;
    int16_t gyro_x, gyro_y, gyro_z;

    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (!(I2C1->SR2 & I2C_SR2_TRA));
    I2C1->DR = MPU6050_GYRO_XOUT_H;
    while (!(I2C1->SR1 & I2C_SR1_TXE));
    I2C1->CR1 |= I2C_CR1_STOP;

    I2C1->CR1 |= I2C_CR1_START;
    while (!(I2C1->SR1 & I2C_SR1_SB));
    I2C1->DR = MPU6050_ADDRESS + 1;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    while (I2C1->SR2 & I2C_SR2_TRA);
    I2C1->CR1 |= I2C_CR1_ACK;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    gyro_x = (data << 8) | I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    gyro_y = (data << 8) | I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    data = I2C1->DR;
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    gyro_z = (data << 8) | I2C1->DR;
    I2C1->CR1 |= I2C_CR1_STOP;

    gyro = gyro_y / 131.0f;

    return gyro;
}

float get_balance(void)
{
    angle = get_angle();
    gyro = get_gyro();
    balance = Kp * angle + Ki * integral + Kd * derivative;
    last_error = angle;
    integral += angle;
    derivative = angle - last_error;

    return balance;
}

void set_motor(float speed1, float speed2)
{
    if (speed1 > 0)
    {
        GPIO_SetBits(MOTOR_PORT, MOTOR1_PIN1);
        GPIO_ResetBits(MOTOR_PORT, MOTOR1_PIN2);
        TIM4->CCR1 = (uint16_t)(speed1 * 1000);
    }
    else if (speed1 < 0)
    {
        GPIO_ResetBits(MOTOR_PORT, MOTOR1_PIN1);
        GPIO_SetBits(MOTOR_PORT, MOTOR1_PIN2);
        TIM4->CCR1 = (uint16_t)(-speed1 * 1000);
    }
    else
    {
        GPIO_ResetBits(MOTOR_PORT, MOTOR1_PIN1);
        GPIO_ResetBits(MOTOR_PORT, MOTOR1_PIN2);
        TIM4->CCR1 = 0;
    }

    if (speed2 > 0)
    {
        GPIO_SetBits(MOTOR_PORT, MOTOR2_PIN1);
        GPIO_ResetBits(MOTOR_PORT, MOTOR2_PIN2);
        TIM4->CCR2 = (uint16_t)(speed2 * 1000);
    }
    else if (speed2 < 0)
    {
        GPIO_ResetBits(MOTOR_PORT, MOTOR2_PIN1);
        GPIO_SetBits(MOTOR_PORT, MOTOR2_PIN2);
        TIM4->CCR2 = (uint16_t)(-speed2 * 1000);
    }
    else
    {
        GPIO_ResetBits(MOTOR_PORT, MOTOR2_PIN1);
        GPIO_ResetBits(MOTOR_PORT, MOTOR2_PIN2);
        TIM4->CCR2 = 0;
    }
}

void pid_control(void)
{
    pid_output = get_balance();
    set_motor(pid_output, -pid_output);
    delay_ms(10);
}

注意：该代码只是一个简单的示例，实际使用时需要根据实际情况进行调整和优化。另外，代码中还需要定义一个延时函数 `delay_ms()`，该函数可以使用定时器或者循环计数实现。