Пример #1
0
        private void UpdateFrom()
        {
            Stopwatch Sw = new Stopwatch();

            Sw.Start();

            while (Flag.SystemThread.InternalColdControlEnabled)
            {
                Thread.Sleep(100);
                this.Invoke((MethodInvoker) delegate
                {
                    #region 显示制冷按钮状态
                    this.ColdingEnabled.Checked = Flag.StartEnabled.RunCold.Colding;
                    #endregion

                    #region 刷新选择按钮状态
                    this.Unit1.SwitchStatus = Flag.Unit[0].Enabled;
                    this.Unit2.SwitchStatus = Flag.Unit[1].Enabled;
                    this.Unit3.SwitchStatus = Flag.Unit[2].Enabled;
                    this.Unit4.SwitchStatus = Flag.Unit[3].Enabled;
                    #endregion

                    #region 刷新液位与液体温度
                    this.WaterTemp.Value       = float.Parse(Flag.WaterBox.Temp.Value.ToString("0.0"));
                    this.WaterHeight.Value     = float.Parse(Flag.WaterBox.Height.Value.ToString("0.0"));
                    this.WaterHeight.BottleTag = Flag.WaterBox.Height.Value.ToString("0.0") + "%";
                    #endregion

                    #region 刷新曲线参数
                    if (Flag.InternalColdControl.ChartRefreshEnabled == true)
                    {
                        Flag.InternalColdControl.ChartRefreshEnabled = false;

                        this.LevelTempChart.ChartAreas[0].AxisX.Maximum = Flag.InternalColdControl.ChartPointLength;
                        this.LevelTempChart.ChartAreas[0].AxisY.Maximum = Flag.InternalColdControl.ChartHightTemp;
                        this.LevelTempChart.ChartAreas[0].AxisY.Minimum = Flag.InternalColdControl.ChartLovTemp;

                        for (int i = 0; i < this.LevelTempChart.Series.Count; i++)
                        {
                            if (i < Flag.Unit.Length)
                            {
                                this.LevelTempChart.Series[i].ChartType = Flag.InternalColdControl.UnitChart[i].Type;
                                this.LevelTempChart.Series[i].Color     = Flag.InternalColdControl.UnitChart[i].Color;
                            }
                            else if (i == this.LevelTempChart.Series.Count - 2)
                            {
                                this.LevelTempChart.Series[i].ChartType = Flag.InternalColdControl.SetTempChart.Type;
                                this.LevelTempChart.Series[i].Color     = Flag.InternalColdControl.SetTempChart.Color;
                            }
                            else if (i == this.LevelTempChart.Series.Count - 1)
                            {
                                this.LevelTempChart.Series[i].ChartType = Flag.InternalColdControl.NowTempChart.Type;
                                this.LevelTempChart.Series[i].Color     = Flag.InternalColdControl.NowTempChart.Color;
                            }
                        }
                    }
                    #endregion

                    #region 刷新一次温度曲线
                    if (Sw.ElapsedMilliseconds >= Flag.InternalColdControl.ChartRefreshTime * 1000)
                    {
                        int StartIndex = Function.Other.SetVable(Flag.WaterBox.Parameter.Count >= Flag.InternalColdControl.ChartPointLength, Flag.WaterBox.Parameter.Count - Flag.InternalColdControl.ChartPointLength, 0);

                        for (int i = 0; i < this.LevelTempChart.Series.Count; i++)
                        {
                            if (i < Flag.Unit.Length)
                            {
                                this.LevelTempChart.Series[i].Enabled = Flag.Unit[i].Enabled;
                                if (Flag.Unit[i].Enabled == true)
                                {
                                    this.LevelTempChart.Series[i].Points.Clear();
                                }
                            }
                            else if (i == this.LevelTempChart.Series.Count - 2)
                            {
                                this.LevelTempChart.Series[i].Enabled = true;
                                this.LevelTempChart.Series[i].Points.Clear();
                            }
                            else if (i == this.LevelTempChart.Series.Count - 1)
                            {
                                this.LevelTempChart.Series[i].Enabled = true;
                                this.LevelTempChart.Series[i].Points.Clear();
                            }
                        }

                        for (int i = StartIndex; i < Flag.WaterBox.Parameter.Count; i++)
                        {
                            for (int j = 0; j < this.LevelTempChart.Series.Count; j++)
                            {
                                if (j < Flag.Unit.Length && Flag.Unit[j].Enabled == true)
                                {
                                    FlagStruct.RecordBase Record = Flag.Unit[j].Evaporator.Out.Temp.GetRecordValue(i);
                                    this.LevelTempChart.Series[j].Points.AddXY(Record.Time, Record.Value);
                                }
                                else if (j == this.LevelTempChart.Series.Count - 2)
                                {
                                    FlagStruct.RecordBase Record = Flag.WaterBox.Parameter.GetRecordValue(i);
                                    this.LevelTempChart.Series[j].Points.AddXY(Record.Time, Record.Value);
                                }
                                else if (j == this.LevelTempChart.Series.Count - 1)
                                {
                                    FlagStruct.RecordBase Record = Flag.WaterBox.Temp.GetRecordValue(i);
                                    this.LevelTempChart.Series[j].Points.AddXY(Record.Time, Record.Value);
                                }
                            }
                        }

                        Sw.Restart();
                    }
                    #endregion
                });
            }
            Flag.SystemThread.InternalColdControlEndState = true;
        }
