标题: MCU51-PC通讯协议 [打印本页]

作者: 51黑黑黑    时间: 2016-2-13 02:54
标题: MCU51-PC通讯协议
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                Copyright (c) 2016, 老马工作室                            */
  4. /*                     All rights reserved.                                 */
  5. /*                                                                          */
  6. /*      Email:pcwebmaster@163.com                                           */
  7. /****************************************************************************/
  8. /****************************************************************************/
  9. /* 文 件 名:comint.c                                                       */
  10. /* 版    本:Version 1.0                                                    */
  11. /* 描    述:串行口中断带通讯协议测试                                       */
  12. /* 主控芯片:STC89LE54RD*/
  13. /* 晶振频率:22.1184MHz*/
  14. /* 作    者:pcwebmaster                                                    */
  15. /* 函    数:                                                               */
  16. /*         system_init                                                     */
  17. /*         com_send_command                                                */
  18. /*         com_command_receive*/
  19. /*CalCRC16_1021*/
  20. /*command_decoder*/
  21. /*send_command*/
  22. /* 测    试: 发送:16 16 02 01 02 01 00 35 03 94 BD接收:49 16 16 06 AA 55 */
  23. /* 测试现象:P05/P06/P07三个LED取反*/
  24. /* 历史记录:20016.02.09测试通过                                            */
  25. /* 北极狼          20016-02-09     Creat Inital version. (Version 1.0)      */
  26. /****************************************************************************/
  27. #include "comint.h"

  28. void main(void)
  29. {
  30.     u_char i = 0;
  31.     system_init();   
  32.     while(1)
  33.     {
  34.         com_command_receive();
  35.     }
  36. }


  37. #include "comint.h"

  38. u_char  data  pint_buf[MAX_RINTL];   /* 串口接收缓冲区       */
  39. u_char  data  pint_read;             /* 串口缓冲区读指针     */
  40. u_char  data  pint_write;            /* 串口缓冲区写指针     */
  41. u_char  data  psend_int;             /* 串口发送允许标志     */
  42. u_char serial_flag = 0;              /* 串口接收数据标志位   */


  43. u_char  idata prec_buf[MAX_COMMAND_LEN];/* 命令接收缓冲区    */
  44. u_char  prec_num;                    /* 命令接收缓冲区字节数 */

  45. u_char serial_lengthl = 0;           /* 消息命令长度低8位    */
  46. u_int  serial_length = 0;            /* 消息命令长度16位     */

  47. u_char ADDRESS[2]={ZU,ZHAN};       /* byte0:通讯组地址, byte1:开发板地址 */

  48. /* 串口发送一个字节 */
  49. void com_send_command(char onebyte)
  50. {
  51.     psend_int = 0;
  52.     SBUF = onebyte;
  53.     while (psend_int != 1);
  54. }

  55. /* 串口接收数据处理 */
  56. void com_command_receive(void)
  57. {
  58.     u_char var1,var4;
  59.     u_int crc_data = 0;
  60.     var4 = pint_read;

  61.     if (var4 != pint_write)
  62.     {
  63.         var1 = pint_buf[var4];
  64.         var4 = var4+1;
  65.         if (var4 >= MAX_RINTL)
  66.             var4=0;

  67.         pint_read = var4;

  68.         switch(serial_flag)
  69.         {
  70.             case 0: /*收到起始位*/
  71.                 if (var1 == SYN)
  72.                 {
  73.                     serial_flag = 1;
  74. //com_send_command(0x01); //测试
  75.                 }
  76.                 else
  77.                 {
  78.                     serial_flag = 0;
  79.                 }
  80.                 break;

  81.             case 1:/*收到起始位*/
  82.                 if (var1 == SYN)
  83.                 {
  84.                     serial_flag = 2;
  85. //com_send_command(0x02); //测试
  86.                 }
  87.                 else
  88.                 {
  89.                     serial_flag = 0;
  90.                 }
  91.                 break;

  92.             case 2:/*收到同步位*/
  93.                 if (var1 == STX)
  94.                 {
  95.                     serial_flag = 3;
  96. //com_send_command(0x03);//测试
  97.                 }
  98.                 else
  99.                 {
  100.                     serial_flag = 0;
  101.                 }
  102.                 break;

  103.             case 3: /*收到组地址*/
  104.                 if (var1 == ADDRESS[0])
  105.                 {
  106.                     serial_flag = 4;
  107.                     prec_num = 1;
  108.                     prec_buf[0] = var1;
  109. //com_send_command(0x04); //测试
  110.                 }
  111.                 else
  112.                 {
  113.                     serial_flag = 0;
  114.                 }
  115.                 break;

  116.             case 4:/*收到本机地址或者广播地址*/
  117.                 if ( (var1 == ADDRESS[1]) || (var1 == 0) )
  118.                 {
  119.                     prec_num = 2;
  120.                     prec_buf[1] = var1;
  121.                     serial_flag = 5;
  122. //com_send_command(0x05); //测试
  123.                 }
  124.                 else
  125.                 {
  126.                     serial_flag = 0;
  127.                 }
  128.                 break;

  129.             case 5:/*数据长度*/
  130.                 prec_num = 3;
  131.                 prec_buf[2] = var1;
  132.                 serial_lengthl = var1;
  133.                 serial_flag = 6;
  134. //com_send_command(0x06);//测试
  135.                 break;

  136.             case 6:
  137.                 prec_num = 4;
  138.                 prec_buf[3] = var1;
  139.                 serial_length |= var1;
  140.                 serial_length = ( (serial_length << 8) & 0xff00 ) + serial_lengthl + 3;
  141.                 serial_flag = 7;
  142. //com_send_command(0x07);//测试
  143.                 break;

  144.             case 7:
  145.                 prec_buf[prec_num] = var1;
  146.                 prec_num++;
  147.                 serial_length--;
  148.                 if (serial_length == 0)
  149.                 {
  150.                     crc_data = CalCRC16_1021(prec_buf, prec_num - 2); /* 计算crc校验和(从组地址开始到ETX )*/

  151.                     if ( ( (crc_data & 0x00ff) == prec_buf[prec_num - 2]) && ( ( (crc_data >>8) & 0x00ff) == prec_buf[prec_num - 1]) ) /* 校验和正确 */
  152.                     {
  153.                         prec_num = 1;
  154.                         var1 = 0;

  155.                         if ( (prec_buf[4] >= 0x31) && (prec_buf[4] <= 0x3b) ) /* 命令有效 */
  156.                         {
  157.                             if (prec_buf[1] != 0x00) /* 如果不是广播地址则回应ACK*/
  158. com_send_command(0x49);//测试                                msg_last_push(MSG_ACK,0);
  159. send_command(ACK); //测试   

  160.                             command_decoder(); /* 如果校验和正确,则进行命令解码 */
  161.                         }
  162.                         else
  163.                         {

  164. send_command(NAK); //测试
  165.                         }
  166.                     }
  167.                     else
  168.                     {

  169. send_command(NAK); //测试
  170.                     }
  171.                     serial_flag = 0;
  172.                     prec_num = 1;
  173.                 }
  174.                 break;

  175.             default:
  176.                 serial_flag = 0;
  177.                 prec_num = 1;
  178.                 break;
  179.         }
  180.     }
  181. }
  182. /* 命令解码子程序 */
  183. void command_decoder(void)
  184. {
  185.     u_char i = 0;

  186.     if (prec_buf[4] == 0x31)       /* 设置报警阈值   */
  187.     {  
  188. P05 = !P05;//测试
  189.         return;
  190.     }
  191.     else if (prec_buf[4] == 0x32)  /* 请求报警阈值 */
  192.     {
  193. P05 = !P06;//测试
  194.         return;
  195.     }
  196.     else if (prec_buf[4] == 0x33)  /* 修改当前时间 */
  197.     {
  198. P07 = !P07;//测试
  199.         return;
  200.     }
  201.     else if (prec_buf[4] == 0x34)  /* 请求当前时间 */
  202.     {
  203. P05 = !P05;//测试
  204. P07 = !P07;//测试
  205.         return;
  206.     }
  207.     else if (prec_buf[4] == 0x35)  /* 请求当前数据 */
  208.     {
  209. com_send_command(0xAA);//测试
  210. com_send_command(0x55);//测试
  211. P0 = ~P0;//测试
  212.         return;
  213.     }
  214.     else if (prec_buf[4] == 0x36)  /* 请求看门狗信息*/
  215.     {
  216. com_send_command(0xFF);//测试
  217.         return;
  218.     }
  219.     else if (prec_buf[4] == 0x37)  /* 请求报警情况 */
  220.     {
  221. com_send_command(0xFF);//测试
  222.         return;
  223.     }
  224.     else if (prec_buf[4] == 0x38)  /* 配置设备地址 */
  225.     {
  226.         ADDRESS[0] = prec_buf[5];  /* 通讯组地址   */
  227.         ADDRESS[1] = prec_buf[6];  /* 站地址   */

  228. com_send_command(0xFF);//测试
  229.         return;
  230.     }
  231.     else if (prec_buf[4] == 0x39)  /* 请求设备地址 */
  232.     {
  233. com_send_command(0xFF);//测试
  234.         return;
  235.     }
  236.     else if (prec_buf[4] == 0x3a)  /* 控制模拟量输出 */
  237.     {
  238. com_send_command(0xFF);//测试
  239.         return;
  240.     }
  241.     else if (prec_buf[4] == 0x3b)  /* 控制开关量输出 */
  242.     {
  243. com_send_command(0xFF);//测试

  244.         return;
  245.     }
  246. }

  247. /* 向PC主机发送消息帧,入口参数:消息类型 */
  248. void send_command(u_char command)
  249. {

  250.     switch (command)
  251.     {
  252.         case ACK:
  253.             com_send_command(SYN);
  254.             com_send_command(SYN);
  255.             com_send_command(ACK);
  256.             break;

  257.         case NAK:
  258.             com_send_command(SYN);
  259.             com_send_command(SYN);
  260.             com_send_command(NAK);
  261.             break;

  262.         default:
  263.             break;
  264.     }
  265. }
  266. void system_init()
  267. {
  268.     u_char loop;

  269.     EA = 0;         /* CPU关中断      */
  270.     pint_read  = 0; /* 串口缓冲读指针 */
  271.     pint_write = 0; /* 串口缓冲写指针 */

  272. //
  273.     SCON = 0x48; //主控芯片STC89LE54RD
  274.     PCON = 0x80;
  275.     TMOD = 0x20;
  276.     TCON = 0x50;
  277.     TH1  = 0xFD;    // 波特率为19200  
  278.     TL1  = 0xFD;
  279.     TR1  = 1;       // 定时器1启动计数*/
  280.     ES   = 1;       /* 串口开中断     */
  281.     PS   = 0;       /* 串口低优先级   */
  282.     REN  = 1;       /* 串口接收允许   */
  283.     EA   = 1;       /* 开CPU中断      */

  284.     loop = SBUF;    /* 清串口缓冲区   */
  285.     for (loop=0; loop<MAX_RINTL; loop++)
  286.     {
  287.         pint_buf[loop] = 0;
  288.     }
  289. }
  290. /*计算CRC校验和使用MTT(0X1021)
  291. 参数:
  292. pBuff 为需计算CRC的缓冲区的头指针
  293. BufferLen 缓冲区长度(以字节计)
  294. */
  295. u_short CalCRC16_1021(u_char x[], u_short BufferLen)
  296. {
  297.     u_short i;
  298.     u_char  j;
  299.     u_short crc16 = 0;
  300.     u_short mask = 0x1021;
  301.     u_char *pByteBuffer;
  302.     u_char tmpbyte;
  303.     u_short calval;

  304.     pByteBuffer = &x[0];

  305.     for (i = 0; i < BufferLen; i++)
  306.     {
  307.         tmpbyte = *pByteBuffer;
  308.         calval = tmpbyte << 8;
  309.         for (j = 0; j < 8; j++)
  310.         {
  311.             if ((crc16 ^ calval) & 0x8000)
  312.                 crc16 = (crc16 << 1) ^ mask;
  313.             else
  314.                 crc16 <<= 1;

  315.             calval <<= 1;
  316.         }
  317.         pByteBuffer++;
  318.     }
  319.     return crc16;
  320. }
  321. /* 串口中断服务程序,使用第3组寄存器 */
  322. void com_int_proc(void) interrupt 4 using 3
  323. {
  324.     u_char temp;
  325.     u_char temp1;

  326.     if (TI == 1)                /* 是发送中断       */
  327.     {
  328.         TI = 0;
  329.         psend_int = 1;          /* 可以发送         */
  330.     }

  331.     if (RI == 1)                /* 是接收中断       */
  332.     {
  333.         RI = 0;                 /* 清串口接收中断   */
  334.         temp1 = SBUF;
  335.         temp  = pint_write + 1; /* 判断是否可以写入 */
  336.         if (temp == MAX_RINTL)
  337.         {
  338.             temp=0;
  339.         }

  340.         if (temp != pint_read)
  341.         {
  342.             pint_buf[pint_write] = temp1; /* 读取数据 */
  343.             pint_write = temp;
  344.         }
  345.     }
  346. }


  347. #ifndef __COMINT_H__
  348. #define __COMINT_H__

  349. #define ZU0x01 /*组地址*///通讯地址修改这两项
  350. #define ZHAN0x02 /*站地址*///通讯地址修改这两项

  351. #include "STC.h"
  352. #include <absacc.h>
  353. #include <intrins.h>
  354. #include <string.h>

  355. typedef unsigned char u_char;
  356. typedef unsigned int  u_int;
  357. typedefunsigned shortu_short;

  358. #define MAX_RINTL        8   /* 串口接收缓冲区长度   */
  359. #define SYN           0x16   /* 通讯同步位*/
  360. #define STX           0x02   /* 通讯起始位*/
  361. #define ETX           0x03   /* 通讯结束位*/

  362. #define ACK           0x06
  363. #define NAK           0x15

  364. #define MSG_ACK          2    /* 正确应答信息         */
  365. #define MSG_NAK          3    /* 错误应答信息         */
  366. #define MAX_COMMAND_LEN  16   /* 串口接受命令长度     */

  367. extern char str_test[25]  ;
  368. extern u_char  data  pint_read;             // 串口缓冲区读指针     */
  369. extern u_char  data  pint_write;            // 串口缓冲区写指针
  370. //extern u_char  data  psend_int;             // 串口发送允许标志   
  371. extern u_char  data  pint_buf[MAX_RINTL];   // 串口接收缓冲区      
  372. extern u_char serial_flag;              /* 串口接收数据标志位   */

  373. extern u_char  idata prec_buf[MAX_COMMAND_LEN];/* 命令接收缓冲区 */

  374. /* 串口发送一个字节 */
  375. extern void com_send_command(char onebyte);
  376. /* 串口接收数据处理 */
  377. extern void com_command_receive(void);
  378. /* 系统初始化 */
  379. extern void system_init();

  380. ///* 串口接收一字节数据 */
  381. //unsigned char UartReadChar(void); //reentrant
  382. /*计算CRC校验和使用MTT(0X1021)
  383. 参数:
  384. pBuff 为需计算CRC的缓冲区的头指针
  385. BufferLen 缓冲区长度(以字节计)
  386. */
  387. u_short CalCRC16_1021(u_char x[], u_short BufferLen);

  388. /* 命令解码子程序 */
  389. void command_decoder(void);
  390. /* 向主机发送消息帧,入口参数:消息类型 */
  391. void send_command(u_char command);

  392. #endif
复制代码



作者: ztx    时间: 2016-2-15 10:04
51黑有你更精彩...................




欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1