MODULE MII1

Developpement Informatique

Programmation C++, Python et MATLAB pour l'electronique et l'informatique industrielle

📚 1ere et 2eme Annee BTS ⏱️ 1ere: 52h | 2eme: 52h 🎯 Informatique Industrielle
01

Introduction au Langage C++

1.1 Presentation du C++

Le C++ est un langage de programmation compile, polyvalent et performant. Cree par Bjarne Stroustrup en 1983, il etend le langage C avec la programmation orientee objet. Il est largement utilise dans les systemes embarques et l'industrie electronique.

✅ Avantages

  • Performances elevees
  • Controle bas niveau
  • Programmation orientee objet
  • Large bibliotheque standard

🔧 Applications

  • Systemes embarques
  • Jeux video
  • Applications temps reel
  • Drivers et firmware

1.2 Structure d'un Programme C++

premier_programme.cpp 
// Mon premier programme C++
#include <iostream>

using namespace std;

int main() {
    // Affichage a l'ecran
    
    // Declaration de variables
    int tension = 12;        // Tension en Volts
    float courant = 0.5;     // Courant en Amperes
    double puissance;         // Puissance en Watts
    
    // Calcul de la puissance
    puissance = tension * courant;
    
    cout << "Puissance = " << puissance << " W" << endl;
    
    return 0;
}

1.3 Types de Donnees Fondamentaux

Type Taille Plage de valeurs Utilisation
char 1 octet -128 a 127 Caracteres, petits entiers
int 4 octets ±2.1 milliards Entiers standards
float 4 octets ±3.4×10³⁸ Nombres decimaux (6-7 chiffres)
double 8 octets ±1.7×10³⁰⁸ Calculs precis (15-16 chiffres)
bool 1 octet true/false Conditions logiques

1.4 Operateurs

Operateurs Arithmetiques

  • + Addition
  • - Soustraction
  • * Multiplication
  • / Division
  • % Modulo (reste)

Operateurs de Comparaison

  • == Egal a
  • != Different de
  • < Inferieur a
  • > Superieur a
  • <= >= Comparaisons

1.5 Structures Conditionnelles

Exemple : Classification d'une tension 
float tension;
cout << "Entrez la tension (V) : ";
cin >> tension;

if (tension < 0) {
    cout << "Erreur : tension negative!" << endl;
} else if (tension < 5) {
    cout << "Tres basse tension" << endl;
} else if (tension < 50) {
    cout << "Basse tension (BT)" << endl;
} else if (tension < 1000) {
    cout << "Haute tension A (HTA)" << endl;
} else {
    cout << "Haute tension B (HTB)" << endl;
}

1.6 Structures de Boucles

Boucle for - Calcul d'une table de resistances 
// Generation d'une table de resistances serie E12
double base_values[] = {1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2};

cout << "=== Serie E12 (1Ω a 10kΩ) ===" << endl;

for (int decade = 0; decade < 5; decade++) {
    double multiplier = pow(10, decade);
    
    for (int i = 0; i < 12; i++) {
        double resistance = base_values[i] * multiplier;
        cout << resistance << " Ω" << endl;
    }
}
Boucle while - Lecture d'un capteur 
int temperature;
int seuil_alarme = 80;

while (true) {
    // Simulation de lecture capteur
    temperature = lire_capteur();
    
    if (temperature >= seuil_alarme) {
        cout << "ALARME: Temperature = " << temperature << "°C" << endl;
        break;  // Sortie de boucle
    }
    
    delay(1000);  // Attente 1 seconde
}
02

Structures de Donnees en C++

2.1 Les Tableaux

Un tableau est une collection d'elements de meme type, stockes de maniere contigue en memoire. Chaque element est accessible par son indice (commencant a 0).

Tableaux - Stockage de mesures 
// Declaration et initialisation d'un tableau
float mesures[10];  // Tableau de 10 elements

