433MHz无线模块解码扫描&定时器输入捕获

_桑榆非晚

已于 2025-05-15 10:37:27 修改

阅读量7.9k

点赞数 43

文章标签：单片机嵌入式硬件

于 2024-04-16 14:45:34 首次发布

本文链接：https://blog.csdn.net/weixin_57586666/article/details/137824132

版权

记录一个小项目，两种方法解码433，包括24Bit数据帧结构和32Bit数据帧结构

1、433接收模块

本文用两种方法解析433Mhz模块的信号，分别是扫描和定时器输入捕获。解析信号首先要了解433信号的编码格式。以24Bit格式帧为例，包含同步码，20位地址码和4位数据码。

数据帧格式如下：同步码 + 20Bit地址码 + 4Bit按键码

可以看出，每组信息都是紧跟在一个同步码后面，所以需要找到这个同步信号，然后解析出后面的24位数据。而同步信号、数据“1”和数据“0”的高低电平持续时间不同，可以根据这一点进行区分。

下图左一是本文使用到的433接收模块，从右到左三个引脚分别是VCC，DATA，GND。再左边是天线。给433模块供电（3.3V），然后把DATA引脚与GND引脚接上示波器，查看数据波形。右图是两个433遥控器，棕色是24位编码格式，黑色是32位编码格式。

通过示波器查看接收模块收到的两个遥控器的数据，整理如下：

棕色遥控器：

上：同步信号 + 0000 0001 0000 0000 0111 + 0100

下：同步信号 + 0000 0001 0000 0000 0111 + 1000

锁：同步信号 + 0000 0001 0000 0000 0111 + 0001

方块：同步信号 + 0000 0001 0000 0000 0111 + 0010

四个按键前20位数据相同，为棕色遥控器的地址码，后面4位数据不同，为数据码，分别对应不同的按键。

高低电平持续时间：

同步信号：高电平 408us 低电平 12.4ms

数据“1”：高电平 1.2ms 低电平 410us

数据“0”：高电平 410us 低电平 1.2ms

黑色遥控器：

上：同步信号 + 1111 0111 1100 1100 1111 0000 0000 + 1000

下：同步信号 + 1111 0111 1100 1100 1111 0000 0000 + 0001

方块：同步信号 + 1111 0111 1100 1100 1111 0000 0000 + 0100

圆圈：同步信号 + 1111 0111 1100 1100 1111 0000 0000 + 0010

黑色遥控器的数据编码为32位，解析方法跟上面的基本一致。

高低电平持续时间：

同步信号：高电平 364us 低电平 8ms

数据“1”：高电平 1.084ms 低电平 362us

数据“0”：高电平 362us 低电平 1.084ms

现在已经整理出了两个遥控器的编码格式，以及每个按键对应的数据。接下来就要想办法把这些数据解析出来，MCU要能够检测到遥控器的哪一个按键被按下，才能去执行对应的功能。

2、扫描方式解析数据

编程思路：

把433接收模块DATA引脚连接在一个IO上，并把IO配置为浮空输入。再配置一个定时器，50us进入一次中断。

每50us检测一下IO的电平，如果是低电平，就开始计数，是高电平的话计算低电平持续的时间（计数值*50us），判断是否符合上面介绍的电平持续时间。如果符合其中一个同步信号，就开始准备接收数据，之后每个低电平过来，都拿它的持续时间跟数据“1”和数据“0”比较，并进行记录。这样就可以把数据解析出来。

源码：

//---------------------------------------------------------------------------------------------------------------------
//一些宏定义和变量

#define RF_DATA_PORT			GPIOA
#define RF_DATA_PIN			GPIO_Pin_8
#define RF_DATA_RCC_PORT	RCC_APB2Periph_GPIOA

