Architecture Fondamentale et Logique de Commutation des Cellules

Le convertisseur modulaire multiniveau (MMC) repose sur la mise en série de cellules de commutation, communément appelées sous-modules (SM). Dans une topologie en pont demi-pont (half-bridge), la gestion de l'état des interrupteurs détermine si le condensateur interne est inséré dans le circuit ou contourné. Cette flexibilité permet de synthétiser une onde de tension proche d'une sinusoïde parfaite.

from enum import Enum

class SwitchState(Enum):
    INSERTED = 1
    BYPASSED = 0

class HalfBridgeSM:
    def __init__(self):
        self.state = SwitchState.BYPASSED

    def update_state(self, target_state: SwitchState):
        self.state = target_state

    def evaluate_behavior(self, arm_current: float) -> str:
        if self.state == SwitchState.INSERTED:
            return "Charging" if arm_current > 0 else "Discharging"
        return "Bypassed"

# Initialisation et test
sm_cell = HalfBridgeSM()
sm_cell.update_state(SwitchState.INSERTED)
print(f"État du condensateur: {sm_cell.evaluate_behavior(arm_current=15.0)}")

Cette approche orientée objet modélise le comportement dynamique d'une cellule. En fonction de l'état commandé et de la direction du courant dans la branche, le système détermine si le condensateur stocke ou restitue de l'énergie.

Algorithme de Tri pour l'Équilibrage des Condensateurs

Dans les configurations monophasées, la dispersion des tensions aux bornes des condensateurs est un défi majeur qui dégrade la qualité de l'onde. L'algorithme de tri est la méthode de prédilection pour gérer cette dispersion. Contrairement à une approche statique, l'implémentation réelle doit intégrer la direction du courant dans la branche pour déterminer la séquence d'insertion optimale.

import heapq

def select_submodules(voltages: list[float], arm_current: float, num_required: int) -> list[int]:
    indexed_voltages = [(v, i) for i, v in enumerate(voltages)]

    if arm_current > 0:
        # Courant positif (charge) : insérer les cellules avec les tensions les plus faibles
        selected = heapq.nsmallest(num_required, indexed_voltages, key=lambda x: x[0])
    else:
        # Courant négatif (décharge) : insérer les cellules avec les tensions les plus élevées
        selected = heapq.nlargest(num_required, indexed_voltages, key=lambda x: x[0])

    return [index for _, index in selected]

# Simulation de l'équilibrage
measured_voltages = [205.2, 198.5, 201.0, 195.8, 203.4]
current_direction = 1.5 
to_insert = 3

chosen_indices = select_submodules(measured_voltages, current_direction, to_insert)
print(f"Indices des sous-modules à insérer : {chosen_indices}")

L'utilisation de structures de données optimisées comme les tas (heaps) permet d'extraire rapidement les tensions extrêmes. En couplant cette logique de tri avec le signe du courant de branche, le contrôleur assure une convergence rapide des tensions vers leur valeur nominale.

Suppression Active des Ondulations par Filtrage Numérique

Les ondulations de tension résiduelles, souvent liées aux fréquences de commutation ou aux harmoniques du réseau, peuvent augmenter les pertes par échauffement. Une approche efficace consiste à isoler les composantes harmoniques indésirables via un filtrage numérique spécifique, tel qu'un filtre coupe-bande (notch filter), pour injecter un signal de compensation en opposition de phase dans la boucle de modulation.

import numpy as np
from scipy import signal

def compensate_ripple(voltage_waveform: np.ndarray, sampling_rate: float, target_freq: float, quality_factor: float = 30.0) -> np.ndarray:
    # Conception d'un filtre coupe-bande pour isoler la fréquence de l'ondulation
    b_notch, a_notch = signal.iirnotch(target_freq, quality_factor, sampling_rate)

    # Extraction de la composante d'ondulation spécifique
    ripple_component = signal.filtfilt(b_notch, a_notch, voltage_waveform)

    # Génération du signal de compensation en opposition de phase
    anti_phase_signal = -ripple_component

    return anti_phase_signal

# Paramètres de simulation
fs = 10000  
t = np.arange(0, 0.1, 1/fs)
fundamental_freq = 50 
ripple_freq = 100 

# Tension de sortie synthétique avec harmonique indésirable
v_out = 100 * np.sin(2 * np.pi * fundamental_freq * t) + 5 * np.sin(2 * np.pi * ripple_freq * t)

compensation_signal = compensate_ripple(v_out, fs, ripple_freq)

L'application d'un filtre IIR coupe-bande permet d'extraire avec précision l'harmonique ciblée sans déphaser excessivement le signal fondamental. Le signal résultant, une fois inversé et sommé à la référence de modulation, annule activement la composante ondulatoire indésirable.