Sisteme de reglare automata

Obiective

Prezentarea unui sistem de reglare automata

Prezentarea unui sistem SCADA care contine sisteme de reglare automata

Prezentarea unui sistem SCADA pentru controlul debitului

Prezentarea unui sistem SCADA pentru controlul temperaturii

Organizarea sarcinilor de lucru

Parcurgeti cele patru capitole ale cursului.

In cadrul fiecarui capitol urmariti exemplele ilustrative si incercati sa le realizati in medul de dezvoltare TIA-Portal.

Fixati principalele idei ale cursului, prezentate în rezumat.

1. Prezentarea unui sistem de reglare automata

SRA - Sistemele de Reglre Automata sunt sisteme cu bucla de reactie (loop control) care functioneaza pe baza analizei in permanenta a valorii de iesire (marimii reglate), preluata prin intermediul reactiei negative. Diferenta dintre valoarea de iesire si valoarea de referinta, numita "eroare", este folosita de SRA pentru eliminarea acesteia sau mentinerea ei in anumite intervale prestabilite.

Un SRA se compune din urmatoarele elemente:

RA - Regulator automat;
PF - Partea fixata(Procesul condus);

Marimile definite:

r - Referinta;
e - Eroarea;
u - Comanda;
v - Perturbatia;
y - Variabila de proces(Marimea reglata, iesirea);

Daca definim H_r(s) functia de transfer a regulatorului si H_f(s) functia de transfer a partii fixate, Schema unui SRA devine:

    Partea fixata(PF) contine procesul tehnologic(PT) asupra caruia actioneaza regulatorul automat(RA).
    Procesul tehnologic(PT) este comandat de catre regulatorul automat(RA) prin intermediul elementelor de executie(EE). Citirea marimii reglate(y - variabila de proces) se face prin intermediul traductorilor(T) care ofera marimea x proportionla cu marimea y adica x=k*y.
    Putem deci reprezenta un SRA sub forma:

Unde:

RA - Regulator automat;
PT - Procesul tehnologic;
EE - Element de Executie;
T - Traductor;

Marimile definite:

r - Referinta;
e - Eroarea;
u - Comanda;
m - Executia;
v - Perturbatia;
y - Variabila de proces(Marimea reglata, iesirea);
x - Reactia;

Mult mai fireasca ar fi reprezentarea in care procesul tehnologic(PT) ar fi reprezentat separat, la care se adauga in mod firesc dispozitivul de automatizare. Aceasta reprezentare ar corespunde dezvoltarii firesti a sistemelor tehnologice in care initial se realizeaza un proces tehnologic dupa care se automatizeaza.

2. Sisteme de reglare automata in SCADA TIA-Portl

Un SRA de ti PID mentine valoarea iesirii y in jurul valorii de referinta r prin intermediul comenzii u. Comanda u este generata de SRA prin intermedul unei functii de transfer caracterizata de trei constante: kp,ki,kd si Ti.

kp este constanta - Proportionala (cu valori intre 0-4)
ki este constanta - Integrativa (cu valori intre 0-5)
kd este constanta - Derivativa (cu valori intre 0.2-2)
Te este timpul de esantionare (250 ms adica timpul de Refresh al HMI)

In imaginea de jos este reprezentata comanda u (cu rosu) si iesirea y(cu verde).

Sistem de Reglare Automata PID

r:			kp:
ki:			kd:

Pentru implementarea regulatorului PID se va folosi metoda "Velocity". Conform acesti metode, comanda u din momentul k depinde de referinta r, de iesirea y si de e_v (e, din momentul k-1). Intervalul de timp dintre momentul k si momentul k-1 este Te(Timpul de esantionare).
Comanda u se obtine prin insumarea elementului proportional, integrativ (inte) si derivativ(deriv) astfel:

    e = r - y;
    inte = inte + e * Te;
    deriv = (e - e_v) / Te;
    u = kp * e + ki * inte + kd * deriv;
    e_v = e;

