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

看前需知：作者本人使用的是四个普通的TT电机加编码器+增量式PID,适合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;
}

总结

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

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

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

文章目录

一、粗谈PID

二、使用的硬件设备

三、软件设计

四、关键代码

1.TIM1定时器：

2.TIM2编码器模式示例：

3.电机初始化：

4.TIM8PWM输出：

5.PID：

6.中断服务函数：

总结

发表回复

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

文章目录

一、粗谈PID

二、使用的硬件设备

三、软件设计

四、关键代码

1.TIM1定时器：

2.TIM2编码器模式示例：

3.电机初始化：

4.TIM8PWM输出：

5.PID：

6.中断服务函数：

总结

相关推荐

深入浅出JVM调优，看完你就懂

linux系统 系统推荐 deepin国产系统 最好用的国产linux系统 Windows系统的优秀替代品 deepin系统安装 系统安装 deepin[通俗易懂]

HBuilder常用快捷键总结「建议收藏」

SpringBoot集成Activiti6教程

jmap使用详解_jmap作用

b站超过1000万粉丝的up主(b站第一位千万up主)

发表回复

linux系统系统推荐 deepin国产系统最好用的国产linux系统 Windows系统的优秀替代品 deepin系统安装系统安装 deepin[通俗易懂]