麦克纳姆轮小车程序（标准库版本）

总结所学

已于 2022-07-19 20:44:56 修改

阅读量3.1k

点赞数 5

分类专栏：麦克纳姆轮小车文章标签： c语言单片机 stm32

于 2022-07-19 20:17:03 首次发布

本文链接：https://blog.csdn.net/u011878611/article/details/125880073

版权

麦克纳姆轮小车专栏收录该内容

3 篇文章 9 订阅

订阅专栏

麦克娜姆轮小车包含蓝牙手机控制，手柄控制，上位机PID调节程序；其它配件程序见原理图；

WIF控制（暂未添加）MPU6050(暂未添加）。

注释部分调试时未做修改，不做参照，直接解读程序：

#include "stm32f10x.h"
#include "bit_band.h"
#include "delay.h"

#include "timer.h"//置位标志位

#include "led.h"
#include "key.h"
#include "beep.h"

#include "MotorDrive.h"
#include "encoder.h"
#include "pid.h"
#include "waveform.h"//串口3与上位机通讯传输PID数据

#include "rf2G4.h"
#include "bluetooth.h"
#include "wifi.h"
#include "usart.h"//留作后期LINUX上位机

#include "oled.h"



u8 MODE=0;//模式选择：0,PS2控制；1，蓝牙控制 ；2，PID控制 ；3，WiFi控制
int Motspeed=60;//转/s

extern u8 F_pid_functiion;
extern u8 F_pid_waveform;
extern u8 F_mileage;
extern u8 F_oled_usart3;

int main(void)
{	
	u8  L_CNT = 0 ;				// 循环计数，LED闪烁
		
// 注：程序中使用中断时，NVIC分组设置应尽量位于程序起始处，并且在设置后尽量不要再更改NVIC分组
//	定时器6，中断分组0.0；
//	定时器3，中断分组0,1；
//	串口1，中断分组1.1;波形显示串口3，中断分组1.2；蓝牙串口4，中断分组1.3；WIFI串口5，中断分组1.4；
//	外部编码器，中断分组（2，0）（2，1）（2，2）（2，3）
//------------------------------------------------------------------------------------------
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

	delay_Init();
	TIM3_Time_Init();	
	
	LED_Init_JX();
	KEY_Init_JX();
	BEEP_Init();		
	
	Car_Init();		
	EncoderInit();
	TIM6_Time_Init();	//用于编码器T法测速计时
	PID_Init();
	Waveform_Config();//配置串口3
	
	Bluetooth_Config();//串口4
	Wifi_Config();//串口5
	
	RF2G4_Init();//使用SPI1
	USART1_Config();	//串口1

	OLED_Init();	//I2C


		
//--------------------蜂鸣器\ 串口1 3 \射频通讯检测----------------------------------------------	
	// 上电蜂鸣器鸣响
	BEEP_Sound();
	// 判断串口通讯成功
	printf("串口3测试通讯成功\n\n\n\n"); 	//测试串口3PID波形输出
	
	Usart1_SendString( USART1, "串口1测试通讯成功\n\n\n\n");//测试串口1上位机通讯
	
	// 判断SI24R1是否正常
	if(!RF2G4_Check())
	{ 
		for( L_CNT=0; L_CNT<10; L_CNT++ )	// 如果2.4G模块连接正常，则LED_Green上电后闪烁几次
		{
			LED = !LED ;
			delay_ms(50);
		}
		LED = 1;
	}
	
	RF2G4_RX_Mode();			// 将SI24R1设置为接收模式

	while(1)
	{
//------------------------Pid调试小车---------------------------------------------------
		//5ms执行一次PID计算
		if(F_pid_functiion==1)
		{
			F_pid_functiion=0;
			PIDSPD_SinglePulse();
		}
			
		if( F_pid_waveform==1 )//100ms发送波形，太快上位机不能下发数据
		{
			F_pid_waveform=0;	
			
//			osci_sendA();			
//			osci_sendB();
//			osci_sendC();
//			osci_sendD();
		 }
		
//--------------------PS2,蓝牙、WIFI小车控制---------------------------------------------------
	
//		RF24L01_control();
		 
//------------------------计算里程--------------------------------------------------	

//	if( F_mileage==1 ) //50ms计算里程
//		{
//			F_mileage=0;
//			GetMileage();	
//		}
		 
//-------------------OLED、串口显示数据---------------------------------------------------
	if( F_oled_usart3==1 )//200ms显示数据
		{
			F_oled_usart3=0;
		  OLED_display();
//			Usart3_display();

			

		}
	}
}

#include "delay.h"

static u16 SysTick_each_us_CNT ;	// SysTick计时1us所需的计数次数
static u16 SysTick_each_ms_CNT ;	// SysTick计时1ms所需的计数次数

// 初始化SysTick定时器
void delay_Init(void)
{
	// RCC通过AHB时钟(HCLK)8分频后作为Cortex系统定时器(SysTick)的可选外部时钟
	// 默认：SystemCoreClock = SYSCLK_FREQ_72MHz ;
	//**********************************************************************************************************
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	// SysTick的时钟选为外部时钟的8分频（HCLK/8）
	
	SysTick_each_us_CNT = SystemCoreClock / 8 / 1000000;	// 得到1us的计数次数

	SysTick_each_ms_CNT = SysTick_each_us_CNT * 1000;		// 得到1ms的计数次数

}


// 延时delay_us_Num微秒	
// 参数delay_us_Num的值应 < 1,864,135(十进制)
//*********************************************
u8 delay_us(u32 delay_us_Num)
{		
	u8  NOP_CNT = 4 ;
	
	u32 T_SysTick_CTR ;
	
	
	// 如果没有此判断，当参数为0时，会陷入死循环
	//********************************************
	if( delay_us_Num == 0 )		// 参数不允许为0
	{ return 0 ; }				// 跳出函数
	
	
	// 当参数是1us时，不使用SysTick定时器，直接使用几个NOP实现1us延时
	//****************************************************************
	if( delay_us_Num == 1 )
	{
		while( --NOP_CNT )		// NOP_CNT = 4 ;
		{
			__NOP();			// NOP：一个指令周期的空操作
		}

		return 0 ;				// 跳出函数
	}
	
	
	// SysTick定时器真正计时前，程序多耗时1us左右，在此负补偿SysTick计数器
	//*****************************************************************
	if( delay_us_Num>1 && delay_us_Num<1000 )
	{ delay_us_Num -- ; }
	
	
	// SysTick->LOAD：SysTick重装载寄存器(SysTick->LOAD为24位计数器)
	// 当计数器递减到0时（或强制清0时），将SysTick->LOAD中的值重新载入计数器
	//**********************************************************************************************************
	SysTick->LOAD = (u32)SysTick_each_us_CNT * delay_us_Num ;			// 将此次函数的计数次数写入重装载寄存器中
	
	
	// SysTick->VAL：SysTick的递减计数器
	// 向SysTick->VAL中写入数据，其就会被清0。
	// 当其递减到0时，COUNTFLAG位置1。
	//**********************************************************************************************************
	SysTick->VAL = 0x00; 						// 将SysTick->VAL清0，从而使得SysTick->LOAD中的值装入SysTick->VAL
		

	// SysTick->CTRL的最低位为SysTick定时器的使能位：1使能 0失能
	//*****************************************************************************************
	SysTick->CTRL |= (u32)0x01 ;				// 使能SysTick定时器，计数器开始递减

	
	// 一直等待计数器递减至0
	//**********************************************************************************************************************
	do{
		T_SysTick_CTR = SysTick->CTRL ;			// 将SysTick->CTRL中的值缓存到T_SysTick_CTR变量中
		
	}while( (T_SysTick_CTR & 0x01) && !(T_SysTick_CTR & (1<<16) ) );	// 当SysTick->CTRL的最低位为1，且第16位为0时，继续循环
	
	
	SysTick->CTRL &= ~ ( (u32)0x01 ) ;			// 失能SysTick定时器

	SysTick->VAL = 0X00;      					// 清0计数器
	
	return 0 ;	// 跳出函数
}



// 延时delay_ms_Num毫秒
// 参数delay_ms_Num的值应 < 1,864(十进制)
//****************************************
u8 delay_ms(u16 delay_ms_Num)
{	 		  	  
	u32 T_SysTick_CTR ;
	
	// 如果没有此判断，当参数为0时，会陷入死循环
	//********************************************
	if( delay_ms_Num == 0 )		// 参数不允许为0
	{ return 0 ; }				// 跳出函数

	// SysTick->LOAD：SysTick重装载寄存器(SysTick->LOAD为24位计数器)
	// 当计数器递减到0时（或强制清0时），将SysTick->LOAD中的值重新载入计数器
	//**********************************************************************************************************
	SysTick->LOAD = (u32)SysTick_each_ms_CNT * delay_ms_Num ;			// 将此次函数的计数次数写入重装载寄存器中
	
	
	// SysTick->VAL：SysTick的递减计数器
	// 向SysTick->VAL中写入数据，其就会被清0。
	// 当其递减到0时，COUNTFLAG位置1。
	//**********************************************************************************************************
	SysTick->VAL = 0x00; 						// 将SysTick->VAL清0，从而使得SysTick->LOAD中的值装入SysTick->VAL
	
	
	// SysTick->CTRL的最低位为SysTick定时器的使能位：1使能 0失能
	//*****************************************************************************************
	SysTick->CTRL |= (u32)0x01 ;				// 使能SysTick定时器，计数器开始递减

		
	// 一直等待计数器递减至0
	//**********************************************************************************************************************
	do{
		T_SysTick_CTR = SysTick->CTRL ;			// 将SysTick->CTRL中的值缓存到T_SysTick_CTR变量中
		
	}while( (T_SysTick_CTR & 0x01) && !(T_SysTick_CTR & (1<<16) ) );	// 当SysTick->CTRL的最低位为1，且第16位为0时，继续循环
	
	
	SysTick->CTRL &= ~ ( (u32)0x01 ) ;			// 失能SysTick定时器
	
	SysTick->VAL = 0X00;      					// 清空计数器
	
	return 0 ;	// 跳出函数
}

#ifndef __DELAY_H
#define __DELAY_H

#include "stm32f10x.h"


// 注：调用延时函数之前，必须先调用delay_Init()将SysTick初始化
//**************************************************************


// 将SysTick定时器的时钟设为：9M=72M/8（HCLK的8分频，HCLK默认为72M）
//**************************************************************
void delay_Init(void) ;				// 初始化SysTick定时器


//**************************************************************
// SysTick时钟：9M（计数9次=1us），计数器最大值：2^24-1=16777215
// SysTick定时器延时时长应 <= 1,864,135 us
//**************************************************************

// 参数delay_us_Num的值应 < 1,864,135(十进制)
//**************************************************************
u8 delay_us(u32 delay_us_Num) ;	// 延时delay_us_Num微秒

// 参数delay_ms_Num的值应 < 1,864(十进制)
//**************************************************************
u8 delay_ms(u16 delay_ms_Num) ;	// 延时delay_ms_Num毫秒




#endif	/* __DELAY_H */

#include "MotorDrive.h"
#include	"PID.h"

//驱动器使能
void MotEN_Init_JX(void)
{	
	GPIO_InitTypeDef  GPIO_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA, ENABLE);	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);//开启重映射时钟
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable , ENABLE);//开启重映射
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);				
	GPIO_ResetBits(GPIOC,GPIO_Pin_0);	
		
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;	
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_ResetBits(GPIOA,GPIO_Pin_15);	
}