// Initialisation avec des valeurs
int codes_couleurs[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
string couleurs[] = {"Noir", "Marron", "Rouge", "Orange", "Jaune",
                     "Vert", "Bleu", "Violet", "Gris", "Blanc"};

// Parcours d'un tableau
for (int i = 0; i < 10; i++) {
    cout << couleurs[i] << " = " << codes_couleurs[i] << endl;
}

// Calcul de la moyenne des mesures
float somme = 0;
for (int i = 0; i < 10; i++) {
    somme += mesures[i];
}
float moyenne = somme / 10;

2.2 Les Tableaux Multidimensionnels

Matrice - Table de verite d'une porte logique 
// Table de verite d'une porte ET (AND)
int table_ET[2][2] = {
    {0, 0},  // A=0: B=0→0, B=1→0
    {0, 1}   // A=1: B=0→0, B=1→1
};

// Affichage de la table
cout << "Table de verite AND" << endl;
cout << "A | B | S" << endl;
cout << "--------" << endl;

for (int a = 0; a < 2; a++) {
    for (int b = 0; b < 2; b++) {
        cout << a << " | " << b << " | " << table_ET[a][b] << endl;
    }
}

2.3 Les Structures (struct)

Une structure permet de regrouper des variables de types differents sous un meme nom. C'est ideal pour representer des entites complexes.

Structure - Composant electronique 
// Definition d'une structure
struct Composant {
    string reference;
    string type;
    double valeur;
    string unite;
    int quantite;
    double prix_unitaire;
};

// Utilisation de la structure
Composant resistance1;
resistance1.reference = "R001";
resistance1.type = "Resistance";
resistance1.valeur = 10000;
resistance1.unite = "Ω";
resistance1.quantite = 50;
resistance1.prix_unitaire = 0.02;

// Initialisation directe
Composant condo1 = {"C001", "Condensateur", 100e-6, "F", 20, 0.15};

// Tableau de structures
Composant inventaire[100];
inventaire[0] = resistance1;
inventaire[1] = condo1;

2.4 Les Pointeurs

Un pointeur est une variable qui contient l'adresse memoire d'une autre variable. Les pointeurs sont essentiels en C++ pour la gestion dynamique de la memoire et l'acces aux registres materiels.

Pointeurs - Concepts de base 
int tension = 12;
int* ptr_tension;      // Declaration d'un pointeur

ptr_tension = &tension;  // ptr contient l'adresse de tension

cout << "Valeur: " << tension << endl;           // 12
cout << "Adresse: " << &tension << endl;          // 0x7fff...
cout << "Pointeur: " << ptr_tension << endl;      // 0x7fff...
cout << "Dereferencement: " << *ptr_tension << endl; // 12

// Modification via pointeur
*ptr_tension = 24;
cout << "Nouvelle valeur: " << tension << endl;  // 24

// Application : acces a un registre materiel (simulation)
volatile uint32_t* GPIO_ODR = (uint32_t*)0x40020014;
*GPIO_ODR |= (1 << 5);  // Set bit 5
⚠️ Precautions avec les Pointeurs
  • Toujours initialiser un pointeur avant utilisation
  • Verifier qu'un pointeur n'est pas NULL avant dereferencement
  • Liberer la memoire allouee dynamiquement avec delete
03

Programmation Orientee Objet en C++

3.1 Concepts Fondamentaux de la POO

📦 Encapsulation

Regroupement des donnees et des methodes dans une classe, avec controle d'acces (public, private, protected).

🧬 Heritage

Creation de nouvelles classes a partir de classes existantes, reutilisant et etendant leurs fonctionnalites.

🎭 Polymorphisme

Capacite d'un objet a prendre plusieurs formes, permettant des comportements differents selon le contexte.

🔲 Abstraction

Representation simplifiee d'une entite, ne montrant que les caracteristiques essentielles.

3.2 Classes et Objets

Classe Resistance - Modelisation d'un composant 
class Resistance {
private:
    double valeur;        // Valeur en Ohms
    double tolerance;     // Tolerance en %
    double puissance_max; // Puissance maximale en Watts
    
public:
    // Constructeur
    Resistance(double val, double tol = 5.0, double pmax = 0.25) {
        valeur = val;
        tolerance = tol;
        puissance_max = pmax;
    }
    
    // Destructeur
    ~Resistance() {
        cout << "Resistance detruite" << endl;
    }
    
    // Accesseurs (getters)
    double getValeur() { return valeur; }
    double getTolerance() { return tolerance; }
    
    // Modificateurs (setters)
    void setValeur(double v) { valeur = v; }
    
    // Methodes
    double calculerCourantMax() {
        return sqrt(puissance_max / valeur);
    }
    
    double calculerTensionMax() {
        return sqrt(puissance_max * valeur);
    }
    
    void afficher() {
        cout << valeur << " Ω ± " << tolerance << "%" << endl;
    }
};

// Utilisation
int main() {
    Resistance r1(10000);           // 10kΩ, 5%, 0.25W
    Resistance r2(4700, 1.0, 0.5); // 4.7kΩ, 1%, 0.5W
    
    r1.afficher();
    cout << "Imax = " << r1.calculerCourantMax() * 1000 << " mA" << endl;
    
    return 0;
}

3.3 Heritage

Heritage - Composants electroniques 
// Classe de base
class Composant {
protected:
    string reference;
    double prix;
    
public:
    Composant(string ref, double p) : reference(ref), prix(p) {}
    
    virtual void afficher() {
        cout << "Ref: " << reference << ", Prix: " << prix << " €" << endl;
    }
    
    virtual double calculerImpedance(double freq) = 0; // Methode abstraite
};

// Classe derivee : Condensateur
class Condensateur : public Composant {
private:
    double capacite;  // en Farads
    
public:
    Condensateur(string ref, double p, double c) 
        : Composant(ref, p), capacite(c) {}
    
    void afficher() override {
        Composant::afficher();
        cout << "Capacite: " << capacite * 1e6 << " µF" << endl;
    }
    
    double calculerImpedance(double freq) override {
        return 1.0 / (2 * M_PI * freq * capacite);
    }
};

// Classe derivee : Bobine
class Bobine : public Composant {
private:
    double inductance;  // en Henrys
    
public:
    Bobine(string ref, double p, double l) 
        : Composant(ref, p), inductance(l) {}
    
    double calculerImpedance(double freq) override {
        return 2 * M_PI * freq * inductance;
    }
};
04

Introduction au Langage Python

4.1 Presentation de Python

Python est un langage de programmation interprete, de haut niveau et polyvalent. Cree par Guido van Rossum en 1991, il privilegie la lisibilite du code et la simplicite syntaxique. Python est tres utilise en electronique pour le prototypage rapide, l'analyse de donnees et l'automatisation.

✅ Avantages

  • Syntaxe claire et lisible
  • Bibliotheques scientifiques riches
  • Prototypage rapide
  • Multi-paradigme

🔧 Applications

  • Automatisation de tests
  • Analyse de donnees (numpy, pandas)
  • Interfaces instruments (PyVISA)
  • Raspberry Pi, MicroPython

4.2 Structure d'un Programme Python

premier_programme.py 
# Mon premier programme Python
# Note : l'indentation est significative en Python!

# Affichage

# Variables (typage dynamique)
tension = 12        # int
courant = 0.5       # float
nom = "Resistance"  # str
actif = True        # bool

# Calcul de la puissance
puissance = tension * courant
print(f"Puissance = {puissance} W")  # f-string (formatage)

# Saisie utilisateur
r = float(input("Entrez la resistance (Ω) : "))
i = tension / r
print(f"Courant = {i*1000:.2f} mA")  # .2f = 2 decimales

4.3 Types de Donnees Python

Type Description Exemple
int Entier (precision arbitraire) x = 42
float Nombre a virgule flottante pi = 3.14159
str Chaine de caracteres s = "Hello"
bool Booleen ok = True
list Liste modifiable [1, 2, 3]
tuple Tuple immuable (1, 2, 3)
dict Dictionnaire cle-valeur {"a": 1, "b": 2}

4.4 Structures de Controle

Conditions et boucles Python 
# Structure conditionnelle
tension = 24

if tension < 5:
    print("Tres basse tension")
elif tension < 50:
    print("Basse tension")
else:
    print("Haute tension")

# Boucle for avec range
for i in range(10):
    print(f"Mesure {i} : {i * 1.5} V")

# Boucle for sur une liste
composants = ["Resistance", "Condensateur", "Bobine"]
for comp in composants:
    print(f"- {comp}")

# Boucle while
temp = 25
while temp < 80:
    print(f"Temperature : {temp}°C")
    temp += 10
✅ L'indentation en Python

En Python, l'indentation (4 espaces par convention) definit les blocs de code. C'est une particularite importante : le code doit etre correctement indente pour fonctionner.

05

Structures de Donnees Python

5.1 Les Listes

Les listes sont des collections ordonnees et modifiables d'elements. Elles peuvent contenir des elements de types differents.

Manipulation de listes 
# Creation de listes
mesures = [1.2, 2.5, 3.1, 4.8, 5.0]
vide = []
mixte = [1, "deux", 3.0, True]

# Acces aux elements
print(mesures[0])     # Premier : 1.2
print(mesures[-1])    # Dernier : 5.0
print(mesures[1:3])   # Slice : [2.5, 3.1]

# Modification
mesures[0] = 1.5
mesures.append(6.2)      # Ajoute a la fin
mesures.insert(0, 0.5)  # Insere au debut
mesures.remove(3.1)     # Supprime une valeur

# Operations courantes
print(len(mesures))      # Longueur
print(sum(mesures))      # Somme
print(max(mesures))      # Maximum
print(min(mesures))      # Minimum

# List comprehension
carres = [x**2 for x in range(10)]
filtrees = [m for m in mesures if m > 2]

5.2 Les Dictionnaires

Les dictionnaires sont des collections de paires cle-valeur, tres utiles pour stocker des donnees structurees.

Dictionnaires - Base de composants 
# Creation d'un dictionnaire
resistance = {
    "reference": "R001",
    "valeur": 10000,
    "unite": "Ω",
    "tolerance": 5,
    "puissance": 0.25
}

# Acces et modification
print(resistance["valeur"])           # 10000
print(resistance.get("stock", 0))    # 0 (valeur par defaut)
resistance["stock"] = 50             # Ajoute une cle

# Parcours
for cle, valeur in resistance.items():
    print(f"{cle}: {valeur}")

# Base de donnees de composants
composants = {
    "R001": {"type": "resistance", "valeur": 10000},
    "C001": {"type": "condensateur", "valeur": 100e-6},
    "L001": {"type": "bobine", "valeur": 10e-3}
}

5.3 Les Tuples

Les tuples sont des sequences immuables, ideales pour stocker des donnees qui ne doivent pas changer.

Tuples - Coordonnees et constantes 
# Creation de tuples
point = (3.5, 2.1)
rgb_rouge = (255, 0, 0)

# Serie E12 (immuable)
E12 = (1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2)

# Deballage (unpacking)
x, y = point
r, g, b = rgb_rouge

# Fonction retournant plusieurs valeurs
def calculer_circuit_rc(r, c, freq):
    xc = 1 / (2 * 3.14159 * freq * c)
    z = (r**2 + xc**2)**0.5
    phi = -atan(xc / r)
    return z, phi  # Retourne un tuple

impedance, phase = calculer_circuit_rc(1000, 1e-6, 1000)
06

Fonctions et Modules Python

6.1 Definition de Fonctions

Fonctions pour l'electronique 
import math

# Fonction simple
def loi_ohm(tension, resistance):
    """Calcule le courant selon la loi d'Ohm."""
    return tension / resistance

# Fonction avec parametre par defaut
def resistance_parallele(r1, r2, r3=None):
    """Calcule la resistance equivalente en parallele."""
    if r3 is None:
        return (r1 * r2) / (r1 + r2)
    else:
        return 1 / (1/r1 + 1/r2 + 1/r3)

# Fonction avec *args (arguments variables)
def resistance_serie(*resistances):
    """Calcule la resistance equivalente en serie."""
    return sum(resistances)

# Fonction avec **kwargs (arguments nommes)
def creer_composant(**proprietes):
    """Cree un dictionnaire de composant."""
    return proprietes

# Utilisation
i = loi_ohm(12, 1000)  # 0.012 A
r_eq = resistance_parallele(1000, 2200)  # 687.5 Ω
r_tot = resistance_serie(100, 220, 470)  # 790 Ω
comp = creer_composant(type="resistance", valeur=10000)

6.2 Modules et Importations

electronique.py - Module personnalise 
# electronique.py - Module de calculs electroniques
import math

# Constantes
PI = math.pi
E12 = (1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2)

def reactance_capacitive(capacite, frequence):
    """Calcule la reactance d'un condensateur."""
    return 1 / (2 * PI * frequence * capacite)

def reactance_inductive(inductance, frequence):
    """Calcule la reactance d'une bobine."""
    return 2 * PI * frequence * inductance

def frequence_coupure_rc(resistance, capacite):
    """Calcule la frequence de coupure d'un filtre RC."""
    return 1 / (2 * PI * resistance * capacite)

def frequence_resonance_lc(inductance, capacite):
    """Calcule la frequence de resonance d'un circuit LC."""
    return 1 / (2 * PI * math.sqrt(inductance * capacite))
Utilisation du module 
# Programme principal
import electronique as elec
from electronique import frequence_coupure_rc, E12

# Utilisation avec alias
xc = elec.reactance_capacitive(100e-9, 10000)
print(f"Xc = {xc:.2f} Ω")

# Import direct
fc = frequence_coupure_rc(10000, 100e-9)
print(f"Fc = {fc:.2f} Hz")

# Utilisation de la constante
print("Serie E12 :", E12)
07

Python pour l'Electronique

7.1 NumPy pour les Calculs

NumPy est la bibliotheque fondamentale pour le calcul scientifique en Python. Elle fournit des tableaux multidimensionnels performants et des fonctions mathematiques.

Analyse de signal avec NumPy 
import numpy as np

# Creation de signaux
t = np.linspace(0, 0.01, 1000)  # 10ms, 1000 points
freq = 1000  # 1 kHz

# Signal sinusoidal
amplitude = 5  # Volts
sinus = amplitude * np.sin(2 * np.pi * freq * t)

# Signal carre
carre = amplitude * np.sign(np.sin(2 * np.pi * freq * t))

# Signal triangulaire
triangle = amplitude * (2 * np.abs(2 * (freq * t % 1) - 1) - 1)

# Statistiques
print(f"Moyenne : {np.mean(sinus):.3f} V")
print(f"Valeur efficace : {np.sqrt(np.mean(sinus**2)):.3f} V")
print(f"Valeur crete : {np.max(np.abs(sinus)):.3f} V")

# FFT (Transformee de Fourier)
fft_result = np.fft.fft(sinus)
freqs = np.fft.fftfreq(len(t), t[1] - t[0])
magnitudes = np.abs(fft_result) / len(t)

7.2 Matplotlib pour la Visualisation

Trace de courbes electroniques 
import matplotlib.pyplot as plt
import numpy as np

# Reponse en frequence d'un filtre RC passe-bas
R = 10000  # 10 kΩ
C = 100e-9  # 100 nF
fc = 1 / (2 * np.pi * R * C)

freq = np.logspace(1, 6, 500)  # 10 Hz a 1 MHz
H = 1 / np.sqrt(1 + (freq / fc)**2)  # Module
phase = -np.arctan(freq / fc) * 180 / np.pi  # Phase en degres

# Diagramme de Bode
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))

