Ablaufinvariant (Reentrant) vs. Vorlage (.vit)

Moin moin,

ich benötige von einer VI, die für einen bestimmten Messgeräte-Typ die Ansteuerung übernimmt, mehrere Instanzen (für jedes vorhandene Gerät eine), die u.a. die Adresse des zugeordneten Geräts speichern. Im weiteren Programmverlauf würde ich über diese Instanzen dann also "direkt" auf das entsprechende Messgerät zugreifen, ohne jedes Mal Adresse und dergleichen übergeben zu müssen.

Bei meinen Recherchen bin ich auf zwei Techniken gestoßen, mit denen ich Instanzen erzeugen kann: Ablaufinvarianten und Vorlagen (also .vit). Mit den Vorlagen habe ich jetzt schon ein wenig rumgespielt und denke, dass sie sich für mich eignen. Die Frage ist nun ob Ablaufinvarianten, also reentrante VIs diesen Job ebenfalls erledigen können? Und wenn ja, besser oder schlechter? Alle Beispiele zu reentranten VIs, die ich bisher gefunden habe, beziehen sich lediglich auf zeitaufwändige, parallele Berechnungen, die sonst nacheinander ablaufen würden.
In meinem Fall muss ich aber zu einem späteren Zeitpunkt im Programm explizit auf eine ganz bestimmte Instanz zugreifen.


Bin für jeden Hinweis dankbar

Anzeige

' schrieb:Moin moin,

ich benötige von einer VI, die für einen bestimmten Messgeräte-Typ die Ansteuerung übernimmt, mehrere Instanzen (für jedes vorhandene Gerät eine), die u.a. die Adresse des zugeordneten Geräts speichern. Im weiteren Programmverlauf würde ich über diese Instanzen dann also "direkt" auf das entsprechende Messgerät zugreifen, ohne jedes Mal Adresse und dergleichen übergeben zu müssen.

Bei meinen Recherchen bin ich auf zwei Techniken gestoßen, mit denen ich Instanzen erzeugen kann: Ablaufinvarianten und Vorlagen (also .vit). Mit den Vorlagen habe ich jetzt schon ein wenig rumgespielt und denke, dass sie sich für mich eignen. Die Frage ist nun ob Ablaufinvarianten, also reentrante VIs diesen Job ebenfalls erledigen können? Und wenn ja, besser oder schlechter? Alle Beispiele zu reentranten VIs, die ich bisher gefunden habe, beziehen sich lediglich auf zeitaufwändige, parallele Berechnungen, die sonst nacheinander ablaufen würden.
In meinem Fall muss ich aber zu einem späteren Zeitpunkt im Programm explizit auf eine ganz bestimmte Instanz zugreifen.
Bin für jeden Hinweis dankbar

VITs sind nur für die Entwicklungs-Umgebung gedacht, damit kopiert man praktisch bestehden Code in ein neues VI. Die Idee diese zur Laufzeit per VI-Server erzeugen zu lassen ist keine gute - auch wenn es geht. Die "richtige" Methode zur Erzeugung von Instanzen von einem bestimmten VI ist, dieses als reentrantes VI zu entwicklen und mehrfach im Code zu verwenden.

Wenn du dann später auf bestimmte Instanzen zugreifen musst, dann musst du dir einen Zugriffsmechanismus überlegen. Ich verwende dazu z.B. immer Queues: beim Start des Reentranten VIs erzeugt dieses VI eine Queue und sendet die Queue-Referenz an ein "Verwaltungs-VI". Damit kann ich dann dieses Reentrante VI wie ein Objekt verwenden ...

Erstmal danke für die Antwort!


Das klingt ja schon mal ganz gut. Da ich allerdings noch LabVIEW-Neuling bin (Learning by doing), habe ich mit Queues noch nix gemacht. Makuckn ob ich das irgendwie hinbekomme
Oder hast du vielleicht ein kurzes Beispiel parat?

Ich hab jetzt mal ein bischen rumgespielt und die Referenz der Instanzen in einem Array gespeichert. Von da aus greife ich dann über Methodenknoten auf die Elemente zu, starte die Instanz-VI und lese die Ausgabeelemente wieder aus.
Der Nachteil dieses Arrays ist, dass ich anhand der Referenz nicht auf den ersten Blick erkennen kann welche Instanz sich dahinter verbirgt. Später sollte es ja so sein, dass ich z.B. zwei Messgeräte habe, von denen eines den Eingangs- und das andere den Ausgangswiderstand misst. Am liebsten würde ich daher die Instanzen mit einem Namen ansprechen. Bei OpenG habe ich mir das Dictionary-Paket runtergeladen, funktioniert auch, aber geht das nicht auch irgendwie anders?