In care:

y este iesirea din pasul curent
r este valoareareferinta
e este eroarea calculata (r-y) din pasul curent
e_v este valoarea calculata pentru e in pasul anterior
u este valoarea calculata pentru comanda din pasul curent
kp este constanta - Proportionala (cu valori intre 0-4)
ki este constanta - Integrativa (cu valori intre 0-5)
kd este constanta - Derivativa (cu valori intre 0.2-2)
Te este timpul de esantionare (250 ms adica timpul de Refresh al HMI)

Variabila de proces adica iesirea y reprezentand totodata marimea reglata ar trebui sa provina din procesul tehnologic(PT) prin plasarea unui traductor. Folosind de exemplu functia de transfer a unui sistem de ordinul 5 si anume: H_f(s)=1/(5s+1). Dupa discretizare obtinem relatia:

y = (u*Te + 5 * y_v) / (5 + Te);
In care:

y este valoarea calculata pentru iesire din pasul curent
y_v este valoarea calculata pentru y in pasul anterior
u este valoarea calculata pentru comanda din pasul curent
Te este timpul de esantionare (250 ms adica timpul de Refresh al HMI)

    Dupa cum se observa ea depinde de de y_v(y din pasul anterior), comanda u din pasul curent si de timpul de esantionare Te.

     Sistem de reglare automata PID realizat in SCADA TIA-Portal

    Pe baza ecuatiilor descrise mai sus, vom realiza proiectul SCADA: Sist_regl_000 proiect ce contine un SRA (sistem de reglare automata) de tip PID (proportional-integrativ-derivativ) discret.
    In cadrul acestui proiect, vom crea pentru inceput, Screen-ul Sra_pid_init pentru initializarea parametrior.

    Pentru a crea acest Screen, avem nevoie de tag-urile: Kp, Ki, Kd, Te de tip "real" si r (Ref-r:set point)bde tip "int".
    Obiectele de tip "Slider" utilizate pentru setarea parametrilor, nu admit decat atribuirea de tag-uri de tip "int".
    Vom defini tag-urile: Kp_int, Ki_int, Kd_int, Te_int de tip "int" dupa care vom calcula valoarea tag-urilor: Kp, Ki, Kd, Te prin impartirea acestora la 100 daca dorim doua zecimale de exemplu.
    Pe evenimentul "Change al fiecarui obiect "Slider" vom atribui functia "sra_init_p()"

Sub init_p()
	If r=0 Then
		SmartTags("Kp_int")=75
		SmartTags("Ki_int")=120
		SmartTags("Kd_int")=1
		SmartTags("Te_int")=5
		SmartTags("r")=400
	End If
	SmartTags("y")=0
	SmartTags("y_v")=0
	SmartTags("inte")=0
	SmartTags("deriv")=0
	SmartTags("e")=0
	SmartTags("e_v")=0
	SmartTags("u")=0
	SmartTags("Kp")=SmartTags("Kp_int")/100
	SmartTags("Ki")=SmartTags("Ki_int")/100
	SmartTags("Kd")=SmartTags("Kd_int")/100
	SmartTags("Te")=SmartTags("Te_int")/100
	SmartTags("r_scal")=SmartTags("r")/10
End Sub

     Implementarea algoritmului de reglre automata in HMI

    Pentru inceput vom implementa algoritmul pentru SRA in HMI.
    Vom crea in continuare, in cadrul acestui proiect, Screen-ul Sra_pid_hmi unde vom afisa grafic evolutia in timp a marimilor u,y,r, folosind obiectul "Trend View". Obiectul "Trend View" admite adaugarea de trend-uri dar tag-urile corespunzatoare trebuie sa fie scalate in domeniul 0-100. Vom introduce pe linga Tagurile u,y,r tag-urile u_scal, y_scal, r_scal scalate in domeniul 0-100

Algoritmul pentru implementarea SRA presupune reglarea in mai multe iteratii.
Pe evenimentul "Load" al screen-ului "Sra_pid_hmi" se vol lansa functiile "init_p()" si "pid_hmi()".

