Arduino allumage en douceur d'une LED RGB à partir d'un bouton. Contrôle de la luminosité des LED par potentiomètre. Description du programme pour Arduino

Dans cette expérience, nous ajoutons une partie de la luminosité à la LED avec un bouton et la diminuons avec l'autre.

LISTE DES PIÈCES POUR L'EXPÉRIENCE

- 1 carte Arduino Uno ;

- 1 breadboard sans soudure ;

- 2 boutons d'horloge ;

- 1 résistance d'une valeur nominale de 220 Ohms ;

- 1 LED ;

- 7 fils mâle-mâle.

SCHÉMA

SCHÉMA SUR PLANCHE À PAIN

NOTE

• Si vous retravaillez le circuit de l'expérience précédente, notez que cette fois, nous devons connecter la LED à un port prenant en charge PWM.

ESQUISSER

télécharger le croquis pour l'IDE Arduino

#define PLUS_BUTTON_PIN 2 #define MINUS_BUTTON_PIN 3 #define LED_PIN 9 int luminosité = 100 ; booléen plusUp = vrai ; booléen minusUp = true ; void setup() ( pinMode(LED_PIN, OUTPUT); pinMode(PLUS_BUTTON_PIN, INPUT_PULLUP); pinMode(MINUS_BUTTON_PIN, INPUT_PULLUP); ) void loop() ( analogWrite(LED_PIN, luminosité); // répond aux clics en utilisant la fonction que nous avons écrite plusUp = handleClick(PLUS_BUTTON_PIN, plusUp, +35); minusUp = handleClick(MINUS_BUTTON_PIN, minusUp, -35); ) // Fonction propre avec 3 paramètres : le numéro de pin avec le bouton // (buttonPin), l'état avant vérification (wasUp ) et gradation // de luminosité lorsque vous cliquez sur le bouton (delta). La fonction renvoie // (retour en anglais) le nouvel état actuel du bouton boolean handleClick(int buttonPin, boolean wasUp, int delta) ( boolean isUp = digitalRead(buttonPin); if (wasUp && !isUp) ( delay(10 ); isUp = digitalRead(buttonPin); // s'il y a eu un clic, change la luminosité de 0 à 255 if (!isUp) Brightness = constrain(brightness + delta, 0, 255); ) return isUp; // renvoie le valeur renvoyée au code de l'appelant)

EXPLICATIONS SUR LE CODE

• Nous pouvons non seulement utiliser les fonctions intégrées, mais également créer les nôtres. Ceci est justifié lorsque nous devons répéter les mêmes actions à différents endroits du code ou, par exemple, nous devons effectuer les mêmes actions sur différentes données, comme dans ce cas : traiter le signal des ports numériques 2 et 3.
• Vous pouvez définir vos propres fonctions n'importe où dans le code en dehors du code des autres fonctions. Dans notre exemple, nous avons défini une fonction après boucle .
• Pour définir notre propre fonction, nous avons besoin de :
  • Déclarez quel type de données il renverra. Dans notre cas c'est booléen. Si la fonction n'effectue que quelques actions et ne renvoie aucune valeur, utilisez le mot-clé vide
  • Attribuez à la fonction un nom - identifiant. Les mêmes règles s'appliquent ici que pour nommer les variables et les constantes. Les fonctions sont nommées dans le même style commeVariables .
  • Entre parenthèses, listez les paramètres passés à la fonction, en indiquant le type de chacun. Il s'agit d'une déclaration de variables visibles dans la fonction nouvellement créée, et uniquement à l'intérieur de celle-ci. Par exemple, si dans cette expérience nous essayons d'accéder à était là ou est en place depuis boucle() Nous recevrons un message d'erreur du compilateur. De même, les variables déclarées dans boucle, ne sont pas visibles par les autres fonctions, mais leurs valeurs peuvent être passées en paramètres.
  • Entre une paire d'accolades, écrivez le code exécuté par la fonction
  • Si la fonction doit renvoyer une valeur, utilisez le mot-clé retour spécifiez quelle valeur renvoyer. Cette valeur doit être du type que nous avons déclaré
