Wenn dein Problem oder deine Frage geklärt worden ist, markiere den Beitrag als "Lösung",
indem du auf den "Lösung" Button rechts unter dem entsprechenden Beitrag klickst. Vielen Dank!
diesmal wieder eine LabVIEW spezifische Frage, bei der ihr mir sicher helfen könnt.
Und zwar hat das jetzt alles wunderbar geklappt, dass ich meinen Temperaturregler mittels LabVIEW programmieren kann und er dann eine gewisse Sequenz durchläuft.
Jetzt habe ich ein neues Programm geschrieben, dass er die Sequenz abbricht und anstatt komplett zurückzufahren einfach die momentane Temperatur halten soll.
Soviel zum Rahmen
Jetzt eben meine Frage: Wie implementiere ich das zweite Programm in meinem ersten?
Also mir schwebt da auf der Oberfläche des ersten Programms dieser klassische rote Button vor, den ich drücken kann und er dann das zweite Programm, sprich den Abbruch initialisiert.
bisher konnte ich meine Programme mit Sequenzen erarbeiten, da die Ausführungen zeitlich linear waren. Das heißt konkret ich habe in jedem einzelnen Abschnitt Parameter eingegeben, die verarbeitet wurden und schließlich einen Wert ausgegeben haben.
Jetzt habe ich aber eine neue Problemstellung:
Und zwar soll das Programm in Ausgangsstellung warten, den Input ausführen und dann wieder in die Ausgängsstellung springen, um auf eine Änderung reagieren zu können.
Sprich konkret hab ich einen Schließmechanismus, der zu Beginn geöffnet oder geschlossen werden soll, dann habe ich anschließend eine Messung, welchhe die Öffnung oder Schließung bestätigt. Aber dann ist der Ablauf eben nicht einfach fertig, wie ich es mit einer Sequenz machen würde. Sondern das Programm soll wieder an den Anfang laufen und dort warten, bis ich den Schalter umlege. Sprich, wenn ich mit Schließung begann, soll es warten bis ich den Hebel auf Öffnung umlege.
Mit Sequenzen geht das scheinbar nicht.
An eine While Schleife habe ich auch schon gedacht, aber das Programm soll ja nicht zig mal ausgeführt werden, sondern nur einmal und dann verharren.
Bei einer For-Schleife habe ich das Problem, dass ich die Anzahl der Ausführungen ja noch nicht kenne, sondern es erstmal x beliebig oft sein soll.
Wäre für einen Stups in die richtige Richtung dankbar.
leider bin ich aus den Vorschlägen nicht ganz schlau geworden. Hinzu kam, dass ich die Beispiele zum herunterladen nicht verwenden konnte, da ich nur LabVIEW 6 habe :-(
Mittlerweile habe ich mir etwas anderes überlegt, auch wenn das vielleicht weniger elegant ist.
Anstatt zu überlegen wie ich das Programm in Bereitschaft halte dachte ich mir, dass ich so eine While Schleife doch beliebig oft durchlaufen lassen kann nur soll dann eben eine Fallunterscheidung bei jedem Durchlauf gemacht werden was zu tun sei. Also am Ende des Programmdurchlaufs soll ein Zustand ausgegeben werden, der dann mit erneutem Durchlauf des Programms verglichen werden soll. Sind die Zustände gleich, einfach warten und dann das Programm erneut ausführen und sind sie verschieden auf den neuen Zustand reagieren.
Ich glaube das kann ich mit Schieberegister realisieren, falls ich dessen Anwendung richtig verstanden habe.
Allerdings hapert es noch ein wenig bei der Ausführung :-(
Wie ich es mir also vorstelle:
Das Programm wird gestartet und ich stelle den Schalter auf EIN. (Spannung wird angeschalten, Lämpchen leuchtet, etc.) am Ende soll dann quasi der Zustand TRUE gemerkt werden.
Nur läuft das Programm erneut durch (While Schleife eben) und ich habe den Schalter nicht verändert.
Nun soll verglichen werden: Zu merkenden Zustand ist TRUE, Schalter steht auf TRUE (Ein) - mache also nichts bis zum nächsten Durchlauf (Z.B. mit Wait x ms).
Erst wenn ich den Schalter auf AUS Stelle (FALSE) soll das Programm merken, dass ich sich etwas getan hat, denn der zu merkende Zustand war TRUE und das ist ungleich FALSE. Also soll es jetzt reagieren und die Aktion durchführen, auf die der Schalter steht: AUS
Was mir allerdings noch ein wenig Kopfzerbrechen macht ist der erste Durchlauf: Denn dort gibt es eigentlich noch keinen Wert zum Vergleich. Es gibt noch keinen zu merkenden Endzustand.
Ich müsste also eine Variable haben, die einen Endzustand simuliert und von mir willkürlich festgesetzt wird (dass das Programm eben starten kann) und dann nach dem ersten Durchlauf überschrieben wird (mit dem zu merkenden Endzustand).
Gibt es dafür eine Funktion?
' schrieb:Ich müsste also eine Variable haben, die einen Endzustand simuliert und von mir willkürlich festgesetzt wird (dass das Programm eben starten kann) und dann nach dem ersten Durchlauf überschrieben wird (mit dem zu merkenden Endzustand).
Gibt es dafür eine Funktion?
Das was du dir da ausgedacht hast entspricht im weitesten Sinne einer State Machine
Zu obigen Frage: Du kannst (musst!) das Schieberegister Initialisieren, d.h. eine Konstante außerhalb der Schleife anschließen. Damit kannst du dann vergleichen. Die Initialisierung ist nur beim ersten Schleifendurchlauf wirksam!
"Is there some mightier sage, of whom we have yet to learn?"
"Opportunity is missed by most people because it is dressed in overalls and looks like work." (Thomas Edison)
Tut mir leid, aber es hapert noch an der Ausführung.
Das mit dem außerhalb Initialisieren hat mir eingeleuchtet, jedoch löst es meiner Meinung nach leider nicht das grundsätzliche Probleme.
Ich versuche es mal ganz allgemein zu fassen:
Zuerst initialisiere ich das ganze mit einer Konstanen außerhalb und durchlaufe die normale Sequenz. Dann wird eine Boolsche Variable rechts an das Schieberegister gegeben, die links wieder hineinkommt.
Und jetzt soll der eigentliche Kreislauf losgehen? Dann muss ich doch aber wieder irgendwann eine Boolsche Variable nach rechts ausgeben...
Also grob gesprochen: Die zwei Kreisläufe laufen irgendwann zusammen und spätestens da bringt LabVIEW eine Fehlermeldung.
Ich habe die Konstante einfach so hineingezogen, bis ich herausgefunden habe, dass ich die schon links an den zu übergebenden Wert des Schieberegisters koppeln kann.
ich versuch gerade die Verwendung der SubViews zu verstehen und deren Einbinung in andere Programme.
Dazu habe ich als Programm einen einfachen Schalter, der abwechseln ein Licht AN bzw. AUS leuchten lässt, je nachdem wie er gerade steht (Boolean -> true / false). (bild1)
Also habe ich für dieses Programm den Schalter (Boolean) und die beiden Lampen (Indicator) als Connector angegeben.
Diese habe ich in ein neues Programm eingebunden, in dem einfach die Boolean mit einer neuen Boolean velinkt wird und die beiden Indicator mit neuen Indicatorn versehen. Quasi als wäre das Miniprogramm mit seiner Case Structure jetzt eine "Black-Box" in seiner Funktionsweise. (bild2)
Wenn ich das Programm jetzt aber laufen lasse, so reagieren die Lampen nicht auf den übergeordneten Schalter. :-(
Fehler in der Denkweise der Datenfluss-Struktur von LV.
Ein SubVI gibt erst dann die Ausgänge an das übergeordnete VI weiter, wenn es beendet ist und alle Ausgänge auch "anliegen". Zwecks While-Schleife im SubVI wird dein SubVI aber NIE beendet.
MfG, Jens
Wer die erhabene Weisheit der Mathematik tadelt, nährt sich von Verwirrung. (Leonardo da Vinci)
!! BITTE !! stellt mir keine Fragen über PM, dafür ist das Forum da - andere haben vielleicht auch Interesse an der Antwort!
