zj.c

我设计的CAN总线模块

#include<89c51.h>
#include<89c668.h>
#include<zj.h>
#include<IIII.h>
#include<ctype.h>
#include<intrins.h>
#include<24c04.h>
//***********************************************************************
jq_ys(unsigned int i);
chishihua();
dog_clr();
fs_x(unsigned char x);
fs_char(unsigned int a,unsigned char const *b);
bit canx_out(unsigned char *j);
can_chuli();
uart_chuli();
eeprom_can(unsigned char a,unsigned  char xdata *b);
uart_bit();
bit char_Comparison(unsigned char *a,unsigned char const *b);
error_chuli();
unsigned char read(unsigned int address);
void write(unsigned int address,unsigned char dd);
//***********************************************************************
//***********************************************************************
//***********************************************************************
//***********************************************************************
//***********************************************************************
main()
{
 chishihua();
 uart_bit();
  fs_char((sizeof("\rokok\r")),"\rokok\r");

{ unsigned int iuiu;
  for(iuiu=0;iuiu<=255;iuiu++)
     {
      EEPROM[iuiu]=0;
     }
 }



 while(1){

 //判断数据是否溢出
 if(can_Full==1)
   {
    fs_char((sizeof("error(3)\r")),"error(3)\r");
    can_Full=0;
   }
 dog_clr();
 //判断CANX接收缓冲区是否有等待处理的数据
 if(can_w_data!=can_r_data)  {can_chuli(); }
 dog_clr();
 //判断串口接收数据是否完成
 if(uart_data_w_Complete==1) {uart_chuli(); uart_data_w_Complete=0;}
 dog_clr();
 //判断错误状态是否改变
 if(can_error==1)          {error_chuli(); can_error=0;}

 //EEPROM数据是否更新
 if((bb[1]&0x0f)==0x0f) { eeprom_can(1,&EEPROM[0X08]); bb[1]=bb[1]&0xf0; }
 if((bb[1]&0xf0)==0xf0) { eeprom_can(2,&EEPROM[0X0c]); bb[1]=bb[1]&0x0f; }
 if((bb[2]&0x0f)==0x0f) { eeprom_can(3,&EEPROM[0X10]); bb[2]=bb[2]&0xf0; }
 if((bb[2]&0xf0)==0xf0) { eeprom_can(4,&EEPROM[0X14]); bb[2]=bb[2]&0x0f; }
 if((bb[3]&0x0f)==0x0f) { eeprom_can(5,&EEPROM[0X18]); bb[3]=bb[3]&0xf0; }
 if((bb[3]&0xf0)==0xf0) { eeprom_can(6,&EEPROM[0X1c]); bb[3]=bb[3]&0x0f; }
 if((bb[4]&0x0f)==0x0f) { eeprom_can(7,&EEPROM[0X20]); bb[4]=bb[4]&0xf0; }

}}
//***********************************************************************
//****************[  1ms ys   ]********************
 jq_ys(unsigned int i)               /***循环延时函数，延时基数为 1MS ***/
 {
  unsigned int a;
  while(i>=1)
       {
        i=i-1;
        a=68;
        while (a>=1)
              {
               a=a-1;
              }
       }
 }
