**闭环问题**记录#高级定时器配置问题&仿真调试&闭环

最新推荐文章于 2023-04-14 10:32:09 发布
最新推荐文章于 2023-04-14 10:32:09 发布
阅读量340 收藏 3
点赞数 4
文章标签： stm32 单片机 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74858024/article/details/129946655
版权

文章目录

 一.高级定时器输出配置问题

 二.仿真调试

三.闭环的代码问题

 一.高级定时器输出配置问题

1.用高级定时器TIM1/TIM8输出PWM波时，必须将其OC配置完整!!!!

​    //TIM_OCStructInit(&TIM_OCInitStructure);
    //初始化Pwm通道TIM8_CH_OC1/2/3/4——并且全部配置！！！
    //或者在前面使用TIM_OCStructInit(&TIM_OCInitStructure);                
    TIM_OCStructInit(&TIM_OCInitStructure);
	TIM_OCInitStructure.TIM_Pulse = 0;
    //设置待装入捕获比较寄存器冲值为0
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
    //设置PWm模式1 CNT<CCR为有效电平
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
    //设置有效电平输出极性为高极性
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
    //使能输出比较状态使能输出到端口
	TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
    //使能输出比较N状态
	TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
    //当 MOE=0 重置 TIM1 输出比较空闲状态
	TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;
    //当 MOE=0 重置 TIM1 输出比较 N 空闲状态
	TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
    //TIM1 输出比较N极性高
	TIM_OC1Init(TIM8,&TIM_OCInitStructure);//配置TIM8的四个通道输出PWM
    TIM_OC2Init(TIM8,&TIM_OCInitStructure);
	TIM_OC3Init(TIM8,&TIM_OCInitStructure);  
    TIM_OC4Init(TIM8,&TIM_OCInitStructure);

​

配置完成之后pwm才能正常输出！！

 二.仿真调试

1.数据不能实时更新的问题

解决方法：打开调试之后-->点击view-->最后的update勾选。（之后watch里的输出变量就能实时更新啦！！）

注意：watch里面的变量当然是全局变量才能监测！！！

三.闭环的代码问题

有篇文章还是不错的https://blog.csdn.net/qq_44343584/article/details/122318756

pwm.h

#ifndef __PWM_H
#define __PWM_H
#include "sys.h"
void PWM_Init_TIM8(u16 arr, u16 psc);
void change_pwm(u16 i);

#define AIN2   PBout(12)
#define AIN1   PBout(13)
#define BIN1   PBout(14)
#define BIN2   PBout(15)
#define ain2   PEout(12)
#define ain1   PEout(13)
#define bin1   PEout(14)
#define bin2   PEout(15)


#endif

 pwm.c

#include "pwm.h"
//#include "Device/Include/stm32f10x.h"   // Device header



void PWM_Init_TIM8(u16 arr, u16 psc)
{
	
	GPIO_InitTypeDef GPIO_InitStructure;	 //定义一个引脚初始化的结构体
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStrue; //定义一个定时中断的结构体
	TIM_OCInitTypeDef TIM_OCInitStructure; //定义一个 PWM 输出的结构
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_TIM8|RCC_APB2Periph_GPIOE,             
    ENABLE);//PB/E控制电机IO,TIM8控制pwm输出引脚
	//控制方向引脚
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //引脚输入输出模式为推挽输出模式
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //引脚输出速度为 50MHZ
	GPIO_Init(GPIOB,&GPIO_InitStructure);//根据上面设置好的GPIO_InitStructure参数初始化引脚
	
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP; //引脚输入输出模式为推挽输出模式
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //引脚输出速度为 50MHZ
	GPIO_Init(GPIOE, &GPIO_InitStructure);//根据上面设置好的GPIO_InitStructure参数初始化引脚
	//pwm引脚
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9; 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	
	//初始化高级定时器TIM8
	TIM_TimeBaseInitStrue.TIM_Period=arr;													            
    //自动重装载值
	TIM_TimeBaseInitStrue.TIM_Prescaler=psc;											    
    //预分频系数
	TIM_TimeBaseInitStrue.TIM_ClockDivision=TIM_CKD_DIV1;	//
	TIM_TimeBaseInitStrue.TIM_CounterMode=TIM_CounterMode_Up//向上计数
	TIM_TimeBaseInit(TIM8,&TIM_TimeBaseInitStrue);
	
	//初始化Pwm通道TIM8_CH_OC1/2/3/4
	TIM_OCInitStructure.TIM_Pulse = 0;//设置待装入捕获比较寄存器的脉冲值
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //使能输出比较状态   //    
    使能输出到端口
	TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;//使能输出比较N状态
	TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;//当 MOE=0 重置 TIM1 输出 
    比较空闲状态
	TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;//当 MOE=0 重置 TIM1 输 
    出比较 N 空闲状态
	TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;//TIM1 输出比较N极性高
	TIM_OC1Init(TIM8,&TIM_OCInitStructure);  
    TIM_OC2Init(TIM8,&TIM_OCInitStructure);
	TIM_OC3Init(TIM8,&TIM_OCInitStructure);  
    TIM_OC4Init(TIM8,&TIM_OCInitStructure);
	
	//使能TIM8在CCR1上的预装载寄存器
	TIM_OC1PreloadConfig(TIM8, TIM_OCPreload_Enable); 
	TIM_OC2PreloadConfig(TIM8, TIM_OCPreload_Enable); 
	TIM_OC3PreloadConfig(TIM8, TIM_OCPreload_Enable); 
	TIM_OC4PreloadConfig(TIM8, TIM_OCPreload_Enable);
	
	TIM_CtrlPWMOutputs(TIM8,ENABLE);//高级定时器的使能函数
	TIM_ARRPreloadConfig(TIM8,ENABLE);//使能TIM8 ARR上的预装载寄存器
	TIM_Cmd(TIM8, ENABLE);//使能TIM8  

}

