Kepler-Release/Venus/Venus_RT/Devices/EFEM/Loadport.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using SecsGem.Core.Application.E87;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using Venus_Core;

using Venus_RT.Devices.YASKAWA;
using Venus_RT.Modules;

namespace Venus_RT.Devices.EFEM
{
    sealed class Loadport : ILoadport
    {
        private readonly EfemBase _controller;

        //---------------------------------Properties------------------------------------
        // 
        public OnlineFlag OnlineFlag { get; set; }
        public ModuleName Module { get; set; }
        public DeviceState Status { get; set; }
        public WaferSize WaferSize { get; set; }
        public WaferStatus[] WaferInfo { get; set; }
        public bool HasCassette { get; set; }
        public bool Protrusion { get; set; }
        public bool IsMapped { get; set; }
        public bool JobDone { get; set; }
        public Stopwatch TimerNotifyJobDone { get; set; }

        public IE87CallBack LPCallBack
        {
            get { return _lpCallBack; }
            set { _lpCallBack = value; }
        }
        private IE87CallBack _lpCallBack;
        public bool IsThicknessValid
        {
            get
            {
                return !_enableThickness || !string.IsNullOrEmpty(_waferThicknessType);
            }
        }

        public string ThicknessType
        {
            get
            {
                return _waferThicknessType;
            }
        }
        public string PortId
        {
            get; private set;
        }

        public bool IsClamped { get; set; }
        public bool IsLoaded { get; set; }
        public bool IsDocked { get; set; }
        public string CarrierId { get; set; }
        public string SmartTag { get; set; }
        public string LotId { get; set; }

        public bool IsBusy { get; set; }
        public bool IsError { get; set; }

        private string[] _slotMap = new string[25];
        public string SlotMap
        {
            get
            {
                if (_slotMap == null)
                {
                    _slotMap = new string[SC.GetValue<int>("EFEM.LoadPort.SlotNumber")];
                }
                for (int i = 0; i < _slotMap.Length; i++)
                {
                    _slotMap[i] = ((int)WaferManager.Instance.GetWafer(Module, i).Status).ToString();
                }
                return string.Join("", _slotMap);
            }
        }
        private string _waferThicknessType;

        private bool _enableThickness;
        private string AlarmWaferProtrude = "WaferProtrude";
        private LoadPortFACallback _faCallback = new LoadPortFACallback();

        // Constructor
        //
        public Loadport(ModuleName mod, EfemBase efem)
        {
            Module = mod;
            PortId = ((int)mod - (int)ModuleName.LP1 + 1).ToString();
            _controller = efem;
			
			TimerNotifyJobDone = new Stopwatch();


            _enableThickness = false;// SC.GetValue<bool>("System.WaferThickness.EnableThickness");

            EV.Subscribe(new EventItem("Event", AlarmWaferProtrude, "Wafer protrude", EventLevel.Alarm, EventType.HostNotification));


            DATA.Subscribe($"{mod}.WaferSize", () => WaferSize.ToString());
            DATA.Subscribe($"{mod}.CassetteState", () => HasCassette ? LoadportCassetteState.Normal : LoadportCassetteState.Absent);
            DATA.Subscribe($"{mod}.CassettePresent", () => HasCassette ? 1 : 0);
            DATA.Subscribe($"{mod}.CassettePlaced", () => HasCassette);
            DATA.Subscribe($"{mod}.SlotMap", () => SlotMap);
            DATA.Subscribe($"{mod}.IsWaferProtrude", () => Protrusion ? 1 : 0);

            DATA.Subscribe($"{mod}.IsMapped", () => IsMapped);
            DATA.Subscribe($"{mod}.IsLoaded", () => IsLoaded);
            DATA.Subscribe($"{mod}.IsClamped", () => IsClamped);
            DATA.Subscribe($"{mod}.IsDocked", () => IsDocked);
            DATA.Subscribe($"{mod}.CarrierId", () => CarrierId);
            DATA.Subscribe($"{mod}.SmartTag", () => SmartTag);




            DATA.Subscribe($"{Module}.WaferThicknessType", () => _waferThicknessType);

            OP.Subscribe($"{Module}.SetThick", (cmd, args) => { SetThick(); return true; });
            OP.Subscribe($"{Module}.SetThin", (cmd, args) => { SetThin(); return true; });
            _lpCallBack = E87LoadPortManager.Instance.GetLoadPort((int)mod - (int)ModuleName.LP1 + 1);
        }

