L'informatique embarquée

Un système embarqué est un système informatique spécialisé, conçu pour réaliser une ou plusieurs fonctions spécifiques, et intégré au sein d'un équipement plus grand dont il fait partie intégrante. Contrairement à un ordinateur personnel, un système embarqué n'est pas conçu pour être polyvalent.

Caractéristiques principales :

• Spécialisation : Il est optimisé pour une tâche précise (ex: gérer le freinage d'une voiture, afficher l'heure sur une montre connectée).
• Autonomie : Il fonctionne souvent de manière autonome, parfois sans intervention humaine directe.
• Contraintes fortes : Il est soumis à des contraintes de taille, de consommation d'énergie, de coût, de performances et de fiabilité. La fiabilité est souvent cruciale, notamment dans les domaines médical ou automobile.
• Interaction avec le monde physique : Il interagit via des capteurs (pour collecter des informations) et des actionneurs (pour agir sur l'environnement).

Différence avec l'informatique de bureau :

• Téléphone portable : C'est un système embarqué complexe qui intègre de nombreux sous-systèmes embarqués (gestion de l'écran, du Wi-Fi, de l'appareil photo, etc.).
• Lave-linge : Gère les cycles de lavage, la température, l'essorage.
• Télécommande de TV : Envoie des signaux infrarouges spécifiques.
• Montre connectée : Mesure le rythme cardiaque, affiche les notifications, gère l'heure.
• Distributeur automatique de boissons : Gère le paiement, la sélection du produit, la distribution.
• Système de freinage ABS d'une voiture : un exemple où la fiabilité est vitale.

L'histoire de l'informatique embarquée est intimement liée à celle de l'électronique et de l'informatique.

• Premiers systèmes embarqués (années 1960-1970) : Les débuts sont marqués par des systèmes très spécialisés et coûteux, souvent dans les domaines militaire et spatial.
  • Un exemple emblématique est le calculateur de guidage du programme Apollo (Apollo Guidance Computer - AGC) dans les années 1960. Il était essentiel pour la navigation et le pilotage des missions lunaires. Il utilisait des circuits intégrés et devait être extrêmement fiable.
  • Les premiers microprocesseurs (Intel 4004 en 1971) ont ouvert la voie.
• Miniaturisation et puissance (années 1980-1990) : L'avènement des microcontrôleurs (un microprocesseur avec de la mémoire et des périphériques intégrés sur une seule puce) a permis une miniaturisation et une réduction des coûts considérables.
  • L'embarqué se démocratise dans l'automobile (gestion moteur, ABS), l'électroménager (lave-linge, micro-ondes) et les jouets.
  • La puissance de calcul augmente, permettant des fonctions plus complexes.
• Impact sur la société (années 2000 à aujourd'hui) : L'explosion de l'Internet des Objets (IoT) a propulsé les systèmes embarqués au cœur de notre quotidien.
  • Connectivité : Les systèmes embarqués deviennent connectés (Wi-Fi, Bluetooth, 4G/5G, LoRa), permettant le contrôle à distance, la collecte de données et l'interaction avec d'autres systèmes.
  • Intelligence Artificielle (IA) : Des capacités d'IA légères commencent à être intégrées (reconnaissance vocale, vision par ordinateur simple).
  • L'informatique embarquée est devenue invisible mais omniprésente, transformant nos maisons, nos transports et notre santé.

Les systèmes embarqués sont partout ! Voici quelques domaines clés :

• Automobile et transports : C'est l'un des plus grands utilisateurs de systèmes embarqués.
  • Sécurité : ABS (système anti-blocage des roues), ESP (contrôle électronique de stabilité), airbags, aide au stationnement.
  • Confort : Climatisation automatique, systèmes d'infodivertissement, régulateurs de vitesse.
  • Gestion moteur : Optimisation de la consommation de carburant et réduction des émissions.
  • Véhicules autonomes : Représentent le futur de l'embarqué dans ce secteur, avec des capteurs complexes (lidars, radars, caméras) et des calculateurs puissants.
  • Aéronautique et spatial : Systèmes de pilotage automatique, contrôle des satellites, gestion des instruments de vol.
• Santé et domotique :
  • Santé : Pacemakers, pompes à insuline, appareils d'imagerie médicale (IRM, scanner), moniteurs de signes vitaux, capteurs portables (wearables) pour le suivi de l'activité physique et du sommeil.
  • Domotique (maison intelligente) : Thermostats connectés, éclairage intelligent, serrures connectées, systèmes d'alarme, assistants vocaux.
• Industrie et espace :
  • Industrie 4.0 : Robots industriels, machines-outils à commande numérique (CNC), systèmes de contrôle de processus (SCADA), capteurs de maintenance prédictive.
  • Défense : Drones militaires, systèmes de guidage de missiles, équipements de communication sécurisés.
  • Énergie : Gestion des réseaux électriques intelligents (smart grids), compteurs communicants (Linky).
  • L'informatique embarquée est le pilier de l'automatisation et de l'optimisation dans presque tous les secteurs économiques.

Un système embarqué est construit autour de quelques éléments fondamentaux :

• Microcontrôleur (MCU) ou Microprocesseur (MPU) :
  • Le microcontrôleur est le "cerveau" du système. C'est une puce unique qui intègre un microprocesseur (l'unité de traitement), de la mémoire (RAM et ROM/Flash) et des périphériques d'entrée/sortie (timers, convertisseurs analogique-numérique, ports série). Il est idéal pour les tâches simples et contraintes en coût/énergie. Exemples : ATMega (Arduino), STM32.
  • Le microprocesseur (comme ceux de nos PC, mais souvent plus petits et moins gourmands) est plus puissant et nécessite des composants externes pour la mémoire et les périphériques. Il est utilisé pour des systèmes plus complexes nécessitant plus de puissance de calcul et de mémoire, souvent avec un système d'exploitation. Exemples : ARM Cortex-A (Raspberry Pi).
  • Le choix entre microcontrôleur et microprocesseur dépend de la complexité de la tâche et des ressources nécessaires.
• Mémoires (RAM, ROM, Flash) :
  • RAM (Random Access Memory) : C'est la mémoire de travail volatile. Elle stocke temporairement les données et les instructions que le microcontrôleur est en train d'utiliser. Son contenu est perdu à l'extinction.
  • ROM (Read-Only Memory) ou Flash Memory : C'est la mémoire non-volatile. Elle stocke le programme (firmware) du système embarqué. Son contenu n'est pas perdu à l'extinction. La mémoire Flash est une forme de ROM qui peut être effacée et réécrite, ce qui est très pratique pour les mises à jour.
• Capteurs et actionneurs :
  • Capteurs : Ce sont les "yeux" et les "oreilles" du système. Ils convertissent des phénomènes physiques (lumière, température, pression, mouvement, son) en signaux électriques que le microcontrôleur peut comprendre. Exemples : capteur de température, accéléromètre, capteur de lumière.
  • Actionneurs : Ce sont les "muscles" du système. Ils convertissent les signaux électriques du microcontrôleur en actions physiques. Exemples : LED (allumer une lumière), moteur (faire tourner une roue), buzzer (émettre un son).

Pour communiquer avec les capteurs, les actionneurs et d'autres systèmes, les systèmes embarqués utilisent diverses interfaces.

• Communication série (UART, SPI, I2C) : Ce sont des protocoles de communication pour échanger des données bit par bit.
  • UART (Universal Asynchronous Receiver/Transmitter) : Utilisé pour la communication point à point, souvent avec un PC pour le débogage ou avec d'autres puces. Nécessite deux fils (Rx, Tx).
  • SPI (Serial Peripheral Interface) : Permet une communication rapide entre un maître et plusieurs esclaves. Utilisé pour les écrans, les cartes SD, certains capteurs. Nécessite 4 fils minimum.
  • I2C (Inter-Integrated Circuit) : Nécessite seulement 2 fils (SDA pour les données, SCL pour l'horloge) et permet de connecter plusieurs dispositifs sur le même bus. Idéal pour les capteurs qui ne nécessitent pas une très haute vitesse.
• Entrées/sorties numériques et analogiques :
  • Entrées/sorties numériques (Digital I/O) : Gèrent des signaux binaires (0 ou 1, ON ou OFF, Vrai ou Faux). Utilisées pour lire l'état d'un bouton (appuyé ou non) ou allumer/éteindre une LED.
  • Entrées analogiques (Analog Input) : Permettent de mesurer des tensions variables (ex: la sortie d'un capteur de température, qui varie en fonction de la chaleur). Un convertisseur analogique-numérique (CAN ou ADC) est nécessaire pour transformer cette tension en une valeur numérique compréhensible par le microcontrôleur.
  • Sorties analogiques (Analog Output) : Moins courantes directement sur les microcontrôleurs, souvent simulées par la Modulation de Largeur d'Impulsion (PWM) pour contrôler la luminosité d'une LED ou la vitesse d'un moteur.
• Connectivité (Bluetooth, Wi-Fi, LoRa) : Pour permettre aux systèmes embarqués de communiquer entre eux ou avec Internet.
  • Bluetooth : Courte portée, faible consommation, idéal pour les appareils portables (écouteurs, montres connectées).
  • Wi-Fi : Portée moyenne, plus gourmand en énergie, permet une connexion à Internet via un routeur.
  • LoRa (Long Range) : Longue portée (plusieurs kilomètres), très faible consommation, faible débit de données. Idéal pour les capteurs dans des zones rurales ou difficiles d'accès.
  • Le choix de l'interface et de la connectivité dépendra de la distance de communication, du débit de données requis et des contraintes énergétiques.

Les systèmes embarqués peuvent fonctionner avec ou sans système d'exploitation.

• Absence d'OS : Pour les systèmes les plus simples et contraints, le programme est exécuté directement sur le matériel, sans couche logicielle intermédiaire. C'est ce qu'on appelle "bare metal" (métal nu). Le développeur gère tout, de l'initialisation du matériel à l'exécution des tâches.
• OS temps réel (RTOS - Real-Time Operating System) : Pour les systèmes plus complexes qui doivent exécuter plusieurs tâches simultanément et respecter des délais stricts.
  • Un RTOS garantit que les tâches critiques sont exécutées dans un laps de temps prévisible et garanti (d'où le "temps réel"). Il gère l'ordonnancement des tâches, la communication entre elles, et l'accès aux ressources partagées.
  • Contraintes de ressources : Les RTOS sont conçus pour être légers, avec une faible empreinte mémoire et une faible consommation CPU, afin de s'adapter aux ressources limitées des systèmes embarqués.
  • Exemples : FreeRTOS (très populaire et open source), Contiki (pour l'IoT avec des contraintes très fortes), Zephyr. Il existe aussi des OS embarqués plus "riches" comme Linux embarqué (utilisé sur Raspberry Pi) pour des applications nécessitant plus de puissance et de fonctionnalités.

• C/C++ pour l'embarqué :
  • Le langage C est le langage roi de l'embarqué. Il est très proche du matériel, permet une gestion fine de la mémoire et des périphériques, et génère un code très optimisé et rapide. Sa portabilité est excellente.
  • Le C++ ajoute des concepts de programmation orientée objet, ce qui peut aider à structurer des projets plus complexes, tout en conservant une grande partie des avantages du C.
  • La maîtrise du C est quasi indispensable pour tout développeur en systèmes embarqués.
• Python pour les couches supérieures :
  • Bien que moins adapté aux microcontrôleurs très contraints en raison de sa consommation de ressources, Python est de plus en plus utilisé sur des plateformes plus puissantes comme le Raspberry Pi ou pour des applications IoT.
  • Il est apprécié pour sa facilité d'apprentissage, sa rapidité de développement et sa vaste bibliothèque de modules, notamment pour l'analyse de données, la connectivité réseau ou l'interface utilisateur.
  • Des versions légères comme MicroPython permettent même d'exécuter Python sur certains microcontrôleurs.
• Assembleur (notions) :
  • Le langage Assembleur est le langage de programmation de plus bas niveau, directement lié à l'architecture spécifique du microprocesseur. Chaque instruction assembleur correspond à une opération élémentaire du processeur.
  • Il est rarement utilisé pour écrire des programmes entiers aujourd'hui, car il est complexe et fastidieux. Cependant, avoir des notions d'assembleur est essentiel pour :
    • Optimiser des portions critiques de code (ex: routines très rapides).
    • Comprendre le fonctionnement interne du matériel.
    • Déboguer des problèmes très bas niveau.
  • L'assembleur est la langue maternelle du microprocesseur.

Les systèmes embarqués sont souvent réactifs : ils attendent qu'un événement se produise pour agir.

• Boucle infinie (loop) :
  • La structure de base de la plupart des programmes embarqués est une boucle infinie (souvent while(1) en C ou la fonction loop() dans Arduino).
  • Le programme tourne en permanence dans cette boucle, vérifiant l'état des capteurs, exécutant des tâches régulières et attendant des événements.
  • Exemple :

    void setup() {
      // Initialisation (une seule fois au démarrage)
      pinMode(LED_BUILTIN, OUTPUT);
    }
    
    void loop() {
      // Boucle infinie (s'exécute en continu)
      digitalWrite(LED_BUILTIN, HIGH); // Allumer la LED
      delay(1000);                     // Attendre 1 seconde
      digitalWrite(LED_BUILTIN, LOW);  // Éteindre la LED
      delay(1000);                     // Attendre 1 seconde
    }
    

• Gestion des interruptions :
  • Pour rendre un système plus réactif et éviter de perdre du temps à vérifier constamment l'état des entrées, on utilise les interruptions.
  • Une interruption est un signal matériel ou logiciel qui suspend temporairement l'exécution du programme principal (la boucle infinie) pour exécuter une tâche spécifique (une routine d'interruption, ou ISR). Une fois l'ISR terminée, le programme principal reprend là où il s'était arrêté.
  • Exemple : Un bouton est appuyé (événement). Au lieu de vérifier constamment l'état du bouton dans la boucle, une interruption est déclenchée, ce qui permet de réagir instantanément.
  • Les interruptions sont cruciales pour la réactivité et le temps réel, car elles permettent de répondre immédiatement à un événement externe.
• Réactivité et temps réel :
  • La réactivité est la capacité du système à répondre rapidement aux événements.
  • Le temps réel est une contrainte plus forte : le système doit non seulement répondre rapidement, mais aussi garantir que la réponse se produira dans un délai maximum défini, sans quoi des conséquences graves peuvent survenir (ex: un système de freinage).
  • Les RTOS (vu précédemment) sont conçus spécifiquement pour garantir ces contraintes de temps réel.

C'est ici que le système embarqué interagit avec le monde physique.

• Lecture de données (capteurs) :
  • Le microcontrôleur lit les signaux provenant des capteurs.
  • Exemple : Lire la valeur d'un capteur de température analogique. Le capteur fournit une tension qui varie avec la température. Le microcontrôleur utilise son CAN (Convertisseur Analogique-Numérique) pour transformer cette tension en une valeur numérique (par exemple, un nombre entre 0 et 1023 pour un CAN 10 bits). Le programme convertit ensuite cette valeur numérique en une température en degrés Celsius ou Fahrenheit.
• Contrôle de dispositifs (actionneurs) :
  • Le microcontrôleur envoie des signaux aux actionneurs pour les contrôler.
  • Exemple : Allumer une LED. Le microcontrôleur envoie un signal numérique "HIGH" (tension élevée) à la broche connectée à la LED pour l'allumer, et "LOW" (tension faible) pour l'éteindre.
  • Exemple : Contrôler la vitesse d'un moteur. On utilise souvent la PWM (Pulse Width Modulation). Le microcontrôleur envoie un signal carré dont le rapport cyclique (le pourcentage du temps où le signal est "HIGH") est variable. Un rapport cyclique élevé correspond à une vitesse plus élevée pour le moteur.
• Exemples pratiques (LED, bouton, moteur) :
  • LED :
    • Lecture d'un bouton (entrée numérique) : si le bouton est appuyé, allumer la LED (sortie numérique).
  • Moteur :
    • Lecture d'un capteur de distance : si l'objet est trop près, faire reculer un petit robot (contrôle d'un moteur via PWM).
  • Capteur de lumière :
    • Lecture d'un capteur de lumière (entrée analogique) : si la luminosité est faible, allumer une LED ou un relai pour une lumière.
  • Ces interactions sont la base de la plupart des systèmes embarqués, permettant au système de percevoir son environnement et d'y réagir.

• Consommation énergétique :
  • De nombreux systèmes embarqués sont alimentés par batterie ou doivent fonctionner avec une très faible consommation (ex: capteurs IoT autonomes pendant des années).
  • Les développeurs doivent optimiser le code et choisir des composants à faible consommation, utiliser des modes veille, et gérer l'énergie de manière très efficace. C'est un défi majeur pour l'autonomie des appareils.
• Taille et coût :
  • Les systèmes embarqués doivent souvent être petits pour s'intégrer dans des produits compacts (montres connectées, implants médicaux).
  • Le coût est également un facteur clé, surtout pour les produits de masse. Choisir les composants les moins chers tout en respectant les performances et la fiabilité est un art.
• Fiabilité et robustesse :
  • Un système embarqué défaillant peut avoir des conséquences graves (arrêt d'une voiture, dysfonctionnement d'un appareil médical, panne industrielle).
  • Ils doivent souvent fonctionner dans des environnements difficiles (températures extrêmes, vibrations, humidité). Les composants sont choisis pour leur robustesse, et le logiciel doit être exempt de bugs et capable de gérer les erreurs.
  • La tolérance aux pannes est essentielle dans les applications critiques.

Ces deux concepts sont souvent confondus mais sont distincts et cruciaux.

• Sécurité (Security) :
  • Concerne la protection contre les attaques malveillantes (piratage, vol de données, prise de contrôle du système).
  • Les systèmes embarqués, surtout connectés (IoT), sont des cibles.
  • Vulnérabilités spécifiques : Faiblesse des protocoles de communication, absence de chiffrement, mots de passe par défaut, absence de mises à jour de sécurité.
  • Protection des données : Chiffrement des communications, authentification forte, isolation des modules critiques, mises à jour de firmware sécurisées.
• Sûreté de fonctionnement (Safety) :
  • Concerne la protection contre les défaillances accidentelles du système qui pourraient entraîner des dommages aux personnes, à l'environnement ou aux biens.
  • Exemple : Un bug logiciel dans un système de freinage ABS ou un pacemaker.
  • Normes de sécurité : Des normes strictes existent (ISO 26262 pour l'automobile, IEC 62304 pour le médical) pour garantir des processus de développement rigoureux, des tests exhaustifs et une gestion des risques.
  • Un système sûr est un système qui ne fera pas de mal, même en cas de défaillance. Un système sécurisé est un système protégé contre les attaques. Les deux sont souvent requis.

L'essor des systèmes embarqués soulève aussi des questions importantes.

• Vie privée et collecte de données :
  • De nombreux appareils connectés collectent des données personnelles (localisation, habitudes, données de santé).
  • Il est crucial de garantir la transparence sur les données collectées, leur utilisation, leur stockage et leur protection, dans le respect des réglementations comme le RGPD.
• Recyclage des composants :
  • La multiplication des objets électroniques embarqués pose un défi en termes de déchets électroniques (DEEE).
  • Il est important de concevoir des produits facilement recyclables et d'encourager les filières de recyclage appropriées.
• Obsolescence programmée :
  • La durée de vie des appareils est parfois limitée par la conception (batterie non remplaçable, non-support logiciel).
  • L'éthique exige de concevoir des produits durables, réparables et évolutifs, pour réduire l'impact environnemental.
  • L'ingénieur en embarqué a une responsabilité éthique et environnementale.

• Arduino et Raspberry Pi :
  • Arduino : C'est une plateforme open-source basée sur des microcontrôleurs (ATmega). Très facile à prendre en main pour les débutants. Idéal pour apprendre les bases de l'électronique et de la programmation embarquée avec le langage Wiring (proche du C++).
  • Raspberry Pi : C'est un nano-ordinateur (microprocesseur ARM) qui exécute généralement une version de Linux (Raspberry Pi OS). Plus puissant qu'Arduino, il permet de réaliser des projets plus complexes, incluant des interfaces graphiques, de la connectivité réseau avancée et des applications Python.
  • Ces deux plateformes sont d'excellents points de départ pour l'expérimentation.
• Environnements de développement intégrés (IDE) :
  • Un IDE est un logiciel qui fournit tout le nécessaire pour écrire, compiler et téléverser du code sur un système embarqué.
  • Arduino IDE : Simple et intuitif, parfait pour Arduino.
  • VS Code (avec extensions) : Très populaire pour le développement C/C++, Python, et embarqué (PlatformIO est une extension très puissante).
  • Environnements propriétaires : Chaque fabricant de microcontrôleurs (STMicroelectronics avec STM32CubeIDE, Microchip avec MPLAB X) propose souvent son propre IDE.
• Exemples de kits de démarrage :
  • Un kit Arduino classique avec une carte Uno, des LED, des résistances, des boutons, un capteur de température.
  • Un kit Raspberry Pi avec la carte, une carte SD pré-installée, une alimentation et un boîtier.

• Conception d'un cahier des charges :
  • Avant de commencer à coder, il faut définir ce que le système doit faire.
  • Exemple : "Je veux un système qui allume une LED verte quand il fait jour et une LED rouge quand il fait nuit."
  • Cela inclut les fonctionnalités, les entrées (capteurs nécessaires), les sorties (actionneurs), et les contraintes (alimentation, taille).
• Programmation d'une fonction basique :
  • Exemple avec Arduino :
    1. Connecter un capteur de lumière (photocellule ou LDR) à une entrée analogique.
    2. Connecter une LED verte et une LED rouge à des sorties numériques.
    3. Écrire le code :

       const int LED_VERTE = 2;
       const int LED_ROUGE = 3;
       const int CAPTEUR_LUMIERE = A0; // Broche analogique
       
       void setup() {
         pinMode(LED_VERTE, OUTPUT);
         pinMode(LED_ROUGE, OUTPUT);
         Serial.begin(9600); // Pour le débogage
       }
       
       void loop() {
         int valeurLumiere = analogRead(CAPTEUR_LUMIERE);
         Serial.print("Luminosité : ");
         Serial.println(valeurLumiere);
       
         if (valeurLumiere > 500) { // Seuil à ajuster
           digitalWrite(LED_VERTE, HIGH); // Jour
           digitalWrite(LED_ROUGE, LOW);
         } else {
           digitalWrite(LED_VERTE, LOW);
           digitalWrite(LED_ROUGE, HIGH); // Nuit
         }
         delay(100); // Petite pause
       }
       

• Test et débogage :
  • Vérifier que le code compile et se téléverse sur la carte.
  • Observer le comportement du système. Utiliser la console série pour afficher les valeurs des capteurs et comprendre ce qui se passe.
  • Identifier et corriger les erreurs (bugs) dans le code ou les branchements.

L'informatique embarquée est un domaine en pleine croissance et offre de nombreuses opportunités professionnelles.

• Ingénieur systèmes embarqués :
  • Conçoit l'architecture matérielle et logicielle des systèmes embarqués.
  • Développe les firmwares, intègre les capteurs et actionneurs.
  • Travaille sur la gestion de l'énergie, la fiabilité et la sécurité.
  • Peut être spécialisé dans un domaine (automobile, médical, IoT).
• Développeur IoT (Internet des Objets) :
  • Se concentre sur la connectivité des objets, la gestion des données collectées et leur transmission vers le cloud.
  • Développe les applications logicielles côté objet (firmware) et côté serveur (backend).
• Recherche et innovation :
  • Travaille sur les nouvelles générations de systèmes embarqués, les architectures innovantes, les algorithmes d'IA embarquée, les techniques de miniaturisation et d'optimisation énergétique.
  • Contribue à faire avancer les technologies de demain dans des domaines comme les véhicules autonomes, la robotique, la santé connectée.
• C'est un domaine stimulant qui demande des compétences à la fois en informatique, en électronique et en intégration système.