TIA Rampenfunktion anpassen in awl

B

batindeko

Level-2
Beiträge
104
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo an Alle,

ich muss eine Rampenfunktion in awl anpassen. Der neue Sollwert darf max. +/-3 oberhalb oder unterhalb des alten Sollwerts liegen und es soll bei größere Sollwertänderung auf 3 begrenzt werden. ich habe folgendes beschrieben aber es läuft nicht wie ich mir das vorstelle vor allem bei größere Sollwertänderung. was ist hier falsch oder habe ich hier ein Denkfehler. Ich bin neu in awl Programmierung.

L 0.2 // Schritt im Normalbetrieb
T #Schritt
UN #Hilfsbit_Rampe // ie Hilfsbit_Rampe dient zur Freigabe zw. 25.0 und 50.0
SPB m001
L 50.0
T #Schritt
m001: L #SW_Input
L #SW_Output
==R
SPB ende1
//###################neuer Sollwert Bereich##########
U "Merker_Freigabe"
SPB m002
L #SW_Output
T #Temp_SW_Output
m002: NOP 0

U "Merker_Freigabe"
SPB m003
L #Temp_SW_Output
L 3.0
+R
T #SW_Oberhalb
m003: NOP 0

U "Merker_Freigabe"
SPB m004
L #Temp_SW_Output
L 3.0
-R
T #SW_Unterhalb
m004: NOP 0

//#################################################
U(
L #SW_Input
L #SW_Unterhalb
>=R
)
SPB m005
SPA SW_Aenderung
m005: NOP 0
U(
L #SW_Input
L #SW_Oberhalb
<=R
)
SPB m006
SPA SW_Aenderung
m006: NOP 0

L #SW_Input
L #SW_Output
-R
ABS // Absolutwert nehmen
L #Schritt // lade Schritt in Akku 1 und Ergebnis von Subtraktion in Akku 2
>R // Vergleich auf grösser von Inhalt von Akku 2(Ergebnis der Subtraktion) mit Inhalt Akku 1(Schritt)
SPB gross
L #SW_Input //wenn Eingabesollwert kleiner als der Schritt=>keine Rampe
T #SW_Output
SPA ende1
gross: NOP 0
L #SW_Input //wenn Eingabesollwert größer als der Schritt ist, werden
L #SW_Output // zwei Fälle unterschieden
<R
SPB positiv
L #SW_Output // 1.Fall
L #Schritt
+R
T #SW_Output
SPA ende
positiv : NOP 0
L #SW_Output //2.Fall
L #Schritt
-R
T #SW_Output
SPA ende

//##########bei groeßeren Sollwertaenderung########################################################

SW_Aenderung : NOP 0

L #SW_Input
L #SW_Output
-R
T #SW_Aenderung
L #SW_Aenderung
L 3
>R
SPB oui

oui: NOP 0
L #SW_Oberhalb
T #Neuer_Sollwert

L #SW_Aenderung
L -3
<R
SPB non
non: NOP 0
L #SW_Unterhalb
T #Neuer_Sollwert


L #Neuer_Sollwert //Lade den neuen Sollwert
L #SW_Output // zwei Fälle unterschieden
<R
SPB lower
L #SW_Output // 1.Fall
L #Schritt
+R
T #SW_Output
SPA ende
lower: NOP 0
L #SW_Output //2.Fall
L #Schritt
-R
T #SW_Output
SPA ende
ende: NOP 0
BEA
ende1: R #Hilfsbit_Rampe
 
