fubowen
/
TrainCamp_fubowen_Modbus
1
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
31 Commits
1 Branch
656 KiB
 
 
 
 
Struktur: c17db5359a
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „c17db5359a“
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus_parse.c

497 Zeilen
13 KiB
Originalformat Blame Verlauf 

  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.                 memcpy(frame.wData, &rxBuf[7], frame.wNum);

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

  88.                 break;

  89. 

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

  91.                 frame.wNum = rxBuf[6];

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

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

  94.                 break;

  95.             

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

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

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

  99.                 break;

  100. 

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

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

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

  104.                 break;

  105. 

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

  107.                 ModbusErr = ERR_FUNC;

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

  109.                 break;

  110.         }

  111.         /*发送响应帧*/

  112.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  113. 

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

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

  116.         {

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

  118.             OSSemPost(ModbusWriteFlash);

  119.         }

  120.     }

  121. }

  122. 

  123. uint8_t ModbusReadCoils(uint16_t addres, uint16_t num)

  124. {

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

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

  127.     uint16_t byteIndO;

  128.     uint8_t bitIndO;

  129. 

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

  131. 

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

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

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

  135. 

  136.     if(ModbusRxLen < 8)

  137.     {

  138.         return ModbusErrReply(0x01, ERR_DATA);

  139.     }

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

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

  142.     {

  143.         return ModbusErrReply(0x01, ERR_OPE_ADDRES);

  144.     }

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

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

  147.     {

  148.         return ModbusErrReply(0x01, ERR_DATA);

  149.     }

  150. 

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

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

  153. 

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

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

  156. 

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

  158.     {

  159.         byteIndO = i / 8;

  160.         bitIndO = i % 8;

  161. 

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

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

  164. 

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

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

  167.         

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

  169.         if(readVal != 0)

  170.         {

  171.             index = 3 + byteIndO;

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

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

  174. 

  175.             ModbusTxBuf[index] |= writeVal;

  176.         }

  177.     }

  178. 

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

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

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

  182.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  183.     ModbusTxLen = 5 + dataLen;

  184. 

  185.     return 0;

  186. }

  187. 

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

  189. {

  190.     uint16_t byteIndI;

  191.     uint8_t bitIndI;

  192.     uint16_t byteIndO;

  193.     uint8_t bitIndO;

  194. 

  195.     uint8_t readVal;

  196.     uint8_t writeVal;

  197. 

  198.     if(ModbusRxLen < 10)

  199.     {

  200.         return ModbusErrReply(0x0F, ERR_DATA);

  201.     }

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

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

  204.     {

  205.         return ModbusErrReply(0x0F, ERR_OPE_ADDRES);

  206.     }

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

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

  209.     {

  210.         return ModbusErrReply(0x0F, ERR_DATA);

  211.     }

  212.    

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

  214.     {

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

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

  217.     

  218.         byteIndO = i / 8;

  219.         bitIndO = i % 8;

  220. 

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

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

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

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

  225. 

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

  227.         if(readVal != 0)

  228.         {

  229.             ModbusCoil[byteIndI] |= writeVal;

  230.         }

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

  232.         else

  233.         {

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

  235.         }

  236.     }

  237.     ModbusTxBuf[0] = SLAVE_ADDRES;

  238.     ModbusTxBuf[1] = 0x0F;

  239.     /*操作地址*/

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

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

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

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

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

  245.     AddCrc16(ModbusTxBuf, 6);

  246.     ModbusTxLen = 8;

  247. 

  248.     return 0;

  249. }

  250. 

  251. uint8_t ModbusReadRegs(uint16_t addres, uint16_t num)

  252. {

  253.     uint8_t index;

  254.     uint8_t readValH;

  255.     uint8_t readValL;

  256.     uint8_t dataLen;

  257. 

  258.     if(ModbusRxLen < 8)

  259.     {

  260.         return ModbusErrReply(0x03, ERR_DATA);

  261.     }

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

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

  264.     {

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

  266.         {

  267.             ;

  268.         }

  269.         else

  270.         {

  271.             return ModbusErrReply(0x03, ERR_OPE_ADDRES);

  272.         } 

  273.     }

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

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

  276.     {

  277.         return ModbusErrReply(0x03, ERR_DATA);

  278.     }

  279. 

  280.     dataLen = num * 2;

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

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

  283.     {

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

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

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

  287. 

  288.         ModbusTxBuf[3] = readValH;

  289.         ModbusTxBuf[4] = readValL;

  290.     }

  291.     else

  292.     {

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

  294.         {

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

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

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

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

  299. 

  300.             ModbusTxBuf[index] = readValH;

  301.             ModbusTxBuf[index + 1] = readValL;

  302.         }

  303.     }

  304. 

  305.     ModbusTxBuf[0] = SLAVE_ADDRES;

  306.     ModbusTxBuf[1] = 0x03;

  307.     ModbusTxBuf[2] = dataLen;

  308.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  309.     ModbusTxLen = 5 + dataLen;

  310. 

  311.     return 0;

  312. }

  313. 

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

  315. {

  316.     uint8_t index;

  317. 

  318.     uint8_t writeValH;

  319.     uint8_t writeValL;

  320.     uint16_t writeVal;

  321. 

  322.     if(ModbusRxLen < 11)

  323.     {

  324.         return ModbusErrReply(0x10, ERR_DATA);

  325.     }

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

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

  328.     {

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

  330.         {

  331.             ;

  332.         }

  333.         else

  334.         {

  335.             return ModbusErrReply(0x10, ERR_OPE_ADDRES);

  336.         }

  337.     }

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

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

  340.     {

  341.         return ModbusErrReply(0x10, ERR_DATA);

  342.     }

  343. 

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

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

  346.     {

  347.         writeValH = data[0];

  348.         writeValL = data[1];

  349.         

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

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

  352.         ModbusExtPage[0] = writeVal;

  353.     }

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

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

  356.     {

  357.         writeValH = data[0];

  358.         writeValL = data[1];

  359.         

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

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

  362.         ModbusExtOdd[0] = writeVal;

  363.     }

  364.     /*正常功能*/

  365.     else

  366.     {

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

  368.         {

  369.             index = i * 2;

  370. 

  371.             writeValH = data[index];

  372.             writeValL = data[index + 1];

  373.         

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

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

  376.             ModbusReg[addres + i] = writeVal;

  377.         }

  378.     }

  379. 

  380.     ModbusTxBuf[0] = SLAVE_ADDRES;

  381.     ModbusTxBuf[1] = 0x10;

  382.     /*操作地址*/

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

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

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

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

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

  388.     AddCrc16(ModbusTxBuf, 6);

  389.     ModbusTxLen = 8;

  390. 

  391.     return 0;

  392. }

  393. 

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

  395. {

  396.     uint16_t byteIndI;

  397.     uint8_t bitIndI;

  398. 

  399.     uint16_t readVal;

  400.     uint8_t writeVal;

  401. 

  402.     if(ModbusRxLen < 8)

  403.     {

  404.         return ModbusErrReply(0x05, ERR_DATA);

  405.     }

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

  407.     if(addres > 0x270F)

  408.     {

  409.         return ModbusErrReply(0x05, 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] = 0x05;

  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.     if(ModbusRxLen < 8)

  456.     {

  457.         return ModbusErrReply(0x06, ERR_DATA);

  458.     }

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

  460.     if(addres > 0x270F)

  461.     {

  462.         return ModbusErrReply(0x06, ERR_OPE_ADDRES);

  463.     }

  464. 

  465.     writeValH = data[0];

  466.     writeValL = data[1];

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

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

  469.     ModbusReg[addres] = writeVal;

  470.     

  471.     ModbusTxBuf[0] = SLAVE_ADDRES;

  472.     ModbusTxBuf[1] = 0x06;

  473.     /*操作地址*/

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

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

  476.     /*成功写入*/

  477.     ModbusTxBuf[4] = writeValH;

  478.     ModbusTxBuf[5] = writeValL;

  479.     AddCrc16(ModbusTxBuf, 6);

  480.     ModbusTxLen = 8;

  481.     

  482.     return 0;

  483. }

  484. 

  485. 

  486. 

  487. uint8_t ModbusErrReply(uint8_t func, uint8_t err)

  488. {

  489.     ModbusTxBuf[0] = SLAVE_ADDRES;

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

  491.     ModbusTxBuf[2] = err;

  492.     AddCrc16(ModbusTxBuf, 3);

  493.     ModbusTxLen = 5;

  494. 

  495.     return err;

  496. }