CAN总线收发节点设计

写在前面

这是微机接口的一个项目作业。
这段时间一直在宿舍隔离，没办法进行焊接和测试，但原理和代码已经在学习板子上经过验证。

设计目标

CAN在工业现场大量应用，尤其是汽车工业，设计一种CAN总线收发节点，该节点自身带8路模拟信号采集，采集结果通过CAN总线发送到上位机并显示。

技术要求

（1）系统以51单片机为控制器，和具有CAN接口的器件能通信；

（2）CAN控制器用SJA1000，总线收发器用PCA82C250；

（3）节点带8路模拟信号采集，信号范围0-5V；

（4）用USB转CAN模块，通过USB口接收CAN节点发送的数据，验证结果是否正确。

提交材料

（1）提交纸质版设计报告1份（包括测量原理、主要电路设计、主要器件选型、程序设计原理、关键程序设计举例等）；

（2）电子版设计报告、系统电气原理图、完整的程序代码

（3）提交实物1套，能现场演示（所需的can调试助手 can总线分析仪可以找我）；

（4）该题目4人完成（1人负责硬件设计、1人负责单片机软件设计、1人负责调试、1人负责设计报告的整理编辑以及答辩PPT制作），在设计报告上写清楚每人所承担的工作。

项目实现

设计成果展示

实物展示

原理图设计

PCB设计

上位机效果

测量原理

ADC数模转换原理，这里采用PCF8591AD采样芯片，测量原理如下：

通过引脚AIN0、AIN1、AIN2、AIN3输入的模拟信号（电压），经过模拟信号多路复用器、采样与保持、比较器，把处理后的数据放入ADC数据寄存器中，通过I2C总线接口传递给51主控芯片。

主要电路设计

供电与程序烧录电路

考虑到板子尺寸的限制以及器件的选型，这里采用UCB转串口芯片CH340，在USB供电的同时，又可通过串口进行程序的烧录，一路双用。

VCC直接作为5V电源输入，在串口芯片那边有一个保险丝12V/1000mA的保险丝进行保护，并通过电容进行滤波与稳压，来防止热插拔效应的干扰。

拨动电源开关，可看到电源指示灯亮起。

51主控芯片附近电路

主控芯片选取的是STC90C51RD+，国产51MCU芯片，简单易学，入门容易。工作电压：5.5V-3.4V，工作温度范围：-40-+85°C,工作频率范围：0-40MHz，用户应用程序空间4K，片上集成1280字节RAM，32个通用I/O口，4个外部中断。基本可以满足项目要求，实现对应的功能。

复位电路

采用阻容复位电路，电容C7是10μF，电阻R7是10K。

晶振电路

使用外部晶振12MHz，此时电容选取47pF。

AD采样电路

采用PCF8591这款芯片，该芯片具有4路模拟输入通道，8位AD采样精度，以及一个DA输出。

电路部分，使用两个电位器作为采样目标，通过改变电位器阻值来改变采样的数值，并通过开关来切换AD采样的通道。

把采集到的数据存放至8位的数据寄存器中，通过I2C总线传输到51主控芯片中。

利用该芯片的一个DA输出通道，可以连接一个LED的灯，转动电位器，可以观察灯的的亮度发生细微的变化，更加的直观。

数码管驱动电路

为了便于调试，这里使用8位共阴数码管进行实时显示，数码管驱动芯片选择74HC573，作为最常见的锁存芯片，在这里一个作为位锁存，一个作为段锁存。

数码管这里采用的是共阴数码管，两个4位的数码管，合成一个8位的数码管。

CAN总线通讯电路

根据实际的项目需求，CAN总线电路采用SJA1000作为CAN控制器，PCA82C250作为CAN总线收发器。

但因单独购买芯片没有相关渠道，转而选择集成化的CAN通讯模块。

主要器件选型

器件选型方面本着有现成的就使用现成的、能简单实现的功能就不做的复杂的原则。器件选型上可以分为两类：芯片类，其他电子器件类。

芯片类

51主控芯片STC90C516RD+

USB转串口芯片CH340G

AD采样芯片PCF8591

锁存器芯片74HC573

CAN通讯模块

其他器件

开关

按键

四位共阴数码管

晶振

供电USB接口

电阻、电容、二极管、LED

程序设计原理

程序框架

整个程序框架包含了：main.c、display.c、i2c.c、uart.c、delay.c。

主函数模块main.c，延时函数模块delay.c、数码管驱动函数模块display.c、i2c驱动函数模块i2c.c、串口通讯函数模块uart.c。相关函数都用.h文件进行封装，提供相关的接口，供主函数调用。

