fubowen
/
TrainCamp_fubowen_Modbus
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
25 提交
1 分支
656 KiB
 
 
 
 
目录树: e30017820a
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'e30017820a'
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus.c

680 行
18 KiB
原始文件 Blame 文件历史 

  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. /*modbus协议帧解析任务*/

  28. void AppTaskModbusParse (void *p_arg)

  29. {

  30.     OS_ERR err;

  31.     MODBUS_FRAME frame;

  32.     uint16_t rxLen;

  33.     uint8_t rxBuf[256];

  34. 

  35.     while(1)

  36.     {

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

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

  39.         

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

  41.         rxLen = ModbusRxLen;

  42.         memcpy(rxBuf, ModbusRxBuf, rxLen);

  43. 

  44.         /*帧分解*/

  45.         frame.slaveAddres = rxBuf[0];

  46.         frame.func = rxBuf[1];

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

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

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

  50. 

  51.         /*crc校验判断*/

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

  53.         {   

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

  55.             ModbusErr = ERR_CRC;

  56.             continue;

  57.         }

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

  59.         if(frame.slaveAddres != SLAVE_ADDRES)

  60.         {

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

  62.             ModbusErr = ERR_SLAVE_ADDRES;

  63.             continue;

  64.         }

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

  66.         OSSemPost(ModbusConnect);

  67. 

  68.         /*功能码分类*/

  69.         switch(frame.func)

  70.         {

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

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

  73.                 break;

  74. 

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

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

  77.                 break;

  78. 

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

  80.                 frame.wNum = rxBuf[6];

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

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

  83.                 break;

  84. 

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

  86.                 frame.wNum = rxBuf[6];

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

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

  89.                 break;

  90.             

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

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

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

  94.                 break;

  95. 

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

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

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

  99.                 break;

  100. 

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

  102.                 ModbusErr = ERR_FUNC;

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

  104.                 break;

  105.         }

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

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

  108.         else

  109.         {

  110.             ModbusSend(ModbusTxBuf, ModbusTxLen);

  111.         }

  112. 

  113.         if(ModbusErr == 0 && (frame.func == 0x0F || frame.func == 0x10 

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

  115.         {

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

  117.             OSSemPost(ModbusWriteFlash);

  118.         }

  119.     }

  120. }

  121. 

  122. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num)

  123. {

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

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

  126.     uint16_t byteIndO;

  127.     uint8_t bitIndO;

  128. 

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

  130. 

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

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

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

  134. 

  135.     if(ModbusRxLen < 8)

  136.     {

  137.         return ModbusErrReply(0x01, ERR_DATA);

  138.     }

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

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

  141.     {

  142.         return ModbusErrReply(0x01, ERR_OPE_ADDRES);

  143.     }

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

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

  146.     {

  147.         return ModbusErrReply(0x01, ERR_DATA);

  148.     }

  149. 

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

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

  152. 

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

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

  155. 

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

  157.     {

  158.         byteIndO = i / 8;

  159.         bitIndO = i % 8;

  160. 

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

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

  163. 

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

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

  166.         

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

  168.         if(readVal != 0)

  169.         {

  170.             index = 3 + byteIndO;

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

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

  173. 

  174.             ModbusTxBuf[index] |= writeVal;

  175.         }

  176.     }

  177. 

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

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

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

  181.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  182.     ModbusTxLen = 5 + dataLen;

  183. 

  184.     return 0;

  185. }

  186. 

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

  188. {

  189.     uint16_t byteIndI;

  190.     uint8_t bitIndI;

  191.     uint16_t byteIndO;

  192.     uint8_t bitIndO;

  193. 

  194.     uint8_t readVal;

  195.     uint8_t writeVal;

  196. 

  197.     if(ModbusRxLen < 10)

  198.     {

  199.         return ModbusErrReply(0x0F, ERR_DATA);

  200.     }

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

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

  203.     {

  204.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  205.     }

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

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

  208.     {

  209.         return ModbusErrReply(0x0F, ERR_DATA);

  210.     }

  211.    

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

  213.     {

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

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

  216.     

  217.         byteIndO = i / 8;

  218.         bitIndO = i % 8;

  219. 

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

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

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

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

  224. 

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

  226.         if(readVal != 0)

  227.         {

  228.             ModbusCoil[byteIndI] |= writeVal;

  229.         }

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

  231.         else

  232.         {

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

  234.         }

  235.     }

  236.     ModbusTxBuf[0] = SLAVE_ADDRES;

  237.     ModbusTxBuf[1] = 0x0F;

  238.     /*操作地址*/

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

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

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

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

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

  244.     AddCrc16(ModbusTxBuf, 6);

  245.     ModbusTxLen = 8;

  246. 

  247.     return 0;

  248. }

  249. 

  250. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num)

  251. {

  252.     uint8_t index;

  253.     uint8_t readValH;

  254.     uint8_t readValL;

  255.     uint8_t dataLen;

  256. 

  257.     if(ModbusRxLen < 8)

  258.     {

  259.         return ModbusErrReply(0x13, ERR_DATA);

  260.     }

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

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

  263.     {

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

  265.         {

  266.             ;

  267.         }

  268.         else

  269.         {

  270.             return ModbusErrReply(0x03, ERR_OPE_ADDRES);

  271.         } 

  272.     }

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

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

  275.     {

  276.         return ModbusErrReply(0x03, ERR_DATA);

  277.     }

  278. 

  279.     dataLen = num * 2;

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

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

  282.     {

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

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

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

  286. 

  287.         ModbusTxBuf[3] = readValH;

  288.         ModbusTxBuf[4] = readValL;

  289.     }

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

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

  292.     {

  293.         return ModbusExtReadOdd(ModbusExtOdd[0]);

  294.     }

  295.     else

  296.     {

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

  298.         {

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

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

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

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

  303. 

  304.             ModbusTxBuf[index] = readValH;

  305.             ModbusTxBuf[index + 1] = readValL;

  306.         }

  307.     }

  308. 

  309.     ModbusTxBuf[0] = SLAVE_ADDRES;

  310.     ModbusTxBuf[1] = 0x03;

  311.     ModbusTxBuf[2] = dataLen;

  312.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  313.     ModbusTxLen = 5 + dataLen;

  314. 

  315.     return 0;

  316. }

  317. 

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

  319. {

  320.     uint8_t index;

  321. 

  322.     uint8_t writeValH;

  323.     uint8_t writeValL;

  324.     uint16_t writeVal;

  325. 

  326.     if(ModbusRxLen < 11)

  327.     {

  328.         return ModbusErrReply(0x10, ERR_DATA);

  329.     }

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

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

  332.     {

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

  334.         {

  335.             ;

  336.         }

  337.         else

  338.         {

  339.             return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  340.         }

  341.     }

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

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

  344.     {

  345.         return ModbusErrReply(0x10, ERR_DATA);

  346.     }

  347. 

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

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

  350.     {

  351.         writeValH = data[0];

  352.         writeValL = data[1];

  353.         

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

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

  356.         ModbusExtPage[0] = writeVal;

  357.     }

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

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

  360.     {

  361.         writeValH = data[0];

  362.         writeValL = data[1];

  363.         

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

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

  366.         ModbusExtOdd[0] = writeVal;

  367.     }

  368.     /*正常功能*/

  369.     else

  370.     {

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

  372.         {

  373.             index = i * 2;

  374. 

  375.             writeValH = data[index];

  376.             writeValL = data[index + 1];

  377.         

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

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

  380.             ModbusReg[addres + i] = writeVal;

  381.         }

  382.     }

  383. 

  384.     ModbusTxBuf[0] = SLAVE_ADDRES;

  385.     ModbusTxBuf[1] = 0x10;

  386.     /*操作地址*/

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

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

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

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

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

  392.     AddCrc16(ModbusTxBuf, 6);

  393.     ModbusTxLen = 8;

  394. 

  395.     return 0;

  396. }

  397. 

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

  399. {

  400.     uint16_t byteIndI;

  401.     uint8_t bitIndI;

  402. 

  403.     uint16_t readVal;

  404.     uint8_t writeVal;

  405. 

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

  407.     if(addres > 0x270F)

  408.     {

  409.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  410.     }

  411.    

  412.     byteIndI = addres / 8;

  413.     bitIndI = addres % 8;

  414.     

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

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

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

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

  419. 

  420.     /*置on*/

  421.     if(readVal == 0xFF00)

  422.     {

  423.         ModbusCoil[byteIndI] |= writeVal;

  424.     }

  425.     /*置off*/

  426.     else if(readVal == 0x0000)

  427.     {

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

  429.     }

  430.     else

  431.     {

  432.         return ModbusErrReply(0x05, ERR_DATA);

  433.     }

  434. 

  435.     ModbusTxBuf[0] = SLAVE_ADDRES;

  436.     ModbusTxBuf[1] = 0x0F;

  437.     /*操作地址*/

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

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

  440.     /*成功写入*/

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

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

  443.     AddCrc16(ModbusTxBuf, 6);

  444.     ModbusTxLen = 8;

  445. 

  446.     return 0;

  447. }

  448. 

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

  450. {

  451.     uint8_t writeValH;

  452.     uint8_t writeValL;

  453.     uint16_t writeVal;

  454.     

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

  456.     if(addres > 0x270F)

  457.     {

  458.         return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  459.     }

  460. 

  461.     writeValH = data[0];

  462.     writeValL = data[1];

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

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

  465.     ModbusReg[addres] = writeVal;

  466.     

  467.     ModbusTxBuf[0] = SLAVE_ADDRES;

  468.     ModbusTxBuf[1] = 0x10;

  469.     /*操作地址*/

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

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

  472.     /*成功写入*/

  473.     ModbusTxBuf[4] = writeValH;

  474.     ModbusTxBuf[5] = writeValL;

  475.     AddCrc16(ModbusTxBuf, 6);

  476.     ModbusTxLen = 8;

  477.     

  478.     return 0;

  479. }

  480. 

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

  482. void USART1_IRQHandler(void)

  483. {

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

  485. 

  486.     uint32_t temp;

  487.     uint16_t rxLenRemain;

  488.     

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

  490.     {

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

  492.         DMA_Cmd(DMA2_Stream2, DISABLE);

  493.         

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

  495.         temp = USART1->SR;

  496.         temp = USART1->DR;

  497.         (void)temp;

  498. 

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

  500.         DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2 | DMA_FLAG_HTIF2);

  501.         

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

  503.         rxLenRemain = DMA_GetCurrDataCounter(DMA2_Stream2);

  504.         ModbusRxLen = MODBUS_RX_BUF_SIZE - rxLenRemain;

  505. 

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

  507.         if(ModbusRxLen != 0)

  508.         {

  509.             OSSemPost(ModbusReceived);

  510.         }

  511.         

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

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

  514.         /*重启DMA*/

  515.         DMA_SetCurrDataCounter(DMA2_Stream2, MODBUS_RX_BUF_SIZE);

  516.         DMA_Cmd(DMA2_Stream2, ENABLE);

  517.     }

  518.     

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

  520. }

  521. 

  522. 

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

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

  525. {

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

  527.     {

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

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

  530.     }

  531. 

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

  533.     DMA_Cmd(DMA2_Stream7, DISABLE);

  534. 

  535.     /*等待DMA关闭*/

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

  537. 

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

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

  540.     

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

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

  543.     DMA_SetCurrDataCounter(DMA2_Stream7, len);

  544. 

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

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

  547.     

  548.     /*启动 DMA 发送*/

  549.     DMA_Cmd(DMA2_Stream7, ENABLE);

  550. }

  551. 

  552. uint8_t ModbusExtReadOdd(uint16_t num)

  553. {

  554.     uint8_t i = 0;

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

  556.     uint8_t numI = num % 125;

  557. 

  558.     uint8_t index;

  559.     uint16_t indexR;

  560.     uint8_t readValH;

  561.     uint8_t readValL;

  562.     uint8_t dataLen;

  563. 

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

  565.     {

  566.         if(j == numJ - 1)

  567.         {

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

  569.             {

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

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

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

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

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

  575. 

  576.                 ModbusTxBuf[index] = readValH;

  577.                 ModbusTxBuf[index + 1] = readValL;

  578.             }

  579.             dataLen = 2 * numI;

  580. 

  581.             ModbusTxBuf[0] = SLAVE_ADDRES;

  582.             ModbusTxBuf[1] = 0x03;

  583.             ModbusTxBuf[2] = dataLen;

  584.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  585.             ModbusTxLen = 5 + dataLen;

  586.         }

  587.         else

  588.         {

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

  590.             {

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

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

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

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

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

  596. 

  597.                 ModbusTxBuf[index] = readValH;

  598.                 ModbusTxBuf[index + 1] = readValL;

  599.             }

  600.             dataLen = 250;

  601. 

  602.             ModbusTxBuf[0] = SLAVE_ADDRES;

  603.             ModbusTxBuf[1] = 0x03;

  604.             ModbusTxBuf[2] = dataLen;

  605.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  606.             ModbusTxLen = 5 + dataLen;

  607.         }

  608.         /*演示2ms*/

  609.         OSTimeDly(OS_TICKS_PER_SEC / 500);  

  610.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  611.     }

  612.     return 0;

  613. }

  614. 

  615. 

  616. uint8_t ModbusErrReply(uint8_t func, uint8_t err)

  617. {

  618.     ModbusTxBuf[0] = SLAVE_ADDRES;

  619.     ModbusTxBuf[1] = func;

  620.     ModbusTxBuf[2] = err;

  621.     AddCrc16(ModbusTxBuf, 3);

  622.     ModbusTxLen = 5;

  623. 

  624.     return err;

  625. }

  626. 

  627. 

  628. 

  629. 

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

  631. {

  632.     uint8_t *dataT = data;

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

  634. 

  635.     /*低前高后*/

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

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

  638. }

  639. 

  640. /*crc16校验*/

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

  642. {

  643.     uint16_t crc;

  644.     uint16_t byteInd;

  645.     uint8_t bitInd;

  646.     

  647.     crc = 0xFFFFu;

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

  649.     {

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

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

  652.         {

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

  654.             {

  655.                 crc >>= 1;

  656.                 crc ^= 0xA001u;

  657.             }

  658.             else

  659.             {

  660.                 crc >>= 1;

  661.             }

  662.         }

  663.     }

  664.     return crc;

  665. }

  666. 

  667. /*crc16检查*/

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

  669. {

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

  671. 

  672.     if(recCrc16 == crc16)

  673.     {

  674.         return 0;

  675.     }

  676.     else

  677.     {

  678.         return -1;

  679.     }

  680. }