20240801_FJEQ_upperpc/FujianEarthquake_seabed_now/FujianEarthquake/ViewModels/ShoreBaseStationControlViewModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;
using FujianEarthquake.Common;
using FujianEarthquake.DataAccess;
using FujianEarthquake.Views.UserControls;

namespace FujianEarthquake.ViewModels
{
    public class ShoreBaseStationControlViewModel : NotifyBase
    {
        public CommandBase ShoreBaseStationSwitchCommand { get; set; }

        public CommandBase ParaSettingCommand { get; set; }

        public CommandBase ProSettingCommand { get; set; }

        public CommandBase ResetDataCommand { get; set; }

        public ShoreBaseStationControlViewModel()
        {
            #region Command Set
            this.ShoreBaseStationSwitchCommand = new CommandBase();
            this.ShoreBaseStationSwitchCommand.DoExcute = new Action<object>(ShoreBaseStationSwitch);
            this.ShoreBaseStationSwitchCommand.DoCanExcute = new Func<object, bool>((o) => true);

            this.ParaSettingCommand = new CommandBase();
            this.ParaSettingCommand.DoExcute = new Action<object>(ParaSetting);
            this.ParaSettingCommand.DoCanExcute = new Func<object, bool>((o) => true);

            this.ProSettingCommand = new CommandBase();
            this.ProSettingCommand.DoExcute = new Action<object>(ProSetting);
            this.ProSettingCommand.DoCanExcute = new Func<object, bool>((o) => true);

            this.ResetDataCommand = new CommandBase();
            this.ResetDataCommand.DoExcute = new Action<object>(ResetData);
            this.ResetDataCommand.DoCanExcute = new Func<object, bool>((o) => true);
            #endregion


            #region DispatcherTimer Set
            timerOutputPowerOpenMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerOutputPowerOpenMsgHidden.Tick += TimerOutputPowerOpenMsgHidden_Tick;

            timerOutputPowerCloseMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerOutputPowerCloseMsgHidden.Tick += TimerOutputPowerCloseMsgHidden_Tick;

            timerOverVolProPowerOpenMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerOverVolProPowerOpenMsgHidden.Tick += TimerOverVolProPowerOpenMsgHidden_Tick;

            timerOverVolProPowerCloseMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerOverVolProPowerCloseMsgHidden.Tick += TimerOverVolProPowerCloseMsgHidden_Tick;

            timerOverCurProPowerOpenMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerOverCurProPowerOpenMsgHidden.Tick += TimerOverCurProPowerOpenMsgHidden_Tick;

            timerOverCurProPowerCloseMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerOverCurProPowerCloseMsgHidden.Tick += TimerOverCurProPowerCloseMsgHidden_Tick;

            timerParaSettingMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerParaSettingMsgHidden.Tick += TimerParaSettingMsgHidden_Tick;

            timerProSettingMsgHidden.Interval = TimeSpan.FromSeconds(2);
            timerProSettingMsgHidden.Tick += TimerProSettingMsgHidden_Tick;

            timerOutputPowerOpen.Interval = TimeSpan.FromSeconds(20);
            timerOutputPowerOpen.Tick += TimerOutputPowerOpen_Tick;

            timerOutputPowerClose.Interval = TimeSpan.FromSeconds(20);
            timerOutputPowerClose.Tick += TimerOutputPowerClose_Tick;

            timerOverVolProPowerOpen.Interval = TimeSpan.FromSeconds(20);
            timerOverVolProPowerOpen.Tick += TimerOverVolProPowerOpen_Tick;

            timerOverVolProPowerClose.Interval = TimeSpan.FromSeconds(20);
            timerOverVolProPowerClose.Tick += TimerOverVolProPowerClose_Tick;

            timerOverCurProPowerOpen.Interval = TimeSpan.FromSeconds(20);
            timerOverCurProPowerOpen.Tick += TimerOverCurProPowerOpen_Tick;

            timerOverCurProPowerClose.Interval = TimeSpan.FromSeconds(20);
            timerOverCurProPowerClose.Tick += TimerOverCurProPowerClose_Tick;

            timerParaSetting.Interval = TimeSpan.FromSeconds(20);
            timerParaSetting.Tick += TimerParaSetting_Tick;

            timerProSetting.Interval = TimeSpan.FromSeconds(20);
            timerProSetting.Tick += TimerProSetting_Tick;
            #endregion
        }


        #region SendMsg Define
        private byte powerAddress { get; set; }       //电源地址

        private byte functionCode { get; set; }            //功能码

        private byte[] startingRegisterAddress { get; set; }   //起始寄存器地址

        private byte[] registerNumber { get; set; }            //寄存器个数

        private byte[] checkCodeCRC { get; set; }             //校验码

        private List<byte> checkByte { get; set; } = new List<byte>();            //校验码Byte

        private List<byte> sendBytes { get; set; } = new List<byte>();             //发送数据
        #endregion

         
        #region Timer Define
        public DispatcherTimer timerOutputPowerOpenMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerOutputPowerCloseMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerOverVolProPowerOpenMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerOverVolProPowerCloseMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerOverCurProPowerOpenMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerOverCurProPowerCloseMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerParaSettingMsgHidden = new DispatcherTimer();
        public DispatcherTimer timerProSettingMsgHidden = new DispatcherTimer();

