Simulaz. Python

GTOT=W*G*H*C

print GTOT

GTOT=1./(1+GTOT)

print GTOT

_,y=control.step_response(GTOT,T=t)

plt.plot(t,y)

plt.grid()

plt.show()

>>> 9.5e+06

-------------------------

s^2 + 1.254e+04 s + 5e+05

s^2 + 1.254e+04 s + 5e+05

-------------------------

s^2 + 1.254e+04 s + 1e+07

Per quanto riguarda la risposta al disturbo con ingresso nullo:

. ()

() = () 1 + ()()()()

s = control.tf('s')

t = np.linspace(0, 0.01, 100)

G=400./(s+40)

H=1./10

W=25000./(s+12500.)

C=9.5

GTOT=W*G*H*C

print GTOT

GTOT=W/(1+GTOT)

print GTOT

_,y=control.step_response(GTOT,T=t)

plt.plot(t,y)

plt.grid()

plt.show()

>>> 9.5e+06

-------------------------

s^2 + 1.254e+04 s + 5e+05

2.5e+04 s^2 + 3.135e+08 s + 1.25e+10

--------------------------------------------

s^3 + 2.504e+04 s^2 + 1.668e+08 s + 1.25e+11

CONTROLLO DINAMICO

Esercizio – Comparsa di oscillazioni retroazionando un sistema

24

() = + 3 + 1

import control

import matplotlib.pyplot as plt

import math

import numpy as np

from control.matlab import *

s=control.tf('s')

G=24/(s**2+3*s+1)

print G

GR=control.feedback (G, 1)

print GR

(p, z) = control.pzmap (G)

print p,z

t,y=control.step_response(G)#N.B.!!!: y,t=step(G)

plt.figure()

plt.plot(t,y,"b")

plt.title('Step Responsse ')

plt.ylabel('Amplitude')

plt.xlabel('Time(sec)')

t,y=control.step_response(GR)

plt.figure()

plt.plot(t,y,"b")

plt.title('Step Responsse ')

plt.ylabel('Amplitude')

plt.xlabel('Time(sec)')

plt.grid(True)

plt.show() :

Esempio sistemi del secondo ordine – stesso

1 9 25

1() = 2() = 3() =

++ 1 + 3 + 9 + 5 + 25

Visualizzare le risposte al gradino

import control

import matplotlib.pyplot as plt

import math

import numpy as np

from control.matlab import *

s = control.tf('s')

t = np.linspace(0, 6, 100)

G1=1/(s**2+s+1)

G2=9/(s**2+3*s+9)

G3=25/(s**2+5*s+25)

_,y1=control.step_response(G1,T=t)

_,y2=control.step_response(G2,T=t)

_,y3=control.step_response(G3,T=t)

plt.plot(t,y1,label="G1")

plt.plot(t,y2,label="G2")

plt.plot(t,y3,label="G3")

plt.legend(loc="lower right")

plt.grid()

plt.show() 

Esempio sistemi del secondo ordine - stesso :

n

1 1 1

1() = 2() = 3() =

+ 0.6 + 1 + 0.4 + 1 + 0.2 + 1

Visualizzare le risposte al gradino

s = control.tf('s')

t = np.linspace(0, 20, 1000)

G1=1/(s**2+0.6*s+1)

G2=1/(s**2+0.4*s+1)

G3=1/(s**2+0.2*s+1)

_,y1=control.step_response(G1,T=t)

_,y2=control.step_response(G2,T=t)

_,y3=control.step_response(G3,T=t)

plt.plot(t,y1,label="G1")

plt.plot(t,y2,label="G2")

plt.plot(t,y3,label="G3")

plt.legend(loc="lower right")

plt.grid()

plt.show() Controllori PID

Controllo Peoporzionale con poli complessi e coniugati

Simulare l’azione proporzionale nel caso di poli reali, con ingresso scalino unitario e Kp=0.1; Kp=1; Kp=!0

import control

import matplotlib.pyplot as plt

import math

import numpy as np

import control.matlab as mlab

from scipy import signal

Kp=[0.1,1,10]

s = control.tf('s')

G = 1/(1+s)

for k in Kp:

GR=k*G/(1+k*G)

t,y=control.step_response(GR)

plt.plot(t,y,label='Kp='+str(k))

plt.title('Proportional Control')

plt.legend(loc="center right")

plt.grid()

plt.show()

Simulare l’azione proporzionale nel caso di poli complessi coniugati, con ingresso scalino unitario e

Kp=0.1;Kp=1;Kp=10

