Application aus über globale Variablen verknüpften VIs

Guten Tag,

ich bin relativ neu in der Verwendung von Labview, und möchte nun das erste mal mit dem Application Builder ein Projekt kompilieren. Das Projekt sieht folgendermaßen aus, dass es aus mehreren verschiedenen main.vis besteht, die jeweils noch weitere sub.vis aufrufen. Diese main.vis kümmern sich jeweils um eigene Aufgaben (zB Steuerung Kamera, erstellen von visuellen Outputs etc.) und laufen an und für sich völlig unabhängig voneinander, es gibt keinen gegenseitigen Aufruf. Die einzige Kommunikation dieser vis geschieht über gemeinsame globale Variablen, die von allen gelesen und geschrieben werden.

Bevor ich mich nun in die Verwendung des Application Builders vertiefe, wollte ich einfach kurz nachfragen, ob bzw. wie man ein solches Projekt kompilieren könnte.
Muss ich dabei, insbesondere durch die Verwendung der globalen Variablen, auf irgendwas bestimmtes achten? Kompiliere ich die einzelnen main.vis selbstständig, und lasse sie so wie in labview parallel laufen? (Ich denke, da stellt sich dann das Problem der globalen Variablen, aber ich weiß eh nicht so ganz, wie Labview das in komiplierten Programmen löst...)

Oder muss ich das Projekt als solches komplett kompilieren, wobei mir dann noch nicht klar ist, wie ich den Aufruf der einzelnen vis gestalten sollte, da sie, wie gesagt, keine Verknüpfung untereinander bis auf die globalen Variablen besitzen?

Für jeden Gedanken, auch die Aussage: Wie kann man nur bin ich sehr dankbar!!!

Grüße

Anzeige

Hallo,

um zu mindestens den ersten Problemen aus dem Weg zu gehen würde ich hergehen und eine "Starter VI" basteln, was letztlich alle benötigten VIs per "Call by Reference" oder "Asynchronous Call" lädt und startet. Aber da du selbst schreibst dass du ein LabVIEW Anfänger bist, würde ich mir an deiner Stelle wirklich Gedanken machen, ob der Einsatz von globalen Variablen bei deinem beschriebenen Einsatzzweck wirklich sinnvoll sind? Du sagst die VIs laufen alle unabhängig voneinander, tauschen aber scheinbar irgendwie Daten per globale Variablen aus. Für mich klingt das im ersten Moment voll danach als wären "Race Conditions" vorprogrammiert. Prinzipiell werden die globalen Variablen auch nicht funktionieren wenn du alle deine "main.vi's" als eigenständige Applikation (*.exe) kompilierst. Hierzu müsstest du andere Mechanismen einsetzen, was das Ganze aber im Moment nicht einfacher werden lässt. Darum siehe oben.

Zum Thema globale Variablen hier mal etwas zum Nachlesen: http://www.ni.com/white-paper/7585/en

Schöne Grüße
Falk

(28.08.2012 08:57 )JoeFritzegard schrieb:  Guten Tag,

ich bin relativ neu in der Verwendung von Labview,

Zur generellen Einarbeitung empfehlen sich auch folgende Links: (falls noch nicht bekannt )

(20.01.2012 11:02 )NWOmason schrieb:  Getting Started with NI LabVIEW Student Training
http://zone.ni.com/devzone/cda/tut/p/id/7466

Introduction to NI LabVIEW - Learn LabVIEW Basics
http://www.ni.com/gettingstarted/labviewbasics/

Sonst kann ich denn Post von Falk nur voll und ganz unterstützen. Hier noch ein paar Mini-Bemerkunkungen:

(28.08.2012 08:57 )JoeFritzegard schrieb:  Bevor ich mich nun in die Verwendung des Application Builders vertiefe, wollte ich einfach kurz nachfragen, ob bzw. wie man ein solches Projekt kompilieren könnte.

Wenn du von 'kompilieren' sprichts, geht es um die Erstellung einer *.exe oder um das wirkliche Kompliat deiner VIs? Die Vis werden generell immer 'zur Laufzeit' kompiliert, also beim Speichern, bzw. während der Programmierung wird die Lauffähigkeit überprüft.

(28.08.2012 08:57 )JoeFritzegard schrieb:  Muss ich dabei, insbesondere durch die Verwendung der globalen Variablen, auf irgendwas bestimmtes achten?

Wenn globale Variablen verwendet werden gibt es i.A. ein 'Global_Variable.vi', welches die Globals enthält.Generell ist sicherzustellen, dass die einzelnen VIs nur die definierten Globals verwenden. Werden undefinierte Globals verwendet, wird dies im VI mit ein 'gebrochenen Pfeil' angezeigt.

(28.08.2012 08:57 )JoeFritzegard schrieb:  Oder muss ich das Projekt als solches komplett kompilieren, wobei mir dann noch nicht klar ist, wie ich den Aufruf der einzelnen vis gestalten sollte, da sie, wie gesagt, keine Verknüpfung untereinander bis auf die globalen Variablen besitzen?

Auch hier stellt sich grundsätzlich die Fragestellung, was du unter 'Kompilierung' verstehts. Die einzelen Main-VIs müssen immer - so wie es bei dir laut deiner Beschreibung ist - einzeln aufgerufen (angeklickt werden), um zu überprüfen, um die Lauffähigkeit überprüfen zu können.