Functia "pid_hmi()" implementeaza algoritmul PID.

Sub pid_hmi()
    Dim inte, deriv,tm
	tm=Timer()
	Do While SmartTags("Tag_ScreenNumber")=3
		If Timer > tm+0.01 Then
			e = r - y
			inte = inte + e * Te
			deriv = (e - e_v) / Te
			u = Kp * e + Ki * inte + Kd * deriv
			e_v = e
			y = (u*Te + 5 * y_v) / (5 + Te)
			y_v=y
			u_scal=u/10
			y_scal=y/10
			r_scal=r/10
			tm=Timer()
		End If	
	Loop
End Sub

     Implementarea algoritmului de reglre automata in PLC

    Implementarea algoritmul de reglre automata in HMI, nu este recomandat deoarece functionarea procesului reglat depinde de HMI care este mult mai lent. Pe de alta parte HMI-ul trebuie sa fie tot timpul pornit, functionarea procesului depinzand de HMI. Solutia mai eficienta consta in implementarea algoritmului de reglre automata in PLC.
    Vom crea in continuare, in cadrul acestui proiect, Screen-ul Sra_pid_plc si vom implementa functia de reglare in PLC. Avem nevoie de urmatoarele tag-uri PLC:

Vom defini in Program Block -- Cyclic Interrupt --urmatoarea rutina:

"Contor" := "Contor" + 1;
IF "Contor" > 999 THEN
    "Contor" := 0;
END_IF;
IF "mod" = 2 THEN
    "e" := INT_TO_REAL("r") - "y";
    "inte" := "inte" + "e" * "Te";
    "deriv" := ("e" - "e_v") / "Te";
    "u" := "Kp" * "e" + "Ki" * "inte" + "Kd" * "deriv";
    "e_v" := "e";
    "y" := ("u" * "Te" + 5 * "y_v") / (5 + "Te");
    "y_v" := "y";
    "u_scal" := REAL_TO_INT("u" / 10);
    "y_scal" := REAL_TO_INT("y" / 10);
    "r_scal" := REAL_TO_INT("r" / 10);
END_IF;

Toate variabilele utilizate in rutina de sus trebuiesc initializate, vom defini in Program Block -- Startup -- urmatoarea rutina:

"mod" := 0;
"Contor" := 0;
"Kp" := 0.75;
"Ki":= 1.2;
"Kd":= 0.01;
"r":= 400;
"r_scal" := 0;
"e" := 0;
"e_v" := 0;
"y" := 0;
"y_v" := 0;
"r" := 400;
"y_scal" := 0;
"inte":= 0;
"deriv":= 0;
"u":= 0;
"u_scal":= 0;

Putem crea acum creen-ul Sra_pid_plc.

    Pe evenimentul "Load" al screen-ului "Sra_pid_hmi" se va lansa functia "init_p()" si vom seta Tag-ul Mod=2, lansandu-se astfel functia de reglare din PLC.

     Sistem de reglare automata a nivelului unui lichid

    Urmatorul screen Sra_pid_nivel foloseste functia de reglare din PLC pentru a regla nivelul de lichid dintr-un tank.
    Pe evenimentul "Load" al screen-ului "Sra_pid_nivel" se va lansa functia "init_p()" si va seta Tag-ul Mod=2

Sistem de reglare automata a turatiei unui motor CC

Pentru inceput vom utiliza un circuit electronic echivalent al unui motor CC.

Inainte de a realiza SRA-ul pentru acest circuit va trebui sa comandam circuitul cu diverse forme de unda pentru a determina raspunsul sistemului.
Avem nevoie de doua tag-uri suplimentare pentru a comanda circuitul si pentru a citi raspunsul:

Vom realiza screen-ul Cmd_s_mcc si vom analiza raspunsul la semnalul rampa:

Adaugam in Program Block -- Cyclic Interrupt --urmatoarea rutina:

