Échelle 5-to-1

Le plan d’apprentissage d’un développeur embarqué doit refléter la nomenclature. Nous l’avons appris à nos dépens en déployant un nœud de surveillance du sol alimenté par le soleil, construit sur ESP32, un back-haul cellulaire SIMCom et AWS IoT Core : firmware, matériel, liaisons radio et flux de travail cloud devaient tous se réunir en même temps, et négliger ne serait-ce qu’une pièce transformait un « petit » ajustement de firmware en semaines de débogage.

Pour garder ce plan ciblé, nous notons chaque compétence sur une échelle 5-to-1 — un cadre complètement agnostique de la technologie :

Comment l’appliquer n’importe où

1. Définissez l’objectif final. À quoi ressemble « prêt pour l’emploi » ou « prêt pour la production » ?
2. Listez les 5. Kit de survie absolu.
3. Identifiez les 4. Pratiques qui durcissent et font évoluer la solution.
4. Remplissez les 3. Outils et optimisations de qualité de vie.
5. Ajoutez les 2 et les 1. Profondeur spécialisée pour les grandes équipes ou les fonctionnalités avancées.

Preuve rapide que cela voyage bien

• Développement web frontend → 5s : HTML/CSS, JS moderne, Git… • 4s : React/Vue, TypeScript, Jest, CI/CD… • 3s : Storybook, tests e2e… • 2s : PWA, animations… • 1s : WebGL, data-viz.
• Data Science / MLOps → 5s : Python, NumPy/Pandas, stats… • 4s : TensorFlow/PyTorch, Docker, tests unitaires… • 3s : Feature stores, MLflow… • 2s : Edge inference… • 1s : Federated learning.

En notant l’impact et la fréquence de chaque sujet, vous vous tracez un chemin clair et évitez d’être submergé.

À quoi ressemblent les 5 pour notre stack ESP32 + SIM + AWS

1. Maîtrise du C/C++ — la langue d’ESP-IDF et des hooks FreeRTOS.
2. Maîtrise d’ESP-IDF (ou Arduino-ESP32) — Wi-Fi, BLE, ADC, API de deep-sleep.
3. Fondamentaux d’électronique — adaptation de niveau des UARTs SIM, lecture des sondes NPK, hygiène EMI.
4. Budget énergétique & charge solaire-Li-ion — garder une batterie 18650 de 4 Ah en vie pendant les semaines nuageuses.
5. Connectivité robuste (Wi-Fi, SIM AT, MQTT/TLS) — acheminer les données des capteurs en toute sécurité vers AWS.

Maîtrisez ces cinq et vous pouvez livrer un prototype fonctionnel. Grimpez dans les 4 — pipelines CI, FreeRTOS avancé, OTA, sécurité — et vous aurez un produit qui survit sur le terrain. Les 3, 2 et 1 complètent le kit d’outils professionnel avec des tableaux de bord, la conformité et la profondeur spécifique au domaine.

L’article qui suit n’est pas une checklist ; c’est une feuille de route séquentielle alignée sur des choix matériels réels. Commencez par les 5, progressez vers les 4, et quand vous toucherez au territoire 3-to-1, vous aurez à la fois la confiance et le contexte pour les appliquer là où ils comptent le plus, de la breadboard à la production.

Compétences pour les développeurs embarqués

Légende – Importance
5 = Indispensable (must-have pour le travail quotidien)
4 = Très important (nécessaire sur la plupart des projets)
3 = Utile (souvent utile, à apprendre rapidement)
2 = Sympa à avoir (à apprendre quand le temps le permet)
1 = Spécialisé / situationnel

Comment lire le tableau

• Commencez par les 5 : maîtrise du langage, SDK du microcontrôleur, bases matérielles, conception du système d’alimentation, connaissance des capteurs et des communications cellulaires sont décisifs pour un appareil de terrain fiable.
• Attaquez les 4 ensuite : environnement de développement, optimisation de l’énergie, OTA, RTOS et sécurité transforment un prototype fonctionnel en un produit prêt pour la production.
• Les 3 complètent le workflow professionnel (CI, tests unitaires, backends cloud, CAO PCB).
• Les 2 et 1 ajoutent de la profondeur pour les grandes équipes ou les fonctionnalités avancées et peuvent être reportés si le planning est serré.
• Utilisez cela comme une feuille de route de compétences : progressez de gauche à droite sur l’échelle d’importance pendant que le projet mûrit.

1 – C/C++

Niveau : 1 – Débutant absolu
– Syntaxe & structure C : modèle de compilation (source → objet → exécutable), fonction main()
– Types de données de base : int, char, float, double, bool
– Variables & constantes : déclaration, initialisation, qualificateur const
– Opérateurs : arithmétiques (+, −, *, /, %), affectation, incrément/décrément
– Flux de contrôle : if/else, switch, boucles for/while/do-while
– E/S simples : printf, sortie console de base
– Introduction aux pointeurs : déclaration de pointeur, déréférencement
– Compilation & débogage : compiler avec gcc -o, interpréter les erreurs de compilation de base

Niveau : 2 – Débutant
– Mémoire & pointeurs : arithmétique des pointeurs, pointeurs vs tableaux, introduction à malloc/free
– Types structurés : struct, union, typedef
– Bases du préprocesseur : #define, #include, include guards
– Classes de stockage : auto, static, extern, règles de portée & de linkage
– Chaînes & tableaux : char[], fonctions de chaîne (strcpy, strlen, etc.)
– Code modulaire : division en plusieurs fichiers .c/.h, bases du makefile (règles, cibles)
– Outils de débogage de base : pas à pas avec gdb, breakpoints, inspection des variables

Niveau : 3 – Intermédiaire
– Gestion dynamique de la mémoire : heap vs stack, patterns de fuite courants, utilisation d’outils comme Valgrind
– Fichier I/O : fopen/fread/fwrite/fclose, pointeurs de fichier, gestion d’erreurs
– Opérations bit à bit : masques, décalages, mise à 1 / à 0 de bits, enum et bit-fields
– Pointeurs de fonction : callbacks, tables de dispatch
– Gestion d’erreurs : codes de retour, errno
– Fondamentaux C++ : classes & objets, constructeurs/destructeurs, spécificateurs d’accès
– Bases de la STL : std::vector, std::string, utilisation simple de std::map et itérateurs
– Namespaces & organisation des headers

Niveau : 4 – Avancé
– Spécificités C embarqué : volatile, I/O mappés en mémoire, const en flash vs RAM
– Linker & système de build : scripts linker personnalisés, placement de sections, flags d’optimisation (-O2, -Os), toolchains de cross-compilation
– Fonctionnalités C++11/14/17 : lambdas, auto, range-based for, constexpr, nullptr
– Smart pointers & RAII : unique_ptr, shared_ptr, gestion des ressources
– Bases des templates : templates de fonction & de classe, spécialisation de template
– Multithreading : std::thread, mutexes, variables conditionnelles, types atomiques
– Concepts temps réel : routines de service d’interruption (ISRs), sections critiques, atténuation de l’inversion de priorité

Niveau : 5 – Expert
– Méta-programmation de templates avancée : templates variadiques, SFINAE, type traits
– Modèle objet C++ profond : vtables, layout d’objets, considérations ABI
– Concurrence lock-free & faible latence : atomics, ordres de mémoire, algorithmes wait-free
– Internes du compilateur & toolchain : pipelines de passes GCC/Clang, écriture de plugins de compilateur personnalisés
– Optimisation des performances : alignement de cache, prédiction de branche, profilage approfondi (par exemple, gprof, compteurs matériels)
– Portage bare-metal : implémentation de stubs newlib, runtime C minimal, code de bring-up
– Normes & sécurité : conformité MISRA-C/C++, outils d’analyse statique (Coverity, Cppcheck)
– Contribution au framework : écriture/optimisation de pilotes pour FreeRTOS ou les internes d’ESP-IDF

2 – ESP-IDF (natif) ou Arduino-ESP32

Niveau : 1 – Débutant absolu
– Installer la toolchain ESP-IDF (Python, Git, scripts ESP-IDF) ou le core Arduino-ESP32
– Configurer VS Code (ou Arduino IDE) pour le développement ESP32
– Builder & flasher l’exemple « blink »
– Explorer la structure du projet (CMakeLists.txt, sdkconfig ou platformio.ini)
– Utiliser les commandes de base idf.py (ou Arduino) : build, clean, flash, monitor

Niveau : 2 – Débutant
– GPIO : configurer les broches, lire les entrées, piloter les LEDs
– ADC : échantillonner des canaux analogiques, convertir les valeurs brutes en tension
– UART & I²C : envoyer/recevoir des chaînes ou des octets simples
– Mode station Wi-Fi : scanner les AP, se connecter, récupérer l’IP
– Périphérique BLE : annoncer, se connecter depuis une appli téléphone
– Modifier menuconfig (table de partition, niveau de log) ou les paramètres de carte Arduino

Niveau : 3 – Intermédiaire
– Tâches FreeRTOS, files d’attente & timers dans le cadre ESP-IDF
– API d’événements Wi-Fi : gérer connect/disconnect, logique de reconnexion
– Client BLE & GATT : découvrir des services, lire/écrire des caractéristiques
– SPI & I²C : intégrer et étalonner un vrai capteur (par exemple, humidité du sol)
– Mises à jour OTA HTTP(S) : configurer les partitions, déclencher les mises à jour
– Utiliser esp_timer, logging détaillé (ESP_LOG*) et codes d’erreur

Niveau : 4 – Avancé
– Créer des composants réutilisables (CMake Component API) ou des bibliothèques Arduino personnalisées
– Construire une table de partition personnalisée & basculer les partitions au runtime
– Provisionnement sécurisé : SmartConfig, configuration Wi-Fi basée sur BLE
– Exemples BLE avancés (L2CAP, mesh)
– Optimiser le DMA SPI & la vitesse/durée des timeouts du bus I²C
– Intégrer mbedTLS pour MQTT over TLS
– Automatiser le build/flash/tests en CI (GitHub Actions, scripts ESP-IDF CI)

