21年F题送药小车（单车）

最新推荐文章于 2024-09-18 00:02:13 发布
最新推荐文章于 2024-09-18 00:02:13 发布
阅读量412 收藏 10
点赞数 8
文章标签： stm32 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79977177/article/details/141222467
版权

哈哈哈，这篇博客想写很久了，但一直拖着没写，毕竟我可是拖延癌晚期患者。OK，话不多说。

这个题是我们学校校赛的题目，当时刚接触stm32才半个月不到吧，刚刚跟完江科大的课程，只做了单纯的一个寻迹小车，哈哈哈。其实对于送药小车这个题目来讲，电控是很简单的，难的是数字识别，你怎么让数字识别的又快又好是这道题的难点（k210这个是我负责视觉模块的队友负责的，但我这里有以前学长的代码，应该也是可以用的，如果有需要可以私信我）。

那么我先说一说电控方向的思路，其实对于第一问来讲，电控真的相当简单，就是让识别到数字1或数字2的时候进入一个你写的函数中（最好别在主函数中写，不然到时候你想改东西的时候可能一不小心改错一个地方就会出事）。然后的代码就是循迹和识别到岔路口转90°了。循迹这个不用说，是最简单的一个东西，不会的朋友可以去看我下一篇博客。至于蓝牙，当时让我另一个队友去搞，其实是很简单的东西，但当时我们课程确实很紧，就没有搞出来。但我后面用了zigbee，就很快搞出来了。但这个题还是没赶得上用，最后我会附上zigbee端的代码（江科大串口收发稍作修改即可）。至于双车，其实有了蓝牙之后双车就很简单了，完全可以自己写出来的。

那么怎么识别到岔路呢？如果你是选择的视觉巡线（用openmv），那你可以就让你视觉模块的队友去星瞳官网上找代码，这些都是有的。直接openmv识别到岔路口转就行了（这种得要延时一下，因为视觉一定是会提前看到的）。如果是灰度循迹，那就直接全部都识别到的时候转就行了。那对于这道题来讲，我个人是推荐视觉的，主要我们就是用视觉做的，哈哈哈。为什么不推荐灰度，因为灰度会有一定概率被数字遮挡导致提前识别，这是一个比较难以避免的问题（选择哪种12路的可能会好一点？）。

然后就是转90°了。这个但是可把我们给害惨了。当时还不太掌握霍尔编码器的使用方法，只能直接给pwm，这就导致了电池的电量也会影响他的转弯，所以我个人是推荐使用编码器的，记录到一遍轮子的一定脉冲数就说明我转过了90，还是相对比较稳定的。当然还可以使用陀螺仪，但一定不要用mpu6050，不然你的程序可能直接就卡死，就会导致循迹也会抽风的情况，对于这道题还是谨慎使用。（这个代码后面没有继续优化了，所以是直接给pwm的）。

至于药品的识别，直接用一个反射式红外传感器调好阈值就可以了。这个代码江科大模数转换那直接拿过来用就可以了。

openmv和k210和stm32通信代码去csdn搜索“Openmv识别Apriltag码并与stm32进行串口通信”，直接拿来用就好了。

下面上代码

主函数：

#include "stm32f10x.h"               // Device header
#include "Delay.h"
#include "OLED.h"
#include "Motor.h"
#include "Serial.h"
#include "encoder.h"
#include "pid.h"
#include "AD.h"
#include "K210.h"
#include "CROSS1.h"
#include "CROSS2.h"
#include "CROSS3.h"
#include "CROSS4.h"
#include "PWM.h"
#include "LED.h"


uint16_t AD_value;

int main(void)
{
	
	OLED_Init();
	Motor_Init();
	Serial_Init();
	Encoder_Init();
	pid_init();
	K210_Init();
	AD_Init();
	LED_Init();
	PWM_Init();
	
	OLED_ShowString(1,1,"speed:");
	OLED_ShowString(2,1,"speed:");
	OLED_ShowString(3,1,"x:");
	
	OLED_ShowString(4,1,"type:");
	OLED_ShowString(1,10,"AD:");
	OLED_ShowString(2,10,"NUM:");
	OLED_ShowString(3,10,"TAY:");
	
	while(1)
	{
			OLED_ShowNum(1,7,num,2);
		OLED_ShowNum(3,3,x_translation ,5);
		OLED_ShowNum(4,6,tag_id,2);
		if(num == 1 | num == 2)
		{
			CROSS1();
			LED_GREEN_ON();
		}
		else if(num == 3 | num == 4)
		{
			CROSS2();
			LED_GREEN_ON();
		}
		else if(num == 5 | num == 6)
		{
			CROSS3();
			LED_GREEN_ON();
		}
		else if(num == 7 | num == 8)
		{
			CROSS4();
			LED_GREEN_ON();
		}
	}
}

第一问（tag_id就是openmv识别到不同路口类型传不同的参数）：


#include "stm32f10x.h"                  // Device header

#include "Delay.h"
#include "motor.h"
#include "Serial.h"
#include "pid.h"
#include "AD.h"
#include "K210.h"
#include "LED.h"
#include "OLED.h"

uint16_t AD_value1 ;
uint16_t see ;//标识符
uint16_t way1;//停下来的次数,第二次停下就不能再转180
uint16_t dir1;//第几次转弯

