Arbre en spirale LED : 4 étapes (avec photos)

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

J'aime toutes sortes de bandes LED. J'ai fait une belle lumière arc-en-ciel avec eux. Même les non adressables sont utiles. J'ai fabriqué une lumière d'extérieur pour parapluie de marché brillante en les attachant aux nervures d'unbrella. Lorsque mon arbre en spirale a soufflé, j'ai décidé d'enrouler une longueur de bande LED autour de lui.

Étape 1: Contrôleur

J'ai décidé d'utiliser des leds RVB non adressables. Cela signifie que je peux avoir un effet programmé mais que toutes les leds changent de couleur simultanément. Cela signifie également qu'un contrôleur sera nécessaire. J'aurais pu utiliser un arduino uno et faire les premiers tests à l'aide d'un blindage RVB, mais j'ai fini par utiliser une seule carte personnalisée avec une puce Atmega328 nue. Il suffisait de changer de programmeur cible et de programmer directement la puce.

Il me restait beaucoup de ces planches d'autres projets de lampes. N'hésitez pas à utiliser un contrôleur préprogrammé en ligne bon marché comme je l'ai fait sur mon parapluie à la place.

J'ai fini par utiliser une démo de fondu enchaîné comme base pour l'arbre.

/** Code pour le cross-fading 3 LEDs, rouge, vert et bleu (RVB) * Pour créer des fondus, vous devez faire deux choses: * 1. Décrire les couleurs que vous souhaitez afficher * 2. Lister l'ordre que vous souhaitez s'estomper * * DÉCRIRE UNE COULEUR: * Une couleur n'est qu'un tableau de trois pourcentages, 0-100, * contrôler les LED rouges, vertes et bleues * * Le rouge est la LED rouge à plein, bleu et vert éteint * int rouge = { 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 DES ORDRE: * Dans la partie principale du programme, vous devez indiquer l'ordre * dans lequel vous souhaitez que les couleurs apparaissent, par exemple * fondu enchaîné (rouge); * fondu enchaîné (vert); * fondu enchaîné (bleu); * * Ces couleurs apparaîtront dans cet ordre, passant d'une * couleur à la suivante * * De plus, vous pouvez régler 5 paramètres facultatifs: * 1. La couleur initiale est définie sur le noir (la première couleur s'estompe donc in), mais * vous pouvez définir la couleur initiale sur n'importe quelle autre couleur * 2. La boucle interne s'exécute sur 1020 interations; 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 * jusqu'à ~ 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ée, * 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 pointilleux -- le fonctionnement interne est expliqué * sous la boucle principale. * * Avril 2007, Clay Shirky *

/ Sortir

int grnPin = 9; // LED verte, connectée à la broche numérique 10 int redPin = 10; // LED rouge, connectée à la broche numérique 9 int bluPin = 11; // LED bleue, connectée à la broche numérique 11

// Tableaux de couleurs

int noir[3] = { 0, 0, 0 }; int blanc[3] = { 100, 100, 100 }; int rouge[3] = { 100, 0, 0 }; int vert[3] = { 0, 100, 0 }; int bleu[3] = { 0, 0, 100 }; int jaune[3] = { 40, 95, 0 }; int dimBlanc[3] = { 30, 30, 30 }; // etc.

// Définir la couleur initiale

int redVal = noir[0]; int grnVal = noir[1]; int bluVal = noir[2];

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

maintien int = 0; // Maintien facultatif lorsqu'une couleur est terminée, avant le prochain crossFade int DEBUG = 0; // 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;

// Configurer les sorties LED

void setup() { pinMode(redPin, OUTPUT); // définit les broches comme sortie pinMode(grnPin, OUTPUT); pinMode(bluPin, SORTIE);

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);

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 réguliers. * 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 + + + + + + + + + + + * G + + + + + * 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 * valeurs 0-255, et il y a 1020 étapes (255*4). * * Pour déterminer la taille d'un pas qu'il devrait y avoir entre une graduation ascendante ou * descendante 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 du pas * 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

* Plage de 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[3]) {

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

int stepR = calculateStep(prevR, R);

int stepG = calculateStep(prevG, G); int stepB = calculateStep(prevB, B);

for (int i = 0; i <= 1020; i++) { redVal = calculateVal(stepR, redVal, i); grnVal = calculateVal(stepG, grnVal, i); bluVal = calculateVal (étape B, bluVal, i);

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

analogWrite(grnPin, grnVal); analogWrite(bluPin, bluVal);

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/RGB: #"); Serial.print(i); Serial.print(" | "); Serial.print(redVal); Serial.print(" / "); Serial.print(grnVal); Serial.print(" / "); Serial.println(bluVal); } DÉBOGAGE += 1; } } // Mettre à jour les valeurs actuelles pour la prochaine boucle prevR = redVal; prevG = grnVal; prevB = bluVal; retarder (tenir); // Pause pour 'attendre' quelques millisecondes avant de reprendre la boucle }

Étape 2: Envelopper l'arbre

J'ai utilisé des bandes imperméables car elles seront à l'extérieur. Ils sont restés tout seuls, mais j'ai rapidement suivi avec des attaches métalliques pour m'assurer qu'ils restent en place. Hack simple et facile. La capacité de puissance de traversée de la bande a facilité l'alimentation de l'alimentation par le bas et la sortie de l'alimentation du haut vers l'étoile.

Étape 3: N'oubliez pas l'étoile en haut

Pour la star, j'ai utilisé une paire de puces de 10W pour attirer l'attention. Je les ai soudés à une feuille de cuivre comme dissipateur thermique. J'aurais pu utiliser plus de bande car il en restait un peu.

Étape 4: l'essayer

Le premier essai avait la vitesse beaucoup trop rapide….

Une fois que je me suis calmé, ça avait l'air plutôt bien.