智能小车比赛

2013年飞思卡尔智能小车比赛创意组
2013-06-21 21:19:05
2013年飞思卡尔智能小车比赛创意组，2013年飞思卡尔智能小车比赛创意组
收起
飞思卡尔智能小车比赛单片机硬件设计资料
2010-12-07 10:25:37
由飞思卡尔半导体公司协办的全国大学生智能小车比赛，内附详细的单片机硬件设计资料
收起
赛道计时，一个用时智能小车比赛的VB串口程序设计
2009-03-29 11:48:07
一个用时智能小车比赛的VB串口程序设计，可以记录每辆小车跑完一圈下来的成绩，并且可以保存起来，没跑完一圈自动刷新。继续记录下一圈的成绩。非常好的程序。
收起
飞思卡尔智能小车比赛的报告
2009-04-02 18:52:44
本报告是为参加“飞思卡尔”杯全国大学生智能汽车邀请赛而撰写的技术报告，系统的介绍了哈尔滨工程大学“极品飞车2号”智能寻线小车的开发研制过程。采取比较成熟的技术，配合创新的设计方案，通过实际试验表明模型...
收起
飞思卡尔

近十个学校的智能小车比赛程序（无保留），要的来拿

千次阅读 多人点赞 2019-06-11 16:07:01

近十个学校的比赛程序（无保留），你懂得。非常经典，做智能车的不容错过噢。好的内容都是回复可见的程序1. #include <hidef.h> /* common defines and macros */ #include <mc9s12...


			
			近十个学校的比赛程序（无保留），你懂得。非常经典，做智能车的不容错过噢。



			好的内容都是回复可见的





			程序1.
			
			
			#include <hidef.h>      /* common defines and macros */
				#include <mc9s12dg128.h>     /* derivative information */
				#pragma LINK_INFO DERIVATIVE "mc9s12dg128b"
				/*************************************************************
				摄像头数据
				***************************************************************/
				unsigned int AbsoluteTime; // 系统时钟，用于闭环调速
				unsigned int Picture1[10][4]={{600,600,0,40},{600,600,0,60},{600,600,0,80},
				                              {600,600,0,100},{600,600,0,120},{600,600,0,140},
				                              {600,600,0,160},{600,600,0,180},{600,600,0,200},
				                              {600,600,0,220}};
				unsigned int Picturewrflag[10];    //图像数据真伪判别标志
				int PictureCoordinate[10]={0,0,0,0,0,0,0,0,0,0};//图像坐标
				unsigned int FieldCNT;
				int RowCNT;
				int CapFlag;
				long coordinate1,coordinate2,line_wideth;
				int se = 0;
				int PMCNT,NextPMCNT;
				int curvature;//曲率
				int ServoMotorPWM;
				int i;
				int TurningLine;
				/*********************************************************************
				PID数据
				***********************************************************************/
				static int CurrentSpeed=0,DstSpeed=90;
				static int waittime=0;
				        int speed_0=0;
				        int e=0,e_1=0;
				        int ie=0;
				        int Kp=35;
				        int Kd=0;
				        int Ki=10;//5;
				        int PACN0_i;
				        int SpeedMin=90,SpeedMax=400;
				        char a;
				/***********************************************************************
				路径记忆数据
				************************************************************************/
				int length=0;
				int bendstraightMemory[100];//直道弯道数据存储
				/*********************************************************************
				摄像头函数
				*********************************************************************/
				void ETCInit(void);
				void CCDInit(void);
				void PWMInit(void);
				void SystemInit(void);
				void PictureDispose(void);
				/*********************************************************************
				PID函数
				**********************************************************************/
				void SpeedPID(void);
				static void RTIInit(void);
				void SetSpeed(void);
				/***********************************************************************
				路径记忆函数
				************************************************************************/
				void JourneyMemory(void);
				/***********************************************************************/
				void main(void) {
				        DisableInterrupts;
				        SystemInit();       
				        EnableInterrupts;   
				  for(;;) {
				  EnableInterrupts;
				  JourneyMemory();
				  PictureDispose();
				  }
				}
				/************************************************************************
				系统初始化区域
				**************************************************************************/
				  void SystemInit(void)
				{        AbsoluteTime = 0; // 初始化系统时钟
				        DDRB = 0xff; // 初始化PORTB，用于数据输出
				        FieldCNT = 0; // 场计数器初始化
				        ETCInit();
				        PWMInit();
				        RTIInit();
				  }
				  static void RTIInit(void) {
				  /* setup of the RTI interrupt frequency */
				  /* adjusted to get 1 millisecond (10.24 ms) with 16 MHz oscillator */
				  RTICTL = 0x64; /* set RTI prescaler */
				  CRGINT = 0x80; /* enable RTI interrupts */  
				  }
				  void ETCInit(void)
				  {   
				   TCTL4_EDG0B=0;
				   TCTL4_EDG0A=1; //0 channel Capture on rising edges only
				   TCTL3_EDG7B=1;
				   TCTL3_EDG7A=0; //7 channel Capture on falling edges only
				   TIOS_IOS0=0; //0 channel input compare
				   TIOS_IOS7=0; //7 channel input compare  
				        TIOS_IOS4 = 0; // 视频输入捕获
				        TIOS_IOS5 = 0; // 行同步
				        TIOS_IOS6 = 0; // 场同步
				        TSCR1_TEN = 1; // 使能计数
				        TSCR1_TFFCA = 1; // 捕获中断、比较中断标志位通过读取数据和写入数据清除
				        PACTL=0x40;   //16位累加器A使能 ,下降沿工作
				PBCTL_PBEN=1;//16位累加器B使能
				        TC4 = TC4; // 清除中断标志位
				        TC5 = TC5;
				        TC6 = TC6;
				        CCDInit();
				  }
				  **********************************
				函数名称：CCDInit
				  功能描述：图像空间初始化
				  ********************************
				 
				  void PWMInit(void) {
				        PWME = 0x00;              // 禁止所有的PWM输出通道
				        PWMPOL = 0xFF;     // 所有的PWM输出高电平有效
				        PWMCLK = 0x00;         // Clock A && Clock B is the clock source for PWM channel 0~7
				        PWMPRCLK = 0x03;         // bus clock:24M;Clock A--8分频，Clock B--0分频
				        PWMCAE = 0x00;         // 所有的PWM输出为左对齐方式输出
				        PWMCTL = 0xFF;         // 将两个8位的PWM输出通道组合成一个16位的PWM输出通
				        PWMCNT01 = 0xFF;         // PWM计数器清零
				        PWMCNT23 = 0xFF;
				        PWMCNT45 = 0xFF;
				        PWMCNT67 = 0xFF;
				        PWMPER01 = 60000; // 驱动前轮舵机，周期20ms，频率50Hz
				        PWMPER23 = 2400; //周期0.1ms，频率10kHz
				        PWMPER67 = 2400;
				        // 设置占空比初始值
				        PWMDTY01 = 4200//舵机要求PWM高电平宽度0.5ms～2.5ms对应计数器数值为3800～4450～5150右
				        PWMDTY23 =1660;
				        PWMDTY67 =0;               
				        PWME = 0xFF;         // 所有PWM通道使能
				        }
				 
				  
				  
				  
				  
				         EnableInterrupts;
				   }
				/**************************************************************************
				速度PID控制区域
				***************************************************************************
				  interrupt void Real_Time_Interrupt(void)
				  {
				        AbsoluteTime++; // 运行系统时钟
				  SpeedPID();   
				  PORTB=(char)(PACN10);
				        CRGFLG = 0x80;         // 清中断标志
				                EnableInterrupts;
				  }
				/*******************************************************************/
				  void SpeedPID(void)
				  {
				   PACN0_i=PACN10;
				          CurrentSpeed = PACN0_i;//码盘输入引脚PT0
				        PACN10=0;
				        e_1=e;
				        e=CurrentSpeed-DstSpeed;//-CurrentSpeed;
				        if(e<-20){
				        PWMDTY67 =0;          
				        PWMDTY23 =2400;
				        }
				        else if(e>20){
				        PWMDTY23=0;
				        PWMDTY67=2400;
				        }
				        else
				        {
				        ie+=e;
				        speed_0=speed_0-(Kp*e/10)-(int)(Ki*ie/1000)+Kd*(e-e_1);
				  SetSpeed();
				        }
				  }
				  void SetSpeed(void)
				  { if(speed_0>2400)
				  speed_0=2400;
				        PWMDTY67 =0;          
				        PWMDTY23 =speed_0;         
				  }
				 
				 
			
			复制代码
			

			 
		
 

 