#define A 2500//阈值
#define B 2000

#define S1 31//左轮速度
#define S2 31//右轮速度
#define V1 32//补转弯时的误差速度
#define V2  29 //转180速度
#define T1  435//小车转弯前直行延时
#define T2  915 //小车左转弯时延时
#define T5  885 //小车右转弯时延时
#define T6  935 //小车右转弯时延时//数字2
#define T7  915 //小车左转弯时延时//数字2
#define T3  900//小车转180延时
#define T4  375//识别到药房继续往前走

void CROSS1(void)
{
	K210_Init();
	Motor_Init();
	Serial_Init();
	pid_init();
	AD_Init();
	LED_Init();
	
	while(see != 3)
	{
		OLED_ShowNum(1,13,AD_GetValue(),4); 
		OLED_ShowNum(2,14,num,2);
		OLED_ShowNum(3,14,tay,2);
		OLED_ShowNum(1,7,left_speed,2);
        OLED_ShowNum(2,7,right_speed,2);
		OLED_ShowNum(3,3,x_translation ,5);
		OLED_ShowNum(4,6,tag_id,2);
		OLED_ShowNum(4,10,dir1,2);
		if(num == 1)//识别到数字1，要左转
		{
			STOP();
			if(see == 0)
				{
					
					STOP();
					if(AD_GetValue() > A)//装上药品
					{
						see = 1;
					}
				}
			
		
			else if(see == 1)
				{
					pid_contorl();
					if(dir1 == 0)
					{
						if(tag_id == 1)//识别到路口了，此时是数字1，要左转
						{
							ON(V1,V1);
							Delay_ms(T1);
							ON(0,S2);
							Delay_ms(T2);
						}
						
						if(tag_id == 3)//送到药房了，要开始卸药
						{
							ON(S1,S2);
							Delay_ms(T4);
							uint16_t i = 1;
							LED_RED_ON();
							Delay_ms(50);
							STOP();
							Delay_ms(1000);
							way1 += 1;//第一次停下
							while(i != 0)
								{
						if(AD_GetValue() < B)//卸下药品了
						{
							see = 2;
							LED_RED_OFF();
							i = 0; 
						}
						if( i == 0)
						{
						break;
						}
							}
						}
					}
					else if(dir1 == 1)
					{
						if(tag_id == 1 )//第二次识别到路口了，此时是返回，要右转
						{
						ON(V1,V1);
						Delay_ms(T1);
						ON(S1,0);
						Delay_ms(T5);
							STOP();
							Delay_ms(200);
						}
						
						else if(tag_id == 3)//回到药房了
						{
							ON(S1,S2);
							Delay_ms(T4);
						LED_GREEN_ON();
						STOP();
						Delay_ms(1500);
							see = 3;
						}
					}
			
				}
				else if(see == 2)//向后转180
				{
						dir1 += 1;
					Delay_ms(500);
					Turnover(V2,V2);
					Delay_ms(T3);
					STOP();
					Delay_ms(600);
					tag_id = 0;
					see = 1;
					
				}
				else if(see == 3)//回到出发点了
				{
					ON(S1,S2);
					Delay_ms(T4);
					LED_GREEN_ON();
					STOP();
				}
			}
		
			
			if(num == 2)//要右转
			{
			STOP();
			if(see == 0)
				{
					STOP();
					if(AD_GetValue() > 	A)//装上药品
					{
						see = 1;
					}
				}
			
		
			else if(see == 1)
				{
					pid_contorl();
					if(dir1 == 0)
					{
						if(tag_id == 1 )//识别到路口了，此时是数字2，要右转
						{
							ON(V1,V1);
							Delay_ms(T1);
							ON(S1,0);
							Delay_ms(T6);
						}
						if(tag_id == 3)//送到药房了，要开始卸药
						{
							uint16_t i = 1;
							ON(S1,S2);
							Delay_ms(T4);
						LED_RED_ON();
						Delay_ms(50);
						STOP();
						Delay_ms(1000);
							way1 += 1;
							while(i != 0)
								{
						if(AD_GetValue() < B)//卸下药品了
						{
							see = 2;
							LED_RED_OFF();
							i = 0; 
						}
							}
						}
					}
			
					else if(dir1 == 1)
					{
						if(tag_id == 1 )//第二次识别到路口了，要左转(返回时)
						{
							ON(V1,V1);
							Delay_ms(T1);
							ON(0,S2);			
							Delay_ms(T7);
						}
						else if(tag_id == 3)//送到药房了，要开始卸药
						{
							ON(S1,S2);
							Delay_ms(T4);
							LED_GREEN_ON();
							Delay_ms(50);
							STOP();
							Delay_ms(1500);
							see = 3;
						}
					}
					
				}
				else if(see == 2)//向后转180
				{
					dir1++;
					Delay_ms(500);
					Turnover2(V2,V2);
					Delay_ms(T3);
					STOP();
					Delay_ms(600);
					tag_id = 0;
					see = 1;
					
				}
				else if(see == 3)//回到出发点了
				{
					ON(S1,S2);
					Delay_ms(T4);
					LED_GREEN_ON();
					STOP();
				}
			}
}
}

