Ingénieur Logiciel Embarqué

Réalisation d'une refactorisation complète du firmware embarqué sur ESP32 pour un système autonome de détection d'obstacles équipé d'un capteur CH201 et d'une IMU.

• Conception d'une architecture event-driven avec state machine applicative et pattern Singleton pour les managers (capteurs, énergie, périphériques).
• Implémentation du Non-Blocking I/O via interruptions timer (ISR) sans aucun delay() bloquant en boucle principale.
• Mise en place d'une gestion adaptative de 5 modes de puissance (IDLE, DETECTING, ALERT, SLEEPING) selon l'état applicatif.
• Développement de templates C++ pour callbacks type-safe et réutilisabilité zéro overhead.
• Assurance du débogage et profilage : analyse des timings ISR, mesure d'utilisation CPU, validation consommation courant.
• Résultat : CPU idle à 94.85%, latence détection <10 ms, autonomie batterie 25h+ sur batterie 3000 mAh @ 120 mA.

Intégration de l'équipe R&D pour développer un système embarqué de vision par ordinateur temps réel destiné à l'assistance à la mobilité urbaine sur Jetson Orin Nano (projet AI4Citizens), en méthodologie Agile avec points d'avancement réguliers et gestion de version Git.

• Réalisation de l'interfaçage bas niveau d'une caméra infrarouge FLIR Lepton 3 (SPI, I2C, C/C++) avec synchronisation dual flux RGB/IR.
• Conception d'une architecture logicielle multi-threadée POSIX avec verrous mutex, files d'attente d'événements et buffers partagés.
• Exécution du débogage système : analyse de race conditions, suivi mémoire sous Valgrind, profilage GDB sur cible embarquée Linux.
• Développement du traitement vidéo temps réel (OpenCV + CUDA) et intégration GStreamer pour pipeline caméra.
• Optimisation des modèles YOLOv8 / YOLOv8-seg (TensorRT FP16/INT8, pruning), suivi multi-ID, génération des GEI.
• Implémentation d'un module de communication BLE vers tablette pour monitoring et transmission d'état système.
• Exécution d'une campagne de validation & benchmarks : mesures latence / FPS / consommation GPU-RAM, comparaison des configurations d'optimisation, protocole de test documenté.
• Résultat : Pipeline stable, temps réel validé en intérieur, latence <46 ms, traitement continu des flux vidéo.

Développement du firmware d'un pluviomètre autonome à énergie optimisée basé sur STM32, en bare metal et temps réel.

• Développement du firmware C/C++ en bare metal : configuration PWM, timers, ADC, DAC, DMA via CMSIS & HAL.
• Exécution du débogage bas niveau avec STM32CubeIDE (GDB intégré) : analyse des registres, points d'arrêt matériels, inspection de la stack.
• Mise en place de modes basse consommation (standby, sleep, low-power run) pour optimiser l'autonomie.
• Réalisation du contrôle d'une vanne électromagnétique et la gestion de capteurs environnementaux (SPI, I2C).
• Implémentation du stockage des données sur module SD (SPI) avec gestion de buffers mémoire.
• Exécution d'une migration complète MSP430 → STM32 (Cortex-M3) avec refonte complète du firmware.
• Résultat : +40% d'autonomie et déclenchement fiable sur événements environnementaux.

Extension du firmware open-source Klipper pour la détection de sauts de pas sur imprimante 3D cartésienne (carte SKR3 / STM32), en binôme et versionné sous GitLab.

• Réalisation d'une analyse approfondie du code source Klipper (Python côté hôte + C côté MCU) : communication série asynchrone Klippy ↔ STM32, file d'attente de commandes, ordonnancement temps réel.
• Exécution de la rétro-ingénierie du flux UART entre Klippy et le driver TMC2209 pour identifier le chemin de lecture du registre SG_RESULT (StallGuard4).
• Modification de tmc2209.py : ajout de SG_RESULT aux registres lisibles, et statistics.py : collecte périodique automatique de SG_RESULT et TSTEP sans commande manuelle.
• Mise en place d'un protocole de test rigoureux sur banc : 5 tests de référence, 5 de validation, 10 avec injection de fautes (blocage moteur), enregistrement et analyse automatisée des logs.
• Développement de deux méthodes de détection : analyse comparative par somme de SG_RESULT, et détection statistique de successions de valeurs nulles.
• Résultat quantifié : détection validée à haute vitesse – moyenne des séquences d'erreur 14.7 (faute) vs 11.3 (référence), soit un écart statistiquement exploitable.

Participation à la conception et au développement complet d'un système embarqué de prélèvement d'échantillons d'eau pour l'Observatoire des Sciences de l'Univers de Rennes (groupe de 3 développeurs).

• Conception de l'architecture firmware sur ESP32 : machine à états (5 états), gestion de 4 électrovannes via relais, contrôle d'une pompe péristaltique EZO-PMP via I2C.
• Intégration des multi-périphériques sur bus I2C : pompe Atlas Scientific + module RTC DS1307, stockage log sur carte SD via SPI.
• Implémentation de l'acquisition de données GPS via protocole MAVLink sur liaison UART depuis contrôleur de vol Pixhawk Black Cube.
• Développement de la communication Bluetooth (BluetoothSerial) vers application mobile créée sous MIT App Inventor : modes manuel et automatique programmé par RTC.
• Réalisation de l'analyse oscilloscope du signal PWM (55.3 Hz) d'un récepteur RC FrSky pour déclenchement de prélèvement par radiocommande.
• Résultat : toutes les fonctionnalités validées sur prototype (hors GPS), modes manuel et automatique fonctionnels.

Réalisation de la conception complète d'un système numérique de traitement de trames (10 bits) sur FPGA Spartan (Nexys 3) en binôme, en méthodologie Cycle en V.

• Développement d'une architecture modulaire en VHDL : conversion série/parallèle (machine à états finie), comparateur, compteur, détection d'erreur de parité.
• Création de testbenches pour chaque composant, simulation et vérification des formes d'onde sous Xilinx ISE.
• Exécution de la synthèse, analyse RTL vs technologique, optimisation des ressources (LUT / registres) avec utilisation plus efficace que les autres binômes.
• Assurance de la validation matérielle réelle : chargement du bitstream, brochage, vérification des signaux à l'oscilloscope et à l'analyseur logique (LogicPort).
• Conception d'un banc de test embarqué (ROM 256 valeurs, générateur d'horloge) pour rejouer 11 trames successives et valider le comportement en conditions réelles.