FurnaceELK/Furnace/FurnaceRT/Devices/IOE84.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using FACore.E87FA;
using FurnaceRT.Equipments.LPs;
using FurnaceRT.Equipments.Systems;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.FA.Core.E87FA;

namespace FurnaceRT.Devices
{
    public enum SignalType
    {
        Acitvie,
        Passive,
    }
    public enum SignalID
    {
        LightCurtain,
        CS_0,
        CS_1,
        AM_AVBL,
        VALID,
        TR_REQ,
        BUSY,
        COMPT,
        CONT,

        L_REQ,
        U_REQ,
        HO_AVBL,
        READY,
        ES
    }


    public class Signal
    {
        public bool Value
        {
            get
            {
                if (_di != null)
                    return _di.Value;
                if (_do != null)
                    return _do.Value;

                return false;
            }
        }

        private SignalID _id;
        private RD_TRIG _trig = new RD_TRIG();
        private DIAccessor _di = null;
        private DOAccessor _do = null;

        public event Action<SignalID, bool> OnChanged;
        public Signal(SignalID id, DIAccessor diAccessor, DOAccessor doAccessor)
        {
            _id = id;
            _di = diAccessor;
            _do = doAccessor;
        }

        public void Monitor()
        {
            if (_di != null)
                _trig.CLK = _di.Value;

            if (_do != null)
                _trig.CLK = _do.Value;

            if (_trig.R)
            {
                if (OnChanged != null)
                    OnChanged(_id, true);
            }

            if (_trig.M)
            {
                if (OnChanged != null)
                    OnChanged(_id, false);
            }
        }

        public void Reset()
        {
            _trig.RST = true;
        }

    }




    public class E84Passiver : BaseDevice, IDevice
    {
        public enum E84State
        {
            Normal,
            LD_TP1_Timeout,
            LD_TP2_Timeout,
            LD_TP3_Timeout,
            LD_TP4_Timeout,
            LD_TP5_Timeout,
            LD_TP6_Timeout,
            ULD_TP1_Timeout,
            ULD_TP2_Timeout,
            ULD_TP3_Timeout,
            ULD_TP4_Timeout,
            ULD_TP5_Timeout,
            ULD_TP6_Timeout,
            Error,

        }

        public enum Timeout
        {
            TP1,
            TP2,
            TP3,
            TP4,
            TP5,
        }
        public bool LightCurtainBroken { get { return !DiLightCurtain; } }   //interlock
        public AccessMode Mode { get; set; }
        public LPTransferState TransferState { get; set; }
        public LPReservationState LPReserved { get; set; }

        public IFALoadPort Provider { get; set; }


        public bool DiLightCurtain { get; set; }
        public bool DiValid { get { return _diValid != null ? _diValid.Value : false; } }
        public bool DiCS0 { get { return _diCS0 != null ? _diCS0.Value : false; } }
        public bool DiCS1 { get { return _diCS1 != null ? _diCS1.Value : false; } }
        public bool DiTrReq { get { return _diTrReq != null ? _diTrReq.Value : false; } }
        public bool DiBusy { get { return _diBusy != null ? _diBusy.Value : false; } }
        public bool DiCompt { get { return _diCompt != null ? _diCompt.Value : false; } }
        public bool DiCont { get { return _diCont != null ? _diCont.Value : false; } }
        public bool DiAmAvbl { get { return _diAmAvbl != null ? _diAmAvbl.Value : false; } }

        public bool DoLoadReq { get { return _doLoadReq != null ? _doLoadReq.Value : false; } }
        public bool DoUnloadReq { get { return _doUnloadReq != null ? _doUnloadReq.Value : false; } }
        public bool DoReady { get { return _doReady != null ? _doReady.Value : false; } }
        public bool DoHOAvbl { get { return _doHOAvbl != null ? _doHOAvbl.Value : false; } }
        public bool DoES { get { return _doES != null ? _doES.Value : false; } }

        public string EventE84LoadTransactionStart => $"E84{Module}LoadTransactionStart";
        public string EventE84UnloadTransactionStart => $"E84{Module}UnloadTransactionStart";
        public string EventE84LoadTransactionComplete => $"E84{Module}LoadTransactionComplete";
        public string EventE84UnloadTransactionComplete => $"E84{Module}UnloadTransactionComplete";
        public string EventE84LoadTransactionRestart => $"E84{Module}LoadTransactionRestart";
        public string EventE84UnloadTransactionRestart => $"E84{Module}UnloadTransactionRestart";
        public string EventE84ChangeAccessModeToAuto => $"E84{Module}ChangeAccessModeToAuto";
        public string EventE84ChangeAccessModeToManual => $"E84{Module}ChangeAccessModeToManual";



        public static string EventE84TP1Timeout = "E84TP1Timeout";
        public static string EventE84TP2Timeout = "E84TP2Timeout";
        public static string EventE84TP3Timeout = "E84TP3Timeout";
        public static string EventE84TP4Timeout = "E84TP4Timeout";
        public static string EventE84TP5Timeout = "E84TP5Timeout";
        public static string EventE84TP6Timeout = "E84TP6Timeout";
        public bool IsFoupPresent
        {
            get
            {
                //if (SC.GetValue<bool>("System.IsSimulatorMode"))
                //    return CarrierManager.Instance.HasCarrier(Module);

                if (_diPresent1 != null && _diPresent2 != null && _diPresent3 != null && _diSeat != null)
                    return _diPresent1.Value && _diPresent2.Value && _diPresent3.Value && _diSeat.Value;

                return false;
            }
        }