// TIM2_PWM输出初始化 
// TIM2_CH1 = PA0
// TIM2_CH2 = PA1
// TIM2_CH3 = PA2
// TIM2_CH4 = PA3
void TIM2_PWM_Init_JX(void)
{  
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;	

	RCC_APB1PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
			
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);	
	
	TIM_TimeBaseStructure.TIM_Period = TIM2_Reload_Num; 
	TIM_TimeBaseStructure.TIM_Prescaler =TIM2_Frequency_Divide;
	TIM_TimeBaseStructure.TIM_ClockDivision = 0; 	
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure); 

	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; 
 	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; 
//	TIM_OCInitStructure.TIM_Pulse = 0;								// 占空比配置CCR
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; 	
	
	TIM_OC1Init(TIM2, &TIM_OCInitStructure);
	TIM_OC2Init(TIM2, &TIM_OCInitStructure);	
	TIM_OC3Init(TIM2, &TIM_OCInitStructure);	
	TIM_OC4Init(TIM2, &TIM_OCInitStructure);
	
//	TIM_ARRPreloadConfig(TIM2,ENABLE);								// 使能TIM2的自动预重装载寄存器，使能影子寄存器 
	
	TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Enable);  			// 使能TIM2在OC1上的预装载寄存器
	TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Enable);				
	TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Enable);				
	TIM_OC4PreloadConfig(TIM2, TIM_OCPreload_Enable);				
	
	TIM_Cmd(TIM2, ENABLE);  	
	
}
//-----------------------------------------------------------------------------------------------------------------