主函数模块main.c
  1. /*
  2.     Date:2022.03.22
  3.     Author:
  4.     Target:主函数
  5. */
  6. #include <reg52.h>
  7. #include "i2c.h"
  8. #include "delay.h"
  9. #include "display.h"
  10. #include <uart.h>
  12. #define AddWr 0x90   //写数据地址
  13. #define AddRd 0x91   //读数据地址
  15. extern bit ack;
  16. bit ReadADFlag;
  18. unsigned char VoltData[5]; //存储电压的全局变量,用于串口通讯
  20. unsigned char numback(unsigned char s);
  21. unsigned char ReadADC(unsigned char Chl);
  22. bit WriteDAC(unsigned char dat);
  23. /*------------------------------------------------
  24.               主程序
  25. ------------------------------------------------*/
  26. main()
  27. {
  28.  unsigned char num=0,num0=0,num1=0,num2=0,num3=0,i;
  29.  Init_Timer0();
  30.  DelayMs(20);
  32.  InitUART();
  34. while (1)         //主循环
  35.   {
  36.  if(ReadADFlag)
  37.   {
  38.   ReadADFlag=0;
  39. //连续读5次，输入通道后多读几次，取最后一次值，以便读出稳定值
  40.  for(i=0;i<5;i++)
  41.     num0=ReadADC(0);
  42.   num0=num0*5*10/256;// x10表示把实际值扩大10，如4.5 变成 45 方便做下一步处理 x5 表示基准电压5V
  43.   TempData[0]=dofly_DuanMa[num0/10]|0x80;
  44.   TempData[1]=dofly_DuanMa[num0%10];
  46.  for(i=0;i<5;i++)
  47.    num1=ReadADC(1);
  48.  num1=num1*5*10/256;   // x10表示把实际值扩大10，如4.5 变成 45 方便做下一步处理
  49.  TempData[2]=dofly_DuanMa[num1/10]|0x80;
  50.  TempData[3]=dofly_DuanMa[num1%10];
  52.  for(i=0;i<5;i++)
  53.     num2=ReadADC(2);
  54.  num2=num2*5*10/256;   // x10表示把实际值扩大10，如4.5 变成 45 方便做下一步处理
  55.  TempData[4]=dofly_DuanMa[num2/10]|0x80;
  56.  TempData[5]=dofly_DuanMa[num2%10];
  58.  for(i=0;i<5;i++)
  59.      num=ReadADC(3);
  60.  num3=num3*5*10/256;   // x10表示把实际值扩大10，如4.5 变成 45 方便做下一步处理
  61.  TempData[6]=dofly_DuanMa[num3/10]|0x80;
  62.  TempData[7]=dofly_DuanMa[num3%10];
  63.  //主循环中添加其他需要一直工作的程序
  65.  VoltData[0]=num0;
  66.  VoltData[1]=num1;
  67.  VoltData[2]=num2;
  68.  VoltData[3]=num3;
  69.  VoltData[4]=0xff;
  71.  SendStr1(VoltData);
  72.     DelayMs(240);//延时循环发送
  73.     DelayMs(240);
  74.    }
  75.  /*
  76.    SendStr1(VoltData);
  77.     DelayMs(240);//延时循环发送
  78.     DelayMs(240);
  79.  */
  80.   }
  81. }
  82. /*------------------------------------------------
  83.              读AD转值程序
  84. 输入参数 Chl 表示需要转换的通道，范围从0-3
  85. 返回值范围0-255
  86. ------------------------------------------------*/
  87. unsigned char ReadADC(unsigned char Chl)
  88.  {
  89.   unsigned char Val;
  90.    Start_I2c();               //启动总线
  91.    SendByte(AddWr);             //发送器件地址
  92.      if(ack==0)return(0);
  93.    SendByte(Chl);            //发送器件子地址
  94.      if(ack==0)return(0);
  95.    Start_I2c();
  96.    SendByte(AddRd);
  97.       if(ack==0)return(0);
  98.    Val=RcvByte();
  99.    NoAck_I2c();                 //发送非应位
  100.    Stop_I2c();                  //结束总线
  101.   return(Val);
  102.  }
  103. /*------------------------------------------------
  104.                写入DA转换数值
  105. 输入参数：dat 表示需要转换的DA数值，范围是0-255
  106. ------------------------------------------------*/
  107. /*bit WriteDAC(unsigned char dat)
  108. {
  109.    Start_I2c();               //启动总线
  110.    SendByte(AddWr);             //发送器件地址
  111.      if(ack==0)return(0);
  112.    SendByte(0x40);            //发送器件子地址
  113.      if(ack==0)return(0);
  114.    SendByte(dat);             //发送数据
  115.      if(ack==0)return(0);
  116.    Stop_I2c();
  117. }*/
  119. ```c
  121. ##### 延时函数模块delay.c
  123. ```c
  124. /*
  125.     Date:2022.03.22
  126.     Author:
  127.     Target:提供延时
  128. */
  130. #include<delay.h>
  132. //uS延时函数，输入参数t，无返回值，延时时间=t*2+5 uS
  133. void DelayUs2x(unsigned int t)
  134. {
  135.     while(--t);
  136. }
  138. //mS延时函数，输入参数t,无返回值，延时时间1mS
  139. void DelayMs(unsigned int t)
  140. {
  141.     while(t--)
  142.     {
  143.         DelayUs2x(245);
  144.         DelayUs2x(245);
  145.     }
  146. }   
  1. #ifndef _DELAY_H_
  2. #define _DELAY_H_
  3. void DelayUs2x(unsigned int t);
  4. void DelayMs(unsigned int t);
  5. #endif
