电机应用-正点原子直流有刷电机例程笔记

Couvrir洪荒猛兽

已于 2024-03-04 16:49:23 修改

阅读量1.2k

点赞数 24

分类专栏： # 电机应用文章标签：笔记

于 2024-03-01 17:57:37 首次发布

本文链接：https://blog.csdn.net/weixin_47077788/article/details/136364986

版权

电机应用专栏收录该内容

9 篇文章 6 订阅

订阅专栏

基础驱动实验：调速和换向

硬件资源：

TIM1_CH1 TIM1_CH1N SHDN刹车引脚
PA8 PB13 PF10

电路原理：

假设让TIM1_CH1输出PWM波，TIM1_CH1N固定输出高电平，此时只要调节TIM1_CH1输出的PWM占空比即可调整电机上的电压，进而控制电机的转速。

当电机需要换向时，我们就让TIM1_CH1固定输出高电平，TIM1_CH1N输出PWM波即可。

功能描述：

比较值变量的绝对值越大，电机速度越快。比较值变量正数为正转，负数反转。

按下KEY0，增大PWM的比较值变量。

按下KEY1，减小PWM的比较值变量。

按下KEY2，电机停止。

初始化工作

TIM_HandleTypeDef g_atimx_cplm_pwm_handle;                              /* 定时器x句柄 */

/**
 * @brief       高级定时器TIMX 互补输出 初始化函数（使用PWM模式1）
 * @note
 *              配置高级定时器TIMX 互补输出, 一路OCy 一路OCyN, 并且可以设置死区时间
 *
 *              高级定时器的时钟来自APB2, 而PCLK2 = 168Mhz, 我们设置PPRE2不分频, 因此
 *              高级定时器时钟 = 168Mhz
 *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
 *              Ft=定时器工作频率, 单位 : Mhz
 *
 * @param       arr: 自动重装值。
 * @param       psc: 时钟预分频数
 * @retval      无
 */

void atim_timx_cplm_pwm_init(uint16_t arr, uint16_t psc)
{
    TIM_OC_InitTypeDef sConfigOC ;
    TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig;

    g_atimx_cplm_pwm_handle.Instance = TIM1;                                /* 定时器x */
    g_atimx_cplm_pwm_handle.Init.Prescaler = psc;                           /* 定时器预分频系数 */
    g_atimx_cplm_pwm_handle.Init.CounterMode = TIM_COUNTERMODE_UP;          /* 向上计数模式 */
    g_atimx_cplm_pwm_handle.Init.Period = arr;                              /* 自动重装载值 */
    g_atimx_cplm_pwm_handle.Init.RepetitionCounter = 0;                     /* 重复计数器寄存器为0 */
    g_atimx_cplm_pwm_handle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;        /* 使能影子寄存器TIMx_ARR */
    HAL_TIM_PWM_Init(&g_atimx_cplm_pwm_handle) ;

    /* 设置PWM输出 */
    sConfigOC.OCMode = TIM_OCMODE_PWM1;                                     /* PWM模式1 */
    sConfigOC.Pulse = 0;                                                    /* 比较值为0 */
    sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;                              /* OCy 低电平有效 */
    sConfigOC.OCNPolarity = TIM_OCNPOLARITY_LOW;                            /* OCyN 低电平有效 */
    sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;                               /* 使用快速模式 */
    sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;                          /* 主通道的空闲状态 */
    sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;                        /* 互补通道的空闲状态 */
    HAL_TIM_PWM_ConfigChannel(&g_atimx_cplm_pwm_handle, &sConfigOC, ATIM_TIMX_CPLM_CHY);    /* 配置后默认清CCER的互补输出位 */

    /* 设置死区参数，开启死区中断 */
    sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_ENABLE;                 /* OSSR设置为1 */
    sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;               /* OSSI设置为0 */
    sBreakDeadTimeConfig.LockLevel =  TIM_LOCKLEVEL_OFF;                    /* 上电只能写一次，需要更新死区时间时只能用此值 */
    sBreakDeadTimeConfig.DeadTime = 0X0F;                                   /* 死区时间 */
    sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;                    /* BKE = 0, 关闭BKIN检测 */
    sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_LOW;             /* BKP = 1, BKIN低电平有效 */
    sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;     /* 使能AOE位，允许刹车后自动恢复输出 */
    HAL_TIMEx_ConfigBreakDeadTime(&g_atimx_cplm_pwm_handle, &sBreakDeadTimeConfig);         /* 设置BDTR寄存器 */

}

atim_timx_cplm_pwm_init(8400 - 1, 0);    /* 168 000 000 / 1 = 168 000 000 168Mhz的计数频率，计数8400次为50us */

初始化主要分为三部分：

1、HAL_TIM_PWM_Init 函数初始化定时器参数，内部会调用HAL_TIM_PWM_MspInit 函数完成引脚配置。

2、HAL_TIM_PWM_ConfigChannel 函数定义定时器PWM1模式。

3、 HAL_TIMEx_ConfigBreakDeadTime 函数来设置死区参数。该实验没用到。

当PWM1递增模式，OCPolarity为低电平，OCNPolarity为低电平，8400的重装载值，比较值为1680。不开主通道，互补通道0.2低，0.8高。主通道高电平。

当PWM1递增模式，OCPolarity为低电平，OCNPolarity为低电平，8400的重装载值，比较值为1680。不开互补通道，主通道0.2低，0.8高。互补通道高电平。

不管上面哪种情况，调大占空比，低电平变宽，转速变快。

电机基础驱动API

电机开启：SD引脚拉高。

电机停止：关闭主通道和互补通道输出，SD引脚拉低。

HAL_TIM_PWM_Stop(&g_atimx_cplm_pwm_handle, TIM_CHANNEL_1);          /* 关闭主通道输出 */
HAL_TIMEx_PWMN_Stop(&g_atimx_cplm_pwm_handle, TIM_CHANNEL_1);       /* 关闭互补通道输出 */

电机旋转方向设置：

关闭主通道和互补通道输出，参数0开启主通道输出。

关闭主通道和互补通道输出，参数1开启互补通道输出。
HAL_TIM_PWM_Start(&g_atimx_cplm_pwm_handle, TIM_CHANNEL_1);     /* 开启主通道输出 */
HAL_TIMEx_PWMN_Start(&g_atimx_cplm_pwm_handle, TIM_CHANNEL_1);  /* 开启互补通道输出 */

电机速度控制：先判断参数是否小于重装载值，符合则设置参数为比较值。
if (para < (__HAL_TIM_GetAutoreload(&g_atimx_cplm_pwm_handle) - 0x0F))  /* 限速 */
{  
    __HAL_TIM_SetCompare(&g_atimx_cplm_pwm_handle, TIM_CHANNEL_1, para);
}
调大比较值，转速就加快。

电机控制：电机旋转方向设置+电机速度控制。motor_pwm_set(float para)。para可正可负。

电压、电流、温度检测实验

电压采集电路：

由于直流有刷电机驱动板的电源电压远超STM32内部ADC所能采集的范围，并不能直接使用ADC进行电压采集，因此需要使用一些硬件电路对电源电压进行处理，使其减小到ADC采集范围。

电流采集电路：

由于STM32内部ADC并不能对电流进行采集，所以需要先把电流的信号转换为电压的信号。

在H桥中加入了一个20mR（0.02R）的采样电阻，这样子就可以得到一个采样电压I-V = 0.02R * 实际电流I。

但是这个采样电压太小了，直接用ADC进行采集的话偏差较大，所以需要对它进行差分放大。

温度采集电路：

利用NCP18XH103F03RB热敏电阻对温度进行检测，该热敏电阻是负温度系数电阻，温度越高，其电阻值越低。

硬件资源：

ADC1_CH0 ADC1_CH8 ADC1_CH9
PA0 PB0 PB1
温度检测引脚电流检测引脚电压检测引脚

初始化工作

初始化工作为ADC+DMA的初始化。转换顺序为电压-温度-电流。

#define ADC_ADCX_CH0                        ADC_CHANNEL_9                                       /* 电压测量通道 */ 
#define ADC_ADCX_CH1                        ADC_CHANNEL_0                                       /* 温度测量通道 */ 
#define ADC_ADCX_CH2                        ADC_CHANNEL_8                                       /* 电流测量通道 */ 

/**
 * @brief       ADC初始化函数
 * @param       无
 * @retval      无
 */
