private void UpdateSeries(IDictionary <string, float> sensors)
        {
            if (!m_startTime.HasValue)
            {
                m_startTime = DateTime.Now;
            }

            var now      = DateTime.Now;
            var xValue   = m_prevReceiveTime.HasValue ? m_xPrevValue + (now - m_prevReceiveTime.Value).TotalSeconds : 0;
            var xAxisMax = xValue + 1;

            m_prevReceiveTime = now;
            if (ShowPuffsBoundariesCheckBox.Checked)
            {
                var isFiring = sensors[SensorsKeys.IsFiring] > 0;
                if (isFiring && !m_isFiring)
                {
                    CreateFiringAnnotation(xValue, true);
                }
                if (!isFiring && m_isFiring && m_xPrevValue > 0)
                {
                    CreateFiringAnnotation(m_xPrevValue, false);
                }
                m_isFiring = isFiring;
            }
            m_xPrevValue = xValue;

            var isCelcius = sensors[SensorsKeys.IsCelcius] > 0;

            m_seriesData[SensorsKeys.Temperature].SetLastValueFormat(isCelcius ? "{0} °C" : "{0} °F");
            m_seriesData[SensorsKeys.TemperatureSet].SetLastValueFormat(isCelcius ? "{0} °C" : "{0} °F");

            foreach (var kvp in m_seriesData)
            {
                var sensorName        = kvp.Key;
                var data              = kvp.Value;
                var readings          = sensors[sensorName];
                var interpolatedValue = Interpolate(readings, data.InterpolationLimits);

                var point = new DataPoint();
                if (Math.Abs(readings) > 0.001)
                {
                    var roundedValue = (float)Math.Round(readings, 3);
                    point.XValue      = xValue;
                    point.YValues     = new double[] { interpolatedValue };
                    point.Tag         = point.Label = roundedValue.ToString(CultureInfo.InvariantCulture);
                    point.MarkerSize  = ChartSelectedMarkerSize;
                    point.MarkerStyle = MarkerStyle.Circle;
                    data.SetLastValue(roundedValue);
                }
                else
                {
                    point.IsEmpty = true;
                    data.SetLastValue(null);
                }
                data.Seires.Points.Add(point);
            }

            if (m_isRecording)
            {
                m_lineBuilder.Clear();
                // Trace time
                m_lineBuilder.Append(xValue.ToString(CultureInfo.InvariantCulture));
                m_lineBuilder.Append(",");
                // Other values
                var values = m_seriesData.Values
                             .Where(x => x.CheckBox.Checked)
                             .Select(x => x.LastValue.HasValue ? x.LastValue.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);

                m_lineBuilder.Append(string.Join(",", values));
                var ex = Safe.Execute(() =>
                {
                    m_fileWriter.WriteLine(m_lineBuilder.ToString());
                    m_fileWriter.Flush();
                });
                if (ex != null)
                {
                    InfoBox.Show("Recording was stopped because of error:\n" + ex.Message);
                    RecordButton.PerformClick();
                }
            }

            while (MainChart.Annotations.Count > 1 && MainChart.Annotations.Count - 1 > ChartMaxFiringAnnotationsCount)
            {
                MainChart.Annotations.RemoveAt(1);
            }

            foreach (var series in MainChart.Series)
            {
                while (series.Points.Count > ChartMaxDataPointsCount)
                {
                    series.Points.RemoveAt(0);
                }
                MainChart.ChartAreas[0].AxisX.Minimum = MainChart.Series[0].Points[0].XValue - 1;

                if (series.Points.Count > 0)
                {
                    var lastPoint = series.Points[series.Points.Count - 1];
                    if (lastPoint.IsEmpty)
                    {
                        continue;
                    }

                    if (series.Points.Count > 1)
                    {
                        var preLastPoint = series.Points[series.Points.Count - 2];
                        preLastPoint.Label      = null;
                        preLastPoint.MarkerSize = ChartMarkerSize;
                    }
                }
            }

            UpdateHorizontalScrollAndAxisXMax(xAxisMax);
            if (IsTracking)
            {
                if (MainChartHorizontalScrollBar.Value == MainChartHorizontalScrollBar.Maximum)
                {
                    // Force zoom.
                    ScrollChartHorizontally(true);
                }
                else if (!m_isScrollingHorizontally)
                {
                    // Zoom applies automatically when changing scrollbar value.
                    MainChartHorizontalScrollBar.Value = MainChartHorizontalScrollBar.Maximum;
                }
            }
        }
