SERVER+MODBUS.docx
《SERVER+MODBUS.docx》由会员分享，可在线阅读，更多相关《SERVER+MODBUS.docx（74页珍藏版）》请在冰豆网上搜索。
SERVER+MODBUS
///////////////////////////////////////////////////////////////SERVER.CPP
1.include "stdafx.h"
2.#include
3.#include
4.#include
5.#include "MODBUS_SHARE.h"
6.#include "MODBUS_SERVER.h"
7.#include "PORT.h"
8.
9.unsigned char buff[256];
10.
11.////////////////////////////////////////////////////////////////////////////////////////////////////
12./*1.对单个PLC操作*/
13./*读一个或多个模拟量 参数：
站号，开始地址， 读的数量， 返回数据变量指针 返回：
－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
14./*40000*/
15.char MODBUS_S_ReadMultiRegD（unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, short int *list）
16.{
17. unsigned short int crc16;
18. unsigned short int crctmp;
19. short int vartmp;
20.
21. memset（buff, 0x00, 255）;
22. buff[0]= rtu;
23. buff[1]= 0x03;
24. buff[2]= （unsigned char）（（RegAdd-40001） >> 8）;
25. buff[3]= （unsigned char）（RegAdd-40001）;
26. buff[4]= （unsigned char）（RegCount >> 8）;
27. buff[5]= （unsigned char）RegCount;
28. crc16= CalcCrcFast（buff, 6）;
29. buff[6]= （unsigned char）（crc16 >> 8）;
30. buff[7]= （unsigned char）crc16;
31.
32. //发送数据
33. unsigned long strlen;
34. if（IsOpen（））
35. {
36. //发送数据
37. strlen= WriteChar（8, （char *）buff）;
38. if（strlen==8）
39. {
40. //读数据
41. memset（buff, 0x00, 255）;
42. Sleep（50）;
43. strlen= ReadChar（255, （char *）buff, 1000）;
44. if（strlen==0）
45. {
46. //无返回
47. return（-2）;
48. }
49. else
50. {
51. //返回长度有效,解析接收缓冲区
52. if（strlen== （3+（RegCount *2）+ 2） && buff[0]== rtu && buff[1]== 0x03）
53. {
54. crc16= CalcCrcFast（buff, 3+（RegCount*2））;
55. crctmp= buff[strlen-2];
56. crctmp= crctmp << 8 | buff[strlen-1];
57. if（crc16== crctmp ）
58. {
59. for（int i=0; i< RegCount; i++）
60. {
61. vartmp= buff[3+（2*i）];
62. vartmp= vartmp << 8;
63. vartmp= vartmp | buff[3+（（2*i）+1）];
64.
65. list[i]= vartmp;
66. }
67. }
68. else
69. {
70. return（-1）;
71. }
72. }
73. else
74. {
75. return（-1）;
76. }
77. }
78. }
79. else
80. {
81. return（-2）;
82. }
83. }
84. else
85. {
86. return（-2）;
87. }
88.
89. return
（1）;
90.}
91.
92./*读一个或多个开关量 参数：
站号，开始地址， 读的数量， 返回数据变量指针 返回：
－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
93./*00000*/
94.char MODBUS_S_ReadMultiRegM（unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, bool *list）
95.{
96. unsigned short int crc16;
97. unsigned short int crctmp;
98.
99. memset（buff, 0x00, 255）;
100. buff[0]= rtu;
101. buff[1]= 0x01;
102. buff[2]= （unsigned char）（RegAdd >> 8）;
103. buff[3]= （unsigned char）RegAdd;
104. buff[4]= （unsigned char）（RegCount >> 8）;
105. buff[5]= （unsigned char）RegCount;
106. crc16= CalcCrcFast（buff, 6）;
107. buff[6]= （unsigned char）（crc16 >> 8）;
108. buff[7]= （unsigned char）crc16;
109.
110. //发送数据
111. unsigned long strlen;
112. if（IsOpen（））
113. {
114. //发送数据
115. strlen= WriteChar（8, （char *）buff）;
116. if（strlen==8）
117. {
118. //读数据
119. memset（buff, 0x00, 255）;
120. Sleep（50）;
121. strlen= ReadChar（255, （char *）buff, 1000）;
122. if（strlen==0）
123. {
124. //无返回
125. return（-2）;
126. }
127. else
128. {
129. //返回长度有效,解析接收缓冲区
130. if（strlen== （3+（（RegCount+7）/8）+ 2） && buff[0]== rtu && buff[1]== 0x01）
131. {
132. crc16= CalcCrcFast（buff, 3+（（RegCount +7）/8））;
133. crctmp= buff[strlen-2];
134. crctmp= crctmp << 8 | buff[strlen-1];
135. if（crc16== crctmp ）
136. {
137. unsigned char row=0, col=0;
138. for（int i=0; i> col & 0x01;
139. }
140. }
141. else
142. {
143. return（-1）;
144. }
145. }
146. else
147. {
148. return（-1）;
149. }
150. }
151. }
152. else
153. {
154. return（-2）;
155. }
156. }
157. else
158. {
159. return（-2）;
160. }
161.
162. return
（1）;
163.}
164.
165./*读一个或多个开关量 参数：
站号，开始地址， 读的数量， 返回数据变量指针 返回：
－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
166./*10000*/
167.char MODBUS_S_ReadMultiRegM_1x（unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, bool *list）
168.{
169. unsigned short int crc16;
170. unsigned short int crctmp;
171.
172. memset（buff, 0x00, 255）;
173. buff[0]= rtu;
174. buff[1]= 0x02;
175. buff[2]= （unsigned char）（（RegAdd-10001）>> 8）;
176. buff[3]= （unsigned char）（RegAdd-10001）;
177. buff[4]= （unsigned char）（RegCount >> 8）;
178. buff[5]= （unsigned char）RegCount;
179. crc16= CalcCrcFast（buff, 6）;
180. buff[6]= （unsigned char）（crc16 >> 8）;
181. buff[7]= （unsigned char）crc16;
182.
183. //发送数据
184. unsigned long strlen;
185. if（IsOpen（））
186. {
187. //发送数据
188. strlen= WriteChar（8, （char *）buff）;
189. if（strlen==8）
190. {
191. //读数据
192. memset（buff, 0x00, 255）;
193. Sleep（50）;
194. strlen= ReadChar（255, （char *）buff, 1000）;
195. if（strlen==0）
196. {
197. //无返回
198. return（-2）;
199. }
200. else
201. {
202. //返回长度有效,解析接收缓冲区
203. if（strlen== （3+（（RegCount+7）/8）+ 2） && buff[0]== rtu && buff[1]== 0x02）
204. {
205. crc16= CalcCrcFast（buff, 3+（（RegCount +7）/8））;
206. crctmp= buff[strlen-2];
207. crctmp= crctmp << 8 | buff[strlen-1];
208. if（crc16== crctmp ）
209. {
210. unsigned char row=0, col=0;
211. for（int i=0; i> col & 0x01;
212. }
213. }
214. else
215. {
216. return（-1）;
217. }
218. }
219. else
220. {
221. return（-1）;
222. }
223. }
224. }
225. else
226. {
227. return（-2）;
228. }
229. }
230. else
231. {
232. return（-2）;
233. }
234.
235. return
（1）;
236.}
237.
238./*写一个模拟量 参数：
站号，写地址， 返回数据变量指针 返回：
小于零失败，大于零表示成功*/
239./*40000*/
240.char MODBUS_S_WriteSingRegD（unsigned char rtu, unsigned short int RegAdd, short int var）
241.{
242. unsigned short int crc16;
243.
244. memset（buff, 0x00, 255）;
245. buff[0]= rtu;
246. buff[1]= 0x06;
247. buff[2]= （unsigned char）（（RegAdd-40001） >> 8）;
248. buff[3]= （unsigned char）（RegAdd-40001）;
249. buff[4]= （unsigned char）（var >> 8）;
250. buff[5]= （unsigned char）var;
251. crc16= CalcCrcFast（buff, 6）;
252. buff[6]= （unsigned char）（crc16 >> 8）;
253. buff[7]= （unsigned char）crc16;
254.
255. //发送数据
256. unsigned long strlen;
257. if（IsOpen（））
258. {
259. //发送数据
260. strlen= WriteChar（8, （char *）buff）;
261. if（strlen==8）
262. {
263. Sleep（50）;
264. strlen= ReadChar（255, （char *）buff, 1000）;
265. //返回长度有效,解析接收缓冲区
266. if（!
（strlen== 8 && buff[0]== rtu && buff[1]== 0x06））
267. {
268. return（-1）;
269.
升级会员 