代码收藏家 基于PID控制的蓝牙循迹小车设计与实现（基于STM32F103）
目录
三、使用systick的中断函数进行pid和速度的计算，还有oled的显示
前言
经过一个月对stm32的学习，终于完成了一个小车的项目，本项目用到了pid对小车进行控速，两个电机，一个万向轮，一个3路灰度循迹模块进行循迹，0.96寸oled进行一些参数的显示，通信方式使用qt写的app传到手机，用手机与hc06蓝牙模块进行简单的通信。
一、霍尔编码器以及定时器计数原理
对于霍尔编码器，工作原理如下
可以得到两种输出方式，通过定时器的编码器计数模式进行计数，计数原理如下
从stm32的开发手册里我们可以看到，配置编码器计数模式的方法
我使用的是定时器3，4对两个电机进行计数，代码如下
void gpio_clk_init(void)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);//定时器3使能
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE);//定时器4使能
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//gpioA使能
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//gpioB使能
//定时器3gpio初始化
GPIO_InitTypeDef gpioa_init;
gpioa_init.GPIO_Pin=GPIO_Pin_6 |GPIO_Pin_7;
gpioa_init.GPIO_Pin=GPIO_Mode_IN_FLOATING;//必须配置成浮空输入
gpioa_init.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA,&gpioa_init);
//定时器4gpio初始化
GPIO_InitTypeDef gpiob_init;
gpiob_init.GPIO_Pin=GPIO_Pin_6 |GPIO_Pin_7;
gpiob_init.GPIO_Pin=GPIO_Mode_IN_FLOATING;//必须配置成浮空输入
gpiob_init.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&gpiob_init);
}
void time3_init(void)
{
NVIC_InitTypeDef nvic_init={0};
gpio_clk_init();//初始化引脚
//定时器初始化
tim3_timbase.TIM_Period=65535;//重装载值
tim3_timbase.TIM_Prescaler=0;//分频值
tim3_timbase.TIM_CounterMode=TIM_CounterMode_Up;//递增计数
tim3_timbase.TIM_ClockDivision=TIM_CKD_DIV1;//不滤波
tim3_timbase.TIM_RepetitionCounter=DISABLE;//失能缓冲区
TIM_TimeBaseInit(TIM3,&tim3_timbase);
//配置编码器捕获
tim3_icinit.TIM_Channel=TIM_Channel_1;//通道1
tim3_icinit.TIM_ICFilter=0;//滤波
tim3_icinit.TIM_ICPolarity=TIM_ICPolarity_Rising;//上升沿捕获
tim3_icinit.TIM_ICPrescaler=TIM_ICPSC_DIV1;//不分频
tim3_icinit.TIM_ICSelection=TIM_ICSelection_DirectTI;//通道选择，TIM输入1、2、3或4被选择为分别连接到IC1、IC2、IC3或IC4
TIM_EncoderInterfaceConfig(TIM3,TIM_EncoderMode_TI12,TIM_ICPolarity_Rising,TIM_ICPolarity_Rising);//配置编码器计数。BothEdge（底部边缘）
TIM_ICInit(TIM3,&tim3_icinit);
tim3_icinit.TIM_Channel=TIM_Channel_2;//通道2
TIM_ICInit(TIM3,&tim3_icinit);
//初始化标志位,计数器
TIM_ClearFlag(TIM3,TIM_FLAG_Update);//清除标志位
TIM_SetCounter(TIM3,0);//TIM3->CNT=0;
//配置中断
nvic_init.NVIC_IRQChannel=TIM3_IRQn;//中断通道
nvic_init.NVIC_IRQChannelCmd=ENABLE;//中断使能
nvic_init.NVIC_IRQChannelPreemptionPriority=2;//抢占优先级；
nvic_init.NVIC_IRQChannelSubPriority=1;//响应优先级
NVIC_Init(&nvic_init);
TIM_ITConfig(TIM3,TIM_IT_Update | TIM_IT_CC1 |TIM_IT_CC2,ENABLE);//配置定时器，允许更新中断,CC1,CC2捕获中断
TIM_Cmd(TIM3,ENABLE);//开启定时器
}
void time4_init(void)
{
NVIC_InitTypeDef nvic_init={0};
gpio_clk_init();//初始化引脚
//定时器初始化
tim4_timbase.TIM_Period=65535;//重装载值
tim4_timbase.TIM_Prescaler=0;//分频值
tim4_timbase.TIM_CounterMode=TIM_CounterMode_Up;//递增计数
tim4_timbase.TIM_ClockDivision=TIM_CKD_DIV1;//不滤波
tim4_timbase.TIM_RepetitionCounter=DISABLE;//失能缓冲区
TIM_TimeBaseInit(TIM4,&tim4_timbase);
//配置编码器捕获
tim4_icinit.TIM_Channel=TIM_Channel_1;//通道1
tim4_icinit.TIM_ICFilter=0;//滤波
tim4_icinit.TIM_ICPolarity=TIM_ICPolarity_Rising;//上升沿捕获
tim4_icinit.TIM_ICPrescaler=TIM_ICPSC_DIV1;//不分频
tim4_icinit.TIM_ICSelection=TIM_ICSelection_DirectTI;//通道选择，TIM输入1、2、3或4被选择为分别连接到IC1、IC2、IC3或IC4
TIM_EncoderInterfaceConfig(TIM4,TIM_EncoderMode_TI12,TIM_ICPolarity_Rising,TIM_ICPolarity_Rising);//配置编码器计数。BothEdge（底部边缘）
TIM_ICInit(TIM4,&tim4_icinit);
tim4_icinit.TIM_Channel=TIM_Channel_2;//通道2
TIM_ICInit(TIM4,&tim4_icinit);
//初始化标志位,计数器
TIM_ClearFlag(TIM4,TIM_FLAG_Update);//清除标志位
TIM_SetCounter(TIM4,0);//TIM4->CNT=0;
//配置中断
nvic_init.NVIC_IRQChannel=TIM4_IRQn;//中断通道
nvic_init.NVIC_IRQChannelCmd=ENABLE;//中断使能
nvic_init.NVIC_IRQChannelPreemptionPriority=2;//抢占优先级；
nvic_init.NVIC_IRQChannelSubPriority=1;//响应优先级
NVIC_Init(&nvic_init);
TIM_ITConfig(TIM4,TIM_IT_Update | TIM_IT_CC1 |TIM_IT_CC2,ENABLE);//配置定时器，允许更新中断,CC1,CC2捕获中断
TIM_Cmd(TIM4,ENABLE);//开启定时器
}还有编写中断函数，对计数值进行处理
void TIM3_IRQHandler(void)
{
//uint8_t i;
if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//判断是否为更新中断
{
TIM_ClearFlag(TIM3,TIM_IT_Update);
}
if((TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)||(TIM_GetITStatus(TIM3, TIM_IT_CC2) != RESET))//判断是否为捕获中断
{
left_count=(short)TIM3->CNT;
TIM_ClearFlag(TIM3, TIM_IT_CC1|TIM_IT_CC2);//清除标志位
}
}
void TIM4_IRQHandler(void)
{
if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)//判断是否为更新中断
{
TIM_ClearFlag(TIM4,TIM_IT_Update);
}
if((TIM_GetITStatus(TIM4, TIM_IT_CC1) != RESET)||(TIM_GetITStatus(TIM4, TIM_IT_CC2) != RESET))//判断是否为捕获中断
{
right_count=(short)TIM4->CNT;
TIM_ClearFlag(TIM4, TIM_IT_CC1|TIM_IT_CC2);//清除标志位
}
}在将电机的AB和编码器供电两极连接到对应引脚就能计数了，可以手动转动轮子，使用串口对计数进行打印，能观察到计数值。
二、使用pwm占空比对电机速度进行控制
我使用的是定时器2进行4路pwm输出，由于定时器2使用了串口2，串口2我用于蓝牙通信，所以需要重定向
我这里使用定时器2的完全重定向到PB10，PB11，PB3，PA15
重定向方法：
定时器2的引脚使用组合：
1.当不重映射时，IO口是PA0、PA1、PA2、PA3
2.要使用PA15、PB3、PA2、PA3的端口组合，要调用下面的语句进行部分重映射：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); //重映射必须要开AFIO时钟
GPIO_PinRemapConfig(GPIO_PartialRemap1_TIM2, ENABLE);
3.要使用PA0、PA1、PB10、PB11的端口组合，要调用下面的语句进行部分重映射：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); //重映射必须要开AFIO时钟
GPIO_PinRemapConfig(GPIO_PartialRemap2_TIM2, ENABLE);
4.要使用PA15、PB3、PB10、PB11的端口组合，要调用下面的语句进行完全重映射：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); //重映射必须要开AFIO时钟
GPIO_PinRemapConfig(GPIO_FullRemap_TIM2, ENABLE);
同时还要禁用JTAG功能，PA15、PB3、PB10、PB11才会正常输出。
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable , ENABLE);//必须禁用swj
代码如下：
void time2_init(void)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);//定时器2使能
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//gpioA使能
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//gpioB使能
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);//AFIO时钟使能
GPIO_PinRemapConfig(GPIO_FullRemap_TIM2,ENABLE);//定时器2重映射,PA15,PB3,PB10,PB11
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable , ENABLE);//必须禁用swj
//定时器2gpio初始化
gpioc_init.GPIO_Pin=GPIO_Pin_3 |GPIO_Pin_10 | GPIO_Pin_11;
gpioc_init.GPIO_Mode=GPIO_Mode_AF_PP;
gpioc_init.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&gpioc_init);
gpioc_init.GPIO_Pin=GPIO_Pin_15 ;
GPIO_Init(GPIOA,&gpioc_init);
//初始化定时器1
tim2_timbase.TIM_Period=999;
tim2_timbase.TIM_Prescaler=359;
tim2_timbase.TIM_ClockDivision=TIM_CKD_DIV1;
tim2_timbase.TIM_CounterMode=TIM_CounterMode_Up;
tim2_timbase.TIM_RepetitionCounter=DISABLE;
TIM_TimeBaseInit(TIM2,&tim2_timbase);
//初始化PWM
tim2_oc.TIM_OCMode=TIM_OCMode_PWM1;//模式PWM
tim2_oc.TIM_Pulse=0;//比较值
tim2_oc.TIM_OutputState=TIM_OutputState_Enable;//输出比较使能
tim2_oc.TIM_OCPolarity=TIM_OCPolarity_High;//输出极性 高电平
TIM_OC1Init(TIM2,&tim2_oc);//通道1
TIM_OC2Init(TIM2,&tim2_oc);//通道2
TIM_OC3Init(TIM2,&tim2_oc);//通道3
TIM_OC4Init(TIM2,&tim2_oc);//通道4
TIM_SetCounter(TIM2,0);//TIM3->CNT=0;计数清0
TIM_CtrlPWMOutputs(TIM2,ENABLE); //MOE 主输出使能（高级定时器必须设置）
TIM_Cmd(TIM2, ENABLE); //使能tim2
}这样定时器2，3，4我们就配置好了，通过修改定时器2每个通道pwm的占空比就能控制电机的转速了
三、使用systick的中断函数进行pid和速度的计算，还有oled的显示
代码如下：
void SysTick_Handler(void)
{
float left_speed=0;//左轮转轴速度
float right_speed=0;//右轮转轴速度
float left_pwm=0;
int left_temp=0;//pid调试用，表示当前速度
float right_pwm=0;
int right_temp=0;//pid调试用，表示当前速度
int integer=0;//整数
int decimal=0;//小数
i++;
if(i>=100)//0.1s，适当要大，因为pwm控速时间越长越稳定
{
//数据处理
left_speed=((float)left_count/1320)*10;//速度=计数值/转一圈的计数值*时间系数，单位：圈/s
right_speed=((float)right_count/1320)*10;//速度=计数值/转一圈的计数值*时间系数，单位：圈/s
if(left_count<0)
left_speed=-left_speed;
if(right_count<0)
right_speed=-right_speed;
//oled显示
j++;
if(j>20)//2s刷新一次,因为耗时较大
{
if(motion_mode==1)//前进
{
integer=left_speed;//整数
decimal=(left_speed-integer)*100;//小数
oled_show_string(65,5,"+",12);
}
else if(motion_mode==-1)//后退
{
integer=right_speed;//整数
decimal=(right_speed-integer)*100;//小数
oled_show_string(65,5,"-",12);
}
if(left_count!=0 || right_count!=0)//电机转动
{
//printf("count=%d\r\n",count);//脉冲个数
//printf("integer=%d,decimal=%d\r\n",integer,decimal);//速度
cap_flag=1;//电机转动
oled_show_num(65,17,integer,2,12);//显示整数
oled_show_char(81,20,'.',12,1);
oled_show_num(97,20,decimal,2,12);//显示小数
oled_show_num(65,33,integer,2,12);//显示整数
oled_show_char(81,35,'.',12,1);
oled_show_num(97,33,decimal,2,12);//显示小数
oled_area_refresh_gram(65,0,108,48);//oled更新
}
else//电机未转动
{
if(cap_flag==1)//判断是否之前转动过，防止车轮未转而重复刷新
{
oled_area_clear(65,0,108,48);
oled_area_refresh_gram(65,0,108,48);//oled更新
cap_flag=0;
}
}
j=0;
SysTick_Config(90000);//使用systick延时后必须重新配置，i2c中使用了，所以必须重新配置
}
//printf("cap_flag=%d,left_count=%d,right_count=%d\r\n",cap_flag,left_count,right_count);
//printf("left_count=%d,left_speed=%f,compara_add=%d\r\n",left_count,left_speed,left_compara);
//printf("right_count=%d,right_speed=%f,right_add=%d\r\n",right_count,right_speed,right_compara);
//pid算法实现
if(open)
{
//(位置离散pid)
left_pwm = PID_realize(&left_pid,left_speed*SPEED_AMPLIF);//逐步调整pwm值到set_point(目标值)(位置离散pid) 速度放大100倍，便于调试
left_compara+=(int)left_pwm;
right_pwm = PID_realize(&right_pid,right_speed*SPEED_AMPLIF);//逐步调整pwm值到set_point(目标值)(位置离散pid) 速度放大100倍，便于调试
right_compara+=(int)right_pwm;
//(增量式pid)
//pwm=PID_add_realize(shaft_speed*SPEED_AMPLIF);//逐步调整pwm值到set_point(目标值)(增量式pid) 速度放大100倍，便于调试
//compara_add=(int)pwm;
left_temp=left_speed*SPEED_AMPLIF;
right_temp=right_speed*SPEED_AMPLIF;
}
set_computer_value(SEND_FACT_CMD, CURVES_CH1, &left_temp, 1);//发送实际值,通道选择ch1以让软件显示图像
set_computer_value(SEND_FACT_CMD, CURVES_CH2, &right_temp, 1);//发送实际值,通道选择ch1以让软件显示图像
i=0;
TIM_SetCounter(TIM3,0);//计数清零
TIM_SetCounter(TIM4,0);//计数清零
left_count=0;//计数清零
right_count=0;//计数清零
}set_computer_value函数是通过串口发送数据到野火的调试助手，可以用于调整合适的pid；
野火的调试助手需要移植到自己的项目中才能使用串口进行通信，移植方法如下
1、野火的protocol.h和protocol.c两个文件添加到项目中，这两个文件包含了通信协议，并进行适当修改
2、修改自己的串口1中断函数，并添加一个Usart_SendArray函数
//用于pid调试
void USART1_IRQHandler(void) //串口1中断服务程序
{
uint8_t ucTemp;
if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE) != RESET)//判断是哪个进入了中断函数
{
ucTemp = USART_ReceiveData(DEBUG_USARTx);//有清除RXNE功能，下面不需要写clearitpending
protocol_data_recv(&ucTemp, 1);
//Usart_SendByte(DEBUG_USARTx,ucTemp);
}
USART_ClearITPendingBit(DEBUG_USARTx,USART_IT_RXNE);
}
/* 发送8位数据的数组 */
void Usart_SendArray(USART_TypeDef* USARTx, uint8_t *array,uint8_t num)
{
uint8_t i;
for( i=0; i<num; i++ )
{
Usart_SendByte(USARTx, array[i]);
}
while( USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET );
}3、main函数要protocol_init(); //初始化pid串口调试协议
结果如图：
四、常用的测速方法：
我使用的是M法
left_speed=((float)left_count/1320)*10;//速度=计数值/转一圈的计数值*时间系数，单位：圈/s
right_speed=((float)right_count/1320)*10;//速度=计数值/转一圈的计数值*时间系数，单位：圈/s五、pid原理
积分控制法也就是 位置离散pid；本项目使用的就是积分控制法
微分控制法也就是 增量式pid；
通过调整Kp，Ki，Kd能达到自己预期的效果，我使用的是试凑法，通过野火串口调试助手进行调参
代码如下
//pid结构体存储数据(位置离散pid)
extern struct _pid{
float target_val; //定义设定值
float actual_val; //定义实际值
float err; //定义偏差值
float integral; //定义积分值
float err_last; //定义上一个偏差值
float Kp,Ki,Kd; //定义比例、积分、微分系数
}left_pid,right_pid;
//pid结构体存储数据(增量式pid)
extern struct _pid_add{
float target_val; //定义设定值
float actual_val; //定义实际值
float err; //定义偏差值
float err_next; //定义下一个
float err_last; //定义最后一个偏差值
float Kp,Ki,Kd; //定义比例、积分、微分系数
}pid_add;
//pid初始化(位置离散pid)
void PID_init(void)
{
left_pid.target_val=0.0;
left_pid.actual_val=0.0;
left_pid.err=0.0;
left_pid.err_last=0.0;
left_pid.integral=0.0;
left_pid.Kp=1;//第一个调，曲线快速上升
left_pid.Ki=0.003;//第三个调，增加波动
left_pid.Kd=1.2;//第二个调，曲线快速稳定在目标
right_pid.target_val=0.0;
right_pid.actual_val=0.0;
right_pid.err=0.0;
right_pid.err_last=0.0;
right_pid.integral=0.0;
right_pid.Kp=1;//第一个调，曲线快速上升
right_pid.Ki=0.003;//第三个调，增加波动
right_pid.Kd=1.2;//第二个调，曲线快速稳定在目标
}
//pid初始化(增量式pid)
void PID_add_init(void)
{
pid_add.target_val=0.0;
pid_add.actual_val=0.0;
pid_add.err=0.0;
pid_add.err_last=0.0;
pid_add.err_next=0.0;
pid_add.Kp=1;//第二个调，曲线快速稳定在目标
pid_add.Ki=0.75;//第一个调，曲线快速上升
pid_add.Kd=0.5;//第三个调,曲线波动小
}
//设置pid
void set_p_i_d(float P,float I,float D)
{
left_pid.Kp=P;
left_pid.Ki=I;
left_pid.Kd=D;
right_pid.Kp=P;
right_pid.Ki=I;
right_pid.Kd=D;
pid_add.Kp=P;
pid_add.Ki=I;
pid_add.Kd=D;
}
//pid算法(位置离散pid)
float PID_realize(struct _pid *pid,float speed)
{
pid->err=pid->target_val-speed;//计算目标值与实际值的误差
pid->integral+=pid->err;//误差累计
pid->actual_val=pid->Kp*pid->err+pid->Ki*pid->integral+pid->Kd*(pid->err-pid->err_last);//pid算法（位置离散pid）
//printf("pid.err=%f,pid.integral=%f,pid.err_last=%f,pid.actual_val=%f\r\n",pid->err,pid->integral,pid->err_last,pid->actual_val);
pid->err_last=pid->err;//误差传递
return pid->actual_val;//返回实际值
}
//pid算法(增量式pid)
float PID_add_realize(float speed)
{
pid_add.err=pid_add.target_val-speed;//计算目标值与实际值的误差
float increment_val=pid_add.Kp*(pid_add.err-pid_add.err_next)+pid_add.Ki*pid_add.err+pid_add.Kd*(pid_add.err-2*pid_add.err_next+pid_add.err_last);
pid_add.actual_val+=increment_val;//累计
pid_add.err_last=pid_add.err_next;//误差传递
pid_add.err_next=pid_add.err;//误差传递
return pid_add.actual_val;//返回实际值
}六、oled的实现
我的oled使用的是iic通信协议，这里要注意，我使用了systick来进行延时，所以使用完后要重新设置systick，你也可以自己设置一个基本定时器来进行延时或者代替systick。
SysTick_Config(90000); //1ms,必须放在delay_us和delay_ms后，
oled相关代码：
//OLED的显存, 每个字节表示8个像素, 128,表示有128列, 8表示有64行, 高位表示第行数.
static uint8_t g_oled_gram[128][8];
//写命令
void oled_write_cmd(uint8_t cmd)
{
i2c_star();
i2c_write_byte(0x78);//oled地址
i2c_wait_ack();
i2c_write_byte(0x00);//写命令命令
i2c_wait_ack();
i2c_write_byte(cmd);//写命令
i2c_wait_ack();
i2c_stop();
}
//写数据
void oled_write_data(uint8_t dat)
{
i2c_star();
i2c_write_byte(0x78);//oled地址
i2c_wait_ack();
i2c_write_byte(0x40);//写数据命令
i2c_wait_ack();
i2c_write_byte(dat);//写数据
i2c_wait_ack();
i2c_stop();
}
//全屏更新
void oled_all_refresh_gram(void)
{
uint8_t i,j;
for(i=0;i<8;i++)//设置为8页
{
oled_write_cmd(0xb0 |i);//设置页
oled_write_cmd(0x00);//设置列（低4bit）因为128列，至少要7bit
oled_write_cmd(0x10);//设置列（高4bit）
for(j=0;j<128;j++)
{
oled_write_data(g_oled_gram[j][i]);//写入数据
}
}
}
//区域更新
void oled_area_refresh_gram(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2)
{
uint8_t pos1,pos2,i,j;
if (x1 > 127 || y1 > 63) return; /* 超出范围了. */
if (x2 > 127 || y2 > 63) return; /* 超出范围了. */
pos1=y1/8;
pos2=y2/8;
for(i=pos1;i<=pos2;i++)//设置为8页
{
oled_write_cmd(0xb0 |i);//设置页
for(j=x1;j<=x2;j++)
{
oled_write_cmd(j&0xf);//设置列（低4bit）因为128列，至少要7bit
oled_write_cmd((j>>4)|0x10);//设置列（高4bit）
oled_write_data(g_oled_gram[j][i]);//写入数据
}
}
}
//全屏清屏
void oled_all_clear(void)
{
uint8_t i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 128; j++)
g_oled_gram[j][i] = 0X00;
oled_all_refresh_gram(); /* 更新显示 */
}
//区域清屏
void oled_area_clear(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2)
{
uint8_t pos1,pos2,i,j;
if (x1 > 127 || y1 > 63) return; /* 超出范围了. */
if (x2 > 127 || y2 > 63) return; /* 超出范围了. */
pos1=y1/8;
pos2=y2/8;
//printf("x1=%d,y1=%d,x2=%d,y2=%d,pos1=%d,pos2=%d\r\n",x1,y1,x2,y2,pos1,pos2);
for(i=pos1;i<=pos2;i++)//设置为8页
for(j=x1;j<=x2;j++)
{
//printf("i=%d,j=%d\r\n",i,j);
g_oled_gram[j][i] = 0X00;
}
}
//全屏点亮
void oled_fill(void)
{
uint8_t i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 128; j++)
g_oled_gram[j][i] = 0XFF;
oled_all_refresh_gram(); /* 更新显示 */
}
//打开
void oled_display_on(void)
{
oled_write_cmd(0X8D); /* SET DCDC命令 */
oled_write_cmd(0X14); /* DCDC ON */
oled_write_cmd(0XAF); /* DISPLAY ON */
}
//关闭
void oled_display_off(void)
{
oled_write_cmd(0X8D); /* SET DCDC命令 */
oled_write_cmd(0X10); /* DCDC OFF */
oled_write_cmd(0XAE); /* DISPLAY OFF */
}
//oled初始化
void oled_init(void)
{
i2c_init();//i2c初始化
delay_ms(100);//延时，重要
oled_write_cmd(0xAE); /* 关闭显示 */
oled_write_cmd(0xD5); /* 设置时钟分频因子,震荡频率 */
oled_write_cmd(0xf0); /* [3:0],分频因子;[7:4],震荡频率 */
oled_write_cmd(0xA8); /* 设置驱动路数 */
oled_write_cmd(0X3F); /* 默认0X3F(1/64) */
oled_write_cmd(0xD3); /* 设置显示偏移 */
oled_write_cmd(0X00); /* 设置列（低4bit）*/
oled_write_cmd(0x10);//设置列（高4bit）
oled_write_cmd(0x40); /* 设置显示开始行 [5:0],行数. */
oled_write_cmd(0x8D); /* 电荷泵设置 */
oled_write_cmd(0x14); /* bit2，开启/关闭 */
oled_write_cmd(0x20); /* 设置内存地址模式 */
oled_write_cmd(0x02); /* [1:0],00，列地址模式;01，行地址模式;10,页地址模式;默认10; */
oled_write_cmd(0xb0); //开启地址0-7
oled_write_cmd(0xA1); /* 段重定义设置,bit0:0,0->0;1,0->127; */
oled_write_cmd(0xC8); /* 设置COM扫描方向;bit3:0,普通模式;1,重定义模式 COM[N-1]->COM0;N:驱动路数 */
oled_write_cmd(0xDA); /* 设置COM硬件引脚配置 */
oled_write_cmd(0x12); /* 128*64 */
oled_write_cmd(0x81); /* 对比度设置 */
oled_write_cmd(0xEF); /* 1~255;默认0X7F (亮度设置,越大越亮) */
oled_write_cmd(0xD9); /* 设置预充电周期 */
oled_write_cmd(0x22); //充电时间
oled_write_cmd(0xf1); /* [3:0],PHASE 1;[7:4],PHASE 2; */
oled_write_cmd(0xDB); /* 设置VCOMH 电压倍率 */
oled_write_cmd(0x20); //0x20,0.77xVcc
oled_write_cmd(0xA4); /* 全局显示开启;bit0:1,开启;0,关闭;(白屏/黑屏) */
oled_write_cmd(0xA6); /* 设置显示方式;bit0:1,反相显示;0,正常显示 */
oled_write_cmd(0xAF); /* 开启显示 */
oled_all_clear();
}
//画点
void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot)
{
uint8_t pos, bx, temp = 0;
if (x > 127 || y > 63) return; /* 超出范围了. */
pos = y / 8; /* 计算GRAM里面的y坐标所在的字节, 每个字节可以存储8个行坐标 */
bx = y % 8; /* 取余数,方便计算y在对应字节里面的位置,及行(y)位置 */
temp = 1 << bx; /* 高位表示低行号, 得到y对应的bit位置,将该bit先置1 */
if (dot) /* 画实心点 */
{
g_oled_gram[x][pos] |= temp;
}
else /* 画空点,即不显示 */
{
g_oled_gram[x][pos] &= ~temp;
}
}
// 显示字符
void oled_show_char(uint8_t x, uint8_t y, uint8_t chr, uint8_t size, uint8_t mode)
{
uint8_t temp, t, t1;
uint8_t y0 = y;
uint8_t *pfont = 0;
uint8_t csize = (size / 8 + ((size % 8) ? 1 : 0)) * (size / 2); /* 得到字体一个字符对应点阵集所占的字节数 */
chr = chr - ' '; /* 得到偏移后的值,因为字库是从空格开始存储的,第一个字符是空格 */
if (size == 12) /* 调用1206字体 */
{
pfont = (uint8_t *)oled_asc2_1206[chr];
}
else if (size == 16) /* 调用1608字体 */
{
pfont = (uint8_t *)oled_asc2_1608[chr];
}
else if (size == 24) /* 调用2412字体 */
{
pfont = (uint8_t *)oled_asc2_2412[chr];
}
else /* 没有的字库 */
{
return;
}
for (t = 0; t < csize; t++)
{
temp = pfont[t];
for (t1 = 0; t1 < 8; t1++)
{
if (temp & 0x80)oled_draw_point(x, y, mode);
else oled_draw_point(x, y, !mode);
temp <<= 1;
y++;
if ((y - y0) == size)
{
y = y0;
x++;
break;
}
}
}
}
//平方函数, m^n
static uint32_t oled_pow(uint8_t m, uint8_t n)
{
uint32_t result = 1;
while (n--)
{
result *= m;
}
return result;
}
//显示len个数字
void oled_show_num(uint8_t x, uint8_t y, uint32_t num, uint8_t len, uint8_t size)
{
uint8_t t, temp;
uint8_t enshow = 0;
for (t = 0; t < len; t++) /* 按总显示位数循环 */
{
temp = (num / oled_pow(10, len - t - 1)) % 10; /* 获取对应位的数字 */
if (enshow == 0 && t < (len - 1)) /* 没有使能显示,且还有位要显示 */
{
if (temp == 0)
{
oled_show_char(x + (size / 2)*t, y, ' ', size, 1); /* 显示空格,站位 */
continue; /* 继续下个一位 */
}
else
{
enshow = 1; /* 使能显示 */
}
}
oled_show_char(x + (size / 2)*t, y, temp + '0', size, 1); /* 显示字符 ，因为是通过两页写的所以size除2*/
}
}
//显示字符串
void oled_show_string(uint8_t x, uint8_t y, const char *p, uint8_t size)
{
while ((*p <= '~') && (*p >= ' ')) /* 判断是不是非法字符! */
{
if (x > (128 - (size / 2))) /* 宽度越界 */
{
x = 0;
y += size; /* 换行 */
}
if (y > (64 - size)) /* 高度越界 */
{
y = x = 0;
oled_all_clear();
}
oled_show_char(x, y, *p, size, 1); /* 显示一个字符 */
x += size / 2; /* ASCII字符宽度为汉字宽度的一半 因为是通过两页写的所以size除2*/
p++;
}
}
七、蓝牙通信
使用串口2
首先对串口2进行初始化
再编写中断函数，通过中断函数对手机发来的数据进行处理，代码如下
void USART2_IRQHandler(void) //串口x中断服务程序
{
float val=0;
uint8_t i=0;
uint8_t temp2;
float decimal=0;
if(USART_GetITStatus(USART2,USART_IT_RXNE) != RESET)//判断中断位
{
USART_ClearITPendingBit(USART2, USART_IT_RXNE);
temp2 = USART_ReceiveData(USART2); //接收数据
if(temp2!='\n')
{
//printf("temp2=%c\r\n",temp2);
if(temp2=='.')
{
integer_flag=2;
return;
}
if(integer_flag==0)//整数部分
{
integer_val=temp2-48;
integer_flag=1;
}
else if(integer_flag==1)
integer_val=integer_val*10+temp2-48;
if(integer_flag==2)//小数部分
{
decimal=(temp2-48);
for(i=0;i<decimal_bit;i++)
decimal/=10;
decimal_val+=decimal;
decimal_bit++;//小数位数
}
}
else
{
val=integer_val+decimal_val;
printf("data=%.2f\r\n",val);
integer_flag=0;
decimal_bit=1;
integer_val=0;
decimal_val=0;
switch((int)val)
{
case 490://停止
left_compara=0;
right_compara=0;
motion_mode=0;
open=0;
break;
case 491://前进
left_compara=0;
right_compara=0;
motion_mode=1;
open=1;
break;
case 492://后退
left_compara=0;
right_compara=0;
motion_mode=-1;
open=1;
break;
case 493://左转
left_compara=0;
right_compara=0;
motion_mode=2;
open=1;
break;
case 494://右转
left_compara=0;
right_compara=0;
motion_mode=3;
open=1;
break;
case 501://蓝牙按键模式
tracking_mod=0;
break;
case 502://循迹模式
tracking_mod=1;
break;
}
if((int)val<10)
{
if(val>3.5)//最大速度
val=3.5;
left_targetspeed=val;//速度放大100倍，便于调试,
right_targetspeed=val;//速度放大100倍，便于调试
}
}
}
} 本人使用的是qt自己开发的一个小app，效果如下
八、3路循迹模块
我使用的是中间3路，当没有遇到黑线是对应引脚输出高电平，灯亮；遇到黑线对应引脚时输出低电平，灯灭。
1、对使用到的gpio初始化，设置为输入模式
2、通过对应引脚的电平循迹
代码如下
if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_14)==0)//中
{
left_set_point=left_targetspeed*SPEED_AMPLIF;//速度放大100倍，便于调试,
right_set_point=right_targetspeed*SPEED_AMPLIF;//速度放大100倍，便于调试
TIM_SetCompare1(TIM2,0);
TIM_SetCompare2(TIM2,left_compara);
TIM_SetCompare3(TIM2,0);
TIM_SetCompare4(TIM2,right_compara);
}
else if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_13)==0)//左
{
left_set_point=left_targetspeed/2*SPEED_AMPLIF;//0.5m/s.速度放大100倍，便于调试,
right_set_point=right_targetspeed*SPEED_AMPLIF;//1m/s.速度放大100倍，便于调试
left_compara=0;
TIM_SetCompare1(TIM2,0);
TIM_SetCompare2(TIM2,0);
TIM_SetCompare3(TIM2,0);
TIM_SetCompare4(TIM2,right_compara);
}
else if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_15)==0)//右
{
right_set_point=right_targetspeed/2*SPEED_AMPLIF;//0.5m/s.速度放大100倍，便于调试
left_set_point=left_targetspeed*SPEED_AMPLIF;//1m/s.速度放大100倍，便于调试,
right_compara=0;
TIM_SetCompare1(TIM2,0);
TIM_SetCompare2(TIM2,left_compara);
TIM_SetCompare3(TIM2,0);
TIM_SetCompare4(TIM2,0);
}就此，整个流程结束。
总结
经过这个小项目我获得了很多收获，虽然工程中遇到很多问题，有的问题会困扰我一天，但是做出来后，我觉得一切的努力都是值得的，可能这个小车还有可以改进的地方，欢迎建议。