文件到原文下载，原文出自：https://bbs.usoftchina.com/thread-205436-1-1.html

收起

展开全文

智能小车设计
2012-10-20 16:26:00
参加智能小车比赛和全国电子设计大赛做控制类的同学可以参考一下，对你们做小车可能有帮助。
收起

51单片机智能小车

2021-05-12 22:37:39

最近学校举办了一个智能小车比赛，比赛内容为用手机蓝牙控制小车拥有5个功能，分别是超声波舵机避障，测距（显示在LCD1602上），红外跟随，循迹还有蓝牙控制小车前进后退左转又转以及停止。文章目录蓝牙...

最近学校举办了一个智能小车比赛，比赛内容为用手机蓝牙控制小车拥有5个功能，分别是超声波舵机避障，测距（显示在LCD1602上），红外跟随，循迹还有蓝牙控制小车前进后退左转又转以及停止。

 




文章目录

蓝牙控制所有功能
	一、整体思路
	二、代码部分
	1、定时器初始化
	2、蓝牙部分控制所有功能
	3、红外跟随
	4、循迹
	三、完整代码


前言

基于51单片机的智能小车是比较基础的小车，很适合初学者学习

 

一、整体思路

这款小车单片机的芯片是52RC的，是有3个定时器T0,T1,T2，一般51的是只有两个定时器T0和T1，在这里我们将PWM模块和舵机共用一个定时器T0，定时器T1用于超声波，定时器T2用做串行口的波特率给蓝牙使用。

二、代码部分

1.定时器初始化

void TimeInit()
{
	
	T2MOD=0x01;//蓝牙
	T2CON=0x30;
	TH2=0xfd;
	TL2=0xfd;
	RCAP2H=0xFF;
	RCAP2L=0xDC;
	TMOD|=0x11;//定时器1用于超声波，定时器0舵机和PWM
	SCON=0x50;
	PCON=0x00;
    TH0=(65536-100)/256;//定时0.1ms
	TL0=(65536-100)%256;
	TH1=0x00;    
    TL1=0x00; 
	TR2=1;
	ET1=1;
    ET0=1;
	PS=1;
    EA=1;
    TR0=1;
	ES=1;
	PT1=0;
	IE=0x92;  
	}


2.蓝牙部分控制所有功能

while(1)                                //程序主循环
  {
		 if(flag_REC==1)				    //
	   {
		flag_REC=0;
		if(buff[0]=='O'&&buff[1]=='N')	//第一个字节为O，第二个字节为N，第三个字节为控制码
		switch(buff[2])
	     {
		      case up :						    // 前进
			  send_str( );
			  run();
			  ShowPort=LedShowData[1]; 
			  break;
		      case down:						// 后退
			  send_str1( );
			  back();
			  ShowPort=LedShowData[2]; 
			  break;
		      case left1:						// 左转
			  send_str3( );
			  leftrun();
			  ShowPort=LedShowData[3];  
			  break;
		      case right1:						// 右转
			  send_str2( );
			  rightrun();
			  ShowPort=LedShowData[4];
			  break;
		      case stop:						// 停止
			  send_str4( );
			  ShowPort=LedShowData[0];
			  stop1();
			  break;
			  case  csbcj:						    //舵机超声波测距
			  send_str5( );
              ShowPort=LedShowData[5];		    
			  Robot_Avoidance();
			  break;
				
				case  hwgs:						   //红外跟随
			   send_str6( );
               ShowPort=LedShowData[6];		    
			   Hwgs();
			   break;
               case  xj:						   //循迹 寻黑线
			   send_str7( );
               ShowPort=LedShowData[7];		    
			   Hwgs();
			   break;
				}
	
			}
}

 

3.红外跟随

