Gravata LED Starry Sky: 9 etapas (com fotos)

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

Há algum tempo, encontrei um brinquedo de criança com fibra ótica em uma loja do dólar e comecei a pensar no que poderia fazer com ele.

Uma das ideias malucas que tive foi fazer uma gravata com o efeito de um céu estrelado.

Eu ainda tinha alguns arduino pro mini's, placas de adafruit e baterias que provavelmente se encaixariam neste projeto.

Assim que encontrei uma bela gravata larga em uma loja de penhores na minha cidade e encontrei uma caixa que pudesse caber no hardware, decidi ir em frente e tentar construí-la.

Este instrutível mostra como eu fiz isso.

Ele roda em um arduino pro mini, carregador adafruit powerboost 500, emmerich icr 18650nh-sp e 5 LEDs brancos. O código torna a mudança de brilho do LED aleatória. (Os primeiros 40 segundos do vídeo têm velocidade 3x)

Etapa 1: esquemas e hardware

Estou usando o seguinte hardware:

- PCB com LEDs brancos de gelo e resistores de 220 Ohm.

- Arduino pro mini (usei uma cópia)

- Carregador Adafruit Powerboost 500

- Emmerich Li-ion accu ICR-18650NH-SP

- Fibras ópticas (em tamanhos diferentes)

Etapa 2: Fazendo a PCB que hospeda os LEDs

Cortei uma tira de um PCB para segurar os LEDs e usei os pinos de LED para soldá-lo ao PCB principal.

Conectou todos os cátodos (-) ao GND e usou metade dos pinos para soldá-lo preso ao PCB principal.

Conectado todos os ânodos (+) aos resistores, e com cabos ao arduino.

Cada LED deve ser conectado a uma das seguintes portas PWM: 3, 5, 6, 9, 10, 11

Tolo eu cometi muitos erros com este projeto e esqueci de verificar as portas PWM corretas, então tive que revender alguns depois. Testado com alto / baixo, então só percebi isso mais tarde.

Comecei com 7 LEDs, mas havia apenas 6 portas PWM e um dos LEDs que resoldei morreu. Acabei de manter os 5 LEDs funcionando e não estou usando o 6º.

Etapa 3: fazendo a caixa

Usei um Bosch GRO (como uma Dremel) e uma furadeira para cortar o formato da bateria, o botão, a porta micro-usb, os cabeçalhos do Arduino e as fibras ópticas. (use uma máscara contra poeira!)

Cole a bateria na caixa com 2 bandas.

Parafusos usados para montar a placa Adafruit e o PCB.

A fricção de abrir e fechar danificou alguns fios. Tive que revendê-los e usar cola para evitar que acontecesse novamente.

Etapa 4: Preparando o Empate

Removida a costura da parte inferior da gravata para caber na folha de borracha.

Para esconder o hardware e ainda poder acessá-lo se necessário, decidi usar um zíper.

Não sou boa com máquina de costura, então minha doce mãe colocou um zíper na parte de trás da gravata.

Feito isso, colei a folha de borracha na gravata. Fiquei com medo de usar muita cola que saturasse o tecido e ficasse visível de frente, então tentei uniformizar e não usar muito. No geral ficou bom, mas em alguns lugares notei muita ou pouca cola, porque ela saiu pelo tecido ou não grudou muito bem no tecido. Felizmente, isso é quase invisível de curta distância com luz forte.

A caixa e a gravata estão feitas. É hora de colar as fibras ópticas!

Etapa 5: colagem da fibra óptica

O brinquedo tinha um grande feixe de fios de fibra ótica que se separava facilmente. Tentei colar um por um no início, mas logo percebi que seria melhor fazer pequenos feixes e colá-los no LED de uma vez. Isso tornaria mais fácil mantê-lo estável até que a cola secasse. Confundiu o primeiro LED ao descobrir isso.

Certifique-se de usar uma cola transparente! O que usei secou bem devagar e a cola de secagem rápida que experimentei no primeiro LED ficou branca, deixando algumas fibras do primeiro LED menos brilhantes.

Colei pequenas folhas de borracha preta para evitar vazamento de luz na parte superior e para separar os LEDs.

Uma das folhas impediu que a caixa fechasse, então adicionei um elástico para manter a tampa fechada.

Etapa 6: Colocando a fibra óptica na gravata

Começando na parte inferior, eu apertei os orifícios com uma agulha e passei as fibras uma por uma. As fibras de cada LED se espalham aleatoriamente pela gravata.

Colei uma tira preta nas costas que deveria ir até a parte menor da gravata para manter o peso da caixa, mas depois de passar todos os fios e sentir a tensão deles decidi colar tudo para a gravata foi uma ideia melhor e corte a tira.