void adc_init(void)
{
    ADC_ChannelConfTypeDef sConfig = {0};

    g_adc_nch_dma_handle.Instance = ADC1;                                           /* ADCx */
    g_adc_nch_dma_handle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;            /* 4分频，ADCCLK = PCLK2/4 = 84/4 = 21Mhz */
    g_adc_nch_dma_handle.Init.Resolution = ADC_RESOLUTION_12B;                      /* 12位模式 */
    g_adc_nch_dma_handle.Init.ScanConvMode = ENABLE;                                /* 扫描模式 多通道使用 */
    g_adc_nch_dma_handle.Init.ContinuousConvMode = ENABLE;                          /* 连续转换模式，转换完成之后接着继续转换 */
    g_adc_nch_dma_handle.Init.DiscontinuousConvMode = DISABLE;                      /* 禁止不连续采样模式 */
    g_adc_nch_dma_handle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* 使用软件触发 */
    g_adc_nch_dma_handle.Init.ExternalTrigConv = ADC_SOFTWARE_START;                /* 软件触发 */
    g_adc_nch_dma_handle.Init.DataAlign = ADC_DATAALIGN_RIGHT;                      /* 右对齐 */
    g_adc_nch_dma_handle.Init.NbrOfConversion = ADC_CH_NUM;                         /* 使用转换通道数，需根据实际转换通道去设置 */
    g_adc_nch_dma_handle.Init.DMAContinuousRequests = ENABLE;                       /* 开启DMA连续转换请求 */
    g_adc_nch_dma_handle.Init.EOCSelection = ADC_EOC_SEQ_CONV;
    HAL_ADC_Init(&g_adc_nch_dma_handle);

    /* 配置使用的ADC通道，采样序列里的第几个转换，增加或者减少通道需要修改这部分 */
    sConfig.Channel = ADC_ADCX_CH0;
    sConfig.Rank = 1;
    sConfig.SamplingTime = ADC_SAMPLETIME_480CYCLES;
    HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);

    sConfig.Channel = ADC_ADCX_CH1;
    sConfig.Rank = 2;
    HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);

    sConfig.Channel = ADC_ADCX_CH2;
    sConfig.Rank = 3;
    HAL_ADC_ConfigChannel(&g_adc_nch_dma_handle, &sConfig);
    
}

#define ADC_CH_NUM                          3                                             /* 需要转换的通道数目 */
#define ADC_COLL                            1000                                          /* 单采集次数 */
#define ADC_SUM                             ADC_CH_NUM * ADC_COLL                         /* 总采集次数 */

uint16_t g_adc_value[ADC_SUM] = {0};                                                      /* 存储ADC原始值 */
uint16_t g_adc_val[ADC_CH_NUM];                                                           /* ADC平均值存放数组 */
HAL_ADC_Start_DMA(&g_adc_nch_dma_handle, (uint32_t *)g_adc_value, ADC_SUM);               /* 开启ADC的DMA传输 */

/**
 * @brief       ADC 采集中断服务回调函数
 * @param       无 
 * @retval      无
 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
    if (hadc->Instance == ADC_ADCX)
    {
        HAL_ADC_Stop_DMA(&g_adc_nch_dma_handle);  /* 关闭DMA转换 */
        calc_adc_val(g_adc_val);                  /* 计算ADC的平均值 */
        HAL_ADC_Start_DMA(&g_adc_nch_dma_handle, (uint32_t *)&g_adc_value, (uint32_t)(ADC_SUM)); /* 启动DMA转换 */
    }
}

/**
 * @brief       计算ADC的平均值（滤波）
 * @param       * p ：存放ADC值的指针地址
 * @note        此函数对电压、温度、电流对应的ADC值进行滤波，
 *              p[0]-p[2]对应的分别是电压、温度和电流
 * @retval      无
 */
void calc_adc_val(uint16_t * p)
{
    uint32_t temp[3] = {0,0,0};
    int i;
	
    for(i=0; i<ADC_COLL; i++)         /* 循环ADC_COLL次取值，累加 */
    {
        temp[0] += g_adc_value[0 + i * ADC_CH_NUM];
        temp[1] += g_adc_value[1 + i * ADC_CH_NUM];
        temp[2] += g_adc_value[2 + i * ADC_CH_NUM];
    }
	
    temp[0] /= ADC_COLL;            /* 取平均值 */
    temp[1] /= ADC_COLL;
    temp[2] /= ADC_COLL;
	
    p[0] = temp[0];                 /* 存入电压ADC通道平均值 */
    p[1] = temp[1];                 /* 存入温度ADC通道平均值 */
    p[2] = temp[2];                 /* 存入电流ADC通道平均值 */
}

初始化工作主要分为四部分：

1、开时钟，引脚初始化。

2、HAL_ADC_Init函数初始化ADC基础参数，HAL_ADC_ConfigChannel函数配置ADC使用通道。

3、HAL_DMA_Init函数初始化DMA通道，__HAL_LINKDMA函数关联ADC和DMA。

4、开启DMA中断，HAL_ADC_Start_DMA函数开启ADC的DMA传输。

ADC转换完成中断中，先关闭DMA传输，然后进行ADC值取平均，再开始DMA传输。calc_adc_val函数就是取g_adc_value的平均值，然后存入g_adc_val。

采集工作

电压采集：

/* 电压计算公式：
 * V_POWER = V_BUS * 25
 * ADC值转换为电压值：电压=ADC值*3.3/4096
 * 整合公式可以得出电压V_POWER= ADC值 *（3.3f * 25 / 4096）
 */
#define ADC2VBUS    (float)(3.3f * 25 / 4096)
printf("Valtage:%.1fV \r\n",    g_adc_val[0]*ADC2VBUS);                   /* 打印电压值*/

温度采集：

/*
    Rt = Rp *exp(B*(1/T1-1/T2))

    Rt 是热敏电阻在T1温度下的阻值；
    Rp是热敏电阻在T2常温下的标称阻值；
    exp是e的n次方，e是自然常数，就是自然对数的底数，近似等于 2.7182818；
    B值是热敏电阻的重要参数，教程中用到的热敏电阻B值为3380；
    这里T1和T2指的是开尔文温度，T2是常温25℃，即(273.15+25)K
    T1就是所求的温度
*/

const float Rp = 10000.0f;          /* 10K */
const float T2 = (273.15f + 25.0f); /* T2 */
const float Bx = 3380.0f;           /* B */
const float Ka = 273.15f;

/**
 * @brief       计算温度值
 * @param       para: 温度采集对应ADC通道的值（已滤波）
 * @note        计算温度分为两步：
                1.根据ADC采集到的值计算当前对应的Rt
                2.根据Rt计算对应的温度值
 * @retval      温度值
 */
float get_temp(uint16_t para)
{
    float Rt;
    float temp;
    
    /* 
        第一步：
        Rt = 3.3 * 4700 / VTEMP - 4700 ,其中VTEMP就是温度检测通道采集回来的电压值,VTEMP = ADC值* 3.3/4096
        由此我们可以计算出当前Rt的值：Rt = 3.3f * 4700.0f / (para * 3.3f / 4096.0f ) - 4700.0f; 
    */
    
    Rt = 3.3f * 4700.0f / (para * 3.3f / 4096.0f ) - 4700.0f;       /* 根据当前ADC值计算出Rt的值 */

    /* 
        第二步：
        根据当前Rt的值来计算对应温度值：Rt = Rp *exp(B*(1/T1-1/T2)) 
    */
    
    temp = Rt / Rp;                 /* 解出exp(B*(1/T1-1/T2)) ，即temp = exp(B*(1/T1-1/T2)) */
    temp = log(temp);               /* 解出B*(1/T1-1/T2) ，即temp = B*(1/T1-1/T2) */
    temp /= Bx;                     /* 解出1/T1-1/T2 ，即temp = 1/T1-1/T2 */
    temp += (1.0f / T2);            /* 解出1/T1 ，即temp = 1/T1 */
    temp = 1.0f / (temp);           /* 解出T1 ，即temp = T1 */
    temp -= Ka;                     /* 计算T1对应的摄氏度 */
    return temp;                    /* 返回温度值 */
}
printf("Temp:%.1fC \r\n",       get_temp(g_adc_val[1]));                  /* 打印温度值*/

电流采集：

/* 电流计算公式：
 * I=（最终输出电压-初始参考电压）/（6*0.02）A
 * ADC值转换为电压值：电压=ADC值*3.3/4096，这里电压单位为V，我们换算成mV,4096/1000=4.096，后面就直接算出为mA
 * 整合公式可以得出电流 I= （当前ADC值-初始参考ADC值）* （3.3 / 4.096 / 0.12）
 */
#define ADC2CURT    (float)(3.3f / 4.096f / 0.12f)

uint16_t init_adc_val;

