Chinaunix首页 | 论坛 | 博客
  • 博客访问: 181538
  • 博文数量: 54
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 2018
  • 用 户 组: 普通用户
  • 注册时间: 2013-03-31 23:14
文章存档

2014年(2)

2013年(52)

分类: 嵌入式

2013-05-07 20:59:44

无仿真自制实验板:
C:
CAN通信+自测试(zh change 单字节+矩阵键盘+收发).zip
PCB图:
CAN-SJA1000j终版二.zip

芯片:SJA1000 CK2752 驱动芯片:PCA82C250
三极管:S8050 D331
连线:AD0~AD7当然接数据总线P0

点击(此处)折叠或打开

  1. /*----------------------------------------------
  2. 发送函数发送矩阵键码值,接收函数将接收的键码值再发送给发送函数
  3. 然后发送函数将收到的键码值显示在数码管上。
  4. ------------------------------------------------*/
  5. #include <reg52.h>
  6. #include "sjapelican.h"                                        
  7. #include "config.h"

  8. sbit p20=P2^0;
  9. sbit p21=P2^1;

  10. unsigned char code NUM[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,
  11.           0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};
  12. unsigned char sendNum=0x00;
  13. unsigned char recvdat=0;

  14. void delay(unsigned t)
  15. {
  16.    while(t--);
  17. }

  18. void Peli_RXD(void) interrupt 0 using 1
  19. {//接收数据函数,在中断服务程序中调用

  20.     uint8 data Status;
  21.     EA = 0;//关CPU中断
  22.     EX0=0;
  23.     if(IE0==1) IE0=0;
  24.     Status = SJA_IR;
  25.     if(Status & RI_BIT)
  26.     {//IR.0 = 1 接收中断
  27.         RX_buffer[0] = SJA_RBSR0;
  28.         RX_buffer[1] = SJA_RBSR1;
  29.         RX_buffer[2] = SJA_RBSR2;
  30.         RX_buffer[3] = SJA_RBSR3;
  31.         RX_buffer[4] = SJA_RBSR4;
  32.         RX_buffer[5] = SJA_RBSR5;
  33.         
  34.         SJA_CMR = RRB_BIT;
  35.         Status = SJA_ALC;//释放仲裁随时捕捉寄存器
  36.         Status = SJA_ECC;//释放错误代码捕捉寄存器

  37.         
  38.     }
  39.     SJA_IER = RIE_BIT;// .0=1--接收中断使能;

  40.     recvdat=RX_buffer[5]&0x0f;
  41.     EX0=1;
  42.     EA = 1;//打开CPU中断
  43.     //mDelay(2000);
  44. }

  45. void MCU_Init(void)
  46. {
  47.     //CPU初始化
  48.     SJA_RST = 1;//SJA1000复位有效
  49.     mDelay(10);    //延时
  50.     SJA_RST = 0;//CAN总线复位管脚,复位无效
  51.     SJA_CS = 0; //CAN总线片选有效
  52.     EX0 = 1; //外部中断0使能;CAN总线接收中断
  53.     IT0 = 0; //CAN总线接收中断,低电平触发

  54.     EA = 1; //打开总中断
  55. }

  56. void keyscan()
  57. {     unsigned l,h,key;
  58.       P2=0xf0;
  59.      l=P2;
  60.      l=l&0xf0;
  61.      if(l!=0xf0)
  62.      {
  63.          delay(200);
  64.          if(l!=0xf0)
  65.          {
  66.              l=P2&0xf0;
  67.              l=l|0x0f;
  68.              P2=l;
  69.              h=P2;
  70.              h=h&0x0f;
  71.              l=l&0xf0;
  72.              key=l+h;
  73.              }
  74.          switch(key)
  75.      {
  76.           case 0xee:sendNum=0x00;break;
  77.          case 0xde:sendNum=0x01;break;
  78.          case 0xbe:sendNum=0x02;break;
  79.          case 0x7e:sendNum=0x03;break;
  80.          case 0xed:sendNum=0x04;break;
  81.          case 0xdd:sendNum=0x05;break;
  82.          case 0xbd:sendNum=0x06;break;
  83.          case 0x7d:sendNum=0x07;break;
  84.          case 0xeb:sendNum=0x08;break;
  85.          case 0xdb:sendNum=0x09;break;
  86.          case 0xbb:sendNum=0x10;break;
  87.          case 0x7b:sendNum=0x11;break;
  88.          case 0xe7:sendNum=0x12;break;
  89.          case 0xd7:sendNum=0x13;break;
  90.          case 0xb7:sendNum=0x14;break;
  91.          case 0x77:sendNum=0x15;break;
  92.      }
  93.          Peli_TXD();
  94.          }
  95.         
  96. }

  97. void main(void)
  98. {
  99.     
  100.     P1=NUM[1];
  101.     MCU_Init();
  102.     P1=NUM[2];
  103.     mDelay(200);
  104.     Peli_Init();
  105.     P1=NUM[3];
  106.     mDelay(200);
  107.     while(1)
  108.     {     
  109.          keyscan();
  110.      P1=NUM[recvdat];
  111.         mDelay(100);
  112.         if((SJA_RXERR!=0)|(SJA_TXERR!=0))//接收错误寄存器积满总线关闭,此时手动清空以继续工作
  113.         {
  114.          MCU_Init();
  115.          Peli_Init();
  116.         }
  117.     }

  118. }

  119. void Peli_Init(void)
  120. { //SJA1000 的初始化
  121.     uint8 bdata Status;     //bdata 可位寻址内部存储
  122.     do
  123.     {// .0=1---reset MODRe,进入复位模式,以便设置相应的寄存器
  124.      //防止未进入复位模式,重复写入
  125.         SJA_MOD = RM_BIT |AFM_BIT; //AFM_BIT单滤波
  126.         Status = SJA_MOD ;
  127.         P1=NUM[5];
  128.     }while(!(Status & RM_BIT));
  129.     // CDR.3=1--时钟关闭, .7=0---basic CAN, .7=1---Peli CAN
  130.     P1=NUM[6];
  131.     SJA_CDR = CANMode_BIT|CLKOff_BIT|CBP_BIT;//时钟
  132.     //16M晶振,波特率125Kbps
  133.     SJA_BTR0 = 0x03;
  134.     SJA_BTR1 = 0x1c;
  135.     // .0=1--接收中断使能; .1=0--关闭发送中断使能
  136.     SJA_IER = RIE_BIT;
  137.     // 配置输出控制寄存器
  138.     //SJA_OCR = NormalMode|Tx0PullDn|OCPOL1_BIT|Tx1PullUp;
  139.     SJA_OCR = NormalMode|Tx0PshPull|Tx1Float;     //推挽,上拉,???
  140.     //释放接收缓冲器
  141.  
  142.     SJA_ACR0 = 0x11;    //用于仲裁    
  143.     SJA_ACR1 = 0x22;
  144.     SJA_ACR2 = 0x33;
  145.     SJA_ACR3 = 0x48;//初始化标识码

  146.     SJA_AMR0 = 0xff;
  147.     SJA_AMR1 = 0xff;
  148.     SJA_AMR2 = 0xff;
  149.     SJA_AMR3 = 0xff;//初始化掩码
  150.     do
  151.     { //确保进入正常工作模式
  152.         SJA_MOD = AFM_BIT;
  153.         Status = SJA_MOD;
  154.      }
  155.     while( !(Status & AFM_BIT) );

  156. }//SJA1000 的初始化


  157. void Peli_TXD( void )    //发送数据函数
  158. {
  159.     uint8 data Status;     //内部数据寄存器
  160.     //初始化标示码头信息
  161.     TX_buffer[0] = 0x81;//.7=1扩展帧;.6=0数据帧; .3=1数据长度 数据长为8 扩展帧模式
  162.     TX_buffer[1] = 0x11;//本节点地址 17
  163.     TX_buffer[2] = 0x22;//             18
  164.     TX_buffer[3] = 0x33;//             19
  165.     TX_buffer[4] = 0x48;//             20

  166.     //初始化发送数据单元
  167.     //TX_buffer[5] = 0x11;     //发送8字节数据。
  168.     TX_buffer[5]=sendNum;
  169.     
  170.     EA=0;    
  171.     do
  172.     {
  173.         Status = SJA_SR;
  174.         P1=NUM[6];
  175.     }
  176.     while( Status & RS_BIT); //SR.4=1 正在接收,等待
  177.     
  178.     do
  179.     {
  180.         Status = SJA_SR;
  181.         P1=NUM[7];
  182.     }
  183.     while(!(Status & TCS_BIT)); //SR.3=0,发送请求未处理完,等待

  184.     do
  185.     {
  186.         Status = SJA_SR;
  187.         P=NUM[8];
  188.     }
  189.     while(!(Status & TBS_BIT)); //SR.2=0,发送缓冲器被锁。等待

  190.     SJA_TBSR0 = TX_buffer[0];
  191.     SJA_TBSR1 = TX_buffer[1];
  192.     SJA_TBSR2 = TX_buffer[2];
  193.     SJA_TBSR3 = TX_buffer[3];
  194.     SJA_TBSR4 = TX_buffer[4];
  195.     SJA_TBSR5 = TX_buffer[5]; //只发送一个字节,字节数可选0?-4;
  196.            
  197.     //SJA_CMR = SRR_BIT|AT_BIT;//置位自发送接收请求
  198.     SJA_CMR=TR_BIT|AT_BIT; //发送失败,重新发送
  199.     P1=NUM[4];
  200.     EA=1;
  201.     mDelay(200);    
  202.     
  203. }

  204. void mDelay(uint16 mtime)
  205. {
  206.     for(; mtime > 0; mtime--)
  207.     {
  208.         uint8 j = 244;
  209.         while(--j);
  210.     }
  211. }
