Amélioration d'un cube d'ambiance LED Arduino (simple) (vidéo incluse): 4 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Après avoir vu un projet de petit cube d'ambiance LED créé par 'earl, j'ai décidé de faire une version améliorée du LED Mood Cube. Ma version sera plus complexe que l'originale, car elle sera légèrement plus grande que l'originale, aura deux couleurs de plus par rapport au cube d'origine (ajout de jaune et de blanc), aura une quantité infinie de rotation de couleurs, etc. devrait être un bon projet à pratiquer sur l'utilisation ultérieure des lumières LED pour ceux qui ont compris le concept de connexion des lumières LED avec des fils.

Étape 1: Matériaux

Voici quelques matériaux dont vous aurez besoin pour fabriquer ce Mood Cube:

• Planche à pain
• Arduino - (J'ai Leonardo ici)
• Alimentation Arduino / Câble USB
• Planche à pain
• Fils de connexion (Beaucoup d'entre eux, j'ai utilisé 29 fils)
• LED rouge x 2
• LED bleue x 2
• LED verte x 2
• LED jaune x 2
• LED blanche x 1
• 9 résistances
• Boîte assez grande pour contenir la planche à pain (j'ai utilisé une boîte à chaussures)
• Couteau tout usage
• Papier

Étape 2: Coder

Quelques explications pour le code donné ici:

Le crédit des codes va à la source originale de mon projet car l'éditeur du projet a créé ces codes. J'ai simplement amélioré certains d'entre eux en les rendant plus complexes. Dans certains codes, vous pourriez voir //改 à la fin. Cela signifie que ce code est édité par moi, il est donc différent de ma source d'origine.

J'ai aussi une version du code sur Arduino Creator.

/* Code pour le fondu enchaîné 3 LEDs, rouge, verte et bleue (RVB) Pour créer des fondus, vous devez faire deux choses: 1. Décrire les couleurs que vous voulez afficher 2. Lister l'ordre dans lequel vous voulez qu'elles se fondent

DÉCRIRE UNE COULEUR:

Une couleur n'est qu'un tableau de trois pourcentages, 0-100, contrôlant les LED rouges, vertes et bleues

Le rouge est la LED rouge à plein, bleu et vert éteint

int red = { 100, 0, 0 } Dim white correspond aux trois LED à 30% int dimWhite = {30, 30, 30} etc.

Certaines couleurs courantes sont fournies ci-dessous, ou créez les vôtres

LISTE DE LA COMMANDE:

Dans la partie principale du programme, vous devez lister l'ordre dans lequel vous souhaitez que les couleurs apparaissent, par ex. fondu enchaîné (rouge); fondu enchaîné (vert); fondu enchaîné (bleu);

Ces couleurs apparaîtront dans cet ordre, s'estompant

une couleur et dans la suivante

De plus, il y a 5 paramètres facultatifs que vous pouvez ajuster:

1. La couleur initiale est définie sur le noir (de sorte que la première couleur s'estompe), mais vous pouvez définir la couleur initiale sur n'importe quelle autre couleur 2. La boucle interne s'exécute sur 1020 interactions; la variable 'wait' définit la durée approximative d'un seul fondu enchaîné. En théorie, une 'attente' de 10 ms devrait faire un crossFade d'environ 10 secondes. En pratique, les autres fonctions exécutées par le code ralentissent à environ 11 secondes sur ma carte. YMMV. 3. Si 'repeat' est réglé sur 0, le programme bouclera indéfiniment. s'il est défini sur un nombre, il bouclera ce nombre de fois, puis s'arrêtera sur la dernière couleur de la séquence. (Réglez 'return' à 1 et rendez la dernière couleur noire si vous voulez qu'elle s'estompe à la fin.) 4. Il y a une variable 'hold' facultative, qui suspend le programme pendant 'hold' millisecondes quand une couleur est terminé, mais avant que la couleur suivante ne commence. 5. Définissez l'indicateur DEBUG sur 1 si vous souhaitez que la sortie de débogage soit envoyée au moniteur série.

Les éléments internes du programme ne sont pas compliqués, mais ils

sont un peu difficiles - le fonctionnement interne est expliqué sous la boucle principale.

Avril 2007, Clay Shirky

*

/ Sortir

int ylwPin = 5; // LED jaune, connectée à la broche numérique 5 //改 int redPin = 6; // LED rouge, connectée à la broche numérique 6 //改 int grnPin = 7; // LED verte, connectée à la broche numérique 7 //改 int bluPin = 8; // LED bleue, connectée à la broche numérique 8 //改 int whiPin = 9; // LED blanche, connectée à la broche numérique 9 //改 int ylwPin2 = 10; // LED jaune, connectée à la broche numérique 10 //改 int redPin2 = 11; // LED rouge, connectée à la broche numérique 11 //改 int grnPin2 = 12; // LED verte, connectée à la broche numérique 12 //改 int bluPin2 = 13; // LED bleue, connectée à la broche numérique 13 //改

// Tableaux de couleurs

int noir[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };//改 int blanc[9] = { 100, 100, 100, 100, 100, 100, 100, 100, 100 };//改 int rouge[9] = { 0, 0, 100, 0, 0, 0, 100, 0, 0 };//改 int vert[9] = { 0, 100, 0, 0, 0, 0, 0, 100, 0 };//改 int bleu[9] = { 0, 0, 0, 100, 0, 0, 0, 0, 100 };//改 int jaune[9] = { 100, 0, 0, 0, 0, 100, 0, 0, 0 }; //改 int violet[9] = { 0, 50, 0, 50, 0, 0, 50, 0, 50 }; //改 int orange[9] = { 50, 50, 0, 0, 0, 50, 50, 0, 0 }; //改 int rose[9] = { 0, 50, 0, 0, 50, 0, 0, 50, 0, }; //改 // etc.

// Définir la couleur initiale

int redVal = noir[0]; int grnVal = noir[1]; int bluVal = noir[2]; int ylwVal = noir[3]; //改 int whiVal = noir[4]; //改

attente int = 15; // Retard interne de fondu enchaîné de 10 ms; augmenter pour les fondus plus lents //改

int hold = 1; // Option retenue lorsqu'une couleur est terminée, avant le prochain crossFade //改 int DEBUG = 1; // Compteur DEBUG; s'il est défini sur 1, écrira les valeurs via serial int loopCount = 60; // À quelle fréquence DEBUG doit-il signaler ? répétition int = 0; // Combien de fois faut-il boucler avant de s'arrêter ? (0 pour aucun arrêt) //改 int j = 0; // Compteur de boucle pour la répétition

// Initialiser les variables de couleur

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; //改

// Configurer les sorties LED

void setup() { pinMode(redPin, OUTPUT); // définit les broches comme sortie pinMode(grnPin, OUTPUT); pinMode(bluPin, SORTIE); pinMode(ylwPin, SORTIE); //改 pinMode(whiPin, OUTPUT); //改 pinMode(grnPin2, OUTPUT); //改 pinMode(bluPin2, OUTPUT); //改 pinMode(ylwPin2, OUTPUT); //改 pinMode(redPin2, OUTPUT); //改

if (DEBUG) { // Si nous voulons voir les valeurs pour le débogage…

Serial.begin(9600); // …configurer la sortie série } }

// Programme principal: liste l'ordre des fondus enchaînés

boucle vide() { crossFade(rouge); fondu enchaîné (vert); fondu enchaîné (bleu); fondu enchaîné (jaune); fondu enchaîné (blanc); fondu enchaîné (rose); fondu enchaîné (violet); fondu enchaîné (orange);

if (repeat) { // Boucle un nombre fini de fois ?

j += 1; if (j >= répéter) { // Sommes-nous déjà arrivés ? sortie(j); // Si oui, arrête. } } }

/* AU-DESSOUS DE CETTE LIGNE SE TROUVE LES MATHÉMATIQUES -- VOUS N'AVEZ PAS BESOIN DE CHANGER CETTE LIGNE POUR LES BASES

Le programme fonctionne comme ceci:

Imaginez un fondu enchaîné qui déplace la LED rouge de 0 à 10, la verte de 0 à 5 et la bleue de 10 à 7, en dix étapes. Nous voudrions compter les 10 étapes et augmenter ou diminuer les valeurs de couleur par incréments égaux. Imaginez qu'un + indique une augmentation d'une valeur de 1, et un - équivaut à une diminution. Notre fondu en 10 étapes ressemblerait à:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + Sol + + + + + B - - -

Le rouge monte de 0 à 10 en dix étapes, le vert de

0-5 en 5 étapes, et le bleu tombe de 10 à 7 en trois étapes.

Dans le programme réel, les pourcentages de couleur sont convertis en

0-255 valeurs, et il y a 1020 étapes (255*4).

Pour déterminer la taille d'un pas qu'il devrait y avoir entre un

tick vers le bas de l'une des valeurs LED, nous appelons calculateStep(), qui calcule l'écart absolu entre les valeurs de début et de fin, puis divise cet écart par 1020 pour déterminer la taille de l'étape entre les ajustements de la valeur. */

int calculateStep(int prevValue, int endValue) {

int step = endValue - prevValue; // Quel est l'écart global ? if (step) { // S'il n'est pas nul, step = 1020 / step; // diviser par 1020 } return step; }

/* La fonction suivante est calculateVal. Lorsque la valeur de boucle, i, atteint la taille de pas appropriée pour l'une des couleurs, il augmente ou diminue la valeur de cette couleur de 1. (R, V et B sont chacun calculés séparément.) */

int calculateVal(int step, int val, int i) {

if ((step) && i % step == 0) { // Si step est différent de zéro et qu'il est temps de changer une valeur, if (step > 0) { // incrémente la valeur si step est positif… val += 1; } else if (étape 255) { val = 255; } else if (val < 0) { val = 0; } valeur de retour; }

/* crossFade() convertit les pourcentages de couleurs en un

0-255, puis boucle 1020 fois, en vérifiant si la valeur doit être mise à jour à chaque fois, puis en écrivant les valeurs de couleur sur les bonnes broches. */

void crossFade(int color) { //改

// Convertir en 0-255 int R = (color[0] * 255) / 100; int G = (couleur[1] * 255) / 100; entier B = (couleur[2] * 255) / 100; entier Y = (couleur[3] * 255) / 100; //改 int W = (couleur[4] * 255) / 100; //改

int stepR = calculateStep(prevR, R);

int stepG = calculateStep(prevG, G); int stepB = calculateStep(prevB, B); int stepY = calculateStep(prevY, Y); //改 int stepW = calculateStep(prevW, W); //改

for (int i = 0; i <= 1020; i++) { redVal = calculateVal(stepR, redVal, i); grnVal = calculateVal(stepG, grnVal, i); bluVal = calculateVal (étape B, bluVal, i); ylwVal = calculateVal(stepY, ylwVal, i); //改 whiVal = calculateVal(stepW, whiVal, i); //改

analogWrite(redPin, redVal); // Écrire les valeurs actuelles sur les broches LED

analogWrite(grnPin, grnVal); analogWrite(bluPin, bluVal); analogWrite(ylwPin, ylwVal); //改 analogWrite(whiPin, whiVal); //改 analogWrite(grnPin2, grnVal); //改 analogWrite(bluPin2, bluVal); //改 analogWrite(ylwPin2, ylwVal); //改 analogWrite(redPin2, redVal); //改

retarder (attendre); // Pause pour 'attendre' millisecondes avant de reprendre la boucle

if (DEBUG) { // Si nous voulons une sortie série, imprimez-la à la

if (i == 0 ou i % loopCount == 0) { // début, et chaque loopCount fois Serial.print("Loop/RGBYW: #"); Serial.print(i); Serial.print(" | "); Serial.print(redVal); Serial.print(" / "); Serial.print(grnVal); Serial.print(" / "); Serial.println(bluVal); Serial.print(" / "); Serial.println(ylwVal); //改 Serial.print(" / "); //改 Serial.println(whiVal); //改 Serial.print(" / "); //改 } DEBUG += 1; } } // Mettre à jour les valeurs actuelles pour la prochaine boucle prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; //改 prevW = whiVal; //改 delay(hold); // Pause pour 'attendre' quelques millisecondes avant de reprendre la boucle }

Étape 3: configuration

1. Obtenez la planche à pain.

2. Démonstration des fils de connexion pour qu'une lumière LED puisse briller:

   1. Mettez la LED sur la planche à pain. Placez l'extrémité la plus longue à gauche et l'extrémité la plus courte à droite.
   2. Placez une extrémité d'un cavalier sur un point situé sur la même rangée que l'extrémité la plus longue de la LED. Placez l'autre extrémité sur la section Digital PWM. Le code spécifiait les LED jaunes à connecter à 10 et 5, les rouges à 6 et 11, les bleues à 8 et 13, les vertes à 7 et 12, et enfin la LED blanche à 9.
   3. Placez une extrémité d'une résistance sur la même rangée avec l'extrémité la plus courte de la LED. Placez l'autre extrémité quelque part à proximité.
   4. Placez une extrémité d'un autre fil de liaison avec la même rangée avec l'extrémité de la résistance qui n'est pas sur la même rangée avec l'extrémité la plus courte de la LED. Placez l'autre extrémité du fil sur la rangée de charge négative.
   5. Placez une extrémité d'un autre fil de liaison sur la rangée de charge négative et placez son autre extrémité sur GND.
3. Répétez l'étape 2 8 fois si vous voulez que 9 LED brillent

4. Placez la planche à pain à l'intérieur de la boîte. Quelques rappels ici:

   1. J'ai utilisé une alimentation. Créez un petit trou pour vos fils à l'aide d'un couteau utilitaire pour passer à travers la boîte et connecter à la planche à pain.
   2. Assurez-vous que la boîte est d'un côté ouvert. Une boîte à chaussures a déjà un côté ouvert. Si la boîte est complètement fermée, coupez un côté de la boîte pour créer un espace ouvert.
   3. Couvrir le côté sans rien avec du papier. C'est pour que les lumières LED brillent à travers le papier.