PendulumValve.cs 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using Venus_RT.Modules;
  5. using MECF.Framework.Common.Communications;
  6. using MECF.Framework.Common.Equipment;
  7. using Venus_Core;
  8. using Aitex.Core.RT.SCCore;
  9. using Aitex.Core.RT.Event;
  10. using Aitex.Core.RT.Device;
  11. using Aitex.Core.RT.Log;
  12. namespace Venus_RT.Devices
  13. {
  14. class PendulumValve : IDevice
  15. {
  16. public enum Operation
  17. {
  18. SetPosition,
  19. GetPositionSP,
  20. Hold,
  21. OpenValve,
  22. CloseValve,
  23. SetPressure,
  24. GetPressureSP,
  25. GetAssembly,
  26. GetPosition,
  27. GetPressure,
  28. GetSensor1Data,
  29. GetSensor2Data,
  30. GetPressureCtrlStatus,
  31. GetDeviceStatus,
  32. GetWarnings,
  33. GetSensorOffset,
  34. GetSensor1Offset,
  35. GetSensor2Offset,
  36. GetLearnStatus,
  37. GetLearnPressureLimit,
  38. GetErrorStatus,
  39. GetFatalErrorStatus,
  40. GetThrottleCycleCounter,
  41. GetIsolationCycleCounter,
  42. GetPowerUpCounter,
  43. GetHardwareConfiguration,
  44. GetFirmwareConfiguration,
  45. GetIdentification,
  46. SetAccessMode,
  47. SetInterfaceConfiguration,
  48. SetValveConfiguration,
  49. SetSensorConfiguration,
  50. SetRangeConfiguration,
  51. SetZero,
  52. SetPressureAlignment,
  53. SetLearn,
  54. DownloadLearnData,
  55. UploadLearnData,
  56. SetPIDConfiguration,
  57. GetPIDConfiguration,
  58. SetValveSpeed,
  59. GetValveSpeed,
  60. Reset,
  61. Invalid,
  62. }
  63. private readonly Dictionary<Operation, string> _noneParaCommandOp = new Dictionary<Operation, string>
  64. {
  65. {Operation.GetPositionSP, "i:38" },
  66. {Operation.Hold, "H:" },
  67. {Operation.CloseValve, "C:" },
  68. {Operation.OpenValve, "O:" },
  69. {Operation.GetPressureSP, "i:38" },
  70. {Operation.GetAssembly, "i:76" },
  71. {Operation.GetPosition, "A:" },
  72. {Operation.GetPressure, "P:" },
  73. {Operation.GetSensor1Data, "i:64" },
  74. {Operation.GetSensor2Data, "i:65" },
  75. {Operation.GetPressureCtrlStatus, "i:36" },
  76. {Operation.GetDeviceStatus, "i:30" },
  77. {Operation.GetWarnings, "i:35" },
  78. {Operation.GetSensorOffset, "i:62" },
  79. {Operation.GetSensor1Offset, "i:60" },
  80. {Operation.GetSensor2Offset, "i:61" },
  81. {Operation.GetLearnStatus, "i:32" },
  82. {Operation.GetLearnPressureLimit, "i:34" },
  83. {Operation.GetErrorStatus, "i:52" },
  84. {Operation.GetFatalErrorStatus, "i:50" },
  85. {Operation.GetThrottleCycleCounter, "i:70" },
  86. {Operation.GetIsolationCycleCounter, "i:71" },
  87. {Operation.GetPowerUpCounter, "i:72" },
  88. {Operation.GetHardwareConfiguration, "i:80" },
  89. {Operation.GetFirmwareConfiguration, "i:82" },
  90. {Operation.GetIdentification, "i:83" },
  91. };
  92. private readonly Dictionary<Operation, string> _singleParaCommandOp = new Dictionary<Operation, string>
  93. {
  94. {Operation.SetPosition, "R:{0:D6}" },
  95. {Operation.SetPressure, "S:{0:D8}" },
  96. {Operation.SetAccessMode, "c:01{0:D2}" },
  97. {Operation.SetInterfaceConfiguration, "s:20{0:D8}" },
  98. {Operation.SetValveConfiguration, "s:04{0:D2}000000" },
  99. {Operation.SetSensorConfiguration, "s:01{0:D8}" },
  100. {Operation.SetRangeConfiguration, "s:21{0:D8}" },
  101. {Operation.SetPressureAlignment, "c:6002{0:D8}" },
  102. {Operation.SetLearn, "L:{0:D8}" },
  103. {Operation.UploadLearnData, "u:{0:D3}" },
  104. {Operation.SetPIDConfiguration, "s:02{0:D8}" },
  105. {Operation.SetValveSpeed, "V:00{0:D4}" }
  106. };
  107. private readonly Dictionary<Operation, string> _twoParaCommandOp = new Dictionary<Operation, string>
  108. {
  109. {Operation.DownloadLearnData, "d:{0:D3}{1:D8}" }
  110. };
  111. private readonly Dictionary<string, string> _deviceError = new Dictionary<string, string>
  112. {
  113. {"000001", "Parity error" },
  114. {"000002", "Input buffer overflow (to many characters) " },
  115. {"000003", "Framing error (data length, number of stop bits)" },
  116. {"000010", "<CR> or <LF> missing" },
  117. {"000011", ": missing" },
  118. {"000012", "Invalid number of characters (between : and [CR][LF])" },
  119. {"000020", "Unknown command" },
  120. {"000021", "Unknown command" },
  121. {"000022", "Invalid value" },
  122. {"000023", "Invalid value" },
  123. {"000030", "Value out of range" },
  124. {"000041", "Command not applicable for hardware configuration" },
  125. {"000060", "ZERO disabled" },
  126. {"000080", "Command not accepted due to local operation" },
  127. {"000082", "Command not accepted due to synchronization, CLOSED or OPEN by digital input, safety mode or fatal error" },
  128. };
  129. public string Module { get; set; }
  130. public string Name { get; set; }
  131. public int Pressure { get; private set; }
  132. public int Position { get; private set; }
  133. public string Status { get; private set; }
  134. public bool IsOpen { get; private set; }
  135. private readonly string EOF = "\r\n";
  136. private readonly int _readInterval = 1000;
  137. private readonly int _position_unit = 100;
  138. private readonly int _pressure_unit = 10;
  139. private int _queryFlag = 0;
  140. private readonly AsyncSerialPort _serial;
  141. private Stopwatch _queryWatch = new Stopwatch();
  142. private string _lastAlarmString = string.Empty;
  143. private Operation[] _querys = new Operation[] { Operation.GetPressure, Operation.GetPosition, Operation.GetDeviceStatus, Operation.GetPressureSP };
  144. public PendulumValve(ModuleName mod)
  145. {
  146. Name = VenusDevice.PendulumValve.ToString();
  147. Module = mod.ToString();
  148. var _PortNum = SC.GetStringValue($"{mod}.PendulumValve.Port");
  149. _serial = new AsyncSerialPort(_PortNum, 9600, 8, System.IO.Ports.Parity.None, System.IO.Ports.StopBits.One, EOF);
  150. IsOpen = false;
  151. }
  152. public bool Initialize()
  153. {
  154. if (!_serial.Open())
  155. {
  156. _noRepeatAlarm("Pendulum Valve 串口无法打开");
  157. return false;
  158. }
  159. _serial.OnDataChanged += OnPortDataChanged;
  160. _serial.OnErrorHappened += OnErrorOccurred;
  161. _queryWatch.Restart();
  162. return true;
  163. }
  164. public void Monitor()
  165. {
  166. if(_queryWatch.ElapsedMilliseconds > _readInterval)
  167. {
  168. SendCommand(_querys[_queryFlag++ % 4]);
  169. _queryWatch.Restart();
  170. }
  171. }
  172. public void Reset()
  173. {
  174. }
  175. public void Terminate()
  176. {
  177. _serial?.Close();
  178. }
  179. private void OnErrorOccurred(string obj)
  180. {
  181. _noRepeatAlarm($"[{Module}] VAT Pendulum Valve error: [{obj}]");
  182. }
  183. private void OnPortDataChanged(string obj)
  184. {
  185. if (string.IsNullOrEmpty(obj))
  186. {
  187. _noRepeatAlarm("VAT Pendulum Valve receive empty message");
  188. return;
  189. }
  190. try
  191. {
  192. var data = obj.TrimEnd().Split(':');
  193. switch(data[0])
  194. {
  195. case "P":
  196. {
  197. int pressure;
  198. if (int.TryParse(data[1], out pressure))
  199. Pressure = pressure / _pressure_unit;
  200. }
  201. break;
  202. case "A":
  203. {
  204. int position;
  205. if (int.TryParse(data[1], out position))
  206. Position = position / _position_unit;
  207. }
  208. break;
  209. case "i":
  210. {
  211. _tryParseInqueryData(obj);
  212. }
  213. break;
  214. case "C":
  215. case "O":
  216. case "H":
  217. case "R":
  218. case "S":
  219. break;
  220. case "E":
  221. {
  222. _noRepeatAlarm($"[{Module}] VAT Pendulum Valve device error: {_deviceError[data[1]]}");
  223. }
  224. break;
  225. default:
  226. {
  227. _noRepeatAlarm($"VAT Pendulum Valve: unrecognized received data: {obj}");
  228. break;
  229. }
  230. }
  231. }
  232. catch (Exception ex)
  233. {
  234. _noRepeatAlarm($"[{Module}] VAT Pendulum Valve error: [{ex.Message}], Data: {obj}");
  235. }
  236. }
  237. private bool SendCommand(Operation op)
  238. {
  239. if(_noneParaCommandOp.ContainsKey(op))
  240. {
  241. return _serial.Write(_noneParaCommandOp[op] + EOF);
  242. }
  243. else
  244. {
  245. return false;
  246. }
  247. }
  248. private bool SendCommand(Operation op, int data)
  249. {
  250. if(_singleParaCommandOp.ContainsKey(op))
  251. {
  252. var cmd = string.Format(_singleParaCommandOp[op], data) + EOF;
  253. return _sendCmd(cmd);
  254. }
  255. else
  256. {
  257. _noRepeatAlarm("This VAT Pendulum Valve command need 1 data");
  258. return false;
  259. }
  260. }
  261. private bool _sendCmd(string cmd)
  262. {
  263. return _serial.Write(cmd);
  264. }
  265. private void _noRepeatAlarm(string alarm)
  266. {
  267. if (_lastAlarmString != alarm)
  268. {
  269. _lastAlarmString = alarm;
  270. LOG.Write(eEvent.ERR_PENDULUM_VALVE, ModuleHelper.Converter(Module), alarm);
  271. EV.PostAlarmLog(Module, alarm);
  272. }
  273. }
  274. private bool _tryParseInqueryData(string data)
  275. {
  276. var cmdPrix = data.Substring(0, 4);
  277. Operation oper = Operation.Invalid;
  278. foreach( var item in _noneParaCommandOp)
  279. {
  280. if(item.Value == cmdPrix)
  281. {
  282. oper = item.Key;
  283. break;
  284. }
  285. }
  286. if( oper == Operation.Invalid)
  287. {
  288. return false;
  289. }
  290. switch(oper)
  291. {
  292. case Operation.GetDeviceStatus:
  293. {
  294. Status = data.Substring(4, 8);
  295. if(Status[1] == 'E')
  296. {
  297. // Fatal Error
  298. _noRepeatAlarm($"Device Status error:{Status}");
  299. }
  300. else if(Status[3] == '1')
  301. {
  302. // Warning Present
  303. _noRepeatAlarm($"Device Warning Present:{Status}");
  304. }
  305. }
  306. break;
  307. case Operation.GetPressureSP:
  308. case Operation.GetPositionSP:
  309. {
  310. string Pressure = data.Substring(4, 8);
  311. //LOG.Write(eEvent.EV_DEVICE_INFO, Module, $" PV Pressure SetPoint: {Pressure}");
  312. }
  313. break;
  314. default:
  315. break;
  316. }
  317. return true;
  318. }
  319. public bool SetPosition(int postion)
  320. {
  321. if(_CheckStatus())
  322. {
  323. IsOpen = postion > 0;
  324. return SendCommand(Operation.SetPosition, postion * _position_unit);
  325. }
  326. return false;
  327. }
  328. public bool SetPressure(int pressure)
  329. {
  330. if(_CheckStatus())
  331. {
  332. IsOpen = true;
  333. return SendCommand(Operation.SetPressure, pressure * _pressure_unit);
  334. }
  335. return false;
  336. }
  337. public bool Hold()
  338. {
  339. return SendCommand(Operation.Hold);
  340. }
  341. public bool TurnValve(bool on)
  342. {
  343. if(_CheckStatus(on))
  344. {
  345. IsOpen = on;
  346. return SendCommand(on ? Operation.OpenValve : Operation.CloseValve);
  347. }
  348. return false;
  349. }
  350. bool _CheckStatus(bool bTurnOn = false)
  351. {
  352. if (Status != null && Status[1] == 'E')
  353. {
  354. _noRepeatAlarm($"PendulumValve is error status, can do turn on/off operation.");
  355. return false;
  356. }
  357. var _chamber = DEVICE.GetDevice<JetPM>(Module);
  358. if (bTurnOn && !_chamber.IsTurboPumpAtSpeed)
  359. {
  360. _noRepeatAlarm($"Turbo Pump not at speed, can not turn on pendulum valve.");
  361. return false;
  362. }
  363. if (_chamber.ForelinePressure > 500)
  364. {
  365. LOG.Write(eEvent.WARN_DEVICE_INFO, Module, $"Foreline Pressure:{_chamber.ForelinePressure} is too high, can not turn on pendulum valve.");
  366. //_noRepeatAlarm($"Foreline Pressure:{_chamber.ForelinePressure} is too high, can not turn on pendulum valve.");
  367. return false;
  368. }
  369. return true;
  370. }
  371. }
  372. }