Lors du débogage d'un essaim de drones, je me suis soudainement souvenu d'une anecdote de l'année dernière où un collègue du laboratoire avait simulé une intégration de véhicules terrestres (UGV) et aériens (UAV), provoquant une incompatibilité des ordres du système. Aujourd'hui, explorons ce sujet fascinant des systèmes multi-agents hétérogènes à ordres mixtes - car dans les scénarios réels, les situations idéales où tous les agents sont parfaitement synchronisés sont rares !

Considérons un scénario typique : les robots terrestres (UGV) sont modélisés par une dynamique du second ordre, tandis que les drones (UAV) sont simplifiés en modèles du premier ordre. Pour que ces agents parviennent à un consensus de position, c'est comme demander à un char et à une voiture de s'arrêter en synchronisation à un carrefour. Dans le code, un détail crucial se cache dans le paramètre du protocole - modifier un chiffre permet de passer entre deux modes de consensus :

def protocole_consensus(etats_agents, type_protocole):
    entrees_commande = []
    for i in range(len(etats_agents)):
        u = 0
        voisins = obtenir_voisins(i)  # Récupérer les indices des voisins
        for j in voisins:
            if type_protocole == 1:  # Protocole dynamique
                delta_pos = etats_agents[j][0] - etats_agents[i][0]
                delta_vel = etats_agents[j][1] - etats_agents[i][1] if len(etats_agents[j])>1 else 0
                u += alpha * delta_pos + beta * delta_vel
            else:  # Protocole statique
                u += gamma * (etats_agents[j][0] - etats_agents[i][0])
        entrees_commande.append(u)
    return entrees_commande

Notez la condition à la ligne 5, qui agit comme un interrupteur pour le changement de protocole. Le protocole dynamique ne considère pas seulemant l'écart de position, mais gère également la synchronisation des vitesses, ajoutant une couche de sécurité au système. Le protocole statique, quant à lui, fonctionne comme un simple contrôleur P, se concentrant uniquement sur l'écart de position actuel.

Le traitement des systèmes à ordres mixtes est encore plus intéressant. Lors de la construction de la matrice de Laplace, une manipulation dimensionnelle est nécessaire :

% Traitement de la matrice d'adjacence pour les agents hétérogènes
L = zeros(total_dim);
for i = 1:nombre_agents
    if type_agent(i) == 1  % Système du second ordre UGV
        bloc = L_ugv(matrice_adjacence, i);
    else  % Système du premier ordre UAV 
        bloc = L_uav(matrice_adjacence, i);
    end
    L((i-1)*dim+1:i*dim, :) = kron(bloc, eye(dim));
end

Cette traitement par blocs est comparable à l'ajout d'un sur-mesure pour chaque type d'agent. Le bloc corrrespondant aux UGV contient des termes de couplage de position et de vitesse, tandis que le bloc UAV ne traite que les informations de position. Les simulations révèlent un phénomène intéressant : sous le protocole dynamique, les UGV ralentissent d'abord pour attendre les UAV, tandis que sous le protocole statique, les UAV nécessitent plus de temps pour s'ajuster.

Les courbes de simultaion montrent clairement ces différences. La courbe de consensus dynamique ressemble aux mouvements de danseurs professionnels, avec une convergence synchronisée de position et de vitesse. La courbe statique, en revanche, rappelle celle d'un débutant, où la position s'aligne finalement mais avec un processus de convergence présentant des "désynchronisations". Cela valide l'analyse théorique - le protocole dynamique améliore l'amortissement du système par le retour de vitesse.

En pratique, un piège à éviter : les mutations topologiques de communication peuvent entraîner des incompatibilités dimensionnelles. J'ai rencontré une erreur lorsque j'ai déplacé soudainement un UGV hors du réseau, problème résolu par l'ajout d'une détection en temps réel des dimensions d'état des agents. Ne supprimez donc jamais cette section de vérification dimensionnelle :

# Vérification des dimensions d'état
def valider_etats(etats_agents):
    dimensions_ensemble = set()
    for etat in etats_agents:
        dimensions_ensemble.add(len(etat))
    assert len(dimensions_ensemble) == 2, "Système avec cas d'ordres mixtes non traités !"

Enfin, un conseil pratique : commencez par valider la connectivité du réseau avec le protocole statique, puis passez au mode dynamique pour optimiser les performances. L'article de Minghao[1] fournit une preuve de stabilité pour les systèmes à ordres mixtes, tandis que la partie expérimentale de l'article de Wang[2] mérite une attention particulière. Le code est disponible sur GitHub, n'oubliez pas d'ajuster la durée de simulation lors du changement de type de protocole, car la convergence statique nécessite généralement 20% de temps supplémentaire.

[1] Minghao, et al. "Consensus des systèmes à ordres hybrides..." CDC 2022

[2] Wang, "Étude expérimentale sur UAV-UGV..." IEEE TRO 2023