第二问和第三问（题目要求3-8随机摆放，所以这里只给出3和4的，5-8其实是一摸一样的。）：

#include "stm32f10x.h"                  // Device header

#include "Delay.h"
#include "motor.h"
#include "Serial.h"
#include "pid.h"
#include "AD.h"
#include "K210.h"
#include "LED.h"
#include "OLED.h"

uint16_t see2 ;//标识符
uint16_t way2;//停下来的次数,第二次停下就不能再转180
uint16_t dir2;//第几次转弯 
uint16_t far;//远端药房标识符
uint16_t wey1,wey2;//1：数字三返回标识符，2：数字4返回标识符
uint16_t lyq1,lyq2;//中段药房返回时标识符

#define C 2500 //光敏电阻阈值
#define D 1800

#define S3 31//左轮速度
#define S4 31//右轮速度
#define V3 32//补转弯时的误差速度
#define V4  29 //转180速度
#define T4  430//小车转弯前直行延时
#define T6  905//小车转180延时
#define T5  890 //小车左转弯时延时//左端的药房
#define T7  865//小车右转弯延时//左端的药房
#define T8  400//小车识别到药房前进延时
#define T9  965 //小车左转弯时延时//右边的药房
#define T10  960 //小车右转弯时延时//右边的药房
#define T11  300


void CROSS2(void)