Vermutlich geht es anderen hier im Forum ähnlich wie mir.
Mir geht es jedenfalls so, dass mir das Lesen von Programmen schwerer fällt als das Schreiben von Programmen.
Wenn ich noch dazu weiss, dass das Programm sich nicht so verhält, wie es erwartet wird und ich vor allem noch nicht einmal weiss, wie es sich überhaupt verhalten soll, dann bleibt von vornherein der "Spass an der Freude" aus, mich damit zu beschäftigen.
Wie soll ich aus einem bekanntermassen nicht funktionierenden Programm herauslesen, was es eigentlich leisten soll?
Manchmal kann das zwar offensichtlich sein, wenn z.B. jemand "nur" eine positive Flanke statt einer negativen oder eine UND-Verknüpfung statt einer ODER-Verknüpfung verwendet oder eine Klammer falsch gesetzt hat.
Aber in diesem Fall bin ich mir noch nicht einmal sicher, ob ich Dich richtig verstehe, wenn Du von Rampe oder von Sollwert sprichst.
Du willst vermutlich Sprünge Deines berechneten Ergebnisses begrenzen bzw. zeitlich ein wenig verschleifen, aber woher kommen die Sprünge und wie soll der zeitliche Ablauf der Reaktion aussehen? Die Steilheit der "Rampe" soll begrenzt werden, aber was, wenn sie nicht begrenzt wird?
Die SprungzielNamen 'oui' und 'non' verstehe ich zwar (dafür reichen meine FranzösischKenntnisse ;) ), aber die bedingten Sprünge auf die direkt folgende ProgrammZeile verwirren etwas.
Rätsel über Rätsel ...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@Heinileini erstmals danke für deine Zeit. Veilleicht muss ich es ausfürlich erklären.
Die Rampenfunktion läuft sehr gut. Sie wird gebraucht um langsam mit der eingestellten Steilheit den Sollwert zu erreichen.
Nun wollte ich die Rampenfunktion erweitern. Ziel ist es bei der Eingabe eines neuen Sollwertes , dass dieser in diesem Bereich bleibt : Alter Sollwert<= neuer Sollwert<=Alter Sollwert+3. Bei größeren Sollwertänderung z.B 1-->5 oder 15 --> 10 dass es auf 3 begrenzt i.e 1-->4 oder 15-->12.


L 0.2 // Schritt bzw Steilheit
T #Schritt
UN #Hilfsbit_Rampe // ie Hilfsbit_Rampe dient zur Freigabe zw. 25.0 und 50.0
SPB m001
L 50.0
T #Schritt
m001: L #SW_Input // Sollwert
L #SW_Output // Istwert
==R
SPB ende1


L #SW_Input
L #SW_Output
-R
ABS // Absolutwert nehmen
L #Schritt //
>R //Sollwert kleiner als der Schritt bzw.
SPB gross
L #SW_Input
T #SW_Output
SPA ende1

gross: NOP 0

L #SW_Input //Sollwert ist größer als der Schritt
L #SW_Output // zwei Fälle unterschieden
<R
SPB positiv
L #SW_Output // 1.Fall
L #Schritt
+R
T #SW_Output
SPA ende
positiv : NOP 0
L #SW_Output //2.Fall
L #Schritt
-R
T #SW_Output
SPA ende

ende: NOP 0
BEA
ende1: R Hilfsbit_Rampe
 
Zunächst habe ich diesen Bereich definiert. Dann war meine Überlegung solange ein Sollwert in dem Bereich (Alter Sollwert-3<= neuer Sollwert<=Alter Sollwert+3) liegt , soll die Rampenfunktion ohne größe Sollwertänderung die Rechnung übernehmen. Erst wenn ein Sollwert außerhalb von diesen Bereich bzw. eine größere Sollwertänderung vorliegt dann sollte gesprungen werden in dem Teil wo der neue Sollwert ausgewertet werden soll. Genau bei dem Teil habe ich ein Problem. Bei dieser Auswertung mit der Differenz läuft es nicht. Was ist hier an meiner Überlegung falsch?
 
Hier kommt erstmal das, was ich ausgetüftelt hatte, bevor ich Deine Beiträge #2 und #3 gesehen habe:
Code: 
     L   irInp ;   // InputVariable REAL 
     L   iorOut :  // InOutVariable REAL
     ==R ;
     SPB end ;
     <R  ;
     SPB neg ;
