STM32F407 模糊控制算法控制电机代码

模糊控制算法是一种常用的控制方法，可以用来控制电机，下面是一个简单的 STM32F407 模糊控制算法控制电机的代码示例：

#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_tim.h"
#include "stm32f4xx_adc.h"

#define F_CPU 168000000

// 定义电机PWM控制引脚
#define MOTOR_PWM_PIN GPIO_Pin_9
#define MOTOR_PWM_PORT GPIOA

// 定义电机方向控制引脚
#define MOTOR_DIR_PIN GPIO_Pin_10
#define MOTOR_DIR_PORT GPIOA

// 定义模糊控制算法的三个输入变量：误差e、误差变化率ce、积分误差ie
float e, ce, ie;

// 定义模糊控制算法的三个输出变量：电压u、电流i、功率p
float u, i, p;

// 定义PID控制器的参数
float Kp = 0.5;
float Ki = 0.1;
float Kd = 0.2;

// 初始化电机PWM控制引脚
void InitMotorPWM()
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

    GPIO_InitStructure.GPIO_Pin = MOTOR_PWM_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(MOTOR_PWM_PORT, &GPIO_InitStructure);

    GPIO_PinAFConfig(MOTOR_PWM_PORT, GPIO_PinSource9, GPIO_AF_TIM1);
}

// 初始化电机方向控制引脚
void InitMotorDir()
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

    GPIO_InitStructure.GPIO_Pin = MOTOR_DIR_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(MOTOR_DIR_PORT, &GPIO_InitStructure);
}

// 初始化定时器1，用于产生PWM信号
void InitTimer1()
{
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
    TIM_OCInitTypeDef TIM_OCInitStruct;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

    TIM_TimeBaseInitStruct.TIM_Period = 1000 - 1;
    TIM_TimeBaseInitStruct.TIM_Prescaler = (F_CPU / 1000000) - 1;
    TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit(TIM1, &TIM_TimeBaseInitStruct);

    TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
    TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
    TIM_OCInitStruct.TIM_Pulse = 0;
    TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_High;
    TIM_OC1Init(TIM1, &TIM_OCInitStruct);

    TIM_Cmd(TIM1, ENABLE);
}

// 初始化ADC采样电机电流
void InitADC()
{
    ADC_InitTypeDef ADC_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
    ADC_InitStructure.ADC_ScanConvMode = DISABLE;
    ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
    ADC_InitStructure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
    ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
    ADC_InitStructure.ADC_NbrOfConversion = 1;
    ADC_Init(ADC1, &ADC_InitStructure);

    ADC_Cmd(ADC1, ENABLE);

    ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_480Cycles);
}

// 获取电机电流ADC采样值
float GetMotorCurrent()
{
    ADC_SoftwareStartConv(ADC1);
    while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
    return ADC_GetConversionValue(ADC1) * 3.3 / 4096 / 0.1;
}

// 模糊控制算法
void FuzzyControl()
{
    // 计算误差e，假设目标速度为1000rpm，当前速度为v
    float v = GetMotorSpeed();
    e = 1000 - v;

    // 计算误差变化率ce，假设采样时间为10ms
    static float last_e = 0;
    ce = (e - last_e) / 0.01;
    last_e = e;

    // 计算积分误差ie，假设采样时间为10ms
    static float ie = 0;
    ie += e * 0.01;

    // 模糊控制规则
    if(e < -10 && ce < -5)
    {
        u = -12;
    }
    else if(e < -10 && ce >= -5 && ce < 0)
    {
        u = -6;
    }
    else if(e < -10 && ce >= 0 && ce < 5)
    {
        u = 0;
    }
    else if(e < -10 && ce >= 5)
    {
        u = 6;
    }
    else if(e >= -10 && e < 0 && ce < -5)
    {
        u = -6;
    }
    else if(e >= -10 && e < 0 && ce >= -5 && ce < 0)
    {
        u = -3;
    }
    else if(e >= -10 && e < 0 && ce >= 0 && ce < 5)
    {
        u = 0;
    }
    else if(e >= -10 && e < 0 && ce >= 5)
    {
        u = 3;
    }
    else if(e >= 0 && e < 10 && ce < -5)
    {
        u = -3;
    }
    else if(e >= 0 && e < 10 && ce >= -5 && ce < 0)
    {
        u = -1;
    }
    else if(e >= 0 && e < 10 && ce >= 0 && ce < 5)
    {
        u = 1;
    }
    else if(e >= 0 && e < 10 && ce >= 5)
    {
        u = 3;
    }
    else if(e >= 10 && ce < -5)
    {
        u = 6;
    }
    else if(e >= 10 && ce >= -5 && ce < 0)
    {
        u = 12;
    }
    else if(e >= 10 && ce >= 0 && ce < 5)
    {
        u = 18;
    }
    else if(e >= 10 && ce >= 5)
    {
        u = 24;
    }

    // 计算电流i，假设电机电阻为1欧姆
    i = u / 1;

    // 计算功率p，假设电机电压为12V
    p = u * 12;
}

// PID控制器
void PIDControl()
{
    static float last_e = 0;
    static float ie = 0;

    // 计算误差e，假设目标速度为1000rpm，当前速度为v
    float v = GetMotorSpeed();
    float e = 1000 - v;

    // 计算误差变化率ce，假设采样时间为10ms
    float ce = (e - last_e) / 0.01;
    last_e = e;

    // 计算积分误差ie，假设采样时间为10ms
    ie += e * 0.01;

    // 计算PID输出
    float u = Kp * e + Ki * ie + Kd * ce;

    // 计算电流i，假设电机电阻为1欧姆
    float i = u / 1;

    // 计算功率p，假设电机电压为12V
    float p = u * 12;
}

int main(void)
{
    // 初始化电机PWM控制引脚
    InitMotorPWM();

    // 初始化电机方向控制引脚
    InitMotorDir();

    // 初始化定时器1，用于产生PWM信号
    InitTimer1();

    // 初始化ADC采样电机电流
    InitADC();

    while(1)
    {
        // 使用模糊控制算法控制电机
        FuzzyControl();

        // 使用PID控制器控制电机
        // PIDControl();

        // 更新电机PWM占空比
        TIM_SetCompare1(TIM1, (int)(1000 * i / 12));

        // 更新电机方向控制引脚
        if(i < 0)
        {
            GPIO_ResetBits(MOTOR_DIR_PORT, MOTOR_DIR_PIN);
        }
        else
        {
            GPIO_SetBits(MOTOR_DIR_PORT, MOTOR_DIR_PIN);
        }

        // 延时10ms
        for(int i=0; i<10000; i++);
    }
}

需要注意的是，这只是一个简单的代码示例，实际应用中还需要根据具体情况进行调整。另外，模糊控制算法和PID控制器都有各自的优缺点，需要根据具体情况选择合适的控制算法。