Kepler-Release/Venus/Venus_MainPages/ViewModels/IOViewModel.cs

using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.IOCore;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase.IO;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;

namespace Venus_MainPages.ViewModels
{
    public class IOViewModel : BindableBase
    {
        #region 私有属性
        private Dictionary<string, IOItem<bool>> _diMap = new Dictionary<string, IOItem<bool>>();
        private Dictionary<string, IOItem<bool>> _doMap = new Dictionary<string, IOItem<bool>>();
        private Dictionary<string, IOItem<float>> _aiMap = new Dictionary<string, IOItem<float>>();
        private Dictionary<string, AOItem32> _aoMap = new Dictionary<string, AOItem32>();

        private ObservableCollection<IOItem<float>> m_AIs = new ObservableCollection<IOItem<float>>();
        private ObservableCollection<AOItem32> m_AOs = new ObservableCollection<AOItem32>();
        private ObservableCollection<IOItem<bool>> m_DIs = new ObservableCollection<IOItem<bool>>();
        private ObservableCollection<IOItem<bool>> m_DOs = new ObservableCollection<IOItem<bool>>();

        private string m_SystemName;

        #endregion

        #region 属性
        public ObservableCollection<IOItem<float>> AIs
        {
            get { return m_AIs; }
            set { SetProperty(ref m_AIs, value); }
        }
        public ObservableCollection<AOItem32> AOs
        {
            get { return m_AOs; }
            set { SetProperty(ref m_AOs, value); }
        }
        public ObservableCollection<IOItem<bool>> DIs
        {
            get { return m_DIs; }
            set { SetProperty(ref m_DIs, value); }
        }
        public ObservableCollection<IOItem<bool>> DOs
        {
            get { return m_DOs; }
            set { SetProperty(ref m_DOs, value); }
        }

        public string SystemName
        {
            get { return m_SystemName; }
            set 
            {

                m_SystemName = value;
                BuildIoSchema();

            }
        }
        #endregion

        #region 命令
        private DelegateCommand<IOItem<bool>> _SetDOCommand;
        public DelegateCommand<IOItem<bool>> SetDOCommand =>
            _SetDOCommand ?? (_SetDOCommand = new DelegateCommand<IOItem<bool>>(SetDO));

        private DelegateCommand<AOItem32> _SetAOCommand;
        public DelegateCommand<AOItem32> SetAOCommand =>
            _SetAOCommand ?? (_SetAOCommand = new DelegateCommand<AOItem32>(SetAO));

        //private DelegateCommand _SetDOCommand;
        //public DelegateCommand SetDOCommand =>
        //    _SetDOCommand ?? (_SetDOCommand = new DelegateCommand(SetDO));

        #endregion




        public IOViewModel()
        {


            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(2);
            timer.Tick += timer_Tick;
            timer.Start();

     

        }
        void timer_Tick(object sender, EventArgs e)
        {
            GetIOs();

        }