//同步信号、数据'0'、数据'1'低电平持续时间范围
#define _24start_us_min		220		//低电平参考值（us）/定时器扫描周期（us）- 预留范围（us）	24Bit格式 同步信号 低电平持续时间参考值	12400us/50us == 248
#define _24start_us_max		260		//低电平参考值（us）/定时器扫描周期（us）+ 预留范围（us）
#define _24num0_us_min		23		//24Bit格式数据'0'低电平持续时间参考值 1200us/50us == 24
#define _24num0_us_max    	26
#define _24num1_us_min    	7		//24Bit格式数据'1'低电平持续时间参考值 410us/50us == 8
#define _24num1_us_max    	10

#define _32start_us_min    155		//32Bit格式 同步信号 低电平持续时间参考值	8000us/50us == 160
#define _32start_us_max    165
#define _32num0_us_min    16		//32Bit格式 数据'0' 低电平持续时间参考值 1084us/50us == 21
#define _32num0_us_max    26
#define _32num1_us_min    6			//32Bit格式 数据'1' 低电平持续时间参考值 360us/50us == 7
#define _32num1_us_max    10


#define RF_DATA  GPIO_ReadInputDataBit(RF_DATA_PORT,RF_DATA_PIN)//读取接口电平

/*
	变量说明：
		last_state		记录上一个电平，用来判断跳变沿  		例如：  last_state == 0   RF_DATA == 1  就表示上升沿
		ReadStep    	控制数据解析的进度   				ReadStep==0，接收同步信号 ；  ReadStep==1，接收24位（或32位）数据  ； ReadStep==2，数据接收完成，解析数据；
		DataFram    	数据帧格式  24位或者32位
		BitCount    	记录当前接收了多少位数据

		decode32_ok		32位格式数据解析成功
		decode24_ok		24位格式数据解析成功
		ReadLoop		读数据的次数							需要循环两次读两组数据
		CheckTime		校验计时								接收完第一组数据后，开始倒计时，如果100ms内没有接收到第二组数据，则解析失败，回到开始重新接收数据
		
		LowTime			低电平持续时间
		
		TempData[2];	存放临时数据
		rf_data32[4];	存放解析成功的32位格式数据，数组前几位存放地址值，最后一位存放数据值
		rf_data24[3];	存放解析成功的24位格式数据
		
*/
unsigned char last_state,ReadStep,DataFram,BitCount,decode32_ok,decode24_ok,ReadLoop;
unsigned int CheckTime;
unsigned int LowTime = 0;
unsigned int TempData[2] = {0};
unsigned char rf_data32[4] = {0};
unsigned char rf_data24[3] = {0};

//---------------------------------------------------------------------------------------------------------------------
//初始化

void RF433_Init(void)
{
	RF433_DATA_IO_Init();
	TIM3_Int_Init(49,71);//72分频，计数50， 即50us计时器      72MHZ经过分频编程1MHZ，1s内中断1M次，1us中断1次，50us终端50次
}

void RF433_DATA_IO_Init(void)
{
	GPIO_InitTypeDef  GPIO_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RF_DATA_RCC_PORT, ENABLE);	    //使用PA端口时钟
	GPIO_InitStructure.GPIO_Pin = RF_DATA_PIN;			   
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; 	 //浮空输入
	GPIO_Init(GPIOA, &GPIO_InitStructure);			    
}
void TIM3_Int_Init(u16 arr,u16 psc)
{
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能
	
	//定时器TIM3初始化
	TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值	
	TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值
	TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位
 
	TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); //使能指定的TIM3中断,允许更新中断

	//中断优先级NVIC设置
	NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级0级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;  //从优先级3级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
	NVIC_Init(&NVIC_InitStructure);  //初始化NVIC寄存器

	TIM_Cmd(TIM3, ENABLE);  //使能TIMx					 
}


//---------------------------------------------------------------------------------------------------------------------
//中断服务函数
void TIM3_IRQHandler(void)   //TIM3中断	50us中断
{
	static unsigned int TIM3_Count = 0;
	if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
	{
		TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx更新中断标志 
		RF433_ReadAWord();		//解析函数
	}	
}


//---------------------------------------------------------------------------------------------------------------------
//解析函数

