LabVIEWForum.de

Hallo liebes Froum

Ich stehe mal wieder vor einem Problem...

Diesmal ist es ein Problem, das sowohl mit LabVIEW, als auch mit Mathematik zu tun hat.

Als ausgang habe ich eine Funktionstabelle (auf dem Bild links zu sehen) Diese soll automatisch von LabVIEW erstellt werden und mit Nullen und Einsen gefüllt werden, sodass nur noch die Ausgänge ausgefüllt werden müssen. Die Anzahl der Eingänge soll frei wählbar sein.

Jetzt beginnt mein eigentliches Problem! LabVIEW soll mir danach automatisch Funktionsgleichungen erstellen. Diese würde ich gerne wahlweise anzeigen oder ausblenden. (da liegt aber nicht mein Problem ) Ich habe leider einfach überhaupt keine Idee, wie ich aus der Tabelle Funktionsgleichungen werden lassen könnte.
Also höchstens ganz viele bauen und die Eins funktioniert dann als Schalter und dann zeigt er die Jeweilige an, aber das kann ja nicht die Lösung sein.
Gibt es eine möglichkeit LabVIEW das automatisch machen zu lassen?

Zu guter letzt soll das ganze dann noch vereinfacht werden Ich mache das per Hand mit einer KV-Tafel, und auch hier habe ich leider überhaupt keinen Ansatz wie ich das machen könnte...

Falls ihr Ideen für die Umsetzung habt wäre ich euch sehr dankbar

Mit freundlichen Grüßen

Hallo Zufall,

also meine Idee wäre, mach doch genau das, was da steht ;-)

Auf der Palette Boolsch gibt es Mehrfacharithmetik, dort kannst du ein Und verwenden und dann Eingänge invertieren (rechtsklick auf den Eingang).

Dann wäre das (hier an dem PC habe ich kein Labview, ist auf dem Laptop, der gerade kein Internet hat) ein Und mit vier Eingängen, und alle außer dem zweiten Eingang invertiert.

Ich hoffe, das ist verständlich, ansonsten bring ich gleich mal den Lappi ans Netz.

Gruß

Stefan

Danke für die schnelle Antwort

Also das verstehe ich leider nicht. Dann könnte ich ja mit der Mehrfacharithmetik ja nur eine Zeile Darstellen, oder?

Und wie verändert sich die Anzahl der Eingänge, wenn Ich meinetwegen von 2 Eingängen auf meiner Benutzeroberfläche auf 20 stelle?

Gerne doch,

also ich dachte gerade so, dass du je eine Zeile mit Mehrfacharithmetik darstellst. Anschließend nimmst du die Ausgänge und veroderst diese. Und schon ist es fertig ;-)
Aber so wie du das sagst, möchtest du ja dann auch eine Tabelle mit sagen wir 20 Eingängen machen? Dann wird die Bedingung schon schwerer... und jetzt habe ich noch mal deine Frage gelesen und verstanden.

Okay... interessante Frage.
Also die einfachste Lösung dafür ist, für jede Zeile die als Ergebnis eine 1 liefert, alle Bedingungen mit und zu verknüpfen:

A1 = /S1 UND S2 UND /S3 UND /S4

anschließend alle verodern. Allerdings muss ich sagen: Boolsche Arithmetik ist bei mir schon ne ganze Weile her und ich wüsste nicht, wie das geht...

Gruß

Stefan

Ja, genau so meine ich das. Also so wie du das jetzt verstanden hast

Ja es wäre gut, wenn man das irgendwie so machen kann, dass die Informationen aus der Tabelle entnommen werden. Ansonsten ist das ja ein riesen Aufwand alle verschiedenen Varianten zu schreiben. So habe ich die Anfangstabelle bis jetzt leider auch nur machen können. Ich habe Schnell ein paar Tabellen in Excel gefüllt, also mit 1 und 0 und lasse sie mir dann bei ausgewählter Eingangsanzahl in einer Real Matrix anzeigen. Das ist aber auch noch nicht das Gelbe vom Ei.

Meines Erachtens liegst Du da mit Labview falsch. Das was Du willst, das macht jedes Programm zur Programmierung von FPGAs. Da kann man u.a. solche Tabellen eingeben, daraus werden Funktionsgleichungen erstellt, diese werden minimiert, und schließlich wird eine JEDEC-Datei zu Programmierung des FPGA erstellt.
Solche Programme kann man von den Herstellern von FPGAs auch kostenlos herunterladen, aber ich bin da nicht mehr auf dem neuesten Stand und kann Dir keinen speziellen Tip geben.

