CyberX8/CyberX8_RT/Devices/DeviceManager.cs

using System;
using System.Collections.Generic;
using System.IO;
using Aitex.Core.Common;
using Aitex.Core.RT.Device;
using MECF.Framework.Common.Equipment;
using CyberX8_RT.Devices;
using CyberX8_RT.Devices.PUF;
using CyberX8_RT.Devices.LinMot;
using CyberX8_RT.Devices.Resistivity;
using CyberX8_RT.Devices.Temperature;
using CyberX8_RT.Devices.AXIS;
using CyberX8_RT.Devices.Loader;
using CyberX8_RT.Devices.TransPorter;
using CyberX8_RT.Devices.PowerSupplier;
using CyberX8_RT.Devices.Facilities;
using CyberX8_RT.Devices.SRD;
using MECF.Framework.Common.TwinCat;
using MECF.Framework.Common.Beckhoff.IOAxis;
using CyberX8_RT.Devices.Prewet;
using MECF.Framework.Common.Device.LinMot;
using CyberX8_RT.Devices.Safety;
using CyberX8_RT.Modules.Dryer;
using CyberX8_RT.Devices.Dryer;
using CyberX8_RT.Devices.Rinse;
using CyberX8_RT.Devices.SignalLight;
using MECF.Framework.Common.ToolLayout;
using CyberX8_RT.Devices.Reservoir;
using CyberX8_RT.Devices.Metal;
using CyberX8_RT.Devices.BarcodeReader;
using MECF.Framework.RT.Core.Equipments;
using System.Threading;
using System.Reflection;
using MECF.Framework.Common.Device.Galil;
using static Mono.Security.X509.X520;
using System.Windows.Media.Imaging;
using CyberX8_RT.Devices.EFEM;

namespace CyberX8_RT.Instances
{
    public class DeviceEntity : DeviceEntityT<DeviceManager>
    {
        public DeviceEntity()
        {
        }
    }

    public class DeviceManager : DeviceManagerBase
    {
        #region 常量
        private const string STRATUS = "Stratus";
        #endregion
        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public override bool Initialize()
        {
            if(ModuleHelper.IsInstalled(ModuleName.PUF1))
            {
                InitPuf(ModuleName.PUF1);
            }

            PufDeviceTimer pufDeviceTimer = new PufDeviceTimer();
            AddCustomDevice(pufDeviceTimer);

            if (ModuleHelper.IsInstalled(ModuleName.Loader1))
            {
                InitLoader(ModuleName.Loader1);
            }

            if(ModuleHelper.IsInstalled(ModuleName.Transporter2))
            {
                InitLoaderTransporter(ModuleName.Transporter2);
            }

            if (ModuleHelper.IsInstalled(ModuleName.Transporter1))
            {
                InitProcessTransporter(ModuleName.Transporter1);
            }

            TransporterDeviceTimer transporterDeviceTimer = new TransporterDeviceTimer();
            AddCustomDevice(transporterDeviceTimer);

            if(ModuleHelper.IsInstalled(ModuleName.Prewet1))
            {
                InitializePrewet(ModuleName.Prewet1);
            }

            TotalSRDDevice totalSRDDevice = new TotalSRDDevice();
            AddCustomDevice(totalSRDDevice);

            if (ModuleHelper.IsInstalled(ModuleName.SRD1))
            {
                InitialSRD(ModuleName.SRD1);
            }

            if(ModuleHelper.IsInstalled(ModuleName.SRD2))
            {
                InitialSRD(ModuleName.SRD2);
            }
            SRDDeviceTimer srdDeviceTimer = new SRDDeviceTimer();
            AddCustomDevice(srdDeviceTimer);


            InitializeDryers();
            InitLinMotAxis();
            InitResisitivity();
            InitializeTemperature();
            InitializePowerSuppliers();
            InitializeRinses();
            InitializeMetals();
            InitializeReservoirs();
            InitBarcodeReader();
            SystemFacilities systemFacilities = new SystemFacilities();
            AddCustomModuleDevice(systemFacilities);

            SafetyDevice safetyDevice = new SafetyDevice();
            AddCustomDevice(safetyDevice);

            TotalReservoirDevice reservoirDevice = new TotalReservoirDevice();
            AddCustomDevice(reservoirDevice);

            AddCustomModuleDevice(new SunWaySignalTower("System", "SignalTower"));

            return true;
        }