# Gain
ax1.semilogx(freq, 20 * np.log10(H), 'b-', linewidth=2)
ax1.axvline(fc, color='r', linestyle='--', label=f'fc = {fc:.1f} Hz')
ax1.axhline(-3, color='g', linestyle=':', label='-3 dB')
ax1.set_ylabel('Gain (dB)')
ax1.set_title('Diagramme de Bode - Filtre RC Passe-Bas')
ax1.grid(True)
ax1.legend()

# Phase
ax2.semilogx(freq, phase, 'b-', linewidth=2)
ax2.axvline(fc, color='r', linestyle='--')
ax2.axhline(-45, color='g', linestyle=':', label='-45°')
ax2.set_xlabel('Frequence (Hz)')
ax2.set_ylabel('Phase (°)')
ax2.grid(True)
ax2.legend()

plt.tight_layout()
plt.savefig('bode_rc.png', dpi=150)
plt.show()

7.3 Communication Serie avec PySerial

Communication avec Arduino 
import serial
import time

# Configuration du port serie
ser = serial.Serial(
    port='/dev/ttyUSB0',  # ou 'COM3' sous Windows
    baudrate=9600,
    timeout=1
)

try:
    # Envoi d'une commande
    ser.write(b'LED_ON\n')
    time.sleep(0.1)
    
    # Lecture de la reponse
    while ser.in_waiting > 0:
        ligne = ser.readline().decode('utf-8').strip()
        print(f"Arduino: {ligne}")
    
    # Acquisition de donnees
    mesures = []
    for i in range(100):
        ser.write(b'READ_ADC\n')
        valeur = int(ser.readline().decode().strip())
        mesures.append(valeur)
        time.sleep(0.01)
    
    print(f"Moyenne ADC: {sum(mesures)/len(mesures):.1f}")

