TIA Variables Register

R

Rosso_89

Level-1
Beiträge
3
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo allerseits,

für ein Projekt bräuchte ich ein variables Register.

Sinn und Zweck ist es anhand 10 Bereitmeldungen (bool) 10 Istwerte Eingangswert (int) 10 Sollwerten Ausgangswert (int) nach Prioritäten zuzuweisen.

Wenn ein Ventilator nicht verfügbar ist, also nicht Bereit, soll dieser in der Priorität an letzte Stelle rutschen. Das ganze soll nach möglichkeit Instanzfähig sein und für alle ca 1000 Fälle funktionieren, auch wenn das wenig Sinn macht.

Die Idee beim Ausprogrammieren sieht bisher so aus wenn alle Ventilatoren Bereit sind

Code: 
// Alle Prio bereit

      U(
      U     #Bereit_Prio_1
      U     #Bereit_Prio_2
      U     #Bereit_Prio_3
      U     #Bereit_Prio_4
      U     #Bereit_Prio_5
      U     #Bereit_Prio_6
      U     #Bereit_Prio_7
      U     #Bereit_Prio_8
      U     #Bereit_Prio_9
      U     #Bereit_Prio_10
      )
      SPBN  Alle_Bereit
      L     #Wert_Prio_1
      T     #Befehl_Prio_1
      L     #Wert_Prio_2
      T     #Befehl_Prio_2
      L     #Wert_Prio_3
      T     #Befehl_Prio_3
      L     #Wert_Prio_4
      T     #Befehl_Prio_4
      L     #Wert_Prio_5
      T     #Befehl_Prio_5
      L     #Wert_Prio_6
      T     #Befehl_Prio_6
      L     #Wert_Prio_7
      T     #Befehl_Prio_7
      L     #Wert_Prio_8
      T     #Befehl_Prio_8
      L     #Wert_Prio_9
      T     #Befehl_Prio_9
      L     #Wert_Prio_10
      T     #Befehl_Prio_10
      SPA   Ende_Ba
Alle_Bereit : NOP 1
Ende_Ba : NOP 1

Und hier der Ansatz wenn einer ausfällt bzw. nicht bereit ist.
Code: 
// Prio1 nicht bereit
      U(
      UN    #Bereit_Prio_1
      U     #Bereit_Prio_2
      U     #Bereit_Prio_3
      U     #Bereit_Prio_4
      U     #Bereit_Prio_5
      U     #Bereit_Prio_6
      U     #Bereit_Prio_7
      U     #Bereit_Prio_8
      U     #Bereit_Prio_9
      U     #Bereit_Prio_10
      )
      SPBN  Prio1_nicht_Bereit
      L     #Wert_Prio_1
      T     #Befehl_Prio_2
      L     #Wert_Prio_2
      T     #Befehl_Prio_3
      L     #Wert_Prio_3
      T     #Befehl_Prio_4
      L     #Wert_Prio_4
      T     #Befehl_Prio_5
      L     #Wert_Prio_5
      T     #Befehl_Prio_6
      L     #Wert_Prio_6
      T     #Befehl_Prio_7
      L     #Wert_Prio_7
      T     #Befehl_Prio_8
      L     #Wert_Prio_8
      T     #Befehl_Prio_9
      L     #Wert_Prio_9
      T     #Befehl_Prio_10
      L     #Wert_Prio_10
      T     #Befehl_Prio_1
      SPA   Ende_Ba
Prio1_nicht_Bereit : NOP 1
.
.
.
// Prio1&2 nicht bereit
      U(
      UN    #Bereit_Prio_1
      UN    #Bereit_Prio_2
      U     #Bereit_Prio_3
      U     #Bereit_Prio_4
      U     #Bereit_Prio_5
      U     #Bereit_Prio_6
      U     #Bereit_Prio_7
      U     #Bereit_Prio_8
      U     #Bereit_Prio_9
      U     #Bereit_Prio_10
      )
      SPBN  Prio1und2_nicht_Bereit
      L     #Wert_Prio_1
      T     #Befehl_Prio_3
      L     #Wert_Prio_2
      T     #Befehl_Prio_4
      L     #Wert_Prio_3
      T     #Befehl_Prio_5
      L     #Wert_Prio_4
      T     #Befehl_Prio_6
      L     #Wert_Prio_5
      T     #Befehl_Prio_7
      L     #Wert_Prio_6
      T     #Befehl_Prio_8
      L     #Wert_Prio_7
      T     #Befehl_Prio_9
      L     #Wert_Prio_8
      T     #Befehl_Prio_10
      L     #Wert_Prio_9
      T     #Befehl_Prio_1
      L     #Wert_Prio_10
      T     #Befehl_Prio_2
      SPA   Ende_Ba
