ELK/Furnace/FurnaceSimulator/Instances/SimulatorSystem.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Core.WCF;
using FurnaceSimulator.Views;
using MECF.Framework.Simulator.Core.Commons;

namespace FurnaceSimulator.Instances
{
    public class SimulatorSystem : Singleton<SimulatorSystem>
    {
        private PeriodicJob _thread;
        private int _shuttleServoStation;
        private int _robotServoStation;

        Random _rd = new Random();

        private List<int> motionStationList;
        private Dictionary<string, int> currentStationDic = new Dictionary<string, int>();
        private Dictionary<string, int> currentPosDic = new Dictionary<string, int>();
        private Dictionary<string, int> targetStationPosDic = new Dictionary<string, int>();
        private Dictionary<string, bool> isAutoMoveDic = new Dictionary<string, bool>();
        private Dictionary<string, bool> logDic = new Dictionary<string, bool>();
        private Dictionary<string, DeviceTimer> timerDic = new Dictionary<string, DeviceTimer>();
        private RD_TRIG _smif1LoadTrig = new RD_TRIG();
        private RD_TRIG _smif2LoadTrig = new RD_TRIG();
        private RD_TRIG _smif1UnloadTrig = new RD_TRIG();
        private RD_TRIG _smif2UnloadTrig = new RD_TRIG();
        private RD_TRIG _smif1HomeTrig = new RD_TRIG();
        private RD_TRIG _smif2HomeTrig = new RD_TRIG();
        private Stopwatch _rAxisHomeTimer = new Stopwatch();
        public SimulatorSystem()
        {

        }

        public void Initialize()
        {
            motionStationList = new List<int>();
            for (int i = 0; i < 100; i++)
            {
                if (motionStationList.Count == 0)
                {
                    motionStationList.Add(0);
                }
                else
                {
                    motionStationList.Add(motionStationList[motionStationList.Count - 1] + 10000);
                }
            }

          
            Singleton<DataManager>.Instance.Initialize(false);

            WcfServiceManager.Instance.Initialize(new Type[]
            {
               typeof(SimulatorPlc1),
               typeof(SimulatorPlc2),
               typeof(SimulatorPlc3),
               typeof(SimulatorPlc4),
               typeof(SimulatorPlc5),
               typeof(SimulatorPlc6),
               typeof(SimulatorPlc7),
               typeof(SimulatorPlc8),
               //typeof(SimulatorPlc9),
            });
            SetDefaultValue();
            _thread = new PeriodicJob(200, OnMonitor, nameof(SimulatorSystem), true);
        }

        public static Int16 Pres2Phy901P(double pressure)
        {
            var voltage = Math.Log10(pressure) + 6;
            var raw = voltage / 10.0 * 0x7fff;
            if (raw < 0) raw = 0;
            else if (raw > 0x7fff) raw = 0x7fff;
            return Convert.ToInt16(raw);
        }

        public double Phy2Pres901P(byte low, byte high)
        {
            Int16 rawValue = BitConverter.ToInt16(new byte[] { low, high }, 0);

            var voltage = Converter.Phy2Logic(rawValue, 1, 9, 3276.7, 29490.3);

            return Math.Pow(10.0, voltage - 6.0);
        }


        public static Int16 Pres2Phy974B(double pressure)
        {
            var voltage = (Math.Log10(pressure) + 11) / 2;
            var raw = voltage / 10.0 * 0x7fff;
            if (raw < 0) raw = 0;
            else if (raw > 0x7fff) raw = 0x7fff;
            return Convert.ToInt16(raw);
        }

        public double Phy2Pres974B(byte low, byte high)
        {
            Int16 rawValue = BitConverter.ToInt16(new byte[] { low, high }, 0);

            var voltage = Converter.Phy2Logic(rawValue, 1.5, 7, 4915.05, 22936.9);

            return Math.Pow(10.0, 2 * voltage - 11.0);
        }
        private SimpleSocketDeviceSimulator _SimpleSocketDeviceSimulator;
        private void SetDefaultValue()
        {
            IO.DI[$"PM1.DI_LP1FOUPInPosition1"].Value = true;
            IO.DI[$"PM1.DI_LP1FOUPInPosition2"].Value = true;
            IO.DI[$"PM1.DI_LP1FOUPInPosition3"].Value = true;
            IO.DI[$"PM1.DI_LP1FOUPDetect"].Value = true;

            IO.DI[$"PM1.DI_LP2FOUPInPosition1"].Value = true;
            IO.DI[$"PM1.DI_LP2FOUPInPosition2"].Value = true;
            IO.DI[$"PM1.DI_LP2FOUPInPosition3"].Value = true;
            IO.DI[$"PM1.DI_LP2FOUPDetect"].Value = true;

            IO.DI[$"PM1.DI_LP3FOUPInPosition1"].Value = true;
            IO.DI[$"PM1.DI_LP3FOUPInPosition2"].Value = true;
            IO.DI[$"PM1.DI_LP3FOUPInPosition3"].Value = true;
            IO.DI[$"PM1.DI_LP3FOUPDetect"].Value = true;

            IO.DI[$"PM1.DI_LP4FOUPInPosition1"].Value = true;
            IO.DI[$"PM1.DI_LP4FOUPInPosition2"].Value = true;
            IO.DI[$"PM1.DI_LP4FOUPInPosition3"].Value = true;
            IO.DI[$"PM1.DI_LP4FOUPDetect"].Value = true;

            IO.DI[$"PM1.DI_WaferRobotEX1AxisHomePosition"].Value = true;
            IO.DI[$"PM1.DI_WaferRobotEX2AxisHomePosition"].Value = true;

            IO.DI[$"PM1.DI_FBLightCurtainFault"].Value = false;
            IO.DI[$"PM1.DI_FBLightCurtainOSSD1"].Value = false;
            IO.DI[$"PM1.DI_FBLightCurtainOSSD2"].Value = false;
            IO.DI[$"PM1.DI_BoatRAxisAlarm"].Value = false;

            IO.DI[$"PM1.DI_LP1FOUPLeftClamp"].Value = false;
            IO.DI[$"PM1.DI_LP1FOUPRightClamp"].Value = false;
            IO.DI[$"PM1.DI_LP1FOUPLeftRelease"].Value = true;
            IO.DI[$"PM1.DI_LP1FOUPRightRelease"].Value = true;

            IO.DI[$"PM1.DI_LP2FOUPLeftClamp"].Value = false;
            IO.DI[$"PM1.DI_LP2FOUPRightClamp"].Value = false;
            IO.DI[$"PM1.DI_LP2FOUPLeftRelease"].Value = true;
            IO.DI[$"PM1.DI_LP2FOUPRightRelease"].Value = true;

            IO.DI[$"PM1.DI_BufferInPositionA1"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionB1"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionC1"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionD1"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionA2"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionB2"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionC2"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionD2"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionA3"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionB3"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionC3"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionD3"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionA4"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionB4"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionC4"].Value = true;
            IO.DI[$"PM1.DI_BufferInPositionD4"].Value = true;
            IO.AI[$"PM1.AI_APCHomeStatus"].FloatValue = 2;
            for (int i = 1; i < 10; i++)
            {
                if (IO.DI[$"PM1.DI_VAC{i}"] != null)
                {
                    IO.DI[$"PM1.DI_VAC{i}"].Value = true;
                }
            }
            IO.DI[$"PM1.DI_BoatUnloadInterlock"].Value = true;
            IO.DI[$"PM1.DI_PS13LStatus"].Value = false;
            IO.DI[$"PM1.DI_FurnaceShutterOpened"].Value = true;
            IO.DI[$"PM1.DI_MiddlePos1BoatZAxis"].Value = true;
            IO.DI[$"PM1.DI_MiddlePos2BoatZAxis"].Value = true;
            IO.DI[$"PM1.DI_MiddlePos3BoatZAxis"].Value = true;
            IO.AI[$"PM1.AI_N26PurgePressure"].FloatValue =2;

            for (int i = 1; i < 100; i++)
            {
                if (IO.DI[$"PM1.DI_AV{i}ILK"] != null)
                {
                    IO.DI[$"PM1.DI_AV{i}ILK"].Value = true;
                }
            }

            //_SimpleSocketDeviceSimulator = new SimpleSocketDeviceSimulator(12000, -1, "\r", ' ', false);
        }