收:

点击(此处)折叠或打开

  1. /*----------------------------------------------
  2. 发送函数发送矩阵键码值,接收函数将接收的键码值再发送给发送函数
  3. 然后发送函数将收到的键码值显示在数码管上。
  4. ------------------------------------------------*/
  5. #include <reg52.h>
  6. #include "sjapelican.h"
  7. #include "config.h"
  8. unsigned char code NUM[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,
  9.           0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};
  10. unsigned char recvdat=0;
  11. unsigned char sendNum=0x00;
  12. void Peli_RXD(void) interrupt 0 using 1
  13. {//接收数据函数,在中断服务程序中调用

  14.     uint8 data Status;
  15.     EA = 0;//关CPU中断
  16.     EX0=0;
  17.     if(IE0==1) IE0=0;
  18.     Status = SJA_IR;
  19.     if(Status & RI_BIT)
  20.     {//IR.0 = 1 接收中断
  21.         RX_buffer[0] = SJA_RBSR0;
  22.         RX_buffer[1] = SJA_RBSR1;
  23.         RX_buffer[2] = SJA_RBSR2;
  24.         RX_buffer[3] = SJA_RBSR3;
  25.         RX_buffer[4] = SJA_RBSR4;
  26.         RX_buffer[5] = SJA_RBSR5;
  27.         
  28.         SJA_CMR = RRB_BIT;
  29.         Status = SJA_ALC;//释放仲裁随时捕捉寄存器
  30.         Status = SJA_ECC;//释放错误代码捕捉寄存器

  31.         
  32.     }
  33.     SJA_IER = RIE_BIT;// .0=1--接收中断使能;

  34.     recvdat=RX_buffer[5]&0x0f;
  35.     
  36.     switch(recvdat)
  37.          {
  38.              case 0x00: sendNum=0x00;    Peli_TXD();break;
  39.              case 0x01: sendNum=0x01;    Peli_TXD();break;
  40.              case 0x02: sendNum=0x02;    Peli_TXD();break;
  41.              case 0x03: sendNum=0x03;    Peli_TXD();break;
  42.              case 0x04: sendNum=0x04;    Peli_TXD();break;
  43.              case 0x05: sendNum=0x05;    Peli_TXD();break;
  44.              case 0x06: sendNum=0x06;    Peli_TXD();break;
  45.              case 0x07: sendNum=0x07;    Peli_TXD();break;
  46.              case 0x08: sendNum=0x08;    Peli_TXD();break;
  47.              case 0x09: sendNum=0x09;    Peli_TXD();break;
  48.              case 0x10: sendNum=0x10;    Peli_TXD();break;
  49.              case 0x11: sendNum=0x11;    Peli_TXD();break;
  50.              case 0x12: sendNum=0x12;    Peli_TXD();break;
  51.              case 0x13: sendNum=0x13;    Peli_TXD();break;
  52.              case 0x14: sendNum=0x14;    Peli_TXD();break;
  53.              case 0x15: sendNum=0x15;    Peli_TXD();break;
  54.             }


  55.     EX0=1;
  56.     EA = 1;//打开CPU中断
  57.     //mDelay(2000);
  58. }

  59. void MCU_Init(void)
  60. {
  61.     //CPU初始化
  62.     SJA_RST = 1;//SJA1000复位有效
  63.     mDelay(10);    //延时
  64.     SJA_RST = 0;//CAN总线复位管脚,复位无效
  65.     SJA_CS = 0; //CAN总线片选有效
  66.     EX0 = 1; //外部中断0使能;CAN总线接收中断
  67.     IT0 = 0; //CAN总线接收中断,低电平触发
  68.     
  69.     EA = 1; //打开总中断
  70. }

  71. void main(void)
  72. {    char num=0,num0=0;
  73.     uint8 bdata Status;
  74.     P1=NUM[1];
  75.     mDelay(200);
  76.     MCU_Init();
  77.     P1=NUM[2];
  78.     mDelay(200);
  79.     Peli_Init();
  80.     P1=NUM[3];
  81.     mDelay(200);
  82.     while(1)
  83.     {     
  84.         P1=NUM[recvdat];
  85.         mDelay(100);
  86.         if((SJA_RXERR!=0)|(SJA_TXERR!=0)) //发送错误寄存器积满总线关闭,此时手动清空以继续工作
  87.         {
  88.          MCU_Init();
  89.          Peli_Init();
  90.         }    
  91.     }

  92. }

  93. void Peli_Init(void)
  94. { //SJA1000 的初始化
  95.     uint8 bdata Status;
  96.     do
  97.     {// .0=1---reset MODRe,进入复位模式,以便设置相应的寄存器
  98.      //防止未进入复位模式,重复写入
  99.         SJA_MOD = RM_BIT |AFM_BIT;
  100.         Status = SJA_MOD ;
  101.         P1=NUM[5];
  102.     }while(!(Status & RM_BIT));
  103.     // CDR.3=1--时钟关闭, .7=0---basic CAN, .7=1---Peli CAN
  104.     P1=NUM[6];
  105.     SJA_CDR = CANMode_BIT|CLKOff_BIT|CBP_BIT;
  106.     //16M晶振,波特率125Kbps
  107.     SJA_BTR0 = 0x03;
  108.     SJA_BTR1 = 0x1c;
  109.     // .0=1--接收中断使能; .1=0--关闭发送中断使能
  110.     SJA_IER = RIE_BIT;
  111.     // 配置输出控制寄存器
  112.     //SJA_OCR = NormalMode|Tx0PullDn|OCPOL1_BIT|Tx1PullUp;
  113.     SJA_OCR = NormalMode|Tx0PshPull|Tx1Float;
  114.     //释放接收缓冲器
  115.     SJA_CMR = RRB_BIT;    //清除接收缓存信息

  116.     SJA_ACR0 = 0x11;
  117.     SJA_ACR1 = 0x22;
  118.     SJA_ACR2 = 0x33;
  119.     SJA_ACR3 = 0x48;//初始化标识码

  120.     SJA_AMR0 = 0xff;
  121.     SJA_AMR1 = 0xff;
  122.     SJA_AMR2 = 0xff;
  123.     SJA_AMR3 = 0xff;//初始化掩码f对应位的ACR任意。即ACR对应位与ID可以不同从而起到滤波效果

  124.     do
  125.     { //确保进入正常工作模式
  126.         SJA_MOD = AFM_BIT;
  127.         Status = SJA_MOD;
  128.      }
  129.     while( !(Status & AFM_BIT) );

  130. }//SJA1000 的初始化

  131. void Peli_TXD( void )    //发送数据函数
  132. {
  133.     uint8 data Status;     //内部数据寄存器
  134.     //初始化标示码头信息
  135.     TX_buffer[0] = 0x81;//.7=1扩展帧;.6=0数据帧; .3=1数据长度 数据长为8 扩展帧模式
  136.     TX_buffer[1] = 0x11;//本节点地址 17
  137.     TX_buffer[2] = 0x22;//             18
  138.     TX_buffer[3] = 0x33;//             19
  139.     TX_buffer[4] = 0x48;//             20

  140.     //初始化发送数据单元
  141.     //TX_buffer[5] = 0x11;     //发送8字节数据。
  142.     TX_buffer[5]=sendNum;
  143.     
  144.     EA=0;    
  145.     do
  146.     {
  147.         Status = SJA_SR;
  148.         P1=NUM[6];
  149.     }
  150.     while( Status & RS_BIT); //SR.4=1 正在接收,等待
  151.     
  152.     do
  153.     {
  154.         Status = SJA_SR;
  155.         P1=NUM[7];
  156.     }
  157.     while(!(Status & TCS_BIT)); //SR.3=0,发送请求未处理完,等待

  158.     do
  159.     {
  160.         Status = SJA_SR;
  161.         P=NUM[8];
  162.     }
  163.     while(!(Status & TBS_BIT)); //SR.2=0,发送缓冲器被锁。等待

  164.     SJA_TBSR0 = TX_buffer[0];
  165.     SJA_TBSR1 = TX_buffer[1];
  166.     SJA_TBSR2 = TX_buffer[2];
  167.     SJA_TBSR3 = TX_buffer[3];
  168.     SJA_TBSR4 = TX_buffer[4];
  169.     SJA_TBSR5 = TX_buffer[5]; //只发送一个字节,字节数可选0?-4;
  170.            
  171.     //SJA_CMR = SRR_BIT|AT_BIT;//置位自发送接收请求
  172.     SJA_CMR=TR_BIT|AT_BIT; //发送失败,重新发送
  173.     P1=NUM[4];
  174.     EA=1;
  175.     mDelay(200);    
  176.     
  177. }

  178. void mDelay(uint16 mtime)
  179. {
  180.     for(; mtime > 0; mtime--)
  181.     {
  182.         uint8 j = 244;
  183.         while(--j);
  184.     }
  185. }





阅读(2479) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~