Melhorando um cubo de ambiente de LED do Arduino (simples) (vídeo incluído): 4 etapas

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

Depois de ver um pequeno projeto de cubo de humor em LED criado por 'Earl, decidi fazer uma versão melhorada do cubo de humor em LED. Minha versão será mais complexa que a original, pois será um pouco maior que a original, terá mais duas cores em relação ao cubo original (adicionado amarelo e branco), terá uma quantidade infinita de rotação de cores, etc. Deve ser um bom projeto para praticar o uso futuro de luzes LED para quem entendeu o conceito de conectar luzes LED com fios.

Etapa 1: Materiais

Aqui estão alguns materiais de que você precisará para fazer este Mood Cube:

• Tábua de pão
• Arduino - (eu tenho Leonardo aqui)
• Fonte de alimentação Arduino / cabo USB
• Tábua de pão
• Jumper Wires (muitos deles, usei 29 fios)
• LED vermelho x 2
• LED azul x 2
• LED verde x 2
• LED amarelo x 2
• LED branco x 1
• 9 resistores
• Caixa grande o suficiente para caber na placa de ensaio (usei uma caixa de sapato)
• Canivete
• Papel

Etapa 2: Código

Algumas explicações para o código fornecido aqui:

O crédito dos códigos vai para a fonte original do meu projeto, pois o editor do projeto criou esses códigos. Eu simplesmente melhorei alguns deles tornando-os mais complexos. Em alguns códigos, você pode ver // 改 no final. Isso significa que este código foi editado por mim, por isso é diferente da minha fonte original.

Eu também tenho uma versão do código no Arduino Creator.

/ * Código para desvanecimento cruzado de 3 LEDs, vermelho, verde e azul (RGB) Para criar desvanecimentos, você precisa fazer duas coisas: 1. Descrever as cores que deseja exibir 2. Liste a ordem em que deseja que elas apareçam

DESCREVENDO UMA COR:

Uma cor é apenas uma matriz de três porcentagens, 0-100, controlando os LEDs vermelho, verde e azul

Vermelho é o LED vermelho totalmente, azul e verde apagados

int red = {100, 0, 0} Dim white 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 DA 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

uma cor e na 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), 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' for 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, em seguida, parará na última cor da sequência. (Defina 'return' para 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 é completo, mas antes que a próxima cor comece. 5. Defina o sinalizador DEBUG como 1 se desejar que a saída de depuração seja enviada ao monitor serial.

Os detalhes internos do programa não são complicados, mas eles

são um pouco exigentes - o funcionamento interno é explicado abaixo do loop principal.

Abril de 2007, Clay Shirky

*

/ Saída

int ylwPin = 5; // LED amarelo, conectado ao pino digital 5 // 改 int redPin = 6; // LED vermelho, conectado ao pino digital 6 // 改 int grnPin = 7; // LED verde, conectado ao pino digital 7 // 改 int bluPin = 8; // LED azul, conectado ao pino digital 8 // 改 int whiPin = 9; // LED branco, conectado ao pino digital 9 // 改 int ylwPin2 = 10; // LED amarelo, conectado ao pino digital 10 // 改 int redPin2 = 11; // LED vermelho, conectado ao pino digital 11 // 改 int grnPin2 = 12; // LED verde, conectado ao pino digital 12 // 改 int bluPin2 = 13; // LED azul, conectado ao pino digital 13 // 改

// Matrizes de cores

int preto [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int branco [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int vermelho [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int verde [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int azul [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int amarelo [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int roxo [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 laranja int [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 rosa intacto [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // etc.

// Definir cor inicial

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

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

int manter = 1; // Retenção opcional quando uma cor estiver completa, antes do próximo crossFade // 改 int DEBUG = 1; // 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; int prevY = ylwVal; int prevW = whiVal; // 改

// Configure as saídas de LED

void setup () {pinMode (redPin, OUTPUT); // define os pinos como saída pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, 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); crossFade (branco); crossFade (rosa); crossFade (roxo); crossFade (laranja);

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 a 10, o verde de 0 a 5 e o azul de 10 a 7, em dez etapas. 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 se pareceria com:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + + G + + + + + B - - -

O vermelho sobe de 0 para 10 em dez etapas, o verde de

0-5 em 5 etapas, e o azul cai de 10 para 7 em três etapas.

No programa real, as porcentagens de cores são convertidas para

0-255 valores e há 1020 etapas (255 * 4).

Para descobrir o quão grande deve haver um degrau entre um para cima ou

down-tick de um dos valores de LED, chamamos calculStep (), que calcula a lacuna absoluta entre os valores inicial e final e, em seguida, 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 de passo apropriado para uma das cores, aumenta ou diminui o valor daquela 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, em seguida, faz um loop de 1020 vezes, verificando se o valor precisa ser atualizado a cada vez e, em seguida, gravando os valores de cor nos pinos corretos. * /

void crossFade (int color ) {// 改

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

int stepR = calculStep (prevR, R);

passo interno G = calcular Passo (prevG, G); etapa int B = calcular etapa (prevB, B); int stepY = calculStep (prevY, Y); // 改 int stepW = calculStep (prevW, W); // 改

para (int i = 0; i <= 1020; i ++) {redVal = calcularVal (stepR, redVal, i); grnVal = calcularVal (stepG, grnVal, i); bluVal = calcularVal (etapaB, bluVal, i); ylwVal = calcularVal (etapa Y, ylwVal, i); // 改 whiVal = CalculeVal (stepW, whiVal, i); // 改

analogWrite (redPin, redVal); // Grava os valores atuais nos pinos de 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); // 改

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 / 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; }} // Atualiza os valores atuais para o próximo loop prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 delay (hold); // Faça uma pausa para 'esperar' milissegundos opcionais antes de retomar o loop}

Etapa 3: configuração

1. Obtenha a placa de ensaio.

2. Demonstração de conexão de fios para que uma luz LED possa brilhar:

   1. Coloque o LED na placa de ensaio. Coloque a extremidade mais longa à esquerda e a mais curta à direita.
   2. Coloque uma extremidade de um fio de jumper em um ponto que esteja na mesma linha com a extremidade mais longa do LED. Coloque a outra extremidade na seção Digital PWM. O código especificava os LEDs amarelos a serem conectados a 10 e 5, os vermelhos a 6 e 11, os azuis a 8 e 13, os verdes a 7 e 12 e, finalmente, os LED brancos a 9.
   3. Coloque uma extremidade de um resistor na mesma linha com a extremidade mais curta do LED. Coloque a outra extremidade em algum lugar próximo.
   4. Coloque uma extremidade de outro fio de ponte com a mesma linha com a extremidade do resistor que não está na mesma linha com a extremidade mais curta do LED. Coloque a outra extremidade do fio na fileira de carga negativa.
   5. Coloque uma extremidade de outro fio de ponte na fileira de carga negativa e coloque a outra extremidade no GND.
3. Repita a Etapa 2 por 8 vezes enquanto deseja que 9 LEDs brilhem

4. Coloque a placa de ensaio dentro da caixa. Alguns lembretes aqui:

   1. Usei uma fonte de alimentação. Crie um pequeno orifício para os fios usando uma faca para passar pela caixa e se conectar à placa de ensaio.
   2. Certifique-se de que a caixa tem um dos lados que está aberto. Uma caixa de sapatos já tem um lado aberto. Se a caixa estiver totalmente fechada, corte de um lado da caixa para fazer um espaço aberto.
   3. Não cubra o lado com papel. Isso é para luzes LED brilharem através do papel.