Outils logiciels de simulation
Exercices corrigés

m = 1.0  # kg
k = 4.0  # N/m
c = 0.2  # N.s/m
F0 = 0.0 # Force extérieure nulle

\(\dot{x} = v\)

\(\dot{v} = \frac{1}{m}(-cv - kx + F(t))\)

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

def system(y, t, m, c, k):
    x, v = y
    dydt = [v, (-c*v - k*x)/m]
    return dydt

# Conditions initiales
y0 = [0.1, 0.0]  # x=0.1m, v=0 m/s

# Temps de simulation
t = np.linspace(0, 10, 1000)

# Résolution
solution = odeint(system, y0, t, args=(m, c, k))

# Extraction des résultats
x = solution[:, 0]
v = solution[:, 1]

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(t, x)
plt.title('Position en fonction du temps')
plt.xlabel('Temps (s)')
plt.ylabel('Position (m)')

plt.subplot(1, 2, 2)
plt.plot(x, v)
plt.title('Portrait de phase')
plt.xlabel('Position (m)')
plt.ylabel('Vitesse (m/s)')

plt.tight_layout()
plt.show()

\(\frac{du_C}{dt} = \frac{1}{\tau}(E - u_C)\) avec \(\tau = RC\)

• Créer un nouveau modèle dans Simulink

• Ajouter un intégrateur pour représenter \(u_C\)

• Ajouter des gains, des sommes et des constantes

• Connecter les blocs selon l'équation différentielle

R = 1000; % Ohms
C = 1e-6; % Farads
tau = R*C; % Constante de temps = 0.001s
E = 5; % Tension d'alimentation

Résultat théorique : \(u_C(t) = E(1-e^{-t/\tau})\)

La simulation montre une charge exponentielle du condensateur avec une constante de temps \(\tau = 1\) ms

On compare la solution analytique avec la simulation numérique

Écart maximal : < 0.1%

\(\frac{dT}{dt} = -h(T - T_{amb})\) avec \(h\) coefficient de transfert thermique

• Ouvrir Xcos (interface graphique de Scilab)

• Placer un intégrateur pour représenter la température T

• Ajouter des opérations arithmétiques pour implémenter l'équation

• Connecter les blocs pour former le système

// Paramètres
T_init = 80; // °C
T_amb = 20;  // °C
h = 0.1;     // Coefficient de transfert

// Équation
s = -h*(T - T_amb);

Solution : \(T(t) = T_{amb} + (T_{init} - T_{amb})e^{-ht}\)

La température diminue exponentiellement vers la température ambiante

• Temps de réponse à 63% : \(\tau = 1/h = 10\) s

• Temps de stabilisation : ~5\(\tau\) = 50 s

Soit un système avec entrée force \(F(t)\) et sortie position \(x(t)\)

Équation : \(m\ddot{x} + b\dot{x} + kx = F(t)\)

• Bloc "Step" pour l'entrée \(F(t)\)

• Bloc "Sum" pour combiner les termes

• Blocs "Gain" pour les coefficients \(1/m\), \(b\), \(k\)

• Blocs "Integrator" pour \(\dot{x}\) et \(x\)

% Paramètres du système
m = 2;  % kg
b = 0.5; % N.s/m
k = 10; % N/m

% Ces valeurs sont entrées dans les blocs Gain

• Configurer le solveur (ode45 par défaut)

• Définir la durée de simulation (par exemple 10s)

• Lancer la simulation

• Sortie : réponse temporelle du système

• Observation de l'amortissement et de la fréquence naturelle

• Comparaison avec la solution analytique

• 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
import numpy as np
import matplotlib.pyplot as plt

# 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))

# Tracé
plt.figure(figsize=(10, 6))
plt.plot(t, y)
plt.title('Réponse indicielle du système asservi')
plt.xlabel('Temps (s)')
plt.ylabel('Sortie')
plt.grid(True)
plt.show()

# Diagramme de Bode
ctrl.bode_plot(sys_closed)
plt.show()

# 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")