finally:
    ser.close()
08

Introduction a MATLAB

8.1 Presentation de MATLAB

MATLAB (MATrix LABoratory) est un environnement de calcul numerique et de programmation developpe par MathWorks. Il est particulierement adapte au calcul matriciel, au traitement du signal et a la simulation de systemes.

8.2 Syntaxe de Base

Bases MATLAB 
% Commentaire en MATLAB

% Variables
tension = 12;           % Scalaire
courant = 0.5;
puissance = tension * courant;

% Affichage
disp(['Puissance = ', num2str(puissance), ' W']);
fprintf('P = %.2f W\n', puissance);

% Vecteurs
t = 0:0.001:1;          % De 0 a 1 par pas de 0.001
t2 = linspace(0, 1, 1001);  % 1001 points entre 0 et 1

% Matrices
A = [1 2 3; 4 5 6; 7 8 9];
B = zeros(3, 3);         % Matrice de zeros
C = ones(3, 3);          % Matrice de uns
I = eye(3);              % Matrice identite

% Acces aux elements
element = A(2, 3);      % Ligne 2, colonne 3
ligne = A(1, :);         % Premiere ligne
colonne = A(:, 2);       % Deuxieme colonne

8.3 Generation de Signaux

Signaux electroniques en MATLAB 
% Parametres
fs = 10000;              % Frequence d'echantillonnage
T = 0.01;                % Duree (10 ms)
t = 0:1/fs:T;            % Vecteur temps
f = 500;                 % Frequence du signal