pos: -R  ;         // Differenz
     L   3.0 ;     // max. Zuwachs
     >=R ;
     SPB erg ;
     TAK ;
     SPA erg ;
neg: -R  ;         // Differenz
     L   -3.0 ;    // min. Zuwachs
     <=R ;
     SPB erg ;
     TAK ;
erg: L   iorOut ;
     +R  ;
end: T   iorOut ;
     BE  ;
Und jetzt muss ich noch die beiden Beiträge lesen ... bis dahin ...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
batindeko schrieb:
Bei größeren Sollwertänderung z.B 1-->5 oder 15 --> 10 dass es auf 3 begrenzt i.e 1-->4 oder 15-->12.
Zum Vergrößern anklicken....
Ich glaube, das hatte ich richtig verstanden und berücksichtigt.

batindeko schrieb:
Ziel ist es bei der Eingabe eines neuen Sollwertes , dass dieser in diesem Bereich bleibt : Alter Sollwert<= neuer Sollwert<=Alter Sollwert+3.
Zum Vergrößern anklicken....
Das habe ich vermutlich anders gedeutet. In meiner Variante wird eine Differenz, die zwischen -3.0 und +3.0 liegt nicht beibehalten, sondern
"beseitigt" in ihrer berechneten Grösse.
Du möchtest aber ±3.0 als "HystereseBand" wirksam werden lassen, in dem der Baustein keine Änderung des Ausgangs vornehmen soll?

Den Schritt = 0.2 bzw. 25.0 (nur im Kommentar) bzw. 50.0 weiss ich immer noch nicht einzuordnen.
Anscheinend willst Du für den Schritt per '#Hilfsbit_Rampe' einen der beiden Werte 0.2 und 50.0 auswählen können, aber was soll der Schritt bewirken?
Wird der nicht ohnehin auf ±3.0 begrenzt, so dass 50.0 nie wirksam werden kann?
 
Heinileini schrieb:
Du möchtest aber ±3.0 als "HystereseBand" wirksam werden lassen, in dem der Baustein keine Änderung des Ausgangs vornehmen soll?
Zum Vergrößern anklicken....
genau ist es
Heinileini schrieb:
Anscheinend willst Du für den Schritt per '#Hilfsbit_Rampe' einen der beiden Werte 0.2 und 50.0 auswählen können, aber was soll der Schritt bewirken?
Zum Vergrößern anklicken....
genau dient zur Auswahl. der Schritt steht hier für die Rate der Rampe
Heinileini schrieb:
Wird der nicht ohnehin auf ±3.0 begrenzt, so dass 50.0 nie wirksam werden kann?
Zum Vergrößern anklicken....
+/-3 begrenzt den eingegebenen Sollwert.
 
Zuletzt bearbeitet:
Habe nochmal geknobelt und gegrübelt und versucht, die gewünschte Funktionsweise zu erraten und bin zu folgendem völlig ungetesteten PseudoCode gelangt. Augen zu und ...
Code: 
     L    0.2    ;  // Schritt bzw. Steilheit
     UN   #Hilfsbit_Rampe ;
     SPB  con    ;
     L    50.0   ;
con: T    trSch  ;  // TempVariable  REAL
     L    irInp  ;  // InputVariable REAL
     L    iorOut ;  // InOutVariable REAL
     ==R         ;
     SPB  end    ;
     <R          ;
     SPB  neg    ;
pos: -R          ;  // Differenz
     L    3.0    ;
     <=R         ;
     SPB  hys    ;  // <= 3.0
     TAK         ;
     L    trSch  ;  // max. Zuwachs
     >=R         ;
     SPA  tst    ;
neg: -R          ;  // Differenz
     L    -3.0   ;
     >=R         ;
     SPB  hys    ;  // >= -3.0
     TAK         ;
     L    trSch  ;  
     NEGR        ;  // min. Zuwachs
     <=R         ;