Niveau : 5 – Expert
– Contribuer de nouveaux pilotes ou corriger des bugs dans le core ESP-IDF (par exemple, calibration ADC)
– Développer un bootloader personnalisé ou des optimisations au niveau ISR
– Affiner les régions de heap FreeRTOS & les paramètres du scheduler
– Implémenter le secure boot & le chiffrement de flash de bout en bout
– Effectuer du tracing et profilage temps réel (ESP-Trace, Perfcnt)
– Architecturer des espaces de travail CMake multi-projets
– Encadrer les autres : définir les meilleures pratiques ESP-IDF et les bibliothèques de composants internes

3 – Fondamentaux FreeRTOS

Niveau : 1 – Débutant absolu
– Comprendre ce qu’est un RTOS et pourquoi l’utiliser
– Installer FreeRTOS (via ESP-IDF ou PlatformIO) et inspecter l’exemple de tâche « hello world »
– Apprendre l’API de base pour créer et démarrer une tâche (xTaskCreate, vTaskStartScheduler)
– Explorer le tick système et comment le scheduler bascule entre les tâches
– Utiliser vTaskDelay pour bloquer une tâche pendant un temps fixe

Niveau : 2 – Débutant
– Créer plusieurs tâches avec différentes priorités et tailles de pile
– Utiliser vTaskDelayUntil pour le timing périodique des tâches
– Comprendre et appliquer les sections critiques (taskENTER_CRITICAL / taskEXIT_CRITICAL)
– Apprendre les états des tâches (Running, Ready, Blocked, Suspended)
– Utiliser vTaskSuspend / vTaskResume pour un contrôle simple des tâches

Niveau : 3 – Intermédiaire
– Communiquer entre tâches avec des files d’attente (xQueueCreate, xQueueSend, xQueueReceive)
– Synchroniser les tâches avec des sémaphores binaires et à comptage (xSemaphoreCreateBinary, xSemaphoreTake)
– Coordonner des événements avec les Event Groups (xEventGroupSetBits, xEventGroupWaitBits)
– Utiliser les timers logiciels (xTimerCreate, callback)
– Détecter et gérer les débordements de pile

Niveau : 4 – Avancé
– Optimiser l’allocation mémoire : choisir et configurer les schémas de heap (heap_1…heap_5) et comprendre la fragmentation
– Employer les notifications de tâche comme sémaphores binaires légers ou messages directs vers une tâche
– Configurer et utiliser le mode tickless idle pour les applications basse consommation
– Générer et interpréter les statistiques d’exécution (vTaskGetRunTimeStats)
– Intégrer FreeRTOS+Trace ou Percepio Tracealyzer

Niveau : 5 – Expert
– Porter FreeRTOS vers du matériel personnalisé ou modifier la couche de portage pour des cas d’usage avancés
– Implémenter et régler des politiques de scheduling personnalisées ou des hook functions (vApplicationIdleHook, vApplicationMallocFailedHook)
– Concevoir des machines à états complexes en utilisant des primitives de synchronisation avancées (mutexes avec héritage de priorité, mutexes récursifs)
– Encadrer les équipes sur les meilleures pratiques, la sécurité (code conforme MISRA) et le réglage du comportement déterministe

4 – Git & GitHub/GitLab

Niveau : 1 – Débutant absolu
– Installer Git ; configurer user.name et user.email
– Initialiser un dépôt (git init) et cloner des dépôts existants (git clone)
– Suivi de fichier de base : git status, git add, git commit
– Voir l’historique avec git log, inspecter les changements avec git diff
– .gitignore simple pour exclure des fichiers

Niveau : 2 – Débutant
– Créer et basculer de branches : git branch, git checkout/git switch
– Configuration remote : git remote add, git fetch, git pull, git push
– Comprendre origin/main vs branches locales
– Résoudre des conflits de fusion simples via l’éditeur ou le CLI
– Utiliser l’interface web GitHub/GitLab pour parcourir les commits et branches

Niveau : 3 – Intermédiaire
– Merge vs rebase : git merge, git rebase ; savoir quand utiliser chacun
– Rebase interactif (git rebase -i) pour nettoyer l’historique
– Tagging : créer des tags annotés et légers ; pousser avec git push –tags
– Travailler avec les pull requests (GitHub) ou merge requests (GitLab) : créer, revoir, merger
– CI basique : ajouter un simple YAML GitHub Actions ou GitLab CI

Niveau : 4 – Avancé
– Gérer les sous-modules (git submodule) et les subtrees
– Écrire des hooks côté client (pre-commit, pre-push) et des hooks simples côté serveur GitLab/GitHub
– Protéger les branches et imposer les merge checks (status checks, approvals)
– Construire des pipelines CI/CD multi-étapes avec cache et artifacts
– Utiliser git bisect pour localiser des bugs ; cherry-pick des commits spécifiques

Niveau : 5 – Expert
– Administrer les paramètres d’organisation GitLab/GitHub : permissions utilisateur/groupe, branches protégées
– Architecturer des stratégies monorepo ; gérer les gros fichiers avec Git LFS
– Développer des outils ou scripts Git personnalisés (libgit2, hooks, automation)
– Plongée dans les internes de Git : stockage d’objets, packfiles, refs, index
– Définir et faire respecter des workflows (Gitflow, trunk-based, GitOps) ; encadrer l’équipe sur les meilleures pratiques

5 – VS Code

Niveau : 1 – Débutant absolu
Topics :

• Installer VS Code sur Windows, macOS ou Linux
• Explorer l’interface : Activity Bar, Side Bar, Editor Panes, Status Bar
• Ouvrir des dossiers et fichiers ; édition de texte de base (onglets, vues partagées)
• Utiliser le terminal intégré pour exécuter des commandes shell
• Invoquer la Palette de commandes (Ctrl+Shift+P) pour les actions courantes
• Effectuer un simple Rechercher & Remplacer (Ctrl+F / Ctrl+H)

Niveau : 2 – Débutant
Topics :

• Découvrir & installer des extensions : C/C++ (ms-vscode.cpptools), ESP-IDF, Arduino-ESP32, PlatformIO IDE
• Personnaliser les paramètres Utilisateur vs Espace de travail via settings.json
• Utiliser la vue Source Control intégrée : stage, commit, push/pull
• Configurer des Tasks de base (tasks.json) pour builder et flasher un « Hello World » ESP32
• Naviguer dans le code avec Outline et Breadcrumbs
• Insérer et utiliser des snippets de code simples

Niveau : 3 – Intermédiaire
Topics :

• Configurer IntelliSense : définir les include paths et macros dans c_cpp_properties.json
• Créer des configurations de lancement (launch.json) pour le débogage GDB via OpenOCD ou JTAG
• Définir des Tasks composites : build → flash → monitor → lint
• Travailler dans des workspaces multi-root (code + docs + tests)
• Intégrer les linters & formateurs (clang-format, cppcheck) comme actions pre-save
• Déboguer les tâches FreeRTOS avec du thread-aware debugging et la vue Debug
• Utiliser le panneau Problems et le Test Explorer pour les tests unitaires

Niveau : 4 – Avancé
Topics :

• Exploiter le Remote Development : SSH, WSL, et espaces de travail conteneurisés Docker
• Créer et partager des snippets de code personnalisés & des templates de fichier pour ESP-IDF/PlatformIO
• Automatiser la CI : exporter les Tasks VS Code vers GitHub Actions ou GitLab CI pipelines
• Personnaliser les raccourcis clavier et utiliser Settings Sync pour partager la configuration entre machines
• Développer des Task Providers réutilisables via l’API VS Code Tasks
• Utiliser les breakpoints conditionnels et fonctionnels, les logpoints, et les expressions watch

Niveau : 5 – Expert
Topics :

• Développer et publier des extensions VS Code complètes (TypeScript & Extension API) pour les workflows ESP32
• Architecturer de grands espaces de travail multi-projets avec des configurations partagées et versionnées
• Optimiser les performances de l’IDE : affiner l’activation des extensions, réduire le temps de démarrage et l’utilisation mémoire
• Implémenter la distribution de paramètres corporate-wide (Settings Cycler, déploiement basé sur GPO)
• Encadrer les coéquipiers sur les meilleures pratiques VS Code et dépanner des workflows complexes
• Contribuer à la communauté VS Code : écrire des guides, des dépôts d’exemples, et parler lors de meetups ou ateliers

6 – PlatformIO

Niveau : 1 – Débutant absolu
Topics :

• Installer l’extension PlatformIO IDE dans VS Code (ou installer PIO Core CLI)
• Créer un nouveau projet PlatformIO (pio init --board esp32dev)
• Inspecter la structure du projet : platformio.ini, src/, lib/
• Builder (pio run) et uploader (pio run --target upload) l’exemple « blink » par défaut
• Ouvrir le moniteur série (pio device monitor) pour voir la sortie

Niveau : 2 – Débutant
Topics :

• Utiliser le Library Manager : pio lib install, pio lib list, ajouter des bibliothèques dans platformio.ini
• Configurer plusieurs environnements (env: sections) pour différentes cartes ou modes de build
• Définir build_flags, monitor_speed, et upload_speed dans platformio.ini
• Exécuter des builds propres (pio run --target clean) et des builds verbeux (pio run --target verbose)
• Utiliser le Unified Debugger (pio debug) pour poser des breakpoints et stepper dans le code

Niveau : 3 – Intermédiaire
Topics :

• Gérer les builds Debug vs Release et les environnements OTA-enabled dans un seul platformio.ini
• Intégrer les tests unitaires avec le PlatformIO Test Runner et le framework Unity
• Ajouter l’analyse statique : activer cppcheck ou clang-tidy via extra scripts ou configs platformio.ini
• Automatiser des étapes pre- ou post-build en utilisant extra_scripts
• Publier et consommer des bibliothèques privées via le PlatformIO Registry

Niveau : 4 – Avancé
Topics :

• Créer et publier des packages Platforms et Boards personnalisés pour un usage interne ou communautaire
• Implémenter des protocoles d’upload avancés (JTAG, OTA, scripts d’upload personnalisés)
• Construire des pipelines CI utilisant les scripts pio ci pour GitHub Actions, GitLab CI ou Jenkins
• Générer et automatiser les rapports de couverture de code pour les tests unitaires
• Profiler la taille du firmware et l’utilisation RAM via le PlatformIO IDE Dashboard

Niveau : 5 – Expert
Topics :

