zhangchengen
/
Modbus_communication
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
52 Commity
3 Gałęzie
375 KiB
 
 
 
 
Drzewo: 67471c2c96
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '67471c2c96'
${ noResults }
Modbus_communication/Modbus_communication/Modbus_RTU_Salve/RTU_Salve.cpp

446 wiersze
16 KiB
Czysty Wina Historia 

  1. #include "RTU_Salve.h"

  2. #include <bitset>

  3. char read_buf[MAX_NUMBER];

  4. 

  5. bitset<MAX_Address> Coil_date; //0-9999

  6. UINT16 Register[MAX_Address]; // 0-9999

  7. unsigned int Response_Message_Len;

  8. unsigned int RTU_Enable = 1;

  9. 

  10. /*********************************************************************************************

  11. * 功能     ：   初始化线圈和寄存器

  12. * 描述	   ：	对线圈和寄存器数组赋值为全1

  13. * 输入     ：   无

  14. * 返回值   ：   无

  15. **********************************************************************************************/

  16. void Init_Coil_Register(void)

  17. {

  18. 	for (int i = 0; i < MAX_Address; i++)

  19. 	{

  20. 		Coil_date[i] = 1;

  21. 		Register[i] = 0xFFFF;

  22. 	}

  23. }

  24. /*********************************************************************************************

  25. * 功能     ：   Bitset转UINT8类型

  26. * 描述	   ：	Bitset ==》UINT8

  27. * 输入     ：   Bitset_Address Bitset的起始地址  Read_Number 要读取的位数

  28. * 返回值   ：   Date 转换后的UNIT8数据

  29. **********************************************************************************************/

  30. UINT8 Bitset_to_Uint8(unsigned int Bitset_Address, unsigned int Read_Number)

  31. {

  32. 	UINT8 Date = 0x00;

  33. 	

  34. 	if (Read_Number >= 8)

  35. 	{

  36. 		unsigned int len = Bitset_Address + 7;

  37. 		for (unsigned int i = 0; i < 8; i++)

  38. 		{

  39. 			Date = Date << 1;

  40. 			Date = Date | (int)Coil_date[len--];

  41. 		}

  42. 	}

  43. 	else

  44. 	{

  45. 		unsigned int len = Bitset_Address + Read_Number-1;

  46. 		for (unsigned int i = 0; i < Read_Number; i++)

  47. 		{

  48. 			Date = Date << 1;

  49. 			Date = Date | (int)Coil_date[len--];

  50. 		}

  51. 	}

  52. 	return Date;

  53. }

  54. 

  55. /*********************************************************************************************

  56. * 功能     ：   生成异常码响应报文

  57. * 描述	   ：	对不支持的功能码生成对应的异常响应报文

  58. * 输入     ：   *Requst_Message 请求报文 *Response_Message响应报文

  59. * 返回值   ：   无

  60. **********************************************************************************************/

  61. void Create_Abnormal_Code_Response_Message(UINT8 *Requst_Message, UINT8 *Response_Message, UINT8 Abnormal_Code)

  62. {

  63. 	Response_Message[0] = Device_ID;

  64. 	Response_Message[1] = Requst_Message[1] + 0x80;

  65. 	Response_Message[2] = Abnormal_Code;

  66. 	Response_Message_Len = 3;

  67. 	UINT16 CRC_date = CRC_16(Response_Message, 3);

  68. 	Response_Message[3] = CRC_date >> 8;//CRC_H

  69. 	Response_Message[4] = (UINT8)CRC_date; //CRC_L

  70. 	Response_Message_Len = 5;

  71. }

  72. 

  73. /*********************************************************************************************

  74. * 功能     ：   生成0x01功能码响应报文

  75. * 描述	   ：	通过判断地址范围生成0x01对应的响应报文

  76. * 输入     ：   *Requst_Message 请求报文 *Response_Message响应报文

  77. * 返回值   ：   无

  78. **********************************************************************************************/

  79. void Create_0x01_Response_Message(UINT8 *Requst_Message, UINT8 *Response_Message)

  80. { 

  81. 	unsigned int Start_Address = Requst_Message[2] << 8 | Requst_Message[3];

  82. 	unsigned int Address_range = Start_Address + (Requst_Message[4] << 8 | Requst_Message[5]);

  83. 	if (Address_range < MAX_Address)//判断地址是否超限

  84. 	{

  85. 		unsigned int Read_Number = Requst_Message[4] << 8 | Requst_Message[5];//要读取的位数

  86. 		unsigned int Read_Len = Count_Read_date_number(Requst_Message[1], Read_Number); //要读取的字节数

  87. 		for (unsigned int i = 3; i < Read_Len + 3; i++)

  88. 		{

  89. 			Response_Message[i] = Bitset_to_Uint8(Start_Address, Read_Number);

  90. 			Start_Address += 8;

  91. 			Read_Number -= 8;

  92. 		}

  93. 		Response_Message[0] = Device_ID;

  94. 		Response_Message[1] = Requst_Message[1];

  95. 		Response_Message[2] = Read_Len;  //响应报文中的后续字节数

  96. 		UINT16 CRC_date = CRC_16(Response_Message, Read_Len+3);

  97. 		Response_Message_Len = Read_Len + 2 + 3;

  98. 		Response_Message[Response_Message_Len - 2] = CRC_date>>8;//CRC_H

  99. 		Response_Message[Response_Message_Len - 1] = (UINT8)CRC_date; //CRC_L

  100. 	}

  101. 	else 

  102. 	{

  103. 		Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message,0x02);

  104. 	}

  105. }

  106. 

  107. /*********************************************************************************************

  108. * 功能     ：   生成0x03功能码响应报文

  109. * 描述	   ：	通过判断地址范围生成0x03对应的响应报文

  110. * 输入     ：   *Requst_Message 请求报文 *Response_Message响应报文

  111. * 返回值   ：   无

  112. **********************************************************************************************/

  113. void Create_0x03_Response_Message(UINT8 *Requst_Message, UINT8 *Response_Message)

  114. {

  115. 	unsigned int Start_Address = Requst_Message[2] << 8 | Requst_Message[3];

  116. 	unsigned int Address_range = Start_Address + (Requst_Message[4] << 8 | Requst_Message[5]);

  117. 	if (Address_range < MAX_Address) //判断地址是否超限

  118. 	{

  119. 		unsigned int Read_Number = Requst_Message[4] << 8 | Requst_Message[5];//要读取的寄存器数量

  120. 		unsigned int Read_Len = Count_Read_date_number(Requst_Message[1

  121. 		], Read_Number); //要读取的字节数

  122. 		for (unsigned int i = 3; i < Read_Len + 3; i= i + 2)

  123. 		{

  124. 			Response_Message[i] = Register[Start_Address] >> 8;

  125. 			Response_Message[i + 1] = (UINT8)Register[Start_Address];

  126. 			Start_Address += 1;

  127. 		}

  128. 		Response_Message[0] = Device_ID;

  129. 		Response_Message[1] = Requst_Message[1];

  130. 		Response_Message[2] = Read_Len; //响应报文中的后续字节数

  131. 		UINT16 CRC_date = CRC_16(Response_Message, Read_Len + 3);

  132. 		Response_Message_Len = Read_Len + 2 + 3;

  133. 		Response_Message[Response_Message_Len - 2] = CRC_date >> 8;//CRC_H

  134. 		Response_Message[Response_Message_Len - 1] = (UINT8)CRC_date; //CRC_L

  135. 	}

  136. 	else //地址超限 

  137. 	{

  138. 		Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message, 0x02);

  139. 	}

  140. }

  141. 

  142. /*********************************************************************************************

  143. * 功能     ：   写入线圈

  144. * 描述	   ：	将数据写入线圈中

  145. * 输入     ：   Write_date_Message 要写入的数据 Write_Number要写入的位数  Start_Address起始地址

  146. * 返回值   ：   无

  147. **********************************************************************************************/

  148. void Write_Coil_date(UINT8 Write_date_Message, unsigned int Write_Number, unsigned int Start_Address)

  149. {

  150. 	if (Write_Number >= 8)

  151. 	{

  152. 		for (unsigned int i = Start_Address; i < Start_Address+8; i++)

  153. 		{

  154. 			Coil_date[i] = Write_date_Message & 1;

  155. 			Write_date_Message = Write_date_Message >> 1;

  156. 		}

  157. 	}

  158. 	else

  159. 	{

  160. 		for (unsigned int i = Start_Address; i < Start_Address + Write_Number; i++)

  161. 		{

  162. 			Coil_date[i] = Write_date_Message & 1;

  163. 			Write_date_Message = Write_date_Message >> 1;

  164. 		}

  165. 	}

  166. }

  167. 

  168. /*********************************************************************************************

  169. * 功能     ：   生成0x0F功能码响应报文

  170. * 描述	   ：	通过判断地址范围生成0x0F对应的响应报文

  171. * 输入     ：   *Requst_Message 请求报文 *Response_Message响应报文

  172. * 返回值   ：   无

  173. **********************************************************************************************/

  174. void Create_0x0F_Response_Message(UINT8 *Requst_Message, UINT8 *Response_Message)

  175. {

  176. 	unsigned int Start_Address = Requst_Message[2] << 8 | Requst_Message[3];

  177. 	unsigned int Address_range = Start_Address + (Requst_Message[4] << 8 | Requst_Message[5]);

  178. 	if (Address_range < MAX_Address)//判断地址是否超限

  179. 	{

  180. 		unsigned int Write_Number = Requst_Message[4] << 8 | Requst_Message[5];//要写入的位数

  181. 		for (int i = 7; i < Requst_Message[6]+7; i++)//执行写入线圈操作

  182. 		{

  183. 			Write_Coil_date(Requst_Message[i], Write_Number, Start_Address);

  184. 			Write_Number -= 8;

  185. 			Start_Address += 8;

  186. 		}

  187. 		Response_Message[0] = Device_ID;

  188. 		Response_Message[1] = Requst_Message[1];

  189. 		Response_Message[2] = Requst_Message[2];

  190. 		Response_Message[3] = Requst_Message[3];

  191. 		Response_Message[4] = Requst_Message[4];

  192. 		Response_Message[5] = Requst_Message[5];

  193. 		UINT16 CRC_date = CRC_16(Response_Message, 6);

  194. 		Response_Message[6] = CRC_date >> 8;//CRC_H

  195. 		Response_Message[7] = (UINT8)CRC_date; //CRC_L

  196. 		Response_Message_Len = 8;

  197. 

  198. 	}

  199. 	else //地址超限

  200. 	{

  201. 		Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message, 0x02);

  202. 	}

  203. }

  204. 

  205. /*********************************************************************************************

  206. * 功能     ：   生成0x10功能码响应报文

  207. * 描述	   ：	通过判断地址范围生成0x10对应的响应报文

  208. * 输入     ：   *Requst_Message 请求报文 *Response_Message响应报文

  209. * 返回值   ：   无

  210. **********************************************************************************************/

  211. void Create_0x10_Response_Message(UINT8 *Requst_Message, UINT8 *Response_Message)

  212. {

  213. 	unsigned int Start_Address = Requst_Message[2] << 8 | Requst_Message[3];

  214. 	unsigned int Address_range = Start_Address + (Requst_Message[4] << 8 | Requst_Message[5]);

  215. 	if (Address_range < MAX_Address)//判断地址是否超限

  216. 	{

  217. 		unsigned int Write_Number = Requst_Message[4] << 8 | Requst_Message[5];//要写入的寄存器个数

  218. 		for (int i = 7; i < Requst_Message[6] + 7; i = i + 2)//执行写入寄存器操作

  219. 		{

  220. 			Register[Start_Address] = Requst_Message[i] << 8 | Requst_Message[i+1];

  221. 			Start_Address++;

  222. 		}

  223. 		Response_Message[0] = Device_ID;

  224. 		Response_Message[1] = Requst_Message[1];

  225. 		Response_Message[2] = Requst_Message[2];

  226. 		Response_Message[3] = Requst_Message[3];

  227. 		Response_Message[4] = Requst_Message[4];

  228. 		Response_Message[5] = Requst_Message[5];

  229. 		UINT16 CRC_date = CRC_16(Response_Message, 6);

  230. 		Response_Message[6] = CRC_date >> 8;//CRC_H

  231. 		Response_Message[7] = (UINT8)CRC_date; //CRC_L

  232. 		Response_Message_Len = 8;

  233. 	}

  234. 	else //地址超限

  235. 	{

  236. 		Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message, 0x02);

  237. 	}

  238. }

  239. 

  240. 

  241. /*********************************************************************************************

  242. * 功能     ：   CRC校验

  243. * 描述	   ：	对请求报文中的数据进行CRC校验

  244. * 输入     ：   *Requst_Message 请求报文 Read_len 接收到到的字节数

  245. * 返回值   ：   true  CRC校验通过

  246. *				false CRC校验不通过

  247. **********************************************************************************************/

  248. bool Check_Requst_Message_CRC(UINT8 *Requst_Message, DWORD Read_len)

  249. {

  250. 	UINT16 CRC_data = CRC_16(Requst_Message, Read_len-2);

  251. 	UINT16 Message_CRC = Requst_Message[Read_len - 2] << 8 | Requst_Message[Read_len - 1];

  252. 	if (CRC_data != Message_CRC)

  253. 		return false;

  254. 	return true;

  255. }

  256. 

  257. /*********************************************************************************************

  258. * 功能     ：   异常码03判定--请求报文长度校验

  259. * 描述	   ：	对请求报文的字节长度进行计算校验

  260. * 输入     ：   *Requst_Message 请求报文 Read_len 接收到到的字节数

  261. * 返回值   ：   true  长度校验通过

  262. *				false 长度校验不通过

  263. **********************************************************************************************/

  264. bool Check_Requst_Message_Len(UINT8 *Requst_Message, DWORD Read_len)

  265. {

  266. 	if (Requst_Message[1] == 0x01 || Requst_Message[1] == 0x03)

  267. 	{

  268. 		if (Read_len != 8)

  269. 			return false;

  270. 	}

  271. 	if (Requst_Message[1] == 0x0F || Requst_Message[1] == 0x10)

  272. 	{

  273. 		unsigned int Number = Requst_Message[4] << 8 | Requst_Message[5];

  274. 		unsigned int  Count_len = Count_Read_date_number(Requst_Message[1], Number);

  275. 		if (Requst_Message[6] != Count_len || Read_len != Count_len + 9)

  276. 			return false;

  277. 	}

  278. 	return true;

  279. }

  280. 

  281. /*********************************************************************************************

  282. * 功能     ：   异常码03判定--请求报文中的操作数量判定

  283. * 描述	   ：	对请求报文中的操作数量进行判定

  284. * 输入     ：   *Requst_Message 请求报文 Read_len 接收到到的字节数

  285. * 返回值   ：   true  校验通过

  286. *				false 校验不通过

  287. **********************************************************************************************/

  288. bool Check_Operation_Number_Requst_Message(UINT8 *Requst_Message)

  289. {

  290. 	unsigned int Operation_Number = Requst_Message[4] << 8 | Requst_Message[5];

  291. 	if (Requst_Message[1] == 0x01)

  292. 	{

  293. 		if (Operation_Number == 0 || Operation_Number > 2000)

  294. 			return false;

  295. 	}

  296. 	if (Requst_Message[1] == 0x03)

  297. 	{

  298. 		if (Operation_Number == 0 || Operation_Number > 125)

  299. 			return false;

  300. 	}

  301. 	if (Requst_Message[1] == 0x0F)

  302. 	{

  303. 		if (Operation_Number < 1 || Operation_Number > 1968)

  304. 			return false;

  305. 	}

  306. 	if (Requst_Message[1] == 0x10)

  307. 	{

  308. 		if (Operation_Number < 1 || Operation_Number > 123)

  309. 			return false;

  310. 	}

  311. 	return true;

  312. }

  313. /*********************************************************************************************

  314. * 功能     ：   生成响应报文

  315. * 描述	   ：	检查设备请求报文来生成对应功能的响应报文

  316. * 输入     ：   *Requst_Message 请求报文 *Response_Message响应报文

  317. * 返回值   ：   true  生成响应报文

  318. *				false 不生成响应报文

  319. **********************************************************************************************/

  320. bool Create_Response_Message(UINT8 *Requst_Message, UINT8 *Response_Message, DWORD Read_len)

  321. {

  322. 	if (Requst_Message[0] != Device_ID) //检查设备ID一致

  323. 		return false;

  324. 	if (Read_len < 8 || Read_len > 256)

  325. 		return false;

  326. 	if (!Check_Requst_Message_CRC(Requst_Message, Read_len))//CRC校验报文是否正确

  327. 		return false;

  328. 	if (RTU_Enable == 0)

  329. 	{

  330. 		Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message, 0x04);

  331. 		return true;

  332. 	}

  333. 	if (!Check_Requst_Message_Len(Requst_Message, Read_len) || !Check_Operation_Number_Requst_Message(Requst_Message))//检查请求报文长度是否正确

  334. 	{

  335. 		Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message, 0x03);

  336. 		return true;

  337. 	}

  338. 	switch (Requst_Message[1])

  339. 	{

  340. 	case 0x01:Create_0x01_Response_Message(Requst_Message, Response_Message); break;

  341. 	case 0x03:Create_0x03_Response_Message(Requst_Message, Response_Message); break;

  342. 	case 0x0F:Create_0x0F_Response_Message(Requst_Message, Response_Message); break;

  343. 	case 0x10:Create_0x10_Response_Message(Requst_Message, Response_Message); break;

  344. 	default: Create_Abnormal_Code_Response_Message(Requst_Message, Response_Message,0x01);

  345. 	}

  346. 	return true;

  347. }

  348. 

  349. 

  350. HANDLE Input_Parameter()

  351. {

  352. 	HANDLE Handle_Com;

  353. 	while (true)

  354. 	{

  355. 		GetComm_Name();

  356. 		string COMM = Input_COMM();

  357. 		unsigned int Baud_Rate = Input_Baud_Rate();

  358. 		BYTE Date_Bits = Input_Date_Bits();

  359. 		BYTE Stop_Bits = Input_Stop_Bits(Date_Bits);

  360. 		BYTE Parity = Input_Parity();

  361. 		Handle_Com = Init_COM((LPCTSTR)COMM.c_str(), Baud_Rate, Date_Bits, Stop_Bits, Parity);

  362. 		if (Handle_Com == INVALID_HANDLE_VALUE)

  363. 		{

  364. 			cout << "初始化串口失败,请重新输入设备信息\n" << endl;

  365. 		}

  366. 		else

  367. 		{

  368. 			printf("初始化串口成功\n");

  369. 			break;

  370. 		}

  371. 	}

  372. 	return Handle_Com;

  373. }

  374. 

  375. int Modbus_RTU_Salve(void)

  376. {

  377. 	UINT8 Requst_Message[MAX_NUMBER];

  378. 	UINT8 Response_Message[MAX_NUMBER];

  379. 	HANDLE Handle_Com = Input_Parameter();

  380. 	Init_Coil_Register();

  381. 	DWORD Read_len;

  382. 	int Count = 0;

  383. 	while (true)

  384. 	{

  385. 		PurgeComm(Handle_Com, PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR | PURGE_TXABORT);//清除缓存

  386. 		BOOL Read_flage = ReadFile(Handle_Com, Requst_Message, 300, &Read_len, NULL); //阻塞等待接收请求报文

  387. 		if (Read_flage && (Read_len > 0))

  388. 		{

  389. 			if (Create_Response_Message(Requst_Message, Response_Message, Read_len))

  390. 			{

  391. 				while (!SendData(Handle_Com, (char*)Response_Message, Response_Message_Len))

  392. 				{

  393. 					Count++;

  394. 					printf("发送失败,重新发送第%d次\n",Count);

  395. 					if (Count > 4)

  396. 					{

  397. 						break;

  398. 					}

  399. 				}

  400. 				printf("主站请求 ：");

  401. 				for (unsigned int i = 0; i < Read_len; i++)

  402. 				{

  403. 					printf("%02x  ", Requst_Message[i]);

  404. 				}

  405. 				printf("\n");

  406. 				printf("从站响应 ：");

  407. 				for (unsigned int i = 0; i < Response_Message_Len; i++)

  408. 				{

  409. 					printf("%02x  ", Response_Message[i]);

  410. 				}

  411. 				printf("\n\n");

  412. 				//Log_Note(Requst_Message, 0, Read_len);

  413. 				//Log_Note(Response_Message, 1, Response_Message_Len);

  414. 			}

  415. 			else

  416. 				continue;

  417. 		}

  418. 		else

  419. 		{

  420. 			printf("设备端口异常,请检查设备连接状态\n");

  421. 			printf("**************************** Press Enter To Contioun ****************************\n");

  422. 			getchar();

  423. 			system("cls");

  424. 			printf("是否重新连接端口： 1 重新连接  0 关闭本软件\n");

  425. 			int a = 0 ;

  426. 			do

  427. 			{

  428. 				cin >> a;

  429. 				cin.clear();

  430. 				cin.sync();

  431. 			} while (!(a == 0 || a == 1));

  432. 			if (a == 1)

  433. 			{

  434. 				CloseHandle(Handle_Com);

  435. 			}

  436. 			else

  437. 				break;

  438. 

  439. 			Handle_Com = Input_Parameter();

  440. 		}

  441. 	}

  442. 	CloseHandle(Handle_Com);

  443. 	getchar();

  444. 	return 0;

  445. }