[嵌入式]51单片机-红外计算器

51单片机-红外计算器

1、硬件：普中-A2开发板
使用哪些硬件资源？

1.1、LCD1602液晶显示器
1.2、红外接收头
1.3、红外遥控器

2、软件介绍：

2.1、共分为8个.c文件。
2.1.1、main.c 主要负责初始化，调用函数进行计算、显示
2.1.2、calculator.c 主要负责计算和字符输入
2.1.3、delay.c 延时函数
2.1.4、lcd1602.c 液晶屏驱动函数
2.1.5、time.c 定时器初始化、中断服务函数
2.1.6、uart.c 串口相关函数
2.1.7、Infrared.c 红外接收函数
2.1.8、EXIT.c 外部中断0初始化及中断服务函数

2.2、Infrared.c和EXIT一起，用来读取红外遥控按键键值，红外接收头接在P3 ^ 2引脚上，因此一旦外部中断0有下降沿，就进入红外接收函数，读取键值。

上代码
1、main.c

#include <REGX52.H>
#include <intrins.h>
#include <stdio.h>
#include <string.h>
#include "time.h"
#include "lcd1602.h"
#include "delay.h"
#include "typedef.h"
#include "key.h"
#include <stdlib.h>
#include "uart.h"
#include "calculator.h"
#include "infrared.h"

uint16_t time0Cnt = 0;//本工程未用到

//主函数
int main(void)
{
	LcdInit();//LCD1602初始化
	Timer0Init();//定时器初始化
	Timer1Init();//定时器初始化
	UART_Init(9600);//串口初始化
	infrared_Init();//红外接收初始化
	EA = 1;//使能所有中断
    
	CalculatorInit(&calculator_s);//计算器结构体初始化
	setDisplayAddr(0, 0);//从第一行第一列开始显示
	printf("calculator");//上电先显示"calculator"，提示这是计算器

    while(1)
    {
		if(infraredValue != 0)//当接收到红外遥控器键值时
		{
			switch(getNumber(&calculator_s))//处理按键输入
			{
				case 0://显示运算结果
					setDisplayAddr(0, 1);//显示在第2行开头
					printf("%s", calculator_s.inputCharBuf);//LCD1602显示计算结果
				break;
				case 1://显示输入的内容
					LcdWriteCom(0x01);  //清屏
					setDisplayAddr(0, 0);//显示在第一行开头
					printf("%s", calculator_s.inputCharBuf);//LCD1602显示输入的字符串
				break;
			}
			infraredValue = 0;
		}
    }
}

2、calculator.h

#ifndef __CALCULATOR_H_
#define __CALCULATOR_H_

#include <REGX52.H>

typedef struct
{
	unsigned char inputCharBuf[16]; //输入的字符数组
	unsigned int inputCharCnt;      //输入的字符个数
    unsigned int offset;            //递归调用计算时偏移量
    unsigned char errorFlag;        //计算错误标志位 0：没有错误 1：被除数等于0 2：其他
	float result;				    //运算结果
}Calculator_S;
extern Calculator_S calculator_s;   //实例化计算器需要的结构体

unsigned char keyDeal(unsigned char keyValue);
void CalculatorInit(Calculator_S *s);
unsigned char getNumber(Calculator_S *s);
float calculator(Calculator_S *s);
float calculator_core(void)reentrant;
float my_atof(const char* pbuf);
void my_cal_atof(float* result, const char *pstr, unsigned int* index);
#endif

3、calculator.c

#include "calculator.h"
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include <math.h>
#include "infrared.h"

#define PRINTF 0 //为1则打印log

Calculator_S calculator_s;//实例化计算器需要的结构体

//计算器结构体全部清零
void CalculatorInit(Calculator_S *s)
{
	memset(s->inputCharBuf, 0x00, sizeof(s->inputCharBuf));
	s->inputCharCnt = 0;
	s->result = 0;
    s->offset = 0;
    s->errorFlag = 0;
}