{
	Motor_Init();
	Serial_Init();
	pid_init();
	AD_Init();
	K210_Init();
	LED_Init();
	
while(see2!=6)
	{
		OLED_ShowNum(1,13,AD_GetValue(),4); 
		OLED_ShowNum(2,14,num,2);
		OLED_ShowNum(3,14,tay,2);
		
		OLED_ShowNum(1,7,left_speed,2);
        OLED_ShowNum(2,7,right_speed,2);
		OLED_ShowNum(3,3,x_translation ,5);
		OLED_ShowNum(4,6,tag_id,2);
//		OLED_ShowNum(4,10,dir2,2);
		if(  num == 3 & tay == 9)//开始时从k210接收到的数字信息
		{
			if(see2 == 0)
			{
				STOP();
				if(AD_GetValue() > C)//装上药品
				{
					see2 = 2;
				}
			}
		}
			
		if( num == 4 & tay == 9)//开始时从k210接收到的数字信息
		{
			if(see2 == 0)
			{
				OLED_ShowNum(3,14,tay,2);
				STOP();
				if(AD_GetValue() > C)//装上药品
				{
					see2 = 3;
				}
			}
		}
			
			if(see2 == 2)//一开始识别数字3
			{
				pid_contorl();
				
				if (dir2 == 0)//前去药房
				{
					OLED_ShowNum(3,14,tay,2);
					
					if (tag_id == 1 & tay == 1)//数字3在左边,且是中端药房
					{
						OLED_ShowNum(3,14,tay,2);
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);						
						Delay_ms(T5);
						wey1 = 1;
						STOP();
						Delay_ms(T11);
						OLED_ShowNum(4,10,wey1,2);
					}
					
					else if(tag_id == 1 & tay ==2)//数字3在右边，且是中端药房
					{
						OLED_ShowNum(3,14,tay,2);
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);						
						Delay_ms(T7);
						wey1 = 2;
						STOP();
						Delay_ms(T11);
					}
					
					else if (tag_id == 2  & tay ==1)//数字3在左边,且是远端药房
					{
						OLED_ShowNum(3,14,tay,2);
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);						
						Delay_ms(T5);
						far+=1;	
						STOP();
						Delay_ms(T11);						
					}
					
					else if(tag_id == 2  & tay == 2)//数字3在右边，且是远端药房
					{
						OLED_ShowNum(3,14,tay,2);
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);					
						Delay_ms(T7);
						far+=2;
						STOP();
						Delay_ms(T11);
					}
					
					if( far == 1 & tag_id == 2)//远端药房的第二次转弯（第一次向左转）
					{
						if( tay == 1)//数字三在左边（左下方）第二次识别到数字3且还是在左边
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);						
						Delay_ms(T5);
						wey1 = 3;//远端药房
						STOP();
						Delay_ms(T11);
						}
						else if ( tay ==2 )//数字3在右端(左上方)第二次识别到数字3且是在右边
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);						
						Delay_ms(T7);
						wey1 = 4;//远端药房
							STOP();
						Delay_ms(T11);
						}
					}
					
					if(far == 2 & tag_id == 2)//远端药房的第二次转弯（第一次向右转）
					{
						if(tay == 1)//数字三在左边（右上方）第二次识别到数字3且是在左边
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);						
						Delay_ms(T5);
						wey1 = 5;//远端药房
							STOP();
						Delay_ms(T11);
						}
						else if (tay == 2)//数字3在右端(右下方)第二次识别到数字3且是在右边
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
						wey1 = 6;//远端药房
							STOP();
						Delay_ms(T11);
						}
					}
					
					if(tag_id == 3)//送到药房了，要开始卸药
					{
						ON(S3,S4);//因为是视觉巡线，就会导致无法完全到达终点，所以再给一个速度
						Delay_ms(T8);
						uint16_t i = 1;
						LED_RED_ON();
						Delay_ms(50);
						STOP();
						way2 += 1;//第一次停下
						while(i!=0)
						{
							if(AD_GetValue() < D)//卸下药品了
							{
								LED_RED_OFF();
								see2 = 4;//开始转180
								i = 0; 
							}
						}
					}
					
				}
				
				else if(dir2 == 1)//返回了
				{
					OLED_ShowNum(4,10,wey1,2);
				if(wey1 == 1)//开始3在左边向左转（中端药房）
				{
					if( tag_id == 1 )//第二次识别到路口了，此时是返回，要右转，因为一开始识别到3在左边
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
						STOP();
						Delay_ms(T11);
						wey1 =0;
					}
				}
				
				else if(wey1 == 2)//开始3在右边向右转(中端药房)
				{
					if(tag_id == 1 )//第二次识别到路口了，要左转
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);				
						Delay_ms(T5);
						STOP();
						Delay_ms(T11);
						wey1 = 0;
					}
				}
				
				else if(wey1 == 3)//三在远端药房的左下方
				{
					uint16_t tm3 = 0;//第几次识别到T型路口
					if(tag_id == 2)
					{
						if(tm3 == 0)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);		
						Delay_ms(T7);
							STOP();
						Delay_ms(T11);
						tm3++;
						}
						else if(tm3 == 1 )
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);	
						Delay_ms(T7);
							STOP();
						Delay_ms(T11);
							tm3++;
						}
					}
				}
				
				else if(wey1 == 4)//三在远端药房的左上方
				{
					uint16_t tn3 = 0; //第几次识别到T型路口
					if(tag_id == 2)
					{
						if(tn3 == 0)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
						tn3++;
							STOP();
						Delay_ms(T11);
						}
						else if(tn3 == 1 )
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);						
						Delay_ms(T7);
							STOP();
						Delay_ms(T11);
							tn3++;
						}
					}
					
				}
				
				else if(wey1 == 5)//三在远端药房的右上方
				{
					uint16_t tt3 = 0;//第几次识别到T型路口
					if( tag_id == 2)
					{
						if(tt3 == 0)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);				
						Delay_ms(T7);
						tt3++;
							STOP();
						Delay_ms(T11);
						}
						else if(tt3 == 1)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);				
						Delay_ms(T5);
							STOP();
						Delay_ms(T11);
							tt3 ++;
						}
					}
				}
				
				else if(wey1 == 6)//三在远端药房的右下方
				{
					uint16_t tq3 = 0;//第几次识别到T型路口
					if( tag_id == 2)
					{
						if(tq3 == 0)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);					
						Delay_ms(T5);
						tq3++;
							STOP();
						Delay_ms(T11);
						}
						else if(tq3 == 1 )
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);					
						Delay_ms(T5);
							STOP();
						Delay_ms(T11);
							tq3++;
						}
					}
				}
				
				if(tag_id == 3)//回到出发点
					{
					ON(S3,S4);
					Delay_ms(T8);
					LED_GREEN_ON();
					STOP();
					Delay_ms(1500);
					see2 = 6;
					}
				
				}
			}
				
				
				else if(see2 == 3)//一开始识别数字4
				{
				pid_contorl();
				
				if (dir2 == 0)//第一次转弯
				{
//					if(tay == 1)//左边
//					{
//						lyq2 += 2; 
//					}
//					if(tay == 2)//右边
//					{
//						lyq2 += 3;
//					}
					if (tag_id == 1 & tay == 1)//数字4在左边,且是中端药房
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);						
						Delay_ms(T5);
						tag_id = 0;  
						Delay_ms(250);
						wey2 = 1;	
					}
					
					else if(tag_id == 1 & tay == 2)//数字4在右边，且是中端药房
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
						tag_id = 0;  
						Delay_ms(250);
						wey2 = 2;
					}
					
					else if (tag_id == 2  & tay == 1)//数字4在左边,且是远端药房
					{	
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);					
						Delay_ms(T5);
						far+=1;
					}
					
					else if(tag_id == 2  & tay == 2)//数字4在右边，且是远端药房
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7); 
						far+=2;
					}
					
					if( far == 1 & tag_id == 2)//远端药房的第二次转弯（第一次向左转）
					{
						if( tay == 1)//数字4在左边（左下方）
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
						wey2 = 3;//远端药房
							Delay_ms(T11);
						}
						else if ( tay == 2)//数字4在右端(左上方)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
						wey2 = 4;//远端药房
							Delay_ms(T11);
						}
					}
					
					if( far == 2 & tag_id == 2)//远端药房的第二次转弯（第一次向右转）
					{
						if( tay == 1)//数字4在左边（右上方）
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);						
						Delay_ms(T5);
						wey2 = 5;//远端药房
							Delay_ms(T11);
						}
						
						else if ( tay == 2)//数字3在右端(右下方)
						{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);					
						Delay_ms(T7);
						wey2 = 6;//远端药房
							Delay_ms(T11);
						}
					}
					
					if(tag_id == 3)//送到药房了，要开始卸药
					{
						ON(S3,S4);//因为是视觉巡线，就会导致无法完全到达终点，所以再给一个速度
						Delay_ms(T8);
						uint16_t i = 1;
						LED_RED_ON();
						Delay_ms(50);
						STOP();
						way2 += 1;//第一次停下
						while(i!=0)
						{
							if(AD_GetValue() < D)//卸下药品了
							{
								LED_RED_OFF();
								see2 = 5;//开始转180
								i = 0; 
							}
						}
					}
				}
				
				else if(dir2 == 1)
				{
					if(wey2 == 1)//开始4在左边向左转（中端药房）
					{
					if(tag_id == 1 )//第二次识别到路口了，此时是返回，要右转，因为一开始识别到4在左边
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
					}
				}
				
				else if(wey2 == 2)//开始4在右边向右转(中端药房)
				{
					if(tag_id == 1 )//第二次识别到路口了，要左转
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
					}
				}
				
				else if(wey2 == 3)//4在远端药房的左下方
				{
					uint16_t wm3 = 0;//第几次识别到T型路口
					if(wm3 == 0 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
						wm3++;
					}
					
					else if(wm3 == 1 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
					}
				}
				
				else if(wey2 == 4)//4在远端药房的左上方
				{
					uint16_t wn3 = 0;//第几次识别到T型路口
					if(wn3 == 0 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
						wn3++;
					}
					
					else if(wn3 == 1 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
					}
				}
				
				else if(wey2 == 5)//4在远端药房的右上方
				{
					uint16_t wt3 = 0;//第几次识别到T型路口
					if(wt3 == 0 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(S3,0);
						Delay_ms(T7);
						wt3++;
					}
					
					else if(wt3 == 1 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
					}
				}
				
				else if(wey2 == 6)//三在远端药房的右下方
				{
					uint16_t wq3 = 0;//第几次识别到T型路口
					if(wq3 == 0 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
						wq3++;
					}
					
					else if(wq3 == 1 & tag_id == 2)
					{
						ON(V3,V3);
						Delay_ms(T4);
						ON(0,S4);
						Delay_ms(T5);
					}
				}
				
				if(tag_id == 3)//回到出发点
					{
					ON(S3,S4);
					Delay_ms(T8);
					LED_GREEN_ON();
					STOP();
					Delay_ms(1500);
					see2 = 6;
					}
				
				}
				}
				
				else if(see2 == 4)//识别3向后转180
				{
					Delay_ms(500);
					Turnover(V4,V4);
					Delay_ms(T6);
					STOP();
					tag_id = 0;
					Delay_ms(800);
					see2 = 2;
					dir2++;	
				}
				
				else if(see2 == 5)//识别4向后转180
				{
					Delay_ms(500);
					Turnover(V4,V4);
					Delay_ms(T6);
					STOP();
					tag_id = 0;
					Delay_ms(800);
					see2 = 3;
					dir2++;	
				}
				
				else if(see2 == 6)//回到出发点了
				{
					LED_GREEN_ON();
					STOP();
				}
		
	}
}

