fubowen
/
TrainCamp_fubowen_Modbus
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
21 Revīzija
1 Atzars
656 KiB
 
 
 
 
Koks: 3b89fa7f43
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '3b89fa7f43'
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus.c

685 rindas
18 KiB
Neapstrādāts Vainot Vēsture 

  1. #include "stm32f4xx.h"

  2. #include "ucos_ii.h"

  3. #include "os.h"

  4. #include "string.h"

  5. #include "modbus.h"

  6. 

  7. 

  8. uint8_t ModbusErr;

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

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

  11. uint16_t ModbusReg[10000];

  12. 

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

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

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

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

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

  18. 

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

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

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

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

  23. 

  24. 

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

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

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

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

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

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

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

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

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

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

  35. uint8_t ModbusExtReadOdd(uint16_t num);

  36. 

  37. 

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

  39. void USART1_IRQHandler(void)

  40. {

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

  42. 

  43.     uint32_t temp;

  44.     uint16_t rxLenRemain;

  45.     

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

  47.     {

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

  49.         DMA_Cmd(DMA2_Stream2, DISABLE);

  50.         

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

  52.         temp = USART1->SR;

  53.         temp = USART1->DR;

  54.         (void)temp;

  55. 

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

  57.         DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2 | DMA_FLAG_HTIF2);

  58.         

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

  60.         rxLenRemain = DMA_GetCurrDataCounter(DMA2_Stream2);

  61.         ModbusRxLen = MODBUS_RX_BUF_SIZE - rxLenRemain;

  62. 

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

  64.         if(ModbusRxLen != 0)

  65.         {

  66.             OSSemPost(ModbusReceived);

  67.         }

  68.         

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

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

  71.         /*重启DMA*/

  72.         DMA_SetCurrDataCounter(DMA2_Stream2, MODBUS_RX_BUF_SIZE);

  73.         DMA_Cmd(DMA2_Stream2, ENABLE);

  74.     }

  75.     

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

  77. }

  78. 

  79. 

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

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

  82. {

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

  84.     {

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

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

  87.     }

  88. 

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

  90.     DMA_Cmd(DMA2_Stream7, DISABLE);

  91. 

  92.     /*等待DMA关闭*/

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

  94. 

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

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

  97.     

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

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

  100.     DMA_SetCurrDataCounter(DMA2_Stream7, len);

  101. 

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

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

  104.     

  105.     /*启动 DMA 发送*/

  106.     DMA_Cmd(DMA2_Stream7, ENABLE);

  107. }

  108. 

  109. 

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

  111. void AppTaskModbusParse (void *p_arg)

  112. {

  113.     OS_ERR err;

  114.     MODBUS_FRAME frame;

  115.     uint16_t rxLen;

  116.     uint8_t rxBuf[256];

  117. 

  118.     while(1)

  119.     {

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

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

  122.         

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

  124.         rxLen = ModbusRxLen;

  125.         memcpy(rxBuf, ModbusRxBuf, rxLen);

  126. 

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

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

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

  130.         {   

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

  132.             ModbusErr = ERR_CRC;

  133.             continue;

  134.         }

  135. 

  136.         frame.slaveAddres = rxBuf[0];

  137.         if(frame.slaveAddres != SLAVE_ADDRES)

  138.         {

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

  140.             ModbusErr = ERR_SLAVE_ADDRES;

  141.             continue;

  142.         }

  143. 

  144.         frame.func = rxBuf[1];

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

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

  147.         

  148.         /*功能码分类*/

  149.         switch(frame.func)

  150.         {

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

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

  153.                 break;

  154. 

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

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

  157.                 break;

  158. 

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

  160.                 frame.wNum = rxBuf[6];

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

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

  163.                 break;

  164. 

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

  166.                 frame.wNum = rxBuf[6];

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

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

  169.                 break;

  170.             

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

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

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

  174.                 break;

  175. 

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

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

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

  179.                 break;

  180. 

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

  182.                 ModbusErr = ERR_FUNC;

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

  184.                 break;

  185.         }

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

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

  188.         {

  189.             ;

  190.         }

  191.         else

  192.         {

  193.             /*启动发送*/

  194.             ModbusSend(ModbusTxBuf, ModbusTxLen);

  195.         }

  196.     }

  197. }

  198. 

  199. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num)

  200. {

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

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

  203.     uint16_t byteIndO;

  204.     uint8_t bitIndO;

  205. 

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

  207. 

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

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

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

  211. 

  212.     if(ModbusRxLen < 8)

  213.     {

  214.         return ModbusErrReply(0x01, ERR_DATA);

  215.     }

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

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

  218.     {

  219.         return ModbusErrReply(0x01, ERR_OPE_ADDRES);

  220.     }

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

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

  223.     {

  224.         return ModbusErrReply(0x01, ERR_DATA);

  225.     }

  226. 

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

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

  229. 

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

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

  232. 

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

  234.     {

  235.         byteIndO = i / 8;

  236.         bitIndO = i % 8;

  237. 

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

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

  240. 

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

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

  243.         

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

  245.         if(readVal != 0)

  246.         {

  247.             index = 3 + byteIndO;

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

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

  250. 

  251.             ModbusTxBuf[index] |= writeVal;

  252.         }

  253.     }

  254. 

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

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

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

  258.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  259.     ModbusTxLen = 5 + dataLen;

  260. 

  261.     return 0;

  262. }

  263. 

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

  265. {

  266.     uint16_t byteIndI;

  267.     uint8_t bitIndI;

  268.     uint16_t byteIndO;

  269.     uint8_t bitIndO;

  270. 

  271.     uint8_t readVal;

  272.     uint8_t writeVal;

  273. 

  274.     if(ModbusRxLen < 10)

  275.     {

  276.         return ModbusErrReply(0x0F, ERR_DATA);

  277.     }

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

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

  280.     {

  281.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  282.     }

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

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

  285.     {

  286.         return ModbusErrReply(0x0F, ERR_DATA);

  287.     }

  288.    

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

  290.     {

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

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

  293.     

  294.         byteIndO = i / 8;

  295.         bitIndO = i % 8;

  296. 

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

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

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

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

  301. 

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

  303.         if(readVal != 0)

  304.         {

  305.             ModbusCoil[byteIndI] |= writeVal;

  306.         }

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

  308.         else

  309.         {

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

  311.         }

  312.     }

  313.     ModbusTxBuf[0] = SLAVE_ADDRES;

  314.     ModbusTxBuf[1] = 0x0F;

  315.     /*操作地址*/

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

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

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

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

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

  321.     AddCrc16(ModbusTxBuf, 6);

  322.     ModbusTxLen = 8;

  323. 

  324.     return 0;

  325. }

  326. 

  327. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num)

  328. {

  329.     uint8_t index;

  330.     uint8_t readValH;

  331.     uint8_t readValL;

  332.     uint8_t dataLen;

  333. 

  334.     if(ModbusRxLen < 8)

  335.     {

  336.         return ModbusErrReply(0x13, ERR_DATA);

  337.     }

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

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

  340.     {

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

  342.         {

  343.             ;

  344.         }

  345.         else

  346.         {

  347.             return ModbusErrReply(0x03, ERR_OPE_ADDRES);

  348.         } 

  349.     }

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

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

  352.     {

  353.         return ModbusErrReply(0x03, ERR_DATA);

  354.     }

  355. 

  356.     dataLen = num * 2;

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

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

  359.     {

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

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

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

  363. 

  364.         ModbusTxBuf[3] = readValH;

  365.         ModbusTxBuf[4] = readValL;

  366.     }

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

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

  369.     {

  370.         return ModbusExtReadOdd(ModbusExtOdd[0]);

  371.     }

  372.     else

  373.     {

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

  375.         {

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

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

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

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

  380. 

  381.             ModbusTxBuf[index] = readValH;

  382.             ModbusTxBuf[index + 1] = readValL;

  383.         }

  384.     }

  385. 

  386.     ModbusTxBuf[0] = SLAVE_ADDRES;

  387.     ModbusTxBuf[1] = 0x03;

  388.     ModbusTxBuf[2] = dataLen;

  389.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  390.     ModbusTxLen = 5 + dataLen;

  391. 

  392.     return 0;

  393. }

  394. 

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

  396. {

  397.     uint8_t index;

  398. 

  399.     uint8_t writeValH;

  400.     uint8_t writeValL;

  401.     uint16_t writeVal;

  402. 

  403.     if(ModbusRxLen < 11)

  404.     {

  405.         return ModbusErrReply(0x10, ERR_DATA);

  406.     }

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

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

  409.     {

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

  411.         {

  412.             ;

  413.         }

  414.         else

  415.         {

  416.             return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  417.         }

  418.     }

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

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

  421.     {

  422.         return ModbusErrReply(0x10, ERR_DATA);

  423.     }

  424. 

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

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

  427.     {

  428.         writeValH = data[0];

  429.         writeValL = data[1];

  430.         

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

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

  433.         ModbusExtPage[0] = writeVal;

  434.     }

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

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

  437.     {

  438.         writeValH = data[0];

  439.         writeValL = data[1];

  440.         

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

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

  443.         ModbusExtOdd[0] = writeVal;

  444.     }

  445.     /*正常功能*/

  446.     else

  447.     {

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

  449.         {

  450.             index = i * 2;

  451. 

  452.             writeValH = data[index];

  453.             writeValL = data[index + 1];

  454.         

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

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

  457.             ModbusReg[addres + i] = writeVal;

  458.         }

  459.     }

  460. 

  461.     ModbusTxBuf[0] = SLAVE_ADDRES;

  462.     ModbusTxBuf[1] = 0x10;

  463.     /*操作地址*/

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

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

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

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

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

  469.     AddCrc16(ModbusTxBuf, 6);

  470.     ModbusTxLen = 8;

  471. 

  472.     return 0;

  473. }

  474. 

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

  476. {

  477.     uint16_t byteIndI;

  478.     uint8_t bitIndI;

  479. 

  480.     uint16_t readVal;

  481.     uint8_t writeVal;

  482. 

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

  484.     if(addres > 0x270F)

  485.     {

  486.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  487.     }

  488.    

  489.     byteIndI = addres / 8;

  490.     bitIndI = addres % 8;

  491.     

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

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

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

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

  496. 

  497.     /*置on*/

  498.     if(readVal == 0xFF00)

  499.     {

  500.         ModbusCoil[byteIndI] |= writeVal;

  501.     }

  502.     /*置off*/

  503.     else if(readVal == 0x0000)

  504.     {

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

  506.     }

  507.     else

  508.     {

  509.         return ModbusErrReply(0x05, ERR_DATA);

  510.     }

  511. 

  512.     ModbusTxBuf[0] = SLAVE_ADDRES;

  513.     ModbusTxBuf[1] = 0x0F;

  514.     /*操作地址*/

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

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

  517.     /*成功写入*/

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

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

  520.     AddCrc16(ModbusTxBuf, 6);

  521.     ModbusTxLen = 8;

  522. 

  523.     return 0;

  524. }

  525. 

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

  527. {

  528.     uint8_t writeValH;

  529.     uint8_t writeValL;

  530.     uint16_t writeVal;

  531.     

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

  533.     if(addres > 0x270F)

  534.     {

  535.         return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  536.     }

  537. 

  538.     writeValH = data[0];

  539.     writeValL = data[1];

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

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

  542.     ModbusReg[addres] = writeVal;

  543.     

  544.     ModbusTxBuf[0] = SLAVE_ADDRES;

  545.     ModbusTxBuf[1] = 0x10;

  546.     /*操作地址*/

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

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

  549.     /*成功写入*/

  550.     ModbusTxBuf[4] = writeValH;

  551.     ModbusTxBuf[5] = writeValL;

  552.     AddCrc16(ModbusTxBuf, 6);

  553.     ModbusTxLen = 8;

  554.     

  555.     return 0;

  556. }

  557. 

  558. uint8_t ModbusExtReadOdd(uint16_t num)

  559. {

  560.     uint8_t i = 0;

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

  562.     uint8_t numI = num % 125;

  563. 

  564.     uint8_t index;

  565.     uint16_t indexR;

  566.     uint8_t readValH;

  567.     uint8_t readValL;

  568.     uint8_t dataLen;

  569. 

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

  571.     {

  572.         if(j == numJ - 1)

  573.         {

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

  575.             {

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

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

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

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

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

  581. 

  582.                 ModbusTxBuf[index] = readValH;

  583.                 ModbusTxBuf[index + 1] = readValL;

  584.             }

  585.             dataLen = 2 * numI;

  586. 

  587.             ModbusTxBuf[0] = SLAVE_ADDRES;

  588.             ModbusTxBuf[1] = 0x03;

  589.             ModbusTxBuf[2] = dataLen;

  590.             AddCrc16(ModbusTxBuf, 3 + dataLen);

  591.             ModbusTxLen = 5 + dataLen;

  592.         }

  593.         else

  594.         {

  595.             for(i = 0; i < 125; 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 = 250;

  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.         OSTimeDlyHMSM(0, 0, 0, 10);

  615.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  616.     }

  617.     return 0;

  618. }

  619. 

  620. 

  621. uint8_t ModbusErrReply(uint8_t func, uint8_t err)

  622. {

  623.     ModbusTxBuf[0] = SLAVE_ADDRES;

  624.     ModbusTxBuf[1] = func;

  625.     ModbusTxBuf[2] = err;

  626.     AddCrc16(ModbusTxBuf, 3);

  627.     ModbusTxLen = 5;

  628. 

  629.     return err;

  630. }

  631. 

  632. 

  633. 

  634. 

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

  636. {

  637.     uint8_t *dataT = data;

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

  639. 

  640.     /*低前高后*/

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

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

  643. }

  644. 

  645. /*crc16校验*/

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

  647. {

  648.     uint16_t crc;

  649.     uint16_t byteInd;

  650.     uint8_t bitInd;

  651.     

  652.     crc = 0xFFFFu;

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

  654.     {

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

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

  657.         {

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

  659.             {

  660.                 crc >>= 1;

  661.                 crc ^= 0xA001u;

  662.             }

  663.             else

  664.             {

  665.                 crc >>= 1;

  666.             }

  667.         }

  668.     }

  669.     return crc;

  670. }

  671. 

  672. /*crc16检查*/

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

  674. {

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

  676. 

  677.     if(recCrc16 == crc16)

  678.     {

  679.         return 0;

  680.     }

  681.     else

  682.     {

  683.         return -1;

  684.     }

  685. }