// Comanda rampa

IF "mod" = 5 THEN
    "u_mcc" := "u_mcc" + 10;
    IF "u_mcc" > 32000 THEN
        "u_mcc" := 0;
    END_IF;
    "u_scal" := "u_mcc" / 320;
    "y_scal" := REAL_TO_INT("y_mcc" / 320);
    "r_scal" := REAL_TO_INT("r" / 10);
END_IF;

Din acelasi screen Cmd_s_mcc vom analiza raspunsul la semnalul treapta.
Adaugam in prealabil in Program Block -- Cyclic Interrupt --urmatoarea rutina:

// Comanda treapta

IF "mod" = 6 THEN
    IF "Contor" > 500 THEN
        "u_mcc" := 31000;
    ELSE
        "u_mcc" := 0;
    END_IF;
    "u_scal" := "u_mcc" / 320;
    "y_scal" := REAL_TO_INT("y_mcc" / 320);
    "r_scal" := REAL_TO_INT("r" / 10);
END_IF;

Urmatorul screen Sra_s_mcc foloseste functia de reglare din PLC pentru a regla nivelul turatia circuitului echivalent al motorului CC.
Pe evenimentul "Load" al screen-ului "Sra_s_mcc" se va lansa functia "init_p_s_mcc()" si va seta Tag-ul Mod=3

Sub init_p_s_mcc()
	SmartTags("Kp_int")=20
	SmartTags("Ki_int")=50
	SmartTags("Kd_int")=1
	SmartTags("Te_int")=10
	SmartTags("r")=300
	SmartTags("y")=0
	SmartTags("y_v")=0
	SmartTags("inte")=0
	SmartTags("deriv")=0
	SmartTags("e")=0
	SmartTags("e_v")=0
	SmartTags("u")=0
	SmartTags("Kp")=SmartTags("Kp_int")/100
	SmartTags("Ki")=SmartTags("Ki_int")/100
	SmartTags("Kd")=SmartTags("Kd_int")/100
	SmartTags("Te")=SmartTags("Te_int")/100
	SmartTags("r_scal")=SmartTags("r")/10
End Sub

Pentru implementarea algoritmului de reglare automata, tinem cont de:

"y_mcc" este valoarea citita de la senzorul de turatie montat la intrarea analogica AI0 : %IW112
Convertorul analogic furnizeaza valori in domeniu 0-32000 pentru tensiuni in domeniul 0-10V
Tensiunea furnizata de senzor este in domeniul 0-7V
Convertorul analogic va furniza valori in domeniu 0-22400 pentru tensiuni in domeniul 0-7V
Stabilim domeniul de reglare : 0-500 deci factorul de scala va fi fs=32000/500=64
Referinta e furnizata de slider-ul de pe ecran avand valori inre 100-400 (lasam marje pentru minim si maxim de 100)
De pe diagrama rezulta un raport intre intrare si iesire de k=0.156
Iesirea "y_mcc" este citita de la AI0 si trebuie scalata cu fs*k adica 64*0.156
Vom folosi deci in loc de "y" ---- "y_mcc"/(64*0.156) adica "y_mcc"/10

Adaugam in Program Block -- Cyclic Interrupt --urmatoarea rutina:

// Regulator PID pentru circuitul echivalent al unui motor de CC

IF "mod" = 3 THEN
    "e" := INT_TO_REAL("r") - "y_mcc" / 10;
    "inte" := "inte" + "e" * "Te";
    "deriv" := ("e" - "e_v") / "Te";
    "u_mcc" := REAL_TO_INT("Kp" * "e" + "Ki" * "inte" + "Kd" * "deriv") * 64;
    IF "u_mcc" > 32000 THEN
        "u_mcc" := 32000;
    END_IF;
    IF "u_mcc" < 0 THEN
        "u_mcc" := 0;
    END_IF;
    "e_v" := "e";
    "y_v" := "y_mcc" / 10;
    "u_scal" := "u_mcc" / 320;
    "y_scal" := REAL_TO_INT("y_mcc" / 60);
    "r_scal" := REAL_TO_INT("r" / 6);