注意：

1. TIM_CtrlPWMOutputs(TIM8,ENABLE);//配置高级定时器这一句必须有！！

2.配置高级定时器需要将TIM_OC1Init（）函数的结构体成员全部赋初值！！！否则无法运行

（可以在新建的结构体数据类型变量下面使用TIM_OCStructInit(&TIM_OCInitStructure)）

 encoder.h(编码器)

#ifndef __ENCODER_H
#define __ENCODER_H
#include "sys.h"
#include "pwm.h"
extern int Encoder_TIM;
void Encoder_Init_TIM2(void);
void Encoder_Init_TIM3(void);
void Encoder_Init_TIM4(void);
void Encoder_Init_TIM5(void);
void Encoder_Init_TIM(void);
int Read_Encoder(u8 TIMX);
#endif

encoder.c

#include "encoder.h"
//#include "Device/Include/stm32f10x.h"// Device header

void Encoder_Init_TIM2(void)
{
//	GPIO_InitTypeDef GPIO_InitStructure;//初始化GPIO-->PA0/PA1
//	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
//	TIM_ICInitTypeDef TIM_ICInitStruct;
	

//	
//	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟
//	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);//使能TIM2_CH1/2-->PA0/1
//	
//	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
//	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0|GPIO_Pin_1;
//	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
//	GPIO_Init(GPIOA,&GPIO_InitStructure);

//以上是发现了TIM2和TIM5的CH1和CH2的IO冲突了使用重映射了TIM2的通道


	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
	TIM_ICInitTypeDef TIM_ICInitStruct;
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO|RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB,         
    ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
	GPIO_PinRemapConfig(GPIO_FullRemap_TIM2 ,ENABLE );
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//重映射TIM2就要禁用这个IO

	
	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

	
	//初始化TIM2
	TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;//TIM向上计数模式
	TIM_TimeBaseInitStruct.TIM_Period = 65534;//配置自动重装载寄存器的值
	TIM_TimeBaseInitStruct.TIM_Prescaler = 0;//配置定时器时钟分频
	TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;	//时钟分频
	TIM_TimeBaseInitStruct.TIM_RepetitionCounter=0;	//重复计数器无效0
	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStruct);
	
	//配置输入通道一
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;	//输入器不分频
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;	//上升沿捕获
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;	//映射到IC1
	TIM_ICInitStruct.TIM_ICFilter = 0;	//不滤波
	TIM_ICInit(TIM2, &TIM_ICInitStruct);
	//初始化通道二
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
	TIM_ICInitStruct.TIM_ICFilter = 0;
	TIM_ICInit(TIM2, &TIM_ICInitStruct);
	
	TIM_EncoderInterfaceConfig(TIM2, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);	//使用编码器模式 3：CH1、CH2 同时计数，为四分频
	
  TIM_ClearFlag(TIM2, TIM_FLAG_Update);			//清理更新标志位
  //TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);//使能更新中断

	
	TIM_SetCounter(TIM2,0);										//将CNT置零
	
	TIM_Cmd(TIM2, ENABLE);										//使能TIM2
}

