CCDCount/CCDCountWpf/PlcMessageShowBindingClass.cs

using CCDCount.DLL;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace CCDCountWpf
{
    public class PlcMessageShowBindingClass : INotifyPropertyChanged
    {
        /// <summary>
        /// 使能完成
        /// </summary>
        private bool enableCompletion;
        public bool EnableCompletion
        {
            get { return enableCompletion; }
            set
            {
                enableCompletion = value;
                OnPropertyChanged("EnableCompletion");
            }
        }

        /// <summary>
        /// 归零完成
        /// </summary>
        private bool returnToZeroCompletion;
        public bool ReturnToZeroCompletion
        {
            get { return returnToZeroCompletion; }
            set
            {
                returnToZeroCompletion = value;
                OnPropertyChanged("ReturnToZeroCompletion");
            }
        }

        /// <summary>
        /// 停止完成
        /// </summary>
        private bool stopCompletion;
        public bool StopCompletion
        {
            get { return stopCompletion; }
            set
            {
                stopCompletion = value;
                OnPropertyChanged("StopCompletion");
            }
        }

        /// <summary>
        /// 速度运行
        /// </summary>
        private bool speedRunning;
        public bool SpeedRunning
        {
            get { return speedRunning; }
            set
            {
                speedRunning = value;
                OnPropertyChanged("SpeedRunning");
            }
        }

        /// <summary>
        /// 回零中
        /// </summary>
        private bool returnToZero;
        public bool ReturnToZero
        {
            get { return returnToZero; }
            set
            {
                returnToZero = value;
                OnPropertyChanged("ReturnToZero");
            }
        }

        /// <summary>
        /// 中转阀开定位完成
        /// </summary>
        private bool transferValveOpenCompletion;
        public bool TransferValveOpenCompletion
        {
            get { return transferValveOpenCompletion; }
            set
            {
                transferValveOpenCompletion = value;
                OnPropertyChanged("TransferValveOpenCompletion");
            }
        }

        /// <summary>
        /// 中转阀关定位完成
        /// </summary>
        private bool transferValveCloseCompletion;
        public bool TransferValveCloseCompletion
        {
            get { return transferValveCloseCompletion; }
            set
            {
                transferValveCloseCompletion = value;
                OnPropertyChanged("TransferValveCloseCompletion");
            }
        }

        /// <summary>
        /// 允许数据交换
        /// </summary>
        private bool allowsDataExchange;
        public bool AllowsDataExchange
        {
            get { return allowsDataExchange; }
            set
            {
                allowsDataExchange = value;
                OnPropertyChanged("AllowsDataExchange");
            }
        }

        /// <summary>
        /// 暂停数据交换
        /// </summary>
        private bool pauseDataExchange;
        public bool PauseDataExchange
        {
            get { return pauseDataExchange; }
            set
            {
                pauseDataExchange = value;
                OnPropertyChanged("PauseDataExchange");
            }
        }

        /// <summary>
        /// 缓存计数延迟完成
        /// </summary>
        private bool cacheCountDelayed;
        public bool CacheCountDelayed
        {
            get { return cacheCountDelayed; }
            set
            {
                cacheCountDelayed = value;
                OnPropertyChanged("CacheCountDelayed");
            }
        }

        /// <summary>
        /// 使能
        /// </summary>
        private bool enable;
        public bool Enable
        {
            get { return enable; }
            set
            {
                enable = value;
                OnPropertyChanged("Enable");
            }
        }

        /// <summary>
        /// 送瓶轮使能完成
        /// </summary>
        private bool bottleFeedingWheelEnableCompletion;
        public bool BottleFeedingWheelEnableCompletion
        {
            get { return bottleFeedingWheelEnableCompletion; }
            set
            {
                bottleFeedingWheelEnableCompletion = value;
                OnPropertyChanged("BottleFeedingWheelEnableCompletion");
            }
        }

        /// <summary>
        /// 送瓶轮停止完成
        /// </summary>
        private bool bottleFeedingWheelStopCompletion;
        public bool BottleFeedingWheelStopCompletion
        {
            get { return bottleFeedingWheelStopCompletion; }
            set
            {
                bottleFeedingWheelStopCompletion = value;
                OnPropertyChanged("BottleFeedingWheelStopCompletion");
            }
        }

        /// <summary>
        /// 速度模式运行速度
        /// </summary>
        private float speedModeRunningSpeed;
        public string SpeedModeRunningSpeed
        {
            get { return speedModeRunningSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = speedModeRunningSpeed;
                    if (PlcSettingMessageBus.pLCManagement.WriteSpeedModeRunningSpeed(result))
                    {
                        speedModeRunningSpeed = result;
                        FaultLog.RecordValueChangeMessage($"速度模式运行速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("SpeedModeRunningSpeed");
                }
            }
        }

        /// <summary>
        /// 点动速度
        /// </summary>
        private float jogSpeed;
        public string JogSpeed
        {
            get { return jogSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = jogSpeed;
                    if(PlcSettingMessageBus.pLCManagement.WriteJogSpeed(result))
                    {
                        jogSpeed = result;
                        FaultLog.RecordValueChangeMessage($"点动速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("JogSpeed");
                }
            }
        }

        /// <summary>
        /// 瓶装设定值
        /// </summary>
        private ushort bottValueSet;
        public ushort BottValueSet
        {
            get { return bottValueSet; }
            set
            {
                float oldValue = bottValueSet;
                if(PlcSettingMessageBus.pLCManagement.WriteBottValueSet(value))
                {
                    bottValueSet = value;
                    FaultLog.RecordValueChangeMessage($"瓶装设定值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottValueSet");
            }
        }

        /// <summary>
        /// 中转阀打开速度
        /// </summary>
        private float transferValveOpeningSpeed;
        public string TransferValveOpeningSpeed
        {
            get { return transferValveOpeningSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = transferValveOpeningSpeed;
                    if(PlcSettingMessageBus.pLCManagement.WriteTransferValveOpeningSpeed(result))
                    {
                        transferValveOpeningSpeed = result;
                        FaultLog.RecordValueChangeMessage($"中转阀打开速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("TransferValveOpeningSpeed");
                }
            }
        }

        /// <summary>
        /// 中转阀打开时间
        /// </summary>
        private UInt32 transferValveOpeningTime;
        public UInt32 TransferValveOpeningTime
        {
            get { return transferValveOpeningTime; }
            set
            {
                UInt32 oldValue = transferValveOpeningTime;
                if (PlcSettingMessageBus.pLCManagement.WriteTransferValveOpeningTime(value))
                {
                    transferValveOpeningTime = value;
                    FaultLog.RecordValueChangeMessage($"中转阀打开时间从{oldValue}修改为{value}");
                }
                OnPropertyChanged("TransferValveOpeningTime");
            }
        }

        /// <summary>
        /// 罐装减速值
        /// </summary>
        private ushort bottingDecelerationValue;
        public ushort BottingDecelerationValue
        {
            get { return bottingDecelerationValue; }
            set
            {
                ushort oldValue = bottingDecelerationValue;
                if (PlcSettingMessageBus.pLCManagement.WriteBottingDecelerationValue(value))
                {
                    bottingDecelerationValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingDecelerationValue");
            }
        }

        /// <summary>
        /// 缓存减速值
        /// </summary>
        private UInt16 cacheDecelerationValue { get; set;}
        public UInt16 CacheDecelerationValue
        {
            get { return cacheDecelerationValue; }
            set
            {
                UInt16 oldValue = cacheDecelerationValue;
                if (PlcSettingMessageBus.pLCManagement.WriteCacheDecelerationValue(value))
                {
                    cacheDecelerationValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheDecelerationValue");
            }
        }

        /// <summary>
        /// 缓存计数延迟时间
        /// </summary>
        private UInt32 cacheCountDelayTiming;
        public UInt32 CacheCountDelayTiming
        {
            get { return cacheCountDelayTiming; }
            set
            {
                UInt32 oldValue = cacheCountDelayTiming;
                if (PlcSettingMessageBus.pLCManagement.WriteCacheCountDelayTiming(value))
                {
                    cacheCountDelayTiming = value;
                    FaultLog.RecordValueChangeMessage($"缓存计数延迟时间从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheCountDelayTiming");
            }
        }


        /// <summary>
        /// 缓存停机值
        /// </summary>
        private ushort cacheShutdownValue;
        public ushort CacheShutdownValue
        {
            get { return cacheShutdownValue; }
            set
            {
                ushort oldValue = cacheShutdownValue;
                if (PlcSettingMessageBus.pLCManagement.WriteCacheShutdownValue(value))
                {
                    cacheShutdownValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存停机值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheShutdownValue");
            }
        }

        /// <summary>
        /// 罐装料筒震台高速值
        /// </summary>
        private ushort bottingMaterialCylinderVibrationTableHighSpeedValue;
        public ushort BottingMaterialCylinderVibrationTableHighSpeedValue
        {
            get { return bottingMaterialCylinderVibrationTableHighSpeedValue; }
            set
            {
                ushort oldValue = bottingMaterialCylinderVibrationTableHighSpeedValue;
                if (PlcSettingMessageBus.pLCManagement.WriteBottingMaterialCylinderVibrationTableHighSpeedValue(value))
                {
                    bottingMaterialCylinderVibrationTableHighSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装料筒震台高速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingMaterialCylinderVibrationTableHighSpeedValue");
            }
        }

        /// <summary>
        /// 罐装过滤震台高速值
        /// </summary>
        private ushort bottingFilterVibrationTableHighSpeedValue;
        public ushort BottingFilterVibrationTableHighSpeedValue
        {
            get { return bottingFilterVibrationTableHighSpeedValue; }
            set
            {
                ushort oldValue = bottingFilterVibrationTableHighSpeedValue;
                if (PlcSettingMessageBus.pLCManagement.WriteBottingFilterVibrationTableHighSpeedValue(value))
                {
                    bottingFilterVibrationTableHighSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装过滤震台高速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingFilterVibrationTableHighSpeedValue");
            }
        }

        /// <summary>
        /// 罐装计数震台高速值
        /// </summary>
        private ushort bottingCountVibrationTableHighSpeedValue;
        public ushort BottingCountVibrationTableHighSpeedValue
        {
            get { return bottingCountVibrationTableHighSpeedValue; }
            set
            {
                ushort oldValue = bottingCountVibrationTableHighSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteBottingCountVibrationTableHighSpeedValue(value))
                {
                    bottingCountVibrationTableHighSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装计数震台高速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingCountVibrationTableHighSpeedValue");
            }
        }

        /// <summary>
        /// 罐装料筒震台减速值
        /// </summary>
        private ushort bottingMaterialCylinderVibrationTableDecelerationSpeedValue;
        public ushort BottingMaterialCylinderVibrationTableDecelerationSpeedValue
        {
            get { return bottingMaterialCylinderVibrationTableDecelerationSpeedValue; }
            set
            {
                ushort oldValue = bottingMaterialCylinderVibrationTableDecelerationSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteBottingMaterialCylinderVibrationTableDecelerationSpeedValue(value))
                {
                    bottingMaterialCylinderVibrationTableDecelerationSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装料筒震台减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingMaterialCylinderVibrationTableDecelerationSpeedValue");
            }
        }

        /// <summary>
        /// 罐装过滤震台减速值
        /// </summary>
        private ushort bottingFilterVibrationTableDecelerationSpeedValue;
        public ushort BottingFilterVibrationTableDecelerationSpeedValue
        {
            get { return bottingFilterVibrationTableDecelerationSpeedValue; }
            set
            {
                ushort oldValue = bottingFilterVibrationTableDecelerationSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteBottingFilterVibrationTableDecelerationSpeedValue(value))
                {
                    bottingFilterVibrationTableDecelerationSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装过滤震台减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingFilterVibrationTableDecelerationSpeedValue");
            }
        }

        /// <summary>
        /// 罐装计数震台减速值
        /// </summary>
        private ushort bottingCountVibrationTableDecelerationSpeedValue;
        public ushort BottingCountVibrationTableDecelerationSpeedValue
        {
            get { return bottingCountVibrationTableDecelerationSpeedValue; }
            set
            {
                ushort oldValue = bottingCountVibrationTableDecelerationSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteBottingCountVibrationTableDecelerationSpeedValue(value))
                {
                    bottingCountVibrationTableDecelerationSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"罐装计数震台减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottingCountVibrationTableDecelerationSpeedValue");
            }
        }

        /// <summary>
        /// 缓存料筒震台高速值
        /// </summary>
        private ushort cacheMaterialCylinderVibrationTableHighSpeedValue;
        public ushort CacheMaterialCylinderVibrationTableHighSpeedValue
        {
            get { return cacheMaterialCylinderVibrationTableHighSpeedValue; }
            set
            {
                ushort oldValue = cacheMaterialCylinderVibrationTableHighSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteCacheMaterialCylinderVibrationTableHighSpeedValue(value))
                {
                    cacheMaterialCylinderVibrationTableHighSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存料筒震台高速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheMaterialCylinderVibrationTableHighSpeedValue");
            }
        }

        /// <summary>
        /// 缓存过滤震台高速值
        /// </summary>
        private ushort cacheFilterVibrationTableHighSpeedValue;
        public ushort CacheFilterVibrationTableHighSpeedValue
        {
            get { return cacheFilterVibrationTableHighSpeedValue; }
            set
            {
                ushort oldValue = cacheFilterVibrationTableHighSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteCacheFilterVibrationTableHighSpeedValue(value))
                {
                    cacheFilterVibrationTableHighSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存过滤震台高速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheFilterVibrationTableHighSpeedValue");
            }
        }

        /// <summary>
        /// 缓存计数震台高速值
        /// </summary>
        private ushort cacheCountVibrationTableHighSpeedValue;
        public ushort CacheCountVibrationTableHighSpeedValue
        {
            get { return cacheCountVibrationTableHighSpeedValue; }
            set
            {
                ushort oldValue = cacheCountVibrationTableHighSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteCacheCountVibrationTableHighSpeedValue(value))
                {
                    cacheCountVibrationTableHighSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存计数震台高速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheCountVibrationTableHighSpeedValue");
            }
        }

        /// <summary>
        /// 缓存料筒震台减速值
        /// </summary>
        private ushort cacheMaterialCylinderVibrationTableDecelerationSpeedValue;
        public ushort CacheMaterialCylinderVibrationTableDecelerationSpeedValue
        {
            get { return cacheMaterialCylinderVibrationTableDecelerationSpeedValue; }
            set
            {
                ushort oldValue = cacheMaterialCylinderVibrationTableDecelerationSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteCacheMaterialCylinderVibrationTableDecelerationSpeedValue(value))
                {
                    cacheMaterialCylinderVibrationTableDecelerationSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存料筒震台减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheMaterialCylinderVibrationTableDecelerationSpeedValue");
            }
        }

        /// <summary>
        /// 缓存过滤震台减速值
        /// </summary>
        private ushort cacheFilterVibrationTableDecelerationSpeedValue;
        public ushort CacheFilterVibrationTableDecelerationSpeedValue
        {
            get { return cacheFilterVibrationTableDecelerationSpeedValue; }
            set
            {
                ushort oldValue = cacheFilterVibrationTableDecelerationSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteCacheFilterVibrationTableDecelerationSpeedValue(value))
                {
                    cacheFilterVibrationTableDecelerationSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存过滤震台减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheFilterVibrationTableDecelerationSpeedValue");
            }
        }

        /// <summary>
        /// 缓存计数震台减速值
        /// </summary>
        private ushort cacheCountVibrationTableDecelerationSpeedValue;
        public ushort CacheCountVibrationTableDecelerationSpeedValue
        {
            get { return cacheCountVibrationTableDecelerationSpeedValue; }
            set
            {
                ushort oldValue = cacheCountVibrationTableDecelerationSpeedValue;
                if(PlcSettingMessageBus.pLCManagement.WriteCacheCountVibrationTableDecelerationSpeedValue(value))
                {
                    cacheCountVibrationTableDecelerationSpeedValue = value;
                    FaultLog.RecordValueChangeMessage($"缓存计数震台减速值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("CacheCountVibrationTableDecelerationSpeedValue");
            }
        }

        /// <summary>
        /// 阀门打开延时
        /// </summary>
        private UInt32 gateOpeningDelay;
        public UInt32 GateOpeningDelay
        {
            get { return gateOpeningDelay; }
            set
            {
                UInt32 oldValue = gateOpeningDelay;
                if(PlcSettingMessageBus.pLCManagement.WriteGateOpeningDelay(value))
                {
                    gateOpeningDelay = value;
                    FaultLog.RecordValueChangeMessage($"阀门打开延时从{oldValue}修改为{value}");
                }
                OnPropertyChanged("GateOpeningDelay");
            }
        }

        /// <summary>
        /// 回零偏移值
        /// </summary>
        private float returnToZeroOffsetValue;
        public string ReturnToZeroOffsetValue
        {
            get { return returnToZeroOffsetValue.ToString("F2"); }
            set
            {
                if (value == "-")
                {
                    return;
                }
                if (float.TryParse(value, out float result))
                {
                    float oldValue = returnToZeroOffsetValue;
                    if (PlcSettingMessageBus.pLCManagement.WriteReturnToZeroOffsetValue(result))
                    {
                        returnToZeroOffsetValue = result;
                        FaultLog.RecordValueChangeMessage($"回零偏移值从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("ReturnToZeroOffsetValue");
                }
            }
        }

        /// <summary>
        /// 回零偏移速度
        /// </summary>
        private float returnToZeroOffsetSpeed;
        public string ReturnToZeroOffsetSpeed
        {
            get { return returnToZeroOffsetSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = returnToZeroOffsetSpeed;
                    if (PlcSettingMessageBus.pLCManagement.WriteReturnToZeroOffsetSpeed(result))
                    {
                        returnToZeroOffsetSpeed = result;
                        FaultLog.RecordValueChangeMessage($"回零偏移速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("ReturnToZeroOffsetSpeed");
                }
            }
        }

        /// <summary>
        /// 中转阀关闭速度
        /// </summary>
        private float transferValveClosingSpeed;
        public string TransferValveClosingSpeed
        {
            get { return transferValveClosingSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = transferValveClosingSpeed;
                    if(PlcSettingMessageBus.pLCManagement.WriteTransferValveClosingSpeed(result))
                    {
                        transferValveClosingSpeed = result;
                        FaultLog.RecordValueChangeMessage($"中转阀关闭速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("TransferValveClosingSpeed");
                }
            }
        }

        /// <summary>
        /// 中转阀开位置
        /// </summary>
        private float transferValveOpenPosition;
        public string TransferValveOpenPosition
        {
            get { return transferValveOpenPosition.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = transferValveOpenPosition;
                    if(PlcSettingMessageBus.pLCManagement.WriteTransferValveOpenPosition(result))
                    {
                        transferValveOpenPosition = result;
                        FaultLog.RecordValueChangeMessage($"中转阀开位置从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("TransferValveOpenPosition");
                }
            }
        }

        /// <summary>
        /// 中转阀关位置
        /// </summary>
        private float transferValveClosePosition;
        public string TransferValveClosePosition
        {
            get { return transferValveClosePosition.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = transferValveClosePosition;
                    if(PlcSettingMessageBus.pLCManagement.WriteTransferValveClosePosition(result))
                    {
                        transferValveClosePosition = result;
                        FaultLog.RecordValueChangeMessage($"中转阀关位置从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("TransferValveClosePosition");
                }
            }
        }

        /// <summary>
        /// 气阀开延时
        /// </summary>
        private UInt32 airValveOpeningDelay;
        public UInt32 AirValveOpeningDelay
        {
            get { return airValveOpeningDelay; }
            set
            {
                UInt32 oldValue = airValveOpeningDelay;
                if(PlcSettingMessageBus.pLCManagement.WriteAirValveOpeningDelay(value))
                {
                    airValveOpeningDelay = value;
                    FaultLog.RecordValueChangeMessage($"气阀开延时从{oldValue}修改为{value}");
                }
                OnPropertyChanged("AirValveOpeningDelay");
            }
        }

        /// <summary>
        /// 装瓶停机值
        /// </summary>
        private UInt16 bottlingShutdownValue;
        public UInt16 BottlingShutdownValue
        {
            get { return bottlingShutdownValue; }
            set
            {
                UInt16 oldValue = bottlingShutdownValue;
                if(PlcSettingMessageBus.pLCManagement.WriteBottlingShutdownValue(value))
                {
                    bottlingShutdownValue = value;
                    FaultLog.RecordValueChangeMessage($"装瓶停机值从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottlingShutdownValue");
            }
        }

        /// <summary>
        /// 装瓶停机时间
        /// </summary>
        private UInt32 bottlingShutdownTime;
        public UInt32 BottlingShutdownTime
        {
            get { return bottlingShutdownTime; }
            set
            {
                UInt32 oldValue = bottlingShutdownTime;
                if(PlcSettingMessageBus.pLCManagement.WriteBottlingShutdownTime(value))
                {
                    bottlingShutdownTime = value;
                    FaultLog.RecordValueChangeMessage($"装瓶停机时间从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottlingShutdownTime");
            }
        }

        /// <summary>
        /// 送瓶轮运行速度
        /// </summary>
        private float bottleFeedingWheelRunningSpeed;
        public string BottleFeedingWheelRunningSpeed
        {
            get { return bottleFeedingWheelRunningSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = bottleFeedingWheelRunningSpeed;
                    if (PlcSettingMessageBus.pLCManagement.WriteBottleFeedingWheelRunningSpeed(result))
                    {
                        bottleFeedingWheelRunningSpeed = result;
                        FaultLog.RecordValueChangeMessage($"送瓶轮运行速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("BottleFeedingWheelRunningSpeed");
                }
            }
        }

        /// <summary>
        /// 送瓶轮点动速度
        /// </summary>
        private float bottleFeedingWheelJogRunningSpeed;
        public string BottleFeedingWheelJogRunningSpeed
        {
            get { return bottleFeedingWheelJogRunningSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = bottleFeedingWheelJogRunningSpeed;
                    if (PlcSettingMessageBus.pLCManagement.WriteBottleFeedingWheelJogRunningSpeed(result))
                    {
                        bottleFeedingWheelJogRunningSpeed = result;
                        FaultLog.RecordValueChangeMessage($"送瓶轮点动速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("BottleFeedingWheelJogRunningSpeed");
                }
            }
        }

        /// <summary>
        /// 送瓶轮回零偏移值
        /// </summary>
        private float bottleFeedingWheelReturnToZeroOffsetValue;
        public string BottleFeedingWheelReturnToZeroOffsetValue
        {
            get { return bottleFeedingWheelReturnToZeroOffsetValue.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = bottleFeedingWheelReturnToZeroOffsetValue;
                    if (PlcSettingMessageBus.pLCManagement.WriteBottleFeedingWheelReturnToZeroOffsetValue(result))
                    {
                        bottleFeedingWheelReturnToZeroOffsetValue = result;
                        FaultLog.RecordValueChangeMessage($"送瓶轮回零偏移值从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("BottleFeedingWheelReturnToZeroOffsetValue");
                }
            }
        }

        /// <summary>
        /// 送瓶轮回零速度
        /// </summary>
        private float bottleFeedingWheelReturnToZeroSpeed;
        public string BottleFeedingWheelReturnToZeroSpeed
        {
            get { return bottleFeedingWheelReturnToZeroSpeed.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = bottleFeedingWheelReturnToZeroSpeed;
                    if (PlcSettingMessageBus.pLCManagement.WriteBottleFeedingWheelReturnToZeroSpeed(result))
                    {
                        bottleFeedingWheelReturnToZeroSpeed = result;
                        FaultLog.RecordValueChangeMessage($"送瓶轮回零速度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("BottleFeedingWheelReturnToZeroSpeed");
                }
            }
        }

        /// <summary>
        /// 送瓶轮定位长度
        /// </summary>
        private float bottleFeedingWheelPositionLength;
        public string BottleFeedingWheelPositionLength
        {
            get { return bottleFeedingWheelPositionLength.ToString("F2"); }
            set
            {
                if (float.TryParse(value, out float result))
                {
                    float oldValue = bottleFeedingWheelPositionLength;
                    if (PlcSettingMessageBus.pLCManagement.WriteBottleFeedingWheelPositionLength(result))
                    {
                        bottleFeedingWheelPositionLength = result;
                        FaultLog.RecordValueChangeMessage($"送瓶轮定位长度从{oldValue}修改为{result}");
                    }
                    OnPropertyChanged("BottleFeedingWheelPositionLength");
                }
            }
        }

        /// <summary>
        /// 送瓶轮暂停时间
        /// </summary>
        private UInt32 bottleFeedingWheelPauseTime;
        public UInt32 BottleFeedingWheelPauseTime
        {
            get { return bottleFeedingWheelPauseTime; }
            set
            {
                UInt32 oldValue = bottleFeedingWheelPauseTime;
                if (PlcSettingMessageBus.pLCManagement.WriteBottleFeedingWheelPauseTime(value))
                {
                    bottleFeedingWheelPauseTime = value;
                    FaultLog.RecordValueChangeMessage($"送瓶轮暂停时间从{oldValue}修改为{value}");
                }
                OnPropertyChanged("BottleFeedingWheelPauseTime");
            }
        }

        /// <summary>
        /// 下料延时
        /// </summary>
        private UInt32 delayBlanking;
        public UInt32 DelayBlanking
        {
            get { return delayBlanking; }
            set
            {
                UInt32 oldValue = delayBlanking;
                if (PlcSettingMessageBus.pLCManagement.WriteDelayBlanking(value))
                {
                    delayBlanking = value;
                    FaultLog.RecordValueChangeMessage($"下料延时从{oldValue}修改为{value}");
                }
                OnPropertyChanged("DelayBlanking");
            }
        }

        //数据绑定核心实现
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}