ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemUI/Views/Maintenance/NewE84View.xaml.cs

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.UI.ViewModel;
using EfemUI.Controls;

namespace EfemUI.Views
{
    public partial class NewE84View : UserControl
    {
        public NewE84ViewModel _e84ViewModel;

        public NewE84View()
        {
            InitializeComponent();

            _e84ViewModel = new NewE84ViewModel();
            DataContext = _e84ViewModel;

            IsVisibleChanged += E84View_IsVisibleChanged;
        }

        private void E84View_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            (DataContext as NewE84ViewModel)?.EnableTimer(IsVisible);
        }

        private void SetControlDefaultValue()
        {
            foreach (TabItem tabItem in root.Items)
            {
                NewE84Info e84Info = (NewE84Info)tabItem.Content;
                e84Info.PLInService.ScId = $"LoadPort.{e84Info.LoadPortName}.PLInService";
                e84Info.PLDataReadSize.ScId = $"LoadPort.{e84Info.LoadPortName}.DataReadSize";
                e84Info.PLStartPage.ScId = $"LoadPort.{e84Info.LoadPortName}.StartPage";
                e84Info.PLEnableAutoCarrierIdRead.ScId = $"LoadPort.{e84Info.LoadPortName}.EnableAutoCarrierIdRead";
                e84Info.PLDefaultPage.ScId = $"LoadPort.{e84Info.LoadPortName}.DefaultPage";
                e84Info.PLInService.Command = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).SetConfigCommand;
                e84Info.BtnReadCarrierID.Command = e84Info.DeviceOperationCommand;
                e84Info.BtnReadCarrierID.CommandParameter = "ReadCarrierIDByIndex";
                e84Info.BtnWriteCarrierID.Command = e84Info.DeviceOperationCommand;
                e84Info.BtnWriteCarrierID.CommandParameter = "WriteCarrierIDByIndex";
                Binding binding = new Binding("CarrierID") { Source = e84Info.E84Data };
                e84Info.txtReadCarrierID.SetBinding(TextBox.TextProperty, binding );
                switch (e84Info.LoadPortName)
                {
                    case "LP1":
                        e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_PLInService;
                        e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_PLInService;
                        e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_DataReadSize;
                        e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_DataReadSize;
                        e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_StartPage;
                        e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_StartPage;
                        e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_EnableAutoCarrierIdRead;
                        e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_EnableAutoCarrierIdRead;
                        e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_DefaultPage;
                        e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_DefaultPage;
                        ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigChanged += E84View_ConfigChanged1;
                        break;
                    case "LP2":
                        e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_PLInService;
                        e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_PLInService;
                        e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_DataReadSize;
                        e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_DataReadSize;
                        e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_StartPage;
                        e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_StartPage;
                        e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_EnableAutoCarrierIdRead;
                        e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_EnableAutoCarrierIdRead;
                        e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_DefaultPage;
                        e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_DefaultPage;
                        ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigChanged += E84View_ConfigChanged;
                        break;
                    case "LP3":
                        e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_PLInService;
                        e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_PLInService;
                        e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_DataReadSize;
                        e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_DataReadSize;
                        e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_StartPage;
                        e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_StartPage;
                        e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_EnableAutoCarrierIdRead;
                        e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_EnableAutoCarrierIdRead;
                        e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_DefaultPage;
                        e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_DefaultPage;
                        ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigChanged += E84View_ConfigChanged2;
                        break;
                    case "LP4":
                        e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_PLInService;
                        e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_PLInService;
                        e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_DataReadSize;
                        e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_DataReadSize;
                        e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_StartPage;
                        e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_StartPage;
                        e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_EnableAutoCarrierIdRead;
                        e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_EnableAutoCarrierIdRead;
                        e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_DefaultPage;
                        e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_DefaultPage;
                        ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigChanged += E84View_ConfigChanged3;
                        break;
                    default:
                        break;
                }

            }
        }

        private void E84View_ConfigChanged3(object sender)
        {
            NewE84Info e84Info = null;
            foreach (TabItem tabItem in root.Items)
            {
                e84Info = (NewE84Info)tabItem.Content;
                if (e84Info.LoadPortName == "LP4")
                    break;
            }
            if (e84Info == null) return;
            e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_PLInService;
            e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_PLInService;
            e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_DataReadSize;
            e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_DataReadSize;
            e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_StartPage;
            e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_StartPage;
            e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_EnableAutoCarrierIdRead;
            e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_EnableAutoCarrierIdRead;
            e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP4_DefaultPage;
            e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP4_DefaultPage;
        }

        private void E84View_ConfigChanged2(object sender)
        {
            NewE84Info e84Info = null;
            foreach (TabItem tabItem in root.Items)
            {
                e84Info = (NewE84Info)tabItem.Content;
                if (e84Info.LoadPortName == "LP3")
                    break;
            }
            if (e84Info == null) return;
            e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_PLInService;
            e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_PLInService;
            e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_DataReadSize;
            e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_DataReadSize;
            e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_StartPage;
            e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_StartPage;
            e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_EnableAutoCarrierIdRead;
            e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_EnableAutoCarrierIdRead;
            e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP3_DefaultPage;
            e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP3_DefaultPage;
        }

        private void E84View_ConfigChanged(object sender)
        {
            NewE84Info e84Info = null;
            foreach (TabItem tabItem in root.Items)
            {
                e84Info = (NewE84Info)tabItem.Content;
                if (e84Info.LoadPortName == "LP2")
                    break;
            }
            if (e84Info == null) return;
            e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_PLInService;
            e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_PLInService;
            e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_DataReadSize;
            e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_DataReadSize;
            e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_StartPage;
            e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_StartPage;
            e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_EnableAutoCarrierIdRead;
            e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_EnableAutoCarrierIdRead;
            e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP2_DefaultPage;
            e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP2_DefaultPage;
        }

        private void E84View_ConfigChanged1(object sender)
        {
            NewE84Info e84Info = null;
            foreach (TabItem tabItem in root.Items)
            {
                e84Info = (NewE84Info)tabItem.Content;
                if (e84Info.LoadPortName == "LP1")
                    break;
            }
            if (e84Info == null) return;
            e84Info.PLInService.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_PLInService;
            e84Info.PLInService.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_PLInService;
            e84Info.PLDataReadSize.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_DataReadSize;
            e84Info.PLDataReadSize.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_DataReadSize;
            e84Info.PLStartPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_StartPage;
            e84Info.PLStartPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_StartPage;
            e84Info.PLEnableAutoCarrierIdRead.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_EnableAutoCarrierIdRead;
            e84Info.PLEnableAutoCarrierIdRead.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_EnableAutoCarrierIdRead;
            e84Info.PLDefaultPage.ScFeedback = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigFeedback.LoadPort_LP1_DefaultPage;
            e84Info.PLDefaultPage.ScSetPoint = ((NewE84InfoViewModel)e84Info.ConfigBorder.DataContext).ConfigSetPoint.LoadPort_LP1_DefaultPage;
        }


        private void E84Info_Loaded(object sender, RoutedEventArgs e)
        {
            SetControlDefaultValue();
        }
    }

    public class NewE84ViewModel : UIViewModelBase
    {
        int lpCount = 6;
        public NewE84ViewModel() : base("E84ViewModel")
        {

            E84InfoDataLps = new NewE84InfoData[lpCount];
            for (int i = 0; i < lpCount; i++)
            {
                E84InfoDataLps[i] = new NewE84InfoData();
            }
            for (int i = 0; i < lpCount; i++)
            {
                Subscribe($"LP{i + 1}.IsPresent");
                Subscribe($"LP{i + 1}.IsPlaced");
                Subscribe($"LP{i + 1}.IsClamped");
                Subscribe($"LP{i + 1}.IsDocked");
                Subscribe($"LP{i + 1}.LoadportState");
                Subscribe($"LP{i + 1}.TransferState");

                Subscribe($"LP{i + 1}.AccessMode");
                Subscribe($"LP{i + 1}.CarrierIDStatus");
                Subscribe($"LP{i + 1}.SlotMapStatus");
                Subscribe($"LP{i + 1}.AccessStatus");
                Subscribe($"LP{i + 1}.CarrierId");
                Subscribe($"LP{i + 1}.SlotMap");
                Subscribe($"LP{i + 1}.Valid");
                Subscribe($"LP{i + 1}.TransferRequest");
                Subscribe($"LP{i + 1}.Busy");
                Subscribe($"LP{i + 1}.TransferComplete");

                Subscribe($"LP{i + 1}.CS0");
                Subscribe($"LP{i + 1}.CS1");
                Subscribe($"LP{i + 1}.CONT");
                Subscribe($"LP{i + 1}.LoadRequest");
                Subscribe($"LP{i + 1}.UnloadRequest");

                Subscribe($"LP{i + 1}.ReadyToTransfer");
                Subscribe($"LP{i + 1}.HandoffAvailable");
                Subscribe($"LP{i + 1}.ES");
                Subscribe($"LP{i + 1}.E84State");

                Subscribe($"LP{i + 1}.IndicatiorLoad");
                Subscribe($"LP{i + 1}.IndicatiorUnload");
                Subscribe($"LP{i + 1}.IndicatiorPresence");
                Subscribe($"LP{i + 1}.IndicatiorPlacement");
                Subscribe($"LP{i + 1}.IndicatiorAlarm");
                Subscribe($"LP{i + 1}.IndicatiorAccessAuto");
                Subscribe($"LP{i + 1}.IndicatiorAccessManual");
                Subscribe($"LP{i + 1}.IndicatiorOpAccess");
                Subscribe($"LP{i + 1}.IndicatiorStatus1");
                Subscribe($"LP{i + 1}.IndicatiorStatus2");


                Subscribe($"LP{i + 1}.SystemStatus");
                Subscribe($"LP{i + 1}.Mode");
                Subscribe($"LP{i + 1}.InitPosMovement");
                Subscribe($"LP{i + 1}.OperationStatus");
                Subscribe($"LP{i + 1}.ErrorCode");
                Subscribe($"LP{i + 1}.ContainerStatus");
                Subscribe($"LP{i + 1}.ClampPosition");
                Subscribe($"LP{i + 1}.LPDoorLatchPosition");
                Subscribe($"LP{i + 1}.VacuumStatus");
                Subscribe($"LP{i + 1}.LPDoorState");
                Subscribe($"LP{i + 1}.WaferProtrusion");
                Subscribe($"LP{i + 1}.ElevatorAxisPosition");
                Subscribe($"LP{i + 1}.DockPosition");
                Subscribe($"LP{i + 1}.MapperPostion");
                Subscribe($"LP{i + 1}.MappingStatus");
                Subscribe($"LP{i + 1}.IsFosbModeActual");
                Subscribe($"LP{i + 1}.CarrierId");
                Subscribe($"LP{i + 1}.WaferMapThickness");
                
            }
            //E84InfoDataLp2 = new E84InfoData();
            //E84InfoDataLp3 = new E84InfoData();
            //E84InfoDataLp4 = new E84InfoData();
            //E84InfoDataLp5 = new E84InfoData();
            //E84InfoDataLp6 = new E84InfoData();

        }

        public NewE84InfoData[] E84InfoDataLps { get; set; }


        //public E84InfoData E84InfoDataLp2 { get; set; }
        //public E84InfoData E84InfoDataLp3 { get; set; }
        //public E84InfoData E84InfoDataLp4 { get; set; }
        //public E84InfoData E84InfoDataLp5 { get; set; }
        //public E84InfoData E84InfoDataLp6 { get; set; }


        //[Subscription("IsPresent", "LP1")]
        //public bool PodPresentLp1
        //{
        //    get => E84InfoDataLp1.PodPresent;
        //    set => E84InfoDataLp1.PodPresent = value;
        //}

        //[Subscription(ParamName.IsPresent, "LP2")]
        //public bool PodPresentLp2
        //{
        //    get => E84InfoDataLp2.PodPresent;
        //    set => E84InfoDataLp2.PodPresent = value;
        //}

        //[Subscription(ParamName.IsPresent, "LP3")]
        //public bool PodPresentLp3
        //{
        //    get => E84InfoDataLp3.PodPresent;
        //    set => E84InfoDataLp3.PodPresent = value;
        //}

        //[Subscription(ParamName.IsPresent, "LP4")]
        //public bool PodPresentLp4
        //{
        //    get => E84InfoDataLp4.PodPresent;
        //    set => E84InfoDataLp4.PodPresent = value;
        //}

        //[Subscription(ParamName.IsPresent, "LP5")]
        //public bool PodPresentLp5
        //{
        //    get => E84InfoDataLp5.PodPresent;
        //    set => E84InfoDataLp5.PodPresent = value;
        //}

        //[Subscription(ParamName.IsPresent, "LP6")]
        //public bool PodPresentLp6
        //{
        //    get => E84InfoDataLp6.PodPresent;
        //    set => E84InfoDataLp6.PodPresent = value;
        //}

        //[Subscription(ParamName.IsPlaced, "LP1")]
        //public bool PodPlacedLp1
        //{
        //    get => E84InfoDataLp1.PodPlaced;
        //    set => E84InfoDataLp1.PodPlaced = value;
        //}

        //[Subscription(ParamName.IsPlaced, "LP2")]
        //public bool PodPlacedLp2
        //{
        //    get => E84InfoDataLp2.PodPlaced;
        //    set => E84InfoDataLp2.PodPlaced = value;
        //}

        //[Subscription(ParamName.IsPlaced, "LP3")]
        //public bool PodPlacedLp3
        //{
        //    get => E84InfoDataLp3.PodPlaced;
        //    set => E84InfoDataLp3.PodPlaced = value;
        //}

        //[Subscription(ParamName.IsPlaced, "LP4")]
        //public bool PodPlacedLp4
        //{
        //    get => E84InfoDataLp4.PodPlaced;
        //    set => E84InfoDataLp4.PodPlaced = value;
        //}

        //[Subscription(ParamName.IsPlaced, "LP5")]
        //public bool PodPlacedLp5
        //{
        //    get => E84InfoDataLp5.PodPlaced;
        //    set => E84InfoDataLp5.PodPlaced = value;
        //}

        //[Subscription(ParamName.IsPlaced, "LP6")]
        //public bool PodPlacedLp6
        //{
        //    get => E84InfoDataLp6.PodPlaced;
        //    set => E84InfoDataLp6.PodPlaced = value;
        //}

        //[Subscription(ParamName.IsClamped, "LP1")]
        //public bool PodLatchedLp1
        //{
        //    get => E84InfoDataLp1.PodLatched;
        //    set => E84InfoDataLp1.PodLatched = value;
        //}

        //[Subscription(ParamName.IsClamped, "LP2")]
        //public bool PodLatchedLp2
        //{
        //    get => E84InfoDataLp2.PodLatched;
        //    set => E84InfoDataLp2.PodLatched = value;
        //}

        //[Subscription(ParamName.IsClamped, "LP3")]
        //public bool PodLatchedLp3
        //{
        //    get => E84InfoDataLp3.PodLatched;
        //    set => E84InfoDataLp3.PodLatched = value;
        //}

        //[Subscription(ParamName.IsClamped, "LP4")]
        //public bool PodLatchedLp4
        //{
        //    get => E84InfoDataLp4.PodLatched;
        //    set => E84InfoDataLp4.PodLatched = value;
        //}

        //[Subscription(ParamName.IsClamped, "LP5")]
        //public bool PodLatchedLp5
        //{
        //    get => E84InfoDataLp5.PodLatched;
        //    set => E84InfoDataLp5.PodLatched = value;
        //}

        //[Subscription(ParamName.IsClamped, "LP6")]
        //public bool PodLatchedLp6
        //{
        //    get => E84InfoDataLp6.PodLatched;
        //    set => E84InfoDataLp6.PodLatched = value;
        //}

        //[Subscription(ParamName.IsDocked, "LP1")]
        //public bool PodDockedLp1
        //{
        //    get => E84InfoDataLp1.PodDocked;
        //    set => E84InfoDataLp1.PodDocked = value;
        //}

        //[Subscription(ParamName.IsDocked, "LP2")]
        //public bool PodDockedLp2
        //{
        //    get => E84InfoDataLp2.PodDocked;
        //    set => E84InfoDataLp2.PodDocked = value;
        //}

        //[Subscription(ParamName.IsDocked, "LP3")]
        //public bool PodDockedLp3
        //{
        //    get => E84InfoDataLp3.PodDocked;
        //    set => E84InfoDataLp3.PodDocked = value;
        //}

        //[Subscription(ParamName.IsDocked, "LP4")]
        //public bool PodDockedLp4
        //{
        //    get => E84InfoDataLp4.PodDocked;
        //    set => E84InfoDataLp4.PodDocked = value;
        //}

        //[Subscription(ParamName.IsDocked, "LP5")]
        //public bool PodDockedLp5
        //{
        //    get => E84InfoDataLp5.PodDocked;
        //    set => E84InfoDataLp5.PodDocked = value;
        //}

        //[Subscription(ParamName.IsDocked, "LP6")]
        //public bool PodDockedLp6
        //{
        //    get => E84InfoDataLp6.PodDocked;
        //    set => E84InfoDataLp6.PodDocked = value;
        //}

        //[Subscription(ParamName.LoadportState, "LP1")]
        //public string LoadPortStateLp1
        //{
        //    get => E84InfoDataLp1.LoadPortState;
        //    set => E84InfoDataLp1.LoadPortState = value;
        //}

        //[Subscription(ParamName.LoadportState, "LP2")]
        //public string LoadPortStateLp2
        //{
        //    get => E84InfoDataLp2.LoadPortState;
        //    set => E84InfoDataLp2.LoadPortState = value;
        //}

        //[Subscription(ParamName.LoadportState, "LP3")]
        //public string LoadPortStateLp3
        //{
        //    get => E84InfoDataLp3.LoadPortState;
        //    set => E84InfoDataLp3.LoadPortState = value;
        //}

        //[Subscription(ParamName.LoadportState, "LP4")]
        //public string LoadPortStateLp4
        //{
        //    get => E84InfoDataLp4.LoadPortState;
        //    set => E84InfoDataLp4.LoadPortState = value;
        //}

        //[Subscription(ParamName.LoadportState, "LP5")]
        //public string LoadPortStateLp5
        //{
        //    get => E84InfoDataLp5.LoadPortState;
        //    set => E84InfoDataLp5.LoadPortState = value;
        //}

        //[Subscription(ParamName.LoadportState, "LP6")]
        //public string LoadPortStateLp6
        //{
        //    get => E84InfoDataLp6.LoadPortState;
        //    set => E84InfoDataLp6.LoadPortState = value;
        //}

        //[Subscription("TransferState", "LP1")]
        //public string PortStateLp1
        //{
        //    get => E84InfoDataLp1.PortState;
        //    set => E84InfoDataLp1.PortState = value;
        //}

        //[Subscription("TransferState", "LP2")]
        //public string PortStateLp2
        //{
        //    get => E84InfoDataLp2.PortState;
        //    set => E84InfoDataLp2.PortState = value;
        //}

        //[Subscription("TransferState", "LP3")]
        //public string PortStateLp3
        //{
        //    get => E84InfoDataLp3.PortState;
        //    set => E84InfoDataLp3.PortState = value;
        //}

        //[Subscription("TransferState", "LP4")]
        //public string PortStateLp4
        //{
        //    get => E84InfoDataLp4.PortState;
        //    set => E84InfoDataLp4.PortState = value;
        //}
        //[Subscription("TransferState", "LP5")]
        //public string PortStateLp5
        //{
        //    get => E84InfoDataLp5.PortState;
        //    set => E84InfoDataLp5.PortState = value;
        //}
        //[Subscription("TransferState", "LP6")]
        //public string PortStateLp6
        //{
        //    get => E84InfoDataLp6.PortState;
        //    set => E84InfoDataLp6.PortState = value;
        //}
        //[Subscription("AccessMode", "LP1")]
        //public string AccessModeLp1
        //{
        //    get => E84InfoDataLp1.AccessMode;
        //    set => E84InfoDataLp1.AccessMode = value;
        //}

        //[Subscription("AccessMode", "LP2")]
        //public string AccessModeLp2
        //{
        //    get => E84InfoDataLp2.AccessMode;
        //    set => E84InfoDataLp2.AccessMode = value;
        //}

        //[Subscription("AccessMode", "LP3")]
        //public string AccessModeLp3
        //{
        //    get => E84InfoDataLp3.AccessMode;
        //    set => E84InfoDataLp3.AccessMode = value;
        //}

        //[Subscription("AccessMode", "LP4")]
        //public string AccessModeLp4
        //{
        //    get => E84InfoDataLp4.AccessMode;
        //    set => E84InfoDataLp4.AccessMode = value;
        //}

        //[Subscription("AccessMode", "LP5")]
        //public string AccessModeLp5
        //{
        //    get => E84InfoDataLp5.AccessMode;
        //    set => E84InfoDataLp5.AccessMode = value;
        //}

        //[Subscription("AccessMode", "LP6")]
        //public string AccessModeLp6
        //{
        //    get => E84InfoDataLp6.AccessMode;
        //    set => E84InfoDataLp6.AccessMode = value;
        //}

        //[Subscription("CarrierIDStatus", "LP1")]
        //public string CarrierIDStatusLP1
        //{
        //    get => E84InfoDataLp1.CarrierIDStatus;
        //    set => E84InfoDataLp1.CarrierIDStatus = value;
        //}
        //[Subscription("CarrierIDStatus", "LP2")]
        //public string CarrierIDStatusLP2
        //{
        //    get => E84InfoDataLp2.CarrierIDStatus;
        //    set => E84InfoDataLp2.CarrierIDStatus = value;
        //}
        //[Subscription("CarrierIDStatus", "LP3")]
        //public string CarrierIDStatusLP3
        //{
        //    get => E84InfoDataLp3.CarrierIDStatus;
        //    set => E84InfoDataLp3.CarrierIDStatus = value;
        //}
        //[Subscription("CarrierIDStatus", "LP4")]
        //public string CarrierIDStatusLP4
        //{
        //    get => E84InfoDataLp4.CarrierIDStatus;
        //    set => E84InfoDataLp4.CarrierIDStatus = value;
        //}

        //[Subscription("CarrierIDStatus", "LP5")]
        //public string CarrierIDStatusLP5
        //{
        //    get => E84InfoDataLp5.CarrierIDStatus;
        //    set => E84InfoDataLp5.CarrierIDStatus = value;
        //}

        //[Subscription("CarrierIDStatus", "LP6")]
        //public string CarrierIDStatusLP6
        //{
        //    get => E84InfoDataLp6.CarrierIDStatus;
        //    set => E84InfoDataLp6.CarrierIDStatus = value;
        //}

        //[Subscription("SlotMapStatus", "LP1")]
        //public string SlotMapStatusLP1
        //{
        //    get => E84InfoDataLp1.SlotMapStatus;
        //    set => E84InfoDataLp1.SlotMapStatus = value;
        //}
        //[Subscription("SlotMapStatus", "LP2")]
        //public string SlotMapStatusLP2
        //{
        //    get => E84InfoDataLp2.SlotMapStatus;
        //    set => E84InfoDataLp2.SlotMapStatus = value;
        //}
        //[Subscription("SlotMapStatus", "LP3")]
        //public string SlotMapStatusLP3
        //{
        //    get => E84InfoDataLp3.SlotMapStatus;
        //    set => E84InfoDataLp3.SlotMapStatus = value;
        //}
        //[Subscription("SlotMapStatus", "LP4")]
        //public string SlotMapStatusLP4
        //{
        //    get => E84InfoDataLp4.SlotMapStatus;
        //    set => E84InfoDataLp4.SlotMapStatus = value;
        //}
        //[Subscription("SlotMapStatus", "LP5")]
        //public string SlotMapStatusLP5
        //{
        //    get => E84InfoDataLp5.SlotMapStatus;
        //    set => E84InfoDataLp5.SlotMapStatus = value;
        //}
        //[Subscription("SlotMapStatus", "LP6")]
        //public string SlotMapStatusLP6
        //{
        //    get => E84InfoDataLp6.SlotMapStatus;
        //    set => E84InfoDataLp6.SlotMapStatus = value;
        //}
        //[Subscription("AccessStatus", "LP1")]
        //public string AccessStatusLP1
        //{
        //    get => E84InfoDataLp1.AccessStatus;
        //    set => E84InfoDataLp1.AccessStatus = value;
        //}
        //[Subscription("AccessStatus", "LP2")]
        //public string AccessStatusLP2
        //{
        //    get => E84InfoDataLp2.AccessStatus;
        //    set => E84InfoDataLp2.AccessStatus = value;
        //}
        //[Subscription("AccessStatus", "LP3")]
        //public string AccessStatusLP3
        //{
        //    get => E84InfoDataLp3.AccessStatus;
        //    set => E84InfoDataLp3.AccessStatus = value;
        //}
        //[Subscription("AccessStatus", "LP4")]
        //public string AccessStatusLP4
        //{
        //    get => E84InfoDataLp4.AccessStatus;
        //    set => E84InfoDataLp4.AccessStatus = value;
        //}
        //[Subscription("AccessStatus", "LP5")]
        //public string AccessStatusLP5
        //{
        //    get => E84InfoDataLp5.AccessStatus;
        //    set => E84InfoDataLp5.AccessStatus = value;
        //}
        //[Subscription("AccessStatus", "LP6")]
        //public string AccessStatusLP6
        //{
        //    get => E84InfoDataLp6.AccessStatus;
        //    set => E84InfoDataLp6.AccessStatus = value;
        //}



        //[Subscription(ParamName.CarrierId, DeviceName.LP1)]
        //public string CarrierIdLp1
        //{
        //    get => E84InfoDataLp1.CarrierID;
        //    set => E84InfoDataLp1.CarrierID = value;
        //}

        //[Subscription(ParamName.CarrierId, DeviceName.LP2)]
        //public string CarrierIdLp2
        //{
        //    get => E84InfoDataLp2.CarrierID;
        //    set => E84InfoDataLp2.CarrierID = value;
        //}

        //[Subscription(ParamName.CarrierId, DeviceName.LP3)]
        //public string CarrierIdLp3
        //{
        //    get => E84InfoDataLp3.CarrierID;
        //    set => E84InfoDataLp3.CarrierID = value;
        //}

        //[Subscription(ParamName.CarrierId, DeviceName.LP4)]
        //public string CarrierIdLp4
        //{
        //    get => E84InfoDataLp4.CarrierID;
        //    set => E84InfoDataLp4.CarrierID = value;
        //}

        //[Subscription(ParamName.CarrierId, DeviceName.LP5)]
        //public string CarrierIdLp5
        //{
        //    get => E84InfoDataLp5.CarrierID;
        //    set => E84InfoDataLp5.CarrierID = value;
        //}

        //[Subscription(ParamName.CarrierId, DeviceName.LP6)]
        //public string CarrierIdLp6
        //{
        //    get => E84InfoDataLp6.CarrierID;
        //    set => E84InfoDataLp6.CarrierID = value;
        //}

        //[Subscription(ParamName.SlotMap, DeviceName.LP1)]
        //public string SlotMapLp1
        //{
        //    get => E84InfoDataLp1.SlotMap;
        //    set => E84InfoDataLp1.SlotMap = value;
        //}

        //[Subscription(ParamName.SlotMap, DeviceName.LP2)]
        //public string SlotMapLp2
        //{
        //    get => E84InfoDataLp2.SlotMap;
        //    set => E84InfoDataLp2.SlotMap = value;
        //}

        //[Subscription(ParamName.SlotMap, DeviceName.LP3)]
        //public string SlotMapLp3
        //{
        //    get => E84InfoDataLp3.SlotMap;
        //    set => E84InfoDataLp3.SlotMap = value;
        //}

        //[Subscription(ParamName.SlotMap, DeviceName.LP4)]
        //public string SlotMapLp4
        //{
        //    get => E84InfoDataLp4.SlotMap;
        //    set => E84InfoDataLp4.SlotMap = value;
        //}

        //[Subscription(ParamName.SlotMap, DeviceName.LP5)]
        //public string SlotMapLp5
        //{
        //    get => E84InfoDataLp5.SlotMap;
        //    set => E84InfoDataLp5.SlotMap = value;
        //}

        //[Subscription(ParamName.SlotMap, DeviceName.LP6)]
        //public string SlotMapLp6
        //{
        //    get => E84InfoDataLp6.SlotMap;
        //    set => E84InfoDataLp6.SlotMap = value;
        //}

        //[Subscription("Valid", DeviceName.LP1)]
        //public bool ValidLp1
        //{
        //    get => E84InfoDataLp1.Valid;
        //    set => E84InfoDataLp1.Valid = value;
        //}

        //[Subscription("Valid", DeviceName.LP2)]
        //public bool ValidLp2
        //{
        //    get => E84InfoDataLp2.Valid;
        //    set => E84InfoDataLp2.Valid = value;
        //}

        //[Subscription("Valid", DeviceName.LP3)]
        //public bool ValidLp3
        //{
        //    get => E84InfoDataLp3.Valid;
        //    set => E84InfoDataLp3.Valid = value;
        //}

        //[Subscription("Valid", DeviceName.LP4)]
        //public bool ValidLp4
        //{
        //    get => E84InfoDataLp4.Valid;
        //    set => E84InfoDataLp4.Valid = value;
        //}

        //[Subscription("Valid", DeviceName.LP5)]
        //public bool ValidLp5
        //{
        //    get => E84InfoDataLp5.Valid;
        //    set => E84InfoDataLp5.Valid = value;
        //}

        //[Subscription("Valid", DeviceName.LP6)]
        //public bool ValidLp6
        //{
        //    get => E84InfoDataLp6.Valid;
        //    set => E84InfoDataLp6.Valid = value;
        //}

        //[Subscription("TransferRequest", DeviceName.LP1)]
        //public bool TransferRequestLp1
        //{
        //    get => E84InfoDataLp1.TransferRequest;
        //    set => E84InfoDataLp1.TransferRequest = value;
        //}

        //[Subscription("TransferRequest", DeviceName.LP2)]
        //public bool TransferRequestLp2
        //{
        //    get => E84InfoDataLp2.TransferRequest;
        //    set => E84InfoDataLp2.TransferRequest = value;
        //}

        //[Subscription("TransferRequest", DeviceName.LP3)]
        //public bool TransferRequestLp3
        //{
        //    get => E84InfoDataLp3.TransferRequest;
        //    set => E84InfoDataLp3.TransferRequest = value;
        //}

        //[Subscription("TransferRequest", DeviceName.LP4)]
        //public bool TransferRequestLp4
        //{
        //    get => E84InfoDataLp4.TransferRequest;
        //    set => E84InfoDataLp4.TransferRequest = value;
        //}

        //[Subscription("TransferRequest", DeviceName.LP5)]
        //public bool TransferRequestLp5
        //{
        //    get => E84InfoDataLp5.TransferRequest;
        //    set => E84InfoDataLp5.TransferRequest = value;
        //}

        //[Subscription("TransferRequest", DeviceName.LP6)]
        //public bool TransferRequestLp6
        //{
        //    get => E84InfoDataLp6.TransferRequest;
        //    set => E84InfoDataLp6.TransferRequest = value;
        //}

        //[Subscription("Busy", DeviceName.LP1)]
        //public bool BusyLp1
        //{
        //    get => E84InfoDataLp1.Busy;
        //    set => E84InfoDataLp1.Busy = value;
        //}

        //[Subscription("Busy", DeviceName.LP2)]
        //public bool BusyLp2
        //{
        //    get => E84InfoDataLp2.Busy;
        //    set => E84InfoDataLp2.Busy = value;
        //}

        //[Subscription("Busy", DeviceName.LP3)]
        //public bool BusyLp3
        //{
        //    get => E84InfoDataLp3.Busy;
        //    set => E84InfoDataLp3.Busy = value;
        //}

        //[Subscription("Busy", DeviceName.LP4)]
        //public bool BusyLp4
        //{
        //    get => E84InfoDataLp4.Busy;
        //    set => E84InfoDataLp4.Busy = value;
        //}

        //[Subscription("Busy", DeviceName.LP5)]
        //public bool BusyLp5
        //{
        //    get => E84InfoDataLp5.Busy;
        //    set => E84InfoDataLp5.Busy = value;
        //}

        //[Subscription("Busy", DeviceName.LP6)]
        //public bool BusyLp6
        //{
        //    get => E84InfoDataLp6.Busy;
        //    set => E84InfoDataLp6.Busy = value;
        //}

        //[Subscription("TransferComplete", DeviceName.LP1)]
        //public bool TransferCompleteLp1
        //{
        //    get => E84InfoDataLp1.TransferComplete;
        //    set => E84InfoDataLp1.TransferComplete = value;
        //}

        //[Subscription("TransferComplete", DeviceName.LP2)]
        //public bool TransferCompleteLp2
        //{
        //    get => E84InfoDataLp2.TransferComplete;
        //    set => E84InfoDataLp2.TransferComplete = value;
        //}

        //[Subscription("TransferComplete", DeviceName.LP3)]
        //public bool TransferCompleteLp3
        //{
        //    get => E84InfoDataLp3.TransferComplete;
        //    set => E84InfoDataLp3.TransferComplete = value;
        //}

        //[Subscription("TransferComplete", DeviceName.LP4)]
        //public bool TransferCompleteLp4
        //{
        //    get => E84InfoDataLp4.TransferComplete;
        //    set => E84InfoDataLp4.TransferComplete = value;
        //}

        //[Subscription("TransferComplete", DeviceName.LP5)]
        //public bool TransferCompleteLp5
        //{
        //    get => E84InfoDataLp5.TransferComplete;
        //    set => E84InfoDataLp5.TransferComplete = value;
        //}

        //[Subscription("TransferComplete", DeviceName.LP6)]
        //public bool TransferCompleteLp6
        //{
        //    get => E84InfoDataLp6.TransferComplete;
        //    set => E84InfoDataLp6.TransferComplete = value;
        //}

        //[Subscription("CS0", DeviceName.LP1)]
        //public bool CS0Lp1
        //{
        //    get => E84InfoDataLp1.CS0;
        //    set => E84InfoDataLp1.CS0 = value;
        //}

        //[Subscription("CS0", DeviceName.LP2)]
        //public bool CS0Lp2
        //{
        //    get => E84InfoDataLp2.CS0;
        //    set => E84InfoDataLp2.CS0 = value;
        //}

        //[Subscription("CS0", DeviceName.LP3)]
        //public bool CS0Lp3
        //{
        //    get => E84InfoDataLp3.CS0;
        //    set => E84InfoDataLp3.CS0 = value;
        //}

        //[Subscription("CS0", DeviceName.LP4)]
        //public bool CS0Lp4
        //{
        //    get => E84InfoDataLp4.CS0;
        //    set => E84InfoDataLp4.CS0 = value;
        //}

        //[Subscription("CS0", DeviceName.LP5)]
        //public bool CS0Lp5
        //{
        //    get => E84InfoDataLp5.CS0;
        //    set => E84InfoDataLp5.CS0 = value;
        //}

        //[Subscription("CS0", DeviceName.LP6)]
        //public bool CS0Lp6
        //{
        //    get => E84InfoDataLp6.CS0;
        //    set => E84InfoDataLp6.CS0 = value;
        //}

        //[Subscription("CS1", DeviceName.LP1)]
        //public bool CS1Lp1
        //{
        //    get => E84InfoDataLp1.CS1;
        //    set => E84InfoDataLp1.CS1 = value;
        //}

        //[Subscription("CS1", DeviceName.LP2)]
        //public bool CS1Lp2
        //{
        //    get => E84InfoDataLp2.CS1;
        //    set => E84InfoDataLp2.CS1 = value;
        //}

        //[Subscription("CS1", DeviceName.LP3)]
        //public bool CS1Lp3
        //{
        //    get => E84InfoDataLp3.CS1;
        //    set => E84InfoDataLp3.CS1 = value;
        //}

        //[Subscription("CS1", DeviceName.LP4)]
        //public bool CS1Lp4
        //{
        //    get => E84InfoDataLp4.CS1;
        //    set => E84InfoDataLp4.CS1 = value;
        //}

        //[Subscription("CS1", DeviceName.LP5)]
        //public bool CS1Lp5
        //{
        //    get => E84InfoDataLp5.CS1;
        //    set => E84InfoDataLp5.CS1 = value;
        //}

        //[Subscription("CS1", DeviceName.LP6)]
        //public bool CS1Lp6
        //{
        //    get => E84InfoDataLp6.CS1;
        //    set => E84InfoDataLp6.CS1 = value;
        //}


        //[Subscription("CONT", DeviceName.LP1)]
        //public bool ContinuousTransferLp1
        //{
        //    get => E84InfoDataLp1.ContinuousTransfer;
        //    set => E84InfoDataLp1.ContinuousTransfer = value;
        //}

        //[Subscription("CONT", DeviceName.LP2)]
        //public bool ContinuousTransferLp2
        //{
        //    get => E84InfoDataLp2.ContinuousTransfer;
        //    set => E84InfoDataLp2.ContinuousTransfer = value;
        //}

        //[Subscription("CONT", DeviceName.LP3)]
        //public bool ContinuousTransferLp3
        //{
        //    get => E84InfoDataLp3.ContinuousTransfer;
        //    set => E84InfoDataLp3.ContinuousTransfer = value;
        //}

        //[Subscription("CONT", DeviceName.LP4)]
        //public bool ContinuousTransferLp4
        //{
        //    get => E84InfoDataLp4.ContinuousTransfer;
        //    set => E84InfoDataLp4.ContinuousTransfer = value;
        //}

        //[Subscription("CONT", DeviceName.LP5)]
        //public bool ContinuousTransferLp5
        //{
        //    get => E84InfoDataLp5.ContinuousTransfer;
        //    set => E84InfoDataLp5.ContinuousTransfer = value;
        //}

        //[Subscription("CONT", DeviceName.LP6)]
        //public bool ContinuousTransferLp6
        //{
        //    get => E84InfoDataLp6.ContinuousTransfer;
        //    set => E84InfoDataLp6.ContinuousTransfer = value;
        //}

        //[Subscription("LoadRequest", DeviceName.LP1)]
        //public bool LoadRequestLp1
        //{
        //    get => E84InfoDataLp1.LoadRequest;
        //    set => E84InfoDataLp1.LoadRequest = value;
        //}

        //[Subscription("LoadRequest", DeviceName.LP2)]
        //public bool LoadRequestLp2
        //{
        //    get => E84InfoDataLp2.LoadRequest;
        //    set => E84InfoDataLp2.LoadRequest = value;
        //}

        //[Subscription("LoadRequest", DeviceName.LP3)]
        //public bool LoadRequestLp3
        //{
        //    get => E84InfoDataLp3.LoadRequest;
        //    set => E84InfoDataLp3.LoadRequest = value;
        //}

        //[Subscription("LoadRequest", DeviceName.LP4)]
        //public bool LoadRequestLp4
        //{
        //    get => E84InfoDataLp4.LoadRequest;
        //    set => E84InfoDataLp4.LoadRequest = value;
        //}

        //[Subscription("LoadRequest", DeviceName.LP5)]
        //public bool LoadRequestLp5
        //{
        //    get => E84InfoDataLp5.LoadRequest;
        //    set => E84InfoDataLp5.LoadRequest = value;
        //}

        //[Subscription("LoadRequest", DeviceName.LP6)]
        //public bool LoadRequestLp6
        //{
        //    get => E84InfoDataLp6.LoadRequest;
        //    set => E84InfoDataLp6.LoadRequest = value;
        //}

        //[Subscription("UnloadRequest", DeviceName.LP1)]
        //public bool UnloadRequestLp1
        //{
        //    get => E84InfoDataLp1.UnloadRequest;
        //    set => E84InfoDataLp1.UnloadRequest = value;
        //}

        //[Subscription("UnloadRequest", DeviceName.LP2)]
        //public bool UnloadRequestLp2
        //{
        //    get => E84InfoDataLp2.UnloadRequest;
        //    set => E84InfoDataLp2.UnloadRequest = value;
        //}

        //[Subscription("UnloadRequest", DeviceName.LP3)]
        //public bool UnloadRequestLp3
        //{
        //    get => E84InfoDataLp3.UnloadRequest;
        //    set => E84InfoDataLp3.UnloadRequest = value;
        //}

        //[Subscription("UnloadRequest", DeviceName.LP4)]
        //public bool UnloadRequestLp4
        //{
        //    get => E84InfoDataLp4.UnloadRequest;
        //    set => E84InfoDataLp4.UnloadRequest = value;
        //}

        //[Subscription("UnloadRequest", DeviceName.LP5)]
        //public bool UnloadRequestLp5
        //{
        //    get => E84InfoDataLp5.UnloadRequest;
        //    set => E84InfoDataLp5.UnloadRequest = value;
        //}

        //[Subscription("UnloadRequest", DeviceName.LP6)]
        //public bool UnloadRequestLp6
        //{
        //    get => E84InfoDataLp6.UnloadRequest;
        //    set => E84InfoDataLp6.UnloadRequest = value;
        //}

        //[Subscription("ReadyToTransfer", DeviceName.LP1)]
        //public bool ReadyToTransferLp1
        //{
        //    get => E84InfoDataLp1.ReadyToTransfer;
        //    set => E84InfoDataLp1.ReadyToTransfer = value;
        //}

        //[Subscription("ReadyToTransfer", DeviceName.LP2)]
        //public bool ReadyToTransferLp2
        //{
        //    get => E84InfoDataLp2.ReadyToTransfer;
        //    set => E84InfoDataLp2.ReadyToTransfer = value;
        //}

        //[Subscription("ReadyToTransfer", DeviceName.LP3)]
        //public bool ReadyToTransferLp3
        //{
        //    get => E84InfoDataLp3.ReadyToTransfer;
        //    set => E84InfoDataLp3.ReadyToTransfer = value;
        //}

        //[Subscription("ReadyToTransfer", DeviceName.LP4)]
        //public bool ReadyToTransferLp4
        //{
        //    get => E84InfoDataLp4.ReadyToTransfer;
        //    set => E84InfoDataLp4.ReadyToTransfer = value;
        //}

        //[Subscription("ReadyToTransfer", DeviceName.LP5)]
        //public bool ReadyToTransferLp5
        //{
        //    get => E84InfoDataLp5.ReadyToTransfer;
        //    set => E84InfoDataLp5.ReadyToTransfer = value;
        //}

        //[Subscription("ReadyToTransfer", DeviceName.LP6)]
        //public bool ReadyToTransferLp6
        //{
        //    get => E84InfoDataLp6.ReadyToTransfer;
        //    set => E84InfoDataLp6.ReadyToTransfer = value;
        //}

        //[Subscription("HandoffAvailable", DeviceName.LP1)]
        //public bool HandoffAvailableLp1
        //{
        //    get => E84InfoDataLp1.HandoffAvailable;
        //    set => E84InfoDataLp1.HandoffAvailable = value;
        //}

        //[Subscription("HandoffAvailable", DeviceName.LP2)]
        //public bool HandoffAvailableLp2
        //{
        //    get => E84InfoDataLp2.HandoffAvailable;
        //    set => E84InfoDataLp2.HandoffAvailable = value;
        //}

        //[Subscription("HandoffAvailable", DeviceName.LP3)]
        //public bool HandoffAvailableLp3
        //{
        //    get => E84InfoDataLp3.HandoffAvailable;
        //    set => E84InfoDataLp3.HandoffAvailable = value;
        //}

        //[Subscription("HandoffAvailable", DeviceName.LP4)]
        //public bool HandoffAvailableLp4
        //{
        //    get => E84InfoDataLp4.HandoffAvailable;
        //    set => E84InfoDataLp4.HandoffAvailable = value;
        //}

        //[Subscription("HandoffAvailable", DeviceName.LP5)]
        //public bool HandoffAvailableLp5
        //{
        //    get => E84InfoDataLp5.HandoffAvailable;
        //    set => E84InfoDataLp5.HandoffAvailable = value;
        //}

        //[Subscription("HandoffAvailable", DeviceName.LP6)]
        //public bool HandoffAvailableLp6
        //{
        //    get => E84InfoDataLp6.HandoffAvailable;
        //    set => E84InfoDataLp6.HandoffAvailable = value;
        //}

        //[Subscription("ES", DeviceName.LP1)]
        //public bool EmergencyOkLp1
        //{
        //    get => E84InfoDataLp1.EmergencyOk;
        //    set => E84InfoDataLp1.EmergencyOk = value;
        //}

        //[Subscription("ES", DeviceName.LP2)]
        //public bool EmergencyOkLp2
        //{
        //    get => E84InfoDataLp2.EmergencyOk;
        //    set => E84InfoDataLp2.EmergencyOk = value;
        //}

        //[Subscription("ES", DeviceName.LP3)]
        //public bool EmergencyOkLp3
        //{
        //    get => E84InfoDataLp3.EmergencyOk;
        //    set => E84InfoDataLp3.EmergencyOk = value;
        //}

        //[Subscription("ES", DeviceName.LP4)]
        //public bool EmergencyOkLp4
        //{
        //    get => E84InfoDataLp4.EmergencyOk;
        //    set => E84InfoDataLp4.EmergencyOk = value;
        //}

        //[Subscription("ES", DeviceName.LP5)]
        //public bool EmergencyOkLp5
        //{
        //    get => E84InfoDataLp5.EmergencyOk;
        //    set => E84InfoDataLp5.EmergencyOk = value;
        //}

        //[Subscription("ES", DeviceName.LP6)]
        //public bool EmergencyOkLp6
        //{
        //    get => E84InfoDataLp6.EmergencyOk;
        //    set => E84InfoDataLp6.EmergencyOk = value;
        //}

        //[Subscription("E84State", "LP1")]
        //public string E84StateLp1
        //{
        //    get => E84InfoDataLp1.E84State;
        //    set => E84InfoDataLp1.E84State = value;
        //}

        //[Subscription("E84State", "LP2")]
        //public string E84StateLp2
        //{
        //    get => E84InfoDataLp2.E84State;
        //    set => E84InfoDataLp2.E84State = value;
        //}

        //[Subscription("E84State", "LP3")]
        //public string E84StateLp3
        //{
        //    get => E84InfoDataLp3.E84State;
        //    set => E84InfoDataLp3.E84State = value;
        //}

        //[Subscription("E84State", "LP4")]
        //public string E84StateLp4
        //{
        //    get => E84InfoDataLp4.E84State;
        //    set => E84InfoDataLp4.E84State = value;
        //}

        //[Subscription("E84State", "LP5")]
        //public string E84StateLp5
        //{
        //    get => E84InfoDataLp5.E84State;
        //    set => E84InfoDataLp5.E84State = value;
        //}

        //[Subscription("E84State", "LP6")]
        //public string E84StateLp6
        //{
        //    get => E84InfoDataLp6.E84State;
        //    set => E84InfoDataLp6.E84State = value;
        //}


        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {
            foreach (var item in data.Keys)
            {
                var tempValue = item;
                int lpIndex = 0;
                if (item.Substring(0, 1) == ".")
                { tempValue = item.Substring(1, item.Length - 1); }
                if (tempValue.Substring(0, 2) == "LP")
                {
                    lpIndex = int.Parse(tempValue.Split('.')[0].Substring(2));
                }
                switch (tempValue.Split('.')[1])
                {
                    case "IsPresent":
                        E84InfoDataLps[lpIndex - 1].PodPresent = (bool)data[item];
                        break;
                    case "IsPlaced":
                        E84InfoDataLps[lpIndex - 1].PodPlaced = (bool)data[item];
                        break;
                    case "IsClamped":
                        E84InfoDataLps[lpIndex - 1].PodLatched = (bool)data[item];
                        break;
                    case "IsDocked":
                        E84InfoDataLps[lpIndex - 1].PodDocked = (bool)data[item];
                        break;
                    case "LoadportState":
                        E84InfoDataLps[lpIndex - 1].LoadPortState = (string)data[item];
                        break;
                    case "TransferState":
                        E84InfoDataLps[lpIndex - 1].PortState = (string)data[item];
                        break;
                    case "AccessMode":
                        E84InfoDataLps[lpIndex - 1].AccessMode = (string)data[item];
                        break;
                    case "CarrierIDStatus":
                        E84InfoDataLps[lpIndex - 1].CarrierIDStatus = (string)data[item];
                        break;
                    case "SlotMapStatus":
                        E84InfoDataLps[lpIndex - 1].SlotMapStatus = (string)data[item];
                        break;
                    case "AccessStatus":
                        E84InfoDataLps[lpIndex - 1].AccessStatus = (string)data[item];
                        break;
                    case "CarrierId":
                        E84InfoDataLps[lpIndex - 1].CarrierID = (string)data[item];
                        break;
                    case "SlotMap":
                        E84InfoDataLps[lpIndex - 1].SlotMap = (string)data[item];
                        break;
                    case "Valid":
                        E84InfoDataLps[lpIndex - 1].Valid = (bool)data[item];
                        break;
                    case "TransferRequest":
                        E84InfoDataLps[lpIndex - 1].TransferRequest = (bool)data[item];
                        break;
                    case "Busy":
                        E84InfoDataLps[lpIndex - 1].Busy = (bool)data[item];
                        break;
                    case "TransferComplete":
                        E84InfoDataLps[lpIndex - 1].TransferComplete = (bool)data[item];
                        break;
                    case "CS0":
                        E84InfoDataLps[lpIndex - 1].CS0 = (bool)data[item];
                        break;
                    case "CS1":
                        E84InfoDataLps[lpIndex - 1].CS1 = (bool)data[item];
                        break;
                    case "CONT":
                        E84InfoDataLps[lpIndex - 1].ContinuousTransfer = (bool)data[item];
                        break;
                    case "LoadRequest":
                        E84InfoDataLps[lpIndex - 1].LoadRequest = (bool)data[item];
                        break;
                    case "UnloadRequest":
                        E84InfoDataLps[lpIndex - 1].UnloadRequest = (bool)data[item];
                        break;
                    case "ReadyToTransfer":
                        E84InfoDataLps[lpIndex - 1].ReadyToTransfer = (bool)data[item];
                        break;
                    case "HandoffAvailable":
                        E84InfoDataLps[lpIndex - 1].HandoffAvailable = (bool)data[item];
                        break;
                    case "ES":
                        E84InfoDataLps[lpIndex - 1].EmergencyOk = (bool)data[item];
                        break;
                    case "E84State":
                        E84InfoDataLps[lpIndex - 1].E84State = (string)data[item];
                        break;


                    case "IndicatiorLoad":
                        E84InfoDataLps[lpIndex - 1].IndicatiorLoad = (IndicatorState)data[item];
                        break;
                    case "IndicatiorUnload":
                        E84InfoDataLps[lpIndex - 1].IndicatiorUnload = (IndicatorState)data[item];
                        break;
                    case "IndicatiorPresence":
                        E84InfoDataLps[lpIndex - 1].IndicatiorPresence = (IndicatorState)data[item];
                        break;
                    case "IndicatiorPlacement":
                        E84InfoDataLps[lpIndex - 1].IndicatiorPlacement = (IndicatorState)data[item];
                        break;
                    case "IndicatiorAlarm":
                        E84InfoDataLps[lpIndex - 1].IndicatiorAlarm = (IndicatorState)data[item];
                        break;
                    case "IndicatiorAccessAuto":
                        E84InfoDataLps[lpIndex - 1].IndicatiorAccessAuto = (IndicatorState)data[item];
                        break;
                    case "IndicatiorAccessManual":
                        E84InfoDataLps[lpIndex - 1].IndicatiorAccessManual = (IndicatorState)data[item];
                        break;
                    case "IndicatiorOpAccess":
                        E84InfoDataLps[lpIndex - 1].IndicatiorOpAccess = (IndicatorState)data[item];
                        break;
                    case "IndicatiorStatus1":
                        E84InfoDataLps[lpIndex - 1].IndicatiorStatus1 = (IndicatorState)data[item];
                        break;
                    case "IndicatiorStatus2":
                        E84InfoDataLps[lpIndex - 1].IndicatiorStatus2 = (IndicatorState)data[item];
                        break;
                    case "SystemStatus":
                        E84InfoDataLps[lpIndex - 1].SystemStatus = (string)data[item];
                        break;
                    case "Mode":
                        E84InfoDataLps[lpIndex - 1].Mode = (string)data[item];
                        break;
                    case "InitPosMovement":
                        E84InfoDataLps[lpIndex - 1].InitPosMovement = (string)data[item];
                        break;
                    case "OperationStatus":
                        E84InfoDataLps[lpIndex - 1].OperationStatus = (string)data[item];
                        break;
                    case "ErrorCode":
                        E84InfoDataLps[lpIndex - 1].ErrorCode = (string)data[item];
                        break;

                    case "ContainerStatus":
                        E84InfoDataLps[lpIndex - 1].ContainerStatus = (string)data[item];
                        break;
                    case "ClampPosition":
                        E84InfoDataLps[lpIndex - 1].ClampPosition = (string)data[item];
                        break;
                    case "LPDoorLatchPosition":
                        E84InfoDataLps[lpIndex - 1].LPDoorLatchPosition = (string)data[item];
                        break;
                    case "VacuumStatus":
                        E84InfoDataLps[lpIndex - 1].VacuumStatus = (string)data[item];
                        break;
                    case "LPDoorState":
                        E84InfoDataLps[lpIndex - 1].LPDoorState = (string)data[item];
                        break;

                    case "WaferProtrusion":
                        E84InfoDataLps[lpIndex - 1].WaferProtrusion = (string)data[item];
                        break;
                    case "ElevatorAxisPosition":
                        E84InfoDataLps[lpIndex - 1].ElevatorAxisPosition = (string)data[item];
                        break;
                    case "DockPosition":
                        E84InfoDataLps[lpIndex - 1].DockPosition = (string)data[item];
                        break;
                    case "MapperPostion":
                        E84InfoDataLps[lpIndex - 1].MapperPostion = (string)data[item];
                        break;
                    case "MappingStatus":
                        E84InfoDataLps[lpIndex - 1].MappingStatus = (string)data[item];
                        break;
                    case "IsFosbModeActual":
                        E84InfoDataLps[lpIndex - 1].IsFosbModeActual = (string)data[item];
                        break;
                    case "WaferMapThickness":
                        Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                        {
                            var getDataList = (int[])data[item];
                            if (getDataList != null)
                            {
                                E84InfoDataLps[lpIndex - 1].AllSlotThickness.Clear();
                                for (int i = 0; i < getDataList.Length; i++)
                                {
                                    E84InfoDataLps[lpIndex - 1].AllSlotThickness.Add(new SlotThickness() { SlotName = $"Slot{i + 1} :", Value = getDataList[i] });
                                }
                            }
                        }));
                        break; 
                    default:
                        break;
                }
            }
            base.InvokeBeforeUpdateProperty(data);
        }
    }
}