12. Traitement d'un signal. Étude spectrale.

PPT

Traitement signal etude spectrale (999.44 Ko)

PDF pour la leçon

Traitement signal etude spectrale (1.77 Mo)

Remarques sur le pdf (Constance)

I.2. A partir du moment ou on introduit p, le laisser partout pour remplacer n
I.2. Phénomène de Gibbs = apparition d'une déformation du signal à proximité d'une discontinuité. C'est un effet de bord
II.1. Rajouter la définition d'un filtre sur slide
II.1. Thérorème de superposition (et pas Hn)
II.2. Module du la fonction de transfert: rajouter |H(jw)| = H(w) (plus clair je trouve)
II.2. Pareil, attention pour l'écriture de la phase à ne pas écrire qu'on fait l'argument du module
III.2. n -> m (pour modulant)

Complément pour expériences

Manip 1.3 pour récupérer fréquence diapasons :

Brancher le micro à l'oscillo et effectuer la FFT d'un diaposon.

Faire sonner les deux diapasons et placer le micro de sorte à récupérer les 2 signaux et effectuer la FFT. On doit voir 2 pics de fréquences liés aux fréquences des deux diapasons. (essayer de prendre des diapasons avec fréquences bien différentes, plus pratique pour la suite)

Manip 2.2 pour filtre passe bas :

Réaliser un circuit RC et relever la tension d'entrée et celle aux bornes du condensateur. Faire varier la fréquence avec le GBF pour tracer le diagramme de bode expérimental du gain. Pour la phase juste montrer le théorique. Tracer les asymptotes pour trouver la fréquence de coupure (intersection asymptotes) et comparer à celle théorique.

Si on a le temps, brancher le micro à la place du GBF sur le filtre et faire résonner les diapasons. Choisir les paramètre R C de sorte à ce que la fréquence de coupure soit entre les deux fréquences des diapasons. Observer à l'oscillo en temporel l'amplitude du signal du micro et celle du signal filtré (aux bornes de C). Pour le diapason avec la fréquence la plus basse l'amplitude n'est pas atténué, le signal ,n'est pas filtré. Pour l'autre diapason, l'amplitude est atténué car on filtre, mais elle n'est pas nulle, car on a un passe bas d'ordre 1 donc avec un pente de -20\dec, ce qui n'est pas assez sélectif pour filtrer totalement ce signal => filtre + sélectif avec par exemple les filtres d'ordre 2

BIBLIO

Lp traitement dun signal etude spectrale (6.75 Mo)

Lp23 traitement d un signal etude spectrale (119.08 Ko)

Lp12 cr (650.75 Ko)

CODE

In [1]:

# Importation des modules
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy.optimize import curve_fit,leastsq
import numpy.random as npr

In [2]:

# Definition de la fonction affine
def f_aff(x, a, b):
    return a*np.log10(x)+b

# Montecarlo
def montecarlo(X, Y, uX, uY, N_mc=100, color='r', mini=None, maxi=None):
    
    sigma_X = uX*np.ones(X.size)
    sigma_Y = uY*np.ones(Y.size)

    param = np.zeros((2,N_mc))
    for i in range(N_mc):
        x_mc = npr.normal(loc=X, scale=sigma_X)
        y_mc = npr.normal(loc=Y, scale=sigma_Y)
        pop, pcov = curve_fit(f_aff, x_mc, y_mc)
        param[0,i] = pop[0]
        param[1,i] = pop[1]
        
    mini = mini if mini else X.min()
    maxi = maxi if maxi else X.max()
    x_th = np.linspace(mini, maxi, 4)
    y_th = f_aff(x_th, *pop)
    for i in range(N_mc):
        y_th = f_aff(x_th, *param[:,i])
        #plt.plot(x_th, y_th, color, alpha=0.05)
    plt.errorbar(X, Y, xerr=uX, yerr=uY, fmt='+', capsize=2, color=color)
    # plt.show()
    
    a_moy = np.mean(param[0,:])
    b_moy = np.mean(param[1,:])
    x = np.linspace(list(X)[0],list(X)[len(X)-1],100)
#    plt.plot(x,f_aff(x,a_moy,b_moy),'b--')

#    a_moy = np.mean(param[0,:])
#    print("La pente moyenne sur les ", N_mc, "mesures est de :", np.round(a_moy,4))
    a_sig = np.std(param[0,:]) #ecart type
#    print("L'écart type entre les pentes des", N_mc, "mesures est de :", np.round(a_sig,4))
#    print("Le résultat est donc de :", f"a = {a_moy:.3f} +/- {a_sig:.3f}")
#    print("Cela correspond à une erreur de:", f"a_rel = {a_sig/a_moy*100:.0f} %")
    return (a_moy, a_sig, b_moy)

