标题: STM32 Modbus RTU Master slave源程序sth11驱动 [打印本页]
作者: ben6    时间: 2019-6-9 15:29
标题: STM32 Modbus RTU Master slave源程序sth11驱动
STM32 KEIL编写 Modbus RTU Master slave程序源码

单片机源程序如下:
  1. #include "stm32f10x.h"
  2. #include "modbus.h"
  3. #include "Init_Config.h"
  4. // Mudbus 功能码
  5. #define ReadCoilSta                0x01                // 读位COIL，对应PLC的DO状态
  6. #define ReadHoldReg                0x03                // 读字，对应PLC的AO状态
  7. #define ForceSingleCoil 0x05                // 写位，只写一位COIL，对应PLC的DO输出
  8. #define PresetSingleReg        0x06            // 写字，对单一寄存器赋值，对应PLC的AO输出
  9. #define SlaveID 0x01                                // 从机ID号
  10. unsigned int crc16(unsigned char* puchMsg,unsigned char usDataLen);
  11. unsigned char  n=17,c[17]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  12. // 变量声明
  13. // 保存接收与发送消息的数组
  14. unsigned char        aRxBuff[8];                    // 接收缓冲区
  15. unsigned char        aTxBuff[17];                // 发送缓冲区
  16. volatile unsigned char        nTxBuff = 0;                        // 发送计数
  17. unsigned char   CommIndex=0;                                // 数据位置索引，从0开始，到CommIndexEnd结束
  18. unsigned char   CommIndexEnd=7;                // 接收长度
  19. unsigned char   RecFinishF=0;                                // 是否接收完成标志
  20. unsigned long        RecTimer=0;                                // 通信间隔时间
  21. unsigned char         FreOneH=0x00;                                        //变频器一高位
  22. unsigned char         FreOneL=0x00;
  23. unsigned char         FreTwoH=0x00;                                        //变频器二高位
  24. unsigned char         FreTwoL=0x00;
  25. unsigned char         Run=0x00;                                        //启动
  26. unsigned char         Stop=0x00;                                        //停止
  27. unsigned char         FrePOne=0x00;                                        //点动变频器一
  28. unsigned char         FrePTwo=0x00;                                        //点动变频器二
  29. unsigned char         FrePROne=0x00;                                        //点加变频器一
  30. unsigned char         FrePDOne=0x00;                                        //减
  31. unsigned char         FrePRTwo=0x00;                                        //点加变频器二
  32. unsigned char         FrePDTwo=0x00;                                        //减
  33. unsigned char         FreR=0x00;                                                //变频器统调加
  34. unsigned char         FreD=0x00;                                                //减
  35. /* Table Of CRC Values for high-order unsigned char */
  36. unsigned char auchCRCHi[] = {
  37. 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  38. 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
  39. 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
  40. 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
  41. 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
  42. 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
  43. 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
  44. 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
  45. 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  46. 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
  47. 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
  48. 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
  49. 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  50. 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
  51. 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
  52. 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
  53. 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
  54. 0x40
  55. };

  57. /* Table of CRC values for low-order unsigned char    */
  58. unsigned char auchCRCLo[] = {
  59. 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
  60. 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
  61. 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
  62. 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
  63. 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
  64. 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
  65. 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
  66. 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
  67. 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
  68. 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
  69. 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
  70. 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
  71. 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
  72. 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
  73. 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
  74. 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
  75. 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
  76. 0x40
  77. };
  78. /*###############################################NO
  79. purpose:                        计算CRC16的值
  80. function name:                crc16
  81. return data:                unsigned int
  82. parameters:                        par1:
  83.                                                 name:                 puchMsg
  84.                                                 type:                 unsigned char*
  85.                                                 meaning:        将要计算CRC16值的
  86.                                                                         所有数据
  87.                                         par2：
  88.                                                 name：                usDataLen
  89.                                                 type：                unsigned char
  90.                                                 meaning:        将要计算CRC16值的
  91.                                                                         数据个数                                               
  92. finished time:                2007/5/16
  93. amended time:       
  94. NO###############################################*/


  97. unsigned int crc16(unsigned char* puchMsg,unsigned char usDataLen)
  98. {
  99. unsigned char uchCRCHi = 0xFF ;
  100.   unsigned char uchCRCLo = 0xFF ;
  101.   unsigned int  uIndex  ;
  102.    while (usDataLen--)
  103.      {
  104.         uIndex = uchCRCHi ^ *puchMsg++;
  105.         uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
  106.         uchCRCLo = auchCRCLo[uIndex] ;
  107.      }
  108.         return (((unsigned int)(uchCRCHi) << 8) | uchCRCLo) ;
  109. }

  111. void InitVar_my(void)
  112. {
  113.         RecFinishF=0;
  114.         CommIndex=0;
  115.         CommIndexEnd=7;  // First enlarge recieve lenght
  116.         RecTimer=0;                            
  117. }

  119. void ParseRecieve(void)         //包解析
  120. {
  121.   unsigned int  uIndex ;
  122.         unsigned int crc16tem;
  123.         unsigned char i = 0;
  124.         sendnum=1;
  125.                
  126.         if (aRxBuff[0] == SlaveID)  // 从机ID是否正确
  127.         {
  128.     crc16tem=((unsigned int)(aRxBuff[CommIndexEnd-1]) << 8) | aRxBuff[CommIndexEnd]; // calculate CRC check, erase two CRC byte
  129.     uIndex=crc16(aRxBuff,CommIndexEnd-1);
  130.     if (crc16tem==uIndex)// crc16检校正确
  131.                 {         
  132.                         switch (aRxBuff[1])                                // 判断功能码
  133.                         {
  134.                         case ReadCoilSta:                                 // 0x01
  135.                                 aTxBuff[0]=SlaveID;
  136.                                 aTxBuff[1]=ReadCoilSta;
  137.                                 aTxBuff[2]=0x01;   //字节数         
  138.                                 nTxBuff=4;
  139.                                 switch (aRxBuff[3])                         //判断起始地址
  140.                                 {
  141.                         /*        case 0x32:                   //画面0                                                                   
  142.                                   aTxBuff[3]=Run|Stop|PPback|PPfo|FrePOne|FrePTwo;
  143.                                   break;
  144.                                 case 0x3c:                             //画面1
  145.                                   aTxBuff[3]=TemR|TemD|SignSwD|SignSwS;
  146.                                   break;*/
  147.                                 case 0x46:                             //变频器设定
  148.                                   aTxBuff[3]=FrePROne|FrePDOne|FrePRTwo|FrePDTwo|FreR|FreD;
  149.                                   break;                       
  150.                                 }                         
  151.                                 crc16tem=crc16(aTxBuff,nTxBuff);
  152.                                 aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  153.                                 aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  154.                         /*        for(i = 0; i < nTxBuff+1; i++)
  155.                         {
  156.                               c[i]=aTxBuff[i];
  157.                                         }  */
  158. //                                USART1_Putc(c,n);
  159.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  160.                                 USART_SendData(USART1, aTxBuff[0]);  
  161.                            // sendnum=1;
  162.                                 break;       

  164.                         case ReadHoldReg:                                // 0x03                读取寄存器值
  165.                                 aTxBuff[0]=SlaveID;
  166.                                 aTxBuff[1]=ReadHoldReg;
  167.                                 aTxBuff[2]=aRxBuff[5]*2;                //每个数据占16位 要读的寄存器数量*2 相应的第3个字节
  168.                                 nTxBuff=3;
  169.                         /*        if(aRxBuff[3]==0x0a)
  170.                                  {
  171.                                    aTxBuff[nTxBuff++]=IntendDisH;                       
  172.                                    aTxBuff[nTxBuff++]=IntendDisL;                 //设定袋长
  173.                                    aTxBuff[nTxBuff++]=IntendNumH;                                                              
  174.                                    aTxBuff[nTxBuff++]=IntendNumL;                 //整本数设定
  175.                                    aTxBuff[nTxBuff++]=FailNumH;                                                              
  176.                                    aTxBuff[nTxBuff++]=FailNumL;                     //脱标次数
  177.                                       aTxBuff[nTxBuff++]=AutoRunH;                       
  178.                                    aTxBuff[nTxBuff++]=AutoRunL;                 //自启动时间                                                                    
  179.                                    aTxBuff[nTxBuff++]=IntendSignH;                       
  180.                                    aTxBuff[nTxBuff++]=IntendSignL;                 //追标长度                                  
  181.                                    aTxBuff[nTxBuff++]=TemH;                       
  182.                                    aTxBuff[nTxBuff++]=TemL;                     //切刀加温
  183.                                    crc16tem=crc16(aTxBuff,nTxBuff);
  184.                                    aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  185.                                    aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  186.                                    for(i = 0; i < nTxBuff+1; i++)
  187.                         {
  188.                               c[i]=aTxBuff[i];
  189.                                         }
  190. //                                   USART1_Putc(c,n);
  191.                                    USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  192.                                    USART_SendData(USART1, aTxBuff[0]);  
  193.                                sendnum=1;
  194.                                  }
  195.                                 if(aRxBuff[3]==0x00)
  196.                                   {
  197.                                    aTxBuff[nTxBuff++]=RecNumH;                       
  198.                                    aTxBuff[nTxBuff++]=RecNumL;                     //计数
  199.                                       aTxBuff[nTxBuff++]=GroupH;                       
  200.                                    aTxBuff[nTxBuff++]=GroupL;                     //批次
  201.                                    aTxBuff[nTxBuff++]=IntendVelH;                       
  202.                                    aTxBuff[nTxBuff++]=IntendVelL;                 //速度
  203.                                    aTxBuff[nTxBuff++]=FreOneH;                       
  204.                                    aTxBuff[nTxBuff++]=FreOneL;                     //变频器一速度
  205.                                    aTxBuff[nTxBuff++]=TemH;                       
  206.                                    aTxBuff[nTxBuff++]=TemL;                         //切刀加热
  207.                                    aTxBuff[nTxBuff++]=FreTwoH;                       
  208.                                    aTxBuff[nTxBuff++]=FreTwoL;                     //变频器二速度
  209.                                   
  210.                                    crc16tem=crc16(aTxBuff,nTxBuff);
  211.                                    aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  212.                                    aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  213.                                    for(i = 0; i < nTxBuff+1; i++)
  214.                         {
  215.                               c[i]=aTxBuff[i];
  216.                                         }
  217. //                                   USART1_Putc(c,n);
  218.                                    USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  219.                                    USART_SendData(USART1, aTxBuff[0]);  
  220.                                sendnum=1;
  221.                                   }

  223.                                   */
  224.                                   if(aRxBuff[3]==0x01)
  225.                                   {
  226.                                    aTxBuff[nTxBuff++]=0x01;                       
  227.                                    aTxBuff[nTxBuff++]=0x02;                      //温度高低
  228.                                       aTxBuff[nTxBuff++]=0x03;                       
  229.                                    aTxBuff[nTxBuff++]=0x04;                                  //湿度高低
  230.                                    crc16tem=crc16(aTxBuff,nTxBuff);                        //crc校验函数
  231.                                    aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  232.                                    aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff); //生成校验码 高位加低位
  233.                         /*           for(i = 0; i < nTxBuff+1; i++)        //将相应数据发送出去
  234.                         {
  235.                               c[i]=aTxBuff[i];
  236.                                         }          */
  237.                                         for(i=0;i<9;i++)
  238.                                 {
  239.               USART_SendData(USART1,aTxBuff[i]);
  240.                                   while (!(USART1->SR & USART_FLAG_TXE));
  241.                              }
  242.                         //          USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
  243.                                 /*        USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  244.                                         USART_Cmd(USART1, ENABLE);                                       
  245.                                         USART_SendData(USART1,aTxBuff[0]); */
  246.                                 //        sendnum=1;

  248.                                   }
  249.                                  if(aRxBuff[3]==0x14)
  250.                                  {                                  
  251.                                    aTxBuff[nTxBuff++]=FreOneH;                       
  252.                                    aTxBuff[nTxBuff++]=FreOneL;                     //变频器一
  253.                                       aTxBuff[nTxBuff++]=FreTwoH;                       
  254.                                    aTxBuff[nTxBuff++]=FreTwoL;                         //变频器二

  256.                                    crc16tem=crc16(aTxBuff,nTxBuff);
  257.                                    aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  258.                                    aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  259.                                    for(i = 0; i < nTxBuff+1; i++)
  260.                         {
  261.                               c[i]=aTxBuff[i];
  262.                                         }
  263. //                                   USART1_Putc(c,n);
  264.                                    USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  265.                                    USART_SendData(USART1, aTxBuff[0]);  
  266.                              //  sendnum=1;
  267.                                  }
  268.                                 /* if(aRxBuff[3]==0x1e)
  269.                                  {                                  
  270.                                    aTxBuff[nTxBuff++]=IntendVelH;                       
  271.                                    aTxBuff[nTxBuff++]=IntendVelL;                 //送料速度
  272.                                       aTxBuff[nTxBuff++]=PluseNOH;                       
  273.                                    aTxBuff[nTxBuff++]=PluseNOL;                         //步进脉冲数
  274.                                    aTxBuff[nTxBuff++]=LineH;                       
  275.                                    aTxBuff[nTxBuff++]=LineL;                         //曲线选择
  276.                                    aTxBuff[nTxBuff++]=CheckH;                       
  277.                                    aTxBuff[nTxBuff++]=CheckL;                         //修轮
  278.                                    crc16tem=crc16(aTxBuff,11);
  279.                                    aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  280.                                    aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  281.                                    for(i =0; i <nTxBuff+1; i++)
  282.                         {
  283.                               c[i]=aTxBuff[i];
  284.                                         }
  285. //                                   USART1_Putc(c,n);
  286.                                    USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  287.                                    USART_SendData(USART1, aTxBuff[0]);  
  288.                                sendnum=1;
  289.                                  } */
  290.                              break;

  292.                         case ForceSingleCoil:                                // 0x05
  293.                                 aTxBuff[0]=SlaveID;
  294.                                 aTxBuff[1]=ForceSingleCoil;       
  295.                                 aTxBuff[2]=aRxBuff[2];
  296.                                 aTxBuff[3]=aRxBuff[3];
  297.                                 nTxBuff=6;
  298.                                 switch (aRxBuff[3])                           //判断地址码
  299.                                 {
  300.                                 /*case  0x32:                                           //启动
  301.                                   if(aRxBuff[4] == 0x00)
  302.                                   {
  303.                                    aTxBuff[4]=0x00;
  304.                                    Run=0x00;                                                             
  305.                                    }               
  306.                                   else if(aRxBuff[4]==0xFF)
  307.                                   {
  308.                                     aTxBuff[4]=0xFF;
  309.                                         Run=0x01;
  310.                                         Stop=0x00;                                                                               
  311.                                    }
  312.                                    break;
  313.                                 case  0x33:                                           //停止
  314.                                   if(aRxBuff[4] == 0x00)
  315.                                   {
  316.                                    aTxBuff[4]=0x00;
  317.                                    Stop=0x00;
  318.                                                                                                
  319.                                    }
  320.                                   else if(aRxBuff[4]==0xFF)
  321.                                    {
  322.                                     aTxBuff[4]=0xFF;
  323.                                         Stop=0x02;
  324.                                         Run=0x00;                                                                               
  325.                                    }
  326.                                    break;
  327.                                 case  0x34:                                           //点退
  328.                                    if(aRxBuff[4] == 0x00)
  329.                                    {
  330.                                    aTxBuff[4]=0x00;
  331.                                    PPback=0x00;                                                             
  332.                                    }
  333.                                    else if(aRxBuff[4]==0xFF)
  334.                                    {
  335.                                     aTxBuff[4]=0xFF;
  336.                                         if(Stop==0x02)
  337.                                            {
  338.                                              PPback=0x04;
  339.                                                  //此处加退料                                                                                                                        
  340.                                        }
  341.                                         if(Run==0x01)
  342.                                            {
  343.                                                    PPback=0x04;
  344.                                                 RecNumL-=0x01;
  345.                                            }
  346.                                         }
  347.                                     break;
  348.                                 case  0x35:                                           //点进
  349.                                    if(aRxBuff[4] == 0x00)
  350.                                    {
  351.                                    aTxBuff[4]=0x00;
  352.                                    PPfo=0x00;                                                             
  353.                                    }
  354.                                    else if(aRxBuff[4]==0xFF&&Stop==0x02)
  355.                                    {
  356.                                     aTxBuff[4]=0xFF;
  357.                                         PPfo=0x08;
  358.                                          //此处加送料                               
  359.                                     }                 
  360.                                     break;         */
  361.                                 case  0x36:                                           //点动变频器1
  362.                                    if(aRxBuff[4] == 0x00)
  363.                                    {
  364.                                    aTxBuff[4]=0x00;
  365.                                    FrePOne=0x00;                                                             
  366.                                    }
  367.                                    else if(aRxBuff[4]==0xFF)
  368.                                    {
  369.                                     aTxBuff[4]=0xFF;
  370.                                         FrePOne=0x10;
  371.                                     }
  372.                                     break;
  373.                                 case  0x37:                                           //点动变频器2
  374.                                    if(aRxBuff[4] == 0x00)
  375.                                    {
  376.                                    aTxBuff[4]=0x00;
  377.                                    FrePTwo=0x00;                                                             
  378.                                    }
  379.                                    else if(aRxBuff[4]==0xFF)
  380.                                    {
  381.                                     aTxBuff[4]=0xFF;
  382.                                         FrePTwo=0x20;
  383.                                     }
  384.                                     break;
  385.                         /*        case  0x3c:                                           //切刀加温
  386.                                    if(aRxBuff[4] == 0x00)
  387.                                    {
  388.                                    aTxBuff[4]=0x00;
  389.                                    TemR=0x00;                                                             
  390.                                    }
  391.                                    else if(aRxBuff[4]==0xFF)
  392.                                    {
  393.                                     aTxBuff[4]=0xFF;
  394.                                         TemR=0x01;
  395.                                         if(TemL<0xDC)
  396.                                         TemL+=0x01;
  397.                                         else TemL+=0x00;
  398.                                     }
  399.                                     break;
  400.                                 case  0x3d:                                           //切刀降温
  401.                                    if(aRxBuff[4] == 0x00)
  402.                                    {
  403.                                    aTxBuff[4]=0x00;
  404.                                    TemD=0x00;                                                             
  405.                                    }
  406.                                    else if(aRxBuff[4]==0xFF)
  407.                                    {
  408.                                     aTxBuff[4]=0xFF;
  409.                                         TemD=0x02;
  410.                                         if(TemL>0)
  411.                                         TemL-=0x01;
  412.                                         else TemL-=0;
  413.                                     }
  414.                                     break;
  415.                                 case  0x3e:                                           //追标深
  416.                                    if(aRxBuff[4] == 0x00)
  417.                                    {
  418.                                    aTxBuff[4]=0x00;
  419.                                    SignSwD=0x00;                                                             
  420.                                    }
  421.                                    else if(aRxBuff[4]==0xFF)
  422.                                    {
  423.                                     aTxBuff[4]=0xFF;
  424.                                         SignSwD=0x04;
  425.                                         SignSwS=0x00;
  426.                                     }
  427.                                     break;
  428.                                 case  0x3f:                                           //追标浅
  429.                                    if(aRxBuff[4] == 0x00)
  430.                                    {
  431.                                    aTxBuff[4]=0x00;
  432.                                    SignSwS=0x00;                                                             
  433.                                    }
  434.                                    else if(aRxBuff[4]==0xFF)
  435.                                    {
  436.                                     aTxBuff[4]=0xFF;
  437.                                         SignSwS=0x08;
  438.                                         SignSwD=0x00;
  439.                                     }
  440.                                     break;*/
  441.                                 case  0x46:                                           //变频器一加
  442.                                    if(aRxBuff[4] == 0x00)
  443.                                    {
  444.                                    aTxBuff[4]=0x00;
  445.                                    FrePROne=0x00;                                                             
  446.                                    }
  447.                                    else if(aRxBuff[4]==0xFF)
  448.                                    {
  449.                                     aTxBuff[4]=0xFF;
  450.                                         FrePROne=0x01;
  451.                                         FreOneL+=0x01;                                       
  452.                                     }
  453.                                     break;
  454.                                 case  0x47:                                           //变频器一减
  455.                                    if(aRxBuff[4] == 0x00)
  456.                                    {
  457.                                    aTxBuff[4]=0x00;
  458.                                    FrePDOne=0x00;                                                             
  459.                                    }
  460.                                    else if(aRxBuff[4]==0xFF)
  461.                                    {
  462.                                     aTxBuff[4]=0xFF;
  463.                                         FrePDOne=0x02;
  464.                                         FreOneL-=0x01;                               
  465.                                     }
  466.                                     break;
  467.                                 case  0x48:                                           //变频器二加
  468.                                    if(aRxBuff[4] == 0x00)
  469.                                    {
  470.                                    aTxBuff[4]=0x00;
  471.                                    FrePRTwo=0x00;                                                             
  472.                                    }
  473.                                    else if(aRxBuff[4]==0xFF)
  474.                                    {
  475.                                     aTxBuff[4]=0xFF;
  476.                                         FrePRTwo=0x04;
  477.                                         FreTwoL+=0x01;                               
  478.                                     }
  479.                                     break;
  480.                                 case  0x49:                                           //变频器二减
  481.                                    if(aRxBuff[4] == 0x00)
  482.                                    {
  483.                                    aTxBuff[4]=0x00;
  484.                                    FrePDTwo=0x00;                                                             
  485.                                    }
  486.                                    else if(aRxBuff[4]==0xFF)
  487.                                    {
  488.                                     aTxBuff[4]=0xFF;
  489.                                         FrePDTwo=0x08;
  490.                                         FreTwoL-=0x01;
  491.                                     }
  492.                                     break;
  493.                                 case  0x4A:                                           //统调加
  494.                                    if(aRxBuff[4] == 0x00)
  495.                                    {
  496.                                    aTxBuff[4]=0x00;
  497.                                    FreR=0x00;                                                             
  498.                                    }
  499.                                    else if(aRxBuff[4]==0xFF)
  500.                                    {
  501.                                     aTxBuff[4]=0xFF;
  502.                                         FreR=0x10;
  503.                                         FreOneL+=0x01;
  504.                                         FreTwoL+=0x10;                                       
  505.                                     }
  506.                                     break;
  507.                                 case  0x4b:                                           //统调减
  508.                                    if(aRxBuff[4] == 0x00)
  509.                                    {
  510.                                    aTxBuff[4]=0x00;
  511.                                    FreD=0x00;                                                             
  512.                                    }
  513.                                    else if(aRxBuff[4]==0xFF)
  514.                                    {
  515.                                     aTxBuff[4]=0xFF;
  516.                                         FreD=0x20;
  517.                                         FreOneL-=0x01;
  518.                                         FreTwoL-=0x10;
  519.                                     }
  520.                                     break;                               
  521.                                 }                                                                                                                              
  522.                                 aTxBuff[5]=0x00;
  523.                                 crc16tem=crc16(aTxBuff,nTxBuff);
  524.                                 aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  525.                                 aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  526.                                 for(i = 0; i < nTxBuff+1; i++)
  527.                         {
  528.                               c[i]=aTxBuff[i];
  529.                                         }
  530. //                                USART1_Putc(c,n);
  531.                                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  532.                                 USART_SendData(USART1, aTxBuff[0]);  
  533.                             sendnum=1;
  534.                             break;
  535.                        
  536.                         case PresetSingleReg:                                // 0x06
  537.                                 for(i=0;i<6;i++)
  538.                                   {aTxBuff[i]=aRxBuff[i];}                       
  539.                                 nTxBuff=6;
  540.                                 switch (aRxBuff[3])                           //判断地址码
  541.                                 {
  542.                                 case 0x14:                                           //变频器一速度
  543.                                  FreOneH=aRxBuff[4];
  544.                                  FreOneL=aRxBuff[5];
  545.                                  break;
  546.                                 case 0x15:                                           //变频器二速度
  547.                                  FreTwoH=aRxBuff[4];
  548.                                  FreTwoL=aRxBuff[5];
  549.                                  break;
  550.                         /*        case 0x0f:                                           //切刀加温
  551.                                  TemH=aRxBuff[4];
  552.                                  TemL=aRxBuff[5];
  553.                                  break;
  554.                                 case 0x0b:                                           //整本数设定
  555.                                  IntendNumH=aRxBuff[4];
  556.                                  IntendNumL=aRxBuff[5];
  557.                                  break;
  558.                                 case 0x0a:                                           //设定袋长
  559.                                  IntendDisH=aRxBuff[4];
  560.                                  IntendDisL=aRxBuff[5];
  561.                                  break;
  562.                                 case 0x1e:                                           //速度
  563.                                  IntendVelH=aRxBuff[4];
  564.                                  IntendVelL=aRxBuff[5];
  565.                                  break;
  566.                                 case 0x0e:                                           //追标长度
  567.                                  IntendSignH=aRxBuff[4];
  568.                                  IntendSignL=aRxBuff[5];
  569.                                  break;
  570.                                 case 0x0c:                                           //脱标次数
  571.                                  FailNumH=aRxBuff[4];
  572.                                  FailNumL=aRxBuff[5];
  573.                                  break;
  574.                                 case 0x0d:                                           //自动起机
  575.                                  AutoRunH=aRxBuff[4];
  576.                                  AutoRunL=aRxBuff[5];
  577.                                  break;
  578.                                 case 0x1f:                                           //步进脉冲数
  579.                                  PluseNOH=aRxBuff[4];
  580.                                  PluseNOL=aRxBuff[5];
  581.                                  break;
  582.                                 case 0x20:                                           //曲线选择
  583.                                  LineH=aRxBuff[4];
  584.                                  LineL=aRxBuff[5];
  585.                                  break;
  586.                                 case 0x21:                                           //修轮
  587.                                  CheckH=aRxBuff[4];
  588.                                  CheckL=aRxBuff[5];
  589.                                  break;        */

  591.                                 }                                                                                                                                                                                                                                                                                                       
  592.                                 crc16tem=crc16(aTxBuff,nTxBuff);
  593.                                 aTxBuff[nTxBuff++]=(unsigned char)(crc16tem>>8);
  594.                                 aTxBuff[nTxBuff]=(unsigned char)(crc16tem & 0x00ff);
  595.                                 for(i = 0; i < nTxBuff+1; i++)
  596.                         {
  597.                               c[i]=aTxBuff[i];
  598.                                         }
  599. //                                USART1_Putc(c,n);
  600.                                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
  601.                 USART_SendData(USART1, aTxBuff[0]);  
  602.                            // sendnum=1;
  603.                             break;
  604.                        
  605.                         }
  606.                 }
  607.         }
  608. }