/* init_adc_val存储电流测量对应的参考电压ADC值，这里进行滤波 */
init_adc_val = g_adc_val[2];            /* 取出第一次得到的值 */
for(t=0;t<1000;t++)
{
    init_adc_val += g_adc_val[2];       /* 现在的值和上一次存储的值相加 */
    init_adc_val /= 2;                  /* 取平均值 */
    delay_ms(1);
}

printf("Current:%.1fmA \r\n",   abs(g_adc_val[2]-init_adc_val)*ADC2CURT); /* 打印电流值*/

编码器测速实验

正点原子的直流有刷电机编码器使用的是磁电增量式编码器，安装在直流有刷电机的尾部，分辨率是11线。

正点原子的直流有刷电机编码器有A、B两相，它们会输出两个相位差为90°的脉冲。当电机正转时，A相脉冲在前；当电机反转时，B相脉冲在前。

STM32定时器的编码器接口模式相当于带有方向选择的外部时钟。在此模式下，外部输入的脉冲信号可以作为计数器的时钟，而计数的方向则是由脉冲相位的先后所决定。

A、B两相脉冲信号从TIMx_CH1和TIMx_CH2这两个通道输入，经过滤波器和边沿检测器（可以设置滤波和反相）的处理，进入到编码器接口控制器中。

Tips：TIMx_CH1和TIMx_CH2这两个通道才支持编码器功能，TIMx_CH3和TIMx_CH4这两个通道不支持。

硬件资源：

TIM3_CH1 TIM3_CH2 TIM6
PC6 PC7 中断计算速度
TIM3编码器A相输入通道 TIM3编码器B相输入通道

编码器接口计数原理

编码器接口可以利用输入脉冲的边沿进行计数，通过计数值的变化量可以算出输入脉冲信号的变化量，也就可以计算出电机的转速。

TIMx从模式控制寄存器（TIMx_SMCR）的0~2位：SMS[2：0]为从模式选择，控制边沿检测的方式。

选择外部信号时，触发信号（TRGI）的有效边沿与外部输入上所选的极性相关。

001：编码器模式1-计数器根据TI1FP1电平在TI2FP2边沿递增/递减计数。

010：编码器模式2-计数器根据TI2FP2电平在TI1FP1边沿递增/递减计数。

011：编码器模式3-计数器根据TI1FP1和TI2FP2的边沿计数，计数的方向取决于另外一个信号的电平。

Tips：

选择仅在TI1或TI2处计数，就相当于对脉冲信号进行了2倍频（上身沿和下降沿），如果编码器输出11个脉冲信号，那么就会计数22次。

选择在TI1和TI2处均计数，就相当于对脉冲信号进行了4倍频（上身沿和下降沿），如果编码器输出11个脉冲信号，那么就会计数44次。

因此可以我们通过计数次数来计算电机速度时，需要除以相应的倍频系数。至此，A、B两相脉冲信号的变化就转换成了定时器的计数变化。

可以通过一分钟内计数的变化量来计算电机速度：

电机转速 = 一分钟内计数的变化量 / 倍频系数 / 编码器线数 / 减速比

编码器模式1：仅在TI1处计数--计数器根据TI1FP1电平在TI2FP2边沿递增/递减计数。

假设把A相接在CH1（TI1），B相接在CH2（TI2），选择仅在TI1处计数（仅检测A相边沿）。脉冲信号会有两种，当编码器正转时A相在前、当编码器反转时B相在前。

正转：当A相上身沿时，B相低电平，表格中对应的是递增计数。当A相下降沿时，B相高电平，表格中对应的是递增计数。即编码器正转对应的计数方向是递增计数。

反转：当A相上身沿时，B相高电平，表格中对应的是递减计数。当A相下降沿时，B相低电平，表格中对应的是递减计数。即编码器反转对应的计数方向是递减计数。

编码器模式2：仅在TI2处计数--计数器根据TI2FP2电平在TI1FP1边沿递增/递减计数。

假设把A相接在CH1（TI1），B相接在CH2（TI2），选择仅在TI2处计数（仅检测B相边沿）。脉冲信号会有两种，当编码器正转时A相在前、当编码器反转时B相在前。

正转：当B相上身沿时，A相高电平，表格中对应的是递增计数。当B相下降沿时，A相低电平，表格中对应的是递增计数。即编码器正转对应的计数方向是递增计数。

反转：当B相上身沿时，A相低电平，表格中对应的是递减计数。当B相下降沿时，A相高电平，表格中对应的是递减计数。即编码器反转对应的计数方向是递减计数。

编码器模式3：在TI1和TI2处均计数--计数器根据TI1FP1和TI2FP2的边沿计数，计数的方向取决于另外一个信号的电平。

假设把A相接在CH1（TI1），B相接在CH2（TI2），选择仅在TI2处计数（仅检测B相边沿）。脉冲信号会有两种，当编码器正转时A相在前、当编码器反转时B相在前。

正转：当A相上身沿时，B相低电平，表格中对应的是递增计数。当B相上身沿时，A相高电平，表格中对应的是递增计数。当A相下降沿时，B相高电平，表格中对应的是递增计数。当B相下降沿时，A相低电平，表格中对应的是递增计数。即编码器正转对应的计数方向是递增计数。

反转：当B相上身沿时，A相低电平，表格中对应的是递减计数。当A相上身沿时，B相高电平，表格中对应的是递减计数。当B相下降沿时，A相高电平，表格中对应的是递减计数。当A相下降沿时，B相低电平，表格中对应的是递减计数。即编码器反转对应的计数方向是递减计数。

计数溢出处理：

编码器在电机运行时会一直旋转并输出脉冲信号，如果时间较长，那么定时器计数就会溢出，我们必须对溢出进行处理，否则电机速度的计算结果就不准了。

当前总计数值 = 计数器当前值 + 溢出次数（可在溢出中断中记录） * 65536。

溢出时读取TIMx控制寄存器1（TIMx_CR1）的位4（DIR，计数方向），以计算总的计数次数变化量。

0：计数器递增计数

1：计数器递减计数

作用：在计数溢出时，读取到溢出方向，后续才能计算总的计数变化量。

相关寄存器：

TIMx_CR1：CEN为计数器使能。

TIMx_CR1：DIR为计数方向。

TIMx_CCMR1（TIMx_CCMR1对应通道1、2，TIMx_CCMR2对应通道3、4）：CC1S选择IC1映射再TI1上。

TIMx_CCMR1（TIMx_CCMR1对应通道1、2，TIMx_CCMR2对应通道3、4）：IC1PSC选择00。一次边沿就触发一次计数。

TIMx_CCMR1（TIMx_CCMR1对应通道1、2，TIMx_CCMR2对应通道3、4）：IC1F用来设置TI1输入采样频率和数据滤波器长度。其中，Fck_int是定时器时钟源频率，按照例程为84MHz，而Fdts是根据TIMx_CR1：CKD来确定的。如果TIMx_CR1：CKD设置为00，则Fdts = Fck_int。N值为采样次数。举例：假设IC1F为0011，并设置IC1映射到TI1上，则表示以Fck_int为采样频率，当连续8次都是采样到TI1为高电平或低电平，滤波器才输出一个有效输出边沿。当8次采样中有高有低，则保持原来的输出，这样就可以滤除高频干扰信号，从而达到滤波的效果。

TIMx_CCER控制各输入输出通道的开关和极性。要使能编码器接口模式，必须设置CC1E和CC22为1，而CC1P和CC2P设置的是边沿触发的方向。

TIMx_SMCR：SMS用于从模式选择，其实就是选择计数器输入时钟的来源。

初始化工作

/********************************* 1 通用定时器 编码器程序 *************************************/

TIM_HandleTypeDef g_timx_encode_chy_handle;         /* 定时器x句柄 */
TIM_Encoder_InitTypeDef g_timx_encoder_chy_handle;  /* 定时器编码器句柄 */

/**
 * @brief       通用定时器TIMX 通道Y 编码器接口模式 初始化函数
 * @note
 *              通用定时器的时钟来自APB1,当PPRE1 ≥ 2分频的时候
 *              通用定时器的时钟为APB1时钟的2倍, 而APB1为42M, 所以定时器时钟 = 84Mhz
 *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
 *              Ft=定时器工作频率,单位:Mhz
 *
 * @param       arr: 自动重装值。
 * @param       psc: 时钟预分频数
 * @retval      无
 */
