-
电机应用-正点原子直流有刷电机例程笔记
目录
基础驱动实验：调速和换向
硬件资源：
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
- {
- 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 ++;
-
相关阅读:
商务呈现-售前评估&支持
TOWE时序上电智能PDU产品在IDC数据中心机房的应用
JS基本数据类型中null和undefined区别及应用
PyTorch微调终极指南2：提升模型的准确性
JavaScript-----DOM元素
82.（cesium之家）cesium点在3d模型上运动
Java集合实现（一） ArrayList源码以及手写ArrayList
0109连续函数的运算和初等函数的连续性-函数与极限-高等数学
香蕉派BPI-Wifi6迷你路由器公开发售
内网渗透神器CobaltStrike之配置与基础操作(一)
- 原文地址：https://blog.csdn.net/weixin_47077788/article/details/136364986