//TIM3_CH1/2-->PA6/PA7
void Encoder_Init_TIM3(void)
{
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
	TIM_ICInitTypeDef TIM_ICInitStruct;
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6|GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	
	//配置时基
	TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
	//TIM向上计数模式
	TIM_TimeBaseInitStruct.TIM_Period = 65534;
	//配置自动重装载寄存器的值
	TIM_TimeBaseInitStruct.TIM_Prescaler = 0x0;
	//配置定时器时钟分频
	TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
	//时钟分频
	TIM_TimeBaseInitStruct.TIM_RepetitionCounter=0;
	//重复计数器无效0
	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);
	
	//配置输入
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;	//输入器不分频
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;	//上升沿捕获
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;	//映射到IC1
	TIM_ICInitStruct.TIM_ICFilter = 0;	//不滤波
	TIM_ICInit(TIM3, &TIM_ICInitStruct);
	
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
	TIM_ICInitStruct.TIM_ICFilter = 0;
	TIM_ICInit(TIM3, &TIM_ICInitStruct);
	
	TIM_EncoderInterfaceConfig(TIM3, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);//使能编码器模式3 0x0003
	
	
  TIM_ClearFlag(TIM3, TIM_FLAG_Update);	
	
	TIM_SetCounter(TIM3,0);
	
	TIM_Cmd(TIM3, ENABLE);
}


void Encoder_Init_TIM4(void)// PB6 PB7
{
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
	TIM_ICInitTypeDef TIM_ICInitStruct;
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	//配置时基
	TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
	//TIM向上计数模式
	TIM_TimeBaseInitStruct.TIM_Period = 65534;
	//配置自动重装载寄存器的值
	TIM_TimeBaseInitStruct.TIM_Prescaler = 0x0;
	//配置定时器时钟分频
	TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
	//时钟分频
	TIM_TimeBaseInitStruct.TIM_RepetitionCounter=0;
	//重复计数器无效0
	TIM_TimeBaseInit(TIM4, &TIM_TimeBaseInitStruct);
	
	//配置输入
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
	//输入器不分频
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
	//上升沿捕获
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
	//映射到IC1
	TIM_ICInitStruct.TIM_ICFilter = 0;
	//不滤波
	TIM_ICInit(TIM4, &TIM_ICInitStruct);
	
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
	TIM_ICInitStruct.TIM_ICFilter = 0;
	TIM_ICInit(TIM4, &TIM_ICInitStruct);
	
	TIM_EncoderInterfaceConfig(TIM4, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);
	//使能编码器模式3 0x0003
	
  TIM_ClearFlag(TIM4, TIM_FLAG_Update);	
	
	TIM_SetCounter(TIM4,0);
	
	TIM_Cmd(TIM4, ENABLE);
}


void Encoder_Init_TIM5(void)//PA0 PA1
{
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
	TIM_ICInitTypeDef TIM_ICInitStruct;
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);
	
	GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_0 | GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	//配置时基
	TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
	//TIM向上计数模式
	TIM_TimeBaseInitStruct.TIM_Period = 65534;
	//配置自动重装载寄存器的值
	TIM_TimeBaseInitStruct.TIM_Prescaler = 0x0;
	//配置定时器时钟分频
	TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
	//时钟分频
	TIM_TimeBaseInitStruct.TIM_RepetitionCounter=0;
	//重复计数器无效0
	TIM_TimeBaseInit(TIM5, &TIM_TimeBaseInitStruct);
	
	//配置输入
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
	//输入器不分频
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
	//上升沿捕获
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
	//映射到IC1
	TIM_ICInitStruct.TIM_ICFilter = 0;
	//不滤波
	TIM_ICInit(TIM5, &TIM_ICInitStruct);
	
	TIM_ICInitStruct.TIM_Channel = TIM_Channel_2;
	TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
	TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
	TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
	TIM_ICInitStruct.TIM_ICFilter = 0;
	TIM_ICInit(TIM5, &TIM_ICInitStruct);
	
	TIM_EncoderInterfaceConfig(TIM5, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);//使能编码器模式3 0x0003
	
	
  TIM_ClearFlag(TIM5, TIM_FLAG_Update);	
	
	TIM_SetCounter(TIM5,0);
	
	TIM_Cmd(TIM5, ENABLE);
}
//编码器初始化
void Encoder_Init_TIM(void)
{
	Encoder_Init_TIM2();
	Encoder_Init_TIM3();
	Encoder_Init_TIM4();
	Encoder_Init_TIM5();
}
//int Encoder_TIM;
//读取不同定时器编码器的CNT值
int Read_Encoder(u8 TIMX)
{
   int Encoder_TIM;
   switch(TIMX)
	 {
		 case 1:  Encoder_TIM= (short)TIM1 -> CNT;  TIM1 -> CNT=0;break;
	     case 2:  Encoder_TIM= (short)TIM2 -> CNT;  TIM2 -> CNT=0;break;
		 case 3:  Encoder_TIM= (short)TIM3 -> CNT;  TIM3 -> CNT=0;break;
		 case 4:  Encoder_TIM= (short)TIM4 -> CNT;  TIM4 -> CNT=0;break;
		 case 5:  Encoder_TIM= (short)TIM5 -> CNT;  TIM5 -> CNT=0;break;
		 case 8:  Encoder_TIM= (short)TIM8 -> CNT;  TIM8 -> CNT=0;break;
		 default: Encoder_TIM=0;
	 }
		return Encoder_TIM;    /*CNT清零*/
}

