SPS- Programmierung mit ST

nach IEC 61131 mit CODESYS V2.3, CODESYS V3, e!COCKPIT

Lösungen Kapitel 12   Fuzzy-Füllstandsregelung

  Kopieren Sie den Programmcode und fügen Sie diesen in Ihre Entwicklungsumgebung ein.
  
 Aufgabe 12.2   Aufgabe 12.3     Übung 12.1   Aufgabe 12.4   Übung 12.2
Aufgaben 12.1 Funktionen zur Fuzzifizierung
 
Alle Variablenwerte sind normiert auf 0.0...1.0
 
FUNCTION FUZ_Rfall:REAL
(*Zugehörigkeitsgrad*)
VAR_INPUT
(*Eingang und Stützpunkte*)
 IN, S1, S2:REAL;
END_VAR
IF IN < S1 THEN
  FUZ_Rfall:= 1.0;
 ELSIF IN > S2 THEN
  FUZ_Rfall:= 0.0;
 ELSE
  FUZ_Rfall:=1.0/(S1-S2)*IN-S2/(S1-S2);
END_IF;

FUNCTION FUZ_Rsteig:REAL
(*Zugehörigkeitsgrad*)
VAR_INPUT
 IN, S1, S2:REAL;
END_VAR
VAR
 m:REAL;
END_VAR
IF IN < S1 THEN
  m:= 0.0;
 ELSIF IN > S2 THEN
  m:= 1.0;
 ELSE
  m:= 1.0/(S2-S1)*IN-S1/(S2-S1);
END_IF;
FUZ_Rsteig:= m;

FUNCTION FUZ_Trapez:REAL(*Zugehörigkeitsgrad*)
VAR_INPUT
 IN:REAL;
 S1:REAL;(*Stützpunkt 1*)
 S2:REAL;(*Stützpunkt 2*)
 S3:REAL;(*Stützpunkt 3*)
 S4:REAL;(*Stützpunkt 4*)
END_VAR
IF IN < S1 THEN
  FUZ_Trapez:= 0.0 ;
 ELSIF IN >= S1 AND IN <= S2 THEN
  FUZ_Trapez:= 1.0/(S2-S1)*IN – S1/(S2-S1);
 ELSIF IN > S2 AND IN < S3 THEN
  FUZ_Trapez:= 1.0 ;
 ELSIF IN >= S3 AND IN <= S4 THEN
  FUZ_Trapez:= 1.0/(S3-S4)*IN – S4/(S3-S4);
 ELSE
  FUZ_Trapez:= 0.0;
END_IF;

PROGRAM PLC_PRG
(*Test der Zugehörigkeitsfunktionen*)
VAR
 temp:REAL:= 20.0;
 m_kalt: REAL;
 m_warm: REAL;
 m_sehr_warm: REAL;
 y: REAL;
END_VAR
m_kalt:= FUZ_Rfall(
       IN:= temp, S1:= 20.0, S2:= 30.0);
m_warm:= FUZ_Trapez(
       IN:= temp, S1:= 20.0, S2:= 30.0, S3:= 30.0, S4:=40.0);
m_sehr_warm:= FUZ_Rsteig(
       IN:= temp, S1:= 30.0, S2:= 40.0);
  
Aufgaben 12.2 Funktion zur Inferenz und Defuzzifizierung
 
FUNCTION DEFUZ_2 : REAL
(*Defuzzifizierung*)
VAR_INPUT
 G1:REAL;(*Erfüllungsgrad für S1*)
 S1:REAL;(*Stützpunkt 1*)
 G2:REAL;(*Erfüllungsgrad für S2*)
 S2:REAL;(*Stützpunkt 2*)
END_VAR
VAR
 y:REAL;(*scharfer Wert*)
END_VAR
y:= (G1*S1+G2*S2)/(G1+G2);
DEFUZ_2:= y;

PROGRAM PLC_PRG
(*****************************************
Test der Zugehörigkeitsfunktionen und
der Inferenz und Defuzzifizierungsfunktion
******************************************)
VAR
 temp:REAL:= 20.0;
 m_kalt: REAL;
 m_warm: REAL;
 m_sehr_warm: REAL;
 y: REAL;
