XS128的红外解码问题·

fgwan · 发表于 2016-11-30 19:26:26

如何将以下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 · 发表于 2016-11-30 19:29:22

只是我改的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

		自动登录	找回密码
密码			注册