CyberX8/Framework/Common/Device/Galil/GalilControllerCfgManager.cs

using Aitex.Common.Util;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Device.Festo;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.Net;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Device.Galil
{
    public class GalilControllerCfgManager : Singleton<GalilControllerCfgManager>
    {

        #region 常量 
        private const string STOPCODE = "StopCode";
        private const string REFERENCE_POSITION = "ReferencePosition";
        private const string TORQUE = "Torque";
        private const string VELOCITY = "Velocity";
        private const string POSITION_ERROR = "PositionError";
        private const string AUXILIARY_POSITION="AuxiliaryPosition";
        private const string GAILI_21 = "Galil21";
        private const string GALIL_40 = "Galil40";
        #endregion

        #region 内部变量
        /// <summary>
        /// 模块数据字典（key-模块名称,value-模块Galil数据)
        /// </summary>
        private Dictionary<string, GalilControllerData> _moduleGalilDataDictionary = new Dictionary<string, GalilControllerData>();
        /// <summary>
        /// 电机数据字典(key-电机名称,value-电机数据)
        /// </summary>
        private Dictionary<string, GalilAxisData> _moduleNameAxisDataDictionary = new Dictionary<string, GalilAxisData>();
        /// <summary>
        /// 电机索引字典(key-电机名称,value-索引)
        /// </summary>
        private Dictionary<string, int> _moduleNameIndexDictionary = new Dictionary<string, int>();
        /// <summary>
        /// 模块电机集合字典(key-模块名称,value-电机集合)
        /// </summary>
        private Dictionary<string,List<string>> _moduleNameLstDictionary= new Dictionary<string,List<string>>();
        /// <summary>
        /// 模块电机配置字典(key-电机名称,value-电机配置)
        /// </summary>
        private Dictionary<string, GalilAxisConfig> _moduleNameAxisConfigDictionary = new Dictionary<string, GalilAxisConfig>();
        /// <summary>
        /// 模块设备配置字典
        /// </summary>
        private Dictionary<string, GalilDeviceConfig> _moduleDeviceConfigDictionary = new Dictionary<string, GalilDeviceConfig>();
        /// <summary>
        /// 模块电机tcp设备字典(key-模块名称,value-tcp设备)
        /// </summary>
        private Dictionary<string, IGalilDevice> _moduleGalilTcpDeviceDictionary = new Dictionary<string, IGalilDevice>();
        /// <summary>
        /// 模块DI数组字典
        /// </summary>
        private ConcurrentDictionary<string, byte[]> _moduleDiDictionary = new ConcurrentDictionary<string, byte[]>();
        /// <summary>
        /// 电机
        /// </summary>
        private char[] _axisArray = null;
        #endregion
        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            bool isSimulate = SC.GetValue<bool>("System.IsSimulatorMode");
            string xmlPath = "";
            try
            {
                if (isSimulate)
                {
                    xmlPath = PathManager.GetCfgDir() + "Devices\\GalilControllerCfg-Simulator.xml";
                }
                else
                {
                    xmlPath = PathManager.GetCfgDir() + "Devices\\GalilControllerCfg.xml";
                }
                GalilControllerCfg cfg = CustomXmlSerializer.Deserialize<GalilControllerCfg>(new FileInfo(xmlPath));
                if (cfg != null)
                {
                    foreach (var config in cfg.GalilDeviceConfigs)
                    {
                        InitializeGalilDevice(config);
                        if (config.GalilType == GAILI_21)
                        {
                            Galil21TcpDevice galilDevice = new Galil21TcpDevice(config.Module, config.IpAddress, config.Port);
                            galilDevice.ReceiveTimeout = config.RecvTimeout;
                            galilDevice.SendTimeout = config.SendTimeout;
                            galilDevice.Initialize();
                            _moduleGalilTcpDeviceDictionary[config.Module] = galilDevice;
                        }
                        else
                        {
                            Galil40TcpDevice galilDevice = new Galil40TcpDevice(config.Module, config.IpAddress, config.Port);
                            galilDevice.ReceiveTimeout = config.RecvTimeout;
                            galilDevice.SendTimeout = config.SendTimeout;
                            galilDevice.Initialize();
                            _moduleGalilTcpDeviceDictionary[config.Module] = galilDevice;
                        }
                    }
                }
            }
            catch
            {
                LOG.WriteLog(eEvent.ERR_GALIL, "Galil", "Load galil xml failed");
            }
        }
        /// <summary>
        /// 初始化Galil 设备
        /// </summary>
        /// <param name="deviceConfig"></param>
        private void InitializeGalilDevice(GalilDeviceConfig deviceConfig)
        {
            List<string> lst = new List<string>();
            int maxIndex = 0;
            _moduleDeviceConfigDictionary[deviceConfig.Module] = deviceConfig;
            foreach(var item in deviceConfig.GalilAxises)
            {
                _moduleNameIndexDictionary[$"{deviceConfig.Module}.{item.Name}"] = item.Index;
                _moduleNameAxisConfigDictionary[$"{deviceConfig.Module}.{item.Name}"]=item;
                if (!lst.Contains(item.Name))
                {
                    lst.Add(item.Name);
                }
                if (maxIndex < item.Index)
                {
                    maxIndex= item.Index;
                }
            }
            if (lst.Count > 0)
            {
                _moduleNameLstDictionary[deviceConfig.Module] = lst;                
            }
            _axisArray = new char[10];
            int a = 'A';
            for (int i = 0; i < _axisArray.Length; i++)
            {
                _axisArray[i] = (char)(a + i);
            }
        }
        /// <summary>
        /// 更新模块数据
        /// </summary>
        /// <param name="controllerData"></param>
        public void UpdateModuleData(string module,GalilControllerData controllerData)
        {
            if (!_moduleGalilDataDictionary.ContainsKey(module))
            {
                _moduleGalilDataDictionary[module] = controllerData;
            }
            if (!_moduleNameLstDictionary.ContainsKey(module))
            {
                return;
            }
            UpdateModuleDI(module, controllerData.Inputs);
            List<string> lst = _moduleNameLstDictionary[module];
            foreach (var item in lst)
            {
                string moduleName = $"{module}.{item}";
                if (!_moduleNameIndexDictionary.ContainsKey(moduleName))
                {
                    continue;
                }
                int index = _moduleNameIndexDictionary[moduleName];
                if(index>=controllerData.GalilAxisDatas.Count)
                {
                    continue;
                }
                GalilAxisData galilAxisData=controllerData.GalilAxisDatas[index];
                CheckAxisDataChanged(moduleName, galilAxisData);
            }
        }

        private void UpdateModuleDI(string module, byte[] diValues)
        {
            if (!_moduleDeviceConfigDictionary.ContainsKey(module))
            {
                return;
            }
            GalilDeviceConfig galilDeviceConfig = _moduleDeviceConfigDictionary[module];
            if (galilDeviceConfig.GalilDigIn.DIs.Count != diValues.Length)
            {
                return;
            }
            bool isInitial = false;
            if (!_moduleDiDictionary.ContainsKey(module))
            {
                _moduleDiDictionary[module] = new byte[galilDeviceConfig.GalilDigIn.DIs.Count];
                isInitial=true;
            }
            byte[] tmpValues=_moduleDiDictionary[module];
            if (tmpValues.Length == diValues.Length)
            {
                for(int i=0;i<tmpValues.Length;i++)
                {
                    GalilDI dI=galilDeviceConfig.GalilDigIn.DIs[i];
                    string diName = dI.Name;
                    byte item=tmpValues[i];
                    byte diValue = diValues[i];
                    if (isInitial)
                    {
                        _moduleDiDictionary[module][i]= item;
                        IOModuleManager.Instance.UpdateIoValue(diName, diValue==1);
                    }
                    else if (item != diValue)
                    {
                        _moduleDiDictionary[module][i] = item;

                        IOModuleManager.Instance.UpdateIoValue(diName, diValue==1);
                    }
                }
            }
        }
        /// <summary>
        /// 检验电机数据是否发生变化
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="axisData"></param>
        private void CheckAxisDataChanged(string moduleName,GalilAxisData axisData)
        {
            if (_moduleNameAxisDataDictionary.ContainsKey(moduleName))
            {
                NotifyGalilAxisData(moduleName, _moduleNameAxisDataDictionary[moduleName],axisData);
                _moduleNameAxisDataDictionary[moduleName].Copy(axisData);
            }
            else
            {
                NotifyGalilAxisAllData(moduleName, axisData);
                _moduleNameAxisDataDictionary[moduleName] = axisData.Clone();
            }
        }
        /// <summary>
        /// 更新Galil电机数据
        /// </summary>
        /// <param name="axisData"></param>
        private void NotifyGalilAxisAllData(string moduleName,GalilAxisData axisData)
        {
            PropertyInfo[] propertyInfos= axisData.GetType().GetProperties();
            foreach(var info in propertyInfos)
            {
                object value = info.GetValue(axisData);
                GalilAxisManager.Instance.UpdateIoValue($"{moduleName}.{info.Name}", value);
            }
        }
        /// <summary>
        /// 通知Galil电机数据
        /// </summary>
        /// <param name="sourceData"></param>
        /// <param name="targetData"></param>
        private void NotifyGalilAxisData(string moduleName,GalilAxisData sourceData, GalilAxisData targetData)
        {
            PropertyInfo[] propertyInfos = sourceData.GetType().GetProperties();
            foreach (var info in propertyInfos)
            {
                object sourceValue= info.GetValue(sourceData);
                object targetValue = info.GetValue(targetData);
                if (sourceValue.ToString() != targetValue.ToString())
                {
                    GalilAxisManager.Instance.UpdateIoValue($"{moduleName}.{info.Name}", targetValue);
                }
            }
        }
        /// <summary>
        /// 设置
        /// </summary>
        /// <param name="module"></param>
        /// <param name="name"></param>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetSystemCommand(string module, string name, string commad, object value)
        {
            if (!_moduleGalilTcpDeviceDictionary.ContainsKey(module))
            {
                LOG.WriteLog(eEvent.ERR_GALIL, module, $"{module} does not have tcp device");
                return false;
            }
            string str = $"{module}.{name}";
            if (_moduleNameIndexDictionary.ContainsKey(str))
            {
                int index = _moduleNameIndexDictionary[str];
                if (index >= _axisArray.Length)
                {
                    LOG.WriteLog(eEvent.ERR_GALIL, module, $"{str} is not matched with index");
                    return false;
                }
                string strCommand = "";
                if (value != null)
                {
                    strCommand = $"{commad}{value};";
                }
                else
                {
                    strCommand = $"{commad};";
                }
                return _moduleGalilTcpDeviceDictionary[module].SetGalilCommand(strCommand);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_GALIL, module, $"{str} is not matched with index");
                return false;
            }
        }
        /// <summary>
        /// 设置
        /// </summary>
        /// <param name="module"></param>
        /// <param name="name"></param>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetAxisCommand(string module, string name,string commad, object value) 
        {
            if (!_moduleGalilTcpDeviceDictionary.ContainsKey(module))
            {
                LOG.WriteLog(eEvent.ERR_GALIL, module, $"{module} does not have tcp device");
                return false;
            }
            string str = $"{module}.{name}";
            if(_moduleNameIndexDictionary.ContainsKey(str))
            {
                int index = _moduleNameIndexDictionary[str];
                if (index >= _axisArray.Length)
                {
                    LOG.WriteLog(eEvent.ERR_GALIL, module, $"{str} is not matched with index");
                    return false;
                }
                string strCommand = "";
                string axis = _axisArray[index].ToString();
                if (value != null)
                {
                    strCommand = $"{commad}{axis}={value};";
                }
                else
                {
                    strCommand = $"{commad}{axis};";
                }
                return _moduleGalilTcpDeviceDictionary[module].SetGalilCommand(strCommand);
            }
            else
            {
                LOG.WriteLog(eEvent.ERR_GALIL, module, $"{str} is not matched with index");
                return false;
            }
        }
        /// <summary>
        /// 获取Galil配置对象
        /// </summary>
        /// <param name="module"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public GalilAxisConfig GetGalilAxisConfig(string module,string name)
        {
            string str = $"{module}.{name}";
            if (_moduleNameAxisConfigDictionary.ContainsKey(str))
            {
                return _moduleNameAxisConfigDictionary[str];
            }
            else
            {
                return null;
            }
        }
    }
}