Kp=1

s = control.tf('s')

Ti=[0.1,1,2]

G = 1/(1+s)

t = np.linspace(0, 20, 100)

for ti in Ti:

C=Kp*(1+1/(ti*s))

GR=C*G/(1+C*G)

_,y=control.step_response(GR,T=t)

plt.plot(t,y,label=r'$\tau_{i}$='+str(ti),linewidth=3)

plt.title('Proportional Integral Control')

leg=plt.legend(loc="center right")

for line in leg.get_lines():

line.set_linewidth(4.0)

plt.grid()

plt.show() Azione proporzionale integrale e proporzionale derivativa

Simulare l’azione proporzionale-integrale nel caso di poli reali, con ingresso scalino unitario e

 

Kp=1; =0.1; =1; =2

1 1 1

Kp=1

s = control.tf('s')

Ti=[0.1,1,2]

G = 1/(1+s)

t = np.linspace(0, 20, 100)

for ti in Ti:

C=Kp*(1+1/(ti*s))

GR=C*G/(1+C*G)

_,y=control.step_response(GR,T=t)

plt.plot(t,y,label=r'$\tau_{i}$='+str(ti))

plt.title('Proportional Integral Control')

plt.legend(loc="center right")

plt.grid()

plt.show()

Simulare l’azione proporzionale-derivativa nel caso di poli reali, con ingresso scalino unitario e



Kp=1; =0; =1

D D

Kp=1

s = control.tf('s')

TD=[0,1]

G = 1/(s**2+2*s+1)

t = np.linspace(0, 6, 100)

for tD in TD:

C=Kp*(1+tD*s)

GR=C*G/(1+C*G)

_,y=control.step_response(GR,T=t)

plt.plot(t,y,label=r'$\tau_{D}$='+str(tD),linewidth=3)

plt.title('Proportional Derivative Control')

leg=plt.legend(loc="center right")

for line in leg.get_lines():

line.set_linewidth(4.0)

plt.grid()

plt.show()

Controllo integrativo: comportamento statico

Kp=10

s = control.tf('s')

TD=0

G = (s+10)/(s**2+100*s+400)

t = np.linspace(0, 50, 100)

u=t

C=Kp*(1/s)

GR=C*G/(1+C*G)

n,d= control.tfdata(GR)

GR= control.tf(n,d)

plt.subplot(2, 1, 1)

_,y=control.step_response(GR,T=t)

plt.grid()

plt.plot(t,y)

plt.subplot(2, 1, 2)

y,_,x=mlab.lsim(GR, u, t)

plt.plot(t,y,'y',t,u,'m')

plt.title('Controllo integrativo: comportamento statico')

plt.grid()

plt.show()

Controllo integrativo- effetto dei disturbi

def unit_step(t,n0,a,b,nP):

t0=n0*((nP+0)/(b-a))

u=[0]*t0;u.extend([1]*(t.size-t0))

return u

Kp=7

s = control.tf('s')

C = Kp*(1+1*(1/s)+0.05*s)

G = 1/(0.007*s**3+0.1*s**2+0.6*s+1)

G=G*C

D=1/(0.1*s+1)

t = np.linspace(0, 8, 1000)

H=1

R=1

d=1

GR=(G*R)/(1+G*H)

GD=D*d/(1+G*H)

_,y1=control.step_response(GR,T=t)

d=unit_step(t,5,int(t[0]),int(t[t.size-1]),t.size)

yd,_,_= mlab.lsim(GD, d, t)

y=y1+yd

plt.plot(t,y)

plt.title('Controllo integrativo: effetto dei disturbi')

plt.grid()

plt.show()

Controllo PID metodo di Ziegler-Nichols

Stabilizzare in retroazione unitaria la seguente fdt con il metodo di Ziegler-Nichols:

1

() = (1 + 0.1 ∙ ) ∙ (1 + 0.2 ∙ ) ∙ (1 + 0.4 ∙ )

s = control.tf('s')

Kp=11.25

C=Kp

G=1/((1+0.1*s)*(1+0.2*s)*(1+0.4*s))

GR=(C*G)/(1+C*G)

t = np.linspace(0, 2, 100)

_,y=control.step_response(GR,T=t)

plt.plot(t,y)

plt.grid()

plt.show()

PID - Verificare l’effetto della stabilizzazione

s = control.tf('s')

Kp=6.75

G=1/((1+0.1*s)*(1+0.2*s)*(1+0.4*s))

print 'G:',G

T=0.67

TI=0.335

TD=0.084