• Les variables dites globales, c'est-à-dire Les variables accessibles depuis n'importe quelle fonction sont généralement déclarées au début du programme. Dans notre cas, c'est luminosité .
• Dans la fonction que nous avons créée poignéeCliquez La même chose se produit que dans l'expérience.
• Car avec un pas d'augmentation de la luminosité de 35, après pas plus de huit clics consécutifs sur l'un des boutons, la valeur de l'expression luminosité + delta ira en dehors de l'intervalle . Utilisation de la fonction contraindre nous limitons les valeurs autorisées pour la variable luminosité limites d'intervalle spécifiées.
• En expression plusUp = handleClick(PLUS_BUTTON_ ÉPINGLE , plusUp, +35) on accède à la variable plusUp deux fois. Parce que le = met la valeur de l'opérande de droite dans celle de gauche, en calculant d'abord ce qui reviendra poignéeCliquez. Alors quand on lui donne plusUp en paramètre, il a toujours l'ancienne valeur calculée lors du dernier appel poignéeCliquez .
• À l'intérieur poignéeCliquez nous calculons la nouvelle valeur de luminosité de la LED et l'écrivons dans une variable globale luminosité, qui à chaque itération boucle vient de passer à analogWrite .

QUESTIONS POUR VOUS TESTER

1. Que signifie le mot-clé ? vide ?
2. Comment un programme se comporte lorsqu'une variable est mentionnée de différents côtés de l'opérateur d'affectation = ?

TÂCHES POUR UNE SOLUTION INDÉPENDANTE

1. Modifiez le code pour que l'étape de changement de luminosité soit ajustée en un seul endroit.
2. Créez une autre fonction et retravaillez le code afin qu'une fonction soit responsable du suivi des frappes au clavier et qu'une autre soit responsable du calcul de la luminosité de la LED et de son retour à analogWrite .

​

Regardons maintenant la LED multicolore, qui est souvent appelée en abrégé : LED RVB. RVB est une abréviation qui signifie : Rouge - rouge, Vert - vert, Bleu - bleu. C'est-à-dire que trois LED distinctes sont placées à l'intérieur de cet appareil. Selon le type, une LED RVB peut avoir une cathode commune ou une anode commune.

1. Mélanger les couleurs

Pourquoi une LED RVB est-elle meilleure que trois LED conventionnelles ? Tout dépend de la capacité de notre vision à mélanger la lumière provenant de différentes sources placées à proximité les unes des autres. Par exemple, si nous plaçons des LED bleues et rouges l'une à côté de l'autre, alors à une distance de plusieurs mètres, leur lueur fusionnera et l'œil verra un point violet. Et si nous ajoutons également du vert, le point nous apparaîtra blanc. C’est exactement ainsi que fonctionnent les écrans d’ordinateur, les téléviseurs et les écrans extérieurs. La matrice TV est constituée de points individuels de différentes couleurs. Si vous prenez une loupe et regardez à travers celle-ci le moniteur allumé, vous pouvez facilement voir ces points. Mais sur un écran extérieur, les points ne sont pas placés de manière très dense, de sorte qu'ils puissent être distingués à l'œil nu. Mais à une distance de plusieurs dizaines de mètres, ces points sont indiscernables. Il s'avère que plus les points multicolores sont proches les uns des autres, moins l'œil a besoin de distance pour mélanger ces couleurs. D'où la conclusion : contrairement à trois LED séparées, le mélange des couleurs d'une LED RVB est déjà perceptible à une distance de 30 à 70 cm. D'ailleurs, une LED RVB avec une lentille mate fonctionne encore mieux.

2. Connecter une LED RVB à Arduino

Étant donné que la LED multicolore est composée de trois LED ordinaires, nous les connecterons séparément. Chaque LED est connectée à sa propre broche et possède sa propre résistance distincte. Dans ce tutoriel, nous utilisons une LED RVB avec une cathode commune, il n'y aura donc qu'un seul fil à la terre. Diagramme schématique
Apparence de la mise en page

3. Programme de contrôle d'une LED RVB

