标题: 触摸屏和单片机进行modbus通讯 RTU slave 文件源码，希望可以帮助到大家 [打印本页]
作者: doer    时间: 2016-5-20 19:09
标题: 触摸屏和单片机进行modbus通讯 RTU slave 文件源码，希望可以帮助到大家
触摸屏和单片机进行modbus通讯，触摸屏需要设置为主机，单片机为从机，modbusRTU slave 源码需要植入单片机，希望可以帮助到大家。


全部资料下载：
ModbusSlave.zip (13.59 KB, 下载次数: 249)

  1. /****************************************Copyright (c)**************************************************
  2. **                                  广州致远电子有限公司
  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. // 函数名称：MB_GetDiscrete
  31. // 输入参数：Address，线圈地址
  32. // 输出参数：返回线圈值（0\1）
  33. // 功能描述：获取离散值函数，访函数由用户编写
  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. // 函数名称：MB_GetCoils
  45. // 输入参数：Address，线圈地址
  46. // 输出参数：返回线圈值（0\1）
  47. // 功能描述：获取线圈值函数，访函数由用户编写
  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. // 函数名称：MB_SetCoil
  59. // 输入参数：Address，线圈地址
  60. //                         CoilValue,线圈值（0\1）
  61. // 输出参数：返回寄存器值
  62. // 功能描述：设置线圈值函数，访函数由用户编写
  63. //**************************************************
  64. uint8_t MB_SetCoil(uint16_t Address,uint8_t CoilValue)
  65. {

  67.         return CoilValue;
  68. }


  71. //**************************************************
  72. // 函数名称：MB_GetInputRegValue
  73. // 输入参数：Address，寄存器地址
  74. // 输出参数：返回寄存器值
  75. // 功能描述：读输入寄存器值函数，访函数由用户编写
  76. //**************************************************
  77. uint16_t MB_GetInputRegValue(uint16_t Address)
  78. {

  80.         return Address;
  81. }

  83. //**************************************************
  84. // 函数名称：MB_GetRegValue
  85. // 输入参数：Address，寄存器地址
  86. // 输出参数：返回寄存器值
  87. // 功能描述：读保持寄存器值函数，访函数由用户编写
  88. //**************************************************
  89. uint16_t MB_GetRegValue(uint16_t Address)
  90. {

  92.         return Address;
  93. }

  95. //**************************************************
  96. // 函数名称：MB_SetRegValue
  97. // 输入参数：Address，寄存器地址
  98. //                         Value，写入的值
  99. // 输出参数：无
  100. // 功能描述：写保持寄存器值函数，访函数由用户编写
  101. //**************************************************
  102. void MB_SetRegValue(uint16_t Address,uint16_t Value)
  103. {

  105. }

  107. /****************************************************************************************/
  108. // 函数名称：FReadCoils
  109. // 输入参数：Response
  110. // 输出参数：无
  111. // 功能描述：处理读单线圈指令01
  112. /***************************************************************************************/
  113. void FReadCoils(PDU_RESPONSE *Response);
  114. /****************************************************************************************/
  115. // 函数名称：FReadDiscreteInputs
  116. // 输入参数：Response
  117. // 输出参数：无
  118. // 功能描述：处理读离散输入指令02
  119. /***************************************************************************************/
  120. void FReadDiscreteInputs(PDU_RESPONSE *Response);
  121. /****************************************************************************************/
  122. // 函数名称：FReadHoldingReg
  123. // 输入参数：Response
  124. // 输出参数：无
  125. // 功能描述：处理读保持寄存器指令03
  126. /****************************************************************************************/
  127. void FReadHoldingReg(PDU_RESPONSE *Response);
  128. /****************************************************************************************/
  129. // 函数名称：FReadInputReg
  130. // 输入参数：Response
  131. // 输出参数：无
  132. // 功能描述：处理读输入寄存器指令04
  133. /****************************************************************************************/
  134. void FReadInputReg(PDU_RESPONSE *Response);
  135. /****************************************************************************************/
  136. // 函数名称：FWriteSingleCoil
  137. // 输入参数：Response
  138. // 输出参数：无
  139. // 功能描述：处理写单线圈指令05
  140. /****************************************************************************************/
  141. void FWriteSingleCoil(PDU_RESPONSE *Response);
  142. /****************************************************************************************/
  143. // 函数名称：FWriteSingleReg
  144. // 输入参数：Response
  145. // 输出参数：无
  146. // 功能描述：处理写单线圈指令06
  147. /****************************************************************************************/
  148. void FWriteSingleReg(PDU_RESPONSE *Response);
  149. /****************************************************************************************/
  150. // 函数名称：FWriteMultipleCoils
  151. // 输入参数：Response
  152. // 输出参数：无
  153. // 功能描述：处理写多线圈指令15
  154. /****************************************************************************************/
  155. void FWriteMultipleCoils(PDU_RESPONSE *Response);
  156. /****************************************************************************************/
  157. // 函数名称：FWriteMultipleReg
  158. // 输入参数：Response
  159. // 输出参数：无
  160. // 功能描述：处理写多寄存器指令16
  161. /****************************************************************************************/
  162. void FWriteMultipleReg(PDU_RESPONSE *Response);
  163. /****************************************************************************************/
  164. // 函数名称：FMaskWriteReg
  165. // 输入参数：Response
  166. // 输出参数：无
  167. // 功能描述：处理屏蔽寄存器指令22
  168. /****************************************************************************************/
  169. void FMaskWriteReg(PDU_RESPONSE *Response);
  170. /****************************************************************************************/
  171. // 函数名称：FRWMultipleReg
  172. // 输入参数：Response
  173. // 输出参数：无
  174. // 功能描述：处理读写多寄存器指令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},        // 写单个线圈
  195. #endif
  196. #if WRITE_SING_REG_EN > 0
  197.         {0x06,FWriteSingleReg},                // 写单个寄存器
  198. #endif
  199. #if WRITE_MULT_COIL_EN > 0
  200.         {0x0f,FWriteMultipleCoils},        // 写多个线圈
  201. #endif
  202. #if WRITE_MULT_REG_EN > 0
  203.         {0x10,FWriteMultipleReg},        // 写多个寄存器
  204. #endif
  205. #if MASK_WRITE_REG_EN > 0
  206.         {0x16,FMaskWriteReg},                // 处理屏蔽寄存器指令
  207. #endif
  208. #if READ_WRITE_REG_EN > 0
  209.         {0x17,FRWMultipleReg},                // 读写多个寄存器
  210. #endif
  211.         {0x00,FTest}                                // 测试功能代码
  212. };

  214. #if READ_DIS_INPUT_EN
  215. //************************************************************************************
  216. // 函数名称：ReadDiscreteInputs
  217. // 输入参数：CoilsDataPtr，存放离散输入数据指针
  218. //                         StAddr,离散的起始地址
  219. //                         Quantity,离散的数量
  220. // 输出参数：正常返回TRUE,出错返回FALSE。
  221. // 功能描述：读离散输入操作函数
  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++)                // 将线圈值写入一个字节
  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. // 函数名称：ReadCoils
  249. // 输入参数：CoilsDataPtr，存放线圈数据指针
  250. //                         StAddr,线圈的起始地址
  251. //                         Quantity,线圈的数量
  252. // 输出参数：正常返回TRUE,出错返回FALSE。
  253. // 功能描述：读多线圈操作函数
  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++)                // 将线圈值写入一个字节
  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. // 函数名称：WriteSingleCoil
  280. // 输入参数：DataPtr,数据指针，
  281. //                         StAddr，寄存器起始地址
  282. //                         Quantity，寄存器数量。
  283. // 输出参数：正常返回TRUE,出错返回FALSE。
  284. // 功能描述：写单线圈处理函数
  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. // 函数名称：WriteMultipleCoils
  295. // 输入参数：DataPtr,数据指针，
  296. //                         StAddr，寄存器起始地址
  297. //                         Quantity，寄存器数量。
  298. // 输出参数：正常返回TRUE,出错返回FALSE。
  299. // 功能描述：写多线圈处理函数
  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. // 函数名称：ReadInputReg
  319. // 输入参数：DataPtr,数据指针，
  320. //                         StAddr，寄存器起始地址
  321. //                         Quantity，寄存器数量。
  322. // 输出参数：正常返回TRUE,出错返回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. // 函数名称：ReadHoldingReg
  343. // 输入参数：DataPtr,数据指针，16位数据高8位在低字节，低8位在高字节
  344. //                         StAddr，寄存器起始地址
  345. //                         Quantity，寄存器数量。
  346. // 输出参数：正常返回TRUE,出错返回FALSE。
  347. // 功能描述：读寄存器处理函数
  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. // 函数名称：WriteHoldingReg
  366. // 输入参数：DataPtr,数据指针，16位数据高8位在低字节，低8位在高字节
  367. //                         StAddr，寄存器起始地址
  368. //                         Quantity，寄存器数量。
  369. // 输出参数：正常返回TRUE,出错返回FALSE。
  370. // 功能描述：写寄存器处理函数
  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. // 函数名称：FReadCoils
  397. // 输入参数：Response，为PDU_RESPONSE类型的指针，PDU_RESPONSE：
  398. //                         typedef struct __PDU_RESPONSE{
  399. //                                uint8*        PDUDataPtr;   请求数据指针,功能代码处理函数必需将处理的数据包存在该指针的开始位始
  400. //                                  uint8        PDUByteLength;请求数据数长度
  401. //                                uint8        ExceptionCode;仅为输出错异常代码，正常操作设为0
  402. //                         }PDU_RESPONSE
  403. // 输出参数：无
  404. // 功能描述：处理读多线圈指令01
  405. /***************************************************************************************/
  406. void FReadCoils(PDU_RESPONSE *Response)
  407. {
  408.         uint8_t * PDUPtr;
  409.         uint16_t StAddr ,Quantity;
  410.         // 从请求PDU中提取相关参数
  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) ;        // 正常返回的数据长度
  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;        // 字节数
  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. // 函数名称：FReadDiscreteInputs
  440. // 输入参数：Response
  441. // 输出参数：无
  442. // 功能描述：处理读离散输入指令02
  443. /***************************************************************************************/
  444. void FReadDiscreteInputs(PDU_RESPONSE *Response)
  445. {
  446.         uint8_t * PDUPtr;
  447.         uint16_t StAddr ,Quantity;
  448.         // 从请求PDU中提取相关参数
  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) ;        // 正常返回的数据长度
  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;        // 字节数
  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. // 函数名称：FReadHoldingReg
  478. // 输入参数：Response
  479. // 输出参数：无
  480. // 功能描述：处理读保持寄存器指令03
  481. /****************************************************************************************/
  482. void FReadHoldingReg(PDU_RESPONSE *Response)
  483. {
  484.         uint8_t * PDUPtr;
  485.         uint16_t StAddr ,Quantity;
  486.         // 从请求PDU中提取相关参数
  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 ;        // 正常返回的数据长度
  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. // 函数名称：FReadInputReg
  516. // 输入参数：Response
  517. // 输出参数：无
  518. // 功能描述：处理读输入寄存器指令04
  519. /****************************************************************************************/
  520. void FReadInputReg(PDU_RESPONSE *Response)
  521. {
  522.         uint8_t * PDUPtr;
  523.         uint16_t StAddr ,Quantity;
  524.         // 从请求PDU中提取相关参数
  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 ;        // 正常返回的数据长度
  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. // 函数名称：FWriteSingleCoil
  555. // 输入参数：Response
  556. // 输出参数：无
  557. // 功能描述：处理写单线圈指令05
  558. /****************************************************************************************/
  559. void FWriteSingleCoil(PDU_RESPONSE *Response)
  560. {
  561.         uint8_t * PDUPtr;
  562.         uint16_t OutputAddr ,OutputValue;
  563.         // 从请求PDU中提取相关参数
  564.         PDUPtr = Response->PDUDataPtr;
  565.         OutputAddr = PDUPtr[1]<<8|PDUPtr[2];
  566.         OutputValue =  PDUPtr[3]<<8|PDUPtr[4];
  567.         
  568.         Response->PDUByteLength = 5 ;        // 正常返回的数据长度
  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. // 函数名称：FWriteSingleReg
  596. // 输入参数：Response
  597. // 输出参数：无
  598. // 功能描述：处理写单线圈指令06
  599. /****************************************************************************************/
  600. void FWriteSingleReg(PDU_RESPONSE *Response)
  601. {
  602.         uint8 * PDUPtr;
  603.         uint16 OutputAddr ,OutputValue;
  604.         // 从请求PDU中提取相关参数
  605.         PDUPtr = Response->PDUDataPtr;
  606.         OutputAddr = PDUPtr[1]<<8|PDUPtr[2];
  607.         OutputValue =  PDUPtr[3]<<8|PDUPtr[4];
  608.         
  609.         Response->PDUByteLength = 2 + 5 ;        // 正常返回的数据长度
  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. // 函数名称：FWriteMultipleCoils
  637. // 输入参数：Response
  638. // 输出参数：无
  639. // 功能描述：处理写多线圈指令15
  640. /****************************************************************************************/
  641. void FWriteMultipleCoils(PDU_RESPONSE *Response)
  642. {
  643.         uint8_t * PDUPtr;
  644.         uint16_t StAddr ,Quantity;
  645.         uint8_t         ByteCount;
  646.         // 从请求PDU中提取相关参数
  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 ;        // 正常返回的数据长度

  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. // 函数名称：FWriteMultipleReg
  680. // 输入参数：Response
  681. // 输出参数：无
  682. // 功能描述：处理写多寄存器指令16
  683. /****************************************************************************************/
  684. void FWriteMultipleReg(PDU_RESPONSE *Response)
  685. {
  686.         uint8_t * PDUPtr;
  687.         uint16_t StAddr ,Quantity;
  688.         uint8_t         ByteCount;
  689.         // 从请求PDU中提取相关参数
  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 ;        // 正常返回的数据长度

  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. // 函数名称：FMaskWriteReg
  723. // 输入参数：Response
  724. // 输出参数：无
  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. // 函数名称：FRWMultipleReg
  771. // 输入参数：Response
  772. // 输出参数：无
  773. // 功能描述：处理读写多寄存器指令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)&&                // 读寄存器的数量是否在有效范围内
  793.            (WriteQuantity>=0x001)&&(WriteQuantity<=0x0079)&&        // 写寄存器的数量是否在有效范围内
  794.            (WriteBytes==(WriteQuantity*2)))                                                // 接收到的字节数是否与写入的寄存器数量一至
  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))        // 写寄存器
  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












复制代码


作者: lisc5920    时间: 2016-11-30 13:11
你好，我想将单片机读取的 一个温度值通过modbus协议 传输到上位机  我的设计思路应该是怎样的呢 能把我简单的说明下吗  谢谢你了！
作者: zhangli019    时间: 2017-1-10 10:18
这个资料很好，尤其是在工业控制应用方面，能制作成符合工业标准的控制器
作者: 51设计    时间: 2020-2-28 15:56
lisc5920 发表于 2016-11-30 13:11
你好，我想将单片机读取的 一个温度值通过modbus协议 传输到上位机  我的设计思路应该是怎样的呢 能把我简 ...

你的问题解决没有？
作者: 51设计    时间: 2020-2-28 16:00
这个有原理图嘛？
作者: 1714730483    时间: 2021-9-22 13:14
好资料，接下来的设计正好需要用到MODbus
作者: dashiwork    时间: 2022-1-26 21:40
路过学习，好东西，收藏一下，
作者: 1234578zqq    时间: 2024-7-27 15:46

好资料，接下来的设计正好需要用到MODbus
作者: 295067924    时间: 2024-8-2 19:43
路过学习，好东西，收藏一下，
作者: haide1998    时间: 2024-10-8 08:52
好资料，正好用到MODbus，谢谢分享！



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1