Par Rémi Favreau — 23 avril 2026

La question que me posent le plus souvent les débutants n’est pas « comment ça marche » mais « par où je commence ». La robotique DIY est intimidante parce qu’elle cumule plusieurs disciplines : mécanique, électronique, programmation, parfois vision par ordinateur. Si on prend chaque brique individuellement, aucune n’est compliquée. Le problème, c’est de savoir dans quel ordre les assembler. Ce guide est la carte du territoire.

Tout ce qui suit est basé sur ce que j’ai vu fonctionner en atelier avec des ados et des adultes qui n’avaient jamais tenu un fer à souder. Le plan est volontairement progressif : on commence par faire clignoter une LED, et on finit avec un robot mobile qui évite les murs. Pas de raccourci, pas de magie, juste six briques empilées dans le bon ordre.

Les six briques d’un robot

Tout robot, du plus simple au plus complexe, se décompose en six parties fonctionnelles. Comprendre ces six briques avant de toucher un seul composant évite de se perdre en route.

1. Le cerveau : la carte de contrôle qui exécute le programme. Raspberry Pi, Arduino, ESP32, ou un simple microcontrôleur PIC. C’est lui qui prend les décisions.
2. Les muscles : les moteurs et leurs drivers. Ils transforment un signal électrique en mouvement physique. Sans eux, le robot est un presse-papier intelligent.
3. Les sens : les capteurs. Ultrason pour la distance, IR pour la ligne, IMU pour l’orientation, caméra pour la vision. On les détaille dans l’article dédié aux cinq capteurs de base.
4. Le squelette : le châssis, la structure qui tient tout ensemble. Acheté en kit, imprimé en 3D, ou bricolé en carton et vis.
5. L’énergie : l’alimentation. Batteries, piles, powerbank. La brique qu’on sous-estime toujours et qui fait capoter la moitié des premiers projets.
6. L’intelligence : le code. Quelques dizaines de lignes Python pour les projets simples, des milliers pour les projets avancés. C’est ce qui donne au robot un comportement.

On peut travailler chaque brique isolément. C’est d’ailleurs comme ça que je recommande de commencer : faire tourner un moteur sans se soucier du capteur, puis lire un capteur sans se soucier du moteur, puis combiner les deux.

Choisir son cerveau : Pi vs Arduino vs ESP32

Le choix de la carte de contrôle conditionne tout le reste. Voici les trois options principales en 2026, sans langue de bois.

Carte	Force principale	Faiblesse principale	Meilleur usage	Prix
Raspberry Pi 4/5	Linux complet, caméra CSI, réseau intégré, Python natif	Consomme beaucoup (2-3W idle, jusqu’à 8-9W en charge sur Pi 5), surdimensionné pour les tâches simples	Vision par ordinateur, serveur embarqué, projets complexes	45-80 €
Arduino Uno/Nano	Temps réel vrai (pas d’OS qui interfère), ultra-simple, 5V natif	Pas de réseau, pas de caméra, mémoire ridicule (2 Ko RAM)	Contrôle moteurs pur, capteurs analogiques, prototypage rapide	5-25 €
ESP32 (famille)	Wi-Fi + Bluetooth intégrés, petit, pas cher, MicroPython ou Arduino IDE	Famille éclatée en 2026 : ESP32 original (dual-core Xtensa), ESP32-S3 (Xtensa LX7), ESP32-C3/C6 (RISC-V single-core). Vérifier la variante achetée.	Projets IoT, télécommande sans fil, capteurs connectés	4-12 €

Mon avis tranché : si c’est ton tout premier robot et que tu n’as jamais touché d’électronique, commence avec un Arduino Nano. Pas un Pi. L’Arduino te force à comprendre le GPIO, le PWM, le timing, les interruptions, sans la couche de complexité d’un système d’exploitation. Quand tu auras fait clignoter une LED, tourner un moteur, et lire un capteur sur Arduino, tu passeras au Pi naturellement pour ajouter la caméra et le réseau. Je sais que sur un site qui s’appelle « RasRobot » cette recommandation est paradoxale. C’est assumé.