void gtim_timx_encoder_chy_init(uint16_t arr, uint16_t psc)
{
    /* 定时器x配置 */
    g_timx_encode_chy_handle.Instance = GTIM_TIMX_ENCODER;                      /* 定时器x */
    g_timx_encode_chy_handle.Init.Prescaler = psc;                              /* 定时器分频 */
    g_timx_encode_chy_handle.Init.Period = arr;                                 /* 自动重装载值 */
    g_timx_encode_chy_handle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;       /* 时钟分频因子 */
    
    /* 定时器x编码器配置 */
    g_timx_encoder_chy_handle.EncoderMode = TIM_ENCODERMODE_TI12;               /* TI1、TI2都检测，4倍频 */
    g_timx_encoder_chy_handle.IC1Polarity = TIM_ICPOLARITY_RISING;              /* 输入极性，非反向 */
    g_timx_encoder_chy_handle.IC1Selection = TIM_ICSELECTION_DIRECTTI;          /* 输入通道选择 */
    g_timx_encoder_chy_handle.IC1Prescaler = TIM_ICPSC_DIV1;                    /* 不分频 */
    g_timx_encoder_chy_handle.IC1Filter = 10;                                   /* 滤波器设置 */
    g_timx_encoder_chy_handle.IC2Polarity = TIM_ICPOLARITY_RISING;              /* 输入极性，非反向 */
    g_timx_encoder_chy_handle.IC2Selection = TIM_ICSELECTION_DIRECTTI;          /* 输入通道选择 */
    g_timx_encoder_chy_handle.IC2Prescaler = TIM_ICPSC_DIV1;                    /* 不分频 */
    g_timx_encoder_chy_handle.IC2Filter = 10;                                   /* 滤波器设置 */
    HAL_TIM_Encoder_Init(&g_timx_encode_chy_handle, &g_timx_encoder_chy_handle);/* 初始化定时器x编码器 */
     
    HAL_TIM_Encoder_Start(&g_timx_encode_chy_handle,GTIM_TIMX_ENCODER_CH1);     /* 使能编码器通道1 */
    HAL_TIM_Encoder_Start(&g_timx_encode_chy_handle,GTIM_TIMX_ENCODER_CH2);     /* 使能编码器通道2 */
    __HAL_TIM_ENABLE_IT(&g_timx_encode_chy_handle,TIM_IT_UPDATE);               /* 使能更新中断 */
    __HAL_TIM_CLEAR_FLAG(&g_timx_encode_chy_handle,TIM_IT_UPDATE);              /* 清除更新中断标志位 */
    
}

/******************************** 2 基本定时器 编码器程序 ************************************/

TIM_HandleTypeDef timx_handler;         /* 定时器参数句柄 */

/**
 * @brief       基本定时器TIMX定时中断初始化函数
 * @note
 *              基本定时器的时钟来自APB1,当PPRE1 ≥ 2分频的时候
 *              基本定时器的时钟为APB1时钟的2倍, 而APB1为42M, 所以定时器时钟 = 84Mhz
 *              定时器溢出时间计算方法: Tout = ((arr + 1) * (psc + 1)) / Ft us.
 *              Ft=定时器工作频率,单位:Mhz
 *
 * @param       arr: 自动重装值。
 * @param       psc: 时钟预分频数
 * @retval      无
 */
void btim_timx_int_init(uint16_t arr, uint16_t psc)
{
    timx_handler.Instance = BTIM_TIMX_INT;                              /* 基本定时器X */
    timx_handler.Init.Prescaler = psc;                                  /* 设置预分频器  */
    timx_handler.Init.CounterMode = TIM_COUNTERMODE_UP;                 /* 向上计数器 */
    timx_handler.Init.Period = arr;                                     /* 自动装载值 */
    timx_handler.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;           /* 时钟分频因子 */
    HAL_TIM_Base_Init(&timx_handler);
    
    HAL_TIM_Base_Start_IT(&timx_handler);                               /* 使能基本定时器x和及其更新中断：TIM_IT_UPDATE */
    __HAL_TIM_CLEAR_IT(&timx_handler,TIM_IT_UPDATE);                    /* 清除更新中断标志位 */
}

gtim_timx_encoder_chy_init(0XFFFF, 0);  /* 编码器定时器初始化，不分频直接84M的计数频率 */
btim_timx_int_init(1000 - 1 , 84 - 1);  /* 基本定时器初始化，1ms计数周期 */

初始化主要分为三部分：

1、HAL_TIM_Encoder_Init函数初始化编码器参数，内部会调用HAL_TIM_Encoder_MspInit函数完成引脚配置并开启中断。

2、HAL_TIM_Encoder_Start函数使能编码器通道。

3、__HAL_TIM_ENABLE_IT函数带进参数TIM_IT_UPDATE使能更新中断。

4、__HAL_TIM_CLEAR_FLAG函数带进参数TIM_IT_UPDATE清除更新中断标志位。

5、HAL_TIM_Base_Init函数初始化基本定时器，内部会调用HAL_TIM_Base_MspInit函数完成引脚配置并开启中断。

6、HAL_TIM_Base_Start_IT函数使能基本定时器中断。

7、__HAL_TIM_CLEAR_IT函数带进参数TIM_IT_UPDATE清除更新中断标志位。

编码器测速工作

在定时器中断中进行这样的处理：

volatile int g_timx_encode_count = 0;                                   /* 溢出次数 */

/**
 * @brief       获取编码器的值
 * @param       无
 * @retval      编码器值
 */
int gtim_get_encode(void)
{
    return ( int32_t )__HAL_TIM_GET_COUNTER(&g_timx_encode_chy_handle) + g_timx_encode_count * 65536;       /* 当前计数值+之前累计编码器的值=总的编码器值 */
}

/**
 * @brief       定时器更新中断回调函数
 * @param        htim:定时器句柄指针
 * @note        此函数会被定时器中断函数共同调用的
 * @retval      无
 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM3)
    {
        if(__HAL_TIM_IS_TIM_COUNTING_DOWN(&g_timx_encode_chy_handle))   /* 判断CR1的DIR位 */
        {
            g_timx_encode_count--;                                      /* DIR位为1，也就是递减计数 */
        }
        else
        {
            g_timx_encode_count++;                                      /* DIR位为0，也就是递增计数 */
        }
    }
    else if (htim->Instance == TIM6)
    {
        int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

        speed_computer(Encode_now, 50);                                 /* 中位平均值滤除编码器抖动数据，50ms计算一次速度*/
    }
}

在TIM3编码器模式下经过65536次计数后进入中断，中断中记录是此时是递减计数进入还是递增计数进入。（从0开始，递减的话一开始就会进入中断了，计数器变为65536开始递减）

在TIM6中1ms进入一次中断，中断记录编码器值（相当于总的计数值），然后进行电机速度计算（用到冒泡排序和一阶低通滤波算法）后传值给g_motor_data.speed，单位转/分（RPM）。

/*************************************    第三部分    编码器测速    ****************************************************/

#define ROTO_RATIO      44  /* 线数*倍频系数，即11*4=44 */
#define REDUCTION_RATIO 30  /* 减速比30:1 */

/* 电机参数结构体 */
typedef struct 
{
  uint8_t state;          /*电机状态*/
  float current;          /*电机电流*/
  float volatage;         /*电机电压*/
  float power;            /*电机功率*/
  float speed;            /*电机实际速度*/
  int32_t motor_pwm;      /*设置比较值大小 */
} Motor_TypeDef;

Motor_TypeDef g_motor_data;  /*电机参数变量*/
ENCODE_TypeDef g_encode;     /*编码器参数变量*/

/**
 * @brief       电机速度计算
 * @param       encode_now：当前编码器总的计数值
 *              ms：计算速度的间隔，中断1ms进入一次，例如ms = 5即5ms计算一次速度
 * @retval      无
 */