注意：

1.TIM2和TIM5的CH1和CH2重复，使用将TIM2使用了完全重映射！！！（也就是我一开始为什么在TIM2中注释掉那一大段的原因）；

2.使用TIM2完全重映射的时候（根据《STM32中文参考手册》和《精英版IO原理图》）

可以看出来原理图中有库函数禁止JTAG的方法！！！

pid.h

#ifndef __PID_H
#define __PID_H
#include "sys.h"
#include "pwm.h"
#include "encoder.h"
//定义一个pid的数据类型
typedef struct
{
	float Target; 			        //设定目标值
	float Measured; 				    //测量值
	float err; 									//本次偏差值
	float err_last; 			  	  //上一次偏差
	float err_beforeLast;
	float pwm; 									//pwm输出
}incrementalpid_t;

extern incrementalpid_t pid[4];
extern int Encoder1;
extern int Target1;
extern int Motor1;

extern int Encoder2;
extern int Target2;
extern int Motor2;

extern int Encoder3;
extern int Target3;
extern int Motor3;

extern int Encoder4;
extern int Target4;
extern int Motor4;
int Incremental_PID1(int Encoder1,int Target1);
int Incremental_PID2(int Encoder2,int Target2);
int Incremental_PID3(int Encoder3,int Target3);
int Incremental_PID4(int Encoder4,int Target4);
void Set_Pwm1(int moto1);
void Set_Pwm2(int moto2);
void Set_Pwm3(int moto3);
void Set_Pwm4(int moto4);
int myabs(int a); //取绝对值

#endif

注意：这里将pid算法中的变量用结构体定义了一个数据类型！！！

下面是重点！！！

pid.c

#include "pid.h"
//#include "Device/Include/stm32f10x.h"   // Device header
#define PI 3.14159265

incrementalpid_t pid[4];
float Kp1=9, Ki1=0.8,Kd1=0;				        //Kp, Ki,Kd控制系数
float Kp2=9, Ki2=0.7,Kd2=0;				        //Kp, Ki,Kd控制系数
float Kp3=9, Ki3=0.8,Kd3=0;				        //Kp, Ki,Kd控制系数
float Kp4=9, Ki4=0.7,Kd4=0;		 		        //Kp, Ki,Kd控制系数
int Motor1;
int Encoder1;
int Motor2;
int Encoder2;
int Motor3;
int Encoder3;
int Motor4;
int Encoder4;
int Target1;
int Target2;
int Target3;
int Target4;

