標(biāo)題: 觸摸屏和單片機(jī)進(jìn)行modbus通訊 RTU slave 文件源碼，希望可以幫助到大家 [打印本頁(yè)]
作者: doer    時(shí)間: 2016-5-20 19:09
標(biāo)題: 觸摸屏和單片機(jī)進(jìn)行modbus通訊 RTU slave 文件源碼，希望可以幫助到大家
觸摸屏和單片機(jī)進(jìn)行modbus通訊，觸摸屏需要設(shè)置為主機(jī)，單片機(jī)為從機(jī)，modbusRTU slave 源碼需要植入單片機(jī)，希望可以幫助到大家。


全部資料下載：
ModbusSlave.zip (13.59 KB, 下載次數(shù): 249)

  1. /****************************************Copyright (c)**************************************************
  2. **                                  廣州致遠(yuǎn)電子有限公司
  3. **
  4. **--------------File Info-------------------------------------------------------------------------------
  5. ** File name:                        MB_PFunction.c
  6. ** Last modified Date:  2005-01-11
  7. ** Last Version:                1.0
  8. ** Descriptions:               
  9. **
  10. **------------------------------------------------------------------------------------------------------
  11. ** Created by:                        ZhouLishan
  12. ** Created date:                2005-01-11
  13. ** Version:                                1.0
  14. ** Descriptions:               
  15. **
  16. **------------------------------------------------------------------------------------------------------
  17. ** Modified by:
  18. ** Modified date:
  19. ** Version:
  20. ** Descriptions:
  21. **
  22. ********************************************************************************************************/
  23. #include        "config.h"

  25. #include        "modbus.h"



  29. //**************************************************
  30. // 函數(shù)名稱(chēng)：MB_GetDiscrete
  31. // 輸入?yún)?shù)：Address，線圈地址
  32. // 輸出參數(shù)：返回線圈值（0\1）
  33. // 功能描述：獲取離散值函數(shù)，訪函數(shù)由用戶編寫(xiě)
  34. //**************************************************
  35. uint8_t MB_GetDiscrete(uint16_t Address)
  36. {
  37.         if(Address/2)
  38.                 return 1;
  39.         else
  40.                 return 0;
  41. }

  43. //**************************************************
  44. // 函數(shù)名稱(chēng)：MB_GetCoils
  45. // 輸入?yún)?shù)：Address，線圈地址
  46. // 輸出參數(shù)：返回線圈值（0\1）
  47. // 功能描述：獲取線圈值函數(shù)，訪函數(shù)由用戶編寫(xiě)
  48. //**************************************************
  49. uint8_t MB_GetCoils(uint16_t Address)
  50. {
  51.         if(Address/2)
  52.                 return 1;
  53.         else
  54.                 return 0;
  55. }

  57. //**************************************************
  58. // 函數(shù)名稱(chēng)：MB_SetCoil
  59. // 輸入?yún)?shù)：Address，線圈地址
  60. //                         CoilValue,線圈值（0\1）
  61. // 輸出參數(shù)：返回寄存器值
  62. // 功能描述：設(shè)置線圈值函數(shù)，訪函數(shù)由用戶編寫(xiě)
  63. //**************************************************
  64. uint8_t MB_SetCoil(uint16_t Address,uint8_t CoilValue)
  65. {

  67.         return CoilValue;
  68. }


  71. //**************************************************
  72. // 函數(shù)名稱(chēng)：MB_GetInputRegValue
  73. // 輸入?yún)?shù)：Address，寄存器地址
  74. // 輸出參數(shù)：返回寄存器值
  75. // 功能描述：讀輸入寄存器值函數(shù)，訪函數(shù)由用戶編寫(xiě)
  76. //**************************************************
  77. uint16_t MB_GetInputRegValue(uint16_t Address)
  78. {

  80.         return Address;
  81. }

  83. //**************************************************
  84. // 函數(shù)名稱(chēng)：MB_GetRegValue
  85. // 輸入?yún)?shù)：Address，寄存器地址
  86. // 輸出參數(shù)：返回寄存器值
  87. // 功能描述：讀保持寄存器值函數(shù)，訪函數(shù)由用戶編寫(xiě)
  88. //**************************************************
  89. uint16_t MB_GetRegValue(uint16_t Address)
  90. {

  92.         return Address;
  93. }

  95. //**************************************************
  96. // 函數(shù)名稱(chēng)：MB_SetRegValue
  97. // 輸入?yún)?shù)：Address，寄存器地址
  98. //                         Value，寫(xiě)入的值
  99. // 輸出參數(shù)：無(wú)
  100. // 功能描述：寫(xiě)保持寄存器值函數(shù)，訪函數(shù)由用戶編寫(xiě)
  101. //**************************************************
  102. void MB_SetRegValue(uint16_t Address,uint16_t Value)
  103. {

  105. }

  107. /****************************************************************************************/
  108. // 函數(shù)名稱(chēng)：FReadCoils
  109. // 輸入?yún)?shù)：Response
  110. // 輸出參數(shù)：無(wú)
  111. // 功能描述：處理讀單線圈指令01
  112. /***************************************************************************************/
  113. void FReadCoils(PDU_RESPONSE *Response);
  114. /****************************************************************************************/
  115. // 函數(shù)名稱(chēng)：FReadDiscreteInputs
  116. // 輸入?yún)?shù)：Response
  117. // 輸出參數(shù)：無(wú)
  118. // 功能描述：處理讀離散輸入指令02
  119. /***************************************************************************************/
  120. void FReadDiscreteInputs(PDU_RESPONSE *Response);
  121. /****************************************************************************************/
  122. // 函數(shù)名稱(chēng)：FReadHoldingReg
  123. // 輸入?yún)?shù)：Response
  124. // 輸出參數(shù)：無(wú)
  125. // 功能描述：處理讀保持寄存器指令03
  126. /****************************************************************************************/
  127. void FReadHoldingReg(PDU_RESPONSE *Response);
  128. /****************************************************************************************/
  129. // 函數(shù)名稱(chēng)：FReadInputReg
  130. // 輸入?yún)?shù)：Response
  131. // 輸出參數(shù)：無(wú)
  132. // 功能描述：處理讀輸入寄存器指令04
  133. /****************************************************************************************/
  134. void FReadInputReg(PDU_RESPONSE *Response);
  135. /****************************************************************************************/
  136. // 函數(shù)名稱(chēng)：FWriteSingleCoil
  137. // 輸入?yún)?shù)：Response
  138. // 輸出參數(shù)：無(wú)
  139. // 功能描述：處理寫(xiě)單線圈指令05
  140. /****************************************************************************************/
  141. void FWriteSingleCoil(PDU_RESPONSE *Response);
  142. /****************************************************************************************/
  143. // 函數(shù)名稱(chēng)：FWriteSingleReg
  144. // 輸入?yún)?shù)：Response
  145. // 輸出參數(shù)：無(wú)
  146. // 功能描述：處理寫(xiě)單線圈指令06
  147. /****************************************************************************************/
  148. void FWriteSingleReg(PDU_RESPONSE *Response);
  149. /****************************************************************************************/
  150. // 函數(shù)名稱(chēng)：FWriteMultipleCoils
  151. // 輸入?yún)?shù)：Response
  152. // 輸出參數(shù)：無(wú)
  153. // 功能描述：處理寫(xiě)多線圈指令15
  154. /****************************************************************************************/
  155. void FWriteMultipleCoils(PDU_RESPONSE *Response);
  156. /****************************************************************************************/
  157. // 函數(shù)名稱(chēng)：FWriteMultipleReg
  158. // 輸入?yún)?shù)：Response
  159. // 輸出參數(shù)：無(wú)
  160. // 功能描述：處理寫(xiě)多寄存器指令16
  161. /****************************************************************************************/
  162. void FWriteMultipleReg(PDU_RESPONSE *Response);
  163. /****************************************************************************************/
  164. // 函數(shù)名稱(chēng)：FMaskWriteReg
  165. // 輸入?yún)?shù)：Response
  166. // 輸出參數(shù)：無(wú)
  167. // 功能描述：處理屏蔽寄存器指令22
  168. /****************************************************************************************/
  169. void FMaskWriteReg(PDU_RESPONSE *Response);
  170. /****************************************************************************************/
  171. // 函數(shù)名稱(chēng)：FRWMultipleReg
  172. // 輸入?yún)?shù)：Response
  173. // 輸出參數(shù)：無(wú)
  174. // 功能描述：處理讀寫(xiě)多寄存器指令23
  175. /****************************************************************************************/
  176. void FRWMultipleReg(PDU_RESPONSE *Response);

  178. void FTest(PDU_RESPONSE *Response){}

  180. AT_CODE FUNCTION_ARRAY        FCodeHandleArray[MAX_FUNCTION]={
  181. #if READ_COILS_EN > 0
  182.         {0x01,FReadCoils},                        // 讀線圈
  183. #endif
  184. #if READ_DIS_INPUT_EN > 0
  185.         {0x02,FReadDiscreteInputs},        // 讀離散量輸入
  186. #endif
  187. #if READ_HOLD_REG_EN > 0
  188.         {0x03,FReadHoldingReg},                // 讀保持寄存器
  189. #endif
  190. #if READ_INPUT_REG_EN > 0
  191.         {0x04,FReadInputReg},                // 讀輸入寄存器
  192. #endif
  193. #if WRITE_SING_COIL_EN > 0
  194.         {0x05,FWriteSingleCoil},        // 寫(xiě)單個(gè)線圈
  195. #endif
  196. #if WRITE_SING_REG_EN > 0
  197.         {0x06,FWriteSingleReg},                // 寫(xiě)單個(gè)寄存器
  198. #endif
  199. #if WRITE_MULT_COIL_EN > 0
  200.         {0x0f,FWriteMultipleCoils},        // 寫(xiě)多個(gè)線圈
  201. #endif
  202. #if WRITE_MULT_REG_EN > 0
  203.         {0x10,FWriteMultipleReg},        // 寫(xiě)多個(gè)寄存器
  204. #endif
  205. #if MASK_WRITE_REG_EN > 0
  206.         {0x16,FMaskWriteReg},                // 處理屏蔽寄存器指令
  207. #endif
  208. #if READ_WRITE_REG_EN > 0
  209.         {0x17,FRWMultipleReg},                // 讀寫(xiě)多個(gè)寄存器
  210. #endif
  211.         {0x00,FTest}                                // 測(cè)試功能代碼
  212. };

  214. #if READ_DIS_INPUT_EN
  215. //************************************************************************************
  216. // 函數(shù)名稱(chēng)：ReadDiscreteInputs
  217. // 輸入?yún)?shù)：CoilsDataPtr，存放離散輸入數(shù)據(jù)指針
  218. //                         StAddr,離散的起始地址
  219. //                         Quantity,離散的數(shù)量
  220. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  221. // 功能描述：讀離散輸入操作函數(shù)
  222. //************************************************************************************        
  223. uint8_t ReadDiscreteInputs(uint8_t *CoilsDataPtr,uint16_t StAddr ,uint16_t Quantity)
  224. {
  225.         uint8_t *CoilsInByte;
  226.         uint8_t offset;
  227.         uint16_t i=0 ;
  228.         CoilsInByte = CoilsDataPtr;
  229.         while(i<Quantity)
  230.         {        
  231.                 *CoilsInByte = 0;
  232.                 for(offset=0;offset<8;offset++,i++)                // 將線圈值寫(xiě)入一個(gè)字節(jié)
  233.                 {
  234.                         if(i<Quantity)
  235.                         {
  236.                                 *CoilsInByte |= MB_GetDiscrete(StAddr+i)<<offset;
  237.                         }
  238.                 }
  239.                 CoilsInByte++;
  240.         }
  241.         return TRUE;
  242. }
  243. #endif


  246. #if READ_COILS_EN
  247. //************************************************************************************
  248. // 函數(shù)名稱(chēng)：ReadCoils
  249. // 輸入?yún)?shù)：CoilsDataPtr，存放線圈數(shù)據(jù)指針
  250. //                         StAddr,線圈的起始地址
  251. //                         Quantity,線圈的數(shù)量
  252. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  253. // 功能描述：讀多線圈操作函數(shù)
  254. //************************************************************************************        
  255. uint8_t ReadCoils(uint8_t *CoilsDataPtr,uint16_t StAddr ,uint16_t Quantity)
  256. {
  257.         uint8_t *CoilsInByte;
  258.         uint8_t offset;
  259.         uint16_t i=0 ;
  260.         CoilsInByte = CoilsDataPtr;
  261.         while(i<Quantity)
  262.         {        
  263.                 *CoilsInByte = 0;
  264.                 for(offset=0;offset<8;offset++,i++)                // 將線圈值寫(xiě)入一個(gè)字節(jié)
  265.                 {
  266.                         if(i<Quantity)
  267.                         {
  268.                                 *CoilsInByte |= MB_GetCoils(StAddr+i)<<offset;
  269.                         }
  270.                 }
  271.                 CoilsInByte++;
  272.         }
  273.         return TRUE;
  274. }
  275. #endif

  277. #if WRITE_SING_COIL_EN
  278. //************************************************************************************
  279. // 函數(shù)名稱(chēng)：WriteSingleCoil
  280. // 輸入?yún)?shù)：DataPtr,數(shù)據(jù)指針，
  281. //                         StAddr，寄存器起始地址
  282. //                         Quantity，寄存器數(shù)量。
  283. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  284. // 功能描述：寫(xiě)單線圈處理函數(shù)
  285. //************************************************************************************        
  286. uint8_t WriteSingleCoil(uint16_t OutputAddr,uint16_t OutputValue)
  287. {
  288.         return MB_SetCoil(OutputAddr,(OutputValue==0xff00)?1:0);
  289. }
  290. #endif

  292. #if WRITE_MULT_COIL_EN
  293. //************************************************************************************
  294. // 函數(shù)名稱(chēng)：WriteMultipleCoils
  295. // 輸入?yún)?shù)：DataPtr,數(shù)據(jù)指針，
  296. //                         StAddr，寄存器起始地址
  297. //                         Quantity，寄存器數(shù)量。
  298. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  299. // 功能描述：寫(xiě)多線圈處理函數(shù)
  300. //************************************************************************************        
  301. uint8 WriteMultipleCoils(uint8 *DataPtr,uint16 StAddr ,uint16 Quantity)
  302. {
  303.         uint16 i;
  304.         uint8         CoilInByte;
  305.         for(i=0;i<Quantity;i++)
  306.         {
  307.                 if((i%8)==0)        
  308.                         CoilInByte = *(DataPtr+(i/8));
  309.                 if( FALSE == MB_SetCoil(StAddr+i,(CoilInByte>>(i%8))&0x01))
  310.                         return FALSE;        
  311.         }
  312.         return TRUE;
  313. }
  314. #endif

  316. #if READ_INPUT_REG_EN
  317. //************************************************************************************
  318. // 函數(shù)名稱(chēng)：ReadInputReg
  319. // 輸入?yún)?shù)：DataPtr,數(shù)據(jù)指針，
  320. //                         StAddr，寄存器起始地址
  321. //                         Quantity，寄存器數(shù)量。
  322. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  323. // 功能描述：讀輸入寄存器
  324. //************************************************************************************        
  325. uint8_t ReadInputReg(uint8_t *DataPtr,uint16_t StAddr ,uint16_t Quantity)
  326. {
  327.         uint8_t i;
  328.         uint16_t        Value;
  329.         for(i=0;i<Quantity;i++)
  330.         {
  331.                 Value = MB_GetInputRegValue(StAddr+i);
  332.                 *(DataPtr+i*2)   = (uint8)(Value>>8);                 // 先傳高位
  333.                 *(DataPtr+i*2+1) = (uint8)Value;                          // 后傳低位
  334.         }
  335.         return TRUE;
  336. }
  337. #endif


  340. #if READ_HOLD_REG_EN+READ_WRITE_REG_EN+MASK_WRITE_REG_EN
  341. //************************************************************************************
  342. // 函數(shù)名稱(chēng)：ReadHoldingReg
  343. // 輸入?yún)?shù)：DataPtr,數(shù)據(jù)指針，16位數(shù)據(jù)高8位在低字節(jié)，低8位在高字節(jié)
  344. //                         StAddr，寄存器起始地址
  345. //                         Quantity，寄存器數(shù)量。
  346. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  347. // 功能描述：讀寄存器處理函數(shù)
  348. //************************************************************************************        
  349. uint8_t ReadHoldingReg(uint8_t *DataPtr,uint16_t StAddr ,uint16_t Quantity)
  350. {
  351.         uint8_t i;
  352.         uint16_t        Value;
  353.         for(i=0;i<Quantity;i++)
  354.         {
  355.                 Value = MB_GetRegValue(StAddr+i);
  356.                 *(DataPtr+i*2)   = (uint8)(Value>>8);         // 先傳高位
  357.                 *(DataPtr+i*2+1) = (uint8)Value;                  // 后傳低位
  358.         }
  359.         return TRUE;
  360. }
  361. #endif

  363. #if WRITE_MULT_REG_EN+READ_WRITE_REG_EN+MASK_WRITE_REG_EN+WRITE_SING_REG_EN
  364. //************************************************************************************
  365. // 函數(shù)名稱(chēng)：WriteHoldingReg
  366. // 輸入?yún)?shù)：DataPtr,數(shù)據(jù)指針，16位數(shù)據(jù)高8位在低字節(jié)，低8位在高字節(jié)
  367. //                         StAddr，寄存器起始地址
  368. //                         Quantity，寄存器數(shù)量。
  369. // 輸出參數(shù)：正常返回TRUE,出錯(cuò)返回FALSE。
  370. // 功能描述：寫(xiě)寄存器處理函數(shù)
  371. //************************************************************************************        
  372. uint8_t WriteHoldingReg(uint8_t *KeepDataPtr,uint16_t StAddr ,uint16_t Quantity)
  373. {
  374.         uint8_t i;
  375.         uint16_t        Value;
  376.         for(i=0;i<Quantity;i++)
  377.         {
  378.                 Value = (*(KeepDataPtr+i*2)<<8)|(*(KeepDataPtr+i*2+1));
  379.                 MB_SetRegValue(StAddr+i,Value);
  380.         }
  381.         return TRUE;
  382. }
  383. #endif










  394. #if READ_COILS_EN > 0
  395. /****************************************************************************************/
  396. // 函數(shù)名稱(chēng)：FReadCoils
  397. // 輸入?yún)?shù)：Response，為PDU_RESPONSE類(lèi)型的指針，PDU_RESPONSE：
  398. //                         typedef struct __PDU_RESPONSE{
  399. //                                uint8*        PDUDataPtr;   請(qǐng)求數(shù)據(jù)指針,功能代碼處理函數(shù)必需將處理的數(shù)據(jù)包存在該指針的開(kāi)始位始
  400. //                                  uint8        PDUByteLength;請(qǐng)求數(shù)據(jù)數(shù)長(zhǎng)度
  401. //                                uint8        ExceptionCode;僅為輸出錯(cuò)異常代碼，正常操作設(shè)為0
  402. //                         }PDU_RESPONSE
  403. // 輸出參數(shù)：無(wú)
  404. // 功能描述：處理讀多線圈指令01
  405. /***************************************************************************************/
  406. void FReadCoils(PDU_RESPONSE *Response)
  407. {
  408.         uint8_t * PDUPtr;
  409.         uint16_t StAddr ,Quantity;
  410.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  411.         PDUPtr = Response->PDUDataPtr;
  412.         StAddr = PDUPtr[1]<<8|PDUPtr[2];
  413.         Quantity =  PDUPtr[3]<<8|PDUPtr[4];
  414.         
  415.         Response->PDUByteLength = 2 + Quantity/8+((Quantity%8)?1:0) ;        // 正常返回的數(shù)據(jù)長(zhǎng)度
  416.         
  417.         if((Quantity>=0x001)&&(Quantity<=0x07d0))
  418.         {
  419.                 if((StAddr<END_COILS_ADDR)&&((StAddr+Quantity)<=END_COILS_ADDR))
  420.                 {                        
  421.                         if(ReadCoils(PDUPtr+2,StAddr,Quantity))
  422.                         {
  423.                                 *(PDUPtr+1) = Quantity/8+(Quantity%8)?1:0;        // 字節(jié)數(shù)
  424.                                 Response->ExceptionCode = 0x00;
  425.                         }
  426.                         else
  427.                                 Response->ExceptionCode = 0x04;
  428.                 }
  429.                 else
  430.                         Response->ExceptionCode = 0x02;
  431.         }
  432.         else
  433.                 Response->ExceptionCode = 0x03;
  434. }
  435. #endif

  437. #if READ_DIS_INPUT_EN >0
  438. /****************************************************************************************/
  439. // 函數(shù)名稱(chēng)：FReadDiscreteInputs
  440. // 輸入?yún)?shù)：Response
  441. // 輸出參數(shù)：無(wú)
  442. // 功能描述：處理讀離散輸入指令02
  443. /***************************************************************************************/
  444. void FReadDiscreteInputs(PDU_RESPONSE *Response)
  445. {
  446.         uint8_t * PDUPtr;
  447.         uint16_t StAddr ,Quantity;
  448.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  449.         PDUPtr = Response->PDUDataPtr;
  450.         StAddr = PDUPtr[1]<<8|PDUPtr[2];
  451.         Quantity =  PDUPtr[3]<<8|PDUPtr[4];
  452.         
  453.         Response->PDUByteLength = 2 + Quantity/8+((Quantity%8)?1:0) ;        // 正常返回的數(shù)據(jù)長(zhǎng)度
  454.         
  455.         if((Quantity>=0x001)&&(Quantity<=0x07d0))
  456.         {
  457.                 if((StAddr<END_DISC_INPUT_ADDR)&&((StAddr+Quantity)<=END_DISC_INPUT_ADDR))
  458.                 {                        
  459.                         if(ReadDiscreteInputs(PDUPtr+2,StAddr,Quantity))
  460.                         {
  461.                                 *(PDUPtr+1) = Quantity/8+(Quantity%8)?1:0;        // 字節(jié)數(shù)
  462.                                 Response->ExceptionCode = 0x00;
  463.                         }
  464.                         else
  465.                                 Response->ExceptionCode = 0x04;
  466.                 }
  467.                 else
  468.                         Response->ExceptionCode = 0x02;
  469.         }
  470.         else
  471.                 Response->ExceptionCode = 0x03;
  472. }
  473. #endif

  475. #if READ_HOLD_REG_EN >0
  476. /****************************************************************************************/
  477. // 函數(shù)名稱(chēng)：FReadHoldingReg
  478. // 輸入?yún)?shù)：Response
  479. // 輸出參數(shù)：無(wú)
  480. // 功能描述：處理讀保持寄存器指令03
  481. /****************************************************************************************/
  482. void FReadHoldingReg(PDU_RESPONSE *Response)
  483. {
  484.         uint8_t * PDUPtr;
  485.         uint16_t StAddr ,Quantity;
  486.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  487.         PDUPtr = Response->PDUDataPtr;
  488.         StAddr = PDUPtr[1]<<8|PDUPtr[2];
  489.         Quantity =  PDUPtr[3]<<8|PDUPtr[4];
  490.         
  491.         Response->PDUByteLength = 2 + Quantity*2 ;        // 正常返回的數(shù)據(jù)長(zhǎng)度
  492.         
  493.         if((Quantity>=0x001)&&(Quantity<=0x007d))
  494.         {
  495.                 if((StAddr<END_HOLDING_REG_ADDR)&&((StAddr+Quantity)<=END_HOLDING_REG_ADDR))
  496.                 {                        
  497.                         if(ReadHoldingReg(PDUPtr+2,StAddr,Quantity))
  498.                         {
  499.                                 *(PDUPtr+1) = Quantity*2;
  500.                                 Response->ExceptionCode = 0x00;
  501.                         }
  502.                         else
  503.                                 Response->ExceptionCode = 0x04;
  504.                 }
  505.                 else
  506.                         Response->ExceptionCode = 0x02;
  507.         }
  508.         else
  509.                 Response->ExceptionCode = 0x03;
  510. }
  511. #endif

  513. #if READ_INPUT_REG_EN >0
  514. /****************************************************************************************/
  515. // 函數(shù)名稱(chēng)：FReadInputReg
  516. // 輸入?yún)?shù)：Response
  517. // 輸出參數(shù)：無(wú)
  518. // 功能描述：處理讀輸入寄存器指令04
  519. /****************************************************************************************/
  520. void FReadInputReg(PDU_RESPONSE *Response)
  521. {
  522.         uint8_t * PDUPtr;
  523.         uint16_t StAddr ,Quantity;
  524.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  525.         PDUPtr = Response->PDUDataPtr;
  526.         StAddr = PDUPtr[1]<<8|PDUPtr[2];
  527.         Quantity =  PDUPtr[3]<<8|PDUPtr[4];
  528.         
  529.         Response->PDUByteLength = 2 + Quantity*2 ;        // 正常返回的數(shù)據(jù)長(zhǎng)度
  530.         
  531.         if((Quantity>=0x001)&&(Quantity<=0x007d))
  532.         {
  533.                 if((StAddr<END_INPUT_REG_ADDR) && ((StAddr+Quantity)<=END_INPUT_REG_ADDR))
  534.                 {                        
  535.                         if(ReadInputReg(PDUPtr+2,StAddr,Quantity))
  536.                         {
  537.                                 *(PDUPtr+1) = Quantity*2;
  538.                                 Response->ExceptionCode = 0x00;
  539.                         }
  540.                         else
  541.                                 Response->ExceptionCode = 0x04;
  542.                 }
  543.                 else
  544.                         Response->ExceptionCode = 0x02;
  545.         }
  546.         else
  547.                 Response->ExceptionCode = 0x03;
  548. }
  549. #endif


  552. #if WRITE_SING_COIL_EN >0
  553. /****************************************************************************************/
  554. // 函數(shù)名稱(chēng)：FWriteSingleCoil
  555. // 輸入?yún)?shù)：Response
  556. // 輸出參數(shù)：無(wú)
  557. // 功能描述：處理寫(xiě)單線圈指令05
  558. /****************************************************************************************/
  559. void FWriteSingleCoil(PDU_RESPONSE *Response)
  560. {
  561.         uint8_t * PDUPtr;
  562.         uint16_t OutputAddr ,OutputValue;
  563.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  564.         PDUPtr = Response->PDUDataPtr;
  565.         OutputAddr = PDUPtr[1]<<8|PDUPtr[2];
  566.         OutputValue =  PDUPtr[3]<<8|PDUPtr[4];
  567.         
  568.         Response->PDUByteLength = 5 ;        // 正常返回的數(shù)據(jù)長(zhǎng)度
  569.         
  570.         if((OutputValue==0x0000)||(OutputValue==0xff00))
  571.         {
  572.                 if( OutputAddr < END_COILS_ADDR )
  573.                 {                        
  574.                         if(WriteSingleCoil(OutputAddr,OutputValue))
  575.                         {
  576.                                 *(PDUPtr+1) = OutputAddr>>8;
  577.                                 *(PDUPtr+2) = OutputAddr;
  578.                                 *(PDUPtr+3)        = OutputValue>>8;
  579.                                 *(PDUPtr+4)        = OutputValue;
  580.                                 Response->ExceptionCode = 0x00;
  581.                         }
  582.                         else
  583.                                 Response->ExceptionCode = 0x04;
  584.                 }
  585.                 else
  586.                         Response->ExceptionCode = 0x02;
  587.         }
  588.         else
  589.                 Response->ExceptionCode = 0x03;
  590. }
  591. #endif

  593. #if WRITE_SING_REG_EN >0
  594. /****************************************************************************************/
  595. // 函數(shù)名稱(chēng)：FWriteSingleReg
  596. // 輸入?yún)?shù)：Response
  597. // 輸出參數(shù)：無(wú)
  598. // 功能描述：處理寫(xiě)單線圈指令06
  599. /****************************************************************************************/
  600. void FWriteSingleReg(PDU_RESPONSE *Response)
  601. {
  602.         uint8 * PDUPtr;
  603.         uint16 OutputAddr ,OutputValue;
  604.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  605.         PDUPtr = Response->PDUDataPtr;
  606.         OutputAddr = PDUPtr[1]<<8|PDUPtr[2];
  607.         OutputValue =  PDUPtr[3]<<8|PDUPtr[4];
  608.         
  609.         Response->PDUByteLength = 2 + 5 ;        // 正常返回的數(shù)據(jù)長(zhǎng)度
  610.         
  611.         if(OutputValue<=0xffff)
  612.         {
  613.                 if(OutputAddr<END_HOLDING_REG_ADDR)
  614.                 {                        
  615.                         if(WriteHoldingReg(&PDUPtr[3],OutputAddr,1))
  616.                         {
  617.                                 *(PDUPtr+1) = OutputAddr>>8;
  618.                                 *(PDUPtr+2) = OutputAddr;
  619.                                 *(PDUPtr+3)        = OutputValue>>8;
  620.                                 *(PDUPtr+4)        = OutputValue;
  621.                                 Response->ExceptionCode = 0x00;
  622.                         }
  623.                         else
  624.                                 Response->ExceptionCode = 0x04;
  625.                 }
  626.                 else
  627.                         Response->ExceptionCode = 0x02;
  628.         }
  629.         else
  630.                 Response->ExceptionCode = 0x03;
  631. }
  632. #endif

  634. #if WRITE_MULT_COIL_EN >0
  635. /****************************************************************************************/
  636. // 函數(shù)名稱(chēng)：FWriteMultipleCoils
  637. // 輸入?yún)?shù)：Response
  638. // 輸出參數(shù)：無(wú)
  639. // 功能描述：處理寫(xiě)多線圈指令15
  640. /****************************************************************************************/
  641. void FWriteMultipleCoils(PDU_RESPONSE *Response)
  642. {
  643.         uint8_t * PDUPtr;
  644.         uint16_t StAddr ,Quantity;
  645.         uint8_t         ByteCount;
  646.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  647.         PDUPtr = Response->PDUDataPtr;
  648.         StAddr = PDUPtr[1]<<8|PDUPtr[2];
  649.         Quantity =  PDUPtr[3]<<8|PDUPtr[4];
  650.         ByteCount = PDUPtr[5];
  651.         
  652.         Response->PDUByteLength = 5 ;        // 正常返回的數(shù)據(jù)長(zhǎng)度

  654.         if((Quantity>=0x001)&&(Quantity<=0x07d0)&&(ByteCount==(Quantity/8+((Quantity%8)?1:0))))
  655.         {
  656.                 if((StAddr<END_COILS_ADDR)&&((StAddr+Quantity)<=(END_COILS_ADDR+1)))
  657.                 {                        
  658.                         if(WriteMultipleCoils(PDUPtr+6,StAddr,Quantity))
  659.                         {
  660.                                 *(PDUPtr+1) = StAddr>>8;
  661.                                 *(PDUPtr+2) = StAddr;
  662.                                 *(PDUPtr+3) = Quantity>>8;
  663.                                 *(PDUPtr+4) = Quantity;
  664.                                 Response->ExceptionCode = 0x00;
  665.                         }
  666.                         else
  667.                                 Response->ExceptionCode = 0x04;
  668.                 }
  669.                 else
  670.                         Response->ExceptionCode = 0x02;
  671.         }
  672.         else
  673.                 Response->ExceptionCode = 0x03;
  674. }
  675. #endif

  677. #if WRITE_MULT_REG_EN >0
  678. /****************************************************************************************/
  679. // 函數(shù)名稱(chēng)：FWriteMultipleReg
  680. // 輸入?yún)?shù)：Response
  681. // 輸出參數(shù)：無(wú)
  682. // 功能描述：處理寫(xiě)多寄存器指令16
  683. /****************************************************************************************/
  684. void FWriteMultipleReg(PDU_RESPONSE *Response)
  685. {
  686.         uint8_t * PDUPtr;
  687.         uint16_t StAddr ,Quantity;
  688.         uint8_t         ByteCount;
  689.         // 從請(qǐng)求PDU中提取相關(guān)參數(shù)
  690.         PDUPtr = Response->PDUDataPtr;
  691.         StAddr = PDUPtr[1]<<8|PDUPtr[2];
  692.         Quantity =  PDUPtr[3]<<8|PDUPtr[4];
  693.         ByteCount = PDUPtr[5];
  694.         
  695.         Response->PDUByteLength = 5 ;        // 正常返回的數(shù)據(jù)長(zhǎng)度

  697.         if((Quantity>=0x001)&&(Quantity<=0x007d)&&(ByteCount==(Quantity*2)))
  698.         {
  699.                 if((StAddr<END_HOLDING_REG_ADDR) && ((StAddr+Quantity)<=(END_HOLDING_REG_ADDR+1)))
  700.                 {                        
  701.                         if(WriteHoldingReg(PDUPtr+6,StAddr,Quantity))
  702.                         {
  703.                                 *(PDUPtr+1) = StAddr>>8;
  704.                                 *(PDUPtr+2) = StAddr;
  705.                                 *(PDUPtr+3) = Quantity>>8;
  706.                                 *(PDUPtr+4) = Quantity;
  707.                                 Response->ExceptionCode = 0x00;
  708.                         }
  709.                         else
  710.                                 Response->ExceptionCode = 0x04;
  711.                 }
  712.                 else
  713.                         Response->ExceptionCode = 0x02;
  714.         }
  715.         else
  716.                 Response->ExceptionCode = 0x03;
  717. }
  718. #endif

  720. #if MASK_WRITE_REG_EN >0
  721. /****************************************************************************************/
  722. // 函數(shù)名稱(chēng)：FMaskWriteReg
  723. // 輸入?yún)?shù)：Response
  724. // 輸出參數(shù)：無(wú)
  725. // 功能描述：處理屏蔽寄存器指令22
  726. /****************************************************************************************/
  727. void FMaskWriteReg(PDU_RESPONSE *Response)
  728. {
  729.         uint16_t RefeAddr,And_Mask,Or_Mask,RegValue;
  730.         uint8_t  *PDUPtr;
  731.         uint8_t  ValueInByte[2];               
  732.         PDUPtr = Response->PDUDataPtr;
  733.         RefeAddr = (PDUPtr[1]<<8)|(PDUPtr[2]);
  734.         And_Mask = (PDUPtr[3]<<8)|(PDUPtr[4]);
  735.         Or_Mask  = (PDUPtr[5]<<8)|(PDUPtr[6]);
  736.         
  737.         Response->PDUByteLength = 7;
  738.         
  739.         if(RefeAddr<END_HOLDING_REG_ADDR)
  740.         {
  741.                 if(ReadHoldingReg(ValueInByte,RefeAddr,1))
  742.                 {        
  743.                         RegValue = (ValueInByte[0]<<8)|(ValueInByte[1]);
  744.                         RegValue = (RegValue & And_Mask)|(Or_Mask & (~And_Mask));
  745.                         ValueInByte[0] = RegValue >> 8;
  746.                         ValueInByte[1] = RegValue ;
  747.                         if(WriteHoldingReg(ValueInByte,RefeAddr,1))
  748.                         {
  749.                                 *(PDUPtr+1) = RefeAddr>>8;
  750.                                 *(PDUPtr+2) = RefeAddr;
  751.                                 *(PDUPtr+3) = And_Mask>>8;
  752.                                 *(PDUPtr+4) = And_Mask;
  753.                                 *(PDUPtr+5) = Or_Mask>>8;
  754.                                 *(PDUPtr+6) = Or_Mask;
  755.                                 Response->ExceptionCode = 0x00;
  756.                         }
  757.                         else
  758.                                 Response->ExceptionCode = 0x04;
  759.                 }
  760.                 else
  761.                         Response->ExceptionCode = 0x03;
  762.         }
  763.         else
  764.                 Response->ExceptionCode = 0x02;
  765. }
  766. #endif

  768. #if READ_WRITE_REG_EN > 0
  769. /****************************************************************************************/
  770. // 函數(shù)名稱(chēng)：FRWMultipleReg
  771. // 輸入?yún)?shù)：Response
  772. // 輸出參數(shù)：無(wú)
  773. // 功能描述：處理讀寫(xiě)多寄存器指令23
  774. /****************************************************************************************/
  775. void FRWMultipleReg(PDU_RESPONSE *Response)
  776. {
  777.         uint16_t ReadStaAddr,        ReadQuantity;
  778.         uint16_t WriteStaAddr,WriteQuantity;
  779.         uint8_t  WriteBytes;
  780.         uint8_t  *WriteValuePtr;
  781.         uint8_t  *PDUPtr;
  782.         PDUPtr = Response->PDUDataPtr;
  783.         ReadStaAddr   = (PDUPtr[1]<<8)|(PDUPtr[2]);
  784.         ReadQuantity  = (PDUPtr[3]<<8)|(PDUPtr[4]);
  785.         WriteStaAddr  = (PDUPtr[5]<<8)|(PDUPtr[6]);
  786.         WriteQuantity = (PDUPtr[7]<<8)|(PDUPtr[8]);
  787.         WriteBytes    = PDUPtr[9];
  788.         WriteValuePtr = &PDUPtr[10];

  790.         Response->PDUByteLength = ReadQuantity*2 + 2;
  791.         
  792.         if((ReadQuantity>=0x001)&&(ReadQuantity<=0x007d)&&                // 讀寄存器的數(shù)量是否在有效范圍內(nèi)
  793.            (WriteQuantity>=0x001)&&(WriteQuantity<=0x0079)&&        // 寫(xiě)寄存器的數(shù)量是否在有效范圍內(nèi)
  794.            (WriteBytes==(WriteQuantity*2)))                                                // 接收到的字節(jié)數(shù)是否與寫(xiě)入的寄存器數(shù)量一至
  795.         {
  796.                 if((ReadStaAddr<END_HOLDING_REG_ADDR)&&((ReadStaAddr+ReadQuantity)<=END_HOLDING_REG_ADDR)&&
  797.                    (WriteStaAddr<END_HOLDING_REG_ADDR)&&((WriteStaAddr+WriteQuantity)<=END_HOLDING_REG_ADDR))
  798.                 {
  799.                         if(WriteHoldingReg(WriteValuePtr,WriteStaAddr,WriteQuantity))        // 寫(xiě)寄存器
  800.                         {
  801.                            if(ReadHoldingReg(PDUPtr+2,ReadStaAddr,ReadQuantity))                // 讀寄存器
  802.                                 {
  803.                                         *(PDUPtr+1) = ReadQuantity*2;
  804.                                         Response->ExceptionCode = 0x00;
  805.                                 }
  806.                                 else
  807.                                         Response->ExceptionCode = 0x04;
  808.                         }
  809.                         else
  810.                                 Response->ExceptionCode = 0x04;
  811.                 }
  812.                 else
  813.                         Response->ExceptionCode = 0x02;
  814.         }
  815.         else
  816.                 Response->ExceptionCode = 0x03;
  817. }
  818. #endif