La combinaison la plus puissante pour un robot intermédiaire : un Pi qui fait le « gros cerveau » (vision, décisions, réseau) et un Arduino en esclave qui fait le « petit cerveau » (contrôle moteurs en temps réel, lecture capteurs rapides). Les deux communiquent via UART série. C’est l’architecture de nombreux robots professionnels simplifiée. Pour la doc officielle : Arduino docs, Espressif ESP-IDF, Raspberry Pi docs.

Moteurs : faire bouger le robot

Trois familles de moteurs coexistent en robotique DIY. Chacune correspond à un type de mouvement.

Moteur DC (courant continu)

Le plus intuitif : on envoie du courant, ça tourne. On inverse la polarité, ça tourne dans l’autre sens. On module le courant en PWM, ça tourne plus ou moins vite. C’est le moteur qu’on trouve dans les kits « Smart Car 2WD » et dans le tutoriel robot 2 roues.

Avantage : simple, pas cher (2 à 5 euros), disponible partout. Inconvénient : pas de positionnement précis sans encodeur externe. Il tourne, mais il ne sait pas de combien il a tourné. Pour des roues motrices sur un robot mobile, c’est parfait. Pour positionner un bras robotique, c’est insuffisant.

Driver associé : le L298N (pont en H dual, 3 à 5 euros), ou le DRV8833 (plus moderne, plus efficace, 2 euros). Le tutoriel L298N détaille le câblage et le code Python.

Moteur pas-à-pas (stepper)

Tourne par incréments discrets (« pas »). Un NEMA 17 standard fait 200 pas par tour, soit 1,8° par pas. Avec un driver microstepping (A4988, TMC2209), on descend à 0,1° par pas. Précision excellente, pas besoin de retour d’information (boucle ouverte). C’est le moteur des imprimantes 3D et des CNC.

Inconvénients : bruyant à basse vitesse (le « chant » caractéristique des imprimantes 3D), consomme du courant même à l’arrêt pour maintenir la position, et le couple diminue avec la vitesse. Pour un robot mobile, c’est rarement le bon choix. Pour un plateau tournant, une tourelle de caméra ou une machine de pick-and-place, c’est idéal.

Servomoteur

Un moteur DC avec réducteur et potentiomètre intégré dans un boîtier compact. On lui envoie un signal PWM (1 ms = 0°, 1,5 ms = 90°, 2 ms = 180°), il se positionne à l’angle demandé et y reste. Le SG90 à 2 euros fait 0-180° avec un couple de 1,8 kg/cm. Le MG996R à 5 euros monte à 10 kg/cm. C’est le moteur des bras articulés, des pattes de marcheur, des tourelles.

Piège classique : ne jamais alimenter un servo depuis le rail 5V du Pi. Un SG90 tire 500 mA en charge, un MG996R peut dépasser 2A. Il faut une alimentation séparée (régulateur BEC 5V 3A ou pack de piles AA dédié), avec la masse commune au Pi.

L’alimentation : la brique qui fait tout rater

Sur les quinze projets que j’ai vus échouer au club scout, douze avaient un problème d’alimentation. Moteurs qui tournent mou, Pi qui reboot au démarrage du moteur, robot qui marche sur la table et s’arrête dès qu’il monte une pente. Presque toujours, le problème est que l’alimentation des moteurs et celle du Pi ne sont pas séparées, ou que la source n’est pas dimensionnée.

Règle d’or : deux circuits, une masse. Le Pi a sa propre alimentation (powerbank USB ou alim secteur 5V 3A). Les moteurs ont leur propre source (piles AA, LiPo, batterie NiMH). Les deux partagent uniquement le fil de masse (GND) pour que le Pi puisse envoyer des signaux de contrôle au driver. Si tu branches les moteurs directement sur le rail 5V du Pi, chaque pic de courant au démarrage d’un moteur fait chuter la tension et le Pi crashe. J’ai vu ce problème si souvent que c’est la première chose que je vérifie quand un projet ne marche pas.

Quel type de batterie choisir ?

