ELK/Furnace/FurnaceRT/Equipments/Systems/IoSmif.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace FurnaceRT.Equipments.Systems
{
    public class IoSmif: SMIFBase
    {
        public IoSmif(string module, XmlElement node, string ioModule = "")
        {
            base.Module = string.IsNullOrEmpty(node.GetAttribute("module")) ? module : node.GetAttribute("module");
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");

            _diPodLockPosition = ParseDiNode("diPodLockPosition", node, ioModule);
            _diPodUnlockPosition = ParseDiNode("diPodUnlockPosition", node, ioModule);
            _diPodOpenPosition = ParseDiNode("diPodOpenPosition", node, ioModule);
            _diPodClosePosition = ParseDiNode("diPodClosePosition", node, ioModule);
            _diPodPresence = ParseDiNode("diPodPresence", node, ioModule);
            _diZAxisUnloadPosition = ParseDiNode("diZAxisUnloadPosition", node, ioModule);
            _diZAxisLoadPosition = ParseDiNode("diZAxisLoadPosition", node, ioModule);
            _diZAxisPosition1 = ParseDiNode("diZAxisPosition1", node, ioModule);
            _diZAxisPosition2 = ParseDiNode("diZAxisPosition2", node, ioModule);
            _diRotateAxisCheck1 = ParseDiNode("diRotateAxisCheck1", node, ioModule);
            _diRotateAxisCheck2 = ParseDiNode("diRotateAxisCheck2", node, ioModule);
            _diSlideAxisExtend = ParseDiNode("diSlideAxisExtend", node, ioModule);
            _diSlideAxisRetract = ParseDiNode("diSlideAxisRetract", node, ioModule);
            _diProtrudedWafer = ParseDiNode("diProtrudedWafer", node, ioModule);
            _diMapping = ParseDiNode("diMapping", node, ioModule);
            _diFfuOK = ParseDiNode("diFfuOK", node, ioModule);
            _diPodLockValveFB = ParseDiNode("diPodLockValveFB", node, ioModule);
            _diPodUnlockValveFB = ParseDiNode("diPodUnlockValveFB", node, ioModule);
            _diPodOpenVavleFB = ParseDiNode("diPodOpenVavleFB", node, ioModule);
            _diPodCloseVavleFB = ParseDiNode("diPodCloseVavleFB", node, ioModule);
            _diRotateArmValve1FB = ParseDiNode("diRotateArmValve1FB", node, ioModule);
            _diRotateArmValve2FB = ParseDiNode("diRotateArmValve2FB", node, ioModule);
            _diSlideArmValve1FB = ParseDiNode("diSlideArmValve1FB", node, ioModule);
            _diSlideArmValve2FB = ParseDiNode("diSlideArmValve2FB", node, ioModule);
            _diSmifCassettePresence = ParseDiNode("diSmifCassettePresence", node, ioModule);
            _diSmifReady = ParseDiNode("diSmifReady", node, ioModule);
            _diSmifHomed = ParseDiNode("diSmifHomed", node, ioModule);
            _diRobotNotExtendToSmif = ParseDiNode("diRobotNotExtendToSmif", node, ioModule);
           

            _doPodLockValve = ParseDoNode("doPodLockValve", node, ioModule);
            _doPodUnlockValve = ParseDoNode("doPodUnlockValve", node, ioModule);
            _doPodOpenVavle = ParseDoNode("doPodOpenVavle", node, ioModule);
            _doPodCloseVavle = ParseDoNode("doPodCloseVavle", node, ioModule);
            _doRotateArmValve1 = ParseDoNode("doRotateArmValve1", node, ioModule);
            _doRotateArmValve2 = ParseDoNode("doRotateArmValve2", node, ioModule);
            _doSlideArmValve1 = ParseDoNode("doSlideArmValve1", node, ioModule);
            _doSlideArmValve2 = ParseDoNode("doSlideArmValve2", node, ioModule);
            _doZAxisBK = ParseDoNode("doZAxisBK", node, ioModule);
            _doLoadSmif = ParseDoNode("doLoadSmif", node, ioModule);
            _doUnloadSmif = ParseDoNode("doUnloadSmif", node, ioModule);
            _doInitSmif = ParseDoNode("doInitSmif", node, ioModule);
            _doStopSmif = ParseDoNode("doStopSmif", node, ioModule);
        }
        #region fields
        private DIAccessor _diPodLockPosition;
        private DIAccessor _diPodUnlockPosition;
        private DIAccessor _diPodOpenPosition;
        private DIAccessor _diPodClosePosition;
        private DIAccessor _diPodPresence;
        private DIAccessor _diZAxisUnloadPosition;
        private DIAccessor _diZAxisLoadPosition;
        private DIAccessor _diZAxisPosition1;
        private DIAccessor _diZAxisPosition2;
        private DIAccessor _diRotateAxisCheck1;
        private DIAccessor _diRotateAxisCheck2;
        private DIAccessor _diSlideAxisExtend;
        private DIAccessor _diSlideAxisRetract;
        private DIAccessor _diProtrudedWafer;
        private DIAccessor _diMapping;
        private DIAccessor _diFfuOK;
        private DIAccessor _diPodLockValveFB;
        private DIAccessor _diPodUnlockValveFB;
        private DIAccessor _diPodOpenVavleFB;
        private DIAccessor _diPodCloseVavleFB;
        private DIAccessor _diRotateArmValve1FB;
        private DIAccessor _diRotateArmValve2FB;
        private DIAccessor _diSlideArmValve1FB;
        private DIAccessor _diSlideArmValve2FB;
        private DIAccessor _diSmifCassettePresence;
        private DIAccessor _diSmifReady;
        private DIAccessor _diSmifHomed;
        private DIAccessor _diRobotNotExtendToSmif;

        private DOAccessor _doPodLockValve;
        private DOAccessor _doPodUnlockValve;
        private DOAccessor _doPodOpenVavle;
        private DOAccessor _doPodCloseVavle;
        private DOAccessor _doRotateArmValve1;
        private DOAccessor _doRotateArmValve2;
        private DOAccessor _doSlideArmValve1;
        private DOAccessor _doSlideArmValve2;
        private DOAccessor _doZAxisBK;
        private DOAccessor _doLoadSmif;
        private DOAccessor _doUnloadSmif;
        private DOAccessor _doInitSmif;
        private DOAccessor _doStopSmif;
          
        #endregion

        #region properties
        //public override bool IsPodPresent => _diPodPresence.Value && _diSmifCassettePresence.Value && !_diProtrudedWafer.Value;
        public override bool IsPodPresent => _diPodPresence.Value;
        public override bool IsIdle => _diSmifReady.Value;
        public override bool IsHomed => _diSmifHomed.Value;
        public string CurrentLotId { get; set; }
        public List<string> WaitLotId { get; set; }
        public bool IsRobotNotExtendTo => _diRobotNotExtendToSmif.Value;
        public override bool IsLoaded => _diZAxisLoadPosition.Value && _diSlideAxisExtend.Value;
        public override bool IsUnloaded => _diZAxisUnloadPosition.Value && _diSlideAxisRetract.Value;
        public override bool IsExtend => _diSlideAxisExtend.Value;
        public override bool IsRetract => _diSlideAxisRetract.Value;
        #endregion

        public override bool Initialize()
        {
            CarrierManager.Instance.SubscribeLocation(Name, 1, SC.GetValue<int>("System.CassetteSlotCount"));
            WaferManager.Instance.SubscribeLocation(Name, SC.GetValue<int>("System.CassetteSlotCount"));
            //CarrierManager.Instance.CreateCarrier(Name);

            //DATA.Subscribe($"{Name}.CurrentLotId", () => CurrentLotId);
            //DATA.Subscribe($"{Name}.WaitLotId", () => WaitLotId);
            MappingResult = new List<string>();
            return true;
        }

        public override void Monitor()
        {
            base.Monitor();
        }

        public override void Reset()
        {
            base.Reset();
        }

        public override void Terminate()
        {
            base.Terminate();
        }

        public override bool HomeSmif(out string reason)
        {
            reason = string.Empty;
            if(!IsIdle)
            {
                reason = $"{Name} is busy";
                return false;
            }
            _doInitSmif.SetPulseValue(true, 2000);
            return true;
        }

        public override bool LoadCassette(out string reason)
        {
            reason = string.Empty;
            //if (!IsIdle)
            //{
            //    reason = $"{Name} is busy";
            //    return false;
            //}
            _doLoadSmif.SetPulseValue(true, 2000);
            return true;
        }

        public override bool UnloadCassette(out string reason)
        {
            reason = string.Empty;
            //if (!IsIdle)
            //{
            //    reason = $"{Name} is busy";
            //    return false;
            //}
            _doUnloadSmif.SetPulseValue(true, 2000);
            return true;
        }
        public override void Stop()
        {
            _doUnloadSmif.SetValue(false, out _);
            _doInitSmif.SetValue(false, out _);
            _doLoadSmif.SetValue(false, out _);
            _doStopSmif.SetPulseValue(true, 2000);
            return;
        }

        public void DeleteCarrier()
        {
            ModuleName chamber = ModuleHelper.Converter(Name);

            if (CarrierManager.Instance.HasCarrier(chamber.ToString()))
            {
                CarrierManager.Instance.DeleteCarrier(chamber.ToString());

                EV.PostInfoLog(Name, $"Carrier deleted from {chamber}");

                var wafers = WaferManager.Instance.GetWafers(chamber);
                for (int i = 0; i < wafers.Length; i++)
                {
                    if (!wafers[i].IsEmpty)
                        WaferManager.Instance.DeleteWafer(chamber, i);
                }
            }
            else
            {
                EV.PostInfoLog(Name, string.Format("No carrier at {0}, delete not valid", chamber.ToString()));
            }
        }
    }
}