void Hwgs()
{
	while(1)
	{
	  
              if(LeftIRBZ==1&&RightIRBZ==1)
			  stop1();	 //调用停止函数	  前面没有光线
              if(LeftIRBZ==1&&RightIRBZ==0)	    //右边检测到红外信号
			 	 {
				 	  rightrun2();	 //调用小车右转函数
					  delay(1);

			     }
			   
			  if(RightIRBZ==1&&LeftIRBZ==0)		//左边检测到红外信号
				 { 
				      
				  	  leftrun2();	  //调用小车左转函数
					  delay(1);

				  }
			  if(RightIRBZ==0&&LeftIRBZ==0)		//两边传感器同时检测到红外
				  {	  
				    run();		    //调用前进函数
					delay(1);		//前进40毫秒
				
				  }
				
			  if(buff[2]!=hwgs)return;
				  }
	          return;
				
      }

4.循迹

在这里我们用到的是三路循迹，有的小车可能有4路、5路循迹， 在这里可以自己根据PWM调节速度。

void Robot_Traction()  //机器人循迹子程序                   
{
	   
	         if(Left_1_led==0&&mid_1_led==1&&Right_1_led==0)//亮的时候为0，不亮才检测到黑线
			   {
			     run1();   
			   }
				              
			  if(Left_1_led==1&&mid_1_led==1&&Right_1_led==0)	   
			 	 {
				 	  left2();		  
					
			     }
			   if(Left_1_led==1&&mid_1_led==0&&Right_1_led==0) //原地向左旋转
			   {
			     leftrun();   
				 
			   }
			  if(Left_1_led==0&&mid_1_led==1&&Right_1_led==1)		
				  {	  
				      right2();		  
					 
				  }
			  
			  if(Left_1_led==0&&mid_1_led==0&&Right_1_led==1) //原地向右旋转
			   {
			     rightrun();   
				 
			   }
			  if(Right_1_led==1&&Left_1_led==1)		
				  {	  
				      run();		   
				  }
}

				


 

 

 

三、完整代码

下面是完整的代码

https://pan.baidu.com/s/1CYsrn7LoVRdI6DA6AxBVkw

链接：https://pan.baidu.com/s/1CYsrn7LoVRdI6DA6AxBVkw

提取码：srkl

收起

展开全文

单片机 c语言

第十届飞思卡尔智能小车赛比赛规则
2014-11-11 21:37:05
第十届飞思卡尔比赛规则
收起
飞思卡尔
智能小车设计指导
2013-04-23 18:11:24
这类小车就是校内智能小车比赛 飞思卡尔采用的类型，通常为后轮直流电机驱动+前轮舵机转向的方式，但是也有例外，像 2007 的全国大学生电子设计竞赛中的电动车跷跷板一题，为了达到精确的控制效果，很多人将后轮改 ...
收起

智能小车-红外循迹篇

热门讨论 2021-05-12 19:51:41

Record:2021/5/12日学院举办的智能小车比赛落下帷幕，特地将比赛出现的问题和经历总结一下，以表纪念。比赛要求蓝牙模板和超声波，测距，目标跟踪四个功能整合在一个程序上，另一项就是红外循迹加避障（不是绕碍,...

Record:2021/5/12日学院举办的智能小车比赛落下帷幕，特地将比赛出现的问题和经历总结一下，以表纪念。

比赛要求蓝牙模板和超声波，测距，目标跟踪四个功能整合在一个程序上，另一项就是红外循迹加避障（不是绕碍,不过也不难）。

我先将记忆深刻的红外循迹避障程序记录下来：

首先直接上代码：

*  晶振:11.0592MHZ
  ZYWIFI0939WIFI控制智能机器人杜邦线接线方法，请一定照做，否则可能不工作，并烧毁小车。
  J3 接到实验板 P4		                           J4 接实验板 P7接口 
   IN1--接到--实验板上的P1.2	               IN5--接到--实验板上的P2.1
   IN2--接到--实验板上的P1.3	               IN6--接到--实验板上的P2.0
   EN1--接到--实验板上的P1.4
   EN2--接到--实验板上的P1.5
   IN3--接到--实验板上的P1.6
   IN4--接到--实验板上的P1.7
   
   J5 接实验班P3接口
   OUT1--接到--实验板上的P3.2	                  OUT3--接到--实验板上的P3.4
   OUT2--接到--实验板上的P3.3					  OUT4--接到--实验板上的P3.5
   VCC-- 接到--实验班上的VCC					  GND--接到--实验板上的GND
    
******************************************************************/
#ifndef _LED_H_
#define _LED_H_


    //定义小车驱动模块输入IO口 
   sbit L293D_IN1=P1^2; 
   sbit L293D_IN2=P1^3;
   sbit L293D_IN3=P1^4;
   sbit L293D_IN4=P1^5;
   sbit L293D_EN1=P1^6;
   sbit L293D_EN2=P1^7;
	

	/***蜂鸣器接线定义*****/
    sbit BUZZ=P2^3;
 
    #define Left_1_led        P3_7	 //左传感器  
	
    #define Right_1_led       P3_6	 //右传感器 
	
	#define mid_1_led         P0^0   //中间循迹

	#define Left_2_led        P3_4	 //左避障传感器  
	
    #define Right_2_led       P3_5	 //右避障传感器    
   
	#define Left_moto_pwm	  P1_6	 //PWM信号端

	#define Right_moto_pwm	  P1_7	 //PWM信号端
	
	#define Left_moto_go      {P1_2=1,P1_3=0;}  //左电机向前走
	#define Left_moto_back    {P1_2=0,P1_3=1;} 	//左边电机向后转
	#define Left_moto_Stop    {P1_2=0,P1_3=0;}         //左边电机停转                     
	#define Right_moto_go     {P1_4=1,P1_5=0;}	//右边电机向前走
	#define Right_moto_back   {P1_4=0,P1_5=1;}	//右边电机向后走
	#define Right_moto_Stop   {P1_4=0,P1_5=0;}      	//右边电机停转   

	unsigned char pwm_val_left  =0;//变量定义
	unsigned char push_val_left =0;// 左电机占空比N/20
	unsigned char pwm_val_right =0;
	unsigned char push_val_right=0;// 右电机占空比N/20
	bit Right_moto_stop=1;
	bit Left_moto_stop =1;
	unsigned  int  time=0;
   
