fubowen
/
TrainCamp_fubowen_Modbus
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
22 Revize
1 Větev
656 KiB
 
 
 
 
Strom: a4d268a1a3
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „a4d268a1a3“
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus.c

705 řádky
19 KiB
Surový Blame Historie 

  1. #include "stm32f4xx.h"

  2. #include "ucos_ii.h"

  3. #include "os.h"

  4. #include "string.h"

  5. #include "modbus.h"

  6. 

  7. extern OS_EVENT* ModbusWriteFlash;      /*接收到modbus写入coil请求报文*/

  8. extern OS_EVENT* ModbusConnect;        /*已接收到modbus正确报文*/

  9. 

  10. uint8_t ModbusErr;

  11. /*0x270F + 1 = K10000 */

  12. uint8_t ModbusCoil[1250];   /*10000/8=1250*/

  13. uint16_t ModbusReg[10000];

  14. 

  15. /*附加功能：页寄存器*/

  16. uint16_t ModbusExtPage[1] = {0};    /*设置地址为0xFFFE*/

  17. uint16_t ModbusExtReg[1];           /*地址映射为0x10000*/

  18. /*附加功能：读取所有单数个寄存器*/

  19. uint16_t ModbusExtOdd[1] = {0};     /*设置地址为0xFFFF*/

  20. 

  21. uint8_t ModbusRxBuf[MODBUS_RX_BUF_SIZE];    /*接收数组*/

  22. uint16_t ModbusRxLen = 0;                   /*接收数据长度*/

  23. uint8_t ModbusTxBuf[MODBUS_TX_BUF_SIZE];    /*发送数组*/

  24. uint16_t ModbusTxLen = 0;                   /*发送数据长度*/

  25. 

  26. 

  27. uint8_t ModbusErrReply(uint8_t func, uint8_t err);

  28. uint16_t Crc16(const uint8_t *data, uint16_t length);

  29. void AddCrc16(uint8_t *data, uint16_t length);

  30. int8_t ChcekCrc16(uint16_t recCrc16, uint8_t *data, uint16_t length);

  31. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num);

  32. uint8_t ModbusWriteCoils(uint16_t addres, uint16_t num, uint8_t *data);

  33. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num);

  34. uint8_t ModbusWriteRegs(uint16_t addres, uint16_t num, uint8_t *data);

  35. uint8_t ModbusWriteReg(uint16_t addres, uint8_t *data);

  36. uint8_t ModbusWriteCoil(uint16_t addres, uint8_t *data);

  37. uint8_t ModbusExtReadOdd(uint16_t num);

  38. 

  39. 

  40. 

  41. /*USART接收空闲中断*/

  42. void USART1_IRQHandler(void)

  43. {

  44.     OSIntEnter();   /*进入中断*/

  45. 

  46.     uint32_t temp;

  47.     uint16_t rxLenRemain;

  48.     

  49.     if(USART_GetITStatus(USART1, USART_IT_IDLE) == SET)

  50.     {

  51.         /*在计算数据长度之前先关闭DMA接收通道，防止计算过程中DMA继续转运数据*/

  52.         DMA_Cmd(DMA2_Stream2, DISABLE);

  53.         

  54.         /*清除IDLE中断标志位*/

  55.         temp = USART1->SR;

  56.         temp = USART1->DR;

  57.         (void)temp;

  58. 

  59.         /*清除传输已经完成TCIF2、传输已经完成一半HTIF2标志位*/

  60.         DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2 | DMA_FLAG_HTIF2);

  61.         

  62.         /*计算数据长度*/

  63.         rxLenRemain = DMA_GetCurrDataCounter(DMA2_Stream2);

  64.         ModbusRxLen = MODBUS_RX_BUF_SIZE - rxLenRemain;

  65. 

  66.         /*释放接收到数据帧信号量，唤醒帧解析任务*/

  67.         if(ModbusRxLen != 0)

  68.         {

  69.             OSSemPost(ModbusReceived);

  70.         }

  71.         

  72.         /*重新指定接收地址*/

  73.         DMA_MemoryTargetConfig(DMA2_Stream2, (uint32_t)ModbusRxBuf, DMA_Memory_0);

  74.         /*重启DMA*/

  75.         DMA_SetCurrDataCounter(DMA2_Stream2, MODBUS_RX_BUF_SIZE);

  76.         DMA_Cmd(DMA2_Stream2, ENABLE);

  77.     }

  78.     

  79.     OSIntExit();    /*退出中断*/

  80. }

  81. 

  82. 

  83. /*modbus响应帧发送*/

  84. void ModbusSend(uint8_t *txBuf, uint16_t len)

  85. {

  86.     if(DMA_GetCmdStatus(DMA2_Stream7) == ENABLE)

  87.     {

  88.         /*等待DMA发送完成*/

  89.         while(DMA_GetFlagStatus(DMA2_Stream7, DMA_FLAG_TCIF7) == RESET);

  90.     }

  91. 

  92.     /*先关闭DMA发送通道*/

  93.     DMA_Cmd(DMA2_Stream7, DISABLE);

  94. 

  95.     /*等待DMA关闭*/

  96.     while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE); 

  97. 

  98.     /*清除传输已经完成TCIF7、传输已经完成一半HTIF7、FIFO错误FEIF7标志位*/

  99.     DMA_ClearFlag(DMA2_Stream7, DMA_FLAG_FEIF7 | DMA_FLAG_HTIF7 | DMA_FLAG_TCIF7);

  100.     

  101.     /*配置发送地址和长度*/

  102.     DMA_MemoryTargetConfig(DMA2_Stream7, (uint32_t)txBuf, DMA_Memory_0);     

  103.     DMA_SetCurrDataCounter(DMA2_Stream7, len);

  104. 

  105.     /*等待串口发送完成*/

  106.     while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);

  107.     

  108.     /*在此处等待3.5个字符的时间*/

  109.     /*启动 DMA 发送*/

  110.     DMA_Cmd(DMA2_Stream7, ENABLE);

  111. }

  112. 

  113. 

  114. /*modbus协议帧解析任务*/

  115. void AppTaskModbusParse (void *p_arg)

  116. {

  117.     OS_ERR err;

  118.     MODBUS_FRAME frame;

  119.     uint16_t rxLen;

  120.     uint8_t rxBuf[256];

  121. 

  122.     while(1)

  123.     {

  124.         /*无限期等待接收到数据帧信号量*/

  125.         OSSemPend(ModbusReceived, 0, &err);

  126.         

  127.         /*数据接收，防止下一帧覆盖*/

  128.         rxLen = ModbusRxLen;

  129.         memcpy(rxBuf, ModbusRxBuf, rxLen);

  130. 

  131.         /*拼接crc校验码（高前低后），接收到的数据帧crc校验码是低前高后*/

  132.         frame.crc = ((uint16_t)(rxBuf[rxLen - 2])) | ((uint16_t)rxBuf[rxLen - 1] << 8);

  133.         if(ChcekCrc16(frame.crc, rxBuf, rxLen) != 0)

  134.         {   

  135.             /*crc校验错误，直接丢弃*/

  136.             ModbusErr = ERR_CRC;

  137.             continue;

  138.         }

  139. 

  140.         frame.slaveAddres = rxBuf[0];

  141.         if(frame.slaveAddres != SLAVE_ADDRES)

  142.         {

  143.             /*从机地址错误，直接丢弃*/

  144.             ModbusErr = ERR_SLAVE_ADDRES;

  145.             continue;

  146.         }

  147.         OSSemPost(ModbusConnect);

  148. 

  149.         frame.func = rxBuf[1];

  150.         frame.opeAddres = ((uint16_t)rxBuf[2] << 8) | ((uint16_t)rxBuf[3]);

  151.         frame.opeNum = ((uint16_t)rxBuf[4] << 8) | ((uint16_t)rxBuf[5]);

  152.         

  153.         /*功能码分类*/

  154.         switch(frame.func)

  155.         {

  156.             case 0x01:/*读线圈*/

  157.                 ModbusErr = ModbusReadCoils(frame.opeAddres, frame.opeNum);

  158.                 break;

  159. 

  160.             case 0x03:/*读寄存器*/

  161.                 ModbusErr = ModbusReadRegs(frame.opeAddres, frame.opeNum);

  162.                 break;

  163. 

  164.             case 0x0F:/*写多个线圈*/

  165.                 frame.wNum = rxBuf[6];

  166.                 memcpy(frame.wData, &rxBuf[7], frame.wNum);

  167.                 ModbusErr = ModbusWriteCoils(frame.opeAddres, frame.opeNum, frame.wData);

  168.                 if(ModbusErr == 0)

  169.                 {

  170.                     OSSemPost(ModbusWriteFlash);

  171.                 }          

  172.                 break;

  173. 

  174.             case 0x10:/*写多个寄存器*/

  175.                 frame.wNum = rxBuf[6];

  176.                 memcpy(frame.wData, &rxBuf[7], frame.wNum);

  177.                 ModbusErr = ModbusWriteRegs(frame.opeAddres, frame.opeNum, frame.wData);

  178.                 if(ModbusErr == 0)

  179.                 {

  180.                     OSSemPost(ModbusWriteFlash);

  181.                 }

  182.                 break;

  183.             

  184.             case 0x05:/*写单个线圈*/

  185.                 memcpy(frame.wData, &rxBuf[4], 2);

  186.                 ModbusErr = ModbusWriteCoil(frame.opeAddres, frame.wData);

  187.                 if(ModbusErr == 0)

  188.                 {

  189.                     OSSemPost(ModbusWriteFlash);

  190.                 }

  191.                 break;

  192. 

  193.             case 0x06:/*写单个寄存器*/

  194.                 memcpy(frame.wData, &rxBuf[4], 2);

  195.                 ModbusErr = ModbusWriteReg(frame.opeAddres, frame.wData);

  196.                 if(ModbusErr == 0)

  197.                 {

  198.                     OSSemPost(ModbusWriteFlash);

  199.                 }

  200.                 break;

  201. 

  202.             default:/*功能码错误*/

  203.                 ModbusErr = ERR_FUNC;

  204.                 ModbusErr = ModbusErrReply(frame.func, ERR_FUNC);

  205.                 break;

  206.         }

  207.         /*实现附加功能时不在这里启动发送*/

  208.         if(frame.func == 0x03 && frame.opeAddres == 0XFFFF)

  209.         {

  210.             ;

  211.         }

  212.         else

  213.         {

  214.             /*启动发送*/

  215.             ModbusSend(ModbusTxBuf, ModbusTxLen);

  216.         }

  217.     }

  218. }

  219. 

  220. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num)

  221. {

  222.     uint16_t byteIndI;  /*字节索引*/

  223.     uint8_t bitIndI;    /*位索引*/

  224.     uint16_t byteIndO;

  225.     uint8_t bitIndO;

  226. 

  227.     uint8_t dataLen;    /*响应帧返回字节数*/

  228. 

  229.     uint8_t index;      /*发送数组索引*/

  230.     uint8_t readVal;    /*读取到的形式值*/

  231.     uint8_t writeVal;   /*写入的形式值*/

  232. 

  233.     if(ModbusRxLen < 8)

  234.     {

  235.         return ModbusErrReply(0x01, ERR_DATA);

  236.     }

  237.     /*操作地址超限*/

  238.     if(addres > 0x270F || (addres + (num - 1)) > 0x270F)

  239.     {

  240.         return ModbusErrReply(0x01, ERR_OPE_ADDRES);

  241.     }

  242.     /*操作数量超限*/

  243.     if(num == 0 || num > 2000)

  244.     {

  245.         return ModbusErrReply(0x01, ERR_DATA);

  246.     }

  247. 

  248.     /*不能num/8+1，当为8的整数时会多一个*/

  249.     dataLen = (num + 7) / 8;

  250. 

  251.     /*清零发送数组*/

  252.     memset(&ModbusTxBuf[3], 0, 253);

  253. 

  254.     for(uint16_t i = 0; i < num; i++)

  255.     {

  256.         byteIndO = i / 8;

  257.         bitIndO = i % 8;

  258. 

  259.         byteIndI = (addres + i) / 8;

  260.         bitIndI = (addres + i) % 8;

  261. 

  262.         /*位掩码读取线圈值*/

  263.         readVal = ModbusCoil[byteIndI] & ((uint8_t)1 << bitIndI);

  264.         

  265.         /*读取到的值为0则不进行操作*/

  266.         if(readVal != 0)

  267.         {

  268.             index = 3 + byteIndO;

  269.             /*将读取到的值移位到要写入的位*/

  270.             writeVal = (uint8_t)1u << bitIndO;

  271. 

  272.             ModbusTxBuf[index] |= writeVal;

  273.         }

  274.     }

  275. 

  276.     ModbusTxBuf[0] = SLAVE_ADDRES;  /*从机地址*/

  277.     ModbusTxBuf[1] = 0x01;          /*功能码*/

  278.     ModbusTxBuf[2] = dataLen;       /*响应帧返回数据字节数*/

  279.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  280.     ModbusTxLen = 5 + dataLen;

  281. 

  282.     return 0;

  283. }

  284. 

  285. uint8_t ModbusWriteCoils(uint16_t addres, uint16_t num, uint8_t *data)

  286. {

  287.     uint16_t byteIndI;

  288.     uint8_t bitIndI;

  289.     uint16_t byteIndO;

  290.     uint8_t bitIndO;

  291. 

  292.     uint8_t readVal;

  293.     uint8_t writeVal;

  294. 

  295.     if(ModbusRxLen < 10)

  296.     {

  297.         return ModbusErrReply(0x0F, ERR_DATA);

  298.     }

  299.     /*操作地址超限*/

  300.     if(addres > 0x270F || (addres + (num - 1)) > 0x270F)

  301.     {

  302.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  303.     }

  304.     /*操作数量超限*/

  305.     if(num == 0 || num > 1968)

  306.     {

  307.         return ModbusErrReply(0x0F, ERR_DATA);

  308.     }

  309.    

  310.     for(uint16_t i = 0; i < num; i++)

  311.     {

  312.         byteIndI = (addres + i) / 8;

  313.         bitIndI = (addres + i) % 8;

  314.     

  315.         byteIndO = i / 8;

  316.         bitIndO = i % 8;

  317. 

  318.         /*位掩码读取要写入的值*/

  319.         readVal = data[byteIndO] | ((uint8_t)1 << bitIndO);

  320.         /*将写入值移位到要写入的位*/

  321.         writeVal = (uint8_t)1 << bitIndI;

  322. 

  323.         /*对应位写入1*/

  324.         if(readVal != 0)

  325.         {

  326.             ModbusCoil[byteIndI] |= writeVal;

  327.         }

  328.         /*对应位写入0*/

  329.         else

  330.         {

  331.             ModbusCoil[byteIndI] &= (~writeVal);

  332.         }

  333.     }

  334.     ModbusTxBuf[0] = SLAVE_ADDRES;

  335.     ModbusTxBuf[1] = 0x0F;

  336.     /*操作地址*/

  337.     ModbusTxBuf[2] = (uint8_t)(addres >> 8);

  338.     ModbusTxBuf[3] = (uint8_t)(addres & 0x00FF);

  339.     /*成功写入的数量*/

  340.     ModbusTxBuf[4] = (uint8_t)(num >> 8);

  341.     ModbusTxBuf[5] = (uint8_t)(num & 0x00FF);

  342.     AddCrc16(ModbusTxBuf, 6);

  343.     ModbusTxLen = 8;

  344. 

  345.     return 0;

  346. }

  347. 

  348. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num)

  349. {

  350.     uint8_t index;

  351.     uint8_t readValH;

  352.     uint8_t readValL;

  353.     uint8_t dataLen;

  354. 

  355.     if(ModbusRxLen < 8)

  356.     {

  357.         return ModbusErrReply(0x13, ERR_DATA);

  358.     }

  359.     /*操作地址超限*/

  360.     if(addres > 0x270F || (addres + (num - 1)) > 0x270F)

  361.     {

  362.         if(addres == 0xFFFF && num == 1)

  363.         {

  364.             ;

  365.         }

  366.         else

  367.         {

  368.             return ModbusErrReply(0x03, ERR_OPE_ADDRES);

  369.         } 

  370.     }

  371.     /*操作数量超限*/

  372.     if(num == 0 || num > 125)

  373.     {

  374.         return ModbusErrReply(0x03, ERR_DATA);

  375.     }

  376. 

  377.     dataLen = num * 2;

  378.     /*附加功能：读取0x10000寄存器*/

  379.     if(ModbusExtPage[0] == 1 && addres == 0x0000)

  380.     {

  381.         /*将16位寄存器值拆分为两个8位*/

  382.         readValH = (uint8_t)(ModbusExtReg[0] >> 8);

  383.         readValL = (uint8_t)(ModbusExtReg[0] & 0x00FF);

  384. 

  385.         ModbusTxBuf[3] = readValH;

  386.         ModbusTxBuf[4] = readValL;

  387.     }

  388.     /*附加功能：读取大量奇数寄存器*/

  389.     else if(addres == 0xFFFF && num == 1)

  390.     {

  391.         return ModbusExtReadOdd(ModbusExtOdd[0]);

  392.     }

  393.     else

  394.     {

  395.         for(uint16_t i = 0; i < num; i++)

  396.         {

  397.             index = 3 + (i * 2);

  398.             /*将16位寄存器值拆分为两个8位*/

  399.             readValH = (uint8_t)(ModbusReg[addres + i] >> 8);

  400.             readValL = (uint8_t)(ModbusReg[addres + i] & 0x00FF);

  401. 

  402.             ModbusTxBuf[index] = readValH;

  403.             ModbusTxBuf[index + 1] = readValL;

  404.         }

  405.     }

  406. 

  407.     ModbusTxBuf[0] = SLAVE_ADDRES;

  408.     ModbusTxBuf[1] = 0x03;

  409.     ModbusTxBuf[2] = dataLen;

  410.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  411.     ModbusTxLen = 5 + dataLen;

  412. 

  413.     return 0;

  414. }

  415. 

  416. uint8_t ModbusWriteRegs(uint16_t addres, uint16_t num, uint8_t *data)

  417. {

  418.     uint8_t index;

  419. 

  420.     uint8_t writeValH;

  421.     uint8_t writeValL;

  422.     uint16_t writeVal;

  423. 

  424.     if(ModbusRxLen < 11)

  425.     {

  426.         return ModbusErrReply(0x10, ERR_DATA);

  427.     }

  428.     /*操作地址超限*/

  429.     if(addres > 0x270F || (addres + (num - 1)) > 0x270F)

  430.     {

  431.         if((addres == 0xFFFE || addres == 0xFFFF) && num == 1)

  432.         {

  433.             ;

  434.         }

  435.         else

  436.         {

  437.             return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  438.         }

  439.     }

  440.     /*操作数量超限*/

  441.     if(num == 0 || num > 123)

  442.     {

  443.         return ModbusErrReply(0x10, ERR_DATA);

  444.     }

  445. 

  446.     /*附加功能：读取0x10000寄存器*/

  447.     if(addres == 0xFFFE && num == 1)

  448.     {

  449.         writeValH = data[0];

  450.         writeValL = data[1];

  451.         

  452.         /*将要写入两个8位值拼接为16位*/

  453.         writeVal = ((uint16_t)writeValH << 8) | ((uint16_t)writeValL & 0x00FF);

  454.         ModbusExtPage[0] = writeVal;

  455.     }

  456.     /*附加功能：读取大量奇数寄存器*/

  457.     else if(addres == 0xFFFF && num == 1)

  458.     {

  459.         writeValH = data[0];

  460.         writeValL = data[1];

  461.         

  462.         /*将要写入两个8位值拼接为16位*/

  463.         writeVal = ((uint16_t)writeValH << 8) | ((uint16_t)writeValL & 0x00FF);

  464.         ModbusExtOdd[0] = writeVal;

  465.     }

  466.     /*正常功能*/

  467.     else

  468.     {

  469.         for(uint16_t i = 0; i < num; i++)

  470.         {

  471.             index = i * 2;

  472. 

  473.             writeValH = data[index];

  474.             writeValL = data[index + 1];

  475.         

  476.             /*将要写入两个8位值拼接为16位*/

  477.             writeVal = ((uint16_t)writeValH << 8) | ((uint16_t)writeValL & 0x00FF);

  478.             ModbusReg[addres + i] = writeVal;

  479.         }

  480.     }

  481. 

  482.     ModbusTxBuf[0] = SLAVE_ADDRES;

  483.     ModbusTxBuf[1] = 0x10;

  484.     /*操作地址*/

  485.     ModbusTxBuf[2] = (uint8_t)(addres >> 8);

  486.     ModbusTxBuf[3] = (uint8_t)(addres & 0x00FF);

  487.     /*成功写入数量*/

  488.     ModbusTxBuf[4] = (uint8_t)(num >> 8);

  489.     ModbusTxBuf[5] = (uint8_t)(num & 0x00FF);

  490.     AddCrc16(ModbusTxBuf, 6);

  491.     ModbusTxLen = 8;

  492. 

  493.     return 0;

  494. }

  495. 

  496. uint8_t ModbusWriteCoil(uint16_t addres, uint8_t *data)

  497. {

  498.     uint16_t byteIndI;

  499.     uint8_t bitIndI;

  500. 

  501.     uint16_t readVal;

  502.     uint8_t writeVal;

  503. 

  504.     /*操作地址超限*/

  505.     if(addres > 0x270F)

  506.     {

  507.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  508.     }

  509.    

  510.     byteIndI = addres / 8;

  511.     bitIndI = addres % 8;

  512.     

  513.     /*位掩码读取要写入的值*/

  514.     readVal = ((uint16_t)data[0] << 8) | ((uint16_t)data[1] & 0x00FF);

  515.     /*将写入值移位到要写入的位*/

  516.     writeVal = (uint8_t)1 << bitIndI;

  517. 

  518.     /*置on*/

  519.     if(readVal == 0xFF00)

  520.     {

  521.         ModbusCoil[byteIndI] |= writeVal;

  522.     }

  523.     /*置off*/

  524.     else if(readVal == 0x0000)

  525.     {

  526.         ModbusCoil[byteIndI] &= (~writeVal);

  527.     }

  528.     else

  529.     {

  530.         return ModbusErrReply(0x05, ERR_DATA);

  531.     }

  532. 

  533.     ModbusTxBuf[0] = SLAVE_ADDRES;

  534.     ModbusTxBuf[1] = 0x0F;

  535.     /*操作地址*/

  536.     ModbusTxBuf[2] = (uint8_t)(addres >> 8);

  537.     ModbusTxBuf[3] = (uint8_t)(addres & 0x00FF);

  538.     /*成功写入*/

  539.     ModbusTxBuf[4] = data[0];

  540.     ModbusTxBuf[5] = data[1];

  541.     AddCrc16(ModbusTxBuf, 6);

  542.     ModbusTxLen = 8;

  543. 

  544.     return 0;

  545. }

  546. 

  547. uint8_t ModbusWriteReg(uint16_t addres, uint8_t *data)

  548. {

  549.     uint8_t writeValH;

  550.     uint8_t writeValL;

  551.     uint16_t writeVal;

  552.     

  553.     /*操作地址超限*/

  554.     if(addres > 0x270F)

  555.     {

  556.         return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  557.     }

  558. 

  559.     writeValH = data[0];

  560.     writeValL = data[1];

  561.     /*将要写入两个8位值拼接为16位*/

  562.     writeVal = ((uint16_t)writeValH << 8) | ((uint16_t)writeValL & 0x00FF);

  563.     ModbusReg[addres] = writeVal;

  564.     

  565.     ModbusTxBuf[0] = SLAVE_ADDRES;

  566.     ModbusTxBuf[1] = 0x10;

  567.     /*操作地址*/

  568.     ModbusTxBuf[2] = (uint8_t)(addres >> 8);

  569.     ModbusTxBuf[3] = (uint8_t)(addres & 0x00FF);

  570.     /*成功写入*/

  571.     ModbusTxBuf[4] = writeValH;

  572.     ModbusTxBuf[5] = writeValL;

  573.     AddCrc16(ModbusTxBuf, 6);

  574.     ModbusTxLen = 8;

  575.     

  576.     return 0;

  577. }

  578. 

  579. uint8_t ModbusExtReadOdd(uint16_t num)

  580. {

  581.     uint8_t i = 0;

  582.     uint8_t numJ = (num + 124) / 125;

  583.     uint8_t numI = num % 125;

  584. 

  585.     uint8_t index;

  586.     uint16_t indexR;

  587.     uint8_t readValH;

  588.     uint8_t readValL;

  589.     uint8_t dataLen;

  590. 

  591.     for(uint16_t j = 0; j < numJ; j++)

  592.     {

  593.         if(j == numJ - 1)

  594.         {

  595.             for(i = 0; i < numI; i++)

  596.             {

  597.                 index = 3 + (i * 2);

  598.                 indexR = j * 250 + 2 * i + 1;

  599.                 /*将16位寄存器值拆分为两个8位*/

  600.                 readValH = (uint8_t)(ModbusReg[indexR] >> 8);

  601.                 readValL = (uint8_t)(ModbusReg[indexR] & 0x00FF);

  602. 

  603.                 ModbusTxBuf[index] = readValH;

  604.                 ModbusTxBuf[index + 1] = readValL;

  605.             }

  606.             dataLen = 2 * numI;

  607. 

  608.             ModbusTxBuf[0] = SLAVE_ADDRES;

  609.             ModbusTxBuf[1] = 0x03;

  610.             ModbusTxBuf[2] = dataLen;

  611.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  612.             ModbusTxLen = 5 + dataLen;

  613.         }

  614.         else

  615.         {

  616.             for(i = 0; i < 125; i++)

  617.             {

  618.                 index = 3 + (i * 2);

  619.                 indexR = j * 250 + 2 * i + 1;

  620.                 /*将16位寄存器值拆分为两个8位*/

  621.                 readValH = (uint8_t)(ModbusReg[indexR] >> 8);

  622.                 readValL = (uint8_t)(ModbusReg[indexR] & 0x00FF);

  623. 

  624.                 ModbusTxBuf[index] = readValH;

  625.                 ModbusTxBuf[index + 1] = readValL;

  626.             }

  627.             dataLen = 250;

  628. 

  629.             ModbusTxBuf[0] = SLAVE_ADDRES;

  630.             ModbusTxBuf[1] = 0x03;

  631.             ModbusTxBuf[2] = dataLen;

  632.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  633.             ModbusTxLen = 5 + dataLen;

  634.         }

  635.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  636.     }

  637.     return 0;

  638. }

  639. 

  640. 

  641. uint8_t ModbusErrReply(uint8_t func, uint8_t err)

  642. {

  643.     ModbusTxBuf[0] = SLAVE_ADDRES;

  644.     ModbusTxBuf[1] = func;

  645.     ModbusTxBuf[2] = err;

  646.     AddCrc16(ModbusTxBuf, 3);

  647.     ModbusTxLen = 5;

  648. 

  649.     return err;

  650. }

  651. 

  652. 

  653. 

  654. 

  655. void AddCrc16(uint8_t *data, uint16_t length)

  656. {

  657.     uint8_t *dataT = data;

  658.     uint16_t crc16 = Crc16(data, length);

  659. 

  660.     /*低前高后*/

  661.     dataT[length] = (uint8_t)(crc16 & 0x00FF);

  662.     dataT[length + 1] = (uint8_t)(crc16 >> 8);

  663. }

  664. 

  665. /*crc16校验*/

  666. uint16_t Crc16(const uint8_t *data, uint16_t length)

  667. {

  668.     uint16_t crc;

  669.     uint16_t byteInd;

  670.     uint8_t bitInd;

  671.     

  672.     crc = 0xFFFFu;

  673.     for (byteInd = 0u; byteInd < length; byteInd++)

  674.     {

  675.         crc ^= (uint16_t)data[byteInd];

  676.         for (bitInd = 0u; bitInd < 8u; bitInd++)

  677.         {

  678.             if ((crc & 0x0001u) != 0u)

  679.             {

  680.                 crc >>= 1;

  681.                 crc ^= 0xA001u;

  682.             }

  683.             else

  684.             {

  685.                 crc >>= 1;

  686.             }

  687.         }

  688.     }

  689.     return crc;

  690. }

  691. 

  692. /*crc16检查*/

  693. int8_t ChcekCrc16(uint16_t recCrc16, uint8_t *data, uint16_t length)

  694. {

  695.     uint16_t crc16 = Crc16(data, (length - 2));

  696. 

  697.     if(recCrc16 == crc16)

  698.     {

  699.         return 0;

  700.     }

  701.     else

  702.     {

  703.         return -1;

  704.     }

  705. }