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

using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.CommonData.DeviceData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Venus_Core;

namespace Venus_MainPages.ViewModels
{
    public class ButterflyValveViewModel : BindableBase
    {
        #region 私有字段
        public string ModuleName = "PMA";
        private string m_DeviceName = "PendulumValve";
        private bool m_IsPositionMode;
        private float m_SetValue;
        private float? m_FeedBackValue;
        //private List<string> m_RtDataKeys;
        private Dictionary<string, object> m_RtDataValues;
        public JetChamber m_JetChamber;
        private string m_Unit;
        private AITPendulumValveData pendulumValveData;
        #endregion

        #region 属性
        public bool IsPositionMode
        { 
        get { return m_IsPositionMode; }
        set 
            {
                if (SetValue > 1000&&value==true)
                {
                    SetValue = 1000;
                }
                if (value == true)
                {
                    Unit = "‰";
                }
                if (value == false)
                {
                    if ((m_JetChamber == JetChamber.Kepler2200A || m_JetChamber == JetChamber.Kepler2200B))
                    {
                        Unit = "Pa";
                    }
                    else
                    {
                        Unit = "mTorr";
                    }
                }

                if (m_IsPositionMode == true && value == false)
                {
                    SetValue = pendulumValveData.PressureSetPoint;

                }
                else if (m_IsPositionMode == false && value == true)
                {
                    SetValue = pendulumValveData.PositionSetPoint;
                }
                SetProperty(ref m_IsPositionMode, value); 
            }
        }

        public float SetValue
        {
            get { return m_SetValue; }
            set 
            {
                if (value > 1000 && IsPositionMode==true)
                { 
                value = 1000;
                }
                if (value < 0 && IsPositionMode == true)
                { 
                value = 0;
                }
                SetProperty(ref m_SetValue, value); 
            }
        }
        public float? FeedBackValue
        {
            get { return m_FeedBackValue; }
            set { SetProperty(ref m_FeedBackValue, value); }
        }
        public string DeviceName
        {
            get { return m_DeviceName; }
            set { SetProperty(ref m_DeviceName, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public string Unit
        {
            get { return m_Unit; }
            set { SetProperty(ref m_Unit, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _SetCommand;
        public DelegateCommand SetCommand =>
            _SetCommand ?? (_SetCommand = new DelegateCommand(OnSet));

        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(OnLoaded));
        #endregion


        public ButterflyValveViewModel()
        {           
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.1);
            timer.Tick += timer_Tick;
            timer.Start();
            //m_JetChamber = (JetChamber)Enum.Parse(typeof(JetChamber), QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.ChamberType").ToString());
        }

        #region 命令方法

        private void OnLoaded()
        {          
            m_JetChamber = (JetChamber)Enum.Parse(typeof(JetChamber), QueryDataClient.Instance.Service.GetConfig($"{ModuleName}.ChamberType").ToString());
            IsPositionMode = false;
            var pendulumValveData = (AITPendulumValveData)QueryDataClient.Instance.Service.GetData($"{ModuleName}.PendulumValve.DeviceData");
            SetValue = pendulumValveData.PressureSetPoint;

        }
        private void OnSet()
        {
            if (IsPositionMode == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetPVPostion", SetValue);
            }
            else
            {
                //if (PressureType == PressureType.Pa && (m_JetChamber == JetChamber.Kepler2200A || m_JetChamber == JetChamber.Kepler2200B))
                //{
                //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetPVPressure", SetValue* 7.5006F);
                //}
                //else
                //{ 
                //    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetPVPressure", SetValue);

                //}
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetPVPressure", SetValue);
            }
        }

        void timer_Tick(object sender, EventArgs e)
        {
            pendulumValveData=  (AITPendulumValveData)QueryDataClient.Instance.Service.GetData($"{ModuleName}.PendulumValve.DeviceData");

            if (IsPositionMode == true)
            {
                FeedBackValue = pendulumValveData.Position;
            }
            else
            {
                FeedBackValue = Convert.ToSingle(Math.Round(pendulumValveData.Pressure, 1));
                //if ( (m_JetChamber==JetChamber.Kepler2200A || m_JetChamber == JetChamber.Kepler2200B))
                //{ 
                //    FeedBackValue = (float)Math.Round(pendulumValveData.Pressure*0.1333F, 1);
                //}
                //else
                //{
                //    FeedBackValue = (float)Math.Round(pendulumValveData.Pressure, 1);
                //}
            }
        }
        #endregion
    }
}