Prio1und2_nicht_Bereit : NOP 1

und so weiter....

Natürlich ist es nicht gerade Sinnvoll und vor allem Effizient die fast 1000 Möglichkeiten zu programmieren.

Vielleicht hat ja wer eine brauchbare Idee. Darf auch gerne SCL sein. AWL ist nur der besseren Übersicht wegen.

Danke euch schonmal
Gruss Rosso
 
Hallo

Kenne mich in AWL nicht gut aus deswegen bin ich vielleicht auch etwas verwirrt;
Du hast also für jeden deiner Ventilatoren einen Sollwert, der nur geschrieben werden soll, wenn der Ventilator bereit ist?
Was soll dann mit den Werten passieren wenn der Ventilator nicht bereit ist?
Oder habe ich das falsch verstanden?

Gruss
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Genau ich habe 10 Ventilatoren in einer Prioritätenliste. Je nach Priorität gibt es einen Sollwert. Wenn ein Ventilator nicht bereit/verfügbar ist, soll dieser an die letzte Stelle wandern und der Sollwert an den nächsten Ventilator gesendet werden der bereit ist. Man könnte es auch als Register sehen im dem die Sollwerte in der Position fest sind und die Ventilatoren flexibel nach Verfügbarkeit.

Das ganze kommt in einen FB und soll instanzmäsig aufrufbar sein.

Die Idee geht mittlerweile auch dahin das ich einen Zähler setze.

Ventilator 1 bereit = 1
Ventilator 1 nicht bereit = 11
Ventilator 2 bereit = 2
Ventilator 2 nicht bereit = 12
Ventilator 3 bereit = 3
Ventilator 3 nicht bereit = 13
Ventilator 4 bereit = 4
Ventilator 4 nicht bereit = 14
.
.
.

und dann am ende einfach eine Auswertung nach Wertigkeit mache und so dann die Position mache an der der Ventilator kommt.
 
Leider(?) ist das mit zur Laufzeit festgelegten Array Grenzen und sowas in TIA nicht möglich.
Ich habe solche Sachen für Bibliotheksbausteine bisher so gelöst, dass ich an meinen Baustein einen Array[*] als In/Out-Parameter übergeben habe. Der Baustein ermittelt dann die Länge des Arrays und nimmt das als Parameter für Schleifendurchläufe.
Wenn ein Anwender den Baustein benutzt legt er mit dem Array, dass er da übergibt die Größe fest.

Möglich wäre da vielleicht auch mit Variant, aber das kapiert wieder keine und man muss so viel Doku schreiben.
 
Rosso_89 schrieb:
Genau ich habe 10 Ventilatoren in einer Prioritätenliste.
Zum Vergrößern anklicken....
In welcher Form liegt Deine PrioritätenListe vor bzw. ist es eigentlich eine Tabelle mit mehreren Spalten, wo in einigen Spalten (hoffentlich) auch die Kriterien vorhanden sind, nach denen die Sortierung nach der jeweiligen Priorität durchgeführt werden kann?
Ich würde mit einem array of struct für die Tabelle arbeiten und dort eine zusätzliche Spalte für das Ergebnis der Sortierung vorsehen, in Form eines SortierIndex. Nur diese Spalte wird dann sortiert und alle anderen Daten zu den einzelnen Ventilatoren bleiben an ihren angestammten Plätzen.
Beim Zugriff auf den Datensatz mit der höchsten Priorität adressierst Du dann das erste Element des arrays, liest den SortierIndex aus und greifst dann mit diesem Index auf die Tabelle zu, um den gewünschten DatenSatz zu lesen bzw. zu beschreiben.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Es gibt eine allgemeine Prioritätenliste für verschiedene "Betriebsarten/Programme" diese Prioritäten beachten allerdings nicht den Ausfall oder das nicht Bereit sein eines Ventilators.