Пример #2
0
        private void UpdateSeries(IDictionary <string, float> sensors)
        {
            if (!m_startTime.HasValue)
            {
                m_startTime = DateTime.Now;
            }

            var isCelcius = sensors[SensorsKeys.Celcius] > 0;

            m_seriesData[SensorsKeys.Temperature].SetLastValueFormat(isCelcius ? "{0} °C" : "{0} °F");
            m_seriesData[SensorsKeys.TemperatureSet].SetLastValueFormat(isCelcius ? "{0} °C" : "{0} °F");

            var now      = DateTime.Now;
            var xValue   = now.ToOADate();
            var xAxisMax = now.AddSeconds(1).ToOADate();

            foreach (var kvp in m_seriesData)
            {
                var sensorName = kvp.Key;
                var data       = kvp.Value;
                var readings   = sensorName == SensorsKeys.Power
                                        ? sensors[SensorsKeys.OutputCurrent] * sensors[SensorsKeys.OutputVoltage]
                                        : sensors[sensorName];

                var interpolatedValue = Interpolate(readings, data.InterpolationLimits);

                var point = new DataPoint();
                if (Math.Abs(readings) > 0.001)
                {
                    var roundedValue = (float)Math.Round(readings, 3);
                    point.XValue      = xValue;
                    point.YValues     = new double[] { interpolatedValue };
                    point.Tag         = point.Label = roundedValue.ToString(CultureInfo.InvariantCulture);
                    point.MarkerSize  = 7;
                    point.MarkerStyle = MarkerStyle.Circle;
                    data.SetLastValue(roundedValue);
                }
                else
                {
                    point.IsEmpty = true;
                    data.SetLastValue(null);
                }
                data.Seires.Points.Add(point);
            }

            if (m_isRecording)
            {
                m_lineBuilder.Clear();
                m_lineBuilder.Append((now - m_recordStartTime).TotalSeconds.ToString(CultureInfo.InvariantCulture));
                m_lineBuilder.Append(",");

                var values = m_seriesData.Values
                             .Where(x => x.CheckBox.Checked)
                             .Select(x => x.LastValue.HasValue ? x.LastValue.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);

                m_lineBuilder.Append(string.Join(",", values));
                var ex = Safe.Execute(() =>
                {
                    m_fileWriter.WriteLine(m_lineBuilder.ToString());
                    m_fileWriter.Flush();
                });
                if (ex != null)
                {
                    InfoBox.Show("Recording was stopped because of error:\n" + ex.Message);
                    RecordButton.PerformClick();
                }
            }

            foreach (var series in MainChart.Series)
            {
                while (series.Points.Count > MaxItems)
                {
                    series.Points.RemoveAt(0);
                }

                if (series.Points.Count > 0)
                {
                    var lastPoint = series.Points[series.Points.Count - 1];
                    if (lastPoint.IsEmpty)
                    {
                        continue;
                    }

                    if (series.Points.Count > 1)
                    {
                        var preLastPoint = series.Points[series.Points.Count - 2];
                        preLastPoint.Label      = null;
                        preLastPoint.MarkerSize = 0;
                    }
                }
            }

            var points = MainChart.Series.SelectMany(x => x.Points).Where(x => !x.IsEmpty).ToArray();

            var minDate = DateTime.FromOADate(points.Min(x => x.XValue));
            var maxDate = DateTime.FromOADate(points.Max(x => x.XValue));

            var range       = maxDate - minDate;
            var framesCount = Math.Floor(range.TotalSeconds / m_timeFrame.TotalSeconds);

            MainChartScrollBar.Maximum = (int)(framesCount * 30);
            if (IsTracking)
            {
                MainChartScrollBar.Value = MainChartScrollBar.Maximum;
                ScrollChart(true);
            }

            MainChart.ChartAreas[0].AxisX.Minimum = m_startTime.Value.AddSeconds(-5).ToOADate();
            MainChart.ChartAreas[0].AxisX.Maximum = xAxisMax;
        }