tst: SPB  erg    ;  // begrenzt
     TAK         ;
     SPA  erg    ;  // nicht begrenzt
hys: L    0.0    ;  // im HystereseBand
erg: L    iorOut ;
     +R          ;
end: T    iorOut ;
     BE          ;
 
Zuletzt bearbeitet:
@Heinileini ich habe den Code getestet aber es hat leider nicht funktioniert.
Außerdem habe ich mein Programm angepasst aber ich stöße vor dem folgenden Problem bei größeren Sollwertänderung läuft das Program nur einmal und wird beendet. Gibt es eine Möglichkeit diesen Teil solange durchlaufen zu lassen bevor es bei bMerker beendet wird. Oder wie kann ich das Aktualisieren der folgenden Variablen SW_Oberhalb und SW_Unterhalb verhindert so dass mein neuer Sollwert nicht geändert wird

</L 0.2 // Schritt
T #Schritt
UN #Hilfsbit_Rampe // ie Hilfsbit_Rampe dient zur Freigabe zw. 25.0 und 50.0
SPB m001
L 50.0
T #Schritt
m001: L #SW_Input
L #SW_Output
==R
SPB ende1
//#####neuer Sollwert Bereich##########
U "Merker_Freigabe"
SPB m002
L #SW_Output
T #Temp_SW_Output
m002: NOP 0

U "Merker_Freigabe"
SPB m003
L #Temp_SW_Output
L 3.0
+R
T #SW_Oberhalb
m003: NOP 0

U "Merker_Freigabe"
SPB m004
L #Temp_SW_Output
L 3.0
-R
T #SW_Unterhalb
m004: NOP 0

//#################################################

L #SW_Unterhalb
L #SW_Input
<=R
SPB m005
TAK
T Neuer_Sollwert
SPA SW_Aenderung
m005: NOP 0
UN bMerker
SPB b001
BEA
b001: L #SW_Oberhalb
L #SW_Input
>=R
SPB m006
TAK
T Neuer_Sollwert
SPA SW_Aenderung

m006: NOP 0
L #SW_Input
L #SW_Output
-R
ABS
L #Schritt
>R
SPB gross
L #SW_Input //wenn Eingabesollwert kleiner als der Schritt=>keine Rampe
T #SW_Output
SPA ende1
gross: NOP 0
L #SW_Input
L #SW_Output
<R
SPB positiv
L #SW_Output // 1.Fall
L #Schritt
+R
T #SW_Output
SPA ende
positiv : NOP 0
L #SW_Output //2.Fall
L #Schritt
-R
T #SW_Output
SPA ende

//####bei groeßeren Sollwertaenderung#######

SW_Aenderung : NOP 0

L #Neuer_Sollwert //Lade den neuen Sollwert
L #SW_Output // zwei Fälle unterschieden
<R
SPB lower
L #SW_Output // 1.Fall
L #Schritt
+R
T #SW_Output
SPA ende

lower: NOP 0
L #SW_Output //2.Fall
L #Schritt
-R
T #SW_Output
SPA ende

ende: NOP 0
SET
S bMerker
BEA
ende1: R #Hilfsbit_Rampe
>
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
batindeko schrieb:
@Heinileini ich habe den Code getestet aber es hat leider nicht funktioniert.
Zum Vergrößern anklicken....
Anscheinend hatte ich Dein Anliegen doch nicht richtig verstanden.
batindeko schrieb:
Außerdem habe ich mein Programm angepasst aber ich stöße vor dem folgenden Problem bei größeren Sollwertänderung läuft das Program nur einmal und wird beendet.
Zum Vergrößern anklicken....
??? Was ist Sollwert und wodurch kommen grössere SW-Änderungen zustande? Was beeinflusst Deinen SW, ausser das Programm selbst?
batindeko schrieb:
Gibt es eine Möglichkeit diesen Teil solange durchlaufen zu lassen bevor es bei bMerker beendet wird.
Zum Vergrößern anklicken....
??? Vermutlich, aber ich weiss nicht wovon Du sprichst und was Du meinst.
batindeko schrieb:
Oder wie kann ich das Aktualisieren der folgenden Variablen SW_Oberhalb und SW_Unterhalb verhindert so dass mein neuer Sollwert nicht geändert wird
Zum Vergrößern anklicken....
??? Woher soll das Programm wissen, ob Dein neuer Sollwert nicht geändert oder irgendwann dann doch wieder geändert werden soll?