END_VAR
m_kalt:= FUZ_Rfall(
       IN:=temp, S1:= 20.0, S2:= 30.0);
m_warm:= FUZ_Trapez(
       IN:= temp,
       S1:= 20.0, S2:= 30.0, S3:= 30.0, S4:= 40.0);
m_sehr_warm:= FUZ_Rsteig(
       IN:=temp, S1:=30.0, S2:= 40.0);
y:= DEFUZ_2(G1:= m_kalt, S1:=1.0, G2:= m_warm, S2:= 0.5);
  
Aufgaben 12.3 Füllstandsregelung mit Fuzzy-Regler
 
FUNCTION_BLOCK BEHAELTER_IT1
(*********************************************************
Simulation eines niedrigen Behälters – IT1-Verhalten.
Der Füllstand steigt bei einem Sollwertsprung verzögert an.
**********************************************************)
VAR_INPUT
 rZUFLUSS, rABFLUSS:REAL;(*0 ... 1.0*)
END_VAR
VAR_OUTPUT
 rHOEHE:REAL;(*0 ... 1.0*)
END_VAR
VAR
 r_m:REAL;(*Steigung*)
END_VAR
IF rHOEHE <= 0.0 THEN (*Begenzung*)
 rHOEHE:= 0.0;
 rABFLUSS:= 0.0;
END_IF;
r_m:= r_m + ((rZUFLUSS – rABFLUSS) – r_m)*3.0* 0.01;(*VerzögerterAnstieg*)
rHOEHE:= rHOEHE + r_m * 0.01;
IF rHOEHE > 1.0 THEN (*Begenzung*)
 rHOEHE:= 1.0;
END_IF;

PROGRAM FUELLSTANDS_REG (*FUZZY-Bibliothek einbinden*)
(*Füllstandsregelung, Task: Zyklisch 100ms*)
VAR
 w:REAL;(*Sollwert*)
 x:REAL;(*Istwert = Füllhöhe*)
 e:REAL;(*Regeldifferenz*)
 y:REAL;(*Stellwert 0...1.0 = Zuflussmenge*)
 z:REAL:= 0.5;(*Abflussmenge*)
 BEHAELTER_1: BEHAELTER_IT1;(*Instanz*)
 m_l:REAL;(*Zugehörigkeitsgrad für "zu leer"*)
 m_v:REAL;(*Zugehörigkeitsgrad für "zu voll"*)
END_VAR
(******************************************************
Simulation des Behälters
*)
BEHAELTER_1(rZUFLUSS:= y, rABFLUSS:= z);
x:= BEHAELTER_1.rHOEHE;
(******************************************************
Fuzzy-Regler
*)
e:= w-x;
IF w = 0.0 OR e = 0.0 THEN y:= 0.0; RETURN; END_IF;
(*Bereich in dem die Regelung einsetzt = -0.1 und +0.1*)
m_v:= FUZ_Rfall(IN:= e, S1:= -0.1, S2:= 0.1);
m_l:= FUZ_Rsteig(IN:= e, S1:= -0.1, S2:= 0.1);
(******************************************************
 Regel 1: WENN "zu voll" DANN y (Ventil) zu
 Regel 2: WENN "zu leer" DANN y (Ventil) auf
 zu -> S1 = 0.0, auf -> S2 = 1.0
 *)
y:= DEFUZ_2(G1:= m_v, S1:= 0.0, G2:= m_l, S2:= 1.0);
  
Übung 12.1 Füllstandsregelung mit Fuzzy-Regler als FB
 
FUNCTION_BLOCK FUZ_REGLER
(******************************************************
Fuzzy-Regler
*******************************************************)
VAR_INPUT
 rSOLLWERT, rISTWERT:REAL;
 rFUZ_S1, rFUZ_S2:REAL;//Stützpunkte Fuzzifizierung
 rDEFUZ_S1, rDEFUZ_S2:REAL; //Stützpunkte Defuzzifizierung
END_VAR
VAR_OUTPUT
 rSTELLWERT:REAL;
END_VAR
VAR
 rDiff:REAL;
 m_1, m_2:REAL; //Zugehörigkeitsgrade der Regeldifferenz
