Chapitre 01
Introduction & outillage

1. Pourquoi Rust pour le temps réel et la robotique ?

En robotique, le code qui tourne dans la boucle de contrôle (lecture des capteurs, filtre de Kalman, calcul de cinématique inverse, envoi des consignes moteur) doit être rapide, prévisible et fiable. Historiquement, ce terrain est occupé par le C et le C++ : accès direct à la mémoire, pas de garbage collector, compilation vers du code machine optimisé. Rust vise exactement la même niche de performance, mais en corrigeant la plus grande source de bugs de ces deux langages : les erreurs mémoire.

Le compilateur Rust (rustc) impose, via son système de propriété (ownership) et d'emprunts (borrowing) que nous détaillerons au chapitre 4, des règles qui éliminent à la compilation des familles entières de bugs : use-after-free, double free, débordements de tampon, accès concurrents non protégés (data races). Ces bugs ne sont pas juste gênants : sur un robot, un déréférencement de pointeur invalide dans la boucle de commande peut se traduire par un bras qui part dans une direction imprévue. Rust ne rend pas ces bugs « moins graves », il empêche le code de compiler tant qu'ils ne sont pas corrigés.

Soyons honnêtes : l'écosystème C/C++ reste plus mature pour certains drivers bas niveau et pour ROS 1. Rust ne remplace pas magiquement des décennies de bibliothèques existantes. Mais pour du code neuf — calcul numérique, algorithmes d'estimation d'état, logique de contrôle — Rust offre les mêmes performances que le C++ avec une classe de bugs en moins, ce qui compte énormément quand ce code pilote un système physique.

2. Installer Rust avec rustup

L'outil d'installation officiel est rustup. Il gère les versions du compilateur, les cibles de compilation (utile plus tard pour cibler un microcontrôleur) et les composants additionnels. Sous Linux ou macOS :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Sous Windows, télécharge et exécute rustup-init.exe depuis rustup.rs. Dans les deux cas, l'installateur pose quelques questions (garde l'option par défaut « installation standard ») puis met en place trois outils essentiels :

• rustc — le compilateur.
• cargo — le gestionnaire de paquets et de projets (l'équivalent d'un make + apt + CMake réunis).
• rustup lui-même — pour mettre à jour la chaîne d'outils (rustup update) ou installer des composants.

Ajoute ensuite deux composants indispensables au quotidien :

rustup component add clippy   # linter
rustup component add rustfmt  # formateur de code

Vérifie que tout est bien installé :

rustc --version
cargo --version
cargo clippy --version
cargo fmt --version

Tu devrais voir quelque chose comme rustc 1.8x.0 (xxxxxxxxx 2026-xx-xx). Si la commande rustc n'est pas trouvée, redémarre ton terminal (l'installateur modifie le PATH dans ton fichier de profil shell).

3. Créer un premier projet avec cargo

Tout projet Rust sérieux passe par cargo, même pour un seul fichier. Crée le projet qui nous servira de point de départ pour le fil rouge du cours :

cargo new robot_kalman
cd robot_kalman

cargo new génère l'arborescence minimale suivante :

robot_kalman/
├── Cargo.toml     # métadonnées du projet + dépendances (équivalent d'un CMakeLists.txt)
├── .gitignore     # ignore déjà le dossier target/
└── src/
    └── main.rs    # point d'entrée du programme

Cargo.toml ressemble à ceci juste après création :

[package]
name = "robot_kalman"
version = "0.1.0"
edition = "2021"

[dependencies]

La section [dependencies] est vide pour l'instant ; à partir du chapitre 9 nous y ajouterons nalgebra pour l'algèbre linéaire. Contrairement au C++ où lier une bibliothèque implique souvent de bricoler un CMakeLists.txt, ajouter une dépendance Rust se résume à une ligne dans ce fichier ; cargo télécharge, compile et lie la bibliothèque automatiquement.

4. Compiler et exécuter

Trois commandes couvrent l'essentiel du cycle de développement :

cargo check            # vérifie que le code compile, sans générer d'exécutable (rapide)
cargo run               # compile (mode debug) puis exécute
cargo build --release   # compile avec toutes les optimisations activées

cargo check est ton meilleur ami pendant l'écriture du code : il fait tourner l'analyse du compilateur (types, emprunts, etc.) sans passer par la génération de code machine, donc c'est nettement plus rapide qu'une compilation complète. Utilise-le en boucle pendant que tu écris, et cargo run quand tu veux réellement exécuter le programme.

Exécute le projet fraîchement créé :

cargo run