復(fù)制代碼


作者: lisc5920    時(shí)間: 2016-11-30 13:11
你好，我想將單片機(jī)讀取的 一個(gè)溫度值通過(guò)modbus協(xié)議 傳輸?shù)缴衔粰C(jī)  我的設(shè)計(jì)思路應(yīng)該是怎樣的呢 能把我簡(jiǎn)單的說(shuō)明下嗎  謝謝你了！
作者: zhangli019    時(shí)間: 2017-1-10 10:18
這個(gè)資料很好，尤其是在工業(yè)控制應(yīng)用方面，能制作成符合工業(yè)標(biāo)準(zhǔn)的控制器
作者: 51設(shè)計(jì)    時(shí)間: 2020-2-28 15:56
lisc5920 發(fā)表于 2016-11-30 13:11
你好，我想將單片機(jī)讀取的 一個(gè)溫度值通過(guò)modbus協(xié)議 傳輸?shù)缴衔粰C(jī)  我的設(shè)計(jì)思路應(yīng)該是怎樣的呢 能把我簡(jiǎn) ...

你的問(wèn)題解決沒(méi)有？
作者: 51設(shè)計(jì)    時(shí)間: 2020-2-28 16:00
這個(gè)有原理圖嘛？
作者: 1714730483    時(shí)間: 2021-9-22 13:14
好資料，接下來(lái)的設(shè)計(jì)正好需要用到MODbus
作者: dashiwork    時(shí)間: 2022-1-26 21:40
路過(guò)學(xué)習(xí)，好東西，收藏一下，
作者: 1234578zqq    時(shí)間: 2024-7-27 15:46

好資料，接下來(lái)的設(shè)計(jì)正好需要用到MODbus
作者: 295067924    時(shí)間: 2024-8-2 19:43
路過(guò)學(xué)習(xí)，好東西，收藏一下，
作者: haide1998    時(shí)間: 2024-10-8 08:52
好資料，正好用到MODbus，謝謝分享！



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1