void RF433_ReadAWord(void)
{
	if(RF_DATA==0)		//记录低电平时间，来判断数据是'1'还是'0'
	{
		LowTime++;
		if(last_state == 1)
		{
			last_state = 0;
		}
	}
	else if(RF_DATA==1)
	{
		if(last_state == 0)	//判断是否是上升沿
		{
			last_state = 1;

			
			//进入这里说明一位数据传输结束了，现在开始判断这一位数据是什么
			if(ReadStep == 0)	//读同步信号
			{
//				if((LowTime > (7500/50)) && (LowTime < (8500/50)))		8000us/50us == 160
				if((LowTime >= _32start_us_min) && (LowTime <= _32start_us_max))
				{
					DataFram = 32;//32 位数据格式，黑色钥匙
					ReadStep = 1;
				}
				else if((LowTime >= _24start_us_min) && (LowTime <= _24start_us_max))		//12400us/50us == 248
				{
					DataFram = 24;//24 位数据格式，棕色钥匙
					ReadStep = 1;					
				}
				LowTime = 0;
			}
			else if(ReadStep == 1)	//接收数据
			{
				if(DataFram == 32)	//32 位数据解析
				{
					if((LowTime >= _32num1_us_min) && (LowTime <= _32num1_us_max))
	//					if((LowTime >= (300/50)) && (LowTime <= (400/50)))	//数据1		360us/50us == 7
					{
						
						TempData[ReadLoop] |= 0x80000000>>BitCount;

						BitCount++;
					}
					else if((LowTime >= _32num0_us_min) && (LowTime <= _32num0_us_max))
	//					else if((LowTime > (900/50)) && (LowTime < (1200/50)))	//数据0		1084us/50us == 21
					{
						TempData[ReadLoop] &= ~(0x80000000>>BitCount);

						BitCount++;
					}
					else	//数据出错，重新接收
					{
						ReadStep = 0;
						BitCount = 0;
					}
					LowTime = 0;
										
				}
				else if(DataFram == 24)	//24 位数据解析
				{
					if((LowTime >= _24num1_us_min) && (LowTime <= _24num1_us_max))		//数据1		410us/50us == 8
					{
						
						TempData[ReadLoop] |= 0x80000000>>BitCount;

						BitCount++;
					}
					else if((LowTime >= _24num0_us_min) && (LowTime <= _24num0_us_max))		//数据0		1200us/50us == 24
					{
						TempData[ReadLoop] &= ~(0x80000000>>BitCount);

						BitCount++;
					}
					else	//数据出错，重新接收
					{
						ReadStep = 0;
						BitCount = 0;
					}
					LowTime = 0;
					
				}
				if(BitCount >= DataFram)	//数据接收完成
				{
					BitCount = 0;
					ReadLoop++;
					if(ReadLoop < 2)	//接收数据少于 2 组
					{
						ReadStep = 0;	//重新读取同步信号，读 2 组数据
						CheckTime = 100000/50;	//接收完第一组，开始倒计时，设置为 100ms 内
					}
					else	//已经读取两组了
					{
						ReadLoop = 0;
						ReadStep = 2;
					}
					
				}
				
				if(ReadLoop==1)		//只读取到一组数据
				{
					CheckTime--;	//校验倒计时，规定时间内没收到第二组，就是校验失败，需要重新接收
					if(CheckTime == 0)
					{
						ReadLoop = 0;
						ReadStep = 0;
					}
				}
					
			}
			if(ReadStep == 2)	//接收完成，处理数据
			{
				
				if(TempData[0] == TempData[1])  	//收到连续两组相同的数据，再开始解析
				{
					if(DataFram == 32)	//32 位数据解析
					{
						rf_data32[0] = TempData[0]>>24;
						rf_data32[1] = TempData[0]>>16;
						rf_data32[2] = TempData[0]>>8;
						rf_data32[3] = TempData[0]>>0;
						decode32_ok = 1;
						RfDuty_32Bit();	//黑色遥控器任务函数，这里也可以在主函数里检测decode32_ok 标志位调用
						
					}
					else if(DataFram == 24)	//24 位数据解析
					{
						rf_data24[0] = TempData[0]>>24;
						rf_data24[1] = TempData[0]>>16;
						rf_data24[2] = TempData[0]>>8;
						decode24_ok = 1;
						RfDuty_24Bit();	//棕色遥控器任务函数
					}
				}

				ReadStep = 0;
				DataFram = 0;
			}
		}
	}	
}

