Sequenzüberprüfung

Hallo Zusammen,

ich hab ein kleines Problem woran ich seit ein paar Tagen sitze.

Ich möchte zyklisch ein Abfolge von Drehzahlen/Rampen fahren.

   

Dabei gibt die letzte Zahl in jeder Zeile an alle wieviel Zyklen diese Zeile ausgeführt werden soll.
1 = jeder Zyklus
2 = alle 2 Zyklen usw

Nun möchte ich aber überprüfen ob der Benutzer falsche Eingaben gemacht hat. Hauptsächlich ob Drehzahlsprünge vorhanden sind. Im Prinzip muss ich nur überprüfen ob die Zieldrehzahl der vorherigen Zeile mit der Startdrehzahl der jetzigen Zeile übereinstimmt. Wenn nun aber einige Zeilen nur alle paar Zyklen gefahren werden, muss ich in irgendeiner Form jede mögliche Kombination von Zyklen Probieren.

Hätte ich jetzt Zyklenzahlen von 1,2,3,5 in der Sequenz müsste ich laut meinem Verständnis folgende Kombinationen überprüfen:
1
1,2
1,3
1,5
1,2,3
1,3,5
1,2,5
1,2,3,5

Richtig?
Im Prinzip müsste ich nur die entsprechenden Zeilen aus dem Array entfernen und in den verbliebenen Zeilen die Drehzahlen überprüfen.

Aber wie realisiere ich das mathematische Problem in Labview. Ich war nie besonders gut in Kombinatorik
Das angehängte Snippet ist allerdings nur die Überprüfung der Gesamtsequenz.

Ich hoffe das mir da jemand helfen kann. Sollte ich zu einem Ergebnis kommen oder Fortschritte erzielen werde ich sie dann hier posten.

Auf gute Zusammenarbeit!
Rino

Gruß Markus

(14.11.2012 08:53 )DrRino schrieb:  Hätte ich jetzt Zyklenzahlen von 1,2,3,5 in der Sequenz müsste ich laut meinem Verständnis folgende Kombinationen überprüfen:
1
1,2
1,3
1,5
1,2,3
1,3,5
1,2,5
1,2,3,5

Hab ich mir gedacht es es nicht so einfach ist mit dem beschreiben des Problems.

Ich beziehe mich jetzt mal auf den Screenshot des Arrays:
1. Zahl = Startdrehzahl
2. Zahl = Zieldrehzahl
3. Zahl = Dauer
4. Schalter = Ein- oder Ausschalten der Zeile (ob diese Zeile gefahren werden soll oder nicht)
5. Ringelement = Rampenfunktion wenn Start = Zieldrehzahl wird die Drehzahl für die Dauer gehalten
6. Zahl = Alle wieviel Zyklen soll diese Zeile gefahren werden 1= jeder Zyklus; 2 = alle 2 Zyklen; 3 = alle 3 Zyklen usw
7. LED = Stellt die Aktive Zeile dar die gefahren wird

Diese Abfolge soll x-mal gefahren werden (Benutzerabhängig)
Eigentliches Problem:
Ich möchte jetzt überprüfen ob in jeder möglichen Zykluskombination die Eingaben korrekt sind und keine Drehzahlsprünge auftreten.

Habe ich jetzt Zeilen die jeden (1) Zyklus und alle (2) Zyklen gefahren werden ergeben sich folgende Möglichkeiten:
1
1,2

Für Zeilen die alle (1), alle (2) und alle (3) Zyklen gefahren werden sollen ergeben sich diese Möglichkeiten:
1 (2te Diagramm im Bild)
1,2 (3te Diagramm im Bild)
1,3 (4te Diagramm im Bild)
1,2,3 (1te Diagramm im Bild)
Siehe Bild:    

Ich muss für diese Kombinationen die Drehzahlabfolgen überprüfen ob der Benutzer einen Fehler bei der Eingabe gemacht hat. Man könnte die Freiheitsgrade auch von vornherein einschränken, allerdings würde mich die mathematische Lösung des Problems interessieren.
Ich hoffe das ich es jetzt ein wenig besser erläutern konnte. Ist immer schwierig das zu erklären wenn man im Thema drin steckt.

Hallo DrRino,

