fubowen
/
TrainCamp_fubowen_Modbus
1
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
24 Commitit
1 Haara
656 KiB
 
 
 
 
Puu: c72fee9dc7
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'c72fee9dc7'
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus.c

695 rivejä
18 KiB
Raaka Blame Historia 

  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.         /*帧分解*/

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

  133.         frame.slaveAddres = rxBuf[0];

  134.         frame.func = rxBuf[1];

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

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

  137. 

  138.         /*crc校验判断*/

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

  140.         {   

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

  142.             ModbusErr = ERR_CRC;

  143.             continue;

  144.         }

  145.         /*从机地址判断*/

  146.         if(frame.slaveAddres != SLAVE_ADDRES)

  147.         {

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

  149.             ModbusErr = ERR_SLAVE_ADDRES;

  150.             continue;

  151.         }

  152.         /*释放正确接收信号量*/

  153.         OSSemPost(ModbusConnect);

  154. 

  155.         /*功能码分类*/

  156.         switch(frame.func)

  157.         {

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

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

  160.                 break;

  161. 

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

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

  164.                 break;

  165. 

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

  167.                 frame.wNum = rxBuf[6];

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

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

  170.                 break;

  171. 

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

  173.                 frame.wNum = rxBuf[6];

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

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

  176.                 break;

  177.             

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

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

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

  181.                 break;

  182. 

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

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

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

  186.                 break;

  187. 

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

  189.                 ModbusErr = ERR_FUNC;

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

  191.                 break;

  192.         }

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

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

  195.         else

  196.         {

  197.             ModbusSend(ModbusTxBuf, ModbusTxLen);

  198.         }

  199. 

  200.         if(ModbusErr == 0 && (frame.func == 0x0F 

  201.                                 || frame.func == 0x10 

  202.                                 || frame.func == 0x05 || frame.func == 0x06))

  203.         {

  204.             /*释放写FLASH信号量*/

  205.             OSSemPost(ModbusWriteFlash);

  206.         }

  207.     }

  208. }

  209. 

  210. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num)

  211. {

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

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

  214.     uint16_t byteIndO;

  215.     uint8_t bitIndO;

  216. 

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

  218. 

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

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

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

  222. 

  223.     if(ModbusRxLen < 8)

  224.     {

  225.         return ModbusErrReply(0x01, ERR_DATA);

  226.     }

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

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

  229.     {

  230.         return ModbusErrReply(0x01, ERR_OPE_ADDRES);

  231.     }

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

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

  234.     {

  235.         return ModbusErrReply(0x01, ERR_DATA);

  236.     }

  237. 

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

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

  240. 

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

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

  243. 

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

  245.     {

  246.         byteIndO = i / 8;

  247.         bitIndO = i % 8;

  248. 

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

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

  251. 

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

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

  254.         

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

  256.         if(readVal != 0)

  257.         {

  258.             index = 3 + byteIndO;

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

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

  261. 

  262.             ModbusTxBuf[index] |= writeVal;

  263.         }

  264.     }

  265. 

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

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

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

  269.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  270.     ModbusTxLen = 5 + dataLen;

  271. 

  272.     return 0;

  273. }

  274. 

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

  276. {

  277.     uint16_t byteIndI;

  278.     uint8_t bitIndI;

  279.     uint16_t byteIndO;

  280.     uint8_t bitIndO;

  281. 

  282.     uint8_t readVal;

  283.     uint8_t writeVal;

  284. 

  285.     if(ModbusRxLen < 10)

  286.     {

  287.         return ModbusErrReply(0x0F, ERR_DATA);

  288.     }

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

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

  291.     {

  292.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  293.     }

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

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

  296.     {

  297.         return ModbusErrReply(0x0F, ERR_DATA);

  298.     }

  299.    

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

  301.     {

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

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

  304.     

  305.         byteIndO = i / 8;

  306.         bitIndO = i % 8;

  307. 

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

  309.         readVal = data[byteIndO] & ((uint8_t)1 << bitIndO);

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

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

  312. 

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

  314.         if(readVal != 0)

  315.         {

  316.             ModbusCoil[byteIndI] |= writeVal;

  317.         }

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

  319.         else

  320.         {

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

  322.         }

  323.     }

  324.     ModbusTxBuf[0] = SLAVE_ADDRES;

  325.     ModbusTxBuf[1] = 0x0F;

  326.     /*操作地址*/

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

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

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

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

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

  332.     AddCrc16(ModbusTxBuf, 6);

  333.     ModbusTxLen = 8;

  334. 

  335.     return 0;

  336. }

  337. 

  338. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num)

  339. {

  340.     uint8_t index;

  341.     uint8_t readValH;

  342.     uint8_t readValL;

  343.     uint8_t dataLen;

  344. 

  345.     if(ModbusRxLen < 8)

  346.     {

  347.         return ModbusErrReply(0x13, ERR_DATA);

  348.     }

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

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

  351.     {

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

  353.         {

  354.             ;

  355.         }

  356.         else

  357.         {

  358.             return ModbusErrReply(0x03, ERR_OPE_ADDRES);

  359.         } 

  360.     }

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

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

  363.     {

  364.         return ModbusErrReply(0x03, ERR_DATA);

  365.     }

  366. 

  367.     dataLen = num * 2;

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

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

  370.     {

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

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

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

  374. 

  375.         ModbusTxBuf[3] = readValH;

  376.         ModbusTxBuf[4] = readValL;

  377.     }

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

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

  380.     {

  381.         return ModbusExtReadOdd(ModbusExtOdd[0]);

  382.     }

  383.     else

  384.     {

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

  386.         {

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

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

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

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

  391. 

  392.             ModbusTxBuf[index] = readValH;

  393.             ModbusTxBuf[index + 1] = readValL;

  394.         }

  395.     }

  396. 

  397.     ModbusTxBuf[0] = SLAVE_ADDRES;

  398.     ModbusTxBuf[1] = 0x03;

  399.     ModbusTxBuf[2] = dataLen;

  400.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  401.     ModbusTxLen = 5 + dataLen;

  402. 

  403.     return 0;

  404. }

  405. 

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

  407. {

  408.     uint8_t index;

  409. 

  410.     uint8_t writeValH;

  411.     uint8_t writeValL;

  412.     uint16_t writeVal;

  413. 

  414.     if(ModbusRxLen < 11)

  415.     {

  416.         return ModbusErrReply(0x10, ERR_DATA);

  417.     }

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

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

  420.     {

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

  422.         {

  423.             ;

  424.         }

  425.         else

  426.         {

  427.             return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  428.         }

  429.     }

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

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

  432.     {

  433.         return ModbusErrReply(0x10, ERR_DATA);

  434.     }

  435. 

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

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

  438.     {

  439.         writeValH = data[0];

  440.         writeValL = data[1];

  441.         

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

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

  444.         ModbusExtPage[0] = writeVal;

  445.     }

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

  447.     else if(addres == 0xFFFF && 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.         ModbusExtOdd[0] = writeVal;

  455.     }

  456.     /*正常功能*/

  457.     else

  458.     {

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

  460.         {

  461.             index = i * 2;

  462. 

  463.             writeValH = data[index];

  464.             writeValL = data[index + 1];

  465.         

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

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

  468.             ModbusReg[addres + i] = writeVal;

  469.         }

  470.     }

  471. 

  472.     ModbusTxBuf[0] = SLAVE_ADDRES;

  473.     ModbusTxBuf[1] = 0x10;

  474.     /*操作地址*/

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

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

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

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

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

  480.     AddCrc16(ModbusTxBuf, 6);

  481.     ModbusTxLen = 8;

  482. 

  483.     return 0;

  484. }

  485. 

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

  487. {

  488.     uint16_t byteIndI;

  489.     uint8_t bitIndI;

  490. 

  491.     uint16_t readVal;

  492.     uint8_t writeVal;

  493. 

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

  495.     if(addres > 0x270F)

  496.     {

  497.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  498.     }

  499.    

  500.     byteIndI = addres / 8;

  501.     bitIndI = addres % 8;

  502.     

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

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

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

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

  507. 

  508.     /*置on*/

  509.     if(readVal == 0xFF00)

  510.     {

  511.         ModbusCoil[byteIndI] |= writeVal;

  512.     }

  513.     /*置off*/

  514.     else if(readVal == 0x0000)

  515.     {

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

  517.     }

  518.     else

  519.     {

  520.         return ModbusErrReply(0x05, ERR_DATA);

  521.     }

  522. 

  523.     ModbusTxBuf[0] = SLAVE_ADDRES;

  524.     ModbusTxBuf[1] = 0x0F;

  525.     /*操作地址*/

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

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

  528.     /*成功写入*/

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

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

  531.     AddCrc16(ModbusTxBuf, 6);

  532.     ModbusTxLen = 8;

  533. 

  534.     return 0;

  535. }

  536. 

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

  538. {

  539.     uint8_t writeValH;

  540.     uint8_t writeValL;

  541.     uint16_t writeVal;

  542.     

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

  544.     if(addres > 0x270F)

  545.     {

  546.         return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  547.     }

  548. 

  549.     writeValH = data[0];

  550.     writeValL = data[1];

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

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

  553.     ModbusReg[addres] = writeVal;

  554.     

  555.     ModbusTxBuf[0] = SLAVE_ADDRES;

  556.     ModbusTxBuf[1] = 0x10;

  557.     /*操作地址*/

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

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

  560.     /*成功写入*/

  561.     ModbusTxBuf[4] = writeValH;

  562.     ModbusTxBuf[5] = writeValL;

  563.     AddCrc16(ModbusTxBuf, 6);

  564.     ModbusTxLen = 8;

  565.     

  566.     return 0;

  567. }

  568. 

  569. uint8_t ModbusExtReadOdd(uint16_t num)

  570. {

  571.     uint8_t i = 0;

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

  573.     uint8_t numI = num % 125;

  574. 

  575.     uint8_t index;

  576.     uint16_t indexR;

  577.     uint8_t readValH;

  578.     uint8_t readValL;

  579.     uint8_t dataLen;

  580. 

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

  582.     {

  583.         if(j == numJ - 1)

  584.         {

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

  586.             {

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

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

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

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

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

  592. 

  593.                 ModbusTxBuf[index] = readValH;

  594.                 ModbusTxBuf[index + 1] = readValL;

  595.             }

  596.             dataLen = 2 * numI;

  597. 

  598.             ModbusTxBuf[0] = SLAVE_ADDRES;

  599.             ModbusTxBuf[1] = 0x03;

  600.             ModbusTxBuf[2] = dataLen;

  601.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  602.             ModbusTxLen = 5 + dataLen;

  603.         }

  604.         else

  605.         {

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

  607.             {

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

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

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

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

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

  613. 

  614.                 ModbusTxBuf[index] = readValH;

  615.                 ModbusTxBuf[index + 1] = readValL;

  616.             }

  617.             dataLen = 250;

  618. 

  619.             ModbusTxBuf[0] = SLAVE_ADDRES;

  620.             ModbusTxBuf[1] = 0x03;

  621.             ModbusTxBuf[2] = dataLen;

  622.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  623.             ModbusTxLen = 5 + dataLen;

  624.         }

  625.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  626.     }

  627.     return 0;

  628. }

  629. 

  630. 

  631. uint8_t ModbusErrReply(uint8_t func, uint8_t err)

  632. {

  633.     ModbusTxBuf[0] = SLAVE_ADDRES;

  634.     ModbusTxBuf[1] = func;

  635.     ModbusTxBuf[2] = err;

  636.     AddCrc16(ModbusTxBuf, 3);

  637.     ModbusTxLen = 5;

  638. 

  639.     return err;

  640. }

  641. 

  642. 

  643. 

  644. 

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

  646. {

  647.     uint8_t *dataT = data;

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

  649. 

  650.     /*低前高后*/

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

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

  653. }

  654. 

  655. /*crc16校验*/

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

  657. {

  658.     uint16_t crc;

  659.     uint16_t byteInd;

  660.     uint8_t bitInd;

  661.     

  662.     crc = 0xFFFFu;

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

  664.     {

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

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

  667.         {

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

  669.             {

  670.                 crc >>= 1;

  671.                 crc ^= 0xA001u;

  672.             }

  673.             else

  674.             {

  675.                 crc >>= 1;

  676.             }

  677.         }

  678.     }

  679.     return crc;

  680. }

  681. 

  682. /*crc16检查*/

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

  684. {

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

  686. 

  687.     if(recCrc16 == crc16)

  688.     {

  689.         return 0;

  690.     }

  691.     else

  692.     {

  693.         return -1;

  694.     }

  695. }