Projet réalisé sur Godot dans un cadre pédagogique en binôme avec Elisa MARCHAND.
Ce projet a pour objectif de concevoir un simulateur de drone permettant aux étudiants d’apprendre la programmation temps réel dans un environnement interactif. Le simulateur remplace un ancien simulateur de voiture utilisé dans l’enseignement et propose un système plus riche, intégrant une simulation physique réaliste ainsi qu’une communication avec un programme externe.
Le simulateur est développé avec le moteur de jeu Godot, tandis que le contrôle du drone est effectué via un programme Python externe. L’application repose sur une architecture client–serveur permettant l’échange de données en temps réel entre la simulation et le programme de contrôle. L’utilisateur peut ainsi piloter un drone virtuel, récupérer ses informations d’état et implémenter ses propres algorithmes de contrôle.
Le projet devait répondre à plusieurs objectifs principaux. Tout d’abord, il fallait créer un simulateur capable de représenter un drone évoluant dans un environnement 3D. Ce drone devait présenter un comportement physique réaliste, notamment grâce à la simulation des forces appliquées sur ses moteurs.
Ensuite, l’application devait permettre une communication avec un programme externe afin que les étudiants puissent écrire leurs propres algorithmes de contrôle. Cette communication devait être non bloquante afin de garantir une réactivité suffisante pour une application temps réel.
Enfin, l’ensemble devait permettre l’exécution de scénarios pédagogiques dans lesquels le drone doit se déplacer vers différentes positions tout en évitant des obstacles.
L’application est organisée en trois composants principaux :
le simulateur graphique développé avec Godot ;
un serveur intégré dans l’application Godot ;
un client Python chargé de piloter le drone.
Le simulateur représente l’environnement 3D dans lequel évolue le drone. Le serveur intégré reçoit les commandes envoyées par le programme Python et met à jour l’état du drone dans la simulation. Le client Python, quant à lui, implémente les algorithmes de contrôle et envoie des commandes au simulateur.
La communication entre le client et le serveur utilise le protocole UDP. Ce protocole a été choisi pour sa légèreté et sa rapidité, ce qui est particulièrement adapté aux systèmes temps réel. Les messages échangés utilisent le format JSON afin de faciliter leur structuration et leur interprétation.
Chaque message contient notamment un identifiant de client, un identifiant de message et un caractère indiquant le type d’action demandée (initialisation du drone, modification de la vitesse ou demande d’information).
Le drone simulé est un quadrirotor composé de quatre moteurs et d’un corps central. Dans Godot, ce drone est modélisé sous la forme d’une scène contenant plusieurs objets physiques.
Chaque moteur est représenté par un RigidBody3D afin de
bénéficier du moteur physique de Godot. Ces moteurs possèdent également
un modèle visuel (MeshInstance3D) et une forme de collision
(CollisionShape3D). Des jointures mécaniques permettent de
relier les moteurs au corps principal du drone afin de former une
structure cohérente.
Le drone est également équipé d’un capteur simulé à l’aide d’un
Raycast. Ce capteur permet de détecter la présence
d’obstacles sur la trajectoire du drone et de transmettre cette
information au programme de contrôle.
Cette architecture modulaire facilite la manipulation des différents éléments du drone et permet d’ajouter facilement de nouveaux comportements ou capteurs.
Un des principaux défis du projet a été la mise en place d’un modèle physique permettant de simuler correctement le comportement du drone. Contrairement à une approche simplifiée où les forces seraient appliquées directement au corps du drone, chaque moteur génère ici une poussée indépendante.
Le contrôle du drone repose sur un système de régulation basé sur des contrôleurs PID (Proportionnel–Intégral–Dérivé). Ces contrôleurs permettent d’ajuster dynamiquement la force appliquée par chaque moteur afin d’atteindre une vitesse cible.
Le système de régulation est organisé sous la forme d’un double PID :
un premier PID calcule l’inclinaison nécessaire du drone pour atteindre la vitesse souhaitée ;
un second PID ajuste les forces des moteurs afin d’atteindre cette inclinaison.
À chaque étape de simulation, le programme lit l’état actuel du drone, notamment sa vitesse et son orientation. L’erreur entre la vitesse actuelle et la vitesse cible est ensuite calculée, ce qui permet d’obtenir les composantes proportionnelle, intégrale et dérivée de la correction.
Ces valeurs sont utilisées pour déterminer les forces à appliquer à chaque moteur. La combinaison des forces permet d’incliner le drone dans la direction souhaitée ou de modifier son altitude.
Cette méthode permet d’obtenir un comportement stable et réaliste, tout en restant suffisamment flexible pour être utilisé dans différents scénarios.
L’interface utilisateur du simulateur reste volontairement simple. Elle comporte principalement plusieurs barres de défilement permettant d’ajuster les coefficients des contrôleurs PID.
Ces paramètres peuvent être modifiés en temps réel afin d’observer leur influence sur le comportement du drone. Les valeurs des coefficients sont transmises aux scripts de contrôle via le système de signaux de Godot.
Cette approche facilite les expérimentations et permet aux étudiants de comprendre l’impact des paramètres de régulation sur la stabilité du système.
La communication entre le programme Python et le simulateur Godot constitue un élément central du projet.
Du côté du client Python, une classe dédiée gère l’envoi et la réception des messages. Les fonctions proposées permettent notamment :
d’initialiser un drone dans la simulation ;
d’envoyer un vecteur de vitesse cible ;
de récupérer différentes informations sur l’état du drone.
Lorsqu’un message est envoyé, il est converti au format JSON puis transmis au serveur via UDP. Le serveur Godot reçoit ensuite ce message, le décode et l’ajoute dans une file d’attente.
Le traitement des messages est effectué dans un second thread afin d’éviter de bloquer la simulation. Chaque message est analysé afin de déterminer l’action à effectuer.
Trois types de messages principaux sont pris en charge :
l’apparition d’un drone dans la simulation ;
la modification de sa vitesse cible ;
les demandes d’informations sur son état.
Une fois l’action exécutée, le serveur peut renvoyer une réponse au client Python, par exemple pour transmettre la position actuelle du drone ou l’état de son capteur.
Le programme Python implémente également un algorithme de contrôle permettant au drone de suivre un parcours composé de plusieurs cibles.
Pour cela, le programme récupère régulièrement la position du drone et celle de la prochaine cible. Un contrôleur PID calcule ensuite un vecteur vitesse permettant de rapprocher le drone de cette cible.
Lorsque le drone se trouve suffisamment proche de la position cible, le programme demande la position de la cible suivante. Ce processus se répète jusqu’à ce que toutes les cibles aient été atteintes.
Le drone est également capable de détecter les obstacles présents sur sa trajectoire. Lorsque le capteur indique la présence d’un obstacle, une stratégie simple d’évitement est appliquée : le drone augmente temporairement son altitude afin de contourner l’objet.
Plusieurs pistes d’amélioration ont été identifiées pour la suite du projet.
Une première possibilité consiste à réimplémenter certaines parties du programme en C++ afin de comparer les performances avec la version actuelle en GDScript.
Il serait également envisageable d’intégrer un système d’exploitation temps réel tel que FreeRTOS afin de rapprocher davantage le projet d’un système embarqué réel.
D’autres améliorations plus modestes pourraient être apportées, comme l’ajout de nouveaux scénarios, la création de cartes supplémentaires ou la mise en place de zones interdites dans l’environnement de simulation.
Ce projet a permis de développer un simulateur de drone réaliste capable d’être contrôlé par un programme externe. L’utilisation du moteur Godot a facilité la création d’un environnement interactif et la simulation physique du drone.
La mise en place d’une communication client–serveur avec Python permet aux utilisateurs d’implémenter leurs propres algorithmes de pilotage, ce qui constitue un outil pédagogique intéressant pour l’apprentissage de la programmation temps réel.
Grâce à la modélisation physique des moteurs et à l’utilisation de contrôleurs PID, le drone présente un comportement cohérent et stable. Le projet constitue ainsi une base solide pour de futurs développements et pour son utilisation dans un contexte pédagogique.