Beiträge

versuch doch einfach mal das modul aus der aktuellen oscat.lib
zugegeben in st ist vieles einfacher, dort kann man eben wirklich programmieren...
naja zumindest was sps anbelangt.

mit in schaltest du die pumpe an und aus.
manual ist ein override eingang für eine hand zwangssteuerung
rst setzt die timer des betriebsstundenzählers auf null.

der ausgang pump steuert die pumpe, und der ontime und cycles zählt betriebsstunden und ein aus zyklen.

wenn du auf das modul einen doppelclick machst
kannst du die werte für zwangssteuerung und minimale laufzeit einstellen.

viel spass

wie ist das gemeint? verstehe ich nicht

hab das ganze mit eingangsvariblen aus einen fb schreiben probiert, es funktioniert.
jedoch werde ich erst nachlesen ob das iec confrom ist. wenn  ja mache ich die aenderung sie ist in jedem fall eine gute idee.

hier der pid regler aus der oscat lib

FUNCTION_BLOCK FT_PID
VAR_INPUT
   actual, set_point, offset, manual_in : REAL;
   Manual : BOOL;
   rst : BOOL := FALSE;
END_VAR
VAR_INPUT
   KP, TN, TV, limit_L, limit_H : REAL;
END_VAR
VAR_OUTPUT
   Y : REAL;
   LIM, overflow : BOOL;
END_VAR
VAR
   integ : FT_INT;
   deriv : FT_deriv;
   diff: REAL;
END_VAR

(*
version 1.1   25 dec 2006
programmer    hugo
tested by      tobias

FT_PID is a pid controller with manual functionality.
The PID controller works according to the fomula Y = KP * ( e + 1/TN * INTEG(e) + TV *DERIV(e)) + offset, while e = set_point - actual.
a rst will reset all internal data, while a switch to manual will cause the controller to follow the function Y = manual_in + offset.
limit_h and Limit_l set the possible output range of Y.
the output flags lim will signal that the output limits are active and overflow will signal that the integrator has reached the max or min limit. 

since rev 1.1 the "trapezregel is used for more accuracy.
*)


IF rst OR KP = 0 THEN
   y := offset;
   integ(rst := 1);
   integ.rst := 0;
ELSIF manual THEN
   Y := manual_in + offset;
   integ(rst := 1);
   integ.rst := 0;
ELSE
   (* calcualtion of the actual PID values *)
   diff := set_point - actual;

   (* integrator is only called if TN > 0 othewrwise it is disabled *)
   IF TN > 0 THEN integ(in := diff, K := 1/TN, out_min := (limit_L - offset) / KP, out_max := (limit_H - offset) / KP); END_IF;
   deriv(in := diff, K := TV);

   (* check if integrator has reached the allowed limits and set overflow if necessary *)
   IF integ.Out >= (limit_H - offset) / KP THEN
      Y := limit_H;
      overflow := TRUE;
   ELSIF integ.Out <= (limit_L - offset) / KP THEN
      Y := limit_L;
      overflow := TRUE;
   ELSE
      Y := KP * (integ.Out + deriv.out + diff) + offset;
      overflow := FALSE;
   END_IF;

   (* this portion limits the output to limit_H and limit_L and set the lim flag if limits are exceeded *)
   IF Y > limit_H THEN
      Y := limit_H;
      Lim := TRUE;
   ELSIF Y < limit_L THEN
      Y := limit_L;
      lim := TRUE;
   ELSE
      lim := FALSE;
   END_IF;
END_IF;

hier das pump interface aus der oscat lib vielleicht kannst du das mitverwenden

FUNCTION_BLOCK actuator_pump
VAR_INPUT
   in : BOOL;
   manual : BOOL;
   rst : BOOL := FALSE;
END_VAR
VAR_INPUT CONSTANT
   min_ontime : TIME := t#10s;
   min_offtime : TIME := t#10s;
   run_every : TIME := t#10000m;
END_VAR
VAR_OUTPUT
   pump : BOOL;
   runtime : REAL;
   cycles : REAL;
END_VAR
VAR
   tx : TIME;
   last_change : TIME;
   meter : ontime;
   old_man : BOOL;
END_VAR

(*
   version 1.0   4 dec 2006
   programmer    oscat
   tested BY      oscat

actuator_pump is a pump interface which cam be controlled by an input in and an input manual.
in or manual high turns the pump output on.
a rst input is used to reset the runtime counters.
when the pump was not active for a time run_every the actuator turns on the pump automatically for min_ontime.
two setup variables min_ontime and min_offtime guarantee a minimum runtime and offtime of the pump.
the units are hours and the output type is real to prevent fromoverfow.

*)

tx := TIME();
IF rst THEN
   rst := FALSE;
   meter(rst := 1);
   meter.rst := 0;
ELSIF manual AND NOT pump AND NOT old_man THEN
   last_change := tx;
   pump := 1;
ELSIF NOT manual AND old_man AND pump AND NOT in THEN
   last_change := tx;
   pump := 0;
ELSIF in AND NOT pump AND tx - last_change >= min_offtime THEN
   last_change := tx;
   pump := 1;
ELSIF pump AND NOT in AND NOT manual AND tx - last_change >= min_ontime THEN
   last_change := tx;
   pump := 0;
ELSIF NOT pump AND tx - last_change >= run_every THEN
   last_change := tx;
   pump := 1;
END_IF;

meter(in := pump);
runtime := meter.ontime;
cycles := meter.cycles;
old_man := manual;

verstehe, wenn jemand von extern einen rst aufruft dann wird er ausgeführt und die rst variable gelöscht.
die grundinitialisierung mir rst = true wuerde dann noch dafür sorgen das er beim ersten aufruft auch gleich initialisiert wird.

ich habe mich bisher nie getraut eine eingangsvariable aus dem programm heraus zu schreiben, ist den das nach iec61131 zulässig?

hast du hierzu auch schon eine beschreibung / source code?

Selbstoptimierung wäre Cool 

das waere absolut cool, aber derzeit habe ich leider noch keine brauchbaren algorithmen / verfahren gefunden
hat jemand hierzu ideen, inputs?

die eingänge tauschen ist ein guter tip, werde ich machen.
aber wieso rst auf true initialisieren, damit waere ein offener rst immer ein rst den rst ist high active.

wird in der rev 1.1 zum 1.1. erledigt, danke für den input.
der pid ist freilaufend, damit er auch bei stark beladener sps exact arbeitet.
ein pid der zyklisch aufgerufen wird kann von einer hoeher priorisierten task unterbrochen werden und dann entstehen fehler.
in der 1.1 werden wir den pid auch auf trapezformel umstellen, die etwas mehr genauigkeit liefert als die jetzt verwendete rechteckformel.

sonstige wünsche bitte mitteilen.