• Contribuer des améliorations ou des correctifs au PlatformIO Core et aux Community Platforms officielles
• Développer des plugins PlatformIO personnalisés pour étendre les fonctionnalités CLI et IDE
• Architecturer et maintenir de grands espaces de travail monorepo ou multi-projets avec PIO Projects
• Écrire des build hooks avancés pour intégrer des toolchains et workflows de déploiement corporate
• Encadrer les équipes sur les meilleures pratiques PlatformIO et dépanner des problèmes complexes de build/débogage cross-plateforme

7 – Linux CLI / WSL

Niveau : 1 – Débutant absolu
Topics :

• Ouvrir un terminal sur Linux ou WSL
• Naviguer dans le système de fichiers : ls, cd, pwd, mkdir
• Voir et inspecter les fichiers : cat, less, head, tail
• Manipuler les fichiers : cp, mv, rm, touch
• Éditer du texte avec un éditeur simple (nano ou vim de base)

Niveau : 2 – Débutant
Topics :

• Permissions de fichier et propriété : chmod, chown, compréhension des bits rwx
• Wildcards, globbing, piping (|) et redirection (>, >>, <)
• Rechercher du texte dans les fichiers : bases de grep
• Gérer les variables d’environnement et votre profil shell (.bashrc, .profile)
• Installer et mettre à jour des packages avec le gestionnaire de packages de votre distribution (apt, yum, pacman)
• Se connecter à des hôtes distants via ssh et transférer des fichiers avec scp

Niveau : 3 – Intermédiaire
Topics :

• Écrire des scripts Bash : shebang, variables, boucles, conditions, fonctions
• Traitement de texte avec find, xargs, awk, sed
• Contrôle des processus et des jobs : ps, top/htop, kill, jobs, bg/fg
• Configurer les règles udev pour les adaptateurs USB/JTAG ESP32
• Invoquer les toolchains de cross-compilation et les systèmes de build (make, cmake, idf.py) depuis le CLI
• Exécuter OpenOCD depuis la ligne de commande pour flasher et déboguer via JTAG/SWD

Niveau : 4 – Avancé
Topics :

• Développer des scripts shell robustes : gestion d’erreurs, logging, tests unitaires (ShellCheck)
• Automatiser des pipelines complètes build–flash–test en shell et les intégrer dans la CI (GitHub Actions, GitLab CI)
• Conteneuriser votre environnement de build avec Docker ou Podman ; écrire des Dockerfiles pour des builds reproductibles
• Débogage et synchro à distance : ssh port forwarding, rsync, tmux/screen pour la persistance de session
• Profiler et déboguer les outils natifs : strace, ltrace, perf

Niveau : 5 – Expert
Topics :

• Builder et maintenir des kernels ou modules Linux personnalisés pour des cibles embarquées
• Architecturer et opérer des runners CI dédiés (bare-metal ou conteneurisés) optimisés pour les cross-compiles embarquées
• Implémenter des techniques avancées de cache et de build distribué (ccache, distcc)
• Concevoir vos propres frameworks CLI ou toolchains, gérer les dotfiles across teams (Git-driven)
• Encadrer les autres sur les meilleures pratiques d’utilisation du shell, les workflows basés sur le terminal, et l’automatisation des tâches de test & déploiement matériel

8 – Framework de tests unitaires (Unity / CppUTest)

Niveau : 1 – Débutant absolu
Topics :

• Comprendre le but et les avantages des tests unitaires
• Installer Unity ou CppUTest (via la bibliothèque PlatformIO, le package pip, ou depuis les sources)
• Créer un fichier de test minimal et inclure les headers du framework
• Écrire une fonction de test simple en utilisant la macro TEST (Unity) ou TEST_GROUP/TEST (CppUTest)
• Exécuter le test runner depuis la ligne de commande et interpréter la sortie PASS/FAIL
• Utiliser les macros d’assertion de base (par exemple, TEST_ASSERT, CHECK_EQUAL)

Niveau : 2 – Débutant
Topics :

• Organiser les tests en suites ou groupes
• Implémenter les fonctions setUp() et tearDown() pour les fixtures de test
• Utiliser une gamme plus large d’assertions : flottants, chaînes, comparaisons de mémoire
• Paramétrer les tests ou boucler sur des données de test
• Intégrer la compilation et l’exécution des tests dans votre build PlatformIO ou CMake
• Générer des données simples de couverture de code (par exemple via gcov) et visualiser les pourcentages de couverture de base

Niveau : 3 – Intermédiaire
Topics :

• Créer des stubs et des fakes pour les fonctions dépendantes du matériel (lectures I²C, conversions ADC)
• Introduire une bibliothèque de mocking (CppUMock ou CMock de Unity) pour simuler les dépendances
• Écrire des tests pour du code asynchrone : simuler des callbacks, des interruptions ou des timers FreeRTOS
• Automatiser les exécutions de tests avec des scripts shell ou un job CI basique
• Collecter et analyser des métriques de couverture détaillées (branche, fonction)
• Tester extensivement les conditions limites et d’erreur

Niveau : 4 – Avancé
Topics :

• Développer des implémentations de mock personnalisées pour les pilotes bas niveau et les abstractions de périphériques
• Utiliser les plugins de détection de fuite mémoire (CppUTest MemoryLeak detector)
• Porter le test runner sur l’appareil pour des tests unitaires on-target
• Écrire des tests pour les primitives de concurrence : sémaphores, files d’attente, notifications de tâches dans FreeRTOS
• Intégrer les rapports de couverture et de test dans un tableau de bord CI (sortie JUnit/XUnit XML)
• Employer des macros d’assertion avancées et des fonctionnalités de paramétrage de test

Niveau : 5 – Expert
Topics :

• Étendre ou personnaliser le framework de test : écrire des plugins, des reporters personnalisés ou de nouvelles macros d’assertion
• Architecturer une infrastructure de test scalable à travers plusieurs projets et plateformes
• Implémenter des bancs de test hardware-in-the-loop (HIL) ou firmware-in-the-loop (FIL) avec contrôle automatisé de gabarit
• Encadrer les équipes sur le TDD, les patterns de conception de tests, et faire respecter les politiques de test
• Contribuer aux projets open-source Unity ou CppUTest (corrections de bugs, nouvelles fonctionnalités)
• Optimiser l’exécution parallèle des tests, les environnements de test conteneurisés, et minimiser l’overhead du runtime des tests

9 – Intégration continue (GitHub Actions / GitLab CI)

Niveau : 1 – Débutant absolu
Topics :

• Apprendre ce qu’est l’Intégration Continue (CI) et pourquoi c’est important (build & test automatisés)
• Identifier les services CI populaires : GitHub Actions vs. GitLab CI
• Créer le fichier de config CI le plus simple (.github/workflows/ci.yml ou .gitlab-ci.yml)
• Ajouter un job qui checkout le code (actions/checkout ou git clone) et affiche un message hello
• Déclencher le workflow à chaque push sur la branche main et visualiser les logs de base dans l’interface web

Niveau : 2 – Débutant
Topics :

• Étendre le job CI pour installer les dépendances (par exemple, Python/pip, PlatformIO, ESP-IDF)
• Ajouter des étapes de build : compiler le firmware (idf.py build ou pio run)
• Exécuter les tests unitaires via pio test ou un test runner personnalisé et interpréter pass/fail
• Apprendre à lire et filtrer la sortie des logs pour les erreurs et avertissements
• Committer et pousser les changements pour déclencher la CI ; corriger des échecs de build simples

Niveau : 3 – Intermédiaire
Topics :

• Diviser build, test, lint et analyse statique en jobs ou stages séparés
• Utiliser les actions intégrées (ou templates GitLab) pour le cache des artifacts de toolchain (actions/cache)
• Implémenter un build matrix pour tester plusieurs cartes ou versions de toolchain en parallèle
• Archiver les artifacts de build (binaires firmware, rapports de test, données de couverture) en téléchargement
• Configurer les dépendances de jobs et l’exécution conditionnelle (needs: dans GitHub Actions, stage: dans GitLab CI)

Niveau : 4 – Avancé
Topics :

• Intégrer les outils de couverture de code (gcov, lcov) et publier des badges de couverture
• Automatiser les vérifications de taille et d’utilisation mémoire du firmware ; faire échouer si les seuils sont dépassés
• Déployer le firmware prêt pour OTA vers un appareil de staging via SSH ou runner personnalisé
• Gérer de manière sécurisée les secrets et tokens (GitHub Secrets, GitLab CI/CD variables)
• Utiliser des self-hosted runners ou des conteneurs Docker pour des environnements de build personnalisés

Niveau : 5 – Expert
Topics :

• Développer des actions CI réutilisables ou des images Docker optimisées pour les builds ESP32
• Architecturer des pipelines multi-projets : bibliothèques partagées, gestion des sous-modules, déclenchements cross-repo
• Implémenter des workflows avancés : previews de branches feature, canary deployments, rollbacks automatiques
• Faire respecter la conformité avec des politiques de branches protégées, des commits signés et des logs d’audit
• Encadrer et documenter les meilleures pratiques CI/CD à travers les équipes ; former au dépannage des échecs de pipeline complexes

10 – Jira & Confluence

Niveau : 1 – Débutant absolu
Topics :

• Comprendre le but du suivi des tickets vs. de la documentation
• S’inscrire à Jira Cloud (ou se connecter à une instance existante)
• Naviguer dans l’interface Jira : projets, tickets, backlog, board
• Créer un ticket de base : sélectionner le projet, le type de ticket, le résumé, la description
• Faire transiter un ticket à travers un workflow simple (To Do → In Progress → Done)
• Ajouter des commentaires et des pièces jointes à un ticket
• S’inscrire à Confluence (ou accéder à l’espace de votre équipe)
• Créer une page Confluence : titre, corps du texte, sauvegarder et éditer

Niveau : 2 – Débutant
Topics :

• Travailler avec différents types de tickets (Task, Bug, Story, Epic) et les champs de priorité
• Utiliser les boards Jira de base : Scrum et Kanban, déplacer les cartes entre les colonnes
• Filtrer les tickets avec du JQL simple (par exemple, project = “XYZ” AND status = “Open”)
• Configurer les notifications e-mail simples et surveiller des tickets
• Dans Confluence, organiser les pages en Spaces et hiérarchies parent-enfant
• Utiliser les macros courantes : Code Block, Table, Panel, Image
• Insérer des liens de tickets Jira et des listes de tickets dans les pages Confluence