        //Active equipment signal
        private DIAccessor _diLightCurtain;
        private DIAccessor _diValid;
        private DIAccessor _diCS0;
        private DIAccessor _diCS1;
        private DIAccessor _diAmAvbl;
        private DIAccessor _diTrReq;
        private DIAccessor _diBusy;
        private DIAccessor _diCompt;
        private DIAccessor _diCont;
        private DIAccessor _diPresent1;
        private DIAccessor _diPresent2;
        private DIAccessor _diPresent3;
        private DIAccessor _diSeat;

        //Passive 
        private DOAccessor _doLoadReq;
        private DOAccessor _doUnloadReq;
        private DOAccessor _doReady;
        private DOAccessor _doHOAvbl;
        private DOAccessor _doES;


        private DeviceTimer _timer = new DeviceTimer();
        private DeviceTimer _timer_TP1 = new DeviceTimer();
        private DeviceTimer _timer_TP2 = new DeviceTimer();
        private DeviceTimer _timer_TP3 = new DeviceTimer();
        private DeviceTimer _timer_TP4 = new DeviceTimer();
        private DeviceTimer _timer_TP5 = new DeviceTimer();
        private DeviceTimer _timer_TP6 = new DeviceTimer();
        private R_TRIG _trigReset = new R_TRIG();

        private List<Signal> _signals = new List<Signal>();

        //timeout
        private SCConfigItem _scTimeoutTP1;
        private SCConfigItem _scTimeoutTP2;
        private SCConfigItem _scTimeoutTP3;
        private SCConfigItem _scTimeoutTP4;
        private SCConfigItem _scTimeoutTP5;
        private SCConfigItem _scTimeoutTP6;
        private SCConfigItem _scTimeoutTP7;
        private SCConfigItem _scTimeoutTP8;

        //private int reqOnTimeout    = 2;        //L_REQ|U_REQ_ON ON ---> TR REQ ON
        //private int readyOnTimeout  = 2;        //READY ON ---> BUSY ON  
        //private int busyOnTimeout   = 2;        //BUSYON -- CARRIAGE DETECT|CARRIAGE REMOVE
        //private int reqOffTimeout   = 2;        //L_REQ|U_REQ off --->BUSY off
        //private int readyOffTimeout = 2;        //Ready off --->Valid off

