YuPu-OrpaonEMS/OrpaonEMS.App/Models/PCSStateModel.cs

using HslCommunication.ModBus;
using OrpaonEMS.App.Services;
using OrpaonEMS.Core.Enums;
using Prism.Mvvm;
using Stateless;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OrpaonEMS.App.Models
{
    /// <summary>
    /// PCS状态模型
    /// </summary>
    public class PCSStateModel : BindableBase
    {
        /// <summary>
        /// 实例化函数
        /// </summary>
        /// <param name="modbusTcpNetDrive"></param>
        public PCSStateModel(InPowerPCSDataService  inPowerPCSDataService)
        {
            PCSStateMachineInitalConfig();
            InPowerPCSDataService = inPowerPCSDataService;
        }


        /// <summary>
        /// PCS的状态信息
        /// </summary>
        /// <returns></returns>
        public PCSState PcsStateInfo { get; set; }

        private string _PcsStateMsg;
        /// <summary>
        /// PCS的状态信息
        /// 状态文本
        /// </summary>
        public string PcsStateMsg
        {
            get { return _PcsStateMsg; }
            set { _PcsStateMsg = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// PCS运行状态机
        /// </summary>
        public StateMachine<PCSState, PCSStateTrigger> PcsStateMachine { set; get; }

        /// <summary>
        /// 上位机连接PCS状态机
        /// </summary>
        public StateMachine<LinkState, LinkStateTrig> CurIPCLinkStateMachine { set; get; }

        /// <summary>
        /// PCS链接状态
        /// </summary>
        public LinkState PcsLinkState { get; set; }

        private string _LinkStateMsg;
        /// <summary>
        /// PCS连接PC的状态信息文本
        /// </summary>
        public string LinkStateMsg
        {
            get { return _LinkStateMsg; }
            set { _LinkStateMsg = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// PCS的初始配置
        /// </summary>
        public void PCSStateMachineInitalConfig()
        {
            //PCS运行状态
            PcsStateMachine = new StateMachine<PCSState, PCSStateTrigger>(PCSState.Inital);
            //初始化->
            PcsStateMachine.Configure(PCSState.Inital)
                .Permit(PCSStateTrigger.RunTrig, PCSState.Run)
                .Permit(PCSStateTrigger.StandbyTrig, PCSState.Standby)
                .Permit(PCSStateTrigger.StopTrig, PCSState.Stop)
                .OnEntry(() => PCSInital());

            PcsStateMachine.Configure(PCSState.Run)
                .Permit(PCSStateTrigger.StandbyTrig, PCSState.Standby)
                .Permit(PCSStateTrigger.StopTrig, PCSState.Stop)
                 .Ignore(PCSStateTrigger.RunTrig)
                .OnEntry(() => PCSStartAsync());

            PcsStateMachine.Configure(PCSState.Stop)
                .Permit(PCSStateTrigger.RunTrig, PCSState.Run)
                .Permit(PCSStateTrigger.StandbyTrig, PCSState.Standby)
                 .Ignore(PCSStateTrigger.StopTrig)
                .OnEntry(() => PCSStopAsync());

            PcsStateMachine.Configure(PCSState.Standby)
                .Permit(PCSStateTrigger.RunTrig, PCSState.Run)
                .Permit(PCSStateTrigger.StopTrig, PCSState.Stop)
                 .Ignore(PCSStateTrigger.StandbyTrig)
                .OnEntry(() => PCSStandbyAsync());


            //PCS 上位机连接状态
            CurIPCLinkStateMachine = new StateMachine<LinkState, LinkStateTrig>(LinkState.Initial);
            CurIPCLinkStateMachine.Configure(LinkState.Initial)
                .Permit(LinkStateTrig.LinkOKTrig, LinkState.LinkOK)
                .Permit(LinkStateTrig.LinkNGTrig, LinkState.LinkNG);
            CurIPCLinkStateMachine.Configure(LinkState.LinkNG)
                .Permit(LinkStateTrig.LinkOKTrig, LinkState.LinkOK)
                .Ignore(LinkStateTrig.LinkNGTrig)
                .OnEntry(() => IPCLinkNG());
            CurIPCLinkStateMachine.Configure(LinkState.LinkOK)
                .Permit(LinkStateTrig.LinkNGTrig, LinkState.LinkNG)
                .Ignore(LinkStateTrig.LinkOKTrig)
                .OnEntry(() => IPCLinkOK());
        }

        #region PCS运行状态

        /// <summary>
        /// PCS 初始化
        /// </summary>
        private void PCSInital()
        {
            PcsStateInfo = PCSState.Inital;
            PcsStateMsg = "初始化";
            Console.WriteLine($"时间：{DateTime.Now.ToString()}：PCS进入【初始】模式 ");

        }

        /// <summary>
        /// PCS 进入停机
        /// </summary>
        /// <returns></returns>
        private void PCSStandbyAsync()
        {
            PcsStateInfo = PCSState.Standby;
            PcsStateMsg = "待机";
            Console.WriteLine($"时间：{DateTime.Now.ToString()}：PCS进入【待机】模式 ");
            //return Task.CompletedTask;
        }

        /// <summary>
        ///  PCS 进入停止
        /// </summary>
        /// <returns></returns>
        private void PCSStopAsync()
        {
            PcsStateInfo = PCSState.Stop;
            PcsStateMsg = "停止";
            Console.WriteLine($"时间：{DateTime.Now.ToString()}：PCS进入【停止】模式 ");
            //return Task.CompletedTask;
        }

        /// <summary>
        /// PCS 进入运行
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        private void PCSStartAsync()
        {
            PcsStateInfo = PCSState.Run;
            PcsStateMsg = "运行";
            Console.WriteLine($"时间：{DateTime.Now.ToString()}：PCS进入【运行】模式 ");
            //return Task.CompletedTask;
        }



        private bool[] _PCSStateValue = new bool[3];
        /// <summary>
        /// PCS运行状态字数据
        ///需要转换数据
        /// </summary>
        public bool[] PCSStateValue
        {
            get { return _PCSStateValue; }
            set
            {
                if (!value.SequenceEqual(_PCSStateValue))
                {
                    if (value[0])
                    {
                        PcsStateMachine.FireAsync(PCSStateTrigger.StopTrig);
                    }
                    else if (value[1])
                    {
                        PcsStateMachine.FireAsync(PCSStateTrigger.StandbyTrig);
                    }
                    else if (value[2])
                    {
                        PcsStateMachine.FireAsync(PCSStateTrigger.RunTrig);
                    }
                    else
                    {
                        PcsStateMachine.FireAsync(PCSStateTrigger.StopTrig);
                    }
                    _PCSStateValue = value;
                }
            }
        }



        /// <summary>
        /// PCS总故障状态
        /// </summary>
        public PcsFaultState PcsSysFaultState { get; set; }


        private string _PcsSysFaultStateMsg;
        /// <summary>
        /// PC总S故障状态文本
        /// </summary>
        public string PcsSysFaultStateMsg
        {
            get { return _PcsSysFaultStateMsg; }
            set { _PcsSysFaultStateMsg = value; RaisePropertyChanged(); }
        }


        private bool _PcsSysFaultStateVaue;
        /// <summary>
        /// 总故障状态字
        /// </summary>
        public bool PcsSysFaultStateVaue
        {
            get { return _PcsSysFaultStateVaue; }
            set
            {
                if (value != _PcsSysFaultStateVaue)
                {
                    if (value)
                    {
                        PcsSysFaultState = PcsFaultState.Fault;
                        PcsSysFaultStateMsg = "故障中";
                        //产生报警
                        Console.WriteLine($"datetime:{DateTime.Now.ToString()} PCS 故障产生");
                    }
                    else
                    {
                        PcsSysFaultState = PcsFaultState.Normal;
                        PcsSysFaultStateMsg = "正常";
                        //故障消失后，故障复位一下
                        InPowerPCSDataService.PCSFaultReset();
                        //报警消失
                        Console.WriteLine($"datetime:{DateTime.Now.ToString()} PCS 故障消失");
                    }
                    _PcsSysFaultStateVaue = value;
                }

            }
        }


        /// <summary>
        /// PCS报警状态
        /// </summary>
        public PcsAlarmState PcsSysAlarmState { get; set; }


        private string _PcsSysAlarmStateMsg = "";
        /// <summary>
        /// PCS报警状态文本
        /// </summary>
        public string PcsSysAlarmStateMsg
        {
            get { return _PcsSysAlarmStateMsg; }
            set { _PcsSysAlarmStateMsg = value; }
        }


        private bool _PcsSysAlarmVaue;
        /// <summary>
        /// PCS报警状态字
        /// </summary>
        public bool PcsSysAlarmVaue
        {
            get { return _PcsSysAlarmVaue; }
            set
            {
                if (value != _PcsSysAlarmVaue)
                {
                    if (value)
                    {
                        PcsSysAlarmState = PcsAlarmState.Alarm;
                        PcsSysAlarmStateMsg = "报警中";
                        //产生报警
                        Console.WriteLine($"datetime:{DateTime.Now.ToString()} PCS 报警产生");
                    }
                    else
                    {
                        PcsSysAlarmState = PcsAlarmState.Normal;
                        PcsSysAlarmStateMsg = "正常";
                        //报警消失后，报警复位一下
                        InPowerPCSDataService.PCSFaultReset();
                        //报警消失
                        Console.WriteLine($"datetime:{DateTime.Now.ToString()} PCS 报警消失");
                    }
                    _PcsSysAlarmVaue = value;
                }

            }
        }

        /// <summary>
        /// PCS并离网状态
        /// </summary>
        public PCSOffLineInfo PcsOffLineState;

        private string _PcsOffLineStateMsg;
        /// <summary>
        /// PCS并离网状态消息
        /// </summary>
        public string PcsOffLineStateMsg
        {
            get { return _PcsOffLineStateMsg; }
            set { _PcsOffLineStateMsg = value; RaisePropertyChanged(); }
        }

        private bool _PcsOffLineStateValue;
        /// <summary>
        /// PCS并离网故障状态值
        /// </summary>
        public bool PcsOffLineStateValue
        {
            get { return _PcsOffLineStateValue; }
            set
            {
                if (value != _PcsOffLineStateValue)
                {
                    if (value)
                    {
                        PcsOffLineState = PCSOffLineInfo.OffLine;
                        PcsOffLineStateMsg = "并网";
                        //产生报警
                        Console.WriteLine($"时间:{DateTime.Now.ToString()} PCS 并网状态");
                    }
                    else
                    {
                        PcsOffLineState = PCSOffLineInfo.OnLine;
                        PcsOffLineStateMsg = "离网";
                        //报警消失
                        Console.WriteLine($"时间:{DateTime.Now.ToString()} PCS 离网状态");
                    }
                    _PcsOffLineStateValue = value;
                }
            }
        }

        /// <summary>
        /// PCS远程本地状态cs
        /// </summary>
        public PcsRemoteLocation PcsRemoteLocationState;


        private string _PcsRemoteLocationStateMsg;
        /// <summary>
        /// PCS远程本地状态消息
        /// </summary>
        public string PcsRemoteLocationStateMsg
        {
            get { return _PcsRemoteLocationStateMsg; }
            set { _PcsRemoteLocationStateMsg = value; RaisePropertyChanged(); }
        }

        private bool _PcsRemoteLocationStateValue;
        /// <summary>
        /// PCS远程本地状态值
        /// </summary>
        public bool PcsRemoteLocationStateValue
        {
            get { return _PcsRemoteLocationStateValue; }
            set
            {
                //if (value != _PCSRemoteLocationValue)
                //{
                if (value)
                {
                    PcsRemoteLocationState = PcsRemoteLocation.Remote;
                    PcsRemoteLocationStateMsg = "远程";
                    //产生报警
                    //Console.WriteLine($"datetime:{DateTime.Now.ToString()} PCS 远程");
                }
                else
                {
                    PcsRemoteLocationState = PcsRemoteLocation.Location;
                    PcsRemoteLocationStateMsg = "本地";
                    //报警消失
                    //Console.WriteLine($"datetime:{DateTime.Now.ToString()} PCS 本地");
                }
                _PcsRemoteLocationStateValue = value;
                //}
            }
        }

        #endregion


        #region 上位机连接状态

        private ushort _LinkBitValue=3;
        /// <summary>
        /// PCS上位机连接的结果值
        /// </summary>
        public ushort LinkBitValue
        {
            get { return _LinkBitValue; }
            set
            {
                if (value != _LinkBitValue)//连接状态值改变
                {
                    switch (value)
                    {
                        case 1:
                            if (CurIPCLinkStateMachine.State!=LinkState.LinkOK)
                            {
                                CurIPCLinkStateMachine.Fire(LinkStateTrig.LinkOKTrig);
                            }
                            break;
                        case 2:
                            if (CurIPCLinkStateMachine.State != LinkState.LinkNG)
                            {
                                CurIPCLinkStateMachine.Fire(LinkStateTrig.LinkNGTrig);
                            }
                            break;
                        default:
                            break;
                    }
                    _LinkBitValue = value;
                }
            }
        }

        public InPowerPCSDataService InPowerPCSDataService { get; }


        /// <summary>
        /// IPC连接NG的执行方法
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void IPCLinkNG()
        {
            LinkStateMsg = "失败";
            PcsLinkState = LinkState.LinkNG;
            Console.WriteLine($"DateTime:{DateTime.Now.ToString()}-【PCS状态模块】-【PCS上位机连接失败】");
        }

        /// <summary>
        /// IPC连接成功的执行方法
        /// </summary>
        private void IPCLinkOK()
        {
            LinkStateMsg = "正常";
            PcsLinkState = LinkState.LinkOK;
            Console.WriteLine($"DateTime:{DateTime.Now.ToString()}-【PCS状态模块】-【PCS上位机连接成功】");
        }

        #endregion

    }
}