        /// <summary>
        /// 初始化PF
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitPuf(ModuleName moduleName)
        {
            GalilAxisConfig flipGalilAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(),"Flip");
            if (flipGalilAxis != null)
            {
                JetAxisBase pufFlipAxis = AxisManager.Instance.GetAxisInstance(flipGalilAxis.Type, moduleName.ToString(), "Flip");
                pufFlipAxis.InterLock = new PufFlipAxisInterLock(pufFlipAxis);
                AddCustomModuleDevice(pufFlipAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), pufFlipAxis);
            }
            GalilAxisConfig rotationGalilAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(), "Rotation");
            if (rotationGalilAxis != null)
            {
                JetAxisBase rotationAxis = AxisManager.Instance.GetAxisInstance(rotationGalilAxis.Type, moduleName.ToString(), "Rotation");
                rotationAxis.InterLock = new PufRotationAxisInterLock(rotationAxis);
                AddCustomModuleDevice(rotationAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), rotationAxis);
            }
            PufVacuum pufVacuum = new PufVacuum(moduleName.ToString());
            AddCustomModuleDevice(pufVacuum);
            PufDistanceSensor distanceSensor = new PufDistanceSensor(moduleName.ToString());
            AddCustomModuleDevice(distanceSensor);
        }
        /// <summary>
        /// 初始化Loader
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitLoader(ModuleName moduleName)
        {
            GalilAxisConfig shuttleAGalilAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(),"ShuttleA");
            if (shuttleAGalilAxis != null)
            {
                JetAxisBase shuttleAAxis = AxisManager.Instance.GetAxisInstance(shuttleAGalilAxis.Type, moduleName.ToString(), "ShuttleA");
                AddCustomModuleDevice(shuttleAAxis);
                shuttleAAxis.InterLock = new LoaderShuttleAxisInterLock(shuttleAAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), shuttleAAxis);
            }
            GalilAxisConfig shuttleBBeckhoffAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(),"ShuttleB");
            if (shuttleBBeckhoffAxis != null)
            {
                JetAxisBase shuttleBAxis = AxisManager.Instance.GetAxisInstance(shuttleBBeckhoffAxis.Type, moduleName.ToString(), "ShuttleB");
                AddCustomModuleDevice(shuttleBAxis);
                shuttleBAxis.InterLock = new LoaderShuttleAxisInterLock(shuttleBAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), shuttleBAxis);
            }
            GalilAxisConfig tiltABeckhoffAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(), "TiltA");
            if (tiltABeckhoffAxis != null)
            {
                JetAxisBase tiltAAxis = AxisManager.Instance.GetAxisInstance(tiltABeckhoffAxis.Type, moduleName.ToString(), "TiltA");
                AddCustomModuleDevice(tiltAAxis);
                tiltAAxis.InterLock = new LoaderTiltAxisInterLock(tiltAAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), tiltAAxis);
            }
            GalilAxisConfig tiltBBeckhoffAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(), "TiltB");
            if (tiltBBeckhoffAxis != null)
            {
                JetAxisBase tiltBAxis = AxisManager.Instance.GetAxisInstance(tiltBBeckhoffAxis.Type, moduleName.ToString(), "TiltB");
                AddCustomModuleDevice(tiltBAxis);
                tiltBAxis.InterLock = new LoaderTiltAxisInterLock(tiltBAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), tiltBAxis);
            }
            GalilAxisConfig crsABeckhoffAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(), "LSA");
            if (crsABeckhoffAxis != null)
            {
                JetAxisBase crsAAxis = AxisManager.Instance.GetAxisInstance(crsABeckhoffAxis.Type, moduleName.ToString(), "LSA");
                AddCustomModuleDevice(crsAAxis);
                crsAAxis.InterLock = new LoaderCRSAxisInterLock(crsAAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), crsAAxis);
            }
            GalilAxisConfig crsBBeckhoffAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(), "LSB");
            if (crsBBeckhoffAxis != null)
            {
                JetAxisBase crsBAxis = AxisManager.Instance.GetAxisInstance(crsBBeckhoffAxis.Type, moduleName.ToString(), "LSB");
                AddCustomModuleDevice(crsBAxis);
                crsBAxis.InterLock = new LoaderCRSAxisInterLock(crsBAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(),  crsBAxis);
            }
            GalilAxisConfig rotationBeckhoffAxis = GalilControllerCfgManager.Instance.GetGalilAxisConfig(moduleName.ToString(), "Rotation");
            if (rotationBeckhoffAxis != null)
            {
                JetAxisBase rotationAxis = AxisManager.Instance.GetAxisInstance(rotationBeckhoffAxis.Type, moduleName.ToString(), "Rotation");
                AddCustomModuleDevice(rotationAxis);
                rotationAxis.InterLock = new LoaderRotationAxisInterLock(rotationAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), rotationAxis);
            }
            LoaderSideDevice loaderSideA=new LoaderSideDevice(moduleName.ToString(),"SideA");
            AddCustomModuleDevice(loaderSideA);
            LoaderSideDevice loaderSideB = new LoaderSideDevice(moduleName.ToString(), "SideB");
            AddCustomModuleDevice(loaderSideB);

            LoaderCommonDevice loaderCommon=new LoaderCommonDevice(moduleName.ToString());
            AddCustomModuleDevice(loaderCommon);

            LoaderDeviceTimer loaderDevice=new LoaderDeviceTimer(moduleName.ToString());
            AddCustomDevice(loaderDevice);
        }
        /// <summary>
        /// 初始化 Loader Transporter
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitLoaderTransporter(ModuleName moduleName)
        {
            BeckhoffAxis gantryBeckhoffAxis = BeckhoffAxisManager.Instance.GetAxis($"{moduleName}.Gantry");
            if (gantryBeckhoffAxis != null)
            {
                JetAxisBase gantryAxis = AxisManager.Instance.GetAxisInstance(gantryBeckhoffAxis.MotorType, moduleName.ToString(), "Gantry");
                gantryAxis.IsForwardSensorLimit = true;
                AddCustomModuleDevice(gantryAxis);
                gantryAxis.InterLock = new LoaderTransPorterGantryAxisInterLock(gantryAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), gantryAxis);
            }
            BeckhoffAxis elevatorBeckhoffAxis = BeckhoffAxisManager.Instance.GetAxis($"{moduleName}.Elevator");
            if (elevatorBeckhoffAxis != null)
            {
                JetAxisBase elevatorAxis = AxisManager.Instance.GetAxisInstance(elevatorBeckhoffAxis.MotorType, moduleName.ToString(), "Elevator");
                elevatorAxis.IsForwardSensorLimit = true;
                AddCustomModuleDevice(elevatorAxis);
                elevatorAxis.InterLock = new LoaderTransPorterElevatorAxisInterLock(elevatorAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), elevatorAxis);
            }
            TransporterCommon transporterCommon = new TransporterCommon(moduleName.ToString());
            AddCustomModuleDevice(transporterCommon);
        }
        /// <summary>
        /// 初始化Process Transporter
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitProcessTransporter(ModuleName moduleName)
        {
            BeckhoffAxis gantryBeckhoffAxis = BeckhoffAxisManager.Instance.GetAxis($"{moduleName}.Gantry");
            if (gantryBeckhoffAxis != null)
            {
                JetAxisBase gantryAxis = AxisManager.Instance.GetAxisInstance(gantryBeckhoffAxis.MotorType, moduleName.ToString(), "Gantry");
                gantryAxis.IsRevSensorLimit = true;
                AddCustomModuleDevice(gantryAxis);
                gantryAxis.InterLock = new ProcessTransporterGantryAxisInterLock(gantryAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), gantryAxis);
            }
            BeckhoffAxis elevatorBeckhoffAxis = BeckhoffAxisManager.Instance.GetAxis($"{moduleName}.Elevator");
            if (elevatorBeckhoffAxis != null)
            {
                JetAxisBase elevatorAxis = AxisManager.Instance.GetAxisInstance(elevatorBeckhoffAxis.MotorType, moduleName.ToString(), "Elevator");
                elevatorAxis.IsForwardSensorLimit = true;
                AddCustomModuleDevice(elevatorAxis);
                elevatorAxis.InterLock = new ProcessTransporterElevatorAxisInterLock(elevatorAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), elevatorAxis);
            }
            TransporterCommon transporterCommon = new TransporterCommon(moduleName.ToString());
            AddCustomModuleDevice(transporterCommon);
        }
        /// <summary>
        /// 初始化SRD
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitialSRD(ModuleName moduleName)
        {
            BeckhoffAxis armBeckhoffAxis = BeckhoffAxisManager.Instance.GetAxis($"{moduleName}.Arm");
            if (armBeckhoffAxis != null)
            {
                JetAxisBase armAxis = AxisManager.Instance.GetAxisInstance(armBeckhoffAxis.MotorType, moduleName.ToString(), "Arm");
                AddCustomModuleDevice(armAxis);
                armAxis.InterLock = new SrdArmAxisInterLock(armAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), armAxis);
            }
            BeckhoffAxis rotationBeckhoffAxis = BeckhoffAxisManager.Instance.GetAxis($"{moduleName}.Rotation");
            if (rotationBeckhoffAxis != null)
            {
                JetAxisBase rotationAxis = AxisManager.Instance.GetAxisInstance(rotationBeckhoffAxis.MotorType, moduleName.ToString(), "Rotation");
                AddCustomModuleDevice(rotationAxis);
                rotationAxis.InterLock = new SrdRotationAxisInterLock(rotationAxis);
                AxisManager.Instance.AddModuleAxis(moduleName.ToString(), rotationAxis);
            }
            SrdCommonDevice srdCommon = new SrdCommonDevice(moduleName.ToString());
            AddCustomModuleDevice(srdCommon);
        }
        /// <summary>
        /// 初即时化Prewet
        /// </summary>
        /// <param name="moduleName"></param>
        private void InitializePrewet(ModuleName moduleName)
        {
            PrewetDevice prewet = new PrewetDevice(moduleName.ToString());
            AddCustomDevice(prewet);
        }
        /// <summary>
        /// 初始化Dryers
        /// </summary>
        private void InitializeDryers()
        {
            foreach(string item in DryerItemManager.Instance.InstalledModules)
            {
                DryerDevice dryerDevice = new DryerDevice(item);
                AddCustomDevice(dryerDevice);
            }
        }
        /// <summary>
        /// 初始化LinMotAxis
        /// </summary>
        private void InitLinMotAxis()
        {
            foreach(string item in LinmotItemManager.Instance.InstalledModules)
            {
                LinmotItem linmotItem=LinmotItemManager.Instance.GetLinmotItem(item);
                for(int i = 0;i< linmotItem.Count; i++)
                {
                    LinMotAxis linMotAxis = new LinMotAxis($"{item}-{i + 1}");
                    linMotAxis.LastSwitchOff = linmotItem.ResetSwitchOff == 1;
                    AddCustomDevice(linMotAxis);
                }
            }
            LinmotDeviceTimer linmotDeviceTimer = new LinmotDeviceTimer();
            AddCustomDevice(linmotDeviceTimer);
        }
        /// <summary>
        /// 初始化水阻计
        /// </summary>
        private void InitResisitivity()
        {
            foreach(string item in ResistivityProbeItemManager.Instance.InstalledModules)
            {
                ResistivityProbeItem resistivityItem = ResistivityProbeItemManager.Instance.GetResistivityProbeItem(item);
                for(int i=0;i<resistivityItem.Count;i++)
                {
                    ResistivityController resistivityController = new ResistivityController($"{item}-{i + 1}");
                    AddCustomDevice(resistivityController);
                }
            }
        }
        /// <summary>
        /// 初始化读码器
        /// </summary>
        private void InitBarcodeReader()
        {
            foreach (string item in BarcodeReaderItemManager.Instance.InstalledModules)
            {
                BarcodeReaderItem barcodeReaderItem = BarcodeReaderItemManager.Instance.GetBarcodeReaderItem(item);
                for (int i = 0; i < barcodeReaderItem.Count; i++)
                {
                    BarcodeReaderController barcodeReaderController = new BarcodeReaderController($"{item}");
                    AddCustomDevice(barcodeReaderController);
                }
            }
        }
        /// <summary>
        /// 初始化温度计
        /// </summary>
        private void InitializeTemperature()
        {
            foreach (string item in TemperatureItemManager.Instance.InstalledModules)
            {
                TemperatureItem temperatureItem = TemperatureItemManager.Instance.GetTemperatureItem(item);
                for (int i = 0; i < temperatureItem.Count; i++)
                {
                    TemperatureController tempController = new TemperatureController($"{item}-{i + 1}");
                    AddCustomDevice(tempController);
                }
            }

        }
        /// <summary>
        /// 初始化PowerSupplier
        /// </summary>
        private void InitializePowerSuppliers()
        {
            foreach(string item in PowerSupplierItemManager.Instance.InstalledModules)
            {
                PowerSupplierItem powerSupplierItem=PowerSupplierItemManager.Instance.GetPowerSupplierItem(item);
                for (int i = 0; i < powerSupplierItem.Count; i++)
                {
                    CellPowerSupplier cellPowerSupplier = new CellPowerSupplier($"{item}-{i + 1}");
                    AddCustomDevice(cellPowerSupplier);
                }
            }
            foreach(string item in CmmPowerItemManager.Instance.InstalledModules)
            {
                CmmPowerItem powerSupplierItem = CmmPowerItemManager.Instance.GetCmmPowerSupplierItem(item);
                for (int i = 0; i < powerSupplierItem.Count; i++)
                {
                    CellPowerSupplier cellPowerSupplier = new CellPowerSupplier($"{item}-{i + 1}");
                    AddCustomDevice(cellPowerSupplier);
                }
            }
        }
        /// <summary>
        /// 初始化Rinse集合
        /// </summary>
        private void InitializeRinses()
        {
            foreach(string item in RinseItemManager.Instance.InstalledModules)
            {
                RinseDevice rinseDevice=new RinseDevice(item);
                AddCustomDevice(rinseDevice);
            }
        }
        /// <summary>
        /// 初始化Reservoirs
        /// </summary>
        private void InitializeReservoirs()
        {
            foreach(string item in ReservoirItemManager.Instance.InstalledModules)
            {
                ReservoirItem reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(item);
                if (reservoirItem.SubType == STRATUS)
                {
                    StandardHotReservoirDevice reservoirDevice = new StandardHotReservoirDevice(item);
                    AddCustomDevice(reservoirDevice);
                }
                else
                {
                    CompactMembranReservoirDevice reservoirDevice = new CompactMembranReservoirDevice(item);
                    AddCustomDevice(reservoirDevice);
                }
            }
        }
        /// <summary>
        /// 初始化Metals
        /// </summary>
        private void InitializeMetals()
        {
            foreach(string item in MetalItemManager.Instance.InstalledModules)
            {
                MetalItem metalItem = MetalItemManager.Instance.GetMetalItem(item);
                if (metalItem.SubType == STRATUS)
                {
                    StandardHotMetalDevice metalDevice = new StandardHotMetalDevice(item);
                    AddCustomDevice(metalDevice);
                }
                else
                {
                    CompactMembranMetalDevice metalDevice = new CompactMembranMetalDevice(item);
                    AddCustomDevice(metalDevice);
                }
            }
        }

        private bool Invoke(string arg1, object[] args)
        {
            string name = (string)args[0];
            string func = (string)args[1];

            object[] param = new object[args.Length - 2];

            for (int i = 2; i < args.Length; i++)
                param[i - 2] = args[i].ToString();

            DEVICE.Do(string.Format("{0}.{1}", name, func), 0, true, param);

            return true;
        }
    }
}