Chinaunix首页 | 论坛 | 博客

Mainintowhile

首页　| 　博文目录　| 　关于我

baidu搜不倒

  • 博客访问： 188398
  • 博文数量： 54
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 2018
  • 用 户 组： 普通用户
  • 注册时间： 2013-03-31 23:14
文章分类

全部博文（54）

文章存档

2014年（2）

2013年（52）

我的朋友
最近访客
推荐博文
相关博文
单片机memoirs 19 CAN On May 7,2013

分类： 嵌入式

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"

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

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

  17. void delay(unsigned t)
  18. {
  19.    while(t--);
  20. }

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

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

  43.         
  44.     }
  45.     SJA_IER = RIE_BIT;// .0=1--接收中断使能；

  47.     recvdat=RX_buffer[5]&0x0f;
  48.     EX0=1;
  49.     EA = 1;//打开CPU中断
  50.     //mDelay(2000);
  51. }

  53. void MCU_Init(void)
  54. {
  55.     //CPU初始化
  56.     SJA_RST = 1;//SJA1000复位有效
  57.     mDelay(10);    //延时
  58.     SJA_RST = 0;//CAN总线复位管脚,复位无效
  59.     SJA_CS = 0; //CAN总线片选有效
  60.     EX0 = 1; //外部中断0使能；CAN总线接收中断
  61.     IT0 = 0; //CAN总线接收中断，低电平触发

  63.     EA = 1; //打开总中断
  64. }

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

  108. void main(void)
  109. {
  110.     
  111.     P1=NUM[1];
  112.     MCU_Init();
  113.     P1=NUM[2];
  114.     mDelay(200);
  115.     Peli_Init();
  116.     P1=NUM[3];
  117.     mDelay(200);
  118.     while(1)
  119.     {     
  120.          keyscan();
  121.      P1=NUM[recvdat];
  122.         mDelay(100);
  123.         if((SJA_RXERR!=0)|(SJA_TXERR!=0))//接收错误寄存器积满总线关闭，此时手动清空以继续工作
  124.         {
  125.          MCU_Init();
  126.          Peli_Init();
  127.         }
  128.     }

  130. }

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

  160.     SJA_AMR0 = 0xff;
  161.     SJA_AMR1 = 0xff;
  162.     SJA_AMR2 = 0xff;
  163.     SJA_AMR3 = 0xff;//初始化掩码
  164.     do
  165.     { //确保进入正常工作模式
  166.         SJA_MOD = AFM_BIT;
  167.         Status = SJA_MOD;
  168.      }
  169.     while( !(Status & AFM_BIT) );

  171. }//SJA1000 的初始化


  174. void Peli_TXD( void )    //发送数据函数
  175. {
  176.     uint8 data Status;     //内部数据寄存器
  177.     //初始化标示码头信息
  178.     TX_buffer[0] = 0x81;//.7=1扩展帧；.6=0数据帧; .3=1数据长度 数据长为8 扩展帧模式
  179.     TX_buffer[1] = 0x11;//本节点地址 17
  180.     TX_buffer[2] = 0x22;//             18
  181.     TX_buffer[3] = 0x33;//             19
  182.     TX_buffer[4] = 0x48;//             20

  184.     //初始化发送数据单元
  185.     //TX_buffer[5] = 0x11;     //发送8字节数据。
  186.     TX_buffer[5]=sendNum;
  187.     
  188.     EA=0;    
  189.     do
  190.     {
  191.         Status = SJA_SR;
  192.         P1=NUM[6];
  193.     }
  194.     while( Status & RS_BIT); //SR.4=1 正在接收，等待
  195.     
  196.     do
  197.     {
  198.         Status = SJA_SR;
  199.         P1=NUM[7];
  200.     }
  201.     while(!(Status & TCS_BIT)); //SR.3=0,发送请求未处理完，等待

  203.     do
  204.     {
  205.         Status = SJA_SR;
  206.         P=NUM[8];
  207.     }
  208.     while(!(Status & TBS_BIT)); //SR.2=0,发送缓冲器被锁。等待

  210.     SJA_TBSR0 = TX_buffer[0];
  211.     SJA_TBSR1 = TX_buffer[1];
  212.     SJA_TBSR2 = TX_buffer[2];
  213.     SJA_TBSR3 = TX_buffer[3];
  214.     SJA_TBSR4 = TX_buffer[4];
  215.     SJA_TBSR5 = TX_buffer[5]; //只发送一个字节，字节数可选0？-4；
  216.            
  217.     //SJA_CMR = SRR_BIT|AT_BIT;//置位自发送接收请求
  218.     SJA_CMR=TR_BIT|AT_BIT; //发送失败，重新发送
  219.     P1=NUM[4];
  220.     EA=1;
  221.     mDelay(200);    
  222.     
  223. }

  225. void mDelay(uint16 mtime)
  226. {
  227.     for(; mtime > 0; mtime--)
  228.     {
  229.         uint8 j = 244;
  230.         while(--j);
  231.     }
  232. }