        #region 私有方法
        public void SetAO(AOItem32 aoItem)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetAoValue32", aoItem.Name, aoItem.NewValue);
        }
        private void SetDO(IOItem<bool> doItem)
        {
            InvokeClient.Instance.Service.DoOperation("System.SetDoValue", doItem.Name, !doItem.Value);
        }
        public void BuildIoSchema()
        {
            if (DIs.Count == 0)
            {
                var itemList = QueryDataClient.Instance.Service.GetData($"{SystemName}.PLC.DIItemList");

                if (itemList != null)
                {
                    DIs = new ObservableCollection<IOItem<bool>>();
                    foreach (var item in (List<NotifiableIoItem>)itemList)
                    {
                        var io = new IOItem<bool>()
                        {
                            Index = item.Index,
                            Name = item.Name,
                            Value = item.BoolValue,
                            Address = item.Address
                        };
                        DIs.Add(io);
                        _diMap.Add($"IO.{item.Name}", io);
                    }
                }
            }
            if (DOs.Count == 0)
            {
                var itemList = QueryDataClient.Instance.Service.GetData($"{SystemName}.PLC.DOItemList");

                if (itemList != null)
                {
                    DOs = new ObservableCollection<IOItem<bool>>();
                    foreach (var item in (List<NotifiableIoItem>)itemList)
                    {
                        var io = new IOItem<bool>()
                        {
                            Index = item.Index,
                            Name = item.Name,
                            Value = item.BoolValue,
                            Address = item.Address
                        };
                        DOs.Add(io);

                        _doMap.Add($"IO.{item.Name}", io);
                    }
                }
            }
            if (AIs.Count == 0)
            {
                var itemList = QueryDataClient.Instance.Service.GetData($"{SystemName}.PLC.AIItemList");

                if (itemList != null)
                {
                    AIs = new ObservableCollection<IOItem<float>>();
                    foreach (var item in (List<NotifiableIoItem>)itemList)
                    {
                        var io = new IOItem<float>()
                        {
                            Index = item.Index,
                            Name = item.Name,
                            Value = item.ShortValue,
                            Address = item.Address
                        };
                        AIs.Add(io);
                        _aiMap.Add($"IO32.{item.Name}", io);
                    }
                }
            }
            if (AOs.Count == 0)
            {
                var itemList = QueryDataClient.Instance.Service.GetData($"{SystemName}.PLC.AOItemList");

                if (itemList != null)
                {
                    AOs = new ObservableCollection<AOItem32>();
                    foreach (var item in (List<NotifiableIoItem>)itemList)
                    {
                        var io = new AOItem32()
                        {
                            Index = item.Index,
                            Name = item.Name,
                            Value = item.ShortValue,
                            Address = item.Address
                        };
                        AOs.Add(io);
                        _aoMap.Add($"IO32.{item.Name}", io);
                    }
                }
            }
        }
        public void GetIOs()
        {
            var diValues = QueryDataClient.Instance.Service.PollData(_diMap.Keys);
            foreach (var item in _diMap)
            {
                if (diValues.ContainsKey(item.Key))
                    _diMap[item.Key].Value = (bool)diValues[item.Key];
            }
            var doValues = QueryDataClient.Instance.Service.PollData(_doMap.Keys);
            foreach (var item in _doMap)
            {
                if (doValues.ContainsKey(item.Key))
                    _doMap[item.Key].Value = (bool)doValues[item.Key];
            }
            var aiValues = QueryDataClient.Instance.Service.PollData(_aiMap.Keys);
            foreach (var item in _aiMap)
            {
                if (aiValues.ContainsKey(item.Key))
                    _aiMap[item.Key].Value = (float)aiValues[item.Key];
            }
            var aoValues = QueryDataClient.Instance.Service.PollData(_aoMap.Keys);
            foreach (var item in _aoMap)
            {
                if (aoValues.ContainsKey(item.Key))
                    _aoMap[item.Key].Value = (float)aoValues[item.Key];
            }
        }
        #endregion
    }
    public class AOItem32 : IOItem<float>
    {
        public static readonly DependencyProperty NewValueProperty = DependencyProperty.Register(nameof(NewValue), typeof(float), typeof(AOItem32), new PropertyMetadata((object)(float)0));
        public static readonly DependencyProperty TextSavedProperty = DependencyProperty.Register(nameof(TextSaved), typeof(bool), typeof(AOItem32), new PropertyMetadata((object)true));

        public float NewValue
        {
            get
            {
                return (float)this.GetValue(NewValueProperty);
            }
            set
            {
                this.SetValue(NewValueProperty, (object)value);
            }
        }

        public bool TextSaved
        {
            get
            {
                return (bool)this.GetValue(TextSavedProperty);
            }
            set
            {
                this.SetValue(TextSavedProperty, (object)value);
            }
        }
    }
}