Construire un scanner LED Knight Rider avec Arduino
N’avez-vous jamais souhaité avoir votre propre voiture Knight Industries Two Thousand (KITT) – vous savez, de Knight Rider ? Construisez un scanner LED pour rapprocher vos rêves de la réalité ! Voici le résultat final :
de quoi avez-vous besoin
Vous n’avez pas besoin de beaucoup de pièces pour ce projet, vous en avez probablement déjà beaucoup :
- 1 x Arduino UNO ou similaire
- 1 planche à pain
- 8 LED rouges
- 8 résistances de 220 ohms
- 1 potentiomètre 10k ohms
- Fils de connexion mâle-mâle
Si vous avez un kit de démarrage Arduino, il y a de fortes chances que vous ayez toutes ces pièces (que pouvez-vous faire avec un kit de démarrage ?).
Pratiquement n’importe quel Arduino fonctionnera tant qu’il dispose de huit broches (vous n’avez jamais utilisé d’Arduino auparavant ? Commencez ici). Vous pouvez utiliser un registre à décalage pour contrôler les LED, bien que cela ne soit pas nécessaire pour ce projet car l’Arduino a suffisamment de broches.
Plan de construction
C’est un projet très simple. Bien que cela puisse sembler compliqué à cause de la quantité de fils, chaque pièce individuelle est assez simple. Chaque diode électroluminescente (LED) est connectée à sa propre broche Arduino. Cela signifie que chaque LED peut être allumée et éteinte individuellement. Des potentiomètres sont connectés aux broches analogiques Arduino pour régler la vitesse du scanner.
circuit
Connectez la broche extérieure gauche du potentiomètre (en regardant vers l’avant, la broche est en bas) à la masse. Connectez la broche externe opposée au +5v. Si cela ne fonctionne pas, inversez ces broches. Connectez la broche du milieu à l’analogique Arduino en 2.
Faire une vidéo du jour
Connectez l’anode (jambe longue) de chaque LED aux broches numériques 1 à 8. Connectez la cathode (jambe courte) à la masse Arduino.
codage
Créez une nouvelle esquisse et enregistrez-la sous le nom de « knightRider ». Voici le code :
const int leds[] = {1,2,3,4,5,6,7,8} ; // broches LED
const int totalLeds = 8 ;
temps entier = 50 ; // vitesse par défaut
void set() {
// initialise toutes les sorties
for(int je = 0; je <= totalLeds; ++i) {
PinMode (DEL[i]production);
}
}
boucle vide() {
for(int je = 0; je < totalLeds - 1; ++i) {
// scanne de gauche à droite
temps = analogRead(2);
écriture numérique (LED[i]Haute);
retard);
écriture numérique (LED[i + 1]Haute);
retard);
écriture numérique (LED[i]bas);
}
for(int je = totalLeds; je > 0; –i) {
// scanne de droite à gauche
temps = analogRead(2);
écriture numérique (LED[i]Haute);
retard);
écriture numérique (LED[i – 1]Haute);
retard);
écriture numérique (LED[i]bas);
}
}
Décomposons-le. Chaque broche de LED est stockée dans un tableau :
const int leds[] = {1,2,3,4,5,6,7,8} ;
Les tableaux sont essentiellement des collections d’éléments connexes. Ces éléments sont définis comme des constantes (« const »), ce qui signifie qu’ils ne peuvent pas être modifiés ultérieurement. Bien que l’utilisation de constantes soit recommandée, vous n’y êtes pas obligé (le code fonctionnera parfaitement si vous supprimez « const »).
Utilisez des crochets (« [ ] ») et un entier appelé index. L’index commence à zéro, donc « leds[2] » renverra le troisième élément du tableau – la broche 3. Les tableaux rendent le code plus rapide et plus facile à lire, ils laissent l’ordinateur faire le gros du travail !
Une boucle for est utilisée pour définir chaque broche comme sortie :
for(int je = 0; je <= totalLeds; ++i) {
PinMode (DEL[i]production);
}
Ce code se trouve dans la fonction « setup() » car il ne doit être exécuté qu’une seule fois au démarrage du programme. Les boucles for sont très utiles. Ils vous permettent d’exécuter le même code encore et encore, en utilisant des valeurs différentes à chaque fois. Ils sont parfaits pour travailler avec des tableaux. Un entier « i » est déclaré, et seul le code à l’intérieur de la boucle peut accéder à cette variable (c’est ce qu’on appelle la « portée »). La valeur de i commence à zéro et augmente de 1 à chaque itération de la boucle. La boucle « casse » (s’arrête) une fois que la valeur de i est inférieure ou égale à la variable « totalLeds ».
La valeur de i est utilisée pour accéder au tableau « leds ». Cette boucle accède à chaque élément du tableau et le configure comme une sortie. Vous pouvez taper manuellement « pinMode(pin, OUTPUT) » huit fois, mais pourquoi écrire huit lignes quand vous pouvez en écrire trois ?
Alors que certains langages de programmation peuvent vous dire combien d’éléments se trouvent dans un tableau (généralement en utilisant une syntaxe comme array.length), Arduino ne le rend pas si facile (il implique plus de mathématiques). Puisque le nombre d’éléments dans le tableau est connu, ce n’est pas un problème.
à l’intérieur de la boucle principale (boucle vide ()) sont les deux autres boucles for. Le premier règle la LED sur ON, puis de 1 à 8 sur OFF. La deuxième boucle règle la LED sur ON puis de 8 – 1 off. Faites attention à la méthode de réglage de la broche actuelle et à la méthode de réglage pour en ajouter une à la broche actuelle. Cela garantit que les deux LED sont toujours allumées en même temps, ce qui rend le scanner plus réaliste.
Au début de chaque boucle, la valeur du pot est lue dans la variable « time »:
temps = analogRead(2);
Faites cela deux fois, une fois à l’intérieur de chaque boucle. Cela nécessite une vérification et une mise à jour constantes. Si cela se trouve en dehors de la boucle, cela fonctionnera toujours, mais avec un petit délai – il ne s’exécutera qu’après la fin de l’exécution de la boucle. Les potentiomètres sont analogiques, utilisez donc « analogRead(pin) ». Cela renverra une valeur comprise entre zéro (minimum) et 1023 (maximum). L’Arduino est capable de convertir ces valeurs en quelque chose de plus utile, mais elles sont parfaites pour ce cas d’utilisation.
Le délai entre les changements de LED (ou la vitesse du scanner) est défini en millisecondes (1/1000e de seconde), de sorte que le temps maximum est légèrement supérieur à 1 seconde.
Analyseur avancé
Maintenant que vous connaissez les bases, regardons quelque chose de plus compliqué. Le scanner allumera des LED par paires en partant de l’extérieur et fonctionnera en interne. Ensuite, il s’inversera et s’appariera de l’intérieur vers l’extérieur. Voici le code :
const int leds[] = {1,2,3,4,5,6,7,8} ; // broches LED
const int totalLeds = 8 ;
const int halfLeds = 4 ;
temps entier = 50 ; // vitesse par défaut
void set() {
// initialise toutes les sorties
for(int je = 0; je <= totalLeds; ++i) {
PinMode (DEL[i]production);
}
}
boucle vide() {
for(int je = 0; je < (halfLeds - 1); ++i) {
// recherche les paires externes
temps = analogRead(2);
écriture numérique (LED[i]Haute);
écriture numérique (LED[(totalLeds – i) – 1]Haute);
retard);
écriture numérique (LED[i]bas);
écriture numérique (LED[(totalLeds – i) – 1]bas);
retard);
}
for(int je = (halfLeds – 1); je > 0; –i) {
// analyse la paire interne
temps = analogRead(2);
écriture numérique (LED[i]Haute);
écriture numérique (LED[(totalLeds – i) – 1]Haute);
retard);
écriture numérique (LED[i]bas);
écriture numérique (LED[(totalLeds – i) – 1]bas);
retard);
}
}
Ce code est un peu plus compliqué. Remarquez comment les deux boucles vont de zéro à « halfLeds – 1 » (3). Cela améliore le scanner. Si les deux boucles commencent à 4 – 0 et 0 – 4, alors la même LED clignotera deux fois dans le même ordre – ce qui n’a pas l’air bien.
Vous devriez maintenant avoir un scanner LED Knight Rider fonctionnel ! Il est facile de le modifier pour utiliser plus ou plus de LED ou pour implémenter vos propres modèles. Ce circuit est facile à porter sur un Raspberry Pi (débutant en Pi ? Commencer ici) ou ESP8266.
Construisez-vous une réplique KITT ? J’aimerais voir tout Knight Rider dans les commentaires.
A propos de l’auteur
