原创转一mega16控制sja1000的程序

 2011-10-27 15:44  1948 3 3 分类: 汽车电子

CAN总线3个节点__程序 mega16 can

2009年12月17日星期四 21:30

先说明下，这个程序只是简单实现mega16+sja1000 和51+sja1000的数据通信，并没有约定数据的具体含义。具体数据待用到的时候再去定义。

Mega的程序：

参考的这篇文章http://www.ourdev.cn/bbs/bbs_content.jsp?bbs_sn=762558&bbs_page_no=3&bbs_id

主程序can.c

#include <iom16v.h>
#include <macros.h>
#include "can.h"

uchar       RX_buffer[13]; //接收的数据
uchar       TX_buffer[13]; //接收的数据
uchar    AMR[4],ACR[4];

// 现在可以读写SJA1000了。
   //配置SJA1000需要使SJA1000进入复位模式，然后对一些寄存器写入数据。在这里，CAN使用Pelican模式，速率为10K，单滤波工作，
   //*************************CAN复位初始化********************//
void CAN_Init(void)
{
   //uchar i_temp=0,j_temp=0;
   uchar temp;
   CLI();
   //Read_SJA1000(CAN_IR);             //读中断寄存器，清除中断位

   //保证进入复位模式,bit0.0不为1，再写CAN_MOD
   do
   {
    Write_SJA1000(CAN_MOD,0x09);
   temp=Read_SJA1000(CAN_MOD);
   //dog();
   }while(!(temp&0x01));

   Write_SJA1000(CAN_CDR,0x88);    //时钟分频寄存器-设置PeliCAN 模式，Clock off 无效
   Write_SJA1000(CAN_BTR0,0x31);   //配置总线定时--10kbps
   Write_SJA1000(CAN_BTR1,0x1c);
   Write_SJA1000(CAN_IER,0x01);   //中断使能寄存器-接收中断使能
   Write_SJA1000(CAN_OCR,0xaa);    //配置输出控制
   Write_SJA1000(CAN_CMR,0x04);   //命令寄存器-释放RXFIF0

   Write_SJA1000(CAN_AMR0,AMR[0]);   //配置验收屏蔽AMR0=0FFH
   Write_SJA1000(CAN_AMR1,AMR[1]);   //配置验收屏蔽AMR1=000H
   Write_SJA1000(CAN_AMR2,AMR[2]);   //配置验收屏蔽AMR2=0FFH
   Write_SJA1000(CAN_AMR3,AMR[3]);   //配置验收屏蔽AMR3=000H

   Write_SJA1000(CAN_ACR0,ACR[0]);   //配置验收代码ACR1=0:广播
   Write_SJA1000(CAN_ACR1,ACR[1]);
   Write_SJA1000(CAN_ACR2,ACR[2]);
   Write_SJA1000(CAN_ACR3,ACR[3]);   //配置验收代码ACR3=地址
   //Write_SJA1000(CAN_EWLR,0xff);   //配置错误报警限制为255
   //##################################################################
   do
   {
   Write_SJA1000(CAN_MOD,0x08); //进入工作模式dan滤波
   temp=Read_SJA1000(CAN_MOD);
   //dog();
   }while(temp&0x01);     // 确认复位标志是否被删除
    //##################################################################
   //do
   //{
   //Write_SJA1000(CAN_MOD,0x0c); //进入自接受模式
   //dog();
   //}while((Read_SJA1000(CAN_MOD))&0x04);
   //Write_SJA1000(CAN_TXB+4,ID3); //配置发送缓冲区的ID3-
   //Write_SJA1000(CAN_IER,0x07);   //配置SJA10000中断-错误报警/发送/接收中断
   SEI();
}

//CAN 发送函数
void CAN_TXD(void)
{
uchar temp,i;
do
{
   temp=Read_SJA1000(CAN_SR); //判断报文接收完毕？
} while(temp&0x10); //SR.4=0 发送闲置，SR.4=1 发送状态中

do
{
   temp=Read_SJA1000(CAN_SR); //判断最后报文请求？
}while(!(temp&0x08)); //SR.3=0 没有余报文请求，SR.3=1 还存在报文请求

do
{
   temp=Read_SJA1000(CAN_SR); //判断TXFIFO 是否锁定？
}while(!(temp&0x04)); //SR.2=0 锁定，SR.2=1 开放

for(i=0;i<13;i++)
Write_SJA1000(CAN_TXB+i,TX_buffer);

Write_SJA1000(CAN_CMR,0x01); //命令寄存器-发送请求

while((temp=Read_SJA1000(CAN_SR))&0x08==0);//等待发送完毕
}

