Idées de projets Arduino : 30 projets du débutant à l'avancé

Tu cherches des idées de projets Arduino ? Tu es au bon endroit : cette liste rassemble 30 projets de niveau débutant, intermédiaire et avancé, et les tableaux t'indiquent ce que fait chaque projet, ce qu'il t'apprend et les composants dont il a besoin. Les idées se compliquent progressivement, de la LED qui s'allume au robot qui évite les obstacles, et chaque niveau s'appuie sur ce que tu as appris au précédent. À la fin, tu trouveras aussi six idées bonus pour l'ESP32 avec Wi-Fi et pour le Raspberry Pi Pico programmé en MicroPython, ainsi qu'une méthode pratique pour planifier un projet du début à la fin.

Pour bien utiliser cette liste, choisis un projet dans le tableau de ton niveau, monte d'abord la version de base, puis améliore-la par petites touches. Ajouter un buzzer à la veilleuse ou un écran au radar de recul t'apprend souvent plus que de commencer un tout nouveau projet. La plupart des projets des tableaux se trouvent dans l'application BlueGrays avec schéma de câblage et code pas à pas ; la colonne "Dans BlueGrays" indique les projets correspondants.

Avant de commencer : de quels composants as-tu besoin ?

Les 7 premiers projets se réalisent tous avec un kit de base : un Arduino Uno (ou Nano), une plaque d'essai, des câbles jumper mâle-mâle, quelques LED de couleur et une LED RGB, des résistances de 220 Ω et 10 kΩ, des boutons-poussoirs, un potentiomètre, une photorésistance (LDR) et un buzzer passif. Pour les projets 8 à 10, ajoute un capteur de distance HC-SR04, un servo SG90 et un capteur de mouvement PIR ; la plupart des kits de démarrage contiennent déjà les trois. Au niveau intermédiaire s'ajoutent des modules comme le DHT11, un écran LCD I2C, un récepteur infrarouge avec télécommande, un afficheur 7 segments et un ruban de LED WS2812B. Au niveau avancé, il te faudra des drivers de moteur, des relais et une alimentation externe. Pour choisir ton kit, consulte le guide du kit de démarrage Arduino ; pour la carte, lis Quel Arduino acheter ?, et pour les connexions internes de la plaque d'essai, Qu'est-ce qu'une breadboard ?.

Niveau débutant : 10 projets Arduino faciles

Les projets de ce niveau enseignent trois compétences de base : la sortie numérique (allumer une LED), l'entrée numérique (lire un bouton) et l'entrée analogique (lire un capteur). Place toujours une résistance devant chaque LED ; pour une LED rouge standard alimentée en 5 V, 220 Ω donnent environ 14 mA, ce qui est sûr. Tu trouveras la bonne valeur pour les autres couleurs avec le calculateur de résistance pour LED.

• Projets à LED (1–3) : la patte longue de la LED (anode) va au plus et la courte (cathode) au moins. Tu trouveras les détails sur les pattes et le choix de la résistance dans Qu'est-ce qu'une LED ? et Qu'est-ce qu'une résistance ?. Régler la durée de l'orange et ajouter un bouton piéton au feu tricolore est une belle première amélioration.
• Projet avec bouton (4) : si tu branches le bouton avec INPUT_PULLUP, aucune résistance externe n'est nécessaire. L'anti-rebond est indispensable pour qu'un appui ne soit pas compté plusieurs fois ; l'article sur le branchement d'un bouton présente les deux méthodes.
• Veilleuse (5) : la LDR et la résistance de 10 kΩ forment un pont diviseur de tension, et analogRead renvoie une valeur entre 0 et 1023. Fixe le seuil en mesurant dans ta propre pièce ; les détails sont dans l'article sur la photorésistance LDR.
• Mélodie (6) : un buzzer actif ne produit qu'une seule tonalité ; pour une mélodie, il faut un buzzer passif. Tu peux voir la différence dans Qu'est-ce qu'un buzzer ?.
• LED RGB (7) : les modèles à anode commune et à cathode commune fonctionnent en logique inversée ; si tu te trompes de type, les couleurs sortent inversées. Le guide utiliser une LED RGB explique les deux types.
• Projets avec capteurs (8–10) : le HC-SR04, le servomoteur et le capteur PIR sont les briques du niveau suivant ; les faire fonctionner d'abord séparément facilite beaucoup les projets intermédiaires.

Niveau intermédiaire : 10 projets Arduino

Au niveau intermédiaire, tu n'utilises plus un seul composant mais plusieurs modules ensemble : tu affiches la valeur d'un capteur sur un écran, tu allumes une LED avec une télécommande ou tu accélères un buzzer selon une mesure. Deux compétences ressortent ici : installer des bibliothèques et temporiser avec millis(). Un radar de recul écrit avec delay() ne peut pas produire un son correct pendant qu'il mesure ; avec millis(), les deux se font en même temps.