//***********************************************************************
chishihua()
{
 P0=0XFF;
 P1=0XFF;
 P2=0XFF;
 P3=0XFF;
 //看门狗
 CCAPM4=0X4C;
 CCAP4L=0XFF;
 CCAP4H=0XFF;
 CMOD=0X44;
 CCON=0X40;
 //12c
 S1ADR=0XA0;
 S1CON=0X0c5;
 //串口初始化
 TMOD=0X22;     //定时器0用于看门狗
 TH0=TL0=0X090;
 TCON=0x00;
 TH1=TL1=0X0FD;
 SCON=0X50;
 TR1=1;
 TR0=1;         //定时器0用于看门狗
 ES=1;
 ES1=1;
 EX1=1;
 PS1=1;
 //设置内部RAM使用，当超过4K范围时读外部地址数据。
 AUXR=0;
 //SJA1000初始化
 {
 unsigned char xdata *j;
 RST=0;                 //设置CAN0
 jq_ys(100);
 RST=1;
 j=cdr;  *j=0x80;
 j=mod;  *j=0x01;        //复位.  错误、发送、接收中断准许。
 j=ier;  *j=0xa7;        //总线错误\错误消极\数据溢出\错误报警\发送\接收,中断准许
 j=amr0; *j=0xff;        //接收屏蔽0
 j=amr1; *j=0xff;        //接收屏蔽1
 j=amr2; *j=0xff;        //接收屏蔽2
 j=amr3; *j=0xff;        //接收屏蔽3
 j=btr0; *j=0x7f;        //总线时序0
 j=btr1; *j=0x7f;        //总线时序1
 j=ocr;  *j=0x0aa;       //输出控制寄存器
 j=mod;  *j=0x00;        //进入工作模式
 j=cmr; *j=0x0c;
 }
 //can-id
 id=read(1);
 id=id<<8;
 id=id+read(2);
 if(id>0x07ff) id=2;
 //****************
 EA=1;        //开放中断
}
//***************************发送字符***********************************
dog_clr()
{
 CH=CL=0;
}
//***************************发送字符***********************************
fs_x(unsigned char x)
{
 EA=0;
 TI=0;
 SBUF=x;
 while(TI==0);
 TI=0;
 EA=1;
}
//***************************发送字符串*********************************
fs_char(unsigned int a,unsigned char const *b)
{
 unsigned int i;
 if(a>0) a=a-1;
 for(i=0;i<a;i++)
    {
     fs_x(*b);
     b++;
    }
}
//***********************************************************************
bit canx_out(unsigned char *j)
{
 unsigned char xdata *p;
 unsigned char a;
 unsigned long i;
 p=cmr; *p=0x02;              //取消发送
 p=sffdlc; *p=(*(j+1))&0x0f;
 p=sffid1; *p=*j; j=j+1;
 p=sffid2; *p=(*j)&0xe0; j=j+1;
 p=sffsj1; *p=*j; j=j+1;
 p=sffsj2; *p=*j; j=j+1;
 p=sffsj3; *p=*j; j=j+1;
 p=sffsj4; *p=*j; j=j+1;
 p=sffsj5; *p=*j; j=j+1;
 p=sffsj6; *p=*j; j=j+1;
 p=sffsj7; *p=*j; j=j+1;
 p=sffsj8; *p=*j; j=j+1;
 can_ti=0;
 p=cmr; *p=0x01;              //开始发送

 for(i=0;i<0x002fff;i++)
    {
     if(can_ti==1)  {  can_ti=0;  FS=!FS; return(0); }
    }
 return (1);
}
//***********************************************************************
can_chuli()
{
 JS=!JS;
 { //串口数据处理
 unsigned char a;
 fs_char((sizeof("can-in")),"can-in");  //发送“CAN-IN”
 fs_char((sizeof(" id=0"))," id=0");  //发送“X id=0”
 a=can_data[can_r_data][0];  a=a>>1;
 fs_x(ascii[a>>4]);                             //发送id“X”
 fs_x(ascii[a&0x0f]);                           //发送id“X”
 a=can_data[can_r_data][1];  a=a>>5; a=a&0x07;
 if(((can_data[can_r_data][0])&0x01)!=0) a=a+8;
 fs_x(ascii[a&0x0f]);                           //发送id“X”
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][2])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][2])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][3])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][3])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][4])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][4])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][5])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][5])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][6])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][6])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][7])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][7])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][8])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][8])&0x0f]);
 fs_x(' ');                                     //发送“ ”
 fs_x(ascii[(can_data[can_r_data][9])>>4]);     //发送第1个数据
 fs_x(ascii[(can_data[can_r_data][9])&0x0f]);
 fs_x('\r');
 }
 //i2c处理
      {
       unsigned int eee=0,uuu=0;
       eee=can_data[can_r_data][0];
       eee=eee<<8;
       eee=eee+can_data[can_r_data][1];
       eee=eee>>5;
       uuu=can_data[can_r_data][8];
       uuu=uuu<<8;
       uuu=uuu+can_data[can_r_data][9];


       if(   (eee==1)&& ((uuu==id)||(uuu==0))  &&  (can_data[can_r_data][2]<8)  &&  (can_data[can_r_data][2]>0)  )
         {
          unsigned char ttt=0;
          ttt=can_data[can_r_data][2];
          ttt=ttt-1;
          EEPROM[0]=EEPROM[0]|(er[ttt]);
          ttt=ttt*4; ttt=ttt+0x24;
          EEPROM[ttt]=can_data[can_r_data][3];   ttt=ttt+1;
          EEPROM[ttt]=can_data[can_r_data][4];   ttt=ttt+1;
          EEPROM[ttt]=can_data[can_r_data][5];   ttt=ttt+1;
          EEPROM[ttt]=can_data[can_r_data][6];
          INT_W=0;
         }
      }
 //接收计数器加一
 can_data[can_r_data][0]=0;
 can_data[can_r_data][1]=0;
 can_data[can_r_data][2]=0;
 can_data[can_r_data][3]=0;
 can_data[can_r_data][4]=0;
 can_data[can_r_data][5]=0;
 can_data[can_r_data][6]=0;
 can_data[can_r_data][7]=0;
 can_data[can_r_data][8]=0;
 can_data[can_r_data][9]=0;

 can_r_data=can_r_data+1;
 if(can_r_data>=700) can_r_data=0;
}
//***********************************************************************
uart_chuli()
{
 if(char_Comparison(uart_data,"can-out")==0)
   {
    unsigned char g;
    bit t=1;
    for(g=7;g<31;g++)
       {
        if(!(( isxdigit(uart_data[g])==1)||(uart_data[g]==' '))) goto ret;
       }
    if(uart_data[31]!='\r')                                   goto ret;
    t=0;
   ret:
    if(t==1)
      {
       fs_char((sizeof("error(1)\r")),"error(1)\r");
      }
    else
      {
       struct {
       unsigned int  id;
       unsigned char sj[8];
       }ls;
       //数据结构装入数局
       ls.id=(id<<5)|0x0008;
       ls.sj[0]=toint(uart_data[ 8]);  ls.sj[0]=ls.sj[0]<<4;  ls.sj[0]=ls.sj[0]+toint(uart_data[ 9]);
       ls.sj[1]=toint(uart_data[11]);  ls.sj[1]=ls.sj[1]<<4;  ls.sj[1]=ls.sj[1]+toint(uart_data[12]);
       ls.sj[2]=toint(uart_data[14]);  ls.sj[2]=ls.sj[2]<<4;  ls.sj[2]=ls.sj[2]+toint(uart_data[15]);
       ls.sj[3]=toint(uart_data[17]);  ls.sj[3]=ls.sj[3]<<4;  ls.sj[3]=ls.sj[3]+toint(uart_data[18]);
       ls.sj[4]=toint(uart_data[20]);  ls.sj[4]=ls.sj[4]<<4;  ls.sj[4]=ls.sj[4]+toint(uart_data[21]);
       ls.sj[5]=toint(uart_data[23]);  ls.sj[5]=ls.sj[5]<<4;  ls.sj[5]=ls.sj[5]+toint(uart_data[24]);
       ls.sj[6]=toint(uart_data[26]);  ls.sj[6]=ls.sj[6]<<4;  ls.sj[6]=ls.sj[6]+toint(uart_data[27]);
       ls.sj[7]=toint(uart_data[29]);  ls.sj[7]=ls.sj[7]<<4;  ls.sj[7]=ls.sj[7]+toint(uart_data[30]);

       //向CANX发送数据
       if(canx_out((unsigned char *)&ls)==1)
            { fs_char((sizeof("error(2) can\r")),"error(2) can\r");  }
       else { fs_char((sizeof("ok\r")),"ok\r");                      }

      }
    goto wancheng;
   }   //canx-out 命令处理完毕


//**********************************************
 if(char_Comparison(uart_data,"bit=")==0)
   {char a;
    a=toint(uart_data[4]);
    if(a>8) goto error;
    fs_char((sizeof("ok\r")),"ok\r");
    write(0,a);
    jq_ys(5);
    uart_bit();
    goto wancheng;
   }

//**********************************************
 if(char_Comparison(uart_data,"dir")==0)
   { const unsigned char ascii[]={"0123456789abcdef"};
    unsigned int i;
    for(i=0;i<=255;i++)
       {
        if((i%16)==0) fs_x('\r');
        fs_x(ascii[(EEPROM[(i)])>>4]);   fs_x(ascii[(EEPROM[(i)])&0x0f]);    fs_x(' ');
       }
    fs_x('\r');
    goto wancheng;
   }
//**********************************************
 if(char_Comparison(uart_data,"?")==0)
   {unsigned char b;
    unsigned char xdata *j;
    //一般错误处理 更新错误计数器与错误标志
    j=sr; b=(*j);
    can_error=1;  can_error_Appearance=1;
    j=ecc;   can_error_ecc=*j;
    j=rxerr; can_error_rxerr=*j;
    j=txerr; can_error_txerr=*j;
    if((b&0x40)!=0)  can_error_es=1;   else can_error_es=0;
    goto wancheng;
   }
//**********************************************
 if(char_Comparison(uart_data,"id=?")==0)
   {
    unsigned int a;
    unsigned char b;
    fs_char((sizeof("id=")),"id=");
    a=id;
    b=(unsigned char)(a>>12);   b=b&0x0f;
    fs_x(ascii[b]);
    b=(unsigned char)(a>>8);    b=b&0x0f;
    fs_x(ascii[b]);
    b=(unsigned char)(a>>4);    b=b&0x0f;
    fs_x(ascii[b]);
    b=(unsigned char)a;         b=b&0x0f;