CyberX8/CyberX8_MainPages/ViewModels/PrewetHomePageViewModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Threading;
using MECF.Framework.Common.OperationCenter;
using Prism.Mvvm;
using Prism.Commands;
using Aitex.Core.RT.DataCenter;
using MECF.Framework.Common.CommonData.PUF;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Utilities;
using MECF.Framework.Common.RecipeCenter;
using System.Collections.ObjectModel;
using CyberX8_MainPages.PMs;
using Aitex.Core.Utilities;
using CyberX8_Core;
using System.Windows.Documents;
using System.Windows;
using MECF.Framework.Common.WaferHolder;
using MECF.Framework.Common.CommonData.Prewet;
using MECF.Framework.Common.Persistent.Prewet;
using MECF.Framework.Common.Device.LinMot;
using Aitex.Core.RT.RecipeCenter;
using MECF.Framework.Common.Device.ResistivityProbe;
using MECF.Framework.Common.Equipment;

namespace CyberX8_MainPages.ViewModels
{
    internal class PrewetHomePageViewModel : BindableBase
    {
        #region 常量
        private const string PUMP_DATA = "PumpData";
        private const string PWT = "pwt";
        private const string PERSISTENT_VALUE = "PersistentValue";
        #endregion


        #region 内部变量

        #region Common
        /// <summary>
        /// 模块名称
        /// </summary>
        private string _module;
        /// <summary>
        /// StateMachine
        /// </summary>
        private string _stateMachine;
        /// <summary>
        /// Status
        /// </summary>
        private string _status;
        /// <summary>
        /// 数据
        /// </summary>
        private PrewetPumpData _prewetPumpData;
        /// <summary>
        /// Threshold
        /// </summary>
        private PrewetPersistentValue _prewetPersistent;
        /// <summary>
        /// KepWetLimitTime
        /// </summary>
        private int _keepWetLimitTime;
        /// <summary>
        /// 当前选择Recipe节点
        /// </summary>
        private RecipeNode _selectedRecipeNode;
        /// <summary>
        /// 选中的Recipe文件的Linmot扫描次数
        /// </summary>
        private int _numberOfRecipeScans;
        /// <summary>
        /// Linmot RunRecipeTotalScanComplete
        /// </summary>
        private int _scanComplete;
        /// <summary>
        /// 是否是Manual模式
        /// </summary>
        private bool _isManualOperationMode;
        #endregion


        #region Motion
        /// <summary>
        /// 当前位置
        /// </summary>
        private double _linmotCurrentPosition;
        /// <summary>
        /// Linmot ScanCount
        /// </summary>
        private int _scanCount;
        /// <summary>
        /// Linmot StatusWord
        /// </summary>
        private short _statusWord;
        /// <summary>
        /// UpMaxSpeed
        /// </summary>
        private double _upMaxSpeed;
        /// <summary>
        /// LinmotDeviceData
        /// </summary>
        private LinMotDeviceData _linMotDeviceData;
        /// <summary>
        /// LinmotName
        /// </summary>
        private string _linmotName;

        #endregion

        #region UI
        /// <summary>
        /// Linmot UI Y轴位置
        /// </summary>
        private double _uiLinmotYPosition = 60.0;
        /// <summary>
        /// IsErrorState 用于腔体变红
        /// </summary>
        private bool _isErrorState;
        /// <summary>
        /// 页面功能启用
        /// </summary>
        private bool _isEnabled;
        /// <summary>
        /// AutoMode页面功能启用
        /// </summary>
        private bool _isAutoEnabled;
        /// <summary>
        /// 是否存在WaferHolder
        /// </summary>
        private bool _isWaferHolder;
        #endregion

        #region Wafer Holder
        /// <summary>
        /// Wafer Holder属性
        /// </summary>
        private WaferHolderInfo _waferHolderInfo;
        /// <summary>
        /// SeqRecipe
        /// </summary>
        private string _seqRecipe;
  

        #endregion

        #region 系统数据
        /// <summary>
        /// 定时器
        /// </summary>
        DispatcherTimer _timer;
        /// <summary>
        /// 查询后台数据集合
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// rt查询key数值字典
        /// </summary>
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
        #endregion

        #region PreWet1
        /// <summary>
        /// RecipeContent
        /// </summary>
        private string _recipeContent;
        /// <summary>
        /// TimeRemaining 
        /// </summary>
        private int _timeRemaining;
        /// <summary>
        /// OfTotalTime 
        /// </summary>
        private int _totalTime;
        /// <summary>
        /// OperatingMode 
        /// </summary>
        private string _operatingMode;
        /// <summary>
        /// State Machine
        /// </summary>
        private string _state;
        /// <summary>
        /// RecipeMode 
        /// </summary>
        private string _recipeMode;
        #endregion