zigbee端代码（使用时赋好值Zigbee_TxPacket[4]， Zigbee_RxPacket[4]，然后使用Zigbee_SendPacket()即可，zigbee配置去b站上搜索zigbee配置，出来第一个跟着做就好了）：

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>

uint8_t Zigbee_TxPacket[4];				//定义发送数据包数组，数据包格式：FF 01 02 03 04 FE
uint8_t Zigbee_RxPacket[4];				//定义接收数据包数组
uint8_t Zigbee_RxFlag;					//定义接收数据包标志位

/**
  * 函    数：串口初始化
  * 参    数：无
  * 返 回 值：无
  */
void Zigbee_Init(void)
{
	/*开启时钟*/
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);	//开启USART1的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);					//将PA9引脚初始化为复用推挽输出
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);					//将PA10引脚初始化为上拉输入
	
	/*USART初始化*/
	USART_InitTypeDef USART_InitStructure;					//定义结构体变量
	USART_InitStructure.USART_BaudRate = 115200;				//波特率
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	//硬件流控制，不需要
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	//模式，发送模式和接收模式均选择
	USART_InitStructure.USART_Parity = USART_Parity_No;		//奇偶校验，不需要
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	//停止位，选择1位
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		//字长，选择8位
	USART_Init(USART3, &USART_InitStructure);				//将结构体变量交给USART_Init，配置USART1
	
	/*中断输出配置*/
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);			//开启串口接收数据的中断
	
	/*NVIC中断分组*/
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			//配置NVIC为分组2
	
	/*NVIC配置*/
	NVIC_InitTypeDef NVIC_InitStructure;					//定义结构体变量
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;		//选择配置NVIC的USART1线
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//指定NVIC线路使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		//指定NVIC线路的抢占优先级为1
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		//指定NVIC线路的响应优先级为1
	NVIC_Init(&NVIC_InitStructure);							//将结构体变量交给NVIC_Init，配置NVIC外设
	
	/*USART使能*/
	USART_Cmd(USART3, ENABLE);								//使能USART1，串口开始运行
}

/**
  * 函    数：串口发送一个字节
  * 参    数：Byte 要发送的一个字节
  * 返 回 值：无
  */