Como os fios de fibra ótica do brinquedo eram muito curtos, foi difícil encaixá-los na gravata. Eu estava limitado ao posicionar a caixa e tive dificuldade em deixar tudo tão plano quanto eu queria.

Etapa 7: colagem de fibras ópticas na amarração

Colei todos os fios de fibra ótica na folha de borracha para evitar que os fios fossem puxados para fora da folha de borracha e para tornar a amarração plana.

Para ter certeza de que não colei a braçadeira na gravata ao pressioná-la, coloquei um pouco de papel entre elas. Não parece muito bom, mas funciona bem. E você não o vê quando está fechado.

Depois que a cola secou, cortei os fios da frente e cortei um pouco a folha de borracha logo acima do fio mais alto, porque a amarração estava um pouco longa.

As fotos com a camisa branca são feitas antes de eu cortar o último pedaço de borracha.

Etapa 8: O Código

Abaixo o código que escrevi para a gravata.

Todos os LEDs têm um ajuste "médio" (não realmente uma média, mas um brilho intermediário).

Assim que atingir essa média, ele decidirá com 3/4 de chance de ir para um brilho menor. Ele também define aleatoriamente um novo brilho mínimo, brilho máximo, tempo de espera para brilho mínimo e máximo e a velocidade que aumenta ou diminui a cada rodada (1-255) de 5 valores predefinidos. Em seguida, ele fará um ciclo até atingir a média novamente. Apenas 2 LEDs podem estar em um ciclo alto ao mesmo tempo.

Cada estado é representado por um valor inteiro (1-7) determinando se está indo médio-baixo, baixo-médio, esperando baixo, atualizando, etc.

Para obter informações sobre como enviar o código para o arduino, dê uma olhada em www.arduino.cc

/ * Starry Sky Tie * * Este é um script para desvanecer aleatoriamente 5 LEDs de uma média para um brilho mais baixo * ou mais alto com configurações aleatórias de menor, maior e tempo * para parecer um céu estrelado quando usado com fibra óptica. * Neste caso, serão implementados em empate. * * Chance de subir / descer = 1/4 para cima, 3/4 para baixo, com um máximo de 2 * subindo até o máximo ao mesmo tempo. * * A média permanece a mesma. * As opções de mínimo, máximo e tempo mudam aleatoriamente * de 5 opções toda vez que um LED atinge a média novamente. * * Escrito por Billy Jaspers em maio de 2019. *

/ Declarar pinos

int LED01 = 3; int LED02 = 5; int LED03 = 6; int LED04 = 9; int LED05 = 11;

// Variáveis de tempo

unsigned long currentTime; tempo de espera longo sem sinal [5]; unsigned long lastRound;

// LED Variables

int brightMin [5] = {10, 10, 10, 10, 10}; // Brilho mínimo int brightAvg [5] = {200, 200, 200, 200, 200}; // Brilho médio int brightMax [5] = {240, 240, 240, 240, 240}; // Brilho máximo int timeWaitLow [5] = {1000, 1000, 1000, 1000, 1000}; // Tempo de espera int timeWaitAvg [5] = {5000, 5000, 5000, 5000, 5000}; // Tempo de espera int timeWaitMax [5] = {4000, 3000, 3000, 3000, 3000}; // Tempo de espera int incremento [5] = {2, 5, 4, 5, 2}; // Incremento no brilho int currentBright [5] = {200, 230, 210, 210, 235}; // Brilho atual

// Possibilidades de variáveis LED

int brightMinPos [5] = {5, 20, 40, 5, 20}; // Possibilidades de brilho mínimo int brightMaxPos [5] = {240, 245, 230, 225, 245}; // Possibilidades de brilho máximo int timeLowPos [5] = {3000, 5000, 4000, 2000, 1000}; // Tempo de espera em possibilidades de baixo brilho int timeHighPos [5] = {3000, 1000, 500, 2000, 4000}; // Tempo de espera em possibilidades de alto brilho int timeAvgPos [5] = {3000, 5000, 4000, 7000, 8000}; // Tempo de espera nas possibilidades de brilho médio int incrementPos [5] = {2, 4, 5, 3, 1}; // incremento nas possibilidades de brilho

// Variables

inicialização bool = verdadeiro; // As configurações de inicialização precisam ser iniciadas?

// Variáveis direcionais

