Le code
Analysons le code, maintenant:
En se référant au schéma de montage, on déclare les constantes pour chaque broche: les boutons poussoirs sont connectés sur les broches 2 et 3, alors que les LEDs sont connectées aux broches 8 à 11.
/*
Déclaration des constantes pour les noms des broches
*/
const int btn_minus = 2; //Bouton 1 pour décrémenter le nombre de LEDs
allumés
const int btn_plus = 3; //Bouton 2 pour incrémenter le nombre de LEDs
allumés
const int led_0 = 8; //Led 0
const int led_1 = 9; //Led 1
const int led_2 = 10; //Led 2
const int led_3 = 11; //Led 3
On créé ensuite les variables nécessaires et les initialise leur état.
/*
Déclaration des variables utilisées pour le comptage et le décomptage
*/
int nombre_led = 0; //le nombre qui sera incrémenté et décrémenté
int etat_bouton; //lecture de l'état des boutons (un seul à la fois
mais une variable suffit; en effet, il n'est pas prévu d'appuyer sur les deux
boutons simultanément)
int memoire_plus = LOW; //état relâché par défaut pour le bouton 2
int memoire_minus = LOW; //état relâché par défaut pour le bouton 1
On initialise ensuite les broches, selon qu'il s'agit des entrées (les boutons) ou des sorties (les LEDs).
/*
Initialisation des broches en entrée/sortie: entrées pour les boutons, sorties
pour les LEDs
*/
void setup()
{
pinMode(btn_plus, INPUT);
pinMode(btn_minus, INPUT);
pinMode(led_0, OUTPUT);
pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT);
pinMode(led_3, OUTPUT);
}
Allons-y pour la partie du programme dans la boucle sans fin (loop)
On utilise digitalRead pour lire l'état du bouton (btn_plus) et inscrire cet état dans la variable etat_bouton.
void loop()
{
//lecture de l'état du bouton d'incrémentation (on lit l'état du btn_plus et
on l'inscrit dans la variable etat_bouton)
etat_bouton = digitalRead(btn_plus);
Maintenant, ça devient sérieux. Regardons ce qui suit:
//Si le bouton a un état différent que celui enregistré ET que cet état est "appuyé"
if((etat_bouton != memoire_plus) && (etat_bouton == HIGH))
Traduisons cela en français: si l'état du bouton 2 est différent de celui enregistré, et que quelqu'un appuie sur le bouton, alors...
Le != signifie est différent de (teste la différence entre deux variables) et l'opérateur logique && signifie ET ( Pour être précis, nous avons: si ... et... avec le if ... &&... Exemple: si il fait beau et chaud, alors on va à la plage).
Rappelons-nous maintenant de l'opération ++ , qui incrémente une variable (variable = variable + 1, c'est-àdire; on ajoute à chaque fois 1 à la variable). Dans notre cas, il s'agit de la valeur de la variable nombre_led qu'on incrémente.
{
nombre_led++; //on incrémente la variable qui indique combien de LEDs devrons s'allumer
}
On enregistre le nouvel état du bouton pour la suite!
memoire_plus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant.
Maintenant, on recommence le tout, mais pour le bouton 1.
//et maintenant pareil pour le bouton qui décrémente
etat_bouton = digitalRead(btn_minus); //lecture de son état
//Si le bouton a un état différent que celui enregistré ET que cet état est "appuyé"
if((etat_bouton != memoire_minus) && (etat_bouton == HIGH))
{
nombre_led--; //on décrémente la valeur de nombre_led
}
memoire_minus = etat_bouton; //on enregistre l'état du bouton pour le tour suivant
Nous allons maintenant limiter le nombre de LEDs à connecter. En effet, dans notre cas, nous avons 4 LEDs. Alors si on appuie 10 fois sur le bouton 2, cela n'allumera que les 4 LEDs.
//on applique des limites au nombre pour ne pas dépasser 4 ou 0 (puisqu'on a
4 LEDs)
if(nombre_led > 4)
{
nombre_led = 4;
}
Traduisons : si on appuie plus de 4 fois sur le bouton, le résultat sera égal à 4.
Même chose maintenant pour le bouton 1.
if(nombre_led < 0)
{
nombre_led = 0;
}
Maintenant, nous devons gérer l'allumage des LEDs. Pour simplifier le code, on va créer une fonction qui servira à gérer l'affichage. Nous allons appeler cette fonction affiche, avec un paramètre int valeur_recue.
Ce paramètre représente le nombre à afficher.
//On créé une fonction affiche() pour l'affichage du résultat
//on lui envoie alors en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}
void affiche(int valeur_recue)
On commence d'abord par éteindre toutes les LEDs.
{
//on éteint toutes les leds
digitalWrite(led_0, LOW);
digitalWrite(led_1, LOW);
digitalWrite(led_2, LOW);
digitalWrite(led_3, LOW);
Si la fonction reçoit le nombre 1, on allume la LED 1. Si elle reçoit le nombre 2, elle allume la LED 1 et 2. Si elle reçoit 3, elle allume la LED 1, 2 et 3. Enfin, si elle reçoit 4, alors elle allume toutes les LEDs:
//Puis on les allume une à une
if(valeur_recue >= 1) // "si la valeur reçue est plus grande ou
égale à 1..."
{
digitalWrite(led_0, HIGH); // "on allume la LED 0
}
Arduino à l'école
http://www.edurobot.ch 79
if(valeur_recue >= 2) // "si la valeur reçue est plus grande ou
égale à 2..."
{
digitalWrite(led_1, HIGH); // "on allume la LED 1 (sous-entendu que
la LED 0 est allumée, puisque la valeur est plus grande que 1)
}
if(valeur_recue >= 3) // "si la valeur reçue est plus grande ou
égale à 3..."
{
digitalWrite(led_2, HIGH); // "on allume la LED 2
}
if(valeur_recue >= 4) // "si la valeur reçue est plus grande ou
égale à 4..."
{
digitalWrite(led_3, HIGH; // "on allume la LED 3
}
}
Le symbole >= signife: ...est supérieur ou égal à.... Il s'agit de tester la supériorité ou l'égalité d'une variable par rapport à une valeur. Ainsi, dans:
if(valeur_recue >= 4)
{
digitalWrite(led_3, HIGH); // "on allume la LED 3
}
Il faut lire: si la variable valeur_recue est supérieure ou égale à 4, alors on allume la LED 3.