//获取输入的数
unsigned char getNumber(Calculator_S *s)
{
	unsigned char keyValue = 0xFF;
	
	if(infraredValue != 0)//接收到新的键值
	{
		switch(infraredValue)
		{
			case 0x09://前括号
				s->inputCharBuf[s->inputCharCnt++] = ')';
			break;
			case 0x07:
				s->inputCharBuf[s->inputCharCnt++] = '(';
			break;
			case 0x43:
				if(s->inputCharCnt > 0)//删除一个字符
				{
					s->inputCharCnt--;
					s->inputCharBuf[s->inputCharCnt] = 0x00;
				}
			break;
			case 0x0d://删除所有字符
				s->inputCharCnt = 0;
				memset(s->inputCharBuf, 0x00, sizeof(s->inputCharBuf));
			break;
			case 0x0c:
				keyValue = '1';
			break;
			case 0x18:
				keyValue = '2';
			break;
			case 0x5e:
				keyValue = '3';
			break;
			case 0x40:
				keyValue = '+';
			break;
			case 0x08:
				keyValue = '4';
			break;
			case 0x1c:
				keyValue = '5';
			break;
			case 0x5a:
				keyValue = '6';
			break;
			case 0x19:
				keyValue = '-';
			break;
			case 0x42:
				keyValue = '7';
			break;
			case 0x52:
				keyValue = '8';
			break;
			case 0x4a:
				keyValue = '9';
			break;
			case 0x45:
				keyValue = '*';
			break;
			case 0x44:
				keyValue = '.';
			break;
			case 0x16:
				keyValue = '0';
			break;
			case 0x15:
				keyValue = '=';
			break;
			case 0x47:
				keyValue = '/';
			break;
			default:
				keyValue = 0xFF;
			break;
		}
		if(keyValue != 0xFF)
		{
			if(keyValue == '=' || s->inputCharCnt >= 15)//输入的是=号
			{
				s->result = calculator(s);//进行计算
				s->inputCharCnt = sprintf(s->inputCharBuf, "%.2f", calculator_s.result);//将计算结果放入输入数组中，while循环中进行显示
				return 0;
			}
			else
			{
				/* 将输入的字符存入字符数组 */
				s->inputCharBuf[s->inputCharCnt++] = keyValue;
				return 1;
			}	
		}
		return 1;
	}

    return 2;//return 2 表示没有新的按键
}

float calculator(Calculator_S *s)
{
	s->offset = 0;//计算偏移量回到输入数组开头
	s->errorFlag = 0;//清除报警位
	s->result = calculator_core();//调用计算函数进行计算

	//清除状态标志位和输入数组
	memset(s->inputCharBuf, 0x00, sizeof(s->inputCharBuf));
	s->inputCharCnt = 0;

	return s->result;//返回计算结果
}

