Wie Hintergrundprozesses ansteurn/programmieren?

  • VB.NET

Es gibt 59 Antworten in diesem Thema. Der letzte Beitrag () ist von egon.

    Wie Hintergrundprozesses ansteurn/programmieren?

    Hallo,

    ich schreibe gerade eine Messauswertesoftware um das Rauschen von Hochfrequenzverstärkern messen und darstellen zu können.
    Für jede Messkurve werden rund 80 Einzelmessungen aufgenommen aus denen dann die Messwerte berechnet werden. Für jede Messung wird ein externes Messgerät entsprechend eingestellt.
    Das Problem ist, dass das Erstellen einer Messkurve rund 5 Minuten dauert und wenn mehrere Messkurven hintereinander aufgenommen werden alles rund 30 Minuten dauern kann. Momentan wird während dieser Zeit die Software blockiert und auch der Bildschirm nicht aktualisiert. Das ist irgendwie sehr unschön...

    Wie kann ich Prozesse im Hintergrund laufen lassen, die sich dann nur bei Erledigung ihrer Aufgabe wieder melden, damit ein nachfolgender Prozess (Messung) gestartet werden kann oder einfach nur der die Werte berechnet werden damit dann der Bildschirm aktualisert werden kann?

    So wird momentan mein Messgerät angesteuert, wenn etwas eingestellt werden soll:

    Dim proc As Process = New Process()
    proc.StartInfo.FileName = Label_talk.Text
    proc.StartInfo.Arguments = " 18 " & Chr(34) & "AT 0DB;SP 0HZ;" & AMPLITUDE & ";" & RESOLUTION_BW & ";" & VIDEO_BW & ";" & FREQUEMZ & ";" & SWEEP_TIMEms & Chr(34)
    proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden
    proc.Start()
    proc.WaitForExit()

    Zum Auslesen der Messwerte wird ein ähnliches externes Programm gestartet, welches die Messwerte in ein TXT-File speichert, welches dann später von meinem Programm ausgewertet werden muss.

    Die große Frage ist, wie alles so im Hintergrund erfolgen kann, dass nichts blockiert wird.

    Über eine Hilfestellung würde ich mich sehr freuen.
    Bilder
    • Softwarefenster.png

      94,02 kB, 1.409×824, 56 mal angesehen
    @egon Deklariere den Prozess WithEvents in der Klasse und fange das Exited-Event auf:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private WithEvents prc As Process
    3. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    4. prc = New Process
    5. prc.StartInfo.FileName = "notepad.exe"
    6. prc.EnableRaisingEvents = True
    7. prc.Start()
    8. End Sub
    9. Private Sub prc_exit(sender As Object, e As EventArgs) Handles prc.Exited
    10. MessageBox.Show("Prozess beendet")
    11. End Sub
    12. End Class
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Vielen Dank. Das ist sehr elegant.

    Nun habe ich aber noch einen Knoten im Hirn...
    Für jeden Messpunkt wird eine Einstellung am Gerät vorgenommen und dann werden vier Messungen durchgeführt, die dann zu einem Messpunkt berechnet und im Diagramm dargestellt werden - das für jede Frequenz.

    Bis jetzt habe ich alles über Spaghetti-Code gelöst: :(
    spezifische Messeinstellung für 1MHz
    - Messung (a)
    - Teilauswertung für Messung (a)
    - Messung (b)
    - Teilauswertung für Messung (b)
    - Messung (c)
    - Teilauswertung für Messung (c)
    - Messung (d)
    - Teilauswertung für Messung (d)

    spezifische Messeinstellung für 2MHz
    -
    -
    -
    -

    ... und das für rund 20 weitere Frequenzen

    Anschließend wird alles ausgewertet und dargestellt - immer schön in Spaghetti-Code :(
    Während dieser Zeit war dann alles bisher blockiert...
    Für jede Messung oder Frequenzteinstellung wurden die speziallen Paramter über eine Function übergeben und als Antwortwert folgte dann dann ein Teilergebnis.
    Wir gestalltet man jetzt am besten den Programmablauf, wenn einzelne Events auftreten können. Wie übergibt man dann am elegantesten die ganzen Parameter?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    @egon Zunächst bist Du ein schlechter C&P-Künstler, denn offensichtlich willst Du nicht die Mesung (d) mehrfach auswerten. ;)
    Ist das Messprogramm Dein eigener Code oder eine "fremde" Exe?
    Da es sich hier um eine Messung mit Hilfe eines Gerätes handelt, gehe ich davon aus, dass immer nur eine Exe laufen kann und die nächste gestartet wird, wenn eine fertig ist.
    Bereite eine Liste mit den Parametern vor (List(Of String)), und wenn Du einen Parameter da rausnimmst, kommen die Ergebnisse in die Instanz einer Auswerteklasse, die kannst Du dann ihrerseits in eine List(Of ClassAuswertung) packen.
    Wenn die Parameter alle und alle Antworten da sind, startest Du die Gesamtauswertung.
    Den entsprechenden Test machst Du immer dann, wenn ein Prozess Excited hat.
    Feddich. :D
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    arrrg. Den Schreibfehler mit Messung(d) habe ich korrigiert. Ja es wird ein externes Programm verwendet, welches mit Parametern aufgerufen wird. Dieses Programm (nicht von mir geschrieben) steurt dann ein Interface an, welches über einen GPIB-Steuerbefehls-Bus einen Spectrum Analyser ansteurt, bzw. ihn ausliest.
    Das mit der List(Of String) habe ich so verstanden, dass ich ein Array anlege in dem ich alles Parameter und Informationen ablege und dass die Ergebnisse dann in einem zweiten Array abgelegt werden.
    Nach jeder Teilmessung wird dann das Array um ein Element verkleinert.
    Nach den vier Teilmessungen wird dann für den jeweiligen Frequenzpunkt die Berechung ausgeführt und dann das Ergebnis wieder in ein Messergebnisse-Array (Frequenz, Messwert )abgelegt.

    Oder meinst du mit "List(Of String)" etwas anderes?
    Meinst du vielleicht "ArrayList"? Was ist der Unterschied zu einem ein oder zweidimensionalem Array?

    egon schrieb:

    Oder meinst du mit "List(Of String)" etwas anderes?
    Ich meine eine List(Of String), sie hat die von Dir beschriebene Funktionalität, die ein Array eben nicht hat.

    VB.NET-Quellcode

    1. Private MyParams As List(Of String)
    2. Private Sub Init()
    3. MyParams = New List(Of String)
    4. MyParams.Add( " 18 " & Chr(34) & "AT 0DB;SP 0HZ;" & AMPLITUDE & ";" & RESOLUTION_BW & ";" & VIDEO_BW & ";" & FREQUEMZ & ";" & SWEEP_TIMEms & Chr(34))
    5. End Sub
    Und sieh Dir mal dies an:

    VB.NET-Quellcode

    1. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    2. Dim AMPLITUDE = "Amp"
    3. Dim RESOLUTION_BW = "Res"
    4. Dim VIDEO_BW = "Vid"
    5. Dim FREQUEMZ = "Freq"
    6. Dim SWEEP_TIMEms = "Sweep"
    7. Label1.Text = " 18 " & Chr(34) & "AT 0DB;SP 0HZ;" & AMPLITUDE & ";" & RESOLUTION_BW & ";" & VIDEO_BW & ";" & FREQUEMZ & ";" & SWEEP_TIMEms & Chr(34)
    8. Label2.Text = String.Format(" 18 ""AT 0DB;SP 0HZ;{0};{1};{2};{3};{4}""", AMPLITUDE, RESOLUTION_BW, VIDEO_BW, FREQUEMZ, SWEEP_TIMEms)
    9. End Sub
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!
    Damit wird für mich ein neues Fass aufgemacht, da ich keine Ahnung von typDataset-basierten Datenmodellen habe. Warum schlägst du es vor? Welche Vorteile hat es?

    Hier mal der Ablauf für einen Frequenzpunkt. Vielleicht beeinflusst das die Auswahl der ProzessSteuerung.

    - externes Programm mit Parametern - Einstellungen übertragen (Für 1 MHz Einstellungen an den Spektrum Analysator übertragen)

    - Relayschaltung 1
    - Wartezeit für Messpunkt 1 MHz (z.B 1200 ms)
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte1.txt übertragen)

    - Relayschaltung 2
    - Wartezeit für Messpunkt 1 MHz
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte2.txt übertragen)

    - Relayschaltung 3
    - Wartezeit für Messpunkt 1 MHz
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte3.txt übertragen)

    - Relayschaltung 4
    - Wartezeit für Messpunkt 1 MHz
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte4.txt übertragen)

    - Berechnung aus den vier Einzelmessungen durchführen und für 1 MHz abspeichern und im Diagramm darstellen. Abgespeichert werden muss die Frequenz (in MHz) als X_Wert und das Messergebnis als Y-Wert.

    Nun wird alles für den nächsten Frequenzpunkt wiederholt.
    Gemessen wird für die Frequenzen (in MHz): 1,2,3,4,5,6,7,8,9,10,15,18,20,25,30,40,50,70,80,120,145,145,150,200

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    Ich kann für für die Programmsteuerung natürlich auch alles in Private-Variablen abspeichern, die dann quasi als Zeiger dienen und die einzelnen Parameter übermitteln. Das könnte ich alleine hinbekommen. Das mit den typDataset-basierten Datenmodellen bekomme ich nicht alleine hin.
    Die Wartezeit sollte man vielleicht auch besser mit Timern im Hintergrund lösen.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    zu post#10: Da fängst du erfreulicherweise quasi an, ein Datenmodell zu konzipieren, indem du dir die Abläufe ühaupt erstmal klarmachst. Aber noch viel zu unklar, was deine Begriffe da im einzelnen bedeuten, und ob die als Datenmodell-Einheit (Entität) verwendbar sind, obs doppelbedeutungen gibt etc.

    In deiner Beschreibung kommen folgende Entität-Kandidaten vor:
    Verstärker, Messpunkt, RelaySchaltung, Messung, Messergebnis

    Das könnten alles Objekte sein (bzw. inne Realität sind das ja Objekte), mit ihren typischen Eigenschaften: Ein Verstärker hat eine Typbezeichnung, Verstärkung, etc, eine Relayschaltung wird auch iwelche Eigenarten haben, und ich könnt mir vorstellen, auf einer Schaltung befinden sich Messpunkte - da muss man deren Position iwie definieren.
    Usw.

    Also Entitäten und ihre Beschreibungen gilt es in Klassen zu übersetzen - und da sehe ich das Problem fehlender Grundlagen: Weisst du ühaupt was das ist, könntest du denn eine Klasse überhaupt schomal programmieren, etwa die Klasse Verstaerker, mit den Properties Name und Verstaerkung?
    Hmmm, Ich glaube, dass wir irgendwie aneinander vorbei reden, da ich mit dein ganzen Begriffen nicht viel anfangen kann - sorry.
    Ich versuche meinen funktionierenden (aber schlecht programmierten) Ablauf genauer zu beschreiben

    - externes Programm mit Parametern starten - notwendige Einstellungen an das eigentliche Messgerät übertragen (Für 1 MHz Einstellungen an den Spektrum Analysator übertragen)
    Dim proc As Process = New Process()
    proc.StartInfo.FileName = Label_talk.Text
    '' 'proc.StartInfo.Arguments = " 18 " + Chr(34) + "RL -52dB;RB 10KHZ;VB 10HZ;AT 0DB;CF 1MHZ;SP 0HZ;ST 1000MS" + Chr(34)
    proc.StartInfo.Arguments = " 18 " & Chr(34) & "AT 0DB;SP 0HZ;" & AMPLITUDE & ";" & RESOLUTION_BW & ";" & VIDEO_BW & ";" & FREQUEMZ & ";" & SWEEP_TIMEms & Chr(34)
    proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden
    proc.Start()
    proc.WaitForExit()
    ''' wird wie abgesprochen verbessert
    - Relayschaltung 1 (Per RS232 werden drei Relays geschaltet - Schaltstellung 1)
    - Wartezeit für Messpunkt 1 MHz (z.B 1200 ms) Wird mit Timer1 gelöst. Nach jeder Veränderung der Relays muss eine bestimmte Zeit gewartet werden, die von der Messfrequenz abhäng
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte1.txt übertragen)
    proc.StartInfo.FileName = Label_binquery.Text
    proc.StartInfo.Arguments = " 18 " + Chr(34) + "TDF P TRA?" + Chr(34) + " messdaten1.txt"
    proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden
    proc.Start()
    proc.WaitForExit()
    ''' wird wie abgesprochen verbessert

    - Relayschaltung 2 (Per RS232 werden drei Relays geschaltet - Schaltstellung 2)
    - Wartezeit für Messpunkt 1 MHz
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte2.txt übertragen)

    - Relayschaltung 3 (Per RS232 werden drei Relays geschaltet - Schaltstellung 3)
    - Wartezeit für Messpunkt 1 MHz
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte3.txt übertragen)

    - Relayschaltung 4 (Per RS232 werden drei Relays geschaltet - Schaltstellung 4)
    - Wartezeit für Messpunkt 1 MHz
    - externes Programm mit Parametern - Messwerte auslesen (werden an die Datei Messwerte4.txt übertragen)

    - Berechnung aus den vier Einzelmessungen durchführen und für 1 MHz abspeichern und im Diagramm darstellen. Abgespeichert werden muss die Frequenz (in MHz) als X_Wert und das Messergebnis als Y-Wert.

    Nun wird alles für den nächsten Frequenzpunkt wiederholt.
    Gemessen wird für die Frequenzen (in MHz): 1,2,3,4,5,6,7,8,9,10,15,18,20,25,30,40,50,70,80,120,145,145,150,200

    Wird das jetzt deutlicher? Ich bin mir da nicht sicher, ob ich deine Fragen vollständig beantwortet habe.

    Es ist natürlich möglich, dass deine Ideen aus #12 mich überfordern würde und ich es so aufbauen muss wie ich es in #11 beschrieben habe.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „egon“ ()

    Du hast mich daran erinnert, dass ich Klassen schon bei der Programmierung von Mikrocontroller verwendet habe. Ich werde jetzt erst mal wieder etwas lesen müssen (Buch: VB2012 von Doberenz & Gewinnus). Da brauche ich etwas Zeit, da allesirgendwie anders ist. Ist dir zufällig eine bessere Literaturquelle hierzu bekannt?
    Auch wenn ich vielleicht den Prozessablauf noch nicht mit einem typDataset-basierten Datenmodell steuern kann, kann ich vielleicht den Code etwas übersichtlicher gestalten, indem alles etwas besser/übersichtlicher programmiert wird.
    Eine Klasse wäre für mich die Möglichkeit den gesamten Messvorgang etwas übersichtlicher auszulagern. Hast du es so gemeint?
    Mit dem Begriff "Entität" kann ich nichts anfangen.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    Verstehe ich den Vorschlag mit den Klassen so richtig, dass es sinnvoll wäre eine Klasse "Verstaerker" zu erschaffen, die für einen bestimmten Verstärker alle Informationen beinhaltet
    Klasse "Verstaerker"
    Mit den Properties: Name, Verstaerkung(frequenzabhängig), Rauschzahl(frequenzabhängig), Frequenz (Ist das ein Propertie?), Anzahl der Frequenzpunkte

    - Wie sind die einzelnen Frequenzpunkte in der neu zu erschaffenden Klasse Verstaerker einzusortieren? Sind das dann auch Properties? Wie werden sie übergeben?
    - Wird der Messablauf und die Berechnung dann auch innerhalb der Klasse "Verstärker" erledigt oder wird dies für eine bessere Übersicht irgendwie anders zusammengefasst.


    Bisher werden die Messpunkte so verwaltet: (mehrere Messkurven)
    Private _CurveDatas As CurveData() = {New CurveData(), New CurveData(), New CurveData(), New CurveData(), New CurveData(), New CurveData(), New CurveData(), New CurveData()}
    und

    Quellcode

    1. Public Class CurveData
    2. Public XValues() As Double 'Frequenzwert
    3. Public XValues_Anzeige() As Double 'Frequenzwert aufbereitet für die Anzeige in Hz, kHz oder MHz
    4. Public YValues() As Double ' Rauschzahl
    5. Public YValues_Anzeige() As Double
    6. End Class

    und übergeben an das Diagramm mit
    Chart1.Series(0).Points.DataBindXY(_CurveDatas(0).XValues_Anzeige, _CurveDatas(0).YValues)
    ach guck - du verstehst doch recht gut, wassich erzählt hab.

    egon schrieb:

    Eine Klasse wäre für mich die Möglichkeit den gesamten Messvorgang etwas übersichtlicher auszulagern. Hast du es so gemeint?
    Ja - nur gehts nicht nur um eine Klasse, sondern ein ganzes System davon: das Datenmodell.

    Und du hast ja auch schon angefangen, wenn du die Klasse Verstaerker hast, und die Klasse CurveData. Wie gesagt: da müssen noch einige weitere Klassen her, etwa "Messpunkt, RelaySchaltung, Messung, Messergebnis" hatte ich geraten.
    Und sowas ist eine Entität: Wenn es etwas inne Wirklichkeit gibt, was man im Datenmodell als Klasse abbildet.
    Und was ich geraten hatte ist natürlich zu 80% falsch, denn ich hab keine Ahnung von der fürs Datenmodell relevanten Realität.

    Allein der Punkt "Verstärkung" ist anders als von mir angenommen: Ich hab mir Verstärkung als einfache Zahl vorgestellt - tatsächlich ists aber eine Funktion v/F - da musste dir auch was für ausdenken, wie du diese komplexe Eigenschaft in deiner Verstaerker-Klasse ansiedelst.
    Wenns immer dieselben standardisierten Frequenzen sind, die gemessen werden, reicht eine Liste der Verstärkungen zu diesen Frquenzen. Aber kann auch komplizierter werden, mit Interpolieren und so - musst du wissen. Womöglich musste sogar eine kleine Klasse "Kennlinie" programmieren, und den Verstärker damit ausstatten.

    Und Ja - das gehört mit zum Plan: dass Funktionalität in die Klassen hineinkommt - aber da gibts kein Patentrezept: Manches gehört rein, manches nicht, und bei manchem ist auch beides möglich. Höchstunwahrscheinlich übrigens, dass vollständig

    egon schrieb:

    ...der Messablauf und die Berechnung dann auch innerhalb der Klasse "Verstärker" erledigt ... wird
    Aber sinnvolle Teile schon.


    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Wird gelöscht: Ich arbeite gerade an einer übersichtlichen Struktur und melde mich später. Danke
    (Dieser Beitrag wurde zu früh geschrieben...)


    Ich habe schon vor deiner Antwort versucht alles irgendwie auf einem Papier weiter zu strukturieren und versuche das mit aufzunehmen, was zu schreibst. Nur verstehe ich dich noch nicht so richtig, da ich die Mächtigkeit der Arbeit mit Klassen und dem was du Datenmodell nennst noch nicht richtig durchschaue/erfasse.

    Warum sollte ich eine Relay-Klasse erschafften, wenn bei jeder Messung vier Zustände nacheinander durchlaufen werden - unabhängig von der Messfrequenz
    Ich habe nun zwei Fragen (siehe unten).
    Hier aber noch zum Verständnis der Relayzustände: (Ich bin mir nicht sicher, ob das für die Diskussion wichtig ist)
    (1) Rauschquelle-ON zusammen mit dem Messobjekt soll veressen werden
    (2) Rauschquelle-OFF zusammen mit dem Messobjekt soll veressen werden
    (3) Rauschquelle-ON alleine ohne Messobjekt soll veressen werden
    (4) Rauschquelle-OFF alleine ohne Messobjekt soll veressen werden

    - Erleichtert z.B. eine Relay-Klasse die Programmierung des Messablaufes? Ich vermute, dass die Klassen irgendwie miteinander verschachtelt werden sollen
    - Arbeitet man mit globalen Zeigern oder werden dynamisch Elemente einer Klasse hinzugefügt oder entfernt um den Messablauf zu steuern?

    Ich melde mich, wenn ich eine für mich logische Struktur gefunden habe und bin dann gespannt ob und wie nachgebessert werden muss ;) Ihr seit mir eine große Hilfe - danke.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „egon“ ()

    egon schrieb:

    - Erleichtert z.B. eine Relay-Klasse die Programmierung des Messablaufes?
    Ja

    egon schrieb:

    Arbeitet man mit globalen Zeigern oder werden dynamisch Elemente einer Klasse hinzugefügt oder entfernt um den Messablauf zu steuern?
    Deine Begrifflichkeiten passen leider ühaupt nicht.
    Zeiger gibts in vb.net nicht. Und ich bin mir auch sicher, dass unter "global" ich was anneres verstehe als du. (ist auf jeden Fall hier nicht relevant).
    Und eine Klasse - das ist der Bauplan für Objekte. Den Bauplan erstellst du im Code-Editor, also einer Klasse kannste nix dynamisch zufügen, ebensowenig, wie man an einer technischen Zeichung einen Ölwechsel vornehmen kann.
    Für den Ölwechsel muss das Auto erstmal gebaut werden - anhand des Planes.
    Also du kannst Klassen so gestalten, dass den daraus erstellten Objekten was zugefügt werden kann - ja. Ja, und vlt. braucht man das auch um den Messablauf zu steuern - ich weiß noch zuwenig über deine Messabläufe.

    Zum Relay: Offsichtlich hat ein Relay 2 Knöpfe:
    RauschQuelle An/Aus
    MessenMitMessobjekt An/Aus

    Das sollte man durchaus als kleine Klasse gestalten.

    VB.NET-Quellcode

    1. public class Relay
    2. public RauschQuelleAn As Boolean
    3. public MessenMitMessobjekt As Boolean
    4. End Class


    Nein - bessere Idee: Was du in den Blick nehmen musst ist die Messung! Dann kannste das Relay weglassen:

    VB.NET-Quellcode

    1. public class Messung
    2. public Property RauschQuelleAn As Boolean
    3. public Property MitMessobjekt As Boolean
    4. ' weitere Properties: Startzeit, Dauer, Frequenz, ...
    5. End Class

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    So, hier nun das Ergebnis meiner Strukturierungsversuche. Leiter ist dieser Beitrag etwas lang geworden. Ich hoffe, dass ich nun auf dem richtigen Weg bin:

    Zu jeden Verstärker gehören folgende Eigenschaften und Schritte

    Jeder Verstärker hat die Eigenschaften:
    1. Name (String)
    2. Gesamtmessung gültig (Boolean)
    3. Anzahl der Messpunkte
    4. Name der Vergleichsrauschquelle
    5. Datum und Uhrzeit und Dauer des gesamten Messvorgangs (String)
    6. Benutzerhinweise zum Verstärker (String)
    7. Und ganz vielen Messpunkte mit X- und Y-Werten und weiteren Informationen (siehe unten)
    8. ?

    Vor der Messung
    - Für jeden Frequenzpunkte müssen Eigenschaften zugewiesen werden, da sie frequenzabhängig sind:
    1. Frequenz (Decimal oder zur Not auch Double)
    2. Messergebnis Rauschzahl (Double)
    3. Messergebnis Verstärkung (Double)
    4. Sind die Berechnungen für den Messpunkt gültig? (Boolean)
    5. Wert der Vergleichsrauschquelle für diese Frequenz (wird für die Berechnung später benötigt) (Double)

    Für die Messung
    Abhängig von der Frequenz müssen in bestimmten Intervallen bestimmte Einstellung des Messgerätes und bestimmte Wartezeiten beim Messvorgang beachtet werden. Zur Vereinfachung gehen wir von drei Frequenzintervallen aus:
    0-2,5 MHz 2,6 bis 7,5 MHz 7,5-200 MHz
    Abhängig von dem Frequenzintervall müssen folgende „Eigenschaften“ für den Messablauf jeweils den einzelnen Messpunkten zusätzlich zugewiesen werden
    1. Parameter für die Einstellungen des Messgerätes (String)
    2. Wartezeit bis sich die Messergebnisse stabilisiert haben.
    Diese Informationen könne natürlich auch vor einer Messung den einzelnen Frequenzpunkten zugewiesen werden und nicht dynamisch während des Messvorgangs. Das ist vielleicht deutlich einfacher und später vom Code her leichter und flexibler zu warten.

    Der Messablauf
    Jeder Messdurchlauf über alle Messpunkte kann für einen Verstärker bis zu 5 Minuten dauern. Damit das Programm nicht blockiert müssen die einzelnen Messschritte im Hintergrund laufen und jeweils einen Event auslösen, damit der nächste Schritt erfolgen kann.
    Zur Steuerung des Messablaufes werden folgende Informationen benötigt:
    1. An welcher Stelle befinde ich mich innerhalb des Messablaufes eines Frequenzpunktes (Integer)
    2. An welcher Stelle befinde ich mich innerhalb der Gesamtmessung (bei welchem Frequenzpunkt – quasi ein Zeiger der den Index wiederspiegelt) (Integer)

    Für jeden Frequenzpunkt
    Es folgt nun ein fester Messablauf. Die Teilschritte sind vermutlich für euch nicht so wichtig.
    1. Die bisher genannten Schritte durchführen
    2. Relaystellung 1 (per RS232 werden drei Relays geschaltet) Die Relaystellungen sind unabhängig von der Frequenz. Es werden bei jedem Frequenzpunkt die hier ausgelisteten Zustände benötigt.
    3. externes Programm mit Parametern starten, die vom Frequenzintervall abhängen (Messgerät wird eingestellt)
    4. Wartezeit damit sich die Messwerte stabilisieren können (abhängig von einem der drei Frequenzintervalle)
    5. externes Programm zum Auslesen der Messwerte starten (werden nach messwerte1.txt gespeichert)
    6. Relaystellung 2
    7. Wartezeit (wie in Punkt 4.)
    8. Wie Punkt 5. - externes Programm zum Auslesen der Messwerte starten (werden nun aber nach messwerte2.txt gespeichert)
    9. Relaystellung 3
    10. Wartezeit (wie in Punkt 4.)
    11. Wie Punkt 5. - externes Programm zum Auslesen der Messwerte starten (werden nun aber nach messwerte3.txt gespeichert)
    12. Relaystellung 4
    13. Wartezeit (wie in Punkt 4.)
    14. Wie Punkt 5. - externes Programm zum Auslesen der Messwerte starten (werden nun aber nach messwerte4.txt gespeichert)
    15. Berechnung durchführen. Es werden die vier *.txt Dateien ausgelesen und die Werte für das Rauschen und die Verstärkung berechnet. Also dem Frequenzpunkt je ein Wert für Rauschen und die Verstärkung zugeordnet.
    Messergebnis für den Frequenzpunkt abspeichern/übergeben
    Wert für Berechnung_gültig = true setzen

    Nach der Messung/ Berechnung aller Frequenzpunkte
    Nach der Messung/ Berechnung aller Frequenzpunkte werden dann alle Informationen dem Diagramm (Chart) übergeben. Die Programmierung des Charts steht und kann dem neuen Ablauf angepasst werden. Die Erstellung einer Diagramm-Klasse könnte dann zu einem späteren Schritt erfolgen (um es nicht noch komplexer zumachen)…
    Momentan vorgesehen sind die Frequenzen (in MHz): 1,2,3,4,5,6,7,8,9,10,15,18,20,25,30,40,50,70,80,120,145,145,150,200
    Nun sind aber in einem späteren Schritt auch weitere Frequenzen möglich.

    Weitere Schritte
    Nun fehlen mir die richtigen Vokabeln. Vielleicht bin ich aber trotzdem verständlich.

    Es wird benötigt eine übergeordnete Klasse „Verstärker“ Zu dieser Klasse gehört eine Messpunkte-Klasse und eine Messablauf-Klasse
    In diesen Klassen sind dann die aufgelisteten Informationen und die Ablaufsteuerung enthalten.
    Ist das sinnvoll?