fubowen
/
TrainCamp_fubowen_Modbus
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
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.
32 Commits
1 Branch
656 KiB
 
 
 
 
Tree: a2aba72b2e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a2aba72b2e'
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus_parse.c

511 lines
13 KiB
Raw Blame History 

  1. #include "stm32f4xx.h"

  2. #include "ucos_ii.h"

  3. #include "os.h"

  4. #include "string.h"

  5. #include "modbus_parse.h"

  6. #include "modbus_rec_send.h"

  7. 

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

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

  10. 

  11. uint8_t ModbusErr;

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

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

  14. uint16_t ModbusReg[10000];

  15. 

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

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

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

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

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

  21. 

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

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

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

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

  26. 

  27. 

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

  29. void AppTaskModbusParse (void *p_arg)

  30. {

  31.     OS_ERR err;

  32.     MODBUS_FRAME frame;

  33.     uint16_t rxLen;

  34.     uint8_t rxBuf[256];

  35. 

  36.     while(1)

  37.     {

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

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

  40.         

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

  42.         rxLen = ModbusRxLen;

  43.         if(rxLen > MODBUS_RX_BUF_SIZE)

  44.         {

  45.             rxLen = 0;

  46.         }

  47.         memcpy(rxBuf, ModbusRxBuf, rxLen);

  48. 

  49.         /*帧分解*/

  50.         frame.slaveAddres = rxBuf[0];

  51.         frame.func = rxBuf[1];

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

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

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

  55. 

  56.         /*crc校验判断*/

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

  58.         {   

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

  60.             ModbusErr = ERR_CRC;

  61.             continue;

  62.         }

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

  64.         if(frame.slaveAddres != SLAVE_ADDRES)

  65.         {

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

  67.             ModbusErr = ERR_SLAVE_ADDRES;

  68.             continue;

  69.         }

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

  71.         OSSemPost(ModbusConnect);

  72. 

  73.         /*功能码分类*/

  74.         switch(frame.func)

  75.         {

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

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

  78.                 break;

  79. 

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

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

  82.                 break;

  83. 

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

  85.                 frame.wNum = rxBuf[6];

  86.                 if(frame.wNum != ((frame.opeNum + 7) / 8))

  87.                 {

  88.                     ModbusErr = ModbusErrReply(0x0F, ERR_DATA);

  89.                 }

  90.                 else

  91.                 {

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

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

  94.                 }        

  95.                 break;

  96. 

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

  98.                 frame.wNum = rxBuf[6];

  99.                 if(frame.wNum != (frame.opeNum * 2))

  100.                 {

  101.                     ModbusErr = ModbusErrReply(0x10, ERR_DATA);

  102.                 }

  103.                 else

  104.                 {

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

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

  107.                 }

  108.                 break;

  109.             

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

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

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

  113.                 break;

  114. 

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

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

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

  118.                 break;

  119. 

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

  121.                 ModbusErr = ERR_FUNC;

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

  123.                 break;

  124.         }

  125.         /*发送响应帧*/

  126.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  127. 

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

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

  130.         {

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

  132.             OSSemPost(ModbusWriteFlash);

  133.         }

  134.     }

  135. }

  136. 

  137. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num)

  138. {

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

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

  141.     uint16_t byteIndO;

  142.     uint8_t bitIndO;

  143. 

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

  145. 

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

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

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

  149. 

  150.     if(ModbusRxLen < 8)

  151.     {

  152.         return ModbusErrReply(0x01, ERR_DATA);

  153.     }

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

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

  156.     {

  157.         return ModbusErrReply(0x01, ERR_OPE_ADDRES);

  158.     }

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

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

  161.     {

  162.         return ModbusErrReply(0x01, ERR_DATA);

  163.     }

  164. 

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

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

  167. 

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

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

  170. 

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

  172.     {

  173.         byteIndO = i / 8;

  174.         bitIndO = i % 8;

  175. 

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

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

  178. 

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

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

  181.         

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

  183.         if(readVal != 0)

  184.         {

  185.             index = 3 + byteIndO;

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

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

  188. 

  189.             ModbusTxBuf[index] |= writeVal;

  190.         }

  191.     }

  192. 

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

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

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

  196.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  197.     ModbusTxLen = 5 + dataLen;

  198. 

  199.     return 0;

  200. }

  201. 

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

  203. {

  204.     uint16_t byteIndI;

  205.     uint8_t bitIndI;

  206.     uint16_t byteIndO;

  207.     uint8_t bitIndO;

  208. 

  209.     uint8_t readVal;

  210.     uint8_t writeVal;

  211. 

  212.     if(ModbusRxLen < 10)

  213.     {

  214.         return ModbusErrReply(0x0F, ERR_DATA);

  215.     }

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

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

  218.     {

  219.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  220.     }

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

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

  223.     {

  224.         return ModbusErrReply(0x0F, ERR_DATA);

  225.     }

  226.    

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

  228.     {

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

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

  231.     

  232.         byteIndO = i / 8;

  233.         bitIndO = i % 8;

  234. 

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

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

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

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

  239. 

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

  241.         if(readVal != 0)

  242.         {

  243.             ModbusCoil[byteIndI] |= writeVal;

  244.         }

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

  246.         else

  247.         {

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

  249.         }

  250.     }

  251.     ModbusTxBuf[0] = SLAVE_ADDRES;

  252.     ModbusTxBuf[1] = 0x0F;

  253.     /*操作地址*/

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

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

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

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

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

  259.     AddCrc16(ModbusTxBuf, 6);

  260.     ModbusTxLen = 8;

  261. 

  262.     return 0;

  263. }

  264. 

  265. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num)

  266. {

  267.     uint8_t index;

  268.     uint8_t readValH;

  269.     uint8_t readValL;

  270.     uint8_t dataLen;

  271. 

  272.     if(ModbusRxLen < 8)

  273.     {

  274.         return ModbusErrReply(0x03, ERR_DATA);

  275.     }

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

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

  278.     {

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

  280.         {

  281.             ;

  282.         }

  283.         else

  284.         {

  285.             return ModbusErrReply(0x03, ERR_OPE_ADDRES);

  286.         } 

  287.     }

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

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

  290.     {

  291.         return ModbusErrReply(0x03, ERR_DATA);

  292.     }

  293. 

  294.     dataLen = num * 2;

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

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

  297.     {

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

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

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

  301. 

  302.         ModbusTxBuf[3] = readValH;

  303.         ModbusTxBuf[4] = readValL;

  304.     }

  305.     else

  306.     {

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

  308.         {

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

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

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

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

  313. 

  314.             ModbusTxBuf[index] = readValH;

  315.             ModbusTxBuf[index + 1] = readValL;

  316.         }

  317.     }

  318. 

  319.     ModbusTxBuf[0] = SLAVE_ADDRES;

  320.     ModbusTxBuf[1] = 0x03;

  321.     ModbusTxBuf[2] = dataLen;

  322.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  323.     ModbusTxLen = 5 + dataLen;

  324. 

  325.     return 0;

  326. }

  327. 

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

  329. {

  330.     uint8_t index;

  331. 

  332.     uint8_t writeValH;

  333.     uint8_t writeValL;

  334.     uint16_t writeVal;

  335. 

  336.     if(ModbusRxLen < 11)

  337.     {

  338.         return ModbusErrReply(0x10, ERR_DATA);

  339.     }

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

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

  342.     {

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

  344.         {

  345.             ;

  346.         }

  347.         else

  348.         {

  349.             return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  350.         }

  351.     }

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

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

  354.     {

  355.         return ModbusErrReply(0x10, ERR_DATA);

  356.     }

  357. 

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

  359.     if(addres == 0xFFFE && 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.         ModbusExtPage[0] = writeVal;

  367.     }

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

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

  370.     {

  371.         writeValH = data[0];

  372.         writeValL = data[1];

  373.         

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

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

  376.         ModbusExtOdd[0] = writeVal;

  377.     }

  378.     /*正常功能*/

  379.     else

  380.     {

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

  382.         {

  383.             index = i * 2;

  384. 

  385.             writeValH = data[index];

  386.             writeValL = data[index + 1];

  387.         

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

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

  390.             ModbusReg[addres + i] = writeVal;

  391.         }

  392.     }

  393. 

  394.     ModbusTxBuf[0] = SLAVE_ADDRES;

  395.     ModbusTxBuf[1] = 0x10;

  396.     /*操作地址*/

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

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

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

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

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

  402.     AddCrc16(ModbusTxBuf, 6);

  403.     ModbusTxLen = 8;

  404. 

  405.     return 0;

  406. }

  407. 

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

  409. {

  410.     uint16_t byteIndI;

  411.     uint8_t bitIndI;

  412. 

  413.     uint16_t readVal;

  414.     uint8_t writeVal;

  415. 

  416.     if(ModbusRxLen < 8)

  417.     {

  418.         return ModbusErrReply(0x05, ERR_DATA);

  419.     }

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

  421.     if(addres > 0x270F)

  422.     {

  423.         return ModbusErrReply(0x05, ERR_OPE_ADDRES);

  424.     }

  425.    

  426.     byteIndI = addres / 8;

  427.     bitIndI = addres % 8;

  428.     

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

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

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

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

  433. 

  434.     /*置on*/

  435.     if(readVal == 0xFF00)

  436.     {

  437.         ModbusCoil[byteIndI] |= writeVal;

  438.     }

  439.     /*置off*/

  440.     else if(readVal == 0x0000)

  441.     {

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

  443.     }

  444.     else

  445.     {

  446.         return ModbusErrReply(0x05, ERR_DATA);

  447.     }

  448. 

  449.     ModbusTxBuf[0] = SLAVE_ADDRES;

  450.     ModbusTxBuf[1] = 0x05;

  451.     /*操作地址*/

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

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

  454.     /*成功写入*/

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

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

  457.     AddCrc16(ModbusTxBuf, 6);

  458.     ModbusTxLen = 8;

  459. 

  460.     return 0;

  461. }

  462. 

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

  464. {

  465.     uint8_t writeValH;

  466.     uint8_t writeValL;

  467.     uint16_t writeVal;

  468.     

  469.     if(ModbusRxLen < 8)

  470.     {

  471.         return ModbusErrReply(0x06, ERR_DATA);

  472.     }

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

  474.     if(addres > 0x270F)

  475.     {

  476.         return ModbusErrReply(0x06, ERR_OPE_ADDRES);

  477.     }

  478. 

  479.     writeValH = data[0];

  480.     writeValL = data[1];

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

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

  483.     ModbusReg[addres] = writeVal;

  484.     

  485.     ModbusTxBuf[0] = SLAVE_ADDRES;

  486.     ModbusTxBuf[1] = 0x06;

  487.     /*操作地址*/

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

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

  490.     /*成功写入*/

  491.     ModbusTxBuf[4] = writeValH;

  492.     ModbusTxBuf[5] = writeValL;

  493.     AddCrc16(ModbusTxBuf, 6);

  494.     ModbusTxLen = 8;

  495.     

  496.     return 0;

  497. }

  498. 

  499. 

  500. 

  501. uint8_t ModbusErrReply(uint8_t func, uint8_t err)

  502. {

  503.     ModbusTxBuf[0] = SLAVE_ADDRES;

  504.     ModbusTxBuf[1] = func | 0x80;

  505.     ModbusTxBuf[2] = err;

  506.     AddCrc16(ModbusTxBuf, 3);

  507.     ModbusTxLen = 5;

  508. 

  509.     return err;

  510. }