Árvore espiral de LED: 4 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Eu adoro todos os tipos de fitas de LED. Fiz uma bela luz de arco-íris com eles. Mesmo os não endereçáveis são úteis. Eu fiz uma luz de guarda-chuva de mercado brilhante ao ar livre, prendendo-os às costelas do guarda-chuva, então quando minha árvore espiral explodiu, decidi enrolá-la em um pedaço de tira de led.

Etapa 1: Controlador

Decidi usar leds RGB não endereçáveis. Isso significa que posso ter um efeito programado, mas todos os leds mudam de cor simultaneamente. Isso também significa que será necessário um controlador. Eu poderia ter usado um arduino uno e feito os testes iniciais usando um escudo RGB, mas acabei usando uma placa única personalizada com um chip Atmega328 vazio. Só precisava trocar o programador de destino e programar o chip diretamente.

Eu tinha muitas dessas placas que sobraram de outros projetos de lâmpadas. Sinta-se à vontade para usar um controlador pré-programado em linha barato como fiz no meu guarda-chuva.

Acabei usando uma demonstração lenta de crossfade como base para a árvore.

/ ** Código para cross-fading 3 LEDs, vermelho, verde e azul (RGB) * Para criar fades, você precisa fazer duas coisas: * 1. Descrever as cores que deseja exibir * 2. Liste a ordem que deseja para que desapareçam * * DESCRIÇÃO DE UMA COR: * Uma cor é apenas uma matriz de três porcentagens, 0-100, * controlando os LEDs vermelho, verde e azul * * Vermelho é o LED totalmente vermelho, azul e verde apagados * int vermelho = {100, 0, 0} * Branco esmaecido são todos os três LEDs a 30% * int dimWhite = {30, 30, 30} * etc. * * Algumas cores comuns são fornecidas abaixo ou faça suas próprias * * LISTAGEM DE ORDEM: * Na parte principal do programa, você precisa listar a ordem * em que deseja que as cores apareçam, por exemplo * crossFade (vermelho); * crossFade (verde); * crossFade (azul); * * Essas cores aparecerão nessa ordem, desaparecendo de * uma cor e passando para a próxima * * Além disso, existem 5 configurações opcionais que você pode ajustar: * 1. A cor inicial é definida como preto (então a primeira cor desaparece em), mas * você pode definir a cor inicial para ser qualquer outra cor * 2. O loop interno é executado por 1020 interações; a variável 'wait' * define a duração aproximada de um único crossfade. Em teoria, * uma 'espera' de 10 ms deve fazer um crossFade de aproximadamente 10 segundos. Na * prática, as outras funções que o código está executando diminuem a velocidade * para cerca de 11 segundos na minha placa. YMMV. * 3. Se 'repeat' estiver definido como 0, o programa será executado em loop indefinidamente. * se for definido como um número, ele repetirá esse número de vezes * e parará na última cor da sequência. (Defina 'return' como 1, * e faça a última cor preta se você quiser que desapareça no final.) * 4. Há uma variável 'hold' opcional, que passa o programa * para 'hold' milissegundos quando uma cor está completa, * mas antes que a próxima cor comece. * 5. Defina o sinalizador DEBUG como 1 se quiser que a saída de depuração seja * enviada para o monitor serial. * * O funcionamento interno do programa não é complicado, mas * é um pouco complicado - o funcionamento interno é explicado * abaixo do loop principal. * * Abril de 2007, Clay Shirky *

/ Saída

int grnPin = 9; // LED verde, conectado ao pino digital 10 int redPin = 10; // LED vermelho, conectado ao pino digital 9 int bluPin = 11; // LED azul, conectado ao pino digital 11

// Matrizes de cores

preto int [3] = {0, 0, 0}; branco int [3] = {100, 100, 100}; vermelho int [3] = {100, 0, 0}; verde int [3] = {0, 100, 0}; int azul [3] = {0, 0, 100}; amarelo int [3] = {40, 95, 0}; int dimWhite [3] = {30, 30, 30}; // etc.

// Definir cor inicial

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

espera interna = 3; // retardo crossFade interno de 10 ms; aumentar para fades mais lentos

int manter = 0; // Retenção opcional quando uma cor estiver completa, antes do próximo crossFade int DEBUG = 0; // contador DEBUG; se definido como 1, gravará os valores de volta via serial int loopCount = 60; // Com que frequência o DEBUG deve relatar? repetição int = 0; // Quantas vezes devemos fazer um loop antes de parar? (0 para nenhuma parada) int j = 0; // Contador de loop para repetição

// Inicializar variáveis de cor

int prevR = redVal; int prevG = grnVal; int prevB = bluVal;

// Configure as saídas de LED