// TIM4_PWM输出初始化 
// TIM4_CH1 = PB6
// TIM4_CH2 = PB7
// TIM4_CH3 = PB8
// TIM4_CH4 = PB9
//-----------------------------------------------------------------------------------------------------------------
void TIM4_PWM_Init_JX(void)
{  
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;	

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);	

	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_10MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);							

	TIM_TimeBaseStructure.TIM_Period = TIM4_Reload_Num;
	TIM_TimeBaseStructure.TIM_Prescaler =TIM4_Frequency_Divide;
	TIM_TimeBaseStructure.TIM_ClockDivision = 0; 	
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); 	
	
	//初始化TIM4_CH1-4的PWM
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; 	
 	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; 
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; 
	
	TIM_OC1Init(TIM4, &TIM_OCInitStructure);  						
	TIM_OC2Init(TIM4, &TIM_OCInitStructure);
	TIM_OC3Init(TIM4, &TIM_OCInitStructure);
	TIM_OC4Init(TIM4, &TIM_OCInitStructure);
	
	TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);  
	TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable);	
	TIM_OC3PreloadConfig(TIM4, TIM_OCPreload_Enable);
	TIM_OC4PreloadConfig(TIM4, TIM_OCPreload_Enable);	
 
	TIM_Cmd(TIM4, ENABLE);	
}
//-----------------------------------------------------------------------------------------------------------------

void Car_Init(void)
{	
	MotEN_Init_JX();
	TIM2_PWM_Init_JX();
	TIM4_PWM_Init_JX();
	
	//驱动器置1使能
	GPIO_SetBits(GPIOA,GPIO_Pin_15);	
	GPIO_SetBits(GPIOC,GPIO_Pin_0);
}
void MotA(int val)
{
	if(val>200)
	{
		TIM2->CCR1=val;	TIM2->CCR2=0;		
	}
	else if(val<-200)
	{
		val=-val;
		TIM2->CCR1=0;		TIM2->CCR2=val;  //50%的启动值
	}
	else
	{
		TIM2->CCR1=0;		TIM2->CCR2=0;
	}
}

void MotB(int val)
{
	if(val>200)
	{
		TIM2->CCR3=val;	TIM2->CCR4=0;
	}
	else if(val<-200)
	{
		val=-val;
		
		TIM2->CCR3=0;		TIM2->CCR4=val; 
	}
	else
	{
		TIM2->CCR3=0;		TIM2->CCR4=0;
	}
}

void MotC(int val)
{
	if(val>200)
	{
		TIM4->CCR1=0;		TIM4->CCR2=val; 
	}
	else if(val<-200)
	{
		val=-val;
		TIM4->CCR1=val;	TIM4->CCR2=0;
	}
	else
	{
		TIM4->CCR1=0;		TIM4->CCR2=0;
	}
}

void MotD(int val)
{
	if(val>200)
	{
		TIM4->CCR3=0;		TIM4->CCR4=val; 
	}
	else if(val<-200)
	{
		val=-val;
		TIM4->CCR3=val;	TIM4->CCR4=0;		
	}
	else
	{
		TIM4->CCR3=0;		TIM4->CCR4=0;
	}
}

void Car_forward(int value)
{
	Mot_speedset(value,value,value,value);	
}
void Car_backward(int value)
{
	Mot_speedset(-value,-value,-value,-value);
}

void Car_left(int value)
{
	Mot_speedset(-value,value,value,-value);
}
void Car_right(int value)
{
	Mot_speedset(value,-value,-value,value);
}

void Car_turnleft(int value)
{
	Mot_speedset(value,value,-value,-value);
}
void Car_turnright(int value)
{
	Mot_speedset(-value,-value,value,value);
}

void Car_leftup(int value)
{
	Mot_speedset(0,value,value,0);
}
void Car_rightup(int value)
{
	Mot_speedset(value,0,0,value);
}

void Car_leftdown(int value)
{
	Mot_speedset(-value,0,0,-value);
}
void Car_rightdown(int value)
{
	Mot_speedset(0,-value,-value,0);
}

void Car_stop(int value)
{
	Mot_speedset(0,0,0,0);
}

/*使用速度 mm/s 作为目标值*/

//空载时转速300RMP，即5转每秒，减速比20，则减速前速度是100转每秒，PWM设置最大值是100,720分频，1ms周期；
//带负载转速是240RMP,即4转每秒，减速比20，则减速前速度是80转每秒；
//电机周长是308mm，减速比是20，则减速前是15mm每转，空载转速是1.5m/s,带负载速度是1200mm/s=1.2m/s；
//void Mot_speedset(int Speed1, int Speed2,int Speed3, int Speed4)//转/s
//{
//	int SPD1=0;
//	int SPD2=0;
//	int SPD3=0;
//	int SPD4=0;
速度是每秒n转，车轮周长乘以1/20=电机本身每转多少毫米，乘以n转每秒，就是每秒多少毫米=速度
//	SPD1=(s32)Speed1*(MotorWheelPerimeter/MotorRedRatio);//需要调用#include "encoder.h"
//	SPD2=(s32)Speed2*(MotorWheelPerimeter/MotorRedRatio); 
//	SPD3=(s32)Speed3*(MotorWheelPerimeter/MotorRedRatio);
//	SPD4=(s32)Speed4*(MotorWheelPerimeter/MotorRedRatio);
//	
//	PIDSpeed_SetGoal_A(SPD1);
//	PIDSpeed_SetGoal_B(SPD2);
//	PIDSpeed_SetGoal_C(SPD3);
//	PIDSpeed_SetGoal_D(SPD4);		
//}

/*使用速度 转/s 作为目标值*/
void Mot_speedset(int Speed1, int Speed2,int Speed3, int Speed4)//转/s
{
	PIDSpeed_SetGoal_A(Speed1);
	PIDSpeed_SetGoal_B(Speed2);
	PIDSpeed_SetGoal_C(Speed3);
	PIDSpeed_SetGoal_D(Speed4);		
}

#ifndef __MOTORDRIVE_H
#define __MOTORDRIVE_H

#include "stm32f10x.h"

//--------------------------------
// 分频系数：720（分频值+1）
// 计数频率：100kHz
// 计数周期：10us
// 重装载值：99
// 溢出周期：1ms
// 溢出频率：1kHz
//--------------------------------------------------------------
#define	TIM2_Frequency_Divide	(72-1)		// TIM2时钟预分频值
#define	TIM2_Reload_Num			(1000-1)		// 自动重装载寄存器的值

#define	TIM4_Frequency_Divide	(72-1)		// TIM1时钟预分频值
#define	TIM4_Reload_Num			(1000-1)		// 自动重装载寄存器的值


//--------------------------------------------------------------

void MotEN_Init_JX(void);	
void TIM2_PWM_Init_JX(void);
void TIM4_PWM_Init_JX(void);