//计算函数 reentrant表示可重入，（51单片机递归必须算好资源）
float calculator_core(void)reentrant
{
    char sign = 0;//符号变量
    float number[2] = {0, 0}; //输入的值转换成浮点数
	char numberCnt = 0;//输入的数个数统计

    sign = '+';//第一个数默认为+，因为-号会在转换成浮点数时转成负数
    while(calculator_s.inputCharCnt > calculator_s.offset)//当输入字符个数大于偏移量时
    {
		/* 遇到左括号开始递归计算 */
        if(calculator_s.inputCharBuf[calculator_s.offset] == '(')
        {
			#if PRINTF == 1
			printf("递归入口\r\n");
			#endif
            calculator_s.offset++;
            calculator_s.result = calculator_core();
        }
		
        /* i == 0时可以转换 */
        if(calculator_s.offset == 0)
        {
            my_cal_atof(&calculator_s.result, (const char*)calculator_s.inputCharBuf, &calculator_s.offset);//字符串转float
		}
        /* 当本个字符是0-9数字，前一个字符不是0-9、.时，可以进行转换 */
        else if(isdigit(calculator_s.inputCharBuf[calculator_s.offset]) 
			&& (!isdigit(calculator_s.inputCharBuf[calculator_s.offset - 1]) && calculator_s.inputCharBuf[calculator_s.offset - 1] != '.'))
        {
            my_cal_atof(&calculator_s.result, (const char*)calculator_s.inputCharBuf, &calculator_s.offset);//字符串转float
        }
				
        /* 非数字或者到最后一个字符了 */
        if(((calculator_s.inputCharBuf[calculator_s.offset] != ' ') && (!isdigit(calculator_s.inputCharBuf[calculator_s.offset]))) 
            || (calculator_s.offset == calculator_s.inputCharCnt - 1))
        {
            switch(sign)
            {
                case '+':
                    if(numberCnt == 2)
                    {
                        number[0] += number[1];
                        number[1] = calculator_s.result;
                    }
                    else
                    {
                        number[numberCnt++] = calculator_s.result;
                    }
                break;
                case '-':
					if(numberCnt == 2)
                    {
                        number[0] += number[1];
                        number[1] = -calculator_s.result;
                    }
                    else
                    {
                        number[numberCnt++] = -calculator_s.result;
                    }
                break;
                case '*':
                    number[numberCnt - 1] *= calculator_s.result;//与前一个数相乘
                break;
                case '/':
                    if(calculator_s.result != 0)
                    {
                        number[numberCnt - 1] /= calculator_s.result;//与前一个数相除
                    }
                    else
                    {
                        calculator_s.errorFlag = 1;//标志被除数等于0
                    }
                break;
                case '%'://取余
                    number[numberCnt - 1] = number[numberCnt - 1] - (int)(number[numberCnt - 1] / calculator_s.result) * calculator_s.result;
                break;
                default:
                    break;
            }
			#if PRINTF == 1
			printf("\r\nsign:%c,%.2f, %.2f\r\n", sign, number[0], number[1]);
			#endif
			sign = calculator_s.inputCharBuf[calculator_s.offset];//更新当前符号
        }
        
        /* 遇到右括号返回递归结果 */
        if(calculator_s.inputCharBuf[calculator_s.offset] == ')')
        {
			#if PRINTF == 1
			printf("递归出口\r\n");
			#endif
			calculator_s.offset++;//偏移量加1
            break;
        }
		calculator_s.offset++;
    }
	#if PRINTF == 1
	printf("result: %.2f\r\n", number[0] + number[1]);
	#endif
    return (number[0] + number[1]);
}

//本计算器专用字符串转浮点数函数，pstr是字符串指针，index为字符串坐标
void my_cal_atof(float* result, const char *pstr, unsigned int* index)
{
    char sign = 1;//默认为正数
    float point = 0.1;
	
	*result = 0;
    while (pstr[*index] < '0' || pstr[*index] > '9')
    {
		//去掉正负号影响
		if (pstr[*index] == '-')
		{
			sign = 2;
		}
		else if(pstr[*index] == '+')
		{
			sign = 1;
		}
        (*index)++;
    }

    while (pstr[*index])
    {
        if (pstr[*index] == '.')
        {
            (*index)++;
            while (pstr[*index] >= '0' && pstr[*index] <= '9')
            {
                *result += point * (pstr[*index] - '0');
                point *= 0.1f;
                (*index)++;
            }
			break;
        }
        else if (pstr[*index] >= '0' && pstr[*index] <= '9')
        {
            *result *= 10;
            *result += pstr[*index] -'0';
        }
		else
		{
			break;
		}
        (*index)++;
    }
	
	(*index)--;
	if(sign == 2)//负数
	{
		*result = -*result;
	}
//	#if PRINTF == 1
//	printf("\r\nmy_cal_atof() = %.2f\r\n", *result);
//	#endif
    return;
}

4、delay.h

#ifndef __DELAY_H_
#define __DELAY_H_

#include "typedef.h"

#define MAIN_FOSC_DELAY        11059200UL    //定义主时钟HZ  

//延时n*1ms
void delay_ms(uint16_t ms);
void delay5us(void);
void delay_us(uint16_t us);
void delay_30us(void);
void delay_40us(void);
#endif

5、delay.c

#include "delay.h"
#include <intrins.h>

void delay5us(void)
{
#if MAIN_FOSC_DELAY == 11059200UL
    _nop_();
#elif MAIN_FOSC_DELAY == 12000000UL
    _nop_();
#elif MAIN_FOSC_DELAY == 22118400UL
    _nop_();
    _nop_();
    _nop_();
#endif
}

