Blog
Projet de feu de circulation basé sur Arduino Uno
Les feux de circulation sont des éléments que l'on voit quotidiennement sur les routes. Ils régulent le flux des véhicules et maintiennent la circulation de manière organisée et sans accidents. La plupart des gens ne réfléchissent jamais au fonctionnement réel de ces feux, mais l'idée sous-jacente est assez simple une fois qu'on l'analyse.
Dans cet article, nous allons construire un petit modèle de système de feux de signalisation à l'aide d'une carte Arduino Uno, de quelques LED et d'une plaque d'expérimentation (breadboard). Il s'agit de l'un des projets les plus courants pour les débutants en électronique et en systèmes embarqués, car il enseigne les bases du contrôle des sorties numériques, de la temporisation et de la construction de circuits, le tout en un seul projet simple.
À la fin de cet article, vous comprendrez le fonctionnement d'un véritable feu de signalisation, comment câbler les composants, comment écrire le code correspondant et comment le tester sur votre propre carte Arduino.
Pourquoi ce projet est un bon point de départ
Toute personne novice en Arduino ou en électronique a souvent du mal à trouver un projet suffisamment simple à comprendre tout en enseignant quelque chose d'utile. Le projet de feu de circulation est parfait pour cela car il ne nécessite qu'une poignée de composants, le câblage n'est pas compliqué et le code est court et facile à suivre. Parallèlement, il introduit des concepts très importants tels que :
- Comment connecter des LED en toute sécurité avec des résistances
- Comment fonctionnent les broches numériques sur un microcontrôleur
- Comment contrôler le chronométrage à l'aide de délais
- Comment structurer un programme à l'aide de boucles
Ce sont les mêmes éléments de base utilisés dans des projets beaucoup plus avancés, ainsi, les apprendre ici vous donne une base solide pour tout ce que vous pourriez construire par la suite.
Composants Requis
Pour construire ce projet, vous n'avez pas besoin de nombreuses pièces. Voici la liste complète :
- Carte Arduino Uno
- Câble USB pour connecter l
- Platine d'expérimentation
- LED Rouge
- LED jaune
- LED verte
- Trois résistances (220 ohms est une bonne valeur pour les LED)
- Fils de connexion (mâle à mâle)
Toutes ces pièces sont bon marché et facilement disponibles dans n'importe quel magasin d'électronique ou boutique en ligne. Si vous êtes étudiant ou amateur, vous avez peut-être déjà la plupart de ces éléments à disposition à partir d'autres petits projets. Pour de futurs projets professionnels, PCBCool peut également prendre en charge Approvisionnement en composants, aidant les clients à gérer la disponibilité et l'approvisionnement des nomenclatures conjointement avec Assemblage de circuits imprimés.
Comprendre le fonctionnement d'un véritable feu de circulation
Avant de plonger dans le câblage, il est utile de comprendre le schéma réel suivi par les feux de circulation dans la vie réelle. Un signal de circulation standard a trois couleurs, chacune ayant une signification :
- Rouge signifie arrêt. Les véhicules ne doivent pas bouger.
- Le jaune signifie "préparez-vous". Le feu est sur le point de changer, les conducteurs devraient donc ralentir.
- Le vert signifie avancer. Les véhicules sont autorisés à circuler.
Le cycle normal dans la plupart des pays se déroule comme suit : le feu reste rouge pendant un certain temps, puis il passe au vert, puis, avant de redevenir rouge, il affiche brièvement le jaune en guise d'avertissement. Ce cycle se répète sans cesse. Notre projet Arduino va reproduire ce même schéma en utilisant des LED au lieu de grosses ampoules de feux de circulation.
Schéma de circuit et câblage
Le câblage pour ce projet est très simple car nous ne travaillons qu'avec trois LED. Chaque LED doit être connectée à une broche numérique de l'Arduino via une résistance, et l'autre patte de chaque LED doit être connectée à la broche de masse.
Ci-dessous se trouve le schéma du circuit montrant comment tout doit être connecté. La LED rouge, la LED jaune et la LED verte sont placées sur la plaque d'expérimentation, chacune étant reliée à l'Arduino à l'aide de fils de connexion colorés. Remarquez comment le fil noir borde le rail inférieur de la plaque d'expérimentation pour fournir une connexion de masse commune à toutes les trois LED.
Tel qu'illustré par le schéma, les connexions sont les suivantes :
- LED rouge connectée à la broche numérique 9
- LED jaune connectée à la broche numérique 8
- LED verte connectée à la broche numérique 7
- Toutes les pattes de masse des LED sont connectées à la broche GND de l'Arduino via le rail de masse de la platine d'expérimentation.
Vous pouvez utiliser différentes broches si vous le souhaitez, assurez-vous simplement que les broches de votre code correspondent aux broches que vous câblerez réellement.
Étapes de câblage
Voici une méthode étape par étape pour construire le circuit :
- Placez l'Arduino à côté de la platine d'expérimentation de manière à ce que les fils puissent confortablement la traverser.
- Insérez les LED rouge, jaune et verte dans la plaque d'expérimentation, en ménageant un espace entre elles. Chaque LED possède deux pattes, une plus longue (positive) et une plus courte (négative).
- Connectez une résistance de 220 ohms à la patte la plus longue (positive) de chaque LED. La résistance protège la LED d'un courant excessif, qui pourrait la griller.
- Connectez une fils de cavalier de l'autre extrémité de chaque résistance aux broches numériques de l'Arduino (9, 8 et 7 dans notre exemple).
- Connectez la patte la plus courte (négative) de chaque LED au rail de masse de la platine d'expérimentation.
- Enfin, connectez le rail de masse du breadboard à la broche GND de l'Arduino à l'aide d'un seul fil de connexion.
Une fois ce câblage terminé, votre breadboard et votre Arduino devraient ressembler à l'image ci-dessous, montrant la configuration physique finale avec les trois LED connectées et câblées à la carte.
Dans cette image, vous pouvez voir l'Arduino Uno alimenté par un câble USB, avec des fils de connexion qui descendent vers la plaque d'expérimentation où les trois LED sont placées en ligne. Cela correspond exactement à ce que nous avons décrit dans le schéma de circuit, mais sous une forme physique réelle au lieu d'un dessin.
Écriture du code
Maintenant que le matériel est prêt, nous devons écrire le programme qui contrôlera les LED. Le langage de programmation Arduino est basé sur C et C++, mais pour un projet comme celui-ci, vous n'avez besoin que de connaître quelques commandes de base.
Voici le code complet pour le projet de feu de circulation :
int redLED = 9 ;
int yellowLED = 8 ;
int greenLED = 7 ;
void setup() {
pinMode(redLED, OUTPUT) ;
pinMode(yellowLED, OUTPUT) ;
pinMode(greenLED, OUTPUT);
}
void loop() {
// Allumage de la lumière rouge
digitalWrite(redLED, HIGH);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, LOW);
delay(5000);
// Allumage de la lumière verte
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, HIGH);
delay(5000);
// Allumage du voyant jaune
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, HIGH);
digitalWrite(greenLED, LOW);
delay(2000);
}
Explication du code
Décomposons ce que fait chaque partie de ce code :
- En haut, nous déclarons trois variables (redLED, yellowLED, greenLED) et leur attribuons les numéros de broche que nous avons utilisés dans notre câblage. Cela rend le code plus facile à lire et à modifier ultérieurement, car nous n'avons pas à nous souvenir des numéros de broche tout au long du programme.
- La fonction setup() s'exécute une seule fois lors de la mise sous tension ou de la réinitialisation de l'Arduino. À l'intérieur, nous indiquons à l'Arduino que chacun de ces trois broches sera utilisé comme une SORTIE, ce qui signifie que l'Arduino enverra de l'énergie hors de ces broches plutôt que de lire l'énergie qui y arrive.
- La fonction loop() s'exécute encore et encore, indéfiniment, tant que l'Arduino est alimenté. C'est là que se déroule le schéma réel du feu de signalisation.
- digitalWrite(redLED, HIGH) allume la LED rouge en envoyant 5 volts à cette broche. digitalWrite(redLED, LOW) l'éteint en envoyant 0 volt.
- delay(5000) indique à l'Arduino d'attendre 5000 millisecondes, soit 5 secondes, avant de passer à la ligne de code suivante. C'est ce qui crée le délai entre chaque lumière.
Parce que la fonction loop() se répète sans cesse, le motif de rouge, puis vert, puis jaune, puis de retour au rouge continuera indéfiniment, tout comme un véritable feu de circulation.
Vous pouvez modifier les valeurs de délai pour que les lumières restent allumées pendant des périodes plus courtes ou plus longues, en fonction du comportement souhaité de votre modèle.
Téléverser le code sur Arduino
Une fois que vous avez écrit ou copié le code dans le logiciel Arduino IDE sur votre ordinateur, suivez ces étapes pour l'exécuter sur votre carte :
- Connectez l'Arduino à votre ordinateur à l'aide du câble USB.
- Ouvrez l'IDE Arduino et copiez-collez le code dans une nouvelle esquisse.
- Allez dans le menu Outils et sélectionnez le type de carte correct, qui devrait être Arduino Uno.
- Également, dans le menu Outils, sélectionnez le port COM correct auquel votre Arduino est connecté.
- Cliquez sur le bouton de téléchargement, qui ressemble à une flèche pointant vers la droite.
- Attendez que l'IDE affiche “ Terminé le téléchargement ” en bas de l'écran.
Une fois le téléchargement terminé, vos LED devraient immédiatement commencer à suivre le schéma des feux de circulation que nous avons défini dans le code.
Test et observation du résultat
Après avoir téléchargé le code, vous devriez voir la LED rouge s'allumer d'abord et rester allumée pendant 5 secondes. Ensuite, elle s'éteindra et la LED verte s'allumera pendant 5 secondes supplémentaires. Après cela, la LED verte s'éteindra et la LED jaune s'allumera pendant 2 secondes, signalant que le cycle est sur le point de redémarrer. Ensuite, l'ensemble du schéma se répète depuis le début avec la lumière rouge à nouveau.
Si vous testez cette configuration dans une pièce plus sombre, la lueur des LED devient beaucoup plus visible et donne un bel effet similaire à celui des feux de signalisation réels s'illuminant la nuit. L'image ci-dessous montre les LED s'allumant dans un environnement tamisé, ce qui souligne vraiment combien les couleurs ressortent une fois que la lumière ambiante est réduite.
Ce type de test est également utile pour confirmer le bon fonctionnement de votre circuit. Si l'une des LED ne s'allume pas, cela signifie généralement l'un des problèmes suivants :
- La LED pourrait être insérée à l'envers, car les LED ne fonctionnent que dans un seul sens.
- Un fil pourrait ne pas être solidement connecté à la breadboard ou à la broche de l'Arduino.
- La valeur de la résistance est peut-être trop élevée, ce qui atténue la LED au point qu'elle n'est plus visible.
- Le code PIN dans le code ne correspond pas au code PIN utilisé dans le câblage. Parcourir cette liste de contrôle résout généralement la plupart des problèmes de câblage courants pour les débutants.
Amélioration et expansion du projet
Une fois que votre feu de circulation de base fonctionne, il existe de nombreuses façons d'étendre ce projet pour le rendre plus avancé et réaliste :
- Ajouter un feu de passage piéton utilisant deux LED supplémentaires (rouge pour stop, vert pour passer) fonctionnant en opposition au feu de circulation principal.
- Ajouter un bouton-poussoir afin que les piétons puissent demander le changement de signal, tout comme les boutons de passage réels.
- Utiliser un écran LCD pour afficher un compte à rebours indiquant le nombre de secondes restantes avant le changement de feu.
- Contrôler plusieurs feux de circulation à une intersection, où une voie doit être rouge pendant que l'autre est verte, et qu'ils changent ensemble de manière synchronisée.
- Ajouter un buzzer qui retentit pendant la phase de feu jaune comme signal d'alerte supplémentaire.
Ces améliorations ne sont pas trop difficiles une fois que vous maîtrisez la version de base, et elles constituent un excellent moyen de continuer à acquérir de nouvelles compétences sur Arduino, telles que la lecture des entrées de boutons, l'utilisation de bibliothèques supplémentaires et la gestion de plusieurs composants fonctionnant ensemble simultanément.
Pensées finales
Le projet de feu de circulation basé sur l'Arduino Uno est l'une des meilleures façons pour les débutants de se familiariser avec l'électronique et la programmation en même temps. Il utilise des composants simples et abordables, et le câblage est suffisamment facile pour être terminé en moins de trente minutes. Parallèlement, les concepts sous-jacents, tels que le contrôle de la sortie numérique et la synchronisation avec des délais, sont utilisés dans d'innombrables autres projets électroniques, des systèmes d'automatisation domestique à la robotique.
FAQ
La raison principale est que chaque couche ajoutée rend le processus de fabrication plus difficile à contrôler. Plus il y a de couches, plus il y a de risques de défauts dans les couches internes, de problèmes d'alignement, de difficultés de laminage et de rebut.
Les pastilles BGA sont petites et espacées de près, de sorte que de petites erreurs de fabrication peuvent facilement devenir des problèmes d'assemblage.
Sam K travaille sur des systèmes électroniques embarqués, avec un accent particulier sur la conception matérielle, le développement de circuits imprimés (PCB), la programmation de firmware, et l'intégration système. Il soutient également l'optimisation des performances et contribue à transformer les idées de produits électroniques en solutions fiables et concrètes.