数码管驱动函数模块display.c
  1. /*
  2.     Date:2022.03.22
  3.     Author:
  4.     Target:数码管驱动
  5. */
  7. #include<display.h>
  8. #include<delay.h>
  10. #define DataPort P0 //定义数据端口 程序中遇到DataPort 则用P0 替换
  11. //sbit LATCH1 = P2^0;//定义锁存使能端口 段锁存
  12. //sbit LATCH2 = P2^3;//                 位锁存
  13. extern bit ReadADFlag;//extern声明，不是定义，外部变量
  14. unsigned char code dofly_DuanMa[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};// 显示段码值0~9
  15. unsigned char code dofly_WeiMa[] = {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//分别对应相应的数码管点亮,即位码
  16. unsigned char TempData[8]; //存储显示值的全局变量
  18. /*
  19. 显示函数，动态扫描数码管，
  20. 参数FirstBit 表示需要显示的是第一位，比如0就是从第一个数码管显示，2就是从第三个数码管显示，
  21. 参数Num表示要显示的位数，也就是几个数码管显示，如要显示两位数，就应该输入2
  22. */
  23. void Display(unsigned char FirstBit,unsigned char Num)
  24. {
  25.     static unsigned char i = 0;
  27.     DataPort=0;   //清空数据，防止有交替重影
  28.     LATCH1=1;     //段锁存
  29.     LATCH1=0;
  31.     DataPort=dofly_WeiMa[i+FirstBit]; //取位码
  32.     LATCH2=1;     //位锁存
  33.     LATCH2=0;
  35.     DataPort=TempData[i]; //取显示数据，段码
  36.     LATCH1=1;     //段锁存
  37.     LATCH1=0;
  39.     i++;
  40.     if(i==Num)
  41.         i=0;
  42. }
  44. /*  定时器初始化  */
  45. void Init_Timer0(void)
  46. {
  47.     TMOD |= 0x01;     //使用模式1，16位定时器，使用"|"符号可以在使用多个定时器时不受影响
  48.     EA=1;            //总中断打开
  49.     ET0=1;           //定时器中断打开
  50.     TR0=1;           //定时器开关打开
  51. }
  53. /*  定时器中断子程序    */
  54. void Init_Timer0_isr(void) interrupt 1
  55. {
  56.     static unsigned int num;
  57.     TH0=(65536-2000)/256;         //重新赋值 高位 低位
  58.     TL0=(65536-2000)%256;         //可以理解成，提前减去2000，就是2ms倒计时
  60.     Display(0,8);       // 调用数码管扫描
  61.     num++;
  62.     if(num==50)        //中断50次，大致100ms
  63.     {
  64.         num = 0;
  65.         ReadADFlag=1;//AD标志位1
  66.     }
  67. }
  1. #include<reg52.h>
  3. #ifndef __DISPLAY_H__
  4. #define __DISPLAY_H__
  6. #define DataPort P0 //定义数据端口 程序中遇到DataPort 则用P0 替换
  7. sbit LATCH1=P2^2;//定义锁存使能端口 段锁存
  8. sbit LATCH2=P2^3;//               位锁存
  10. extern unsigned char TempData[8]; //存储显示值的全局变量
  11. extern unsigned char code dofly_DuanMa[10];
  13. void Display(unsigned char FirstBit,unsigned char Num);
  15. void Init_Timer0(void);
  17. #endif
i2c驱动函数模块i2c.c
  1. /*
  2.     Date:2022.03.22
  3.     Author:
  4.     Target:i2c驱动
  5. */
  7. #include <i2c.h>
  8. #include <delay.h>
  10. #define  _Nop()  _nop_()  //定义空指令 一个空指令大致为1us
  12. bit ack;
  14. sbit SDA=P2^1;//数据线
  15. sbit SCL=P2^0;//时钟线
  17. /*  启动i2c总线  */
  18. void Start_I2c()
  19. {
  20.   SDA=1;   //发送起始条件的数据信号
  21.   _Nop();
  22.   SCL=1;
  23.   _Nop();    //起始条件建立时间大于4.7us,延时
  24.   _Nop();
  25.   _Nop();
  26.   _Nop();
  27.   _Nop();
  28.   SDA=0;     //发送起始信号
  29.   _Nop();    //起始条件锁定时间大于4μ
  30.   _Nop();
  31.   _Nop();
  32.   _Nop();
  33.   _Nop();
  34.   SCL=0;    //钳住I2C总线，准备发送或接收数据
  35.   _Nop();
  36.   _Nop();
  37. }
  39. /*  关闭i2c总线 */
  40. void Stop_I2c()
  41. {
  42.   SDA=0;    //发送结束条件的数据信号
  43.   _Nop();   //发送结束条件的时钟信号
  44.   SCL=1;    //结束条件建立时间大于4μ
  45.   _Nop();
  46.   _Nop();
  47.   _Nop();
  48.   _Nop();
  49.   _Nop();
  50.   SDA=1;    //发送I2C总线结束信号
  51.   _Nop();
  52.   _Nop();
  53.   _Nop();
  54.   _Nop();
  55. }
  57. /*
  58. 发送字节数据
  59. 将数据c发送出去,可以是地址,也可以是数据,发完后等待应答,并对
  60. 此状态位进行操作.(不应答或非应答都使ack=0 假)
  61. 发送数据正常，ack=1; ack=0表示被控器无应答或损坏。
  62. */
  63. void  SendByte(unsigned char c)
  64. {
  65.  unsigned char BitCnt;
  67.  for(BitCnt=0;BitCnt<8;BitCnt++)  //要传送的数据长度为8位
  68.     {
  69.      if((c<<BitCnt)&0x80)   //把c左移7位，但c本身的值是不会变的
  70.         SDA=1;   //判断发送位
  71.        else  SDA=0;
  72.      _Nop();
  73.      SCL=1;               //置时钟线为高，通知被控器开始接收数据位
  74.       _Nop();
  75.       _Nop();             //保证时钟高电平周期大于4μ
  76.       _Nop();
  77.       _Nop();
  78.       _Nop();
  79.      SCL=0;
  80.     }
  82.     _Nop();
  83.     _Nop();
  84.     SDA=1;               //8位发送完后释放数据线，准备接收应答位
  85.     _Nop();
  86.     _Nop();
  87.     SCL=1;
  88.     _Nop();
  89.     _Nop();
  90.     _Nop();
  91.     if(SDA==1)
  92.     ack=0;
  93.     else ack=1;        //判断是否接收到应答信号
  94.     SCL=0;
  95.     _Nop();
  96.     _Nop();
  97. }
  99. /*
  100. 接受字节数据
  101. 用来接收从器件传来的数据,并判断总线错误(不发应答信号)，发完后请用应答函数。
  102. */
  103. unsigned char  RcvByte()
  104. {
  105.   unsigned char retc;
  106.   unsigned char BitCnt;
  108.   retc=0;
  109.   SDA=1;             //置数据线为输入方式
  110.   for(BitCnt=0;BitCnt<8;BitCnt++)
  111.       {
  112.         _Nop();
  113.         SCL=0;       //置时钟线为低，准备接收数据位
  114.         _Nop();
  115.         _Nop();      //时钟低电平周期大于4.7us
  116.         _Nop();
  117.         _Nop();
  118.         _Nop();
  119.         SCL=1;       //置时钟线为高使数据线上数据有效
  120.         _Nop();
  121.         _Nop();
  122.         retc=retc<<1;
  123.         if(SDA==1)retc=retc+1; //读数据位,接收的数据位放入retc中
  124.         _Nop();
  125.         _Nop();
  126.       }
  127.   SCL=0;
  128.   _Nop();
  129.   _Nop();
  130.   return(retc);
  131. }
  133. /*----------------------------------------------------------------
  134.                      应答子函数
  135. 原型:  void Ack_I2c(void);
  137. ----------------------------------------------------------------*/
  138. /*void Ack_I2c(void)
  139. {
  141.   SDA=0;
  142.   _Nop();
  143.   _Nop();
  144.   _Nop();
  145.   SCL=1;
  146.   _Nop();
  147.   _Nop();              //时钟低电平周期大于4μ
  148.   _Nop();
  149.   _Nop();
  150.   _Nop();
  151.   SCL=0;               //清时钟线，钳住I2C总线以便继续接收
  152.   _Nop();
  153.   _Nop();
  154. }*/
  155. /*----------------------------------------------------------------
  156.                      非应答子函数
  157. 原型:  void NoAck_I2c(void);
  159. ----------------------------------------------------------------*/
  160. void NoAck_I2c(void)
  161. {
  163.   SDA=1;
  164.   _Nop();
  165.   _Nop();
  166.   _Nop();
  167.   SCL=1;
  168.   _Nop();
  169.   _Nop();              //时钟低电平周期大于4μ
  170.   _Nop();
  171.   _Nop();
  172.   _Nop();
  173.   SCL=0;                //清时钟线，钳住I2C总线以便继续接收
  174.   _Nop();
  175.   _Nop();
  176. }
  178. /*----------------------------------------------------------------
  179.                     向无子地址器件发送字节数据函数
  180. 函数原型: bit  ISendByte(unsigned char sla,ucahr c);
  181. 功能:     从启动总线到发送地址，数据，结束总线的全过程,从器件地址sla.
  182.            如果返回1表示操作成功，否则操作有误。
  183. 注意：    使用前必须已结束总线。
  184. ----------------------------------------------------------------*/
  185. /*bit ISendByte(unsigned char sla,unsigned char c)
  186. {
  187.    Start_I2c();               //启动总线
  188.    SendByte(sla);             //发送器件地址
  189.      if(ack==0)return(0);
  190.    SendByte(c);               //发送数据
  191.      if(ack==0)return(0);
  192.   Stop_I2c();                 //结束总线
  193.   return(1);
  194. }
  195. */
  197. /*----------------------------------------------------------------
  198.                     向有子地址器件发送多字节数据函数
  199. 函数原型: bit  ISendStr(unsigned char sla,unsigned char suba,ucahr *s,unsigned char no);
  200. 功能:     从启动总线到发送地址，子地址,数据，结束总线的全过程,从器件
  201.           地址sla，子地址suba，发送内容是s指向的内容，发送no个字节。
  202.            如果返回1表示操作成功，否则操作有误。
  203. 注意：    使用前必须已结束总线。
  204. ----------------------------------------------------------------*/
  205. /*bit ISendStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char no)
  206. {
  207.    unsigned char i;
  208.  for(i=0;i<no;i++)
  209.     {
  210.    Start_I2c();               //启动总线
  211.    SendByte(sla);             //发送器件地址
  212.      if(ack==0)return(0);
  213.    SendByte(suba);            //发送器件子地址
  214.      if(ack==0)return(0); 
  216.      SendByte(*s);            //发送数据
  217.        if(ack==0)return(0);
  218.      Stop_I2c();                  //结束总线
  219.      DelayMs(1);               //必须延时等待芯片内部自动处理数据完毕
  220.      s++;
  221.      suba++;
  222.     }
  223.   return(1);
  224. }
  225. */
  226. /*----------------------------------------------------------------
  227.                     向无子地址器件读字节数据函数
  228. 函数原型: bit  IRcvByte(unsigned char sla,ucahr *c);
  229. 功能:     从启动总线到发送地址，读数据，结束总线的全过程,从器件地
  230.           址sla，返回值在c.
  231.            如果返回1表示操作成功，否则操作有误。
  232. 注意：    使用前必须已结束总线。
  233. ----------------------------------------------------------------*/
  234. /*bit IRcvByte(unsigned char sla,unsigned char *c)
  235. {
  236.    Start_I2c();                //启动总线
  237.    SendByte(sla+1);            //发送器件地址
  238.      if(ack==0)return(0);
  239.    *c=RcvByte();               //读取数据
  240.      NoAck_I2c();              //发送非就答位
  241.      Stop_I2c();               //结束总线
  242.   return(1);
  243. }
  245. */
  246. /*----------------------------------------------------------------
  247.                     向有子地址器件读取多字节数据函数
  248. 函数原型: bit  ISendStr(unsigned char sla,unsigned char suba,ucahr *s,unsigned char no);
  249. 功能:     从启动总线到发送地址，子地址,读数据，结束总线的全过程,从器件
  250.           地址sla，子地址suba，读出的内容放入s指向的存储区，读no个字节。
  251.            如果返回1表示操作成功，否则操作有误。
  252. 注意：    使用前必须已结束总线。
  253. ----------------------------------------------------------------*/
  254. /*bit IRcvStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char no)
  255. {
  256.    unsigned char i;
  258.    Start_I2c();               //启动总线
  259.    SendByte(sla);             //发送器件地址
  260.      if(ack==0)return(0);
  261.    SendByte(suba);            //发送器件子地址
  262.      if(ack==0)return(0);
  264.    Start_I2c();
  265.    SendByte(sla+1);
  266.       if(ack==0)return(0);
  268.   for(i=0;i<no-1;i++)
  269.     {
  270.      *s=RcvByte();              //发送数据
  271.       Ack_I2c();                //发送就答位
  272.      s++;
  273.     }
  274.    *s=RcvByte();
  275.     NoAck_I2c();                 //发送非应位
  276.     Stop_I2c();                    //结束总线
  277.   return(1);
  278. }
  279. */

  2. #ifndef __I2C_H__
  3. #define __I2C_H__  
  5. #include <reg52.h>          //头文件的包含
  6. #include <intrins.h>
  8. #define  _Nop()  _nop_()        //定义空指令
  10. /*------------------------------------------------
  11.                     启动总线
  12. ------------------------------------------------*/
  13. void Start_I2c();
  14. /*------------------------------------------------
  15.                     结束总线
  16. ------------------------------------------------*/
  17. void Stop_I2c();
  18. /*----------------------------------------------------------------
  19.                  字节数据传送函数
  20. 函数原型: void  SendByte(unsigned char c);
  21. 功能:  将数据c发送出去,可以是地址,也可以是数据,发完后等待应答,并对
  22.      此状态位进行操作.(不应答或非应答都使ack=0 假)
  23.      发送数据正常，ack=1; ack=0表示被控器无应答或损坏。
  24. ------------------------------------------------------------------*/
  25. void  SendByte(unsigned char c);
  26. /*----------------------------------------------------------------
  27.                  字节数据传送函数
  28. 函数原型: unsigned char  RcvByte();
  29. 功能:  用来接收从器件传来的数据,并判断总线错误(不发应答信号)，
  30.      发完后请用应答函数。
  31. ------------------------------------------------------------------*/
  32. unsigned char  RcvByte();
  33. /*----------------------------------------------------------------
  34.                      应答子函数
  35. 原型:  void Ack_I2c(void);
  36. ----------------------------------------------------------------*/
  37. void Ack_I2c(void);
  38. /*----------------------------------------------------------------
  39.                      非应答子函数
  40. 原型:  void NoAck_I2c(void);
  41. ----------------------------------------------------------------*/
  42. void NoAck_I2c(void);
  43. /*----------------------------------------------------------------
  44.                     向无子地址器件发送字节数据函数
  45. 函数原型: bit  ISendByte(unsigned char sla,ucahr c);
  46. 功能:     从启动总线到发送地址，数据，结束总线的全过程,从器件地址sla.
  47.            如果返回1表示操作成功，否则操作有误。
  48. 注意：    使用前必须已结束总线。
  49. ----------------------------------------------------------------*/
  50. bit ISendByte(unsigned char sla,unsigned char c);
  52. /*----------------------------------------------------------------
  53.                     向有子地址器件发送多字节数据函数
  54. 函数原型: bit  ISendStr(unsigned char sla,unsigned char suba,ucahr *s,unsigned char no);
  55. 功能:     从启动总线到发送地址，子地址,数据，结束总线的全过程,从器件
  56.           地址sla，子地址suba，发送内容是s指向的内容，发送no个字节。
  57.            如果返回1表示操作成功，否则操作有误。
  58. 注意：    使用前必须已结束总线。
  59. ----------------------------------------------------------------*/
  60. bit ISendStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char no);
  62. /*----------------------------------------------------------------
  63.                     向无子地址器件读字节数据函数
  64. 函数原型: bit  IRcvByte(unsigned char sla,ucahr *c);
  65. 功能:     从启动总线到发送地址，读数据，结束总线的全过程,从器件地
  66.           址sla，返回值在c.
  67.            如果返回1表示操作成功，否则操作有误。
  68. 注意：    使用前必须已结束总线。
  69. ----------------------------------------------------------------*/
  70. bit IRcvByte(unsigned char sla,unsigned char *c);
  71. /*----------------------------------------------------------------
  72.                     向有子地址器件读取多字节数据函数
  73. 函数原型: bit  ISendStr(unsigned char sla,unsigned char suba,ucahr *s,unsigned char no);
  74. 功能:     从启动总线到发送地址，子地址,读数据，结束总线的全过程,从器件
  75.           地址sla，子地址suba，读出的内容放入s指向的存储区，读no个字节。
  76.            如果返回1表示操作成功，否则操作有误。
  77. 注意：    使用前必须已结束总线。
  78. ----------------------------------------------------------------*/
  79. bit IRcvStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char no);
  81. #endif