• Piles AA (4 ou 6 en série) : solution la plus sûre pour débuter. 4×AA = 6V, 6×AA = 9V. Pas de risque d’incendie, facile à remplacer, disponible au supermarché. Inconvénient : tension qui chute au fur et à mesure de la décharge, poids élevé.
• LiPo 7,4V (2S) : plus léger, tension plus stable, rechargeable. Mais exige des précautions de sécurité strictes (ne pas décharger sous 6,6V, ne pas perforer, stocker dans un sac ignifugé). Pour un projet supervisé avec des ados, on reste aux piles AA.
• NiMH rechargeables : compromis entre les deux. Moins dangereuses que la LiPo, rechargeables, bonne capacité. Tension légèrement inférieure aux alcalines (1,2V vs 1,5V par cellule).

Consommation réelle : Pi 4 vs Pi 5 (chiffres mesurés)

Pour dimensionner l’alimentation d’un robot mobile, il faut savoir précisément ce que tire la carte de contrôle en fonction de sa charge. Voici les chiffres publiés par la communauté (Jeff Geerling, CNX Software) en 2024-2025.

État	Pi 4 (4 Go)	Pi 5 (4 Go)	Arduino Nano
Idle (rien à faire)	~2,8 W	~2,6 W	~0,1 W
Charge moyenne (Python, capteur)	~3,5 W	~4 W	~0,2 W
Charge forte (OpenCV, 4 cœurs)	~5,5 W	~8,8 W	(N/A)
Standby (Pi 5 avec power button)	(N/A)	~1,3 W	~0 W

Implication concrète pour ton robot mobile : avec un powerbank 5 000 mAh à 5 V (soit 25 Wh théoriques, ~22 Wh utilisables), compte 4 à 5 heures d’autonomie sur un Pi 4 en charge moyenne, 3 à 4 heures sur un Pi 5 (qui consomme 30 % de plus en charge soutenue). Un Arduino Nano dans les mêmes conditions tiendrait 200+ heures — c’est pour ça qu’il reste la meilleure option pour les petits robots à batterie.

💡 En résumé : Pi 5 plus performant mais 30 % plus gourmand en charge. Pour un robot simple qui ne fait pas de vision par ordinateur, le Pi 4 reste le meilleur compromis consommation/performance. Arduino pour les projets à très longue autonomie (capteur nomade, alarme, tracker).

Le châssis : acheter ou fabriquer

Trois voies, chacune avec ses avantages.

Le kit tout-en-un. Les « Smart Car 2WD/4WD » vendus entre 8 et 25 euros incluent le châssis en acrylique ou aluminium, les moteurs DC, les roues, la roulette folle, la visserie. Avantage : prêt en 20 minutes. Inconvénient : rigidité et adaptabilité limitées. Pour un premier robot, c’est le meilleur choix parce que le temps passé à fabriquer un châssis est du temps qu’on ne passe pas à comprendre le code et les capteurs.

L’impression 3D. Si tu as accès à une imprimante 3D (la tienne, celle d’un fablab, ou un service d’impression en ligne), les modèles sur Thingiverse et Printables sont innombrables. Coût matière : 2 à 5 euros. Temps d’impression : 3 à 8 heures selon la taille. L’avantage décisif : la personnalisation est infinie. On imprime le châssis autour des composants plutôt que d’adapter les composants au châssis.

La construction maison. Carton fort, contreplaqué, profilés aluminium de chez Leroy Merlin, boîte de conserve découpée (oui, j’ai vu ça au club). C’est moche, c’est bancal, et c’est exactement ce qui rend le projet mémorable. Le robot en boîte de raviolis qui finit par rouler droit a plus de valeur pédagogique que le kit parfait sorti de la boîte.

Le code : structure d’un programme robot

Quel que soit le langage (Python sur Pi, C++ sur Arduino, MicroPython sur ESP32), un programme de robot suit toujours le même squelette. C’est la boucle « sense-think-act » :

#!/usr/bin/env python3
"""
Squelette sense-think-act pour robot DIY.
Testé sur Pi 4 + L298N + HC-SR04 avec moteurs DC de kit 2WD.
Code complet sur github.com/rasrobot/robot-diy-examples (MIT).
"""
from gpiozero import Motor, DistanceSensor
from time import sleep
import sys

# --- Configuration matérielle (à adapter à ton câblage) ---
moteur_g = Motor(forward=17, backward=27, enable=12)
moteur_d = Motor(forward=22, backward=23, enable=13)
capteur = DistanceSensor(echo=25, trigger=24, max_distance=2)

SEUIL_CM = 20
VITESSE = 0.7

