Introduction à Rust embarqué
Commencez avec Rust embarqué en découvrant la chaîne d’outils, les cartes de développement courantes et les bases de la programmation sans système d’exploitation.
Introduction à Rust embarqué est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.
Bienvenue dans Rust embarqué
Bienvenue dans le monde de Rust embarqué ! Cette leçon vous permettra de commencer à programmer des microcontrôleurs et d'autres appareils aux ressources limitées avec Rust.
Nous verrons pourquoi Rust est un excellent choix pour les systèmes embarqués et ce qui rend ce domaine particulier par rapport au développement traditionnel pour ordinateur de bureau ou pour le Web.
Rust embarqué ou Rust standard
Lorsque vous programmez des systèmes embarqués, vous travaillez souvent sans système d'exploitation. Cela signifie que vous interagissez directement avec le matériel.
- Pas de système d'exploitation : ni Linux, ni Windows, ni macOS.
- Ressources limitées : mémoire (RAM) et stockage (Flash) limités.
- Accès direct au matériel : vous contrôlez directement les périphériques tels que les GPIO, les minuteurs et les interfaces de communication.
La chaîne d'outils de Rust embarqué
Pour commencer, vous devez effectuer une configuration légèrement différente de celle de Rust standard. Vous utiliserez généralement rustup pour installer des composants spécifiques :
- Prise en charge de la cible : par exemple,
rust-std-arm-none-eabipour les microcontrôleurs ARM Cortex-M. cargo-generate: un outil permettant de créer de nouveaux projets à partir de modèles, très utilisé dans les configurations embarquées.- Outils de débogage : notamment
probe-rspour transférer le programme sur votre appareil et le déboguer.
Notions de base de la compilation croisée
Le développement embarqué implique souvent une compilation croisée. Cela signifie que vous compilez votre code sur un type d'ordinateur (par exemple, le CPU x86 de votre ordinateur portable) pour l'exécuter sur un autre (par exemple, un microcontrôleur ARM Cortex-M).
Rust utilise des triplets de cible (par exemple, thumbv7em-none-eabihf) pour indiquer l'architecture, le fabricant, le système d'exploitation (ou son absence) et l'ABI de l'appareil cible.
Cartes de développement courantes
Vous rencontrerez différents microcontrôleurs (MCU) dans Rust embarqué. Parmi les choix populaires figurent :
- Série STM32 : polyvalente et largement utilisée dans l'industrie.
- ESP32 : connue pour ses fonctionnalités Wi-Fi et Bluetooth.
- Série nRF52 : excellente pour les applications Bluetooth Low Energy (BLE).
Ces cartes fournissent le matériel physique nécessaire à l'exécution de votre code Rust.
Comprendre le fonctionnement sans système d'exploitation
La programmation au plus près du matériel signifie que votre code s'exécute directement sur le matériel, sans système d'exploitation sous-jacent pour gérer les ressources ou fournir des abstractions.
Tout est à votre charge : initialiser la mémoire, configurer l'horloge et les périphériques, et gérer les interruptions. C'est un niveau de programmation bas, mais il vous offre un contrôle total.
Structure d'un programme au plus près du matériel
Un programme Rust embarqué est différent d'un programme standard. Voici une structure de base :
#![no_std]: ne pas lier la bibliothèque standard.#![no_main]: ne pas utiliser le point d'entréemainpar défaut.#[cortex_m_rt::entry]: indique le véritable point d'entrée pour les appareils Cortex-M.
Ce programme minimal pourrait être compilé pour une cible embarquée, mais il nécessite un gestionnaire de panique et une bibliothèque d'exécution.
#![no_std]
#![no_main]
// A minimal panic handler for embedded systems
use panic_halt as _;
// The entry point for ARM Cortex-M microcontrollers
#[cortex_m_rt::entry]
fn main() -> ! {
// This function runs once on device startup.
// Here you would initialize your hardware peripherals.
// For example, setting up a GPIO pin.
loop {
// Your main application loop runs here.
// This loop will run forever, performing tasks.
// Example: Toggle an LED, read sensor data.
}
}Le « Hello, World! » embarqué
Puisqu'il n'y a pas de console sur laquelle afficher du texte, le « Hello, World! » classique des systèmes embarqués consiste généralement à faire clignoter une LED.
Cette action simple montre que vous avez réussi à :
- Compiler votre code pour la cible.
- Le transférer sur l'appareil.
- Prendre le contrôle d'un périphérique matériel élémentaire (une broche d'entrée/sortie à usage général).
Organisation de la mémoire et scripts de l'éditeur de liens
En programmation au plus près du matériel, vous devez comprendre comment le code compilé et les données de votre programme sont organisés dans la mémoire du microcontrôleur.
Les scripts de l'éditeur de liens (souvent fournis par les paquets de prise en charge des cartes) définissent cette organisation de la mémoire en indiquant où se trouvent les différentes sections de votre programme (par exemple, le code, les données statiques, le tas et la pile) dans la mémoire Flash (en lecture seule) et RAM (en lecture-écriture) de l'appareil.
Vérification rapide des notions de base de l'embarqué
Vérifions votre compréhension des fondamentaux de Rust embarqué.
Récapitulatif : débuter avec Rust embarqué
Dans cette leçon, nous avons présenté Rust embarqué, en mettant en évidence ses difficultés particulières telles que la programmation au plus près du matériel et la compilation croisée. Nous avons étudié les principaux composants de la chaîne d'outils, les cartes de développement courantes et la structure fondamentale d'un programme no_std.
Vous avez également appris que faire clignoter une LED est l'équivalent embarqué de « Hello, World! », et vous avez découvert les scripts de l'éditeur de liens. Vous êtes maintenant prêt à approfondir l'écriture de code pour le monde réel !
Questions Fréquemment Posées
La leçon « Introduction à Rust embarqué » est-elle gratuite ?
Oui — le texte complet de « Introduction à Rust embarqué » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Introduction à Rust embarqué » ?
Commencez avec Rust embarqué en découvrant la chaîne d’outils, les cartes de développement courantes et les bases de la programmation sans système d’exploitation. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « Introduction à Rust embarqué » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Introduction à Rust embarqué
- Couches d’abstraction matérielle et pilotes de périphériques
- Concepts du développement de systèmes d’exploitation