void Car_Init(void);
void MotA(int val);
void MotB(int val);
void MotC(int val);
void MotD(int val);

void Car_forward(int value);
void Car_backward(int value);
void Car_left(int value);
void Car_right(int value);		
void Car_turnleft(int value);	
void Car_turnright(int value);	

void Car_leftup(int value);	
void Car_rightup(int value);	
void Car_leftdown(int value);
void Car_rightdown(int value);	
void Car_stop(int value);
	
void Mot_speedset(int Speed1, int Speed2,int Speed3, int Speed4);
	
//----------------------------------------------------------------------------

#endif /* __PWM_H */

#include "led.h"


void LED_Init_JX(void)
{	
	GPIO_InitTypeDef  GPIO_InitStructure;	

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);	
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	GPIO_ResetBits(GPIOC,GPIO_Pin_3);		
}

#ifndef __LED_H
#define __LED_H

#include "stm32f10x.h"


#define LED	PC_out(3)	

void LED_Init_JX(void);	


#endif

#include "timer.h"
#include	"PID.h"

void TIM3_Time_Init(void)
{
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
	
	TIM_TimeBaseStructure.TIM_Period = TIM3_Reload_Num ; 	
	TIM_TimeBaseStructure.TIM_Prescaler = TIM3_Frequency_Divide;
	TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; 
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
 
	TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); 

	NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; 
	NVIC_InitStructure.NVIC_IRQChannelSubPriority =1; 
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; 
	NVIC_Init(&NVIC_InitStructure); 

	TIM_Cmd(TIM3, ENABLE);  
}


u8 F_pid_functiion=0;//PID计算，5ms

u8 F_pid_waveform=0;//上位机波形显示，100ms

u8 F_oled_usart3=0;//OLED显示和串口输出标志位，200ms

u8 F_mileage=0;//里程计算标志位，50ms

u16 C_stop=0;//小车失联计数位
u8  F_stop=0;//小车失联停止标志位，1s

void TIM3_IRQHandler(void)
{ 
 	if( TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET )
	{
				
		static u16 C_pid_function=0;//5ms
		static u16 C_pid_waveform=0;//100ms
		
		static u16 C_oled_usart3=0;//200ms
		
		static u16 C_mileage=0;		//50ms		
		
		TIM_ClearITPendingBit(TIM3, TIM_IT_Update );  		
			
		C_pid_function++;
		
		if(C_pid_function >= 5)	
		{
			C_pid_function = 0;
			
			F_pid_functiion = 1;	//5ms 执行PID功能函数
		}
		
		C_pid_waveform++;	
		
		if(C_pid_waveform >= 100)	
		{
			C_pid_waveform = 0;
			
			F_pid_waveform = 1 ;	//100ms pid发送上位机波形，调试用
			
		}
		
		C_oled_usart3++;
		
		if(C_oled_usart3 >= 200)	//200MS
		{
			C_oled_usart3 = 0;
			
			F_oled_usart3 = 1 ;	//200ms执行OLED和串口输出显示
		}
		
		C_mileage++;
		
		if(C_mileage >= 50)	
		{
			C_mileage=0;
			
			F_mileage=1;	//50ms 里程表调用一次计数
		}
			
		C_stop ++;	
		
		if(C_stop >= 1000)	
		{
			C_stop = 0;
			
			F_stop = 1;			// 1s小车接收不到信号停车
		}
	}
}
//------------------------------------------------------------------------------------

#ifndef	__TIMER_H
#define	__TIMER_H

#include "stm32f10x.h"

//--------------------------------
// 分频系数：72（分频值+1）
// 计数频率：1MHz
// 计数周期：1us
// 重装载值：4999
// 溢出周期：5ms
//--------------------------------------------------------------
#define	TIM3_Frequency_Divide	72-1	
#define	TIM3_Reload_Num			1000-1
//--------------------------------------------------------------


void TIM3_Time_Init(void) ;


#endif	/* __TIMER_H */

#include "usart.h"

static void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;
    
  /* 配置USART为中断源 */
  NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
  /* 抢断优先级*/
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  /* 子优先级 */
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  /* 使能中断 */
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  /* 初始化配置NVIC */
  NVIC_Init(&NVIC_InitStructure);
}

void USART1_Config(void)//串口1通讯
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;

	// 打开串口GPIO的时钟
	DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
	
	// 打开串口外设的时钟
	DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);

	// 将USART Tx的GPIO配置为推挽复用模式
	GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);

  // 将USART Rx的GPIO配置为浮空输入模式
	GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
	
	// 配置串口的工作参数
	// 配置波特率
	USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
	// 配置 针数据字长
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	// 配置停止位
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	// 配置校验位
	USART_InitStructure.USART_Parity = USART_Parity_No ;
	// 配置硬件流控制
	USART_InitStructure.USART_HardwareFlowControl = 
	USART_HardwareFlowControl_None;
	// 配置工作模式，收发一起
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	// 完成串口的初始化配置
	USART_Init(DEBUG_USARTx, &USART_InitStructure);
	
	// 串口中断优先级配置
	NVIC_Configuration();
	
	// 使能串口接收中断
	USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);	
	
	// 使能串口
	USART_Cmd(DEBUG_USARTx, ENABLE);	    
}

/*****************  发送一个字节 **********************/
void Usart1_SendByte( USART_TypeDef * pUSARTx, uint8_t ch)
{
	/* 发送一个字节数据到USART */
	USART_SendData(pUSARTx,ch);
		
	/* 等待发送数据寄存器为空 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}

/****************** 发送8位的数组 ************************/
void Usart1_SendArray( USART_TypeDef * pUSARTx, uint8_t *array, uint16_t num)
{
  uint8_t i;
	
	for(i=0; i<num; i++)
  {
	    /* 发送一个字节数据到USART */
	    Usart1_SendByte(pUSARTx,array[i]);	
  
  }
	/* 等待发送完成 */
	while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET);
}

/*****************  发送字符串 **********************/
void Usart1_SendString( USART_TypeDef * pUSARTx, char *str)
{
	unsigned int k=0;
  do 
  {
      Usart1_SendByte( pUSARTx, *(str + k) );
      k++;
  } while(*(str + k)!='\0');
  
  /* 等待发送完成 */
  while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
  {}
}

/*****************  发送一个16位数 **********************/
void Usart1_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
	uint8_t temp_h, temp_l;
	
	/* 取出高八位 */
	temp_h = (ch&0XFF00)>>8;
	/* 取出低八位 */
	temp_l = ch&0XFF;
	
	/* 发送高八位 */
	USART_SendData(pUSARTx,temp_h);	
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
	
	/* 发送低八位 */
	USART_SendData(pUSARTx,temp_l);	
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}