/**************************************************************************
函数功能：增量PI控制器
入口参数：编码器测量值，目标速度
返回  值：电机PWM
根据增量式离散PID公式 
pwm+=Kp[e（k）-e(k-1)]+Ki*e(k)+Kd[e(k)-2e(k-1)+e(k-2)]
e(k)代表本次偏差 
e(k-1)代表上一次的偏差  以此类推 
pwm代表增量输出
在我们的速度控制闭环系统里面，只使用PI控制
pwm+=Kp[e（k）-e(k-1)]+Ki*e(k)
**************************************************************************/
int Incremental_PID1(int Encoder1,int Target1)
{ 	
	pid[0].err=Target1-Encoder1;                //计算偏差
	pid[0].pwm+=Kp1*(pid[0].err-pid[0].err_last)+Ki1*pid[0].err+Kd1*(pid[0].err- 
    2*pid[0].err_last+pid[0].err_beforeLast);   //增量式PID控制器
    //===PWM满幅是7200 限制在7100
	if(pid[0].pwm<-7000)  
    pid[0].pwm = -7000;
    else if(pid[0].pwm>7000)   
    pid[0].pwm =  7000;
	pid[0].err_beforeLast=pid[0].err_last;
	pid[0].err_last=pid[0].err;	                   //保存上一次偏差 
	return pid[0].pwm;                         //增量输出
}
int Incremental_PID2(int Encoder2,int Target2)
{ 	
	pid[1].err=Target2-Encoder2;                //计算偏差
	pid[1].pwm+=Kp2*(pid[1].err-pid[1].err_last)+Ki2*pid[1].err+Kd2*(pid[1].err- 
    2*pid[1].err_last+pid[1].err_beforeLast);   //增量式PID控制器
         //===PWM满幅是7200 限制在7100
	 if(pid[1].pwm<-7000)  
		 pid[1].pwm = -7000;
	 else if(pid[1].pwm>7000)   
		 pid[1].pwm =  7000;
	 pid[1].err_beforeLast=pid[1].err_last;
		pid[1].err_last=pid[1].err;	                   //保存上一次偏差 
	return pid[1].pwm;                         //增量输出
}
int Incremental_PID3(int Encoder3,int Target3)
{ 	
	pid[2].err=Target3-Encoder3;                //计算偏差
	pid[2].pwm+=Kp3*(pid[2].err-pid[2].err_last)+Ki3*pid[2].err+Kd3*(pid[2].err- 
    2*pid[2].err_last+pid[2].err_beforeLast);   //增量式PID控制器
    //===PWM满幅是7200 限制在7100
	if(pid[2].pwm<-7000)  
    pid[2].pwm = -7000;
	else if(pid[2].pwm>7000)   
	pid[2].pwm =  7000;
	pid[2].err_beforeLast=pid[2].err_last;
	pid[2].err_last=pid[2].err;	                   //保存上一次偏差 
	return pid[2].pwm;                         //增量输出
}
int Incremental_PID4(int Encoder4,int Target4)
{ 	
	pid[3].err=Target4-Encoder4 //计算偏差
	pid[3].pwm+=Kp4*(pid[3].err-pid[3].err_last)+Ki4*pid[3].err+Kd4*(pid[3].err-        
    2*pid[3].err_last+pid[3].err_beforeLast);//增量式PID控制器
    //===PWM满幅是7200 限制在7100
	if(pid[3].pwm<-7000)  
	pid[3].pwm = -7000;
	else if(pid[3].pwm>7000)   
	pid[3].pwm =  7000;
	pid[3].err_beforeLast=pid[3].err_last;
	pid[3].err_last=pid[3].err;	                   //保存上一次偏差 
	return pid[3].pwm;                         //增量输出
}


void Set_Pwm1(int moto1)//赋值给PWM寄存器
{
 if(moto1>0) AIN1=0,   AIN2=1;
	else      AIN1=1,   AIN2=0;
	TIM8->CCR1=myabs(moto1);
}

void Set_Pwm2(int moto2)//赋值给PWM寄存器
{
 if(moto2>0) BIN1=0,   BIN2=1;
	else      BIN1=1,   BIN2=0;
	TIM8->CCR2=myabs(moto2);
}

void Set_Pwm3(int moto3)//赋值给PWM寄存器
{
 if(moto3>0) ain1=1,   ain2=0;
	else      ain1=0,   ain2=1;
	TIM8->CCR3=myabs(moto3);
}

void Set_Pwm4(int moto4)//赋值给PWM寄存器
{
 if(moto4>0) bin1=1,   bin2=0;
	else      bin1=0,   bin2=1;
	TIM8->CCR4=myabs(moto4);
}

int myabs(int a) //取绝对值
{ 		   
	 int temp;
	 if(a<0)  temp=-a;  
	 else temp=a;
	 return temp;
}

最后是一个重中之重！！！！

将encoder/pwm/pid放在一个定时中断服务函数中！！！

timer.c