#pragma interrupt_handler can_rx:3     //外部INT1中断
void can_rx(void)
{
uchar i,temp;
CLI();
asm("nop");
temp=Read_SJA1000(CAN_IR); //读取中断寄存器
if(temp&0x01)   //接收中断
   {
    for(i=0;i<13;i++)
    RX_buffer=Read_SJA1000(CAN_RXB+i);
   Write_SJA1000(CAN_CMR,0x04);

        Read_SJA1000(CAN_ALC);//释放仲裁随时捕捉寄存器
        Read_SJA1000(CAN_ECC);//释放错误代码捕捉寄存器
    }
    //IER = 0x01;// .0=1--接收中断使能；
    //EA = 1;//打开CPU中断
SEI();


}
void delay(uchar t)
{
uchar i,j;
for(i=0;i<t;i++)
   for(j=0;j<100;j++);
}

//变量初始化 #############################################
void Init_Data(void)
{
int i;
ACR[0]='C'; //本节点地址为CAN1
ACR[1]='A';
ACR[2]='N';
ACR[3]='1';

AMR[0]=0xff;//全部标示符屏蔽
AMR[1]=0xff; //接受全部节点的数据
AMR[2]=0xff;
AMR[3]=0xff;
TX_buffer[0]=0x88; //EFF 格式，数据长度8 的TX 帧信息
TX_buffer[1]='C'; //目的标示符为CAN2
TX_buffer[2]='A';
TX_buffer[3]='N';
TX_buffer[4]='1';
TX_buffer[5]=0x00; //发送数据
TX_buffer[6]=0x00;
TX_buffer[7]=0x00;
TX_buffer[8]=0x00;
TX_buffer[9]=0x00;
TX_buffer[10]=0x00;
TX_buffer[11]=0x00;
TX_buffer[12]=0x00;
for(i=0;i<13;i++) //接收缓冲变量初始化
{
   RX_buffer=0x00;
}
//TXD_Data=0x00; //发送数据初始化
//RXD_Data=0x00; //接收数据初始化
}
void main()
{

//INT1初始化
MCUCR=0X00;    //INT1        低电平中断
GICR|=BIT(7);   //int1使能
GIFR=0;     //清除中断标志       手册说写1清零

DDRD=0x17;
//sja1000硬件复位
RST_on;
delay(100);
RST_off;
delay(100);
RST_on;

    Init_Data();
SEI();      //开总中断
CAN_Init();
while(1)
{
   CAN_TXD();
   delay(200);delay(200);delay(200);delay(200);delay(200);
   delay(200);delay(200);delay(200);delay(200);delay(200);
   delay(200);delay(200);delay(200);delay(200);delay(200);
}
}
头文件can.h

//******************引脚信号定义***************************//
#define uchar unsigned char
#define uint unsigned int

//#define CS_1        (PORTB|= (1<<4 ))      //AD7705片选
//#define CS_0        (PORTB&= ~(1<<4 ))

#define RST_on      (PORTD|= (1<<5 ))
#define RST_off     (PORTD&= ~(1<<5 ))

#define WR_on       (PORTD|= (1<<0 ))       //WR高
#define WR_off      (PORTD&= ~(1<<0))       //WR低

#define RD_on       (PORTD|= (1<<1 ))           //RD高
#define RD_off      (PORTD&= ~(1<<1))          //RD低

#define CAN_cs_on   (PORTD|= (1<<4 ))       //CAN高
#define CAN_cs_off (PORTD&= ~(1<<4))      //CAN低

#define ALE_on      (PORTD|= (1<<2 ))          //ALE高
#define ALE_off     (PORTD&= ~(1<<2))         //ALE低