void delay_us(uint16_t us)
{
    uint16_t i = us;
    i = (i > 4) ? (i - 4) : i;
    while(i--)
    {
        #if MAIN_FOSC_DELAY == 11059200UL
            _nop_();
        #elif MAIN_FOSC_DELAY == 12000000UL
            _nop_();
        #elif MAIN_FOSC_DELAY == 22118400UL
            _nop_();
            _nop_();
            _nop_();
        #endif
    }
}


void delay_ms(uint16_t ms)
{
    uint16_t i, j;
#if MAIN_FOSC_DELAY == 11059200UL
    for(i=ms; i>0; i--)
	{
        for(j=114; j>0; j--)
		{
			;
		}
	}
#elif MAIN_FOSC_DELAY == 12000000UL
	for(i=0; i<ms; i++)
	{
        for(j=0; j<123; j++)
		{
			;
		}
	}
#endif
}

//延时30微秒
void delay_30us(void)
{
#if MAIN_FOSC_DELAY == 11059200
    unsigned char i;
    i = 11;
    while(--i);
#elif MAIN_FOSC_DELAY == 12000000
    unsigned char i;
    _nop_();
    i = 12;
    while(--i);
#endif
}

//延时40微秒
void delay_40us(void)		//@11.0592MHz
{
#if MAIN_FOSC_DELAY == 11059200
    unsigned char i;
    _nop_();
    i = 15;
    while(--i);
#elif MAIN_FOSC_DELAY == 12000000
    unsigned char i;
    _nop_();
    i = 17;
    while(--i);
#endif
}

6、typedef.h

#ifndef __TYPEDEF_H_
#define __TYPEDEF_H_

//#define uint16_t unsigned int
#define __WEAK                                 __attribute__((weak))

typedef unsigned long uint32_t;
typedef unsigned int  uint16_t;
typedef unsigned char uint8_t;

#endif

7、lcd1602.h

#ifndef __LCD1602_H_
#define __LCD1602_H_

#define QUICK 1 //有此宏定义时，为快速模式，否则为慢速模式

/**********************************
包含头文件
**********************************/
#include <REGX52.H>
#include "typedef.h"

/**********************************
PIN口定义
**********************************/
#define LCD1602_DATAPINS P0
sbit LCD1602_RS=P2^6;
sbit LCD1602_RW=P2^5;
sbit LCD1602_E=P2^7;

extern unsigned char code userCodeBuf[];//用户自定义的7个字的地址数组

/**********************************
函数声明
**********************************/
/*在51单片机12MHZ时钟下的延时函数*/
void Lcd1602_Delay1ms(uint16_t c);   //误差 0us
/*LCD1602写入8位命令子函数*/
void LcdWriteCom(uint8_t com);
/*LCD1602写入8位数据子函数*/	
void LcdWriteData(uint8_t dat)	;
/*LCD1602初始化子程序*/		
void LcdInit();				
void displayString(uint8_t* buf, uint16_t N, uint8_t Lin);
void setDisplayAddr(unsigned char x, unsigned char y);
#endif

8、lcd1602.c

#include "lcd1602.h"
#include "delay.h"
#include <stdio.h>
#ifdef UART //定义才调用下方的文件头
#include "uart.h"
#endif


/* 字符获取方式：
   点阵格式：阴码
   取模走向：顺向
   取模方式：逐行式
   输出数制：十六进制
   用8*8点阵的后5列
 */
unsigned char code table[]= {
    0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x00,//一
	
    0x00,0x00,0x0E,0x00,0x1F,0x00,0x00,0x00,//二

    0x00,0x1F,0x00,0x0E,0x00,0x1F,0x00,0x00,//三

    0x08,0x0f,0x12,0x0f,0x0a,0x1f,0x02,0x02,//年

    0x0f,0x09,0x0f,0x09,0x0f,0x09,0x0b,0x11,//月

    0x0F,0x09,0x09,0x0F,0x09,0x09,0x0F,0x00,//日

    0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,//冒号

    0x18,0x18,0x07,0x08,0x08,0x08,0x07,0x00//℃
};

code unsigned char userCodeBuf[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07}; //自定义字符数据地址

//重写putchar函数
char putchar(char c)
{
	if(c >= 0x20 && c <= 0x7E)
	{
		LcdWriteData(c); //显示一个字符
	}
	#ifdef UART
		sendByte(c);
	#endif

	return c;
}

