Bloc si Arduino : bouton et LED avec if-else, en blocs et en C++

Le bloc si sur Arduino permet à un programme de choisir entre deux chemins selon une question : « Le bouton est-il appuyé ? Si oui, allume la LED, sinon éteins-la. » En C++ Arduino, cette structure s'appelle if/else, et le bloc « si … faire … sinon » de la programmation par blocs BlueGrays en est l'équivalent exact. Dans cet article, tu vas utiliser un projet bouton et LED pour apprendre à régler une broche en entrée et à la lire, puis le bloc si, les opérateurs de comparaison, les conditions imbriquées et la façon de combiner deux conditions avec « et », bloc par bloc et ligne par ligne.

Jusqu'ici, nos programmes faisaient toujours la même chose : la LED s'allumait, attendait, s'éteignait et attendait encore. Ils n'écoutaient jamais le monde extérieur. Avec les conditions, la carte décide en regardant un bouton, un capteur de lumière ou une distance qu'elle mesure, et c'est là que commence le vrai plaisir de la programmation robotique. Tous les exemples viennent de projets en blocs gratuits : tu peux ouvrir leurs blocs et leur code sur la page programmation par blocs ou dans l'appli et suivre en parallèle.

Entrée et sortie : dans quel sens travaille une broche ?

Les broches numériques d'Arduino font l'un de deux travaux. Une broche réglée en sortie fournit 5 V (HIGH) ou 0 V (LOW) ; c'est ainsi qu'on pilote une LED, un buzzer ou un relais. Une broche réglée en entrée ne fournit rien, elle écoute seulement la tension présente : sur un Arduino Uno, elle lit HIGH au-dessus d'environ 3 V et LOW en dessous de 1,5 V. En blocs, ce choix se fait dans la section de configuration : le bloc « régler la broche 13 en ENTRÉE » devient pinMode(13, INPUT); en C++, et « régler la broche 7 en SORTIE » devient pinMode(7, OUTPUT);. Pour lire la broche, on utilise le bloc « lire la broche 13 ». Il ne ressemble pas aux autres : ce n'est pas une commande qu'on empile, mais un bloc de valeur arrondi qui s'emboîte dans un emplacement d'un autre bloc. Son équivalent C++ est digitalRead(13), qui renvoie HIGH ou LOW. Comme HIGH vaut 1 et LOW vaut 0 sur Arduino, tu peux aussi ranger le résultat dans une variable comme un nombre. En bref, les blocs de commande font quelque chose, les blocs de valeur donnent un résultat, et l'emplacement de condition du bloc si ne se remplit qu'avec un tel résultat.

Câblage : bouton sur 13, LED sur 7, résistance pull-down obligatoire

Dans le projet Allumer une LED avec un bouton-poussoir (Push), le bouton est sur D13 et la LED sur D7. Une patte du bouton va au 5V, l'autre à D13, et une résistance de pull-down de 10 kΩ est placée entre D13 et GND. Bouton relâché, la résistance tire la broche vers GND et on lit LOW. Quand tu appuies, le 5V arrive directement sur la broche et on lit HIGH. Comme la résistance est grande, seul un demi-milliampère environ circule du 5V vers GND pendant l'appui. La patte longue de la LED va à D7 à travers une résistance de 220 Ω, la courte à GND.

Le bloc si et if/else : la LED s'allume tant que tu appuies

La version en blocs du projet comporte deux sections. Dans « configuration (une fois) », la broche 13 est réglée en ENTRÉE et la broche 7 en SORTIE. Dans « répéter indéfiniment », il n'y a qu'un seul grand bloc : si … faire … sinon. Son emplacement de condition hexagonal contient la comparaison « lire la broche 13 = HAUT ». Si la condition est vraie, le bloc « écrire HAUT sur la broche 7 » de la branche « faire » s'exécute ; sinon, c'est le bloc « écrire BAS sur la broche 7 » de la branche « sinon ».

1void setup() {
2  pinMode(13, INPUT);    // Buton girişi (harici pull-down) / Button input (external pull-down)
3  pinMode(7, OUTPUT);    // LED çıkışı / LED output
4}
5
6void loop() {
7  if (digitalRead(13) == HIGH) {   // Buton basılı mı? / Is the button pressed?
8    digitalWrite(7, HIGH);         // Basılı: LED yanar / Pressed: LED on
9  } else {
10    digitalWrite(7, LOW);          // Bırakıldı: LED söner / Released: LED off
11  }
12}
13