        private bool OnMonitor()
        {
            try
            {
                //return true;
                //MonitorValve();
                MonitorLP("PM1", "LP1");
                MonitorLP("PM1", "LP2");
                MonitorFIMS("PM1", "FIMS1");
                MonitorFIMS("PM1", "FIMS2");
                MonitorBuffer();
                MonitorMFC();
                MonitorDoor();
                MonitorRAxis("PM1");
                MonitorZAxis("PM1");
                MonitorHeater();
                MonitorAPC();
                MonitorHeaterBand();

                if (IO.DO[$"PM1.DO_ShutterOpen"].Value)
                {
                    IO.DI[$"PM1.DI_FurnaceShutterOpened"].Value = IO.DO[$"PM1.DO_ShutterOpen"].Value;
                    IO.DI[$"PM1.DI_FurnaceShutterClosed"].Value = IO.DO[$"PM1.DO_ShutterClose"].Value;
                }
                if (IO.DO[$"PM1.DO_ShutterClose"].Value)
                {
                    IO.DI[$"PM1.DI_FurnaceShutterOpened"].Value = IO.DO[$"PM1.DO_ShutterOpen"].Value;
                    IO.DI[$"PM1.DI_FurnaceShutterClosed"].Value = IO.DO[$"PM1.DO_ShutterClose"].Value;
                }

                IO.AI[$"PM1.AI_BufferTargetPosFb"].FloatValue = IO.AO[$"PM1.AO_TargetPositionBufferAxis"].FloatValue;
                IO.AI[$"PM1.AI_BoatTargetPosFb"].FloatValue = IO.AO[$"PM1.AO_BoatPosition"].FloatValue;

                IO.DI[$"PM1.DI_VaccumPumpBothOn"].Value = true;


                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_1RHCAirInOpened"] != null) { IO.DI[$"PM1.DI_AV91_1RHCAirInOpened"].Value = IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_2RHCAirInOpened"] != null) { IO.DI[$"PM1.DI_AV91_2RHCAirInOpened"].Value = IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_3RHCAirOutOpened"] != null) { IO.DI[$"PM1.DI_AV91_3RHCAirOutOpened"].Value = IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_4RHCAirOutOpened"] != null) { IO.DI[$"PM1.DI_AV91_4RHCAirOutOpened"].Value = IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_1RHCAirInClosed"] != null) { IO.DI[$"PM1.DI_AV91_1RHCAirInClosed"].Value = !IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_2RHCAirInClosed"] != null) { IO.DI[$"PM1.DI_AV91_2RHCAirInClosed"].Value = !IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_3RHCAirOutClosed"] != null) { IO.DI[$"PM1.DI_AV91_3RHCAirOutClosed"].Value = !IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_ValveAV91"] != null && IO.DI[$"PM1.DI_AV91_4RHCAirOutClosed"] != null) { IO.DI[$"PM1.DI_AV91_4RHCAirOutClosed"].Value = !IO.DO[$"PM1.DO_ValveAV91"].Value; }
                if (IO.DO[$"PM1.DO_LAExhaustValveOpen"] != null && IO.DO[$"PM1.DO_LAExhaustValveClose"] != null &&
                    (IO.DO[$"PM1.DO_LAExhaustValveOpen"].Value || IO.DO[$"PM1.DO_LAExhaustValveClose"].Value))
                {
                    IO.DI[$"PM1.DI_AV66CommonExhaustOpened"].Value = IO.DO[$"PM1.DO_LAExhaustValveOpen"].Value;
                    IO.DI[$"PM1.DI_AV66CommonExhaustClosed"].Value = IO.DO[$"PM1.DO_LAExhaustValveClose"].Value;
                }

                if (IO.DO[$"PM1.DO_FFUAirInValveOpen"] != null && IO.DO[$"PM1.DO_FFUAirInValveClose"] != null &&
                    (IO.DO[$"PM1.DO_FFUAirInValveOpen"].Value || IO.DO[$"PM1.DO_FFUAirInValveClose"].Value))
                {
                  //  IO.DI[$"PM1.DI_AV65FFUAirInOpened"].Value = IO.DO[$"PM1.DO_FFUAirInValveOpen"].Value;
                    //IO.DI[$"PM1.DI_AV65FFUAirInClosed"].Value = IO.DO[$"PM1.DO_FFUAirInValveClose"].Value;
                }

                return true;
            }
            catch (Exception e)
            {
                LOG.Write(e);
            }
            return true;
        }

        public void Terminate()
        {
            _thread.Stop();
        }
        private void MonitorHeaterBand()
        {
            for (int i = 1; i < 20; i++)
            {
                if (IO.AI[$"PM1.AI_ForelineHeater{i}TempPV"] != null)
                {
                    IO.DI[$"PM1.DI_ForelineHeater{i}ControlDoing"].Value = IO.DO[$"PM1.DO_ForelineHeater{i}Enable"].Value;
                    IO.AI[$"PM1.AI_ForelineHeater{i}TempPV"].FloatValue = IO.AO[$"PM1.AO_ForelineHeater{i}TempSV"].FloatValue;
                    IO.AI[$"PM1.AI_ForelineHeater{i}PBFeedback"].FloatValue = IO.AO[$"PM1.AO_ForelineHeater{i}PBSV"].FloatValue;
                    IO.AI[$"PM1.AI_ForelineHeater{i}TIFeedback"].FloatValue = IO.AO[$"PM1.AO_ForelineHeater{i}TISV"].FloatValue;
                    IO.AI[$"PM1.AI_ForelineHeater{i}TDFeedback"].FloatValue = IO.AO[$"PM1.AO_ForelineHeater{i}TDSV"].FloatValue;
                    IO.AI[$"PM1.AI_ForelineHeater{i}ManualMVFeedback"].FloatValue = IO.AO[$"PM1.AO_ForelineHeater{i}TempSV"].FloatValue > 0 ? 100 : 0;
                }
            }

            if (IO.AI[$"PM1.AI_CapHeaterTempPV"] != null)
            {
                IO.DI[$"PM1.DI_CapHeaterControlDoing"].Value = IO.DO[$"PM1.DO_CapHeaterEnable"].Value;
                IO.AI[$"PM1.AI_CapHeaterTempPV"].FloatValue = IO.AO[$"PM1.AO_CapHeaterTempSV"].FloatValue;
                IO.AI[$"PM1.AI_CapHeaterPBFeedback"].FloatValue = IO.AO[$"PM1.AO_CapHeaterPBSV"].FloatValue;
                IO.AI[$"PM1.AI_CapHeaterTIFeedback"].FloatValue = IO.AO[$"PM1.AO_CapHeaterTISV"].FloatValue;
                IO.AI[$"PM1.AI_CapHeaterTDFeedback"].FloatValue = IO.AO[$"PM1.AO_CapHeaterTDSV"].FloatValue;
                IO.AI[$"PM1.AI_CapHeaterControlOutput"].FloatValue = IO.AO[$"PM1.AO_CapHeaterTempSV"].FloatValue > 0 ? 100 : 0;
            }

            if (IO.AI[$"PM1.AI_APCExternalHeaterTempPV"] != null)
            {
                IO.DI[$"PM1.DI_APCExternalHeaterControlDoing"].Value = IO.DO[$"PM1.DO_APCExternalHeaterEnable"].Value;
                IO.AI[$"PM1.AI_APCExternalHeaterTempPV"].FloatValue = IO.AO[$"PM1.AO_APCExternalHeaterTempSV"].FloatValue;
                IO.AI[$"PM1.AI_APCExternalHeaterPBFeedback"].FloatValue = IO.AO[$"PM1.AO_APCExternalHeaterPBSV"].FloatValue;
                IO.AI[$"PM1.AI_APCExternalHeaterTIFeedback"].FloatValue = IO.AO[$"PM1.AO_APCExternalHeaterTISV"].FloatValue;
                IO.AI[$"PM1.AI_APCExternalHeaterTDFeedback"].FloatValue = IO.AO[$"PM1.AO_APCExternalHeaterTDSV"].FloatValue;
                IO.AI[$"PM1.AI_APCExternalHeaterControlOutput"].FloatValue = IO.AO[$"PM1.AO_APCExternalHeaterTempSV"].FloatValue > 0 ? 100 : 0;
            }

            if (IO.AI[$"PM1.AI_APCRingHeaterTempPV"] != null)
            {
                IO.DI[$"PM1.DI_APCRingHeaterControlDoing"].Value = IO.DO[$"PM1.DO_APCRingHeaterEnable"].Value;
                IO.AI[$"PM1.AI_APCRingHeaterTempPV"].FloatValue = IO.AO[$"PM1.AO_APCRingHeaterTempSV"].FloatValue;
                IO.AI[$"PM1.AI_APCRingHeaterPBFeedback"].FloatValue = IO.AO[$"PM1.AO_APCRingHeaterPBSV"].FloatValue;
                IO.AI[$"PM1.AI_APCRingHeaterTIFeedback"].FloatValue = IO.AO[$"PM1.AO_APCRingHeaterTISV"].FloatValue;
                IO.AI[$"PM1.AI_APCRingHeaterTDFeedback"].FloatValue = IO.AO[$"PM1.AO_APCRingHeaterTDSV"].FloatValue;
                IO.AI[$"PM1.AI_APCRingHeaterControlOutput"].FloatValue = IO.AO[$"PM1.AO_APCRingHeaterTempSV"].FloatValue > 0 ? 100 : 0;
            }

            for (int i = 1; i < 80; i++)
            {
                for (int ch=1;ch<40;ch++)
                {
                    if (IO.AO[$"PM1.AO_Unit{i}CH{ch}SV"] != null && IO.AI[$"PM1.AI_Unit{i}CH{ch}SV"] != null)
                    {
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}EnableIn"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}EnableIn"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}SV"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}SV"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}PV"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}SV"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}PID_P"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}PID_P"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}PID_I"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}PID_I"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}PID_D"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}PID_D"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}UpRate"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}UpRate"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}DownRate"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}DownRate"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}AutotuneActivate"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}AutotuneActivate"].FloatValue;
                        //IO.AI[$"PM1.AI_Unit{i}CH{ch}AlarmHigher"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}AlarmHigher"].FloatValue;
                        //IO.AI[$"PM1.AI_Unit{i}CH{ch}AlarmLower"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}AlarmLower"].FloatValue;
                        IO.AI[$"PM1.AI_Unit{i}CH{ch}WorkingOutput"].FloatValue = IO.AO[$"PM1.AO_Unit{i}CH{ch}SV"].FloatValue > 0 ? 100 : 0;
                    }
                }
                
            }

        }
        private void MonitorAPC()
        {
            IO.AI[$"PM1.AI_APCSelectController"].FloatValue = IO.AO[$"PM1.AO_APCControllerModeSelect"].FloatValue;
            IO.AI[$"PM1.AI_APCControlModeStatus"].FloatValue = IO.AO[$"PM1.AO_APCSpecifyControlMode"].FloatValue;
            IO.AI[$"PM1.AI_APCPositionActualValue"].FloatValue = IO.AO[$"PM1.AO_APCSpecifyTargetOpeningForValveOpeningControl"].FloatValue;
            if (IO.AO[$"PM1.AO_APCSlowVacuumTargetPressure"].FloatValue > 0)
            {
                IO.AI[$"PM1.AI_APCValueSensorInput1"].FloatValue = IO.AO[$"PM1.AO_APCSlowVacuumTargetPressure"].FloatValue;
                IO.AI[$"PM1.AI_APCValueSensorInput2"].FloatValue = IO.AO[$"PM1.AO_APCSlowVacuumTargetPressure"].FloatValue;
            }
            else if (IO.AO[$"PM1.AO_APCSpecifyTargetVacuumPressureControl"].FloatValue > 0)
            {
                IO.AI[$"PM1.AI_APCValueSensorInput1"].FloatValue = IO.AO[$"PM1.AO_APCSpecifyTargetVacuumPressureControl"].FloatValue;
                IO.AI[$"PM1.AI_APCValueSensorInput2"].FloatValue = IO.AO[$"PM1.AO_APCSpecifyTargetVacuumPressureControl"].FloatValue;
            }
        }
        private void MonitorHeater()
        {
            IO.AI[$"Heater.AI_HeaterUCascadePV"].FloatValue = IO.AO[$"Heater.AO_HeaterUCascadeControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterUHeaterPV"].FloatValue = IO.AO[$"Heater.AO_HeaterUHeaterControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterUWorkingOutput"].FloatValue = IO.AO[$"Heater.AO_HeaterUCascadeControlModeSV"].FloatValue > 0 || IO.AO[$"Heater.AO_HeaterUHeaterControlModeSV"].FloatValue > 0 ? 100 : 0;
            IO.DI[$"Heater.DI_HeaterUEnableOutput"].Value = IO.DO[$"Heater.DO_HeaterUEnableIn"].Value;

            IO.AI[$"Heater.AI_HeaterCUCascadePV"].FloatValue = IO.AO[$"Heater.AO_HeaterCUCascadeControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterCUHeaterPV"].FloatValue = IO.AO[$"Heater.AO_HeaterCUHeaterControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterCUWorkingOutput"].FloatValue = IO.AO[$"Heater.AO_HeaterCUCascadeControlModeSV"].FloatValue > 0 || IO.AO[$"Heater.AO_HeaterCUHeaterControlModeSV"].FloatValue > 0 ? 100 : 0;
            IO.DI[$"Heater.DI_HeaterCUEnableOutput"].Value = IO.DO[$"Heater.DO_HeaterCUEnableIn"].Value;

            IO.AI[$"Heater.AI_HeaterCCascadePV"].FloatValue = IO.AO[$"Heater.AO_HeaterCCascadeControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterCHeaterPV"].FloatValue = IO.AO[$"Heater.AO_HeaterCHeaterControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterCWorkingOutput"].FloatValue = IO.AO[$"Heater.AO_HeaterCCascadeControlModeSV"].FloatValue > 0 || IO.AO[$"Heater.AO_HeaterCHeaterControlModeSV"].FloatValue > 0 ? 100 : 0;
            IO.DI[$"Heater.DI_HeaterCEnableOutput"].Value = IO.DO[$"Heater.DO_HeaterCEnableIn"].Value;

            IO.AI[$"Heater.AI_HeaterCLCascadePV"].FloatValue = IO.AO[$"Heater.AO_HeaterCLCascadeControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterCLHeaterPV"].FloatValue = IO.AO[$"Heater.AO_HeaterCLHeaterControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterCLWorkingOutput"].FloatValue = IO.AO[$"Heater.AO_HeaterCLCascadeControlModeSV"].FloatValue > 0 || IO.AO[$"Heater.AO_HeaterCLHeaterControlModeSV"].FloatValue > 0 ? 100 : 0;
            IO.DI[$"Heater.DI_HeaterCLEnableOutput"].Value = IO.DO[$"Heater.DO_HeaterCLEnableIn"].Value;

            IO.AI[$"Heater.AI_HeaterLCascadePV"].FloatValue = IO.AO[$"Heater.AO_HeaterLCascadeControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterLHeaterPV"].FloatValue = IO.AO[$"Heater.AO_HeaterLHeaterControlModeSV"].FloatValue;
            IO.AI[$"Heater.AI_HeaterLWorkingOutput"].FloatValue = IO.AO[$"Heater.AO_HeaterLCascadeControlModeSV"].FloatValue > 0 || IO.AO[$"Heater.AO_HeaterLHeaterControlModeSV"].FloatValue > 0 ? 100 : 0;
            IO.DI[$"Heater.DI_HeaterLEnableOutput"].Value = IO.DO[$"Heater.DO_HeaterLEnableIn"].Value;
        }

        public void MonitorCylinder()
        {
            //var valveList = new List<Tuple<string, string, string, string>>
            //                {
            //                    new Tuple<string, string, string, string>(
            //                        $"PMA.DO_LiftPinUp",
            //                        $"PMA.DO_LiftPinDown",
            //                        $"PMA.DI_LiftPinUp",
            //                        $"PMA.DI_LiftPinDown"
            //                    ),
            //                    new Tuple<string, string, string, string>(
            //                        $"PMB.DO_LiftPinUp",
            //                        $"PMB.DO_LiftPinDown",
            //                        $"PMB.DI_LiftPinUp",
            //                        $"PMB.DI_LiftPinDown"
            //                    ),
            //                    new Tuple<string, string, string, string>(
            //                        $"PMC.DO_LiftPinUp",
            //                        $"PMC.DO_LiftPinDown",
            //                        $"PMC.DI_LiftPinUp",
            //                        $"PMC.DI_LiftPinDown"
            //                    ),
            //                    new Tuple<string, string, string, string>(
            //                        $"MF.DO_SlitDoorPMAOpen",
            //                        $"MF.DO_SlitDoorPMAClose",
            //                        $"MF.DI_SlitDoorPMAOpen",
            //                        $"MF.DI_SlitDoorPMAClose"
            //                    ),
            //                     new Tuple<string, string, string, string>(
            //                        $"MF.DO_SlitDoorPMBOpen",
            //                        $"MF.DO_SlitDoorPMBClose",
            //                        $"MF.DI_SlitDoorPMBOpen",
            //                        $"MF.DI_SlitDoorPMBClose"
            //                    ),
            //                     new Tuple<string, string, string, string>(
            //                        $"MF.DO_SlitDoorPMCOpen",
            //                        $"MF.DO_SlitDoorPMCClose",
            //                        $"MF.DI_SlitDoorPMCOpen",
            //                        $"MF.DI_SlitDoorPMCClose"
            //                    ),
            //                     new Tuple<string, string, string, string>(
            //                        $"MF.DO_CassDoorOpen",
            //                        $"MF.DO_CassDoorClose",
            //                        $"MF.DI_CassetteDoorOpen",
            //                        $"MF.DI_CassetteDoorClose"
            //                    ),
            //                };

            //foreach (var valve in valveList)
            //{
            //    if (IO.DO[valve.Item1].Value != IO.DO[valve.Item2].Value)
            //    {
            //        IO.DI[valve.Item3].Value = IO.DO[valve.Item1].Value;
            //        IO.DI[valve.Item4].Value = IO.DO[valve.Item2].Value;
            //    }

            //}

            //if(IO.DO[$"MF.DO_CassSliderOut"].Value)
            //{
            //    IO.DI[$"MF.DI_CassSliderCylinderOut"].Value = true;
            //    IO.DI[$"MF.DI_CassSliderCylinderIn"].Value = false;
            //    IO.DI[$"MF.DI_CassetteNestOutSW"].Value = true;
            //}
            //if (IO.DO[$"MF.DO_CassSliderIn"].Value)
            //{
            //    IO.DI[$"MF.DI_CassSliderCylinderOut"].Value = false;
            //    IO.DI[$"MF.DI_CassSliderCylinderIn"].Value = true;
            //    IO.DI[$"MF.DI_CassetteNestOutSW"].Value = false;
            //}

        }

        private void MonitorSMIF()
        {
            _smif1LoadTrig.CLK = IO.DO[$"SMIF.DO_LoadSmif1"].Value;
            _smif1UnloadTrig.CLK = IO.DO[$"SMIF.DO_UnLoadSmif1"].Value;
            _smif1HomeTrig.CLK = IO.DO[$"SMIF.DO_InitSmif1"].Value;

            _smif2LoadTrig.CLK = IO.DO[$"SMIF.DO_LoadSmif2"].Value;
            _smif2UnloadTrig.CLK = IO.DO[$"SMIF.DO_UnLoadSmif2"].Value;
            _smif2HomeTrig.CLK = IO.DO[$"SMIF.DO_InitSmif2"].Value;

            if (_smif1LoadTrig.R)
            {
                IO.DI[$"SMIF.DI_Smif1Ready"].Value = false;
            }
            if (_smif1LoadTrig.T)
            {
                IO.DI[$"SMIF.DI_Smif1Ready"].Value = true;
                IO.DI[$"SMIF.DI_Smif1ZAxisLoadPositionSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif1SlideAxisExtendSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif1ZAxisUnloadPositionSensor"].Value = false;
                IO.DI[$"SMIF.DI_Smif1SlideAxisRetractSensor"].Value = false;
            }

            if (_smif1UnloadTrig.R)
            {
                IO.DI[$"SMIF.DI_Smif1Ready"].Value = false;
            }
            if (_smif1UnloadTrig.T)
            {
                IO.DI[$"SMIF.DI_Smif1Ready"].Value = true;
                IO.DI[$"SMIF.DI_Smif1ZAxisUnloadPositionSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif1SlideAxisRetractSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif1ZAxisLoadPositionSensor"].Value = false;
                IO.DI[$"SMIF.DI_Smif1SlideAxisExtendSensor"].Value = false;
            }

            if (_smif1HomeTrig.R)
            {
                IO.DI[$"SMIF.DI_Smif1Ready"].Value = false;
                IO.DI[$"SMIF.DI_Smif1Homed"].Value = false;
            }
            if (_smif1HomeTrig.T)
            {
                IO.DI[$"SMIF.DI_Smif1Ready"].Value = true;
                IO.DI[$"SMIF.DI_Smif1Homed"].Value = true;
            }

            if (_smif2LoadTrig.R)
            {
                IO.DI[$"SMIF.DI_Smif2Ready"].Value = false;
            }
            if (_smif2LoadTrig.T)
            {
                IO.DI[$"SMIF.DI_Smif2Ready"].Value = true;
                IO.DI[$"SMIF.DI_Smif2ZAxisLoadPositionSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif2SlideAxisExtendSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif2ZAxisUnloadPositionSensor"].Value = false;
                IO.DI[$"SMIF.DI_Smif2SlideAxisRetractSensor"].Value = false;
            }

            if (_smif2UnloadTrig.R)
            {
                IO.DI[$"SMIF.DI_Smif2Ready"].Value = false;
            }
            if (_smif2UnloadTrig.T)
            {
                IO.DI[$"SMIF.DI_Smif2Ready"].Value = true;
                IO.DI[$"SMIF.DI_Smif2ZAxisUnloadPositionSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif2SlideAxisRetractSensor"].Value = true;
                IO.DI[$"SMIF.DI_Smif2ZAxisLoadPositionSensor"].Value = false;
                IO.DI[$"SMIF.DI_Smif2SlideAxisExtendSensor"].Value = false;
            }

            if (_smif2HomeTrig.R)
            {
                IO.DI[$"SMIF.DI_Smif2Ready"].Value = false;
                IO.DI[$"SMIF.DI_Smif2Homed"].Value = false;
            }
            if (_smif2HomeTrig.T)
            {
                IO.DI[$"SMIF.DI_Smif2Ready"].Value = true;
                IO.DI[$"SMIF.DI_Smif2Homed"].Value = true;
            }
        }
        private void MonitorMotion()
        {
            //MonitorModule("Shuttle", "Z");
            //MonitorModule("Shuttle", "R");
            //MonitorModule("TM", "Z");
            //MonitorModule("TM", "E");
            //MonitorModule("TM", "R");

            //IO.AI[$"Motion.AI_ShuttleRStatus"].Value = IO.AO[$"Motion.AO_ShuttleRMotionStationSet"].Value;
            //IO.AI[$"Motion.AI_TMEStatus"].Value = IO.AO[$"Motion.AO_TMEMotionStationSet"].Value;
            //IO.AI[$"Motion.AI_TMRStatus"].Value = IO.AO[$"Motion.AO_TMRMotionStationSet"].Value;
            //IO.AI[$"Motion.AI_TMEMotionDirection"].Value = IO.AO[$"Motion.AO_TMEMotionDirectionSet"].Value;
            //IO.AI[$"Motion.AI_TMRMotionDirection"].Value = IO.AO[$"Motion.AO_TMRMotionDirectionSet"].Value;
            //IO.AI[$"Motion.AI_ShuttleRMotionDirection"].Value = IO.AO[$"Motion.AO_ShuttleRMotionDirectionSet"].Value;

            MonitorRobot();
            MonitorShuttle();
        }

        private void MonitorRobot()
        {
            //short valueL = IO.AO[$"MF.AO_RobotServoTargetStationL"].Value;
            //short valueH = (short)IO.AO[$"MF.AO_RobotServoTargetStationH"].Value;
            //UInt32 tmp = (ushort)valueL + (UInt32)(((ushort)valueH) << 16);
            //int station = tmp > Int32.MaxValue ? (int)((~tmp + 1) * -1) : (int)tmp;

            //IO.AI[$"MF.AI_RobotServoTargetStationL"].Value = IO.AO[$"MF.AO_RobotServoTargetStationL"].Value > 0 ? IO.AO[$"MF.AO_RobotServoTargetStationL"].Value : IO.AI[$"MF.AI_RobotServoTargetStationL"].Value;
            //IO.AI[$"MF.AI_RobotServoTargetStationH"].Value = IO.AO[$"MF.AO_RobotServoTargetStationH"].Value > 0 ? IO.AO[$"MF.AO_RobotServoTargetStationH"].Value : IO.AI[$"MF.AI_RobotServoTargetStationH"].Value;
            //IO.AI[$"MF.AI_RobotDCMotor1TargetStationL"].Value = IO.AO[$"MF.AO_RobotDCMotor1TargetStationL"].Value > 0 ? IO.AO[$"MF.AO_RobotDCMotor1TargetStationL"].Value : IO.AI[$"MF.AI_RobotDCMotor1TargetStationL"].Value;
            //IO.AI[$"MF.AI_RobotDCMotor1TargetStationH"].Value = IO.AO[$"MF.AO_RobotDCMotor1TargetStationH"].Value > 0 ? IO.AO[$"MF.AO_RobotDCMotor1TargetStationH"].Value : IO.AI[$"MF.AI_RobotDCMotor1TargetStationH"].Value;
            //IO.AI[$"MF.AI_RobotDCMotor2TargetStationL"].Value = IO.AO[$"MF.AO_RobotDCMotor2TargetStationL"].Value > 0 ? IO.AO[$"MF.AO_RobotDCMotor2TargetStationL"].Value : IO.AI[$"MF.AI_RobotDCMotor2TargetStationL"].Value;
            //IO.AI[$"MF.AI_RobotDCMotor2TargetStationH"].Value = IO.AO[$"MF.AO_RobotDCMotor2TargetStationH"].Value > 0 ? IO.AO[$"MF.AO_RobotDCMotor2TargetStationH"].Value : IO.AI[$"MF.AI_RobotDCMotor2TargetStationH"].Value;
            //IO.AI[$"MF.AI_RobotStatus"].Value = (short)((IO.DO[$"MF.DO_RobotServoOn"].Value ? 1 : 0) + 
            //    ((_robotServoStation == station ? 1 : 0) << 1) + (1 << 10) + ((IO.DO[$"MF.DO_RobotServoPinSearch"].Value ? 1:0) << 11));

            //_robotServoStation = station;
        }

        private void MonitorShuttle()
        {
            //short valueL = IO.AO[$"MF.AO_ShuttleServoTargetStationL"].Value;
            //short valueH = (short)IO.AO[$"MF.AO_ShuttleServoTargetStationH"].Value;
            //UInt32 tmp = (ushort)valueL + (UInt32)(((ushort)valueH) << 16);
            //int station = tmp > Int32.MaxValue ? (int)((~tmp + 1) * -1) : (int)tmp;
            //if(station == 1)
            //{
            //    IO.DI["MF.DI_ShuttleUp"].Value = false;
            //    IO.DI["MF.DI_ShuttleDown"].Value = false;
            //}
            //else if(station == 2)
            //{
            //    IO.DI["MF.DI_ShuttleUp"].Value = true;
            //    IO.DI["MF.DI_ShuttleDown"].Value = true;
            //}
            //else
            //{
            //    IO.DI["MF.DI_ShuttleUp"].Value = true;
            //    IO.DI["MF.DI_ShuttleDown"].Value = false;
            //}

            //IO.AI[$"MF.AI_ShuttleServoTargetStationL"].Value = IO.AO[$"MF.AO_ShuttleServoTargetStationL"].Value > 0 ? IO.AO[$"MF.AO_ShuttleServoTargetStationL"].Value : IO.AI[$"MF.AI_ShuttleServoTargetStationL"].Value;
            //IO.AI[$"MF.AI_ShuttleServoTargetStationH"].Value = IO.AO[$"MF.AO_ShuttleServoTargetStationH"].Value > 0 ? IO.AO[$"MF.AO_ShuttleServoTargetStationH"].Value : IO.AI[$"MF.AI_ShuttleServoTargetStationH"].Value;
            //IO.AI[$"MF.AI_ShuttleDCMotor1TargetStationL"].Value = IO.AO[$"MF.AO_ShuttleDCMotor1TargetStationL"].Value != 0 ? IO.AO[$"MF.AO_ShuttleDCMotor1TargetStationL"].Value : IO.AI[$"MF.AI_ShuttleDCMotor1TargetStationL"].Value;
            //IO.AI[$"MF.AI_ShuttleDCMotor1TargetStationH"].Value = IO.AO[$"MF.AO_ShuttleDCMotor1TargetStationH"].Value != 0 ? IO.AO[$"MF.AO_ShuttleDCMotor1TargetStationH"].Value : IO.AI[$"MF.AI_ShuttleDCMotor1TargetStationH"].Value;
            //IO.AI[$"MF.AI_ShuttleStatus"].Value = (short)((IO.DO[$"MF.DO_RobotServoOn"].Value ? 1 : 0) +
            //    ((_shuttleServoStation == station ? 1 : 0) << 1) + (1 << 10));

            //_shuttleServoStation = station;

            //IO.DI["MF.DI_CassNestAIn"].Value = IO.AI[$"MF.AI_ShuttleDCMotor1TargetStationL"].Value == 1;
            //IO.DI["MF.DI_CassNestBIn"].Value = IO.AI[$"MF.AI_ShuttleDCMotor1TargetStationL"].Value != 1;

            //IO.DI["MF.DI_ShuttleUp"].Value = IO.AO[$"MF.AO_ShuttleServoTargetStationL"].Value == 2;//opposite
            //IO.DI["MF.DI_ShuttleDown"].Value = IO.AO[$"MF.AO_ShuttleServoTargetStationL"].Value == 1;//opposite
        }

        private void MonitorValve()
        {
            IO.DI[$"MF.DI_ASOpenPosition"].Value = IO.DO[$"MF.DO_ASOpenPosition"].Value;
            IO.DI[$"MF.DI_ASClosePosition"].Value = IO.DO[$"MF.DO_ASClosePosition"].Value;

            IO.DI[$"MF.DI_ASUpPosition"].Value = IO.DO[$"MF.DO_ASUpPosition"].Value;
            IO.DI[$"MF.DI_ASDownPosition"].Value = IO.DO[$"MF.DO_ASDownPosition"].Value;

            if (IO.DO[$"MF.DO_BoatElevatorZAxisStop"].Value)
            {
                IO.DI[$"MF.DI_Zone1Sensor"].Value = false;
                IO.DI[$"MF.DI_Zone2Sensor"].Value = false;
                IO.DI[$"MF.DI_CapCloseSensor"].Value = false;
                IO.DI[$"MF.DI_HomePosition"].Value = false;
            }
            if (IO.DO[$"MF.DO_MoveToP1Position"].Value)
            {
                IO.DI[$"MF.DI_Zone1Sensor"].Value = IO.DO[$"MF.DO_MoveToP1Position"].Value;
                IO.DI[$"MF.DI_Zone2Sensor"].Value = false;
                IO.DI[$"MF.DI_CapCloseSensor"].Value = false;
                IO.DI[$"MF.DI_HomePosition"].Value = false;
            }
            if (IO.DO[$"MF.DO_MoveToP2Position"].Value)
            {
                IO.DI[$"MF.DI_Zone2Sensor"].Value = IO.DO[$"MF.DO_MoveToP2Position"].Value;
                IO.DI[$"MF.DI_Zone1Sensor"].Value = false;
                IO.DI[$"MF.DI_CapCloseSensor"].Value = false;
                IO.DI[$"MF.DI_HomePosition"].Value = false;
            }
            if (IO.DO[$"MF.DO_MoveToPPPosition"].Value)
            {
                IO.DI[$"MF.DI_CapCloseSensor"].Value = IO.DO[$"MF.DO_MoveToPPPosition"].Value;
                IO.DI[$"MF.DI_Zone1Sensor"].Value = false;
                IO.DI[$"MF.DI_Zone2Sensor"].Value = false;
                IO.DI[$"MF.DI_HomePosition"].Value = false;
            }
            if (IO.DO[$"MF.DO_HomePosition"].Value)
            {
                IO.DI[$"MF.DI_HomePosition"].Value = IO.DO[$"MF.DO_HomePosition"].Value;
                IO.DI[$"MF.DI_Zone1Sensor"].Value = false;
                IO.DI[$"MF.DI_Zone2Sensor"].Value = false;
                IO.DI[$"MF.DI_CapCloseSensor"].Value = false;
            }
            IO.DI[$"MF.DI_ZAxisMoving"].Value = IO.DO[$"MF.DO_HomePosition"].Value || IO.DO[$"MF.DO_MoveToPPPosition"].Value ||
                IO.DO[$"MF.DO_MoveToP2Position"].Value || IO.DO[$"MF.DO_MoveToP1Position"].Value;

            if (IO.DO[$"MF.DO_BoatElevatorRotateStop"].Value)
            {
                IO.DI[$"MF.DI_RotationAxisHomed"].Value = false;
            }
            if (IO.DO[$"MF.DO_BoatElevatorRotateHome"].Value)
            {
                IO.DI[$"MF.DI_RotationAxisHomed"].Value = IO.DO[$"MF.DO_BoatElevatorRotateHome"].Value;
            }
            if (IO.DO[$"MF.DO_BoatElevatorRotateContinuous"].Value || IO.DO[$"MF.DO_BoatElevatorRotateInterval"].Value)
            {
                IO.DI[$"MF.DI_RotationAxisHomed"].Value = false;
            }
            IO.DI[$"MF.DI_RotationAxisMoving"].Value = IO.DO[$"MF.DO_BoatElevatorRotateHome"].Value ||
                IO.DO[$"MF.DO_BoatElevatorRotateContinuous"].Value || IO.DO[$"MF.DO_BoatElevatorRotateInterval"].Value;

            IO.DI[$"EFEM.DI_Valve1EX"].Value = IO.DO[$"EFEM.DO_Valve1EX"].Value;
            IO.DI[$"EFEM.DI_Valve1RE"].Value = IO.DO[$"EFEM.DO_Valve1RE"].Value;
            IO.DI[$"EFEM.DI_Valve2EX"].Value = IO.DO[$"EFEM.DO_Valve2EX"].Value;
            IO.DI[$"EFEM.DI_Valve2RE"].Value = IO.DO[$"EFEM.DO_Valve2RE"].Value;

            //IO.DI[$"PM1.DI_M21REALOUT"].Value = IO.DO[$"PM1.DO_M21ValveOpen"].Value;
            //IO.DI[$"PM1.DI_D11REALOUT"].Value = IO.DO[$"PM1.DO_D11ValveOpen"].Value;
            //IO.DI[$"PM1.DI_M11REALOUT"].Value = IO.DO[$"PM1.DO_M11ValveOpen"].Value;
            //IO.DI[$"PM1.DI_J11REALOUT"].Value = IO.DO[$"PM1.DO_J11ValveOpen"].Value;
            //IO.DI[$"PM1.DI_VV2REALOUT"].Value = IO.DO[$"PM1.DO_VV2ValveOpen"].Value;
            //IO.DI[$"PM1.DI_IV2REALOUT"].Value = IO.DO[$"PM1.DO_IV2ValveOpen"].Value;
        }

        private void MonitorMFC()
        {
            for (int i = 1; i < 52; i++)
            {
                if (IO.AO[$"PM1.AO_MFC{i}AirFlowSV"] != null)
                {
                    IO.AI[$"PM1.AI_MFC{i}AirFlowPV"].FloatValue = IO.AO[$"PM1.AO_MFC{i}AirFlowSV"].FloatValue;
                }

            }

            if(IO.AO[$"PM1.AO_MFM57AirFlowSV"] != null && IO.AI[$"PM1.AI_MFM57AirFlowPV"] != null)
                IO.AI[$"PM1.AI_MFM57AirFlowPV"].FloatValue = IO.AO[$"PM1.AO_MFM57AirFlowSV"].FloatValue;


            //IO.AI[$"PM1.AI_APCFeedback"].Value = IO.AO[$"PM1.AO_APCSetpoint"].Value;
        }

        private void MonitorModule(string module, string submodule)
        {
            //string uniqueModule = module + submodule;

            //string AO_MotionServoStop = $"Motion.AO_{uniqueModule}MotionServoStop";
            //string AO_MotionJogN = $"Motion.AO_{uniqueModule}MotionJogN";
            //string AO_MotionJogP = $"Motion.AO_{uniqueModule}MotionJogP";
            //string AO_MotionJogSpeedL = $"Motion.AO_{uniqueModule}MotionJogSpeedL";
            //string AO_MotionJogSpeedH = $"Motion.AO_{uniqueModule}MotionJogSpeedH";
            //string AO_MotionPositionSet = $"Motion.AO_{uniqueModule}MotionPositionSet";
            //string AO_MotionAutoSpeedL = $"Motion.AO_{uniqueModule}MotionAutoSpeedL";
            //string AO_MotionAutoSpeedH = $"Motion.AO_{uniqueModule}MotionAutoSpeedH";

            //string AO_MotionServoOn = $"Motion.AO_{module}MotionServoOn";
            //string AO_MotionAutoMove = $"Motion.AO_{module}MotionAutoMove";
            //string AO_MotionAbort = $"Motion.AO_{module}MotionAbort";

            //string AI_MotionSystemStatus = $"Motion.AI_{uniqueModule}MotionSystemStatus";
            //string AI_MotionServoStatus = $"Motion.AI_{uniqueModule}MotionServoStatus";
            //string AI_MotionPositionL = $"Motion.AI_{uniqueModule}MotionPositionL";
            //string AI_MotionPositionH = $"Motion.AI_{uniqueModule}MotionPositionH";
            //string AI_MotionTargetPositionL = $"Motion.AI_{uniqueModule}MotionTargetPositionL";
            //string AI_MotionTargetPositionH = $"Motion.AI_{uniqueModule}MotionTargetPositionH";
            //string AI_MotionSpeedL = $"Motion.AI_{uniqueModule}MotionSpeedL";
            //string AI_MotionSpeedH = $"Motion.AI_{uniqueModule}MotionSpeedH";
            //string AI_MotionPositionSet = $"Motion.AI_{uniqueModule}MotionPositionSet";

            //if (!currentStationDic.ContainsKey(uniqueModule))
            //{
            //    currentStationDic.Add(uniqueModule, 0);
            //}

            //if (!currentPosDic.ContainsKey(uniqueModule))
            //{
            //    currentPosDic.Add(uniqueModule, 0);
            //}

            //if (!targetStationPosDic.ContainsKey(uniqueModule))
            //{
            //    targetStationPosDic.Add(uniqueModule, 0);
            //}

            //if (!isAutoMoveDic.ContainsKey(module))
            //{
            //    isAutoMoveDic.Add(module, false);
            //}

            //if (!logDic.ContainsKey(uniqueModule))
            //{
            //    logDic.Add(uniqueModule, false);
            //}

            //if (!timerDic.ContainsKey(uniqueModule))
            //{
            //    timerDic.Add(uniqueModule, new DeviceTimer());
            //}

            //if (IO.AO[AO_MotionJogN].Value > 1 || IO.AO[AO_MotionJogP].Value > 1)
            //{
            //    short valueL = (short)IO.AO[AO_MotionJogSpeedL].Value;
            //    short valueH = (short)IO.AO[AO_MotionJogSpeedH].Value;
            //    valueH = valueH > Int16.MaxValue ? (short)((~valueH + 1) * -1) : (short)valueH;
            //    int jogSpeed = valueL + ((valueH + 1) << 16);
            //    currentPosDic[uniqueModule] = IO.AO[AO_MotionJogN].Value > 1 ? motionStationList[currentStationDic[uniqueModule]] - jogSpeed : motionStationList[currentStationDic[uniqueModule]] + jogSpeed;
            //    IO.AI[AI_MotionPositionL].Value = (short)(currentPosDic[uniqueModule] & 0xFFFF);
            //    IO.AI[AI_MotionPositionH].Value = (short)((currentPosDic[uniqueModule] >> 16) & 0xFFFF);
            //}

            ////station
            //targetStationPosDic[uniqueModule] = IO.AO[AO_MotionPositionSet].Value;
            //var targetPos = motionStationList[targetStationPosDic[uniqueModule]];
            //IO.AI[AI_MotionTargetPositionL].Value = (short)(targetPos & 0xFFFF);
            //IO.AI[AI_MotionTargetPositionH].Value = (short)((targetPos >> 16) & 0xFFFF);

            //if (!isAutoMoveDic[module] && IO.AO[AO_MotionAutoMove].Value == 1)
            //{
            //    currentPosDic[uniqueModule] = motionStationList[currentStationDic[uniqueModule]];
            //}

            //int MotionServoStatusValue = 0;
            //if (isAutoMoveDic[module])
            //{
            //    IO.AI[AI_MotionTargetPositionL].Value = (short)(targetPos & 0xFFFF);
            //    IO.AI[AI_MotionTargetPositionH].Value = (short)((targetPos >> 16) & 0xFFFF);
            //    IO.AI[AI_MotionSpeedL].Value = IO.AO[AO_MotionAutoSpeedL].Value;
            //    IO.AI[AI_MotionSpeedH].Value = IO.AO[AO_MotionAutoSpeedH].Value;
            //    short valueLow = (short)IO.AO[AO_MotionAutoSpeedL].Value;
            //    short valueHigh = (short)IO.AO[AO_MotionAutoSpeedH].Value;
            //    valueHigh = valueHigh > Int16.MaxValue ? (short)((~valueHigh + 1) * -1) : (short)valueHigh;
            //    int moveSpeed = valueLow + ((valueHigh + 1) << 16);

            //    int status = (IO.AI[AI_MotionServoStatus].Value & 0xBF);
            //    if (targetPos == currentPosDic[uniqueModule])
            //    {
            //        if (logDic[uniqueModule])
            //        {
            //            LOG.Write(String.Format("Scheduler axis move stop uniqueModule={0} target={1},time span {2}", uniqueModule, targetStationPosDic[uniqueModule], timerDic[uniqueModule].GetElapseTime()));
            //            logDic[uniqueModule] = false;
            //            timerDic[uniqueModule].Stop();
            //        }
            //        status += 0x40;
            //    }
            //    else
            //    {
            //        if (timerDic[uniqueModule].IsIdle())
            //        {
            //            LOG.Write(String.Format("Scheduler axis move start uniqueModule={0} target={1}", uniqueModule, targetStationPosDic[uniqueModule]));
            //            timerDic[uniqueModule].Start(500000);
            //            logDic[uniqueModule] = true;
            //        }
            //    }

            //    if (targetPos > currentPosDic[uniqueModule])
            //    {
            //        currentPosDic[uniqueModule] += 5000;

            //        if (currentPosDic[uniqueModule] >= targetPos)
            //        {
            //            currentStationDic[uniqueModule] = targetStationPosDic[uniqueModule];
            //            targetPos = currentPosDic[uniqueModule];
            //            status += 0x40;
            //        }
            //    }

            //    if (targetPos < currentPosDic[uniqueModule])
            //    {
            //        currentPosDic[uniqueModule] -= 5000;

            //        if (currentPosDic[uniqueModule] <= targetPos)
            //        {
            //            currentStationDic[uniqueModule] = targetStationPosDic[uniqueModule];
            //            targetPos = currentPosDic[uniqueModule];
            //            status += 0x40;
            //        }
            //    }

            //    //position done. bit 6
            //    MotionServoStatusValue = status | MotionServoStatusValue;

            //    IO.AI[AI_MotionPositionL].Value = (short)(currentPosDic[uniqueModule] & 0xFFFF);
            //    IO.AI[AI_MotionPositionH].Value = (short)((currentPosDic[uniqueModule] >> 16) & 0xFFFF);
            //}

            //int systemStatus = 0;
            //if (IO.AO[AO_MotionServoOn].Value == 1)
            //    systemStatus = 2 + (isAutoMoveDic[module] ? 16 : 32) + (IO.AO[AO_MotionAbort].Value == 1 ? 4 : 0); ;
            //IO.AI[AI_MotionSystemStatus].Value = (short)systemStatus;

            //isAutoMoveDic[module] = IO.AO[AO_MotionAutoMove].Value == 1;

            ////servo on. bit 5
            //MotionServoStatusValue = MotionServoStatusValue | (IO.AO[AO_MotionServoOn].Value == 1 ? 0x20 : 0);

            ////ready. Servo stop. bit 6
            //MotionServoStatusValue = MotionServoStatusValue | (IO.AO[AO_MotionServoStop].Value == 0 ? 0x40 : 0);

            ////servo normal. bit 1
            //MotionServoStatusValue = MotionServoStatusValue | 2;

            //IO.AI[AI_MotionServoStatus].Value = (short)MotionServoStatusValue;
            //IO.AI[AI_MotionPositionSet].Value = IO.AO[AO_MotionPositionSet].Value;


        }
        private void MonitorRAxis(string module)
        {
            if (IO.DI[$"{module}.DI_BoatRAxisHomeBusy"].Value != IO.DO[$"{module}.DO_BoatRAxisHomeCmd"].Value &&
                IO.DO[$"{module}.DO_BoatRAxisHomeCmd"].Value)
            {
                IO.DI[$"{module}.DI_BoatRAxisHomeDone"].Value = false;
                if (!_rAxisHomeTimer.IsRunning)
                    _rAxisHomeTimer.Restart();
            }
            if (_rAxisHomeTimer.IsRunning && _rAxisHomeTimer.ElapsedMilliseconds > 3000)
            {
                IO.DI[$"{module}.DI_BoatRAxisHomeDone"].Value = true;
                _rAxisHomeTimer.Stop();
            }
            IO.DI[$"{module}.DI_BoatRAxisHomeBusy"].Value = IO.DO[$"{module}.DO_BoatRAxisHomeCmd"].Value;
            IO.DI[$"{module}.DI_BoatRAxisRotationBusy"].Value = IO.DO[$"{module}.DO_BoatRAxisRotationForward"].Value || IO.DO[$"{module}.DO_BoatRAxisRotationReverse"].Value;
        }
        private void MonitorZAxis(string module)
        {
            if ((int)(IO.AO[$"{module}.AO_BoatPosition"].FloatValue + 0.00001) == 1)
            {
                IO.DI[$"{module}.DI_HmPosBoatZAxis"].Value = true;
                IO.DI[$"{module}.DI_MiddlePos3BoatZAxis"].Value = true;
                IO.DI[$"{module}.DI_MiddlePos1BoatZAxis"].Value = false;
                IO.DI[$"{module}.DI_MiddlePos2BoatZAxis"].Value = false;
            }
            if ((int)(IO.AO[$"{module}.AO_BoatPosition"].FloatValue + 0.00001) == 2)
            {
                IO.DI[$"{module}.DI_HmPosBoatZAxis"].Value = false;
                IO.DI[$"{module}.DI_MiddlePos3BoatZAxis"].Value = false;
                IO.DI[$"{module}.DI_MiddlePos1BoatZAxis"].Value = true;
                IO.DI[$"{module}.DI_MiddlePos2BoatZAxis"].Value = false;
            }
            if ((int)(IO.AO[$"{module}.AO_BoatPosition"].FloatValue + 0.00001) == 3)
            {
                IO.DI[$"{module}.DI_HmPosBoatZAxis"].Value = false;
                IO.DI[$"{module}.DI_MiddlePos3BoatZAxis"].Value = false;
                IO.DI[$"{module}.DI_MiddlePos1BoatZAxis"].Value = false;
                IO.DI[$"{module}.DI_MiddlePos2BoatZAxis"].Value = true;
            }

            IO.AI[$"{module}.AI_BoatTargetPosFb"].FloatValue = IO.AO[$"{module}.AO_BoatPosition"].FloatValue;
        }
        private void MonitorLP(string module, string lp)
        {
            if (IO.DO[$"{module}.DO_{lp}FOUPClamp"].Value)
            {
                IO.DI[$"{module}.DI_{lp}FOUPLeftClamp"].Value = true;
                IO.DI[$"{module}.DI_{lp}FOUPRightClamp"].Value = true;
                IO.DI[$"{module}.DI_{lp}FOUPLeftRelease"].Value = false;
                IO.DI[$"{module}.DI_{lp}FOUPRightRelease"].Value = false;
            }
            if (IO.DO[$"{module}.DO_{lp}FOUPRelease"].Value)
            {
                IO.DI[$"{module}.DI_{lp}FOUPLeftClamp"].Value = false;
                IO.DI[$"{module}.DI_{lp}FOUPRightClamp"].Value = false;
                IO.DI[$"{module}.DI_{lp}FOUPLeftRelease"].Value = true;
                IO.DI[$"{module}.DI_{lp}FOUPRightRelease"].Value = true;
            }
        }

        private void MonitorFIMS(string module, string fims)
        {
            IO.DI[$"{module}.DI_{fims}LoadComplete"].Value = IO.DO[$"{module}.DO_{fims}LoadCommand"].Value;
            IO.DI[$"{module}.DI_{fims}UnloadComplete"].Value = IO.DO[$"{module}.DO_{fims}UnloadCommand"].Value;
            IO.DI[$"{module}.DI_{fims}HomeComplete"].Value = IO.DO[$"{module}.DO_{fims}HomeCommand"].Value;

            if (IO.DI[$"{module}.DI_{fims}FOUPDock"] != null && IO.DO[$"{module}.DO_{fims}Dock"] != null) IO.DI[$"{module}.DI_{fims}FOUPDock"].Value = IO.DO[$"{module}.DO_{fims}Dock"].Value;

            if (IO.DI[$"{module}.DI_{fims}FOUPUndock"] != null && IO.DO[$"{module}.DO_{fims}Undock"] != null) IO.DI[$"{module}.DI_{fims}FOUPUndock"].Value = IO.DO[$"{module}.DO_{fims}Undock"].Value;
            if (IO.DI[$"{module}.DI_{fims}Seal"] != null && IO.DO[$"{module}.DO_{fims}Seal"] != null) IO.DI[$"{module}.DI_{fims}Seal"].Value = IO.DO[$"{module}.DO_{fims}Seal"].Value;
            if (IO.DI[$"{module}.DI_{fims}Release"] != null && IO.DO[$"{module}.DO_{fims}Release"] != null) IO.DI[$"{module}.DI_{fims}Release"].Value = IO.DO[$"{module}.DO_{fims}Release"].Value;
            if (IO.DI[$"{module}.DI_{fims}DoorClosed"] != null && IO.DO[$"{module}.DO_{fims}DoorClose"] != null) IO.DI[$"{module}.DI_{fims}DoorClosed"].Value = IO.DO[$"{module}.DO_{fims}DoorClose"].Value;
            if (IO.DI[$"{module}.DI_{fims}DoorOpened"] != null && IO.DO[$"{module}.DO_{fims}DoorOpen"] != null) IO.DI[$"{module}.DI_{fims}DoorOpened"].Value = IO.DO[$"{module}.DO_{fims}DoorOpen"].Value;
            if (IO.DI[$"{module}.DI_{fims}LatchOn"] != null && IO.DO[$"{module}.DO_{fims}Latch1On"] != null) IO.DI[$"{module}.DI_{fims}LatchOn"].Value = IO.DO[$"{module}.DO_{fims}Latch1On"].Value || IO.DO[$"{module}.DO_{fims}Latch2On"].Value;
            if (IO.DI[$"{module}.DI_{fims}LatchOff"] != null && IO.DO[$"{module}.DO_{fims}Latch1Off"] != null) IO.DI[$"{module}.DI_{fims}LatchOff"].Value = IO.DO[$"{module}.DO_{fims}Latch1Off"].Value || IO.DO[$"{module}.DO_{fims}Latch2Off"].Value;
            if (IO.DI[$"{module}.DI_{fims}CollisionAvoidanceUp"] != null && IO.DO[$"{module}.DO_{fims}CollisionAvoidanceUp"] != null) IO.DI[$"{module}.DI_{fims}CollisionAvoidanceUp"].Value = IO.DO[$"{module}.DO_{fims}CollisionAvoidanceUp"].Value;
            if (IO.DI[$"{module}.DI_{fims}CollisionAvoidanceDown"] != null && IO.DO[$"{module}.DO_{fims}CollisionAvoidanceDown"] != null) IO.DI[$"{module}.DI_{fims}CollisionAvoidanceDown"].Value = IO.DO[$"{module}.DO_{fims}CollisionAvoidanceDown"].Value;
            if (IO.DI[$"{module}.DI_{fims}N2PurgeValveOpened"] != null && IO.DO[$"{module}.DO_{fims}N2PurgeValveOpen"] != null) IO.DI[$"{module}.DI_{fims}N2PurgeValveOpened"].Value = IO.DO[$"{module}.DO_{fims}N2PurgeValveOpen"].Value;
            if (IO.DI[$"{module}.DI_{fims}N2PurgeValveClosed"] != null && IO.DO[$"{module}.DO_{fims}N2PurgeValveClose"] != null) IO.DI[$"{module}.DI_{fims}N2PurgeValveClosed"].Value = IO.DO[$"{module}.DO_{fims}N2PurgeValveClose"].Value;
        }

        private void MonitorBuffer()
        {
            switch (IO.AO[$"PM1.AO_TargetPositionBufferAxis"].FloatValue)
            {
                case 1:
                case 9:
                    IO.DI[$"PM1.DI_L1Position"].Value = true;
                    break;
                case 2:
                case 10:
                    IO.DI[$"PM1.DI_L2Position"].Value = true;
                    break;
                case 3:
                case 11:
                    IO.DI[$"PM1.DI_L3Position"].Value = true;
                    break;
                case 4:
                case 12:
                    IO.DI[$"PM1.DI_L4Position"].Value = true;
                    break;
                case 5:
                case 13:
                    IO.DI[$"PM1.DI_H1Position"].Value = true;
                    break;
                case 6:
                case 14:
                    IO.DI[$"PM1.DI_H2Position"].Value = true;
                    break;
                case 7:
                case 15:
                    IO.DI[$"PM1.DI_H3Position"].Value = true;
                    break;
                case 8:
                case 16:
                    IO.DI[$"PM1.DI_H4Position"].Value = true;
                    break;
            }
            IO.AI[$"PM1.AI_BufferTargetPosFb"].FloatValue = IO.AO[$"PM1.AO_TargetPositionBufferAxis"].FloatValue;
        }

        private void MonitorDoor()
        {
            if (IO.DI[$"PM1.DI_AGVDoorOpened"] != null && IO.DO[$"PM1.DO_AGVDoorSwitchOpen"] != null) IO.DI[$"PM1.DI_AGVDoorOpened"].Value = IO.DO[$"PM1.DO_AGVDoorSwitchOpen"].Value;
            if (IO.DI[$"PM1.DI_AGVDoorClosed"] != null && IO.DO[$"PM1.DO_AGVDoorSwitchClose"] != null) IO.DI[$"PM1.DI_AGVDoorClosed"].Value = IO.DO[$"PM1.DO_AGVDoorSwitchClose"].Value;
        }
    }
}