Composons un programme simple, qui éclairera tour à tour chacune des trois couleurs. const octet rPin = 3 ; const octet gPin = 5 ; const octet bPin = 6 ; void setup() ( pinMode(rPin, OUTPUT); pinMode(gPin, OUTPUT); pinMode(bPin, OUTPUT); ) void loop() ( // éteint le bleu, active le rouge digitalWrite(bPin, LOW); digitalWrite( rPin, HIGH); delay(500); // éteint le rouge, active le vert digitalWrite(rPin, LOW); digitalWrite(gPin, HIGH); delay(500); // éteint le vert, active le bleu digitalWrite(gPin , LOW); digitalWrite( bPin, HIGH); delay(500); ) Chargez le programme sur Arduino et observez le résultat. Ton navigateur ne fait pas prend en charge la balise vidéo. Optimisons un peu le programme : à la place des variables rPin, gPin et bPin, nous utiliserons un tableau. Cela nous aidera dans les prochaines tâches. const octet rgbPins = (3,5,6); void setup() ( pour (octet i=0; i<3; i++) pinMode(rgbPins[i], OUTPUT); } void loop() { digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); digitalWrite(rgbPins, LOW); digitalWrite(rgbPins, HIGH); delay(500); }

4. Sept couleurs de l'arc-en-ciel

Essayons maintenant d'éclairer deux couleurs en même temps. Programmons la séquence de couleurs suivante :

• rouge
• rouge + vert = jaune
• vert
• vert + bleu = bleu clair
• bleu
• bleu + rouge = violet

Nous avons omis la couleur orange pour plus de simplicité. Il s'est donc avéré qu'il s'agissait de six couleurs de l'arc-en-ciel 🙂 const byte rgbPins = (3,5,6) ; const octet arc-en-ciel = ( (1,0,0), // rouge (1,1,0), // jaune (0,1,0), // vert (0,1,1), // bleu ( 0,0,1), // bleu (1,0,1), // violet ); void setup() ( pour (octet i=0; i<3; i++) pinMode(rgbPins[i], OUTPUT); } void loop() { // перебираем все шесть цветов for(int i=0; i<6; i++){ // перебираем три компоненты каждого из шести цветов for(int k=0; k<3; k++){ digitalWrite(rgbPins[k], rainbow[i][k]); } delay(1000); } } В результате работы программы получается: Your browser does not support the video tag.

5. Changement de couleur en douceur

Ce n'est pas pour rien que nous avons connecté la LED RVB aux broches 3, 5 et 6. Comme vous le savez, ces broches permettent de générer un signal PWM de différents rapports cycliques. En d’autres termes, nous ne pouvons pas simplement allumer ou éteindre la LED, mais contrôler le niveau de tension de celle-ci. Cela se fait à l'aide de la fonction analogWrite. Assurons-nous que notre LED passera entre les couleurs de l'arc-en-ciel non pas brusquement, mais en douceur. const octet rgbPins = (3,5,6); int dim = 1 ; void setup() ( pour (octet i=0; i<3; i++){ pinMode(rgbPins[i], OUTPUT); } // начальное состояние - горит красный цвет analogWrite(rgbPins, 255); analogWrite(rgbPins, 0); analogWrite(rgbPins, 0); } void loop() { // гасим красный, параллельно разжигаем зеленый for(int i=255; i>=0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) // éteint le vert, allume le bleu en parallèle pour (int i=255 ; i> =0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) // éteint le bleu, allume le rouge en parallèle for(int i=255 ; i>=0; i--)( analogWrite(rgbPins, i/dim); analogWrite(rgbPins, (255-i)/dim); delay(10); ) ) La variable dim détermine la luminosité de la lueur. À dim = 1, nous avons une luminosité maximale. Chargez le programme sur Arduino. Votre navigateur ne prend pas en charge la balise vidéo.

Tâches

1. Indicateur de température. Ajoutons une thermistance au circuit et connectons-la à l'entrée analogique. La LED doit changer de couleur en fonction de la température de la thermistance. Plus la température est basse, plus la couleur est bleue et plus la température est élevée, plus la couleur est rouge.
2. Lampe RVB avec régulateur. Ajoutons trois résistances variables au circuit et connectons-les aux entrées analogiques. Le programme doit lire en permanence les valeurs des résistances et changer la couleur du composant LED RVB correspondant.

Dans cet exemple, vous apprendrez à modifier la luminosité d'une LED à l'aide de résistances de différentes intensités.

Pour cet exemple, vous aurez besoin

1 LED de 5 mm de diamètre

1 résistance de 270 ohms (rouge, violet, marron)

1 résistance de 470 ohms (jaune, violet, marron)

1 résistance de 2,2 kOhm (rouge, rouge, rouge)

1 résistance de 10 kOhm (marron, noir, orange)

LED - informations générales

Les LED sont bien utilisées dans les appareils pour différents types d'indication. Ils consomment peu d'électricité et sont durables.

Dans cet exemple, nous utilisons les LED les plus courantes d'un diamètre de 5 mm. Les LED d'un diamètre de 3 millimètres et les grandes LED d'un diamètre de 10 mm sont également courantes.

Il n'est pas recommandé de connecter la LED directement à une batterie ou à une source de tension. Tout d’abord, vous devez d’abord déterminer où exactement la LED a ses pattes négatives et positives. Eh bien, deuxièmement, il est nécessaire d'utiliser des résistances de limitation de courant, sinon la LED grillera très rapidement.

Si vous n'utilisez pas de résistance avec la LED, la LED tombera en panne très rapidement car trop de courant la traversera. En conséquence, la LED chauffera et la lumière génératrice de contact sera détruite.

Il existe deux façons de distinguer les pattes positives et négatives d’une LED.

La première est que la jambe positive est plus longue.

La seconde est qu'en entrant dans le boîtier de la diode elle-même, il y a un bord plat sur le connecteur de la patte négative.

Si vous rencontrez une LED qui a un bord plat sur la branche la plus longue, la branche la plus longue est toujours positive.

Résistances - informations générales

Résister - résistance (anglais)

Comme leur nom l’indique, les résistances résistent au flux d’électricité. Plus la valeur (ohms) de la résistance est élevée, plus la résistance est grande et moins le courant circulera dans le circuit dans lequel elle est installée. Nous utiliserons cette propriété des résistances pour réguler le courant qui traverse la LED et donc sa luminosité.

Mais d’abord, parlons un peu des résistances.

Les unités dans lesquelles la résistance est mesurée sont les Ohms, qui dans de nombreuses sources sont désignées par la lettre grecque Ω - Omega Puisque Ohm est une petite valeur de résistance (presque imperceptible dans un circuit), nous fonctionnerons souvent avec des unités telles que kOhm - kiloohm (1 000 ohms) et MOhm mégaohm (1 000 000 ohms).

Dans cet exemple, nous utiliserons des résistances de quatre valeurs différentes : 270 Ω, 470 Ω, 2,2 kΩ et 10 kΩ. Les tailles de ces résistances sont les mêmes. La couleur aussi. La seule chose qui les distingue, ce sont les rayures colorées. C'est à partir de ces bandes que la valeur des résistances est déterminée visuellement.

Pour les résistances qui ont trois bandes colorées et la dernière bande dorée, les correspondances suivantes fonctionnent :

Marron 1

rouge 2

Orange 3

Vert 5

Violet 7

Les deux premières bandes indiquent les 2 premières valeurs numériques, donc rouge, violet signifie 2, 7. La bande suivante est le nombre de zéros qui doivent être placés après les deux premiers chiffres. Autrement dit, si la troisième bande est marron, comme sur la photo ci-dessus, il y aura un zéro et la valeur de la résistance sera de 270 Ω.

Résistance avec des rayures marron, noires, orange : 10 et trois zéros, donc 10000 Ω. Soit 10 kΩ.

Contrairement aux LED, les résistances n’ont pas de pattes positives et négatives. Peu importe la jambe que vous utilisez pour les connecter à l’alimentation/à la terre.

Diagramme de connexion

Connectez-vous selon le schéma ci-dessous :

L'Arduino dispose d'une broche 5V pour alimenter les périphériques. Nous l'utiliserons pour alimenter une LED et une résistance. Vous n'aurez besoin de rien d'autre de la carte, connectez-la simplement via USB à votre ordinateur.

Avec une résistance de 270 Ω, la LED doit s'allumer assez fort. Si vous remplacez la résistance de 270 Ω par une résistance de 470 Ω, la LED ne brillera pas aussi fort. Avec une résistance de 2,2 kΩ, la LED devrait s'éteindre un peu plus. Après tout, avec une résistance de 10 kΩ, la LED sera à peine visible. Il est probable que pour voir la différence lors de la dernière étape, vous devrez retirer l'adaptateur rouge et l'utiliser comme interrupteur. Ensuite, vous pouvez voir la différence de luminosité.

À propos, vous pouvez réaliser cette expérience avec les lumières éteintes.

Diverses options d'installation de résistances

Au moment où 5 V est connecté à une branche de la résistance, la deuxième branche de la résistance est connectée à la branche positive de la LED et la deuxième branche de la LED est connectée à la terre. Si nous déplaçons la résistance pour qu'elle se trouve derrière la LED comme indiqué ci-dessous, la LED restera allumée.

LED clignotante

Nous pouvons connecter la LED à la sortie Arduino. Déplacez le fil rouge de la broche d'alimentation 5 V vers D13 comme indiqué ci-dessous.

Téléchargez maintenant l'exemple « Blink » que nous avons examiné. Veuillez noter que les deux LED - celle intégrée et celle externe que vous avez installée - ont commencé à clignoter.

Essayons d'utiliser une autre broche sur l'Arduino. Disons D7. Déplacez le connecteur de la broche D13 à la broche D7 et modifiez la ligne suivante de votre code :

Téléchargez le croquis modifié sur l'Arduino. La LED continuera à clignoter, mais cette fois en utilisant l'alimentation de la broche D7.

Dans les leçons précédentes, nous nous sommes familiarisés avec les circuits les plus simples - l'assemblage et. Aujourd'hui, nous assemblons un modèle avec un potentiomètre (résistance variable) et une LED. Un tel modèle peut être utilisé pour contrôler un robot.

Potentiomètre est une variable résistance à résistance réglable.Les potentiomètres sont utilisés en robotique comme régulateurs de divers paramètres - volume sonore, puissance, tension, etc. Dans notre modèleen tournant le bouton du potentiomètreLa luminosité de la LED en dépendra. C'est aussi l'un des schémas de base.

Instructions vidéo pour assembler le modèle :

Pour assembler le modèle, nous avons besoin de :

• Carte Arduino (ou analogues);
• Planche à pain ;
• 6 fils et/ou cavaliers mâle-mâle ;
• Diode électro-luminescente;
• potentiomètre (résistance variable);
• Résistance de 220 ohms ;
• Arduino IDE, téléchargeable sur le site Arduino.

De quoi avez-vous besoin pour connecter un potentiomètre et une LED à Arduino ?

Schéma de connexion pour le modèle Arduino avec potentiomètre et LED :

Schéma de connexion pour modèle Arduino avec potentiomètre et LED

Le programme suivant convient au fonctionnement de ce modèle (vous pouvez simplement copier le programme dans l'IDE Arduino) :

// donne les noms des broches avec LED
// et potentiomètre
#définir la led 9
#définir le pot A0
void setup()
{
// broche avec LED - sortie
pinMode (led, SORTIE);
// broche avec potentiomètre - entrée
pinMode(pot, INPUT);
}
boucle vide()
{
// déclare la variable x
entier x ;
// lit la tension du potentiomètre :
// un nombre de 0 à 1023 sera reçu
// divisez-le par 4, vous obtenez un nombre dans la plage
// 0-255 (la partie fractionnaire sera supprimée)
x = lectureanalogique(pot) / 4 ;
// affiche le résultat sur la LED
analogWrite(led, x);
}

Voici à quoi ressemble le modèle Arduino assemblé d'un potentiomètre avec une LED :

Modèle Arduino avec potentiomètre et LED assemblés

Ceci termine la troisième leçon « Arduino pour les débutants ». À suivre!

Articles de cours :

1. Première leçon: .
2. Deuxième leçon : .
3. Troisième leçon : .
4. Quatrième leçon : .
5. Cinquième leçon : .
6. Leçon six : .
7. Septième leçon : .
8. Huitième leçon : .
9. Neuvième leçon :

Et essayons d'accomplir une nouvelle tâche. Je pense que tout le monde a vu les guirlandes du Nouvel An dans lesquelles les LED clignotent en douceur. Disons que nous voulons faire quelque chose comme ça.
Nous avons déjà examiné la fonction digitalWrite() et savons que la valeur qu'elle écrit peut être de deux options : élevée ou faible. Dans ce cas, la fonction analogWrite() nous aidera. Les "formulations" des fonctions ne diffèrent que par les préfixes initiaux, elles sont donc faciles à retenir.

La fonction analogWrite(), comme digitalWrite(), contient deux arguments entre parenthèses et fonctionne sur le même principe verbal : « où, quoi ». La principale différence est la possibilité d'enregistrer une large plage de valeurs au lieu des valeurs habituelles LOW ou HIGH. Cela nous permettra d'ajuster la luminosité de la LED. La principale remarque à garder à l’esprit est que cette fonctionnalité ne fonctionne que sur certains contacts. Ces broches sont marquées d'un symbole "~". Ce symbole indique qu'il s'agit d'un contact PWM. PWM (modulation de largeur d'impulsion) sonne comme PWM (modulation de largeur d'impulsion) en russe. Le principe de fonctionnement est basé sur la modification de la durée de l'impulsion. Graphiquement, cela peut être représenté ainsi :

Essayons de comprendre comment cela fonctionne en regardant un exemple simple. Pour ce faire, vous devez connecter la LED au contact PWM via une résistance de 150 Ohm et « câbler » un programme simple dans l'Arduino. Le schéma de connexion et le code de croquis sont présentés ci-dessous :

void setup()
{
pinMode (led, SORTIE);
}

boucle vide()
{
pour (int je = 0; je<=255; i++)
{
analogWrite(led,i);
retard(10);
}
pour(int i=255; i>=0; i--)
{
analogWrite(led,i);
retard(10);
}
}

Je pense que le code est généralement clair, mais nous devons prêter un peu d'attention à la boucle for(). Il existe une autorisation. Puisque nous travaillons avec une résolution de 8 bits (cela sera discuté un peu plus tard), la valeur minimale sera 0 et la valeur maximale sera 255. À la fin de chaque itération, nous fixons le délai à 10 ms.

Revenons au schéma de la leçon précédente et essayons de créer une guirlande similaire en utilisant la fonction analogWrite().

int boutonPin = 2;
broches int = (3,5,6,9,10,11);

booléen lastButton = FAIBLE ;
booléen currentButton = LOW ;
booléen activer = faux ;

void setup()
{
pinMode(boutonPin, INPUT);
pour (int mode = 0; mode<= 5; mode++) pinMode(pins, OUTPUT);
}

booléen anti-rebond (booléen dernier)
{
courant booléen = digitalRead (buttonPin);
si(dernier != actuel)
{
retard(5);
courant = digitalRead (boutonPin);
}
courant de retour ;
}

boucle vide()
{
currentButton = anti-rebond (lastButton);
if(lastButton == FAIBLE && currentButton == HIGH)
{
activer = !activer;
}

Si (activer == vrai)
{
pour (int je=0; je<=5; i++)
{
pour (int luminosité = 0 ; luminosité<= 255; brightness++)
{
retard(1);
}
retard(40);
}
pour (int je=0; je<=5; i++)
{
pour (int luminosité = 255 ; luminosité >= 0 ; luminosité--)
{
analogWrite (broches [i], luminosité);
retard(1);
}
retard(40);
}
}

Si (activer == faux)
{
pour (int je = 0; je<= 5; i++) digitalWrite(pins[i], LOW);
}

LastButton = boutonactuel ;
}

Visuellement, le croquis est devenu un peu plus complexe. En fait, tout est simple ici et découvrons-le. Nous devons identifier toutes les LED connectées, mais au lieu de la LED int habituelle, nous utilisons un tableau dont chaque élément est une broche PWM sur l'Arduino. Dans le corps de la fonction void setup(), nous avons également agi de manière astucieuse. Nous avons confié le « listing » de tous les contacts à la boucle for(), à chaque itération de laquelle le contact correspondant est configuré sur OUTPUT. Passons à la fonction void loop(). La fonction debounce() et la condition initiale if() restent inchangées. Nous vérifions toujours les niveaux de deux variables : la valeur précédente (initialement FAIBLE) et l'état actuel du bouton. Lorsque ces conditions sont remplies, la valeur de la variable d'activation est inversée. Dans cet esprit, nous avons ajouté deux conditions if() plus simples. Si activate = true, alors la guirlande est allumée, dont la fluidité est contrôlée par la boucle for(). Si activate = false, alors toutes les LED sont éteintes. A la fin des conditions, la variable lastButton prend l'état actuel du bouton.
En testant notre programme, nous avons remarqué que tout ne fonctionnait pas comme prévu. Rappelez-vous, dans la dernière leçon, nous avons apporté un amendement selon lequel si le délai est important, le bouton se déclenchera après son expiration ? Dans l'exemple précédent, lorsque la guirlande était allumée, le délai total dans le corps de la fonction void loop() était de 85 ms. Cela nous a donné l’opportunité d’« y arriver » dans un certain laps de temps. Dans ce schéma, dans les mêmes conditions, le retard diffère plusieurs fois. Peut-être que si vous souhaitez éteindre la guirlande, le mot « interruption » s'impose. Ce sera la solution à ce problème !

J'espère que cet article vous a été utile. Dans le prochain didacticiel, nous examinerons les interruptions dans Arduino et obtiendrons le résultat souhaité.