% Signal sinusoidal
A = 5;                   % Amplitude
sinus = A * sin(2*pi*f*t);

% Signal carre
carre = A * square(2*pi*f*t);

% Signal triangulaire
triangle = A * sawtooth(2*pi*f*t, 0.5);

% Signal avec bruit
bruit = 0.5 * randn(size(t));
signal_bruite = sinus + bruit;

% Trace
figure;
subplot(2,2,1); plot(t*1000, sinus); title('Sinusoide');
xlabel('Temps (ms)'); ylabel('Tension (V)'); grid on;

subplot(2,2,2); plot(t*1000, carre); title('Carre');
xlabel('Temps (ms)'); ylabel('Tension (V)'); grid on;

subplot(2,2,3); plot(t*1000, triangle); title('Triangulaire');
xlabel('Temps (ms)'); ylabel('Tension (V)'); grid on;

subplot(2,2,4); plot(t*1000, signal_bruite); title('Sinus bruite');
xlabel('Temps (ms)'); ylabel('Tension (V)'); grid on;
09

Traitement du Signal avec MATLAB

9.1 Analyse Frequentielle - FFT

Transformee de Fourier 
% Signal compose de plusieurs frequences
fs = 1000;               % Frequence d'echantillonnage
T = 1;                   % Duree 1 seconde
t = 0:1/fs:T-1/fs;