Mit der Liste kann somit nicht gearbeitet werden da sie nur 10 verschiedene feste Prioritäten in den"Betriebsarten/Programme" vorgibt und es somit unter allen Berücksichtigungen etwa 150.000 verschiedene Szenarien wären, sollte ich es ausprogrammieren.

Am ehesten wird es wohl mit einem Zähler möglich die Prioritäten zu ermitteln und der Zahl nach zu sortieren. Wer den niedrigsten Wert hat bekommt die höchste Priorität. Ähnlich einem Betriebsstunden ausgleich nur das die eigentliche Priotität und das zur Verfügungstehen dann den Wert hermacht nach den abgeglichen wird.
 
Rosso_89 schrieb:
1. Es gibt eine allgemeine Prioritätenliste für verschiedene "Betriebsarten/Programme" diese Prioritäten beachten allerdings nicht den Ausfall oder das nicht Bereit sein eines Ventilators.

2. Mit der Liste kann somit nicht gearbeitet werden da sie nur 10 verschiedene feste Prioritäten in den"Betriebsarten/Programme" vorgibt und es somit unter allen Berücksichtigungen etwa 150.000 verschiedene Szenarien wären, sollte ich es ausprogrammieren.

3. Am ehesten wird es wohl mit einem Zähler möglich die Prioritäten zu ermitteln und der Zahl nach zu sortieren. Wer den niedrigsten Wert hat bekommt die höchste Priorität. Ähnlich einem Betriebsstunden ausgleich nur das die eigentliche Priotität und das zur Verfügungstehen dann den Wert hermacht nach den abgeglichen wird.
Zum Vergrößern anklicken....
Zu 1.:
Na ja, den "Ausfall oder das nicht Bereit sein"-Aspekt wirst Du als Programmierer sicherlich eigenmächtig noch hinzufügen dürfen bzw. müssen, ohne den "Geist" der PrioritätenListe dadurch auf den Kopf zu stellen. Das scheint aber auch Dein kleinstes Problem zu sein.

Zu 2.:
Mit der Liste kann nicht gearbeitet werden, weil sie nur 10 verschiedene feste Prioritäten vorgibt und Du damit schon auf 150.000 verschiedene Szenarien kommst? :confused:
Die Variante "ausprogrammieren" scheidet sicherlich aus. Darum haben wir ja auch das Thema 'Array' ins Spiel gebracht, um das Arbeiten mit ProgrammSchleifen vorzubereiten - allein schon in Hinblick auf das Sortieren.

Zu 3.:
Um eine Gewichtung der verschiedenen Kriterien für die Priorisierung zu erreichen, bietet es sich an, mit Zahlen zu arbeiten bzw. nach solchen Zahlen zu sortieren.
Das allerdings mit Zählern in Angriff zu nehmen ... kann man sicherlich machen, wäre mir aber schon zu unübersichtlich (aber, je nach Verwendung, vielleicht dennoch angebracht?).
Wenn Du diese Zahlen als DINT festlegst, dann hast Du schon (ich sage mal vorsichtshalber) 31 BitPositionen zur Verfügung, um 31 Ja/Nein-Entscheidungen gewichtet in die Zahl zu schreiben (zu odern oder zu addieren).
Je nach dem, was Deine 10 verschiedene feste Prioritäten aussagen, könnten diese wohl 10 der 31 Bits belegen und Reserve für Erweiterungen und die "AusschlussKriterien" Ausfall/nicht-bereit bleibt auch noch.

Wenn wirklich die vorgegebene PrioritätenListe Dein "KernProblem" sein sollte, könntest Du hierzu bitte etwas konkreter werden, damit wir Dich besser verstehen können?
 
Zurück
Oben