XS128的红外解码问题·

fgwan

    如何将以下51的红外解码程序改成飞思卡尔XS128的程序？如能解决将不胜感激。我用的红外遵循NCE协议。我用飞思卡尔XS128改了一个星期也没改出来，飞思卡尔XS128用的输入捕捉模块，但是一直没现象。
   51程序如下：
//本解码程序适用于NEC的upd6121及其兼容芯片的解码，支持大多数遥控器 实验板采用11.0592MHZ晶振
#include<reg52.h>       //包含单片机寄存器的头文件
#include<intrins.h>  //包含_nop_()函数定义的头文件
sbit IR=P3^2;           //将IR位定义为P3.2引脚
sbit RS=P2^0;    //寄存器选择位，将RS位定义为P2.0引脚
sbit RW=P2^1;    //读写选择位，将RW位定义为P2.1引脚
sbit E=P2^2;     //使能信号位，将E位定义为P2.2引脚
sbit BF=P0^7;    //忙碌标志位，，将BF位定义为P0.7引脚
sbit BEEP = P3^6; //蜂鸣器控制端口P36
unsigned char flag;
unsigned char code string[ ]= {"1602IR-CODE TEST"};
unsigned char a[4];    //储存用户码、用户反码与键数据码、键数据反码
unsigned int LowTime,HighTime; //储存高、低电平的宽度
/*****************************************************
函数功能：延时1ms
***************************************************/
void delay1ms()
{
   unsigned char i,j;       
         for(i=0;i<10;i++)
          for(j=0;j<33;j++)
           ;                 
}
/*****************************************************
函数功能：延时若干毫秒
入口参数：n
***************************************************/
void delay(unsigned char n)
{
   unsigned char i;
        for(i=0;i<n;i++)
           delay1ms();
}



/*********************************************************/
void beep()                //蜂鸣器响一声函数
{
  unsigned char i;
  for (i=0;i<100;i++)
   {
   delay1ms();
   BEEP=!BEEP;       //BEEP取反
   }
   BEEP=1;           //关闭蜂鸣器
   delay(250);       //延时     
}




/*****************************************************
函数功能：判断液晶模块的忙碌状态
返回值：result。result=1，忙碌;result=0，不忙
***************************************************/
unsigned char BusyTest(void)
  {
    bit result;
        RS=0;       //根据规定，RS为低电平，RW为高电平时，可以读状态
    RW=1;
    E=1;        //E=1，才允许读写
    _nop_();   //空操作
    _nop_();
    _nop_();
    _nop_();   //空操作四个机器周期，给硬件反应时间       
    result=BF;  //将忙碌标志电平赋给result
        E=0;
    return result;
  }