Niveau : 3 – Intermédiaire
Topics :

• Personnaliser les écrans de ticket et ajouter des champs personnalisés
• Définir et modifier des workflows simples : statuts, transitions, validateurs
• Créer et partager des dashboards avec des gadgets (Filter Results, Burndown Chart)
• Écrire des requêtes JQL avancées pour des filtres et boards complexes
• Configurer les swimlanes du board par requêtes ou assignees
• Dans Confluence, créer et utiliser des Templates et Blueprints
• Gérer les permissions de page, les labels et les restrictions de page
• Utiliser les macros Include Page, Excerpt et Page Properties pour des rapports dynamiques

Niveau : 4 – Avancé
Topics :

• Construire des règles Jira Automation : triggers, conditions, actions (par exemple, auto-assign, envoyer des alertes)
• Mettre en place des SLAs, des service desks et suivre les métriques avec Jira Service Management
• Architecturer des boards multi-projets et des releases cross-projets
• Utiliser Portfolio for Jira (Advanced Roadmaps) pour planifier les timelines et dépendances
• Dans Confluence, créer des Blueprints personnalisés et des overrides de thème
• Intégrer du contenu dynamique : graphiques depuis Jira, diagrammes Gliffy, macros Live
• Analyser les analytics de page et l’activité des utilisateurs pour optimiser le contenu

Niveau : 5 – Expert
Topics :

• Administrer les paramètres globaux de Jira : permissions, schémas de types de tickets, schémas de workflow
• Concevoir des workflows complexes de niveau entreprise avec branchings, approvals et automation
• Intégrer Jira avec des outils externes (CI/CD, Slack, GitHub) via webhooks et apps
• Piloter l’implémentation ITSM : change management, incident/problem workflows
• Dans Confluence, développer des plugins personnalisés ou utiliser ScriptRunner pour l’automation
• Définir des templates d’espace, le look-and-feel global, et des schémas de permissions avancés
• Encadrer et former les équipes sur les meilleures pratiques et politiques de gouvernance Jira/Confluence

11 – Électronique numérique & analogique

Niveau : 1 – Débutant absolu
Topics :

• Comprendre les unités électriques de base : tension (V), courant (A), résistance (Ω), puissance (W)
• Apprendre la loi d’Ohm (V = I∙R) et les calculs de base en série/parallèle
• Identifier les composants passifs : résistances, condensateurs, inductances
• Utiliser un multimètre pour mesurer la tension, le courant et la résistance dans des circuits DC simples
• Lire et interpréter les symboles de circuits et les schémas de base

Niveau : 2 – Débutant
Topics :

• Construire et analyser des réseaux de résistances en série et en parallèle et des diviseurs de tension
• Introduire les condensateurs : courbes de charge/décharge, constantes de temps RC, filtres passe-bas/passe-haut simples
• Comprendre les niveaux de logique numérique (TTL vs CMOS) et comment ils se traduisent en GPIO ESP32
• Techniques de level shifting : diviseurs résistifs, level shifters à base de MOSFET pour signaux UART
• Utiliser des breadboards et des fils de liaison pour prototyper des circuits d’interface capteur

Niveau : 3 – Intermédiaire
Topics :

• Concevoir un front-end analogique pour capteurs : choix et configuration d’op-amps (inverseur, non-inverseur)
• Implémenter des amplificateurs d’instrumentation pour signaux différentiels de capteurs (par exemple, sondes NPK)
• Interfaçage ADC : comprendre la pleine échelle, la résolution, la fréquence d’échantillonnage et le choix de la tension de référence
• Fondamentaux EMI/EMC : condensateurs de découplage, stratégies de mise à la terre, règles de layout de base
• Analyser et atténuer le bruit : blindage, câblage torsadé, perles de ferrite

Niveau : 4 – Avancé
Topics :

• Créer des circuits de mesure de précision : méthodes d’étalonnage, compensation de la dérive thermique
• Conception avancée de filtres : topologies de filtres actifs (Butterworth, Bessel du deuxième ordre)
• Conception d’alimentation : sélection et layout de convertisseurs DC-DC, LDO, et découplage bulk/céramique
• Layout PCB pour signaux mixtes : séparation des masses analogique/numérique, traces à impédance contrôlée, mise à la terre en étoile
• Effectuer des vérifications de conformité EMI de base : sondage proche, techniques d’analyse spectrale

Niveau : 5 – Expert
Topics :

• Architecturer des front-ends analogiques bas bruit : solutions discrètes personnalisées, budget de bruit et sélection de composants
• Concevoir et intégrer des circuits intégrés mixtes : ADC/DAC haute résolution, isolation numérique, et optimisation du timing SPI/I²C
• Développer et valider des configurations de PMIC ou de circuits de gestion d’alimentation personnalisés pour appareils à batterie
• Diriger les efforts de certification EMI/EMC : rédaction des plans de test, interprétation des normes CE/FCC, tests de pré-conformité et remédiation
• Encadrer et revoir les conceptions analogiques & mix-signal de l’équipe, optimiser pour la fabricabilité, le coût et la fiabilité

12 – Conception PCB (KiCad / Altium)

Niveau : 1 – Débutant absolu
Topics :

• Comprendre ce qu’est un PCB et pourquoi on l’utilise (vs breadboard ou perfboard)
• Installer KiCad ou Altium Designer et explorer l’interface
• Créer un nouveau projet schématique et placer des composants de base (résistance, LED, connecteur)
• Exécuter l’Electrical Rules Check (ERC) pour attraper les erreurs évidentes de netlist
• Générer une netlist et l’importer dans un layout PCB vierge
• Placer les empreintes sur le contour de carte et router des traces simples en couche unique
• Exporter des fichiers Gerber et de perçage de base

Niveau : 2 – Débutant
Topics :

• Construire et gérer une bibliothèque personnelle de symboles et d’empreintes
• Définir et appliquer des design rules : largeurs de trace, clearances, anneaux de perçage
• Utiliser les plans de masse et d’alimentation pour simplifier le routage et améliorer la fiabilité
• Ajouter du texte silkscreen, les désignateurs de composants et les couches mécaniques de contour de carte
• Travailler avec des empreintes traversantes et de surface, en comprenant les pads et les réglages de soudure
• Exécuter le Design Rule Check (DRC) et corriger les erreurs de clearance/chevauchement courantes
• Générer un package de fabrication complet : Gerbers, perçage NC, BOM

Niveau : 3 – Intermédiaire
Topics :

• Créer des schémas multi-feuilles (hiérarchiques) et gérer la connectivité des nets
• Définir un stackup contrôlé pour des cartes 4 ou 6 couches, incluant les épaisseurs diélectriques
• Router des paires différentielles et des paires à longueur égale (USB, SPI, lignes haute vitesse)
• Utiliser une gestion avancée des plans : split planes, thermal reliefs, zones de remplissage
• Intégrer des modèles 3D pour les vérifications d’encombrement avec le boîtier
• Automatiser la génération de BOM avec des champs personnalisés et export vers CSV ou Excel
• Collaborer via Git (ou SVN) sur les fichiers de projet PCB et gérer l’historique des versions

Niveau : 4 – Avancé
Topics :

• Design for manufacturability (DFM) : panélisation, fiduciels, dessins d’assemblage
• Pratiques d’intégrité de signal haute vitesse : contrôle d’impédance, stitching de vias, chemins de retour
• Créer et réutiliser des templates de projet avec des design rules et des stackups de couches corporate-wide
• Effectuer des analyses thermiques et de distribution de puissance de base dans l’outil ECAD
• Écrire et exécuter des scripts (Python dans KiCad ou scripts Altium) pour automatiser les tâches répétitives
• Développer et gérer des bibliothèques de composants centralisées avec des états de cycle de vie et des variantes approuvées
• Intégrer les données ECAD avec la CAO mécanique pour de l’ingénierie simultanée

Niveau : 5 – Expert
Topics :

• Architecturer des systèmes rigid-flex et multi-cartes (backplane), définir les zones de flexion et les renforts
• Diriger des revues de conception axées sur DFM, DFA (assemblage) et DFT (test), et encadrer les concepteurs juniors
• Développer des empreintes conformes IPC et créer une documentation de standards internes
• Guider l’intégration PLM/ERP pour la gestion du cycle de vie des pièces et les workflows d’approvisionnement
• Planifier et exécuter les packages de certification (UL, CE, FCC) avec toute la documentation requise
• Optimiser les fonctionnalités avancées : vias enterrés/aveugles, impédance contrôlée, conceptions HDI avec microvias
• Contribuer ou personnaliser des plugins d’outils ECAD et construire des pipelines automatisés de validation des données pour le fabricant

13 – Budget énergétique & charge solaire-Li-ion

Niveau : 1 – Débutant absolu
Topics :

• Comprendre la relation entre tension, courant et puissance (P = V × I)
• Apprendre les caractéristiques de base des batteries Li-ion : tension nominale (~3,7 V), capacité (mAh/Ah), plages de tension sûres
• Utiliser un multimètre pour mesurer tension et courant dans des circuits simples alimentés par batterie
• Identifier les rails d’alimentation de base sur une carte ESP32 et lire leurs étiquettes (5 V, 3,3 V)
• Se familiariser avec un petit panneau solaire : spécifications de tension en circuit ouvert (Voc) et de courant de court-circuit (Isc)

Niveau : 2 – Débutant
Topics :

• Construire un tableur simple de budget énergétique : lister chaque sous-système (ESP32, capteur, radio) avec son courant de fonctionnement et son duty cycle
• Calculer les courants moyen et de crête ; estimer l’autonomie sur une capacité de batterie donnée
• Comparer les régulateurs linéaires (LDO) vs régulateurs à découpage simples pour abaisser à 3,3 V
• Câbler un circuit intégré de charge Li-ion de base (par exemple, MCP73831) sur une breadboard et observer le comportement de la LED de charge
• Mesurer la sortie du panneau sous différents niveaux de lumière et apprendre à lire les courbes de sa datasheet

Niveau : 3 – Intermédiaire
Topics :