/重定向c库函数printf到串口，重定向后可使用printf函数
//int fputc(int ch, FILE *f)
//{
//		/* 发送一个字节数据到串口 */
//		USART_SendData(DEBUG_USARTx, (uint8_t) ch);
//		
//		/* 等待发送完毕 */
//		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);		
//	
//		return (ch);
//}

/重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
//int fgetc(FILE *f)
//{
//		/* 等待串口输入数据 */
//		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);

//		return (int)USART_ReceiveData(DEBUG_USARTx);
//}

// 串口中断接收上位机PID参数
void DEBUG_USART_IRQHandler(void)
{
	if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)
	{	
    u8 data=USART_ReceiveData(DEBUG_USARTx);//获取数据
    USART_SendData(DEBUG_USARTx, data);
  }
  USART_ClearITPendingBit(DEBUG_USARTx, USART_IT_RXNE);
}

#ifndef __USART_H
#define	__USART_H


#include "stm32f10x.h"
#include <stdio.h>

// 串口1-USART1
#define  DEBUG_USARTx                   USART1
#define  DEBUG_USART_CLK                RCC_APB2Periph_USART1
#define  DEBUG_USART_APBxClkCmd         RCC_APB2PeriphClockCmd
#define  DEBUG_USART_BAUDRATE           115200

// USART GPIO 引脚宏定义
#define  DEBUG_USART_GPIO_CLK           (RCC_APB2Periph_GPIOA)
#define  DEBUG_USART_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
    
#define  DEBUG_USART_TX_GPIO_PORT       GPIOA   
#define  DEBUG_USART_TX_GPIO_PIN        GPIO_Pin_9
#define  DEBUG_USART_RX_GPIO_PORT       GPIOA
#define  DEBUG_USART_RX_GPIO_PIN        GPIO_Pin_10

#define  DEBUG_USART_IRQ                USART1_IRQn
#define  DEBUG_USART_IRQHandler         USART1_IRQHandler


void USART1_Config(void);
void Usart1_SendByte( USART_TypeDef * pUSARTx, uint8_t ch);
void Usart1_SendString( USART_TypeDef * pUSARTx, char *str);
void Usart1_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch);
void Usart1_SendArray( USART_TypeDef * pUSARTx, uint8_t *array, uint16_t num);


#endif /* __USART_H */

#include "key.h"


void KEY_Init_JX(void)
{	
	GPIO_InitTypeDef  GPIO_InitStructure;	

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14|GPIO_Pin_15;				
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; 
	
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}

#ifndef __KEY_H
#define __KEY_H


#include "stm32f10x.h"
#include "bit_band.h"

#define 	KEY1		PC_in(15)	
#define 	KEY2		PC_in(14)	

void KEY_Init_JX(void) ;


#endif	/* __KEY_H */

//****************************************************************************************************
//	在"stm32f10x.h"中：
//
//	#define FLASH_BASE            ((uint32_t)0x08000000) 	// FLASH基地址
//	#define SRAM_BASE             ((uint32_t)0x20000000) 	// SRAM基地址（位带区）
//	#define PERIPH_BASE           ((uint32_t)0x40000000) 	// 外设(寄存器)基地址（位带区）
//
//	#define SRAM_BB_BASE          ((uint32_t)0x22000000) 	// SRAM的别名区的基地址
//	#define PERIPH_BB_BASE        ((uint32_t)0x42000000) 	// 外设的别名区的基地址
//
//	#define FSMC_R_BASE           ((uint32_t)0xA0000000) 	// FSMC寄存器基地址
//
//
//	bit_word_addr = bit_band_base + (byte_offset * 32) + (bit_number * 4)
//
//	bit_word_addr：别名区中，对应的'字'的地址，它和位带区的某个位是映射关系
//	bit_band_base：别名区的起始地址，SRAM_BB_BASE 或 PERIPH_BB_BASE。
//	byte_offset：包含目标位的字节所在位带区的地址
//	bit_number：目标在字节中的序号（由低到高）
//
//****************************************************************************************************
#ifndef __BIT_BAND_H
#define __BIT_BAND_H

#include "stm32f10x.h"	

// 注：参数：Pin_x不应该超过15
//****************************************************************************************************
#define	PA_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X1080C * 32) + (Pin_x * 4)))
#define	PB_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X10C0C * 32) + (Pin_x * 4)))
#define	PC_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X1100C * 32) + (Pin_x * 4)))
#define	PD_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X1140C * 32) + (Pin_x * 4)))
#define	PE_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X1180C * 32) + (Pin_x * 4)))
#define	PF_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X11C0C * 32) + (Pin_x * 4)))
#define	PG_out(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X1200C * 32) + (Pin_x * 4)))


#define	PA_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X10808 * 32) + (Pin_x * 4)))
#define	PB_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X10C08 * 32) + (Pin_x * 4)))
#define	PC_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X11008 * 32) + (Pin_x * 4)))
#define	PD_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X11408 * 32) + (Pin_x * 4)))
#define	PE_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X11808 * 32) + (Pin_x * 4)))
#define	PF_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X11C08 * 32) + (Pin_x * 4)))
#define	PG_in(Pin_x)		* ((volatile unsigned long *)(0x42000000 + (0X12008 * 32) + (Pin_x * 4)))
//****************************************************************************************************

#endif	/* __BIT_BAND_H */

#include "rf2G4.h"
#include "MotorDrive.h"
#include "waveform.h"


// 2G4通信地址
//------------------------------------------------------------------------------------------		
const u8 RF2G4_ADDR_TX[5] = {0x34,0x43,0x10,0x10,0x01};	
const u8 RF2G4_ADDR_RX[5] = {0x34,0x43,0x10,0x10,0x01};		// 或者可用ASCII：jixin

//------------------------------------------------------------------------------------------

u8 RF2G4_Send_Data[14] = { 0 };		// 2.4G发射数据缓存数组
			 
u8 RF2G4_Receive_Data[14] = { 0 };	// 2.4G接收数据缓存数组


// 	无线发射(RF2G4_Send_Data[14])：共输出14个数据，分别为
//--------------------------------------------------------------
// 	0  == KEY1	
//	1  == KEY2	
//	2  == KEY3			
//	3  == KEY4			
//	4  == 0				
//	5  == 0			
//	6  == 0			
//	7  == 0			
//	8  == 0			
//	9  == 0				
//ADC数据：
//	10 == 左转，右转
//	11 == 油门

//  12 == 左右运行		
//  13 == 前后运行
//--------------------------------------------------------------