/*****************************************************
函数功能：将模式设置指令或显示地址写入液晶模块
入口参数：dictate
***************************************************/
void WriteInstruction (unsigned char dictate)
{   
    while(BusyTest()==1); //如果忙就等待
         RS=0;                  //根据规定，RS和R/W同时为低电平时，可以写入指令
         RW=0;   
         E=0;                   //E置低电平(根据表8-6，写指令时，E为高脉冲，
                             // 就是让E从0到1发生正跳变，所以应先置"0"
         _nop_();
         _nop_();             //空操作两个机器周期，给硬件反应时间
         P0=dictate;            //将数据送入P0口，即写入指令或地址
         _nop_();
         _nop_();
         _nop_();
         _nop_();               //空操作四个机器周期，给硬件反应时间
         E=1;                   //E置高电平
         _nop_();
         _nop_();
         _nop_();
         _nop_();               //空操作四个机器周期，给硬件反应时间
          E=0;                  //当E由高电平跳变成低电平时，液晶模块开始执行命令
}
/*****************************************************
函数功能：指定字符显示的实际地址
入口参数：x
***************************************************/
void WriteAddress(unsigned char x)
{
     WriteInstruction(x|0x80); //显示位置的确定方法规定为"80H+地址码x"
}
/*****************************************************
函数功能：将数据(字符的标准ASCII码)写入液晶模块
入口参数：y(为字符常量)
***************************************************/
void WriteData(unsigned char y)
{
    while(BusyTest()==1);  
          RS=1;           //RS为高电平，RW为低电平时，可以写入数据
          RW=0;
          E=0;            //E置低电平(根据表8-6，写指令时，E为高脉冲，
                       // 就是让E从0到1发生正跳变，所以应先置"0"
          P0=y;           //将数据送入P0口，即将数据写入液晶模块
          _nop_();
          _nop_();
          _nop_();
     _nop_();       //空操作四个机器周期，给硬件反应时间
          E=1;          //E置高电平
          _nop_();
          _nop_();
          _nop_();
         _nop_();        //空操作四个机器周期，给硬件反应时间
         E=0;            //当E由高电平跳变成低电平时，液晶模块开始执行命令
}
/*****************************************************
函数功能：对LCD的显示模式进行初始化设置
***************************************************/
void LcdInitiate(void)
{
   delay(15);             //延时15ms，首次写指令时应给LCD一段较长的反应时间
   WriteInstruction(0x38);  //显示模式设置：16×2显示，5×7点阵，8位数据接口
        delay(5);   //延时5ms　
        WriteInstruction(0x38);
        delay(5);
        WriteInstruction(0x38);
        delay(5);
        WriteInstruction(0x0C);  //显示模式设置：显示开，有光标，光标闪烁
        delay(5);
        WriteInstruction(0x06);  //显示模式设置：光标右移，字符不移
        delay(5);
        WriteInstruction(0x01);  //清屏幕指令，将以前的显示内容清除
        delay(5);
}
/************************************************************
函数功能：对4个字节的用户码和键数据码进行解码
说明：解码正确，返回1，否则返回0
出口参数：dat
*************************************************************/
bit DeCode(void)        
{

   unsigned char  i,j;
        unsigned char temp;    //储存解码出的数据
        for(i=0;i<4;i++)      //连续读取4个用户码和键数据码
          {
                 for(j=0;j<8;j++)  //每个码有8位数字
                         {
                 temp=temp>>1;  //temp中的各数据位右移一位，因为先读出的是高位数据                                                                       
                           TH0=0;         //定时器清0
                           TL0=0;         //定时器清0
                           TR0=1;         //开启定时器T0
                      while(IR==0)   //如果是低电平就等待
                       ;              //低电平计时
                             TR0=0;         //关闭定时器T0
                           LowTime=TH0*256+TL0;    //保存低电平宽度
                           TH0=0;         //定时器清0
                           TL0=0;         //定时器清0
                           TR0=1;         //开启定时器T0
                           while(IR==1)   //如果是高电平就等待
                               ;                          
                           TR0=0;        //关闭定时器T0
                           HighTime=TH0*256+TL0;   //保存高电平宽度
                           if((LowTime<370)||(LowTime>640))
                                              return 0;        //如果低电平长度不在合理范围，则认为出错，停止解码                       
                           if((HighTime>420)&&(HighTime<620))   //如果高电平时间在560微秒左右，即计数560／1.085＝516次
                                   temp=temp&0x7f;       //(520-100=420, 520+100=620)，则该位是0
                           if((HighTime>1300)&&(HighTime<1800)) //如果高电平时间在1680微秒左右，即计数1680／1.085＝1548次
                                   temp=temp|0x80;       //(1550-250=1300,1550+250=1800),则该位是1
                     }                                     
           a=temp;        //将解码出的字节值储存在a                                                                                                                                                                         
    }                                                    
  if(a[2]=~a[3])  //验证键数据码和其反码是否相等,一般情况下不必验证用户码
         return 1;     //解码正确，返回1
}

/*------------------二进制码转换为压缩型BCD码,并显示---------------*/