Tu devrais voir s'afficher :

   Compiling robot_kalman v0.1.0 (/chemin/vers/robot_kalman)
    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/robot_kalman`
Hello, world!

5. Le premier programme, ligne par ligne

Ouvre src/main.rs : cargo y a déjà généré le programme le plus simple possible.

fn main() {
    println!("Hello, world!");
}

fn main() déclare la fonction point d'entrée, exactement comme en C. Pas de type de retour ici : une fonction qui ne retourne rien a le type unité (), implicite. Modifions ce programme pour saluer notre projet :

fn main() {
    println!("Bonjour, robot !");
}

Remarque le ! après println : ce n'est pas une fonction, c'est une macro. En Rust, tout identifiant suivi de ! est une macro, invoquée à la compilation. println! vérifie à la compilation que le nombre et le type des arguments correspondent au format demandé — une erreur de format est donc détectée avant même l'exécution, contrairement à printf en C où un mauvais %d/%s est un bug silencieux (voire une faille de sécurité) qui ne se révèle qu'à l'exécution.

fn main() {
    let angle_deg = 42.5;
    let iteration = 7;
    println!("Itération {iteration} — angle mesuré : {angle_deg} deg");
    println!("{} et {} sont interpolés", 0.0, 1.0);
}

6. Cargo.toml : dépendances et profils de compilation

Cargo.toml centralise la configuration du projet. Deux notions à connaître dès maintenant, même si nous les creuserons plus tard :

[package]
name = "robot_kalman"
version = "0.1.0"
edition = "2021"

[dependencies]
# nalgebra = "0.33"   # décommenté au chapitre 9, pour l'algèbre linéaire

# Profil utilisé par "cargo build" et "cargo run" (sans --release)
[profile.dev]
opt-level = 0          # pas d'optimisation : compilation rapide, exécution lente

# Profil utilisé par "cargo build --release"
[profile.release]
opt-level = 3           # optimisations maximales
lto = true               # link-time optimization : inlining inter-modules
codegen-units = 1        # meilleure optimisation au prix d'une compilation plus lente
panic = "abort"          # pas de déroulement de pile en cas de panic : code plus petit et plus prévisible

Le bloc [profile.release] ci-dessus n'est pas obligatoire — Cargo a déjà de bonnes valeurs par défaut pour opt-level et panic — mais c'est une configuration courante en robotique embarquée : lto = true et codegen-units = 1 permettent au compilateur d'optimiser à travers les frontières de modules, ce qui compte pour du code de boucle de contrôle appelé des milliers de fois par seconde.

7. Outillage quotidien : clippy et rustfmt

Deux commandes à exécuter systématiquement avant de committer du code, y compris (surtout) sur un projet de robotique où un avertissement ignoré peut cacher un vrai bug numérique :

cargo clippy   # linter : détecte les erreurs probables et les non-idiomes
cargo fmt      # formate le code selon le style Rust standard

8. Le fil rouge du cours

Tout au long de ce cours, nous allons construire progressivement un même projet, robot_kalman, celui que tu viens de créer. Il évoluera chapitre après chapitre pour devenir un mini moteur de calcul pour bras robotisé, comprenant :

• des types représentant l'état du robot (position articulaire, vitesse, pose de l'effecteur) — chapitre 5 ;
• de l'algèbre linéaire maison puis via nalgebra (vecteurs, matrices) — chapitres 6, 7, 9 et 10 ;
• un calcul de cinématique directe à partir de paramètres de Denavit-Hartenberg — chapitre 11 ;
• un calcul de cinématique inverse par méthode numérique — chapitre 12 ;
• un filtre de Kalman linéaire complet pour fusionner des mesures bruitées et estimer l'état réel du bras — chapitre 13 ;
• des optimisations pensées pour tourner dans une boucle de contrôle temps réel, sans allocation mémoire — chapitre 14.

Garde ce projet ouvert au fil des chapitres : chaque nouvelle notion viendra s'y greffer, exactement comme un vrai projet de robotique grandit au fil du développement.

Exercices

cargo new robot_kalman
cd robot_kalman
cargo run

fn main() {
    println!("Bienvenue dans robot_kalman !");

    let nb_articulations = 6;
    println!("Nombre d'articulations : {nb_articulations}");

    let carre = nb_articulations * nb_articulations;
    println!("Carré du nombre d'articulations : {carre}");
}

cargo build
ls -lh target/debug/robot_kalman

cargo build --release
ls -lh target/release/robot_kalman

fn main() {
    let angle_mesure = 0.1 + 0.2; // en toute rigueur, ne vaut pas exactement 0.3 en binaire
    let angle_cible = 0.3;

    // Version fautive, détectée par clippy (clippy::float_cmp) :
    // if angle_mesure == angle_cible { ... }

    // Version correcte : comparaison à un epsilon près
    let epsilon = 1e-6;
    if (angle_mesure - angle_cible).abs() < epsilon {
        println!("Angle atteint (à epsilon près) !");
    } else {
        println!("Écart résiduel : {}", angle_mesure - angle_cible);
    }
}

Récapitulatif