void setDisplayAddr(unsigned char x, unsigned char y)
{
    LcdWriteCom(0x80 + x + 0x40 * y);    //设置数据指针起点，从LCD头部开始显示
}

/*******************************************************************************
* 函 数 名         : displayString
* 函数功能		   : LCD1602显示一串字符串 ,buf 为要显示的数组，N为要显示的长度，Lin为要显示在哪行
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
void displayString(uint8_t* buf, uint16_t N, uint8_t Lin)
{
    int i;
	N = (N > 16) ? 16 : N;//防止出现大于16的情况
    if(Lin == 0)
    {
        LcdWriteCom(0x80);    //设置数据指针起点，从LCD头部开始显示
    }
    else 
    {
        LcdWriteCom(0x80 + 0x40); //第二行显示
    }
    for(i = 0; i < N; i++)
    {
        LcdWriteData(buf[i]); //显示一个字符
    }
}

//判断忙指令
void Busy(void)
{
	LCD1602_DATAPINS = 0xff;
	LCD1602_RS = 0;
	LCD1602_RW = 1;
   	while(LCD1602_DATAPINS & 0x80)
   	{
		LCD1602_E = 0;
   		LCD1602_E = 1;
   	}
	LCD1602_E = 0;
}

/*******************************************************************************
* 函 数 名         : LcdWriteCom
* 函数功能		   : 向LCD写入一个字节的命令
* 输    入         : com
* 输    出         : 无
*******************************************************************************/
void LcdWriteCom(uint8_t com)	  //写入命令
{
	Busy();
	LCD1602_RS = 0;	   //选择发送命令
	LCD1602_RW = 0;	   //选择写入
	
	LCD1602_DATAPINS = com;     //放入命令
	delay_ms(1);		//等待数据稳定

	LCD1602_E = 1;	          //写入时序
	#ifdef QUICK
	delay_ms(1);	  //保持时间
	#else 
	delay_ms(5);	  //保持时间
	#endif
	LCD1602_E = 0;
}

/*******************************************************************************
* 函 数 名         : LcdWriteData
* 函数功能		   : 向LCD写入一个字节的数据
* 输    入         : dat
* 输    出         : 无
*******************************************************************************/		      
void LcdWriteData(uint8_t dat)			//写入数据
{
	Busy();
	LCD1602_RS = 1;	//选择输入数据
	LCD1602_RW = 0;	//选择写入

	LCD1602_DATAPINS = dat; //写入数据
	delay_ms(1);

	LCD1602_E = 1;   //写入时序
	#ifdef QUICK
	delay_ms(1);	  //保持时间
	#else 
	delay_ms(5);	  //保持时间
	#endif
	LCD1602_E = 0;
}

/*******************************************************************************
* 函 数 名       : LcdInit()
* 函数功能		 : 初始化LCD屏
* 输    入       : 无
* 输    出       : 无
*******************************************************************************/		   
void LcdInit()						  //LCD初始化子程序
{
	unsigned char i = 0;
	
	//等待LCD1602初始化
    delay5us();
    delay_us(5);
	delay_30us();
	delay_40us();
 	LcdWriteCom(0x38);  //开显示
	LcdWriteCom(0x0c);  //开显示不显示光标
	LcdWriteCom(0x06);  //写一个指针加1
	LcdWriteCom(0x01);  //清屏
	LcdWriteCom(0x80);  //设置数据指针起点
	
	setDisplayAddr(0, 0);
	displayString("lcd1602 Init", 12, 0);
	/* 开始写入你要显示的自定义字符、汉字代码 */
	LcdWriteCom(0x40); 
    for(i=0; i<64; i++)
    {
        LcdWriteData(table[i]);
    }
    displayString("            ", 12, 0);
}

9、time.h

#ifndef __TIME_H_
#define __TIME_H_
#include <REGX52.H>
#include "typedef.h"


#define T1MS_0 (65536-MAIN_FOSC_DELAY/12/1000)   //1ms timer calculation method in 12T mode
#define T1MS_1 (65536-MAIN_FOSC_DELAY/12/1000)   //1ms timer calculation method in 12T mode


