Projets Arduino vacances d'hiver : plan pas à pas sur 14 jours
Projets Arduino pour les vacances d'hiver : un plan de 14 jours avec un kit de démarrage, trois voies (Uno, ESP32, Pico), liste de matériel et projet final.
La meilleure façon de réussir des projets Arduino pendant les vacances d'hiver n'est pas de bricoler au hasard pendant deux semaines, mais d'enchaîner de petits projets où chaque jour s'appuie sur le précédent. Dans ce guide, tu trouveras un plan prêt à l'emploi : avec un kit de démarrage et 1 à 2 heures par jour, tu passes en 14 jours de l'allumage d'une LED à la lecture de capteurs, à l'affichage de texte sur un écran et à la commande d'un moteur. Le projet de chaque jour, le matériel nécessaire et le lien vers l'article détaillé sont indiqués ; à la fin, tu réaliseras un projet final qui réunit tout ce que tu as appris.
Le plan s'adapte à trois voies : l'Arduino Uno si tu n'as aucune expérience, l'ESP32 si tu as les bases et veux connecter ton projet à Internet, la Raspberry Pi Pico si tu veux apprendre Python. Les sujets des jours sont les mêmes dans les trois voies ; seuls la carte, les numéros de broches et le langage changent. Si tu n'as pas encore de carte, tu peux faire les premiers jours dans le simulateur Wokwi ou Tinkercad, puis passer au vrai montage quand ton matériel arrive.
Avant de commencer : quel matériel te faut-il ?
Presque toute la liste ci-dessous se trouve dans les kits de démarrage standard. S'il te manque une pièce, change simplement l'ordre des jours ; par exemple, sans servo, remplace le jour 13 par un projet de mélodie avec buzzer. Si tu hésites sur le kit à choisir, l'article sur le kit de démarrage Arduino compare en détail leur contenu.
| Matériel | Quantité | Jours d'utilisation |
|---|---|---|
| Arduino Uno, ESP32 ou Raspberry Pi Pico + câble USB | 1 | Tous les jours |
| Breadboard et fils de connexion mâle-mâle | 1 + 30 | Tous les jours |
| LED (rouge, jaune, verte) | 6–8 | 1, 2, 3, 6, 7, 9, 11 |
| Résistance 220 Ω | 8 | 1, 2, 3, 6, 7, 11 |
| Résistance 10 kΩ | 2 | 7 |
| Résistance 1 kΩ (diviseur de tension pour ESP32 et Pico) | 3 | 10, 11 |
| Bouton poussoir | 2 | 4, 7, 9 |
| Potentiomètre 10 kΩ | 1 | 5, 13 |
| LED RVB | 1 | 6 |
| LDR (photorésistance) | 1 | 7 |
| Buzzer passif | 1 | 8, 11 |
| Capteur de distance HC-SR04 | 1 | 10, 11 |
| Capteur de température et d'humidité DHT11 | 1 | 12 |
| Écran LCD 16x2 I2C | 1 | 12, 14 |
| Servomoteur SG90 | 1 | 13, 14 |
Quelle voie choisir : Uno, ESP32 ou Pico ?
Les trois cartes peuvent réaliser tout ce plan, mais chacune offre une expérience d'apprentissage différente. L'Uno fonctionne en 5 V, donc elle se branche directement à tous les modules du kit, et la grande majorité des exemples en ligne sont écrits pour elle ; si tu découvres l'électronique, c'est la voie où le débogage est le plus simple. L'ESP32 se programme avec le même langage Arduino, mais son processeur double cœur à 240 MHz, son Wi-Fi et son Bluetooth permettent de consulter ton projet final depuis un téléphone ; en contrepartie, n'oublie pas que ses broches fonctionnent en 3,3 V. La Pico, elle, exécute ton code MicroPython dès que tu l'enregistres ; si tu fais du Python au lycée, tu transposes directement tes connaissances au matériel. Si tu hésites, jette un œil au comparatif Arduino ou ESP32.
| Voie | Pour qui ? | Langage et éditeur | Points forts | À surveiller |
|---|---|---|---|---|
| Arduino Uno | Ceux qui débutent en électronique | C++ Arduino, IDE Arduino | Broches 5 V, compatibilité directe avec tous les modules du kit, le plus d'exemples de code | Pas de Wi-Fi, seulement 2 Ko de RAM |
| ESP32 | Ceux qui ont les bases et veulent se connecter à Internet | C++ Arduino, IDE Arduino (paquet de cartes ESP32) | Wi-Fi et Bluetooth, double cœur 240 MHz, CAN 12 bits | Broches 3,3 V, diviseur de tension nécessaire pour les capteurs à signal 5 V |
| Raspberry Pi Pico | Ceux qui veulent apprendre Python | MicroPython, Thonny | Exécution immédiate sans compilation, double cœur 133 MHz, prix bas | Broches 3,3 V, pas de connexion sans fil sur la Pico classique (la Pico W en a) |
Organisation quotidienne : la règle de 1 à 2 heures
- 15 premières minutes de lecture : lis l'article du jour, puis dessine sur papier le schéma du circuit et le tableau des broches.
- 30 à 45 minutes de montage et de code : monte le circuit câble USB débranché, vérifie encore une fois les connexions, puis téléverse le code.
- 20 minutes de modifications : une fois le code fonctionnel, change au moins un élément toi-même : la durée, la broche, le seuil ou le nombre de LED. C'est là que l'on apprend vraiment.
- 10 minutes de notes : note dans un carnet ce que tu as fait, où tu as bloqué et comment tu as résolu le problème ; pour le projet final, ces notes te feront gagner beaucoup de temps.
- Jours souples : si tu es malade ou si un projet déborde, tu peux utiliser les jours 7 et 14 comme jours de rattrapage.
Semaine 1 : les bases (jours 1 à 7)
L'objectif de la première semaine est d'apprendre par la pratique quatre notions fondamentales : sortie numérique, entrée numérique, lecture analogique et PWM. Chaque jour ajoute en moyenne une nouvelle commande et une nouvelle pièce ; à la fin du jour 7, tu utiliseras sans souci pinMode, digitalWrite, digitalRead, analogRead, analogWrite et Serial.println.
- Jour 1 – Allumer une LED : fais tourner Blink avec la LED intégrée, puis branche une LED externe sur D13 via une résistance de 220 Ω sur la breadboard et modifie la durée du clignotement. Matériel : carte, breadboard, 1 LED, 1 résistance 220 Ω. À lire : Comment utiliser une breadboard, Calcul de la résistance d'une LED.
- Jour 2 – Feu tricolore : branche les LED rouge, jaune et verte sur D10, D9 et D8 et reproduis avec delay la séquence d'un vrai carrefour. Matériel : 3 LED, 3 résistances 220 Ω. À lire : Feu tricolore Arduino.
- Jour 3 – LED chenillard et Knight Rider : apprends à utiliser une boucle for et un tableau de broches pour allumer 6 LED à la suite. Matériel : 6 LED, 6 résistances 220 Ω. À lire : Knight Rider et LED chenillard, Les tableaux Arduino.
- Jour 4 – LED avec bouton : fais d'abord une LED qui reste allumée tant que tu appuies, puis une LED qui change d'état à chaque appui (toggle) ; tu y découvriras INPUT_PULLUP et l'anti-rebond. Matériel : 1 bouton, 1 LED, 1 résistance 220 Ω. À lire : Comment brancher un bouton sur Arduino, Résistances pull-up et pull-down.
- Jour 5 – Potentiomètre et moniteur série : lis une valeur de 0 à 1023 avec analogRead, observe-la dans le moniteur série et convertis-la avec map en vitesse de clignotement de la LED. Matériel : potentiomètre 10 kΩ, 1 LED. À lire : Qu'est-ce qu'un potentiomètre, Utiliser le moniteur série, La fonction map.
- Jour 6 – PWM et LED RVB : allume et éteins progressivement une LED avec analogWrite (effet de respiration), puis mélange les trois canaux de la LED RVB pour créer ta propre couleur. Matériel : 1 LED RVB, 3 résistances 220 Ω. À lire : Qu'est-ce que le PWM, Utiliser une LED RVB.
- Jour 7 – Veilleuse LDR et révision de la semaine : branche la LDR en diviseur de tension avec une résistance de 10 kΩ et allume la LED quand la pièce s'assombrit. Dans la seconde moitié de la journée, monte le feu tricolore à bouton piéton ci-dessous. Matériel : LDR, résistance 10 kΩ, 3 LED, bouton. À lire : Capteur de lumière LDR, Diviseur de tension.
Le projet de clôture de la semaine 1 réunit ce que tu as appris aux jours 2, 4 et 5 dans un seul circuit : un feu reste vert pour les voitures ; quand le piéton appuie sur le bouton, il passe au jaune puis au rouge, et revient au vert cinq secondes plus tard. Le bouton se branche entre D2 et GND ; grâce à la résistance pull-up interne, aucune résistance externe n'est nécessaire, et la broche lit LOW quand on appuie.
1// Yaya butonlu trafik lambası / Pedestrian button traffic light
2const int RED_PIN = 10; // kırmızı LED / red LED
3const int YELLOW_PIN = 9; // sarı LED / yellow LED
4const int GREEN_PIN = 8; // yeşil LED / green LED
5const int BUTTON_PIN = 2; // buton, diğer ucu GND / button, other leg to GND
6
7void setup() {
8 pinMode(RED_PIN, OUTPUT);
9 pinMode(YELLOW_PIN, OUTPUT);
10 pinMode(GREEN_PIN, OUTPUT);
11 pinMode(BUTTON_PIN, INPUT_PULLUP); // basılınca LOW okunur / reads LOW when pressed
12 digitalWrite(GREEN_PIN, HIGH); // araçlara yeşil / green for cars
13 Serial.begin(9600);
14}
15
16void loop() {
17 if (digitalRead(BUTTON_PIN) == LOW) {
18 Serial.println("Yaya istegi / Pedestrian request");
19 delay(1000);
20 digitalWrite(GREEN_PIN, LOW);
21 digitalWrite(YELLOW_PIN, HIGH); // sarı: yavaşla / yellow: slow down
22 delay(2000);
23 digitalWrite(YELLOW_PIN, LOW);
24 digitalWrite(RED_PIN, HIGH); // araçlar durur, yaya geçer / cars stop, pedestrians cross
25 delay(5000);
26 digitalWrite(YELLOW_PIN, HIGH); // kırmızı + sarı: hazırlan / red + yellow: get ready
27 delay(1500);
28 digitalWrite(RED_PIN, LOW);
29 digitalWrite(YELLOW_PIN, LOW);
30 digitalWrite(GREEN_PIN, HIGH);
31 delay(3000); // art arda basmayı engelle / ignore repeated presses
32 }
33}Le dernier delay(3000) du code empêche le feu de repasser aussitôt au rouge si un piéton appuie plusieurs fois de suite sur le bouton ; les vrais feux utilisent un délai d'attente similaire. Comme modification personnelle, essaie de rendre la durée du rouge réglable avec un potentiomètre, ou de faire émettre de courts bips au buzzer pendant que le rouge est allumé. La faiblesse de ce code est que la carte ne peut rien faire d'autre pendant un delay ; tu résoudras ce problème au jour 9 avec millis.
Semaine 2 : son, temps, capteurs et écran (jours 8 à 14)
Pendant la deuxième semaine, la carte commence à mesurer le monde extérieur et à afficher les résultats. Ces jours-ci, tu installeras ta première bibliothèque, tu mesureras le temps à la microseconde et tu afficheras du texte sur un écran. Les projets étant un peu plus longs, n'hésite pas à répartir une journée sur deux si nécessaire ; le plan n'est pas une course, c'est une méthode pour prendre une habitude.
- Jour 8 – Buzzer et mélodie : joue une note avec tone(broche, fréquence, durée) ; 262 Hz est le do, 294 Hz le ré, 330 Hz le mi. Un buzzer actif ne produit qu'un seul son fixe ; pour une mélodie, il faut un buzzer passif. Matériel : buzzer passif. À lire : Qu'est-ce qu'un buzzer.
- Jour 9 – millis à la place de delay : fais clignoter une LED toutes les secondes tout en lisant un bouton en même temps. C'est la base du projet final ; tout projet qui fait plusieurs choses à la fois utilise millis ou une machine à états. Matériel : 2 LED, bouton. À lire : Différence entre millis et delay, Machine à états Arduino.
- Jour 10 – Mesurer une distance avec le HC-SR04 : mesure le temps d'aller-retour de l'onde sonore ; comme le son voyage dans l'air à environ 343 m/s, diviser le temps en microsecondes par 58 donne la distance en centimètres. Matériel : HC-SR04. À lire : Capteur de distance HC-SR04.
- Jour 11 – Aide au stationnement : combine les jours 8 et 10 : plus l'obstacle approche, plus l'intervalle entre les bips du buzzer raccourcit, et la LED clignote à chaque bip. Matériel : HC-SR04, buzzer passif, LED, résistance 220 Ω. À lire : Système de stationnement Arduino.
- Jour 12 – DHT11 et LCD I2C : installe ta première bibliothèque et affiche la température et l'humidité sur l'écran LCD 16x2. Grâce à l'I2C, l'écran se branche avec seulement 4 fils ; l'adresse de la plupart des modules est 0x27 ou 0x3F. Matériel : DHT11, LCD 16x2 I2C. À lire : Ajouter une bibliothèque Arduino, Capteur DHT11, Écran LCD I2C.
- Jour 13 – Servomoteur et plan du projet final : fais tourner le SG90 de 0 à 180 degrés avec la bibliothèque Servo et commande l'angle avec le potentiomètre. Dans la seconde moitié de la journée, choisis ton projet final et mets ton plan sur papier en suivant les étapes ci-dessous. Matériel : servo SG90, potentiomètre. À lire : Qu'est-ce qu'un servomoteur, Servo qui tremble.
- Jour 14 – Projet final et présentation : assemble les codes des jours précédents, place le circuit dans une boîte ou une maquette en carton, filme une courte vidéo et présente ton projet à ta famille ou à ta classe. Matériel : liste des pièces du projet final. À lire : Présenter un projet à un salon scientifique.
Le code ci-dessous est l'aide au stationnement du jour 11 ; il réutilise dans une fonction la méthode de mesure de distance apprise au jour 10. Le délai maximal de 30 000 microsecondes de pulseIn correspond à environ 5 mètres ; si le capteur ne reçoit pas d'écho, le code renvoie -1 au lieu d'attendre indéfiniment. La fonction map convertit la plage 0–50 cm en une pause de 50–500 ms, de sorte que les bips s'accélèrent à mesure que l'obstacle approche.
1// Park sensörü: HC-SR04 + buzzer + LED / Parking sensor: HC-SR04 + buzzer + LED
2const int TRIG_PIN = 7;
3const int ECHO_PIN = 6;
4const int BUZZER_PIN = 5; // pasif buzzer / passive buzzer
5const int LED_PIN = 4; // 220 ohm dirençle / with a 220 ohm resistor
6
7long readDistanceCm() {
8 digitalWrite(TRIG_PIN, LOW);
9 delayMicroseconds(2);
10 digitalWrite(TRIG_PIN, HIGH); // 10 mikrosaniye tetik darbesi / 10 microsecond trigger pulse
11 delayMicroseconds(10);
12 digitalWrite(TRIG_PIN, LOW);
13 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
14 if (duration == 0) return -1; // yankı yok / no echo
15 return duration / 58; // mikrosaniye -> cm / microseconds -> cm
16}
17
18void setup() {
19 pinMode(TRIG_PIN, OUTPUT);
20 pinMode(ECHO_PIN, INPUT);
21 pinMode(BUZZER_PIN, OUTPUT);
22 pinMode(LED_PIN, OUTPUT);
23 Serial.begin(9600);
24}
25
26void loop() {
27 long cm = readDistanceCm();
28 Serial.print("Mesafe / Distance: ");
29 Serial.print(cm);
30 Serial.println(" cm");
31
32 if (cm > 0 && cm < 50) {
33 int pause = map(cm, 0, 50, 50, 500); // yaklaştıkça kısalır / shorter when closer
34 tone(BUZZER_PIN, 2000, 50); // 2 kHz, 50 ms bip / 2 kHz, 50 ms beep
35 digitalWrite(LED_PIN, HIGH);
36 delay(50);
37 digitalWrite(LED_PIN, LOW);
38 delay(pause);
39 } else {
40 noTone(BUZZER_PIN);
41 digitalWrite(LED_PIN, LOW);
42 delay(200);
43 }
44}| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN / 5V | VBUS (5 V) |
| HC-SR04 GND | GND | GND | GND |
| HC-SR04 TRIG | D7 | GPIO 5 | GP14 |
| HC-SR04 ECHO | D6 | GPIO 18 (avec diviseur de tension) | GP15 (avec diviseur de tension) |
| Buzzer (+) | D5 | GPIO 19 | GP13 |
| LED (avec 220 Ω) | D4 | GPIO 23 | GP12 |
Voie ESP32 : le même plan, avec le Wi-Fi en plus
Si tu avances avec l'ESP32, tu fais les jours 1 à 13 avec presque les mêmes codes ; tu changes seulement les numéros de broches. Deux différences sont à connaître : analogRead renvoie une valeur de 0 à 4095 sur l'ESP32 (12 bits), et pour la lecture analogique il vaut mieux privilégier les broches ADC1 (GPIO 32–39), car les broches ADC2 sont inutilisables quand le Wi-Fi est activé. Après le jour 9, réserve en outre une soirée au Wi-Fi : le code ci-dessous affiche la distance mesurée par l'aide au stationnement sur une page web du réseau local, la page se rafraîchit chaque seconde et la LED s'allume quand la distance passe sous 30 cm. Si tu laisses le buzzer branché sur le GPIO 19 comme dans le tableau, ajouter une alerte sonore au projet final sera aussi plus facile. Pour la mise en route de la carte, consulte l'article Qu'est-ce que l'ESP32.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // kendi ağ adın / your network name
5const char* WIFI_PASS = "Sifre123"; // kendi şifren / your password
6
7const int TRIG_PIN = 5;
8const int ECHO_PIN = 18; // gerilim bölücüyle / through a voltage divider
9const int LED_PIN = 23;
10
11WebServer server(80);
12
13long readDistanceCm() {
14 digitalWrite(TRIG_PIN, LOW);
15 delayMicroseconds(2);
16 digitalWrite(TRIG_PIN, HIGH);
17 delayMicroseconds(10);
18 digitalWrite(TRIG_PIN, LOW);
19 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
20 if (duration == 0) return -1;
21 return duration / 58;
22}
23
24void handleRoot() {
25 long cm = readDistanceCm();
26 digitalWrite(LED_PIN, (cm > 0 && cm < 30) ? HIGH : LOW); // 30 cm altında uyarı / warn below 30 cm
27 String html = "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='1'></head><body>";
28 html += "<h1>Mesafe: " + String(cm) + " cm</h1></body></html>";
29 server.send(200, "text/html", html);
30}
31
32void setup() {
33 Serial.begin(115200);
34 pinMode(TRIG_PIN, OUTPUT);
35 pinMode(ECHO_PIN, INPUT);
36 pinMode(LED_PIN, OUTPUT);
37 WiFi.mode(WIFI_STA);
38 WiFi.begin(WIFI_SSID, WIFI_PASS);
39 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
40 delay(500);
41 Serial.print(".");
42 }
43 Serial.println();
44 Serial.print("IP: ");
45 Serial.println(WiFi.localIP()); // bu adresi tarayıcıya yaz / type this address in a browser
46 server.on("/", handleRoot);
47 server.begin();
48}
49
50void loop() {
51 server.handleClient();
52}Après le téléversement, ouvre le moniteur série à 115200 bauds ; une fois la connexion établie, saisis l'adresse IP affichée dans le navigateur de ton téléphone. Ton téléphone et l'ESP32 doivent être sur le même réseau Wi-Fi. L'ESP32 ne se connecte qu'aux réseaux 2,4 GHz ; s'il n'arrive pas à se connecter, applique la liste de vérification de l'article ESP32 ne se connecte pas au Wi-Fi. Pour ton projet final, ajouter à cette page les données du DHT11 et un lien pour allumer et éteindre une LED serait un bon objectif pour la suite.
Voie Raspberry Pi Pico : les mêmes jours avec MicroPython
Sur la voie Pico, tu utilises l'éditeur Thonny à la place de l'IDE Arduino ; une fois MicroPython installé une seule fois sur la Pico, le code part sur la carte dès que tu l'enregistres et l'exécutes. La LED intégrée est sur GP25 sur la Pico classique (sur la Pico W, on y accède avec Pin("LED")), le PWM passe par machine.PWM, la lecture analogique par machine.ADC, et read_u16 renvoie une valeur entre 0 et 65535. Si la syntaxe Python t'est étrangère, jette un œil à l'article Bases de MicroPython avant le jour 1 ; le guide Qu'est-ce que la Raspberry Pi Pico présente la carte. Le code ci-dessous est l'équivalent MicroPython de l'aide au stationnement du jour 11 et utilise la colonne Pico du tableau des broches.
1from machine import Pin, PWM, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN) # gerilim bölücüyle / through a voltage divider
6buzzer = PWM(Pin(13)) # pasif buzzer / passive buzzer
7led = Pin(12, Pin.OUT)
8
9def mesafe_cm():
10 trig.value(0)
11 time.sleep_us(2)
12 trig.value(1)
13 time.sleep_us(10) # 10 mikrosaniye tetik / 10 microsecond trigger
14 trig.value(0)
15 sure = time_pulse_us(echo, 1, 30000) # 30 ms zaman aşımı / 30 ms timeout
16 if sure < 0:
17 return -1 # yankı yok / no echo
18 return sure / 58
19
20while True:
21 cm = mesafe_cm()
22 print("Mesafe / Distance:", cm, "cm")
23 if 0 < cm < 50:
24 bekle = int(50 + cm * 9) # yaklaştıkça kısalır / shorter when closer
25 buzzer.freq(2000)
26 buzzer.duty_u16(32768) # yüzde 50 doluluk / 50 percent duty
27 led.value(1)
28 time.sleep_ms(50)
29 buzzer.duty_u16(0)
30 led.value(0)
31 time.sleep_ms(bekle)
32 else:
33 buzzer.duty_u16(0)
34 led.value(0)
35 time.sleep_ms(200)Projet final : que vas-tu terminer à la fin des vacances ?
Le projet final rassemble dans un seul appareil utile les éléments appris en deux semaines. Un bon projet final doit avoir au moins une entrée (capteur ou bouton), un traitement (code qui décide) et une sortie (LED, son, écran ou moteur). Aucune des options ci-dessous ne demande de pièce coûteuse en dehors du kit ; choisis celle qui correspond à ton niveau et travaille dessus à partir du jour 13. Pour d'autres idées, consulte la liste d'idées de projets Arduino.
| Niveau / voie | Projet final | Jours combinés | Matériel supplémentaire |
|---|---|---|---|
| Uno – débutant | Assistant de stationnement intelligent : bips qui s'accélèrent avec la distance, centimètres sur le LCD, barrière à servo qui descend à 10 cm | 4, 9, 10, 11, 12, 13 | Aucun, le kit suffit |
| Uno – alternative | Mini station météo : données du DHT11 sur le LCD, changement de page avec un bouton, rétroéclairage éteint dans le noir | 4, 7, 9, 12 | Aucun, le kit suffit |
| ESP32 | Station de pièce consultable depuis le téléphone : température, humidité et distance sur une page web, LED allumée et éteinte depuis le navigateur | 6, 9, 10, 12 + Wi-Fi | Aucun, la carte ESP32 suffit |
| Pico | Jeu de réaction : une LED s'allume à un moment aléatoire et le plus rapide à appuyer gagne, le temps s'affiche dans la console Thonny, le gagnant est fêté par une mélodie du buzzer | 4, 8, 9 | Un deuxième bouton |
- Définis-le en une phrase : écris clairement ce que fera l'appareil, par exemple « le bip s'accélère quand la voiture approche du garage, la barrière descend à 10 cm ».
- Dessine un schéma entrée-traitement-sortie : dessine sur papier, avec des cases, quel capteur fournira les données, sur quoi le code décidera et quelle pièce réagira.
- Fais un plan de broches : note dans un tableau la broche de chaque pièce. Place les sorties qui demandent du PWM, comme la luminosité d'une LED, sur les broches marquées ~ ; n'oublie pas que sur l'Uno, la bibliothèque Servo désactive le PWM sur D9 et D10. L'outil schéma de brochage t'aidera à lire le brochage de ta carte.
- Teste pièce par pièce : fais d'abord fonctionner chaque module seul avec son propre petit code ; ne passe pas à l'assemblage tant que tous ne marchent pas séparément.
- Assemble et supprime les delay : regroupe les codes dans un seul fichier et remplace les longs delay par la structure millis apprise au jour 9, afin que la lecture des capteurs, le son et l'écran ne s'attendent pas les uns les autres.
- Mets en boîte et présente : place le circuit dans une boîte en carton ou en plastique, fixe les fils avec du ruban adhésif et filme une vidéo de présentation de 30 à 60 secondes. Si tu veux rendre le circuit permanent, souder sur une plaque perforée peut être ta prochaine étape.
Où tu risques de bloquer et comment t'en sortir
| Problème | Cause probable | Solution |
|---|---|---|
| Le code ne se téléverse pas, le port n'apparaît pas | Mauvaise carte ou mauvais port sélectionné, pilote CH340 manquant ou câble qui ne sert qu'à charger | Choisis la carte et le port dans le menu Outils, utilise un câble USB capable de transférer des données, installe le pilote |
| La LED ne s'allume pas du tout | LED montée à l'envers ou pattes qui ne sont pas sur des rangées différentes de la breadboard | La patte longue (anode) doit être côté broche, la patte courte (cathode) côté GND ; essaie de décaler le branchement d'une rangée |
| Le bouton se déclenche sans appui | Broche flottante, pas de résistance pull-up | Utilise pinMode(broche, INPUT_PULLUP) et relie l'autre patte du bouton à GND |
| Le HC-SR04 affiche toujours 0 ou -1 | TRIG et ECHO inversés ou capteur non alimenté en 5 V | Vérifie le tableau des broches, branche VCC sur 5 V, oriente le capteur vers une surface plane à au moins 2 cm |
| Le rétroéclairage du LCD est allumé mais aucun texte | Contraste ou adresse I2C incorrect | Tourne le potentiomètre bleu au dos du module, essaie les adresses 0x27 et 0x3F |
| La carte redémarre quand le servo bouge | Le servo consomme plus de courant que l'USB ne peut en fournir | Alimente le servo avec une source externe de 5 V et relie le GND de la source au GND de la carte |
| Erreur « Failed to connect » au téléversement sur l'ESP32 | La carte n'entre pas en mode téléchargement | Maintiens le bouton BOOT enfoncé au début du téléversement et relâche-le quand « Connecting... » s'affiche |
Au bout de deux semaines, tu n'auras pas seulement un projet final qui fonctionne, mais aussi une méthode pour apprendre seul un nouveau capteur ou module : lire, dessiner, monter, tester, modifier. Si tu gardes cette habitude à raison d'un projet par semaine après la rentrée, tu seras prêt pour un travail de niveau salon scientifique d'ici les vacances d'été ; l'article Idées de projets Arduino pour le TÜBİTAK est un bon point de départ pour la phase d'idées. Les schémas et les codes des projets du plan (LED, feu tricolore, bouton, veilleuse LDR, mesure de distance et DHT11) sont disponibles pas à pas dans l'application BlueGrays pour Uno, ESP32 et Pico, et tu peux suivre chaque jour depuis l'application.
Questions fréquentes
Peut-on apprendre Arduino pendant les vacances d'hiver ?
Oui, avec 1 à 2 heures de travail régulier par jour, il est possible d'apprendre en deux semaines les entrées-sorties numériques et analogiques, la lecture de capteurs, l'écran et la commande de moteur. L'important est de terminer chaque jour un petit projet complet et de modifier le code toi-même. À la fin des vacances, tu seras capable de réaliser un projet qui combine plusieurs modules.
Quel kit acheter pour débuter avec Arduino ?
Un kit de démarrage contenant un Arduino Uno, une breadboard, des fils, des LED, des résistances, un bouton, un potentiomètre, une LDR, un buzzer, un HC-SR04, un DHT11, un servo et un LCD I2C suffit pour tout ce plan. Les clones de l'Uno exécutent le même code que la carte d'origine ; il faudra peut-être seulement installer le pilote CH340.
Faut-il commencer avec Arduino, ESP32 ou Raspberry Pi Pico ?
Si tu n'as aucune expérience, l'Arduino Uno est le départ le plus simple : il fonctionne en 5 V et la plupart des exemples sont écrits pour lui. Si tu veux connecter tes projets à Internet, l'ESP32 est un meilleur choix ; si tu veux apprendre Python, la Raspberry Pi Pico avec MicroPython convient mieux. Les notions de base que tu apprends sont les mêmes sur les trois cartes.
Peut-on apprendre Arduino sans carte ?
Oui. Les simulateurs en ligne comme Wokwi et Tinkercad te permettent de brancher virtuellement des LED, boutons, potentiomètres, HC-SR04, servos et LCD et d'exécuter le code. Tu peux faire toute la première semaine du plan en simulation, puis tester le même code sur un vrai circuit quand ta carte arrive.
Quel est le projet Arduino le plus facile à réaliser ?
Le projet le plus facile consiste à brancher une LED avec une résistance de 220 Ω et à la faire clignoter (Blink). Viennent ensuite le feu tricolore, la commande d'une LED par bouton et la veilleuse avec LDR. Ces quatre projets enseignent les bases d'Arduino : sortie numérique, entrée numérique et lecture analogique.
Faut-il savoir programmer pour apprendre Arduino ?
Tu n'as pas besoin de savoir programmer avant de commencer ; le langage Arduino est basé sur le C++, mais dans les projets de débutant, tu avances avec quelques commandes et de simples structures if et for. Exécuter des exemples tout faits et les modifier ligne par ligne est la méthode la plus rapide. Si tu connais Python, tu peux faire les mêmes projets avec la Raspberry Pi Pico et MicroPython.
Projets à réaliser après cet article
Voir tous les projets
Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Feu de circulation
Une copie miniature du feu tricolore que tu vois chaque jour dans la rue. Le rouge reste allumé deux secondes, l'orange brille un court instant, le vert reste deux secondes, puis on revient au rouge…

Allumer une LED avec un bouton-poussoir (Push)
Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

Veilleuse avec LDR
Une petite veilleuse qui s'allume toute seule quand il fait nuit et s'éteint au matin.

HC-SR04 Mesure de la distance (affichage en série)
Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

Température et humidité avec DHT11
Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

Simulateur de Feu de Circulation Raspberry Pi Pico (3 LEDs séquentielles)
Nous simulons un vrai feu de circulation avec des LEDs rouge, jaune et verte. Vert 4 sec "passez", jaune 1,5 sec "préparez", rouge 3 sec "arrêtez" et rouge+jaune 1 sec "départ" (motif européen). Apprends la définition de fonction, la logique de machine à états et la synchronisation multi-GPIO. Circuit simple : 3 LEDs sur GP11/GP12/GP13, chacune avec 220Ω.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

