Kepler-Release/Venus/Framework/Common/Device/Common/DeviceManagerBase.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using System.Xml;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;

namespace Aitex.Core.RT.Device
{
    public class DeviceManagerBase : IDeviceManager
    {
        private Dictionary<string, IDevice> _nameDevice = new Dictionary<string, IDevice>();
        private Dictionary<Type, List<IDevice>> _typeDevice = new Dictionary<Type, List<IDevice>>();

        protected XmlElement DeviceModelNodes { get; private set; }

        DeviceTimer _peformanceTimer = new DeviceTimer();
        R_TRIG _trigExceed500 = new R_TRIG();
 
        public DeviceManagerBase()
        {
            DEVICE.Manager = this;
        }

        public virtual void Terminate()
        {

            foreach (var device in _nameDevice.Values)
            {
                device.Terminate();
            }

        }

        public void Monitor()
        {
           

            foreach (var device in _nameDevice.Values)
            {
                try
                {
                    _peformanceTimer.Start(0);

                    device.Monitor();

                    _trigExceed500.CLK = _peformanceTimer.GetElapseTime() > 500;
                    if (_trigExceed500.Q)
                    {
                        //LOG.Warning($"{device.Module}.{device.Name} monitor time {_peformanceTimer.GetElapseTime()} ms");
                    }
                }
                catch (Exception ex)
                {
                    //LOG.Write(ex, string.Format("Monitor {0} Exception", device.Name));
                    throw (ex);
                }
            }
 
            
        }

        public void Reset()
        {
            foreach (var device in _nameDevice.Values)
            {
                device.Reset();
            }

            _trigExceed500.RST = true;
        }

        public void Initialize(string modelFile, string type, ModuleName mod, string ioModule="")
        {
            if (!File.Exists(modelFile))
            {
                throw new ApplicationException(string.Format("did not find the device model file {0} ", modelFile));
            }

            XmlDocument _dom = new XmlDocument();
            try
            {
                _dom.Load(modelFile);
                XmlElement node = _dom.SelectSingleNode("DeviceModelDefine") as XmlElement;
                if (node == null)
                {
                    throw new ApplicationException(string.Format("device mode file {0} is not valid", modelFile));
                }

                string fileType = node.GetAttribute("type");
                if (fileType != type)
                {
                    throw new ApplicationException(string.Format("the type {0} in device mode file {1} is in accordance with the system type {2}", fileType, modelFile, type));
                }
                DeviceModelNodes = node;

                foreach (XmlNode devicesNode1 in node.ChildNodes)
                {
                    if (devicesNode1.NodeType == XmlNodeType.Comment)
                        continue;

                    XmlElement nodeDevices = devicesNode1 as XmlElement;

                    if (null == nodeDevices) continue;

                    string assName = nodeDevices.GetAttribute("assembly");
                    if (string.IsNullOrEmpty(assName))
                        assName = "MECF.Framework.Common";
                    
                    string typeName = nodeDevices.GetAttribute("classType");
                    if (string.IsNullOrEmpty(typeName))
                        typeName = "Aitex.Core.RT.Device.Unit." + nodeDevices.Name.Substring(0, nodeDevices.Name.Length - 1);

                    string isEnabled = nodeDevices.GetAttribute("IsEnabled");
                    if (isEnabled == "False" || isEnabled == "false") continue;

                    Assembly assembly = Assembly.Load(assName);
                    Type deviceType = assembly.GetType(typeName);


                    if (deviceType == null)
                    {
                        //throw new ApplicationException(string.Format("can not find the device type {0}", "Aitex.Core.RT.Device.Unit." + typeName));
                        continue;
                    }

                    foreach (var nodeDeviceChild in nodeDevices.ChildNodes)
                    {

                        XmlElement nodeDevice = nodeDeviceChild as XmlElement;

                        if (nodeDevice == null)
                        {
                            //LOG.Write("Device Model File contains non element node, " + (nodeDeviceChild as XmlNode).Value);
                            continue;
                        }

                        IDevice device = Activator.CreateInstance(deviceType, mod.ToString(), nodeDevice, ioModule) as IDevice;

                        System.Diagnostics.Debug.Assert(!_nameDevice.ContainsKey(device.Name), $"DeviceModel config file contains duplicated name {device.Name}");

                        DATA.Subscribe(device, string.Format("{0}.{1}.{2}", mod, nodeDevices.Name.Substring(0, nodeDevices.Name.Length - 1), device.Name));

                        _nameDevice.Add($"{device.Module}.{device.Name}", device);

                        if (!_typeDevice.ContainsKey(deviceType))
                            _typeDevice[deviceType] = new List<IDevice>();
                        _typeDevice[deviceType].Add(device);

                        Task task = Task.Run(()=> InitDevice(device));
                    }
                }

                //Initialize();
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex);
                throw;
            }
        }