END_VAR
rDiff:= rSOLLWERT - rISTWERT;
IF rSOLLWERT = 0.0 OR rDiff = 0.0 THEN rSTELLWERT:= 0.0; RETURN; END_IF;
(*Bereich in dem die Regelung einsetzt*)
m_1:= FUZ_Rfall(IN:= rDiff, S1:= rFUZ_S1, S2:= rFUZ_S2);
m_2:= FUZ_Rsteig(IN:= rDiff, S1:= rFUZ_S1, S2:= rFUZ_S2);
(*Defuzzifizierung*)
rSTELLWERT:= DEFUZ_2(G1:= m_1, S1:= rDEFUZ_S1, G2:= m_2, S2:= rDEFUZ_S2);

PROGRAM FUELLSTANDS_REG
(******************************************************************
Fuzzy, Füllstandsregelung mit FB, Task: Zyklisch 100ms
Bibliothek "FUZZY.library" aus 12_A2 über den Bibliotheksverwalter
hinzugefügt.
Zur Simulation können Sie nach dem Einloggen und Start den
Sollwert "w" vorbereiten und schreiben.
Beobachten Sie den Istwert "x".
*******************************************************************)
VAR
 w:REAL;(*Sollwert*)
 x:REAL;(*Istwert = Füllhöhe*)
 e:REAL;(*Regeldifferenz*)
 y:REAL;(*Stellwert 0...1.0 = Zuflussmenge*)
 z:REAL:= 0.5;(*Abflussmenge*)
 BEHAELTER_1: BEHAELTER_IT1;(*Instanz*)
 FUZ_REGLER1:FUZ_REGLER;
END_VAR
(************ Simulation des Behälters ****************)
BEHAELTER_1(rZUFLUSS:= y, rABFLUSS:= z);
x:= BEHAELTER_1.rHOEHE;
(****************Fuzzy-Regler**************************)
FUZ_REGLER1(
            rSOLLWERT:= w,
            rISTWERT:= x,
            rFUZ_S1:= -0.1, //+/-10%
            rFUZ_S2:= 0.1,
            rDEFUZ_S1:= 0.0,
            rDEFUZ_S2:= 1.0,
            rSTELLWERT=> y);
  
Aufgaben 12.4
                     		 Mehrfachgrößen-FUZZY-Regler, hier Störgrößenaufschaltung
 
PROGRAM FUELLSTANDS_REG
(******************************************************************
Fuzzy, Mehrfachgrößen-Füllstandsregelung,
Task: Zyklisch 100ms
Bibliothek "FUZZY.library" bzw. "FUZZY.lib" aus Kap. 12
über den Bibliotheksverwalter hinzugefügt.
Zur Simulation können Sie nach dem Einloggen und Start den
Sollwert "w" und Abfluss "z" vorbereiten und schreiben.
Beobachten Sie den Istwert "x", die Füllhöhe.
*******************************************************************)
VAR
 w:REAL;(*Sollwert*)
 x:REAL;(*Istwert = Füllhöhe*)
 e:REAL;(*Regeldifferenz*)
 y:REAL;(*Stellwert 0...1.0 = Zuflussmenge*)
 z:REAL:= 0.5;(*Abflussmenge*)
 BEHAELTER_1: BEHAELTER_IT1;(*Instanz*)
(*Zugehörigkeitsgrade*)
 m_l:REAL;(*für "zu leer", e ist positiv*)
 m_v:REAL;(* für "zu voll"*)
 m_k:REAL;(* für Ablauf "klein"*)
 m_g:REAL;(* für Ablauf "groß"*)
(*Erfüllungsgrade G*)
 g1, g2, g3, g4:REAL;
