Hallo,

Ich versuche schon seit gefühlten 2 Tagen einen Verzögerungstimer in Strukturiertem Text einzubauen, welcher die simple Aufgabe hat nach seinem Aufruf eine gewisse Zeit vergehen zu lassen und erst dann die nächste Codezeile zu lesen. Ich habe es bisher geschafft einen zu implementieren, jedoch will dieser nicht reseten, also genauer gesagt, das ganze funktioniert nur einmal.

hier einmal der Code:

FUNCTION_BLOCK Delay
VAR_INPUT
   ZEIT : TIME;
END_VAR
VAR_OUTPUT
   OK : BOOL;
END_VAR
VAR
   timer : TP;
END_VAR
--------------------------
IF timer.Q = TRUE THEN
   timer();
ELSE
timer(IN := FALSE);
timer.PT := ZEIT;
timer(IN := TRUE);
END_IF
OK := NOT timer.Q;

Vielen Dank schon mal im Voraus.

Hallo

In der Steuerungstechnik wird kein Programm angehalten.
Wie soll das ergebnis aussehen das du haben möchtest?

Angehalten soll es ja auch nicht wirklich werden. Ich brauche lediglich eine gewisse Verzögerung.
Bsp.:
Wenn ein Sensor anschlägt, dann soll erst nach 2sec ein Aktor betätigt werden.

Wie bereits gesagt funktioniert der oben angeschriebene Code nur bei einem Durchlauf. Beim nächsten Aufruf wird gleich ohne Verzögerung das Signal ausgegeben, welches ich darauf zurückschliesse das der Timer nicht zurückgesetzt wird. Wichtig ist dabei das der Code als Funktionsblock programmiert wurde und im Hauptprogramm auch als Funktion aufgerufen wird.

Hallo

Verögert dein FB Output schalten könnte so aussehen

(* Aufruf des Timmers *)
timer (IN := xBedingung ,PT := ZEIT );
(* Ausgang zuornen *)
OK := timer.Q;

Die Zuordnung des Ausganges habe ich ja bereits in dem Code gemacht den ich in meinem ersten Post veröffentlicht habe. Ein Bsp. von meinem Hauptprogramm sieht so aus:

 
PROGRAM test
VAR
   t_wait : timer; 
END_VAR
--------------------------
t_wait(ZEIT := T#3S);
IF t_wait.OK = TRUE THEN
(*Code ausführen*)
END_IF

Und irgendwie will das ganze nicht funktionieren.

Mit TON habe ich bereits versucht einen Funktionsbaustein zu implementieren, jedoch ohne Erfolg.

Das Problem ist einfach das der in meinem ersten Post implementierte Funktionsbaustein irgendwo einen Fehler hat, so das bei erneutem Aufruf keine Verzögerung stattfindet. Ich finde den Fehler aber einfach nicht.

1. Ist die Zeit noch nicht abgelaufen schaltest du den Eingang ständig zwischen False und TRUE hin und her.

timer(IN := FALSE);
timer.PT := ZEIT;
timer(IN := TRUE);

1. Ist die Zeit Abgelaufen rufst du den Baustein nur noch auf mit dem letzten zustand.

timer();

1. Was sollte dein Progamm machen ? nach Zeit X ein Programmteil bearbeiten für ein Zylus ? Danach wieder die Zeit warten?
   ODER Wass soll der Ausgang machen wenn die Zeit abgelaufen ist?

FUNCTION_BLOCK Delay
VAR_INPUT
ZEIT : TIME;
END_VAR
VAR_OUTPUT
OK : BOOL;
END_VAR
VAR
timer : TP;
END_VAR

IF timer.Q = TRUE THEN
timer(IN := FALSE);
( Dein Programm der für ein Zyklus bearbeitet wird ? )
ELSE

timer.PT := ZEIT;
timer(IN := TRUE);

END_IF
OK := NOT timer.Q;

Das Hauptprogramm wird zyklisch abgearbeitet. Dort schalte ich gewisse Aktoren aufgrund eines Sensorstandes. Um Sicherheitshalber nicht jeden Aktor sofort nach Aktivierung des Sensors zu schalten brauche ich eine kleine Verzögerung. Diese wollte ich anhand eines separaten FB implementieren, zwecks Wiederverwendung.
Da ich das Hauptprogramm ja zyklisch abarbeite muss der FB auch bei jedem neuen Aufruf verzögern.

Kurzes Beispiel wie ich es meine:

PROGRAM Test
VAR
   verzögerung : Delay; //Mein Baustein aus dem ersten Post
   aktor : BOOL; 
   sensor : BOOL;
END_VAR
aktor := false;
if sensor = true then
verzögerung(ZEIT := T#3s); //baustein wird aufgerufen
if verzögerung.OK = true then //wenn Ausgang OK aus dem Baustein Delay aktiv ist, dann soll die nächste Zeile abgearbeitet und Aktor aktiviert werden
aktor := true;
end_if
end_if

Dario_S hat geschrieben:

PROGRAM Test
VAR
   verzögerung : Delay; //Mein Baustein aus dem ersten Post
   aktor : BOOL; 
   sensor : BOOL;
END_VAR
aktor := false;
if sensor = true then
verzögerung(ZEIT := T#3s); //baustein wird aufgerufen
if verzögerung.OK = true then //wenn Ausgang OK aus dem Baustein Delay aktiv ist, dann soll die nächste Zeile abgearbeitet und Aktor aktiviert werden
aktor := true;
end_if
end_if

Lösung ohne Delay-Baustein:

VAR
  Timer : TON;
  sensor : BOOL;
  aktor : BOOL;
END_VAR
---
Timer(IN:=sensor, PT:=T#3s);
aktor := Timer.Q;

PS: Versuch mal dein Programm zu Debuggen (Breakpoints), dann verstehst du, warum dein Programm nicht funktioniert. JSchoehaus hat es auch schon erklärt.

hallo liebe forenmitglieder,

ich muss gestehen ich hatte einen denkfehler. da ich längere zeit keine sps programmierung gemacht habe und vorher mich eine zeit lang mit microcontroller programmierung beschäftigt habe, konnte ich wohl nicht so richtig in meinen gedanken die funktion der beiden system umschalten hehe. tut mir leid für die grosse verwirrung, jetzt wird mir auch einiges klarer.

ich wollte aber trotzdem nur mal fragen wie es möglich ist den TON zu reseten? ich weiss das er von meinem IN Signal abhängt, aber obwohl ich dieses Signal wieder auf FALSE und dann auf TRUE setze, geht das Ausgangssignal Q des TON ohne verzögerung durch.

vielen dank nochmal für die gute hilfe

Moin

TON funktioniert so:
Bei jeder STEIGENDEN Flanke am Eingang IN fängt die Zeit von 0 an zu laufen die unter pt angegeben ist.
ET zeigt die bereits abgelaufene zeit des Timers an. Wenn ET >= PT dann wird Ausgang Q gesetzt.
Zum reseten reicht also ein AUFRUF mit IN:=FALSE.

Ich vermute du setzt nur den Parameter auf FALSE und rufst dann den Timer nicht auf.

Also z.B.:

Timer: TON;

Timer(IN := TRUE,pt := t#5s);
If Timer. Q then
Timer.IN := FALSE; <- DAS IST KEIN AUFRUF, ALSO AUCH KEIN RESET
Timer(IN:=FALSE); <- DAS IST EIN AUFRUF inkl RESET
end_if