        public void Initialize(string modelFile, string modelType, string moduleName, string ioPath, string scPath)
        {
            if (!File.Exists(modelFile))
            {
                throw new ApplicationException(string.Format("did not find the device model file {0} ", modelFile));
            }

            XmlDocument _dom = new XmlDocument();
            try
            {
                _dom.Load(modelFile);
                XmlElement node = _dom.SelectSingleNode("DeviceModelDefine") as XmlElement;
                if (node == null)
                {
                    throw new ApplicationException(string.Format("device mode file {0} is not valid", modelFile));
                }

                string fileType = node.GetAttribute("type");
                if (fileType != modelType)
                {
                    throw new ApplicationException(string.Format("the type {0} in device mode file {1} is different with the system type {2}", fileType, modelFile, modelType));
                }
                DeviceModelNodes = node;

                foreach (XmlNode nodeModelChild in node.ChildNodes)
                {
                    if (nodeModelChild.NodeType == XmlNodeType.Comment)
                        continue;
                    XmlElement nodeDevices = nodeModelChild as XmlElement;

                    if (null == nodeDevices) continue;
                    string assName = nodeDevices.GetAttribute("assembly");
                    if (string.IsNullOrEmpty(assName))
                        assName = "MECF.Framework.RT.EquipmentLibrary";

                    string className = nodeDevices.Name.Substring(0, nodeDevices.Name.Length - 1);
                    string typeName = nodeDevices.GetAttribute("classType");
                    if (string.IsNullOrEmpty(typeName))
                        typeName = "Aitex.Core.RT.Device.Unit." + className;

                    Assembly assembly = Assembly.Load(assName);
                    Type deviceType = assembly.GetType(typeName);

                    if (deviceType == null)
                    {
                        //throw new ApplicationException(string.Format("can not find the device type {0}", "Aitex.Core.RT.Device.Unit." + typeName));
                        continue;
                    }

                    foreach (var nodeDeviceChild in nodeDevices.ChildNodes)
                    {

                        XmlElement nodeDevice = nodeDeviceChild as XmlElement;

                        if (nodeDevice == null)
                        {
                            //LOG.Write("Device Model File contains non element node, " + (nodeDeviceChild as XmlNode).Value);
                            continue;
                        }

                        nodeDevice.SetAttribute("ioPath", ioPath);
                        nodeDevice.SetAttribute("scPath", scPath);

                        IDevice device = Activator.CreateInstance(deviceType, moduleName, nodeDevice, ioPath) as IDevice;

                        System.Diagnostics.Debug.Assert(!_nameDevice.ContainsKey(device.Name), $"DeviceModel config file contains duplicated name {device.Name}");

                        DATA.Subscribe(device, string.Format("{0}.{1}.{2}", device.Module, className, device.Name));

                        _nameDevice.Add(device.Name, device);

                        if (!_typeDevice.ContainsKey(deviceType))
                            _typeDevice[deviceType] = new List<IDevice>();
                        _typeDevice[deviceType].Add(device);

                        Task task = Task.Run(() => InitDevice(device));
                    }
                }

                Initialize();
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex);
                throw;
            }
        }

        private void InitDevice(IDevice device)
        {
            try
            {
                if (!device.Initialize())
                {
                    //LOG.Write($"{device.Name} initialize failed.");
                }
            }
            catch (Exception e)
            {
                LOG.WriteExeption(e);
            }
        }

        public IDevice AddCustomDevice(IDevice device, string groupType, Type deviceType)
        {
            DATA.Subscribe(device, string.Format("{0}.{1}.{2}", device.Module, groupType, device.Name));
            if (!string.IsNullOrEmpty(device.Module) && device.Module != "System")
            {
                _nameDevice.Add(device.Module + "."+ device.Name, device);
            }
            else
            {
                _nameDevice.Add( device.Name, device);
            }

            if (!_typeDevice.ContainsKey(deviceType))
                _typeDevice[deviceType] = new List<IDevice>();
            _typeDevice[deviceType].Add(device);

            device.Initialize();

            //Task task = Task.Run(()=>device.Initialize());

            return device;
        }

        public IDevice AddCustomDevice(IDevice device, Type deviceType)
        {
            try
            {
                DATA.Subscribe(device, string.Format("{0}.{1}", device.Module, device.Name));

 
                    _nameDevice.Add(device.Name, device);
 
                if (!_typeDevice.ContainsKey(deviceType))
                    _typeDevice[deviceType] = new List<IDevice>();
                _typeDevice[deviceType].Add(device);

                device.Initialize();
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex);
                throw;
            }


            //Task task = Task.Run(()=>device.Initialize());

            return device;
        }

        public IDevice AddCustomDevice(IDevice device)
        {
            try
            {
                DATA.Subscribe(device, string.Format("{0}.{1}", device.Module, device.Name));


                _nameDevice.Add(device.Name, device);

                if (!_typeDevice.ContainsKey(device.GetType()))
                    _typeDevice[device.GetType()] = new List<IDevice>();
                _typeDevice[device.GetType()].Add(device);

                device.Initialize();
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex);
                throw;
            }


            //Task task = Task.Run(()=>device.Initialize());

            return device;
        }

        public IDevice AddCustomModuleDevice(IDevice device)
        {
            try
            {
                DATA.Subscribe(device, string.Format("{0}.{1}", device.Module, device.Name));


                _nameDevice.Add($"{device.Module}.{device.Name}", device);

                if (!_typeDevice.ContainsKey(device.GetType()))
                    _typeDevice[device.GetType()] = new List<IDevice>();
                _typeDevice[device.GetType()].Add(device);

                device.Initialize();
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex);
                throw;
            }


            //Task task = Task.Run(()=>device.Initialize());

            return device;
        }

        public virtual bool Initialize()
        {

            return true;
        }

        public T GetDevice<T>(string name) where T : class,IDevice
        {
            if (!_nameDevice.ContainsKey(name))
                return null;

            return _nameDevice[name] as T;
        }

        public object GetDevice(string name)
        {
            if (!_nameDevice.ContainsKey(name))
                return null;

            return _nameDevice[name];
        }

        public List<T> GetDevice<T>() where T : class, IDevice
        {
            if (!_typeDevice.ContainsKey(typeof(T)))
                return null;

            List<T> result = new List<T>();
            foreach (var d in _typeDevice[typeof(T)])
            {
                result.Add(d as T);
            }

            return result;
        }

        public List<IDevice> GetAllDevice()
        {
            return _nameDevice.Values.ToList();
        }


    }
}