• Introduire les concepts de Maximum Power Point Tracking (MPPT) : pourquoi le MPPT améliore la récolte d’énergie vs ombrage passif
• Sélectionner et configurer un contrôleur de charge solaire tout fait (par exemple, Adafruit Solar LiPo Charger)
• Dimensionner le panneau solaire et la batterie pour l’autonomie cible et les pires conditions météo ; inclure des marges de sécurité
• Concevoir un circuit à double entrée d’alimentation : batterie plus solaire, avec ORing à diode idéale ou diodes Schottky
• Implémenter des états de firmware basse consommation (deep sleep, light sleep) et mesurer le courant de quiescence

Niveau : 4 – Avancé
Topics :

• Évaluer et choisir entre différents circuits intégrés ou modules MPPT pour usage embarqué (par exemple, STSPIN, série TI BQ)
• Concevoir un arbre d’alimentation PCB personnalisé : convertisseurs buck/boost, interrupteurs de charge, indicateurs power-good
• Modéliser les courbes de charge/décharge et les effets thermiques ; simuler dans SPICE ou un tableur
• Implémenter une gestion dynamique de l’alimentation dans le firmware : adapter la fréquence d’échantillonnage ou le duty cycle radio en fonction du SoC de la batterie
• Ajouter des protections matérielles : surtension, sous-tension, surintensité et surveillance de température

Niveau : 5 – Expert
Topics :

• Architecturer un algorithme MPPT entièrement personnalisé dans le firmware ou un FPGA, réglé pour les profils solaires locaux
• Développer ou modifier le firmware d’un circuit de gestion d’alimentation (par exemple, pour un BMS personnalisé) et optimiser pour une efficacité > 98 %
• Diriger la conception pour le harvesting d’énergie en environnement extrême : faible luminosité, températures extrêmes, analyse d’ombrage partiel
• Intégrer des diagnostics avancés de santé de batterie : coulométrie, suivi d’impédance, algorithmes prédictifs de SoC/SoH
• Encadrer les équipes sur les compromis des systèmes d’alimentation, préparer la documentation pour les certifications de sécurité UL/IEC, et optimiser pour le rendement et la fiabilité en fabrication

14 – Gestion de batterie (18650)

Niveau : 1 – Débutant absolu
Topics :

• Apprendre les spécifications de base des cellules Li-ion 18650 : tension nominale, capacité, courant max de charge/décharge
• Comprendre la sécurité de base des cellules : pas de court-circuit, polarité correcte, éviter la sur-décharge
• Mesurer la tension de la cellule avec un multimètre ; reconnaître les points pleine (4,2 V) vs vide (≈3,0 V)
• Identifier les fonctionnalités courantes des circuits de protection : coupure sur/sous-tension, surintensité
• Pratiquer la manipulation sûre : utiliser un support approprié, ne jamais percer ou écraser les cellules

Niveau : 2 – Débutant
Topics :

• Câbler un module chargeur simple à une seule cellule (par exemple, TP4056) et surveiller les LEDs d’état de charge
• Comprendre le profil de charge CC-CV : courant constant jusqu’au seuil, puis tension constante en décroissance
• Ajouter un PCB de protection à la cellule : comprendre comment fonctionne la protection à base de MOSFET
• Lire les courbes de charge/décharge de la datasheet de la cellule et les directives de dérating
• Calculer grossièrement l’état de charge (SoC) à partir de la courbe tension vs SoC

Niveau : 3 – Intermédiaire
Topics :

• Introduire les bases de la coulométrie : mesurer la charge entrante/sortante via une résistance de shunt et un ADC
• Sélectionner et intégrer un amplificateur de détection de courant (par exemple, INA219) ou un circuit intégré coulomb-counter dédié
• Étalonner votre système de coulométrie : offset, gain et compensation de dérive
• Combiner le SoC basé sur la tension et la coulométrie pour améliorer la précision
• Implémenter des vérifications de santé de batterie de base : comptage de cycles, estimation de la dégradation de capacité

Niveau : 4 – Avancé
Topics :

• Concevoir un circuit de charge équilibrée multi-cellules (2–4 cellules) avec résistances d’équilibrage ou circuit intégré d’équilibrage actif
• Intégrer un circuit intégré BMS complet (par exemple, série TI BQ769x0) : sur/sous-tension, surintensité, surveillance de température
• Implémenter des algorithmes SoC et SoH dans le firmware : filtre de Kalman ou compteur de coulombs adaptatif
• Ajouter une sonde de température (NTC ou numérique) et une compensation pour les courbes de charge/décharge
• Valider la sécurité en conditions de défaut : simuler court-circuit, surintensité, surtempérature, et journaliser les événements de défaut

Niveau : 5 – Expert
Topics :

• Architecturer un firmware BMS personnalisé : algorithmes avancés d’équilibrage de cellules, profils de charge adaptatifs
• Optimiser la précision de la coulométrie sur le long terme : correction de dérive, compensation de température, algorithmes auto-apprenants
• Diriger les efforts de certification : documentation et création de plans de test IEC 62133, UL 2054, UN 38.3
• Concevoir des fonctionnalités de sécurité redondantes : surveillance double circuit intégré, watchdogs, états de sécurité matériels
• Encadrer et revoir les conceptions de sous-système batterie : analyse des modes de défaillance, fabricabilité, et plans de tests de fiabilité

15 – Comms cellulaires (SIMCom AT, PPP, TCP/IP)

Niveau : 1 – Débutant absolu
Topics :

• Apprendre les concepts cellulaires de base : GSM vs LTE vs NB-IoT
• Identifier le brochage de la carte SIM et comment insérer/éjecter la SIM
• Alimenter et câbler un module SIMCom à un microcontrôleur ou à un adaptateur USB-to-UART
• Ouvrir un terminal série (minicom, PuTTY) au bon débit en bauds
• Envoyer des commandes AT simples : AT, ATI, AT+CSQ
• Interpréter les réponses : OK, ERROR, et codes de qualité de signal de base

Niveau : 2 – Débutant
Topics :

• Vérifier l’enregistrement réseau : AT+CREG? et AT+CGREG?
• Configurer le contexte PDP : AT+CGDCONT=1,”IP”,””
• Utiliser PPP pour établir une liaison IP : écrire un chat script et invoquer pppd
• Vérifier la connectivité IP via PPP : pinger un hôte connu ou utiliser un outil de test de socket
• Envoyer et lire des SMS : AT+CMGF=1, AT+CMGS=””, AT+CMGR=
• Gérer les codes d’erreur de base : lire et décoder +CME ERROR:

Niveau : 3 – Intermédiaire
Topics :

• Ouvrir et gérer des sockets TCP : AT+CIPSTART=”TCP”,”host”,”port”
• Envoyer et recevoir des données sur le socket : AT+CIPSEND et AT+CIPRXGET
• Surveiller les codes de résultat non sollicités (URCs) : +CIPSTATUS, +TCP_CLOSED
• Implémenter une logique de reconnexion automatique dans le firmware quand le socket ou PPP tombe
• Utiliser les modes de veille du module pour économiser l’énergie : AT+CFUN, AT+CSCLK
• Sécuriser la liaison avec des commandes TLS de base si supporté (par exemple, AT+SSLOPT)

Niveau : 4 – Avancé
Topics :

• Intégrer le montage PPP dans des tâches RTOS avec des callbacks d’événement sur connect/disconnect
• Gérer plusieurs APNs et contextes de fallback pour la résilience en roaming
• Exécuter un client MQTT sur le socket cellulaire en utilisant des commandes AT
• Interroger les données GNSS/localisation si le module le supporte : AT+CGPS=1, AT+CGPSINFO
• Profiler le débit et la latence : mesurer les débits de données et optimiser le buffering du firmware
• Diagnostiquer les problèmes RF et réseau en utilisant des commandes d’info réseau étendues (par exemple, AT+QENG)

Niveau : 5 – Expert
Topics :

• Développer ou optimiser une bibliothèque d’analyse de commandes AT avec des machines à états et un buffering robuste
• Concevoir un daemon PPP personnalisé ou une pile IP légère pour systèmes profondément embarqués
• Implémenter l’intégration au niveau pilote : transferts UART basés sur DMA, contrôle de flux matériel
• Supporter des modes de données avancés : sockets bruts, multicast/broadcast UDP, mode données SMS
• Gérer le provisionnement sécurisé des certificats dans le flash et la gestion end-to-end des sessions TLS
• Encadrer les équipes sur les meilleures pratiques de l’IoT cellulaire : optimisation des coûts, conformité réglementaire, et considérations d’antenne/RF

16 – Protocoles IoT (MQTT / HTTPS)

Niveau : 1 – Débutant absolu
Topics :

• Comprendre ce que sont les protocoles IoT et pourquoi ils importent pour les appareils contraints
• Apprendre les bases de MQTT : modèle publish/subscribe, rôle du broker, topics, niveaux QoS (0, 1, 2)
• Apprendre les bases de HTTPS : requête/réponse client-serveur, principes REST, URLs, méthodes (GET, POST)
• Installer un client MQTT desktop (MQTT.fx, MQTT Explorer) et se connecter à un broker public (par exemple, test.mosquitto.org )
• Utiliser curl pour faire des requêtes HTTPS GET simples vers des API publiques

Niveau : 2 – Débutant
Topics :

• Écrire du firmware pour connecter un ESP32 à un broker MQTT en utilisant une bibliothèque simple (par exemple, PubSubClient pour Arduino ou esp_mqtt_client pour ESP-IDF)
• Publier des lectures de capteurs vers un topic de test ; s’abonner et journaliser les messages d’un autre topic
• Construire des payloads JSON de base et parser les JSON entrants dans le firmware
• Effectuer des requêtes HTTPS depuis l’ESP32 : configurer HTTPClient (Arduino) ou esp_http_client (ESP-IDF)
• Gérer la validation de certificat à un niveau basique (utiliser le mode insecure pour commencer, puis passer à une root CA correcte)

Niveau : 3 – Intermédiaire
Topics :