void Zigbee_SendByte(uint8_t Byte)
{
	USART_SendData(USART3, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

/**
  * 函    数：串口发送一个数组
  * 参    数：Array 要发送数组的首地址
  * 参    数：Length 要发送数组的长度
  * 返 回 值：无
  */
void Zigbee_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i < Length; i ++)		//遍历数组
	{
		Zigbee_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：串口发送一个字符串
  * 参    数：String 要发送字符串的首地址
  * 返 回 值：无
  */
void Zigbee_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != '\0'; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Zigbee_SendByte(String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：次方函数（内部使用）
  * 返 回 值：返回值等于X的Y次方
  */
uint32_t Zigbee_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	//设置结果初值为1
	while (Y --)			//执行Y次
	{
		Result *= X;		//将X累乘到结果
	}
	return Result;
}

/**
  * 函    数：串口发送数字
  * 参    数：Number 要发送的数字，范围：0~4294967295
  * 参    数：Length 要发送数字的长度，范围：0~10
  * 返 回 值：无
  */
void Zigbee_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i < Length; i ++)		//根据数字长度遍历数字的每一位
	{
		Zigbee_SendByte(Number / Zigbee_Pow(10, Length - i - 1) % 10 + '0');	//依次调用Serial_SendByte发送每位数字
	}
}

/**
  * 函    数：使用printf需要重定向的底层函数
  * 参    数：保持原始格式即可，无需变动
  * 返 回 值：保持原始格式即可，无需变动
  */
int fputc(int ch, FILE *f)
{
	Zigbee_SendByte(ch);			//将printf的底层重定向到自己的发送字节函数
	return ch;
}

/**
  * 函    数：自己封装的prinf函数
  * 参    数：format 格式化字符串
  * 参    数：... 可变的参数列表
  * 返 回 值：无
  */
void Zigbee_Printf(char *format, ...)
{
	char String[100];				//定义字符数组
	va_list arg;					//定义可变参数列表数据类型的变量arg
	va_start(arg, format);			//从format开始，接收参数列表到arg变量
	vsprintf(String, format, arg);	//使用vsprintf打印格式化字符串和参数列表到字符数组中
	va_end(arg);					//结束变量arg
	Zigbee_SendString(String);		//串口发送字符数组（字符串）
}

/**
  * 函    数：串口发送数据包
  * 参    数：无
  * 返 回 值：无
  * 说    明：调用此函数后，Serial_TxPacket数组的内容将加上包头（FF）包尾（FE）后，作为数据包发送出去
  */
void Zigbee_SendPacket(void)
{
	Zigbee_SendByte(0xFF);
	Zigbee_SendArray(Zigbee_TxPacket, 4);
	Zigbee_SendByte(0xFE);
}

/**
  * 函    数：获取串口接收数据包标志位
  * 参    数：无
  * 返 回 值：串口接收数据包标志位，范围：0~1，接收到数据包后，标志位置1，读取后标志位自动清零
  */
uint8_t Zigbee_GetRxFlag(void)
{
	if (Zigbee_RxFlag == 1)			//如果标志位为1
	{
		Zigbee_RxFlag = 0;
		return 1;					//则返回1，并自动清零标志位
	}
	return 0;						//如果标志位为0，则返回0
}

/**
  * 函    数：USART1中断函数
  * 参    数：无
  * 返 回 值：无
  * 注意事项：此函数为中断函数，无需调用，中断触发后自动执行
  *           函数名为预留的指定名称，可以从启动文件复制
  *           请确保函数名正确，不能有任何差异，否则中断函数将不能进入
  */
void USART3_IRQHandler(void)
{
	static uint8_t RxState = 0;		//定义表示当前状态机状态的静态变量
	static uint8_t pRxPacket = 0;	//定义表示当前接收数据位置的静态变量
	if (USART_GetITStatus(USART3, USART_IT_RXNE) == SET)		//判断是否是USART1的接收事件触发的中断
	{
		uint8_t RxData = USART_ReceiveData(USART3);				//读取数据寄存器，存放在接收的数据变量
		
		/*使用状态机的思路，依次处理数据包的不同部分*/
		
		/*当前状态为0，接收数据包包头*/
		if (RxState == 0)
		{
			if (RxData == 0xFF)			//如果数据确实是包头
			{
				RxState = 1;			//置下一个状态
				pRxPacket = 0;			//数据包的位置归零
			}
		}
		/*当前状态为1，接收数据包数据*/
		else if (RxState == 1)
		{
			Zigbee_RxPacket[pRxPacket] = RxData;	//将数据存入数据包数组的指定位置
			pRxPacket ++;				//数据包的位置自增
			if (pRxPacket >= 4)			//如果收够4个数据
			{
				RxState = 2;			//置下一个状态
			}
		}
		/*当前状态为2，接收数据包包尾*/
		else if (RxState == 2)
		{
			if (RxData == 0xFE)			//如果数据确实是包尾部
			{
				RxState = 0;			//状态归0
				Zigbee_RxFlag = 1;		//接收数据包标志位置1，成功接收一个数据包
			}
		}
		
		USART_ClearITPendingBit(USART3, USART_IT_RXNE);		//清除标志位
	}
}

视觉pid（直接调用pid_control()，这里的ON（ ，）其实就是驱动电机，这个代码我就不加了，非常简单）：

#include <stdio.h>
#include <stdlib.h>
#include "stm32f10x.h" // Device header
#include "Serial.h"
#include "encoder.h"
#include "PWM.h"
#include "motor.h"
#include "OLED.h"

#define PID_KP 0.2
#define PID_KI 0.01
#define PID_KD 18


