Système embarqué

Tu réalises la partie électronique et informatique d’un projet mécatronique : la carte, ses capteurs, ses actionneurs, et le programme qui les pilote. Cette page est ton point d’entrée. Elle déroule la réalisation du sous-système embarqué en sept étapes, du besoin technique jusqu’à la validation au banc. À chaque étape, elle te dit ce que tu dois produire (le livrable) et où trouver la méthode pour y arriver.

Inutile de tout lire d’affilée : repère l’étape où tu en es, et suis les liens. Le fil rouge est un bras robotisé 3 axes, le même projet que celui des phases du cycle en V, vu ici sous l’angle de son électronique. Deux regards, un seul projet.¹

Cette colonne est orthogonale au cycle en V

Le cycle en V est la colonne gestion de projet : l’axe temporel (revues, jalons, équipe, livrables). La présente page est la colonne ingénierie embarquée : l’axe technique (du choix du matériel jusqu’à la mise au point). Les deux décrivent le même projet sous deux angles : ici le « comment réaliser », là le « quand décider et valider ». Tout le pilotage (revue, nomenclature, jalon) reste porté par les phases du V : chaque étape ci-dessous renvoie à la phase qui la cadre, sans la réécrire.

Les sept étapes

1. Cadrer le besoin embarqué — quelles fonctions techniques l’électronique et l’informatique doivent assurer
2. Choisir le matériel — microcontrôleur ou ordinateur monocarte, famille, alimentation
3. Concevoir l’électronique — schéma, niveaux de tension, circuit imprimé, simulation
4. Programmer — algorithme de commande, langage, périphériques, firmware
5. Faire communiquer — bus filaires et liaisons sans fil (si le besoin l’exige)
6. Fiabiliser et déboguer — temps réel, robustesse, instruments de mesure
7. Intégrer et tester — assembler au reste du système, valider au banc

Chaque étape suppose la précédente sans interdire les allers-retours : tu reviendras souvent au matériel ou au schéma après un essai.

1. Cadrer le besoin embarqué

Avant de choisir une carte, formule ce que l’électronique et l’informatique doivent faire : quelles fonctions techniques portent les exigences du cahier des charges. C’est la traduction du besoin en fonctions réalisables, côté embarqué.

Pars de la décomposition fonctionnelle du système et isole les fonctions qui reviennent à l’élec/info : commander des actionneurs, acquérir des grandeurs, dialoguer, décider. Chacune devient une contrainte chiffrée qui guidera tous les choix suivants : nombre d’entrées-sorties, résolution, cadence, latence.

• Décomposition fonctionnelle — découper le système en fonctions
• Chaîne d’énergie et d’information — repérer ce qui relève de la commande et de la mesure

Côté cycle en V : ce cadrage s’inscrit dans la phase concept, qui arbitre l’architecture et en porte le livrable.

Livrable 1/7 — Les fonctions embarquées, définies et chiffrées

Le schéma bloc fonctionnel du sous-système et son tableau « fonction → exigence embarquée ». Rendu papier. C’est le contrat d’entrée de toutes les étapes suivantes.

2. Choisir le matériel

La question : quel matériel exécute le mieux les fonctions de l’étape 1 ? Des capteurs et des actionneurs d’abord, puis la carte : microcontrôleur (réactif, temps réel, sobre en énergie) ou ordinateur monocarte (puissant, sous Linux) ? Quelle famille ? Et comment alimenter l’ensemble ?

Le panorama des familles et l’aide au choix sont portés par le hub microcontrôleur. Ne le réécris pas : va le consulter, et reviens avec une carte candidate. Pense l’alimentation dès ce stade : c’est elle qui conditionne l’autonomie et la stabilité.

• Microcontrôleur — panorama des familles, microcontrôleur contre monocarte, aide au choix
• Familles : Arduino, ESP32, ESP8266, STM32, Teensy, PIC
• Raspberry Pi — l’option ordinateur monocarte, et l’architecture à deux cerveaux
• Lire une datasheet — comparer des composants sur pièces
• Concevoir une alimentation — source, régulation, autonomie

Côté cycle en V : le choix d’architecture matérielle est arbitré en phase concept.

Livrable 2/7 — Le matériel retenu : carte, capteurs, actionneurs

Une matrice de choix tranchée et le budget d’alimentation. Rendu papier (la note de choix). La commande du matériel suit.

3. Concevoir l’électronique

La carte choisie ne suffit pas. Il faut dessiner le circuit autour d’elle : relier capteurs et actionneurs, adapter les niveaux de tension, distribuer l’énergie, protéger les entrées. Puis vérifier le comportement avant de souder quoi que ce soit.

Lis et produis le schéma de principe, traque les incompatibilités de tension (un capteur 5 V sur une entrée 3,3 V détruit l’entrée), et simule les parties incertaines. Le passage au circuit imprimé vient quand le schéma est stabilisé.

• Analyser un schéma électronique — lire et produire un schéma de principe
• Niveaux de tension — 3,3 V / 5 V, compatibilité et adaptation
• Simulation électronique — calculer le comportement avant de câbler
• Circuit imprimé — du schéma à la carte fabricable, avec KiCad

Côté cycle en V : ces livrables nourrissent le dossier technique (schémas, routage, simulations).

Livrable 3/7 — Le schéma électronique validé