Wie ich das ganze nu aber mit Queues lösen soll - wie du es vorgeschlagen hast - weiß ich nicht. Machst du das jeweils über eine Ein- und Ausgabe-Queue pro Instanz oder wie? So nach dem Motto vorne immer Befehle an die VI in die InputQueue reinschieben und das Ergebnis dann hinten aus der OutputQueue auslesen?

Wäre super, wenn du mir ein Beispiel geben könntest wie du das machst.



Hier mein kleiner Test (LV 8.6)


  InstanzenTest.zip (Größe: 26,11 KB / Downloads: 294)

' schrieb:Wie ich das ganze nu aber mit Queues lösen soll - wie du es vorgeschlagen hast - weiß ich nicht. Machst du das jeweils über eine Ein- und Ausgabe-Queue pro Instanz oder wie? So nach dem Motto vorne immer Befehle an die VI in die InputQueue reinschieben und das Ergebnis dann hinten aus der OutputQueue auslesen?

Wäre super, wenn du mir ein Beispiel geben könntest wie du das machst.
Hier mein kleiner Test (LV 8.6)

genau so. Jedes "Modul" (=reentrantes VI) erzeugt eine eigene Queue mit einem eigenen Namen. Die Queue Referenz der Instanz wird wiederum an ein "Verwaltungs-Modul" übergeben, so dass ich sowohl zur Instanz (über die Instanz-Queue) als auch aus der Instanz heraus kommunizieren kann.

Ein Beispiel findest du im Anhang ...


  Modul_Bsp.LV851.zip (Größe: 80,97 KB / Downloads: 348)

hmm ... klappts?

wenn ich mich schon ne Stunde hinsetzte und ein Beispiel programmiere hätt ich doch irgendwie ganz gern mal Feedback

Anzeige

Hi!

Danke für das Beispiel und deine Mühe! Ich lag seit Samstag flach wegen einer Mandelentzündung, daher melde ich mich so spät.

Also das Beispiel funktioniert und ich bin gerade dabei, es komplett zu verstehen. Wie gesagt Queues sind noch Neuland für mich


Ich gebe mal kurz wieder wie ich dein Beispiel verstehe:

Programmstart: MainQ wird erzeugt; MainQ verwaltet die "Befehle" an die Module.
Modulstart: Modul registriert sich über die MainQ; ModulQ wird in Array gespeichert.
Increment-Klick: Increment-Befehl für Modulx an MainQ => Increment-Befehl an ModulxQ => Get-Befehl an ModulxQ => Get-Befehl an MainQ => Anzeige


Ich frage mich allerdings ob das Speichern der ModulQ im Array notwendig ist? Kann man die Queue nicht einfach über den Namen ansprechen? Am liebsten würde ich es nämlich vermeiden, Instanzen über einen ArrayIndex anzusprechen, da dabei die Zuordnung Index<->Name nicht klar ersichtlich ist. Gerade in meinem Falle wo an einem Arbeitsplatz mehrere verschiedene Messgerätetypen verwendet werden. Da hat man dann in einem Array plötzlich 2 Keithley, 1 Fluke, 1 DMP40 , etc. Ein "gemischtes" Array über Indizes anzusprechen behagt mir daher nicht.
Bei OpenG hab ich mir das Dictionary-Paket geladen wo man die Daten mit Schlüsseln speichern kann. Allerdings wundert es mich, dass LV sowas nicht selbst anbietet
Aber braucht man das bei Queues überhaupt? Schließlich haben sie ja einen Namen, den ich direkt ansprechen kann?

' schrieb:Aber braucht man das bei Queues überhaupt? Schließlich haben sie ja einen Namen, den ich direkt ansprechen kann?

müsste auch gehen, mir ist das irgendwie "lieber", wenn ich die Referenzen in einem Array habe ...

' schrieb:VITs sind nur für die Entwicklungs-Umgebung gedacht, damit kopiert man praktisch bestehden Code in ein neues VI. Die Idee diese zur Laufzeit per VI-Server erzeugen zu lassen ist keine gute - auch wenn es geht. Die "richtige" Methode zur Erzeugung von Instanzen von einem bestimmten VI ist, dieses als reentrantes VI zu entwicklen und mehrfach im Code zu verwenden.

Eine Frage habe ich noch. Und zwar geht es um die Instanzierung selbst. In deinem Beispiel hast du die Reentrante VI einfach 2x ins BD eingebaut. Dadurch werden ja auch zwei feste Instanzen erzeugt. Wenn ich nun aber "auf Knopfdruck" neue brauche, geht das so nicht, oder? Dann müsste ich das ja wieder über den VI-Server zur Laufzeit tun. Im obigen Zitat meintest du das sei keine gute Idee. Oder bezog sich das nur auf die VITs?

So stelle ich mir das vor (unabhängig von Queues, etc.):