/************************************************************************/	
//延时函数	
   void delay(unsigned int k)
{    
     unsigned int x,y;
	 for(x=0;x<k;x++) 
	   for(y=0;y<200;y++);
}
/************************************************************************/
//前速前进
     void  run(void)
{
     push_val_left=20;	 //速度调节变量 0-20。。。0最小，20最大
	 push_val_right=20;
	 Left_moto_go ;   //左电机往前走
	 Right_moto_go ;  //右电机往前走
}

//后退函数 
     void  backrun(void)
{
     push_val_left=12;	 //速度调节变量 0-20。。。0最小，20最大
	 push_val_right=12;
	 Left_moto_back;   //左电机往后走
	 Right_moto_back;  //右电机往后走
}

//左转
     void  leftrun(void)
{	 
     push_val_left=14;
	 push_val_right=20;
	 Right_moto_go ;  //右电机往前走
     Left_moto_go   ;  //左电机后走
}
      //急左转
     void  moreleft(void)
{	 
     push_val_left=15;
	 push_val_right=15;
	 Right_moto_go ;  //右电机往前走
     Left_moto_back   ;  //左电机后走
}

//右转
     void  rightrun(void)
{ 
	 push_val_left=20;
	 push_val_right=14;
     Left_moto_go  ;   //左电机往前走
	 Right_moto_go    ;  //右电机往后走	
}
//急右转
     void  moreright(void)
{ 
	 push_val_left=16;
	 push_val_right=16;
     Left_moto_go  ;   //左电机往前走
	 Right_moto_back    ;  //右电机往后走	
}

//停止
     void  stop(void)
{	 
     
	 Right_moto_Stop ;  //右电机停止
     Left_moto_Stop  ;  //左电机停止
}

/************************************************************************/
/*                    PWM调制电机转速                                   */
/************************************************************************/
/*                    左电机调速                                        */
/*调节push_val_left的值改变电机转速,占空比            */
		void pwm_out_left_moto(void)
{  
   if(Left_moto_stop)
   {
    if(pwm_val_left<=push_val_left)
	       {
		     Left_moto_pwm=1; 
//		     Left_moto_pwm1=1; 
		   }
	else 
	       {
	         Left_moto_pwm=0;
//		     Left_moto_pwm1=0; 
		   }
	if(pwm_val_left>=20)
	       pwm_val_left=0;
   }
   else    
          {
           Left_moto_pwm=0;
//           Left_moto_pwm1=0; 
		  }
}
/******************************************************************/
/*                    右电机调速                                  */  
   void pwm_out_right_moto(void)
{ 
  if(Right_moto_stop)
   { 
    if(pwm_val_right<=push_val_right)
	      {
	       Right_moto_pwm=1; 
//		   Right_moto_pwm1=1; 
		   }
	else 
	      {
		   Right_moto_pwm=0;
//		   Right_moto_pwm1=0; 
		  }
	if(pwm_val_right>=20)
	       pwm_val_right=0;
   }
   else    
          {
           Right_moto_pwm=0;
//           Right_moto_pwm1=0; 
	      }
}
       
/***************************************************/
///*TIMER0中断服务子函数产生PWM信号*/
 	void timer0()interrupt 1   using 2
{
     TH0=0XFc;	  //1Ms定时
	 TL0=0X18;
	 time++;
	 pwm_val_left++;
	 pwm_val_right++;
	 pwm_out_left_moto();
	 pwm_out_right_moto();
 }	

/*********************************************************************/	

#endif

	#include<AT89X52.H>		  //包含51单片机头文件，内部有各种寄存器定义
	#include<ZY-4WD_PWM.H>		  //包含HL-1蓝牙智能小车驱动IO口定义等函数
     
//主函数
	void main(void)
{	

	unsigned char i;
	unsigned char flag; //  标记点
    P1=0X00;   //关电机	

		 	TMOD=0X01;
        	TH0= 0XFc;		  //1ms定时
         	TL0= 0X18;
           	TR0= 1;
        	ET0= 1;
	        EA = 1;			   //开总中断


	while(1)	//无限循环
	{ 
			    if(Left_2_led==0 || Right_2_led==0) //遇到障碍物

			 {	 
     
	            	 backrun();
					 delay(1);
					 stop();
              }
	 
			 //有信号为0  没有信号为1
			   	if(Left_1_led==1&&mid_1_led==1&&Right_1_led==1)//亮的时候为0，1才检测到黑线
			   {							 
			     	 run();
			   }
             
				              
			  if(Left_1_led==1&&mid_1_led==1&&Right_1_led==0)	   
			 	 {
				 	  leftrun();
					  flag=0;
					  delay(1);		  
					
			     }
			 
			  if(Left_1_led==0&&mid_1_led==1&&Right_1_led==1)		
				  {	  
				      rightrun();
					  flag=1;		  
					  delay(1);	
				  }
			  
			 
			  if(Right_1_led==1&&Left_1_led==1)		
				  {	  
				      run();		   
				  }
			if(Left_1_led==0&&mid_1_led==0&&Right_1_led==0)//亮的时候为0，1才检测到黑线
			   {							 //跑出赛道
			     if(flag==1) 
				 {						//右急转
				   moreright();
				 } 
				   if(flag==0) 
				 {						//左急转
				   moreleft();
				 }   
			   }

	 }
}


我们在基础的代码上进行的修改，让它的速度尽量发挥到极致，这个小车在淘宝上买的，大概两百多，感兴趣的话可以买一辆挺好玩的。

根据小车传感器原理图我们可以知道P3.6，P3.7，P0.0为三个红外循迹传感器，P3.4,P3.5为左右避障传感器大家要根据原理图进行更改，需要原理图的可以私聊我，在调试小车时，就因为没有认真看原理图在代码编写的时候一直出问题，还有一定一定一定要将代码放在准确的文件夹里，我好多次就是改代码改了一下午没找到错误，后来才发现代码写到另一个备份的文件夹里，白白浪费一个下午的时间。

