Guida sulla simulazione ed uso di Python in

ambito Ingegneristico con riferimento al

Introduzione alla
Simulazione in
Python-SimuPy
Uso del Package SimuPy per
l’analisi dei Sistemi Dinamici

Ingegnere Massimo Talia-17/12/2021

1
Installazione di Python
Python è un linguaggio interpretato ad alto livello orientato agli oggetti sviluppato nel Febbraio del 1991
da Guido Van Rossum adatto, tra gli altri usi, a sviluppare applicazioni distribuite, scripting,
computazione numerica e system testing. Per scaricare l’inteprete Python basta andare su
https://www.python.org/ e cliccare sul menù download e scegliere Windows, Linux o macOS in base al
sistema operativo installato.

Una volta installato l’interprete secondo le indicazioni dal sito indicato sopra e aver settato la variabile
d’ambiente su Windows durante l’installazione, procedere con l’installazione del Package SimuPy
attraverso l’uso del gestore di applicazioni aggiuntive o package PIP, verificando prima se è operativo
da prompt DOS di Windows. Digitare pulsante logo Windows+R e scrivere in apri il comando CMD. Una
volta aperta la finestra del prompt di DOS, verificare la versione di PIP come in immagine di sotto.

Se la versione di PIP non è aggiornata all’ultima versione digitare da linea di comando la riga indicata in
figura seguente, avviando il prompt di DOS di nuovo come amministratore utilizzando la barra di ricerca

2
di Windows 10 in basso o cercando tra i programmi installati, tasto destro del mouse e scegliere di
avviare il prompt di DOS come amministratore.

Verificare di non aver già installato SimuPy cercando la lista di package installati attraverso il comando
da DOS C:\>py –m pip list. Per avere maggiori informazioni sui comandi PIP digitare C:\>py –m pip, per
informazioni sui comandi Python digitare C:\>py –h . Per installare SimuPy basta digitare il comando
C:\>py –m pip install simupy. Per reperire esempi o applicazioni utilizzare la versione Zip SimuPy-Master
ottenibile tramite Git all’indirizzo https://github.com/simupy/simupy.git tramite applicativo Git desktop
o all’indirizzo web https://github.com/simupy/simupy

3
Applicazione del metodo Ziegler-Nichols per la taratura PID ad anello chiuso per un
sistema massa molla smorzatore

Figura 1-Sistema massa molla smorzatore

Un sistema massa molla smorzatore è il classico esempio che rappresenta un modello semplificato di
sistema oscillante, che nel mondo concreto può essere ad esempio rappresentato dagli ammortizzatori
di un autoveicolo. Le variabili dinamiche o stati sono rappresentati dallo spostamento s(t) e dalla
derivata dello spostamento o velocità v(t)=𝑥(𝑡)̇ . Quindi in una rappresentazione ISU LTI il vettore degli
stati è:

𝑠(𝑡)
X(t)=
𝑣(𝑡)

L’ingresso u(t)= F(t) è la forza per fare oscillare il corpo, mentre l’uscita è pari allo spostamento
y(t)=s(t). A ciclo aperto il sistema oscilla in maniera dipendente dal forzamento ed incontrollatamente,
senza poter farlo evolvere in maniera desiderata. Lo scopo di un filtro di controllo a ciclo chiuso è quello
di stabilizzare le oscillazioni, fare variare le performance dinamiche e statiche secondo delle specifiche.
Nel caso del sistema di sopra, il controllore è la mano umana che fa variare le oscillazioni del corpo. In
generale nel campo dell’ingegneria applicata al mondo reale, un sistema di controllo è un meccanismo
di controllo delle performance di un prodotto secondo limiti di legge o requisiti di prodotto prestabiliti
dal costruttore. Esso può essere di tipo: elettromeccanico, meccanico, elettrico, elettronico,
informatico (computers o PLC industriali). Una rappresentazione ISU (Ingresso Stato Uscita) matriciale
del sistema descritto precedentemente è la seguente:

0 1 0
𝐴𝑐 = 𝐵𝑐 = 𝐶 = [ 1 0] 𝐷 = 0
−𝑘/𝑚 −𝑏/𝑚 1/𝑚

Dove Ac e Bc sono le matrici dinamiche degli stati C e D sono relative all’uscita. Il sistema è strettamente
proprio poiché 𝐷 = 0.

4
Lo schema di controllo PID a ciclo chiuso è il seguente:

Figura 2-Schema di controllo a ciclo chiuso PID