• Radar de recul (11) : diviser par 58 le temps d'écho du HC-SR04 en microsecondes donne la distance en centimètres. Tu trouveras le code non bloquant de ce projet plus bas, dans la partie planification ; les détails du capteur sont dans l'article HC-SR04.
• Afficheur de température (12) : ne lis pas le DHT11 plus d'une fois par seconde ; le capteur produit au maximum une nouvelle valeur par seconde. Brancher l'écran en I2C ne demande que 4 fils ; voir DHT11 et écran LCD I2C.
• Horloge numérique et dé (14, 17) : sur les afficheurs 7 segments, la différence entre anode commune et cathode commune est essentielle ; l'article sur l'afficheur 7 segments donne les tables de segments.
• Télécommande et Bluetooth (15, 18) : chaque touche d'une télécommande IR possède son propre code, qu'il faut d'abord lire sur le moniteur série. Les détails sont dans les articles récepteur IR et télécommande et module Bluetooth HC-05.
• NeoPixel (20) : chaque LED WS2812B peut consommer environ 60 mA en blanc maximal, si bien qu'un ruban de 30 LED peut atteindre 1,8 A. Les détails sont dans l'article WS2812B NeoPixel.

Niveau avancé : 10 projets Arduino

Les projets avancés combinent plusieurs capteurs, des moteurs et des charges du monde réel. Ici, la conception de l'alimentation et la mécanique comptent autant que le code : alimenter les moteurs séparément, brancher le relais en toute sécurité, bien fixer les câbles. Côté code, raisonner en machine à états te simplifie la vie : pour une serrure, par exemple, tu définis séparément des états comme "en attente, saisie du code, ouverte, alarme" et, dans chaque état, tu ne fais que le travail qui lui correspond.

• Projets de serrure (21–22) : enregistrer le code dans l'EEPROM plutôt que de l'écrire en dur dans le programme conserve tes réglages même si la carte est éteinte puis rallumée. Pour le câblage, vois les articles clavier matriciel et RFID RC522 ; n'oublie pas que le RC522 fonctionne en 3,3 V.
• Robots (23–24) : les moteurs à courant continu ne se branchent pas directement sur une broche de l'Arduino ; il faut un driver comme le L298N. Le L298N fait chuter la tension de 2 V ou plus, alors alimente des moteurs de 6 V avec une source de 7 à 9 V. Les détails sont dans l'article piloter un moteur CC avec le L298N.
• Arrosage intelligent (25) : les capteurs de sol résistifs bon marché se corrodent s'ils sont alimentés en permanence ; alimente le capteur depuis une broche uniquement pendant la mesure. Utilise un relais pour la pompe ; voir capteur d'humidité du sol et module relais.
• Alarme gaz (26) : la résistance chauffante du MQ-2 a besoin de quelques minutes de préchauffage à chaque mise sous tension ; fixe le seuil en mesurant à l'air pur une fois le capteur chaud. Les détails sont dans l'article capteur de gaz MQ-2.
• Jeux (28–29) : le tampon d'image de 1 Ko de l'OLED occupe la moitié des 2 Ko de RAM de l'Uno ; surveille l'utilisation de la mémoire dans les jeux. Pour les commandes, tu peux utiliser un joystick à la place des boutons ; pour l'écran, consulte l'article OLED SSD1306.

6 idées bonus avec l'ESP32 et le Raspberry Pi Pico

Si ton projet doit se connecter à Internet, être piloté depuis un téléphone ou envoyer des données à un serveur, passer de l'Arduino Uno à l'ESP32 est la voie la plus simple : le Wi-Fi et le Bluetooth sont intégrés et il se programme avec le même Arduino IDE. Le Raspberry Pi Pico, lui, est bon marché, rapide et programmable en MicroPython, ce qui en fait un excellent choix si tu veux apprendre Python. Pour choisir, aide-toi du comparatif Arduino ou ESP32 ?, et pour démarrer, lis les articles Qu'est-ce que l'ESP32 ? et Qu'est-ce que le Raspberry Pi Pico ?.

Comment planifier un projet du début à la fin ?