Das habe ich mir auch schon gedacht

Wir hatten in der Schule eine Projektarbeit. Die hälfte unseres Abiturs wird darin bestehen, möglichst vieles rund um dieses Projekt zu automatisieren.

Wir sollten eine Maschine automatisieren (mit einer SPS steuern) und Messdaten mit LabVIEW erfassen und auswerten. Da die zeit nicht gereicht hat, sind wir nicht so weit gekommen, LabVIEW mit der Messkarte zu verbinden (die Kraftmessdosen sind nicht fertig geworden). Unser Lehrer meint jedoch, dass wir trotzdem drüber schreiben (mit einer Messkarte kommt nichts dran). Und dann bleibt einfach nicht mehr so viel übrig, was man automatisieren könnte.

Da wir uns schon vorarbeiten sollen, und uns mit vielen verschiedenen Möglichkeiten auseinandersetzen sollen, da es sonst zeitlich nicht machbar sein wird, habe ich schon einiges gemacht (Visualisieren und das, was geplant war, mit künstlich generierten Werten machen) aber mit diesem Problem komme ich einfach nicht weiter.

Also, dass LabVIEW warscheinlich nicht die beste Wahl ist habe ich mir schon fast gedacht Aber wenn doch noch jemand Ideen hat, wie man dieses Problem lösen kann, dann würde ich mich sehr über diese freuen

Moin moin,

ich habe eben gegoogelt und etwas gefunden:

http://www.wolframalpha.com/input/?i=S1+...T+%28S4%29

Wolframalpha kann dir boolsche Mathematik machen und das ganze auch noch minimieren. Wenn du dir einen Code schreibst, der aus der Tabelle genau die zeile baut, die du brauchst
S1 && NOT (S2)&& NOT (S3) && NOT (S4) // Befehl für Wolframalpha

kannst du eventuell, wenn du auf der Seite die entsprechende Zeile für minimierten Code findest eine Online Abfrage machen.

Ich hab aber keine Ahnung ob und wie das in Labview geht^^

Gruß

Stefan

Moment, dein Problem ist doch lediglich:

Du hast eine Funktionstabelle wie in Post 1 gegeben (alle Eingänge + was dabei am Ausgang rauskommt) und das in allen Varianten. Daher:

Labview muss eigentlich nur das machen was da steht. *hust* Außerdem willst du Labview dazu bringen die Funktions daraus zu generieren. Das ist etwas anspruchsvoller.

Zum ersten Teil:

das vorgehen ist eigentlich Straight forward. Entweder du liest über ActiveX (wenn ich mich recht erinnere) die Tabelle aus deinem Excel File ein, oder du machst das direkt in Labview (das eingeben lassen).

Dazu brauchst du:
1. Einen Numerischen Eingang für die Anzahl der "Eingänge" + potentiell einen Regler für die Anzahl der Ausgänge (in deinem Fall verstehe ich das so dass es nur einen Ausgang gibt, entsprechend brauchst du nur einen Regler).

2. Vermutlich am besten ein String Array für die Bezeichnungen.

3. ein 2D Bool Array *ist wahrscheinlich am praktischsten*