#define tar 30 //目标速度
#define MAX_SPEED 60 //限幅速度
#define MIN_SPEED 0

   int32_t    left_speed ,right_speed ,  pid_output1;//左轮速度，右轮速度，pid计算后的输出值
struct pid{
	int16_t error;
	int16_t last_error;	
	float ki; 
	float kd;
    float kp;
//	int16_t ferror;//滤波后的误差
//	int16_t flast_error;	//上次滤波后的误差
}pid;



void left_xianfu(void)//限制左轮速度
{
	if(left_speed <= MIN_SPEED)
	{
		left_speed = MIN_SPEED;
	}
	
	else if( left_speed >= MAX_SPEED ) 
	{
		left_speed = MAX_SPEED;
	}
}

void right_xianfu(void)//限制右轮速度
{
	if( right_speed <= MIN_SPEED ) 
		{
		right_speed = MIN_SPEED;
 
	} 
		
	else if( right_speed >= MAX_SPEED )
	{
		right_speed = MAX_SPEED;
	}
}


void pid_init( void )
{
	pid.error= 0;
	pid.last_error = 0;
	pid.kp = PID_KP;
	pid.ki = PID_KI;
	pid.kd = PID_KD;
	
	return;
}
 int32_t pid_output( void) //此时计算出的pid误差值
{
	pid.error = (x_translation-32);//误差传入,靠左接收到的x_translation减小，要右转，左轮速度大
//	float a = 0.3;//滤波
//	pid.ferror = a*pid.error + (1-a)* pid.flast_error;//滤波算法
	int32_t P;
	static int32_t I;
	int32_t D;
	int32_t pid_output;
	
	P = pid.kp * pid.error;                      
	I +=pid.ki * pid.error;
	D = pid.kd * ( pid.error - pid.last_error );
	pid.last_error= pid.error;
//	pid.flast_error= pid.ferror;
	pid_output = P + I + D;
	return pid_output;
}
 
 
void speed_by_pid( int32_t pid_output )//pid改变速度使小车在直线上走
{
  if(!pid.error)
	{
    left_speed  = tar;
    right_speed = tar;
	ON(tar,tar);  
    return;
	}
  
	left_speed =  left_speed + pid_output;
	left_xianfu();
 
	right_speed =  right_speed - pid_output;
 
	right_xianfu();
	ON(left_speed,right_speed); 
		return ;
}



void pid_contorl()
{
	left_speed= 30;
	right_speed= 30;
	pid_output1=pid_output();
	OLED_ShowSignedNum(2,10,pid_output1,4);
	speed_by_pid(pid_output1);
	
	
}


//void pid_control_motor(void)
//{
//	if(pid.error >= 7 && pid.error <= 9){
//      Right2();
//      return;
//    }else if(pid.error >= -9 && pid.error <= -7){
//      Left2();
//}     return;
//	ON2();
//    }
//