void two_2_bcd(unsigned char date)
{

   unsigned char temp;
   temp=date;
   date&=0xf0;
   date>>=4;                    //右移四位得到高四位码
   date&=0x0f;                  //与0x0f想与确保高四位为0
   if(date<=0x09)
   {                 
     WriteData(0x30+date);            //lcd显示键值高四位
   }
   else
   {
     date=date-0x09;
         WriteData(0x40+date);
   }
   date=temp;
   date&=0x0f;
   if(date<=0x09)
   {
     WriteData(0x30+date);            //lcd显示低四位值
   }
   else
   {
     date=date-0x09;
         WriteData(0x40+date);
   }
   WriteData(0x48);                 //显示字符'H'
}
/************************************************************
函数功能：1602LCD显示
*************************************************************/
void Disp(void)
{  
    WriteAddress(0x40);  // 设置显示位置为第一行的第1个字
      two_2_bcd(a[0]);
          WriteData(0x20);
          two_2_bcd(a[1]);
                  WriteData(0x20);
          two_2_bcd(a[2]);
                   WriteData(0x20);
          two_2_bcd(a[3]);

}
/************************************************************
函数功能：主函数
*************************************************************/
void main()
{
           unsigned char i;       
        LcdInitiate();         //调用LCD初始化函数  
    delay(10);
                   WriteInstruction(0x01);//清显示：清屏幕指令
                WriteAddress(0x00);  // 设置显示位置为第一行的第1个字
                  i = 0;
                while(string != '\0')    //'\0'是数组结束标志
                        {                                                // 显示字符        WWW.RICHMCU.COM
                                WriteData(string);
                                i++;       
                        }
        EA=1;        //开启总中断
   EX0=1;       //开外中断0
   ET0=1;       //定时器T0中断允许
   IT0=1;       //外中断的下降沿触发  
        TMOD=0x01;   //使用定时器T0的模式1       
        TR0=0;       //定时器T0关闭
   while(1);   //等待红外信号产生的中断
         
}
/************************************************************
函数功能：红外线触发的外中断处理函数
*************************************************************/
void Int0(void) interrupt 0
  {
     EX0=0;      //关闭外中断0，不再接收二次红外信号的中断，只解码当前红外信号
          TH0=0;      //定时器T0的高8位清0
          TL0=0;      //定时器T0的低8位清0
          TR0=1;            //开启定时器T0         
          while(IR==0);          //如果是低电平就等待，给引导码低电平计时
          TR0=0;                //关闭定时器T0     
          LowTime=TH0*256+TL0;  //保存低电平时间
          TH0=0;      //定时器T0的高8位清0
          TL0=0;      //定时器T0的低8位清0
          TR0=1;            //开启定时器T0
          while(IR==1);  //如果是高电平就等待，给引导码高电平计时
          TR0=0;        //关闭定时器T0
          HighTime=TH0*256+TL0;        //保存引导码的高电平长度
     if((LowTime>7800)&&(LowTime<8800)&&(HighTime>3600)&&(HighTime<4700))
                 {
                    //如果是引导码,就开始解码,否则放弃,引导码的低电平计时
               //次数＝9000us/1.085=8294, 判断区间:8300－500＝7800，8300＋500＝8800.
              if(DeCode()==1) // 执行遥控解码功能
                 {
               
                  Disp();//调用1602LCD显示函数
                  beep();//蜂鸣器响一声 提示解码成功
                 }
                 }
          EX0=1;   //开启外中断EX0
  }

fgwan

只是我改的XS128程序，但是没有现象。求大神指点一二，小弟我将不胜感激涕零。
#include <hidef.h>      /* common defines and macros */
#include "derivative.h"      /* derivative-specific definitions */
#include "lcd.h"

#define IR PTIH_PTIH0
#define IR_dir DDRH_DDRH0
#define LEDCPU PORTK_PK4
#define LEDCPU_dir DDRK_DDRK4

#define  BUS_CLOCK                   32000000           //总线频率
#define  OSC_CLOCK                   16000000           //晶振频率

unsigned char flagR=0;
unsigned char chongdie=0;

unsigned char CDR1=0,CDR2=0,CDR3=0,CDR4=0,CDR5=0,CDR6=0,CDR7=0,CDR8=0,CDR9=0,CDR10=0;
unsigned char CDR11=0,CDR12=0,CDR13=0,CDR14=0,CDR15=0,CDR16=0,CDR17=0,CDR18=0,CDR19=0,CDR20=0;
unsigned char CDR21=0,CDR22=0,CDR23=0,CDR24=0,CDR25=0,CDR26=0,CDR27=0,CDR28=0,CDR29=0,CDR30=0;
unsigned char CDR31=0,CDR32=0,CDR33=0,CDR34=0,CDR35=0,CDR36=0,CDR37=0,CDR38=0,CDR39=0,CDR40=0;
unsigned char CDR41=0,CDR42=0,CDR43=0,CDR44=0,CDR45=0,CDR46=0,CDR47=0,CDR48=0,CDR49=0,CDR50=0;
unsigned char CDR51=0,CDR52=0,CDR53=0,CDR54=0,CDR55=0,CDR56=0,CDR57=0,CDR58=0,CDR59=0,CDR60=0;
unsigned char CDR61=0,CDR62=0,CDR63=0,CDR64=0,CDR65=0,CDR66=0,CDR67=0;