Was das programm dann machen muss: bei setzen des Eingänge Reglers wird automatisch das Bool Array entsprechend einer solchen Tabelle vorbelegt mit Ausgangsbelegungen alle auf False (zum Beispiel). Das String Array wird mit Bezeichnern gefüllt (die nur dazu dienen dass der Nutzer versteht wie das Bool Array zu verstehen ist.

Heist für 2 Eingänge:

String Array: E1 E2 A1
False False False
true False False
False true False
true true False

Um das zu generieren dürfte es am Einfachsten sein die Zahlen von 0 - 2^Anz(E) - 1 hochzuzählen, in ein Binär Array mit Länge (E) zu wandeln, am Ende noch so viele False anhängen wie man Ausgänge hat und dann einfach verknüpfen zu dem 2D Array.
Eventuell könnte es auch sinnvoll sein 2 2D Arrays zu machen, dann kann man das Array für die Eingänge als Anzeigeelement machen und verhindert so nicht gewollte Nutzereingriffe (der soll ja nur angeben was die Ausgänge machen sollen bei gegebenen Eingangsbelegung).

Der Nutzer trägt dann einfach seine Daten für A1 A2 etc. ein.

Jegliche Anfragen kann man intern wieder durch Umwandeln der Eingabe"zeile" (Werte für E1 - En) in eine Zahl erledigen (da diese dann wieder den Index des gewünschten Ausgabeelements darstellt ^^).

Zum generieren der Formel: Die einfachste Variante ist wahrscheinlich erst zu unterscheiden ob mehr Ausgänge True oder mehr False sind. Das minimale wird jeweils genommen. Anschließend mit der bekannten Variante (weis nichtmehr genau wie es hieß) für jeden einzelnen Fall die Formeln erstellen und verknüpfen.

An der Beispieltabelle:

E1 E2 A1
False False False
true False true
False true true
true true False


Bei A = False durch baut man die Formel mit:

[E1 ODER E2] UND [NICHT(E1) ODER NICHT(E2)] (am besten mal selbst durchrechnen und klarmachen dass das der Tabelle oben entspricht; die Blöcke in Eckigen Klammern setzen sich folgendermaßen zusammen: alle Eingänge "verodert"; wenn in der Funktionstabelle ein "true" steht, dann wird NICHT(Eingang) benutzt, sonst Eingang); das ganze wird dann noch "verundet".
Man kann sich leicht klarmachen, dass der Ausdruck in [] jeweils nur dann False wird, wenn die "abgelesene" Zeile vorliegt (erster Klammerausdurck entspricht zum Beispiel Zeile 1). Ist einer der Klammerausdrücke false, dann wird durch das "verunden" der Ausgang false.

Umgekehrt wenn man die A = true Cases nimmt:

[E1 UND NICHT(E2)] ODER [NICHT(E1) UND E2]

Hier entspricht ein true in der Tabelle dem Eingang, ein false NICHT(Eingang); diesmal wird innen verundet (entsprechend gibt der [] Ausdruck nur dann true aus, wenn die Zeile anliegt aus der er erstellt wurde) und aussen verodert (entsprechend wird für ein true in irgendeinem Klammerausdruck immer true ausgegeben).

Man kann leicht ersehen, dass die Formel immer dann am kürzesten ist, wenn man möglichst wenige Ausdrücke zum erstellen benutzen muss.

Damit kriegst du auch immer eine Stimmige generische Formel hin. Willst du die dann noch weiter kürzen musst du über die so erstellte Formel noch eine Routine drüberlaufen lassen die die vereinfacht (Fälle zusammenfasst wo ein Parameter egal ist zum Beispiel etc.). Das ist dann beliebig anspruchsvoll.

Aber wie gesagt:

- Funktionstabelle übernehmen und damit Richtig auswerten - kein Thema (steht ja alles eingegeben da und zwar für JEDEN Fall)
- eine generische Gleichung erstellen - kein Thema (siehe Ansatz weiter oben)
- erstellte Gleichung optimieren: beliebig kompliziert

Hallo zusammen,

Grundlagen zum Thema bietet Wikipedia: hier und hier
Ob und wie man den Algorithmus im zweiten Link jetzt programmatisch löst, sei dahingestellt...

- Wenn du wirklich 20 Eingänge hast, dann musst du auch 2^20 (1048576) Zustände verwalten. Viel Spaß beim Ausfüllen der Wahrheitstabelle...
- Ich würde (für den Anfang) auf irgendwelche Optimierungen verzichten: Rechner sind heute schnell genug, um eine Tabelle zu durchsuchen.
- Ich würde die Eingänge als boolsches Array zusammenfassen und einfach als Index in deine Wahrheitstabelle verwenden. Dann entfällt das aufwendige Suchen - man bezahlt das mit dem für die Tabelle nötigen Speicher (bei 20 Eingängen wären das 128 KiB)...

Edit: Mal ein VI zur Veranschaulichung:
[attachment=43586]
- Wahrheitstabelle als CSV (mit einer Headerzeile) abspeichern
- Tabelle einlesen: Anzahl der Spalten bestimmt die Anzahl der Eingänge
- Bei einer vorsortierten Wahrheitstabelle braucht man nur die Spalte mit den Ausgangswerten indizieren.
- Die Bitmaske dient dazu, den Eingangsvektor auf den erlaubten Bereich zu limitieren...
- Der Teil im Sequenzrahmen braucht nur einmal zu Programmbeginn ausgeführt werden, um z.b. eine Feedbacknode mit den nötigen Daten zu befüllen...