# === 1. SENSE ===
def lire_capteurs():
    """Retourne la distance en cm devant le robot."""
    return capteur.distance * 100

# === 2. THINK ===
def decider(distance):
    """Logique minimale : éviter si obstacle proche, sinon avancer."""
    if distance < SEUIL_CM:
        return "eviter"
    return "avancer"

# === 3. ACT ===
def avancer():
    moteur_g.forward(VITESSE)
    moteur_d.forward(VITESSE)

def tourner_droite(duree=0.3):
    moteur_g.forward(VITESSE)
    moteur_d.backward(VITESSE)
    sleep(duree)

def stop():
    moteur_g.stop()
    moteur_d.stop()

def agir(action):
    if action == "eviter":
        stop()
        sleep(0.1)
        tourner_droite()
        stop()
    else:
        avancer()

# === Boucle principale (~20 Hz) ===
try:
    print("Robot démarré. Ctrl+C pour arrêter.")
    while True:
        distance = lire_capteurs()
        action = decider(distance)
        agir(action)
        sleep(0.05)  # 20 itérations/seconde
except KeyboardInterrupt:
    stop()
    print("Arrêt propre.")
    sys.exit(0)

💡 En résumé : lire capteurs → décider → piloter moteurs, en boucle. Toutes les complexités (PID, IA, vision par ordinateur) sont des variantes plus sophistiquées de ces trois étapes.

Ce squelette a l'air trivial, mais il structure la pensée. Les erreurs les plus courantes chez les débutants sont : mélanger la lecture capteur et l'action moteur dans la même fonction (impossible à déboguer), oublier le sleep en fin de boucle (le CPU tourne à 100 % pour rien), et ne pas gérer l'arrêt propre (Ctrl+C qui laisse les moteurs sous tension).

Progression recommandée : de la LED au robot qui navigue

Voici l'ordre que j'utilise en atelier. Chaque marche prend entre 2 et 10 heures selon ton rythme.

1. Allumer une LED : le « Hello World » de l'électronique. 10 minutes, zéro risque, satisfaction immédiate. Le tuto LED est ici.
2. Lire un bouton poussoir : comprendre les entrées digitales, les interruptions, le debouncing.
3. Faire tourner un moteur DC : brancher un L298N, écrire trois lignes Python, voir le moteur répondre.
4. Mesurer une distance : brancher un HC-SR04, lire la distance en temps réel dans le terminal.
5. Combiner moteur + capteur : le robot 2 roues évite-obstacles. C'est le premier « vrai » robot.
6. Ajouter l'odométrie : des encodeurs sur les roues, un compteur de distance, un robot qui sait où il est.
7. Ajouter la vision : Pi Camera + OpenCV. Le robot « voit » un objet coloré et le suit. Un saut de complexité, mais le résultat est spectaculaire.

Le piège classique est de vouloir commencer à l'étape 5 ou 7 sans avoir fait les étapes 1 à 4. Ça fonctionne rarement. Les bases (GPIO, PWM, lecture capteur, alimentation) doivent être solides avant de construire dessus. C'est ennuyeux à dire, mais c'est la réalité que j'observe en atelier depuis des années.

Combien ça coûte, au total

Budget réaliste pour un premier robot mobile fonctionnel, tout compris :

Composant	Budget
Carte de contrôle (Pi 4 occasion ou Arduino Nano clone)	10-45 €
Kit châssis 2WD + moteurs + roues	8-15 €
Driver moteur L298N ou DRV8833	3-5 €
Capteur ultrason HC-SR04	2-3 €
Breadboard + fils dupont	3-5 €
Piles AA + support	5-8 €
Carte microSD (si Pi)	8-12 €

Avec un Arduino Nano clone : 35 à 55 euros. Avec un Raspberry Pi 4 d'occasion : 55 à 90 euros. Ce sont des ordres de grandeur, pas des prix exacts. Le coût baisse si tu récupères des composants (vieux clavier USB, câbles USB qui traînent, carton pour le châssis) et monte si tu achètes tout neuf chez un distributeur français avec livraison express.

Questions fréquentes

Par quel cerveau commencer quand on n'a jamais touché à l'électronique ?