串口通讯函数模块uart.c
  1. #include <reg52.h> //包含头文件，一般情况不需要改动，头文件包含特殊功能寄存器的定义
  2. #include "delay.h"
  3. #include <uart.h>
  5. //串口初始化
  6.  void InitUART  (void)
  7. {
  9.     SCON  = 0x50;               // SCON: 模式 1, 8-bit UART, 使能接收
  10.     TMOD |= 0x20;               // TMOD: timer 1, mode 2, 8-bit 重装
  11.     TH1   = 0xFD;               // TH1:  重装值 9600 波特率 晶振 11.0592MHz
  12.     TR1   = 1;                  // TR1:  timer 1 打开
  13.     EA    = 1;                  //打开总中断
  14.     //ES    = 1;                  //打开串口中断
  15. }        
  17. //发送一个字节
  18. void SendByte1(unsigned char dat)
  19. {
  20.  SBUF = dat;
  21.  while(!TI);
  22.       TI = 0;
  23. }
  25. //发送一个字符串
  26. void SendStr1(unsigned char *s)
  27. {
  28.  while(*s!=0xff)// \0 表示字符串结束标志，通过检测是否字符串末尾
  29.   {
  30.   SendByte1(*s);
  31.   s++;
  32.   }
  33. }
  1. #ifndef __uart_H__
  2. #define __uart_H__  
  4. void InitUART  (void);
  6. void SendByte1(unsigned char dat);
  8. void SendStr1(unsigned char *s);
  10. #endif