// RF2G4初始化
//------------------------------------------------------------------------------------------
void RF2G4_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	 
  
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;	//CSN片选引脚
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 
 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
 	GPIO_Init(GPIOC, &GPIO_InitStructure);
  
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;	//CE模式引脚，未使用
 	GPIO_Init(GPIOB, &GPIO_InitStructure);	
  
	GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_1;   //中断引脚未使用
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; 	
	GPIO_Init(GPIOB, &GPIO_InitStructure);
						 

	SPI2_Init();    		// 初始化SPI	 
 
	RF2G4_CE=0; 			// 使能SI24R1
	
	RF2G4_CSN=1;			// SPI片选取消  
	
}
//------------------------------------------------------------------------------------------	 	 


// 2G4的SPI读写
//==========================================================================================

// SPI对SI24R1寄存器的写操作
// Reg 			= 寄存器
// Write_Value 	= 写入的值
// return		= 状态值
//--------------------------------------------------------
u8 RF2G4_Write_Reg(u8 Reg,u8 Write_Value)
{
	u8 V_Reg;	
	
   	RF2G4_CSN = 0;                 		// 片选使能
	
  	V_Reg =SPI2_ReadWriteByte(Reg);		// 发送寄存器号 ，返回状态值
	
  	SPI2_ReadWriteByte(Write_Value);	// 写入寄存器的值
	
  	RF2G4_CSN = 1;                 		// 禁止SPI传输	 
	
  	return(V_Reg);       				// 返回状态值
}
//--------------------------------------------------------

// 向寄存器中写入指定长度的数据
// Reg		= 寄存器
// P_Data 	= 数据指针
// N_Data 	= 数据个数
// return 	= 此次读到的状态寄存器值
//--------------------------------------------------------
u8 RF2G4_Write_Cont(u8 Reg, u8* P_Data, u8 N_Data)//P_Data是地址指针变量
{
	u8 V_Reg = 0;
	u8 C_Write = 0;
	
 	RF2G4_CSN = 0;          	
	
  	V_Reg = SPI2_ReadWriteByte(Reg);	// 选定寄存器,并读取状态值
	
  	for(; C_Write<N_Data; C_Write++)
	{
		SPI2_ReadWriteByte(*P_Data++); 	// 写入数据，*P_Data++是数据
	}
		 
  	RF2G4_CSN = 1;       			
	
  	return V_Reg;          				// 返回读到的状态值
}
//--------------------------------------------------------



// SPI对SI24R1寄存器的读操作
// Reg 		= 寄存器
// return 	= 写入的值
//--------------------------------------------------------
u8 RF2G4_Read_Reg(u8 Reg)
{
	u8 V_Reg;	    
	
 	RF2G4_CSN = 0;          	
	
  	SPI2_ReadWriteByte(Reg);   			// 发送寄存器号（包含命令+寄存器地址）
	
  	V_Reg=SPI2_ReadWriteByte(0xFF);		// 读取寄存器内容
	
  	RF2G4_CSN = 1;          	
	
  	return(V_Reg);           			// 返回寄存器的值
}	
//--------------------------------------------------------



// 从寄存器中读出指定长度的数据
// Reg = 寄存器(位置)
// P_Data = 数据指针
// N_Data = 数据个数
// return = 此次读到的状态寄存器值
//----------------------------------------------------------------------------
u8 RF2G4_Read_Cont(u8 Reg, u8* P_Data, u8 N_Data)
{
	u8 V_Reg;
	u8 C_Read = 0;	
	
  	RF2G4_CSN = 0;           			// 使能SPI传输
	
  	V_Reg=SPI2_ReadWriteByte(Reg);		// 发送寄存器值(位置),并读取状态值
	
 	for(; C_Read<N_Data;C_Read++)
	
	P_Data[C_Read] = SPI2_ReadWriteByte(0xFF);	// 读出数据

  	RF2G4_CSN = 1;       				// 关闭SPI传输
	
  	return V_Reg;        				// 返回读到的状态值
}
//----------------------------------------------------------------------------
//==========================================================================================			   


// 检测SI24R1是否正常
// return = 0:成功,	1:失败
//---------------------------------------------------------------------------------------------------
u8 RF2G4_Check(void)
{
	u8 Array_Test[5]={0X66,0X66,0X66,0X66,0X66};
	u8 C_Test = 0;
	
	SPI2_SetSpeed(SPI_BaudRatePrescaler_4); 			// SPI速度为9Mhz（SI24R1的最大SPI时钟为10Mhz）
	
	RF2G4_Write_Cont(W_REGISTER+TX_ADDR,Array_Test,5);	// 写入5个字节的地址.	
	
	RF2G4_Read_Cont(TX_ADDR,Array_Test,5); 				// 读出写入的地址  
	
	for(; C_Test<5; C_Test++)
	if(Array_Test[C_Test]!=0X66)
		break;
	
	if(C_Test!=5)return 1;		// SI24R1错误	
	
	return 0;		 			// SI24R1正确
}
//---------------------------------------------------------------------------------------------------



// 初始化SI24R1为接收模式
//-----------------------------------------------------------------------------------------------------------
void RF2G4_RX_Mode(void)
{
	RF2G4_CE = 0;	  //待机模式，无数据传输
  	RF2G4_Write_Cont(W_REGISTER+RX_ADDR_P0, (u8*)RF2G4_ADDR_RX, RX_ADR_WIDTH);	// 设置RX节点地址，(u8*)RF2G4_ADDR_RX，数组转化为指针变量
	  
  	RF2G4_Write_Reg(W_REGISTER+EN_AA,0x01);    		// 使能通道0的自动应答
  	RF2G4_Write_Reg(W_REGISTER+EN_RXADDR,0x01);		// 使能通道0的接收地址
  	RF2G4_Write_Reg(W_REGISTER+RF_CH,40);	     	// 设置RF通信频率2440MHz
  	RF2G4_Write_Reg(W_REGISTER+RX_PW_P0,14);		// 设置通道0的有效数据宽度（14位）
  	RF2G4_Write_Reg(W_REGISTER+RF_SETUP,0x0F);		// 设置:发射功率0dBm，电流消耗11.3mA、射频数据率2Mbps
  	RF2G4_Write_Reg(W_REGISTER+CONFIG, 0x0F);		// 配置参数;接收模式、开机模式、CRC=2Byte、开启CRC、。。。
  RF2G4_CE = 1; 	// CE为高,进入接收模式 
}					
//-----------------------------------------------------------------------------------------------------------