Пример #2
0
        private void UpdateFrom()
        {
            Stopwatch Sw = new Stopwatch();

            Sw.Start();

            while (Flag.SystemThread.UnitWorkStateEnabled)
            {
                Thread.Sleep(100);

                this.Invoke((MethodInvoker) delegate
                {
                    #region 刷新选定机组的压力与温度数据
                    this.CompressorPressureIn.Text     = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.In.Pressure.Value.ToString("0.00") + "Mpa";
                    this.CompressorPressureOut.Text    = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Pressure.Value.ToString("0.00") + "Mpa";
                    this.CondenserPressureIn.Text      = Flag.Unit[Flag.UnitWorkState.UnitIndex].Condenser.In.Pressure.Value.ToString("0.00") + "Mpa";
                    this.CondenserPressureOut.Text     = Flag.Unit[Flag.UnitWorkState.UnitIndex].Condenser.Out.Pressure.Value.ToString("0.00") + "Mpa";
                    this.EvaporatorPressureIn.Text     = Flag.Unit[Flag.UnitWorkState.UnitIndex].Evaporator.In.Pressure.Value.ToString("0.00") + "Mpa";
                    this.EvaporatorPressureOut.Text    = Flag.Unit[Flag.UnitWorkState.UnitIndex].Evaporator.Out.Pressure.Value.ToString("0.00") + "Mpa";
                    this.HeatExchangerPressureOut.Text = Flag.Unit[Flag.UnitWorkState.UnitIndex].HeatExchanger.Out.Pressure.Value.ToString("0.00") + "Mpa";

                    this.CompressorTempOut.Text = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Temp.Value.ToString("0.0") + "℃";
                    this.CondenserTempOut.Text  = Flag.Unit[Flag.UnitWorkState.UnitIndex].Condenser.Out.Temp.Value.ToString("0.0") + "℃";
                    this.EvaporatorTempIn.Text  = Flag.Unit[Flag.UnitWorkState.UnitIndex].Evaporator.Out.Temp.Value.ToString("0.0") + "℃";
                    #endregion

                    #region 刷新压缩机组曲线参数
                    if (Flag.UnitWorkState.ChartRefreshEnabled == true)
                    {
                        Flag.UnitWorkState.ChartRefreshEnabled = false;

                        this.UnitChart.ChartAreas[0].AxisX.Maximum = Flag.UnitWorkState.ChartPointLength;

                        this.UnitChart.ChartAreas[0].AxisY.Maximum = Flag.UnitWorkState.ChartHightTemp;
                        this.UnitChart.ChartAreas[0].AxisY.Minimum = Flag.UnitWorkState.ChartLovTemp;

                        this.UnitChart.ChartAreas[0].AxisY2.Maximum = Flag.UnitWorkState.ChartHightPressure;
                        this.UnitChart.ChartAreas[0].AxisY2.Minimum = Flag.UnitWorkState.ChartLovPressure;

                        this.UnitChart.Series[0].Color = Flag.UnitWorkState.CompressorInPressureChart.Color;
                        this.UnitChart.Series[1].Color = Flag.UnitWorkState.CompressorOutPressureChart.Color;

                        this.UnitChart.Series[2].Color = Flag.UnitWorkState.CondenserInPressureChart.Color;
                        this.UnitChart.Series[3].Color = Flag.UnitWorkState.CondenserOutPressureChart.Color;

                        this.UnitChart.Series[4].Color = Flag.UnitWorkState.EvaporatorInPressureChart.Color;
                        this.UnitChart.Series[5].Color = Flag.UnitWorkState.EvaporatorOutPressureChart.Color;

                        this.UnitChart.Series[6].Color = Flag.UnitWorkState.HeatExchangerOutPressureChart.Color;

                        this.UnitChart.Series[7].Color = Flag.UnitWorkState.CompressorOutTempChart.Color;
                        this.UnitChart.Series[8].Color = Flag.UnitWorkState.CondenserOutTempChart.Color;
                        this.UnitChart.Series[9].Color = Flag.UnitWorkState.EvaporatorInTempChart.Color;

                        this.UnitChart.Series[0].ChartType = Flag.UnitWorkState.CompressorInPressureChart.Type;
                        this.UnitChart.Series[1].ChartType = Flag.UnitWorkState.CompressorOutPressureChart.Type;

                        this.UnitChart.Series[2].ChartType = Flag.UnitWorkState.CondenserInPressureChart.Type;
                        this.UnitChart.Series[3].ChartType = Flag.UnitWorkState.CondenserOutPressureChart.Type;

                        this.UnitChart.Series[4].ChartType = Flag.UnitWorkState.EvaporatorInPressureChart.Type;
                        this.UnitChart.Series[5].ChartType = Flag.UnitWorkState.EvaporatorOutPressureChart.Type;

                        this.UnitChart.Series[6].ChartType = Flag.UnitWorkState.HeatExchangerOutPressureChart.Type;

                        this.UnitChart.Series[7].ChartType = Flag.UnitWorkState.CompressorOutTempChart.Type;
                        this.UnitChart.Series[8].ChartType = Flag.UnitWorkState.CondenserOutTempChart.Type;
                        this.UnitChart.Series[9].ChartType = Flag.UnitWorkState.EvaporatorInTempChart.Type;
                    }
                    #endregion

                    #region 刷新一次曲线,包含温度和压力
                    if (Sw.ElapsedMilliseconds >= Flag.UnitWorkState.ChartRefreshTime * 1000)
                    {
                        for (int i = 0; i < this.UnitChart.Series.Count; i++)
                        {
                            this.UnitChart.Series[i].Points.Clear();
                        }

                        int StartIndex = Function.Other.SetVable(Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Pressure.Count >= Flag.UnitWorkState.ChartPointLength, Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Pressure.Count - Flag.UnitWorkState.ChartPointLength, 0);

                        for (int i = StartIndex; i < Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Pressure.Count; i++)
                        {
                            FlagStruct.RecordBase CompressorPressureIn = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.In.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[0].Points.AddXY(CompressorPressureIn.Time, CompressorPressureIn.Value);

                            FlagStruct.RecordBase CompressorPressureOut = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[1].Points.AddXY(CompressorPressureOut.Time, CompressorPressureOut.Value);

                            FlagStruct.RecordBase CondenserPressureIn = Flag.Unit[Flag.UnitWorkState.UnitIndex].Condenser.In.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[2].Points.AddXY(CondenserPressureIn.Time, CondenserPressureIn.Value);

                            FlagStruct.RecordBase CondenserPressureOut = Flag.Unit[Flag.UnitWorkState.UnitIndex].Condenser.Out.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[3].Points.AddXY(CondenserPressureOut.Time, CondenserPressureOut.Value);

                            FlagStruct.RecordBase EvaporatorPressureIn = Flag.Unit[Flag.UnitWorkState.UnitIndex].Evaporator.In.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[4].Points.AddXY(EvaporatorPressureIn.Time, EvaporatorPressureIn.Value);

                            FlagStruct.RecordBase EvaporatorPressureOut = Flag.Unit[Flag.UnitWorkState.UnitIndex].Evaporator.Out.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[5].Points.AddXY(EvaporatorPressureOut.Time, EvaporatorPressureOut.Value);

                            FlagStruct.RecordBase HeatExchangerPressureOut = Flag.Unit[Flag.UnitWorkState.UnitIndex].HeatExchanger.Out.Pressure.GetRecordValue(i);
                            this.UnitChart.Series[6].Points.AddXY(HeatExchangerPressureOut.Time, HeatExchangerPressureOut.Value);

                            FlagStruct.RecordBase CompressorTempOut = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.Out.Temp.GetRecordValue(i);
                            this.UnitChart.Series[7].Points.AddXY(CompressorTempOut.Time, CompressorTempOut.Value);

                            FlagStruct.RecordBase CondenserTempOut = Flag.Unit[Flag.UnitWorkState.UnitIndex].Condenser.Out.Temp.GetRecordValue(i);
                            this.UnitChart.Series[8].Points.AddXY(CondenserTempOut.Time, CondenserTempOut.Value);

                            FlagStruct.RecordBase EvaporatorTempIn = Flag.Unit[Flag.UnitWorkState.UnitIndex].Evaporator.Out.Temp.GetRecordValue(i);
                            this.UnitChart.Series[9].Points.AddXY(EvaporatorTempIn.Time, EvaporatorTempIn.Value);
                        }

                        Sw.Restart();
                    }
                    #endregion
                });
                if (Sw.ElapsedMilliseconds >= 2000)
                {
                    this.Invoke((MethodInvoker) delegate
                    {
                        #region 显示冷水机运行状态
                        this.CoolWaterIn.PipeLineActive   = Flag.Unit[0].Compressor.RunAndStop.State || Flag.Unit[1].Compressor.RunAndStop.State || Flag.Unit[2].Compressor.RunAndStop.State || Flag.Unit[3].Compressor.RunAndStop.State;
                        this.CoolWaterOut1.PipeLineActive = Flag.Unit[0].Compressor.RunAndStop.State || Flag.Unit[1].Compressor.RunAndStop.State || Flag.Unit[2].Compressor.RunAndStop.State || Flag.Unit[3].Compressor.RunAndStop.State;
                        this.CoolWaterOut2.PipeLineActive = Flag.Unit[0].Compressor.RunAndStop.State || Flag.Unit[1].Compressor.RunAndStop.State || Flag.Unit[2].Compressor.RunAndStop.State || Flag.Unit[3].Compressor.RunAndStop.State;
                        this.CoolWaterOut3.PipeLineActive = Flag.Unit[0].Compressor.RunAndStop.State || Flag.Unit[1].Compressor.RunAndStop.State || Flag.Unit[2].Compressor.RunAndStop.State || Flag.Unit[3].Compressor.RunAndStop.State;
                        #endregion

                        #region 显示压缩机组运行状态
                        this.BypassValve.EdgeColor   = Function.Other.SetVable(Flag.Unit[Flag.UnitWorkState.UnitIndex].BypassValve.State, Color.Green, Color.Red);
                        this.ParallelValve.EdgeColor = Function.Other.SetVable(Flag.Unit[Flag.UnitWorkState.UnitIndex].ParallelValve.State, Color.Green, Color.Red);

                        this.CompressorOutPipe.PipeLineActive    = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;
                        this.CondenserOutPipe.PipeLineActive     = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;
                        this.HeatExchangerOutPipe.PipeLineActive = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;
                        this.EvaporatorInPipe.PipeLineActive     = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;
                        this.EvaporatorOutPipe.PipeLineActive    = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;
                        this.CompressorInPipe.PipeLineActive     = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;

                        this.BranchPipe.PipeLineActive = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State;
                        this.BranchPipe.Visible        = Flag.Unit[Flag.UnitWorkState.UnitIndex].ParallelValve.State;

                        this.BypassInPipe1.PipeLineActive       = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].BypassValve.State;
                        this.BypassInPipe2.PipeLineActive       = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].BypassValve.State;
                        this.BypassOutPipe.PipeLineActive       = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].BypassValve.State;
                        this.BypassCapillaryOut1.PipeLineActive = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].BypassValve.State;
                        this.BypassCapillaryOut2.PipeLineActive = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].BypassValve.State;

                        this.ParallelInPipe.PipeLineActive            = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].ParallelValve.State;
                        this.ParallelOutPipe.PipeLineActive           = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].ParallelValve.State;
                        this.ParallelCapillaryOutPipe1.PipeLineActive = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].ParallelValve.State;
                        this.ParallelCapillaryOutPipe2.PipeLineActive = Flag.Unit[Flag.UnitWorkState.UnitIndex].Compressor.RunAndStop.State && Flag.Unit[Flag.UnitWorkState.UnitIndex].ParallelValve.State;

                        #endregion
                    });
                }
            }
            Flag.SystemThread.UnitWorkStateEndState = true;
        }