void speed_computer(int32_t encode_now, uint8_t ms)
{
    uint8_t i = 0, j = 0;
    float temp = 0.0;
    static uint8_t sp_count = 0, k = 0;
    static float speed_arr[10] = {0.0};                     /* 存储速度进行滤波运算 */

    if (sp_count == ms)                                     /* 计算一次速度 */
    {
        /* 计算电机转速 
           第一步 ：计算ms毫秒内计数变化量
           第二步 ；计算1min内计数变化量：g_encode.speed * ((1000 / ms) * 60 ，
           第三步 ：除以编码器旋转一圈的计数次数（倍频倍数 * 编码器分辨率）
           第四步 ：除以减速比即可得出电机转速
        */
        g_encode.encode_now = encode_now;                                /* 取出编码器当前计数值 */
        g_encode.speed = (g_encode.encode_now - g_encode.encode_old);    /* 计算编码器计数值的变化量 */
        
        speed_arr[k++] = (float)(g_encode.speed * ((1000 / ms) * 60.0) / REDUCTION_RATIO / ROTO_RATIO );    /* 保存电机转速 */
        
        g_encode.encode_old = g_encode.encode_now;          /* 保存当前编码器的值 */

        /* 累计10次速度值，后续进行滤波*/
        if (k == 10)
        {
            for (i = 10; i >= 1; i--)                       /* 冒泡排序*/
            {
                for (j = 0; j < (i - 1); j++) 
                {
                    if (speed_arr[j] > speed_arr[j + 1])    /* 数值比较 */
                    { 
                        temp = speed_arr[j];                /* 数值换位 */
                        speed_arr[j] = speed_arr[j + 1];
                        speed_arr[j + 1] = temp;
                    }
                }
            }
            
            temp = 0.0;
            
            for (i = 2; i < 8; i++)                         /* 去除两边高低数据 */
            {
                temp += speed_arr[i];                       /* 将中间数值累加 */
            }
            
            temp = (float)(temp / 6);                       /*求速度平均值*/
            
            /* 一阶低通滤波
             * 公式为：Y(n)= qX(n) + (1-q)Y(n-1)
             * 其中X(n)为本次采样值；Y(n-1)为上次滤波输出值；Y(n)为本次滤波输出值，q为滤波系数
             * q值越小则上一次输出对本次输出影响越大，整体曲线越平稳，但是对于速度变化的响应也会越慢
             */
            g_motor_data.speed = (float)( ((float)0.48 * temp) + (g_motor_data.speed * (float)0.52) );
            k = 0;
        }
        sp_count = 0;
    }
    sp_count ++;
}

速度环控制实现

PID相关函数

#if INCR_LOCT_SELECT

/* 增量式PID参数相关宏 */
#define  KP      8.50f               /* P参数*/
#define  KI      5.00f               /* I参数*/
#define  KD      0.10f               /* D参数*/
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms*/

#else

/* 位置式PID参数相关宏 */
#define  KP      10.0f               /* P参数*/
#define  KI      6.00f               /* I参数*/
#define  KD      0.5f                /* D参数*/
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms*/

#endif

/* PID参数结构体 */
typedef struct
{
    __IO float  SetPoint;            /* 设定目标 */
    __IO float  ActualValue;         /* 期望输出值 */
    __IO float  SumError;            /* 误差累计 */
    __IO float  Proportion;          /* 比例常数 P */
    __IO float  Integral;            /* 积分常数 I */
    __IO float  Derivative;          /* 微分常数 D */
    __IO float  Error;               /* Error[1] */
    __IO float  LastError;           /* Error[-1] */
    __IO float  PrevError;           /* Error[-2] */
} PID_TypeDef;

PID_TypeDef  g_speed_pid;           /* 速度环PID参数结构体 */

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    g_speed_pid.SetPoint = 0;       /* 设定目标值 */
    g_speed_pid.ActualValue = 0.0;  /* 期望输出值 */
    g_speed_pid.SumError = 0.0;     /* 积分值 */
    g_speed_pid.Error = 0.0;        /* Error[1] */
    g_speed_pid.LastError = 0.0;    /* Error[-1] */
    g_speed_pid.PrevError = 0.0;    /* Error[-2] */
    g_speed_pid.Proportion = KP;    /* 比例常数 Proportional Const */
    g_speed_pid.Integral = KI;      /* 积分常数 Integral Const */
    g_speed_pid.Derivative = KD;    /* 微分常数 Derivative Const */ 
}

/**
 * @brief       pid闭环控制
 * @param       *PID：PID结构体变量地址
 * @param       Feedback_value：当前实际值
 * @retval      期望输出值
 */
int32_t increment_pid_ctrl(PID_TypeDef *PID, float Feedback_value)
{
    PID->Error = (float)(PID->SetPoint - Feedback_value);                   /* 计算偏差 */
    
#if  INCR_LOCT_SELECT                                                       /* 增量式PID */
    
    PID->ActualValue += (PID->Proportion * (PID->Error - PID->LastError))                          /* 比例环节 */
                        + (PID->Integral * PID->Error)                                             /* 积分环节 */
                        + (PID->Derivative * (PID->Error - 2 * PID->LastError + PID->PrevError));  /* 微分环节 */
    
    PID->PrevError = PID->LastError;                                        /* 存储偏差，用于下次计算 */
    PID->LastError = PID->Error;
    
#else                                                                       /* 位置式PID */
    
    PID->SumError += PID->Error;
    PID->ActualValue = (PID->Proportion * PID->Error)                       /* 比例环节 */
                       + (PID->Integral * PID->SumError)                    /* 积分环节 */
                       + (PID->Derivative * (PID->Error - PID->LastError)); /* 微分环节 */
    PID->LastError = PID->Error;
    
#endif
    return ((int32_t)(PID->ActualValue));                                   /* 返回计算后输出的数值 */
}

PID运算

主要体现在TIM6定时中断中用来编码器测速时。

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度*/
         
if (val % SMAPLSE_PID_SPEED == 0)                               /* 50ms进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了*/
    { 
        /* PID计算，输出比较值（占空比） */
        g_motor_data.motor_pwm = increment_pid_ctrl(&g_speed_pid, g_motor_data.speed);

        if (g_motor_data.motor_pwm >= 8200)                     /* 限速 */
        {
            g_motor_data.motor_pwm = 8200;
        }
        else if (g_motor_data.motor_pwm <= -8200)
        {
            g_motor_data.motor_pwm = -8200;
        }

        motor_pwm_set(g_motor_data.motor_pwm);                                  /* 设置电机转速 */
    }
    val = 0;
}
val ++;

电流环控制实现

PID相关函数

#define  INCR_LOCT_SELECT  0         /* 0：位置式，1：增量式 */

#if INCR_LOCT_SELECT

/* 增量式PID参数相关宏 */
#define  KP      0.0f                /* P参数*/
#define  KI      6.0f                /* I参数*/
#define  KD      4.0f                /* D参数*/
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms*/

#else

/* 位置式PID参数相关宏 */
#define  KP      10.0f               /* P参数*/
#define  KI      7.0f                /* I参数*/
#define  KD      2.0f                /* D参数*/
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms*/

#endif

/* PID参数结构体 */
typedef struct
{
    __IO float  SetPoint;            /* 设定目标 */
    __IO float  ActualValue;         /* 期望输出值 */
    __IO float  SumError;            /* 误差累计 */
    __IO float  Proportion;          /* 比例常数 P */
    __IO float  Integral;            /* 积分常数 I */
    __IO float  Derivative;          /* 微分常数 D */
    __IO float  Error;               /* Error[1] */
    __IO float  LastError;           /* Error[-1] */
    __IO float  PrevError;           /* Error[-2] */
} PID_TypeDef;

PID_TypeDef  g_current_pid;             /* 电流环PID参数结构体 */

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    g_current_pid.SetPoint = 40;        /* 设定目标值 */
    g_current_pid.ActualValue = 0.0;    /* 期望输出值 */
    g_current_pid.SumError = 0.0;       /* 积分值 */
    g_current_pid.Error = 0.0;          /* Error[1] */
    g_current_pid.LastError = 0.0;      /* Error[-1] */
    g_current_pid.PrevError = 0.0;      /* Error[-2] */
    g_current_pid.Proportion = KP;      /* 比例常数 Proportional Const */
    g_current_pid.Integral = KI;        /* 积分常数 Integral Const */
    g_current_pid.Derivative = KD;      /* 微分常数 Derivative Const */ 
}

PID运算

ADC中相对于电压、电流、温度检测实验，ADC转换完成中断回调函数处理增加了处理内容。

旧机制是求ADC通道的平均值g_adc_val[2]。

新机制：

1、求ADC通道的平均值g_adc_val[2]。

2、然后累加16次g_adc_val[2]后平均到add_adc。这个步骤不断重复，充当当前ADC值。

3、然后继续累加17次add_adc后平均到init_adc_value。这个步骤只可以满足一次，然后充当初始ADC值。

4、根据电流I = （当前ADC值 - 初始ADC值） * （3.3 / 4096 / 0.12 / 1000），即可求得temp_c，单位mA。

5、根据一阶低通滤波 (float)((g_motor_data.current * (float)0.60) + ((float)0.40 * temp_c))求得g_motor_data.current。

6、如果g_motor_data.current小于20mA，则过滤掉这微弱浮动电流。

