25. Oscillateurs ; portraits de phase et non-linéarités.

PPT

Oscillatuers portrait phase non linearite (291.68 Ko)

PDF pour la leçon

Oscillateur portrait phase (2.26 Mo)

Commentaires PDF

III. 2. Dans le calcul en régime linéaire: R₁i' + R₂i = 0 (R₁ et R₂ inversées)
III. 2. Dans le calcul en régime saturé: Remplacer R₁ par R₂ dans les expressions de U_AM
III. 2. Equation différentielle en régime saturé (5): ..... = +-V_sat (et pas ..... = 0) et R = R₂

Compléments pour expériences

Pendule de Borda : voir dans fruchard

Vérifier formule de Borda en mesurant la demi période et donc période du pendule avec une fourche optique et arduino (même code que chute grille) pour différents angles
si le temps et phyphox, vérifier perte de l'isochronisme et l'apparition d'harmoniques

BIBLIO

Lp oscillateurs portraits de phase et non linearites (3.11 Mo) : bien pour pratie sur oscillateur à résistance négative

Lp49 oscillateurs portraits de phase et non lin arit s (921.57 Ko)

Lp49 oscillateurs portraits de phase et non linearites (4.48 Mo)

07440719 osc (807 Ko) : plus de détails sur oscillateurs auto-entretenus et résistance négative

08040903 (114.76 Ko) : plus de détails sur les différents portraits de phase avec images

CODE

In [2]:

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

#%matplotlib qt

Limite des petits angles¶

In [25]:

x = np.linspace(0,np.pi/2,100)
plt.plot(x,np.sin(x),label=r'$sin(\theta)$')
plt.plot(x,x,label=r'$\theta$')
plt.plot(x,x-x**3/6,label=r'$\theta-\theta^3/6$')
plt.xlabel('Angle [deg]')
plt.xticks([0, np.pi/4, np.pi/2], [r'0', r'45', r'90'])
plt.legend()
plt.show()

In [27]:

x = np.linspace(0,np.pi/2,100)
plt.plot(x,np.cos(x),label=r'$cos(\theta)$')
plt.plot(x,1-x**2/2,label=r'$1-\theta^2/2$')
plt.plot(x,1-x**2/2+x**4/24,label=r'$1-\theta^2/2+\theta^4/24$')
plt.xlabel('Angle [deg]')
plt.xticks([0, np.pi/4, np.pi/2], [r'0', r'45', r'90'])
plt.legend()
plt.show()

In [3]:

x = np.linspace(0,np.pi/2,100)
plt.plot(x,np.sin(x),label='sin(x)')
plt.plot(x,x,label='x')
plt.plot(x,x-x**3/6,label='x-x**3/6')
plt.xlabel('Angle [rad]')
plt.legend()
plt.show()

In [4]:

def conv_rad_deg(a):
    return a*180/np.pi

In [5]:

round(conv_rad_deg(0.5))

Out[5]:

In [6]:

x = np.linspace(0,np.pi/2,100)
plt.plot(x,np.cos(x),label='cos(x)')
plt.plot(x,1-x**2/2,label='1-x²/2')
plt.plot(x,1-x**2/2+x**4/24,label='1-x²/2+x**4/24')
plt.xlabel('Angle [rad]')
plt.legend()
plt.show()

Pendule de Borda¶

Mise en avant du non-isochronisme¶

In [7]:

T_nonlin = np.array([])*1e-6
n = np.linspace(0,len(T_nonlin)-1,len(T_nonlin))

print(n)

popc, pcov = curve_fit(affine, n[:5], T_nonlin[:5])

a,b = popc

plt.plot(T_nonlin,'x') # Permet de montrer la baisse de la période avec le temps dû aux frottements
plt.plot(n, a*n + b)
plt.xlabel("Numéro d'interruption")
plt.ylabel("Temps d'interruption (en s)")

Out[7]:

Text(0, 0.5, "Temps d'interruption (en s)")

In [8]:

def affine(x,a,b):
    return a*x + b