Je länger Dein Programm wird und je länger ich darauf starre, desto weniger erschliesst sich mir, was das Programm eigentlich wie tun soll.
 
@Heinileini mein Programm ist eine Rampenfunktion. Sie hat grundsätzlich zwei Parameter : SW_Input und SW_Output.
SW_Input ist mein Sollwertgeber. SW_Output ist das Ergebnis der treppenförmigen Änderung des Sollwertes bis der Endwert erreicht ist.
Am Anfang des Algorithumus wird geprüft ob die Differenz zw. SW_Input und SW_Output größer als der Schritt ist
L #SW_Input
L #SW_Output
-R
ABS
L #Schritt
>R

solange die Differenz kleiner als der Schritt ist, wird der Sollwert sofort am SW_Output übergeben
SPB gross
L #SW_Input
T #SW_Output
SPA ende1

Wenn die Differenz größer als der Schritt ist, wird nun SW_Output als Referenzpunkt genommen und mit dem festgelegten
Schritt addiert oder subtrahiert bis der Endwert erreicht wird.
gross: NOP 0
L #SW_Input
L #SW_Output
<R
SPB positiv
L #SW_Output // 1.Fall
L #Schritt
+R
T #SW_Output
SPA ende
positiv : NOP 0
L #SW_Output //2.Fall
L #Schritt
-R
T #SW_Output
SPA ende
ende : NOP 0
BEA
ende1: R #Hilfsbit_Rampe

Die oben beschriebene Rampenfunktion läuft fehlerfrei.

nun möchte ich diese Rampenfunktion erweitern: Sie soll nun zusätzlich auf größere SW_Änderungen reagieren. Damit meine ich
der Sollwert darf nun zw. dem vorigen Sollwert +3 und dem vorigen Sollwert -3 vorliegen. Wenn er außerhalb dieses Bereichs liegt , muss der Sollwert entweder mit dem vorigen Sollwert +3 oder dem vorigen Sollwert - 3 begrenzt werden.
zB. der vorige Sollwert war 5. Ich gebe nun 10 als neuer Sollwert ein. In diesem Fall handelt es sich bei mir um eine größere Sollwertänderung, da 10 außerhalb des folgenden Bereichs 2 <= X <= 8 ist. Der Sollwert wird nun entweder auf 8 oder auf 2 begrenzt je nach dem wir in die ansteigende oder absteigende Richtung sind
Code:
 
Zuletzt bearbeitet:
Deine ±3-Begrenzung hatte ich bisher gaaanz anders verstanden.
Bisher: solange innerhalb der ±3-Begrenzung, dann den bisherigen AusgangsWert unverändert beibehalten, ansonsten "business as usual", also das Verhalten entsprechend Deiner anfangs beschriebenen Regeln, abhängig von der jeweils angewälten Schrittweite.
Jetzt: eine überlagerte RampenFunktion, die die anfangs definierte überflüssig macht, wenn der Absolutwert der Schrittweite grösser ist als 3.

Anwahl der Schrittweite:
Laut Kommentar im Programm kannst Du zwischen 25.0 und 50.0 umschalten.
Laut Anweisungen im Programm kannst Du zwischen 0.2 und 50.0 umschalten.
:unsure:
Fall a: Laut Kommentar ist die Schrittweite immer deutlich grösser als die Begrenzung auf ±3.
Die Begrenzung auf die Schrittweite ist überflüssig, weil dann anschliessend noch auf ±3 begrenzt wird.
Fall b: Laut Anweisungen ist die Schrittweite mal deutlich kleiner als ±3 und mal ist sie deutlich grösser.
Dadurch wird der Fall b "unübersichtlich".
Ist die Schrittweite unter 3 gewählt (z.B. 0.2), dann kommen die "grossen Sprünge" gar nicht mehr vor, weil sie durch die kleine Schrittweite der RampenFunktion weggebügelt werden.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Grüß euch,