// 初始化SI24R1为发射模式
//-------------------------------------------------------------------------------------------------------------------
void RF2G4_TX_Mode(void)
{														 
	RF2G4_CE = 0;	//待机模式
//比起接收模式多的选项1	
  	RF2G4_Write_Cont(W_REGISTER+TX_ADDR,(u8*)RF2G4_ADDR_TX,TX_ADR_WIDTH);		// 设置TX节点地址
	
  	RF2G4_Write_Cont(W_REGISTER+RX_ADDR_P0,(u8*)RF2G4_ADDR_RX,RX_ADR_WIDTH); 	// 设置RX节点地址（ACK）	  

  	RF2G4_Write_Reg(W_REGISTER+EN_AA,0x01);     	// 使能通道0的自动应答,即设置为增强模式    
  	RF2G4_Write_Reg(W_REGISTER+EN_RXADDR,0x01); 	// 使能通道0的接收地址
//比起接收模式多的选项 2 
  	RF2G4_Write_Reg(W_REGISTER+SETUP_RETR,0x1A);	// 设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次
	
  	RF2G4_Write_Reg(W_REGISTER+RF_CH,40);       	// 设置RF通信频率
  	RF2G4_Write_Reg(W_REGISTER+RF_SETUP,0x0F);  	// 设置:发射功率0dBm、射频数据率2Mbps  
  	RF2G4_Write_Reg(W_REGISTER+CONFIG,0x0E);    	// 配置参数;接收模式、开机模式、CRC=2Byte、开启CRC、。。。
	RF2G4_CE = 1;	//进入发送模式
}
//-------------------------------------------------------------------------------------------------------------------



// SI24R1发送一帧数据
// P_Data	= 待发送数据首地址
// N_Data	= 待发送数据的个数
// return	= 发送完成状况
//-------------------------------------------------------------------------------------------
u8 RF2G4_Tx_Packet(u8* P_Data,u8 N_Data)
{
	u8 V_Reg;
	
 	SPI2_SetSpeed(SPI_BaudRatePrescaler_4);	// SPI速度为9Mhz（24L01的最大SPI时钟为10Mhz）   
	
	RF2G4_CE = 0;//待机模式，无数据传输，其实可以让其一直为1就行，不需要等0，发送到缓存器后再发送出去。
	
  RF2G4_Write_Cont(W_TX_PAYLOAD,P_Data,N_Data);	// 将要发送的数据写入发送缓存器,P_Data上面已经定义是个指针地址，这直接使用这个变量就代表指针
	
 	RF2G4_CE = 1;			// 进入发送模式，CE为高,>10us发送完成	   
	
	while(RF2G4_IRQ != 0);	// 等待发送完成置1
	
	V_Reg = RF2G4_Read_Reg(STATUS);  // 读取状态寄存器的值	   
	
	RF2G4_Write_Reg(W_REGISTER+STATUS,V_Reg); 	// 清除TX_DS/MAX_RT中断标志，写1清除中断
	
	
	if(V_Reg & TX_MAX)	// 判断是否达到最大重发次数
	{
		RF2G4_Write_Reg(FLUSH_TX,0xFF);	// 清除TX_FIFO 
		
		return TX_FAIL_MAX; 	// 返回发送失败（达到最大重发次数）
	}
	
	if(V_Reg & TX_OK)	
	{
		return TX_SUCCESS;		// 返回发送成功
	}

	return TX_FAIL;				// 返回发送失败
}
//-------------------------------------------------------------------------------------------


// SI24R1接收一帧数据
// P_Data	= 缓存接收数据的首地址
// N_Data	= 待缓存数据的个数
// return	= 数据接收情况
//-------------------------------------------------------------------------------------------
u8 RF2G4_Rx_Packet(u8* P_Data,u8 N_Data)
{
	u8 V_Reg;		    							   
	SPI2_SetSpeed(SPI_BaudRatePrescaler_4); 	// SPI速度为9Mhz（SI24R1的最大SPI时钟为10Mhz）   
	
	V_Reg=RF2G4_Read_Reg(STATUS);  				// 读取状态寄存器的值    	 
	
	RF2G4_Write_Reg(W_REGISTER+STATUS,V_Reg); 	// 清除RX_DS/MAX_RT中断标志
	
	if(V_Reg & RX_OK)		// 判断是否接收到数据
	{
		RF2G4_Read_Cont(R_RX_PAYLOAD,P_Data,N_Data);	// 读取数据
		
		RF2G4_Write_Reg(FLUSH_RX,0xFF);					// 清除RX_FIFO 
		
		return RX_SUCCESS; 	// 返回接收成功
	}	  
	
	return RX_FAIL;			// 返回接收失败
}


//-------------------2G4手柄控制小车---------------------------------------------------

extern char MODE;
extern u16 C_stop;
extern u8  F_stop;

void RF24L01_control(void)
{
	if(MODE==0)
	{
		
		if(RF2G4_Rx_Packet(RF2G4_Receive_Data,14)== RX_SUCCESS)	// 判断是否接收到数据	
		{			
			//测试接收的数据发送到到串口3
		 Usart3_SendArray(USART3, RF2G4_Receive_Data, 14);
			
			
			 F_stop = 0 ;	//停车标志位清零
			 C_stop = 0 ;	// 停车计数清零，重新计数
			
										
		// 根据接收到的指令执行相应动作						
		//-------------------------------------------------------------------------------------------------
			if(RF2G4_Receive_Data[10]<177&&RF2G4_Receive_Data[10]>77)
			{
					if( RF2G4_Receive_Data[13]>177)
						{
							if(RF2G4_Receive_Data[12]<177&&RF2G4_Receive_Data[12]>77)	Car_forward(RF2G4_Receive_Data[11]/2.55);
							else if(RF2G4_Receive_Data[12]>177)	Car_rightup(RF2G4_Receive_Data[11]/2.55);
							else if(RF2G4_Receive_Data[12]<77) Car_leftup(RF2G4_Receive_Data[11]/2.55);
							else Car_stop(0);
						}
					else if( RF2G4_Receive_Data[13]<77)
						{
							if(RF2G4_Receive_Data[12]<177&&RF2G4_Receive_Data[12]>77) Car_backward(RF2G4_Receive_Data[11]/2.55);
							else if(RF2G4_Receive_Data[12]>177) Car_rightdown(RF2G4_Receive_Data[11]/2.55);
							else if(RF2G4_Receive_Data[12]<77) Car_leftdown(RF2G4_Receive_Data[11]/2.55);
							else Car_stop(0);
						}		
					else if( RF2G4_Receive_Data[13]<177&&RF2G4_Receive_Data[13]>77)
						{
							if( RF2G4_Receive_Data[12]>177)	Car_right(RF2G4_Receive_Data[11]/2.55);						
							else if( RF2G4_Receive_Data[12]<77)	Car_left(RF2G4_Receive_Data[11]/2.55);		
							else Car_stop(0);	
						}	
			}
			else if( RF2G4_Receive_Data[10]>177)	Car_turnright(RF2G4_Receive_Data[11]/2.55);
		  else if( RF2G4_Receive_Data[10]<77)	Car_turnleft(RF2G4_Receive_Data[11]/2.55);							
			else Car_stop(0);
		}	
		if( F_stop == 1) Car_stop(0);	// 命令失效，小车熄火
	}
}