//定时器0
void Timer0Init(void); //定时器初始化为1ms一次
//定时器1
void Timer1Init(void); //定时器初始化为1ms一次
#endif

10、time.c

#include "time.h"
#include "delay.h"
#ifdef ADC0809 //定义才调用下方的文件头
#include "ADC0809.h"
#endif
#ifdef UART //定义才调用下方的文件头
#include "uart.h"
#endif

extern uint16_t time0Cnt;

//定时器0中断
void Timer0Init(void) //定时器初始化为1ms一次
{
    TMOD |= 0X01; //选择为定时器0模式，工作方式1，仅用TR0打开启动。

    TL0 = T1MS_0;//给定时器赋初值，定时1ms ,计算方式(65536 -(12/12*1000))%256
    TH0 = T1MS_0 >> 8;//给定时器赋初值，定时1ms ,计算方式(65536 -(12/12*1000))/256
    ET0 = 1; //打开定时器0中断允许
    TR0 = 1; //打开定时器
}

//定时器1中断
void Timer1Init(void) //定时器初始化为1ms一次
{
    TMOD |= 0x10;                    //set timer1 as mode1 (16-bit)
    TL1 = T1MS_1;                     //initial timer1 low byte
    TH1 = T1MS_1 >> 8;                //initial timer1 high byte
    TR1 = 0;                        //timer1 start running
    ET1 = 1;                        //enable timer1 interrupt
}

void time0_isr() interrupt 1 using 0
{
    TL0 = T1MS_0;//手动重装载
    TH0 = T1MS_0 >> 8;//手动重装载
	
	#ifdef ADC0809
	CLK = !CLK;//ADC0809的时钟信号
	#endif
	
	#ifdef UART
	if(timeout < RECEIVE_TIMEOUT)//当小于接收超时时间时
	{
		if(++timeout == RECEIVE_TIMEOUT)
		{
			receiveFinshFlag = 1;//串口1帧数据接收完毕
		}
	}
	#endif
	
	time0Cnt++;
}

/* Timer0 interrupt routine */
void time1_isr() interrupt 3 using 1
{
    TL1 = T1MS_1;                     //reload timer1 low byte
    TH1 = T1MS_1 >> 8;                //reload timer1 high byte

}

11、uart.h

#ifndef __UART_H_
#define __UART_H_
#include <REGX52.H>

#define RECEIVE_TIMEOUT 5 //接收超时时间设为5ms
#define RECEIVE_LENGTH 5 //接收长度为5字节

extern volatile unsigned char UART_Buf[RECEIVE_LENGTH];//串口接收数组
extern volatile unsigned char receiveCnt;//串口接收的数据长度
extern volatile unsigned int timeout;//接收超时
extern volatile bit receiveFinshFlag;//接收完毕标志位

void UART_Init(unsigned int baud);
void sendString(unsigned char* s, int length);
void sendByte(unsigned char b);
#endif

12、uart.c

#include "uart.h"
#include "delay.h"

volatile unsigned char UART_Buf[RECEIVE_LENGTH];//串口接收数组
volatile unsigned char receiveCnt = 0;//串口接收的数据长度
volatile unsigned int timeout = 0xFF;
volatile bit receiveFinshFlag = 0;//接收完毕标志位

//串口1中断服务函数
void UART_isr(void) interrupt 4 using 1
{
	UART_Buf[receiveCnt++] = SBUF;
	timeout = 0;
	receiveCnt = (receiveCnt >= RECEIVE_LENGTH) ? 0 : receiveCnt;//防止数组越界
    RI = 0;//清除接收中断标志位
}

//串口初始化 0:2400 1:4800 2:9600
void UART_Init(unsigned int baud)
{
	TMOD &= 0x0F;
	TMOD |= 0x20;
	TH1 = -(MAIN_FOSC_DELAY/12/32/baud); //Set auto-reload vaule
	TL1 = -(MAIN_FOSC_DELAY/12/32/baud); //Set auto-reload vaule
	SCON = 0x50;
	ET1 = 0;
	TR1 = 1;
    ES = 1;
	sendString("UART is OK!\r\n", 13);
}

