1. 全栈程序员必看首页

基于stm32四轮小车简易PID控制

全栈程序员-用户IM • • 未分类

基于stm32四轮小车简易PID控制看前需知：作者本人使用的是四个普通的TT电机加编码器+增量式PID,适合PID初学者，但是需要对PID和增量式PID有一定的认知，本篇未有详细介绍，以代码应用为主，大佬勿喷。文章目录一、粗谈PID？二、使用的硬件设备三、软件设计四、关键代码1.TIM1定时器：2.TIM2编码器模式示例：3.电机初始化：4.TIM8PWM输出：5.PID：6.中断服务函数：总结*云中何曾落羽，踏遍三岛寻声*一、粗谈PID？PID在生活中很常见，举个例子。例如生活中，一个加热器需要对某个物体进行恒温控制，但是由于某

大家好，又见面了，我是你们的朋友全栈君。

看前需知：作者本人使用的是四个普通的TT电机加编码器+增量式PID,适合PID初学者，但是需要对PID和增量式PID有一定的认知，本篇未有详细介绍，以代码应用为主，大佬勿喷。

文章目录

*云中何曾落羽，踏遍三岛寻声*

一、粗谈PID

PID在生活中很常见，举个例子。例如生活中，一个加热器需要对某个物体进行恒温控制，但是由于某种原因导致温度过高或者过低，这时候传感器会返回相应的数据，告诉控制器应当作出相应的调整，降温或者是加热，这就完成了一个简单的PID的闭环控制。PID就是修正公式里面的三个系数简称。
增量式PID控制将当前时刻的控制量和上一时刻的控制量做差，以差值为新的控制量，是一种递推式的算法。

在这里插入图片描述

二、使用的硬件设备

1、stm32f103rct6
2、某宝TT电机（小黄电机）+霍尔编码器
3、两块l2980驱动模块
4、四个18650电池供电

三、软件设计

1、四个电机分别使用IO口：PB8-PB9、PB10-PB11 、
PB12-PB13 、PB14-PB15。
2、PWM使用高级定时器TIM8的CH1-CH4，所用到的IO口：PC6 PC7 PC8 PC9。
3、四个编码器对应四个定时器TIM2 TIM3 TIM4 TIM5。开启自带的编码器模式，需同时开启对应的CH1和CH2。（对应的引脚可查看数据手册）
4、用TIM1进行中断计时。
注：TIM2需要完全重映射，因为未重映射时与TIM5的CH1，CH2引脚相同。 GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable , ENABLE); 这个禁用也不可忘了！

四、关键代码

1.TIM1定时器：

void Timer_Init(void)
{ 
   

TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
	
	TIM_TimeBaseStructure.TIM_Period = 9999;//自动重新装载寄存器周期的值澹ㄥ计数值澹)
	TIM_TimeBaseStructure.TIM_Prescaler = 719;//时钟分频系数
	TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;//对外部时钟进行采样的时钟分频
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数
	TIM_TimeBaseStructure.TIM_RepetitionCounter=0; //高级定时器1是用定时器功能配置这个才可以是正常的计数频率一开始的72mhz 值得注意的地方
	TIM_TimeBaseInit(TIM1,&TIM_TimeBaseStructure);//参数初始化

	TIM_ClearFlag(TIM1, TIM_FLAG_Update);
	TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);

	TIM_Cmd(TIM1, ENABLE);//启动定时器 

}

2.TIM2编码器模式示例：

void Encoder_Init_TIM2(void)
{ 
   
	TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;  
  TIM_ICInitTypeDef TIM_ICInitStructure;  
  GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);//使能定时器2的时钟
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE); 
  
  GPIO_PinRemapConfig(GPIO_FullRemap_TIM2, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable , ENABLE); 
	
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;	//端口配置
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
  GPIO_Init(GPIOA, &GPIO_InitStructure);					      //根据设定参数初始化GPIOA
 

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;	//端口配置
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
  GPIO_Init(GPIOB, &GPIO_InitStructure);					      //根据设定参数初始化GPIOA
 

	
  TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
  TIM_TimeBaseStructure.TIM_Prescaler = 0x0; // 预分频器 
  TIM_TimeBaseStructure.TIM_Period = ENCODER_TIM_PERIOD; //设定计数器自动重装值
  TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;//选择时钟分频：不分频
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;TIM向上计数 
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
  TIM_EncoderInterfaceConfig(TIM2, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);//使用编码器模式3
  TIM_ICStructInit(&TIM_ICInitStructure);
  TIM_ICInitStructure.TIM_ICFilter = 10;
  TIM_ICInit(TIM2, &TIM_ICInitStructure);
  TIM_ClearFlag(TIM2, TIM_FLAG_Update);//清除TIM的更新标志位
  TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
  //Reset counter
  TIM_SetCounter(TIM2,0);
  TIM_Cmd(TIM2, ENABLE); 
}