• Implémenter la persistance de session MQTT : messages retain, clean session = false
• Utiliser le Last Will and Testament (LWT) MQTT pour signaler les déconnexions inattendues
• Organiser les hiérarchies de topics avec des wildcards (+, #) pour une messagerie d’appareils scalable
• Gérer les certificats TLS dans le flash : convertir PEM en DER, embarquer dans la partition
• Gérer les requêtes HTTPS POST avec des corps JSON et parser les réponses JSON ; gérer les headers

Niveau : 4 – Avancé
Topics :

• Concevoir et implémenter une architecture MQTT sécurisée : certificats clients, authentification mutuelle TLS
• Optimiser les performances MQTT : batcher les publications, utiliser le QoS de manière appropriée, minimiser l’overhead keepalive
• Implémenter l’authentification mutuelle HTTPS (certificats clients) et gérer la rotation des certificats
• Intégrer MQTT over WebSockets pour des tableaux de bord basés sur navigateur ou des réseaux contraints
• Construire un client REST stateful léger sur ESP32 avec retry, backoff et patterns de circuit breaker

Niveau : 5 – Expert
Topics :

• Architecturer un pont de protocole personnalisé : traduire entre CoAP, MQTT et HTTPS pour des réseaux IoT hétérogènes
• Développer un plugin ou une extension de broker MQTT maison pour l’autorisation, le filtrage ou la transformation personnalisés
• Prototyper et évaluer des protocoles IoT alternatifs (par exemple, MQTT-SN, AMQP, LwM2M) pour des cas d’usage spécialisés
• Diriger des audits de sécurité : threat modeling, évaluations de vulnérabilité des piles de communication IoT
• Encadrer les équipes sur la conception de architectures de messagerie IoT à grande échelle, sécurisées et résilientes avec des protocoles hybrides

17 – TLS / bases de sécurité mbedTLS

Niveau : 1 – Débutant absolu
Topics :

• Apprendre les concepts cryptographiques de base : plaintext vs ciphertext, chiffrement symétrique vs asymétrique, hachage
• Comprendre ce que fournit TLS : confidentialité, intégrité, authenticité
• Étudier le flux de handshake TLS de haut niveau : ClientHello, ServerHello, échange de clés, record layer
• Installer mbedTLS et explorer le répertoire d’exemples programs/ssl
• Builder et exécuter les exemples ssl_client1 et ssl_server2 sur votre desktop

Niveau : 2 – Débutant
Topics :

• Configurer mbedTLS via config.h : activer seulement les modules nécessaires (SSL/TLS, X.509, primitives crypto)
• Générer un certificat et une clé auto-signés avec OpenSSL ; convertir entre les formats PEM et DER
• Modifier et exécuter ssl_client2 pour effectuer un HTTPS GET contre un serveur public
• Définir la version TLS minimale et choisir des cipher suites de base dans la configuration SSL
• Activer le logging de débogage mbedTLS pour tracer les étapes du handshake et les codes d’erreur

Niveau : 3 – Intermédiaire
Topics :

• Implémenter l’authentification PSK (Pre-Shared Key) dans mbedTLS pour les appareils contraints
• Embarquer des certificats et des clés dans le flash ou les lire depuis une partition de filesystem au runtime
• Utiliser le parseur X.509 de mbedTLS pour valider les certificats serveur contre un bundle de root CA
• Amorcer le générateur de nombres aléatoires avec un TRNG matériel (par exemple, esp_hardware_poll de l’ESP32) via mbedtls_ctr_drbg
• Intégrer mbedTLS comme composant dans ESP-IDF et invoquer des connects TLS depuis une tâche FreeRTOS

Niveau : 4 – Avancé
Topics :

• Implémenter le mTLS (certificats client et serveur) dans un environnement embarqué
• Concevoir un mécanisme de rotation de certificats avec protection de rollback du firmware
• Optimiser l’empreinte mémoire : désactiver les modules inutilisés, régler l’utilisation heap vs stack dans mbedtls_platform_set_calloc_free
• Se brancher sur un accélérateur crypto matériel (délégation RSA/ECC) et l’enregistrer auprès de la couche PK de mbedTLS
• Stocker les clés privées de manière sécurisée : utiliser le chiffrement de flash ou un élément sécurisé externe (ATECC608A)

Niveau : 5 – Expert
Topics :

• Contribuer des correctifs ou de nouvelles fonctionnalités au core mbedTLS (par exemple, ajouter une nouvelle cipher suite ou améliorer le code constant-time)
• Effectuer des audits de sécurité et du fuzz testing sur le handshake et les primitives crypto
• Construire une configuration mbedTLS conforme FIPS 140-2 et documenter la validation des modules
• Développer des implémentations résistantes aux attaques par canaux auxiliaires et durcir contre les attaques par timing ou analyse de puissance
• Définir et encadrer sur les politiques de sécurité de niveau entreprise : threat modeling, gestion du cycle de vie des clés, processus de divulgation de vulnérabilités

18 – Calibration & compensation des capteurs

Niveau : 1 – Débutant absolu
Topics :

• Comprendre ce que signifient « calibration de capteur » et « compensation » et pourquoi c’est important
• Apprendre à lire les valeurs ADC brutes d’un capteur en code (par exemple, adc1_get_raw)
• Journaliser les sorties brutes du capteur à des conditions ambiantes en utilisant le serial print ou un simple data logger
• Se familiariser avec les étalons de base : résistances fixes connues, tensions de référence connues
• Tracer les lectures brutes vs valeurs attendues dans un tableur pour voir la linéarité ou les erreurs d’offset

Niveau : 2 – Débutant
Topics :

• Effectuer un étalonnage à deux points (offset & gain) : collecter des lectures à deux concentrations ou charges connues
• Calculer et implémenter une simple formule de mapping linéaire dans le firmware
• Documenter les étapes et résultats d’étalonnage : inclure les conditions de test (température, humidité)
• Introduire des métriques d’erreur : erreur moyenne, écart-type, erreur max
• Automatiser la collecte des données d’étalonnage avec des scripts ou des commandes shell simples

Niveau : 3 – Intermédiaire
Topics :

• Caractériser la réponse du capteur sur toute sa plage avec des données multi-points (au moins 5–10 points)
• Ajuster des courbes d’ordre supérieur (régression polynomiale) ou des segments linéaires par morceaux dans un outil comme Python ou Excel
• Implémenter la compensation de température et d’humidité : lire les capteurs environnementaux et appliquer des formules de correction
• Valider la compensation en comparant les readings compensées contre des instruments de référence dans différentes conditions
• Stocker les coefficients d’étalonnage en mémoire non volatile (mémoire RTC, partition NVS, ou flash)

Niveau : 4 – Avancé
Topics :

• Développer des protocoles d’étalonnage robustes : randomiser l’ordre des tests, contrôler les variables environnementales, journaliser les métadonnées
• Utiliser des techniques statistiques : détection d’outliers, intervalles de confiance, études de répétabilité/reproductibilité
• Automatiser les routines d’étalonnage sur l’appareil : mode d’étalonnage interactif avec prompts utilisateur
• Implémenter des routines d’auto-étalonnage ou d’auto-zéro pour éliminer la dérive pendant les déploiements longs
• Gérer et versionner les données d’étalonnage dans un backend ou une base de données d’étalonnage

Niveau : 5 – Expert
Topics :

• Architecturer des algorithmes de compensation multivariés (par exemple, en utilisant la fusion de capteurs ou des régresseurs machine-learning pour des interférences croisées complexes)
• Concevoir et construire des bancs d’étalonnage automatisés ou des gabarits de test pour l’étalonnage en haut volume de production
• Définir et faire respecter des standards et procédures d’étalonnage (documentation de style ISO 17025)
• Surveiller la dérive d’étalonnage sur le terrain et déclencher à distance le ré-étalonnage ou les mises à jour de firmware
• Encadrer et former l’équipe sur les concepts avancés de métrologie ; publier des directives internes d’étalonnage et des white papers

19 – Journalisation de données & stockage OTA

Niveau : 1 – Débutant absolu
Topics :

• Apprendre ce que signifie le stockage persistant sur un ESP32 et pourquoi il est utile pour la journalisation ou le staging OTA
• Comprendre la différence entre les systèmes de fichiers en flash interne (SPIFFS, LittleFS) et les cartes SD externes
• Monter SPIFFS dans Arduino (SPIFFS.begin()) ou ESP-IDF (esp_vfs_spiffs_register)
• Lister les fichiers, ouvrir un fichier en écriture ("w"), écrire une ligne, fermer, puis rouvrir en lecture et afficher le contenu
• Initialiser et monter une carte SD (Arduino SD.begin(), ESP-IDF esp_vfs_fat_sdspi_mount), ouvrir un fichier et faire des read/write de base

Niveau : 2 – Débutant
Topics :

• Utiliser le mode append ("a") pour ajouter de nouvelles entrées de log sans écraser les données existantes
• Parcourir les répertoires : ouvrir des répertoires, lire les noms de fichiers, filtrer par extension ou horodatage
• Configurer la taille de partition SPIFFS/LittleFS dans platformio.ini ou sdkconfig, reflasher et vérifier
• Explorer les différences de LittleFS : montages plus rapides, wear leveling intégré, opérations de métadonnées
• Détecter et gérer les erreurs de montage, vérifier l’espace libre avant d’écrire, récupérer un système de fichiers corrompu

Niveau : 3 – Intermédiaire
Topics :

• Implémenter la rotation des logs : quand un fichier dépasse un seuil de taille ou d’âge, le fermer et en commencer un nouveau ; supprimer les plus anciens
• Journaliser efficacement des données binaires de capteurs : sérialiser des structs ou des floats, écrire/relire en mémoire
• Monter et utiliser FAT sur SD avec support des longs noms de fichiers ; gérer plusieurs partitions SD
• Créer une couche d’abstraction pour que votre code puisse basculer entre SPIFFS, LittleFS ou SD par configuration
• Stager de gros chunks de données ou de firmware dans une partition dédiée « ota_data » en utilisant des écritures flash brutes

Niveau : 4 – Avancé
Topics :

• Comprendre et éditer la table de partition ESP32 : entrées factory, ota_0, ota_1, data (spiffs/littlefs)
• Utiliser les API OTA d’ESP-IDF : esp_ota_begin(), esp_ota_write(), esp_ota_end(), esp_ota_set_boot_partition()
• Télécharger et écrire une image firmware complète dans la partition OTA inactive, vérifier son intégrité, basculer le boot
• Gérer les mises à jour interrompues : détecter les écritures partielles, revenir à la dernière version firmware connue comme bonne
• Optimiser la résilience du système de fichiers : utiliser des opérations de fichier atomiques, des stratégies de journalisation ou du double-buffering

Niveau : 5 – Expert
Topics :

• Concevoir des layouts de partition personnalisés : plusieurs partitions de données, redimensionnement dynamique, intégration de flash off-chip
• Implémenter des systèmes de fichiers chiffrés et/ou compressés pour sécuriser les données au repos et réduire l’usure
• Développer des mises à jour delta-OTA ou basées sur des patches pour minimiser la taille de téléchargement et le temps de mise à jour
• Construire des bancs de test automatisés pour simuler la corruption du système de fichiers et valider les flux de récupération OTA
• Encadrer sur les meilleures pratiques : alignement des partitions, gestion de l’usure du flash, intégration du secure boot et gestion complète du cycle de vie des données stockées et des mises à jour de firmware

20 – Flux de mise à jour OTA à distance

Niveau : 1 – Débutant absolu
Topics :

• Comprendre ce que sont les mises à jour OTA (Over-The-Air) et pourquoi elles sont utiles
• Explorer un exemple OTA simple dans Arduino (ArduinoOTA) ou ESP-IDF (ota_https_simple)
• Configurer votre environnement de développement pour activer l’OTA : inclure la bibliothèque/composant OTA
• Flasher l’exemple « blink » avec OTA activé et confirmer qu’il annonce un service ou un point de terminaison HTTP
• Déclencher une mise à jour OTA manuelle depuis VS Code ou l’Arduino IDE et observer le redémarrage du firmware

Niveau : 2 – Débutant
Topics :

• Héberger un binaire firmware sur un serveur HTTP(S) local ou un simple serveur de fichiers
• Écrire du code firmware pour récupérer le manifest de version ou l’URL du binaire via HTTP en utilisant HTTPClient ou esp_http_client
• Télécharger et appliquer la mise à jour vers la partition secondaire en utilisant l’API OTA d’ESP-IDF (esp_ota_begin, esp_ota_write, esp_ota_end)
• Vérifier l’intégrité de la nouvelle image en utilisant les checksums intégrés ou les headers HTTP ETag
• Implémenter un rollback de base : si le nouveau firmware ne boot pas ou signale une erreur, revenir à la partition précédente

Niveau : 3 – Intermédiaire
Topics :

• Automatiser les déclencheurs OTA : vérifier les mises à jour au boot ou sur des timers périodiques, comparer la version actuelle au manifest
• Sécuriser le canal de mise à jour : passer de HTTP à HTTPS, valider les certificats serveur, épingler les CA dans le flash
• Supporter le delta-OTA (diffs binaires) pour réduire la taille de téléchargement : intégrer et appliquer des patches plutôt que des images complètes
• Utiliser MQTT ou MQTT-SN pour notifier les appareils des mises à jour disponibles et contrôler le déploiement par appareil ou par groupe
• Stocker les métadonnées de mise à jour (version, horodatage, statut) dans le stockage non volatile (NVS) pour l’audit

Niveau : 4 – Avancé
Topics :

• Intégrer avec un service OTA cloud (par exemple, AWS IoT Device Management, Azure IoT Hub) via leurs APIs REST/MQTT
• Implémenter des déploiements progressifs : déployer d’abord vers un petit pourcentage d’appareils, surveiller la santé, puis étendre le déploiement
• Concevoir un schéma de partitions A/B avec golden image fallback et health checks automatisés au démarrage
• Automatiser les pipelines de build, signature et publication de firmware dans CI/CD ; embarquer les signatures et vérifier dans l’appareil
• Gérer les mises à jour multi-composants (bootloader, table de partition, application, filesystem) dans une seule transaction

Niveau : 5 – Expert
Topics :

• Architecturer un backend de gestion OTA personnalisé : versioning, groupes d’appareils, mises à jour différentielles, intégration de télémétrie
• Implémenter la sécurité end-to-end : signature de code avec des clés asymétriques, intégration du secure boot, protection contre le replay
• Optimiser les mécanismes de mise à jour pour les réseaux à faible bande passante ou intermittents : livraison par chunks, reprise du téléchargement, contrôle de débit adaptatif
• Construire des chemins de mise à jour redondants : plusieurs serveurs, partage peer-to-peer, stratégies de fallback CDN
• Encadrer les équipes sur les meilleures pratiques : conformité aux normes industrielles (par exemple, IEC 62443), gestion robuste des erreurs, et gestion complète du cycle de vie des versions de firmware

21 – Théorie du contrôle & de l’estimation

Niveau : 1 – Débutant absolu
Topics :

• Saisir l’idée de base d’une boucle de contrôle : consigne, mesure et erreur
• Différencier les systèmes en boucle ouverte vs boucle fermée
• Implémenter un simple contrôleur on/off (bang-bang) en pseudocode ou en C
• Comprendre la notion de réponse du système : rise time, overshoot, settling time (conceptuel)
• Apprendre ce que signifie « estimation » : utiliser des mesures bruitées pour inférer une valeur vraie

Niveau : 2 – Débutant
Topics :

• Dériver et coder un contrôleur proportionnel (P) : output = Kₚ·error
• Ajouter les termes intégral (I) et dérivé (D) pour construire un contrôleur PID ; régler Kₚ, Kᵢ, K_d par essai-erreur
• Implémenter un filtre passe-bas du premier ordre (discret) pour des lectures de capteurs bruitées
• Modéliser des systèmes simples sous forme d’équations aux différences (par exemple, circuit RC discret)
• Écrire un filtre moving-average ou un lissage exponentiel dans le firmware

Niveau : 3 – Intermédiaire
Topics :

• Représenter des systèmes sous forme d’espace d’état (ẋ = Ax + Bu ; y = Cx + Du) et discrétiser pour le firmware
• Concevoir et implémenter un filtre de Kalman discret pour un modèle à vitesse constante 1D
• Analyser la stabilité d’un système contrôlé par PID avec le lieu des racines ou les diagrammes de Bode (MATLAB/Python)
• Implémenter l’anti-windup pour le terme I et le filtrage dérivé dans un algorithme PID
• Embarquer le code de contrôle & estimation dans des tâches FreeRTOS avec un timing déterministe

Niveau : 4 – Avancé
Topics :

• Concevoir des contrôleurs par retour d’état optimal (LQR) et des observateurs de Kalman discrets
• Étendre aux Filtres de Kalman Étendus (EKF) pour les systèmes non linéaires (par exemple, cinématique simple d’un robot mobile)
• Effectuer une conception dans le domaine fréquentiel : marge de gain & phase, filtres notch, réglage PID par méthodes de Ziegler–Nichols et relais
• Coder un prototype de MPC (model predictive control) en C ou C++, avec un petit horizon
• Profiler le temps d’exécution et la mémoire des boucles de contrôle ; optimiser pour les contraintes temps réel

Niveau : 5 – Expert
Topics :

• Architecturer des schémas de contrôle non linéaires : sliding-mode, contrôle adaptatif, contrôleurs robustes H∞
• Diriger le développement de bibliothèques EKF/UKF personnalisées ou de solveurs MPC pour des cibles embarquées
• Encadrer l’équipe sur l’estimation avancée : fusion multi-capteurs (IMU + GPS + sondes de sol) en utilisant des techniques SLAM
• Publier des directives internes sur les meilleures pratiques de contrôle/estimation et la vérification de sécurité
• Contribuer de nouveaux algorithmes ou des améliorations aux projets open-source de contrôle/estimation ou à des articles académiques

22 – Scripts Python / Bash

Niveau : 1 – Débutant absolu
Topics :

• Installer Python 3 et pip ; vérifier avec python3 --version et pip3 --version
• Ouvrir un shell bash ; exécuter bash --version
• Créer et exécuter un script « hello world » Python (hello.py) et un script bash simple (hello.sh)
• Ajouter des shebangs (#!/usr/bin/env python3 et #!/usr/bin/env bash) et rendre les scripts exécutables (chmod +x)
• Utiliser les commandes bash de base : echo, ls, pwd, cd ; et print() de Python, assignations simples de variables

Niveau : 2 – Débutant
Topics :

• Types de données Python (int, float, string, list, dict) et flux de contrôle (if, for, while) ; définir des fonctions simples
• Variables bash, paramètres positionnels ($1, $2), règles de quoting, if [ ] et boucles for de base
• Fichier I/O : open/read/write en Python ; redirection (>, >>) et lecture de lignes en bash (while read)
• Importer et utiliser les modules intégrés de Python (os, sys) ; sourcer des scripts bash assistants plus petits avec source
• Gestion d’erreurs de base : try/except en Python ; set -e et trap '…' ERR en bash

Niveau : 3 – Intermédiaire
Topics :

• Environnements virtuels Python (python3 -m venv), requirements.txt, installer des packages tiers via pip
• Parsing d’arguments bash en utilisant getopts ou getopt et écrire des fonctions bash réutilisables
• Scripts d’automatisation de build : invoquer make, idf.py, ou pio depuis Python (subprocess) ou bash
• Utiliser argparse de Python pour des interfaces CLI robustes et le module logging pour des logs structurés
• Shell I/O avancé : pipes (|), process substitution (<(), >()), here-docs (<<EOF) et command substitution

Niveau : 4 – Avancé
Topics :

• Écrire des tests unitaires Python avec pytest ou unittest ; faire respecter le style avec flake8/pylint et ajouter des type hints avec mypy
• Durcir les scripts bash : set -euxo pipefail, validation des paramètres, fonctions de nettoyage trap, mode debug (set -x)
• Utiliser Python pour des tâches concurrentes : threading, multiprocessing, et outils de haut niveau comme concurrent.futures
• Construire des modules Python réutilisables et les installer via setup.py/pyproject.toml ; gérer versions et dépendances
• Automatiser les étapes CI/CD : écrire des scripts Python ou bash qui orchestrent des jobs GitHub Actions ou GitLab CI

Niveau : 5 – Expert
Topics :

• Développer et publier des outils CLI Python autonomes en utilisant des frameworks comme Click ou Typer ; publier des packages sur PyPI
• Architecturer de grands frameworks bash : scripts modulaires, systèmes de plugins, coprocesses, redirections I/O avancées
• Profiler et optimiser les scripts Python (par exemple, cProfile, line_profiler), adopter asyncio pour les tâches à haut débit
• Intégrer les scripts avec les services système : écrire des unit files systemd, des scripts d’entry-point de conteneurs, de l’automatisation Docker-Compose
• Définir et enseigner les meilleures pratiques d’équipe pour le scripting : sécurité (sanitization des entrées, éviter l’injection), documentation, et templates de code maintenables

23 – Bases du cloud & tableaux de bord

Niveau : 1 – Débutant absolu
Topics :

• Saisir le concept des plateformes IoT cloud vs solutions on-premise
• S’inscrire à un essai gratuit AWS IoT Core ou Azure IoT Hub
• Naviguer dans le portail AWS IoT ou Azure : explorer la section Things/Devices et voir les dashboards de vue d’ensemble
• Installer et exécuter un outil desktop (AWS IoT Explorer ou Azure IoT Explorer) pour se connecter et envoyer un message de télémétrie d’exemple
• Comprendre ce qu’est InfluxDB : installer une instance InfluxDB 2.x locale via Docker ou binaire, exécuter le CLI intégré, et écrire un seul point de données

Niveau : 2 – Débutant
Topics :

• Enregistrer un appareil (« Thing ») dans AWS IoT Core ou un appareil dans Azure IoT Hub ; télécharger et inspecter les certificats générés ou les SAS tokens
• Utiliser le SDK AWS IoT (C/Python) ou le Azure Device SDK pour publier une télémétrie JSON simple via MQTT
• Installer Grafana, ajouter InfluxDB comme source de données, et créer un panneau de série temporel de base affichant un champ
• Écrire des données dans InfluxDB depuis la ligne de commande (en utilisant curl ou le CLI Influx) et les vérifier dans l’interface InfluxDB
• Explorer les concepts Grafana : dashboards, panneaux, requêtes, sélecteur de plage temporelle

Niveau : 3 – Intermédiaire
Topics :

• Implémenter du code appareil de style production : connexions MQTT persistantes, logique de reconnexion, payloads JSON structurés, hiérarchies de topics
• Définir une règle AWS IoT pour transférer la télémétrie entrante vers une fonction Lambda, une table DynamoDB ou un stream Kinesis
• Configurer des tâches InfluxDB ou Telegraf pour ingérer et transformer automatiquement les flux de données entrants
• Construire des dashboards Grafana multi-panneaux en utilisant des requêtes Flux ou InfluxQL : ajouter des jauges, des graphiques et des panneaux stat
• Configurer des règles d’alerte simples dans Grafana basées sur des seuils, et configurer un canal de notification e-mail ou Slack

Niveau : 4 – Avancé
Topics :

• Durcir l’authentification : verrouiller les politiques IoT dans AWS, affiner le RBAC d’Azure IoT Hub, faire tourner les certificats/SAS tokens selon un calendrier
• Utiliser AWS IoT Device Shadows ou Azure Digital Twins pour synchroniser l’état desired/reported entre le cloud et l’appareil
• Faire évoluer InfluxDB avec des politiques de rétention, des requêtes continues ou des Tasks, et des shard groups pour le stockage à long terme
• Implémenter le provisioning Grafana (as code) pour gérer les dashboards et alertes via des fichiers JSON/YAML dans Git
• Intégrer Grafana avec des gestionnaires d’alertes ou services de notification externes (PagerDuty, OpsGenie, Microsoft Teams)

Niveau : 5 – Expert
Topics :

• Architecturer un backbone IoT global et résilient : failover multi-région AWS IoT Core ou Azure IoT Hub, intégration de gateway edge avec Greengrass ou Azure IoT Edge
• Automatiser l’infrastructure complète : écrire des modules Terraform ou des templates ARM/Bicep pour déployer les ressources IoT, clusters InfluxDB, instances Grafana, et politiques IAM
• Optimiser l’ingestion de données à haut volume : écritures en batch, techniques de compression, stratégies de backpressure, et procédures de backfill
• Concevoir et faire respecter des dashboards multi-tenants dans Grafana avec du RBAC granulaire et du filtrage de source de données
• Encadrer les équipes sur les meilleures pratiques pour le contrôle des coûts, la conformité sécurité (GDPR, HIPAA), les politiques de rétention de données, et la surveillance opérationnelle de la stack IoT analytics

24 – Conformité réglementaire & environnementale

Niveau : 1 – Débutant absolu
Topics :

• Apprendre pourquoi l’homologation réglementaire et les cotes environnementales comptent pour un appareil commercial
• Comprendre la portée du marquage CE (UE) vs la certification FCC (US) vs les codes IP de base
• Identifier quelles directives s’appliquent (par exemple, CEM, LVD pour CE ; Part 15 pour FCC) et ce que signifie un indice IP67
• Trouver et mettre en favoris les ressources officielles : base de données NANDO de l’UE, portail d’autorisation d’équipements FCC

Niveau : 2 – Débutant
Topics :

• Étudier les standards essentiels : immunité/émissions CEM (EN 61326-1 / FCC Part 15 Subpart B), sécurité (EN 61010‐1)
• Apprendre comment les indices IP sont testés (jet d’eau, chambre à poussière) et ce que signifie chaque chiffre
• Rassembler les datasheets et déclarations de conformité des fournisseurs pour chaque module ou composant
• Documenter le chemin de conformité attendu dans un simple tableur ou checklist

Niveau : 3 – Intermédiaire
Topics :

• Rédiger un Dossier Technique (CE) ou un plan de test FCC : inclure block diagrams, schémas, BOM, évaluation des risques
• Implémenter une atténuation EMI/EMC de base : ajouter des ferrites, des choke modes communs, des ground pours sur le PCB
• Effectuer des tests de pré-conformité internes : sondage EMI proche, tests ESD gun, vérifications d’isolation de base
• Préparer les artworks d’étiquetage de l’appareil : marquage CE, FCC ID, symboles WEEE, avertissements d’utilisation sûre

Niveau : 4 – Avancé
Topics :

• Gérer le processus de certification formelle avec un Organisme Notifié (CE) ou un laboratoire accrédité FCC : soumettre des échantillons, assister aux tests
• Analyser les rapports de test, piloter les changements de conception pour résoudre les échecs (par exemple, modifications de layout, joints de boîtier)
• Coordonner les tests environnementaux et mécaniques : cyclage thermique, vibrations, tests d’infiltration pour atteindre l’indice IP cible
• Assembler et signer la Déclaration de Conformité (CE) et déposer le FCC Form 731 pour l’autorisation d’équipement

Niveau : 5 – Expert
Topics :

• Définir une stratégie de conformité globale couvrant CE, FCC, UL/CSA, RoHS, REACH, WEEE et autres selon les besoins
• Architecturer du matériel et du firmware modulaires pour simplifier les re-tests et les variantes régionales
• Diriger les programmes de conformité fournisseurs : faire respecter le change-control des composants, auditer le QMS du fabricant
• Maintenir et mettre à jour les Dossiers Techniques et les exhibits FCC à travers les révisions de produit ; gérer les audits de surveillance périodiques
• Servir de liaison principale avec les organismes réglementaires, gérer les constats de non-conformité et les actions correctives, encadrer l’équipe sur les meilleures pratiques de stewardship réglementaire continu.

25 – Outils de documentation (Markdown, Doxygen)

Niveau : 1 – Débutant absolu
Topics :

• Comprendre le but de la documentation de projet : READMEs, références API, how-tos
• Installer un éditeur Markdown ou utiliser le support intégré de VS Code
• Écrire la syntaxe Markdown de base : headers (#–###), gras/italique, listes à puces & numérotées
• Insérer des liens et des images en Markdown ([text](url), ![alt](path))
• Prévisualiser un README.md dans VS Code ou sur GitHub

Niveau : 2 – Débutant
Topics :

• Créer des tables, des blockquotes et des blocs de code fenced en Markdown
• Utiliser des liens relatifs et des ancres pour de la documentation multi-page
• Installer Doxygen et générer un Doxyfile par défaut
• Annoter les sources C/C++ avec des commentaires Doxygen (///, /** ... */) pour les fonctions et types
• Exécuter Doxygen pour produire une sortie HTML et parcourir la documentation générée

Niveau : 3 – Intermédiaire
Topics :

• Personnaliser les paramètres du Doxyfile : input paths, EXTRACT_ALL, EXTRACT_PRIVATE, support des diagrammes, formats de sortie
• Embarquer du contenu Markdown dans les commentaires Doxygen et inclure des fichiers Markdown externes via \include
• Organiser la documentation en modules et groupes en utilisant les tags @defgroup et @addtogroup
• Intégrer l’exécution de Doxygen dans votre build CMake ou PlatformIO pour que la doc se mette à jour à chaque build
• Utiliser des extensions VS Code pour prévisualiser combinément Markdown et commentaires Doxygen en ligne

Niveau : 4 – Avancé
Topics :

• Étendre Doxygen avec des filtres de tags personnalisés ou des pré-processeurs d’input (par exemple, scripts Python)
• Automatiser les builds de documentation dans les pipelines CI et publier vers GitHub Pages, GitLab Pages ou Confluence via des convertisseurs
• Générer des diagrammes PlantUML ou Graphviz à partir des annotations de code et les inclure dans la documentation
• Maintenir des métriques de doc-coverage : écrire des scripts pour détecter les fonctions/types non documentés et faire échouer la CI si en dessous d’un seuil
• Définir et publier un guide de style pour l’utilisation de Markdown et Doxygen dans l’équipe

Niveau : 5 – Expert
Topics :

• Développer des layouts et thèmes Doxygen personnalisés (XSLT, templates CSS/HTML personnalisés) pour correspondre à l’identité visuelle de l’entreprise
• Architecturer un pipeline de documentation hybride utilisant Sphinx ou MkDocs aux côtés de Doxygen, avec des sorties versionnées et de la recherche
• Automatiser l’inclusion de documentation cross-repository via des sous-modules Git, des Doxyfiles composites ou du linking basé sur des tags
• Diriger des revues de documentation, faire respecter les quality gates de documentation dans la CI, et encadrer l’équipe sur les meilleures pratiques
• Contribuer aux outils de documentation open-source ou écrire des plugins/extensions (par exemple, pour le rendu avancé de diagrammes ou des exemples de code live)