        private E84State _state;
        private string _lastSignalValue = "";
        //private Timeout _tp;
        /// <summary>
        /// This constructor uses DeviceModel's node to define IOs
        /// </summary>
        /// <param name="module"></param>
        /// <param name="node"></param>
        /// <param name="ioModule"></param>
        public E84Passiver(string module, XmlElement node, string ioModule = "")
        {
            base.Module = node.GetAttribute("module");
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");


            _diLightCurtain = ParseDiNode("LightCurtain", node, ioModule);
            _signals.Add(new Signal(SignalID.LightCurtain, _diLightCurtain, null));
            //Indicates that the signal transition is active and selected
            //ON: valid; OFF: not valid
            _diValid = ParseDiNode("VALID", node, ioModule);
            _signals.Add(new Signal(SignalID.VALID, _diValid, null));

            //Carrier stage 0
            //ON: Use the load port for carrier handoff; vice versa
            _diCS0 = ParseDiNode("CS_0", node, ioModule);
            _signals.Add(new Signal(SignalID.CS_0, _diCS0, null));

            //Carrier stage 1
            //ON: Use the load port for carrier handoff; vice versa
            _diCS1 = ParseDiNode("CS_1", node, ioModule);
            _signals.Add(new Signal(SignalID.CS_1, _diCS1, null));

            //Transfer Arm Available
            //ON: Handoff is available; OFF: Handoff is unavailable with any error
            _diAmAvbl = ParseDiNode("AM_AVBL", node, ioModule);
            _signals.Add(new Signal(SignalID.AM_AVBL, _diAmAvbl, null));

            //Transfer Request
            //ON: Request Handoff; vice versa
            _diTrReq = ParseDiNode("TR_REQ", node, ioModule);
            _signals.Add(new Signal(SignalID.TR_REQ, _diTrReq, null));

            //BUSY for transfer
            //ON: Handoff is in progress; vice versa
            _diBusy = ParseDiNode("BUSY", node, ioModule);
            _signals.Add(new Signal(SignalID.BUSY, _diBusy, null));

            //Complete Transfer
            //ON:The handoff is completed; vice versa
            _diCompt = ParseDiNode("COMPT", node, ioModule);
            _signals.Add(new Signal(SignalID.COMPT, _diCompt, null));

            //Continuous Handoff
            //ON: Continuous Handoff; vice versa
            _diCont = ParseDiNode("CONT", node, ioModule);
            _signals.Add(new Signal(SignalID.CONT, _diCont, null));

            _diPresent1 = ParseDiNode("Present1", node, ioModule);
            _diPresent2 = ParseDiNode("Present2", node, ioModule);
            _diPresent3 = ParseDiNode("Present3", node, ioModule);
            _diSeat = ParseDiNode("Seat", node, ioModule);

            //Load Request
            //ON: The load port is assigned to load a carrier; vice versa
            //CS_0 && VALID && !CarrierLoaded
            _doLoadReq = ParseDoNode("L_REQ", node, ioModule);
            _signals.Add(new Signal(SignalID.L_REQ, null, _doLoadReq));

            //Unload Request
            //ON: The load port is assigned to unload a carrier; vice versa
            //CS_0 && VALID && !CarrierUnloaded
            _doUnloadReq = ParseDoNode("U_REQ", node, ioModule);
            _signals.Add(new Signal(SignalID.U_REQ, null, _doUnloadReq));

            //READY for transfer(after accepted the transfer request set ON, turned OFF when COMPT ON)
            //ON: Ready for handoff; vice versa
            _doReady = ParseDoNode("READY", node, ioModule);
            _signals.Add(new Signal(SignalID.READY, null, _doReady));

            //Indicates the passive equipment is not available for the handoff.
            //ON: Handoff is available; OFF: vice versa but with error
            //ON when normal; OFF when : Maintenance mode / Error State 
            _doHOAvbl = ParseDoNode("HO_AVBL", node, ioModule);
            _signals.Add(new Signal(SignalID.HO_AVBL, null, _doHOAvbl));

            //Emergency stop
            _doES = ParseDoNode("ES", node, ioModule);
            _signals.Add(new Signal(SignalID.ES, null, _doES));

            foreach (var signal in _signals)
            {
                signal.OnChanged += OnSignalChange;
            }

            _scTimeoutTP1 = SC.GetConfigItem("FA.E84.TP1");
            _scTimeoutTP2 = SC.GetConfigItem("FA.E84.TP2");
            _scTimeoutTP3 = SC.GetConfigItem("FA.E84.TP3");
            _scTimeoutTP4 = SC.GetConfigItem("FA.E84.TP4");
            _scTimeoutTP5 = SC.GetConfigItem("FA.E84.TP5");
            _scTimeoutTP6 = SC.GetConfigItem("FA.E84.TP6");
            _scTimeoutTP7 = SC.GetConfigItem("FA.E84.TP7");
            _scTimeoutTP8 = SC.GetConfigItem("FA.E84.TP8");

            OP.Subscribe($"{Module}.E84Place", (cmd, param) =>
            {
                if (!AutoLoad(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not Place, {reason}");
                    return false;
                }

                return true;
            });

            OP.Subscribe($"{Module}.E84Pick", (cmd, param) =>
            {
                if (!AutoUnLoad(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not Pick, {reason}");
                    return false;
                }

                return true;
            });
            OP.Subscribe($"{Module}.E84Retry", (cmd, param) =>
            {
                if (!E84Retry(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not retry E84 transaction, {reason}");
                    return false;
                }

                return true;
            });
            OP.Subscribe($"{Module}.E84Complete", (cmd, param) =>
            {
                if (!E84Complete(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not complete E84 transaction, {reason}");
                    return false;
                }

                return true;
            });

            DATA.Subscribe($"{Module}.E84State", () => _state.ToString());
            //DATA.Subscribe($"{Module}.TransferState", () => TransferState.ToString());
            //DATA.Subscribe($"{Module}.AccessMode", () => Mode.ToString());

            DATA.Subscribe($"{Module}_E84STATE", () => (ushort)_state);
            //DATA.Subscribe($"{Module}_TRANSFER_STATE", () => (ushort)TransferState);
            //DATA.Subscribe($"{Module}_ACCESS_MODE", () => (ushort)Mode);
            DATA.Subscribe($"{Module}.LightCurtain", () => (_diLightCurtain != null ? _diLightCurtain.Value : true));
            DATA.Subscribe($"{Module}.Valid", () => _diValid.Value);
            DATA.Subscribe($"{Module}.TransferRequest", () => _diTrReq.Value);
            DATA.Subscribe($"{Module}.Busy", () => _diBusy.Value);
            DATA.Subscribe($"{Module}.TransferComplete", () => _diCompt.Value);
            DATA.Subscribe($"{Module}.CS0", () => _diCS0.Value);
            DATA.Subscribe($"{Module}.CS1", () => _diCS1.Value);
            DATA.Subscribe($"{Module}.CONT", () => _diCont.Value);

            DATA.Subscribe($"{Module}.LoadRequest", () => _doLoadReq.Value);
            DATA.Subscribe($"{Module}.UnloadRequest", () => _doUnloadReq.Value);
            DATA.Subscribe($"{Module}.ReadyToTransfer", () => _doReady.Value);
            DATA.Subscribe($"{Module}.HandoffAvailable", () => _doHOAvbl.Value);
            DATA.Subscribe($"{Module}.ES", () => _doES.Value);

            int index = (int)(ModuleName)(Enum.Parse(typeof(ModuleName), Module)) - 1;

            EV.Subscribe(new EventItem(60061 + 10 * index, "Event", AlarmTP1timeout, $"{Module} Occurred TP1 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60062 + 10 * index, "Event", AlarmTP2timeout, $"{Module} Occurred TP2 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60063 + 10 * index, "Event", AlarmTP3timeout, $"{Module} Occurred TP3 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60064 + 10 * index, "Event", AlarmTP4timeout, $"{Module} Occurred TP4 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60065 + 10 * index, "Event", AlarmTP5timeout, $"{Module} Occurred TP5 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem("Event", EventE84LoadTransactionStart, $"{Module} Load Transaction Start", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84UnloadTransactionStart, $"{Module} Unload Transaction Start", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84LoadTransactionComplete, $"{Module} Load Transaction Complete", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84UnloadTransactionComplete, $"{Module} Unload Transaction Complete", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84LoadTransactionRestart, $"{Module} Load Transaction Restart", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84UnloadTransactionRestart, $"{Module} Unload Transaction Restart", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84ChangeAccessModeToAuto, $"{Module} Change Access Mode To Auto", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));
            EV.Subscribe(new EventItem("Event", EventE84ChangeAccessModeToManual, $"{Module} Change Access Mode To Manual", EventLevel.Information, Aitex.Core.RT.Event.EventType.EventUI_Notify));

            _thread = new PeriodicJob(10, OnTimer, $"{Module}.{Name} MonitorE84Handler", true);
        }
        private string AlarmTP1timeout { get => $"{Module}TP1Timeout"; }
        private string AlarmTP2timeout { get => $"{Module}TP2Timeout"; }
        private string AlarmTP3timeout { get => $"{Module}TP3Timeout"; }
        private string AlarmTP4timeout { get => $"{Module}TP4Timeout"; }
        private string AlarmTP5timeout { get => $"{Module}TP5Timeout"; }

        /// <summary>
        /// This constructor gets IO signals using GetIO
        /// </summary>
        /// <param name="module"></param>
        /// <param name="name"></param>
        /// <param name="display"></param>
        /// <param name="deviceId"></param>
        public E84Passiver(string module, string name, string display, string deviceId)
        {
            Module = module;
            Name = name;
            Display = display;
            DeviceID = deviceId;


            _diLightCurtain = IO.DI[$"DI_{module}_LightCurtain"];
            _signals.Add(new Signal(SignalID.LightCurtain, _diLightCurtain, null));
            //Indicates that the signal transition is active and selected
            //ON: valid; OFF: not valid
            _diValid = IO.DI[$"DI_{module}_VALID"];
            _signals.Add(new Signal(SignalID.VALID, _diValid, null));

            //Carrier stage 0
            //ON: Use the load port for carrier handoff; vice versa
            _diCS0 = IO.DI[$"DI_{module}_CS_0"];
            _signals.Add(new Signal(SignalID.CS_0, _diCS0, null));

            //Carrier stage 1
            //ON: Use the load port for carrier handoff; vice versa
            _diCS1 = IO.DI[$"DI_{module}_CS_1"] ?? IO.DI[$"DI_{module}_CS_0"];
            _signals.Add(new Signal(SignalID.CS_1, _diCS1, null));

            //Transfer Arm Available
            //ON: Handoff is available; OFF: Handoff is unavailable with any error
            _diAmAvbl = IO.DI[$"DI_{module}_AM_AVBL"];
            _signals.Add(new Signal(SignalID.AM_AVBL, _diAmAvbl, null));

            //Transfer Request
            //ON: Request Handoff; vice versa
            _diTrReq = IO.DI[$"DI_{module}_TR_REQ"];
            _signals.Add(new Signal(SignalID.TR_REQ, _diTrReq, null));

            //BUSY for transfer
            //ON: Handoff is in progress; vice versa
            _diBusy = IO.DI[$"DI_{module}_BUSY"];
            _signals.Add(new Signal(SignalID.BUSY, _diBusy, null));

            //Complete Transfer
            //ON:The handoff is completed; vice versa
            _diCompt = IO.DI[$"DI_{module}_COMPT"];
            _signals.Add(new Signal(SignalID.COMPT, _diCompt, null));

            //Continuous Handoff
            //ON: Continuous Handoff; vice versa
            _diCont = IO.DI[$"DI_{module}_CONT"];
            _signals.Add(new Signal(SignalID.CONT, _diCont, null));

            //Load Request
            //ON: The load port is assigned to load a carrier; vice versa
            //CS_0 && VALID && !CarrierLoaded
            _doLoadReq = IO.DO[$"DI_{module}_L_REQ"];
            _signals.Add(new Signal(SignalID.L_REQ, null, _doLoadReq));

            //Unload Request
            //ON: The load port is assigned to unload a carrier; vice versa
            //CS_0 && VALID && !CarrierUnloaded
            _doUnloadReq = IO.DO[$"DI_{module}_U_REQ"];
            _signals.Add(new Signal(SignalID.U_REQ, null, _doUnloadReq));

            //READY for transfer(after accepted the transfer request set ON, turned OFF when COMPT ON)
            //ON: Ready for handoff; vice versa
            _doReady = IO.DO[$"DI_{module}_READY"];
            _signals.Add(new Signal(SignalID.READY, null, _doReady));

            //Indicates the passive equipment is not available for the handoff.
            //ON: Handoff is available; OFF: vice versa but with error
            //ON when normal; OFF when : Maintenance mode / Error State 
            _doHOAvbl = IO.DO[$"DI_{module}_HO_AVBL"];
            _signals.Add(new Signal(SignalID.HO_AVBL, null, _doHOAvbl));

            //Emergency stop
            _doES = IO.DO[$"DI_{module}_ES"];
            _signals.Add(new Signal(SignalID.ES, null, _doES));

            foreach (var signal in _signals)
            {
                signal.OnChanged += OnSignalChange;
            }

            _scTimeoutTP1 = SC.GetConfigItem("FA.E84.TP1");
            _scTimeoutTP2 = SC.GetConfigItem("FA.E84.TP2");
            _scTimeoutTP3 = SC.GetConfigItem("FA.E84.TP3");
            _scTimeoutTP4 = SC.GetConfigItem("FA.E84.TP4");
            _scTimeoutTP5 = SC.GetConfigItem("FA.E84.TP5");
            _scTimeoutTP6 = SC.GetConfigItem("FA.E84.TP6");
            _scTimeoutTP7 = SC.GetConfigItem("FA.E84.TP7");
            _scTimeoutTP8 = SC.GetConfigItem("FA.E84.TP8");


            OP.Subscribe($"{Module}.E84Place", (cmd, param) =>
            {
                if (!AutoLoad(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not Place, {reason}");
                    return false;
                }

                return true;
            });

            OP.Subscribe($"{Module}.E84Pick", (cmd, param) =>
            {
                if (!AutoUnLoad(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not Pick, {reason}");
                    return false;
                }

                return true;
            });
            OP.Subscribe($"{Module}.E84Retry", (cmd, param) =>
            {
                if (!E84Retry(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not retry E84 transaction, {reason}");
                    return false;
                }

                return true;
            });
            OP.Subscribe($"{Module}.E84Complete", (cmd, param) =>
            {
                if (!E84Complete(out var reason))
                {
                    EV.PostWarningLog(Module, $"{Name} can not complete E84 transaction, {reason}");
                    return false;
                }

                return true;
            });

            DATA.Subscribe($"{Module}.E84State", () => _state.ToString());
            //DATA.Subscribe($"{Module}.TransferState", () => TransferState.ToString());
            // DATA.Subscribe($"{Module}.AccessMode", () => Mode.ToString());
            DATA.Subscribe($"{Module}.LightCurtain", () => _diLightCurtain.Value);
            DATA.Subscribe($"{Module}.Valid", () => _diValid.Value);
            DATA.Subscribe($"{Module}.TransferRequest", () => _diTrReq.Value);
            DATA.Subscribe($"{Module}.Busy", () => _diBusy.Value);
            DATA.Subscribe($"{Module}.TransferComplete", () => _diCompt.Value);
            DATA.Subscribe($"{Module}.CS0", () => _diCS0.Value);
            DATA.Subscribe($"{Module}.CS1", () => _diCS1.Value);
            DATA.Subscribe($"{Module}.CONT", () => _diCont.Value);

            DATA.Subscribe($"{Module}.LoadRequest", () => _doLoadReq.Value);
            DATA.Subscribe($"{Module}.UnloadRequest", () => _doUnloadReq.Value);
            DATA.Subscribe($"{Module}.ReadyToTransfer", () => _doReady.Value);
            DATA.Subscribe($"{Module}.HandoffAvailable", () => _doHOAvbl.Value);
            DATA.Subscribe($"{Module}.ES", () => _doES.Value);

            int index = (int)(ModuleName)(Enum.Parse(typeof(ModuleName), Module)) - 1;
            EV.Subscribe(new EventItem(60061 + 10 * index, "Event", AlarmTP1timeout, $"{Module} Occurred TP1 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60062 + 10 * index, "Event", AlarmTP2timeout, $"{Module} Occurred TP2 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60063 + 10 * index, "Event", AlarmTP3timeout, $"{Module} Occurred TP3 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60064 + 10 * index, "Event", AlarmTP4timeout, $"{Module} Occurred TP4 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
            EV.Subscribe(new EventItem(60065 + 10 * index, "Event", AlarmTP5timeout, $"{Module} Occurred TP5 Timeout", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));

            _thread = new PeriodicJob(10, OnTimer, $"{Module}.{Name} MonitorE84Handler", true);
        }



        private PeriodicJob _thread;
        public bool Stop(out string reason)
        {
            reason = String.Empty;
            ResetSignal();
            return false;
        }

        public bool AutoLoad(out string reason)
        {
            //reason = String.Empty;
            //if (Mode != LPAccessMode.AUTO)
            //{
            //    if (!SetAMHS(out reason))
            //    {
            //        return false;
            //    }
            //}
            //if (Provider.ReadyForLoad())
            //{
            //    TransferState = LPTransferState.READY_TO_LOAD;
            //    return true;
            //}
            reason = "Not Ready For Auto Load";
            return false;
        }

        public bool AutoUnLoad(out string reason)
        {
            //reason = String.Empty;
            //if (Mode != LPAccessMode.AUTO)
            //{
            //    if (!SetAMHS(out reason))
            //    {
            //        return false;
            //    }
            //}
            //if (Provider.ReadyForUnload())
            //{
            //    TransferState = LPTransferState.READY_TO_UNLOAD;
            //    return true;
            //}
            reason = "Not Ready For Auto Load";
            return false;
        }

        public bool SetAMHS(out string reason)
        {
            reason = "";
            Provider.SetAccessMode(true, out reason);
            return true;
        }

        public bool SetManual(out string reason)
        {
            reason = "";
            Provider.SetAccessMode(false, out reason);
            return true;
        }

        public bool E84Retry(out string reason)
        {
            reason = "";
            var dvid = new SerializableDictionary<string, object>();
            int portID = 0;
            dvid["PORT_ID"] = int.TryParse(Module.Replace("LP", ""), out portID) ? portID : portID;
            ResetSignal();
            //Provider.E84Retry();


            return true;
        }
        public bool E84Complete(out string reason)
        {
            reason = "";
            var dvid = new SerializableDictionary<string, object>();
            int portID = 0;
            dvid["PORT_ID"] = int.TryParse(Module.Replace("LP", ""), out portID) ? portID : portID;

            switch (_state)
            {
                case E84State.Error:
                    ResetSignal();
                    break;
                case E84State.LD_TP1_Timeout:
                    if (IsFoupPresent)
                    {
                        EV.Notify(EventE84LoadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup not detected";
                        return false;
                    }

                    break;
                case E84State.LD_TP2_Timeout:
                    if (IsFoupPresent)
                    {
                        EV.Notify(EventE84LoadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup not detected";
                        return false;
                    }
                    break;
                case E84State.LD_TP3_Timeout:
                    if (IsFoupPresent)
                    {
                        EV.Notify(EventE84LoadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup not detected";
                        return false;
                    }
                    break;
                case E84State.LD_TP4_Timeout:
                    if (IsFoupPresent)
                    {
                        EV.Notify(EventE84LoadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup not detected";
                        return false;
                    }
                    break;
                case E84State.LD_TP5_Timeout:
                    ResetSignal();
                    break;
                case E84State.ULD_TP1_Timeout:
                    if (!IsFoupPresent)
                    {
                        EV.Notify(EventE84UnloadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup detected";
                        return false;
                    }

                    break;
                case E84State.ULD_TP2_Timeout:
                    if (!IsFoupPresent)
                    {
                        EV.Notify(EventE84UnloadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup detected";
                        return false;
                    }
                    break;
                case E84State.ULD_TP3_Timeout:
                    if (!IsFoupPresent)
                    {
                        EV.Notify(EventE84UnloadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup detected";
                        return false;
                    }

                    break;
                case E84State.ULD_TP4_Timeout:
                    if (!IsFoupPresent)
                    {
                        EV.Notify(EventE84UnloadTransactionComplete, dvid);
                        ResetSignal();
                    }
                    else
                    {
                        reason = "Foup detected";
                        return false;
                    }

                    break;
                case E84State.ULD_TP5_Timeout:
                    ResetSignal();
                    break;
                default:
                    ResetSignal();

                    break;
            }
            return true;
        }

        public bool Initialize()
        {
            ResetSignal();



            return true;
        }

        private bool InvokeReset(string arg1, object[] arg2)
        {
            //string reason;
            EV.PostInfoLog(Module, $"E84 reset {Module}.{Name}");

            ResetSignal();

            return true;
        }

        public void Terminate()
        {
            ResetSignal();
        }

        private void ResetSignal()
        {
            _doLoadReq.SetValue(false, out _);
            _doUnloadReq.SetValue(false, out _);
            _doReady.SetValue(false, out _);
            _doHOAvbl.SetValue(false, out _);
            _doES.SetValue(false, out _);
            _timer_TP1.Stop();
            _timer_TP2.Stop();
            _timer_TP3.Stop();
            _timer_TP4.Stop();
            _timer_TP5.Stop();
            _state = E84State.Normal;
            foreach (var signal in _signals)
            {
                signal.Reset();
            }
        }

        private LPTransferState preTranState;

        private bool OnTimer()
        {
            try
            {
                foreach (var signal in _signals)
                {
                    signal.Monitor();
                }

                RecordSignalChange();
                if (Provider == null)
                    return true;

                TransferState = (LPTransferState)Provider.GetTransferState();
                Mode = (AccessMode)Provider.GetAccessMode();
                LPReserved = (LPReservationState)Provider.GetReservedState();

                if (_diLightCurtain != null)
                {
                    DiLightCurtain = _diLightCurtain.Value;
                    if (SC.ContainsItem("Fa.E84.BypassLightCurtain") && SC.GetValue<bool>("Fa.E84.BypassLightCurtain"))
                        DiLightCurtain = true;
                }
                else DiLightCurtain = true;

                if (LightCurtainBroken || TransferState == LPTransferState.OUT_OF_SERVICE || Mode != AccessMode.Auto)
                {
                    _doHOAvbl.SetValue(false, out _);
                    _doLoadReq.SetValue(false, out _);
                    _doUnloadReq.SetValue(false, out _);
                    _doReady.SetValue(false, out _);
                    _doES.SetValue(false, out _);
                    _timer_TP1.Stop();
                    _timer_TP2.Stop();
                    _timer_TP3.Stop();
                    _timer_TP4.Stop();
                    _timer_TP5.Stop();
                    _timer_TP6.Stop();
                    preTranState = TransferState;
                    return true;
                }

                if (_state != E84State.Normal)
                    return true;

                _doHOAvbl.SetValue(true, out _);
                _doES.SetValue(true, out _);
                var dvid = new SerializableDictionary<string, object>();
                int portID = 0;
                dvid["PORT_ID"] = int.TryParse(Module.Replace("LP", ""), out portID) ? portID : portID;


                if (TransferState == LPTransferState.READY_TO_LOAD && !IsFoupPresent)
                {
                    preTranState = TransferState;
                    if (DiCS0 && DiValid && !_doLoadReq.Value)
                    {
                        _doLoadReq.SetValue(true, out _);

                    }
                    if (DiCS0 && DiValid && _doLoadReq.Value && !DiTrReq)
                    {
                        if (_timer_TP1.IsIdle()) _timer_TP1.Start(_scTimeoutTP1.IntValue * 1000);

                    }
                    if (DiCS0 && DiValid && _doLoadReq.Value && DiTrReq && !_doReady.Value)
                    {
                        _timer_TP1.Stop();
                        _doReady.SetValue(true, out _);

                        if (Provider != null) Provider.OnE84HandoffStart(true, out _);
                        EV.Notify(EventE84LoadTransactionStart, dvid);
                    }

                }

                if (TransferState == LPTransferState.TRANSFER_BLOCKED && preTranState == LPTransferState.READY_TO_LOAD)  //Load Sequence
                {
                    if (DiCS0 && DiValid && _doLoadReq.Value && DiTrReq && _doReady.Value && !DiBusy)
                    {
                        if (_timer_TP2.IsIdle()) _timer_TP2.Start(_scTimeoutTP2.IntValue * 1000);

                    }
                    if (DiCS0 && DiValid && _doLoadReq.Value && DiTrReq && _doReady.Value && DiBusy)
                    {
                        _timer_TP2.Stop();
                        if (!IsFoupPresent)
                        {
                            if (_timer_TP3.IsIdle()) _timer_TP3.Start(_scTimeoutTP3.IntValue * 1000);

                        }
                        else
                        {
                            _timer_TP3.Stop();
                            _doLoadReq.SetValue(false, out _);
                        }
                    }
                    if (DiCS0 && DiValid && !_doLoadReq.Value && DiTrReq && _doReady.Value && DiBusy)
                    {
                        if (_timer_TP4.IsIdle()) _timer_TP4.Start(_scTimeoutTP4.IntValue * 1000);

                    }
                    if (DiCS0 && DiValid && !_doLoadReq.Value && _doReady.Value && !DiBusy)
                    {
                        _timer_TP4.Stop();

                    }
                    if (DiCS0 && DiValid && !_doLoadReq.Value && _doReady.Value && DiCompt)
                    {
                        _doReady.SetValue(false, out _);
                        _timer_TP4.Stop();

                        if (_timer_TP5.IsIdle()) _timer_TP5.Start(_scTimeoutTP5.IntValue * 1000);

                    }
                    if (!DiCS0 && !_doLoadReq.Value && !_doUnloadReq.Value && !DiTrReq && !_doReady.Value && !DiBusy && !DiCompt)

                    {
                        _timer_TP5.Stop();
                        EV.Notify(EventE84LoadTransactionComplete, dvid);
                        preTranState = LPTransferState.TRANSFER_BLOCKED;

                        var lpmodule = Singleton<EquipmentManager>.Instance.Modules[ModuleHelper.Converter(Module)] as LoadPortModule;
                        if (IsFoupPresent)
                            lpmodule.Invoke("ReadID");
                        //if (Provider != null) Provider.OnE84HandoffComplete(true,out _);
                    }



                }



                if (TransferState == LPTransferState.READY_TO_UNLOAD)
                {
                    preTranState = TransferState;
                    if (DiCS0 && DiValid && !_doUnloadReq.Value)
                    {
                        _doUnloadReq.SetValue(true, out _);

                        //Provider.LPTSTrans();
                        //EV.Notify(EventE84UnloadTransactionStart, dvid);
                    }
                    if (DiCS0 && DiValid && _doUnloadReq.Value && !DiTrReq)
                    {
                        if (_timer_TP1.IsIdle()) _timer_TP1.Start(_scTimeoutTP1.IntValue * 1000);

                    }
                    if (DiCS0 && DiValid && _doUnloadReq.Value && DiTrReq && !_doReady.Value)
                    {
                        _timer_TP1.Stop();
                        _doReady.SetValue(true, out _);
                        EV.Notify(EventE84UnloadTransactionStart, dvid);
                        if (Provider != null) Provider.OnE84HandoffStart(false, out _);
                    }
                }

                if (TransferState == LPTransferState.TRANSFER_BLOCKED && preTranState == LPTransferState.READY_TO_UNLOAD)  //Unload Sequence
                {

                    if (DiCS0 && DiValid && _doUnloadReq.Value && DiTrReq && _doReady.Value && !DiBusy)
                    {
                        if (_timer_TP2.IsIdle()) _timer_TP2.Start(_scTimeoutTP1.IntValue * 1000);

                    }
                    if (DiCS0 && DiValid && _doUnloadReq.Value && DiTrReq && _doReady.Value && DiBusy)
                    {
                        _timer_TP2.Stop();
                        if (IsFoupPresent)
                        {
                            if (_timer_TP3.IsIdle()) _timer_TP3.Start(_scTimeoutTP3.IntValue * 1000);
                        }
                        else
                        {
                            _timer_TP3.Stop();
                            _doUnloadReq.SetValue(false, out _);

                        }
                    }
                    if (DiCS0 && DiValid && !_doUnloadReq.Value && DiTrReq && _doReady.Value && DiBusy)
                    {
                        if (_timer_TP4.IsIdle()) _timer_TP4.Start(_scTimeoutTP4.IntValue * 1000);

                    }
                    if (DiCS0 && DiValid && DiTrReq && _doReady.Value && !DiBusy)
                    {
                        _timer_TP4.Stop();

                    }
                    if (DiCS0 && DiValid && !_doUnloadReq.Value && _doReady.Value && DiCompt)
                    {
                        _doReady.SetValue(false, out _);
                        _timer_TP4.Stop();

                        if (_timer_TP5.IsIdle()) _timer_TP5.Start(_scTimeoutTP5.IntValue * 1000);

                    }
                    if (!DiValid && !_doUnloadReq.Value && !DiTrReq && !_doReady.Value && !DiBusy && !DiCompt)
                    {
                        _timer_TP5.Stop();
                        EV.Notify(EventE84UnloadTransactionComplete, dvid);
                        preTranState = LPTransferState.TRANSFER_BLOCKED;
                        if (Provider != null) Provider.OnE84HandoffComplete(false, out _);
                    }
                }

                if (_timer_TP1.IsTimeout())
                {
                    if (preTranState == LPTransferState.READY_TO_LOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP1Timeout, dvid);
                        _state = E84State.LD_TP1_Timeout;
                        _timer_TP1.Stop();
                        if (Provider != null) Provider.E84Error(_state.ToString());

                    }
                    if (preTranState == LPTransferState.READY_TO_UNLOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);

                        //EV.Notify(EventE84TP1Timeout, dvid);
                        _state = E84State.ULD_TP1_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());

                    }

                    _timer_TP1.Stop();
                    EV.Notify(AlarmTP1timeout);



                }

                if (_timer_TP2.IsTimeout())
                {
                    if (preTranState == LPTransferState.READY_TO_LOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP2Timeout, dvid);
                        _state = E84State.LD_TP2_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());
                    }
                    if (preTranState == LPTransferState.READY_TO_UNLOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP2Timeout, dvid);
                        _state = E84State.ULD_TP2_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());

                    }
                    _timer_TP2.Stop();
                    EV.Notify(AlarmTP2timeout);
                }

                if (_timer_TP3.IsTimeout())
                {
                    if (preTranState == LPTransferState.READY_TO_LOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP3Timeout, dvid);
                        _state = E84State.LD_TP3_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());
                    }
                    if (preTranState == LPTransferState.READY_TO_UNLOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP3Timeout, dvid);
                        _state = E84State.ULD_TP3_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());
                    }
                    _timer_TP3.Stop();
                    EV.Notify(AlarmTP3timeout);
                }

                if (_timer_TP4.IsTimeout())
                {
                    if (preTranState == LPTransferState.READY_TO_LOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP4Timeout, dvid);
                        _state = E84State.LD_TP4_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());
                    }
                    if (preTranState == LPTransferState.READY_TO_UNLOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP4Timeout, dvid);
                        _state = E84State.ULD_TP4_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());
                    }
                    _timer_TP4.Stop();
                    EV.Notify(AlarmTP4timeout);

                }
                if (_timer_TP5.IsTimeout())
                {
                    if (preTranState == LPTransferState.READY_TO_LOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP5Timeout, dvid);
                        _state = E84State.LD_TP5_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());

                    }
                    if (preTranState == LPTransferState.READY_TO_UNLOAD)
                    {
                        _doLoadReq.SetValue(false, out _);
                        _doUnloadReq.SetValue(false, out _);
                        _doReady.SetValue(false, out _);
                        _doHOAvbl.SetValue(false, out _);
                        //EV.Notify(EventE84TP5Timeout, dvid);
                        _state = E84State.ULD_TP5_Timeout;
                        if (Provider != null) Provider.E84Error(_state.ToString());
                    }
                    _timer_TP5.Stop();
                    EV.Notify(AlarmTP5timeout);
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
            return true;

        }

        public void Reset()
        {
            //_doLoadReq.SetValue(false, out _);
            //_doUnloadReq.SetValue(false, out _);
            //_doReady.SetValue(false, out _);
            //_doHOAvbl.SetValue(false, out _);
            //_doES.SetValue(false, out _);
            //_state = E84State.Normal;
            //foreach (var signal in _signals)
            //{
            //    signal.Reset();
            //}                

        }
        private void RecordSignalChange()
        {
            string tempSignal = $"{Name} E84 signal change to following,Active: Valid:{_diValid.Value}," +
                $"CS0:{_diCS0.Value},TransferRequest:{_diTrReq.Value},Busy:{_diBusy.Value},Complete:{_diCompt.Value}," +
                $"Passive:LoadRequest:{_doLoadReq.Value},UnloadRequest:{_doUnloadReq.Value},Ready:{_doReady.Value}," +
                $"HoAvl:{_doHOAvbl.Value},ES:{_doES.Value},LightCurtain:" +
                $"{(_diLightCurtain == null ? "None" : _diLightCurtain.Value.ToString())}," +
                $"Present Sensor1:{(_diPresent1 == null ? "None" : _diPresent1.Value.ToString())}," +
                $"Present Sensor2:{(_diPresent2 == null ? "None" : _diPresent2.Value.ToString())}," +
                $"Present Sensor3:{(_diPresent3 == null ? "None" : _diPresent3.Value.ToString())}," +
                $"Seat Sensor:{(_diSeat == null ? "None" : _diSeat.Value.ToString())},";
            if (tempSignal != _lastSignalValue)
            {
                _lastSignalValue = tempSignal;
                LOG.Write(_lastSignalValue);
            }
        }


        private void autoRecovery()
        {
            var dvid = new SerializableDictionary<string, object>();
            int portID = 0;
            dvid["PORT_ID"] = int.TryParse(Module.Replace("LP", ""), out portID) ? portID : portID;

            switch (_state)
            {
                case E84State.Error:
                    break;
                case E84State.LD_TP1_Timeout:
                    if (IsFoupPresent) EV.Notify(EventE84LoadTransactionComplete, dvid);
                    else EV.Notify(EventE84LoadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.LD_TP2_Timeout:
                    if (IsFoupPresent) EV.Notify(EventE84LoadTransactionComplete, dvid);
                    else EV.Notify(EventE84LoadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.LD_TP3_Timeout:
                    if (IsFoupPresent) EV.Notify(EventE84LoadTransactionComplete, dvid);
                    else EV.Notify(EventE84LoadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.LD_TP4_Timeout:
                    if (IsFoupPresent) EV.Notify(EventE84LoadTransactionComplete, dvid);
                    else EV.Notify(EventE84LoadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.LD_TP5_Timeout:
                    if (!IsFoupPresent) EV.Notify(EventE84LoadTransactionComplete, dvid);
                    else EV.Notify(EventE84LoadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.ULD_TP1_Timeout:
                    if (!IsFoupPresent) EV.Notify(EventE84UnloadTransactionComplete, dvid);
                    else EV.Notify(EventE84UnloadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.ULD_TP2_Timeout:
                    if (!IsFoupPresent) EV.Notify(EventE84UnloadTransactionComplete, dvid);
                    else EV.Notify(EventE84UnloadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.ULD_TP3_Timeout:
                    if (!IsFoupPresent) EV.Notify(EventE84UnloadTransactionComplete, dvid);
                    else EV.Notify(EventE84UnloadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.ULD_TP4_Timeout:
                    if (!IsFoupPresent) EV.Notify(EventE84UnloadTransactionComplete, dvid);
                    else EV.Notify(EventE84UnloadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                case E84State.ULD_TP5_Timeout:
                    if (!IsFoupPresent) EV.Notify(EventE84UnloadTransactionComplete, dvid);
                    else EV.Notify(EventE84UnloadTransactionRestart, dvid);
                    ResetSignal();
                    break;
                default: break;
            }
            ResetSignal();

        }

        private void OnSignalChange(SignalID signal, bool value)
        {

        }

        public void Monitor()
        {

        }
    }
}