#define FALSE 0
#define TRUE 1
#define CANBE_C 6                       //总线关闭次数设定值
//*******************CAN寄存器地址**************************//
#define CAN_MOD     0      //模式寄存器
#define CAN_CMR     1      //命令寄存器只写
#define CAN_SR      2      //状态寄存器只读
#define CAN_IR      3      //中断寄存器只读
#define CAN_IER     4      //中断使能寄存器
#define CAN_BTR0    6      //总线定时寄存器0
#define CAN_BTR1    7      //总线定时寄存器1
#define CAN_OCR     8      //输出控制寄存器
#define CAN_TEST    9      //测试寄存器
#define CAN_ALC     11     //仲裁丢失寄存器
#define CAN_ECC     12     //错误代码捕捉寄存器
#define CAN_EWLR    13     //错误报警限制寄存器
#define CAN_EXERR   14     //RX错误计数寄存器
#define CAN_TXERR   15     //TX错误计数寄存器
#define CAN_ACR0    16     //验收码寄存器0
#define CAN_ACR1    17     //验收码寄存器1
#define CAN_ACR2    18     //验收码寄存器2
#define CAN_ACR3    19     //验收码寄存器3
#define CAN_AMR0    20     //验收屏蔽寄存器0
#define CAN_AMR1    21     //验收屏蔽寄存器1
#define CAN_AMR2    22     //验收屏蔽寄存器2
#define CAN_AMR3    23     //验收屏蔽寄存器3
#define CAN_TXB     16     //发送缓冲区首地址(工作模式)
#define CAN_RXB     16     //接收缓冲区首地址(工作模式)
#define CAN_RMC     29     //RX信息计数器
#define CAN_RBSA    30     //RX缓冲区起始地址寄存器
#define CAN_CDR     31     //时钟分频器
#define ID3         00      //ID3

//**************************读SJA1000*************************//
uchar Read_SJA1000(uchar address)
{
uchar data;
asm("nop");
ALE_off;
WR_on;
RD_on;
CAN_cs_on;
DDRA=0xff;          //数据口为输出
PORTA=address;      //输出数据的地址
asm("nop");//delay5us(1);
ALE_on;
asm("nop");//delay5us(1);
//DDRA=0xff;          //数据口为输出
PORTA=address;     //输出数据的地址   //再次输出地址，确保一致。
asm("nop");//delay5us(1);
ALE_off;
//delay5us(1);
CAN_cs_off;
RD_off;
asm("nop");//delay5us(2);
asm("nop");
DDRA=0x00;       //数据口为输入
PORTA=0xff;      //上拉
asm("nop");
data=PINA;       //获得数据
asm("nop");//delay5us(1);
RD_on;
CAN_cs_on;
asm("nop");//delay5us(2);
//dog();
return data;
}
//**************************写SJA10000*************************//
void Write_SJA1000(uchar address,uchar data)
{ asm("nop");
//uint temp1,temp2;
DDRA=0xff;          //数据口为输出
PORTA=address;     //输出数据的地址
CAN_cs_on;
ALE_off;
WR_on;
RD_on;
asm("nop");//delay5us(1);
ALE_on;
asm("nop");//delay5us(1);
//DDRA=0xff;          //数据口为输出
PORTA=address;     //输出数据的地址   再次输出地址，确保数据准确
asm("nop");//delay5us(1);
ALE_off;
//delay5us(1);
CAN_cs_off;
WR_off;
asm("nop");//delay5us(1);
asm("nop");
//DDRA=0xff;
PORTA=data;     //输出数据
asm("nop");//delay5us(2);
WR_on;
PORTA=data;     //再次输出数据，取保一致
CAN_cs_on;
asm("nop");//delay5us(2);
asm("nop");
//dog();
}
=================================================================

==================================================================

##########################################################################

###################################################################

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

stc89c52的程序

只发接受的了。

//############接收程序##########
#include "reg52.h"
#include "sja1000.h"
#include "1602.h"

#define uchar unsigned char
uchar temp[3],tt;
//i0脚定义
sbit SJACS=P2^0;
sbit SJARST=P2^3;

//接收代码变量,接收屏蔽变量,发送缓冲变量, 接收缓冲变量, 发送数据,接收数据, 点击变量
uchar ACR[4],AMR[4],   TXD_Buffer[13], RXD_Buffer[13], TXD_Data,RXD_Data, Click;
//函数声明

void CAN_TXD(void);
void CAN_RXD(void);
void Delay_1ms(int x);
void Delay_50us(int t);
void Init_Data(void);
void Init_CPU(void);
void Init_CAN(void);

//主函数#####################################################
void main(void)
{
init_1602();
LCD_write_string(0,0," 20");//2009年的20

Init_Data();
Init_CPU();
Init_CAN();
while(1)
{




}
}

//1毫秒延迟函数
void Delay_1ms(int x)
{
int j;
for(;x>0;x--)
   for(j=125;j>0;j--);
}
//50微秒延迟函数
void Delay_50us(int t)
{
uchar j;
t--;
for(;t>0;t--)
   for(j=19;j>0;j--);
}