niuniu在学习
关注
2021电赛F题智能送药小车.zip
11-14
这是一份关于2021年电子设计竞赛（电赛）F题的项目资料，主要关注的是智能送药小车的实现。该小车结合了先进的计算机视觉技术和微控制器技术，以完成自动配送药物的任务。 【openmv】 OpenMV是一款开源且低成本的...
2021电赛F题送药小车，利用模板匹配进行数字识别。
07-25
openmv非4plus跑不了神经网络，故最好使用模板匹配亦或者特征点识别来进行识别数字，但特征点识别是使用灰度图，很可能与数字造成误识别，故准确性较低，使用模板匹配识别数字。
2021年电赛F题-智能送药小车
07-20
灰度循迹 这部分我使用的是五路灰度循迹，也是根据灰度管检测当前时刻的巡线变化来得出巡线偏差，带入PID进行计算，这和OpenMv巡线类似，我给出如何获得误差，大家就可以把误差带入PID进行计算了 ...
电赛F题-送药小车项目源码文档资料.zip
06-06
电赛F题—送药小车项目源码文档资料.zip电赛F题—送药小车项目源码文档资料.zip电赛F题—送药小车项目源码文档资料.zip电赛F题—送药小车项目源码文档资料.zip电赛F题—送药小车项目源码文档资料.zip电赛F题—送药...
智能送药小车（字模）.7z
12-01
在2021年的大赛中，F题为“智能送药小车”，这是一个融合了硬件电路设计、软件编程、自动控制等多个领域的综合项目。 智能送药小车的核心在于它的智能化特性，这主要体现在以下几个方面： 1. **自动导航**：小车应...
【STM32系统】基于STM32设计的智能垃圾桶（语音、颜色识别、称重、光强、烟雾、人体识别、步进电机、水泵）——文末资料下载
嵌入式阿齐Archie
09-13 2820
功能简介：四个按键可分别打开四个垃圾桶（可回收垃圾、厨余垃圾、有害垃圾、其他垃圾）oled显示屏显示四个垃圾桶的打开/关闭状态、烟雾浓度、光照强度、称重的重量和识别到的颜色（白色、红色、绿色、蓝色）四个垃圾桶分别检测到有人时会自动打开垃圾桶，人离开3s后自动关闭垃圾桶。环境光强过暗时自动打开灯光。检测到的烟雾浓度过高时会进行自动水泵打开和蜂鸣器报警。唤醒词“智能垃圾桶”，语音模块唤醒并回复播报“我在...”。语音识别到人说出的对应的垃圾名称/命令词，系统会播报对应的垃圾分类名字（回复语）并
STM32与ESP8266的使用
m0_51830537的博客
09-12 904
【代码】STM32与ESP8266的使用。
STM32启用FPU浮点运算
qq_36658033的博客
09-13 480
跳转定义如下两个定义：能跳转，并且都是1，那么就打开FPU：这两个寄存器可以查手册；1、不需要多余的操作，不需要去定义宏，也不需要你去写什么打开操作；我不知道为啥能搞一堆乱糟糟的东西；使用STM32G4系列使用cubemax产生工程；1、首先需要去寄存器打开这个FPU的硬件使能。文件：system_stm32g4xx.c。尽管跳转后是灰色的：但是跳转过来指示的行，这个打开在.S文件的上电复位就有，重点1后，没有编译，勾选后不生效；不想了解的，可以不用看；
STM32点亮第一个LED
u012902518的博客
09-12 662
纯小白文，STM32第一步，从常量，RCC，GPIO，LED开始，点亮GPIOB上的LED。
蓝桥杯-STM32G431RBT6（UART解析字符串sscanf和解决串口BUG）
最新发布
JK03820的博客
09-18 456
链接: https://pan.baidu.com/s/1s-FNqcBW1CerVNHGyEfvuQ?pwd=0820 提取码: 0820。假如没接受完成，执行函数，就可能会把count直接清零，就会重新接受。中的含义是：读取最多 4 个字符并将其存储为字符串。它确保读取的字符串长度不超过 4 个字符。通过网盘分享的文件：串口.zip。：这是一个定义的函数，名为。
STM32外设-0.96寸OLED显示屏
xuhc_zd的博客
09-17 579
STM32外设-0.96寸OLED显示屏
金葫芦STM32L431上手流程
weixin_55762309的博客
09-17 477
AHL-GEC-IDE(4.55)软件安装流程
STM32 BootLoader 刷新项目 (六) 获取帮助-命令0x52
艾格北峰嵌入式
09-17 1022
在嵌入式MCU软件开发中，通过串口进行人机交互是非常常见且重要的操作方式。获取帮助的命令通常用来向用户展示所有支持的交互指令及其使用方法。
控制STM32蜂鸣器示例代码（江科大）
yangyangyiyang_的博客
09-17 220
以下代码来源于本人学习江科大的课程，这是一个简单的STM32微控制器程序，用于控制连接到GPIOB第12号引脚的蜂鸣器。程序通过GPIOB的第12号引脚输出PWM波形来控制蜂鸣器的频率，从而产生声音。如果你对如何使用某个特定的库函数感到困惑，这里有一个简单的方法可以帮助您快速获取所需信息。
SHT30温湿度传感器详解（STM32）
qq_44016222的博客
09-17 627
SHT30是一种常见的温湿度传感器，是一款完全校准的线性化的温湿度数字传感器，增强了数字信号。I2C通讯频率达1MHz。具有高可靠性及高稳定性。该传感器广泛应用于各种场景，小米的温湿度传感器就是使用的SHT30,本文是已硬件IIC来驱动SHT30。以下是SHT30温湿度传感器的参数：型号SHT30工作电压2.4~5.5V接口输出IIC测量温度范围-40~125℃测量湿度范围0~100%RH湿度精度3%RH温度精度0.3℃。
【STM32 Blue Pill编程】-定时器PWM模式
视觉与物联智能
09-14 301
在文中，我们将介绍如何使用 STM32 Blue Pill 定时器的PWM模式以及如何配置它们以生成具有不同占空比和频率的信号。 我们将使用 LED调光器示例来演示如何使用 STM32Cube IDE 和 HAL 库以及有关 PWM 模式的综合指南在 PWM 模式下设置定时器。
ARM和51和stm32的区别
Caihua的博客
09-17 684
ARM：一种通用的高性能微处理器架构，被多家制造商使用。51（8051）：一种经典的8位微控制器架构，适用于简单、低成本的嵌入式应用。STM32：基于ARM Cortex-M内核的微控制器系列，提供高性能和丰富的功能，适用于各种复杂的嵌入式系统。
【STM32】esp8266连接wifi
yyqzjw的博客
09-13 642
使用串口二接收esp8266的数据，单片机接收，使用串口1将数据发送给串口助手串口2波特率设置74880，串口1设置115200在初始化的时候需要将复位引脚拉低20ms,然后再拉高20ms,设置GPIOB的输出模式对PB12做输出处理。
【STM32】独立看门狗（IWDG）原理详解及编程实践（下）
m0_73931287的博客
09-13 833
1、初始化 IWDG 2. 配置 IWDG 3. 喂狗 4. 处理看门狗复位 5、完整示例，展示如何在STM32中配置和使用IWDG 6、标准库版本
2021电赛f题送药小车方案
04-19
2021电赛f题是一个送药小车方案，通过实现自主避障和路径规划等功能，将药品输送到指定地点。具体方案可以考虑使用ROS框架开发，结合雷达、摄像头等传感器进行环境感知和导航控制。同时，需要考虑药品保温、运输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值