void setup () {pinMode (redPin, OUTPUT); // define os pinos como saída pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT);

if (DEBUG) {// Se quisermos ver os valores para depuração…

Serial.begin (9600); //… configurar a saída serial}}

// Programa principal: lista a ordem dos crossfades

loop vazio () {crossFade (vermelho); crossFade (verde); crossFade (azul); crossFade (amarelo);

if (repeat) {// Fazemos loop um número finito de vezes?

j + = 1; if (j> = repeat) {// Já chegamos? saída (j); // Se sim, pare. }}}

/ * ABAIXO DESTA LINHA ESTÁ A MATEMÁTICA - VOCÊ NÃO DEVE PRECISAR ALTERAR ISTO PARA OS BÁSICOS

* * O programa funciona assim: * Imagine um crossfade que move o LED vermelho de 0-10, * o verde de 0-5 e o azul de 10 para 7, em * dez passos. * Gostaríamos de contar os 10 passos e aumentar ou * diminuir os valores das cores em incrementos de passos uniformes. * Imagine que um + indica aumentar um valor em 1 e um - * é igual a diminuí-lo. Nosso desvanecimento de 10 etapas ficaria assim: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + + * G + + + + + * B - - - * * O vermelho aumenta de 0 a 10 em dez etapas, o verde de * 0-5 em 5 etapas e o azul cai de 10 a 7 em três etapas. * * No programa real, as porcentagens de cor são convertidas para valores * 0-255 e há 1020 etapas (255 * 4). * * Para descobrir o quão grande deve haver um passo entre uma marca para cima ou * para baixo de um dos valores do LED, chamamos calculStep (), * que calcula a lacuna absoluta entre os valores inicial e final, * e então divide essa lacuna por 1020 para determinar o tamanho da etapa * entre os ajustes no valor. * /

int calculStep (int prevValue, int endValue) {

etapa int = valor final - valor anterior; // Qual é a lacuna geral? if (step) {// Se for diferente de zero, step = 1020 / step; // dividir por 1020} etapa de retorno; }

/ * A próxima função é calcularVal. Quando o valor do loop, i, * atinge o tamanho do passo apropriado para uma das * cores, aumenta ou diminui o valor dessa cor em 1. * (R, G e B são calculados separadamente.) * /

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

if ((step) && i% step == 0) {// Se a etapa for diferente de zero e for hora de alterar um valor, if (step> 0) {// incrementa o valor se step for positivo… val + = 1; } senão se (etapa 255) {val = 255; } senão se (val <0) {val = 0; } return val; }

/ * crossFade () converte as cores de porcentagem em um

* Intervalo de 0-255, depois faz um loop de 1020 vezes, verificando se * o valor precisa ser atualizado a cada vez e, em seguida, escrevendo * os valores de cor nos pinos corretos. * /

void crossFade (int color [3]) {

// Converter para 0-255 int R = (color [0] * 255) / 100; int G = (cor [1] * 255) / 100; int B = (cor [2] * 255) / 100;

int stepR = calculStep (prevR, R);

passo interno G = calcular Passo (prevG, G); etapa int B = calcular etapa (prevB, B);

para (int i = 0; i <= 1020; i ++) {redVal = calcularVal (stepR, redVal, i); grnVal = calcularVal (stepG, grnVal, i); bluVal = calcularVal (etapaB, bluVal, i);

analogWrite (redPin, redVal); // Grava os valores atuais nos pinos de LED

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

atrasar (esperar); // Pausa por 'esperar' milissegundos antes de retomar o loop

if (DEBUG) {// Se quisermos uma saída serial, imprima-a no

if (i == 0 ou i% loopCount == 0) {// começando, e cada loopCount vezes Serial.print ("Loop / RGB: #"); Serial.print (i); Serial.print ("|"); Serial.print (redVal); Serial.print ("/"); Serial.print (grnVal); Serial.print ("/"); Serial.println (bluVal); } DEBUG + = 1; }} // Atualiza os valores atuais para o próximo loop prevR = redVal; prevG = grnVal; prevB = bluVal; atrasar (manter); // Faça uma pausa para 'esperar' milissegundos opcionais antes de retomar o loop}

Etapa 2: embrulhando a árvore

Usei tiras à prova d'água, pois elas serão ao ar livre. Eles grudaram por conta própria, mas eu rapidamente segui com amarras de arame para ter certeza de que ficariam no lugar. Hack simples e fácil. A capacidade de alimentação direta da tira facilitou a alimentação da fonte de alimentação na parte inferior e obter energia da parte superior para a estrela.

Etapa 3: não se esqueça da estrela no topo

Para a estrela usei um par de chips de 10W para chamar a atenção. Soldei-os a uma folha de cobre como dissipador de calor. Eu poderia ter usado mais tira, já que sobrou um pouco.

Etapa 4: Experimentar

A primeira tentativa teve uma velocidade muito rápida….

Depois de me acalmar, parecia muito bom.