1. Décris en une phrase ce qu'il doit faire : "Si un obstacle est à moins de 50 cm, les bips doivent accélérer." Si la phrase est claire, le projet l'est aussi.
2. Liste les entrées et les sorties : les entrées sont les capteurs et les boutons ; les sorties, les LED, buzzers, moteurs et écrans. Attribue une broche à chacun ; tu peux voir le brochage de ta carte dans l'outil Pinout.
3. Calcule le budget de courant : additionne le courant consommé par chaque composant. Une broche d'Arduino Uno supporte 40 mA en maximum absolu, et tu ne devrais pas dépasser 20 mA pour un fonctionnement sûr ; au-delà, utilise un transistor, un relais ou un driver. L'outil loi d'Ohm s'occupe des calculs.
4. Teste chaque module séparément : lis d'abord le capteur sur le moniteur série et fais sonner le buzzer avec un programme à part. Si tu branches tout d'un coup et que rien ne marche, trouver la panne devient beaucoup plus difficile.
5. Assemble les morceaux : regroupe le code dans une seule loop() en utilisant millis() au lieu de delay(), pour que chaque tâche s'exécute à son rythme.
6. Mets-le en boîtier et documente-le : photographie le circuit qui fonctionne et garde le tableau de câblage et le code. Tu gagneras beaucoup de temps en réutilisant les mêmes composants dans ton prochain projet.

Appliquons ces étapes au radar de recul du niveau intermédiaire. L'entrée est le HC-SR04 (TRIG sur la broche 9, ECHO sur la broche 10) et la sortie un buzzer passif (broche 8). Le capteur consomme environ 15 mA et un petit buzzer passif reste dans les limites de la broche ; le courant total est donc largement couvert par l'USB. Le code ci-dessous mesure la distance environ 16 fois par seconde et, quand un obstacle est à moins de 50 cm, accélère les bips proportionnellement à la distance : chaque bip et le silence qui le suit durent 10 ms par centimètre, soit 400 ms à 40 cm et 100 ms à 10 cm. En dessous de 5 cm, le son devient continu.

1const int TRIG = 9;
2const int ECHO = 10;
3const int BUZZER = 8;                       // pasif buzzer / passive buzzer
4
5unsigned long olcumZaman = 0, bipZaman = 0;
6long mesafe = 400;                          // cm
7bool bipAcik = false, sesCaliyor = false;
8
9long mesafeOlc() {
10  digitalWrite(TRIG, LOW);
11  delayMicroseconds(2);
12  digitalWrite(TRIG, HIGH);
13  delayMicroseconds(10);                    // 10 µs tetik darbesi / 10 µs trigger pulse
14  digitalWrite(TRIG, LOW);
15  unsigned long sure = pulseIn(ECHO, HIGH, 30000UL);  // en fazla 30 ms bekle / wait at most 30 ms
16  if (sure == 0) return 400;                // yankı yok: engel uzakta / no echo: obstacle is far
17  return sure / 58;                         // µs -> cm
18}
19
20void setup() {
21  pinMode(TRIG, OUTPUT);
22  pinMode(ECHO, INPUT);
23  pinMode(BUZZER, OUTPUT);
24}
25
26void loop() {
27  unsigned long simdi = millis();
28  if (simdi - olcumZaman >= 60) {           // saniyede yaklaşık 16 ölçüm / about 16 readings per second
29    olcumZaman = simdi;
30    mesafe = mesafeOlc();
31  }
32
33  bool sesli = false;
34  if (mesafe < 5) {                         // çok yakın: sürekli ses / very close: continuous tone
35    sesli = true;
36  } else if (mesafe < 50) {                 // yaklaştıkça bipler sıklaşır / beeps speed up as it gets closer
37    if (simdi - bipZaman >= (unsigned long)mesafe * 10) {
38      bipZaman = simdi;
39      bipAcik = !bipAcik;
40    }
41    sesli = bipAcik;
42  }
43
44  if (sesli != sesCaliyor) {                // yalnızca değişince çal ya da sustur / switch only on change
45    sesCaliyor = sesli;
46    if (sesli) tone(BUZZER, 2000);
47    else noTone(BUZZER);
48  }
49}

Deux points du code méritent ton attention. D'abord, nous avons donné à pulseIn() un délai maximal de 30 ms ; si aucun écho ne revient, le code n'attend pas indéfiniment et considère la distance comme égale à 400 cm. Ensuite, tone() n'est appelé que lorsque l'état du son change ; ainsi le buzzer n'est pas relancé à chaque passage et ne grésille pas. Pour aller plus loin, essaie d'afficher la distance sur un écran LCD I2C ou OLED et d'ajouter une barre d'alerte de LED vertes, jaunes et rouges.

Erreurs fréquentes dans le choix et le montage des projets

Quel projet est fait pour toi ? Choix rapide selon tes centres d'intérêt

Quand tu auras terminé les 30 projets de la liste, tu auras utilisé presque toutes les briques de base de l'Arduino : entrées et sorties numériques et analogiques, PWM, I2C, temporisation, pilotage de moteurs et machines à états. Pour savoir à quoi sert chaque capteur, jette aussi un œil au guide des capteurs Arduino. Dans l'application BlueGrays, tu trouveras la plupart de ces idées, de la LED qui s'allume au robot éviteur d'obstacles et de la station d'arrosage intelligente au serveur web ESP32, avec des schémas pas à pas et du code prêt à l'emploi, pour démarrer tout de suite avec un projet adapté à ton niveau.