Shaker/ShakerControl/ViewModel/AnalogDataViewModel.cs

using Shaker.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OxyPlot;
using System.Collections.ObjectModel;
using ShakerControl.Tools;
using System.Runtime.CompilerServices;
using System.Diagnostics;

namespace ShakerControl.ViewModel
{
    public class EigenwertViewModel:ViewModelBase<IModel>
    {
        private float max;
        private float min;
        private float avg;
        private float rms;

        public float Max { get => max; set =>UpdateProperty(ref max , value); }
        public float Min { get => min; set =>UpdateProperty(ref min, value); }
        public float Avg { get => avg; set =>UpdateProperty(ref avg , value); }
        public float Rms { get => rms; set =>UpdateProperty(ref rms , value); }
        public unsafe void CalcEigenwert(ref float value,uint len)
        {            float low = float.MaxValue;
            float upper = float.MinValue;
            float* ptr = (float*)Unsafe.AsPointer<float>(ref value);
            for(uint i=0;i<len;i++)
            {
                low = low < ptr[i] ? low : ptr[i];
                upper = upper > ptr[i] ? upper : ptr[i];
            }
            Max = upper;
            Min = low;
            if(len==0)
            {
                Max = 0;
                Min = 0;
                Avg = 0;
                Rms = 0;
                return;
            }
            Avg = MainWindowViewModel.Default.Calc.Sum.Sum(ref value, len)/len;
            Rms = MainWindowViewModel.Default.Calc.Sum.Rms(ref value, len);

        }
    }
    public class AnalogDataViewModel : ViewModelBase<IModel>
    {
        public const string DATACHANGEDEVENT = "DataChangedEvent";
        private object locker = new object();
        private bool isSaveData = false;
        private ShakerControl.ShakerFile.IShakerFile file = new ShakerFile.V1_0.ShakerFile();

        public static AnalogDataViewModel Default { get; } = new AnalogDataViewModel();
        public ObservableCollection<EigenwertViewModel> Eigenwerts { get; } = new ObservableCollection<EigenwertViewModel>();
        static AnalogDataViewModel()
        {

        }
        private AnalogDataViewModel()
        {
        }
        public bool IsSaveData
        {
            get => isSaveData;
            set
            {
                if (value == isSaveData) return;
                UpdateProperty(ref isSaveData, value);
                if(value)
                {
                    if (file.IsOpen) file.Close();
                    file.CreateFile($"{ShakerControlConfigViewModel.Default.DataDirectory}{DateTime.Now:yyyyMMdd-HHmmSS}.sdt");
                    file.WriteInfo(new ShakerFile.ShakerInfo()
                    {
                        AccelerationSensitivity = MainWindowViewModel.Default.ShakerSensitivity.Acceleration,
                        ChannelCount = MainWindowViewModel.Default.ShakerConfig.ChannelCount,
                        DisplacementSensitivity = MainWindowViewModel.Default.ShakerSensitivity.Displacement,
                        FPGAClock = MainWindowViewModel.Default.ShakerConfig.FPGAClock,
                        FrameCount = 0,
                        InitialLocation = MainWindowViewModel.Default.ShakerConfig.InitialLocation,
                        IsOutSignal = MainWindowViewModel.Default.ShakerControl.OutSignal,
                        MaxAcceleration = MainWindowViewModel.Default.ShakerSecurity.MaxAcceleration,
                        MaxDisplacement = MainWindowViewModel.Default.ShakerSecurity.MaxDisplacement,
                        MaxDriver = MainWindowViewModel.Default.ShakerSecurity.MaxDriver,
                        MaxFrequency = MainWindowViewModel.Default.ShakerConfig.MaxFrequency,
                        MaxJitterAcceleration = MainWindowViewModel.Default.ShakerSecurity.MaxJitterAcceleration,
                        MaxJitterDisplacement = MainWindowViewModel.Default.ShakerSecurity.MaxJitterDisplacement,
                        MaxOutInput = MainWindowViewModel.Default.ShakerSecurity.MaxOutInput,
                        MaxVelocity = MainWindowViewModel.Default.ShakerSecurity.MaxVelocity,
                        MinFrequency = MainWindowViewModel.Default.ShakerConfig.MinFrequency,
                        SampleRate = MainWindowViewModel.Default.ShakerConfig.SampleRate,
                        TestType =MainWindowViewModel.Default.TestType,
                    },new ShakerFile.ShakerStringInfo()
                    {
                        ChannelNames =string.Join(',', MainWindowViewModel.Default.ShakerConfig.ChannelNames),
                        ShakerName = DeviceMangerViewModel.Default.CurrentDevice.Name,
                        ShakerSN = DeviceMangerViewModel.Default.CurrentDevice.SN,
                        TestConfig = MainWindowViewModel.Default.SweepFreqConfig.Model.GetBytes(),
                    });
                }
                else
                {
                    if (file.IsOpen) file.Close();
                }
            }
        }
        public ObservableCollection<List<DataPoint>> DataPoints { get; } = new ObservableCollection<List<DataPoint>>();
        public override void Init()
        {
            base.Init();
            lock (locker)
            {
                DataPoints.Clear();
                Eigenwerts.Clear();
                for (int i = 0; i < MainWindowViewModel.Default.ShakerConfig.ChannelCount; i++)
                {
                    DataPoints.Add(new List<DataPoint>());
                    Eigenwerts.Add(new EigenwertViewModel());
                }
            }
            float[,] data = new float[MainWindowViewModel.Default.ShakerConfig.ChannelCount, MainWindowViewModel.Default.ShakerConfig.SampleRate];
            Random random = new Random();
            for(int i=0;i<MainWindowViewModel.Default.ShakerConfig.ChannelCount;i++)
            {
                float ampt = random.NextSingle() * 15 + 2;
                float freq = random.NextSingle() * 10 + 1;
                for(int j=0;j<MainWindowViewModel.Default.ShakerConfig.SampleRate;j++)
                {
                    data[i, j] = MathF.Sin(MathF.PI * ((float)j / MainWindowViewModel.Default.ShakerConfig.SampleRate) * freq * 360 / 180f) * ampt + random.NextSingle()*2;
                }
            }
            UpdateData(data);
        }
        public void UpdateData(float[,] data)
        {
            if (data == null) return;
            if (data.GetLength(1) != MainWindowViewModel.Default.ShakerConfig.SampleRate || data.GetLength(0) != MainWindowViewModel.Default.ShakerConfig.ChannelCount) return;

            lock (locker)
            {
                List<List<DataPoint>> points = Enumerable.Range(0, (int)MainWindowViewModel.Default.ShakerConfig.ChannelCount).Select(x => new List<DataPoint>()).ToList();

                for (int j = 0; j < MainWindowViewModel.Default.ShakerConfig.SampleRate; j++)
                {
                    double t = (double)j / MainWindowViewModel.Default.ShakerConfig.SampleRate;
                    for (int i = 0; i < MainWindowViewModel.Default.ShakerConfig.ChannelCount; i++)
                    {
                        points[i].Add(new DataPoint(t, data[i, j]));
                    }
                }
                for (int i = 0; i < MainWindowViewModel.Default.ShakerConfig.ChannelCount; i++)
                {
                    Eigenwerts[i].CalcEigenwert(ref data[i, 0], MainWindowViewModel.Default.ShakerConfig.SampleRate);
                    DataPoints[i] = points[i];
                }
                if(IsSaveData && file.IsOpen)
                {
                    file.WriteData(ref data[0, 0], data.Length);
                }
            }
            GetEvent(DATACHANGEDEVENT).Publish(this, null);
        }
    }
}