#include "timer.h"
#include "Device/Include/stm32f10x.h"   // Device header
#include "pwm.h"
#include "encoder.h"
#include "pid.h"




void  TIM6_Init(u16 arr, u16 psc)
{
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   
	/* 配置时基结构体 */
	NVIC_InitTypeDef NVIC_InitStruct;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);//使能定时器时钟
	
	TIM_TimeBaseStructure.TIM_Prescaler = psc;   	//配置定时器时钟分频
	TIM_TimeBaseStructure.TIM_Period = arr;       //配置自动重装载寄存器的值  
	TIM_TimeBaseStructure.TIM_ClockDivision =0; //时钟分割
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //TIM向上计数模式
	TIM_TimeBaseInit(TIM6, &TIM_TimeBaseStructure);	//初始化TIM6时间基数单位

	TIM_ClearFlag(TIM6, TIM_FLAG_Update);	//清除更新中断，防止一打开中断立马产生中断
	TIM_ITConfig(TIM6, TIM_IT_Update, ENABLE);	//打开定时器更新中断
/*配置中断优先级*/
	NVIC_InitStruct.NVIC_IRQChannel = TIM6_IRQn;   //使能外部中断通道
	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;   //使能外部中断通道
	NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1; //抢占优先级1
	NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;    //响应优先级3
	NVIC_Init(&NVIC_InitStruct);
	TIM_Cmd(TIM6, ENABLE);	//使能定时器
	
}
void TIM6_IRQHandler(void)
{
	if(TIM_GetFlagStatus(TIM6,TIM_FLAG_Update)==SET)
 {
   TIM_ClearITPendingBit(TIM6,TIM_IT_Update);   //===清除定时器1中断标志位
	 Encoder1=Read_Encoder(2);                     //取定时器2计数器的值
	 Encoder2=Read_Encoder(3);                     //取定时器4计数器的值  
	 Encoder3=Read_Encoder(4); 
	 Encoder4=Read_Encoder(5); 
//   Led_Flash(100);                              //LED闪烁
	 Motor1=Incremental_PID1(Encoder1,Target1);    //===位置PID控制器
	 Motor2=Incremental_PID2(Encoder2,Target2);
	 Motor3=Incremental_PID3(Encoder3,Target3);
	 Motor4=Incremental_PID4(Encoder4,Target4);
   Set_Pwm1(Motor1);
	 Set_Pwm2(Motor2);
	 Set_Pwm3(Motor3);
	 Set_Pwm4(Motor4);
//	 PID_Output();
//	 PID_Output1();
 } 
}

就此基本实现闭环！！！

上阶段余留任务：双舵机控制实现&编码器测值在仿真实时更新输出

本阶段实现任务：驱动四个电机&驱动舵机控制夹子&基本闭环

存在的一些问题：在哪给CCR设初值&四路编码器只能测出一个数值&仿真环境的使用

下一阶段任务：学习上位机使用&闭环代码完善&学习麦克纳姆轮&遥控驱动小车&红外寻迹&视觉沟通&电池给板子供电

