Sub VI soll im Hintergrund weiterlaufen

Hi folks,

wie der Name oben schon sagt arbeite ich gerade mit Sub VIs.
Dabei werden die Daten des Frontpanels an ein Sub VI übergeben, dass die entsprechenden Befehle ausführt. Z.B. einen bestimmten Temperaturwert in einer bestimmten Zeit erreichen.

Nun soll in dem Sub VI aber die (eben genannte) Zeit mitlaufen, sodass Lab View selbstständig reagieren kann, sobald diese abgelaufen ist. Mein Problem ist eben nur, sobald ich das Unterprogramm verlasse und wieder auf das Front Panel zurückkehre, kann ich da (scheinbar?!?) nicht mehr agieren, weil Lab View erst noch das Ende des Unterprogramms abwartet?!?

Vielleicht bissel verquer meine Beschreibung, aber genauso fühle ich mich auch gerade bei der Programmierung mit diesen verschiedenen "Ebenen". :-(

Cheers.

Anzeige

Hallo,

lass Dein SubVi in einer parallelen Schleife laufen oder lasse ein extra VI laufen und übergebe die Daten in einer globalen Variable.

kpa

Hi,

das mit der globalen Variablen war eine gute Idee.

Leider habe ich immernoch ein Problem und weiß nicht genau ob es jetzt an der Verwendung der globalen Variablen liegt oder an der Programmstruktur von Lab View.

Und zwar habe ich zwei While Schleifen nebeneinander geschalten, wovon die erste mit einem Boolean beendet wird ("Stop if true" mit Boolean und "Waiting for front panel activity"), der gleichzeitig die globale Variable darstellt.
Durch das Beenden werden ja die Daten aus der Whileschleife zum weiteren Verarbeiten frei gegeben...

...und dann an die zweite While Schleife übergeben.
Darin werden nun die Daten Schritt für Schritt in einer Sequenz weiterverarbeitet. Dass sie Sequnez nun nicht unendlich oft wiederholt wird (While die Whileschleife auf "continue if true" steht mit einer "true constant") halte ich sie im letzten Schritt an, indem ich sie an die Globale Variable kopple (Whilfe Schleife auf "Stop if True" mit der Globalen Variablen als Boolean).


Der Boolean steht auf Mechanical Action: "Latch when released"

Meine Intention ist also:
Ich bestätige die Eingabe in der ersten While Schleife mit der Boolean Variable und somit kann auch die zweite Whileschleife loslaufen. Durch das Latch when released geht globale Variable wieder in den "false-Zustand" über, sodass doch die zweite Schleife nur einen Durchlauf der Sequenz erlauben dürfte, weil sie im letzten Schritt wieder angehalten wird.

Leider funktioniert das alles nicht so, sondern die zweite. Schleife wird wieder und wieder ausgeführt. :-(

Please help.

Cheers.

Hi folks,

also hier mal die Konkretisierung meines Problems: Ich denke es hängt echt an der globalen Variablen.

Und zwar in Kombination mit diesem Boolean und der Mechanical Action: Latch when Released.

Wenn ich diesen OK Button (Boolean) drücke, so schreibt das doch ein "true" in die globale Variable.
Nur dieser Button geht ja dann durch die eingestelle Mechanical Action wieder in den Ausgangszustand. Und steht somit wieder auf false.
Und schreibt das nicht "false" in die globale Variable?!?

Zumindest habe ich den Eindruck, dass es so ist. :-(

Cheers.

' schrieb:das mit der globalen Variablen war eine gute Idee.

"Globale Variablen" sind nie guten Ideen, wenn dann eine Lokale Variable (resepktive ein neues Bedien/Anzeige-Element).

Zitat:Leider habe ich immernoch ein Problem und weiß nicht genau ob es jetzt an der Verwendung der globalen Variablen liegt oder an der Programmstruktur von Lab View.

Wenn, dann nicht an der Programmstruktur von LV, sondern an "deiner". Du generierst ja die Programmstruktur.

Zitat:Und zwar habe ich zwei While Schleifen nebeneinander geschalten, wovon die erste mit einem Boolean beendet wird ("Stop if true" mit Boolean und "Waiting for front panel activity"), der gleichzeitig die globale Variable darstellt.

Wäre an sich nix gegen einzuwenden.

Zitat:Durch das Beenden werden ja die Daten aus der Whileschleife zum weiteren Verarbeiten frei gegeben...

Alle Daten, ob Global oder Lokal, sind grundsätzlich "freigegeben". Auch wenn die eine While-Schleife noch läuft, kann die andere While-Schleife auf deren Daten zugreifen.

Zitat:Meine Intention ist also:
Ich bestätige die Eingabe in der ersten While Schleife mit der Boolean Variable und somit kann auch die zweite Whileschleife loslaufen. Durch das Latch when released geht globale Variable wieder in den "false-Zustand" über, sodass doch die zweite Schleife nur einen Durchlauf der Sequenz erlauben dürfte, weil sie im letzten Schritt wieder angehalten wird.

Das klinkt aber sehr nach einen linearen Ablauf. D.h, du benötigst nicht unbedingt zwei parallel laufende Prozesse, sondern lediglich einen sequenzierten Ablauf: Erst soll die eine While-Schleife etwas machen, dann wird sie beendet, danach soll in der zweiten While-Schleife etwas gemacht werden. Ist dem so, oder hab ich dich falsch verstanden?
Wenn dem so ist, müssen die While-Schleifen nicht parallel sein - hintereinander, also sequenziert, wäre da doch ausreichend. Dass der Gesamtvorgang (erste While-Schleife, dann zweite While-Schleife) selbst wiederholbar sein soll (was mit einer übergeordneten While-Schleife ginge) ist ein anderer Aspekt.

Kannst du notfalls mal ein Muster-VI machen und posten?

Zitat:Das klinkt aber sehr nach einen linearen Ablauf. D.h, du benötigst nicht unbedingt zwei parallel laufende Prozesse, sondern lediglich einen sequenzierten Ablauf: Erst soll die eine While-Schleife etwas machen, dann wird sie beendet, danach soll in der zweiten While-Schleife etwas gemacht werden. Ist dem so, oder hab ich dich falsch verstanden?
Wenn dem so ist, müssen die While-Schleifen nicht parallel sein - hintereinander, also sequenziert, wäre da doch ausreichend. Dass der Gesamtvorgang (erste While-Schleife, dann zweite While-Schleife) selbst wiederholbar sein soll (was mit einer übergeordneten While-Schleife ginge) ist ein anderer Aspekt.

Das mit dem linearen Ablauf ist eben das Problem.

Von meiner Programmierung her geht es in der ersten Schleife darum eine Befehlskette in Form eines 2D Arrays zusammenzustellen.

In der zweiten Schleife geht es nun darum diese Befehlskette auszuführen, indem die einzelnen Befehle an die entsprechende Portnummer geschickt werden.

ABER!
Weshalb ich diesen parallelen Aufwand betreibe, ist die Tatsache dass das Erstellen einer neuen Befehlskette möglich sein soll noch während das Ausführen im Gange ist.

Sprich der Benutzer hat eine Befehlskette eingegeben, welche den Temperaturverlauf für 4 verschiedene Öfen vorgibt.
Jetzt klickt er auf OK und die Befehle werden ausgefüht.
Jetzt bemerkt er nach einiger Zeit (der Temperaturverlauf ist noch nicht beendet), dass er sich bei einer der Öfen geirrt hat. D.h. er möchte für diesen einen neuen Befehl erstellen ohne dass die anderen davon beinträchtigt werden.

Hope that helps.

Was das Muster angeht, schaue ich mal, da ich das ganze auf verschiedene Unterprogramme verteilt habe.

Cheers.

Anzeige

' schrieb:Von meiner Programmierung her geht es in der ersten Schleife darum eine Befehlskette in Form eines 2D Arrays zusammenzustellen.
In der zweiten Schleife geht es nun darum diese Befehlskette auszuführen, indem die einzelnen Befehle an die entsprechende Portnummer geschickt werden.
ABER!
Weshalb ich diesen parallelen Aufwand betreibe, ist die Tatsache dass das Erstellen einer neuen Befehlskette möglich sein soll noch während das Ausführen im Gange ist.
Sprich der Benutzer hat eine Befehlskette eingegeben, welche den Temperaturverlauf für 4 verschiedene Öfen vorgibt.
Jetzt klickt er auf OK und die Befehle werden ausgefüht.
Jetzt bemerkt er nach einiger Zeit (der Temperaturverlauf ist noch nicht beendet), dass er sich bei einer der Öfen geirrt hat. D.h. er möchte für diesen einen neuen Befehl erstellen ohne dass die anderen davon beinträchtigt werden.

Gut, jetzt bin ich dabei. (Jetzt brauch ich auch kein Muster mehr).

Vorschlag:
Mach ein VI, in dem der Benutzer seine Verläufe generiert. Dass dieses VI schon aufwändig werden kann, steht hier nicht zur Debatte. Irgendwann ist der Bediener mit Erstellen eines Verlaufes respektive mehrerer Verläufe fertig. Zu diesem Zeitpunkt klickt der Bediener auf einen Button "Daten zur Ausführung senden". Jetzt sendet dieses VI den Verlauf respektive die Verläufe mittels Queue an das ausführende VI. (Dass bei vier Öfen vier mal per Queue gesendet wird, steht auch nicht nicht zur Debatte. Hat den Vorteil: Oh, da passt einer nicht, dann ändern wir nur einen). Nach dem Senden läuft diese VI weiter. Der Benutzer will ja schließlich einen Verlauf anpassen können.

Außerdem hast du ein zweites VI (eigenlich einen zweiten "Prozess"), das die Verläufe abarbeitet. (Überlegung: Das VI abreitet nur einen einzigen Ofen ab. Durch Instanzierung des VIs (invariante Ausführung), können beliebig viele genau dieser VIs parallel laufen.) Dieses VI holt sich die Daten aus der Queue - und arbeitet genau diesen Ablauf ab.

Durch das Managemant der Verläufe mittels Queue/Melder entsteht eine Entkopplung zwischen Eingabe und Abarbeitung der Verläufe.

Bedenke, dass das Abarbeiten eines Verlaufes ggf. angehalten werden muss. Das würde auch per Queue aus der Eingabemaske heraus geschehen können.

Das, was du bisher als While-Schleife bezeichnet hast, fällt eher unter den Begriff "Task", "Prozess" etc. Im Endeffekt würdest du diese beiden "Haupt-VIs" ganz einfach parallel in ein übergeordnetes VI legen - dann würde beide parallel ausgeführt werden.

Kannst du meiner Intension, die beiden Vorgänge "Eingabe" und "Abarbeitung" so wie beschrieben zu trennen und entsprechend abzuarbeiten, folgen?

Und noch ein Nachtrag:
Ich sehe gerade du hast LV 61? Gibts denn da schon Queues? Kommst du nicht irgendwie an was aktuelles?

Hi,

spontan sagt mir das alles nix. Dafür bin ich noch zu neu bei Lab View.

Aber wie es der Zufall so wollte hatte eben ein Kumpel Zeit, dem ich meine Problematik geschildert habe und der unabhängig von dir mit der Idee der Queues kam.

Hat mir eben mal schnell die grobe Programmskizze programmiert mit all den neuen Programmelementen, die ich noch nix zuvor gesehen hatte.

Werde mich da jetzt also einarbeiten, dass ich das in die Tat umsetzen kann.

Dank dir!

Cheers.

Hi,

also das mit den Queues funktioniert jetzt halbwegs. Leider nur halbwegs. :-(

In der Schleife links unten wird der Rampen Array erstellt und dann per Lokale Variable in der Schleife rechts darüber in die Queue geschoben GENAU DANN, wenn ich den "Ok" Button drücke. Dann merkt der Queue doch eine Aktivität und das neue Element wird in der Schleife oben drüber ausgelesen und zur Ausführung geschickt.

Jetzt habe ich nur das Problem, dass immer der Array ausgeführt wird, den ich ganz zu anfang eingegeben habe. Wenn ich nachträglich einen anderen eingebe, so wird immernoch der erste asugeführt.
Hängt das irgendwie an der Art wie ich die Queue fülle? Trotz FiFo?

Cheers.

Edit: Ich habe die max. Size mittlerweile von 1 auf -1 gestellt. Trotzdem tut sich nix.

' schrieb:Hängt das irgendwie an der Art wie ich die Queue fülle?

Ja, da kann ich doch beruhigt ja sagen - heißt: liegt im Endeffekt an deinem "Algorithmus".

Für was brauchst du denn die mittlere While-Schleife? Nur zum Weiterleiten des Array-Inhaltes? Dafür brauchst du keine While-Schleife.

Mach das Weiterleiten (Schreiben in die Queue) in die große Schleife - und zwar im True-Case nach dem Bedienelement Rampen.

So wie du das gepostet hast, besteht ein weiterer Fehler: Die Variable RampenArray hat immer den selben Wert. Deine Hauptschleife wird nie verlassen (außer Programmabbruch). Daher wird das Anzeigeelement nie beschrieben, sodass in der Lokalen Variablen nie was neues hineinkommt.

Im Schieberegister steht zwar immer die Aktuelle Eingabe - dort wird es aber niemals herausgeholt.