3.电机初始化：

void dj1_Init(void)
{ 
   
 
 GPIO_InitTypeDef  GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	 //使能PB端口时钟
GPIO_InitStructure.GPIO_Pin =GPIO_Pin_11|GPIO_Pin_10|GPIO_Pin_9|GPIO_Pin_8;	
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 //IO口速度为50MHz
 GPIO_Init(GPIOB, &GPIO_InitStructure);					 //根据设定参数初始化GPIOB
	
}

4.TIM8PWM输出：

void PWM_Init(u16 arr,u16 psc)

{ 
   		 		
GPIO_InitTypeDef GPIO_InitStructure;
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    TIM_OCInitTypeDef  TIM_OCInitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8, ENABLE);// 
     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE);  //使能GPIO外设时钟使能
                                                                             
// GPIO_PinRemapConfig(GPIO_FullRemap_TIM3, ENABLE); //全映射 PC6-9

   //设置该引脚为复用输出功能,输出TIM8 CH1的PWM脉冲波形
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9; //TIM_CH1
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //复用推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    
    TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值
    TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值 不分频
    TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    TIM_TimeBaseInit(TIM8, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
    
 
    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; //选择定时器模式:TIM脉冲宽度调制模式2
    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //比较输出使能
    TIM_OCInitStructure.TIM_Pulse = 0; //设置待装入捕获比较寄存器的脉冲值
    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; //输出极性:TIM输出比较极性高
		
		
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset ; 

TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Disable; 

//TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;

    TIM_OC1Init(TIM8, &TIM_OCInitStructure);  //根据TIM_OCInitStruct中指定的参数初始化外设TIMx
    TIM_OC2Init(TIM8, &TIM_OCInitStructure);
    TIM_OC3Init(TIM8, &TIM_OCInitStructure);
	  TIM_OC4Init(TIM8, &TIM_OCInitStructure);
    TIM_CtrlPWMOutputs(TIM8,ENABLE);    //MOE 主输出使能 

    TIM_OC1PreloadConfig(TIM8, TIM_OCPreload_Enable);  //CH1预装载使能 
    TIM_OC2PreloadConfig(TIM8, TIM_OCPreload_Enable); 
		TIM_OC3PreloadConfig(TIM8, TIM_OCPreload_Enable); 
		TIM_OC4PreloadConfig(TIM8, TIM_OCPreload_Enable); 
    TIM_ARRPreloadConfig(TIM8, ENABLE); //使能TIMx在ARR上的预装载寄存器
    
    TIM_Cmd(TIM8, ENABLE);  //使能TIM8 
   
}

5.PID：

static double   Proportion=0.45;                               //比例常数 Proportional Const
static double   Integral=0.1;                                 //积分常数 Integral Const
static double   Derivative=0;                                 //b不采用微分

/********************增量式PID控制设计************************************/
//NowPoint当前输出值
//SetPoint设定值
int PID_Calc1(int NowPoint,int SetPoint) 
{ 
   
                             //微分常数 Derivative Const
	static int      LastError1;                                //Error[-1]
	static int      PrevError1;                                //Error[-2]
  int iError,Outpid;                                   //当前误差
	
  iError=SetPoint-NowPoint;                           //增量计算
  Outpid=(Proportion * iError)                   //E[k]项
              -(Integral * LastError1)      //E[k-1]项
              +(Derivative * PrevError1);   //E[k-2]项
              
  PrevError1=LastError1;                     //存储误差，用于下次计算
  LastError1=iError;
  return(Outpid);                                      //返回增量值
}

int PID_Calc2(int NowPoint,int SetPoint) 
{ 
   
                             //微分常数 Derivative Const
	static int      LastError2;                                //Error[-1]
	static int      PrevError2;                                //Error[-2]
  int iError,Outpid;                                   //当前误差
	
  iError=SetPoint-NowPoint;                           //增量计算
  Outpid=(Proportion * iError)                   //E[k]项
              -(Integral * LastError2)      //E[k-1]项
              +(Derivative * PrevError2);   //E[k-2]项
              
  PrevError2=LastError2;                     //存储误差，用于下次计算
  LastError2=iError;
  return(Outpid);                                      //返回增量值
}


int PID_Calc3(int NowPoint,int SetPoint) 
{ 
   
                             //微分常数 Derivative Const
	static int      LastError3;                                //Error[-1]
	static int      PrevError3;                                //Error[-2]
  int iError,Outpid;                                   //当前误差
	
  iError=SetPoint-NowPoint;                           //增量计算
  Outpid=(Proportion * iError)                   //E[k]项
              -(Integral * LastError3)      //E[k-1]项
              +(Derivative * PrevError3);   //E[k-2]项
              
  PrevError3=LastError3;                     //存储误差，用于下次计算
  LastError3=iError;
  return(Outpid);                                      //返回增量值
}