上位机部分程序
  1. namespace 微机上位机
  2. {
  3.     public partial class Form1 : Form
  4.     {
  5.     //初始化
  6.         private void Form1_Load(object sender, EventArgs e)
  7.         {
  8.             comboBox1.Text = "COM1";
  9.             comboBox2.Text = "9600";
  10.             serialPort1.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(senddata);
  11.         }
  13.     //接受数据
  14.         private void senddata(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
  15.         {
  16.             length = serialPort1.BytesToRead;   //获取缓冲区字节数
  17.             serialPort1.Read(R_data, 0, length);
  18.             this.Invoke(new EventHandler(display));
  19.         }
  21.     //显示数据
  22.         private void display(object sender, EventArgs e)
  23.         {
  24.             double[] sample = new double[8];
  25.             sample[0] = (Convert.ToDouble(R_data[0])) / 10;
  26.             sample[1] = (Convert.ToDouble(R_data[1])) / 10;
  27.             sample[2] = (Convert.ToDouble(R_data[2])) / 10;
  28.             sample[3] = (Convert.ToDouble(R_data[3])) / 10;
  29.             sample[4] = (Convert.ToDouble(R_data[4])) / 10;
  30.             sample[5] = (Convert.ToDouble(R_data[5])) / 10;
  31.             sample[6] = (Convert.ToDouble(R_data[6])) / 10;
  32.             sample[7] = (Convert.ToDouble(R_data[7])) / 10;
  34.             textBox1.Text = sample[0].ToString();
  35.             textBox2.Text = sample[1].ToString();
  36.             textBox3.Text = sample[2].ToString();
  37.             textBox4.Text = sample[3].ToString();
  38.             textBox5.Text = sample[0].ToString();
  39.             textBox6.Text = sample[1].ToString();
  40.             textBox7.Text = sample[2].ToString();
  41.             textBox8.Text = sample[3].ToString();
  42.             textBox9.Text = sample[4].ToString();
  43.             textBox10.Text = sample[5].ToString();
  44.             textBox11.Text = sample[6].ToString();
  45.             textBox12.Text = sample[7].ToString();
  46.             ovalShape1.FillColor = Color.LightGreen;
  47.             ovalShape2.FillColor = Color.LightGreen;
  48.             ovalShape3.FillColor = Color.LightGreen;
  49.             ovalShape4.FillColor = Color.LightGreen;
  50.             ovalShape5.FillColor = Color.LightGreen;
  51.             ovalShape6.FillColor = Color.LightGreen;
  52.             ovalShape7.FillColor = Color.LightGreen;
  53.             ovalShape8.FillColor = Color.LightGreen;
  54.             ovalShape9.FillColor = Color.LightGreen;
  55.             ovalShape10.FillColor = Color.LightGreen;
  56.             ovalShape11.FillColor = Color.LightGreen;
  57.             ovalShape12.FillColor = Color.LightGreen;
  59.         }
  61.     //开启串口
  62.         private void button1_Click_1(object sender, EventArgs e)
  63.         {
  64.             R_Flag = 1;
  65.             serialPort1.ReceivedBytesThreshold = 4;
  66.             serialPort1.RtsEnable = true;
  67.             if (serialPort1.IsOpen)
  68.             {
  69.                 try
  70.                 {
  71.                     timer1.Stop();
  72.                     serialPort1.Close();
  73.                     button1.Text = "打开串口";
  74.                 }
  75.                 catch
  76.                 {
  77.                     MessageBox.Show("端口错误", "Error");
  78.                     button1.Text = "关闭串口";
  79.                 }
  80.             }
  81.             else
  82.             {
  83.                 try
  84.                 {
  85.                     serialPort1.PortName = comboBox1.Text;
  86.                     serialPort1.BaudRate = Convert.ToInt16(comboBox2.Text, 10);
  87.                     serialPort1.Parity = System.IO.Ports.Parity.None;
  88.                     serialPort1.StopBits = System.IO.Ports.StopBits.One;
  89.                     serialPort1.DataBits = 8;
  90.                     serialPort1.Open();
  91.                     timer1.Start();
  92.                     button1.Text = "关闭串口";
  93.                 }
  94.                 catch
  95.                 {
  96.                     MessageBox.Show("端口错误", "Error");
  97.                     serialPort1.Close();
  98.                     button1.Text = "打开串口";
  99.                 }
  100.             }
  101.         }
  103.     //配置报文长度
  104.         private void button2_Click(object sender, EventArgs e)
  105.         {
  106.             serialPort1.ReceivedBytesThreshold = Convert.ToInt16(textBox13.Text, 10);
  107.         }
  109.     }
  110. }

关键程序设计

延时模块

12MHz晶振，一个指令周期大约是1μs，这里封装了两个函数，一个μs级别的，一个ms级别的。

  1. //uS延时函数，输入参数t，无返回值，延时时间=t*2+5 uS
  2. void DelayUs2x(unsigned int t)
  3. {
  4.     while(--t);
  5. }
  7. //mS延时函数，输入参数t,无返回值，延时时间1mS
  8. void DelayMs(unsigned int t)
  9. {
  10.     while(t--)
  11.     {
  12.         DelayUs2x(245);
  13.         DelayUs2x(245);
  14.     }
  15. }

数码管驱动模块

段码位码的的编写
  1. unsigned char code dofly_DuanMa[10] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};// 显示段码值0~9
  2. unsigned char code dofly_WeiMa[] = {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//分别对应相应的数码管点亮,即位码
  3. unsigned char TempData[8]; //存储显示值的全局变量

这里是使用到了一个小工具：段码值分别编写0-9的数值。

位码则是8位，比如fd代表1111 1101

使用的芯片属于锁存器，打开或者关闭制定锁存器，就可实现数据的显示。

定时器模块的调用
  1. /*  定时器初始化  */
  2. void Init_Timer0(void)
  3. {
  4.     TMOD |= 0x01;     //使用模式1，16位定时器，使用"|"符号可以在使用多个定时器时不受影响
  5.     EA=1;            //总中断打开
  6.     ET0=1;           //定时器中断打开
  7.     TR0=1;           //定时器开关打开
  8. }
  10. /*  定时器中断子程序    */
  11. void Init_Timer0_isr(void) interrupt 1
  12. {
  13.     static unsigned int num;
  14.     TH0=(65536-2000)/256;         //重新赋值 高位 低位
  15.     TL0=(65536-2000)%256;         //可以理解成，提前减去2000，就是2ms倒计时
  17.     Display(0,8);       // 调用数码管扫描
  18.     num++;
  19.     if(num==50)        //中断50次，大致100ms
  20.     {
  21.         num = 0;
  22.         ReadADFlag=1;//AD标志位1
  23.     }
  24. }

定时器初始化，定时器有四个模式，这里选择模式1，十六位定时器/计数器。

把数码管扫描函数，放到中断函数中，每隔100ms扫描一次。

i2c模块的编写

数据线，时钟线，主要参考时序图，什么时候开始发送数据，什么时候结束发送数据。一个空指令是1μs。

  1. /*  启动i2c总线  */
  2. void Start_I2c()
  3. {
  4.   SDA=1;   //发送起始条件的数据信号
  5.   _Nop();
  6.   SCL=1;
  7.   _Nop();    //起始条件建立时间大于4.7us,延时
  8.   _Nop();
  9.   _Nop();
  10.   _Nop();
  11.   _Nop();
  12.   SDA=0;     //发送起始信号
  13.   _Nop();    //起始条件锁定时间大于4μ
  14.   _Nop();
  15.   _Nop();
  16.   _Nop();
  17.   _Nop();
  18.   SCL=0;    //钳住I2C总线，准备发送或接收数据
  19.   _Nop();
  20.   _Nop();
  21. }
  23. /*  关闭i2c总线 */
  24. void Stop_I2c()
  25. {
  26.   SDA=0;    //发送结束条件的数据信号
  27.   _Nop();   //发送结束条件的时钟信号
  28.   SCL=1;    //结束条件建立时间大于4μ
  29.   _Nop();
  30.   _Nop();
  31.   _Nop();
  32.   _Nop();
  33.   _Nop();
  34.   SDA=1;    //发送I2C总线结束信号
  35.   _Nop();
  36.   _Nop();
  37.   _Nop();
  38.   _Nop();
  39. }

串口通讯模块的编写

发送字符串，要在最后设置一个校验位，就是告诉计算机，这次的数据发完了，停下吧。

  1. //发送一个字符串
  2. void SendStr1(unsigned char *s)
  3. {
  4.  while(*s!=0xff)// ff表示数据发完了
  5.   {
  6.   SendByte1(*s);
  7.   s++;
  8.   }
  9. }

主函数模块的数据数据处理

读取到的数据是一个0~256（二的八次方）之间的数，参考电压这里是5V，所以要把读取到的数带入公式中计算，然后分小数点前的数据，因为要在数码管显示，所以|0x80，加上小数点，小数点后直接保留就好。

  1. //连续读5次，输入通道后多读几次，取最后一次值，以便读出稳定值
  2.  for(i=0;i<5;i++)
  3.     num0=ReadADC(0);
  4.   num0=num0*5*10/256;// x10表示把实际值扩大10，如4.5 变成 45 方便做下一步处理 x5 表示基准电压5V
  5.   TempData[0]=dofly_DuanMa[num0/10]|0x80;
  6.   TempData[1]=dofly_DuanMa[num0%10];

通讯部分数据处理，十六进制的数据报文。

  1.  VoltData[0]=num0;
  2.  VoltData[1]=num1;
  3.  VoltData[2]=num2;
  4.  VoltData[3]=num3;
  5.  VoltData[4]=0xff;
  7. SendStr1(VoltData);
  8. DelayMs(240);//延时循环发送
  9. DelayMs(240);

CAN总线收发节点设计的更多相关文章

  1. TX2平台CAN总线收发功能的测试

    前言 项目实现过程中需要将获取的数据信息通过CAN总线传输到控制规划模块,本文主要介绍如何在TX2平台测试CAN总线的收发功能. TX2是英伟达旗下为嵌入式平台人工智能应用开发出的一个硬件平台,TX1 ...

  2. CAN总线多节点通信异常分析及解决

    一.CAN物理层特征 CAN收发器的作用是负责逻辑电平和信号电平之间的转换.即从CAN控制芯片输出逻辑电平到CAN收发器,然后经过CAN收发器内部转换将逻辑电平转换为差分信号输出到CAN总线上,CAN ...

  3. CAN总线中节点ID相同会怎样？

    CAN-bus网络中原则上不允许两个节点具有相同的ID段,但如果两个节点ID段相同会怎样呢? 实验前,我们首先要对CAN报文的结构组成.仲裁原理有清晰的认识. 一.CAN报文结构 目前使用最广泛的CA ...

  4. 由RS-232串口到PROFIBUS-DP总线的转换接口设计

    转自:http://gongkong.ofweek.com/2013-08/ART-310007-11001-28716256_2.html 1.PROFIBUS-DP网络协议 PROFIBUS的网络 ...

  5. 基于 FPGA 的 PCIE 总线 Linux 驱动设计

    硬件平台 Kintex ®-7 family of FPGAs Intel X86 软件平台 Linux 4.15.0-36-generic #39~16.04.1-Ubuntu Xilinx xap ...

  6. SOA实践之基于服务总线的设计

    在上文中,主要介绍了SOA的概念,什么叫做“服务”,“服务”应该具备哪些特性.本篇中,我将介绍SOA的一种很常见的设计实践--基于服务总线的设计. 基于服务总线的设计 基于总线的设计,借鉴了计算机内部 ...

  7. SOA服务总线设计

    背景 基于总线的设计,借鉴了计算机内部硬件组成的设计思想(通过总线传输数据).在分布式系统中,不同子系统之间需要实现相互通信和远程调用,比较直接的方式就是“点对点”的通信方式,但是这样会暴露出一些很明 ...

  8. 基于AHB总线的master读写设计（Verilog）

    一.AHB总线学习 1. AHB总线结构 如图所示,AHB总线系统利用中央多路选择机制实现主机与从机的互联问题.从图中可以看出,AHB总线结构主要可分为三部分:主机.从机.控制部分.控制部分由仲裁器. ...

  9. 探讨CAN总线的抗干扰能力

    探讨CAN总线的抗干扰能力 CAN总线经近20年的发展已步入壮年期,它不仅在汽车领域的应用占据一定优势,在其他工业应用上也生机勃勃.枝繁叶茂.究竟是什么原因使它这么成功?当人们发现它的局限性,又面临新 ...

随机推荐

  1. oracle 中有数据但是sql查询不出来结果（中文）

    如 select * from user where name like '%王%': 无数据: 而数据库中确实有姓王的用户. 配置环境变量 NLS_LANG = AMERICAN_AMERICA.A ...

  2. (leetcode)二叉树的前序遍历-c语言实现

    给定一个二叉树,返回它的 前序 遍历. 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 进阶: 递归算法很简单,你可以通过迭代算法完成吗? 前序遍历 前序遍历首先 ...

  3. Rsync反弹shell

    vulhub环境靶机 : 192.168.91.130 攻击机:kali 192.168.91.128 一.环境搭建 vulhub环境靶机环境搭建 ​ 在纯净ubuntu中部署vulhub环境: 1. ...

  4. python写一个web目录扫描器

    用到的模块urliib error #coding = utf-8 #web目录扫描器 by qianxiao996 #博客地址:https://blog.csdn.net/qq_36374896 i ...

  5. Cobalt Strike之LINK木马

    在同一目录下 新建一个exp.ps1 一个test.txt exp.ps1代码 $file = Get-Content "test.txt" $WshShell = New-Obj ...

  6. loj2341「WC2018」即时战略(随机化，LCT/动态点分治)

    loj2341「WC2018」即时战略(随机化,LCT/动态点分治) loj Luogu 题解时间 对于 $ datatype = 3 $ 的数据,explore操作次数只有 $ n+log n $ ...

  7. 12.19 file 与io流

    12.19 file与io流 File 1. 新建文件或者文件夹 新建文件 File F = new File(pathname:"路径+文件名");Boolean flag = ...

  8. BIO、NIO、AIO的区别

    一.基本概念 1.BIO:同步阻塞IO 2.NIO:同步非阻塞IO 3.AIO:异步阻塞IO IO操作包括两部分,发起IO请求.IO数据读写.阻塞非阻塞主要针对线程发起IO请求之后是否立即返回来定义的 ...

  9. (转载)mos管电压规格是什么，什么是VMOS管栅极

    电压规格:VDSS.VDS.BVDSS.V(BR)DSS VDSS中的"V"表示电压,前面的"D"."S"表示"Drain&quo ...

  10. 转载：STL常用容器的底层数据结构实现

    转载至:https://blog.csdn.net/qq_28584889/article/details/88763090 vector :底层数据结构为数组,支持快速随机访问 list:底层数据结 ...