uint16_t g_adc_val[ADC_CH_NUM];                     /*ADC平均值存放数组*/
/**
 * @brief       ADC采集中断回调函数
 * @param       无 
 * @retval      无
 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{

    float temp_c = 0.0;
    static float add_adc = 0;
    static float init_adc_value = 0;
    static uint8_t adc_count1 = 0, adc_count2 = 0;
    
    if ( hadc->Instance == ADC_ADCX )                               /* 判断是不是ADC1 */
    { 
        adc_count1++;
        HAL_ADC_Stop_DMA(&g_adc_nch_dma_handle);                    /* 关闭DMA转换 */
        
        calc_adc_val(g_adc_val);                                    /* 计算ADC的平均值 */
        add_adc += g_adc_val[2];                                    /* 取出电流通道对应的ADC值进行累计 */

        if (adc_count1 >= 15)                                       /* 累计15次 */
        {
            add_adc = (float)(add_adc / adc_count1);                /* 取平均值 */

            if (adc_count2 <= 16)                                   /* 采集16次ADC平均值计算参考电压的ADC值 */
            {
                adc_count2++;
                init_adc_value += add_adc;                          /* 对平均值累计求和 */

                if (adc_count2 == 16)                               /* 平均值累计16次 */
                { 
                    adc_count2 = 17;                                /* 不再进入 */
                    init_adc_value = (init_adc_value / 16.0f);      /* 存储初始ADC值 */
                }
            }
            if (adc_count2 >= 17)                                   /* 采集完参考ADC值后，采集电流通道当前ADC值 */
            {
                temp_c = (add_adc - init_adc_value) * ADC2CURT;                                                 /* 计算电流 */
                
                g_motor_data.current = (float)((g_motor_data.current * (float)0.60) + ((float)0.40 * temp_c));  /* 一阶低通滤波 */

                if (g_motor_data.current <= 20)                                                                 /* 过滤掉微弱浮动电流 */
                {
                    g_motor_data.current = 0.0;
                }
            }
            add_adc = 0;
            adc_count1 = 0;
        }
        HAL_ADC_Start_DMA(&g_adc_nch_dma_handle, (uint32_t *)&g_adc_value, (uint32_t)(ADC_SUM));                /* 启动DMA转换 */
    }
}

然后进行电流的PID运算。

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度 */
         
if (val % SMAPLSE_PID_SPEED == 0)                               /* 进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了 */
    { 
        /* PID计算，输出比较值（占空比），再进行一阶低通滤波 */
        motor_pwm_temp = increment_pid_ctrl(&g_current_pid, g_motor_data.current);
        g_motor_data.motor_pwm = (int32_t)((g_motor_data.motor_pwm * 0.5) + (motor_pwm_temp * 0.5));

        if (g_motor_data.motor_pwm >= 8200)                 /* 限制占空比 */
        {
            g_motor_data.motor_pwm = 8200;
        }
        else if (g_motor_data.motor_pwm <= 0)
        {
            g_motor_data.motor_pwm = 0;
        }

        motor_pwm_set(g_motor_data.motor_pwm);              /* 设置占空比（电机转速） */
    }
    val = 0;
}

val ++;

位置环控制实现

PID相关函数

/* 增量式PID参数相关宏 */
#define  KP      15.0f               /* P参数*/
#define  KI      0.00f               /* I参数*/
#define  KD      7.50f               /* D参数*/
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms */

/* PID参数结构体 */
typedef struct
{
    __IO float  SetPoint;            /* 设定目标 */
    __IO float  ActualValue;         /* 期望输出值 */
    __IO float  SumError;            /* 误差累计 */
    __IO float  Proportion;          /* 比例常数 P */
    __IO float  Integral;            /* 积分常数 I */
    __IO float  Derivative;          /* 微分常数 D */
    __IO float  Error;               /* Error[1] */
    __IO float  LastError;           /* Error[-1] */
    __IO float  PrevError;           /* Error[-2] */
} PID_TypeDef;

PID_TypeDef  g_location_pid;             /*位置环PID参数结构体*/

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    g_location_pid.SetPoint = 0.0;       /* 设定目标值 */
    g_location_pid.ActualValue = 0.0;    /* 期望输出值 */
    g_location_pid.SumError = 0.0;       /* 积分值 */
    g_location_pid.Error = 0.0;          /* Error[1] */
    g_location_pid.LastError = 0.0;      /* Error[-1] */
    g_location_pid.PrevError = 0.0;      /* Error[-2] */
    g_location_pid.Proportion = KP;      /* 比例常数 Proportional Const */
    g_location_pid.Integral = KI;        /* 积分常数 Integral Const */
    g_location_pid.Derivative = KD;      /* 微分常数 Derivative Const */ 
}

PID运算

ADC部分继续沿用电流环的采集方法。

使用g_motor_data.location存储编码器计数值，然后进行PID运算。

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度 */
         
g_motor_data.location = Encode_now;                             /* 获取当前计数总值，用于位置闭环控制 */
         
if (val % SMAPLSE_PID_SPEED == 0)                               /* 进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了 */
    { 
        /* PID计算，输出比较值（占空比），再进行一阶低通滤波 */
        motor_pwm_temp = increment_pid_ctrl(&g_location_pid, g_motor_data.location);
        g_motor_data.motor_pwm = (int32_t)((g_motor_data.motor_pwm * 0.5) + (motor_pwm_temp * 0.5));

        if (g_motor_data.motor_pwm >= 4200)                     /* 限制占空比 */
        {
            g_motor_data.motor_pwm = 4200;
        }
        else if (g_motor_data.motor_pwm <= -4200)
        {
            g_motor_data.motor_pwm = -4200;
        }

        motor_pwm_set(g_motor_data.motor_pwm);                  /* 设置占空比（电机转速）*/
    }
    val = 0;
}
val ++;

速度+位置双环控制实现

双环控制中，外环控制的是优先考虑对象，内环用于对控制效果进行优化。

Tips：双环控制时，外环PID参数调节幅度不能太大，这对于整个曲线的影响很大。

PID相关函数

/* 定义位置环（外环）PID参数相关宏 */
#define  L_KP      0.18f                 /* P参数 */
#define  L_KI      0.00f                 /* I参数 */
#define  L_KD      0.08f                 /* D参数 */

/* 定义速度环（内环）PID参数相关宏 */
#define  S_KP      20.0f                 /* P参数 */
#define  S_KI      10.00f                /* I参数 */
#define  S_KD      0.02f                 /* D参数 */

PID_TypeDef  g_location_pid;             /* 位置环PID参数结构体 */
PID_TypeDef  g_speed_pid;                /* 速度环PID参数结构体 */

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    /* 初始化位置环PID参数 */
    g_location_pid.SetPoint = 0.0;       /* 目标值 */
    g_location_pid.ActualValue = 0.0;    /* 期望输出值 */
    g_location_pid.SumError = 0.0;       /* 积分值 */
    g_location_pid.Error = 0.0;          /* Error[1] */
    g_location_pid.LastError = 0.0;      /* Error[-1] */
    g_location_pid.PrevError = 0.0;      /* Error[-2] */
    g_location_pid.Proportion = L_KP;    /* 比例常数 Proportional Const */
    g_location_pid.Integral = L_KI;      /* 积分常数 Integral Const */
    g_location_pid.Derivative = L_KD;    /* 微分常数 Derivative Const */ 
    
    /* 初始化速度环PID参数 */
    g_speed_pid.SetPoint = 0.0;          /* 目标值 */
    g_speed_pid.ActualValue = 0.0;       /* 期望输出值 */
    g_speed_pid.SumError = 0.0;          /* 积分值 */
    g_speed_pid.Error = 0.0;             /* Error[1] */
    g_speed_pid.LastError = 0.0;         /* Error[-1] */
    g_speed_pid.PrevError = 0.0;         /* Error[-2] */
    g_speed_pid.Proportion = S_KP;       /* 比例常数 Proportional Const */
    g_speed_pid.Integral = S_KI;         /* 积分常数 Integral Const */
    g_speed_pid.Derivative = S_KD;       /* 微分常数 Derivative Const */ 
    
}

PID运算

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度 */

if (val % SMAPLSE_PID_SPEED == 0)                               /* 进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了 */
    { 
        g_motor_data.location = (float)Encode_now;              /* 获取当前编码器总计数值，用于位置闭环控制 */

        g_motor_data.motor_pwm = increment_pid_ctrl(&g_location_pid, g_motor_data.location);    /* 位置环PID控制（外环） */
                
        if (g_motor_data.motor_pwm >= 150)                      /* 限制外环输出（目标速度） */
        {
            g_motor_data.motor_pwm = 150;
        }
        else if (g_motor_data.motor_pwm <= -150)
        {
            g_motor_data.motor_pwm = -150;
        }
                
        g_speed_pid.SetPoint = g_motor_data.motor_pwm;          /* 设置目标速度，外环输出作为内环输入 */
                
        g_motor_data.motor_pwm = increment_pid_ctrl(&g_speed_pid, g_motor_data.speed);          /* 速度环PID控制（内环） */
                
        if (g_motor_data.motor_pwm >= 8200)                     /* 限制占空比 */
        {
            g_motor_data.motor_pwm = 8200;
        }
        else if (g_motor_data.motor_pwm <= -8200)
        {
            g_motor_data.motor_pwm = -8200;
        }

        motor_pwm_set(g_motor_data.motor_pwm);                  /* 设置占空比（电机转速） */
        }
    val = 0;
}
val ++;