Mets le code à côté des blocs et la correspondance saute aux yeux. Le mot if correspond à « si », la condition digitalRead(13) == HIGH entre parenthèses à l'emplacement de condition, la première paire d'accolades à la branche « faire », et else avec ses accolades à la branche « sinon ». Chaque bloc placé dans une branche devient une ligne entre les accolades correspondantes. Comme loop() tourne des dizaines de milliers de fois par seconde, la carte relit sans cesse le bouton ; dès que tu lèves le doigt, la condition est fausse au tour suivant et la LED s'éteint. D'où le nom « Push » : la LED ne reste allumée que tant que tu appuies. La branche « sinon » est facultative ; un bloc si avec seulement la branche « faire » devient un if sans else. Mais si tu supprimes la branche « sinon » ici, la LED ne s'éteint plus jamais une fois allumée, car il ne reste aucune ligne pour l'éteindre. Penser aux deux branches de chaque condition est une bonne habitude.

Blocs de comparaison : =, ≠, < et >

Marche/arrêt avec un bouton : si imbriqués et variable d'état

Dans le projet Push, la LED ne restait allumée que tant que tu maintenais le bouton. Pour qu'elle se comporte comme un vrai interrupteur, « un appui pour allumer, un autre pour éteindre », le programme doit retenir deux choses : si la LED est allumée en ce moment et ce que le bouton a lu au tour précédent. Le projet Allumer et éteindre une LED avec un bouton déclare pour cela deux entiers dans la section « variables globales (en haut) » : ledState (0 = éteinte, 1 = allumée) et lastButton (la lecture précédente). Le circuit reste le même : bouton sur D13 avec pull-down externe, LED sur D7.

1int ledState = 0;     // LED durumu: 0 = sönük, 1 = yanık / LED state: 0 = off, 1 = on
2int lastButton = 0;   // Butonun önceki okuması / Previous button reading
3
4void setup() {
5  pinMode(13, INPUT);   // Buton girişi (harici pull-down) / Button input (external pull-down)
6  pinMode(7, OUTPUT);   // LED çıkışı / LED output
7}
8
9void loop() {
10  int button = digitalRead(13);   // Butonu oku / Read the button
11  if (button != lastButton) {     // Buton durumu değişti / Button state changed
12    if (button == 1) {            // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13      ledState = !ledState;       // Durumu ters çevir / Flip the state
14      digitalWrite(7, ledState);
15    }
16    delay(50);                    // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17    lastButton = button;          // Bu okumayı sakla / Store this reading
18  }
19}
20

Le cœur du programme, ce sont les deux blocs si imbriqués. La condition extérieure button ≠ lastButton n'est vraie qu'au tour où l'état du bouton change ; pendant les milliers de tours où tu maintiens le bouton ou ne le touches pas, il ne se passe rien. Un changement peut aller dans deux sens : appui (0 vers 1) ou relâchement (1 vers 0). La condition intérieure button = 1 ne garde que l'appui. Ainsi la LED change une fois par appui et pas du tout au relâchement. Dans le code, les if imbriqués se voient aux accolades dans les accolades. En blocs, le si intérieur se loge dans la branche « faire » du si extérieur : on voit d'un coup d'œil quelle ligne dépend de quelle condition.

Le bloc non ledState s'écrit !ledState en C++. Le point d'exclamation donne le contraire logique : le contraire de 0 est 1, celui de tout nombre non nul est 0. Affecter à ledState son propre contraire inverse l'état à chaque appui. Le bloc suivant, « écrire ledState sur la broche 7 », correspond à la ligne digitalWrite(7, ledState) ; comme HIGH vaut 1 et LOW vaut 0, la valeur de la variable peut être écrite directement sur la broche. Enfin, lastButton reçoit la lecture de ce tour pour que la comparaison du tour suivant soit juste. Si tu oublies cette affectation, lastButton reste toujours à 0 ; tant que tu appuies, la condition extérieure est vraie à chaque tour et la LED clignote très vite.

Condition analogique : une veilleuse avec LDR

Les conditions ne servent pas qu'avec HIGH et LOW. Dans le projet Veilleuse avec LDR, le bloc « définir value à lecture analogique A0 » convertit la tension sur A0, où est branchée la LDR, en un nombre entre 0 et 1023 ; en C++, c'est la ligne value = analogRead(A0);. Le bloc si teste ensuite value < 50. Si la valeur est inférieure à 50, il fait sombre et la LED sur D13 s'allume ; sinon elle s'éteint. La structure est la même que dans le projet Push ; seule la comparaison dans l'emplacement de condition change.

