fubowen
/
TrainCamp_fubowen_Modbus
1
0
포크 0
코드 이슈 0 풀 리퀘스트 0 릴리즈 0 위키 활동
25개 이상의 토픽을 선택하실 수 없습니다. Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13 커밋
1 브렌치
656 KiB
 
 
 
 
트리: ab61557cea
브랜치 태그
${ item.name }
${ searchTerm } 브랜치 생성
from 'ab61557cea'
${ noResults }
TrainCamp_fubowen_Modbus/modbus/modbus.c

391 lines
9.2 KiB
Raw Blame 히스토리 

  1. #include "stm32f4xx.h"

  2. #include "hardware.h"

  3. #include "ucos_ii.h"

  4. #include "os.h"

  5. #include "app_cfg.h"

  6. #include "sys_cfg.h"

  7. #include "string.h"

  8. #include "modbus.h"

  9. 

  10. extern OS_EVENT* ModbusReceived;       /*接收到modbus请求报文*/

  11. 

  12. 

  13. 

  14. 

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

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

  17. uint16_t ModbusReg[10000];

  18. 

  19. 

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

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

  22. uint8_t ModbusReadCoil(uint16_t addres, uint16_t num);

  23. uint8_t ModbusWriteCoil(uint16_t addres, uint16_t num, uint8_t *data);

  24. uint8_t ModbusReadReg(uint16_t addres, uint16_t num);

  25. uint8_t ModbusWriteReg(uint16_t addres, uint16_t num, uint8_t *data);

  26. 

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

  28. void USART1_IRQHandler(void)

  29. {

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

  31. 

  32.     uint32_t temp;

  33.     uint16_t rxLenRemain;

  34.     

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

  36.     {

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

  38.         DMA_Cmd(DMA2_Stream2, DISABLE);

  39.         

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

  41.         temp = USART1->SR;

  42.         temp = USART1->DR;

  43.         (void)temp;

  44. 

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

  46.         DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2 | DMA_FLAG_HTIF2);

  47.         

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

  49.         rxLenRemain = DMA_GetCurrDataCounter(DMA2_Stream2);

  50.         ModbusRxLen = MODBUS_RX_BUF_SIZE - rxLenRemain;

  51. 

  52.         if(ModbusRxLen != 0)

  53.         {

  54.             OSSemPost(ModbusReceived);

  55.         }

  56.         

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

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

  59.         /*重启DMA*/

  60.         DMA_SetCurrDataCounter(DMA2_Stream2, MODBUS_RX_BUF_SIZE);

  61.         DMA_Cmd(DMA2_Stream2, ENABLE);

  62.     }

  63.     

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

  65. }

  66. 

  67. 

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

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

  70. {

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

  72.     DMA_Cmd(DMA2_Stream7, DISABLE);

  73. 

  74.     /*等待DMA关闭*/

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

  76. 

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

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

  79.     

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

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

  82.     DMA_SetCurrDataCounter(DMA2_Stream7, len);

  83.     

  84.     /*启动 DMA 发送*/

  85.     DMA_Cmd(DMA2_Stream7, ENABLE);

  86. }

  87. 

  88. 

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

  90. void AppTaskModbusParse (void *p_arg)

  91. {

  92.     INT8U err;

  93.     MODBUS_FRAME frame;

  94.     uint16_t rxLen;

  95.     uint8_t rxBuf[256];

  96. 

  97.     while(1)

  98.     {

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

  100.         

  101.         rxLen = ModbusRxLen;

  102. 

  103.         memcpy(rxBuf, ModbusRxBuf, rxLen);

  104. 

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

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

  107.         {   

  108.             /****************************crc错误处理******************************/

  109.         }

  110. 

  111. 

  112.         frame.slaveAddres = rxBuf[0];

  113.         if(frame.slaveAddres != SLAVE_ADDRES)

  114.         {

  115.             /*****************************从机地址错误处理************************/

  116.         }

  117. 

  118. 

  119.         frame.func = rxBuf[1];

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

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

  122.     

  123.     

  124. 

  125.         switch(frame.func)

  126.         {

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

  128.                 ModbusReadCoil(frame.opeAddres, frame.opeNum);

  129. 

  130.                 break;

  131. 

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

  133.                 ModbusReadReg(frame.opeAddres, frame.opeNum);

  134. 

  135.                 break;

  136. 

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

  138.                 frame.wNum = rxBuf[6];

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

  140. 

  141.                 ModbusWriteCoil(frame.opeAddres, frame.opeNum, frame.wData);

  142. 

  143.             

  144.                 break;

  145. 

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

  147.                 frame.wNum = rxBuf[6];

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

  149. 

  150.                 ModbusWriteReg(frame.opeAddres, frame.opeNum, frame.wData);

  151. 

  152.                 break;

  153. 

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

  155. 

  156. 

  157. 

  158.                 break;

  159. 

  160.         }

  161.         ModbusSend(ModbusTxBuf, ModbusTxLen);

  162.     }

  163. }

  164. 

  165. uint8_t ModbusReadCoil(uint16_t addres, uint16_t num)

  166. {

  167.     uint16_t byteIndI;

  168.     uint8_t bitIndI;

  169.     uint16_t byteIndO;

  170.     uint8_t bitIndO;

  171. 

  172.     uint8_t dataLen;

  173. 

  174.     uint8_t index;

  175.     uint8_t readVal;

  176.     uint8_t writeVal;

  177. 

  178. 

  179.     if(addres > 0x270F || (addres + num) > 0x270F)

  180.     {

  181.         /********************地址超限处理*****************/

  182.     }

  183. 

  184. 

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

  186. 

  187.     memset(&ModbusTxBuf[3], 0, 253);/*清零发送数组*/

  188. 

  189.     

  190. 

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

  192.     {

  193.         byteIndO = i / 8;

  194.         bitIndO = i % 8;

  195. 

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

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

  198. 

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

  200.         

  201.         if(readVal != 0)

  202.         {

  203.             index = 3 + byteIndO;

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

  205. 

  206.             ModbusTxBuf[index] |= writeVal;

  207.         }

  208.     }

  209. 

  210.     ModbusTxBuf[0] = SLAVE_ADDRES;

  211.     ModbusTxBuf[1] = 0x01;

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

  213.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  214.     ModbusTxLen = 5 + dataLen;

  215. }

  216. 

  217. uint8_t ModbusWriteCoil(uint16_t addres, uint16_t num, uint8_t *data)

  218. {

  219.     uint16_t byteIndI;

  220.     uint8_t bitIndI;

  221.     uint16_t byteIndO;

  222.     uint8_t bitIndO;

  223. 

  224.     uint8_t readVal;

  225.     uint8_t writeVal;

  226. 

  227. 

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

  229.     {

  230.         /********************地址超限处理*****************/

  231.     }

  232.    

  233. 

  234. 

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

  236.     {

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

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

  239.     

  240.         byteIndO = i / 8;

  241.         bitIndO = i % 8;

  242. 

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

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

  245. 

  246. 

  247.         if(readVal != 0)

  248.         {

  249.             ModbusCoil[byteIndI] |= writeVal;

  250.         }

  251.         else

  252.         {

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

  254.         }

  255. 

  256.         ModbusTxBuf[0] = SLAVE_ADDRES;

  257.         ModbusTxBuf[1] = 0x0F;

  258.         /*操作地址*/

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

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

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

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

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

  264.         AddCrc16(ModbusTxBuf, 6);

  265.         ModbusTxLen = 8;

  266.     }

  267. }

  268. 

  269. uint8_t ModbusReadReg(uint16_t addres, uint16_t num)

  270. {

  271.     uint8_t index;

  272.     uint8_t readValH;

  273.     uint8_t readValL;

  274.     uint8_t dataLen;

  275. 

  276.     

  277.     

  278.     if(addres > 0x270F || (addres + num) > 0x270F)

  279.     {

  280.         /********************地址错误处理*****************/

  281.     }

  282. 

  283. 

  284.     dataLen = num * 2;

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

  286.     {

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

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

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

  290. 

  291.         ModbusTxBuf[index] = readValH;

  292.         ModbusTxBuf[index + 1] = readValL;

  293.     }

  294.     ModbusTxBuf[0] = SLAVE_ADDRES;

  295.     ModbusTxBuf[1] = 0x03;

  296.     ModbusTxBuf[2] = dataLen;

  297.     AddCrc16(ModbusTxBuf, 3 + dataLen);

  298.     ModbusTxLen = 5 + dataLen;

  299. }

  300. 

  301. uint8_t ModbusWriteReg(uint16_t addres, uint16_t num, uint8_t *data)

  302. {

  303.     uint8_t index;

  304. 

  305.     uint8_t writeValH;

  306.     uint8_t writeValL;

  307.     uint16_t writeVal;

  308.     

  309.     

  310.     if(addres > 0x270F || (addres + num) > 0x270F)

  311.     {

  312.         /********************地址错误处理*****************/

  313.     }

  314. 

  315. 

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

  317.     {

  318.         index = i * 2;

  319. 

  320.         writeValH = data[index];

  321.         writeValL = data[index + 1];

  322.         

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

  324.         ModbusReg[addres + i] = writeVal;

  325.     }

  326. 

  327.     ModbusTxBuf[0] = SLAVE_ADDRES;

  328.     ModbusTxBuf[1] = 0x10;

  329.     /*操作地址*/

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

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

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

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

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

  335.     AddCrc16(ModbusTxBuf, 6);

  336.     ModbusTxLen = 8;

  337.     

  338. }

  339. 

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

  341. 

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

  343. {

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

  345. 

  346.     /*低前高后*/

  347.     data[length] = (uint8_t)(crc16 & 0x00FF);

  348.     data[length + 1] = (uint8_t)(crc16 >> 8);

  349. }

  350. 

  351. /*crc16校验*/

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

  353. {

  354.     uint16_t crc;

  355.     uint16_t byteInd;

  356.     uint8_t bitInd;

  357.     

  358.     crc = 0xFFFFu;

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

  360.     {

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

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

  363.         {

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

  365.             {

  366.                 crc >>= 1;

  367.                 crc ^= 0xA001u;

  368.             }

  369.             else

  370.             {

  371.                 crc >>= 1;

  372.             }

  373.         }

  374.     }

  375.     return crc;

  376. }

  377. 

  378. /*crc16检查*/

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

  380. {

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

  382. 

  383.     if(recCrc16 == crc16)

  384.     {

  385.         return 0;

  386.     }

  387.     else

  388.     {

  389.         return -1;

  390.     }

  391. }