C=Kp*(1+1/(TI*s)+TD*s)

print 'C:',C

CG=control.series(C,G)

GR=control.feedback(CG,1)

print "GR:",GR

t = np.linspace(0, 2, 100)

_,y=control.step_response(GR,T=t)

plt.plot(t,y)

plt.grid()

plt.show()

>>>

G: 1

--------------------------------

0.008 s^3 + 0.14 s^2 + 0.7 s + 1

C:

0.1899 s^2 + 2.261 s + 6.75

---------------------------

0.335 s

GR: 0.1899 s^2 + 2.261 s + 6.75

------------------------------------------------------

0.00268 s^4 + 0.0469 s^3 + 0.4244 s^2 + 2.596 s + 6.75

CONTROLLO ON-OFF

Esempio di controllo ON-OFF di temperatura per la climatizzazione di un ambiente. Scopo del controllo è di

mantenere il livello di temperatura T(t) di unastanza entro i margini prestabiliti, rappresentati da una soglia

inferiore TINF e una soglia superiore TSUP.

N=500

t1=0.

t2=10.

K=1

dt=(t2-t1)/N

TRIF=20

T0=0

TSUP=TRIF+3

TINF=TRIF-3

TRIF = (TSUP + TINF)/2.

T=[0]*N

To=[0]*N

Td=[0]*N

NOISE=9

x=[0]*N

t=0

pos = int(math.log10(abs(dt)))

n=abs(pos)+1

tau=dt*10**(n)

t=[0]*N

ON=TRIF

OFF=0

c=ON

for i in range (0,N):

if(i>N/4):

Td[i]=NOISE

if i>0:

T[i]=(((c-To[i-1])*K+c)-T[i-1])*(dt/tau)+T[i-1]

else:

T[i]=T0

To[i]=T[i]+Td[i]

t[i]=i*dt

if(i*dt>6):

x[i]=0

if(i>0):

if(To[i]>=TINF and To[i]<TSUP and x[i-1]==ON):

x[i]=ON

if(To[i]>TINF and To[i]<TSUP and x[i-1]==OFF):

x[i]=OFF

if(To[i]<=TINF):

x[i]=ON

if(To[i]>=TSUP):

x[i]=OFF

if(To[i]==TRIF):

x[i]=OFF

c=x[i]

plt.plot(t,To)

plt.plot(t,x)

plt.axhline(y=TSUP, color='r', linestyle='-')

plt.axhline(y=TINF, color='y', linestyle='-')

plt.grid()

plt.show()

Esempio – Controllo ON-OFF serbatoio

qi_def=40

qi=qi_def

qu=30.

h0=0

A=20.

h=h0

hsup=20.

hinf=10.

hrif=(hinf+hsup)/2.

v=0

t1=0.

t2=(60.*60.)/1.5

N=500

dt=(t2-t1)/N

t = np.linspace(t1, t2, N)

V=[]

H=[]

ON=1

OFF=0

tau=15.

for i in range(t.size):

if i>0:

h=h+((qi*v-qu)*(dt/tau))/A

else:

h=h0

if(i>0):

if h>=hinf and h<hsup and v==ON:

v=ON

if h>hinf and h<hsup and v==OFF:

v=OFF

if(h<=hinf):

v=ON

if(h>=hsup):

v=OFF

if(h==hrif):

v=OFF

V.append(qi*v)

H.append(h)

plt.gcf().canvas.set_window_title('Serbatoio ON-OFF')

plt.plot(t,H,'g',t,V,'r')

plt.ylim(0,50)

plt.axhline(y=hsup, color='m', linestyle='-')

plt.axhline(y=hinf, color='y', linestyle='-')

plt.grid()

plt.show()

CONTROLLO DI POTENZA

Parzializzazione di semionda

N=100

f=100.

t1=0.

t2=1./f

t = np.linspace(t1, t2, N)

X=[]

T=[]

dt=(t2-t1)/N

thresh=0.3

x=np.abs(np.sin(2*np.pi*f*t))

r=[(2./N)*(i%(N/2)) for i in range(N)]

#y = [x if i >= thresh else i for i in r]

#y =[j if i >= thresh else 0 for i in r for j in x]

y=[0]*len(x)

for i in range(len(r)):

if r[i]>=thresh:

y[i]=x[i]

else:

y[i]=0

plt.subplot(3, 1, 1)

plt.plot(t,x,'b')

plt.subplot(3, 1, 2)

plt.plot(t,r,'r')

plt.subplot(3, 1, 3)

pl