MCProtocolPlc.cs 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Linq;
  5. using System.Runtime.InteropServices;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8. using System.Xml;
  9. using Aitex.Core.RT.Log;
  10. using Aitex.Core.Util;
  11. using MECF.Framework.Common.Communications;
  12. namespace MECF.Framework.RT.Core.IoProviders
  13. {
  14. public class MCProtocolPlc : IoProvider,IConnection
  15. {
  16. public string Address
  17. {
  18. get { return $"{_ip}:{_port}"; }
  19. }
  20. public bool IsConnected
  21. {
  22. get { return IsOpened; }
  23. }
  24. public bool Connect()
  25. {
  26. return true;
  27. }
  28. public bool Disconnect()
  29. {
  30. return true;
  31. }
  32. private string _ip = "127.0.0.1";
  33. private string _localIp = "127.0.0.1";
  34. private int _port = 6731;
  35. private int _socketId = 101;
  36. private int _stationId = 102;
  37. private byte[] _bufferIn;
  38. private byte[] _bufferOut;
  39. private MCProtocol.MC_COMMAND_HEADER _header;
  40. //private MCProtocol.MC_RESPONSE_HEADER _response;
  41. private MCProtocol.MC_BATCH_COMMAND _batchCommand;
  42. private MCSocket _socket;
  43. protected override void SetParameter(XmlElement nodeParameter)
  44. {
  45. string strIp = nodeParameter.GetAttribute("ip");
  46. string strPort = nodeParameter.GetAttribute("port");
  47. string networkId = nodeParameter.GetAttribute("network_id");
  48. string stationId = nodeParameter.GetAttribute("station_id");
  49. _port = int.Parse(strPort);
  50. _ip = strIp;
  51. _socketId = int.Parse(networkId);
  52. _stationId = int.Parse(stationId);
  53. ConnectionManager.Instance.Subscribe(Name, this);
  54. }
  55. public override void Open()
  56. {
  57. _socket = new MCSocket();
  58. _header = new MCProtocol.MC_COMMAND_HEADER()
  59. {
  60. ProtocolID = MCProtocol.MC_SUBHEADER_COMMAND_MESSAGE,
  61. NetworkID = (byte)_socketId,
  62. StationID = (byte)_stationId,
  63. RequestIONumber = MCProtocol.MC_REQUEST_MODULE_IO_NUMBER,
  64. RequestStationNumber = MCProtocol.MC_REQUEST_MODULE_STATION_NUMBER,
  65. RequestDataLen = 0,
  66. CPUMonitorTimer = (ushort)(MCProtocol.MC_CPU_MONITOR_TIMER * 2),
  67. };
  68. _batchCommand = new MCProtocol.MC_BATCH_COMMAND()
  69. {
  70. Command = MCProtocol.MC_COMMAND_BATCH_READ,
  71. DeviceCode = MCProtocol.MC_DEVICE_CODE_DATA_REGISTER_WORD,
  72. DevicePoints = 0,
  73. HeadAddr = 0,
  74. Reserved = 0,
  75. SubCommand = MCProtocol.MC_SUBCOMMAND_WORD_UNITS,
  76. };
  77. _bufferOut = new byte[2048];
  78. _bufferIn = new byte[2048];
  79. _socket.Open(_ip, _port, _localIp);
  80. SetState(IoProviderStateEnum.Opened);
  81. }
  82. protected override void Close()
  83. {
  84. _socket.Close();
  85. SetState(IoProviderStateEnum.Closed);
  86. }
  87. Random _rd = new Random();
  88. protected override bool[] ReadDi(int offset, int size)
  89. {
  90. if (!_socket.Connected)
  91. {
  92. return new bool[640];
  93. }
  94. _batchCommand.Command = MCProtocol.MC_COMMAND_BATCH_READ;
  95. _batchCommand.SubCommand = MCProtocol.MC_SUBCOMMAND_BIT_UNITS;
  96. _batchCommand.HeadAddr = (ushort)(offset & 0xFFFF);
  97. _batchCommand.Reserved = (byte)(offset >> 16);
  98. _batchCommand.DevicePoints = (ushort)size;
  99. _header.RequestDataLen = (ushort)(MCProtocol.MC_BATCH_COMMAND_SIZE + MCProtocol.JUNK_SIZE);
  100. byte[] buffer = MCProtocol.Struct2Bytes(_header);
  101. byte[] command = MCProtocol.Struct2Bytes(_batchCommand);
  102. Array.Copy(buffer, 0, _bufferOut, 0, buffer.Length);
  103. Array.Copy(command, 0, _bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE, command.Length);
  104. if (!WriteData(_bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE + MCProtocol.MC_BATCH_COMMAND_SIZE))
  105. {
  106. return null;
  107. }
  108. if (!ReceiveData(_bufferIn, MCProtocol.MC_QHEADER_RESPONSE_SIZE))
  109. {
  110. return null;
  111. }
  112. MCProtocol.MC_RESPONSE_HEADER responseHeader =
  113. MCProtocol.ToStruct<MCProtocol.MC_RESPONSE_HEADER>(_bufferIn);
  114. if (responseHeader.CompleteCode != MCProtocol.MC_COMPLETE_CODE_SUCCESS)
  115. {
  116. return null;
  117. }
  118. int dataLength = responseHeader.ResponseDataLen - MCProtocol.JUNK_SIZE;
  119. if (!ReceiveData(_bufferIn, dataLength))
  120. {
  121. return null;
  122. }
  123. byte[] result = new byte[dataLength * 2];
  124. for (int i = 0; i < dataLength; i++)
  125. {
  126. if ((_bufferIn[i] & 0x10) == 0x10)
  127. {
  128. result[i * 2 + 0] = 0x01;
  129. }
  130. if ((_bufferIn[i] & 0x01) == 0x01)
  131. {
  132. result[i * 2 + 1] = 0x01;
  133. }
  134. }
  135. return result.Select(x => x == 0x01).Take(size).ToArray();
  136. }
  137. protected override short[] ReadAi(int offset, int size)
  138. {
  139. _batchCommand.Command = MCProtocol.MC_COMMAND_BATCH_READ;
  140. _batchCommand.SubCommand = MCProtocol.MC_SUBCOMMAND_WORD_UNITS;
  141. _batchCommand.HeadAddr = (ushort)(offset & 0xFFFF);
  142. _batchCommand.Reserved = (byte)(offset >> 16);
  143. _batchCommand.DevicePoints = (ushort)size;
  144. _header.RequestDataLen = (ushort)(MCProtocol.MC_BATCH_COMMAND_SIZE + MCProtocol.JUNK_SIZE);
  145. byte[] buffer = MCProtocol.Struct2Bytes(_header);
  146. byte[] command = MCProtocol.Struct2Bytes(_batchCommand);
  147. Array.Copy(buffer, 0, _bufferOut, 0, buffer.Length);
  148. Array.Copy(command, 0, _bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE, command.Length);
  149. if (!WriteData(_bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE + MCProtocol.MC_BATCH_COMMAND_SIZE))
  150. {
  151. return null;
  152. }
  153. if (!ReceiveData(_bufferIn, MCProtocol.MC_QHEADER_RESPONSE_SIZE))
  154. {
  155. return null;
  156. }
  157. MCProtocol.MC_RESPONSE_HEADER responseHeader =
  158. MCProtocol.ToStruct<MCProtocol.MC_RESPONSE_HEADER>(_bufferIn);
  159. if (responseHeader.CompleteCode != MCProtocol.MC_COMPLETE_CODE_SUCCESS)
  160. {
  161. return null;
  162. }
  163. int dataLength = responseHeader.ResponseDataLen - MCProtocol.JUNK_SIZE;
  164. if (!ReceiveData(_bufferIn, dataLength))
  165. {
  166. return null;
  167. }
  168. int sizeofT1 = Marshal.SizeOf(typeof(byte));
  169. int sizeofT2 = Marshal.SizeOf(typeof(ushort));
  170. short[] result = new short[sizeofT1 * 2 / sizeofT2];
  171. for (int i = 0; i < result.Length; i++)
  172. {
  173. result[i] = (short)BitConverter.ToUInt16(_bufferIn, offset + i * 2);
  174. }
  175. return Array.ConvertAll(MCProtocol.Byte2Ushort(_bufferIn, offset, dataLength), x => (short)x);
  176. }
  177. protected override void WriteDo(int offset, bool[] data)
  178. {
  179. if (!_socket.Connected)
  180. {
  181. return;
  182. }
  183. // bool[] boolData = new bool[data.Length];
  184. // boolData = data.Select(x => x==(byte)1).ToArray();
  185. // WriteDo(offset, boolData);
  186. //}
  187. {
  188. bool doN2 = data[10];
  189. if(doN2 == false)
  190. {
  191. //Console.WriteLine($"DO_N2 = {doN2}");
  192. }
  193. }
  194. //protected void WriteDo(int offset, bool[] data)
  195. //{
  196. _batchCommand.Command = MCProtocol.MC_COMMAND_BATCH_WRITE;
  197. _batchCommand.SubCommand = MCProtocol.MC_SUBCOMMAND_BIT_UNITS;
  198. byte[] byteData = MCProtocol.TransBoolArrayToByteData(data);
  199. _batchCommand.HeadAddr = (ushort)(offset & 0xFFFF);
  200. _batchCommand.Reserved = (byte)(offset >> 16);
  201. _batchCommand.DevicePoints = (ushort)data.Length;
  202. _header.RequestDataLen = (ushort)(MCProtocol.MC_BATCH_COMMAND_SIZE + MCProtocol.JUNK_SIZE + byteData.Length);
  203. byte[] header = MCProtocol.Struct2Bytes(_header);
  204. byte[] command = MCProtocol.Struct2Bytes(_batchCommand);
  205. Array.Copy(header, 0, _bufferOut, 0, header.Length);
  206. Array.Copy(command, 0, _bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE, command.Length);
  207. Array.Copy(byteData, 0, _bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE + MCProtocol.MC_BATCH_COMMAND_SIZE, byteData.Length);
  208. if (!WriteData(_bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE + MCProtocol.MC_BATCH_COMMAND_SIZE + byteData.Length))
  209. {
  210. return;
  211. }
  212. if (!ReceiveData(_bufferIn, MCProtocol.MC_QHEADER_RESPONSE_SIZE))
  213. {
  214. return;
  215. }
  216. MCProtocol.MC_RESPONSE_HEADER responseHeader =
  217. MCProtocol.ToStruct<MCProtocol.MC_RESPONSE_HEADER>(_bufferIn);
  218. if (responseHeader.CompleteCode != MCProtocol.MC_COMPLETE_CODE_SUCCESS)
  219. {
  220. //LOG.Write("Write PLC failed with code," + responseHeader.CompleteCode);
  221. return;
  222. }
  223. int dataLength = responseHeader.ResponseDataLen - MCProtocol.JUNK_SIZE;
  224. if (dataLength > 0 && !ReceiveData(_bufferIn, dataLength))
  225. {
  226. return;
  227. }
  228. }
  229. protected override void WriteAo(int offset, short[] data)
  230. {
  231. if (!_socket.Connected)
  232. {
  233. return;
  234. }
  235. ushort[] uData = new ushort[data.Length];
  236. uData = data.Select(x => (ushort)x).ToArray();
  237. WriteAo(offset, uData);
  238. }
  239. protected void WriteAo(int offset, ushort[] data)
  240. {
  241. _batchCommand.Command = MCProtocol.MC_COMMAND_BATCH_WRITE;
  242. _batchCommand.SubCommand = MCProtocol.MC_SUBCOMMAND_WORD_UNITS;
  243. _batchCommand.HeadAddr = (ushort)(offset & 0xFFFF);
  244. _batchCommand.Reserved = (byte)(offset >> 16);
  245. _batchCommand.DevicePoints = (ushort)data.Length;
  246. _header.RequestDataLen = (ushort)(MCProtocol.MC_BATCH_COMMAND_SIZE + MCProtocol.JUNK_SIZE + MCProtocol.ShortSize * data.Length);
  247. byte[] header = MCProtocol.Struct2Bytes(_header);
  248. byte[] command = MCProtocol.Struct2Bytes(_batchCommand);
  249. byte[] byteData = MCProtocol.Ushort2Byte(data);
  250. Array.Copy(header, 0, _bufferOut, 0, header.Length);
  251. Array.Copy(command, 0, _bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE, command.Length);
  252. Array.Copy(byteData, 0, _bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE + MCProtocol.MC_BATCH_COMMAND_SIZE, byteData.Length);
  253. if (!WriteData(_bufferOut, MCProtocol.MC_QHEADER_COMMAND_SIZE + MCProtocol.MC_BATCH_COMMAND_SIZE + MCProtocol.ShortSize * data.Length))
  254. {
  255. return;
  256. }
  257. if (!ReceiveData(_bufferIn, MCProtocol.MC_QHEADER_RESPONSE_SIZE))
  258. {
  259. return;
  260. }
  261. MCProtocol.MC_RESPONSE_HEADER responseHeader =
  262. MCProtocol.ToStruct<MCProtocol.MC_RESPONSE_HEADER>(_bufferIn);
  263. if (responseHeader.CompleteCode != MCProtocol.MC_COMPLETE_CODE_SUCCESS)
  264. {
  265. //LOG.Write("Write PLC failed with code," + responseHeader.CompleteCode);
  266. return;
  267. }
  268. int dataLength = responseHeader.ResponseDataLen - MCProtocol.JUNK_SIZE;
  269. if (dataLength > 0 && !ReceiveData(_bufferIn, dataLength))
  270. {
  271. return;
  272. }
  273. }
  274. private bool WriteData(byte[] data, int length)
  275. {
  276. if (!_socket.Connected)
  277. {
  278. return false;
  279. }
  280. return _socket.Write(data, length);
  281. }
  282. private bool ReceiveData(byte[] data, int length)
  283. {
  284. if (!_socket.Connected)
  285. {
  286. return false;
  287. }
  288. return _socket.Read(data, length);
  289. }
  290. }
  291. }