meine erste Frage: Warum AWL, oder handelt es sich um die 300er/400er Welt?

Anyhow,
sowohl in der TIA-Welt als auch in der Simatic-Managerwelt gäbe es die Funktion "LIMIT" (FC22) die auch über AWL aufgerufen werden kann.

Kurz mein Pseudocode dazu:
Code: 
L output
L 3.0
-R
T minimum

L output
L 3.0
+R
T maximum

CALL LIMIT
MN:= minimum
IN:= input
MX:= maximum
OUT:= output //RET_VAL := output für Simatic Manager

würde das weiterhelfen?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
DeltaMikeAir schrieb:
Schreibt er ja in #1. Es ist ein vorhandener Code, er soll ihn nur anpassen.
Zum Vergrößern anklicken....
Mir ist es eher darum gegangen, dass man sich selbst einen FC_Limit in einer etwas übersichtlichen Sprache programmieren könnte und die Funktion ebenfalls in AWL aufrufen kann.
Ist jetzt vielleicht ein weinig falsch rüber gekommen, aber nur weil man eine AWL Funktion ausbauen soll, kann man sich so das Programmiererleben ein wenig einfacher machen.
Da es diese Funktion aber bereits gibt, wäre das auch überflüssig.
 
batindeko schrieb:
richtig ist ich kann zwischen 0.2 und 50.0 umschalten wobei ich die 50.0 nicht brauche
Zum Vergrößern anklicken....
Dann wundert es mich aber nicht, dass das Programm bei "grossen Sprüngen" nicht so funktioniert, wie erwartet, denn ...
Heinileini schrieb:
Ist die Schrittweite unter 3 gewählt (z.B. 0.2), dann kommen die "grossen Sprünge" gar nicht mehr vor, weil sie durch die kleine Schrittweite der RampenFunktion weggebügelt werden.
Zum Vergrößern anklicken....
 
Heinileini schrieb:
Fall a: Laut Kommentar ist die Schrittweite immer deutlich grösser als die Begrenzung auf ±3.
Die Begrenzung auf die Schrittweite ist überflüssig, weil dann anschliessend noch auf ±3 begrenzt wird.
Fall b: Laut Anweisungen ist die Schrittweite mal deutlich kleiner als ±3 und mal ist sie deutlich grösser.
Dadurch wird der Fall b "unübersichtlich"
Zum Vergrößern anklicken....
Die Schrittweite bzw. der Schritt ist eine Konstante in diesen Fall 0.2. Die Rampenfunktion wird erst angewendet, wenn die Differenz zw. SW_Input und SW_Output größer als die Schrittweite ist. Dann hat man diese zwei Fälle wenn der SW_Input kleiner der SW_Output ist, wird der Output als Referenzpunkt genommen und Subtrahiert bis der Endwert erreicht und umgekehrt.
Die Begrenzung kommt erst bei größeren Sollwertänderung
 

Similar threads

B
TIA Hilfe bei Verständnis der Schleife in AWL
Antworten
17
Aufrufe
1K
ducati
D
C
Step 7 AWL-Programm verstehen
Antworten
7
Aufrufe
3K
PN/DP
PN/DP
B
TIA AWL Code in FUP umschreiben
2
Antworten
26
Aufrufe
4K
batindeko
B
Dekuika
Step 7 Zähler AWL
Antworten
8
Aufrufe
2K
Dekuika
Dekuika
Y
TIA AWL Umwandlung in FUP oder KOP
Antworten
4
Aufrufe
2K
GUNSAMS
G
Zurück
Oben