WalkingAxisBaseDevice.cs 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316
  1. using Aitex.Core.RT.Device;
  2. using Aitex.Core.RT.Event;
  3. using Aitex.Core.RT.Fsm;
  4. using Aitex.Core.RT.DataCenter;
  5. using System;
  6. using System.Collections.Generic;
  7. using System.Linq;
  8. using System.Text;
  9. using System.Threading.Tasks;
  10. using Aitex.Core.RT.OperationCenter;
  11. using MECF.Framework.Common.Event;
  12. using Aitex.Core.RT.SCCore;
  13. using MECF.Framework.Common.Equipment;
  14. namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.WalkingAixs
  15. {
  16. public abstract class WalkingAxisBaseDevice : Entity, IDevice
  17. {
  18. public bool IsBusy { get; protected set; }
  19. protected DateTime _dtActionStart;
  20. public bool IsAllowedToMove { get; set; } = true;
  21. protected WalkingAxisBaseDevice(string module, string name)
  22. : base()
  23. {
  24. Module = module;
  25. Name = name;
  26. InitializeMotion();
  27. }
  28. private void InitializeMotion()
  29. {
  30. BuildTransitionTable();
  31. SubscribeDataVariable();
  32. SubscribeOperation();
  33. Running = true;
  34. }
  35. public event Action<string, AlarmEventItem> OnDeviceAlarmStateChanged;
  36. public bool HasAlarm { get; }
  37. public string Module { get; set; }
  38. public string Name { get; set ; }
  39. public WalkingAxisState DeviceState { get => (WalkingAxisState)fsm.State; }
  40. public abstract int GetCurrentStation();
  41. public virtual bool IsArrivedTarget
  42. {
  43. get { return (TargetStation == GetCurrentStation()); }
  44. }
  45. public int TargetStation { get; set; }
  46. public abstract void Monitor();
  47. public virtual int TimeLimitHome
  48. {
  49. get
  50. {
  51. if (SC.ContainsItem($"WalkingAxis.{Name}.HomeTimeout"))
  52. return SC.GetValue<int>($"WalkingAxis.{Name}.HomeTimeout");
  53. return 180;
  54. }
  55. }
  56. public virtual int TimeLimitMove
  57. {
  58. get
  59. {
  60. if (SC.ContainsItem($"WalkingAxis.{Name}.MoveTimeout"))
  61. return SC.GetValue<int>($"WalkingAxis.{Name}.MoveTimeout");
  62. return 60;
  63. }
  64. }
  65. public void Reset()
  66. {
  67. }
  68. public enum WalkingAxisMsg
  69. {
  70. Reset,
  71. Init,
  72. StartMove,
  73. Stop,
  74. Error,
  75. ActionDone,
  76. }
  77. public enum WalkingAxisState
  78. {
  79. Init,
  80. Initializing,
  81. Idle,
  82. Moving,
  83. ERROR,
  84. Stopped,
  85. Busy,
  86. Resetting,
  87. }
  88. private void BuildTransitionTable()
  89. {
  90. fsm = new StateMachine<WalkingAxisBaseDevice>(Module + Name + ".StateMachine", (int)WalkingAxisState.Init, 5);
  91. AnyStateTransition(WalkingAxisMsg.Error, fError, WalkingAxisState.ERROR);
  92. AnyStateTransition(WalkingAxisMsg.Stop, fStop, WalkingAxisState.Stopped);
  93. Transition(WalkingAxisState.Init, WalkingAxisMsg.Init, fStartInit, WalkingAxisState.Initializing);
  94. Transition(WalkingAxisState.Initializing, FSM_MSG.TIMER, fMonitorInit, WalkingAxisState.Idle);
  95. Transition(WalkingAxisState.Initializing, WalkingAxisMsg.ActionDone, fInitComplete, WalkingAxisState.Idle);
  96. Transition(WalkingAxisState.Idle, WalkingAxisMsg.Init, fStartInit, WalkingAxisState.Initializing);
  97. Transition(WalkingAxisState.Idle, WalkingAxisMsg.StartMove, fStartMove, WalkingAxisState.Moving);
  98. Transition(WalkingAxisState.Moving, FSM_MSG.TIMER, fMonitorMove, WalkingAxisState.Idle);
  99. Transition(WalkingAxisState.Moving, WalkingAxisMsg.ActionDone, fMoveComplete, WalkingAxisState.Idle);
  100. Transition(WalkingAxisState.ERROR, WalkingAxisMsg.Reset, fStartReset, WalkingAxisState.Resetting);
  101. Transition(WalkingAxisState.Stopped, WalkingAxisMsg.Reset, fStartReset, WalkingAxisState.Resetting);
  102. Transition(WalkingAxisState.Idle, WalkingAxisMsg.Reset, fStartReset, WalkingAxisState.Resetting);
  103. Transition(WalkingAxisState.Init, WalkingAxisMsg.Reset, fStartReset, WalkingAxisState.Resetting);
  104. Transition(WalkingAxisState.Resetting, FSM_MSG.TIMER, fMonitorResetting, WalkingAxisState.Idle);
  105. }
  106. protected virtual bool fMonitorResetting(object[] param)
  107. {
  108. return true;
  109. }
  110. public virtual bool IsReady()
  111. {
  112. return ((!IsBusy) && (DeviceState == WalkingAxisState.Idle));
  113. }
  114. private void SubscribeDataVariable()
  115. {
  116. DATA.Subscribe($"{Module}.{Name}.State", () => DeviceState.ToString());
  117. }
  118. private void SubscribeOperation()
  119. {
  120. OP.Subscribe($"{Module}.{Name}.Home", (string cmd, object[] param) =>
  121. {
  122. string reason = "";
  123. if (!Home(null))
  124. {
  125. EV.PostWarningLog(Module, $"{Name} can not home, {reason}");
  126. return false;
  127. }
  128. EV.PostInfoLog(Module, $"{Name} home");
  129. return true;
  130. });
  131. OP.Subscribe($"{Module}.{Name}.Reset", (string cmd, object[] param) =>
  132. {
  133. string reason = "";
  134. if (!Reset(null))
  135. {
  136. EV.PostWarningLog(Module, $"{Name} can not clear alarm, {reason}");
  137. return false;
  138. }
  139. EV.PostInfoLog(Module, $"{Name} reset alarm");
  140. return true;
  141. });
  142. OP.Subscribe($"{Module}.{Name}.MoveTo", (string cmd, object[] param) =>
  143. {
  144. string reason = "";
  145. if (!MoveTo(param))
  146. {
  147. EV.PostWarningLog(Module, $"{Name} can not move to {param[0].ToString()}, {reason}");
  148. return false;
  149. }
  150. EV.PostInfoLog(Module, $"{Name} move to {param[0]}");
  151. return true;
  152. });
  153. OP.Subscribe($"{Module}.{Name}.Stop", (string cmd, object[] param) =>
  154. {
  155. string reason = "";
  156. if (!Stop(null))
  157. {
  158. EV.PostWarningLog(Module, $"{Name} can not Stop, {reason}");
  159. return false;
  160. }
  161. EV.PostInfoLog(Module, $"{Name} Stop");
  162. return true;
  163. });
  164. }
  165. protected virtual bool fStop(object[] param)
  166. {
  167. IsBusy = false;
  168. return true;
  169. }
  170. protected abstract bool fStartReset(object[] param);
  171. protected abstract bool fMonitorMove(object[] param);
  172. protected abstract bool fStartMove(object[] param);
  173. protected abstract bool fMonitorInit(object[] param);
  174. protected abstract bool fStartInit(object[] param);
  175. protected virtual bool fError(object[] param)
  176. {
  177. return true;
  178. }
  179. protected virtual bool fInitComplete(object[] param)
  180. {
  181. IsBusy = false;
  182. return true;
  183. }
  184. protected virtual bool fMoveComplete(object[] param)
  185. {
  186. IsBusy = false;
  187. return true;
  188. }
  189. public virtual bool Home(object[] param)
  190. {
  191. IsBusy = true;
  192. return CheckToPostMessage((int)WalkingAxisMsg.Init, param);
  193. }
  194. public virtual bool MoveTo(object[] param)
  195. {
  196. int temp;
  197. if (int.TryParse(param[0].ToString(), out temp))
  198. {
  199. TargetStation = temp;
  200. IsBusy = true;
  201. return CheckToPostMessage((int)WalkingAxisMsg.StartMove, new object[] { temp});
  202. }
  203. return false;
  204. }
  205. public virtual bool MoveTo(ModuleName module)
  206. {
  207. int temp;
  208. if (!SC.ContainsItem($"WalkingAxis.{Name}.{module}StationIndex")) return false;
  209. temp = SC.GetValue<int>($"WalkingAxis.{Name}.{module}StationIndex");
  210. TargetStation = temp;
  211. IsBusy = true;
  212. return CheckToPostMessage((int)WalkingAxisMsg.StartMove, new object[] { temp });
  213. }
  214. public virtual int GetStationIndex(ModuleName module)
  215. {
  216. if (!SC.ContainsItem($"WalkingAxis.{Name}.{module}StationIndex")) return 0;
  217. return SC.GetValue<int>($"WalkingAxis.{Name}.{module}StationIndex");
  218. }
  219. public virtual bool Reset(object[] param)
  220. {
  221. IsBusy = false;
  222. return CheckToPostMessage((int)WalkingAxisMsg.Reset, param);
  223. }
  224. public virtual bool Stop(object[] param)
  225. {
  226. IsBusy = true;
  227. return CheckToPostMessage((int)WalkingAxisMsg.Stop, param);
  228. }
  229. public virtual bool OnActionDone(object[] param)
  230. {
  231. IsBusy = false;
  232. return CheckToPostMessage((int)WalkingAxisMsg.ActionDone, param);
  233. }
  234. public virtual bool OnError(object[] param)
  235. {
  236. return CheckToPostMessage((int)WalkingAxisMsg.Error, param);
  237. }
  238. public virtual bool OnError(string msg)
  239. {
  240. EV.PostAlarmLog("WalkingAxis", $"{Name} occurred error:{msg}.");
  241. return CheckToPostMessage((int)WalkingAxisMsg.Error, null);
  242. }
  243. public bool CheckToPostMessage(int msg, params object[] args)
  244. {
  245. if (!fsm.FindTransition(fsm.State, msg))
  246. {
  247. EV.PostWarningLog(Name, $"{Name} is in { (WalkingAxisState)fsm.State} state,can not do {(WalkingAxisMsg)msg}");
  248. return false;
  249. }
  250. fsm.PostMsg(msg, args);
  251. return true;
  252. }
  253. public bool Check(int msg, out string reason, params object[] args)
  254. {
  255. if (!fsm.FindTransition(fsm.State, msg))
  256. {
  257. reason = String.Format("{0} is in {1} state,can not do {2}", Name, (WalkingAxisState)fsm.State, (WalkingAxisMsg)msg);
  258. return false;
  259. }
  260. reason = "";
  261. return true;
  262. }
  263. }
  264. }