//变量初始化 #############################################
void Init_Data(void)
{
int i;
ACR[0]='C'; //本节点地址为CAN1
ACR[1]='A';
ACR[2]='N';
ACR[3]='2';

AMR[0]=0xff;//全部标示符屏蔽
AMR[1]=0xff; //接受全部节点的数据
AMR[2]=0xff;
AMR[3]=0xff;
TXD_Buffer[0]=0x88; //EFF 格式，数据长度8 的TX 帧信息
TXD_Buffer[1]='C'; //目的标示符为CAN2
TXD_Buffer[2]='A';
TXD_Buffer[3]='N';
TXD_Buffer[4]='1';
TXD_Buffer[5]=TXD_Data; //发送数据
TXD_Buffer[6]=0x00;
TXD_Buffer[7]=0x00;
TXD_Buffer[8]=0x00;
TXD_Buffer[9]=0x00;
TXD_Buffer[10]=0x00;
TXD_Buffer[11]=0x00;
TXD_Buffer[12]=0x00;
for(i=0;i<13;i++) //接收缓冲变量初始化
{
   RXD_Buffer=0x00;
}
TXD_Data=0x00; //发送数据初始化
RXD_Data=0x00; //接收数据初始化
}
//CPU 初始化 ##############################################
void Init_CPU(void)
{
SJACS=1; // 使片选无效
SJARST=1; // 硬件复位无效
//IT0=1; // 外部中断0为电平触发方式
IT1=0; // 外部中断1为跳电沿触发方式

//EX0=1; // 外部中断0使能
EX1=1; // 外部中断1使能
EA=1; // 全局中断使能
}
//CAN 初始化###########################################
void Init_CAN(void)
{
unsigned char bdata temp; //建立存储在bdata 中的临时变量temp
do
{
   MODR=0x09;
   temp=MODR; //模式寄存器-设置复位模式而且单验收滤波模式
} while(!(temp&0x01)); //判断

CDR=0x88; //时钟分频寄存器-设置PeliCAN 模式，Clock off 有效
BTR0=0x31; //总线时序寄存器-波特率为10kbps
BTR1=0x1c;
IER=0x01; //中断使能寄存器-接收中断使能
OCR=0xaa; //输出控制寄存器-借签...
CMR=0x04; //命令寄存器-释放RXFIF0
ACR0=ACR[0]; //接收代码寄存器-本节点地址位CAN1
ACR1=ACR[1];
ACR2=ACR[2];
ACR3=ACR[3];

AMR0=AMR[0]; //接收屏蔽寄存器-无任何屏蔽
AMR1=AMR[1];
AMR2=AMR[2];
AMR3=AMR[3]; //最后两位为无用位，必须设置为逻辑1
do
{
   MODR=0x08;
   temp=MODR; //模式寄存器-推出复位模式，保持单验收滤波模式
}while(temp&0x01); //判断...

}
/*

//CAN 发送函数
void CAN_TXD(void)
{
unsigned char bdata temp;
do
{
   temp=SR; //判断报文接收完毕？
}while(temp&0x10); //SR.4=0 发送闲置，SR.4=1 发送状态中

do
{
   temp=SR; //判断最后报文请求？
}while(!(temp&0x08)); //SR.3=0 没有余报文请求，SR.3=1 还存在报文请求

do
{
   temp=SR; //判断TXFIFO 是否锁定？
}while(!(temp&0x04)); //SR.2=0 锁定，SR.2=1 开放

TBSR0=TXD_Buffer[0];
TBSR1=TXD_Buffer[1];
TBSR2=TXD_Buffer[2];
TBSR3=TXD_Buffer[3];
TBSR4=TXD_Buffer[4];
TBSR5=TXD_Buffer[5];
TBSR6=TXD_Buffer[6];
TBSR7=TXD_Buffer[7];
TBSR8=TXD_Buffer[8];
TBSR9=TXD_Buffer[9];
TBSR10=TXD_Buffer[10];
TBSR11=TXD_Buffer[11];
TBSR12=TXD_Buffer[12];
CMR=0x01; //命令寄存器-发送请求
}
*/
//CAN 接收函数
void CAN_RXD(void)
{
unsigned char te;
te = IR;
if( te & 0x01) //判断是否接收中断
{
   RXD_Buffer[0]=RBSR0; //读取RXFIFO
   RXD_Buffer[1]=RBSR1;
   RXD_Buffer[2]=RBSR2;
   RXD_Buffer[3]=RBSR3;
   RXD_Buffer[4]=RBSR4;
   RXD_Buffer[5]=RBSR5; //年
   RXD_Buffer[6]=RBSR6; // 月
   RXD_Buffer[7]=RBSR7; // 日
   RXD_Buffer[8]=RBSR8; //   时
   RXD_Buffer[9]=RBSR9; //    分
   RXD_Buffer[10]=RBSR10; //   秒
   RXD_Buffer[11]=RBSR11; //   星期
   RXD_Buffer[12]=RBSR12; //   0xaa

   CMR = 0X04; //释放RXFIFO 中的空间
   te = ALC; //释放仲裁随时捕捉寄存器
   te = ECC; //释放错误代码捕捉寄存器




   //##############   年
   temp[0]=RXD_Buffer[5]/10+'0';
   temp[1]=RXD_Buffer[5]%10+'0';
   temp[2]=0;
   LCD_write_string(3,0,temp);
   LCD_write_char(5,0,'-');
        //##############   月
   temp[0]=RXD_Buffer[6]/10+'0';
   temp[1]=RXD_Buffer[6]%10+'0';
   temp[2]=0;
   LCD_write_string(6,0,temp);
   LCD_write_char(8,0,'-');
        //##############   日
   temp[0]=RXD_Buffer[7]/10+'0';
   temp[1]=RXD_Buffer[7]%10+'0';
   temp[2]=0;

   LCD_write_string(9,0,temp);
   LCD_write_string(11,0," ");
        //############## 星期
   temp[0]=RXD_Buffer[8]/10+'0';
   temp[1]=RXD_Buffer[8]%10+'0';
   temp[2]=0;

   LCD_write_string(13,0,temp);
        //##############
   //##############   时
   temp[0]=RXD_Buffer[9]/10+'0';
   temp[1]=RXD_Buffer[9]%10+'0';
   temp[2]=0;

   LCD_write_string(5,1,temp);
   LCD_write_char(7,1,':');
        //##############   分
   temp[0]=RXD_Buffer[10]/10+'0';
   temp[1]=RXD_Buffer[10]%10+'0';
   temp[2]=0;

   LCD_write_string(8,1,temp);
   LCD_write_char(10,1,':');
        //############## 秒
   temp[0]=RXD_Buffer[11]/10+'0';
   temp[1]=RXD_Buffer[11]%10+'0';
   temp[2]=0;

   LCD_write_string(11,1,temp);
        //##############

}
}
//外部中断0函数-点击中断
/*
void Ir_EX0(void) interrupt 0
{
Delay_1ms(20); //软件消抖
EA=0; //关闭全局使能
EX0=0; //外部中断0使无效
Click++;
if(Click>=100)
   Click=0;
TXD_Data=Click; //发送数据赋值
TXD_Buffer[5]=TXD_Data;
CAN_TXD(); //调用发送函数
EX0=1; //外部中断0使能
EA=1; //全局中断使能
}
*/
//外部中断1函数-RXFIFO 饱和中断
void Ir_EX1(void) interrupt 2
{
EA=0; //关闭全局使能
EX1=0; //外部中断1使无效
CAN_RXD(); //调用接收函数
RXD_Data=RXD_Buffer[5]; //接收数据变量赋值
EX1=1; //外部中断1使能
EA=1; //全局中断使能
}

