private void Form1_SensorValueChanged(object sender, SensorValueEventArgs e)
        {
            if(e.OldValue > THRESHOLD_TRAIN1_ON_MARK && e.CurrentValue < THRESHOLD_TRAIN1_ON_MARK)
            {
                _train1DiffTime = DateTime.Now - _train1TimeOnMark;
                _train1TimeOnMark = DateTime.Now;
                this.Train1LoopCount++;
                _train1Velocity = (62 * 2 + 315 * 2 * Math.PI) / _train1DiffTime.TotalSeconds;  // mm/s

                _train1PWM = Math.Max(Math.Min(_train1PWM + (int)((TARGET_VELOCITY - _train1Velocity) * 0.1), 100), 0);

                System.Media.SystemSounds.Beep.Play();
            }
        }
 private void Form1_SensorValueChanged(object sender, SensorValueEventArgs e)
 {
     if(e.OldValue > THRESHOLD_TRAIN1_ON_MARK && e.CurrentValue < THRESHOLD_TRAIN1_ON_MARK)
     {
         _train1DiffTime = DateTime.Now - _train1TimeOnMark;
         _train1TimeOnMark = DateTime.Now;
         this.Train1LoopCount++;
     }
 }
Ejemplo n.º 3
0
        private void Form1_SensorValueChanged(object sender, SensorValueEventArgs e)
        {
            if (e.OldValue < THRESHOLD_TRAIN_ON_MARK && e.CurrentValue > THRESHOLD_TRAIN_ON_MARK)
            {
                _train1DiffTime = DateTime.Now - _train1TimeOnMark;
                _train1TimeOnMark = DateTime.Now;
                this.Train1LoopCount++;
                //_train1Velocity = (62 * 2 + 315 * 2 * Math.PI) / _train1DiffTime.TotalSeconds;  // mm/s
                _train1Velocity = 248 / _train1DiffTime.TotalSeconds;  // mm/s

                _train1VelocityList[2] = _train1VelocityList[1];
                _train1VelocityList[1] = _train1VelocityList[0];
                _train1VelocityList[0] = _train1Velocity;

                double e0 = _train1VelocityList[0] - _train1VelocityList[1];
                double e1 = _train1VelocityList[1] - _train1VelocityList[2];

                System.Media.SystemSounds.Beep.Play();
            }
        }
Ejemplo n.º 4
0
        private void Controller_Sensor2ValueReceived(object sender, SensorValueEventArgs e)
        {
            DateTime time = DateTime.Now;

            Sensor2Data.AsyncInvoke(x =>
            {
                x.Rows.Add(new object[]
                {
                    time,
                    e.Status,
                    e.Before.Sensor1,
                    e.Before.Sensor2,
                    e.After == null ? 0f : e.After.Value.Sensor1,
                    e.After == null ? 0f : e.After.Value.Sensor2,
                    e.Delta == null ? 0f : e.Delta.Value.Sensor1,
                    e.Delta == null ? 0f : e.Delta.Value.Sensor2
                });
            });
            SensorChart.AsyncInvoke(x =>
            {
                if (!x.IsDisposed)
                {
                    x.Series["Sensor1Before"].Points.AddXY(time, e.Before.Sensor1);
                    x.Series["Sensor1After"].Points.AddXY(time, e.After == null ? 0f : e.After.Value.Sensor1);
                    x.Series["Sensor1MaxPlus"].Points.AddXY(time, 3.5f);
                    x.Series["Sensor1MaxMinus"].Points.AddXY(time, -3.5f);
                    x.Series["Sensor1MinPlus"].Points.AddXY(time, 0.75f);
                    x.Series["Sensor1MinMinus"].Points.AddXY(time, -0.75f);

                    x.Series["Sensor2Before"].Points.AddXY(time, e.Before.Sensor2);
                    x.Series["Sensor2After"].Points.AddXY(time, e.After == null ? 0f : e.After.Value.Sensor2);
                    x.Series["Sensor2MaxPlus"].Points.AddXY(time, 3.5f);
                    x.Series["Sensor2MaxMinus"].Points.AddXY(time, -3.5f);
                    x.Series["Sensor2MinPlus"].Points.AddXY(time, 0.75f);
                    x.Series["Sensor2MinMinus"].Points.AddXY(time, -0.75f);

                    x.Series["Sensor1Delta"].Points.AddXY(time, e.Delta == null ? 0f : e.Delta.Value.Sensor1);
                    x.Series["Sensor2Delta"].Points.AddXY(time, e.Delta == null ? 0f : e.Delta.Value.Sensor2);
                }
            });
            switch (e.Status)
            {
            case StatusCode.PASS:
            {
                Stats1.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["Passed"].Points.Count > 0)
                            {
                                x.Series["Passed"].Points[0].SetValueXY("Passed", x.Series["Passed"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["Passed"].Points.AddXY("Passed", 1);
                            }
                        }
                    });
                break;
            }

            case StatusCode.FAILED:
            {
                Stats1.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["Failed"].Points.Count > 0)
                            {
                                x.Series["Failed"].Points[0].SetValueXY("Failed", x.Series["Failed"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["Failed"].Points.AddXY("Failed", 1);
                            }
                        }
                    });
                break;
            }

            case StatusCode.FIRST_BENDED:
            {
                Stats2.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["FirstBended"].Points.Count > 0)
                            {
                                x.Series["FirstBended"].Points[0].SetValueXY("FirstBended", x.Series["FirstBended"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["FirstBended"].Points.AddXY("FirstBended", 1);
                            }
                        }
                    });
                break;
            }

            case StatusCode.SECOND_BENDED:
            {
                Stats2.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["SecondBended"].Points.Count > 0)
                            {
                                x.Series["SecondBended"].Points[0].SetValueXY("SecondBended", x.Series["SecondBended"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["SecondBended"].Points.AddXY("SecondBended", 1);
                            }
                        }
                    });
                break;
            }
            }
        }