//----------------------------------------------------------------------------------------------
//任务函数
void RfDuty_32Bit(void)
{
decode32_ok = 0;
	if(rf_data32[3] == 0x08)
		printf("黑色钥匙上三角\r\n");
	else if(rf_data32[3] == 0x01)	
		printf("黑色钥匙下三角\r\n");
	else if(rf_data32[3] == 0x04)	
		printf("黑色钥匙方块\r\n");
	else if(rf_data32[3] == 0x02)	
		printf("黑色钥匙圆\r\n");	
}


void RfDuty_24Bit(void)
{
Decode24_ok = 0;
	if(rf_data24[2] == 0x74)
		printf("棕色钥匙上三角\r\n");
	else if(rf_data24[2] == 0x78)	
		printf("棕色钥匙下三角\r\n");
	else if(rf_data24[2] == 0x71)	
		printf("棕色钥匙锁\r\n");
	else if(rf_data24[2] == 0x72)	
		printf("棕色钥匙方块\r\n");	
}

//--------------------------------------------------------------------------
//main函数

int main(void)
{	
  

	uart_init(115200); 
	RF433_Init();
	
	printf("433遥控器\r\n");

	while(1)
	{

			
	}
}

3、定时器输入捕获方式解析数据

定时器输入捕获的编程思路跟扫描方式很相似，只是把检测低电平时间的任务交给了定时器，不再用扫描的方式对变量累加，本文使用定时器5的通道1。定时器的计数部分配置为1us中断，配置过程跟上面类似，这里主要注意定时器输入捕获的一些参数。

TIM_ICInitTypeDef TIM5_ICInitStructure;

//初始化TIM5输入捕获参数

TIM5_ICInitStructure.TIM_Channel = TIM_Channel_1; //CC1S=01 选择输入端 IC1映射到TI1上

TIM5_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling; //下降沿捕获

TIM5_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上

TIM5_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1; //配置输入分频,不分频

TIM5_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器不滤波

TIM_ICInit(TIM5, &TIM5_ICInitStructure);

第一个参数是选择通道，选择通道1就行了。

第二个是选择上升沿还是下降沿捕获，因为要捕获低电平所以先设置为下降沿捕获，在检测到下降沿后清0定时器的计数值，再更改为上升沿捕获，这样在捕获到上升沿时，定时器的计数值就是低电平的持续时间。

第三个参数是映射，IC1可以映射到TI1，也可以映射到TI2，选择TI1就好（这里个人理解，如果映射到TI1，那么定时器的通道一电平跳变时触发捕获中断，如果映射到二，那么定时器通道二电平跳变时触发捕获中断）。

第四个是分频，可以设置检测到几个上升沿才算做一个有效上升沿，如果设置为8，就是连续8个上升沿才记一次，这里不分频，就是每一个上升沿进入中断。

第五个参数是滤波，检测到上升沿后，进行一些时钟周期的延迟，如果一直保持高电平，才算有效上升沿，把一些持续时间短的信号滤掉，这里不滤波，检测到高电平立刻进入中断。

源码：

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

//宏定义和变量说明



#define h_24start_us_min 208 //24Bit格式 同步信号 高电平参考值 408us

#define h_24start_us_max 608

#define h_24num0_us_min 210 //24Bit格式数据'0'高电平持续时间参考值 410us

#define h_24num0_us_max     610

#define h_24num1_us_min     1000 //24Bit格式数据'1'高电平持续时间参考值 1200us

#define h_24num1_us_max     1400