END_IF;

Putem trece acum la reglarea turatiei unui motor CC.

Pentru masurarea turatiei, s-a cuplat un generator pe axul motorului de CC

Raspunsul sistemului la semnal treapta fiind:

Raspunsul sistemului la semnal rampa fiind:

     - De pe diagrama rezulta un raport intre intrare si iesire de k=0.1
     - Vom folosi deci in loc de "y" ---- "y_mcc"/(64*0.1) adica "y_mcc"/6

    Adaugam in Program Block -- Cyclic Interrupt --urmatoarea rutina:

// Regulator PID pentru un  motor de CC
 
IF "mod" = 4 THEN
    "e" := INT_TO_REAL("r") - "y_mcc" / 6;
    "inte" := "inte" + "e" * "Te";
    "deriv" := ("e" - "e_v") / "Te";
    "u_mcc" := REAL_TO_INT("Kp" * "e" + "Ki" * "inte" + "Kd" * "deriv") * 64;
    IF "u_mcc" > 32000 THEN
        "u_mcc" := 32000;
    END_IF;
    IF "u_mcc" < 0 THEN
        "u_mcc" := 0;
    END_IF;
    "e_v" := "e";
    "y_v" := "y_mcc" / 6;
    "u_scal" := "u_mcc" / 160;
    "y_scal" := REAL_TO_INT("y_mcc" / 30);
    "r_scal" := REAL_TO_INT("r" / 5);
END_IF;

Raspunsul sistemului pentru k1=0,5 fiind:

Pentru Ki=0.7 obtinem:

3. Utilizarea unui bloc PID Compact
Capitol realizat cu contributia stud: Iulia Coros

Vom folosi in continuare blocul PID Compact pentru a realiza proiectul: Sist_regl_001 si vom adauga un SRA de tip PID Compact.

Configurare bloc PID Compact

Pasul 1 – Adaugam in proiectul nostru un nou bloc de tipul Cyclic interrupt in limbaj Leader si setam Cyclic time pe 100 de milisecunde.
Pasul 2 – In acest bloc creat adaugam blocul PID Compact pe care il gasim la categoria Technology.
Pasul 3 – Ne creem in tabelul de tag-uri urmatoarele variabile.

Atentie! Variabila pe care dorim sa o atribuim iesirii (Output) trebuie ss fie de tip REAL.
Atribuim aceste tag-uri blocului PID in felul urmator:

Putem vedea ca regulatorul a fost adaugat in folderul System blocks si in Technology Objects.
Pasul 4 – Pentru meniul de configurare a regulatorului apasam pe aceasta iconita:

Din aceste setari de configurare putem selecta tipul de regulator in functie de parametrul pe care dorim sa il reglam.

Foarte important! Regulatorul functioneaza in modul automat doar dupa ce pornim simularea si dam un restart (Stop CPU – Start CPU) unitatii centrale de procesare de pe butoanele:

Alegem tipul intrarii si iesirii pe care dorim sa le folosim.

Setam limitele superioare si inferioare ale semnalelor de intrare si iesire.

Tot din acest meniu putem seta manual parametri regulatorului sau schimba tipul acestuia (PID sau PI).

O metoda mai eficienta pentru setarea parametrilor regulatorului se face prin optiunea de FineTuning.

Exemplu de utilizare – Sistem de reglare automata a turatiei unei turbine (SRAV)

Dorim sa mentinem tensiunea furnizata consumatorilor constanta deci trebuie sa mentinem o turatie constanta a turbinei. Pentru acest lucru trebuie sa reglam deschiderea valvei de admisie in functie de turatia turbinei. La un consum de energie mai mare al consumatorilor, creste curentul si turatia turbinei tinde sa scada. Scaderea turatiei determina deschiderea valvei de admisie, care duce la cresterea turatiei.