Arduino Nano ou Uno. Le Pi est plus puissant mais ajoute la complexité d'un système d'exploitation, de la configuration Wi-Fi, de la carte SD. L'Arduino te force à comprendre ce que fait chaque broche. Quand tu auras fait clignoter une LED, tourner un moteur et lire un capteur sur Arduino, tu passeras au Pi naturellement.

Combien de temps pour aller de zéro au premier robot qui roule ?

Une dizaine d'heures réparties sur deux ou trois week-ends, en suivant la progression recommandée (LED → moteur → capteur → combinaison). L'erreur classique est de vouloir aller directement au robot mobile sans avoir maîtrisé le GPIO et le PWM. Ça finit presque toujours en frustration et abandon.

Peut-on construire un robot entièrement sans soudure ?

Oui. Breadboard + fils dupont suffisent pour 80 % des projets débutants. Quelques composants exigent la soudure (Raspberry Pi Zero 2W qui n'a pas de header soudé, certains capteurs breakout bas de gamme). Un fer à souder à 15 euros + de l'étain sans plomb s'apprend en une après-midi et ouvre beaucoup de possibilités.

Budget minimum pour un vrai premier robot mobile ?

Entre 30 et 45 euros tout compris si tu pars sur un Arduino Nano clone (10 €) + kit châssis 2WD (10 €) + L298N (4 €) + HC-SR04 (2 €) + breadboard/fils (4 €) + piles AA avec support (5 €). Avec un Raspberry Pi, compter 55 à 90 euros. Les clones chinois fonctionnent très bien pour apprendre.

Le robot doit-il absolument utiliser Python ?

Non. Sur Arduino, c'est du C++ (l'IDE Arduino simplifie fortement la syntaxe C++). Sur ESP32, tu as le choix entre C++ (Arduino IDE ou ESP-IDF) et MicroPython. Sur Raspberry Pi, Python est le plus répandu mais rien n'empêche d'utiliser Node.js, Go ou Rust. Pour un premier projet, reste sur Python ou l'IDE Arduino selon ta plateforme.

Quelles sont les erreurs qui cassent le hardware définitivement ?

Cinq classiques : brancher du 5V sur une broche qui tolère 3,3V max (HC-SR04 ECHO direct sur GPIO Pi), inverser la polarité d'un composant polarisé (LED à l'envers c'est OK, condensateur électrolytique à l'envers c'est un mini pétard), court-circuiter VCC et GND, tirer plus de courant qu'une broche GPIO ne peut fournir (pas de LED sans résistance), et laisser une LiPo en décharge profonde. La plupart des autres erreurs sont récupérables.

Les cinq erreurs que tout le monde fait

En six ans d'ateliers, j'ai compilé les incidents récurrents. Pas trois, pas dix, cinq. Les mêmes, à chaque fois.

• Alimenter les moteurs via le Pi. Déjà dit plus haut, mais ça mérite d'être répété : le Pi n'est pas une source d'énergie pour les moteurs. Deux circuits, une masse.
• Oublier la masse commune. Deux alimentations séparées, oui. Mais GND doit être partagé entre le Pi et le driver, sinon les signaux logiques ne sont pas référencés et le driver reçoit du bruit au lieu de commandes.
• Brancher le HC-SR04 directement sur le GPIO (sans pont diviseur). Le capteur fonctionne en 5V, le Pi en 3,3V. Sans pont diviseur, le signal ECHO à 5V peut endommager la broche GPIO. Deux résistances, 30 secondes de montage, et le problème est réglé pour toujours.
• Tester sur une table. Un robot mal câblé peut foncer droit devant à pleine vitesse. Sur une table, ça finit par terre. Toujours tester au sol, dans un espace dégagé, avec la main prête à débrancher l'alimentation moteurs.
• Vouloir tout faire en même temps. Brancher moteurs, capteurs, caméra, IMU, servos le premier jour. Résultat : câblage spaghetti, impossible de diagnostiquer quel composant pose problème. Une brique à la fois.

Si ton robot ne marche pas et que tu es bloqué, passe par la page contact. Les photos de câblage et les messages d'erreur du terminal sont les deux informations les plus utiles pour diagnostiquer à distance. Le guide ultime du Raspberry Pi couvre les bases matérielles si tu as besoin de reprendre en amont.