% Signal = 50 Hz + 120 Hz + bruit
signal = 3*sin(2*pi*50*t) + 2*sin(2*pi*120*t) + 0.5*randn(size(t));

% Calcul de la FFT
N = length(signal);
Y = fft(signal);
P2 = abs(Y/N);
P1 = P2(1:N/2+1);
P1(2:end-1) = 2*P1(2:end-1);
f = fs*(0:(N/2))/N;

% Trace
figure;
subplot(2,1,1);
plot(t(1:200)*1000, signal(1:200));
title('Signal temporel');
xlabel('Temps (ms)'); ylabel('Amplitude');
grid on;

subplot(2,1,2);
plot(f, P1);
title('Spectre de frequence');
xlabel('Frequence (Hz)'); ylabel('|Amplitude|');
xlim([0 200]);
grid on;

9.2 Filtrage Numerique

Conception de filtres 
% Conception d'un filtre passe-bas Butterworth
fc = 100;                % Frequence de coupure
ordre = 4;               % Ordre du filtre
[b, a] = butter(ordre, fc/(fs/2), 'low');

% Application du filtre
signal_filtre = filter(b, a, signal);

% Reponse en frequence
figure;
freqz(b, a, 1024, fs);
title('Reponse en frequence du filtre');

% Comparaison signal original vs filtre
figure;
subplot(2,1,1);
plot(t(1:500)*1000, signal(1:500));
title('Signal original');
xlabel('Temps (ms)'); grid on;

