WAGO: 6 Pumpen in Abhängigkeit der Temperatur und der Betriebsdauer aktivieren

SPS-Programmierung
1

Moin Moin

ich habe ein Problem mit der Realisierung einer Steuerung (Wago 750-838 CanOpen)
Aufgabenstellung:
6 Pumpen sollen in Abhängigkeit der Temperatur und der bisherigen Betriebsdauer aktiviert werden.

Es sollen 6 Temperatur-Bereiche programmiert werden. In der 1. Stufe soll die Pumpe mit der geringsten Betriebsdauer aktiviert werden. In der zweiten Stufe wird die Pumpe mit der zweitwenigsten Betriebsdauer zur Ersten zugeschaltet usw. bis in der 6 Stufe alle Pumpen laufen.
Ich habe in der WAGO-Bibliothek “Gebäude_allgemein.lib” die FBs
“Fb_Stufen” → Stufenschalter bis max 5 Stufen
“FbBetrDauer” → nimmt die Betriebsdauer auf
“FbLaufzeit” → nimmt von max 3 “Geräten” die Betriebsdauer auf und aktiviert das “Gerät” mit der geringsten
Da die FBs leider nicht 1 zu 1 übernommen werden können, habe ich Probleme eine Lösung für die Aufgabenstellung zu finden.

Habt Ihr eine Idee, wie ich das Problem anpacken kann?
Besonders auch die Zuschaltung einer weiteren Pumpe in bspw. der 2 Stufe macht mir Probleme. Wie erhalte ich denn die Pumpe mit der 2. geringsten Betriebsdauer?
Vielleicht habe ich auch nur Probleme, weil ich versuche die Aufgabe in FUP zu lösen?!?!?

Bin über alle Informationen/Tipps/Vorschläge und natürlich Lösungen dankbar!!!

LG
Leidi

2

Hallo.

habe auf dem 750-837 etwas ähnliches realisiert. Bei meiner Lösung werden die Pumpen und Ventilatoren “Reihe um” angewählt. Die absolute Betriebsdauer ist dabei allerdings nicht ausschlaggebend.
Alles weitere kannst Du dem Code entnehmen.

Viele Grüße

Jürgen


FUNCTION_BLOCK zKaskade_7

VAR_INPUT
  Required : INT;
  Ready_01,    Ready_02, Ready_03, Ready_04, Ready_05, Ready_06, Ready_07: BOOL;

END_VAR

VAR_OUTPUT
	ReadyCount : INT;
   	Out_01, Out_02, Out_03, Out_04, Out_05, Out_06, Out_07: BOOL;

END_VAR

VAR_INPUT CONSTANT
	CycleTime: UINT;
      OverlapTime: UINT;        (*Überlappungszeit*)
END_VAR

VAR
    Oscillator :TON;
    CycleTimeCount: UINT;
    OverlapTimeCount: UINT;        (*Überlappungszeit Zähler*)

    Ready : ARRAY [1..7] OF BOOL := FALSE;
    Out : ARRAY [1..7] OF BOOL := FALSE;




    RequiredExt : INT;

    OutOnTime : ARRAY [1..7] OF UINT;
    OutOffTime : ARRAY [1..7] OF UINT;


    ForCount : INT;
    OverlapFlag: BOOL;
    OldValueTime: UINT;
    SearchRes: INT;
	OutCount : INT;


END_VAR





(*Beginn: Pumpenabschalten wenn nicht bereit-----------------------------*)
FOR ForCount:=1 TO 7 BY 1 DO
    IF (Ready[ForCount] = FALSE) THEN
        Out[ForCount] := FALSE;
    END_IF
END_FOR;
(*Ende: Pumpenabschalten wenn nicht bereit-------------------------------*)