        #region PWT recipe
        /// <summary>
        /// RecipeModuleName
        /// </summary>
        private string _recipeModuleName;
        /// <summary>
        /// RecipeType
        /// </summary>
        private string _recipeType;
        /// <summary>
        /// AchievedRunRecipeCycle
        /// </summary>
        private int _achievedRunRecipeCycle;
        /// <summary>
        /// 当前Recipe
        /// </summary>
        private string _currentRecipe;
        #endregion

        #endregion

        #region 属性

        #region Common
        /// <summary>
        /// 模块名称
        /// </summary>
        public string Module { get { return _module; } set { SetProperty(ref _module, value); } }
        /// <summary>
        /// StateMachine
        /// </summary>
        public string StateMachine { get { return _stateMachine; } set { SetProperty(ref _stateMachine, value); } }
        /// <summary>
        /// Status
        /// </summary>
        public string Status { get { return _status; } set { SetProperty(ref _status, value); } }
        /// <summary>
        /// Commondata
        /// </summary>
        public PrewetPumpData PrewetPumpData
        {
            get { return _prewetPumpData; }
            set { SetProperty(ref _prewetPumpData, value); }
        }
        /// <summary>
        /// KeepWetLimitTime
        /// </summary>
        public int KeepWetLimitTime { get { return _keepWetLimitTime; } set { SetProperty(ref _keepWetLimitTime, value); } }
        /// <summary>
        /// 选中的Recipe文件的Linmot扫描次数
        /// </summary>
        public int NumberOfRecipeScans { get { return _numberOfRecipeScans; } set { SetProperty(ref _numberOfRecipeScans, value); } }
        /// <summary>
        /// Linmot RunRecipeTotalScanComplete
        /// </summary>
        public int ScanComplete { get { return _scanComplete; } set { SetProperty(ref _scanComplete, value); } }
        /// <summary>
        /// Threshold
        /// </summary>
        public PrewetPersistentValue PrewetPersistent
        {
            get { return _prewetPersistent; }
            set { SetProperty(ref _prewetPersistent, value); }
        }
        public RecipeNode SelectedRecipeNode
        {
            get { return _selectedRecipeNode; }
            set { SetProperty(ref _selectedRecipeNode, value); }
        }
        /// <summary>
        /// 是否是Manual模式
        /// </summary>
        public bool IsManualOperationMode { get { return _isManualOperationMode; } set { SetProperty(ref _isManualOperationMode, value); } }
        #endregion

        #region Motion
        /// <summary>
        /// 当前位置
        /// </summary>
        public double LinmotCurrentPosition { get { return _linmotCurrentPosition; } set { SetProperty(ref _linmotCurrentPosition, value); } }
        /// <summary>
        /// Linmot Scan次数
        /// </summary>
        public int ScanCount { get { return _scanCount; } set { SetProperty(ref _scanCount, value); } }
        /// <summary>
        /// Linmot StatusWord
        /// </summary>
        public short StatusWord { get { return _statusWord; } set { SetProperty(ref _statusWord, value); } }
        /// <summary>
        /// LinMotDeviceData
        /// </summary>
        public LinMotDeviceData LinmotDeviceCommonData { get { return _linMotDeviceData; } set { SetProperty(ref _linMotDeviceData, value); } }
        /// <summary>
        /// UpMaxSpeed
        /// </summary>
        public double UpMaxSpeed { get { return _upMaxSpeed; } set { SetProperty(ref _upMaxSpeed, value); } }
        /// <summary>
        /// LinmotName
        /// </summary>
        public string LinmotName { get { return _linmotName; } set { SetProperty(ref _linmotName, value); } }
        #endregion

        #region UI
        /// <summary>
        /// Linmot UI Y轴位置
        /// </summary>
        public double UILinmotYPosition { get { return _uiLinmotYPosition; } set { SetProperty(ref _uiLinmotYPosition, value); } }
        /// <summary>
        /// IsErrorState
        /// </summary>
        public bool IsErrorState { get { return _isErrorState; } set { SetProperty(ref _isErrorState, value); } }
        /// <summary>
        /// 页面功能启用
        /// </summary>
        public bool IsEnabled
        {
            get { return _isEnabled; }
            set { SetProperty(ref _isEnabled, value); }
        }
        /// <summary>
        /// AutoMode页面功能启用
        /// </summary>
        public bool IsAutoEnabled
        {
            get { return _isAutoEnabled; }
            set { SetProperty(ref _isAutoEnabled, value); }
        }
        /// <summary>
        /// 是否存在WaferHolder
        /// </summary>
        public bool IsWaferHolder { get { return _isWaferHolder; } set { SetProperty(ref _isWaferHolder, value); } }
        #endregion