头文件sja1000.c

/*CAN 总线SJA1000寄存器地址定义（用的是PeliCAN 模式，扩展帧EFF 模式）*/
#define uchar unsigned char
uchar xdata MODR _at_ 0xFE00; // 模式寄存器
uchar xdata CMR _at_ 0xFE01; // 命令寄存器
uchar xdata SR _at_ 0xFE02; // 状态寄存器
uchar xdata IR _at_ 0xFE03; // 中断寄存器
uchar xdata IER _at_ 0xFE04; // 中断使能寄存器
uchar xdata BTR0 _at_ 0xFE06; // 总线定时寄存器0 ；总线波特率的选择
uchar xdata BTR1 _at_ 0xFE07; // 总线定时寄存器1 ；总线波特率的选择
uchar xdata OCR _at_ 0xFE08; // 输出控制寄存器

uchar   xdata    TEST   _at_   0xFE09;   //#########################
uchar   xdata    RX_error   _at_   0xFE0E;   //14 RX error counter
uchar   xdata    TX_error   _at_   0xFE0F;   //15 TX error counter
uchar xdata ACR0 _at_ 0xFE10;//16;
uchar xdata ACR1 _at_ 0xFE11;//17;
uchar xdata ACR2 _at_ 0xFE12;//18;
uchar xdata ACR3 _at_ 0xFE13;//19; // 接收代码（0x16_0x19）；接收过滤位选择*复位模式
uchar xdata AMR0 _at_ 0xFE14;//20;
uchar xdata AMR1 _at_ 0xFE15;//21;
uchar xdata AMR2 _at_ 0xFE16;//22;
uchar xdata AMR3 _at_ 0xFE17;//23; // 掩码（0x20_0x23）; 接收过滤的选择*复位模式
uchar xdata CDR _at_ 0xFE1F;//31; // 时钟分频器
uchar xdata ALC _at_ 0xFE0B;//11; // 仲裁丢失捕捉寄存器
uchar xdata ECC _at_ 0xFE0C;//12; // 误码捕捉寄存器