END_VAR
(******************************************************
Simulation des Behälters
*)
BEHAELTER_1(rZUFLUSS:= y, rABFLUSS:= z, rHOEHE=> x);
(******************************************************
Fuzzy-Regler
*)
e:= w-x;(*Regeldifferenz*)
IF w = 0.0 OR e = 0.0 THEN y:= 0.0; RETURN; END_IF;
(*Bereich e in dem die Regelung einsetzt = -0.1 und +0.1*)
m_v:= FUZ_Rfall(IN:= e, S1:= -0.1, S2:= 0.1);
m_l:= FUZ_Rsteig(IN:= e, S1:= -0.1, S2:= 0.1);
(*Bereich z (Ablauf) in dem die Regelung einsetzt = 0,25 und 0,75*)
m_k:=FUZ_Rfall(IN:= z, S1:= 0.25, S2:= 0.75);
m_g:=FUZ_Rsteig(IN:= z, S1:= 0.25, S2:= 0.75);
(*******************************************************
Regel 1: Wenn "zu voll" UND z klein dann y (Ventil) zu
Regel 2: Wenn "zu voll“ UND z groß, dann y mittel
Regel 3: Wenn "zu leer“ UND z klein, dann y mittel
Regel 4: Wenn "zu leer“ UND z groß, dann y auf
Erfüllungsgrade: UND -> MIN-Funktion
*)
G1:= MIN(m_v, m_k);
G2:= MIN(m_v, m_g);
G3:= MIN(m_l, m_k);
G4:= MIN(m_l, m_g);
(*******************************************************
Defuzifizierung
y zu -> S1 =0, Y mittel -> S2,S3 = 0.5 Y auf -> S4 -> 1.0
*)
y:= DEFUZ_4(
            G1:= g1,
            S1:= 0.0,
            G2:= g2,
            S2:= 0.5,
            G3:= g3,
            S3:= 0.5,
            G4:= g4,
            S4:= 1.0);

FUNCTION_BLOCK BEHAELTER_IT1
(*********************************************************
Simulation eines niedrigen Behälters – IT1-Verhalten.
Der Füllstand steigt bei einem Sollwertsprung verzögert an.
**********************************************************)
VAR_INPUT
 rZUFLUSS, rABFLUSS:REAL;(*0 ... 1.0*)
END_VAR
VAR_OUTPUT
 rHOEHE:REAL;(*0 ... 1.0*)
END_VAR
VAR
 r_m:REAL;(*Steigung*)
END_VAR
IF rHOEHE <= 0.0 THEN (*Begenzung*)
 rHOEHE:= 0.0;
 rABFLUSS:= 0.0;
END_IF;
r_m:= r_m + ((rZUFLUSS – rABFLUSS) – r_m)*3.0* 0.01;(*VerzögerterAnstieg*)
rHOEHE:= rHOEHE + r_m * 0.01;
IF rHOEHE > 1.0 THEN (*Begenzung*)
 rHOEHE:= 1.0;
END_IF;

FUNCTION DEFUZ_4 : REAL
(*****************************************
Defuzzifizierung - Höhenmethode
für vier Erfüllungsgrade
******************************************)
VAR_INPUT
 G1: REAL;(*Erfüllungsgrad für S1*)
 S1: REAL;(*Stützpunkt 1*)
 G2: REAL;(*Erfüllungsgrad für S2*)
 S2: REAL;(*Stützpunkt 2*)
 G3, S3, G4, S4: REAL;
END_VAR
DEFUZ_4:= (G1*S1+G2*S2+G3*S3+G4*S4)/(G1+G2+G3+G4);
  
Übung 12.2 Fuzzy-Füllstansregelung über die Abflussmenge
 
PROGRAM FUELLSTANDS_REG
(**************************************
Füllstansregelung über die Abflussmenge
***************************************)
VAR
 w:REAL;(*Sollwert*)
 x: REAL;(*Istwert = Füllhöhe*)
 e:REAL;(*Regeldiferenz*)
 y: REAL;(*Stellwert 0...1.0 = Abflussmenge*)
 z:REAL:=0.5;(*Zuflussmenge*)
 BEHAELTER_1: BEHAELTER_IT1;
 m_n, m_p: REAL;
END_VAR
(*****************************************
Behaltersimulation
*)
BEHAELTER_1(rZUFLUSS:= z, rABFLUSS:= y);
x:= BEHAELTER_1.rHOEHE;
(*****************************************
Regler
*)
e:= w-x; (*Regeldifferenz*)
m_n:= FUZ_Rfall(IN:= e, S1:=-0.1, S2:= 0.1);
m_p:= FUZ_Rsteig(IN:= e, S1:=-0.1, S2:= 0.1);
y:= DEFUZ_2(G1:= m_p, S1:= 0.0, G2:= m_n, S2:= 1.0);
  

© Vogel Buchverlag