unsigned char TR1=0,TR2=0,TR3=0,TR4=0,TR5=0,TR6=0,TR7=0,TR8=0,TR9=0,TR10=0;
unsigned char TR11=0,TR12=0,TR13=0,TR14=0,TR15=0,TR16=0,TR17=0,TR18=0,TR19=0,TR20=0;
unsigned char TR21=0,TR22=0,TR23=0,TR24=0,TR25=0,TR26=0,TR27=0,TR28=0,TR29=0,TR30=0;
unsigned char TR31=0,TR32=0,TR33=0,TR34=0,TR35=0,TR36=0,TR37=0,TR38=0,TR39=0,TR40=0;
unsigned char TR41=0,TR42=0,TR43=0,TR44=0,TR45=0,TR46=0,TR47=0,TR48=0,TR49=0,TR50=0;
unsigned char TR51=0,TR52=0,TR53=0,TR54=0,TR55=0,TR56=0,TR57=0,TR58=0,TR59=0,TR60=0;
unsigned char TR61=0,TR62=0,TR63=0,TR64=0,TR65=0,TR66=0,TR67=0;

unsigned char t1,t2,t3,t4,t5,t6,t7,t8,t9,t10;
unsigned char t11,t12,t13,t14,t15,t16,t17,t18,t19,t20;
unsigned char t21,t22,t23,t24,t25,t26,t27,t28,t29,t30;
unsigned char t31,t32,t33,t34,t35,t36,t37,t38,t39,t40;
unsigned char t41,t42,t43,t44,t45,t46,t47,t48,t49,t50;
unsigned char t51,t52,t53,t54,t55,t56,t57,t58,t59,t60;
unsigned char t61,t62,t63,t64,t65,t66,t67,t68;

unsigned char A0,A1,A2,A3,A4,A5,A6,A7;
unsigned char B0,B1,B2,B3,B4,B5,B6,B7;
unsigned char C0,C1,C2,C3,C4,C5,C6,C7;
unsigned char D0,D1,D2,D3,D4,D5,D6,D7;

