protected override QState ActiveTest_Running(IQEvent qEvent)
{
QState result = base.ActiveTest_Running(qEvent);
if (result == null)
{
return(null);
}
else
{
switch (qEvent.QSignal)
{
case (int)QFSignal.TestStep:
NextStep();
return(null);
// DESIGN NOTE: Wait for the associated ActiveTest to complete...
case (int)QFSignal.TestResult:
if (string.IsNullOrEmpty(((TestEvent)qEvent).Reason))
{
TransitionToPassed();
}
else
{
TransitionToFailed(((TestEvent)qEvent).Reason);
}
return(null);
}
return(result);
}
}
private QState DoOperand1(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("operand1");
return(null);
case (int)CalcSignals.ClearEntry:
Clear();
#if (STATIC_TRANS)
TransitionTo(Begin, s_TranIdx_Operand1_Begin);
#else
TransitionTo(Begin);
#endif
return(null);
case (int)CalcSignals.Operator:
this.myOperand1 = double.Parse(myDisplay);
myOperator = ((CalcEvent)qevent).KeyChar;
#if (STATIC_TRANS)
TransitionTo(OpEntered, s_TranIdx_Operand1_OpEntered);
#else
TransitionTo(OpEntered);
#endif
return(null);
}
return(Calculate);
}
private QState DoPolling(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
MainForm.Instance.SetTimer();
OnDisplayState("Polling");
return(null);
case (int)QSignals.Init:
InitializeState(Processing);
return(null);
case (int)ReminderSignals.TimerTick:
OnDisplayPoll(++myPollCtr);
if ((myPollCtr & frequency) == 0) //using Samek's C-style technique
{
this.Enqueue(new ReminderEvent(ReminderSignals.DataReady));
}
return(null);
case (int)ReminderSignals.Terminate:
TransitionTo(Final);
return(null);
case (int)QSignals.Exit:
MainForm.Instance.KillTimer();
return(null);
}
if (qevent.QSignal >= (int)QSignals.UserSig)
{
isHandled = false;
}
return(this.TopState);
}
protected void DoPolledEvent(IQEventManager eventManager, IQHsm hsm, IQEvent ev, PollContext pollContext)
{
if (OnPolledEvent (eventManager, hsm, ev, pollContext))
{
RaisePolledEvent (eventManager, PolledEvent, hsm, ev, pollContext);
}
}
protected void DoUnhandledTransition(IQHsm hsm, MethodInfo stateMethod, IQEvent qEvent)
{
if (OnUnhandledTransition (hsm, stateMethod, qEvent))
{
RaiseUnhandledTransition (UnhandledTransition, hsm, stateMethod, qEvent);
}
}
private QState DoZero2(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("zero2");
return(null);
case (int)CalcSignals.NonZeroDigit:
Insert(((CalcEvent)qevent).KeyChar);
#if (STATIC_TRANS)
TransitionTo(Int2, s_TranIdx_Zero2_Int2);
#else
TransitionTo(Int2);
#endif
return(null);
case (int)CalcSignals.DecimalPoint:
Insert(((CalcEvent)qevent).KeyChar);
#if (STATIC_TRANS)
TransitionTo(Frac2, s_TranIdx_Zero2_Frac2);
#else
TransitionTo(Frac2);
#endif
return(null);
}
return(Operand2);
}
private QState StateCheckGetputServerConnection(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob))
{
try
{
if (FISManager.Instance.IsFISConnected)
{
TransitionTo(stateISIDataProcess);
}
else
{
throw new Exception("Can't connect to data server, please check GetputServer program or check network connection!!");
}
}
catch (Exception ex)
{
ButtonList btnlst = new ButtonList(ErrorButton.Retry, ErrorButton.NoButton, ErrorButton.Abort);
TransitionToErrorState(btnlst, ex);
}
return(null);
}
return(stateRun);
}
public HsmEventHolder(QEventManagerBase eventManager, IQHsm hsm, IQEvent ev)
{
_EventManager = eventManager;
_Hsm = hsm;
_Event = ev;
_Principal = System.Threading.Thread.CurrentPrincipal;
}
protected QState Happy(IQEvent evt)
{
switch (evt.QSignal)
{
case (int)QSignals.Entry:
SomeAction(Actions.Smile);
return(null);
case (int)PersonSignals.Poke:
SomeAction(Actions.Laugh);
return(null);
case (int)PersonSignals.Noise:
TransitionTo(Elated);
return(null);
case (int)PersonSignals.Punch:
SomeAction(Actions.Scream);
TransitionTo(Sad);
return(null);
//It is not necessary to declare either
//the 'Entry' or 'Exit' cases...
//case (int)QSignals.Exit:
// return null;
}
return(Awake);
}
protected virtual QState ActiveTest_Running(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry:
return(null);
case (int)InternalSignal.TestStep:
Step((TestEvent)qEvent, 0);
return(null);
case (int)QFSignal.Timeout:
Timeout(qEvent);
return(null);
case (int)QFSignal.Error:
Error(qEvent);
return(null);
case (int)QFSignal.TestAbort:
TransitionToAborted((TestEvent)qEvent);
return(null);
case (int)QSignals.Exit:
return(null);
}
return(this.TopState);
}
protected virtual QState S_Sparking(IQEvent ev)
{
switch (ev.QSignal)
{
case QSignals.Entry: {
LogStateEvent(StateLogType.Entry, s_Sparking);
SetTimeOut("Sparking_t1_Spark", TimeSpan.FromSeconds(SparkFrequencyInterval()), new QEvent("Spark"), TimeOutType.Repeat);
SetTimeOut("Sparking_t0_StopSpinning", TimeSpan.FromSeconds(RandomSpinInterval()), new QEvent("StopSpinning"), TimeOutType.Single);
} return(null);
case QSignals.Exit: {
ClearTimeOut("Sparking_t1_Spark");
ClearTimeOut("Sparking_t0_StopSpinning");
LogStateEvent(StateLogType.Exit, s_Sparking);
} return(null);
case QualifiedFlintSignals.Spark: {
FuelMixture.Send(new QEvent(FuelMixtureSignals.Ignite));
LogStateEvent(StateLogType.EventTransition, s_Sparking, s_Sparking, "Spark", "t1-every SparkFrequencyInterval() raise Spark/^FuelMixture.Ignite()");
TransitionTo(s_Sparking, s_trans_t1_Spark_Sparking_2_Sparking);
return(null);
} // Spark
case QualifiedFlintSignals.StopSpinning: {
LogStateEvent(StateLogType.EventTransition, s_Sparking, s_NoSparks, "StopSpinning", "t0-after RandomSpinInterval() raise StopSpinning");
TransitionTo(s_NoSparks, s_trans_t0_StopSpinning_Sparking_2_NoSparks);
return(null);
} // StopSpinning
} // switch
return(TopState);
} // S_Sparking
protected virtual void Response(IQEvent qEvent)
{
IActor actor = (IActor)qEvent;
if (actor.Name == Test.Steps[CurrentStep].Actor.Name)
{
try
{
bool complete = false;
switch (actor.Type)
{
case ActorType.Port:
complete = PortResponse((PortEvent)qEvent);
break;
case ActorType.Process:
case ActorType.Prompt:
case ActorType.Recorder:
case ActorType.Log:
complete = true;
break;
}
if (complete)
{
CompleteStep();
}
}
catch (Exception ex)
{
TransitionToFailed(ex.Message);
}
}
}
protected void Timeout(IQEvent qEvent)
{
IActor actor = (IActor)qEvent;
switch (actor.Type)
{
case ActorType.Test:
if (actor.Name == Name)
{
TestTimeout((TestEvent)qEvent);
}
break;
case ActorType.Port:
if (actor.Name == Test.Steps[CurrentStep].Actor.Name)
{
PortTimeout((PortEvent)qEvent);
}
break;
case ActorType.Process:
if (actor.Name == Test.Steps[CurrentStep].Actor.Name)
{
ProcessTimeout((ProcessEvent)qEvent);
}
break;
}
}
protected void DoPolledEvent(IQEventManager eventManager, IQHsm hsm, IQEvent ev, PollContext pollContext)
{
if (OnPolledEvent(eventManager, hsm, ev, pollContext))
{
RaisePolledEvent(eventManager, PolledEvent, hsm, ev, pollContext);
}
}
protected QState Monitoring(IQEvent qEvent)
{
if (qEvent.IsSignal(SigStateJob))
{
if (RecallDeferredSignal(HSTWorkcell.SigRunTestScript))
{
UpdateSignalRecipient(HSTWorkcell.SigRunTestScript);
return(null);
}
return(null);
}
if (qEvent.IsSignal(HSTWorkcell.SigRunTestScript))
{
ResetAllVariables();
_commandLines = System.IO.File.ReadAllLines(HSTMachine.Workcell.HSTSettings.Install.TestScript);
CommandQueue = new Queue <string>();
for (int i = 0; i < _commandLines.Length; i++)
{
CommandQueue.Enqueue(_commandLines[i]);
}
ProcessNextCommand();
return(null);
}
return(base.TopState);
}
protected void DoEventManagerDispatchException(IQEventManager eventManager, Exception ex, IQHsm hsm, IQEvent ev)
{
if (OnEventManagerDispatchException (eventManager, ex, hsm, ev))
{
RaiseEventManagerDispatchException (EMDispatchException, eventManager, ex, hsm, ev);
}
}
protected void RaiseEventManagerDispatchException(EventManagerDispatchExceptionHandler handler, IQEventManager eventManager, Exception ex, IQHsm hsm, IQEvent ev)
{
if (handler != null)
{
handler (eventManager, ex, hsm, ev);
}
}
private QState StateSaveTDFDataFile(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob) || qEvent.IsSignal(_sigTimeout))
{
try
{
if (_workcell.HSTSettings.Install.EnabledTDFFileSystem || _workcell.HSTSettings.Install.EnabledSaveTDFFileOnly)
{
_controller.SaveTDFDataToLocalFile(_currentFolaTagInfo, _currentOutputRunCarrier);
}
TransitionTo(stateWaitForOutputCarrierComplete);
}
catch (Exception ex)
{
if (_retryCountSaveTDF < 2)
{
Thread.Sleep(200);
Log.Error(this, "Failed to get ISI data. Retry count: {0}, Exception: {1}, StateName: {2}", _retryCountSendSeatrack, ex.Message, this.CurrentStateName);
TransitionTo(stateSaveTDFDataFile);
}
else
{
ButtonList btnlst = new ButtonList(ErrorButton.Retry, ErrorButton.NoButton, ErrorButton.NoButton);
TransitionToErrorState(btnlst, ex);
}
_retryCountSaveTDF++;
}
return(null);
}
return(stateRun);
}
private void LogEvent(string stateName, IQEvent qEvent)
{
if (stateName == "Top")
{
Debug.WriteLine("Why Top?");
}
string message;
switch (qEvent.QSignal)
{
case (int)QSignals.Entry:
message = String.Format("{0} - Entering", stateName);
break;
case (int)QSignals.Exit:
message = String.Format("{0} - Exiting", stateName);
break;
case (int)QSignals.Init:
message = String.Format("{0} - Init", stateName);
break;
case (int)QSignals.Empty:
return;
default:
message = String.Format("{0} - Handling event {1}", stateName, qEvent.ToString());
break;
}
//Console.WriteLine(message);
Debug.WriteLine(message);
}
private QState Hungry(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry:
LogMessage(String.Format("Philosopher {0} is hungry.", m_PhilosopherId));
TableEvent tableEvent = new TableEvent(DPPSignal.Hungry, m_PhilosopherId);
LogMessage(String.Format("Philosopher {0} publishes Hungry event.", m_PhilosopherId));
QF.Instance.Publish(tableEvent);
return(null);
case (int)DPPSignal.Eat:
if (((TableEvent)qEvent).PhilosopherId == m_PhilosopherId)
{
LogMessage(String.Format("Philosopher {0} receives eat signal.", m_PhilosopherId));
TransitionTo(m_StateEating, ref s_Tran_Hungry_Eating);
}
return(null);
case (int)QSignals.Exit:
LogMessage(String.Format("Philosopher {0} is exiting hungry state.", m_PhilosopherId));
return(null);
}
return(this.TopState);
}
protected QState Asleep(IQEvent evt)
{
switch (evt.QSignal)
{
case (int)QSignals.Entry:
SomeAction(Actions.Snore);
return(null);
case (int)PersonSignals.Poke:
//This is called a "self-transition".
//It causes 'exit' and 'entry' to fire again.
TransitionTo(Asleep);
return(null);
case (int)PersonSignals.Punch:
SomeAction(Actions.Scream);
TransitionTo(Sad);
return(null);
case (int)PersonSignals.Tired:
Stop();
return(null);
case (int)PersonSignals.Noise:
CurrentState.DB += 20;
Console.WriteLine(" DB += 20");
if (CurrentState.DB >= 40)
{
TransitionTo(Awake);
}
return(null);
}
return(TopState);
}
protected override QState StateRunInit(IQEvent qEvent)
{
LogMessage("StateRunInit", qEvent);
if (HSTMachine.Workcell.HSTSettings.Install.EnableDebugLog && !qEvent.QSignal.ToString().Equals("Empty") && !qEvent.QSignal.ToString().Equals("Init") && !qEvent.QSignal.ToString().Equals("SigTimeout"))
{
Log.Info(this, "{0}, ProcessName:{1}, StateName:StateRunInit, QEvent:{2}, QSignal:{3}, Message: Initialization completed.", LoggerCategory.StateTransition, _processName, qEvent.ToString(), qEvent.QSignal.ToString());
}
LogMessage("StateRunInit", qEvent);
if (qEvent.IsSignal(QSignals.Entry))
{
_isStateInitialized = false;
ClearDeferredSignals();
}
// Initialization completed. Signal to stop state.
if (qEvent.IsSignal(QSignals.Exit))
{
if (!_workcell.Process.IsErrorState && !this._isErrorstate)
{
this.stateHistory = this.targetState;
ClearDeferredSignals();
_isStateInitialized = true;
}
}
return(stateProcess);
}
public static void Trace(MethodInfo info, IQEvent evt)
{
string sigName = null;
if (evt == null)
{
if (info != null)
{
Console.WriteLine("BEGIN TRANSITION to state '{0}'", info.Name);
}
else
{
Console.WriteLine("END TRANSITION");
}
}
else
{
if ((int)evt.QSignal < (int)QSignals.UserSig)
{
sigName = ((QSignals)evt.QSignal).ToString();
}
else
{
sigName = ((PersonSignals)evt.QSignal).ToString();
}
Console.WriteLine("Event '{0}' to state '{1}'", sigName, info.Name);
}
}
private QState StateCheckNextZoneReady(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob) || qEvent.IsSignal(_sigTimeout))
{
try
{
if (_controller.NextZoneReady())
{
TransitionTo(stateOutputTurnSectionReleaseCarrier);
}
else
{
//lai: reduce from 200 march12-2016
_qTimer.FireIn(new TimeSpan(0, 0, 0, 0, 150), new QEvent(_sigTimeout));
}
}
catch (Exception ex)
{
ButtonList btnlst = new ButtonList(ErrorButton.Retry, ErrorButton.Stop, ErrorButton.NoButton);
TransitionToErrorState(btnlst, ex);
}
return(null);
}
return(stateRun);
}
protected override QState StateStartup(IQEvent qEvent)
{
if (qEvent.IsSignal(SigInitialized))
{
}
return(base.StateStartup(qEvent));
}
protected bool IsSigStateJob(IQEvent qEvent, string state)
{
if (qEvent.IsSignal(SigStateJob))
{
EventParam evtParam = ((QEvent)qEvent).EventObject as EventParam;
if (evtParam == null)
{
return(false);
}
if (evtParam.Consumer == null)
{
return(false);
}
if (evtParam.Consumer == state)
{
return(true);
}
else
{
if (HSTMachine.Workcell.HSTSettings.Install.EnableDebugLog && !qEvent.QSignal.ToString().Equals("Empty") && !qEvent.QSignal.ToString().Equals("Init") && !qEvent.QSignal.ToString().Equals("SigTimeout"))
{
Log.Info(this, "{0}, ProcessName:{1}, StateName:In IsSigStateJob, Unable to consume signal {2}. Handler:{3}, Consumer:{4}", LoggerCategory.StateTransition, _processName, qEvent.QSignal.ToString(), state, evtParam.Consumer);
}
return(false);
}
}
else
{
return(false);
}
}
private QState StateRunInitCompleteMoveToParkPosition(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob))
{
try
{
if (!_workcell.IsIgnoreHomeAxisForByPass)
{
_controller.DoJobMoveZToPark(false, false);
}
if (HSTWorkcell.disableBoundaryCheck)
{
PublishSignal(new QEvent(HSTWorkcell.SigOutputEEBoundaryCheckComplete));
}
TransitionTo(stateWaitForPrecisorReadyForPick);
}
catch (Exception ex)
{
ButtonList btnlst = new ButtonList(ErrorButton.OK, ErrorButton.NoButton, ErrorButton.NoButton);
TransitionToErrorState(btnlst, ex);
}
return(null);
}
return(stateRunInit);
}
private QState StateWaitForOutputCarrierComplete(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob))
{
_retryCountSaveTDF = 0;
_retryCountSendSeatrack = 0;
if (RecallDeferredSignal(HSTWorkcell.SigOutputProcessDataComplete))
{
UpdateSignalRecipient(HSTWorkcell.SigOutputProcessDataComplete);
}
return(null);
}
if (qEvent.IsSignal(HSTWorkcell.SigOutputProcessDataComplete))
{
var outputData = (object[])(qEvent as QEvent).EventObject;
if (outputData != null)
{
_currentFolaTagInfo = (FolaTagData)outputData[0];
_currentOutputRunCarrier = (Carrier)outputData[1];
}
TransitionTo(stateSentSeatrackData);
return(null);
}
return(stateRun);
}
protected virtual QState S_TimeKeeping_Time(IQEvent ev)
{
switch (ev.QSignal)
{
case QSignals.Entry: {
LogStateEvent(StateLogType.Entry, s_TimeKeeping_Time);
_TimeKeeping_DeepHistory = s_TimeKeeping_Time;
SetTimeOut("TimeKeeping_Time_t0_TickEvt", TimeSpan.FromSeconds(1), new QEvent("TickEvt"), TimeOutType.Repeat);
} return(null);
case QSignals.Exit: {
ClearTimeOut("TimeKeeping_Time_t0_TickEvt");
LogStateEvent(StateLogType.Exit, s_TimeKeeping_Time);
} return(null);
case QualifiedSampleWatchSignals.ModeEvt: {
LogStateEvent(StateLogType.EventTransition, s_TimeKeeping_Time, s_TimeKeeping_Date, "ModeEvt", "ModeEvt");
TransitionTo(s_TimeKeeping_Date, s_trans_ModeEvt_TimeKeeping_Time_2_TimeKeeping_Date);
return(null);
} // ModeEvt
case QualifiedSampleWatchSignals.TickEvt: {
TickTime();
LogStateEvent(StateLogType.EventTransition, s_TimeKeeping_Time, s_TimeKeeping_Time, "TickEvt", "t0-every 1 raise TickEvt/TickTime()");
TransitionTo(s_TimeKeeping_Time, s_trans_t0_TickEvt_TimeKeeping_Time_2_TimeKeeping_Time);
return(null);
} // TickEvt
} // switch
return(s_TimeKeeping);
} // S_TimeKeeping_Time
public DispatchExceptionFailureEventArgs(Exception ex, IQHsm hsm, System.Reflection.MethodInfo stateMethod, IQEvent ev)
{
_Exception = ex;
_Hsm = hsm;
_StateMethod = stateMethod;
_OriginalEvent = ev;
}
protected virtual QState S_Setting_Minute(IQEvent ev)
{
switch (ev.QSignal)
{
case QSignals.Entry: {
LogStateEvent(StateLogType.Entry, s_Setting_Minute, "SetMinute()");
SetMinute();
} return(null);
case QSignals.Exit: {
LogStateEvent(StateLogType.Exit, s_Setting_Minute);
} return(null);
case QualifiedSampleWatchSignals.ModeEvt: {
IncrMinute();
LogStateEvent(StateLogType.EventTransition, s_Setting_Minute, s_Setting_Minute, "ModeEvt", "ModeEvt/IncrMinute()");
TransitionTo(s_Setting_Minute, s_trans_ModeEvt_Setting_Minute_2_Setting_Minute);
return(null);
} // ModeEvt
case QualifiedSampleWatchSignals.SetEvt: {
LogStateEvent(StateLogType.EventTransition, s_Setting_Minute, s_Setting_Day, "SetEvt", "SetEvt");
TransitionTo(s_Setting_Day, s_trans_SetEvt_Setting_Minute_2_Setting_Day);
return(null);
} // SetEvt
} // switch
return(s_Setting);
} // S_Setting_Minute
protected virtual QState S_TimeKeeping(IQEvent ev)
{
switch (ev.QSignal)
{
case QSignals.Init: {
LogStateEvent(StateLogType.Init, s_TimeKeeping, s_TimeKeeping_Time);
InitializeState(s_TimeKeeping_Time);
} return(null);
case QSignals.Entry: {
LogStateEvent(StateLogType.Entry, s_TimeKeeping);
_TimeKeeping_DeepHistory = s_TimeKeeping;
} return(null);
case QSignals.Exit: {
LogStateEvent(StateLogType.Exit, s_TimeKeeping);
} return(null);
case QualifiedSampleWatchSignals.SetEvt: {
LogStateEvent(StateLogType.EventTransition, s_TimeKeeping, s_Setting, "SetEvt", "SetEvt");
TransitionTo(s_Setting, s_trans_SetEvt_TimeKeeping_2_Setting);
return(null);
} // SetEvt
} // switch
return(TopState);
} // S_TimeKeeping
private QState StatePublishSigOutputCarrierPlaceDone(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob))
{
if (HSTMachine.Workcell.HSTSettings.Install.OperationMode == OperationMode.Bypass && HSTMachine.Workcell.HSTSettings.Install.BypassMeasurementTestAtTestProbe == true)
{
// Do nothing
}
else
{
_workcell.Process.OutputStationProcess.Controller.IncomingTestedCarrier = CommonFunctions.Instance.TestedCarrierQueue.First();
}
if (CheckDeferredSignal(HSTWorkcell.SigOutputCarrierReadyForPlace))
{
RemoveDeferredSignal(HSTWorkcell.SigOutputCarrierReadyForPlace);
}
_controller.PlaceHGAMoveUp();
PublishSignal(new QEvent(HSTWorkcell.SigOutputCarrierPlaceDone));
TransitionTo(stateWaitForPrecisorReadyForPick);
}
return(stateRun);
}
protected virtual QState S_Setting(IQEvent ev)
{
switch (ev.QSignal)
{
case QSignals.Init: {
LogStateEvent(StateLogType.Init, s_Setting, s_Setting_Hour);
InitializeState(s_Setting_Hour);
} return(null);
case QSignals.Entry: {
LogStateEvent(StateLogType.Entry, s_Setting, "Blink()");
Blink();
} return(null);
case QSignals.Exit: {
NoBlink();
LogStateEvent(StateLogType.Exit, s_Setting, "NoBlink()");
} return(null);
case QualifiedSampleWatchSignals.SetEvt: {
QState toState_TimeKeeping = _TimeKeeping_DeepHistory == null ? s_TimeKeeping : _TimeKeeping_DeepHistory;
LogStateEvent(StateLogType.EventTransition, s_Setting, toState_TimeKeeping, "SetEvt", "SetEvt");
TransitionTo(toState_TimeKeeping);
return(null);
} // SetEvt
} // switch
return(TopState);
} // S_Setting
public HsmEventHolder (QEventManagerBase eventManager, IQHsm hsm, IQEvent ev)
{
_EventManager = eventManager;
_Hsm = hsm;
_Event = ev;
_Principal = System.Threading.Thread.CurrentPrincipal;
}
private QState StateWaitForInputCarrierComplete(IQEvent qEvent)
{
LogStateInfo(_processName, System.Reflection.MethodBase.GetCurrentMethod().Name, qEvent);
if (qEvent.IsSignal(SigStateJob))
{
if (RecallDeferredSignal(HSTWorkcell.SigInputRFIDReadComplete))
{
UpdateSignalRecipient(HSTWorkcell.SigInputRFIDReadComplete);
}
return(null);
}
if (qEvent.IsSignal(HSTWorkcell.SigInputRFIDReadComplete))
{
var inputDataCarrier = (Carrier)(qEvent as QEvent).EventObject;
if (inputDataCarrier != null)
{
_currentRunCarrier = inputDataCarrier;
}
TransitionTo(stateCheckGetputServerConnection);
return(null);
}
return(stateRun);
}
protected virtual void DoDispatchException(IQHsm hsm, Exception ex, MethodInfo stateMethod, IQEvent ev)
{
if (OnDispatchException (hsm, ex, stateMethod, ev))
{
RaiseDispatchException (DispatchException, hsm, ex, stateMethod, ev);
}
}
protected override QState s02(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Init: CWrite("s02-INIT;"); InitializeState(m_s021); return null;
}
return base.s02(qEvent);
}
protected override QState s1(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)MyQSignals.B_Sig: Console.Write("s1-B-overriden;"); return null;
}
// Everything else we pass on to the state handler of the base class
return base.s1(qEvent);
}
protected QState s021(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: CWrite("s021-ENTRY;"); return null;
case (int)QSignals.Exit: CWrite("s021-EXIT;"); return null;
}
return m_s02;
}
protected QState s01(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s01-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s01-EXIT;"); return null;
case (int)MyQSignals.Sig1: Console.Write("s01-Sig1;"); TransitionTo(m_s02, ref s_Tran_s01_s02); return null;
}
return m_s0;
}
public void Send(IQEvent ev)
{
if (OnQEvents (ev))
{
if (QEvents != null)
{
QEvents (this, ev);
}
}
}
protected QState s0(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s0-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s0-EXIT;"); return null;
case (int)QSignals.Init: Console.Write("s0-INIT;"); InitializeState(m_s01); return null;
}
return this.TopState;
}
protected virtual QState s02(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s02-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s02-EXIT;"); return null;
case (int)MyQSignals.Sig2: Console.Write("s02-Sig2;"); TransitionTo(m_s01, ref s_Tran_s02_s01); return null;
}
return m_s0;
}
public void AsyncDispatchFront(IQHsm hsm, IQEvent ev)
{
lock (_QLock)
{
#warning Using a stack will alway push the most recent event to the front - thus reversing instead of maintaining "insert" order
HsmEventHolder holder = new HsmEventHolder (this, hsm, ev);
_FrontStack.Push (holder);
}
_WaitHandle.Set ();
}
protected QState s0(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s0-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s0-EXIT;"); return null;
case (int)QSignals.Init: Console.Write("s0-INIT;"); InitializeState(m_s1); return null;
case (int)MyQSignals.E_Sig: Console.Write("s0-E;"); TransitionTo(m_s211, ref s_Tran_s0_s211); return null;
}
return this.TopState;
}
private QState CatchAll(IQEvent qEvent)
{
LogEvent(MethodBase.GetCurrentMethod().Name, qEvent);
switch (qEvent.QSignal)
{
case (int)QSignals.Init:
InitializeState(this.InitializeBoard);
return null;
case (int)ControllerSignal.Reset:
TransitionTo(this.InitializeBoard);
return null;
}
return this.TopState;
}
protected virtual QState s1(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s1-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s1-EXIT;"); return null;
case (int)QSignals.Init: Console.Write("s1-INIT;"); InitializeState(m_s11); return null;
case (int)MyQSignals.A_Sig: Console.Write("s1-A;"); TransitionTo(m_s1, ref s_Tran_s1_s1); return null;
case (int)MyQSignals.B_Sig: Console.Write("s1-B;"); TransitionTo(m_s11, ref s_Tran_s1_s11); return null;
case (int)MyQSignals.C_Sig: Console.Write("s1-C;"); TransitionTo(m_s2, ref s_Tran_s1_s2); return null;
case (int)MyQSignals.D_Sig: Console.Write("s1-D;"); TransitionTo(m_s0, ref s_Tran_s1_s0); return null;
case (int)MyQSignals.F_Sig: Console.Write("s1-F;"); TransitionTo(m_s211, ref s_Tran_s1_s211); return null;
}
return m_s0;
}
private QState InitializeBoard(IQEvent qEvent)
{
LogEvent(MethodBase.GetCurrentMethod().Name, qEvent);
switch (qEvent.QSignal)
{
case (int)ControllerSignal.ProcessFrame:
m_MainModel.ImageProcessor.DetectedBlobsImage = null;
DetectBoardRectangles();
return null;
case (int)ControllerSignal.BoardInitialized:
TransitionTo(this.Initialized);
return null;
}
return this.CatchAll;
}
private QState Eating(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry:
LogMessage(String.Format("Philosopher {0} is eating.", m_PhilosopherId));
m_Timer.FireIn(c_EatTime, new PhilosopherEvent(DPPSignal.Timeout));
return null;
case (int)DPPSignal.Timeout:
TransitionTo(m_StateThinking, ref s_Tran_Eating_Thinking);
return null;
case (int)QSignals.Exit:
LogMessage(String.Format("Philosopher {0} is exiting eating state.", m_PhilosopherId));
TableEvent tableEvent = new TableEvent(DPPSignal.Done, m_PhilosopherId);
LogMessage(String.Format("Philosopher {0} publishes Done event.", m_PhilosopherId));
QF.Instance.Publish(tableEvent);
return null;
}
return this.TopState;
}
protected QState s11(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s11-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s11-EXIT;"); return null;
case (int)MyQSignals.G_Sig: Console.Write("s11-G;"); TransitionTo(m_s211, ref s_Tran_s11_s211); return null;
case (int)MyQSignals.H_Sig: // internal transition with a guard
if (m_Foo) // test the guard condition
{
Console.Write("s11-H;");
m_Foo = false;
return null;
}
break;
}
return m_s1;
}
protected QState s211(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s211-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s211-EXIT;"); return null;
case (int)MyQSignals.D_Sig: Console.Write("s211-D;"); TransitionTo(m_s21, ref s_Tran_s211_s21); return null;
case (int)MyQSignals.G_Sig: Console.Write("s211-G;"); TransitionTo(m_s0, ref s_Tran_s211_s0); return null;
}
return m_s21;
}
protected QState s21(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s21-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s21-EXIT;"); return null;
case (int)QSignals.Init: Console.Write("s21-INIT;"); InitializeState(m_s211); return null;
case (int)MyQSignals.B_Sig: Console.Write("s21-B;"); TransitionTo(m_s211, ref s_Tran_s21_s211); return null;
case (int)MyQSignals.H_Sig: // self transition with a guard
if (!m_Foo) // test the guard condition
{
Console.Write("s21-H;");
m_Foo = true;
TransitionTo(m_s21, ref s_Tran_s21_s21); // self transition
return null;
}
break; // break to return the superstate
}
return m_s2; // return the superstate
}
protected QState s2(IQEvent qEvent)
{
switch (qEvent.QSignal)
{
case (int)QSignals.Entry: Console.Write("s2-ENTRY;"); return null;
case (int)QSignals.Exit: Console.Write("s2-EXIT;"); return null;
case (int)QSignals.Init: Console.Write("s2-INIT;"); InitializeState(m_s21); return null;
case (int)MyQSignals.C_Sig: Console.Write("s2-C;"); TransitionTo(m_s1, ref s_Tran_s2_s1); return null;
case (int)MyQSignals.F_Sig: Console.Write("s2-F;"); TransitionTo(m_s11, ref s_Tran_s2_s11); return null;
}
return m_s0;
}
private QState DoSlowTwo(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("SlowTwo");
return null;
case (int)RtcSignals.Start:
bool completedOK2 = DoSomeInterruptibleWork2();
if (completedOK2)
{
this.lastCompleted = LastCompletedStep.SlowTwo;//not really needed
TransitionTo(Completed);
}
else
{
TransitionTo(Dispatching);
}
return null;
}
return Interruptible;
}
private QState DoSlowOne(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("SlowOne");
return null;
case (int)RtcSignals.Start:
bool completedOK1 = DoSomeInterruptibleWork1();
if (completedOK1)
{
this.lastCompleted = LastCompletedStep.SlowOne;
TransitionTo(SlowTwo);
}
else
{
TransitionTo(Dispatching);
}
return null;
}
return Interruptible;
}
private QState DoInterruptible(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("Interruptible");
return null;
case (int)RtcSignals.Abort:
SendAbortSignal();
TransitionTo(Dispatching);
return null;
}
return TopState;
}
//UNDONE: revise this code
private QState DoFinal(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("HSM terminated");
singleton = null;
MainForm.Instance.Close();
System.Windows.Forms.Application.Exit();
return null;
}
return this.TopState;
}
private QState DoDispatching(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("Dispatching State");
//lastCompleted = LastCompletedStep.None;
return null;
case (int)RtcSignals.Start:
switch (this.lastCompleted)
{
case LastCompletedStep.None:
case LastCompletedStep.SlowTwo:
TransitionTo(CantInterrupt);
break;
case LastCompletedStep.CantInterrupt:
TransitionTo(SlowOne);
break;
case LastCompletedStep.SlowOne:
TransitionTo(SlowTwo);
break;
}
return null;
}
if (qevent.QSignal >= (int)QSignals.UserSig)
{
isHandled = false;
}
return this.TopState;
}
private QState DoCompleted(IQEvent qevent)
{
switch (qevent.QSignal)
{
case (int)QSignals.Entry:
OnDisplayState("Completed");
lastCompleted = LastCompletedStep.None;
return null;
case (int)RtcSignals.Start:
TransitionTo(CantInterrupt);
return null;
}
return TopState;
}