Le schéma de principe vérifié et la simulation des parties incertaines (preuve de concept simulée). Rendu papier + simulation. Le circuit imprimé en est la version fabricable.

4. Programmer

Deux temps : concevoir l’algorithme de commande (la logique, indépendante du code), puis l’écrire pour la carte. La logique se raconte d’abord en français, puis se décrit avec un logigramme, une machine à états ou un GRAFCET. Le code l’implémente ensuite en pilotant les périphériques : entrées-sorties, convertisseur analogique-numérique, sorties PWM.

Choisis d’abord la forme d’algorithme adaptée à ton problème, puis le langage : C++ dans l’écosystème Arduino, MicroPython, ou l’environnement constructeur de ta famille. Le firmware est l’organisation d’ensemble du programme embarqué.

• Concevoir la logique : algorithme — logigramme, machine à états, GRAFCET, chronogramme
• Langage : C++ (écosystème Arduino) ou MicroPython
• Périphériques : GPIO, convertisseur analogique-numérique, sortie PWM, manipulation de bits
• Firmware — structurer l’ensemble du programme embarqué

Côté cycle en V : l’algorithme et le code sont des livrables du dossier technique.

Livrable 4/7 — Algorithme et documentation

L’algorithme de commande (logigramme ou machine à états) et son implémentation, qui compile et tourne sur la carte. Un algorithme + du code.

5. Faire communiquer

Cette étape ne concerne que les projets dont le cahier des charges exige de dialoguer : piloter à distance, superviser, transmettre des mesures. Si c’est ton cas, choisis comment les composants dialoguent : un bus filaire entre puces d’une même carte, une liaison sans fil ou câblée vers l’extérieur. Chaque liaison a ses contraintes : nombre de fils, débit, distance, nombre de participants.

Choisis le bus selon le besoin : I²C pour relier plusieurs capteurs avec deux fils, SPI pour la vitesse, UART pour une liaison simple. Pour le sans-fil, Wi-Fi ou BLE.

• Bus de communication — UART, I²C, SPI
• Technologies sans fil — Wi-Fi, BLE, Zigbee, LoRa

Côté cycle en V : les choix de communication figurent au dossier technique.

Livrable 5/7 — Choix des technologies de communication (si le cahier des charges l'exige)

La répartition des échanges (bus internes, liaison sans fil) et une liaison éprouvée de bout en bout, typiquement une preuve de concept sur breadboard.

6. Fiabiliser et déboguer

Un montage qui marche au premier essai n’est pas fiable pour autant. Cette étape durcit le système : garantir le temps réel (interruptions, temporisateurs), survivre aux blocages (chien de garde), économiser l’énergie (veille), et surtout trouver les bugs avec les bons instruments.

Mobilise les notions transverses de temps réel et de robustesse, puis les fiches du palier ingénieur de ta famille (chien de garde, PID, système temps réel…). Pour déboguer, l’oscilloscope et le multimètre voient ce que le code ne dit pas.

Attention au mot « déboguer »

Cette étape traite les bugs d’exécution : le programme compile, se téléverse et tourne, mais mal. Une erreur qui empêche la compilation ou le téléversement ne se cherche pas ici : elle se lit dans le message du compilateur, à l’étape 4, avec lire et comprendre les erreurs.

• Temps réel et robustesse : interruptions, temporisateurs, veille, gestion mémoire
• Instruments de mesure — multimètre, oscilloscope
• Déboguer un système embarqué — méthode pour traquer un bug
• Le palier ingénieur de ta famille : Arduino, ESP32, STM32…

Côté cycle en V : la robustesse se prépare dès la preuve de concept et se consolide au dossier technique.

Livrable 6/7 — Protocole de tests et débogage

Le protocole de tests dérivé du cahier des charges (chaque exigence validée seule, puis en simultané), les parades aux risques techniques en place (temps réel, chien de garde, veille) et la trace des bugs traités. Système robuste + journal de débogage.

7. Intégrer et tester

Le sous-système embarqué rejoint enfin le reste du projet, la mécanique et l’opérateur. Tu vérifies au banc que chaque fonction de l’étape 1 est tenue. C’est le moment de vérité : la spécification est-elle satisfaite ?

Le déroulé de l’intégration et de la qualification, de la pyramide de tests au relevé des écarts, est porté par la phase d’intégration du cycle en V. Ne le redécris pas : exécute-le sur ton sous-système.

• Intégration et tests — assembler, qualifier, conclure (phase du V)

Côté cycle en V : cette étape est la phase intégration et tests elle-même, vue côté embarqué.

Livrable 7/7 — Produit fini

Chaque fonction de l’étape 1 testée, mesurée, validée ou tracée en écart. Sous-système assemblé + dossier de recette. C’est la phase d’intégration du V, exécutée sur l’embarqué.

Le management, c’est le cycle en V

Cette colonne décrit l’ingénierie, elle ne pilote pas le projet. Les revues, les jalons, la nomenclature, le suivi d’équipe et la validation des livrables sont décrits par la branche Conduite de projet :

• Cadrer (étapes 1-2) se décide en phase concept.
• Concevoir, programmer, communiquer, fiabiliser (étapes 3-6) alimentent le dossier technique.
• Intégrer et tester (étape 7) est la phase intégration et tests.

Si une fiche te demande de produire un planning, une revue ou une analyse de risques projet, c’est que tu touches au pilotage : suis le lien vers le cycle en V.