#ifndef __RF2G4_H
#define __RF2G4_H	


#include "stm32f10x.h"
#include "bit_band.h"
#include "spi.h"



//--------------------------------
// 2G4通信地址
//--------------------------------
extern const u8 RF2G4_ADDR_TX[5];

extern const u8 RF2G4_ADDR_RX[5];

//地址宽度
#define 	TX_ADR_WIDTH    5   		// 发射地址宽度（5字节）
#define 	RX_ADR_WIDTH    5   		// 接收地址宽度（5字节）
//--------------------------------

// 2.4G发射数据缓存数组
extern u8 RF2G4_Send_Data[14];

// 2.4G接收数据缓存数组
extern u8 RF2G4_Receive_Data[14];

//--------------------------------------
//---------------------------------------------------------------
//SI24R1连接
#define 	RF2G4_CE   		PB_out(0) 	// SI24R1选信号
#define 	RF2G4_CSN  		PC_out(2) 	// SPI片选信号	   
#define 	RF2G4_IRQ  		PB_in(1)  	// IRQ主机数据输入

//---------------------------------------------------------------		

//SI24R1寄存器操作命令
//-----------------------------------------------------------------------------------
#define 	R_REGISTER    		0x00  	// 读寄存器,低5位为寄存器地址
#define 	W_REGISTER   		  0x20  	// 写寄存器,低5位为寄存器地址
#define 	R_RX_PAYLOAD     	0x61  	// 读RX有效数据,1~32字节
#define 	W_TX_PAYLOAD     	0xA0  	// 写TX有效数据,1~32字节
#define 	FLUSH_TX        	0xE1  	// 清除TX FIFO寄存器.发射模式下用
#define 	FLUSH_RX        	0xE2  	// 清除RX FIFO寄存器.接收模式下用
#define 	NOP             	0xFF  	// 空操作,可以用来读状态寄存器	 
//-----------------------------------------------------------------------------------

//SPI(SI24R1)寄存器地址
//----------------------------------------------------------------------------------------------------------------------
#define 	CONFIG          	0x00  	// 配置寄存器地址;bit0:1接收模式,0发射模式;bit1:1上电,0掉电选择;bit2:CRC模式：0,8位模式;
										//bit3:1，CRC使能，bit4:中断MAX_RT(达到最大重发次数中断)使能;bit5:中断TX_DS使能;bit6:中断RX_DR使能										
#define 	EN_AA           	0x01  	// 使能自动应答功能  bit0~5,对应通道0~5
#define 	EN_RXADDR       	0x02  	// 接收数据通道允许,bit0~5,对应通道0~5
#define 	RF_CH           	0x05  	// 射频通道,bit6:0,工作通道频率设置;
#define 	RF_SETUP        	0x06  	// RF寄存器;bit3:传输速率(0:1Mbps,1:2Mbps);bit2:1,发射功率;bit0:低噪声放大器增益
#define 	RX_PW_P0        	0x11  	// 通道0接收数据宽度(1~32字节),设置为0则非法
#define 	RX_ADDR_P0      	0x0A  	// 数据通道0设置地址,最大长度5个字节,低字节在前

#define 	TX_ADDR         	0x10  	// 发送地址(低字节在前),ShockBurstTM模式下,RX_ADDR_P0与此地址相等
#define 	SETUP_RETR      	0x04  	// 建立自动重发;bit3:0,自动重发计数器;bit7:4,自动重发延时 250*x+86us
#define 	STATUS          	0x07  	// 状态寄存器;bit0:TX FIFO满标志;bit3:1,接收数据通道号(最大:6);bit4,达到最多次重发
										// bit5:数据发送完成中断;bit6:接收数据中断;
#define 	TX_MAX  			0x10  	// 达到最大发送次数中断
#define 	TX_OK   			0x20  	// TX发送完成中断
#define 	RX_OK   			0x40  	// 接收到数据中断

#define		TX_FAIL_MAX			2		// 发送失败
#define		TX_SUCCESS			0		// 发送成功
#define		TX_FAIL				1		// 发送失败
#define		RX_SUCCESS			0		// 接收成功
#define		RX_FAIL				1		// 接收失败


//未使用寄存器
#define 	SETUP_AW        	0x03  	// 设置地址宽度(所有数据通道):bit1,0:00,3字节;01,4字节;02,5字节;默认11是5个字节，所以程序中未进行设置
#define 	OBSERVE_TX      	0x08  	// 发送检测寄存器,bit7:4,数据包丢失计数器;bit3:0,重发计数器
#define 	RSSI              0x09  	// 载波检测寄存器,bit0,载波检测;
#define 	FIFO_STATUS 		0x17  	// FIFO状态寄存器;bit0,RX FIFO寄存器空标志;bit1,RX FIFO满标志;bit2,3,保留
										// bit4,TX FIFO空标志;bit5,TX FIFO满标志;bit6,1,循环发送上一数据包.0,不循环;
//----------------------------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------
void RF2G4_Init(void);						
u8 RF2G4_Write_Reg(u8 Reg,u8 Write_Value);	
u8 RF2G4_Write_Cont(u8 Reg, u8* P_Data, u8 N_Data);	
u8 RF2G4_Read_Reg(u8 Reg);						
u8 RF2G4_Read_Cont(u8 Reg, u8* P_Data, u8 N_Data);

u8 RF2G4_Check(void);	

void RF2G4_RX_Mode(void);	
void RF2G4_TX_Mode(void);	

u8 RF2G4_Tx_Packet(u8* P_Data,u8 N_Data);
u8 RF2G4_Rx_Packet(u8* P_Data,u8 N_Data);
//-------------------------------------------------------------------------------------

void RF24L01_control(void);

#endif	/* __RF2G4_H */

#include "beep.h"
#include "delay.h"

void BEEP_Init(void)
{
 
 GPIO_InitTypeDef  GPIO_InitStructure;
 	
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	
 
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;		
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 GPIO_Init(GPIOA, &GPIO_InitStructure);	 
 
 GPIO_ResetBits(GPIOA,GPIO_Pin_8);

}

void BEEP_Sound(void)
{
	BEEP=1;  
	delay_ms(100);	
	BEEP=0;
}

#ifndef __BEEP_H
#define __BEEP_H	 

#include "stm32f10x.h"
#include "bit_band.h"

#define BEEP PA_out(8)	   

void BEEP_Init(void);	
void BEEP_Sound(void);
		 				    
#endif