#define l_24start_us_min 11400 //24Bit格式 同步信号 低电平参考值 12400us

#define l_24start_us_max 13400

#define l_24num0_us_min 1000 //24Bit格式数据'0'低电平持续时间参考值 1200us

#define l_24num0_us_max 1400

#define l_24num1_us_min 200 //24Bit格式数据'1'低电平持续时间参考值 410us

#define l_24num1_us_max 600



#define h_32start_us_min 164 //32Bit格式 同步信号 高电平持续时间参考值 364us

#define h_32start_us_max 564

#define h_32num0_us_min 162 //32Bit格式 数据'0' 高电平持续时间参考值 362us

#define h_32num0_us_max 562

#define h_32num1_us_min 884 //32Bit格式 数据'1' 高电平持续时间参考值 1084us

#define h_32num1_us_max 1284



#define l_32start_us_min 7000 //32Bit格式 同步信号 低电平持续时间参考值 8000us

#define l_32start_us_max 9000

#define l_32num0_us_min 884 //32Bit格式 数据'0' 低电平持续时间参考值 1084us

#define l_32num0_us_max 1284

#define l_32num1_us_min 160 //32Bit格式 数据'1' 低电平持续时间参考值 360us

#define l_32num1_us_max 560





/*

变量说明：

DataFram     数据帧格式  24位或者32位

BitCount     记录当前接收了多少位数据



decode32_ok 32位格式数据解析成功

decode24_ok 24位格式数据解析成功

ReadLoop 读数据的次数 需要循环两次读两组数据

CheckTime 校验计时 接收完第一组数据后，开始倒计时，如果100ms内没有接收到第二组数据，则解析失败，回到开始重新接收数据



TempData[2]; 存放临时数据

rf_data32[4]; 存放解析成功的32位格式数据，数组前几位存放地址值，最后一位存放数据值

rf_data24[3]; 存放解析成功的24位格式数据



*/

unsigned char DataFram,BitCount,decode32_ok,decode24_ok,ReadLoop;

unsigned int CheckTime;

unsigned int TempData[2] = {0};

unsigned char rf_data32[4] = {0};

unsigned char rf_data24[3] = {0};



/*TIM5CH1_CAPTURE_STA

Bit7 Bit6 Bit5 Bit4~Bit0

捕获完成 同步码 下降沿 保留

*/

u8  TIM5CH1_CAPTURE_STA=0; //输入捕获状态     

u16 TIM5CH1_CAPTURE_LVAL; //记录低电平持续时间

u16 TIM5CH1_CAPTURE_HVAL;





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

//初始化

void RF433_Init(void)

{

TIM5_Cap_Init(0xFFFF,71);//72分频   72MHZ经过分频变成1MHZ，1us中断1次

}



void TIM5_Cap_Init(u16 arr,u16 psc)

{  

GPIO_InitTypeDef GPIO_InitStructure;

TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

    NVIC_InitTypeDef NVIC_InitStructure;

TIM_ICInitTypeDef  TIM5_ICInitStructure;



RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE); //使能TIM5时钟

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);  //使能GPIOA时钟



GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0;  //PA0 清除之前设置  

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0 输入  

GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_ResetBits(GPIOA,GPIO_Pin_0);



//初始化定时器5 TIM5  

TIM_TimeBaseStructure.TIM_Period = arr; //设定计数器自动重装值

TIM_TimeBaseStructure.TIM_Prescaler =psc; //预分频器   

TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim

TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式

TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位

  

//初始化TIM5输入捕获参数

TIM5_ICInitStructure.TIM_Channel = TIM_Channel_1; //CC1S=01 选择输入端 IC1映射到TI1上

   TIM5_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling; //下降沿捕获

   TIM5_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; //映射到TI1上

   TIM5_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;  //配置输入分频,不分频

   TIM5_ICInitStructure.TIM_ICFilter = 0x00;//IC1F=0000 配置输入滤波器 不滤波

   TIM_ICInit(TIM5, &TIM5_ICInitStructure);