unsigned char a[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char b[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char c[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
unsigned char d[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
/*************************************************************/
/*                      初始化锁相环                         */
/*************************************************************/
void INIT_PLL(void)
{
    CLKSEL &= 0x7f;       //set OSCCLK as sysclk
    PLLCTL &= 0x8F;       //Disable PLL circuit
    CRGINT &= 0xDF;
   
    #if(BUS_CLOCK == 40000000)
      SYNR = 0x44;
    #elif(BUS_CLOCK == 32000000)
      SYNR = 0x43;     
    #elif(BUS_CLOCK == 24000000)
      SYNR = 0x42;
    #endif

    REFDV = 0x81;         //PLLCLK=2×OSCCLK×(SYNDIV+1)/(REFDIV+1)＝64MHz ,fbus=32M
    PLLCTL =PLLCTL|0x70;  //Enable PLL circuit
    asm NOP;
    asm NOP;
    while(!(CRGFLG&0x08)); //PLLCLK is Locked already
    CLKSEL |= 0x80;        //set PLLCLK as sysclk
}

/************************************************************/
/*                    初始化TIM模块                         */
/************************************************************/
void initialize_tim(void)
{
  /*TSCR1_TFFCA = 1;  // 定时器标志位快速清除
  TSCR1_TEN = 1;    // 定时器使能位. 1=允许定时器正常工作; 0=使主定时器不起作用(包括计数器)
  TIOS  = 0xfe;      //指定通道0为输入捕捉方式，其余通道为输出比较方式
  TCTL4 = 0x01;            // 设置通道0为捕捉上升沿方式
  TIE   = 0x01;     // 允许通道0定时中断
  TSCR2 = 0x07;            // 预分频系数pr2-pr0:111,时钟周期为1.6us, //128分频  定时器的计数器频率=625000HZ
  TFLG1 = 0xff;            // 清除各IC/OC中断标志位
  TFLG2 = 0xff;     // 清除自由定时器中断标志位
  */
  TSCR2 = 0x05;    //625000定时器溢出中断设置 允许定时器溢出中断，禁止计数器复位，总线时钟32分频
  TIOS  = 0xfe;    //T0用于输入捕捉
  TCTL4 = 0x03;    //05  01 都是上升沿捕捉   11任何边沿捕捉
  TIE   = 0x01;    //03允许输入捕捉中断申请
  TSCR1 = 0X80;    //使能TIM模块
}




  void sj(){
      t1=TR2+65535*(CDR2-CDR1)-TR1;
      t2=TR3+65535*(CDR3-CDR2)-TR2;
      t3=TR4+65535*(CDR4-CDR3)-TR3;
      t4=TR5+65535*(CDR5-CDR4)-TR4;
      t5=TR6+65535*(CDR6-CDR5)-TR5;
      t6=TR7+65535*(CDR7-CDR6)-TR6;
      t7=TR8+65535*(CDR8-CDR7)-TR7;
      t8=TR9+65535*(CDR9-CDR8)-TR8;
      t9=TR10+65535*(CDR10-CDR9)-TR9;
      t10=TR11+65535*(CDR11-CDR10)-TR10;
      t11=TR12+65535*(CDR12-CDR11)-TR11;
      t12=TR13+65535*(CDR13-CDR12)-TR12;
      t13=TR14+65535*(CDR14-CDR13)-TR13;
      t14=TR15+65535*(CDR15-CDR14)-TR14;
      t15=TR16+65535*(CDR16-CDR15)-TR15;
      t16=TR17+65535*(CDR17-CDR16)-TR16;
      t17=TR18+65535*(CDR18-CDR17)-TR17;
      t18=TR19+65535*(CDR19-CDR18)-TR18;
      t19=TR20+65535*(CDR20-CDR19)-TR19;
      t20=TR21+65535*(CDR21-CDR20)-TR20;
      t21=TR22+65535*(CDR22-CDR21)-TR21;
      t22=TR23+65535*(CDR23-CDR22)-TR22;
      t23=TR24+65535*(CDR24-CDR23)-TR23;
      t24=TR25+65535*(CDR25-CDR24)-TR24;
      t25=TR26+65535*(CDR26-CDR25)-TR25;
      t26=TR27+65535*(CDR27-CDR26)-TR26;
      t27=TR28+65535*(CDR28-CDR27)-TR27;
      t28=TR29+65535*(CDR29-CDR28)-TR28;
      t29=TR30+65535*(CDR30-CDR29)-TR29;
      t30=TR31+65535*(CDR31-CDR30)-TR30;
      t31=TR32+65535*(CDR32-CDR31)-TR31;
      t32=TR33+65535*(CDR33-CDR32)-TR32;
      t33=TR34+65535*(CDR34-CDR33)-TR33;
      t34=TR35+65535*(CDR35-CDR34)-TR34;
      t35=TR36+65535*(CDR36-CDR35)-TR35;
      t36=TR37+65535*(CDR37-CDR36)-TR36;
      t37=TR38+65535*(CDR38-CDR37)-TR37;
      t38=TR39+65535*(CDR39-CDR38)-TR38;
      t39=TR40+65535*(CDR40-CDR39)-TR39;
      t40=TR41+65535*(CDR41-CDR40)-TR40;
      t41=TR42+65535*(CDR42-CDR41)-TR41;
      t42=TR43+65535*(CDR43-CDR42)-TR42;
      t43=TR44+65535*(CDR44-CDR43)-TR43;
      t44=TR45+65535*(CDR45-CDR44)-TR44;
      t45=TR46+65535*(CDR46-CDR45)-TR45;
      t46=TR47+65535*(CDR47-CDR46)-TR46;
      t47=TR48+65535*(CDR48-CDR47)-TR47;
      t48=TR49+65535*(CDR49-CDR48)-TR48;
      t49=TR50+65535*(CDR50-CDR49)-TR49;
      t50=TR51+65535*(CDR51-CDR50)-TR50;
      t51=TR52+65535*(CDR52-CDR51)-TR51;
      t52=TR53+65535*(CDR53-CDR52)-TR52;
      t53=TR54+65535*(CDR54-CDR53)-TR53;
      t54=TR55+65535*(CDR55-CDR54)-TR54;
      t55=TR56+65535*(CDR56-CDR55)-TR55;
      t56=TR57+65535*(CDR57-CDR56)-TR56;
      t57=TR58+65535*(CDR58-CDR57)-TR57;
      t58=TR59+65535*(CDR59-CDR58)-TR58;
      t59=TR60+65535*(CDR60-CDR59)-TR59;
      t60=TR61+65535*(CDR61-CDR60)-TR60;
      t61=TR62+65535*(CDR62-CDR61)-TR61;
      t62=TR63+65535*(CDR63-CDR62)-TR62;
      t63=TR64+65535*(CDR64-CDR63)-TR63;
      t64=TR65+65535*(CDR65-CDR64)-TR64;
      t65=TR66+65535*(CDR66-CDR65)-TR65;
      t66=TR67+65535*(CDR67-CDR66)-TR66;
      
  }
  
  void dm(){
    if((t4>460)&&(t4<660)) {A0=0;} //该位是0
                if((t4>1500)&&(t4<1800)) {A0=1;} //该位是1
                if((t6>460)&&(t6<660)) {A1=0;} //该位是0
                if((t6>1500)&&(t6<1800)) {A1=1;} //该位是1                      
          if((t8>460)&&(t8<660)) {A2=0;} //该位是0
                if((t8>1500)&&(t8<1800)) {A2=1;} //该位是1
                if((t10>460)&&(t10<660)) {A3=0;} //该位是0
                if((t10>1500)&&(t10<1800)) {A3=1;} //该位是1
                if((t12>460)&&(t12<660)) {A4=0;} //该位是0
                if((t12>1500)&&(t12<1800)) {A4=1;} //该位是1
                if((t14>460)&&(t14<660)) {A5=0;} //该位是0
                if((t14>1500)&&(t14<1800)) {A5=1;} //该位是1                      
          if((t16>460)&&(t16<660)) {A6=0;} //该位是0
                if((t16>1500)&&(t16<1800)) {A6=1;} //该位是1
                if((t18>460)&&(t18<660)) {A7=0;} //该位是0
                if((t18>1500)&&(t18<1800)) {A7=1;} //该位是1
               
                if((t20>460)&&(t20<660)) {B0=0;} //该位是0
                if((t20>1500)&&(t20<1800)) {B0=1;} //该位是1
                if((t22>460)&&(t22<660)) {B1=0;} //该位是0
                if((t22>1500)&&(t22<1800)) {B1=1;} //该位是1                      
          if((t24>460)&&(t24<660)) {B2=0;} //该位是0
                if((t24>1500)&&(t24<1800)) {B2=1;} //该位是1
                if((t26>460)&&(t26<660)) {B3=0;} //该位是0
                if((t26>1500)&&(t26<1800)) {B3=1;} //该位是1
                if((t28>460)&&(t28<660)) {B4=0;} //该位是0
                if((t28>1500)&&(t28<1800)) {B4=1;} //该位是1
                if((t30>460)&&(t30<660)) {B5=0;} //该位是0
                if((t30>1500)&&(30<1800)) {B5=1;} //该位是1                      
          if((t32>460)&&(t32<660)) {B6=0;} //该位是0
                if((t32>1500)&&(t32<1800)) {B6=1;} //该位是1
                if((t34>460)&&(t34<660)) {B7=0;} //该位是0
                if((t34>1500)&&(t34<1800)) {B7=1;} //该位是1
               
                if((t36>460)&&(t36<660)) {C0=0;} //该位是0
                if((t36>1500)&&(t36<1800)) {C0=1;} //该位是1
                if((t38>460)&&(t38<660)) {C1=0;} //该位是0
                if((t38>1500)&&(t38<1800)) {C1=1;} //该位是1                      
          if((t40>460)&&(t40<660)) {C2=0;} //该位是0
                if((t40>1500)&&(t40<1800)) {C2=1;} //该位是1
                if((t42>460)&&(t42<660)) {C3=0;} //该位是0
                if((t42>1500)&&(t42<1800)) {C3=1;} //该位是1
                if((t44>460)&&(t44<660)) {C4=0;} //该位是0
                if((t44>1500)&&(t44<1800)) {C4=1;} //该位是1
                if((t46>460)&&(t46<660)) {C5=0;} //该位是0
                if((t46>1500)&&(t46<1800)) {C5=1;} //该位是1                      
          if((t48>460)&&(t48<660)) {C6=0;} //该位是0
                if((t48>1500)&&(t48<1800)) {C6=1;} //该位是1
                if((t50>460)&&(t50<660)) {C7=0;} //该位是0
                if((t50>1500)&&(t50<1800)) {C7=1;} //该位是1
               
                if((t52>460)&&(t52<660)) {D0=0;} //该位是0
                if((t52>1500)&&(t52<1800)) {D0=1;} //该位是1
                if((t54>460)&&(t54<660)) {D1=0;} //该位是0
                if((t54>1500)&&(t54<1800)) {D1=1;} //该位是1                      
          if((t56>460)&&(t56<660)) {D2=0;} //该位是0
                if((t56>1500)&&(t56<1800)) {D2=1;} //该位是1
                if((t58>460)&&(t58<660)) {D3=0;} //该位是0
                if((t58>1500)&&(t58<1800)) {D3=1;} //该位是1
                if((t60>460)&&(t60<660)) {D4=0;} //该位是0
                if((t60>1500)&&(t60<1800)) {D4=1;} //该位是1
                if((t62>460)&&(t62<660)) {D5=0;} //该位是0
                if((t62>1500)&&(t62<1800)) {D5=1;} //该位是1                      
          if((t64>460)&&(t64<660)) {D6=0;} //该位是0
                if((t64>1500)&&(t64<1800)) {D6=1;} //该位是1
                if((t68>460)&&(t68<660)) {D7=0;} //该位是0
                if((t68>1500)&&(t68<1800)) {D7=1;} //该位是1
  }
  
  void cl(){
     a[0]=(A0/1)+0x30;
     a[1]=(A1/1)+0x30;
     a[2]=(A2/1)+0x30;
     a[3]=(A3/1)+0x30;
     a[4]=(A4/1)+0x30;
     a[5]=(A5/1)+0x30;
     a[6]=(A6/1)+0x30;
     a[7]=(A7/1)+0x30;
     
     b[0]=(B0/1)+0x30;
     b[1]=(B1/1)+0x30;
     b[2]=(B2/1)+0x30;
     b[3]=(B3/1)+0x30;
     b[4]=(B4/1)+0x30;
     b[5]=(B5/1)+0x30;
     b[6]=(B6/1)+0x30;
     b[7]=(B7/1)+0x30;
     
     c[0]=(C0/1)+0x30;
     c[1]=(C1/1)+0x30;
     c[2]=(C2/1)+0x30;
     c[3]=(C3/1)+0x30;
     c[4]=(C4/1)+0x30;
     c[5]=(C5/1)+0x30;
     c[6]=(C6/1)+0x30;
     c[7]=(C7/1)+0x30;
     
     d[0]=(D0/1)+0x30;
     d[1]=(D1/1)+0x30;
     d[2]=(D2/1)+0x30;
     d[3]=(D3/1)+0x30;
     d[4]=(D4/1)+0x30;
     d[5]=(D5/1)+0x30;
     d[6]=(D6/1)+0x30;
     d[7]=(D7/1)+0x30;
  
  }
  
  void xs(){
    write_command(0x80);
     delay_1ms(2);
      write_Data(a[0]);
      write_Data(a[1]);
      write_Data(a[2]);
      write_Data(a[3]);
      write_Data(a[4]);
      write_Data(a[5]);
      write_Data(a[6]);
      write_Data(a[7]);
      
      write_command(0x90);
      delay_1ms(2);
      write_Data(b[0]);
      write_Data(b[1]);
      write_Data(b[2]);
      write_Data(b[3]);
      write_Data(b[4]);
      write_Data(b[5]);
      write_Data(b[6]);
      write_Data(b[7]);
      
      write_command(0x88);
      delay_1ms(2);
      write_Data(c[0]);
      write_Data(c[1]);
      write_Data(c[2]);
      write_Data(c[3]);
      write_Data(c[4]);
      write_Data(c[5]);
      write_Data(c[6]);
      write_Data(c[7]);

     write_command(0x98);
      delay_1ms(2);
      write_Data(d[0]);
      write_Data(d[1]);
      write_Data(d[2]);
      write_Data(d[3]);
      write_Data(d[4]);
      write_Data(d[5]);
      write_Data(d[6]);
      write_Data(d[7]);

  
  }
  
void hwjm(){
    sj();
  if((t1>8700)&&(t1<9300)&&(t2>4200)&&(t2<4800)){
       dm();
       cl();
       xs();
     }
  /*else{
    write_command(0x81);
    delay_1ms(2);
    Write_String("解码错误");
  } */
    flagR=0;
     
}



/*************************************************************/
/*                           主函数                          */
/*************************************************************/

void main(void) {
  LEDCPU_dir=1;
  LEDCPU=0;
  INIT_PLL();
  INIT_PORT();
  lcd_clear();
  delay_1ms(5);
  
  initialize_tim();
//write_command(0x81);
//delay_1ms(2);
//  Write_String("红外解码结果");
   
        EnableInterrupts;


while(1){

     hwjm();
   }

}

/*************************************************************/
/*                   输入捕捉中断函数                        */
/*              用于采集脉冲方式的车速信号                   */
/*************************************************************/
#pragma CODE_SEG __NEAR_SEG NON_BANKED
void interrupt 8 TC0_ISR(void)  //1-任何边沿中断
{
   TFLG1_C0F=1;//   清中断标志位
   TSCR2_TOI=1;  //允许定时器溢出中断
//  flag_R++;   //球通过右侧激光需要进两次中断记录次数
   flagR++;
   if(flagR>67) flagR=0;
//  if(flag_R>2) flag_R=1;
//  if(flag_R==1) {CD_R1=chongdie;T_R1=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
//  if(flag_R==2) {CD_R2=chongdie;T_R2=TC0;} //第二次经过 记录溢出次数2
   
   if(flagR==1) {CDR1=chongdie;TR1=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==2) {CDR2=chongdie;TR2=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==3) {CDR3=chongdie;TR3=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==4) {CDR4=chongdie;TR4=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==5) {CDR5=chongdie;TR5=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==6) {CDR6=chongdie;TR6=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==7) {CDR7=chongdie;TR7=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==8) {CDR8=chongdie;TR8=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==9) {CDR9=chongdie;TR9=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==10) {CDR10=chongdie;TR10=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==11) {CDR11=chongdie;TR11=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==12) {CDR12=chongdie;TR12=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==13) {CDR13=chongdie;TR13=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==14) {CDR14=chongdie;TR14=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==15) {CDR15=chongdie;TR15=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==16) {CDR16=chongdie;TR16=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==17) {CDR17=chongdie;TR17=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==18) {CDR18=chongdie;TR18=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==19) {CDR19=chongdie;TR19=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==20) {CDR20=chongdie;TR20=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==21) {CDR21=chongdie;TR21=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==22) {CDR22=chongdie;TR22=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==23) {CDR23=chongdie;TR23=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==24) {CDR24=chongdie;TR24=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==25) {CDR25=chongdie;TR25=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==26) {CDR26=chongdie;TR26=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==27) {CDR27=chongdie;TR27=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==28) {CDR28=chongdie;TR28=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==29) {CDR29=chongdie;TR29=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==30) {CDR30=chongdie;TR30=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==31) {CDR31=chongdie;TR31=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==32) {CDR32=chongdie;TR32=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==33) {CDR33=chongdie;TR33=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==34) {CDR34=chongdie;TR34=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==35) {CDR35=chongdie;TR35=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==36) {CDR36=chongdie;TR36=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==37) {CDR37=chongdie;TR37=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==38) {CDR38=chongdie;TR38=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==39) {CDR39=chongdie;TR39=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==40) {CDR40=chongdie;TR40=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==41) {CDR41=chongdie;TR41=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==42) {CDR42=chongdie;TR42=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==43) {CDR43=chongdie;TR43=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==44) {CDR44=chongdie;TR44=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==45) {CDR45=chongdie;TR45=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==46) {CDR46=chongdie;TR46=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==47) {CDR47=chongdie;TR47=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==48) {CDR48=chongdie;TR48=TC0;} //第二次经过 记录溢出次数2
   if(flagR==49) {CDR49=chongdie;TR49=TC0;} //第二次经过 记录溢出次数2
   if(flagR==50) {CDR50=chongdie;TR50=TC0;} //第二次经过 记录溢出次数2
   if(flagR==51) {CDR51=chongdie;TR51=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==52) {CDR52=chongdie;TR52=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==53) {CDR53=chongdie;TR53=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==54) {CDR54=chongdie;TR54=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==55) {CDR55=chongdie;TR55=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==56) {CDR56=chongdie;TR56=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==57) {CDR57=chongdie;TR57=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==58) {CDR58=chongdie;TR58=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==59) {CDR59=chongdie;TR59=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==60) {CDR60=chongdie;TR60=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==61) {CDR61=chongdie;TR61=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==62) {CDR62=chongdie;TR62=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==63) {CDR63=chongdie;TR63=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==64) {CDR64=chongdie;TR64=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==65) {CDR65=chongdie;TR65=TC0;}//第一次经过 记录溢出次数1，以及TC0的值
   if(flagR==66) {CDR66=chongdie;TR66=TC0;} //第二次经过 记录溢出次数2  
   if(flagR==67) {CDR67=chongdie;TR67=TC0;} //第二次经过 记录溢出次数2
   
}

void interrupt 16 TIME_over(void)  //主定时器溢出中断
{
   TFLG2_TOF=1;//   清中断标志位
   chongdie++;
}

#pragma CODE_SEG  DEFAULT