红外接收C语言实现 NEC 定时器

使用定时器实现红外的接收，定时器的时间为80uS，协议为NEC。

	
typedef unsigned char bit;
typedef unsigned char BYTE;

#define SBIC_s_RedRec (_pa1)//IO口

//timer 80us 定时器每80us进去一次
#define n_InfraredLowBitMin 4//560us
#define n_InfraredLowBitMax 10//560us
#define n_InfraredZeroBitMin n_InfraredLowBitMin
#define n_InfraredZeroBitMax n_InfraredLowBitMax
#define n_InfraredOneBitMin  15//1.69ms
#define n_InfraredOneBitMax  27//1.69ms

#define n_InfraredHeadLowMin 90//9ms 20%容忍
#define n_InfraredHeadLowMax 135//9ms 20%容忍
#define n_InfraredHeadHighMin 45//4ms 20%容忍
#define n_InfraredHeadHighMax 67//4ms 20%容忍

#define n_InfraredRepeatMin 22//2.25ms 20%容忍
#define n_InfraredRepeatMax 33//2.25ms 20%容忍

#define n_InfraredErrorMax 140//12ms

bit f_intoRedCount;
bit f_redReceiveHead;//是否接收到引导头
bit f_redReceiveHeadL;//是否接收到引导头的9ms
bit f_redDataHeadL;//数据位的0.56ms
bit f_redReceiveSucceed;//接收成功了
bit f_redReceiveRepeat;//接收到重复信号

BYTE D_redReceiveRepeatNum;
BYTE D_redCount;
BYTE D_redReceiveBitNum ;//目前接接收到多少位了
BYTE D_arrRedRec[4] ;
BYTE D_getRedData;//成功之后获取的数据
BYTE D_repeatValidTime;//可以重复之前信号的时间20ms*50
BYTE f_getRedDataSign;//收到了信号
void INFRARED_DEAL();

while(1)
{
	if(f_20ms)
	{
		f_20ms=0;
		INFRARED_DEAL();
		if(f_getRedDataSign)
		{
			//do something
			f_getRedDataSign=0;
		}

	}
}


void INTERRUPT_TIMER(void)
{
	BYTE errorSign = 0;
	
	_timer = 0;//清中断标志位
	
	if((f_intoRedCount == 0) && (!SBIC_s_RedRec))
	{
		f_intoRedCount = 1;
		f_redReceiveHead = 0;
		f_redReceiveHeadL = 0;
		f_redDataHeadL = 0;
		D_redCount = 0;
		D_redReceiveBitNum = 0;

		D_arrRedRec[0]=0;
		D_arrRedRec[1]=0;
		D_arrRedRec[2]=0;
		D_arrRedRec[3]=0;
	}

	if(f_intoRedCount)
	{
		if(++D_redCount > n_InfraredErrorMax)
		{
			D_redCount=0;
			errorSign = 1;
		}
		
		if(f_redReceiveHead)
		{
			if(D_redReceiveBitNum<32)
			{
				if(f_redDataHeadL == 0)
				{
					if(SBIC_s_RedRec)
					{
						if((n_InfraredLowBitMin<D_redCount) && (n_InfraredLowBitMax>D_redCount))
						{
							f_redDataHeadL = 1;
							D_redCount = 0;
						}
						else 
						{
							errorSign = 1;
							
						}
					}
				}
				else
				{
					if(!SBIC_s_RedRec)
					{
						if((n_InfraredZeroBitMin<D_redCount) && (n_InfraredZeroBitMax>D_redCount))
						{
							f_redDataHeadL = 0;
							D_redCount = 0;
							D_redReceiveBitNum++;
						}
						else if ((n_InfraredOneBitMin<D_redCount) && (n_InfraredOneBitMax>D_redCount))
						{
							f_redDataHeadL = 0;
							D_redCount = 0;
							D_arrRedRec[D_redReceiveBitNum>>3] |=  (1<<(D_redReceiveBitNum&0x07));
							D_redReceiveBitNum++;
						}
						else 
						{
							errorSign = 1;
						}
					}
				}
			}
			else
			{
				if((D_arrRedRec[0] == 0)&&(D_arrRedRec[1] == 0xff)&&(D_arrRedRec[2] == (0XFF^D_arrRedRec[3])))//
				{
					f_redReceiveSucceed = 1;
					D_getRedData = D_arrRedRec[2];
					D_repeatValidTime = 50;
				}
				errorSign = 1;//并不是报错，只是借助报错跳出
			}
		}
		else
		{
			if(f_redReceiveHeadL == 0)
			{
				if(SBIC_s_RedRec)
				{
					if((n_InfraredHeadLowMin<D_redCount) && (n_InfraredHeadLowMax>D_redCount))
					{
						f_redReceiveHeadL = 1;
						D_redCount = 0;
					}
					else errorSign = 1;
				}
			}
			else
			{
				if(!SBIC_s_RedRec)
				{
					if((n_InfraredHeadHighMin<D_redCount) && (n_InfraredHeadHighMax>D_redCount))
					{
						f_redReceiveHead = 1;
						D_redCount = 0;
					}
					else if((n_InfraredRepeatMin<D_redCount) && (n_InfraredRepeatMax>D_redCount))
					{
						f_redReceiveRepeat = 1;
						errorSign = 1;//借助错误信号退出
					}
					else errorSign = 1;	
				}
			}
		}
	}
	if(errorSign)
	{
		f_intoRedCount = 0;
		f_redReceiveHead = 0;
		f_redReceiveHeadL = 0;
		f_redDataHeadL = 0;
		D_redCount = 0;
		D_redReceiveBitNum = 0;
	}
}

void INFRARED_DEAL()
{
	if(D_repeatValidTime)D_repeatValidTime--;
	else
	{
		D_getRedData=0;
	}
	
	if(f_redReceiveRepeat&0x01)
	{
		f_redReceiveRepeat = 0;
		D_repeatValidTime=50;//20*50=1000ms,两个重复帧最大间隔1s
		++D_redReceiveRepeatNum;
		if(D_redReceiveRepeatNum>2)
		{
			D_redReceiveRepeatNum = 0;
			if((D_getRedData==0X18) || (D_getRedData==0X59))
			{
				f_redReceiveSucceed=1;
				//重复n次后，根据data进行处理
			}
		}
	}
	
	if(f_redReceiveSucceed)
	{
		f_redReceiveSucceed = 0;
		f_redReceiveRepeat = 0;
		D_redReceiveRepeatNum = 0;
		switch(D_getRedData)//获取到的数据
		{
			case 0x18:
				f_getRedDataSign=1;	
				//其他处理
				break;			
			case 0x59:
				f_getRedDataSign=1;
				//其他处理
				break;						
			default:
				break;
		}
	}
	
}