1int value;   // Işık okuması (0-1023) / Light reading (0-1023)
2
3void setup() {
4  pinMode(13, OUTPUT);   // LED çıkışı / LED output
5}
6
7void loop() {
8  value = analogRead(A0);   // Işık seviyesini oku / Read the light level
9
10  // Eşik 50: altı karanlık sayılır, hassasiyeti bu sayıyla ayarla
11  // Threshold 50: anything below counts as dark. Tune the sensitivity with this number
12  if (value < 50) {
13    digitalWrite(13, HIGH);   // Karanlık: LED yanar / Dark: LED on
14  } else {
15    digitalWrite(13, LOW);    // Aydınlık: LED söner / Bright: LED off
16  }
17}
18

Selon ta LDR et la résistance du circuit, le seuil de 50 peut être trop bas ou trop haut pour ta pièce. Pour trouver le bon nombre, utilise d'abord le projet Mesurer l'intensité lumineuse avec une LDR et observe dans le moniteur série les valeurs en pleine lumière et dans le noir, puis place le seuil entre les deux. Si la valeur oscille juste autour du seuil, la LED peut scintiller ; utiliser deux seuils distincts pour allumer et éteindre règle très bien le problème. Le fonctionnement d'une LDR est expliqué dans l'article capteur de lumière LDR.

Combiner des conditions : le bloc et et &&

Parfois, une seule condition ne suffit pas. Dans le projet HC-SR04 Mesure de la distance (affichage en série), la distance mesurée n'est affichée dans le moniteur série que si elle est comprise entre 3 cm et 100 cm. En blocs, deux comparaisons sont reliées côte à côte par un bloc et : « distance > minDistance et distance < maxDistance ». En C++, la ligne devient if (distance > minDistance && distance < maxDistance). L'opérateur && ne donne vrai que si les deux côtés sont vrais ; si un seul est faux, la condition est fausse. Les valeurs absurdes hors de la plage du capteur n'arrivent donc jamais à l'écran. En C++, « ou » s'écrit || et une seule condition vraie suffit. Tu peux tester les tables de vérité de ET, OU et NON avec l'outil portes logiques.

Les mêmes conditions sur ESP32 : pull-up interne et logique inversée

Le projet ESP32 Contrôle de LED avec bouton poussoir (Push) utilise le même bloc si sur un ESP32, avec deux différences. La LED est sur GPIO 5, le bouton sur GPIO 4, et la broche du bouton reçoit l'option d'entrée avec pull-up du bloc de broche. En C++, c'est pinMode(BUTTON_PIN, INPUT_PULLUP); : une résistance interne à la puce tire la broche vers HIGH, aucune résistance externe n'est nécessaire. Cette fois, le bouton va à GND, donc la broche lit LOW à l'appui et la condition devient « lire la broche BUTTON_PIN = BAS ». Le projet ESP32 Contrôle de LED avec bouton (Toggle) gère la marche/arrêt avec le bloc de temps écoulé, millis(), au lieu d'une attente de 50 ms, et relie encore deux conditions par un bloc et. Les broches de l'ESP32 fonctionnent en 3,3 V ; ne branche pas le bouton sur 5 V.

Erreurs fréquentes et solutions

Ouvrir blocs et code côte à côte dans l'appli

Tous les projets de cet article font partie des projets en blocs gratuits de l'appli BlueGrays. Active l'interrupteur Voir en blocs dans la section code d'un projet et le code est remplacé par le même programme en blocs ; touche l'image pour l'ouvrir en plein écran. L'onglet Comprendre les blocs explique le programme étape par étape : chaque étape n'affiche que ses blocs et ce qu'ils font, ce qui permet de suivre les blocs si imbriqués un par un. Les exemples if/else et digitalRead du Guide du code existent aussi en blocs. Les blocs ne sont pas téléversés directement sur la carte et, pour l'instant, tu ne peux pas composer tes propres programmes en blocs ; sur la carte va toujours le vrai code C++ du projet, que tu copies dans l'Arduino IDE avant de le téléverser. Pour réviser, les Questions du jour te proposent 5 questions chaque jour, du niveau A1 au niveau C2.

Maintenant que tu maîtrises les conditions, l'étape suivante consiste à gérer répétitions et compteurs : dans la partie boucles et variables, tu verras le lien entre « répéter indéfiniment » et loop(), et entre le bloc de comptage et une boucle for. D'ici là, tu peux consulter dans l'appli BlueGrays le schéma et le code des projets LED avec bouton, veilleuse avec LDR et bouton sur ESP32, passer à la vue en blocs avec Voir en blocs et à l'explication pas à pas avec Comprendre les blocs.