in deinem Bild sehe ich keine Sprünge, nur schöne Rampen

Im Ernst:
Entweder im Sinne einer Benutzerführung vorher Einschränkungen bei der Eingabe machen oder im Nachhinein kontrollieren.

Einfache Kontrollmöglichkeit:
- Aus den eingegebenen Daten einen Plot der Drehzahl erstellen, den der User auch gleich zu sehen bekommt. Da du ja weißt, wie deine "Zeilen" abgearbeitet werden, kannsst du auch sehr schnell einen solchen Plot generieren!
- Im Plot Drehzahlsprünge suchen: sehr einfach, wenn zwei aufeinanderfolgende Drehzahlwert (Ende zu Start der nächsten Zeile) abweichen. Für den User gleich noch farbig markieren!

Hallo DrRino

Wie Gerd schon erläutert hat, kannst du die Eingaben überprüfen.

Als Alternative könnte man auch automatisch eine Rampenfunktion ausführen, wenn Drehzahlsprünge auftreten.
So hast du sichergestellt, dass immer bei der richtigen Drehzahl gestartet wird.
Ob dies für dich in Frage kommt, musst du selber entscheiden

Gruss
Chris

Ich hab die Diagramme mal leicht modifiziert.
Jetzt wäre quasi die Gesamtsequenz also 1 & 2 & 3 gültig.
1 = Gültig
1 & 2 = ungültig
1 & 3 = ungültig

Ich kann die Rampe während des Fahrens schon einbauen, aber ich würde gern vorher wissen ob das was der Benutzer eingibt korrekt ist

Wahrscheinlich werd ich schon vorher ein die Anzahl an unterschiedliche Zyklenzahlen auf 3 Begrenzen da ist der Programmieraufwand noch relativ klein.

Die Anzahl an Kombinationsmöglichkeiten beträgt 2^(n-1) wobei n die Anzahl der Elemente ist.
Bei 1,2 & 3 währen das 2^(3-1)=4
Damit kann ich schonmal eine For-Schleife aufbauen. Ich glaub dafür brauch ich noch ein paar mehr.

Hallo Rino,

du kannst natürlich deine Energie darauf verwenden, Rekursion in LabVIEW zu erlernen (was nicht grundsätzlich falsch wäre).
Du kannst aber den Ablauf auch sehr einfach "simulieren", in dem du den oben angesprochenen Plot erstellst und dort einfach nach Sprüngen suchst. Dies hätte den Vorteil, dass du dem Benutzer gleich grafisch den Fehler zeigen kannst!

Ich hab mir jetzt selbst eine Lösung zusammengebaut. (siehe Anhang)
Die Erklärung könnte jetzt etwas schwammig werden.

Im Prinzip habe ich eine Anzahl von Elementen (n).
Die Gesamtanzahl an Kombinationen ergibt sich in meinem Fall aus 2^(n-1)
Alle weiteren Spalten in der Tabelle werden nun folgendermaßen zusammengebaut:
Zeilenweises einfügen des Elements 2 bis die Elementanzahl (Beispiel Spalte 2: 2^(n-2)=8) erreicht ist (Zähler zählt hoch). Danach werden dieselbe Anzahl an Nullen eingefügt. (Zähler zählt wieder runter)
Ist die Elementanzahl (Beispiel Spalte 3: 2^(n-3)=4) erreicht werden die gleiche Anzahl an Nullen ins Array geschrieben. Kommt der Zähler bei 0 an wird wieder das Element bis zu Elementanzahl eingefügt. Solange bis die Gesamtanzahl an Zeilen erreicht ist.

Diese vorgehensweise wird für alle Elemente durchgeführt. Das gibt mir ein Array mit allen von mir benötigten Kombinationen. Funktioniert sogar mit einer größeren Anzahl an Elementen, allerdings steigt dann auch der Rechenaufwand exponentiell.

   

Ich hoffe man hat ein wenig verstanden was ich hier erklärt habe. Man kann das sicherlich auch noch optimieren allerdings kenn ich mich dazu zu wenig in LabView aus. Verbesserungsvorschläge vor allem ressourcenschonendere werden gern angenommen.

Wem die neue LabView Version nicht zu verfügung steht, für den kann ich das auch gern in eine frühere Version konvertieren.

Mfg
Rino