/ * 0 = Esperando na média 1 = indo da média para o mínimo 2 = esperando no mínimo 3 = indo da baixa para a média 4 = indo da média para o máximo 5 = esperando no máximo 6 = indo da alta para a média 7 = atualizando variáveis * / int statusLED [5] = {0, 0, 0, 0, 0}; Int quantidadeAltoLED = 0; int refreshRate = 50; bool statusWaiting [5] = {falso, falso, falso, falso, falso}; // O Led está esperando?

// Variáveis aleatórias

long randomNumber; // Long para armazenar o número aleatório long randomNumberTwo; // Desejo armazenar o segundo número aleatório

// contadores

int i = 0; // Contador para o loop principal

void setup () {

Serial.begin (115200); // Iniciar serial randomSeed (analogRead (A0)); // Set randomseed

// Declare saídas

pinMode (LED01, SAÍDA); pinMode (LED02, SAÍDA); pinMode (LED03, SAÍDA); pinMode (LED04, SAÍDA); pinMode (LED05, SAÍDA); }

// Grava dados para LEDs

void writeToLED () {analogWrite (LED01, currentBright [0]); analogWrite (LED02, currentBright [1]); analogWrite (LED03, currentBright [2]); analogWrite (LED04, currentBright [3]); analogWrite (LED05, currentBright [4]); }

// Loop principal

void loop () {if (startup) {// Configurações de inicialização lastRound = millis (); // Define lastRound para inicialização writeToLED (); // Grava os dados de início no LED startup = false; // Desativa a inicialização} currentTime = millis (); // Definir a hora atual

if (currentTime - lastRound> = refreshRate) {

para (i = 0; i <5; i ++) {if (statusLED == 7) {// -7- Atualizando Led randomNumber = random (5); brightMin = brightMinPos [randomNumber]; // Definir valor aleatório para brilho mínimo randomNumber = random (5); brightMax = brightMaxPos [randomNumber]; // Definir valor aleatório para brilho máximo randomNumber = random (5); timeWaitLow = timeLowPos [randomNumber]; // Definir valor aleatório para baixo tempo de espera randomNumber = random (5); timeWaitMax = timeHighPos [randomNumber]; // Definir valor aleatório para alto tempo de espera randomNumber = random (5); timeWaitAvg = timeAvgPos [randomNumber]; // Define um valor aleatório para o tempo médio de espera randomNumber = random (5); incremento = incrementPos [randomNumber]; // Definir valor aleatório para valor de incremento randomNumber = random (2); // Defina o valor aleatório para a direção randomNumberTwo = random (2); // Definir valor aleatório para direção if (randomNumber == 1 && randomNumberTwo == 0 && amountHighLED = brightAvg ) {statusLED = 0; // Se estiver no ponto mais baixo: Vá para Média de espera} else {currentBright = currentBright + incremento ; // Else: Maior brilho}} else if (statusLED == 2) {// -2- Waiting Low if (! StatusWaiting ) {// Se não estiver esperando: waitingTime = millis (); // Definir o tempo de espera statusWaiting = true; // Comece a esperar} else if (statusWaiting && currentTime-waitingTime > = timeWaitLow ) {// Se a espera AND timeWaitAvg passou: statusWaiting = false; // Parar de esperar statusLED = 3; // Defina statusLed como Aguardando atualização}} else if (statusLED == 1) {// -1- Indo médio para baixo if (currentBright <= brightMin ) {statusLED = 2; // Se estiver no ponto mais baixo: Vá para Espera Baixa} else {currentBright = currentBright -increment ; // Else: Lower Brightness}} else if (statusLED == 6) {// -6- Indo de Max para Avg if (currentBright = timeWaitMax ) {// Se a espera AND timeWaitAvg passou: statusWaiting = falso; // Parar de esperar statusLED = 6; // Defina statusLed como Aguardando atualização}} else if (statusLED == 4) {// -4- Indo de média a máxima if (currentBright > = brightMax ) {statusLED = 5; // Se estiver no ponto mais baixo: Vá para Aguardando Alto} else {currentBright = currentBright + incremento ; // Else: Maior brilho}} else if (statusLED == 0) {// -0- Esperando na média if (! StatusWaiting ) {// Se não estiver esperando: waitingTime = millis (); // Define o tempo de espera statusWaiting = true; // Comece a esperar} else if (statusWaiting && currentTime-waitingTime > = timeWaitAvg ) {// Se a espera AND timeWaitAvg passou: statusWaiting = false; // Parar de esperar statusLED = 7; // Defina statusLed para Aguardando atualização}}} i = 0; lastRound = milis (); // Definido quando a última rodada terminar. writeToLED (); // Grave todos os dados nos LEDs}}

Etapa 9: Produto Final

Acho que funcionou bem. A gravata não é muito grossa, rígida, longa ou pesada e o efeito estrela fica incrível.