int PID_Calc4(int NowPoint,int SetPoint) 
{ 
   
                             //微分常数 Derivative Const
	static int      LastError4;                                //Error[-1]
	static int      PrevError4;                                //Error[-2]
  int iError,Outpid;                                   //当前误差
	
  iError=SetPoint-NowPoint;                           //增量计算
  Outpid=(Proportion * iError)                   //E[k]项
              -(Integral * LastError4)      //E[k-1]项
              +(Derivative * PrevError4);   //E[k-2]项
              
  PrevError4=LastError4;                     //存储误差，用于下次计算
  LastError4=iError;
  return(Outpid);                                      //返回增量值
}

6.中断服务函数：

void dj1_Init(void)
{ 
   
 
int Encoder_Front_Left,Encoder_Front_Right,Encoder_Back_Right,Encoder_Back_Left;
int Left_t,Right_t,Encoder_R,Encoder_L;
int Moto_Front_Left,Moto_Front_Right,Moto_Back_Left,Moto_Back_Right; 
int para1,para2,para3,para4;//增量
int SetPoint1=30;//设置目标值单位RPM
int SetPoint2=30;
//使用减速比是1：120的减速箱
#define SetPoint_back SetPoint1*6240/600//换算成编码器速度，因为最终pid控制的是编码器的脉冲数量
#define SetPoint_front SetPoint2*6240/600//换算成编码器速度，因为最终pid控制的是编码器的脉冲数量

//Time1定时器1中断服务函数
//200ms定时
void TIM1_UP_IRQHandler(void)
{ 
   
	if(TIM_GetFlagStatus(TIM1, TIM_IT_Update) != RESET)   //时间到了
	{ 
   
		TIM_ClearITPendingBit(TIM1, TIM_FLAG_Update);//清中断
			
		  Encoder_Front_Left=myabs(Read_Encoder(2));  //读取编码器 
		  Encoder_Front_Right=myabs(Read_Encoder(3));
		  Encoder_Back_Left=myabs(Read_Encoder(4));
		  Encoder_Back_Right=myabs(Read_Encoder(5));
			
			para1=PID_Calc1(Encoder_Front_Left,SetPoint_back);	//左电机，计数得到增量式PID的增量数值 
		  para2=PID_Calc2(Encoder_Front_Right,SetPoint_back);
		  para3=PID_Calc3(Encoder_Back_Left,SetPoint_front);
		  para4=PID_Calc4(Encoder_Back_Right,SetPoint_front);
		
		
		
		
			if((para1<-3)||(para1>3)) // 不做 PID 调整，避免误差较小时频繁调节引起震荡。
			{ 
   
				Moto_Front_Left +=para1;  
			}   
					if(Moto_Front_Left>3500) Moto_Front_Left=3500;//限幅
			    TIM8->CCR1=Moto_Front_Left;//更新pwm
	 
			if((para2<-3)||(para2>3)) // 不做 PID 调整，避免误差较小时频繁调节引起震荡。
			{ 
   
				Moto_Front_Right +=para2;  
			}   
					if(Moto_Front_Right>3500) Moto_Front_Right=3500;//限幅
			    TIM8->CCR2=Moto_Front_Right;
			
	/// 
			if((para3<-3)||(para3>3)) // 不做 PID 调整，避免误差较小时频繁调节引起震荡。
			{ 
   
				Moto_Back_Left +=para3;  
			}   
					if(Moto_Back_Left>3500) Moto_Back_Left=3500;//限幅
			    TIM8->CCR3=Moto_Back_Left;//更新pwm
	 
			if((para4<-3)||(para4>3)) // 不做 PID 调整，避免误差较小时频繁调节引起震荡。
			{ 
   
				Moto_Back_Right +=para4;  
			}   
					if(Moto_Back_Right>3500) Moto_Back_Right=3500;//限幅
			    TIM8->CCR4=Moto_Back_Right;//更新pwm
			delay_ms(2);
			
	  	}
	
		
}

int myabs(int a)
{ 
    		   
	int temp;
	if(a<0)  
	  temp=-a;  
	else 
	  temp=a;
	return temp;
}

总结

由于本人为新手，代码可能显得冗长，本文关于速度的计算设置就不写了，可以结合其他大佬博主的文章尝试理解，需要代码的可以评论区留言+一键三连（嘿嘿嘿）。书写不易，感谢支持，大家一起进步！

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/140759.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号