复制代码

  1. /******************** (C) COPYRIGHT 2012 WildFire Team **************************
  2. * 文件名  ：main.c
  3. * 描述    ：实现sht10传感器的modbus与上位机的通讯。         
  4. * 实验平台：奋斗mini开发板
  5. * 库版本  ：ST3.5.0
  6. **********************************************************************************/
  7. #include "stm32f10x.h"
  8. #include "Init_Config.h"
  9. #include "modbus.h"
  10. #include "myiic.h"
  11. #include "MeasuerTEMP.h"
  12. #include "Systick.h"
  13. /*
  14. * 函数名：main
  15. * 描述  : 主函数
  16. * 输入  ：无
  17. * 输出  : 无
  18. */
  19. int main(void)
  20. {
  21.         RCC_Configuration();

  23.         Init_Config();
  24.        
  25.         SHT10_Config();
  26.          
  27.         SysTick_Init();       

  29. while (1)
  30.     {


  33.         if(Uart0_rev_comflag==0x01)
  34.           {       

  36.           Uart0_rev_comflag=0x00;
  37.           
  38.           ParseRecieve();

  40.          USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);

  42.           }          
  43.     }

  45. }
  46. /******************* (C) COPYRIGHT 2012 WildFire Team *****END OF FILE************/
复制代码

所有资料51hei提供下载:
STM32_MODBUS1.7z (186.31 KB, 下载次数: 139)


作者: Longan.Wang    时间: 2022-3-25 10:51
谢谢！可以参考一下！
作者: 雪玉寐影    时间: 2022-5-4 03:59
这个应该是slave从机，不是master吧



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