        #region Prewet1
        /// <summary>
        /// RecipeContent
        /// </summary>
        public string RecipeContent
        {
            get { return _recipeContent; }
            set { SetProperty(ref _recipeContent, value); }
        }
        /// <summary>
        /// TimeRemaining 
        /// </summary>
        public int TimeRemaining
        {
            get { return _timeRemaining; }
            set { SetProperty(ref _timeRemaining, value); }
        }
        /// <summary>
        /// TotalTime  
        /// </summary>
        public int TotalTime
        {
            get { return _totalTime; }
            set { SetProperty(ref _totalTime, value); }
        }
        /// <summary>
        /// OperatingMode
        /// </summary>
        public string OperatingMode
        {
            get { return _operatingMode; }
            set { SetProperty(ref _operatingMode, value); }
        }
        /// <summary>
        /// State
        /// </summary>
        public string State
        {
            get { return _state; }
            set { SetProperty(ref _state, value); }
        }
        /// <summary>
        /// RecipeMode
        /// </summary>
        public string RecipeMode
        {
            get { return _recipeMode; }
            set { SetProperty(ref _recipeMode, value); }
        }
        #endregion

        #region PWT recipe
        /// <summary>
        /// RecipeModuleName
        /// </summary>
        public string RecipeModuleName
        {
            get { return _recipeModuleName; }
            set { SetProperty(ref _recipeModuleName, value); }
        }
        /// <summary>
        /// RecipeType
        /// </summary>
        public string RecipeType
        {
            get { return _recipeType; }
            set { SetProperty(ref _recipeType, value); }
        }
        
        public int AchievedRunRecipeCycle
        {
            get { return _achievedRunRecipeCycle; }
            set { SetProperty(ref _achievedRunRecipeCycle, value); }
        }
        /// <summary>
        /// 当前运行的Recipe
        /// </summary>
        public string CurrentRecipe
        {
            get { return _currentRecipe; }
            set { SetProperty(ref _currentRecipe, value); }
        }
        #endregion

        #region Wafer Holder
        /// <summary>
        /// Wafer Holder属性
        /// </summary>
        public WaferHolderInfo WaferHolderInfo { get { return _waferHolderInfo; } set { SetProperty(ref _waferHolderInfo, value); } }
        /// <summary>
        /// SeqRecipe
        /// </summary>
        public string SeqRecipe
        {
            get { return _seqRecipe; }
            set { SetProperty(ref _seqRecipe, value); }
        }
        #endregion

        #endregion

        #region Command指令
        public ICommand InitializeCommand { get; set; }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public PrewetHomePageViewModel()
        {
            InitializeCommand = new DelegateCommand<object>(InitializeAction);
        }
  
        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadData(string systemName)
        {
            Module = systemName;
            RecipeModuleName = "PWT Recipe";
            RecipeType = "pwt";
            _rtDataKeys.Clear();
            List<string> lst = new List<string>();
            lst.Add($"{Module}.LinmotName");
            _rtDataValueDic = QueryDataClient.Instance.Service.PollData(lst);
            if (_rtDataValueDic != null)
            {
                LinmotName = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.LinmotName");
                if (!string.IsNullOrEmpty(LinmotName))
                {
                    _rtDataKeys.Add($"{LinmotName}.ScanCount");
                    _rtDataKeys.Add($"{LinmotName}.StatusWord");
                    _rtDataKeys.Add($"{LinmotName}.Position");
                    _rtDataKeys.Add($"{LinmotName}.CurrentPrewetUIPostion");
                }
            }
            _rtDataKeys.Add($"{Module}.WaferHolder");
            _rtDataKeys.Add($"{Module}.SequenceRecipe");
            _rtDataKeys.Add($"{Module}.AchievedCycle");
            _rtDataKeys.Add($"{Module}.GetKeepWetLimit");
            _rtDataKeys.Add($"{Module}.{PERSISTENT_VALUE}");
            _rtDataKeys.Add($"{Module}.{PUMP_DATA}");
            _rtDataKeys.Add($"{Module}.FsmState");
            _rtDataKeys.Add($"{Module}.TotalTime");
            _rtDataKeys.Add($"{Module}.TimeRemain");
            _rtDataKeys.Add($"{Module}.LinmotDeviceData");
            _rtDataKeys.Add($"{Module}.CurrentStateMachine");
            _rtDataKeys.Add($"{Module}.CurrentStatus");
            _rtDataKeys.Add($"{Module}.CurrentRecipe");
            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(200);
                _timer.Tick += Timer_Tick; 
            }
            _timer.Start();
        }
        /// <summary>
        /// 定时器执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    PrewetPumpData = CommonFunction.GetValue<PrewetPumpData>(_rtDataValueDic, $"{Module}.{PUMP_DATA}");
                    WaferHolderInfo = CommonFunction.GetValue<WaferHolderInfo>(_rtDataValueDic, $"{Module}.WaferHolder");
                    if(WaferHolderInfo != null)
                    {
                        IsWaferHolder = true;
                    }
                    else
                    {
                        IsWaferHolder = false;
                    }