subplot(2,1,2);
plot(t(1:500)*1000, signal_filtre(1:500));
title('Signal filtre (fc = 100 Hz)');
xlabel('Temps (ms)'); grid on;

9.3 Diagramme de Bode

Analyse d'un systeme 
% Fonction de transfert d'un filtre RC passe-bas
% H(s) = 1 / (1 + RC*s)
R = 10000;               % 10 kΩ
C = 100e-9;              % 100 nF
tau = R * C;

% Definition de la fonction de transfert
num = [1];               % Numerateur
den = [tau 1];           % Denominateur: tau*s + 1
sys = tf(num, den);

% Diagramme de Bode
figure;
bode(sys);
grid on;
title('Diagramme de Bode - Filtre RC Passe-Bas');

% Calcul de la frequence de coupure
fc = 1 / (2 * pi * tau);
fprintf('Frequence de coupure: %.2f Hz\n', fc);
10

Simulink pour l'Electronique

10.1 Introduction a Simulink

Simulink est un environnement graphique de simulation et de conception basee sur les modeles. Il permet de creer des systemes dynamiques par assemblage de blocs fonctionnels sans ecrire de code.

📦 Blocs de Base

  • Sources (Step, Sine Wave, Pulse)
  • Operateurs (Sum, Gain, Product)
  • Integrateurs et derivateurs
  • Afficheurs (Scope, Display)