收：

点击(此处)折叠或打开

  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. {//接收数据函数，在中断服务程序中调用

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

  33.         
  34.     }
  35.     SJA_IER = RIE_BIT;// .0=1--接收中断使能；

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


  60.     EX0=1;
  61.     EA = 1;//打开CPU中断
  62.     //mDelay(2000);
  63. }

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

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

  100. }

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

  126.     SJA_ACR0 = 0x11;
  127.     SJA_ACR1 = 0x22;
  128.     SJA_ACR2 = 0x33;
  129.     SJA_ACR3 = 0x48;//初始化标识码

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

  136.     do
  137.     { //确保进入正常工作模式
  138.         SJA_MOD = AFM_BIT;
  139.         Status = SJA_MOD;
  140.      }
  141.     while( !(Status & AFM_BIT) );

  143. }//SJA1000 的初始化

  145. void Peli_TXD( void )    //发送数据函数
  146. {
  147.     uint8 data Status;     //内部数据寄存器
  148.     //初始化标示码头信息
  149.     TX_buffer[0] = 0x81;//.7=1扩展帧；.6=0数据帧; .3=1数据长度 数据长为8 扩展帧模式
  150.     TX_buffer[1] = 0x11;//本节点地址 17
  151.     TX_buffer[2] = 0x22;//             18
  152.     TX_buffer[3] = 0x33;//             19
  153.     TX_buffer[4] = 0x48;//             20

  155.     //初始化发送数据单元
  156.     //TX_buffer[5] = 0x11;     //发送8字节数据。
  157.     TX_buffer[5]=sendNum;
  158.     
  159.     EA=0;    
  160.     do
  161.     {
  162.         Status = SJA_SR;
  163.         P1=NUM[6];
  164.     }
  165.     while( Status & RS_BIT); //SR.4=1 正在接收，等待
  166.     
  167.     do
  168.     {
  169.         Status = SJA_SR;
  170.         P1=NUM[7];
  171.     }
  172.     while(!(Status & TCS_BIT)); //SR.3=0,发送请求未处理完，等待

  174.     do
  175.     {
  176.         Status = SJA_SR;
  177.         P=NUM[8];
  178.     }
  179.     while(!(Status & TBS_BIT)); //SR.2=0,发送缓冲器被锁。等待

  181.     SJA_TBSR0 = TX_buffer[0];
  182.     SJA_TBSR1 = TX_buffer[1];
  183.     SJA_TBSR2 = TX_buffer[2];
  184.     SJA_TBSR3 = TX_buffer[3];
  185.     SJA_TBSR4 = TX_buffer[4];
  186.     SJA_TBSR5 = TX_buffer[5]; //只发送一个字节，字节数可选0？-4；
  187.            
  188.     //SJA_CMR = SRR_BIT|AT_BIT;//置位自发送接收请求
  189.     SJA_CMR=TR_BIT|AT_BIT; //发送失败，重新发送
  190.     P1=NUM[4];
  191.     EA=1;
  192.     mDelay(200);    
  193.     
  194. }

  196. void mDelay(uint16 mtime)
  197. {
  198.     for(; mtime > 0; mtime--)
  199.     {
  200.         uint8 j = 244;
  201.         while(--j);
  202.     }
  203. }





阅读(2544) | 评论(0) | 转发(1) |
0

上一篇：单片机memoirs 18 NRF905 On May 6,2013

下一篇：嵌入式Memo17 mini2440 编写驱动步骤总结_驱动开发流程_（led字符驱动）On May27.2013

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6