代码部分，我们在原代码的基础上增加了flag函数，这是为了在速度极高的情况之下，小车就有跑出赛道的可能却依然能跑回赛道（这也就意味着没检测到黑线小车就会跑了）。正是这个flag函数的存在使得可以将小车的硬件发挥到极致，所以我们把PWM调速调到最高小车也不会跑离赛道太多（会有一丢丢的跑出去），避障的话我加了一个后退的函数，避免速度太快直接撞上。至少电机反转减速倒退然后保持一定距离。 

下面就是测试哪个速度能将跑出最快的成绩了，我们用黑色胶带在宿舍自己搞了一个赛道然后测试时间：





最左边是前进速度左右电机都为20，左右电机在转向的时候都是向前走，依靠两边的速度差进行转向（测试过一边电机向后一边向前转，不过速度不太理想）；后面最好速度为一圈11.3秒，可能存在一些偶然误差，不过这确实是比较理想的数据了。

然后静静等待比赛结果了，不管怎样这五天和同学一起研究挺开心的，不论结果如何不断冲刺吧！

我们的目标可是不断超越！

收起

展开全文

单片机程序设计

智能小车资料
2018-02-09 23:16:52
智能小车，飞思卡尔比赛用小车，分为电磁组，光电组，ccd组，小车可自动寻找路线，自动驾驶
收起
飞思卡尔智能汽车比赛
2011-09-07 21:15:51
智能小车比赛的内部资料，里面有获奖的各种信息。希望对大家有所帮助
收起
智能小车电路设计
2012-10-20 16:27:39
智能小车电路设计，对小车比赛和电子设计大赛控制类的同学有帮助，你们可以参考一下如何去高效，方便，经济的设计电路
收起

智能车比赛总结（树莓派控制的智障小车）

2020-12-31 16:55:32

忙忙碌碌两个星期，这次的智能车校内赛终于是落下了帷幕。不管结果如何，准备的过程才是真正的收获，尤其是对于一个第一次使用单片机（开发板）的小白来说，实实在在学到了很多东西。下面将对这次的比赛过程做一个...

忙忙碌碌两个星期，这次的智能车校内赛终于是落下了帷幕。不管结果如何，准备的过程才是真正的收获，尤其是对于一个第一次使用单片机（开发板）的小白来说，实实在在学到了很多东西。下面将对这次的比赛过程做一个小小的总结。
1、比赛要求
比赛要求参赛队每组设计一个自动或半自动的机器人，比赛过程中，从启动区出发进入迷宫，击倒靶标，再从出口驶出。决赛中机器人需要先获取裁判出示的随机打靶顺序，按顺序击倒靶标。
2、硬件准备
1）小车底盘加水弹枪云台。小车底盘我们使用的是麦轮的底盘，主要考虑在行动中可以自由旋转和平移。水弹枪云台使用两个自由度的云台控制（两个舵机分别控制它的平移角度和倾斜角度）



2）开发板。我们的是树莓派3B+开发板，主要是因为树莓派可以使用Python语言编写，编程小白容易上手。/偷笑



3）电机驱动板。我们使用了两块L293N电机驱动板控制四路电机。



4）舵机驱动板。舵机控制板至少需要同时控制两路舵机，满足此条件即可，我们是用的是以前学长自己画的控制板，这里就不在展示。

如果有能力自己画一块板子，把电机驱动和舵机驱动整合到一块板子上最好，这样可以节省很多空间。我没学过PCB也不会，所以只能自己东拼西凑找来一堆凑着用。/惭愧

5）水弹枪电机驱动板。水弹枪电机由于负载较大所以其功率也大，建议单独使用一块驱动板控制。我们使用的是MOS驱动模块。（主要是便宜 ）



6）超声波模块。超声波模块最好使用三个，前左右各一个，可以让小车灵活的避障和转弯。也有使用一个舵机加一个超声波判断的，个人感觉这种判断方式会占用不必要的时间。而且对于新手来说加大了编程的困难度，当然，大佬请忽略。/笑哭



7）摄像头。摄像头主要用来识别AprilTag标签，在打靶和走十字路口时用到。我们使用的是openMV，其一识别AprilTag标签的程序官方已经做的很好，可以直接使用，其二openMV也可以作为一块单片机使用，这样我们就相当于有了两块控制开发板，岂不妙哉。



8）VCC、GND面包板。有了VCC、GND面包板我们就可将电源和接地引出，一来可以扩展接口，二来方便接线。次面包板建议使用两块，一块用来走电源大于6V的电，一块走信号电，小于5V。

9）杜邦线若干。
3、物理接线
接线也是一件技术活，最考验细心和耐心。接线之前应该先把控制板的GPIO口定义完成，这样在接线的时候才能做到有条不紊，也更方便检查。

1）电机驱动

首先应该是电机线已经焊接到电机两端并且保证焊接牢靠。（哈哈哈，说的好像是废话）

四个电机分别接到驱动板的四个电机接口，正负可以不用太在意，后面可调，但是哪个电机接到哪个接口要记住，最好用笔记下来，正所谓好记性不如烂笔头，不然后面还得测，麻烦。ENA、ENB是电机的使能端，若想要使用PWM调速，则拔掉使能端与旁边引脚的跳线帽，将使能端接定义的IO口；若不用PWM调速，则插上跳线帽，使其始终高电平，因为其是高电平有效。若是其他驱动板没有始终高电平的引脚可以接到控制板的GPIO口，在程序中直接给高电平或者接到控制板的高电平输出，反正很多种办法使其在工作时保持高电平，看自己喜好。剩下的IN接控制板GPIO口，控制电机正反转。

驱动板电源接12V端口，GND接电源负极，电源大小视具体情况而定，我们接了8V电源，想接12V来着因为第一次弄总是不大胆，怕把电机给烧了（实际上已经少了一个，但是没给12V电压，具体原因至今没找到，怀疑是缠上了头发。/捂脸），其实完全可以接12V，我们小车的速度始终没上去，就是因为电压不够，后悔。

注意：驱动板和控制板一定要共地（也就是驱动板的GND要和控制板的GND接到一起），不然电机是动不起来的。

2）舵机驱动

