Shaker/Avalonia/ShakerApp/ViewModels/ShakerStatus/ShakerStatusViewModel.cs

using Avalonia.Collections;
using Avalonia.Controls;
using Avalonia.Controls.Documents;
using CommunityToolkit.Mvvm.Input;
using Newtonsoft.Json.Linq;
using OxyPlot;
using OxyPlot.Axes;
using OxyPlot.Series;
using Shaker.Models;
using Shaker.Models.Tools;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace ShakerApp.ViewModels
{
    public sealed class ShakerStatusViewModel:ViewModelBase<ShakerStatusModel>
    {
        private float givenDisplacement;
        private float measuredDisplacement;
        private float acceleration;
        private float valveDrive;
        private float outSignal;

        public float GivenDisplacement { get => givenDisplacement; set => SetProperty(ref givenDisplacement, value); }
        public float MeasuredDisplacement { get => measuredDisplacement; set => SetProperty(ref measuredDisplacement, value); }
        public float Acceleration { get => acceleration; set => SetProperty(ref acceleration, value); }
        public float ValveDrive { get => valveDrive; set => SetProperty(ref valveDrive, value); }
        public float OutSignal { get => outSignal; set => SetProperty(ref outSignal, value); }
        public ViewModels.AnalogSignalPreviewViewModel DisplacementSignal { get; } = new AnalogSignalPreviewViewModel(AnalogType.Displacement)
        {
            CanChangedAnalog = false,
        };
        public AnalogSignalPreviewViewModel ValveDriveSignal { get; } = new AnalogSignalPreviewViewModel(AnalogType.Driver)
        {
            CanChangedAnalog = false,
        };
        private float workPosition = 0;
        private bool valvePower = false;

        [PropertyAssociation(nameof(ShakerStatusModel.RTStatus))]
        public bool PowerIsEnabled => RTStatus == RTStatus.WaitValvePower;
        [PropertyAssociation(nameof(ShakerStatusModel.RTStatus))]
        public bool RiseTableEnabled => RTStatus == RTStatus.WaitRiseTable;
        [PropertyAssociation(nameof(ShakerStatusModel.RTStatus))]
        public bool DropTableEnabled => RTStatus == RTStatus.WaitSignalGen;
        [PropertyAssociation(nameof(ShakerStatusModel.RTStatus))]
        public bool SignalStartEnabled => RTStatus == RTStatus.WaitSignalGen;
        [PropertyAssociation(nameof(ShakerStatusModel.RTStatus))]
        public bool SignalStopEnabled => RTStatus == RTStatus.SignalGen;
        [PropertyAssociation(nameof(ShakerStatusModel.ErrorCode))]
        public bool RestEnabeld => ErrorCode!=0;

        [PropertyAssociation(nameof(ShakerStatusModel.RTStatus))]
        public RTStatus RTStatus { get => Model.RTStatus; set => SetProperty(ref Model.RTStatus, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.Start))]
        public bool Start { get => Model.Start; set => SetProperty(ref Model.Start, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.IsTableRised))]
        public bool IsTableRised { get => Model.IsTableRised; set => SetProperty(ref Model.IsTableRised, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.IsTableDroped))]
        public bool IsTableDroped { get => Model.IsTableDroped; set => SetProperty(ref Model.IsTableDroped, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.IsFaultRelease))]
        public bool IsFaultRelease { get => Model.IsFaultRelease; set => SetProperty(ref Model.IsFaultRelease, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.RiseCount))]
        public uint RiseCount { get => Model.RiseCount; set => SetProperty(ref Model.RiseCount, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.SignalGenStopCount))]
        public uint SignalGenStopCount { get => Model.SignalGenStopCount; set => SetProperty(ref Model.SignalGenStopCount, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.EmergencyStopCount))]
        public uint EmergencyStopCount { get => Model.EmergencyStopCount; set => SetProperty(ref Model.EmergencyStopCount, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.IsSignalGenStoped))]
        public bool IsSignalGenStoped { get => Model.IsSignalGenStoped; set => SetProperty(ref Model.IsSignalGenStoped, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.ZeroChangedCount))]
        public uint ZeroChangedCount { get => Model.ZeroChangedCount; set => SetProperty(ref Model.ZeroChangedCount, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.WarnCode))]
        public ushort WarnCode { get => Model.WarnCode; set => SetProperty(ref Model.WarnCode, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.ClosedValve))]
        public bool ClosedValve { get => Model.ClosedValve; set => SetProperty(ref Model.ClosedValve, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.DropCount))]
        public uint DropCount { get => Model.DropCount; set => SetProperty(ref Model.DropCount, value); }
        [PropertyAssociation(nameof(ShakerStatusModel.ErrorCode))]
        public ushort ErrorCode { get => Model.ErrorCode; set => SetProperty(ref Model.ErrorCode, value); }
        public float WorkPosition 
        { 
            get => workPosition;
            set
            {
                SetProperty(ref workPosition, value);
                CommunicationViewModel.Intance.LocalCommunication?.GetEvent(Topic.ZEROCHANGE).Publish(this, null, value);
            }
        }
        private ShakerStatusViewModel()
        {
            Content = typeof(Views.ShakerStatusControlView);
            ButtonVisibily = false;
            GetEvent<AllConfig>().Subscrip((sender, args) =>
            {
                valvePower = false;
                UpDateModel(args.Data.ShakerStatus);
                if(CommunicationViewModel.Intance.ServiceIsStart)
                {
                    CommunicationViewModel.Intance.ServiceCommunication.GetEvent<ShakerStatusModel>().Publish(this, args.Data.ShakerStatus);
                }
                CommunicationViewModel.Intance.LocalCommunication?.GetEvent<ShakerStatusModel>()?.Subscrip((sender, args) =>
                {
                    UpDateModel(args.Data);
                    CommunicationViewModel.Intance.ServiceCommunication?.GetEvent<ShakerStatusModel>()?.Publish(this, args.Data);
                });
            });
            GetEvent(Topic.DATA).Subscrip((_, _) =>
            {
                var data = ShakerDataViewModel.Instance.GetAnalogData(AnalogType.Displacement);
                GivenDisplacement = data[0].Item2.RMS;
                MeasuredDisplacement = data[1].Item2.RMS;
                data = ShakerDataViewModel.Instance.GetAnalogData(AnalogType.Driver);
                ValveDrive = data[0].Item2.RMS;
                data = ShakerDataViewModel.Instance.GetAnalogData(AnalogType.OutSignal);
                OutSignal = data[0].Item2.RMS;
                data = ShakerDataViewModel.Instance.GetAnalogData(AnalogType.Acceleration);
                Acceleration = data[0].Item2.RMS;
            });
        }
        protected override void RefreshUI(List<string> changedNames)
        {
            base.RefreshUI(changedNames);
            if(changedNames.Contains(nameof(RTStatus)))
            {
                OnPropertyChanged(nameof(PowerIsEnabled));
                OnPropertyChanged(nameof(RiseTableEnabled));
                OnPropertyChanged(nameof(DropTableEnabled));
                OnPropertyChanged(nameof(SignalStartEnabled));
                OnPropertyChanged(nameof(SignalStopEnabled));
                OnPropertyChanged(nameof(RestEnabeld));
            }
        }
        public override bool CanCancel => false;
        static ShakerStatusViewModel()
        {

        }
        public ICommand RiseTableCommand => new RelayCommand(RiseTableCommandExecute);
        private void RiseTableCommandExecute()
        {
            CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.RISETABLE).Publish(this, null);
        }
        public ICommand DropTableCommand => new RelayCommand(DropTableCommandExecute);
        private void DropTableCommandExecute()
        {
            CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.DROPTABLE).Publish(this, null);
        }
        public ICommand ResetCommand => new RelayCommand(Reset);
        private void Reset()
        {
            CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.RESETERROR).Publish(this, null);
        }

        public ICommand EmergencyStopCommand => new RelayCommand(EmergencyStopCommandExecute);
        private void EmergencyStopCommandExecute()
        {

        }

        public ICommand StartCommand=> new RelayCommand(StartCommandExecute);
        private void StartCommandExecute()
        {
            CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.STARTSIGNALGEN).Publish(this, null);
        }
        public ICommand StopCommand => new RelayCommand(StopCommandExecute);
        private void StopCommandExecute()
        {
            CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.STOPSIGNALGEN).Publish(this, null);
        }

        public static ShakerStatusViewModel Instance { get; } = new ShakerStatusViewModel();

       
        public bool ValvePower 
        { 
            get => valvePower;
            set
            {
                //if (valvePower == value) return;
                SetProperty(ref valvePower, value);
                CommunicationViewModel.Intance.LocalCommunication.GetEvent(Topic.VALVEPOWER).Publish(this, null, value);
            }
        }
    }

}