Hier möchte ich nochmals auf den guten Hinweis von Falk verweisen bzgl. des Starter VIs. Sollte nämlich eines der zahlreichen Main-VIs nicht kompilierbar sein ('broken'), kann dies komfortabel im Starter VI dedektiert werden

Beste Grüße,
NWO


PS: @all: Sorry für den langen Post

Bei Verwendung von Globalen Variablen zum Datenaustausch zwischen mehreren Haupt-VIs hat man keine Synchronisation.
Das heißt: Die GVs können mit ganz unterschiedlichen Raten gelesen als geschrieben werden. Ist die Leserate z.B 10, die Schreibrate 1, dann wird bin Lesen immer 10mal der gleiche Wert gelesen, ohne dass das Lese-VI im Einzelfall weiß, ob der Wert neu ist oder ob es noch der alte ist. Und umgekehrt: Wenn die Schreibrate 10 ist und die Leserate 1, dann verschwinden 9 von 10 neuen Werte im Nirvana.
Das kann durchaus so gewollt sein, und in diesem speziellen Fall wären die GVs auch richtig verwendet.
Weitaus häufiger geht es aber darum, dass alle gesendetet Werte auch richtig empfangen werden. Und in diesem Falle sind Queues oder Melder die einzig richtige Lösung.
Und da Du dich selbt als Anfänger bezeichnest, und der Umgang mit Queues etwas schwieriger ist als als der Umgang mit GVs, gehe ich eher davon aus, dass bei Deinem Programm Queues die an sich richtige Lösung wären, dass Du dich aber mit Queues noch gar nicht befasst hast und einzig aus diesem Grunde GVs verwendest.
Also, sollte ich recht haben: hole das nach.

Beispiel, wo GVs sinnvoll sinnvoll sind:
In der Initialsierungsphase eines Programms werden Grundeinstellungen festgelegt, die später in mehreren (Sub-)Vis gebraucht werden. Um nicht an jeden dieser VIs dafür einen Eingangsdraht anschließen zu müssen, kann man diese Einstellungen als GV abspeichern. Hier spielt Synchronisation keine Rolle, und wenn Du deine GVs so verwendet haben solltest, dann wäre die Sache OK.

Hallo!

Erstmal vielen Danke fürs Anworten und die viele guten Anregungen.

Kurz zu den globalen Variablen: Es ist richtig, und mir auch bewusst, dass globale Variablen nicht gerade optimal sind Ist bisher so gewählt, da es momentan darum geht, dass erstmal alles funktioniert. Zudem hat es den Vorteil, dass das gesamte Program sehr flexibel ist, da alles Unterprogramme für sich alleine laufen können.

Mit kompilieren meinte ich das erstellen einer *.exe. War natürlich sehr ungünstig ausgedrückt

Also, ich denke, ich werde mal ausprobieren, alles über eine Art Starter-vi zusammenzufassen, und schauen ob es funktioniert. Meine Hoffnung war, dass man evlt. vll doch alle Programmteile als einzelne *.exe laufen lassen kann (hätte ja sein können, dass sich die globalen variablen irgendwie als *.dll geteilt werden können, oder wie auch immer), und man jedem, ohne sich groß mit Threading und weiterem beschäftigen zu müssen, einen eigenen Prozessor zuweisen kann

Unabhängig davon, werde ich mich danach mal daran setzen, die gennanten Tipps bezüglich Synchronität umzusetzen, und aus dem laufenden Programm auch mal ein schönes zu machen!

Alos, erstmal Danke sehr und viele Grüße

Trotzdem würde ich mir dann gleich von Anfang an ein geeignetes Programmierkonzept überlegen, sonst kannst Du später nochmal neu anfangen, wenn es nur halblebig tut.

Gruß Markus

(29.08.2012 15:02 )JoeFritzegard schrieb:  Ist bisher so gewählt, da es momentan darum geht, dass erstmal alles funktioniert.

Hallo Joe,

Zitat:Meine Hoffnung war, dass man evlt. vll doch alle Programmteile als einzelne *.exe laufen lassen kann (hätte ja sein können, dass sich die globalen variablen irgendwie als *.dll geteilt werden können, oder wie auch immer), und man jedem, ohne sich groß mit Threading und weiterem beschäftigen zu müssen, einen eigenen Prozessor zuweisen kann

Gerade dies wird nie und nimmer funktionieren: jede Executable (in Windows) hat ihren eigenen Adress-Space! Ein Executable kann also nicht die Globals anderer Executables lesen/zugreifen. Auch DLLs werden jeweils in den Adressspace der jeweiligen Exe "kopiert", auch hier kann kein Datenaustausch stattfinden.
Datenaustausch zwischen Executables kann nur über "Netzwerk" (auch localhost) oder über VIServer-Aufrufe gelingen - oder du packst (wie schon vorgeschlagen) alle VIs in ein MainVI...

Dann brauchst Du "Shared Variables", wenn Du an Variablen festhalten möchtest.

Gruß Markus

(29.08.2012 16:09 )GerdW schrieb:  nur über "Netzwerk" (auch localhost)