鼬894
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
STM32__04—PMW呼吸灯
weixin_58931449的博客
05-07 2310
一，OC比较输出比较 OC比较输出可以通过比较CNT与CCR的值从而控制输出的高低电平，如当CNT>CCR时输出高电平，CNT<=CCR时输出低电平，这时我们可以通过控制CNT与CCR的值去输出不同的频率和占空比的PWM信号。 所以我们这里需要使用通用定时器的CCR寄存器（红框部分） 配置方法可以参考B站江科大这张图 注意：我们这里使用的是正极性驱动驱动（LED阴极接PA0，阳极接电源负极） 二，代码部分 1，打开RCC，使用内部时钟源 2，TIM2初始化 3...
STM32单片机入门学习笔记——定时器TIM第二部分
Raider1的博客
01-19 4606
OC（Output Compare）输出比较；IC（Input Compare）输入捕获；CC（Capture/Compare）输入捕获和输出比较的单元输出比较可以通过比较CNT（计数器）与CCR捕获/比较寄存器值的关系，来对输出电平进行置1、置0或翻转的操作，用于输出一定频率和占空比的PWM波形每个高级定时器和通用定时器都拥有4个输出比较通道，高级定时器的前3个通道额外拥有死区生成和互补输出的功能PWM频率=计数器的更新频率CK_PSC / (PSC + 1) / (ARR + 1)第一部分提到过PWM
stm32定时器--通道pwm输出参数TIM_OCInitStructure如何配置
qq_41976419的博客
06-18 3万+
设置定时器的pwm输出时需配置TIM_OCInitTypeDef结构体的参数，输入捕获是用TIM_ICInitTypeDef结构体。 typedef struct { uint16_t TIM_OCMode; // uint16_t TIM_OutputState; //输出状态 uint16_t TIM_OutputNState; //互补通道的输出状态 uint16_t TIM_Pulse; //占空比 uint16_t TIM_OCPola...
TIM_OCMode_PWM2；TIM_OCMode_PWM1
热门推荐
gtkknd的专栏
09-15 4万+
首先，本人虽然初学STM32但极力反对一种误人子弟的观点：“对于STM32这样级别的MCU，有库函数就不用去看寄存器怎么操作的了！” 好了，言归正传，最近总看到很多朋友对于PWM这个实验有很多的疑惑，看到原子也在极力的回复也挺累的（体谅一下幸苦的原子大神，(*^__^*) ），所以我打算写这么一篇文字来阐述一下我个人对STM32的PWM的理解。 首先来说，你要使用PWM模式你得
STM32定时器配置为编码器模式
m0_63171897的博客
04-14 3566
在做平衡小车时候，因为板子的缘故（STM32F103ZET6）最小系统，有一些引脚没有引出来，网上大部分的平衡小车的代码是基于STM32F103C8T6的，移植代码的时候遇到几个坑。对于F103系列来说，可以用作编码器模式的有高级定时器TIM1和TIM8，通用定时器有TIM2 TIM3 TIM4 TIM5，且每个定时器只有通道1和通道2能作为正交解码，还要注意一下定时器5和定时器2是32位定时器，装载数值时注意要装载0xffffffff。这是踩坑的主要地方，学的不够深入不了
STM32：TIM定时器输出比较（OC）
qq_44386182的博客
03-20 8019
PWM（Pluse Width Modulation）脉冲宽度调制在具有惯性的系统中，可以通过对一系列脉冲的宽度进行调制，来等效地获得所需要的模拟量，常用于电机控速等领域，也就是说，使用这个PWM波形，是用来等效地实现一个模拟信号的输出，也就是以一个很快的频率，给电机通电、断电，也就使电机维持在一个中等速度PWM参数：频率=1/Ts 占空比=Ton/Ts 分辨率=占空比变化步距这四个函数就是配置输出比较模块，一个函数配置一个单元用来给输出比较结构体赋一个默认的值的。
基于STM32单片机闭环步进电机驱动调速仿真（仿真+源码+全套资料）.zip
最新发布
10-30
【标题】：基于STM32单片机的闭环步进电机驱动调速系统 在现代自动化设备和机器人技术中，步进电机作为一种精确控制位置和速度的执行元件，被广泛应用。本项目着重介绍如何利用STM32单片机实现闭环步进电机驱动调速...
目标运动闭环跟踪模拟系统
02-13
运用多媒体定时器技术实现了对电机的内部闭环控制;采用脉冲宽度调制(PWM)技术实现了对电机的速度控制,提高了目标的仿真精度。小目标的运动速度可以达到10°/s,精度<0.1°/s,归一化标准偏差0.09。利用该装置实现了...
pwm_9_no_PLL.zip_PLL_三电平双闭环_三电平控制_三电平整流器_电平 闭环
07-14
标题中的“pwm_9_no_PLL.zip_PLL_三电平双闭环_三电平控制_三电平整流器_电平_闭环”指的是一个关于三电平整流器的MATLAB仿真模型，其中涉及到了无锁相环（PLL）的脉宽调制（PWM）控制策略和三电平双闭环控制系统。...
Proteus 仿真MSP430实例14例(带源码).rar
11-06
**Proteus 仿真MSP430实例详解** Proteus是一款强大的电子设计自动化（EDA）工具，它集成了电路原理图设计、PCB布局、元器件库、虚拟原型测试以及嵌入式软件的仿真等多种功能。MSP430系列微控制器是德州仪器（TI）...
基于FPGA的无刷直流电机闭环控制器
04-18
FPGA是一种可编程逻辑器件，能够根据设计需求灵活配置，实现数字信号处理、控制逻辑等功能。在BLDC电机控制器中，FPGA可以执行以下任务： 1. 传感器接口：连接霍尔效应传感器或编码器，获取电机转子位置信息。 2. ...
STM32固件库TIM定时器中常用函数的含义
wcl501375的博客
03-05 3487
1.TIM_DeInit函数的功能是将外设TIMx寄存器重设为值，其中x可以为2,3,4。 2.TIM_TimeBaseInit函数的功能是根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位，TIMx可以为1,2,3,4,5,8.
stm32 的定时器4产生PWM
crjmail的博客
03-29 5657
利用PB9产生PWM信号一、引脚初始化        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOB, &amp;GPIO_Ini...
stm32里toggle_STM32 定时器输出比较时间模式
weixin_39627455的博客
12-29 1157
原标题：STM32 定时器输出比较时间模式之前在《SM32定时器要点》中曾经讲过，定时器可以配置成六种模式，如下：TIM_OCMode函数库描述解释TIM_OCMode_TimingTIM输出比较冻结，输出比较不起作用TIM_OOCMode_ActiveTIM输出比较主动模式当比较发生时，强制输出高电平TIM_OCMode_InactiiveTIM输出比较非主动模式当比较发生时，强制输出低电平TI...
STM32F4XX 学习日志：定时器中断模拟PWM波实现呼吸灯
YuHWEI的博客
01-25 5395
STM32F4XX 学习日志：定时器中断模拟PWM波实现呼吸灯前言任务目标解决办法过程定时器配置标准库时钟主频配置出现问题中断服务函数主函数小结以上代码亲测有效。 前言 使用反客科技STM32F407VET6 M1的核心板，板载8M主时钟晶振（HSE），32.768kHz低速外部晶振（LSE）。含有一个用户LED以及一个用户按键。 任务目标 初学使用标准库开发，学长布置了使用定时器产生PWM波来实现呼吸灯的任务。 但是这块板子上的LED灯接在PC13的引脚上。查询了最小原理图以及数据手册后发现，PC13并
32F103的TIMER配置
WSCH_Prophet的博客
09-13 1898
void WSCH_PwmChannel(TIM_TypeDef *TIMx, uint16_t TIM_Channel_x, uint16_t TIM_PulseVal) { TIM_OCInitTypeDef TIM_OCInitStructure; STM32_GPIO_Init(PIN_T38, GPIO_Mode_AF_PP);//引脚配置 //独立配置-PWM引脚 TIM_OCInitStructure.TIM_Pulse = ...
学习记录（5）
qq_53100815的博客
05-02 565
这里写目录标题一、关于PWM输出PWM输出原理PWM工作方式相关寄存器PWM模式配置PWM输出配置步骤二、关于输入捕获 一、关于PWM输出 PWM输出原理 [注]: 向上计数模式 通过比较输入捕获寄存器的值和计数器的值，即当定时器的值小于CCRX的值时输出低电平，高于CCRX的值时输出高电平，从而产生PWM脉冲信号。 [注]: 由ARR控制周期，由CCRX控制占空比。 占空比：有效电平在一个周期内所占周期的比率。 当定时器工作在向上计数PWM 模式，且当 CNT<CCRx 时，输出 0，当 CNT&
TIM_OCMode_PWM1与TIM_OCMode_PWM2的区别
zyc18700766982的博客
09-16 5205
TIMx_CNT>TIMx_CCRn时，输出无效电平。可以是TIM_OCPolarity_High（高电平）或者TIM_OCPolarity_Low（低电平）TIMx_CNT>TIMx_CCRn时，输出有效电平。有效电平由TIM_OCInitStructure.TIM_OCPolarity决定。TIM_OCMode_PWM1 PWM模式1。TIMx_CNT
输出比较模式时的TIM_OCMode_PWM1和TIM_OCMode_PWM2区别
zhjmyx的专栏
11-05 5390
配合结构体成员TIM_OCInitTypeDef.TIM_OCPolarity来一起使用。 现在假定TIM_OCInitTypeDef.TIM_OCPolarity =TIM_OCPolarity_High,则起始波形为高电位。 若TIM_OCInitTypeDef.TIM_OCMode =TIM_OCMode_PWM1时： 当计时器值小于比较器设定值时则TIMX输出...
stm32驱动86闭环步进电机
06-24
在调试时，可以利用调试工具进行仿真和监测程序执行状态，从而找出程序中存在的问题。在优化程序时，可以利用STM32内置的DSP模块加速程序执行，提高驱动效率和精度。 综上所述，STM32控制器具有强大的驱动能力，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值