电流+位置双环控制实现

双环控制中，外环控制的是优先考虑对象，内环用于对控制效果进行优化。

Tips：双环控制时，外环PID参数调节幅度不能太大，这对于整个曲线的影响很大。

PID相关函数

#define  INCR_LOCT_SELECT  0         /* 0：位置式，1：增量式 */

/* 注意：双环控制的时候，外环PID参数调节幅度不要太大，这对于整个曲线的影响很大 */

#if INCR_LOCT_SELECT

/* 定义位置环PID参数相关宏 */
#define  L_KP      0.18f             /* P参数 */
#define  L_KI      0.00f             /* I参数 */
#define  L_KD      0.08f             /* D参数 */

/* 定义电流环PID参数相关宏 */
#define  C_KP      10.00f            /* P参数 */
#define  C_KI      9.00f             /* I参数 */
#define  C_KD      0.00f             /* D参数 */
#define SMAPLSE_PID_SPEED  50        /* 采样周期 单位ms */

#else

/* 定义位置环PID参数相关宏 */
#define  L_KP      0.18f             /* P参数 */
#define  L_KI      0.00f             /* I参数 */
#define  L_KD      0.08f             /* D参数 */

/* 定义电流环PID参数相关宏 */
#define  C_KP      10.00f            /* P参数 */
#define  C_KI      7.00f             /* I参数 */
#define  C_KD      0.00f             /* D参数 */
#define SMAPLSE_PID_SPEED  50        /* 采样周期 单位ms */

#endif

PID_TypeDef  g_location_pid;             /* 位置环PID参数结构体 */
PID_TypeDef  g_current_pid;              /* 电流环PID参数结构体 */

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    /* 初始化位置环PID参数 */
    g_location_pid.SetPoint = 0.0;       /* 目标值 */
    g_location_pid.ActualValue = 0.0;    /* 期望输出值 */
    g_location_pid.SumError = 0.0;       /* 积分值 */
    g_location_pid.Error = 0.0;          /* Error[1] */
    g_location_pid.LastError = 0.0;      /* Error[-1] */
    g_location_pid.PrevError = 0.0;      /* Error[-2] */
    g_location_pid.Proportion = L_KP;    /* 比例常数 Proportional Const */
    g_location_pid.Integral = L_KI;      /* 积分常数 Integral Const */
    g_location_pid.Derivative = L_KD;    /* 微分常数 Derivative Const */ 
    
    /* 初始化电流环PID参数 */
    g_current_pid.SetPoint = 0.0;        /* 目标值 */
    g_current_pid.ActualValue = 0.0;     /* 期望输出值 */
    g_current_pid.SumError = 0.0;        /* 积分值*/
    g_current_pid.Error = 0.0;           /* Error[1]*/
    g_current_pid.LastError = 0.0;       /* Error[-1]*/
    g_current_pid.PrevError = 0.0;       /* Error[-2]*/
    g_current_pid.Proportion = C_KP;     /* 比例常数 Proportional Const */
    g_current_pid.Integral = C_KI;       /* 积分常数 Integral Const */
    g_current_pid.Derivative = C_KD;     /* 微分常数 Derivative Const */
}

PID运算

电流在内环，不能有负数。需对传入的位置环做处理。

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度 */
         
if (val % SMAPLSE_PID_SPEED == 0)                               /* 进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了 */
    { 
        g_motor_data.location = (float)Encode_now;              /* 获取当前编码器总计数值，用于位置闭环控制 */

        g_motor_data.motor_pwm = increment_pid_ctrl(&g_location_pid, g_motor_data.location);    /* 位置环PID控制（外环） */
                
        if ( g_motor_data.motor_pwm > 0)                        /* 判断位置环输出值是否为正数 */
        {
            dcmotor_dir(0);                                     /* 输出为正数，设置电机正转 */
        }
        else
        {
            g_motor_data.motor_pwm = -g_motor_data.motor_pwm;   /* 输出为负数，取反 */
            dcmotor_dir(1);                                     /* 设置电机反转 */
        }
                    
        if (g_motor_data.motor_pwm >= 120)                      /* 限制外环输出（目标电流） */
        {
            g_motor_data.motor_pwm = 120;
        }
        g_current_pid.SetPoint = g_motor_data.motor_pwm;        /* 设置目标电流，外环输出作为内环输入 */

        g_motor_data.motor_pwm = increment_pid_ctrl(&g_current_pid, g_motor_data.current);      /* 电流环PID控制（内环） */
                
        if (g_motor_data.motor_pwm >= 8200)                     /* 限制占空比 */
        {
            g_motor_data.motor_pwm = 8200;
        }
        else if (g_motor_data.motor_pwm <= 0)
        {
            g_motor_data.motor_pwm = 0;
        }

        dcmotor_speed(g_motor_data.motor_pwm);                  /* 设置占空比 */
    }
    val = 0;
}
val ++;

电流+速度双环控制实现

双环控制中，外环控制的是优先考虑对象，内环用于对控制效果进行优化。

Tips：双环控制时，外环PID参数调节幅度不能太大，这对于整个曲线的影响很大。

PID相关函数

#define  INCR_LOCT_SELECT  0         /* 0：位置式，1：增量式 */

/* 注意：双环控制的时候，外环PID参数调节幅度不要太大，这对于整个曲线的影响很大 */

#if INCR_LOCT_SELECT

/* 定义速度环（外环）PID参数相关宏 */
#define  S_KP      1.500f            /* P参数 */
#define  S_KI      0.023f            /* I参数 */
#define  S_KD      0.010f            /* D参数 */

/* 定义电流环（内环）PID参数相关宏 */
#define  C_KP      1.00f             /* P参数 */
#define  C_KI      3.00f             /* I参数 */
#define  C_KD      0.00f             /* D参数 */
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms */

#else

/*定义速度环（外环）PID参数相关宏*/
#define  S_KP      1.500f            /* P参数 */
#define  S_KI      0.023f            /* I参数 */
#define  S_KD      0.002f            /* D参数 */

/* 定义电流环（内环）PID参数相关宏 */
#define  C_KP      1.00f             /* P参数 */
#define  C_KI      3.75f             /* I参数 */
#define  C_KD      0.00f             /* D参数 */
#define  SMAPLSE_PID_SPEED  50       /* 采样周期 单位ms */

#endif

PID_TypeDef  g_speed_pid;       /* 速度环PID参数结构体 */
PID_TypeDef  g_current_pid;     /* 电流环PID参数结构体 */

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    /* 初始化速度环PID参数 */
    g_speed_pid.SetPoint = 0;           /* 目标值 */
    g_speed_pid.ActualValue = 0.0;      /* 期望输出值 */
    g_speed_pid.SumError = 0.0;         /* 积分值 */
    g_speed_pid.Error = 0.0;            /* Error[1] */
    g_speed_pid.LastError = 0.0;        /* Error[-1] */
    g_speed_pid.PrevError = 0.0;        /* Error[-2] */
    g_speed_pid.Proportion = S_KP;      /* 比例常数 Proportional Const */
    g_speed_pid.Integral = S_KI;        /* 积分常数 Integral Const */
    g_speed_pid.Derivative = S_KD;      /* 微分常数 Derivative Const */

    /* 初始化电流环PID参数 */
    g_current_pid.SetPoint = 0.0;       /* 目标值 */
    g_current_pid.ActualValue = 0.0;    /* 期望输出值 */
    g_current_pid.SumError = 0.0;       /* 积分值*/
    g_current_pid.Error = 0.0;          /* Error[1]*/
    g_current_pid.LastError = 0.0;      /* Error[-1]*/
    g_current_pid.PrevError = 0.0;      /* Error[-2]*/
    g_current_pid.Proportion = C_KP;    /* 比例常数 Proportional Const */
    g_current_pid.Integral = C_KI;      /* 积分常数 Integral Const */
    g_current_pid.Derivative = C_KD;    /* 微分常数 Derivative Const */
}

PID运算

电流在内环，不能有负数。需对传入的速度环做处理。

还增加了积分限幅处理，即给定可接受的偏差累计值最大值和最小值。

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度 */
         
