zj.c

我设计的CAN总线模块

    fs_x(ascii[b]);

    fs_x('\r');

    goto wancheng;
   }
//**********************************************
 if(char_Comparison(uart_data,"id=")==0)
   {
    unsigned int a;
    unsigned char b;
    b=toint(uart_data[3]);
    a=b; a=a<<4;
    b=toint(uart_data[4]);
    a=a+b; a=a<<4;
    b=toint(uart_data[5]);
    a=a+b; a=a<<4;
    b=toint(uart_data[6]);
    a=a+b;

    if(a<0x7ff)
      {
       id=a;
       fs_char((sizeof("ok\r")),"ok\r");
       b=(unsigned char)(a>>8);
       write(1,b);
       b=(unsigned char)(a&0x00ff);
       jq_ys(5);
       write(2,b);
       goto wancheng;
      }
   }
//**********************************************
error:
fs_char((sizeof("error(1)\r")),"error(1)\r");
wancheng:
 {
 unsigned char i;
 for(i=0;i<sizeof(uart_data);i++)   { uart_data[i]=0;  }
 }
 uart_data_i=0;
 uart_data_w_Complete=0;
}
//***********************************************************************
eeprom_can(unsigned char a,unsigned  char xdata *b)
{
 struct {
  unsigned int  id;
  unsigned char sj[8];
  }ls;
//数据结构装入数局
 ls.id=(id<<5)|0x0008;

 ls.sj[0]=a;
 ls.sj[1]=*b; b=b+1;
 ls.sj[2]=*b; b=b+1;
 ls.sj[3]=*b; b=b+1;
 ls.sj[4]=*b;
 ls.sj[5]=0;
 ls.sj[6]=0;
 ls.sj[7]=1;
//向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");                      }
}
//***********************************************************************
uart_bit()
{
 unsigned char a;
 a=read(0);
 switch (a)
        {       //300波特
         case 0:  {  fs_char((sizeof("bit=300\r")),"bit=300\r");
                     TR1=0;  TH1=TL1=0X040;  PCON=0X00;  TR1=1;    }
         break;
                //1200波特
         case 1:  {  fs_char((sizeof("bit=1200\r")),"bit=1200\r");
                     TR1=0;  TH1=TL1=0X0d0;  PCON=0X00;  TR1=1;    }
         break;
                //2400波特
         case 2:  {  fs_char((sizeof("bit=2400\r")),"bit=2400\r");
                     TR1=0;  TH1=TL1=0X0e8;  PCON=0X00;  TR1=1;    }
         break;
                //4800波特
         case 3:  {  fs_char((sizeof("bit=4800\r")),"bit=4800\r");
                     TR1=0;  TH1=TL1=0X0f4;  PCON=0X00;  TR1=1;    }
         break;
                //9600波特
         case 4:  {  fs_char((sizeof("bit=9600\r")),"bit=9600\r");
                     TR1=0;  TH1=TL1=0X0fa;  PCON=0X00;  TR1=1;    }
         break;
                //19200波特
         case 5:  {  fs_char((sizeof("bit=19200\r")),"bit=19200\r");
                     TR1=0;  TH1=TL1=0X0fd;  PCON=0X00;  TR1=1;    }
         break;
                //38400波特
         case 6:  {  fs_char((sizeof("bit=38400\r")),"bit=38400\r");
                     TR1=0;  TH1=TL1=0X0fd;  PCON=0X80;  TR1=1;    }
         break;
                //57600波特
         case 7:  {  fs_char((sizeof("bit=57600\r")),"bit=57600\r");
                     TR1=0;  TH1=TL1=0X0fe;  PCON=0X80;  TR1=1;    }
         break;
                //115200波特
         case 8:  {  fs_char((sizeof("bit=115200\r")),"bit=115200\r");
                     TR1=0;  TH1=TL1=0X0ff;  PCON=0X80;  TR1=1;    }
         break;

         default: {  fs_char((sizeof("chushihua_bit=19200\r")),"chushihua_bit=19200\r");
                                                      }

        }




}
//***********************************************************************
bit char_Comparison(unsigned char *a,unsigned char const *b)
{
 while(*b!=0)
      {
       if(*a!=*b) return(1);
       a=a+1; b=b+1;
      }
 return(0);
}
//***********************************************************************
error_chuli()
{
 const unsigned char ascii[]={"0123456789abcdef"};
 if(can_exit_Appearance==1)
   {
    fs_char((sizeof("error(4) can exit\r")),"error(4) can exit\r");
    can_exit_Appearance=0;
   }
 if(can_error_Appearance==1)
   {
    can_error_Appearance=0;
    //输出ERRC
    fs_char((sizeof("error(4) can errc=")),"error(4) can errc=");
    fs_x(ascii[(can_error_ecc&0x80)>>7]);
    fs_x(ascii[(can_error_ecc&0x40)>>6]);
    //输出DIR
    fs_char((sizeof(" dir="))," dir=");
    fs_x(ascii[(can_error_ecc&0x20)>>5]);
    //输出SEG
    fs_char((sizeof(" seg="))," seg=");
    fs_x(ascii[(can_error_ecc&0x10)>>4]);
    fs_x(ascii[(can_error_ecc&0x08)>>3]);
    fs_x(ascii[(can_error_ecc&0x04)>>2]);
    fs_x(ascii[(can_error_ecc&0x02)>>1]);
    fs_x(ascii[can_error_ecc&0x01]);
    fs_x(' ');
    //输出txerr
    fs_char((sizeof(" txerr="))," txerr=");
    fs_x(ascii[(can_error_txerr&0xf0)>>4]);
    fs_x(ascii[can_error_txerr&0x0f]);
    fs_x(' ');
    //输出rxerr
    fs_char((sizeof(" rxerr="))," rxerr=");
    fs_x(ascii[(can_error_rxerr&0xf0)>>4]);
    fs_x(ascii[can_error_rxerr&0x0f]);
    fs_x(' ');
    //输出es
    fs_char((sizeof("es=")),"es=");
    fs_x(ascii[(unsigned char )can_error_es]);
    fs_x('\r');
   }
}
//***********************************************************************
//***********************************************************************
//********************************中断***********************************
//***********************************************************************
//***********************************************************************
can_int1() interrupt 2
{
 unsigned char a,b;
 unsigned char xdata *j;

 j=ir; a=(*j);


 //检测是否为错误中断
 if(((a&0xa4)!=0))
   {
    CW=!CW;
    //检测是否为总线脱离
    j=sr; b=(*j);
    if((b&0x80)==0x80)
      {
       j=mod; *j=0x00;
       jq_ys(1000);
       can_error=1;
       can_exit_Appearance=1;
       return;
      }
    //一般错误处理 更新错误计数器与错误标志
    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;
   }


 //检测是否为发送中断
 if((a&0x02)==0x02)   can_ti=1;


 //检测是否为接收中断
 if((a&0x01)==0x01)
   {
    unsigned int ee;
    unsigned char trr;
    ee=can_w_data+1;
    if(ee>=700) ee=0;
    j=sffdlc; trr=*j;
    trr=trr&0xc0;
    if(!(trr!=0))
      {
       if(can_r_data!=ee)
         {
          j=sffid1; can_data[can_w_data][0]=(*j);
          j=sffid2; can_data[can_w_data][1]=(*j);
          j=sffdlc; trr=*j;
          can_data[can_w_data][1]=(can_data[can_w_data][1]&0xe0)|(trr&0x0f);
          j=sffsj1; can_data[can_w_data][2]=(*j);
          j=sffsj2; can_data[can_w_data][3]=(*j);
          j=sffsj3; can_data[can_w_data][4]=(*j);
          j=sffsj4; can_data[can_w_data][5]=(*j);
          j=sffsj5; can_data[can_w_data][6]=(*j);
          j=sffsj6; can_data[can_w_data][7]=(*j);
          j=sffsj7; can_data[can_w_data][8]=(*j);
          j=sffsj8; can_data[can_w_data][9]=(*j);
          can_w_data=can_w_data+1;
          if(can_w_data>=700) can_w_data=0;
         }
       else  { can_Full=1;  }
      }
    j=cmr; *j=0x0c;           //释放缓冲区
   }
}
//***********************************************************************
uart_int() interrupt 4
{
#define BS  0x08
 char i;
 if(TI==1)  {TI=0;}
 if(RI==1)
    {
     RI=0;
     if(uart_data_w_Complete==1) return;

     if(uart_data_i>50)   //判断接收数据指针是否益处
       {
        uart_data_i=0;
        for(i=0;i<sizeof(uart_data);i++)   { uart_data[i]=0;  }
        return;
       }

     if(SBUF==BS)         //判断是否为退格字符
       {
        if(uart_data_i!=0)
          {
           uart_data_i=uart_data_i-1;
           uart_data[uart_data_i]=0;
          }
        return;
       }
     uart_data[uart_data_i]=SBUF;
     uart_data_i=uart_data_i+1;
     if(SBUF=='\r')
     { uart_data_w_Complete=1; }
    }
}
//***********************************************************************













