Пример #1
0
        private async void TraceSamples()
        {
            Thread.CurrentThread.Priority = ThreadPriority.Highest;
            var    modValue       = 1000;
            var    samplesToClear = 0;
            double sampledTime    = 0;
            double sampleNumber   = 0;
            var    updateRanges   = 0;
            var    m = 10;

            while (true)
            {
                //var watch = System.Diagnostics.Stopwatch.StartNew();

                if (token.IsCancellationRequested == true)
                {
                    await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                    {
                        SampleMinimumX = 0;
                        SampleMaximumX = 1;
                        VSenseCollection.Clear();
                        ISenseCollection.Clear();
                        IRefCollection.Clear();
                        TemperatureFourCollection.Clear();
                        TemperatureThreeCollection.Clear();
                        TemperatureTwoCollection.Clear();
                        TemperatureOneCollection.Clear();
                    }));

                    break;
                }

                var numberOfAvailableSamples = traceModel.GetNumberOfAvailableSamples().Result;
                if (numberOfAvailableSamples.succesfulResponse)
                {
                    var availableSamples     = Helper.GetIntFromBigEndian(numberOfAvailableSamples.response);
                    var firstAvailableSample = traceModel.GetFirstAvailableSampleIndex().Result;
                    if (firstAvailableSample.succesfulResponse)
                    {
                        var i = Helper.GetIntFromBigEndian(firstAvailableSample.response) % modValue;

                        //for (var t = 0; t < availableSamples; t+=m)
                        //{
                        //    if (token.IsCancellationRequested == true)
                        //    {
                        //        break;
                        //    }
                        //Console.WriteLine($"available samples: {availableSamples}");

                        var updateNumber = Math.Max(refresh, availableSamples);
                        for (var j = 0; j < availableSamples; j++)
                        {
                            sampledTime = sampleNumber / (double)selectedResolution;

                            if (updateRanges >= refresh)
                            {
                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    SampleMaximumX = sampledTime + refreshTime;
                                    SampleMinimumX = sampledTime;
                                }));

                                updateRanges = 0;
                            }
                            // Update chart
                            var vSense = traceModel.ReadVsenseSamples(i).Result;
                            if (vSense.succesfulResponse)
                            {
                                var vSenseDataValue = Helper.GetFloatFromBigEndian(vSense.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    VSenseCollection.SurpressedAdd(new DataPoint(sampledTime, vSenseDataValue), refresh);

                                    if (sampleNumber > refresh)
                                    {
                                        VSenseCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }

                            var iSense = traceModel.ReadIsenseSamples(i).Result;
                            if (iSense.succesfulResponse)
                            {
                                var iSenseDataValue = Helper.GetFloatFromBigEndian(iSense.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    ISenseCollection.SurpressedAdd(new DataPoint(sampledTime, iSenseDataValue), refresh);

                                    if (sampleNumber > refresh)
                                    {
                                        ISenseCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }

                            var iRef = traceModel.ReadIrefSamples(i).Result;
                            if (iRef.succesfulResponse)
                            {
                                var iRefDataValue = Helper.GetFloatFromBigEndian(iRef.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    IRefCollection.SurpressedAdd(new DataPoint(sampledTime, iRefDataValue), refresh);

                                    if (sampleNumber > refresh)
                                    {
                                        IRefCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }

                            var temperatureOne = traceModel.ReadTempOneSamples(i).Result;
                            if (temperatureOne.succesfulResponse)
                            {
                                var temperatureOneDataValue = Helper.GetFloatFromBigEndian(temperatureOne.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    TemperatureOneCollection.SurpressedAdd(new DataPoint(sampledTime, temperatureOneDataValue), refresh);

                                    if (sampleNumber > refresh)
                                    {
                                        TemperatureOneCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }

                            var temperatureTwo = traceModel.ReadTempTwoSamples(i).Result;
                            if (temperatureTwo.succesfulResponse)
                            {
                                var temperatureTwoDataValue = Helper.GetFloatFromBigEndian(temperatureTwo.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    TemperatureTwoCollection.SurpressedAdd(new DataPoint(sampledTime, temperatureTwoDataValue), refresh);

                                    if (sampleNumber > refresh)
                                    {
                                        TemperatureTwoCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }

                            var temperatureThree = traceModel.ReadTempThreeSamples(i).Result;
                            if (temperatureThree.succesfulResponse)
                            {
                                var temperatureThreeDataValue = Helper.GetFloatFromBigEndian(temperatureThree.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    TemperatureThreeCollection.SurpressedAdd(new DataPoint(sampledTime, temperatureThreeDataValue), refresh);

                                    if (sampleNumber > refresh)
                                    {
                                        TemperatureThreeCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }

                            var temperatureFour = traceModel.ReadTempFourSamples(i).Result;
                            if (temperatureFour.succesfulResponse)
                            {
                                var temperatureFourDataValue = Helper.GetFloatFromBigEndian(temperatureFour.response);

                                await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                                {
                                    TemperatureFourCollection.SurpressedAdd(new DataPoint(sampledTime, temperatureFourDataValue), refresh);
                                    if (sampleNumber > refresh)
                                    {
                                        TemperatureFourCollection.SurpressedRemoveAt(0);
                                    }
                                }));
                            }
                            // update what to read next
                            i = (i + 1) % modValue;
                            samplesToClear++;
                            sampleNumber++;
                            updateRanges++;



                            //}
                        }

                        var removeSamples = traceModel.SetReadSamples(samplesToClear).Result;
                        if (removeSamples.succesfulResponse)
                        {
                            var foo = traceModel.GetNumberOfAvailableSamples().Result;

                            var foo2 = Helper.GetIntFromBigEndian(foo.response);
                            if (foo2 > 20)
                            {
                                traceModel.SetReadSamples(foo2).Wait();
                                var foo3 = traceModel.GetNumberOfAvailableSamples().Result;
                                //var foo4 = Helper.GetIntFromBigEndian(foo3.response);
                                //Console.WriteLine($"!!!available samples AFTER CLEAR: {foo4}");
                            }

                            //Console.WriteLine($"Cleared: {samplesToClear} samples");
                            samplesToClear = 0;
                        }

                        //watch.Stop();
                        //var elapsedMs = watch.ElapsedMilliseconds;
                        //Console.WriteLine($"Time: {elapsedMs} ****");
                    }
                }
            }
        }