Application pédagogique : Utilisation d'une simulation interactive pour comprendre le comportement d'un pendule simple et les concepts liés aux oscillations.
- Identifier les paramètres influents (longueur, masse, gravité)
- Implémenter l'équation du mouvement
- Créer une interface interactive
- Permettre la modification des paramètres en temps réel
- Visualiser les résultats graphiquement
\(\frac{d^2\theta}{dt^2} + \frac{g}{l}\sin(\theta) = 0\)
Pour de petites oscillations : \(\frac{d^2\theta}{dt^2} + \frac{g}{l}\theta = 0\)
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
def pendulum_model(state, t, g, l):
theta, omega = state
dtheta_dt = omega
domega_dt = -(g/l) * np.sin(theta)
return [dtheta_dt, domega_dt]
# Paramètres
g = 9.81 # m/s²
l = 1.0 # m
theta0 = np.pi/4 # rad
omega0 = 0.0 # rad/s
state0 = [theta0, omega0]
t = np.linspace(0, 10, 1000)# Résolution
solution = odeint(pendulum_model, state0, t, args=(g, l))
theta = solution[:, 0]
# Affichage
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(t, theta)
plt.title('Angle en fonction du temps')
plt.xlabel('Temps (s)')
plt.ylabel('Angle (rad)')
plt.subplot(1, 2, 2)
plt.plot(theta, solution[:, 1])
plt.title('Portrait de phase')
plt.xlabel('Angle (rad)')
plt.ylabel('Vitesse angulaire (rad/s)')
plt.tight_layout()
plt.show()• Exploration de l'effet de la longueur sur la période
• Influence de l'amplitude initiale
• Transition entre petits et grands angles
• Visualisation immédiate des effets des paramètres
• Possibilité de tests multiples sans contraintes physiques
• Compréhension intuitive des concepts d'oscillation
La simulation du pendule simple permet une exploration interactive des paramètres physiques et une meilleure compréhension des concepts d'oscillation, d'amortissement et de période.
• Équation du pendule : \(\ddot{\theta} + \frac{g}{l}\sin(\theta) = 0\)
• Période : \(T = 2\pi\sqrt{\frac{l}{g}}\) (petites oscillations)
• Portraits de phase : Visualisation de l'espace des états
Système masse-ressort-amortisseur : Modèle fondamental en mécanique permettant d'étudier les vibrations et l'amortissement.
\(m\ddot{x} + c\dot{x} + kx = F(t)\)
Où \(m\) est la masse, \(c\) le coefficient d'amortissement, \(k\) la raideur
m = 1.0 # kg
k = 4.0 # N/m
c = 0.5 # N.s/m
F0 = 0.0 # N (force extérieure nulle)Pulsation propre : \(\omega_0 = \sqrt{\frac{k}{m}} = \sqrt{\frac{4.0}{1.0}} = 2.0\) rad/s
Amortissement réduit : \(\delta = \frac{c}{2\sqrt{mk}} = \frac{0.5}{2\sqrt{1.0 \times 4.0}} = 0.125\)
def mass_spring_damper_system(state, t, m, c, k):
x, v = state
dxdt = v
dvdt = (F0 - c*v - k*x) / m
return [dxdt, dvdt]
# Conditions initiales
x0 = 0.1 # m
v0 = 0.0 # m/s
state0 = [x0, v0]
# Résolution
solution = odeint(mass_spring_damper_system, state0, t, args=(m, c, k))
x = solution[:, 0]
v = solution[:, 1]import matplotlib.widgets as widgets
fig, ax = plt.subplots(figsize=(10, 6))
plt.subplots_adjust(bottom=0.25)
# Graphique initial
line, = ax.plot(t[:500], x[:500])
ax.set_xlim(0, 5)
ax.set_ylim(-0.2, 0.2)
ax.set_xlabel('Temps (s)')
ax.set_ylabel('Position (m)')
ax.set_title('Position du système en fonction du temps')
# Sliders pour contrôle interactif
ax_m = plt.axes([0.2, 0.1, 0.5, 0.03])
slider_m = widgets.Slider(ax_m, 'Masse (kg)', 0.1, 5.0, valinit=m)
ax_k = plt.axes([0.2, 0.05, 0.5, 0.03])
slider_k = widgets.Slider(ax_k, 'Raideur (N/m)', 1.0, 20.0, valinit=k)
def update(val):
# Recalculer la simulation avec nouveaux paramètres
pass # Implémentation simplifiée
slider_m.on_changed(update)
slider_k.on_changed(update)La simulation du système masse-ressort-amortisseur permet d'explorer l'effet des paramètres sur le comportement vibratoire, favorisant une compréhension intuitive des concepts d'amortissement et de fréquence naturelle.
• Équation du mouvement : \(m\ddot{x} + c\dot{x} + kx = F(t)\)
• Amortissement réduit : \(\delta = \frac{c}{2\sqrt{mk}}\)
• Comportement : Sous-amorti, critique, sur-amorti
Circuit RC : Circuit composé d'une résistance R et d'un condensateur C, utilisé pour étudier les phénomènes de charge/décharge.
\(\tau\frac{du_C}{dt} + u_C = E\) où \(\tau = RC\) est la constante de temps
Charge : \(u_C(t) = E(1 - e^{-t/\tau})\)
Décharge : \(u_C(t) = E e^{-t/\tau}\)
R = 1000 # Ohms
C = 1e-6 # Farads
tau = R*C # Constante de temps = 0.001s
E = 5.0 # Voltst = np.linspace(0, 0.005, 1000) # 5ms
u_charge = E * (1 - np.exp(-t/tau))
plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.plot(t, u_charge)
plt.title('Charge du condensateur')
plt.xlabel('Temps (s)')
plt.ylabel('Tension (V)')
plt.grid(True)
plt.subplot(1, 3, 2)
i_charge = (E/R) * np.exp(-t/tau)
plt.plot(t, i_charge)
plt.title('Courant de charge')
plt.xlabel('Temps (s)')
plt.ylabel('Courant (A)')
plt.grid(True)
plt.subplot(1, 3, 3)
plt.plot(u_charge, i_charge)
plt.title('Trajectoire dans le plan (u,i)')
plt.xlabel('Tension (V)')
plt.ylabel('Courant (A)')
plt.grid(True)
plt.tight_layout()
plt.show()• Visualisation de la constante de temps \(\tau\)
• Compréhension de l'évolution exponentielle
• Relation entre tension et courant
• Effet des paramètres R et C
La simulation du circuit RC permet de visualiser les phénomènes de charge/décharge exponentielle, renforçant la compréhension des concepts de constante de temps et de comportement transitoire.
• Constante de temps : \(\tau = RC\)
• Charge : \(u_C(t) = E(1-e^{-t/\tau})\)
• Décharge : \(u_C(t) = E e^{-t/\tau}\)
Système thermique : Modèle de transfert de chaleur permettant d'étudier les phénomènes de conduction, convection et rayonnement.
\(\frac{dT}{dt} = -h(T - T_{\text{amb}})\)
Où \(h\) est le coefficient de transfert thermique
\(T(t) = T_{\text{amb}} + (T_0 - T_{\text{amb}})e^{-ht}\)
T_init = 80.0 # °C
T_amb = 20.0 # °C
h = 0.05 # s^-1 (coefficient de transfert)t = np.linspace(0, 100, 1000) # 100s
T = T_amb + (T_init - T_amb) * np.exp(-h*t)
plt.figure(figsize=(10, 6))
plt.plot(t, T, linewidth=2)
plt.title('Refroidissement thermique')
plt.xlabel('Temps (s)')
plt.ylabel('Température (°C)')
plt.grid(True, alpha=0.3)
# Ajouter des lignes de repère
tau = 1/h # Constante de temps
plt.axvline(x=tau, color='red', linestyle='--', alpha=0.7, label=f'τ = {tau:.1f}s')
plt.axhline(y=T_amb + 0.37*(T_init-T_amb), color='orange', linestyle='--', alpha=0.7, label='37% de ΔT')
plt.legend()
plt.show()• Compréhension de la loi de refroidissement
• Visualisation de la constante de temps
• Effet des propriétés thermiques
• Analogie avec d'autres systèmes exponentiels
La simulation du système thermique illustre la loi de Newton du refroidissement et permet de comprendre l'effet des propriétés thermiques sur le comportement transitoire.
• Loi de Newton : \(\frac{dT}{dt} = -h(T - T_{\text{amb}})\)
• Solution : \(T(t) = T_{\text{amb}} + (T_0 - T_{\text{amb}})e^{-ht}\)
• Constante de temps : \(\tau = 1/h\)
Système asservi : Système avec une boucle de retour pour contrôler la sortie en fonction d'une consigne, utilisé pour étudier la commande automatique.
• Consigne : \(r(t)\)
• Correcteur : \(C(s)\)
• Processus : \(G(s)\)
• Retour unitaire
\(G(s) = \frac{K}{s(s+a)}\) avec \(K=2\), \(a=1\)
Correcteur PI : \(C(s) = K_p + \frac{K_i}{s}\) avec \(K_p=1\), \(K_i=0.5\)
import control as ctrl
# Définition des fonctions de transfert
num_G = [2]
den_G = [1, 1, 0]
G = ctrl.TransferFunction(num_G, den_G)
num_C = [1, 0.5]
den_C = [1, 0]
C = ctrl.TransferFunction(num_C, den_C)
# Système en boucle fermée
sys_closed = ctrl.feedback(C*G, 1)
# Réponse indicielle
t, y = ctrl.step_response(sys_closed, T=np.linspace(0, 10, 1000))
plt.figure(figsize=(10, 6))
plt.plot(t, y, linewidth=2, label='Sortie')
plt.axhline(y=1, color='red', linestyle='--', alpha=0.7, label='Consigne')
plt.title('Réponse indicielle du système asservi')
plt.xlabel('Temps (s)')
plt.ylabel('Sortie')
plt.grid(True, alpha=0.3)
plt.legend()
plt.show()# Analyse fréquentielle
mag, phase, omega = ctrl.bode_plot(sys_closed)
# Marges de stabilité
gm, pm, wg, wp = ctrl.margin(C*G)
print(f"Marge de gain: {gm:.2f} dB")
print(f"Marge de phase: {pm:.2f} deg")
print(f"Pulsation de gain: {wg:.2f} rad/s")
print(f"Pulsation de phase: {wp:.2f} rad/s")• Compréhension des concepts de commande
• Analyse des performances temporelles
• Étude de la stabilité
• Influence des paramètres de réglage
La simulation du système asservi permet d'étudier les concepts de commande automatique, de comprendre les performances temporelles et fréquentielles, et d'analyser la stabilité.
• Asservissement : Boucle de retour pour contrôler la sortie
• Fonction de transfert : Représentation en domaine de Laplace
• Stabilité : Marges de gain et de phase
- Modélisation : Abstraction du système réel en modèle mathématique
- Simulation : Implémentation du modèle dans un environnement informatique
- Visualisation : Représentation graphique des résultats
- Exploration : Variation des paramètres pour observer les effets
- Validation : Comparaison avec des données expérimentales
- Conclusion : Synthèse des observations pour renforcer les concepts
- La simulation est un outil d'apprentissage, pas une fin en soi
- Les modèles doivent rester simples pour favoriser la compréhension
- L'interaction avec le modèle renforce l'apprentissage
- La visualisation aide à développer l'intuition physique
- La validation est essentielle pour établir la crédibilité du modèle
- Simulation de systèmes mécaniques : Oscillateurs, structures, machines
- Simulation de systèmes électriques : Circuits, alimentations, commandes
- Simulation de systèmes thermiques : Transferts de chaleur, échangeurs
- Simulation de systèmes hydrauliques : Circuits fluidiques, pompes
- Simulation de systèmes de commande : Asservissements, régulations
- Les applications pédagogiques permettent de concrétiser les concepts abstraits
- La simulation offre une sécurité pour l'expérimentation
- L'interaction avec les modèles favorise l'apprentissage actif
- La visualisation aide à comprendre les comportements dynamiques
- La validation renforce la crédibilité des modèles