Oscillator(IN := NOT Oscillator.Q, PT:= T#1s);

IF Oscillator.Q = TRUE THEN
(*Beginn: Bestandsaufnahme----------------------------------------------------*)
    Ready[1]  := Ready_01;
    Ready[2]  := Ready_02;
    Ready[3]  := Ready_03;
    Ready[4]  := Ready_04;
    Ready[5]  := Ready_05;
    Ready[6]  := Ready_06;
    Ready[7]  := Ready_07;


    Out[1]  := Out_01;
    Out[2]  := Out_02;
    Out[3]  := Out_03;
    Out[4]  := Out_04;
    Out[5]  := Out_05;
    Out[6]  := Out_06;
    Out[7]  := Out_07;


    OutCount := 0;
    ReadyCount := 0;
    FOR ForCount:=1 TO 7 BY 1 DO
        IF (Out[ForCount] = TRUE) THEN
            OutCount := OutCount + 1;
            OutOnTime[ForCount] := OutOnTime[ForCount] + 1;
            OutOffTime[ForCount] := 0;
        ELSIF (Ready[ForCount] = TRUE) THEN
                OutOffTime[ForCount] := OutOffTime[ForCount] + 1;
                OutOnTime[ForCount] := 0;
        ELSIF (Ready[ForCount] = FALSE) THEN
            OutOnTime[ForCount] := 0;
            OutOffTime[ForCount] := 0;
        END_IF

        IF (Ready[ForCount] = TRUE) THEN
            ReadyCount := ReadyCount + 1;
        END_IF
    END_FOR;
(*Ende: Bestandsaufnahme------------------------------------------------------*)

    CycleTimeCount := CycleTimeCount + 1;
    IF CycleTimeCount >= CycleTime THEN (*Bei zu langer Laufzeit abschalten*)
        CycleTimeCount := 0;
        OverlapFlag := TRUE;
    END_IF

    IF ((OverlapFlag = TRUE) AND (Required>0)) THEN
        OverlapTimeCount := OverlapTimeCount + 1;
        RequiredExt := Required + 1;
    ELSE
        RequiredExt := Required;
    END_IF


    IF OverlapTimeCount >= OverlapTime THEN
        OverlapTimeCount := 0;
        OverlapFlag := FALSE;
    END_IF

    IF (ReadyCount > RequiredExt) THEN
        WHILE (OutCount < RequiredExt) DO
            OldValueTime := 0;
            SearchRes := 1;
            FOR ForCount:=1 TO 7 BY 1 DO
                IF ((OutOffTime[ForCount] > OldValueTime)
                 AND (Ready[ForCount] = TRUE) AND (Out[ForCount] = FALSE)) THEN
                    OldValueTime := OutOffTime[ForCount];
                    SearchRes := ForCount;
                END_IF
            END_FOR;
            IF (Ready[SearchRes] = TRUE) THEN
                Out[SearchRes] := TRUE;
                OutCount := OutCount + 1;
            END_IF
        END_WHILE
    ELSE
        FOR ForCount:=1 TO 7 BY 1 DO
            IF (Ready[ForCount] = TRUE) THEN
                Out[ForCount] := TRUE;
            END_IF
        END_FOR;
    END_IF


    WHILE (OutCount > RequiredExt) DO
        OldValueTime := 0;
        SearchRes := 1;
        FOR ForCount:=1 TO 7 BY 1 DO
            IF ((OutOnTime[ForCount] > OldValueTime)
             AND (Ready[ForCount] = TRUE) AND (Out[ForCount] = TRUE)) THEN
                OldValueTime := OutOnTime[ForCount];
                SearchRes := ForCount;
            END_IF
        END_FOR;
        Out[SearchRes] := FALSE;
        OutCount := OutCount - 1;
    END_WHILE


END_IF

Out_01 := Out[1];
Out_02 := Out[2];
Out_03 := Out[3];
Out_04 := Out[4];
Out_05 := Out[5];
Out_06 := Out[6];
Out_07 := Out[7];
3

Noch was, den “Stufenschalter” müsstest Du noch selber erfinden. Ich denke mein Regler passt nicht so ganz auf Deine Anwendung

4

Vielen Dank Dorfmeister

Brr…habe mir eben deinen Vorschlag angesehen.
RESPEKT sagt der Greenhorn!!! Bin ehrlich: habe es noch nicht 100%ig verstanden, da ich mit ST (noch) keine Erfahrung habe. Aber ich denke, um die Aufgabe zu lösen, wird es fast unumgänglich werden sich damit zu beschäftigen, oder?!?
Bin in meinen Gedanken nun soweit, dass ich in einem FUP-Unterprogramm die Betriebsdauern über den WAGO-FB logge und diese dann in einem weiteren ST-Unterprogramm auf IRGENDEINE Art auswerten werde, um die Reihenfolge der Pumpenanschaltung in Abhängigkeit der Stufe zu realiesieren. Die Geschichte mit den Stufen ist ja eigentlich mit nem einfachen Vergleich möglich (wobei da noch ne Hysterse drin sein müßte).

Also, nach wie vor, bin ich über jeden weiteren Tipp und Lösungsvorschlag dankbar.

LG