Пример #3
0
        private void UpdateFrom()
        {
            Stopwatch Sw = new Stopwatch();

            Sw.Start();

            Color _Color     = Color.White;
            bool  _IsTwinkle = false;

            bool[]    IsTwinkle   = new bool[8];
            Stopwatch TwinkleTime = new Stopwatch();

            Stopwatch ChangeTime = new Stopwatch();

            while (Flag.SystemThread.ExternalTempControlEnabled)
            {
                Thread.Sleep(100);

                this.Invoke((MethodInvoker) delegate
                {
                    #region STL控制中

                    this.groupBox1.Enabled = !Flag.Handler.IsHandlerControl;
                    this.groupBox2.Enabled = !Flag.Handler.IsHandlerControl;

                    #endregion

                    #region 显示加热器开启状态

                    this.HeatingEnabled.Checked = Flag.StartEnabled.RunHeat.Heating;

                    #endregion

                    #region 提示按下应用按钮,更改产品名称
                    if (this.IndependentHeat.Checked == true)
                    {
                        if (Flag.StartEnabled.IndependentHeat != this.IndependentHeat.Checked ||
                            Flag.StartEnabled.OddTestArmVarieties.Name != this.OddTestArmVarietiesName.Text ||
                            Flag.StartEnabled.EvenTestArmVarieties.Name != this.EvenTestArmVarietiesName.Text)
                        {
                            if (ChangeTime.IsRunning == false)
                            {
                                ChangeTime.Start();
                            }
                        }
                        else
                        {
                            ChangeTime.Stop();
                            AppTempSet.BackColor = Color.White;
                        }
                    }
                    else
                    {
                        if (Flag.StartEnabled.IndependentHeat != this.IndependentHeat.Checked || Flag.StartEnabled.VarietiesName != this.ListComBox.Text)
                        {
                            if (ChangeTime.IsRunning == false)
                            {
                                ChangeTime.Start();
                            }
                        }
                        else
                        {
                            ChangeTime.Stop();
                            AppTempSet.BackColor = Color.White;
                        }
                    }

                    if (ChangeTime.ElapsedMilliseconds >= 500)
                    {
                        if (AppTempSet.BackColor == Color.White)
                        {
                            AppTempSet.BackColor = Color.Green;
                        }
                        else
                        {
                            AppTempSet.BackColor = Color.White;
                        }
                        ChangeTime.Restart();
                    }

                    #endregion

                    #region 提示更改设定,更改 IC 或 Inside 使能
                    if (Flag.Handler.IsHandlerControl == false)
                    {
                        if (this.IndependentUse.Checked == true)
                        {
                            for (int i = 0; i < Flag.ExternalTestTempChange.TestArmUseIcHeat.Length; i++)
                            {
                                Switch.ZDSwitch TestArm = Function.Other.FindControl(this.TestArmUseHeat, "TestArm" + (i + 1).ToString() + "_Use") as Switch.ZDSwitch;

                                if (Flag.ExternalTestTempChange.TestArmUseIcHeat[i] != TestArm.Checked)
                                {
                                    IsTwinkle[i] = true;
                                }
                                else
                                {
                                    IsTwinkle[i] = false;
                                }
                            }
                            _IsTwinkle = false;
                            for (int i = 0; i < IsTwinkle.Length; i++)
                            {
                                if (IsTwinkle[i] == true)
                                {
                                    _IsTwinkle = true;
                                    break;
                                }
                            }
                            if (_IsTwinkle == true || Flag.ExternalTestTempChange.IndependentUseHeat != this.IndependentUse.Checked)
                            {
                                if (TwinkleTime.IsRunning == false)
                                {
                                    TwinkleTime.Restart();
                                }
                            }
                            else
                            {
                                TwinkleTime.Stop();
                                ApplyUse.BackColor = Color.White;
                                for (int i = 0; i < Flag.ExternalTestTempChange.TestArmUseIcHeat.Length; i++)
                                {
                                    Label TestArm     = Function.Other.FindControl(this.TestArmUseHeat, "TestArm" + (i + 1).ToString() + "_Use_lb") as Label;
                                    TestArm.BackColor = Color.White;
                                }
                            }

                            if (TwinkleTime.ElapsedMilliseconds >= 500)
                            {
                                if (ApplyUse.BackColor == Color.White)
                                {
                                    ApplyUse.BackColor = Color.Green;
                                }
                                else
                                {
                                    ApplyUse.BackColor = Color.White;
                                }

                                for (int i = 0; i < Flag.ExternalTestTempChange.TestArmUseIcHeat.Length; i++)
                                {
                                    Label TestArm = Function.Other.FindControl(this.TestArmUseHeat, "TestArm" + (i + 1).ToString() + "_Use_lb") as Label;
                                    if (IsTwinkle[i] == true)
                                    {
                                        if (ApplyUse.BackColor == Color.White)
                                        {
                                            TestArm.BackColor = Color.White;
                                        }
                                        else
                                        {
                                            TestArm.BackColor = Color.Silver;
                                        }
                                    }
                                    else
                                    {
                                        TestArm.BackColor = Color.White;
                                    }
                                }
                                TwinkleTime.Restart();
                            }
                        }
                        else
                        {
                            for (int i = 0; i < Flag.ExternalTestTempChange.TestArmUseIcHeat.Length; i++)
                            {
                                Label TestArm     = Function.Other.FindControl(this.TestArmUseHeat, "TestArm" + (i + 1).ToString() + "_Use_lb") as Label;
                                TestArm.BackColor = Color.White;
                            }

                            if (Flag.ExternalTestTempChange.UseIcHeat != this.UseHeatChange.Checked || Flag.ExternalTestTempChange.IndependentUseHeat != this.IndependentUse.Checked)
                            {
                                if (TwinkleTime.IsRunning == false)
                                {
                                    TwinkleTime.Restart();
                                }
                            }
                            else
                            {
                                TwinkleTime.Stop();
                                ApplyUse.BackColor         = Color.White;
                                UseHeatChange_lb.BackColor = Color.White;
                            }

                            if (TwinkleTime.ElapsedMilliseconds >= 500)
                            {
                                if (Flag.ExternalTestTempChange.UseIcHeat != this.UseHeatChange.Checked)
                                {
                                    if (ApplyUse.BackColor == Color.White)
                                    {
                                        UseHeatChange_lb.BackColor = Color.Silver;
                                    }
                                    else
                                    {
                                        UseHeatChange_lb.BackColor = Color.White;
                                    }
                                }
                                if (Flag.ExternalTestTempChange.IndependentUseHeat != this.IndependentUse.Checked || Flag.ExternalTestTempChange.UseIcHeat != this.UseHeatChange.Checked)
                                {
                                    if (ApplyUse.BackColor == Color.White)
                                    {
                                        ApplyUse.BackColor = Color.Green;
                                    }
                                    else
                                    {
                                        ApplyUse.BackColor = Color.White;
                                    }
                                }

                                TwinkleTime.Restart();
                            }
                        }
                    }
                    #endregion

                    #region 更新TestArm加热通道
                    if (this.TestArmUseHeat.Enabled == true)
                    {
                        for (int i = 0; i < Flag.TestArm.Length; i++)
                        {
                            Switch.ZDSwitch TestArm = Function.Other.FindControl(this.TestArmUseHeat, "TestArm" + (i + 1).ToString() + "_Use") as Switch.ZDSwitch;
                            Label TestArm_lb        = Function.Other.FindControl(this.TestArmUseHeat, "TestArm" + (i + 1).ToString() + "_Use_lb") as Label;

                            TestArm.Enabled    = Flag.ExternalTestTempChange.TestArmEnabled[i];
                            TestArm_lb.Enabled = Flag.ExternalTestTempChange.TestArmEnabled[i];
                        }
                    }
                    #endregion

                    #region TestArm

                    for (int i = 0; i < Flag.TestArm.Length; i++)
                    {
                        Panel TestArm        = Chiller.Function.Other.FindControl(this.DisplayTemp, "TestArm" + (i + 1).ToString()) as Panel;
                        Label TestArm_Inside = Chiller.Function.Other.FindControl(this.DisplayTemp, "TestArm" + (i + 1).ToString() + "_Inside") as Label;
                        Label TestArm_IC     = Chiller.Function.Other.FindControl(this.DisplayTemp, "TestArm" + (i + 1).ToString() + "_IC") as Label;

                        if (TestArm == null || TestArm_Inside == null || TestArm_IC == null)
                        {
                            continue;
                        }

                        #region 显示测试头内部温度状态

                        if (Flag.ExternalTestTempChange.TestArmEnabled[i])
                        {
                            if (Flag.TestArm[i].Heat_Inside.GetInData.ErrCode != "")
                            {
                                TestArm_Inside.Text      = Flag.TestArm[i].Heat_Inside.GetInData.ErrCode;
                                TestArm_Inside.ForeColor = Color.Red;
                            }
                            else
                            {
                                TestArm_Inside.Text      = Flag.TestArm[i].Heat_Inside.GetInData.PV.ToString("0.0") + "℃";
                                TestArm_Inside.ForeColor = Color.Blue;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp == true)
                        {
                            if (Flag.TestArm[i].Heat_Inside.GetInData.ErrCode != "")
                            {
                                TestArm_Inside.Text      = Flag.TestArm[i].Heat_Inside.GetInData.ErrCode;
                                TestArm_Inside.ForeColor = Color.Red;
                            }
                            else
                            {
                                TestArm_Inside.Text      = Flag.TestArm[i].Heat_Inside.GetInData.PV.ToString("0.0") + "℃";
                                TestArm_Inside.ForeColor = Color.Black;
                            }
                        }
                        else
                        {
                            TestArm_Inside.Text      = "- ℃";
                            TestArm_Inside.ForeColor = Color.Black;
                        }

                        #endregion

                        #region 显示测试头IC温度状态

                        if (Flag.ExternalTestTempChange.TestArmEnabled[i])
                        {
                            if (Flag.TestArm[i].Heat_IC.GetInData.ErrCode != "")
                            {
                                TestArm_IC.Text      = Flag.TestArm[i].Heat_IC.GetInData.ErrCode;
                                TestArm_IC.ForeColor = Color.Red;
                            }
                            else
                            {
                                TestArm_IC.Text      = Flag.TestArm[i].Heat_IC.GetInData.PV.ToString("0.0") + "℃";
                                TestArm_IC.ForeColor = Color.Blue;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp)
                        {
                            if (Flag.TestArm[i].Heat_IC.GetInData.ErrCode != "")
                            {
                                TestArm_IC.Text      = Flag.TestArm[i].Heat_IC.GetInData.ErrCode;
                                TestArm_IC.ForeColor = Color.Red;
                            }
                            else
                            {
                                TestArm_IC.Text      = Flag.TestArm[i].Heat_IC.GetInData.PV.ToString("0.0") + "℃";
                                TestArm_IC.ForeColor = Color.Black;
                            }
                        }
                        else
                        {
                            TestArm_IC.Text      = "- ℃";
                            TestArm_IC.ForeColor = Color.Black;
                        }

                        #endregion

                        #region 显示背景颜色
                        if (TestArm_IC.ForeColor == Color.Red || TestArm_Inside.ForeColor == Color.Red)
                        {
                            TestArm.BackColor = Color.Yellow;
                        }
                        else if (TestArm_IC.ForeColor == Color.Black && TestArm_Inside.ForeColor == Color.Black)
                        {
                            TestArm.BackColor = Color.Silver;
                        }
                        else
                        {
                            TestArm.BackColor = Color.White;
                        }
                        #endregion
                    }

                    #endregion

                    #region ColdPlate
                    for (int i = 0; i < Flag.ColdPlate.Length; i++)
                    {
                        Panel ColdPlate     = Chiller.Function.Other.FindControl(this.DisplayTemp, "ColdPlate" + (i + 1).ToString()) as Panel;
                        Label ColdPlateTemp = Chiller.Function.Other.FindControl(this.DisplayTemp, "ColdPlate" + (i + 1).ToString() + "Temp") as Label;

                        if (ColdPlate == null || ColdPlateTemp == null)
                        {
                            continue;
                        }


                        if (Flag.ExternalTestTempChange.ColdPlateEnabled[i])
                        {
                            if (Flag.ColdPlate[i].Heat.GetInData.ErrCode != "")
                            {
                                ColdPlateTemp.Text      = Flag.ColdPlate[i].Heat.GetInData.ErrCode;
                                ColdPlateTemp.ForeColor = Color.Red;
                                ColdPlate.BackColor     = Color.Yellow;
                            }
                            else
                            {
                                ColdPlateTemp.Text      = Flag.ColdPlate[i].Heat.GetInData.PV.ToString("0.0") + "℃";
                                ColdPlateTemp.ForeColor = Color.Blue;
                                ColdPlate.BackColor     = Color.White;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp == true)
                        {
                            if (Flag.ColdPlate[i].Heat.GetInData.ErrCode != "")
                            {
                                ColdPlateTemp.Text      = Flag.ColdPlate[i].Heat.GetInData.ErrCode;
                                ColdPlateTemp.ForeColor = Color.Red;
                                ColdPlate.BackColor     = Color.Yellow;
                            }
                            else
                            {
                                ColdPlateTemp.Text      = Flag.ColdPlate[i].Heat.GetInData.PV.ToString("0.0") + "℃";
                                ColdPlateTemp.ForeColor = Color.Black;
                                ColdPlate.BackColor     = Color.Silver;
                            }
                        }
                        else
                        {
                            ColdPlateTemp.Text      = "- ℃";
                            ColdPlateTemp.ForeColor = Color.Black;
                            ColdPlate.BackColor     = Color.Silver;
                        }
                    }

                    #endregion

                    #region HotPlate
                    for (int i = 0; i < Flag.ColdPlate.Length; i++)
                    {
                        Panel HotPlate     = Chiller.Function.Other.FindControl(this.DisplayTemp, "HotPlate" + (i + 1).ToString()) as Panel;
                        Label HotPlateTemp = Chiller.Function.Other.FindControl(this.DisplayTemp, "HotPlate" + (i + 1).ToString() + "Temp") as Label;

                        if (HotPlate == null || HotPlateTemp == null)
                        {
                            continue;
                        }

                        if (Flag.ExternalTestTempChange.HotPlateEnabled[i])
                        {
                            if (Flag.HotPlate[i].Heat.GetInData.ErrCode != "")
                            {
                                HotPlateTemp.Text      = Flag.HotPlate[i].Heat.GetInData.ErrCode;
                                HotPlateTemp.ForeColor = Color.Red;
                                HotPlate.BackColor     = Color.Yellow;
                            }
                            else
                            {
                                HotPlateTemp.Text      = Flag.HotPlate[i].Heat.GetInData.PV.ToString("0.0") + "℃";
                                HotPlateTemp.ForeColor = Color.Blue;
                                HotPlate.BackColor     = Color.White;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp == true)
                        {
                            if (Flag.HotPlate[i].Heat.GetInData.ErrCode != "")
                            {
                                HotPlateTemp.Text      = Flag.HotPlate[i].Heat.GetInData.ErrCode;
                                HotPlateTemp.ForeColor = Color.Red;
                                HotPlate.BackColor     = Color.Yellow;
                            }
                            else
                            {
                                HotPlateTemp.Text      = Flag.HotPlate[i].Heat.GetInData.PV.ToString("0.0") + "℃";
                                HotPlateTemp.ForeColor = Color.Black;
                                HotPlate.BackColor     = Color.Silver;
                            }
                        }
                        else
                        {
                            HotPlateTemp.Text      = "- ℃";
                            HotPlateTemp.ForeColor = Color.Black;
                            HotPlate.BackColor     = Color.Silver;
                        }
                    }

                    #endregion

                    #region TestArm And Socket Shield

                    for (int i = 0; i < Flag.TestArm.Length; i++)
                    {
                        Label TestArmShield = Chiller.Function.Other.FindControl(this.DisplayTemp, "TestArm" + (i + 1).ToString() + "Shield") as Label;
                        Label SocketShield  = Chiller.Function.Other.FindControl(this.DisplayTemp, "Socket" + (i + 1).ToString() + "Shield") as Label;

                        #region TestArm Shield

                        if (TestArmShield == null)
                        {
                            continue;
                        }

                        if (Flag.ExternalTestTempChange.BorderEnabled[i])
                        {
                            if (Flag.BorderTemp[i].Heat.GetInData.ErrCode != "")
                            {
                                TestArmShield.Text      = Flag.BorderTemp[i].Heat.GetInData.ErrCode;
                                TestArmShield.ForeColor = Color.Red;
                            }
                            else
                            {
                                TestArmShield.Text      = Flag.BorderTemp[i].Heat.GetInData.PV.ToString("0.0") + "℃";
                                TestArmShield.ForeColor = Color.Blue;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp == true)
                        {
                            if (Flag.BorderTemp[i].Heat.GetInData.ErrCode != "")
                            {
                                TestArmShield.Text      = Flag.BorderTemp[i].Heat.GetInData.ErrCode;
                                TestArmShield.ForeColor = Color.Red;
                            }
                            else
                            {
                                TestArmShield.Text      = Flag.BorderTemp[i].Heat.GetInData.PV.ToString("0.0") + "℃";
                                TestArmShield.ForeColor = Color.Black;
                            }
                        }
                        else
                        {
                            TestArmShield.Text      = "- ℃";
                            TestArmShield.ForeColor = Color.Black;
                        }

                        #endregion

                        #region Socket Shield

                        if (SocketShield == null)
                        {
                            continue;
                        }

                        if (Flag.ExternalTestTempChange.BorderEnabled[i + 10])
                        {
                            if (Flag.BorderTemp[i + 10].Heat.GetInData.ErrCode != "")
                            {
                                SocketShield.Text      = Flag.BorderTemp[i + 10].Heat.GetInData.ErrCode;
                                SocketShield.ForeColor = Color.Red;
                            }
                            else
                            {
                                SocketShield.Text      = Flag.BorderTemp[i + 10].Heat.GetInData.PV.ToString("0.0") + "℃";
                                SocketShield.ForeColor = Color.Blue;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp == true)
                        {
                            if (Flag.BorderTemp[i + 10].Heat.GetInData.ErrCode != "")
                            {
                                SocketShield.Text      = Flag.BorderTemp[i + 10].Heat.GetInData.ErrCode;
                                SocketShield.ForeColor = Color.Red;
                            }
                            else
                            {
                                SocketShield.Text      = Flag.BorderTemp[i + 10].Heat.GetInData.PV.ToString("0.0") + "℃";
                                SocketShield.ForeColor = Color.Black;
                            }
                        }
                        else
                        {
                            SocketShield.Text      = "- ℃";
                            SocketShield.ForeColor = Color.Black;
                        }

                        #endregion
                    }

                    #endregion

                    #region ColdPlate Shield
                    for (int i = 0; i < Flag.ColdPlate.Length; i++)
                    {
                        Label ColdPlateTemp = Chiller.Function.Other.FindControl(this.DisplayTemp, "ColdPlate" + (i + 1).ToString() + "Shield") as Label;

                        if (ColdPlateTemp == null)
                        {
                            continue;
                        }

                        if (Flag.ExternalTestTempChange.BorderEnabled[i + 8])
                        {
                            if (Flag.BorderTemp[i + 8].Heat.GetInData.ErrCode != "")
                            {
                                ColdPlateTemp.Text      = Flag.BorderTemp[i + 8].Heat.GetInData.ErrCode;
                                ColdPlateTemp.ForeColor = Color.Red;
                            }
                            else
                            {
                                ColdPlateTemp.Text      = Flag.BorderTemp[i + 8].Heat.GetInData.PV.ToString("0.0") + "℃";
                                ColdPlateTemp.ForeColor = Color.Blue;
                            }
                        }
                        else if (Flag.ExternalTestTempChange.NoEnableDisplayTemp == true)
                        {
                            if (Flag.BorderTemp[i + 8].Heat.GetInData.ErrCode != "")
                            {
                                ColdPlateTemp.Text      = Flag.BorderTemp[i + 8].Heat.GetInData.ErrCode;
                                ColdPlateTemp.ForeColor = Color.Red;
                            }
                            else
                            {
                                ColdPlateTemp.Text      = Flag.BorderTemp[i + 8].Heat.GetInData.PV.ToString("0.0") + "℃";
                                ColdPlateTemp.ForeColor = Color.Black;
                            }
                        }
                        else
                        {
                            ColdPlateTemp.Text      = "- ℃";
                            ColdPlateTemp.ForeColor = Color.Black;
                        }
                    }

                    #endregion

                    #region 刷新界面显示露点值

                    Chiller.Function.Other.SetText(Flag.DewPoint[0].IsConnect, Flag.DewPoint[0].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm1DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[1].IsConnect, Flag.DewPoint[1].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm2DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[2].IsConnect, Flag.DewPoint[2].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm3DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[3].IsConnect, Flag.DewPoint[3].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm4DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[4].IsConnect, Flag.DewPoint[4].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm5DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[5].IsConnect, Flag.DewPoint[5].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm6DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[6].IsConnect, Flag.DewPoint[6].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm7DewPoint);
                    Chiller.Function.Other.SetText(Flag.DewPoint[7].IsConnect, Flag.DewPoint[7].DewPoint.ToString("0.0") + "℃", "Err", ref this.TestArm8DewPoint);

                    Chiller.Function.Other.SetFColor(Flag.DewPoint[0].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm1DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[1].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm2DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[2].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm3DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[3].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm4DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[4].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm5DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[5].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm6DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[6].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm7DewPoint);
                    Chiller.Function.Other.SetFColor(Flag.DewPoint[7].IsConnect, Color.RoyalBlue, Color.Red, ref this.TestArm8DewPoint);
                    #endregion

                    #region 刷新曲线参数
                    if (Flag.ExternalTempControlChart.ChartRefreshEnabled == true)
                    {
                        Flag.ExternalTempControlChart.ChartRefreshEnabled = false;

                        this.HandleTempChart.ChartAreas[0].AxisX.Maximum = Flag.ExternalTempControlChart.ChartPointLength;
                        this.HandleTempChart.ChartAreas[0].AxisY.Maximum = Flag.ExternalTempControlChart.ChartHightTemp;
                        this.HandleTempChart.ChartAreas[0].AxisY.Minimum = Flag.ExternalTempControlChart.ChartLovTemp;

                        for (int i = 0; i < Flag.ExternalTempControlChart.TempChart.Length; i++)
                        {
                            this.HandleTempChart.Series[i].Color     = Flag.ExternalTempControlChart.TempChart[i].Color;
                            this.HandleTempChart.Series[i].ChartType = Flag.ExternalTempControlChart.TempChart[i].Type;
                        }
                    }
                    #endregion

                    #region 刷新一次温度曲线

                    if (Sw.ElapsedMilliseconds >= Flag.ExternalTempControlChart.ChartRefreshTime * 1000)
                    {
                        this.HandleTempChart.Series[this.HandleTempChart.Series.Count - 1].Points.Clear();

                        for (int i = 0; i < this.HandleTempChart.Series.Count - 1; i++)
                        {
                            if (i <= 7)
                            {
                                this.HandleTempChart.Series[i].Enabled = Flag.TestArm[i].Heat_IC.SetToHeat.Enabled;

                                if (Flag.TestArm[i].Heat_IC.SetToHeat.Enabled == true)
                                {
                                    this.HandleTempChart.Series[i].Points.Clear();
                                }
                            }
                            else if (i == 8 || i == 9)
                            {
                                this.HandleTempChart.Series[i].Enabled = Flag.ColdPlate[i - 8].Heat.SetToHeat.Enabled;

                                if (Flag.ColdPlate[i - 8].Heat.SetToHeat.Enabled == true)
                                {
                                    this.HandleTempChart.Series[i].Points.Clear();
                                }
                            }
                            else if (i == 10 || i == 11)
                            {
                                this.HandleTempChart.Series[i].Enabled = Flag.HotPlate[i - 10].Heat.SetToHeat.Enabled;

                                if (Flag.HotPlate[i - 10].Heat.SetToHeat.Enabled == true)
                                {
                                    this.HandleTempChart.Series[i].Points.Clear();
                                }
                            }
                        }


                        int StartIndex = Chiller.Function.Other.SetVable(Flag.TestArm[0].Heat_IC.NowRecord.Count >= Flag.ExternalTempControlChart.ChartPointLength, Flag.TestArm[0].Heat_IC.NowRecord.Count - Flag.ExternalTempControlChart.ChartPointLength, 0);

                        for (int i = StartIndex; i < Flag.TestArm[0].Heat_IC.NowRecord.Count; i++)
                        {
                            //加载设定温度
                            FlagStruct.RecordBase Record1 = Flag.TestArm[0].Heat_IC.SetRecord.GetValue(i);
                            this.HandleTempChart.Series[this.HandleTempChart.Series.Count - 1].Points.AddXY(Record1.Time, Record1.Value);

                            //加载当前温度
                            for (int j = 0; j < this.HandleTempChart.Series.Count - 1; j++)
                            {
                                if (j <= 7)
                                {
                                    if (Flag.TestArm[j].Heat_IC.SetToHeat.Enabled == true)
                                    {
                                        FlagStruct.RecordBase Record2 = Flag.TestArm[j].Heat_IC.NowRecord.GetValue(i);
                                        this.HandleTempChart.Series[j].Points.AddXY(Record2.Time, Record2.Value);
                                    }
                                }
                                else if (j == 8 || j == 9)
                                {
                                    if (Flag.ColdPlate[j - 8].Heat.SetToHeat.Enabled == true)
                                    {
                                        FlagStruct.RecordBase Record2 = Flag.ColdPlate[j - 8].Heat.NowRecord.GetValue(i);
                                        this.HandleTempChart.Series[j].Points.AddXY(Record2.Time, Record2.Value);
                                    }
                                }
                                else if (j == 10 || j == 11)
                                {
                                    if (Flag.HotPlate[j - 10].Heat.SetToHeat.Enabled == true)
                                    {
                                        FlagStruct.RecordBase Record2 = Flag.HotPlate[j - 10].Heat.NowRecord.GetValue(i);
                                        this.HandleTempChart.Series[j].Points.AddXY(Record2.Time, Record2.Value);
                                    }
                                }
                            }
                        }

                        Sw.Restart();
                    }
                    #endregion
                });
            }
            Flag.SystemThread.ExternalTempControlEndState = true;
        }