//***********************************************************************
#define ENDRDSLA 0XC0
#define ENDWRSLA 0XA0
#define WRSLA    0X60
#define RDSLA    0XA8
#define DATA_WRSLA 0X80
#define DATA_RDSLA 0X0B8
bit WRSLA_BIT=0;
bit RDSLA_BIT=0;
unsigned char POINT=0;

i2c_int() interrupt 5
{
        if(S1STA==WRSLA)              //器件收到自己的地址60
              {
               WRSLA_BIT=1;
               S1CON=0XC5;
               return;
              }
        if(S1STA==DATA_WRSLA)         //器件收到写地址
              {
               if(WRSLA_BIT==1)
                   {
                    WRSLA_BIT=0;
                    S1CON=0XC5;
                    POINT=S1DAT;
                   }                  //器件收到写数据
               else
                   {     unsigned char idata a;
                    S1CON=0XC5;
                    EEPROM[POINT]=S1DAT;
                    a=POINT;
                    bb[a>>3]=bb[a>>3]|(er[a&0x07]);
                    POINT=POINT+1;
                    //if(POINT>0x3f) POINT=0;
                   }
               return;
              }
        if(S1STA==ENDWRSLA)           //器件收到写结束信号
              {
               S1CON=0XC5;
               return;
              }



        if(S1STA==RDSLA)
              {
               S1DAT=EEPROM[POINT];
               if(POINT==0)
                 {
                  EEPROM[POINT]=0;
                  INT_W=1;
                 }
               S1CON=0XC5;
               POINT=POINT+1;
               if(POINT>0x3f)POINT=0;
               return;
              }
        if(S1STA==DATA_RDSLA)
              {
               S1DAT=EEPROM[POINT];
               if(POINT==0)
                 {
                  EEPROM[POINT]=0;
                  INT_W=1;
                 }
               S1CON=0XC5;
               POINT=POINT+1;
               //if(POINT>0x3f)POINT=0;
               return;
              }
        if(S1STA==ENDRDSLA)
              {
               S1CON=0XC5;
               return;
              }
        S1CON=0XC5;
}
/******************************************************/