theta = np.array([])*(np.pi/180) #angle initial avant de lacher pendule
utheta = 1*(np.pi/180)
theta2 = theta**2

T10 = np.array([])*1e-6 # numéro d interruption (données d'arduino) pour cet angle
T20 = np.array([])*1e-6
T30 = np.array([])*1e-6
T40 = np.array([])*1e-6
T50 = np.array([])*1e-6
T60 = np.array([])*1e-6
T70 = np.array([])*1e-6



T10 = T10[:3]
T20 = T20[:3]
T30 = T30[:3]
T40 = T40[:3]
T50 = T50[:3]
T60 = T60[:3]
T70 = T70[:3]


T = np.zeros(len(theta))

n = np.linspace(0,len(T10) - 1,len(T10))

T_list = [T10, T20, T30, T40, T50, T60, T70]


for i in range(len(theta)):
    popc, pcov = curve_fit(affine,n,T_list[i])
    T[i] = popc[0]*2

def func(x,a,b,c):
    return a*(1 + b*x + c*x**2)

popc,pcov = curve_fit(func, theta2, T, p0=[0.3, 6.25e-2, 3.6e-3])

a,b,c = popc
ub = np.sqrt(pcov[1,1])
uc = np.sqrt(pcov[2,2])

plt.plot(theta2, T, 'x', label='data')
plt.plot(theta2, func(theta2, *popc), label='fit')
plt.xlabel('theta')
plt.ylabel('Période T')
plt.legend()
plt.show()

print("La valeur théorique de b est 6.25e-2")
print("La valeur expérimentale de b est (", np.round(b*1e2,1), '+-', np.round(ub*1e2,1), ') e-2')
print("La valeur théorique de c est 3.6e-3")
print("La valeur expérimentale de c est (", np.round(c*1e3,1), '+-', np.round(uc*1e3,1), ') e-3')

La valeur théorique de b est 6.25e-2
La valeur expérimentale de b est ( 5.4 +- 0.5 ) e-2
La valeur théorique de c est 3.6e-3
La valeur expérimentale de c est ( 2.7 +- 3.3 ) e-3

Enrichissement spectral¶

In [63]:

data = pd.read_csv('data.csv', delimiter = ',', decimal='.')

t = data['Time (s)'].values
vwz = data['Gyroscope z (rad/s)'].values # Données du gyroscope, vitesse angulaire en z

t_fft_r = t[1000:6000]
vwz_fft_r = vwz[1000:6000]

t_fft_g = t[15000:20000]
vwz_fft_g = vwz[15000:20000]

t_fft_k = t[55000:60000]
vwz_fft_k = vwz[55000:60000]

plt.subplot(2,1,1)
plt.plot(t,vwz)
plt.plot(t_fft_r, vwz_fft_r, 'r-')
plt.plot(t_fft_g, vwz_fft_g, 'g-')
plt.plot(t_fft_k, vwz_fft_k, 'k-')
plt.title("Evolution des oscillations au cours du temps (theta = 90°)")
plt.xlabel('Temps (en s)')
plt.ylabel('Vitesse angulaire (en rad/s)')

# Number of sample points
N = len(t_fft_r)
# sample spacing
T = t[1] - t[0]
yf_r = sp.fft.fft(vwz_fft_r)
yf_g = sp.fft.fft(vwz_fft_g)
yf_k = sp.fft.fft(vwz_fft_k)
xf = sp.fft.fftfreq(N, T)[:N//2]

plt.subplot(2,1,2)
plt.plot(xf, 2.0/N * np.abs(yf_r[0:N//2]), 'r')
plt.plot(xf, 2.0/N * np.abs(yf_g[0:N//2]), 'g')
plt.plot(xf, 2.0/N * np.abs(yf_k[0:N//2]), 'k')
plt.xlim(0,3)
plt.xlabel('Fréquence (en Hz)')
plt.ylabel('Amplitude')

Out[63]:

Text(0, 0.5, 'Amplitude')

In [ ]:

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