🔌 Bibliotheques Electroniques

  • Simscape Electrical
  • Composants passifs (R, L, C)
  • Semi-conducteurs
  • Sources et mesures

10.2 Simulation d'un Circuit RC

Creation programmatique d'un modele Simulink 
% Parametres du circuit RC
R = 10000;      % Resistance en Ohms
C = 100e-6;     % Capacite en Farads
tau = R * C;   % Constante de temps

% Creation du modele
model = 'circuit_RC';
new_system(model);
open_system(model);

% Fonction de transfert H(s) = 1/(1 + tau*s)
add_block('simulink/Sources/Step', [model '/Step']);
add_block('simulink/Continuous/Transfer Fcn', [model '/RC Filter']);
add_block('simulink/Sinks/Scope', [model '/Scope']);

% Configuration du bloc Transfer Function
set_param([model '/RC Filter'], 'Numerator', '[1]');
set_param([model '/RC Filter'], 'Denominator', sprintf('[%f 1]', tau));

% Connexions
add_line(model, 'Step/1', 'RC Filter/1');
add_line(model, 'RC Filter/1', 'Scope/1');

% Simulation
sim(model, 5*tau);  % Simulation sur 5 constantes de temps

10.3 Asservissement de Vitesse d'un Moteur DC

Modele de moteur a courant continu 
% Parametres du moteur DC
Ra = 2.0;       % Resistance d'armature (Ohm)
La = 0.5;       % Inductance d'armature (H)
Kb = 0.1;       % Constante de f.e.m. (V/(rad/s))
Kt = 0.1;       % Constante de couple (N.m/A)
J = 0.02;       % Moment d'inertie (kg.m²)
B = 0.001;      % Coefficient de frottement

% Fonction de transfert du moteur
% Entree: tension Va, Sortie: vitesse angulaire ω
num_motor = Kt;
den_motor = [La*J, (Ra*J + La*B), (Ra*B + Kb*Kt)];
G_motor = tf(num_motor, den_motor);

% Correcteur PID
Kp = 100;
Ki = 200;
Kd = 1;
C_pid = pid(Kp, Ki, Kd);

% Systeme en boucle fermee
sys_bf = feedback(C_pid * G_motor, 1);

% Analyse temporelle
figure;
step(sys_bf);
title('Reponse indicielle - Asservissement de vitesse');
grid on;

% Caracteristiques de la reponse
info = stepinfo(sys_bf);
fprintf('Temps de montee: %.3f s\n', info.RiseTime);
fprintf('Depassement: %.1f %%\n', info.Overshoot);
fprintf('Temps de stabilisation: %.3f s\n', info.SettlingTime);

10.4 Deploiement sur Arduino avec Simulink

✅ Simulink Support Package for Arduino

Le package Simulink pour Arduino permet de :

  • Generer automatiquement le code C/C++ pour Arduino
  • Utiliser des blocs GPIO, ADC, PWM directement dans Simulink
  • Tester en temps reel avec le mode External
  • Deployer le modele sur la carte sans ecrire de code
Configuration pour Arduino 
% Configuration du modele pour Arduino
model = 'mon_projet_arduino';

% Selection de la carte
set_param(model, 'HardwareBoard', 'Arduino Uno');

% Configuration du port serie
set_param(model, 'ExtModeMexFile', 'ext_serial_win32_comm');

% Parametres de simulation
set_param(model, 'StopTime', 'inf');  % Execution continue
set_param(model, 'FixedStep', '0.01'); % Pas de 10 ms

% Generation et televersement
rtwbuild(model);  % Genere le code et televerse

MII1 : Developpement Informatique

1ere Annee : 52h | 2eme Annee : 52h

© 2025 - Support Pedagogique