舵机接线盒普通直流电机接线大差不差，舵机引出的是三根线，一根信号线，两根电源线。将其插到控制板的对应接口，然后控制板会有一根信号引脚将其接到控制板的GPIO口即可。电源可以使用和电机的同一个电源。

3）MOS模块

VIN,GND接电源，V+、V-接水弹枪电机，VCC、GND接控制板电源或者GPIO口自定义高低电平，SIG接GPIO口，输入的是PWM信号，控制水弹枪的射速。

4）树莓派与openMV通信物理接线

树莓派与openMV选用UART通信，树莓派的RX连接OpenMV 的TX，树莓派的TX连接OpenMV 的RX，树莓派的GND连接OpenMV 的GND。
4、软件控制
1）追踪AprilTag标签云台控制

云台使用两个舵机分别控制它的平移和倾斜角度，两个舵机的控制我们在openMV完成，一来可以使它不会与小车的动作冲突，二来openMV有类似的官方代码，修修改改就可以使用，何乐不为（其实还是因为自己菜，也在树莓派里面写过，效果不如在openMV完成）。云台使用PID控制，使其能够准确地瞄准标签中心。控制框图如下：



控制流程图：

打靶有一个要求，比赛前由裁判抽取打靶顺序，机器人应按照裁判抽取的顺序进行打靶。这里我们使用数组存入顺序然后按顺序抽取数组中的元素给小车的击打信号。

程序：

（云台控制加与树莓派通信，未包含射击部分）
import sensor, image, time

from pid import PID
from pyb import Servo
from pyb import UART

uart = UART(3,115200)
pan_servo=Servo(1)
tilt_servo=Servo(2)
pan_angle = 0
tilt_angle = 0


#pan_pid = PID(p=0.07, i=0, imax=90) #脱机运行或者禁用图像传输，使用这个PID
#tilt_pid = PID(p=0.05, i=0, imax=90) #脱机运行或者禁用图像传输，使用这个PID
pan_pid = PID(p=0.2, i=1.5, imax=90)#在线调试使用这个PID
tilt_pid = PID(p=0.22, i=0, imax=90)#在线调试使用这个PID

sensor.reset() # Initialize the camera sensor.
sensor.set_pixformat(sensor.RGB565) # use RGB565.
sensor.set_framesize(sensor.QQVGA) # use QQVGA for speed.
sensor.skip_frames(10) # Let new settings take affect.
sensor.set_auto_whitebal(False) # turn this off.
clock = time.clock() # Tracks FPS.

def find_max(blobs):
    max_size=0
    for blob in blobs:
        if blob[2]*blob[3] > max_size:
            max_blob=blob
            max_size = blob[2]*blob[3]
    return max_blob


while(True):
    if uart.any():
        a = uart.readline().decode()
        b = int(a)
    clock.tick() # Track elapsed milliseconds between snapshots().
    img = sensor.snapshot() # Take a picture and return the image.

    blobs = img.find_apriltags()
    if blobs:
        max_blob = find_max(blobs)
        pan_error = max_blob.cx()-img.width()/2
        tilt_error = max_blob.cy()-img.height()/2

        #print("pan_error: ", pan_error)
        #print("tilt_error:", tilt_error)

        img.draw_rectangle(max_blob.rect()) # rect
        img.draw_cross(max_blob.cx(), max_blob.cy()) # cx, cy

        pan_output=pan_pid.get_pid(pan_error,1)/4
        tilt_output=tilt_pid.get_pid(tilt_error,1)
        print("pan_output",pan_output,"tilt_output",tilt_output)

        #pan_angle = pan_angle + pan_output
        #tilt_angle = tilt_angle - tilt_output
        pan_servo.angle(-pan_output)
        tilt_servo.angle(-tilt_output)
        #print("pan_angle",pan_angle,"tilt_angle",tilt_angle)
        output_str="%d,%d,%d" % (0,max_blob.id(),max_blob.id())
        # UART 3, and baudrate.
        print('you send:',output_str)
        uart.write(output_str)

    else:
        #pan_servo.angle(0)
        #tilt_servo.angle(0)
        output_str = '[%d]' % 0
        print('you send:',output_str)
        uart.write(output_str)


2）小车避障控制

在小车的前左右分别装上超声波，根据超声波测得的距离实现避障功能。控制流程图如下图所示。



超声波测距程序：
import RPi.GPIO as GPIO
import time

#超声波引脚
Trig_F = 16
Echo_F = 18

Trig_L = 13
Echo_L = 15

Trig_R = 11
Echo_R = 12

#设置引脚模式
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

GPIO.setup(Trig_F, GPIO.OUT)
GPIO.setup(Echo_F, GPIO.IN)

GPIO.setup(Trig_L, GPIO.OUT)
GPIO.setup(Echo_L, GPIO.IN)

GPIO.setup(Trig_R, GPIO.OUT)
GPIO.setup(Echo_R, GPIO.IN)

#前方距离
def Distance_Front():
    GPIO.output(Trig_F, 0)
    time.sleep(0.000002)
    GPIO.output(Trig_F, 1)
    time.sleep(0.00001)
    GPIO.output(Trig_F, 0)
    while GPIO.input(Echo_F) == 0:
        pass
    emitTime = time.time()
    while GPIO.input(Echo_F) == 1:
        pass
    acceptTime = time.time()
    totalTime = acceptTime - emitTime
    distance = totalTime * 340 / 2 * 100
    print('front:',distance)
    time.sleep(0.06)
    return  distance

#左侧距离
def Distance_Left():
    GPIO.output(Trig_L, 0)
    time.sleep(0.000002)
    GPIO.output(Trig_L, 1)
    time.sleep(0.00001)
    GPIO.output(Trig_L, 0)
    while GPIO.input(Echo_L) == 0:
        pass
    emitTime = time.time()
    while GPIO.input(Echo_L) == 1:
        pass
    acceptTime = time.time()
    totalTime = acceptTime - emitTime
    distance = totalTime * 340 / 2 * 100
    print('left:',distance)
    time.sleep(0.06)
    return  distance