                    SeqRecipe = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.SequenceRecipe");
                    AchievedRunRecipeCycle = CommonFunction.GetValue<int>(_rtDataValueDic, $"{Module}.AchievedCycle");
                    //获取的是配置文件中keepwet开始的等待时间，后续倒计时实现在后端实现
                    KeepWetLimitTime = CommonFunction.GetValue<int>(_rtDataValueDic, $"{Module}.GetKeepWetLimit");
                    PrewetPersistent = CommonFunction.GetValue<PrewetPersistentValue>(_rtDataValueDic, $"{Module}.{PERSISTENT_VALUE}");
                    State = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.FsmState");
                    if ("Manual".Equals(PrewetPersistent.OperatingMode))
                    {
                        IsEnabled = true;
                        IsAutoEnabled = true;
                    }
                    else if ("Auto".Equals(PrewetPersistent.OperatingMode))
                    {
                        IsAutoEnabled = true;
                        IsEnabled = false;
                    }
                    else
                    {
                        State = "Stopped";
                        IsEnabled = false;
                        IsAutoEnabled = false;
                    }
                    StateMachine = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.CurrentStateMachine");
                    Status = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.CurrentStatus");
                    LinmotDeviceCommonData = CommonFunction.GetValue<LinMotDeviceData>(_rtDataValueDic, $"{Module}.LinmotDeviceData");
                    UpMaxSpeed = LinmotDeviceCommonData.UpMaxSpeed / 1000;
                    if(!string.IsNullOrEmpty(LinmotName))
                    {
                        ScanCount = CommonFunction.GetValue<int>(_rtDataValueDic, $"{LinmotName}.ScanCount");
                        StatusWord = CommonFunction.GetValue<short>(_rtDataValueDic, $"{LinmotName}.StatusWord");
                        LinmotCurrentPosition = CommonFunction.GetValue<double>(_rtDataValueDic, $"{LinmotName}.Position");
                        UILinmotYPosition = CommonFunction.GetValue<double>(_rtDataValueDic, $"{LinmotName}.CurrentPrewetUIPostion");
                    }
                    //Error时UI腔体变红
                    IsErrorState = "Error".Equals(State) ? true : false;
                    //Recipe Running时Linmot完成完整Scan的计数
                    ScanComplete = AchievedRunRecipeCycle * NumberOfRecipeScans + ScanCount;
                    if ((StatusWord & 0b010000000000000) >> 13 != 1)  
                    {
                        ScanComplete -= ScanCount;
                    }
                    CurrentRecipe = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.CurrentRecipe");
                    TotalTime = CommonFunction.GetValue<int>(_rtDataValueDic, $"{Module}.TotalTime");
                    TimeRemaining = CommonFunction.GetValue<int>(_rtDataValueDic, $"{Module}.TimeRemain");
                    TimeRemaining = TimeRemaining < 0 ? 0 : TimeRemaining;
                    if (State == "Idle")
                    {
                        TimeRemaining = 0;
                    }
                }
            }
        }
        /// <summary>
        /// 隐藏
        /// </summary>
        public void Hide()
        {
            if (_timer != null)
            {
                _timer.Stop();
            }
        }

        #region 指令Action
        /// <summary>
        /// Initialize Action
        /// </summary>
        /// <param name="param"></param>
        private void InitializeAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{Module}.InitializeAll");
        }
        #endregion

    }
}