TIA Wie lässt sich eine If Else Anweisung in FUP realisieren?

Heinileini, Du hast natürlich recht. Egal ob ich den Baustein zyklisch oder sporadisch oder sonstwie aufrufe, der Ausgang bleibt bis zum nächsten Aufruf true und wird erst dann wieder auf true/false geprüft.Ich muss halt noch viel lernen. Hoffentlich kommt nicht das Rentenalter dazwischen.;)
Edit: Was ich mich aber frage: wenn nicht zyklisch, wie bekommt mein Baustein , in einer vernünftigen Zeitspanne, mit, dass Y_loc unter 8V sinkt, damit der Ausgang GR_loc wieder false wird.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Das ganze ist doch eh ne akademische Aufgabe. In der Praxis würde man sowieso nicht mit der Spannung rechnen sondern mit der richtigen physikalischen Größe und ausserdem ne Hysterese einbauen, sonst toggelt das mal ordentlich hinundher. Wenn dann nen Schütz am Ausgang hängt, viel Spaß.
Dann wären wir aber doch wieder beim IF THEN ELSIF bzw. Setzen Rücksetzen...
Und Else wäre auch aus dem Spiel.
 
Das ganze ist doch eh ne akademische Aufgabe. In der Praxis würde man sowieso nicht mit der Spannung rechnen sondern mit der richtigen physikalischen Größe und ausserdem ne Hysterese einbauen, sonst toggelt das mal ordentlich hinundher. Wenn dann nen Schütz am Ausgang hängt, viel Spaß.
Dann wären wir aber doch wieder beim IF THEN ELSIF bzw. Setzen Rücksetzen...
Und Else wäre auch aus dem Spiel.
Käse ist es schon deshalb, weil Y_loc ja eine Ausgangsspannung sein soll. Und wie hoch die ist, weiss ich doch vorher. Oder hab ich da was falsch verstanden?
 
Edit: Was ich mich aber frage: wenn nicht zyklisch, wie bekommt mein Baustein , in einer vernünftigen Zeitspanne, mit, dass Y_loc unter 8V sinkt, damit der Ausgang GR_loc wieder false wird.
Indem Du den Baustein in einer "vernünftigen Zeitspanne" wieder aufrufst.
Ehe Du an der Entscheidung scheiterst, was eine "vernünftige Zeitspanne" in Deinem Anwendungsfall ist und was man drumherum programmieren könnte bzw. müsste, um dies sicherzustellen, nimm einfach eine zyklische Bearbeitung. Schliesslich wurde die für diesen Zweck erfunden und sie funktioniert auch sehr zuverlässigund planbar.
Eine zyklische Bearbeitung könnte auch eine sein, die in einem ZeitAlarm aufgerufen wird. Allerdings verzichtet man dann auf den "Service" des BetriebsSystems, automatisch die ZyklusZeit zu überwachen. Was allerdings nicht bedeuten soll, dass man sich keine Gedanken darüber machen muss, was passiert, wenn die Abarbeitung im ZeitAlarm zuviel Zeit beansprucht. Das KuddelMuddel kommt sonst ganz von allein, aber ohne dass Du eine entsprechende Meldung erhältst. Diese Aussage ist allerdings "ohne Gewähr": das KuddelMuddel könnte/dürfte auch "auf Umwegen" zu einer gelegentlichen(?) ZyklusZeitÜberschreitung im OB1-Zyklus führen.
Egal, wie man's macht, bitte bedenken, dass man das Problem eigentlich nur verlagert, es aber dadurch nicht beseitigt, wenn man die Ausführung von ProgrammTeilen woanders hinschiebt.
Der Ansatz, für mehrere ZeitAlarme nicht nur unterschiedliche, sondern teilerfremde Zeiten zu wählen, hilft auch nicht so gut, wie man anfangs vielleicht annehmen könnte.
Auch hierbei treten periodisch Häufungen von "gleichtzeitig" stattfindenden ProgrammAusführungsZeiten auf.
Besser, einfacher, übersichtlicher finde ich es, wenn man einen ZeitAlarm mit kurzer WiederholDauer nimmt und in diesem ProgrammZweig dafür sorgt, dass die Aufgaben auf verschiedene Zyklen dieses ZeitAlarms möglichst ausgewogen verteilt werden. Aber auch dieses Verfahren wird leider beim Austüfteln viel zu schnell zu einer anspruchsvollen Hin- und Her-Schieberei.