//中断分组初始化

NVIC_InitStructure.NVIC_IRQChannel = TIM5_IRQn;  //TIM3中断

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  //先占优先级2级

NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  //从优先级0级

NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能

NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器



TIM_ITConfig(TIM5,TIM_IT_Update|TIM_IT_CC1,ENABLE);//允许更新中断 ,允许CC1IE捕获中断



    TIM_Cmd(TIM5,ENABLE ); //使能定时器5



}



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

//中断服务函数

//定时器5中断服务程序  

void TIM5_IRQHandler(void)

{

if (TIM_GetITStatus(TIM5, TIM_IT_Update) != RESET)

{     



}



if (TIM_GetITStatus(TIM5, TIM_IT_CC1) != RESET)//捕获1发生捕获事件

{



if(TIM5CH1_CAPTURE_STA&0x20) //第二步，捕获上升沿

{   

TIM5CH1_CAPTURE_STA &= ~0x20;

TIM5CH1_CAPTURE_LVAL = TIM_GetCapture1(TIM5); //读取低电平持续的时间



TIM_SetCounter(TIM5,0);

TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Falling); //准备捕获下降沿



if(TIM5CH1_CAPTURE_STA&0x40) //如果接收到了同步码

{

if(DataFram == 32) //32 位数据解析

{

if((TIM5CH1_CAPTURE_LVAL >= l_32num1_us_min) && (TIM5CH1_CAPTURE_LVAL <= l_32num1_us_max) && (TIM5CH1_CAPTURE_HVAL >= h_32num1_us_min) && (TIM5CH1_CAPTURE_HVAL <= h_32num1_us_max)) //数据1

{

TempData[ReadLoop] |= 0x80000000>>BitCount;

BitCount++;

}

else if((TIM5CH1_CAPTURE_LVAL >= l_32num0_us_min) && (TIM5CH1_CAPTURE_LVAL <= l_32num0_us_max) && (TIM5CH1_CAPTURE_HVAL >= h_32num0_us_min) && (TIM5CH1_CAPTURE_HVAL <= h_32num0_us_max)) //数据0

{

TempData[ReadLoop] &= ~(0x80000000>>BitCount);

BitCount++;

}

else //数据出错，重新接收

{

TIM5CH1_CAPTURE_STA &= ~0x40; //重新读取同步信号

BitCount = 0;

}



}

else if(DataFram == 24) //24 位数据解析

{

if((TIM5CH1_CAPTURE_LVAL >= l_24num1_us_min) && (TIM5CH1_CAPTURE_LVAL <= l_24num1_us_max) && (TIM5CH1_CAPTURE_HVAL >= h_24num1_us_min) && (TIM5CH1_CAPTURE_HVAL <= h_24num1_us_max)) //数据1

{

TempData[ReadLoop] |= 0x80000000>>BitCount;

BitCount++;

}

else if((TIM5CH1_CAPTURE_LVAL >= l_24num0_us_min) && (TIM5CH1_CAPTURE_LVAL <= l_24num0_us_max) && (TIM5CH1_CAPTURE_HVAL >= h_24num0_us_min) && (TIM5CH1_CAPTURE_HVAL <= h_24num0_us_max)) //数据0

{

TempData[ReadLoop] &= ~(0x80000000>>BitCount);

BitCount++;

}

else //数据出错，重新接收

{

TIM5CH1_CAPTURE_STA &= ~0x40; //重新读取同步信号

BitCount = 0;

}



}

if(BitCount >= DataFram) //黑色钥匙 32 位数据

{

BitCount = 0;

ReadLoop++;

if(ReadLoop < 2) //接收数据少于 2 组

{

TIM5CH1_CAPTURE_STA &= ~0x40; //重新读取同步信号，读 2 组数据

CheckTime = 100000; //接收完第一组，开始倒计时，设置为 100ms 内

}

else //已经读取两组了

{

ReadLoop = 0;

TIM5CH1_CAPTURE_STA |= 0x80; //标记读取数据完成

rf433_decode();

}



}

if(ReadLoop==1) //读取到一组数据，等待第二组，倒计时

{

CheckTime--; //校验倒计时，规定时间内没收到第二组，就是校验失败，需要重新接收

if(CheckTime == 0)

{

ReadLoop = 0;

TIM5CH1_CAPTURE_STA &= ~0x40; //重新读取同步信号

}

}



}

else //没有收到同步码

{

if((TIM5CH1_CAPTURE_LVAL >= l_32start_us_min) && (TIM5CH1_CAPTURE_LVAL <= l_32start_us_max) && (TIM5CH1_CAPTURE_HVAL >= h_32start_us_min) && (TIM5CH1_CAPTURE_HVAL <= h_32start_us_max))

{

DataFram = 32;//32 位数据格式，黑色钥匙

TIM5CH1_CAPTURE_STA |= 0x40; //标记收到了同步码

}

else if((TIM5CH1_CAPTURE_LVAL >= l_24start_us_min) && (TIM5CH1_CAPTURE_LVAL <= l_24start_us_max) && (TIM5CH1_CAPTURE_HVAL >= h_24start_us_min) && (TIM5CH1_CAPTURE_HVAL <= h_24start_us_max))

{

DataFram = 24;//24 位数据格式，棕色钥匙

TIM5CH1_CAPTURE_STA |= 0x40;

}

}

TIM5CH1_CAPTURE_HVAL=0;



}

else   //第一步，捕获下降沿

{

TIM5CH1_CAPTURE_HVAL = TIM_GetCapture1(TIM5); //读取高电平持续的时间

TIM5CH1_CAPTURE_LVAL=0;

TIM_SetCounter(TIM5,0);

TIM5CH1_CAPTURE_STA|=0X20; //标记捕获到了下降沿

TIM_OC1PolarityConfig(TIM5,TIM_ICPolarity_Rising); //准备捕获上升沿

}

    

}

 

    TIM_ClearITPendingBit(TIM5, TIM_IT_CC1|TIM_IT_Update); //清除中断标志位



}





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