Diagrammes de Bode d'un filtre passe-bas d'ordre 1¶

In [3]:

R = 20*1e3
C = 10*1e-9
w0 = 1/(R*C)

df = pd.DataFrame({'f [Hz]' : [0,0,0], 
                   'ue [V]' : [0,0,0],
                   'us [V]' : [0,0,0],
                   'phi_T [micros]' : [0,0,0]},
                  index = [1,2,3],
                  columns = ['f [Hz]','ue [V]','us [V]','phi_T [micros]'])

df['T [s]'] = [1/df['f [Hz]'][i] for i in df.index]
df['phi_expe [rad]'] = [-df['phi_T [micros]'][i]*1e-6*2*np.pi/df['T [s]'][i] for i in df.index]
df['phi [rad]'] = [-np.arctan(2*np.pi*df['f [Hz]'][i]/w0) for i in df.index]
df['phi [deg]'] = [df['phi [rad]'][i] * 180 / np.pi for i in df.index]
df['G [dB]'] = [20*np.log10(df['us [V]'][i]/df['ue [V]'][i]) for i in df.index]
#print(df)

In [4]:

plt.subplot(3,1,1)
plt.plot(df['f [Hz]'],df['G [dB]'],'+')
plt.xscale('log')
plt.xlabel('Fréquence [Hz]')
plt.ylabel('Gain [dB]')
#plt.subplot(3,1,2)
#plt.plot(df['f [Hz]'],df['phi_expe [rad]'],'+')
#plt.xscale('log')
#plt.xlabel('Fréquence [Hz]')
#plt.ylabel('Phase [rad]')
plt.subplot(3,1,3)
plt.plot(df['f [Hz]'],df['phi [deg]'],'+')
plt.xscale('log')
plt.xlabel('Fréquence [Hz]')
plt.ylabel('Phase [°]')
plt.show()

In [5]:

uf = 1
uG = 1

f1 = df['f [Hz]'][:5]
G1 = df['G [dB]'][:5]

f2 = df['f [Hz]'][20:]
G2 = df['G [dB]'][20:]

plt.plot(df['f [Hz]'],df['G [dB]'],'+')
plt.xscale('log')
plt.xlabel('Fréquence [Hz]')
plt.ylabel('Gain [dB]')

a_moy1, a_sig1, b_moy1 = montecarlo(f1, G1, uf , uG, color='blue', mini=f1.min(), maxi=f1.max())
a_moy2, a_sig2, b_moy2 = montecarlo(f2, G2, uf , uG, color='blue', mini=f2.min(), maxi=f2.max())

x1 = np.linspace(20,1000,10000)
plt.plot(x1,f_aff(x1,a_moy1,b_moy1),'r--')
x2 = np.linspace(500,50000,10000)
plt.plot(x2,f_aff(x2,a_moy2,b_moy2),'r--')
plt.axvline(w0/(2*np.pi), color="grey")

Out[5]:

<matplotlib.lines.Line2D at 0x28480189b50>

In [104]:

import numpy as np
import numpy.random as npr
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

In [105]:

w = 2 * np.pi * 1  # pulsation d'une fréquence de 1 Hz
t = np.linspace(-np.pi / 2, np.pi / 2, 1000)
A = 1  # amplitude

plt.figure()
for nmax in np.array([1, 5, 13]):
    s = 0
    for n in range(1, nmax + 1, 2):
        # print('n =', n)
        sn = (4 * 0.5) / (n * np.pi) * np.sin(n * w * t)
        s = s + sn

    plt.grid()
    plt.plot(t, s, label='n='+str(nmax))
plt.xticks([-np.pi / 2, 0, np.pi / 2], [r'$\frac{-\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$'])
plt.xlabel('t')
plt.ylabel('amplitude')
plt.title('Amplitude en fonction du temps pour différentes valeurs de n')
plt.legend()
plt.show()

In [103]:

plt.figure()
nmax = 111
s = 0
for n in range(1, nmax + 1, 2):
    # print('n =', n)
    sn = (4 * 0.5) / (n * np.pi) * np.sin(n * w * t)
    s = s + sn

plt.grid()
plt.plot(t, s, label='n='+str(nmax))
plt.xticks([-np.pi / 2, 0, np.pi / 2], [r'$\frac{-\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$'])
plt.xlabel('t')
plt.ylabel('amplitude')
plt.title('Amplitude en fonction du temps pour différentes valeurs de n')
plt.legend()
plt.show()

Date de dernière mise à jour : 12/06/2024