        // Methods
        //

        public void OnError()
        {
            IsError = true;
            IsBusy = false;
        }


        public void SetThick()
        {
            _waferThicknessType = "Thick";

            SC.SetItemValue($"System.WaferThickness.{Module}WaferThicknessType", _waferThicknessType);

            _controller.SetThickness(Module, _waferThicknessType);
        }

        public void SetThin()
        {
            _waferThicknessType = "Thin";

            SC.SetItemValue($"System.WaferThickness.{Module}WaferThicknessType", _waferThicknessType);

            _controller.SetThickness(Module, _waferThicknessType);
        }


        #region Home
        public void Home()
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not home");
                return;
            }

            IsBusy = true;

            _controller.Home(Module);
        }
		
		public void NoteJobStart()
        {
            JobDone = false;
        }
		
        public void NoteJobComplete()
        {
            TimerNotifyJobDone.Restart();
            JobDone = true;
        }

        public void OnHomeFailed(string data)
        {
            IsError = true;
            IsBusy = false;
        }

        public void OnHomed()
        {
            IsError = false;
            IsBusy = false;

            IsClamped = false;

            IsLoaded = false;

            IsMapped = false;

            IsDocked = false;
        }

        #endregion

        #region Load

        public void Load()
        {
            if (IsLoaded)
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} is loaded, can not load");
                return;
            }

            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy, can not load");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error, can not load");
                return;
            }
            IsBusy = true;

            _controller.Load(Module);
        }

        public void LoadStart()
        {
            if(_lpCallBack!=null)
            {
                _lpCallBack.LoadStart();
            }
        }

        public void OnLoadFailed(string data)
        {
            IsError = true;
            IsBusy = false;

            _faCallback.LoadFailed(this);
        }

        public void OnLoaded()
        {
            IsError = false;
            IsBusy = false;

            IsLoaded = true;

            IsMapped = true;

            _faCallback.LoadComplete(this);
            if(_lpCallBack!=null)
            {
                _lpCallBack.LoadComplete();
            }
        }
        #endregion


        #region unload

        public void Unload()
        {
            if (!IsLoaded)
            {
                EV.PostWarningLog(Module.ToString(), $"{Module} is not loaded, can not unload");
                return;
            }


            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not unload");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not unload");
                return;
            }

            IsBusy = true;

            _controller.Unload(Module);
        }

        public void UnloadStart()
        {
            if(_lpCallBack!=null)
            {
                _lpCallBack.UnLoadStart();
            }
        }
        public void OnUnloadFailed(string data)
        {
            IsError = true;
            IsBusy = false;

            _faCallback.UnloadFailed(this);
        }

        public void OnUnloaded()
        {
            IsBusy = false;
            IsError = false;

            IsLoaded = false;

            IsMapped = false;

            if (SC.GetValue<bool>("EFEM.AutoUnlockAfterUnload"))
            {
                _faCallback.UnloadComplete(this);
            }
            else
            {
                 
            }
 
        }
        #endregion


        #region Dock

        public void Dock()
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not dock");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not dock");
                return;
            }
            IsBusy = true;

            _controller.Dock(Module);
        }

        public void OnDocked()
        {
            IsBusy = false;
            IsError = false;
            IsDocked = true;

        }

        public void OnDockFailed(string data)
        {
            IsError = true;
            IsBusy = false;
        }

        #endregion

        #region Undock

        public void Undock()
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not undock");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not undock");
                return;
            }
            IsBusy = true;

            _controller.Undock(Module);
        }

        public void OnUndocked()
        {
            IsBusy = false;
            IsError = false;
            IsDocked = false;

        }

        public void OnUndockFailed(string data)
        {
            IsError = true;
            IsBusy = false;
        }

        #endregion

        #region Clamp

        public void Clamp(bool isUnloadClamp)
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not clamp");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not clamp");
                return;
            }
            IsBusy = true;

            _controller.Clamp(Module, isUnloadClamp);
        }

        public void OnClamped(bool isUnloadClamp)
        {
            IsBusy = false;
            IsError = false;

            IsClamped = true;

            if (isUnloadClamp)
            {
                _faCallback.UnloadComplete(this);
                
            }
            else
            {
                _faCallback.Clamped(this);
            }

            
        }

        public void OnClampFailed(string data)
        {
            IsError = true;
            IsBusy = false;
        }

        #endregion

        #region Unclamp

        public void Unclamp()
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not unclamp");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not unclamp");
                return;
            }
            IsBusy = true;

            _controller.Unclamp(Module);
        }


        public void OnUnclamped()
        {
            IsBusy = false;
            IsError = false;

            IsClamped = false;

            _faCallback.Unclamped(this);
        }

        public void OnUnclampFailed(string data)
        {


        }


        #endregion

        #region map

        public void Map()
        {
            _controller.Map(Module);
        }



        #endregion

        #region carrierID

        public void ReadCarrierID()
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not read carrier ID");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not read carrier ID");
                return;
            }
            IsBusy = true;

            _controller.ReadCarrierId(Module);
        }

        public void OnCarrierIDRead(string data)
        {
            IsBusy = false;
            IsError = false;

            //Regex rg = new Regex("(?<=(" + "LOT :" + "))[.\\s\\S]*?(?=(" + "QTY :" + "))", RegexOptions.Multiline | RegexOptions.Singleline);
            //string carrierID = rg.Match(data).Value.Replace(":", "").Trim();

            //data =
            //    "CST:C082259     TYPE:CST25_AU   LOT:AF2403      QTY:24          FLOW:033000     STATUS:HOLD     PRI:3-1         PD:0418A        CSRLOT:         CLEAN:2021/11/14 19:57:50       EQPGRP:DUMMY    STAGE:CP-TEST1  RECIPE:DUMMY    EMP:N           ";


            var items = data.Split(new string[] { " ", "\t", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);

            CarrierId = "";
            foreach (var item in items)
            {
                if (item.StartsWith("CST:") && item.Length > 4)
                    CarrierId = item.Substring(4).Trim();

                if (item.StartsWith("LOT:") && item.Length > 4)
                    LotId = item.Substring(4).Trim();
            }

            if (string.IsNullOrEmpty(CarrierId))
            {
                CarrierId = data;
            }

            SmartTag = data;

            _faCallback.IDRead(this);
        }

        public void OnCarrierIDReadFailed(string data)
        {
            IsError = true;
            IsBusy = false;

            _faCallback.ReadIDFailed(this);
        }

        public void WriteCarrierID(string id)
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not write carrier ID");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not write carrier ID");
                return;
            }
            IsBusy = true;

            _controller.WriteCarrierId(Module, id);
        }

        public void OnCarrierIDWrite(string data)
        {
            IsBusy = false;
            IsError = false;

            var items = data.Split(new string[] { " ", "\t", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);

            CarrierId = "";
            foreach (var item in items)
            {
                if (item.StartsWith("CST:") && item.Length > 4)
                    CarrierId = item.Substring(4);
            }

            if (string.IsNullOrEmpty(CarrierId))
            {
                CarrierId = data;
            }

            SmartTag = data;

            _faCallback.IDWrite(this);
        }

        public void OnCarrierIDWriteFailed(string data)
        {
            IsError = true;
            IsBusy = false;

            _faCallback.WriteIDFailed(this);
        }
        #endregion

        #region event
        public void HandleEvent(EfemEventArgs eArg)
        {
            switch (eArg.CommandType)
            {
                case EfemOperation.GetWaferInfo:
                    string sWaferInfo = eArg.DataList[0];
                    bool resultNormal = true;
                    for (byte index = 0; index < sWaferInfo.Length; index++)
                    {
                        int waferState = int.Parse(sWaferInfo.Substring(index, 1));

                        //合理的映射到内部支持的叠片/交叉片
                        if (waferState >= 7) waferState = 7;
                        else if (waferState >= 2) waferState = 3;

                        WaferStatus st = (WaferStatus)waferState;

                        WaferManager.Instance.UpdateWaferSize(this.Module, index, WaferSize);

                        if (st != WaferStatus.Empty)
                        {
                            WaferManager.Instance.CreateWafer(this.Module, index, st);

                            if (st == WaferStatus.Normal)
                            {
                                //EV.PostInfoLog(this.Module.ToString(), $"Found Wafer on Slot {index + 1} {WaferSize}");
                            }
                            else
                            {
                                resultNormal = false;
                            }
                        }
                    }
                    if (resultNormal)
                    {
                        _faCallback.CarrierSlotMapComplete(this);
                    }
                    else
                    {
                        _faCallback.CarrierSlotMapFailed(this);
                    }

                    this.IsMapped = true;
                    break;

                case EfemOperation.SigStatus:
                    // EVT: SIGSTAT/P2/00000381/00000000;

                    string sParam = eArg.DataList[0];

                    ModuleName mod = sParam.ToModule();
                    if (!ModuleHelper.IsLoadPort(mod))
                        return;

                    // DATA1 & DATA2
                    int nData1 = Convert.ToInt32(eArg.DataList[1], 16);
                    int nData2 = Convert.ToInt32(eArg.DataList[2], 16);

                    BitArray baData1 = new BitArray(new int[] { nData1 });
                    BitArray baData2 = new BitArray(new int[] { nData2 });

                    // wafer size
                    this.WaferSize = !baData1[6] ? WaferSize.WS3 :
                                     !baData1[7] ? WaferSize.WS4 :
                                     !baData1[8] ? WaferSize.WS6 : WaferSize.WS0;

                    // placement & present
                    bool bPlacement = baData1[0]; // bit 0
                    bool bPresence = !baData1[1]; // bit 1
                    bool bArrived = bPlacement && bPresence;

                    if (HasCassette)
                    {
                        if (!bArrived)
                        {
                            this.HasCassette = false;
                            this.IsMapped = false;
                            //EV.PostInfoLog(mod.ToString(), "Cassette removed");
                            OP.DoOperation("System.CassetteLeave");     //For unload light control off afer job done
                            CarrierManager.Instance.DeleteCarrier(Module.ToString());
                            WaferManager.Instance.DeleteWafer(this.Module, 0, 25);

                            _faCallback.CarrierRemoved(this);
                            JobDone = false;
                            _waferThicknessType = "";
                        }
                    }
                    else
                    {
                        if (bArrived)
                        {
                            this.HasCassette = true;
                            CarrierManager.Instance.CreateCarrier(Module.ToString());
                            _faCallback.CarrierArrived(this);                            

                            JobDone = false;
                            _waferThicknessType = "";
                        }
                    }

                    this.Protrusion = !baData1[9];
                    if (Protrusion)
                    {
                        //EV.PostAlarmLog(Module.ToString(), "发现 wafer 突出");

                        //EV.Notify(AlarmWaferProtrude);
                        //Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                    }

                    // DATA2, loadport上面的LED 灯， 暂时不需要用到
                    break;
                default:
                    break;
            }
        }



        #endregion

        #region TagData

        public void ReadTagData()
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not read tag data");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not read tag data");
                return;
            }
            IsBusy = true;

            _controller.ReadTagData(Module);
        }

        public void OnTagDataRead(string data)
        {
            IsBusy = false;
            IsError = false;

            //Regex rg = new Regex("(?<=(" + "LOT :" + "))[.\\s\\S]*?(?=(" + "QTY :" + "))", RegexOptions.Multiline | RegexOptions.Singleline);
            //string carrierID = rg.Match(data).Value.Replace(":", "").Trim();

            //data =
            //    "CST:C082259     TYPE:CST25_AU   LOT:AF2403      QTY:24          FLOW:033000     STATUS:HOLD     PRI:3-1         PD:0418A        CSRLOT:         CLEAN:2021/11/14 19:57:50       EQPGRP:DUMMY    STAGE:CP-TEST1  RECIPE:DUMMY    EMP:N           ";


            var items = data.Split(new string[] { " ", "\t", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);

            CarrierId = "";
            foreach (var item in items)
            {
                if (item.StartsWith("CST:") && item.Length > 4)
                    CarrierId = item.Substring(4);

                if (item.StartsWith("LOT:") && item.Length > 4)
                    LotId = item.Substring(4).Trim();
            }

            if (string.IsNullOrEmpty(CarrierId))
            {
                CarrierId = data;
            }

            SmartTag = data;

            _faCallback.TagDataRead(this);
        }

        public void OnTagDataReadFailed(string data)
        {
            IsError = true;
            IsBusy = false;

            _faCallback.ReadTagDataFailed(this);
        }

        public void WriteTagData(string tagData)
        {
            if (IsBusy)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is busy can not write tag data");
                return;
            }
            if (IsError)
            {
                EV.PostInfoLog(Module.ToString(), $"{Module} is error can not write tag data");
                return;
            }
            IsBusy = true;

            _controller.WriteTagData(Module, tagData);
        }

        public void OnTagDataWrite(string data)
        {
            IsBusy = false;
            IsError = false;

            var items = data.Split(new string[] { " ", "\t", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);

            CarrierId = "";
            foreach (var item in items)
            {
                if (item.StartsWith("CST:") && item.Length > 4)
                    CarrierId = item.Substring(4);
            }

            if (string.IsNullOrEmpty(CarrierId))
            {
                CarrierId = data;
            }

            SmartTag = data;

            _faCallback.TagDataWrite(this);
        }

        public void OnTagDataWriteFailed(string data)
        {
            IsError = true;
            IsBusy = false;

            _faCallback.WriteTagDataFailed( this);
        }



        #endregion

        public void SetOnline(bool online)
        {
            OnlineFlag = online ? OnlineFlag.Online : OnlineFlag.Offline;
        }

        sealed class LoadPortFACallback
        {
            private string CARRIER_ARRIVED = "CARRIER_ARRIVED";
            private string CARRIER_REMOVED = "CARRIER_REMOVED";
            private string SLOT_MAP_AVAILABLE = "SLOT_MAP_AVAILABLE";
            private string SLOT_MAP_FAILED = "SLOT_MAP_FAILED";
            private const string CARRIER_LOADED = "CARRIER_LOADED";
            private const string PortLoadFailed = "PortLoadFailed";
            private const string CARRIER_UNLOADED = "CARRIER_UNLOADED";
            private const string PortUnloadFailed = "PortUnloadFailed";
            private const string PortClamped = "PortClamped";
            private const string PortUnclamped = "PortUnclamped";
            private const string CARRIER_ID_READ = "CARRIER_ID_READ";
            private const string PortReadIDFailed = "PortReadIDFailed";
            private const string PortIDWrite = "PortIDWrite";
            private const string PortWriteIDFailed = "PortWriteIDFailed";
            private const string PortTagDataRead = "PortTagDataRead";
            private const string PortReadTagDataFailed = "PortReadTagDataFailed";
            private const string PortTagDataWrite = "PortTagDataWrite";
            private const string PortWriteTagDataFailed = "PortWriteTagDataFailed";


            public LoadPortFACallback()
            {
                EV.Subscribe(new EventItem("Event", CARRIER_ARRIVED, "Carrier Arrived"));
                EV.Subscribe(new EventItem("Event", CARRIER_REMOVED, "Carrier Removed"));
                EV.Subscribe(new EventItem("Event", SLOT_MAP_AVAILABLE, "Slot map available"));
                EV.Subscribe(new EventItem("Event", SLOT_MAP_FAILED, "Slot map failed"));
                EV.Subscribe(new EventItem("Event", CARRIER_LOADED, "Carrier Loaded"));
                EV.Subscribe(new EventItem("Event", PortLoadFailed, PortLoadFailed));
                EV.Subscribe(new EventItem("Event", CARRIER_UNLOADED, "Carrier Unloaded"));
                EV.Subscribe(new EventItem("Event", PortUnloadFailed, PortUnloadFailed));
                EV.Subscribe(new EventItem("Event", PortClamped, "Port Clamped"));
                EV.Subscribe(new EventItem("Event", PortUnclamped, PortUnclamped));
                EV.Subscribe(new EventItem("Event", CARRIER_ID_READ, "Carrier Id Read"));
                EV.Subscribe(new EventItem("Event", PortReadIDFailed, PortReadIDFailed));
                EV.Subscribe(new EventItem("Event", PortIDWrite, PortIDWrite));
                EV.Subscribe(new EventItem("Event", PortWriteIDFailed, PortWriteIDFailed));
                EV.Subscribe(new EventItem("Event", PortTagDataRead, PortTagDataRead));
                EV.Subscribe(new EventItem("Event", PortReadTagDataFailed, PortReadTagDataFailed));
                EV.Subscribe(new EventItem("Event", PortTagDataWrite, PortTagDataWrite));
                EV.Subscribe(new EventItem("Event", PortWriteTagDataFailed, PortWriteTagDataFailed));
            }


            public void CarrierArrived(Loadport lp)
            {
                SerializableDictionary<string, string> dvid = new SerializableDictionary<string, string>();
                dvid["PortID"] = lp.PortId;

                EV.Notify(CARRIER_ARRIVED, dvid);
            }

            public void CarrierRemoved(Loadport lp)
            {
                SerializableDictionary<string, string> dvid = new SerializableDictionary<string, string>();
                dvid["PortID"] = lp.PortId;
                dvid["CarrierID"] = lp.CarrierId ?? "";
                EV.Notify(CARRIER_REMOVED, dvid);
            }

            public void CarrierSlotMapComplete(Loadport lp)
            {
                SerializableDictionary<string, string> dvid = new SerializableDictionary<string, string>();

                dvid["SlotMap"] = lp.SlotMap;
                dvid["PortID"] = lp.PortId;
                dvid["CarrierID"] = lp.CarrierId ?? "";

                EV.Notify(SLOT_MAP_AVAILABLE, dvid);
            }

            public void CarrierSlotMapFailed(Loadport lp)
            {

            }
            public void LoadComplete(Loadport lp)
            {
                ModuleName moduleName = lp.Module;
                var dvid = new SerializableDictionary<string, string>
                {
                    ["CarrierID"] = lp.CarrierId ?? "",
                    ["PortID"] = lp.PortId.ToString()
                };
                EV.Notify(CARRIER_LOADED, dvid);
            }

            public void LoadFailed(Loadport lp)
            {
            }

            public void UnloadComplete(Loadport lp)
            {
                ModuleName moduleName = lp.Module;
                var dvid = new SerializableDictionary<string, string>
                {
                    ["CarrierID"] = lp.CarrierId ?? "",
                    ["PortID"] = lp.PortId.ToString()
                };
                EV.Notify(CARRIER_UNLOADED, dvid);
            }

            public void UnloadFailed(Loadport lp)
            {
               
            }

            public void Clamped(Loadport lp)
            {
               
            }

            public void Unclamped(Loadport lp)
            {
               
            }

            public void IDRead(Loadport lp)
            {
                
            }

            public void ReadIDFailed(Loadport lp)
            {
                
            }


            public void IDWrite(Loadport lp)
            {
               
            }

            public void WriteIDFailed(Loadport lp)
            {
                
            }



            public void TagDataRead(Loadport lp)
            {
                
            }

            public void ReadTagDataFailed(Loadport lp)
            {
            }


            public void TagDataWrite(Loadport lp)
            {
                
            }

            public void WriteTagDataFailed(Loadport lp)
            {
              
            }
        }
    }

}