//********************************************************************************************************************
// Error Check Functions
//********************************************************************************************************************
/// <summary>
/// Retruns Error Code:
/// 0: OK;
/// 1: Short;
/// 2: Open;
/// 4: Instable;
/// </summary>
private UInt16 ErrorCheck_ShortOpen(TTA_measurement myTTA, int MeasCycle)
{
long raw_file_mean = 0;
int pre_points = 1001;
//Mittelwert berechnen (Short und Open)
for (int j = pre_points; j < myTTA.Binary_Raw_Files.GetLength(1); j++)
{
raw_file_mean += +myTTA.Binary_Raw_Files[MeasCycle, j];
}
raw_file_mean /= (myTTA.Binary_Raw_Files.GetLength(1) - pre_points);
//Short (2^15 = 32768 --> mit Puffer)
if (raw_file_mean < -32000)
{
return(1);
}
//Open (2^15 = 32768 --> mit Puffer)
if (raw_file_mean > 32000)
{
return(2);
}
//Kein Fehler
return(0);
}
//**************************************************************************************************
// Z_th
//**************************************************************************************************
#region Z_th
private void Button_Zth_signle_Click(object sender, EventArgs e)
{
//TTA-Mess-File erzeugen erzeugen
myTTA = new TTA_measurement()
{
MyRack = rthTEC_Rack1,
MyDAQ = DAQ_Unit,
GUI = this,
};
//Plots initisieren
Graph_new_Measurment_for_TTA(myTTA);
//Spectrum einstellen
DAQ_Unit.Setting_for_TTA();
DAQ_Unit.Setting_Trigger(rthTEC_Rack1);
//Backroundworker definieren
myBackroundWorker = new BackgroundWorker()
{
WorkerSupportsCancellation = true,
};
//Aufgabe definieren
myBackroundWorker.DoWork += new DoWorkEventHandler((state, args) =>
{
bool noError = true;
//Messen --> aktuell noch DEMO
if (noError)
{
noError = myTTA.Start_Single_TTA();
}
//Daten konvertieren und abarbeiten
if (noError)
{
noError = myTTA.Convert_Data();
}
//Graphen plotten
if (noError)
{
Add_Series_to_Data(myTTA);
Update_Voltage_Plots_for_TTA();
}
//UI wieder aktiviern
Set_Old_Enable_Status();
}
);
//Alle Knöpfe deaktiveren
Disable_All_Controlls();
//Backroundworker starten
myBackroundWorker.RunWorkerAsync();
}
public void Add_Series_to_RAW(TTA_measurement myTTA, int Messung)
{
//Es dürfen nich alle Pukte übertragen werden (Datenmenge)
//ungefähr 20Tausend DatenPunkte
int steps = myTTA.Binary_Raw_Files.GetLength(1) / 20000;
//Auf 10^x Wert runden
steps = (int)Math.Pow(10, Math.Round(Math.Log10(steps)));
//Daten in Passende Liste einfügen
List <RAW_DataPoint> myRawDataList = new List <RAW_DataPoint>();
for (int sample = 0; sample < myTTA.Binary_Raw_Files.GetLength(1); sample += steps)
{
myRawDataList.Add(
new RAW_DataPoint()
{
Value = myTTA.Binary_Raw_Files[Messung, sample],
Time = (decimal)sample / myTTA.MyDAQ.Frequency,
}
);
}
//Muss so kompliziert sein, da UI nicht im Thread liegt
chartControl_RAW.Invoke((MethodInvoker) delegate
{
var neueSerie = new Series("Cycle " + (Messung + 1).ToString(), ViewType.Line)
{
CheckableInLegend = true,
DataSource = myRawDataList,
ArgumentScaleType = ScaleType.Numerical,
ArgumentDataMember = "Time",
ValueScaleType = ScaleType.Numerical,
};
neueSerie.ValueDataMembers.AddRange(new string[] { "Value" });
chartControl_RAW.Series.Add(neueSerie);
//Resize x-Achse
//((LineSeriesView)neueSerie.View).LineMarkerOptions.Kind = MarkerKind.Triangle;
//((LineSeriesView)neueSerie.View).MarkerVisibility = DevExpress.Utils.DefaultBoolean.True;
});
}
private UInt16 ErrorCheck_Instabil(TTA_measurement myTTA)
{
//Wenn nur ein Zyklus, dann kann stabilität nich überprüft werden
if (myTTA.MyRack.Cycles < 2)
{
return(0);
}
//Punkte zum definieren
List <long> Liste_Punkte = new List <long>()
{
myTTA.Binary_Raw_Files.GetLength(1) - (myTTA.Binary_Raw_Files.GetLength(1) / 3), //@ 2/3
myTTA.Binary_Raw_Files.GetLength(1) - (myTTA.Binary_Raw_Files.GetLength(1) / 5), //@ 4/5
myTTA.Binary_Raw_Files.GetLength(1) - 1 //@ End
};
//Jeden Punkt definieren
foreach (long point in Liste_Punkte)
{
//Feld für Werte erzeugen
long[] values = new long[myTTA.MyRack.Cycles];
//Werte herauslösen
for (int cycle_nr = 0; cycle_nr < myTTA.MyRack.Cycles; cycle_nr++)
{
values[cycle_nr] = myTTA.Binary_Raw_Files[cycle_nr, point];
}
//Auf stabilität prüfen (immer mit erstem vergleichen)
for (int cycle_nr = 1; cycle_nr < myTTA.MyRack.Cycles; cycle_nr++)
{
//Voltage = Bitwert * 2*Range / 2^16 / Gain + Offset
long differenc_in_mv = (values[0] - values[cycle_nr]) * Range / 2 / (long)Math.Pow(2, 15);
//Wenn untesschied > 5mV
if (Math.Abs(differenc_in_mv) > 5)
{
return(4);
}
}
}
//Kein Fehler
return(0);
}
public void Add_Series_to_Data(TTA_measurement myTTA)
{
chartControl_DATA_Top.Invoke((MethodInvoker) delegate
{
var neueSerie = new Series("LED " + chartControl_DATA_Top.Series.Count.ToString(), ViewType.Line)
{
CheckableInLegend = true,
DataSource = myTTA.Average_Heat_Compressed,
ArgumentScaleType = ScaleType.Numerical,
ArgumentDataMember = "Time",
ValueScaleType = ScaleType.Numerical,
CrosshairLabelPattern = "{S} : {V:0.000} V"
};
neueSerie.ValueDataMembers.AddRange(new string[] { "Voltage" });
chartControl_DATA_Top.Series.Add(neueSerie);
});
chartControl_DATA_Bottom.Invoke((MethodInvoker) delegate
{
var neueSerie = new Series("LED " + chartControl_DATA_Bottom.Series.Count.ToString(), ViewType.Line)
{
CheckableInLegend = true,
DataSource = myTTA.Average_Meas_Compressed,
ArgumentScaleType = ScaleType.Numerical,
ArgumentDataMember = "Time",
ValueScaleType = ScaleType.Numerical,
CrosshairLabelPattern = "{S} : {V:0.000} V"
};
neueSerie.ValueDataMembers.AddRange(new string[] { "Voltage" });
chartControl_DATA_Bottom.Series.Add(neueSerie);
});
}
private void Graph_new_Measurment_for_TTA(TTA_measurement myTTA)
{
//Abfragen ob Beschriftung vorhanden
if (chartControl_DATA_Top.Titles.Count == 0)
{
//Wenn nicht
Graph_Init_for_TTA(myTTA);
}
//Abfragen ob Beschriftung passten für TTA
else if (!chartControl_DATA_Top.Titles[0].Text.Contains("Z_th"))
{
//Wenn nicht
Graph_Init_for_TTA(myTTA);
}
else
{
//Sonst nur RAW leeren
chartControl_RAW.Series.Clear();
//Hinzufügen leere unsichbare Serie (damit Achsen angezeigt werden)
var neueSerie = new Series("Empty", ViewType.Line)
{
LabelsVisibility = DevExpress.Utils.DefaultBoolean.False,
ShowInLegend = false,
Visible = true,
};
chartControl_RAW.Series.Add(neueSerie);
//Zeit neu eistellen
XYDiagram test = (XYDiagram)chartControl_RAW.Diagram;
test.AxisX.WholeRange.MaxValue = (myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Heat) / 1000; //Zugelassener Bereich
test.AxisX.VisualRange.MaxValue = (myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Heat) / 1000; //Sichtbarrer Bereich
}
}
/// <summary>
/// Retruns true if no error occured while sending the settings
/// </summary>
public override bool Measure_TTA_Several_Cycles_DEMO(TTA_measurement myTTA, ATIM_MainWindow GUI)
{
//StatusBar anpassen
GUI.StatusBar_TTA_Single(0, (int)myTTA.MyRack.Cycles);
//Plot für Single Curves initialsisiern
//AsyncChart_single_Vf_init();
//Mögliche Errors mitzählen
uint error_Sum = 0;
//1. Parameter für Messlänge senden********************************************************************************
//Sample Anzahl berechnen (Heizplus + Messpuls + Puffer[alle in ms]) * Frequenz
long samples = Decimal.ToInt64((myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Meas + 0.5m) / 1000 * Frequency);
//Sampels nach Trigger berechnen (100µs davor)
long postTriggerSamples = samples - Decimal.ToInt64(0.0001m * Frequency);
//error_Sum += Set_Sample_Count(samples);
//error_Sum += Set_Samples_PostTrigger(postTriggerSamples);
//2. Feld für die Messdaten generiern******************************************************************************
//Pointer und Händler für Datenfeld
IntPtr daten_Pointer;
GCHandle hBufferHandle;
//Zugehöriges Feld in Klasse TTA measurement erzeugen
myTTA.Creat_RowDataField(samples);
//Speicherplatz sperren
hBufferHandle = GCHandle.Alloc(myTTA.Binary_Raw_Files, GCHandleType.Pinned);
//Pointer für gesperten Speicherplatz suchen
daten_Pointer = hBufferHandle.AddrOfPinnedObject();
//Init Stability Check (weiß nicht wozu)
//double stability_limit = 1; //1%
//bool[] no_stability = new bool[3];
//int[,] values_for_stability_check = new int[3, myTTA_Measurement.param.anzahl_Zyklen];
//3. Messung starten************************************************************************************************
for (int i = 0; i < myTTA.MyRack.Cycles; i++)
{
//Falls über Cancel abgebrochen wurde --> Speicher freigeben
if (GUI.myBackroundWorker.CancellationPending)
{
hBufferHandle.Free();
return(false);
}
//error_Sum += WaitTime_for_Trigger_inf();
//error_Sum += Adopt_Settings();
//error_Sum += Start_Card();
//error_Sum += Wait_to_fill_PreTrigger();
//error_Sum += Enable_Trigger();
//error_Sum += Force_Trigger_after_time((long)myTTA.MyRack.Time_Heat);
//Zählvariablen in Button hochzählen
GUI.StatusBar_TTA_Single(i + 1, (int)myTTA.MyRack.Cycles);
//System.Threading.Thread.Sleep((int)(myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Meas));
System.Threading.Thread.Sleep(1000);
//Stromquelle Pulsen
//myTTA.MyRack.SinglePuls_withoutDelay();
//Wurde ein Trigger Event gefunden (wenn nich Rückgabewert ist 263)
/*if (Did_Trigger_Event_occured() == 263)
* {
* //Fehlermeldung
* //SetAsyncText(Spectrum_answer, "Kein Trigger gefunden");
*
* error_Sum += 263;
* error_Sum += Force_Trigger();
* }*/
//4. Daten abholen**********************************************************************************************
//WArten bis alle Daten vorhanden sind (unendlich lang möglich)
//error_Sum += WaitTime_for_Trigger_inf();
//error_Sum += Wait_for_all_samples();
//Datentransfer einstellen (Datapointer enspricht der Stelle des ersten Samples im Array)
//Bei weiteren Zyklen muss dieser Pointer geändert werden
//DataPointer is [0,0]
//anzahl_samples entspricht der Länge einer Zeile
//2 ist notwendig für short (2byte)
//i ist die aktuelle Zeile (Zyklus)
IntPtr aktuellerPointer = new IntPtr(daten_Pointer.ToInt64() + 2 * i * samples);
Random rnd = new Random();
//Daten für Demo erzeugen
int j = 0;
int help_t = 0;
for (; j < 1000; j++)
{
myTTA.Binary_Raw_Files[i, j] = -32767;
}
for (; j < samples / 2; j++)
{
help_t++;
myTTA.Binary_Raw_Files[i, j] = (short)(10000 + 15000 * Math.Exp(-(double)help_t / 1500000) + rnd.Next(-100, 100));
}
help_t = 0;
for (; j < samples - 1000; j++)
{
help_t++;
myTTA.Binary_Raw_Files[i, j] = (short)(-10000 - 15000 * Math.Exp(-(double)help_t / 1500000) + rnd.Next(-100, 100));
}
for (; j < samples; j++)
{
myTTA.Binary_Raw_Files[i, j] = -32767;
}
//error_Sum += Send_Pointer_of_Array(aktuellerPointer, samples);
//error_Sum += Get_Data();
//5. Auf Fehler prüfen*****************************************************************************************
/*
* (Text in Antwortfenster ändern
* if (error_Sum == 0) { SetAsyncText(Spectrum_answer, "Measurement correct\r\n"); }
* else { SetAsyncText(Spectrum_answer, "Error while measurement\r\n"); }
*/
//Gleich in Graph ausgeben
GUI.Add_Series_to_RAW(myTTA, i);
//myTTA.ErrorCode = ErrorCheck_ShortOpen(myTTA, i);
//Wenn Short oder Open --> Abbruch (keine weiteren Zyklen)
//if (myTTA.ErrorCode != 0)
// break;
}
//Stabilitäts-Check
//if (myTTA.ErrorCode == 0)
// myTTA.ErrorCode = ErrorCheck_Instabil(myTTA);
hBufferHandle.Free();
//Auf Errors checken
if (error_Sum != 0)
{
MessageBox.Show("An Error occured while measurment!\n Error Code: ." + myTTA.ErrorCode.ToString(), "Warning",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(false);
}
else
{
return(true);
}
}
public virtual decimal Get_Constant_Voltage(TTA_measurement myTTA, ATIM_MainWindow GUI)
{
return(0);
}
public virtual bool Measure_TTA_Several_Cycles_DEMO(TTA_measurement myTTA, ATIM_MainWindow GUI)
{
return(false);
}
public override decimal Get_Constant_Voltage(TTA_measurement myTTA, ATIM_MainWindow GUI)
{
//Konstante Spannung über mehrere Samples messen
//1. Daten-Felder definieren***************************************************************************************
//Übergabe-Parameter für NI-Karte definieren
IAsyncResult uebergabe_parameter_ReadWaveform_Constant = null;
//Ausgangsdaten
AnalogSingleChannelReader messInfo_NI_SinglePulse_Constant = null;
// Task für Messung erzeugen
NationalInstruments.DAQmx.Task myTask_NI_Constant = null;
//2. NI-Karte scharf stellen***********************************************************************************
try
{
myTask_NI_Constant = new NationalInstruments.DAQmx.Task("myTask_Constant");
// Kanal erzeugen:
//---------------------------------------------------------------------------------
//physicalChannelName As String: z.B. Dev1/ai3
//nameToAssignChannel As String: sollte leer bleiben (Zweck keine Ahnung)
//terminalConfiguration As AITerminalConfiguration: Differential oder ähnlich
//minimumValue As Double: z.B. -10 [V] untere Grenze
//maximumValue As Double: z.B. 10 [V]
//customScaleName As String:
//---------------------------------------------------------------------------------
myTask_NI_Constant.AIChannels.CreateVoltageChannel(VISA_or_Channel_Name, "",
AITerminalConfiguration.Differential, -Range / 1000, Range / 1000, AIVoltageUnits.Volts);
// Timing-Parameter definieren:
//---------------------------------------------------------------------------------
//signalSource As string: Wenn interne Clock verwendet wird ""
//rate As double: Abtastfrequenz in Hz (Interne Clock)
//activeEdge As SampleClockActiveEdge: Bei welcher Flanke der Clock abgetastet wird
//sampleMode As SampleQuantityMode: Legt fest ob dauerhaft gemessen wird, oder bis
// nur eine endliche Anzahl (nächster Parameter)
//samplesPerChannel As int: Anzahl der Samples
//---------------------------------------------------------------------------------
myTask_NI_Constant.Timing.ConfigureSampleClock("", Frequency, SampleClockActiveEdge.Rising,
SampleQuantityMode.FiniteSamples, (int)Frequency / 1000);
// Trigger definieren
//---------------------------------------------------------------------------------
//Kein Trigger definieren --> Sofort starten
//---------------------------------------------------------------------------------
myTask_NI_Constant.Triggers.StartTrigger.ConfigureNone();
//TimeOut anpassen
myTask_NI_Constant.Stream.Timeout = 2000;
// Verify the Task
myTask_NI_Constant.Control(TaskAction.Verify);
//Messwert-Ausgabe definieren
messInfo_NI_SinglePulse_Constant = new AnalogSingleChannelReader(myTask_NI_Constant.Stream);
// Use SynchronizeCallbacks to specify that the object
// marshals callbacks across threads appropriately.
messInfo_NI_SinglePulse_Constant.SynchronizeCallbacks = true;
uebergabe_parameter_ReadWaveform_Constant = messInfo_NI_SinglePulse_Constant.BeginReadWaveform((int)Frequency / 1000, null, null);
}
catch (DaqException ex)
{
//Bei Daq Exception soll die Fehlermeldung ausgegeben werden (z.B. kein Kanal, ...)
MessageBox.Show(ex.Message);
//Task beenden
myTask_NI_Constant.Dispose();
return(0);
}
//6. Daten auswerten*******************************************************************************************
try
{
// vorhandene Daten auslesen
AnalogWaveformSampleCollection <double> test = messInfo_NI_SinglePulse_Constant.EndReadWaveform(uebergabe_parameter_ReadWaveform_Constant).Samples;
//Durchschnitt berechnen
double average = 0;
for (int counter = 0; counter < test.Count; counter++)
{
average += test[counter].Value;
}
return((decimal)average / test.Count / myTTA.MyRack.Gain + myTTA.MyRack.U_offset / 1000);
}
catch (DaqException ex)
{
//Bei Fehler -> Fehlermeldung ausgeben (hier z.B. Timeout)
MessageBox.Show(ex.Message);
return(0);
}
finally
{
// Task beenden
myTask_NI_Constant.Dispose();
}
}
public override bool Measure_TTA_Several_Cycles_DEMO(TTA_measurement myTTA, ATIM_MainWindow GUI)
{
return(true);
}
public override bool Measure_TTA_Several_Cycles(TTA_measurement myTTA, ATIM_MainWindow GUI)
{
//StatusBar anpassen
GUI.StatusBar_TTA_Single(0, (int)myTTA.MyRack.Cycles);
//1. Parameter für Messlänge senden********************************************************************************
//Sampelzahl und Abtastfrequenz definieren (Times sind in ms deswegen /1000)
int anzahl_samples = Convert.ToInt32(Frequency) / 1000
* Decimal.ToInt32(myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Meas);
//Sample überschuss, da Umschalten derzeit nicht richtig
int sample_ueberschuss = 2000;
//Trigger berechnen
double trigger = decimal.ToDouble((numericUpDown_Trigger.Value - myTTA.MyRack.U_offset / 1000) * myTTA.MyRack.Gain);
//2. Daten-Felder definieren***************************************************************************************
//Übergabe-Parameter für NI-Karte definieren
IAsyncResult uebergabe_parameter_ReadWaveform = null;
//Ausgangsdaten
AnalogSingleChannelReader messInfo_NI_SinglePulse = null;
//Feld für Daten definieren (mit 100x max- beginnen)
myTTA.Creat_RowDataField(100 + anzahl_samples + sample_ueberschuss);
//3. Loop**********************************************************************************************************
for (int i = 0; i < myTTA.MyRack.Cycles; i++)
{
//4. NI-Karte scharf stellen***********************************************************************************
try
{
// Task für Messung erzeugen
myTask_NI = new NationalInstruments.DAQmx.Task("myTask");
// Kanal erzeugen:
//---------------------------------------------------------------------------------
//physicalChannelName As String: z.B. Dev1/ai3
//nameToAssignChannel As String: sollte leer bleiben (Zweck keine Ahnung)
//terminalConfiguration As AITerminalConfiguration: Differential oder ähnlich
//minimumValue As Double: z.B. -10 [V] untere Grenze
//maximumValue As Double: z.B. 10 [V]
//customScaleName As String:
//---------------------------------------------------------------------------------
myTask_NI.AIChannels.CreateVoltageChannel(VISA_or_Channel_Name, "",
AITerminalConfiguration.Differential, -Range / 1000, Range / 1000, AIVoltageUnits.Volts);
// Timing-Parameter definieren:
//---------------------------------------------------------------------------------
//signalSource As string: Wenn interne Clock verwendet wird ""
//rate As double: Abtastfrequenz in Hz (Interne Clock)
//activeEdge As SampleClockActiveEdge: Bei welcher Flanke der Clock abgetastet wird
//sampleMode As SampleQuantityMode: Legt fest ob dauerhaft gemessen wird, oder bis
// nur eine endliche Anzahl (nächster Parameter)
//samplesPerChannel As int: Anzahl der Samples
//---------------------------------------------------------------------------------
myTask_NI.Timing.ConfigureSampleClock("", Frequency, SampleClockActiveEdge.Rising,
SampleQuantityMode.FiniteSamples, anzahl_samples + sample_ueberschuss);
// Trigger definieren
//---------------------------------------------------------------------------------
//source As String: Herkuft des Triggers. Hier gleich wie Daten (Dev1/ai3)
//slope As AnalogEdgeStartTriggerSlope: Rising or Falling
//level As Double: Trigger Level (vorher bestimmt
//---------------------------------------------------------------------------------
myTask_NI.Triggers.StartTrigger.ConfigureAnalogEdgeTrigger(VISA_or_Channel_Name,
AnalogEdgeStartTriggerSlope.Rising, trigger);
//Hysterese festlegen (keine Ahnung ob das Wichtig ist)
//---------------------------------------------------------------------------------
//Hysteresis as Double: Wert der Hysterese
//---------------------------------------------------------------------------------
myTask_NI.Triggers.StartTrigger.AnalogEdge.Hysteresis = 0.05;
//TimeOut anpassen
myTask_NI.Stream.Timeout = (Int32)(1.2m * (myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Meas));
// Verify the Task
myTask_NI.Control(TaskAction.Verify);
//Messwert-Ausgabe definieren
messInfo_NI_SinglePulse = new AnalogSingleChannelReader(myTask_NI.Stream);
// Use SynchronizeCallbacks to specify that the object
// marshals callbacks across threads appropriately.
messInfo_NI_SinglePulse.SynchronizeCallbacks = true;
uebergabe_parameter_ReadWaveform = messInfo_NI_SinglePulse.BeginReadWaveform(anzahl_samples + sample_ueberschuss, null, null);
}
catch (DaqException ex)
{
//Bei Daq Exception soll die Fehlermeldung ausgegeben werden (z.B. kein Kanal, ...)
MessageBox.Show(ex.Message);
//Task beenden
myTask_NI.Dispose();
}
//5. Puls starten**********************************************************************************************
System.Threading.Thread.Sleep(300);
myTTA.MyRack.SinglePuls_withDelay();
System.Threading.Thread.Sleep(1000);
//6. Daten auswerten*******************************************************************************************
try
{
// vorhandene Daten auslesen
AnalogWaveformSampleCollection <double> test = messInfo_NI_SinglePulse.EndReadWaveform(uebergabe_parameter_ReadWaveform).Samples;
double factor = Math.Pow(2, 15) / (Range / 1000);
//Mit 100mal Minimalwert beginnen. (Für umschaltpunkt suche)
for (int counter = 0; counter < 100; counter++)
{
myTTA.Binary_Raw_Files[i, counter] = short.MinValue;
}
//Daten in Binär (short umrechnen) & TTA übergeben
for (int counter = 100; counter < test.Count; counter++)
{
double helping_Double = test[counter].Value * factor;
myTTA.Binary_Raw_Files[i, counter] = (short)(helping_Double);
}
//Gleich in Graph ausgeben
GUI.Add_Series_to_RAW(myTTA, i);
}
catch (DaqException ex)
{
//Bei Fehler -> Fehlermeldung ausgeben (hier z.B. Timeout)
MessageBox.Show(ex.Message);
return(false);
}
finally
{
// Task beenden
myTask_NI.Dispose();
}
//7. StatusBar anpassen****************************************************************************************
GUI.StatusBar_TTA_Single(i + 1, (int)myTTA.MyRack.Cycles);
}
return(true);
}
private void Graph_Init_for_TTA(TTA_measurement myTTA)
{
//Zwischenspeicher umschreiben
akt_Graph_Setup = "TTA";
//Größe der Überschriften
Font myFont_Headline = new Font("Tahoma", 12, FontStyle.Bold);
Font myFont_Axis = new Font("Tahoma", 10);
DevExpress.XtraCharts.ChartTitle myChartTitle;
//Ober Graph für RAW............................................................................
chartControl_RAW.Series.Clear();
myChartTitle = new DevExpress.XtraCharts.ChartTitle()
{
Text = "Raw Values DAC",
Font = myFont_Headline,
Dock = DevExpress.XtraCharts.ChartTitleDockStyle.Top,
};
chartControl_RAW.Titles.Clear();
chartControl_RAW.Titles.Add(myChartTitle);
//Diagramm erzeugen (Muss wegen laufzeit in Begin Init und EndInit)
XYDiagram xyDigaram_RAW;
((System.ComponentModel.ISupportInitialize)(this.chartControl_RAW)).BeginInit();
xyDigaram_RAW = new XYDiagram();
chartControl_RAW.Diagram = xyDigaram_RAW;
//Achsen-Titel setzen
xyDigaram_RAW.AxisX.Title.Text = "Time in [s]";
xyDigaram_RAW.AxisX.Title.Visibility = DevExpress.Utils.DefaultBoolean.True;
xyDigaram_RAW.AxisX.Title.Font = myFont_Axis;
xyDigaram_RAW.AxisY.Title.Text = "Bit-Value";
xyDigaram_RAW.AxisY.Title.Visibility = DevExpress.Utils.DefaultBoolean.True;
xyDigaram_RAW.AxisY.Title.Font = myFont_Axis;
//Min-Max - Achse
decimal zeit_max = (myTTA.MyRack.Time_Heat + myTTA.MyRack.Time_Meas) / 1000;
xyDigaram_RAW.AxisX.VisibleInPanesSerializable = "-1";
xyDigaram_RAW.AxisX.VisualRange.Auto = false;
xyDigaram_RAW.AxisX.WholeRange.MaxValue = zeit_max * 2; //Zugelassener Bereich
xyDigaram_RAW.AxisX.WholeRange.MinValue = 0;
xyDigaram_RAW.AxisX.VisualRange.MaxValue = zeit_max; //Sichtbarrer Bereich
xyDigaram_RAW.AxisX.VisualRange.MinValue = 0;
xyDigaram_RAW.AxisX.VisualRange.SideMarginsValue = 0; //Überstand Links und rechts
xyDigaram_RAW.AxisY.VisibleInPanesSerializable = "-1";
xyDigaram_RAW.AxisY.VisualRange.Auto = false;
xyDigaram_RAW.AxisY.WholeRange.MaxValue = 32768;
xyDigaram_RAW.AxisY.WholeRange.MinValue = -32768;
xyDigaram_RAW.AxisY.VisualRange.MaxValue = 32768; //Sichtbarrer Bereich
xyDigaram_RAW.AxisY.VisualRange.MinValue = -32768;
xyDigaram_RAW.AxisY.NumericScaleOptions.AutoGrid = false;
xyDigaram_RAW.AxisY.NumericScaleOptions.GridSpacing = 16384;
xyDigaram_RAW.AxisY.Interlaced = true;
xyDigaram_RAW.AxisY.VisualRange.SideMarginsValue = 1; //Überstand Links und rechts
((System.ComponentModel.ISupportInitialize)(this.chartControl_RAW)).EndInit();
//Label & Legend
chartControl_RAW.CrosshairOptions.GroupHeaderPattern = "{A} sec";
chartControl_RAW.CrosshairOptions.HighlightPoints = false;
chartControl_RAW.Legend.MarkerMode = LegendMarkerMode.CheckBox;
//Hinzufügen leere unsichbare Serie (damit Achsen angezeigt werden)
var neueSerie = new Series("Empty", ViewType.Line)
{
LabelsVisibility = DevExpress.Utils.DefaultBoolean.False,
ShowInLegend = false,
Visible = true,
};
chartControl_RAW.Series.Add(neueSerie);
//Ober Graph für RAW................................................................................
chartControl_DATA_Top.Series.Clear();
myChartTitle = new DevExpress.XtraCharts.ChartTitle()
{
Text = "Z_th curve for heating",
Font = myFont_Headline,
Dock = DevExpress.XtraCharts.ChartTitleDockStyle.Top
};
chartControl_DATA_Top.Titles.Clear();
chartControl_DATA_Top.Titles.Add(myChartTitle);
//Diagramm erzeugen (Muss wegen laufzeit in Begin Init und EndInit)
XYDiagram xyDiagram_DATA_Top;
((System.ComponentModel.ISupportInitialize)(this.chartControl_DATA_Top)).BeginInit();
xyDiagram_DATA_Top = new XYDiagram();
chartControl_DATA_Top.Diagram = xyDiagram_DATA_Top;
//Achsen-Titel setzen
xyDiagram_DATA_Top.AxisX.Title.Text = "Time in [s]";
xyDiagram_DATA_Top.AxisX.Title.Visibility = DevExpress.Utils.DefaultBoolean.True;
xyDiagram_DATA_Top.AxisX.Title.Font = myFont_Axis;
xyDiagram_DATA_Top.AxisY.Title.Text = "Voltage [V]";
xyDiagram_DATA_Top.AxisY.Title.Visibility = DevExpress.Utils.DefaultBoolean.True;
xyDiagram_DATA_Top.AxisY.Title.Font = myFont_Axis;
//Min-Max - Achse
xyDiagram_DATA_Top.AxisX.VisibleInPanesSerializable = "-1";
xyDiagram_DATA_Top.AxisX.VisualRange.Auto = false;
xyDiagram_DATA_Top.AxisX.WholeRange.MaxValue = myTTA.MyRack.Time_Heat / 1000; //Zugelassener Bereich
xyDiagram_DATA_Top.AxisX.WholeRange.MinValue = 1m / myTTA.MyDAQ.Frequency;
xyDiagram_DATA_Top.AxisX.VisualRange.MaxValue = myTTA.MyRack.Time_Heat / 1000; //Sichtbarrer Bereich
xyDiagram_DATA_Top.AxisX.VisualRange.MinValue = 1m / myTTA.MyDAQ.Frequency;
xyDiagram_DATA_Top.AxisX.VisualRange.SideMarginsValue = 0; //Überstand Links und rechts
xyDiagram_DATA_Top.AxisX.Logarithmic = true;
xyDiagram_DATA_Top.AxisY.VisibleInPanesSerializable = "-1";
xyDiagram_DATA_Top.AxisY.VisualRange.Auto = false;
xyDiagram_DATA_Top.AxisY.WholeRange.MaxValue = 10;
xyDiagram_DATA_Top.AxisY.WholeRange.MinValue = 0;
xyDiagram_DATA_Top.AxisY.VisualRange.MaxValue = 10; //Sichtbarrer Bereich
xyDiagram_DATA_Top.AxisY.VisualRange.MinValue = 0;
xyDiagram_DATA_Top.AxisY.NumericScaleOptions.GridSpacing = 1;
xyDiagram_DATA_Top.AxisY.VisualRange.SideMarginsValue = 0; //Überstand Links und rechts
((System.ComponentModel.ISupportInitialize)(this.chartControl_DATA_Top)).EndInit();
//Label & Legend
chartControl_DATA_Top.CrosshairOptions.GroupHeaderPattern = "{A} sec";
chartControl_DATA_Top.CrosshairOptions.HighlightPoints = false;
chartControl_DATA_Top.Legend.MarkerMode = LegendMarkerMode.CheckBox;
//Hinzufügen leere unsichbare Serie (damit Achsen angezeigt werden)
neueSerie = new Series("Empty", ViewType.Line)
{
LabelsVisibility = DevExpress.Utils.DefaultBoolean.False,
ShowInLegend = false,
Visible = true,
};
chartControl_DATA_Top.Series.Add(neueSerie);
//Ober Graph für RAW...................................................................................
chartControl_DATA_Bottom.Series.Clear();
myChartTitle = new DevExpress.XtraCharts.ChartTitle()
{
Text = "Z_th curve for cooling",
Font = myFont_Headline,
Dock = DevExpress.XtraCharts.ChartTitleDockStyle.Top
};
chartControl_DATA_Bottom.Titles.Clear();
chartControl_DATA_Bottom.Titles.Add(myChartTitle);
//Diagramm erzeugen (Muss wegen laufzeit in Begin Init und EndInit)
XYDiagram xyDiagram_DATA_Bottom;
((System.ComponentModel.ISupportInitialize)(this.chartControl_DATA_Bottom)).BeginInit();
xyDiagram_DATA_Bottom = new XYDiagram();
chartControl_DATA_Bottom.Diagram = xyDiagram_DATA_Bottom;
//Achsen-Titel setzen
xyDiagram_DATA_Bottom.AxisX.Title.Text = "Time in [s]";
xyDiagram_DATA_Bottom.AxisX.Title.Visibility = DevExpress.Utils.DefaultBoolean.True;
xyDiagram_DATA_Bottom.AxisX.Title.Font = myFont_Axis;
xyDiagram_DATA_Bottom.AxisY.Title.Text = "Voltage [V]";
xyDiagram_DATA_Bottom.AxisY.Title.Visibility = DevExpress.Utils.DefaultBoolean.True;
xyDiagram_DATA_Bottom.AxisY.Title.Font = myFont_Axis;
//Min-Max - Achse
xyDiagram_DATA_Bottom.AxisX.VisibleInPanesSerializable = "-1";
xyDiagram_DATA_Bottom.AxisX.VisualRange.Auto = false;
xyDiagram_DATA_Bottom.AxisX.WholeRange.MaxValue = myTTA.MyRack.Time_Heat / 1000; //Zugelassener Bereich
xyDiagram_DATA_Bottom.AxisX.WholeRange.MinValue = 1m / myTTA.MyDAQ.Frequency;
xyDiagram_DATA_Bottom.AxisX.VisualRange.MaxValue = myTTA.MyRack.Time_Heat / 1000; //Sichtbarrer Bereich
xyDiagram_DATA_Bottom.AxisX.VisualRange.MinValue = 1m / myTTA.MyDAQ.Frequency;
xyDiagram_DATA_Bottom.AxisX.VisualRange.SideMarginsValue = 0; //Überstand Links und rechts
xyDiagram_DATA_Bottom.AxisX.Logarithmic = true;
xyDiagram_DATA_Bottom.AxisY.VisibleInPanesSerializable = "-1";
xyDiagram_DATA_Bottom.AxisY.VisualRange.Auto = true;
xyDiagram_DATA_Bottom.AxisY.WholeRange.MaxValue = 10;
xyDiagram_DATA_Bottom.AxisY.WholeRange.MinValue = 0;
xyDiagram_DATA_Bottom.AxisY.VisualRange.MaxValue = 10; //Sichtbarrer Bereich
xyDiagram_DATA_Bottom.AxisY.VisualRange.MinValue = 0;
xyDiagram_DATA_Bottom.AxisY.NumericScaleOptions.GridSpacing = 1;
xyDiagram_DATA_Bottom.AxisY.VisualRange.SideMarginsValue = 0; //Überstand Links und rechts
((System.ComponentModel.ISupportInitialize)(this.chartControl_DATA_Bottom)).EndInit();
//Label & Legend
chartControl_DATA_Bottom.CrosshairOptions.GroupHeaderPattern = "{A} sec";
chartControl_DATA_Bottom.CrosshairOptions.HighlightPoints = false;
chartControl_DATA_Bottom.Legend.MarkerMode = LegendMarkerMode.CheckBox;
//Hinzufügen leere unsichbare Serie (damit Achsen angezeigt werden)
neueSerie = new Series("Empty", ViewType.Line)
{
LabelsVisibility = DevExpress.Utils.DefaultBoolean.False,
ShowInLegend = false,
Visible = true,
};
chartControl_DATA_Bottom.Series.Add(neueSerie);
}
private void Button_Auto_Zth_Click(object sender, EventArgs e)
{
//Abfrage ob alle nötigen Geräte angeschlossen (BSP alt)
/*
* if (!Is_Spectrum_Activ() ) { return; }
* if (!Is_Heller_Activ() ) { return; }
* if (!Is_Power_Supply_Activ()) { return; }
* if (!Is_XYZ_Aktive() ) { return; }
* if (!Is_Directory_Correct() ) { return; }
* if (!Is_FileName_Correct() ) { return; }
* if (!Is_Gerber_Correct() ) { return; }
*/
//TTA-Mess-File erzeugen erzeugen
TTA_measurement myTTA = new TTA_measurement()
{
MyRack = rthTEC_Rack1,
MyDAQ = DAQ_Unit,
MyXYZ = myXYZ,
Output_File_Folder = myFileSetting.readBox_FileFolder1.MyPath,
Output_File_Name = myFileSetting.readBox_FileFolder1.MyFileName,
GUI = this,
MyMovement = myFileSetting.readBox_Movement1.Movements_XYA
};
//Plots initisieren
Graph_new_Measurment_for_TTA(myTTA);
//Spectrum einstellen
DAQ_Unit.Setting_for_TTA();
DAQ_Unit.Setting_Trigger(rthTEC_Rack1);
//Backroundworker definieren
myBackroundWorker = new BackgroundWorker()
{
WorkerSupportsCancellation = true,
};
//Aufgabe definieren
myBackroundWorker.DoWork += new DoWorkEventHandler((state, args) =>
{
//Messung für alle starten
//spectrum1.Measure_TTA_Several_Cycles_DEMO(myTTA, this);
DAQ_Unit.Measure_TTA_Several_Cycles(myTTA, this);
//Daten konvertieren und abarbeiten
myTTA.Convert_Data();
//Graphen plotten
Add_Series_to_Data(myTTA);
Update_Voltage_Plots_for_TTA();
//UI wieder aktiviern
Set_Old_Enable_Status();
}
);
//Alle Knöpfe deaktiveren
Disable_All_Controlls();
//Backroundworker starten
myBackroundWorker.RunWorkerAsync();
}
