Le feu tricolore Arduino est un petit projet amusant que vous pouvez construire en moins d'une heure. Voici comment construire le vôtre à l'aide d'un Arduino et comment changer le circuit pour une variante avancée.
Si vous préférez regarder ce tutoriel sous forme de vidéo, nous avons ce qu'il vous faut :
En plus de l'Arduino de base, vous aurez besoin de :
Presque tous les Arduino fonctionneront pour ce projet, à condition qu'ils aient suffisamment de broches. Assurez-vous de lire notre guide d'achat Arduino si vous n'êtes pas sûr du modèle dont vous avez besoin. Vous avez peut-être déjà ces pièces dans votre kit de démarrage Arduino.
Commençons petit. Un feu de circulation simple et basique est un bon point de départ. Voici le circuit :
Connectez l'anode (jambe longue) de chaque LED aux broches numériques huit, neuf et dix (via une résistance de 220 ohms). Connectez les cathodes (jambe courte) à la masse de l'Arduino.
Commencez par définir des variables afin de pouvoir adresser les lumières par leur nom plutôt que par un numéro. Démarrez un nouveau projet Arduino et commencez par ces lignes :
int rouge =10 ;
int jaune =9 ;
int vert =8; Ensuite, ajoutons la fonction de configuration, où vous configurerez les LED rouges, jaunes et vertes comme sorties. Puisque vous avez créé des variables pour représenter les numéros de broches, vous pouvez désormais faire référence aux broches par leur nom à la place :
annuler la configuration(){
pinMode (rouge, SORTIE);
pinMode (jaune, SORTIE);
pinMode (vert, SORTIE);
} Le pinMode configure l'Arduino pour utiliser une broche donnée comme sortie. Vous devez le faire pour que vos LED fonctionnent. Passons maintenant à la logique réelle du feu de circulation. Voici le code dont vous avez besoin. Ajoutez ceci sous vos définitions de variables et votre fonction de configuration :
boucle vide(){
changeLumières();
retard (15000);
}
void changeLights(){
// vert éteint, jaune allumé pendant 3 secondes
digitalWrite (vert, BAS);
digitalWrite (jaune, ÉLEVÉ);
retard (3000);
// éteint le jaune, puis allume le rouge pendant 5 secondes
digitalWrite (jaune, BAS);
digitalWrite (rouge, ÉLEVÉ);
retard (5000);
// rouge et jaune allumés pendant 2 secondes (le rouge est déjà allumé cependant)
digitalWrite (jaune, ÉLEVÉ);
retard (2000);
// éteint le rouge et le jaune, puis allume le vert
digitalWrite (jaune, BAS);
digitalWrite (rouge, BAS);
digitalWrite(vert, ÉLEVÉ);
retard (3000);
} Téléchargez ce code sur votre Arduino et exécutez (assurez-vous de sélectionner la bonne carte et le bon port dans les Outils> Conseil et Outils> Port menus). Vous devriez avoir un feu tricolore fonctionnel qui change toutes les 15 secondes, comme ceci (accéléré) :
Décomposons ce code. Les changeLumières fonction effectue tout le travail acharné. Cela fait tourner le feu de signalisation en passant par le jaune et le rouge, puis de nouveau au vert. Comme cela est appelé à l'intérieur de la boucle fonction, l'Arduino exécutera ce code pour toujours, avec une pause de 15 secondes à chaque fois.
Les changeLumières fonction se compose de quatre étapes distinctes :
Ces quatre étapes reproduisent le processus utilisé dans les vrais feux de circulation. Pour chaque étape, le code est très similaire. La LED appropriée est allumée ou éteinte à l'aide de digitalWrite . Il s'agit d'une fonction Arduino utilisée pour régler les broches de sortie sur HIGH (pour on) ou LOW (pour off).
Après avoir activé ou désactivé les voyants requis, le délai fait attendre l'Arduino pendant un certain temps. Trois secondes dans ce cas.
Maintenant que vous connaissez les bases, améliorons-le. Ajoutez un bouton poussoir pour que les piétons changent de lumière quand ils le souhaitent :
Remarquez comment le feu de circulation est exactement le même que dans l'exemple précédent. Connectez le bouton à la broche numérique 12. Vous remarquerez que le commutateur est doté d'une résistance à haute impédance de 10 kohms, et vous vous demandez peut-être pourquoi. Il s'agit d'une résistance pull-down.
Un interrupteur laisse passer le courant ou non. Cela semble assez simple, mais dans un circuit logique, le courant doit toujours circuler dans un état haut ou bas (rappelez-vous, 1 ou 0, HIGH ou LOW). Vous pourriez supposer qu'un interrupteur à bouton-poussoir qui n'est pas réellement enfoncé serait dans un état BAS, mais en fait, on dit qu'il est "flottant", car aucun courant n'est tiré du tout.
Dans cet état flottant, il est possible qu'une fausse lecture se produise car elle fluctue avec les interférences électriques. En d'autres termes, un interrupteur flottant ne donne ni une lecture HAUTE ni BASSE fiable. Une résistance pull-down maintient une petite quantité de courant circulant lorsque l'interrupteur est fermé, assurant ainsi une lecture précise de l'état bas.
Dans d'autres circuits logiques, vous pouvez trouver une résistance de rappel à la place, et cela fonctionne sur le même principe, mais en sens inverse, en s'assurant que cette porte logique particulière est par défaut élevée.
Maintenant, dans la partie boucle du code, au lieu de changer les lumières toutes les 15 secondes, vous allez plutôt lire l'état du bouton-poussoir et ne changer les lumières que lorsqu'il est activé.
Commencez par ajouter une nouvelle variable pour stocker votre épingle de bouton :
int bouton =12 ; // l'interrupteur est sur la broche 12
Maintenant, dans la fonction de configuration, ajoutez une nouvelle ligne pour déclarer le commutateur comme entrée. Ajoutez une ligne pour régler les feux de circulation sur la scène verte. Sans ce réglage initial, ils s'éteindraient jusqu'à la première fois changeLights s'exécute.
pinMode(bouton, INPUT);
digitalWrite(vert, ÉLEVÉ); Remplacez la fonction de boucle entière par la suivante :
boucle vide() {
si (numériqueRead(bouton) ==HIGH){
retard(15); // logiciel anti-rebond
si (numériqueRead(bouton) ==HIGH) {
// si le commutateur est HIGH, c'est-à-dire. poussé vers le bas - changez les lumières !
changeLumières();
retard (15000); // attend 15 secondes
}
}
} Ça devrait le faire. Vous vous demandez peut-être pourquoi la vérification du bouton se produit deux fois (digitalRead(button) ), séparés par un petit retard. C'est anti-rebond. Tout comme la résistance de pull-down pour le bouton, cette simple vérification empêche le code de détecter des interférences mineures lors d'une pression sur un bouton.
En attendant à l'intérieur du si déclaration pendant 15 secondes, les feux de circulation ne peuvent pas changer pendant au moins cette durée. Une fois les 15 secondes écoulées, la boucle redémarre. A chaque redémarrage de la boucle, il relit l'état du bouton, mais s'il n'est pas pressé, le if l'instruction ne s'active jamais, les lumières ne changent jamais et le programme redémarre à nouveau.
Voici à quoi cela ressemble (accéléré):
Essayons un modèle plus avancé. Au lieu d'un passage piéton, changez votre circuit pour avoir deux feux tricolores :
Connectez le deuxième feu aux broches numériques 11, 12 et 13.
Tout d'abord, affectez vos nouvelles broches de feux tricolores à des variables et configurez-les en tant que sorties, comme dans le premier exemple :
// léger un
int rouge1 =10 ;
int jaune1 =9 ;
int vert1 =8 ;
// allume deux
int rouge2 =13 ;
int jaune2 =12 ;
int vert2 =11 ;
void setup(){
// en allumer un
pinMode(rouge1, SORTIE);
pinMode(jaune1, SORTIE);
pinMode(vert1, SORTIE);
// allume deux
pinMode(rouge2, SORTIE);
pinMode(jaune2, SORTIE);
pinMode(vert2, SORTIE);
} Maintenant, mettez à jour votre boucle pour utiliser le code du premier exemple (au lieu du passage pour piétons) :
boucle vide(){
changeLumières();
retard (15000);
} Encore une fois, tout le travail est effectué dans le changeLights une fonction. Plutôt que de devenir rouge> rouge &jaune> vert , ce code alternera les feux de circulation. Quand l'un est au vert, l'autre est au rouge. Voici le code :
annuler changeLights(){
// allume les deux jaunes
digitalWrite(vert1, BAS);
digitalWrite(jaune1, ÉLEVÉ);
digitalWrite(jaune2, ÉLEVÉ);
retard (5000);
// éteint les deux jaunes, et en face le vert et le rouge
digitalWrite(jaune1, BAS);
digitalWrite(red1, HIGH);
digitalWrite(jaune2, BAS);
digitalWrite(red2, LOW);
digitalWrite(vert2, ÉLEVÉ);
retard (5000);
// les deux jaunes se rallument
digitalWrite(jaune1, ÉLEVÉ);
digitalWrite(jaune2, ÉLEVÉ);
digitalWrite(vert2, BAS);
retard (3000);
// éteint les deux jaunes, et en face le vert et le rouge
digitalWrite(vert1, ÉLEVÉ);
digitalWrite(jaune1, BAS);
digitalWrite(red1, LOW);
digitalWrite(jaune2, BAS);
digitalWrite(red2, HIGH);
retard (5000);
} Voici à quoi cela ressemble (accéléré) :
C'est tout pour aujourd'hui. Votre nouvelle compréhension des LED et des boutons Arduino s'applique à toutes sortes de projets différents. Si vous souhaitez étendre ces feux de circulation, pourquoi ne pas construire un carrefour à quatre voies (ou plus), avec de nombreux passages pour piétons et des feux de signalisation pour piétons ? Vous pouvez programmer facilement de nombreuses cartes Arduino différentes !
Ou pourquoi ne pas développer vos nouvelles compétences avec un projet plus important tel que ce contrôleur MIDI DIY ou un robot Arduino avec Xod ? Vous pouvez également jeter un œil au codage Arduino avec VS Code et PlatformIO.
Crédit image :androsvector/Shutterstock