#右侧距离
def Distance_Right():
    GPIO.output(Trig_R, 0)
    time.sleep(0.000002)
    GPIO.output(Trig_R, 1)
    time.sleep(0.00001)
    GPIO.output(Trig_R, 0)
    while GPIO.input(Echo_R) == 0:
        pass
    emitTime = time.time()
    while GPIO.input(Echo_R) == 1:
        pass
    acceptTime = time.time()
    totalTime = acceptTime - emitTime
    distance = totalTime * 340 / 2 * 100
    time.sleep(0.06)
    print('right:',distance)
    return  distance

小车避障程序：
import RPi.GPIO as GPIO
import Ultrasonic as u
import time

#左前轮引脚设置
FrontLeft_0 = 35
FrontLeft_1 = 37
FrontLeft_en = 40
#右前轮引脚设置
FrontRight_0 = 31
FrontRight_1 = 33
FrontRight_en = 38
#左后轮引脚设置
BackLeft_0 = 26
BackLeft_1 = 29
BackLeft_en =36
#右后轮引脚设置
BackRight_0 = 24
BackRight_1 = 22
BackRight_en = 32


GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

GPIO.setup(FrontLeft_0,GPIO.OUT)
GPIO.setup(FrontLeft_1,GPIO.OUT)
GPIO.setup(FrontLeft_en,GPIO.OUT)
GPIO.setup(FrontRight_0,GPIO.OUT)
GPIO.setup(FrontRight_1,GPIO.OUT)
GPIO.setup(FrontRight_en,GPIO.OUT)
GPIO.setup(BackLeft_0,GPIO.OUT)
GPIO.setup(BackLeft_1,GPIO.OUT)
GPIO.setup(BackLeft_en,GPIO.OUT)
GPIO.setup(BackRight_0,GPIO.OUT)
GPIO.setup(BackRight_1,GPIO.OUT)
GPIO.setup(BackRight_en,GPIO.OUT)
    
#PWM设置
FrontLeft_pwm = GPIO.PWM(FrontLeft_en, 100)
FrontRight_pwm = GPIO.PWM(FrontRight_en, 100)
BackLeft_pwm = GPIO.PWM(BackLeft_en, 100)
BackRight_pwm = GPIO.PWM(BackRight_en, 100)

#设置初始速度
FrontLeft_pwm.start(0)
FrontRight_pwm.start(0)
BackLeft_pwm.start(0)
BackRight_pwm.start(0)

# 左前轮向前转
def front_left_forward(speed):
    FrontLeft_pwm.ChangeDutyCycle(speed)
    GPIO.output(FrontLeft_0,GPIO.HIGH)
    GPIO.output(FrontLeft_1,GPIO.LOW)
    #time.sleep(time)
    
# 左后轮向前转
def rear_left_forward(speed):
    BackLeft_pwm.ChangeDutyCycle(speed)
    GPIO.output(BackLeft_0,GPIO.HIGH)
    GPIO.output(BackLeft_1,GPIO.LOW)

# 右前轮向前转
def front_right_forward(speed):
    FrontRight_pwm.ChangeDutyCycle(speed)
    GPIO.output(FrontRight_0,GPIO.HIGH)
    GPIO.output(FrontRight_1,GPIO.LOW)

# 右后轮向前转
def rear_right_forward(speed):
    BackRight_pwm.ChangeDutyCycle(speed)
    GPIO.output(BackRight_0,GPIO.HIGH)
    GPIO.output(BackRight_1,GPIO.LOW)

# 左前轮向后转
def front_left_back(speed):
    FrontLeft_pwm.ChangeDutyCycle(speed)
    GPIO.output(FrontLeft_0,GPIO.LOW)
    GPIO.output(FrontLeft_1,GPIO.HIGH)
    
# 左后轮向后转
def rear_left_back(speed):
    BackLeft_pwm.ChangeDutyCycle(speed)
    GPIO.output(BackLeft_0,GPIO.LOW)
    GPIO.output(BackLeft_1,GPIO.HIGH)

# 右前轮向后转
def front_right_back(speed):
    FrontRight_pwm.ChangeDutyCycle(speed)
    GPIO.output(FrontRight_0,GPIO.LOW)
    GPIO.output(FrontRight_1,GPIO.HIGH)

# 右后轮向后转
def rear_right_back(speed):
    BackRight_pwm.ChangeDutyCycle(speed)
    GPIO.output(BackRight_0,GPIO.LOW)
    GPIO.output(BackRight_1,GPIO.HIGH)

# 前进，4个轮子全部向前转
def forward(speed_fl,speed_fr,speed_bl,speed_br):
    front_left_forward(speed_fl)
    front_right_forward(speed_fr)
    rear_left_forward(speed_bl)
    rear_right_forward(speed_br)
    
# 后退，4个轮子全部向后转
def backward(speed_fl,speed_fr,speed_bl,speed_br):
    front_left_back(speed_fl)
    front_right_back(speed_fr)
    rear_left_back(speed_bl)
    rear_right_back(speed_br)

# 左转
def turnleft(speed_fl,speed_fr,speed_bl,speed_br):
    front_left_back(speed_fl)
    rear_left_back(speed_bl)
    front_right_forward(speed_fr)
    rear_right_forward(speed_br)
    
# 右转
def turnright(speed_fl,speed_fr,speed_bl,speed_br):
    front_right_back(speed_fr)
    rear_right_back(speed_br)
    front_left_forward(speed_fl)
    rear_left_forward(speed_bl)
    
# 左平移
def left_translation(speed_fl,speed_fr,speed_bl,speed_br):
    front_left_back(speed_fl)
    rear_left_forward(speed_bl)
    front_right_forward(speed_fr)
    rear_right_back(speed_br)

# 右平移
def right_translation(speed_fl,speed_fr,speed_bl,speed_br):
    front_left_forward(speed_fl)
    rear_left_back(speed_bl)
    front_right_back(speed_fr)
    rear_right_forward(speed_br)    
                
    