Käse ist es schon deshalb, weil Y_loc ja eine Ausgangsspannung sein soll. Und wie hoch die ist, weiss ich doch vorher. Oder hab ich da was falsch verstanden?
Dass Du das vorher weisst, nehmen wir mal als gegeben an, aber was muss man programmieren, damit es auch die CPU weiss und entsprechend angepasst reagieren kann?
Ich verstehe die Aufgabe im weiteren Sinne so, dass kein linearer Zusammenhang zwischen der Stellgrösse und deren Wirkung besteht und man deshalb versucht, dies zu kompensieren/linearisieren. Aber müsste man dafür nicht eine sagen wir mal "UmkehrFunktion" basteln?
 
Was ich meinte ist, dass von der Ausgangsspannung Y_loc und nicht der Eingangsspannung x_loc die Rede ist.
Aaach sooo.
Ich weiss ehrlich gesagt schon länger nicht mehr so genau, wovon hier im Thread jeweils die Rede ist.
Den Faden habe ich schon längst verloren, weil ich eigentlich dachte, das Thema sei reichlich abgegrast. Und trotzdem drehen wir uns hier immer wieder auf's Neue im Kreis ... irgendwie ... irgendwarum ... irgendwohin ... keine Ahnung (aber davon jede Menge! ;) ).
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Eine Anmerkung zum Thema hab' ich aber noch

@PN/DP Müsste das bei SCL nicht so aussehen?

Code:
IF Y_loc >= 22118 THEN
GR_loc := TRUE;
ELSE
GR_loc := FALSE;
END IF;
Die FUP-Entsprechung für Deinen Vorschlag wäre so:
Code:
       +-------+
       |  >=   |
       |  INT  |       GR_loc
Y_loc--|IN1    |      +-----+
22118--|IN2    |--+---|  S  |
       +-------+  |   +-----+
                  |
                  |    GR_loc
                  |   +-----+
                  +--o|  R  |
                      +-----+
Die Invertierung des VKE beim ELSE und die Zuweisung des FALSE kann man aber rauskürzen und das VKE direkt zuweisen (wie Heinileini in #12 zeigte):
Code:
SCL:

GR_loc := Y_loc >= 22118 ;


FUP:
       +-------+
       |  >=   |
       |  INT  |       GR_loc
Y_loc--|IN1    |      +-----+
22118--|IN2    |------|  =  |
       +-------+      +-----+


Man kann das Ergebnis boolscher Ausdrücke direkt verwenden und z.B. boolschen Variablen zuweisen. Man muß boolsche Ergebnisse auch nicht vergleichen ob sie TRUE oder FALSE sind - sie sind ja schon boolsch. Die unnötig "gesteigerte" SCL-Variante der IF..ELSE-Lösung sieht häufig so aus:
Code:
IF (Y_loc >= 22118) = TRUE THEN
  GR_loc := TRUE;
ELSE
  GR_loc := FALSE;
END IF;
Hier fällt imho sogar noch deutlicher auf, daß das ganze Konstrukt unnötig umständlich ist. Für "wenn das Ergebnis TRUE ist dann weise TRUE zu, wenn es FALSE ist dann weise FALSE zu" kann man direkt sagen: weise das Ergebnis zu. GR_loc := (Y_loc >= 22118) ; :cool:


Einen ELSE-Zweig braucht man nur, wenn man da etwas machen will, was mehr als das VKE vom IF braucht und nicht einfach nur die Invertierung der THEN-Anweisung ist. Z.B.:
Code:
     +-------+
     |   <   |
     |  INT  |         +-------+
  i--|       |         |  ADD  |
999--|       |--+------|  INT  |
     +-------+  |   i--|       |-i
                |   1--|       |
                |      +-------+
                |
                |
                |      +-------+
                |      |  MOVE |
                +-----o|       |-i
                    0--|       |
                       +-------+
SCL:

IF i < 999 THEN
  i := i + 1;
ELSE
  i := 0;
END_IF;

Harald
 
Zurück
Oben