private void UpdateChart(float update_time, double YValue, int sensor_number)
{
// InvokeRequired required compares the thread ID of the
// calling thread to the thread ID of the creating thread.
// If these threads are different, it returns true.
if (this.chart1.InvokeRequired)
{
UpdateChartCallback d = new UpdateChartCallback(UpdateChart);
this.Invoke(d, new object[] { update_time, YValue, sensor_number });
}
else
{
//graphUpdate++;
//if (graphUpdate == 10)
// {
// chart1.Series.ResumeUpdates();
// chart1.Series.Invalidate();
// chart1.Series.SuspendUpdates();
// graphUpdate = 0;
// }
if (sensor_number == 1)
{
chart1.Series["Sensor 1"].Points.AddXY((update_time / 60), YValue);
}
else if (sensor_number == 2)
{
chart1.Series["Sensor 2"].Points.AddXY((update_time / 60), YValue);
}
else if (sensor_number == 3)
{
chart1.Series["Sensor 3"].Points.AddXY((update_time / 60), YValue);
}
else if (sensor_number == 4)
{
chart1.Series["Sensor 4"].Points.AddXY((update_time / 60), YValue);
}
//if (addrow_gridview == 4)
//{
// DataGridViewRow gridviewrow = (DataGridViewRow)dataGridView1.Rows[0].Clone();
// gridviewrow.Cells[0].Value = value1;
// gridviewrow.Cells[1].Value = value2;
// gridviewrow.Cells[2].Value = value3;
// gridviewrow.Cells[3].Value = value4;
// row_number++;
// dataGridView1.Rows.Add(gridviewrow);
// if (row_number >= 10)
// {
// dataGridView1.FirstDisplayedScrollingRowIndex = row_number - 10;// FirstDisplayedScrollingRowIndex
// }
//}
//chart1.ChartAreas[0].RecalculateAxesScale();
}
}
private void UpdateChart(string temp, string hum)
{
if (this.Chart_TH.InvokeRequired)
{
UpdateChartCallback recv = new UpdateChartCallback(UpdateChart);
this.Invoke(recv, new object[] { temp, hum }); //Invoke를 실행해 아래 else구문을 실행하도록 한다.
}
//아래 내용을 실행한다.
else
{
string chart_x = date + "\r\n" + time;
Chart_TH.Series["Temp"].Points.AddXY(chart_x, temp);
Chart_TH.Series["Humidity"].Points.AddXY(chart_x, hum);
if (Chart_TH.Series["Temp"].Points.Count > 5)
{
Chart_TH.Series["Temp"].Points.RemoveAt(0);
Chart_TH.Series["Humidity"].Points.RemoveAt(0);
}
}
}
private void UpdateChart()
{
if (this.chart.InvokeRequired)
{
UpdateChartCallback c = new UpdateChartCallback(UpdateChart);
this.Invoke(c, new object[] { });
}
else
{
chart.Series["Average Moving Average"].Points.DataBindY(movAvgScoreList);
chart.Series["Average"].Points.DataBindY(avgScoreList);
chart.Series["Max Moving Average"].Points.DataBindY(movMaxScoreList);
chart.Series["Max"].Points.DataBindY(maxScoreList);
}
}
private void UpdateChart(Sample sample, Sample raw, RowingSignal rowingSignal)
{
if (chart.InvokeRequired)
{
try
{
UpdateChartCallback d = new UpdateChartCallback(UpdateChart);
Invoke(d, new object[] { sample, raw, rowingSignal });
}
catch (ObjectDisposedException e)
{
Console.WriteLine(e.ToString()); // swallow the exception (this happens when killing the window)
}
}
else
{
if (String.IsNullOrEmpty(X) || String.IsNullOrEmpty(Y))
return;
double valueX = 0, valueY = 0;
double rawX = 0, rawY = 0;
switch (X)
{
case "X":
valueX = sample.x;
rawX = raw.x;
break;
case "Y":
valueX = sample.y;
rawX = raw.y;
break;
case "Z":
valueX = sample.z;
rawX = raw.z;
break;
case "A":
valueX = sample.a;
rawX = raw.a;
break;
case "B":
valueX = sample.b;
rawX = raw.b;
break;
case "C":
valueX = sample.c;
rawX = raw.c;
break;
case "time":
if(time >= MAXX)
{
time = MINX;
rowingSignals.Points.Clear();
}
valueX = time;
rawX = time;
time += X_STEP;
break;
default: return;
}
switch (Y)
{
case "X":
valueY = sample.x;
rawY = raw.x;
break;
case "Y":
valueY = sample.y;
rawY = raw.y;
break;
case "Z":
valueY = sample.z;
rawY = raw.z;
break;
case "A":
valueY = sample.a;
rawY = raw.a;
break;
case "B":
valueY = sample.b;
rawY = raw.b;
break;
case "C":
valueY = sample.c;
rawY = raw.c;
break;
default: return;
}
readsAccumulated.Points.AddXY(valueX, valueY);
lblXValue.Text = valueX.ToString();
lblYValue.Text = valueY.ToString();
lblYRaw.Text = rawY.ToString();
readsRaw.Points.AddXY(rawX, rawY);
if (readsAccumulated.Points.Count > LINE_LENGTH_IN_SAMPLES)
{
readsAccumulated.Points.RemoveAt(0);
}
if(readsRaw.Points.Count > LINE_LENGTH_IN_SAMPLES)
{
readsRaw.Points.RemoveAt(0);
}
if(rowingSignal != null)
{
rowingSignals.Points.AddXY(rawX, rawY);
if(rowingSignal.StrokeTime > 0)
{
lblStrokeRate.Text = rowingSignal.SmoothedStrokeRate.ToString("0.0");
}
}
}
}
/// <summary>
/// Updates thread-safely the chart
/// </summary>
/// <param name="xValues">Abscissa values</param>
/// <param name="yValues">Ordinate values</param>
void UpdateChart(double[] xValues, double[] yValues)
{
if (this.Chart.InvokeRequired)
{
if (Chart.Parent != null)
{
UpdateChartCallback d = new UpdateChartCallback(UpdateChart);
Chart.Parent.Invoke(d, new object[] { xValues, yValues });
}
}
else
{
int seriesIndex = 0;
for (int i = 0; i < Inputs.Count; i++)
{
for (int j = 0; j < Inputs[i].Count; j++)
{
if (Chart.Series != null)
{
if (seriesIndex < Chart.Series.Count)
{
Chart.Series[seriesIndex].Points.AddXY(UpdateCount * TimestepUnit, Convert.ToDouble(Inputs[i][j].Value));
}
}
seriesIndex++;
}
}
}
}