        public DispatcherTimer timerOutputPowerOpen = new DispatcherTimer();
        public DispatcherTimer timerOutputPowerClose = new DispatcherTimer();
        public DispatcherTimer timerOverVolProPowerOpen = new DispatcherTimer();
        public DispatcherTimer timerOverVolProPowerClose = new DispatcherTimer();
        public DispatcherTimer timerOverCurProPowerOpen = new DispatcherTimer();
        public DispatcherTimer timerOverCurProPowerClose = new DispatcherTimer();
        public DispatcherTimer timerParaSetting = new DispatcherTimer();
        public DispatcherTimer timerProSetting = new DispatcherTimer();
        #endregion


        #region Para Set
        public float setVoltageValue=0.0f;
        public float setCurrentValue=0.0f;

        private void TimerParaSettingMsgHidden_Tick(object sender, EventArgs e)
        {
            ParaSettingMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }


        private void TimerParaSetting_Tick(object sender, EventArgs e)
        {
            if (!ParaSettingIsReceived)
            {
                ParaSettingMsgVisibility = Visibility.Visible;
                ParaSettingMsg = "设置电压电流值发送成功，但未收到回复！";
                timerParaSettingMsgHidden.Start();
                ParaSettingMsgForeground = new SolidColorBrush(Colors.Red);
                ParaSettingBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }


        private float setVoltage;

        public float SetVoltage
        {
            get { return setVoltage; }
            set { setVoltage = value; this.DoNotify(); }
        }

        private float setCurrent;

        public float SetCurrent
        {
            get { return setCurrent; }
            set { setCurrent = value; this.DoNotify(); }
        }


        private string paraSettingMsg;

        public string ParaSettingMsg
        {
            get { return paraSettingMsg; }
            set { paraSettingMsg = value; this.DoNotify(); }
        }


        private Brush paraSettingMsgForeground;

        public Brush ParaSettingMsgForeground
        {
            get { return paraSettingMsgForeground; }
            set { paraSettingMsgForeground = value; this.DoNotify(); }
        }


        private Visibility paraSettingMsgVisibility;

        public Visibility ParaSettingMsgVisibility
        {
            get { return paraSettingMsgVisibility; }
            set { paraSettingMsgVisibility = value; this.DoNotify(); }
        }


        private bool paraSettingIsReceived = false;

        public bool ParaSettingIsReceived
        {
            get { return paraSettingIsReceived; }
            set { paraSettingIsReceived = value; this.DoNotify(); }
        }


        private bool paraSettingBtnIsEnabled = true;

        public bool ParaSettingBtnIsEnabled
        {
            get { return paraSettingBtnIsEnabled; }
            set { paraSettingBtnIsEnabled = value; this.DoNotify(); }
        }

        /// <summary>
        /// 设置额定电压和额定电流
        /// </summary>
        /// <param name="o"></param>
        public void ParaSetting(object o)
        {
            ParaSettingBtnIsEnabled = false;
            ParaSettingIsReceived = false;
            setVoltageValue = 0.0f;
            setCurrentValue = 0.0f;

            powerAddress = 0x01;
            functionCode = 0x10;        //功能码
            startingRegisterAddress = new byte[2] { 0x00, 0x95 };   //起始寄存器地址
            registerNumber = new byte[2] { 0x00, 0x02 };            //寄存器个数
            byte number = 0x04;

            int voltageSet = (int)(SetVoltage * 10);
            byte[] voltage = Tools.DecimalToTwoByteArray(voltageSet);
            int currentSet = (int)(SetCurrent * 10);
            byte[] current = Tools.DecimalToTwoByteArray(currentSet);

            //校验码计算
            checkByte.Clear();
            checkByte.Add(powerAddress);
            checkByte.Add(functionCode);
            checkByte.AddRange(startingRegisterAddress);
            checkByte.AddRange(registerNumber);
            checkByte.Add(number);
            checkByte.AddRange(voltage);
            checkByte.AddRange(current);
            checkCodeCRC = Tools.CalculateModbusCRC(checkByte.ToArray());
            //发送指令
            sendBytes.Clear();
            sendBytes.Add(powerAddress);
            sendBytes.Add(functionCode);
            sendBytes.AddRange(startingRegisterAddress);
            sendBytes.AddRange(registerNumber);
            sendBytes.Add(number);
            sendBytes.AddRange(voltage);
            sendBytes.AddRange(current);
            sendBytes.AddRange(checkCodeCRC);

            bool result = false;
            if (MainWindow.mainViewModel.clientModel1.IsConnected)
                result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
            else
            {
                ParaSettingMsgVisibility = Visibility.Visible;
                ParaSettingMsg = "通信未连接！";
                timerParaSettingMsgHidden.Start();
                ParaSettingMsgForeground = new SolidColorBrush(Colors.Red);
                ParaSettingBtnIsEnabled = true;
                return;
            }

            if (result)
            {
                ParaSettingMsgVisibility = Visibility.Visible;
                ParaSettingMsg = "设置电压电流值发送成功！";
                timerParaSettingMsgHidden.Start();
                ParaSettingMsgForeground = new SolidColorBrush(Colors.Green);
                timerParaSetting.Start();

                setVoltageValue = SetVoltage;
                setCurrentValue = SetCurrent;
            }
            else
            {
                ParaSettingMsgVisibility = Visibility.Visible;
                ParaSettingMsg = "设置电压电流值发送失败！";
                timerParaSettingMsgHidden.Start();
                ParaSettingMsgForeground = new SolidColorBrush(Colors.Red);
                ParaSettingBtnIsEnabled = true;
            }

            string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','数据请求','{ParaSettingMsg}');";
            DBHelper.ExecuteNonQuery(sql, 1);
        }
        #endregion


        #region Pro Value Set
        public float proVoltageValue = 0.0f;
        public float proCurrentValue = 0.0f;

        private void TimerProSettingMsgHidden_Tick(object sender, EventArgs e)
        {
            ProSettingMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }


        private void TimerProSetting_Tick(object sender, EventArgs e)
        {
            if (!ProSettingIsReceived)
            {
                ProSettingMsgVisibility = Visibility.Visible;
                ProSettingMsg = "设置输出过压过流保护值发送成功，但未收到回复！";
                timerProSettingMsgHidden.Start();
                ProSettingMsgForeground = new SolidColorBrush(Colors.Red);
                ProSettingBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }


        private float proVoltage;

        public float ProVoltage
        {
            get { return proVoltage; }
            set { proVoltage = value; this.DoNotify(); }
        }


        private float proCurrent;

        public float ProCurrent
        {
            get { return proCurrent; }
            set { proCurrent = value; this.DoNotify(); }
        }


        private bool proSettingBtnIsEnabled = true;

        public bool ProSettingBtnIsEnabled
        {
            get { return proSettingBtnIsEnabled; }
            set { proSettingBtnIsEnabled = value; this.DoNotify(); }
        }


        private bool proSettingIsReceived = false;

        public bool ProSettingIsReceived
        {
            get { return proSettingIsReceived; }
            set { proSettingIsReceived = value; this.DoNotify(); }
        }


        private string proSettingMsg;

        public string ProSettingMsg
        {
            get { return proSettingMsg; }
            set { proSettingMsg = value; this.DoNotify(); }
        }


        private Brush proSettingMsgForeground;

        public Brush ProSettingMsgForeground
        {
            get { return proSettingMsgForeground; }
            set { proSettingMsgForeground = value; this.DoNotify(); }
        }


        private Visibility proSettingMsgVisibility;

        public Visibility ProSettingMsgVisibility
        {
            get { return proSettingMsgVisibility; }
            set { proSettingMsgVisibility = value; this.DoNotify(); }
        }


        /// <summary>
        /// 设置过压过流保护值
        /// </summary>
        /// <param name="o"></param>
        public void ProSetting(object o)
        {
            ProSettingBtnIsEnabled = false;
            ProSettingIsReceived = false;
            proVoltageValue = 0.0f;
            proCurrentValue = 0.0f;

            powerAddress = 0x01;
            functionCode = 0x10;        //功能码
            startingRegisterAddress = new byte[2] { 0x00, 0x9D };   //起始寄存器地址
            registerNumber = new byte[2] { 0x00, 0x02 };            //寄存器个数
            byte number = 0x04;

            int voltagePro = (int)(ProVoltage * 10);
            byte[] voltage = Tools.DecimalToTwoByteArray(voltagePro);
            int currentPro = (int)(ProCurrent * 10);
            byte[] current = Tools.DecimalToTwoByteArray(currentPro);

            //校验码计算
            checkByte.Clear();
            checkByte.Add(powerAddress);
            checkByte.Add(functionCode);
            checkByte.AddRange(startingRegisterAddress);
            checkByte.AddRange(registerNumber);
            checkByte.Add(number);
            checkByte.AddRange(voltage);
            checkByte.AddRange(current);
            checkCodeCRC = Tools.CalculateModbusCRC(checkByte.ToArray());
            //发送指令
            sendBytes.Clear();
            sendBytes.Add(powerAddress);
            sendBytes.Add(functionCode);
            sendBytes.AddRange(startingRegisterAddress);
            sendBytes.AddRange(registerNumber);
            sendBytes.Add(number);
            sendBytes.AddRange(voltage);
            sendBytes.AddRange(current);
            sendBytes.AddRange(checkCodeCRC);

            bool result = false;
            if (MainWindow.mainViewModel.clientModel1.IsConnected)
                result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
            else
            {
                ProSettingMsgVisibility = Visibility.Visible;
                ProSettingMsg = "通信未连接！";
                timerProSettingMsgHidden.Start();
                ProSettingMsgForeground = new SolidColorBrush(Colors.Red);
                ProSettingBtnIsEnabled = true;
                return;
            }

            if (result)
            {
                ProSettingMsgVisibility = Visibility.Visible;
                ProSettingMsg = "设置输出过压过流保护值发送成功！";
                timerProSettingMsgHidden.Start();
                ProSettingMsgForeground = new SolidColorBrush(Colors.Green);
                timerProSetting.Start();

                proVoltageValue = ProVoltage;
                proCurrentValue = ProCurrent;
            }
            else
            {
                ProSettingMsgVisibility = Visibility.Visible;
                ProSettingMsg = "设置输出过压过流保护值发送失败！";
                timerProSettingMsgHidden.Start();
                ProSettingMsgForeground = new SolidColorBrush(Colors.Red);
                ProSettingBtnIsEnabled = true;
            }

            string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','数据请求','{ParaSettingMsg}');";
            DBHelper.ExecuteNonQuery(sql, 1);
        }
        #endregion


        #region Reset Data
        /// <summary>
        /// 读取电压电流设置值和输出过压过流保护值
        /// </summary>
        /// <param name="o"></param>
        public void ResetData(object o)
        {
            powerAddress = 0x01;
            functionCode = 0x03;        //功能码
            startingRegisterAddress = new byte[2] { 0x00, 0x95 };   //起始寄存器地址
            registerNumber = new byte[2] { 0x00, 0x05 };            //寄存器个数

            //校验码计算
            checkByte.Clear();
            checkByte.Add(powerAddress);
            checkByte.Add(functionCode);
            checkByte.AddRange(startingRegisterAddress);
            checkByte.AddRange(registerNumber);
            checkCodeCRC = Tools.CalculateModbusCRC(checkByte.ToArray());
            //发送指令
            sendBytes.Clear();
            sendBytes.Add(powerAddress);
            sendBytes.Add(functionCode);
            sendBytes.AddRange(startingRegisterAddress);
            sendBytes.AddRange(registerNumber);
            sendBytes.AddRange(checkCodeCRC);

            bool result = false;
            if (MainWindow.mainViewModel.clientModel1.IsConnected)
                result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
            else
            {
                return;
            }

            string msg;
            if (result)
            {
                msg = "读取电压电流设置值、输出过压过流保护值发送成功！";
            }
            else
            {
                msg = "读取电压电流设置值、输出过压过流保护值发送失败！";
            }

            string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','数据请求','{msg}');";
            DBHelper.ExecuteNonQuery(sql, 1);
        }
        #endregion


        #region Pow Set

        #region Timer Tick
        private void TimerOutputPowerOpenMsgHidden_Tick(object sender, EventArgs e)
        {
            OutputPowerOpenMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOutputPowerCloseMsgHidden_Tick(object sender, EventArgs e)
        {
            OutputPowerCloseMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverVolProPowerOpenMsgHidden_Tick(object sender, EventArgs e)
        {
            OverVolProPowerOpenMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverVolProPowerCloseMsgHidden_Tick(object sender, EventArgs e)
        {
            OverVolProPowerCloseMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverCurProPowerOpenMsgHidden_Tick(object sender, EventArgs e)
        {
            OverCurProPowerOpenMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverCurProPowerCloseMsgHidden_Tick(object sender, EventArgs e)
        {
            OverCurProPowerCloseMsgVisibility = Visibility.Hidden;

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOutputPowerOpen_Tick(object sender, EventArgs e)
        {
            if (!OutputPowerOpenIsReceived)
            {
                OutputPowerOpenMsgVisibility = Visibility.Visible;
                OutputPowerOpenMsg = "开启输出开关发送成功，但未收到回复！";
                timerOutputPowerOpenMsgHidden.Start();
                OutputPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                OutputPowerOpenBtnIsEnabled = true;
                OutputPowerCloseBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOutputPowerClose_Tick(object sender, EventArgs e)
        {
            if (!OutputPowerCloseIsReceived)
            {
                OutputPowerCloseMsgVisibility = Visibility.Visible;
                OutputPowerCloseMsg = "关闭输出开关发送成功，但未收到回复！";
                timerOutputPowerCloseMsgHidden.Start();
                OutputPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                OutputPowerOpenBtnIsEnabled = true;
                OutputPowerCloseBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverVolProPowerOpen_Tick(object sender, EventArgs e)
        {
            if (!OverVolProPowerOpenIsReceived)
            {
                OverVolProPowerOpenMsgVisibility = Visibility.Visible;
                OverVolProPowerOpenMsg = "开启输出过压保护允许发送成功，但未收到回复！";
                timerOverVolProPowerOpenMsgHidden.Start();
                OverVolProPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                OverVolProPowerOpenBtnIsEnabled = true;
                OverVolProPowerCloseBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverVolProPowerClose_Tick(object sender, EventArgs e)
        {
            if (!OverVolProPowerCloseIsReceived)
            {
                OverVolProPowerCloseMsgVisibility = Visibility.Visible;
                OverVolProPowerCloseMsg = "关闭输出过压保护允许发送成功，但未收到回复！";
                timerOverVolProPowerCloseMsgHidden.Start();
                OverVolProPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                OverVolProPowerOpenBtnIsEnabled = true;
                OverVolProPowerCloseBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverCurProPowerOpen_Tick(object sender, EventArgs e)
        {
            if (!OverCurProPowerOpenIsReceived)
            {
                OverCurProPowerOpenMsgVisibility = Visibility.Visible;
                OverCurProPowerOpenMsg = "开启输出过流保护允许发送成功，但未收到回复！";
                timerOverCurProPowerOpenMsgHidden.Start();
                OverCurProPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                OverCurProPowerOpenBtnIsEnabled = true;
                OverCurProPowerCloseBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }

        private void TimerOverCurProPowerClose_Tick(object sender, EventArgs e)
        {
            if (!OverCurProPowerCloseIsReceived)
            {
                OverCurProPowerCloseMsgVisibility = Visibility.Visible;
                OverCurProPowerCloseMsg = "关闭输出过流保护允许发送成功，但未收到回复！";
                timerOverCurProPowerCloseMsgHidden.Start();
                OverCurProPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                OverCurProPowerOpenBtnIsEnabled = true;
                OverCurProPowerCloseBtnIsEnabled = true;
            }

            // 停止定时器
            (sender as DispatcherTimer).Stop();
        }
        #endregion


        #region Page Define
        private ImageSource overState;

        public ImageSource OutputState
        {
            get { return overState; }
            set { overState = value; this.DoNotify(); }
        }


        private string outputPowerOpenMsg;

        public string OutputPowerOpenMsg
        {
            get { return outputPowerOpenMsg; }
            set { outputPowerOpenMsg = value; this.DoNotify(); }
        }


        private Brush outputPowerOpenMsgForeground;

        public Brush OutputPowerOpenMsgForeground
        {
            get { return outputPowerOpenMsgForeground; }
            set { outputPowerOpenMsgForeground = value; this.DoNotify(); }
        }


        private Visibility outputPowerOpenMsgVisibility;

        public Visibility OutputPowerOpenMsgVisibility
        {
            get { return outputPowerOpenMsgVisibility; }
            set { outputPowerOpenMsgVisibility = value; this.DoNotify(); }
        }


        private bool outputPowerOpenIsReceived = false;

        public bool OutputPowerOpenIsReceived
        {
            get { return outputPowerOpenIsReceived; }
            set { outputPowerOpenIsReceived = value; this.DoNotify(); }
        }


        private bool outputPowerOpenBtnIsEnabled = true;

        public bool OutputPowerOpenBtnIsEnabled
        {
            get { return outputPowerOpenBtnIsEnabled; }
            set { outputPowerOpenBtnIsEnabled = value; this.DoNotify(); }
        }


        private string outputPowerCloseMsg;

        public string OutputPowerCloseMsg
        {
            get { return outputPowerCloseMsg; }
            set { outputPowerCloseMsg = value; this.DoNotify(); }
        }


        private Brush outputPowerCloseMsgForeground;

        public Brush OutputPowerCloseMsgForeground
        {
            get { return outputPowerCloseMsgForeground; }
            set { outputPowerCloseMsgForeground = value; this.DoNotify(); }
        }


        private Visibility outputPowerCloseMsgVisibility;

        public Visibility OutputPowerCloseMsgVisibility
        {
            get { return outputPowerCloseMsgVisibility; }
            set { outputPowerCloseMsgVisibility = value; this.DoNotify(); }
        }


        private bool outputPowerCloseIsReceived = false;

        public bool OutputPowerCloseIsReceived
        {
            get { return outputPowerCloseIsReceived; }
            set { outputPowerCloseIsReceived = value; this.DoNotify(); }
        }


        private bool outputPowerCloseBtnIsEnabled = true;

        public bool OutputPowerCloseBtnIsEnabled
        {
            get { return outputPowerCloseBtnIsEnabled; }
            set { outputPowerCloseBtnIsEnabled = value; this.DoNotify(); }
        }


        private ImageSource overVolProAllowState;

        public ImageSource OverVolProAllowState
        {
            get { return overVolProAllowState; }
            set { overVolProAllowState = value; this.DoNotify(); }
        }


        private string overVolProPowerOpenMsg;

        public string OverVolProPowerOpenMsg
        {
            get { return overVolProPowerOpenMsg; }
            set { overVolProPowerOpenMsg = value; this.DoNotify(); }
        }


        private Brush overVolProPowerOpenMsgForeground;

        public Brush OverVolProPowerOpenMsgForeground
        {
            get { return overVolProPowerOpenMsgForeground; }
            set { overVolProPowerOpenMsgForeground = value; this.DoNotify(); }
        }


        private Visibility overVolProPowerOpenMsgVisibility;

        public Visibility OverVolProPowerOpenMsgVisibility
        {
            get { return overVolProPowerOpenMsgVisibility; }
            set { overVolProPowerOpenMsgVisibility = value; this.DoNotify(); }
        }


        private bool overVolProPowerOpenIsReceived = false;

        public bool OverVolProPowerOpenIsReceived
        {
            get { return overVolProPowerOpenIsReceived; }
            set { overVolProPowerOpenIsReceived = value; this.DoNotify(); }
        }


        private bool overVolProPowerOpenBtnIsEnabled = true;

        public bool OverVolProPowerOpenBtnIsEnabled
        {
            get { return overVolProPowerOpenBtnIsEnabled; }
            set { overVolProPowerOpenBtnIsEnabled = value; this.DoNotify(); }
        }


        private string overVolProPowerCloseMsg;

        public string OverVolProPowerCloseMsg
        {
            get { return overVolProPowerCloseMsg; }
            set { overVolProPowerCloseMsg = value; this.DoNotify(); }
        }


        private Brush overVolProPowerCloseMsgForeground;

        public Brush OverVolProPowerCloseMsgForeground
        {
            get { return overVolProPowerCloseMsgForeground; }
            set { overVolProPowerCloseMsgForeground = value; this.DoNotify(); }
        }


        private Visibility overVolProPowerCloseMsgVisibility;

        public Visibility OverVolProPowerCloseMsgVisibility
        {
            get { return overVolProPowerCloseMsgVisibility; }
            set { overVolProPowerCloseMsgVisibility = value; this.DoNotify(); }
        }


        private bool overVolProPowerCloseIsReceived = false;

        public bool OverVolProPowerCloseIsReceived
        {
            get { return overVolProPowerCloseIsReceived; }
            set { overVolProPowerCloseIsReceived = value; this.DoNotify(); }
        }


        private bool overVolProPowerCloseBtnIsEnabled = true;

        public bool OverVolProPowerCloseBtnIsEnabled
        {
            get { return overVolProPowerCloseBtnIsEnabled; }
            set { overVolProPowerCloseBtnIsEnabled = value; this.DoNotify(); }
        }


        private ImageSource overCurProAllowState;

        public ImageSource OverCurProAllowState
        {
            get { return overCurProAllowState; }
            set { overCurProAllowState = value; this.DoNotify(); }
        }


        private string overCurProPowerOpenMsg;

        public string OverCurProPowerOpenMsg
        {
            get { return overCurProPowerOpenMsg; }
            set { overCurProPowerOpenMsg = value; this.DoNotify(); }
        }


        private Brush overCurProPowerOpenMsgForeground;

        public Brush OverCurProPowerOpenMsgForeground
        {
            get { return overCurProPowerOpenMsgForeground; }
            set { overCurProPowerOpenMsgForeground = value; this.DoNotify(); }
        }


        private Visibility overCurProPowerOpenMsgVisibility;

        public Visibility OverCurProPowerOpenMsgVisibility
        {
            get { return overCurProPowerOpenMsgVisibility; }
            set { overCurProPowerOpenMsgVisibility = value; this.DoNotify(); }
        }


        private bool overCurProPowerOpenIsReceived = false;

        public bool OverCurProPowerOpenIsReceived
        {
            get { return overCurProPowerOpenIsReceived; }
            set { overCurProPowerOpenIsReceived = value; this.DoNotify(); }
        }


        private bool overCurProPowerOpenBtnIsEnabled = true;

        public bool OverCurProPowerOpenBtnIsEnabled
        {
            get { return overCurProPowerOpenBtnIsEnabled; }
            set { overCurProPowerOpenBtnIsEnabled = value; this.DoNotify(); }
        }


        private string overCurProPowerCloseMsg;

        public string OverCurProPowerCloseMsg
        {
            get { return overCurProPowerCloseMsg; }
            set { overCurProPowerCloseMsg = value; this.DoNotify(); }
        }


        private Brush overCurProPowerCloseMsgForeground;

        public Brush OverCurProPowerCloseMsgForeground
        {
            get { return overCurProPowerCloseMsgForeground; }
            set { overCurProPowerCloseMsgForeground = value; this.DoNotify(); }
        }


        private Visibility overCurProPowerCloseMsgVisibility;

        public Visibility OverCurProPowerCloseMsgVisibility
        {
            get { return overCurProPowerCloseMsgVisibility; }
            set { overCurProPowerCloseMsgVisibility = value; this.DoNotify(); }
        }


        private bool overCurProPowerCloseIsReceived = false;

        public bool OverCurProPowerCloseIsReceived
        {
            get { return overCurProPowerCloseIsReceived; }
            set { overCurProPowerCloseIsReceived = value; this.DoNotify(); }
        }


        private bool overCurProPowerCloseBtnIsEnabled = true;

        public bool OverCurProPowerCloseBtnIsEnabled
        {
            get { return overCurProPowerCloseBtnIsEnabled; }
            set { overCurProPowerCloseBtnIsEnabled = value; this.DoNotify(); }
        }
        #endregion


        public void ShoreBaseStationSwitch(object o)
        {
            string[] msg = o.ToString().Split(',');
            int switchNum = msg[1].Equals("True") ? 1 : 0;

            switch (msg[0])
            {
                case "OutputPowerPicker":
                    OutputPowerOpenBtnIsEnabled = false;
                    OutputPowerCloseBtnIsEnabled = false;
                    OutputPowerOpenIsReceived = false;
                    OutputPowerCloseIsReceived = false;

                    powerAddress = 0x01;
                    functionCode = 0x05;        //功能码
                    startingRegisterAddress = new byte[2] { 0x00, 0x85 };   //起始寄存器地址
                    byte[] operation = new byte[2];

                    if (msg[1].Equals("True"))   //打开
                    {
                        operation = new byte[2] { 0x00, 0x00 };
                    }
                    else
                    {
                        operation = new byte[2] { 0xFF, 0x00 };
                    }

                    //校验码计算
                    checkByte.Clear();
                    checkByte.Add(powerAddress);
                    checkByte.Add(functionCode);
                    checkByte.AddRange(startingRegisterAddress);
                    checkByte.AddRange(operation);
                    checkCodeCRC = Tools.CalculateModbusCRC(checkByte.ToArray());
                    //发送指令
                    sendBytes.Clear();
                    sendBytes.Add(powerAddress);
                    sendBytes.Add(functionCode);
                    sendBytes.AddRange(startingRegisterAddress);
                    sendBytes.AddRange(operation);
                    sendBytes.AddRange(checkCodeCRC);

                    bool result = false;

                    if (msg[1].Equals("True"))   //打开
                    {
                        if (MainWindow.mainViewModel.clientModel1.IsConnected)
                            result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
                        else
                        {
                            OutputPowerOpenMsgVisibility = Visibility.Visible;
                            OutputPowerOpenMsg = "通信未连接！";
                            timerOutputPowerOpenMsgHidden.Start();
                            OutputPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                            OutputPowerOpenBtnIsEnabled = true;
                            OutputPowerCloseBtnIsEnabled = true;
                            return;
                        }

                        if (result)
                        {
                            OutputPowerOpenMsgVisibility = Visibility.Visible;
                            OutputPowerOpenMsg = "开启输出开关发送成功！";
                            timerOutputPowerOpenMsgHidden.Start();
                            OutputPowerOpenMsgForeground = new SolidColorBrush(Colors.Green);
                            timerOutputPowerOpen.Start();
                        }
                        else
                        {
                            OutputPowerOpenMsgVisibility = Visibility.Visible;
                            OutputPowerOpenMsg = "开启输出开关发送失败！";
                            timerOutputPowerOpenMsgHidden.Start();
                            OutputPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                            OutputPowerOpenBtnIsEnabled = true;
                            OutputPowerCloseBtnIsEnabled = true;
                        }

                        string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','继电控制','{OutputPowerOpenMsg}');";
                        DBHelper.ExecuteNonQuery(sql, 1);
                    }
                    else
                    {
                        if (MainWindow.mainViewModel.clientModel1.IsConnected)
                            result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
                        else
                        {
                            OutputPowerCloseMsgVisibility = Visibility.Visible;
                            OutputPowerCloseMsg = "通信未连接！";
                            timerOutputPowerCloseMsgHidden.Start();
                            OutputPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                            OutputPowerCloseBtnIsEnabled = true;
                            OutputPowerOpenBtnIsEnabled = true;
                            return;
                        }

                        if (result)
                        {
                            OutputPowerCloseMsgVisibility = Visibility.Visible;
                            OutputPowerCloseMsg = "关闭输出开关发送成功！";
                            timerOutputPowerCloseMsgHidden.Start();
                            OutputPowerCloseMsgForeground = new SolidColorBrush(Colors.Green);
                            timerOutputPowerClose.Start();
                        }
                        else
                        {
                            OutputPowerCloseMsgVisibility = Visibility.Visible;
                            OutputPowerCloseMsg = "关闭输出开关发送失败！";
                            timerOutputPowerCloseMsgHidden.Start();
                            OutputPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                            OutputPowerCloseBtnIsEnabled = true;
                            OutputPowerOpenBtnIsEnabled = true;
                        }

                        string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','继电控制','{OutputPowerCloseMsg}');";
                        DBHelper.ExecuteNonQuery(sql, 1);
                    }

                    break;

                case "OverVolProPowerPicker":
                    OverVolProPowerOpenBtnIsEnabled = false;
                    OverVolProPowerCloseBtnIsEnabled = false;
                    OverVolProPowerOpenIsReceived = false;
                    OverVolProPowerCloseIsReceived = false;

                    powerAddress = 0x01;
                    functionCode = 0x05;        //功能码
                    startingRegisterAddress = new byte[2] { 0x00, 0x88 };   //起始寄存器地址

                    if (msg[1].Equals("True"))   //打开
                    {
                        operation = new byte[2] { 0x00, 0x00 };
                    }
                    else
                    {
                        operation = new byte[2] { 0xFF, 0x00 };
                    }

                    //校验码计算
                    checkByte.Clear();
                    checkByte.Add(powerAddress);
                    checkByte.Add(functionCode);
                    checkByte.AddRange(startingRegisterAddress);
                    checkByte.AddRange(operation);
                    checkCodeCRC = Tools.CalculateModbusCRC(checkByte.ToArray());
                    //发送指令
                    sendBytes.Clear();
                    sendBytes.Add(powerAddress);
                    sendBytes.Add(functionCode);
                    sendBytes.AddRange(startingRegisterAddress);
                    sendBytes.AddRange(operation);
                    sendBytes.AddRange(checkCodeCRC);

                    result = false;

                    if (msg[1].Equals("True"))   //打开
                    {
                        if (MainWindow.mainViewModel.clientModel1.IsConnected)
                            result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
                        else
                        {
                            OverVolProPowerOpenMsgVisibility = Visibility.Visible;
                            OverVolProPowerOpenMsg = "通信未连接！";
                            timerOverVolProPowerOpenMsgHidden.Start();
                            OverVolProPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                            OverVolProPowerOpenBtnIsEnabled = true;
                            OverVolProPowerCloseBtnIsEnabled = true;
                            return;
                        }

                        if (result)
                        {
                            OverVolProPowerOpenMsgVisibility = Visibility.Visible;
                            OverVolProPowerOpenMsg = "开启输出过压保护允许发送成功！";
                            timerOverVolProPowerOpenMsgHidden.Start();
                            OverVolProPowerOpenMsgForeground = new SolidColorBrush(Colors.Green);
                            timerOverVolProPowerOpen.Start();
                        }
                        else
                        {
                            OverVolProPowerOpenMsgVisibility = Visibility.Visible;
                            OverVolProPowerOpenMsg = "开启输出过压保护允许发送失败！";
                            timerOverVolProPowerOpenMsgHidden.Start();
                            OverVolProPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                            OverVolProPowerOpenBtnIsEnabled = true;
                            OverVolProPowerCloseBtnIsEnabled = true;
                        }

                        string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','继电控制','{OverVolProPowerOpenMsg}');";
                        DBHelper.ExecuteNonQuery(sql, 1);
                    }
                    else
                    {
                        if (MainWindow.mainViewModel.clientModel1.IsConnected)
                            result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
                        else
                        {
                            OverVolProPowerCloseMsgVisibility = Visibility.Visible;
                            OverVolProPowerCloseMsg = "通信未连接！";
                            timerOverVolProPowerCloseMsgHidden.Start();
                            OverVolProPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                            OverVolProPowerCloseBtnIsEnabled = true;
                            OverVolProPowerOpenBtnIsEnabled = true;
                            return;
                        }

                        if (result)
                        {
                            OverVolProPowerCloseMsgVisibility = Visibility.Visible;
                            OverVolProPowerCloseMsg = "关闭输出过压保护允许发送成功！";
                            timerOverVolProPowerCloseMsgHidden.Start();
                            OverVolProPowerCloseMsgForeground = new SolidColorBrush(Colors.Green);
                            timerOverVolProPowerClose.Start();
                        }
                        else
                        {
                            OverVolProPowerCloseMsgVisibility = Visibility.Visible;
                            OverVolProPowerCloseMsg = "关闭输出过压保护允许发送失败！";
                            timerOverVolProPowerCloseMsgHidden.Start();
                            OverVolProPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                            OverVolProPowerCloseBtnIsEnabled = true;
                            OverVolProPowerOpenBtnIsEnabled = true;
                        }

                        string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','继电控制','{OverVolProPowerCloseMsg}');";
                        DBHelper.ExecuteNonQuery(sql, 1);
                    }

                    break;

                case "OverCurProPowerPicker":
                    OverCurProPowerOpenBtnIsEnabled = false;
                    OverCurProPowerCloseBtnIsEnabled = false;
                    OverCurProPowerOpenIsReceived = false;
                    OverCurProPowerCloseIsReceived = false;

                    powerAddress = 0x01;
                    functionCode = 0x05;        //功能码
                    startingRegisterAddress = new byte[2] { 0x00, 0x89 };   //起始寄存器地址

                    if (msg[1].Equals("True"))   //打开
                    {
                        operation = new byte[2] { 0x00, 0x00 };
                    }
                    else
                    {
                        operation = new byte[2] { 0xFF, 0x00 };
                    }

                    //校验码计算
                    checkByte.Clear();
                    checkByte.Add(powerAddress);
                    checkByte.Add(functionCode);
                    checkByte.AddRange(startingRegisterAddress);
                    checkByte.AddRange(operation);
                    checkCodeCRC = Tools.CalculateModbusCRC(checkByte.ToArray());
                    //发送指令
                    sendBytes.Clear();
                    sendBytes.Add(powerAddress);
                    sendBytes.Add(functionCode);
                    sendBytes.AddRange(startingRegisterAddress);
                    sendBytes.AddRange(operation);
                    sendBytes.AddRange(checkCodeCRC);

                    result = false;

                    if (msg[1].Equals("True"))   //打开
                    {
                        if (MainWindow.mainViewModel.clientModel1.IsConnected)
                            result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
                        else
                        {
                            OverCurProPowerOpenMsgVisibility = Visibility.Visible;
                            OverCurProPowerOpenMsg = "通信未连接！";
                            timerOverCurProPowerOpenMsgHidden.Start();
                            OverCurProPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                            OverCurProPowerOpenBtnIsEnabled = true;
                            OverCurProPowerCloseBtnIsEnabled = true;
                            return;
                        }

                        if (result)
                        {
                            OverCurProPowerOpenMsgVisibility = Visibility.Visible;
                            OverCurProPowerOpenMsg = "开启输出过流保护允许发送成功！";
                            timerOverCurProPowerOpenMsgHidden.Start();
                            OverCurProPowerOpenMsgForeground = new SolidColorBrush(Colors.Green);
                            timerOverCurProPowerOpen.Start();
                        }
                        else
                        {
                            OverCurProPowerOpenMsgVisibility = Visibility.Visible;
                            OverCurProPowerOpenMsg = "开启输出过流保护允许发送失败！";
                            timerOverCurProPowerOpenMsgHidden.Start();
                            OverCurProPowerOpenMsgForeground = new SolidColorBrush(Colors.Red);
                            OverCurProPowerOpenBtnIsEnabled = true;
                            OverCurProPowerCloseBtnIsEnabled = true;
                        }

                        string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','继电控制','{OverCurProPowerOpenMsg}');";
                        DBHelper.ExecuteNonQuery(sql, 1);
                    }
                    else
                    {
                        if (MainWindow.mainViewModel.clientModel1.IsConnected)
                            result = MainWindow.mainViewModel.clientModel1.SendMessage(sendBytes.ToArray());
                        else
                        {
                            OverCurProPowerCloseMsgVisibility = Visibility.Visible;
                            OverCurProPowerCloseMsg = "通信未连接！";
                            timerOverCurProPowerCloseMsgHidden.Start();
                            OverCurProPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                            OverCurProPowerCloseBtnIsEnabled = true;
                            OverCurProPowerOpenBtnIsEnabled = true;
                            return;
                        }

                        if (result)
                        {
                            OverCurProPowerCloseMsgVisibility = Visibility.Visible;
                            OverCurProPowerCloseMsg = "关闭输出过流保护允许发送成功！";
                            timerOverCurProPowerCloseMsgHidden.Start();
                            OverCurProPowerCloseMsgForeground = new SolidColorBrush(Colors.Green);
                            timerOverCurProPowerClose.Start();
                        }
                        else
                        {
                            OverCurProPowerCloseMsgVisibility = Visibility.Visible;
                            OverCurProPowerCloseMsg = "关闭输出过流保护允许发送失败！";
                            timerOverCurProPowerCloseMsgHidden.Start();
                            OverCurProPowerCloseMsgForeground = new SolidColorBrush(Colors.Red);
                            OverCurProPowerCloseBtnIsEnabled = true;
                            OverCurProPowerOpenBtnIsEnabled = true;
                        }

                        string sql = $"insert into log_record(StationID,RecordTime,Device_Name,Operation_Type,Record) values('1','{DateTime.Now}','岸基电源','继电控制','{OverCurProPowerCloseMsg}');";
                        DBHelper.ExecuteNonQuery(sql, 1);
                    }

                    break;
            }
        }
        #endregion

    }
}