Il metodo di Ziegler-Nichols per la taratura dei controllori PID (Proporzionale, Integrale, Derivativo),
risalente al 1942, è tra i più usati nell’industria ed è apprezzato per la sua semplicità, per il fatto di non
richiedere un modello matematico del processo e per le prestazioni che riesce a produrre. Si tratta di un
algoritmo per trovare il cosiddetto "guadagno critico" Kc, dal quale si deriveranno gli altri parametri del
PID.
Algoritmo:
1. Il processo viene fatto controllare da un controllore esclusivamente proporzionale
(KI e KD vengono impostati a zero);
2. Il guadagno K del controllore proporzionale viene gradualmente aumentato;
3. Il guadagno critico Ku è il valore del guadagno per cui la variabile controllata presenta
oscillazioni sostenute, cioè che non spariscono dopo un transitorio: questa è una misura
dell'effetto dei ritardi e della dinamica del processo;
4. Si registra il periodo critico Pu delle oscillazioni sostenute;

Secondo la seguente tabella, si determinano le costanti per il controllore P, PI o PID.

Metodo Ziegler–Nichols
Tipo Kp tau_I Tau_D
P 0,50Ku - -
PI 0,45Ku Pu/1,2 -
PID 0,60Ku Pu/2 Pu/8
Tabella 1-Taratura Ziegler-Nichols

5
Implementazione software in Python-SimuPy dell’algoritmo di taratura PID

Utilizzando SimuPy è stato implementato l’algoritmo PID nel codice come segue.

import numpy as np

from scipy import signal, linalg

from simupy.systems import LTISystem, SystemFromCallable

from simupy.block_diagram import BlockDiagram

import matplotlib.pyplot as plt

#construct second order system state 2x2 (Mass-Spring-Damper) and input matrices

#Mass

m=1

#External force u=d/m

d=1

#Viscosity coefficient, damping ratio zita=b/2mxWn

b=1

#Spring elongation coefficient, squared natural frequency Wn^2=k/m

k=1

#s(t) displacement , v(t) speed

#Dynamical Matrices x=[s(t), v(t)], d(x)/d(t)=v(t), y(t)=s(t)=[1 0]*s(t)

#dim(Ac)=2x2, dim(Bc)=2x1, Dim(Cc)=1x2, dim(Dc)=0

Ac = np.c_[[0, -k/m], [1, -b/m]]

Bc = np.r_[0, d/m].reshape(-1, 1)

#augment state and input matrices to add integral error state

A_aug = np.hstack((np.zeros((3,1)), np.vstack((np.r_[1, 0], Ac))))

B_aug = np.hstack(( np.vstack((0, Bc)), -np.eye(3,1)))

#construct the system LTI from augmented state matrices

aug_sys = LTISystem(A_aug, B_aug,)

6
#construct PID system by Ziegler-Nichols Method

#proportional coefficient

Kc = 1

#integral time constant tau_I

tau_I = 1

#derivative time constant tau_D

tau_D = 1

#Feedback Gain Matrix (1x3)

#K(s)=Kc*[(tau_I*s+1)/tau_I*s]*[(tau_D*s+1)/(alpha*tau_D*s+1)]

#alpha=0,05:0,2

#integral coefficient Ki=Kc/tau_I

#derivative coefficient Kd=Kc*tau_D

K = -np.r_[Kc/tau_I, Kc, Kc*tau_D].reshape((1,3))

#LTI system Gain Matrix

pid = LTISystem(K)

#construct reference (ref=1(t))

ref = SystemFromCallable(lambda *args: np.ones(1), 0, 1)

#create block diagram

BD = BlockDiagram(aug_sys, pid, ref)

BD.connect(aug_sys, pid)

# PID requires feedback

BD.connect(pid, aug_sys, inputs=[0])

# PID output to system control input

BD.connect(ref, aug_sys, inputs=[1])

# reference output to system command input 20 seconds

res = BD.simulate(20)

#simulate

7
#plot

plt.figure()

plt.plot(res.t, res.y[:, 0], label=r'$\int x(t)$')

plt.plot(res.t, res.y[:, 1], label='$y(t)=x(t)=s(t)$')

plt.plot(res.t, res.y[:, 2], label=r'$\dot{x(t)}=v(t)$')

plt.plot(res.t, res.y[:, 3], label='$u(t)=Kp(t)+Ki(t)+Kd(t)$')

plt.plot(res.t, res.y[:, 4], label='ref=1*t')

plt.xlabel('seconds')

plt.ylabel('Closed loop outputs')

#Plot Grid

plt.grid(True, 'both', 'both')

plt.legend()

plt.show()

La risposta dinamica a ciclo chiuso è stata tracciata con matplotlib.pyplot , presente nei pacchetti
installati nell’interprete Python e necessario in SimuPy per tracciare i grafici. In legenda c’è la
descrizione dei segnali, in particolare vengono tracciati i tre segnali intermedi uscenti dal blocco di
controllo PID, il segnale u(t) a ciclo chiuso, gli stati x(t) e l’uscita y(t) controllata rispetto ad un
riferimento ref di segnale costante unitario o gradino unitario. Il segnale costante in ingresso potrebbe
essere un segnale in corrente continua o una tensione di ingresso constante.

Figura 3-Evoluzione dinamica a Ciclo chiuso PID