/*******发送一个字节到串口*************************************************************/
void sendByte(unsigned char b)
{
    ES = 0;
    SBUF = b;
    while(!TI);
    TI = 0;
    ES = 1;
}

/*******发送一个字符串到串口*************************************************************/
void sendString(unsigned char* s, int length)
{
    int i;
    for(i = 0; i < length; i++)
    {
        sendByte(s[i]);
    }
}

13、Infrared.h

#ifndef __INFRARED_H_
#define __INFRARED_H_

#include <REGX52.H>
#include "typedef.h"

sbit infrared_in = P3 ^ 2;//红外接收头引脚

extern unsigned char infraredValue;//红外接收键值

void infrared_Init(void);
void readInfrared(unsigned char* dat);
#endif

14、Infrared.c

#include "infrared.h"
#include "delay.h"
#include "EXIT.h"
#include <intrins.h>

unsigned char infraredValue;//红外接收键值

//红外通讯初始化
void infrared_Init(void)
{
	EXIT0_Init();//外部中断0初始化
	EA = 1;
	infrared_in = 1;
}

void readInfrared(unsigned char* dat)
{
    unsigned char i,j;//循环控制变量
    unsigned char Time;//高电平时间计算
	unsigned int errorCnt;//等待计时
    unsigned char readBuf[2];//临时存放数组
    
	Time = 0;					 
	delay_ms(7);	//7ms
	if(!infrared_in)		//确认是否真的接收到正确的信号
	{
		errorCnt = 1000;				//1000*10us=10ms,超过说明接收到错误的信号
		/*当两个条件都为真是循环，如果有一个条件为假的时候跳出循环，免得程序出错的时
		侯，程序死在这里*/	
		while((infrared_in == 0)&&( errorCnt > 0))	//等待前面9ms的低电平过去  		
		{			
			delay_us(1);
			errorCnt--;
		} 
		if(infrared_in == 1)			//如果正确等到9ms低电平
		{
			errorCnt = 500;
			while((infrared_in == 1) && (errorCnt > 0))		 //等待4.5ms的起始高电平过去
			{
				delay_us(1);
				errorCnt--;
			}
			for(i=0; i<4; i++)		//共有4组数据
			{				
				for(j=0; j<8; j++)	//接收一字节数据
				{
					errorCnt = 60;		
					while((infrared_in == 0)&&(errorCnt > 0))//等待信号前面的560us低电平过去
					{
						delay_us(10);
						errorCnt--;
					}
					errorCnt = 500;
					while((infrared_in == 1) && (errorCnt > 0))	 //计算高电平的时间长度。
					{
						delay_us(10);	 //0.1ms
						Time++;
						errorCnt--;
						if(Time > 30)
						{
							return;
						}
					}
					readBuf[i%2] >>= 1;	    //i表示第几组数据
					if(Time >= 8)			//如果高电平出现大于565us，那么是1
					{
						readBuf[i%2] |= 0x80;
					}
					Time = 0;		//用完时间要重新赋值							
				}
			}
		}
        //校验失败，则让值等于0
		if(readBuf[0] != ~readBuf[1])
		{
			*dat = 0;
		}
        else
        {
            *dat = readBuf[0];//校验成功，得到键值
        }
	}
}

15、EXIT.h

#ifndef __EXIT_H_
#define __EXIT_H_


#include "typedef.h"

void EXIT0_Init(void);
void EXIT1_Init(void);



#endif

16、EXIT.c

#include "EXIT.h"
#include "infrared.h"
#include <REGX52.H>

#ifdef EXIT_0
void EXIT0_Init(void)
{
	IT0=1;	//INT0负跳变触发	
    EX0 = 1; //开外部INTO中断
}

//外部中断0中断服务函数
void exint0() interrupt 0           //(location at 0003H)
{   
#ifdef INFRARED //若在keil编译指令中定义了这个宏，且为1，这调用下方读取红外信号的函数
    readInfrared(&infraredValue);
#endif
}
#endif

#ifdef EXIT_1
void EXIT1_Init(void)
{
	IT1=1;	//INT1负跳变触发	
    EX1 = 1; //开外部INTO中断
}

//外部中断1中断服务函数
void exint1() interrupt 2           //(location at 0013H)
{

}
#endif