def pause():
    FrontLeft_pwm.ChangeDutyCycle(0)
    GPIO.output(FrontLeft_0,GPIO.LOW)
    GPIO.output(FrontLeft_1,GPIO.LOW)
    #GPIO.output(ForntLeft_en,GPIO.LOW)
    FrontRight_pwm.ChangeDutyCycle(0)
    GPIO.output(FrontRight_0,GPIO.LOW)
    GPIO.output(FrontRight_1,GPIO.LOW)
    #GPIO.output(FrontRight_en,GPIO.LOW)
    BackLeft_pwm.ChangeDutyCycle(0)
    GPIO.output(BackLeft_0,GPIO.LOW)
    GPIO.output(BackLeft_1,GPIO.LOW)
    #GPIO.output(BackLeft_en,GPIO.LOW)
    BackRight_pwm.ChangeDutyCycle(0)
    GPIO.output(BackRight_0,GPIO.LOW)
    GPIO.output(BackRight_1,GPIO.LOW)
    #GPIO.output(BackRight_en,GPIO.LOW)

def stop():
    pause()
    GPIO.cleanup()
    
def run():
    distance_front = u.Distance_Front()
    distance_left = u.Distance_Left()
    distance_right = u.Distance_Right()
    #自动运行，避障
    if distance_front < 50:
        #backward(100,100,100,100)
        if distance_left > 60:
            turnleft(100,100100,100)
        elif distance_right > 60:
            turnright(100,100,100,100)
        else:
            backward(100,100,100,100)
    elif distance_left < 18:
        right_translation(100,100,100,100)
    elif distance_right < 18:
        left_translation(100,100,100,100)
    else:    
        forward(100,100,100,100)    

关于如何判断小车是否到达射击区域，比赛场地是有AprilTag标签提示的，发现标签停止，执行射击程序，此组射击完成执行运动程序。

3）树莓派与openMV通信

按照上述完成接线后进行通信程序编写

树莓派端
# -*- coding: utf-8 -*
import serial
import time

ser = serial.Serial("/dev/ttyAMA0",115200)

if not ser.isOpen():
    print("open failed")
else:
    print("open success: ")
    print(ser)

try:
    while True:
        count = ser.inWaiting()
        if count > 0:
            recv = ser.read(count)
            print("recv: " + recv)
            ser.write(recv)
        time.sleep(0.05) 
except KeyboardInterrupt:
    if ser != None:
        ser.close()

openMV端
# UART Control
#
# This example shows how to use the serial port on your OpenMV Cam. Attach pin
# P4 to the serial input of a serial LCD screen to see "Hello World!" printed
# on the serial LCD display.

import time
from pyb import UART

# Always pass UART 3 for the UART number for your OpenMV Cam.
# The second argument is the UART baud rate. For a more advanced UART control
# example see the BLE-Shield driver.
uart = UART(3, 115200)

while(True):
    uart.write("Hello World!\r")
    time.sleep(1000)



这里没想清楚通信程序怎么在子程序中完成，所以把通信写在了主程序中，若有好的可以写在子程序的想法，欢迎联系。

上述只是通信测试的程序。

收起

展开全文

python 自动驾驶

智能消防小车
2018-06-04 21:25:32
用于智能消防小车比赛的代码开发》》》》》》》》》》》》》》》》》》》》》》
收起
智能小车题目
2013-08-13 00:42:57
智能消防车题目就是2012年广西区比赛题目仅供参考
收起
智能遥控小车
2019-01-12 14:29:58
本资源是在keil平台上编写的基于stm32的遥控智能小车程序，也可用于智能小船。采用nrf2401射频模块进行无线传输，5110液晶显示屏进行人机交互，可四电机同时进行控制，经实验和比赛考验，可放心使用!
收起
竞赛中智能小车的设计技巧
2013-03-17 00:55:37
各大电子设计比赛陆续开展,例如"飞思卡尔"杯全国大学生智能车竞赛,全国大学生电子设计大赛等,智能小车是其中很重要的一个比赛项目。智能小车实用有趣,贴近生活。易于上手等特点,让越来越多的电子爱好者逐渐对智能...
收起
编码在智能小车系统设计中的应用
2012-11-09 10:10:17
结合实际参赛经验,对智能小车系统的设计进行了介绍,给出了系统的硬件结构框架设计方案,并在此基础上进行了系统软件流程设计,论述了对赛道进行二进制编码方式实现智能小车的处理算法,从而保证了智能小车全部比赛功能...
收起
飞思卡尔智能小车算法介绍.ppt
2020-08-07 00:25:54
第3章智能汽车设计基础一...软件部分是整个智能车系统的灵魂,在硬件方面各参赛队之间大同小异,真正体现各参赛队智能车的优势和最后决定比赛成绩妤坏的往往是软件部分,尤其是核心控制算法的设计本章首先简要介绍软
收起
智能循迹小车diy
2019-10-02 01:03:05
智能循迹小车，是许多本科毕业论文首选项目。也有相应的比赛项目。网上有不少智能循迹小车的整车，套件，或者配件卖，但是自己完完全全diy一个智能循迹小车，还是有一定挑战性的。网上有一个比较全的制作...
收起
2003年智能小车（全国大学生电子设计竞赛）.zip
2021-03-23 15:56:22
2003年智能小车（全国大学生电子设计竞赛）源代码，适用于毕业设计、比赛、出书项目实例，实际设计参考。
收起

2013年飞思卡尔智能小车比赛创意组

飞思卡尔智能小车比赛单片机硬件设计资料

赛道计时，一个用时智能小车比赛的VB串口程序设计

飞思卡尔智能小车比赛的报告

近十个学校的智能小车比赛程序（无保留），要的来拿

智能小车设计

51单片机智能小车

文章目录

前言

一、整体思路

二、代码部分

1.定时器初始化

2.蓝牙部分控制所有功能

3.红外跟随

4.循迹

三、完整代码

第十届飞思卡尔智能小车赛比赛规则

智能小车设计指导

智能小车-红外循迹篇

智能小车资料

飞思卡尔智能汽车比赛

智能小车电路设计

智能车比赛总结（树莓派控制的智障小车）

1、比赛要求

2、硬件准备

3、物理接线

4、软件控制

智能消防小车

智能小车题目

智能遥控小车

竞赛中智能小车的设计技巧

编码在智能小车系统设计中的应用

飞思卡尔智能小车算法介绍.ppt

智能循迹小车diy

2003年智能小车（全国大学生电子设计竞赛）.zip

智能小车比赛