Modellazione di un sistema lineare con Python

Question

Mi piacerebbe simulare/modellare un sistema lineare, lineare, tempo-invariante (in particolare un'approssimazione PLL bloccata) con python.

Ogni sottoblocco all'interno del modello ha una funzione di trasferimento nota che viene fornita in termini di frequenza complessa H(s) = K/(s * tau + 1). Usando il modello, vorrei vedere come la risposta del sistema e la risposta al rumore sono influenzate dal cambiamento dei parametri (ad esempio il guadagno VCO). Ciò implicherebbe l'uso di diagrammi di Bode e di grafici di locus di radici.

Quali moduli Python dovrei cercare per portare a termine il lavoro?

Answer 1

So che questo è un po 'vecchio, ma una ricerca mi ha portato a questa domanda. Ho messo questo insieme quando non sono riuscito a trovare un buon modulo per questo. Non è molto, ma è un buon inizio se qualcun altro si trova qui.

import matplotlib.pylab as plt 
import numpy as np 
import scipy.signal 

def bode(G,f=np.arange(.01,100,.01)): 
    plt.figure() 
    jw = 2*np.pi*f*1j 
    y = np.polyval(G.num, jw)/np.polyval(G.den, jw) 
    mag = 20.0*np.log10(abs(y)) 
    phase = np.arctan2(y.imag, y.real)*180.0/np.pi % 360 

    plt.subplot(211) 
    #plt.semilogx(jw.imag, mag) 
    plt.semilogx(f,mag) 
    plt.grid() 
    plt.gca().xaxis.grid(True, which='minor') 

    plt.ylabel(r'Magnitude (db)') 

    plt.subplot(212) 
    #plt.semilogx(jw.imag, phase) 
    plt.semilogx(f,phase) 
    plt.grid() 
    plt.gca().xaxis.grid(True, which='minor') 
    plt.ylabel(r'Phase (deg)') 
    plt.yticks(np.arange(0, phase.min()-30, -30)) 

    return mag, phase 

f=scipy.signal.lti([1],[1,1]) 
bode(f) 

Edit: sono tornato qui perché qualcuno upvoted questa risposta, si dovrebbe provare Control Systems Library. Hanno implementato la maggior parte degli strumenti del sistema di controllo Matlab con sintassi e tutto il resto.

Answer 2

scipy e numpy moduli sono adatti per la vostra applicazione.

Answer 3

Come ha detto @Matt, so che questo è vecchio. Ma questo è emerso come il mio primo hit di Google, quindi volevo modificarlo.

È possibile utilizzare scipy.signal.lti per modellare sistemi lineari, tempo invarianti. Questo ti dà lti.bode.

Per una risposta all'impulso sotto forma di H (s) = (As^2 + Bs + C)/(Ds^2 + Es + F), immettere h = scipy.signal.lti([A,B,C],[D,E,F]). Per ottenere la trama del bode, dovresti fare plot(*h.bode()[:2]).

Answer 4

Secondo http://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.bode.html è ora possibile utilizzare questo:

from scipy import signal 
import matplotlib.pyplot as plt 

s1 = signal.lti([1], [1, 1]) 
w, mag, phase = signal.bode(s1) 

plt.figure() 
plt.semilogx(w, mag) # bode magnitude plot 
plt.figure() 
plt.semilogx(w, phase) # bode phase plot 
plt.show() 

Answer 5

ho avuto diagrammi di Bode lavorare in questo modo, utilizzando python-controllo.

from matplotlib.pyplot import * # Grab MATLAB plotting functions 
from control.matlab import * # MATLAB-like functions 


# Transfer functions for dynamics 
G_modele = tf([1], [13500, 345, 1]); 

# Use state space versions 
G_modele = tf2ss(G_modele); 

figure(1); 
bode(G_modele, dB=1); 
show(); 

Il codice è stata scattata principalmente da questo esempio che è molto ampia

http://www.cds.caltech.edu/~murray/wiki/index.php/Python-control/Example:_Vertical_takeoff_and_landing_aircraft