if (val % SMAPLSE_PID_SPEED == 0)                               /* 进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了 */
    { 
                
        integral_limit( &g_speed_pid , 7000 , -7000 );          /* 速度环积分限幅 */
        integral_limit( &g_current_pid , 2500 , -2500 );        /* 电流环积分限幅 */
                
        g_motor_data.motor_pwm = increment_pid_ctrl(&g_speed_pid, g_motor_data.speed);         /* 速度环PID控制（外环） */
                
        if ( g_motor_data.motor_pwm > 0)                        /* 判断速度环输出值是否为正数 */
        {
            dcmotor_dir(0);                                     /* 输出为正数，设置电机正转 */
        }
        else
        {
            g_motor_data.motor_pwm = -g_motor_data.motor_pwm;   /* 目标电流不能为负数，速度环输出要取反 */
            dcmotor_dir(1);                                     /* 设置电机反转 */
        }
                    
        if (g_motor_data.motor_pwm >= 200)                      /* 限制外环输出（目标电流） */
        {
            g_motor_data.motor_pwm = 200;
        }
        g_current_pid.SetPoint = g_motor_data.motor_pwm;        /* 设置目标电流，外环输出作为内环输入 */

        g_motor_data.motor_pwm = increment_pid_ctrl(&g_current_pid, g_motor_data.current);      /* 电流环PID控制（内环） */
                
        if (g_motor_data.motor_pwm >= 8200)                     /* 限制占空比 */
        {
            g_motor_data.motor_pwm = 8200;
        }
        else if (g_motor_data.motor_pwm <= 0)                   /* 滤掉无效输出 */
        {
            g_motor_data.motor_pwm = 0;
        }

        dcmotor_speed(g_motor_data.motor_pwm);                  /* 设置占空比 */
    }
    val = 0;
}
val ++;

电流+速度+位置三环控制实现

PID相关函数

/* 定义位置环PID参数相关宏 */
#define  L_KP      0.06f             /* P参数 */
#define  L_KI      0.00f             /* I参数 */
#define  L_KD      0.01f             /* D参数 */

/* 定义速度环PID参数相关宏 */
#define  S_KP      5.00f             /* P参数 */
#define  S_KI      0.30f             /* I参数 */
#define  S_KD      0.01f             /* D参数 */

/* 定义电流环PID参数相关宏 */
#define  C_KP      8.00f             /* P参数 */
#define  C_KI      4.00f             /* I参数 */
#define  C_KD      1.00f             /* D参数 */

PID_TypeDef  g_location_pid;    /* 位置环PID参数结构体 */
PID_TypeDef  g_speed_pid;       /* 速度环PID参数结构体 */
PID_TypeDef  g_current_pid;     /* 电流环PID参数结构体 */

/**
 * @brief       pid初始化
 * @param       无
 * @retval      无
 */
void pid_init(void)
{
    /* 初始化位置环PID参数 */
    g_location_pid.SetPoint = 0.0;      /* 目标值 */
    g_location_pid.ActualValue = 0.0;   /* 期望输出值 */
    g_location_pid.SumError = 0.0;      /* 积分值*/
    g_location_pid.Error = 0.0;         /* Error[1]*/
    g_location_pid.LastError = 0.0;     /* Error[-1]*/
    g_location_pid.PrevError = 0.0;     /* Error[-2]*/
    g_location_pid.Proportion = L_KP;   /* 比例常数 Proportional Const */
    g_location_pid.Integral = L_KI;     /* 积分常数 Integral Const */
    g_location_pid.Derivative = L_KD;   /* 微分常数 Derivative Const */

    /* 初始化速度环PID参数 */
    g_speed_pid.SetPoint = 0.0;         /* 目标值 */
    g_speed_pid.ActualValue = 0.0;      /* 期望输出值 */
    g_speed_pid.SumError = 0.0;         /* 积分值 */
    g_speed_pid.Error = 0.0;            /* Error[1] */
    g_speed_pid.LastError = 0.0;        /* Error[-1] */
    g_speed_pid.PrevError = 0.0;        /* Error[-2] */
    g_speed_pid.Proportion = S_KP;      /* 比例常数 Proportional Const */
    g_speed_pid.Integral = S_KI;        /* 积分常数 Integral Const */
    g_speed_pid.Derivative = S_KD;      /* 微分常数 Derivative Const */

    /* 初始化电流环PID参数 */
    g_current_pid.SetPoint = 0.0;       /* 目标值 */
    g_current_pid.ActualValue = 0.0;    /* 期望输出值 */
    g_current_pid.SumError = 0.0;       /* 积分值*/
    g_current_pid.Error = 0.0;          /* Error[1]*/
    g_current_pid.LastError = 0.0;      /* Error[-1]*/
    g_current_pid.PrevError = 0.0;      /* Error[-2]*/
    g_current_pid.Proportion = C_KP;    /* 比例常数 Proportional Const */
    g_current_pid.Integral = C_KI;      /* 积分常数 Integral Const */
    g_current_pid.Derivative = C_KD;    /* 微分常数 Derivative Const */
}

PID运算

int Encode_now = gtim_get_encode();                             /* 获取编码器值，用于计算速度 */

speed_computer(Encode_now, 5);                                  /* 中位平均值滤除编码器抖动数据，5ms计算一次速度 */
         
if (val % SMAPLSE_PID_SPEED == 0)                               /* 进行一次pid计算 */
{
    if (g_run_flag)                                             /* 判断电机是否启动了 */
    { 
        g_motor_data.location = (float)Encode_now;              /* 获取当前编码器总计数值，用于位置闭环控制 */
                
        integral_limit(&g_location_pid , 1000 ,-1000);          /* 位置环积分限幅 */
        integral_limit(&g_speed_pid , 200 ,-200);               /* 速度环积分限幅 */
        integral_limit(&g_current_pid , 150 ,-150);             /* 电流环积分限幅 */
                
        if( (g_location_pid.Error <= 20) && (g_location_pid.Error >= -20) )                     /* 设置闭环死区 */
        {
            g_location_pid.Error = 0;                           /* 偏差太小了，直接清零 */
            g_location_pid.SumError = 0;                        /* 清除积分 */
        }
                
        g_motor_data.motor_pwm = increment_pid_ctrl(&g_location_pid, g_motor_data.location);    /* 位置环PID控制（最外环） */
                
        if (g_motor_data.motor_pwm >= 120)                      /* 限制外环输出（目标速度） */
        {
            g_motor_data.motor_pwm = 120;
        }
        else if (g_motor_data.motor_pwm <= -120)
        {
            g_motor_data.motor_pwm = -120;
        }
                
        g_speed_pid.SetPoint = g_motor_data.motor_pwm;          /* 设置目标速度，外环输出作为内环输入 */
        g_motor_data.motor_pwm = increment_pid_ctrl(&g_speed_pid, g_motor_data.speed);         /* 速度环PID控制（次外环） */
                
        if ( g_motor_data.motor_pwm > 0)                        /* 判断速度环输出值是否为正数 */
        {
            dcmotor_dir(0);                                     /* 输出为正数，设置电机正转 */
        }
        else
        {
            g_motor_data.motor_pwm = -g_motor_data.motor_pwm;   /* 输出取反 */
            dcmotor_dir(1);                                     /* 设置电机反转 */
        }
                    
        if (g_motor_data.motor_pwm >= 100)                      /* 限制外环输出（目标电流） */
        {
            g_motor_data.motor_pwm = 100;
        }
        g_current_pid.SetPoint = g_motor_data.motor_pwm;        /* 设置目标电流，外环输出作为内环输入 */

        g_motor_data.motor_pwm = increment_pid_ctrl(&g_current_pid, g_motor_data.current);      /* 电流环PID控制（内环） */
                
        if (g_motor_data.motor_pwm >= 8200)                     /* 限制占空比 */
        {
            g_motor_data.motor_pwm = 8200;
        }
        else if (g_motor_data.motor_pwm <= 0)                   /* 滤掉无效输出 */
        {
            g_motor_data.motor_pwm = 0;
        }

        dcmotor_speed(g_motor_data.motor_pwm);                  /* 设置占空比 */
    }
    val = 0;
}
val ++;

Couvrir洪荒猛兽

关注

24
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
电机应用-正点原子直流有刷电机例程笔记

在TIM6中1ms进入一次中断，中断记录编码器值（相当于总的计数值），然后进行电机速度计算（用到冒泡排序和一阶低通滤波算法）后传值给g_motor_data.speed，单位转/分（RPM）。假设让TIM1_CH1输出PWM波，TIM1_CH1N固定输出高电平，此时只要调节TIM1_CH1输出的PWM占空比即可调整电机上的电压，进而控制电机的转速。A、B两相脉冲信号从TIMx_CH1和TIMx_CH2这两个通道输入，经过滤波器和边沿检测器（可以设置滤波和反相）的处理，进入到编码器接口控制器中。
复制链接

扫一扫