uchar xdata TBSR0 _at_ 0xFE10;//16; //TX 帧信息(标准帧、扩展帧）寄存器
uchar xdata TBSR1 _at_ 0xFE11;//17; //TX 帧信息(标准帧数据1、扩展帧识别码1）寄存器
uchar xdata TBSR2 _at_ 0xFE12;//18; //TX 帧信息(标准帧数据1、扩展帧识别码2）寄存器
uchar xdata TBSR3 _at_ 0xFE13;//19; //TX 帧信息(标准帧数据1、扩展帧识别码3）寄存器
uchar xdata TBSR4 _at_ 0xFE14;//20; //TX 帧信息(标准帧数据2、扩展帧识别码4）寄存器
uchar xdata TBSR5 _at_ 0xFE15;//21; //TX 帧信息(标准帧数据3、扩展帧数据1）寄存器
uchar xdata TBSR6 _at_ 0xFE16;//22; //TX 帧信息(标准帧数据4、扩展帧数据2）寄存器
uchar xdata TBSR7 _at_ 0xFE17;//23; //TX 帧信息(标准帧数据5、扩展帧数据3）寄存器
uchar xdata TBSR8 _at_ 0xFE18;//24; //TX 帧信息(标准帧数据6、扩展帧数据4）寄存器
uchar xdata TBSR9 _at_ 0xFE19;//25; //TX 帧信息(标准帧数据7、扩展帧数据5）寄存器
uchar xdata TBSR10 _at_ 0xFE1A;//26; //TX 帧信息(标准帧数据8、扩展帧数据6）寄存器
uchar xdata TBSR11 _at_ 0xFE1B;//27; //TX 帧信息(扩展帧数据7）寄存器
uchar xdata TBSR12 _at_ 0xFE1C;//28; //TX 帧信息(扩展帧数据8）寄存器

uchar xdata RBSR0 _at_ 0xFE10;//16; //RX 帧信息(标准帧、扩展帧）寄存器
uchar xdata RBSR1 _at_ 0xFE11;//17; //RX 识别码(标准帧、扩展帧）寄存器1
uchar xdata RBSR2 _at_ 0xFE12;//18; //RX 帧信息(标准帧、扩展帧）识别码2寄存器
uchar xdata RBSR3 _at_ 0xFE13;//19; //RX 帧信息(标准帧数据1、扩展帧识别码3）寄存器
uchar xdata RBSR4 _at_ 0xFE14;//20; //RX 帧信息(标准帧数据2、扩展帧识别码4）寄存器
uchar xdata RBSR5 _at_ 0xFE15;//21; //RX 帧信息(标准帧数据3、扩展帧数据1）寄存器
uchar xdata RBSR6 _at_ 0xFE16;//22; //RX 帧信息(标准帧数据4、扩展帧数据2）寄存器
uchar xdata RBSR7 _at_ 0xFE17;//23; //RX 帧信息(标准帧数据5、扩展帧数据3）寄存器
uchar xdata RBSR8 _at_ 0xFE18;//24; //RX 帧信息(标准帧数据6、扩展帧数据4）寄存器
uchar xdata RBSR9 _at_ 0xFE19;//25; //RX 帧信息(标准帧数据7、扩展帧数据5）寄存器
uchar xdata RBSR10 _at_ 0xFE1A;//26; //RX 帧信息(标准帧数据8、扩展帧数据6）寄存器
uchar xdata RBSR11 _at_ 0xFE1B;//27; //RX 帧信息(扩展帧数据7）寄存器
uchar xdata RBSR12 _at_ 0xFE1C;//28; //RX 帧信息(扩展帧数据8）寄存器