//解码函数和任务函数



void rf433_decode(void)

{

if(TIM5CH1_CAPTURE_STA | 0x80) //接收到一次完整数据，开始解码

{

if(TempData[0] == TempData[1])   //收到连续两组相同的数据，再开始解析

{

if(DataFram == 32) //32 位数据解析

{

rf_data32[0] = TempData[0]>>24;

rf_data32[1] = TempData[0]>>16;

rf_data32[2] = TempData[0]>>8;

rf_data32[3] = TempData[0]>>0;

decode32_ok = 1;

RfDuty_32Bit();

}

else if(DataFram == 24) //24 位数据解析

{



rf_data24[0] = TempData[0]>>24;

rf_data24[1] = TempData[0]>>16;

rf_data24[2] = TempData[0]>>8;

decode24_ok = 1;

RfDuty_24Bit();

}

}

TIM5CH1_CAPTURE_STA = 0;//状态标志位清0

DataFram = 0;

}

}



void RfDuty_32Bit(void)

{

decode32_ok = 0;

if(rf_data32[3] == 0x08)

printf("黑色钥匙上三角\r\n");

else if(rf_data32[3] == 0x01)

printf("黑色钥匙下三角\r\n");

else if(rf_data32[3] == 0x04)

printf("黑色钥匙方块\r\n");

else if(rf_data32[3] == 0x02)

printf("黑色钥匙圆\r\n");

}





void RfDuty_24Bit(void)

{

decode24_ok = 0;

if(rf_data24[2] == 0x74)

printf("棕色钥匙上三角\r\n");

else if(rf_data24[2] == 0x78)

printf("棕色钥匙下三角\r\n");

else if(rf_data24[2] == 0x71)

printf("棕色钥匙锁\r\n");

else if(rf_data24[2] == 0x72)

printf("棕色钥匙方块\r\n");

}

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

//运行结果