Ponte de velas tremeluzentes: 6 etapas (com fotos)

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

Este instrutível mostra como transformar uma ponte de vela simples com luz estática em uma bela luz de ambiente brilhante com infinitas variações de luzes piscando, cintilantes, padrões de ondas e outros enfeites. Comprei no After Christmas Sales uma ponte de velas por 8 €. Possui 7 luzes led e um adaptador de parede 33 V 3 W. Ela brilha com uma cor branca brilhante e quente e ficará perfeita para este projeto, onde vou colocar um Arduino para fazer as velas piscarem. O Arduino mais popular é o Arduino Uno. Neste projeto, usarei um Arduino Mega 2560.

Vou abandonar a fonte de alimentação de 30 V e usar um banco de energia simples de 5 V destinado a telefones celulares como fonte de alimentação.

Uma boa coisa a saber sobre os bancos de potência é que eles possuem um circuito interno, que transforma a bateria 3,7 V em 5 V. Como o processo consome um pouco de energia, o banco de potência desliga sozinho, se não for utilizado. Se o banco de energia for usado para gadgets DIY baseados em Arduino, o gadget não pode simplesmente entrar no modo de economia de energia e começar novamente após alguns minutos. Isso desligará o banco de energia. Esta ponte de velas tremeluzentes não tem modo de espera. Ele usa energia constantemente, mantendo o banco de energia ativo, até que o cabo de alimentação seja desconectado.

O vídeo mostra a ponte de velas em modo estático e piscando totalmente. A cintilação total é realmente irritante para os olhos, enquanto o vídeo suaviza um pouco. Depois que o hardware foi consertado, incluindo cabos de corte, soldagem de novas conexões e adição de alguns componentes, todos os padrões de luz desejados são criados escrevendo código para o Arduino. Os padrões que incluo neste instrutível são:

• 4 luzes piscando diferentes imitando velas reais
• 2 cintilações diferentes (intermitência aleatória de luzes estáticas)
• 2 padrões de onda diferentes
• luz estática simples

A troca de padrões ocorre por meio de um botão, o único elemento da interface do usuário. Quanto mais padrões se deseja e quanto mais ajustabilidade se deseja, mais botões e botões giratórios precisam ser adicionados. Mas a beleza está na simplicidade. Mantenha o número de padrões selecionáveis baixo. Escolha as melhores configurações durante a codificação e o teste, não adicionando muitos controles ao hardware.

Suprimentos

• Ponte de 1 vela LED com 7 lâmpadas. Certifique-se de que é um modelo DC de baixa tensão, com baterias ou com uma fonte de alimentação de parede, que transforma o mortal 110 - 240 V AC em cerca de 6 - 30 V DC. Portanto, é perfeitamente seguro hackear a ponte de velas.
• 1 Arduino Mega (qualquer outro microcontrolador serve, apenas certifique-se de programá-lo)
• 1 prototipagem breadboard
• fios de jumper e outros fios
• ferramenta de solda
• multímetro
• 7 resistores, 120 Ω
• 1 botão de ação (mostrarei como você pode usar o botão integrado em um Arduino)
• Um transistor darlington IC para 7 transistores, ULN2803AP vai servir (se você usar um Arduino Uno ou Meaga, você realmente não precisa disso)
• Um banco de energia de 5 V destinado a telefones celulares

Etapa 1: examine o que você tem

Descubra em que tensão cada LED opera e a quantidade de corrente que flui.

1. Abra a parte inferior da ponte de velas. Encontre os dois fios que vão até uma vela.
2. Retire um pouco do isolamento dos cabos, revelando os fios de cobre sem cortar os fios de cobre.
3. Acenda as luzes (relaxe, são apenas alguns volts) e meça a voltagem nos fios de cobre revelados.
4. Corte o cabo em um dos pontos de medição (neste ponto as luzes se apagam, é claro), retire um pouco do isolamento (3 - 4 mm) em ambas as extremidades. Meça a corrente passando. O que você faz é reconectar o cabo cortado ao multímetro, deixando toda a corrente fluir pelo multímetro, que agora informa a quantidade de corrente.

Minhas leituras

A tensão em uma vela (etapa 3): 3,1 V

Observe que a fonte de alimentação para a ponte de velas era de 33 V. Portanto, sete vezes 3,1 V é apenas 21,7 V. Em algumas das velas deve haver um resistor extra. Se eu tivesse medido a voltagem da vela, deve ter sido cerca de 11 V.

A corrente fluindo quando as velas acendem (etapa 4): 19 mA

Vou alimentar tudo com uma bateria de 5 V 2 A. Para as velas, preciso diminuir a tensão de 5 V para 3 V. Preciso de um resistor, que reduzirá a tensão de 2 V em uma corrente de 19 mA.

2 V / 0,019 A = 105 Ω

A dissipação de energia é:

2 V * 19 mA = 38 mW

Isso é insignificante. Muito mais poderia explodir o próprio resistor. Mesmo assim, sem um resistor de 105 Ω eu posso explodir o LED. Tenho resistores de 100 Ω e 120 Ω. Eu vou com 120 Ω. Dá mais proteção.

Testar todas as 7 velas com 3 V deu uma luz brilhante, exceto para uma vela, que tinha uma luz muito fraca, com apenas 0,8 mA passando. Esta era minha vela com o resistor extra. Acontece que as outras velas não tinham resistências. As luzes LED usadas no lustre destinam-se simplesmente a 3 V! A vela com o resistor extra teve que ser aberta com violência moderada, mas nada quebrou. O resistor foi encontrado logo abaixo do minúsculo LED dentro da lâmpada de plástico da vela. Tive que dessoldar e voltar a soldar os fios. Ficou um pouco bagunçado, já que o ferro de solda aqueceu um pouco da cola quente, que havia sido usada na montagem.

Então agora eu sei que qualquer fonte de energia que eu usar, qualquer que seja a voltagem, eu tenho que diminuir a voltagem para 3 V, permitindo a passagem de 19 mA.

Se eu estivesse mais familiarizado com a tecnologia LED, teria reconhecido o tipo de LED usado e saberia que precisava de 3 V.

Etapa 2: um pouco de solda

Nesta etapa, eu conecto todos os fios positivos (+) das 5 velas a um fio. Em seguida, adiciono um fio negativo (-) separado para cada vela. Uma luz LED só acende quando '+' e '-' vão para a direita. Uma vez que você tem apenas duas extremidades de cabo idênticas de cada vela, você deve testar qual é '+' e qual é '-'. Para isso, você precisa de uma fonte de alimentação de 3 V. Eu tinha um pequeno pacote de bateria incluindo duas baterias AAA. Uma bateria tipo moeda de 3 V também funciona muito bem para testes.

A ponte de velas precisa de 8 cabos para passar entre o Arduino e a ponte. Se você encontrar um cabo com 8 fios isolados, isso seria ótimo. Um fio deve conter 120 mA, o restante deles carrega apenas 20 mA no máximo. Eu escolhi usar 4 cabos de fio duplo, que por acaso eu tinha.

A primeira imagem mostra como preparei um fio comum para conectar todos os fios '+' das velas. Retire um pouco do isolamento do fio comum para cada vela. Adicione um pedaço de tubo de isolamento retrátil (a faixa amarela na imagem) para cada junta e coloque-o no local certo do cabo comum. Solde o fio '+' de cada vela até sua junta, cubra a junta com o tubo retrátil e encolha-o. Claro, fita adesiva simples também serve, tudo ficará coberto no final.

A segunda imagem mostra os fios '-' de que cada vela precisa. O fio comum '+' vai diretamente para o pino de 5 V do Arduino (ou talvez através da placa de ensaio). Cada fio '-' vai para seu próprio pino do transistor IC (novamente, provavelmente através da placa de ensaio).

Um Arduino costuma ser chamado de placa de prototipagem. Uma placa de ensaio também é algo que você usa em protótipos. O que descrevo neste instrutível é um protótipo. Não vou desenvolvê-lo em um produto brilhante e chique com tudo escondido em belas caixas de plástico. Levá-lo do protótipo para o próximo nível significaria substituir a placa de ensaio por uma placa de circuito impresso e componentes soldados e até mesmo substituir o Arduino por um simples chip microcontrolador (na verdade, esse chip é o cérebro do Arduino). E ter tudo cabido em uma caixa de plástico ou dentro da ponte de velas cortada.

Etapa 3: as conexões

Sobre Arduinos, retirado desta página:

• Corrente máxima total por pino de entrada / saída: 40mA
• Soma das correntes de todos os pinos de entrada / saída combinados: 200mA

Minhas velas consomem 19 mA cada, quando alimentadas por 3 V. Existem sete delas, o que perfaz 133 mA. Assim, eu poderia alimentá-los diretamente dos pinos de saída. No entanto, tenho alguns CIs de transistor Darlington sobressalentes. Então pensei, por que não. Meu circuito faz as coisas da maneira correta: os pinos de dados são apenas para sinais, não para energia. Em vez disso, uso o pino de 5 V no Arduino para alimentar as luzes LED. Durante a execução do teste, tenho meu laptop conectado ao Arduino. Tudo é alimentado pelo USB do laptop, que dá 5 V. O Arduino Mega tem um fusível próprio, que sopra a 500 mA para proteger o computador. Minhas velas consomem 133 mA no máximo. O Arduino provavelmente muito menos. Tudo funciona bem, quando alimentado pelo laptop, então usar uma bateria de 5 V conectada à porta USB do Arduino é ótimo.

Os pinos de dados D3 - D9 vão para o IC ULN2803APGCN. Os LEDs operam em 3 V. Cada lâmpada é conectada à fonte de 5 V e posteriormente a um resistor de 120 Ω. Além de um canal do IC, que finalmente conecta o circuito ao solo por meio de um transistor darlington no IC.

Um botão é adicionado ao circuito para permitir alguma ação do usuário. A ponte de velas poderia, portanto, ter alguns programas selecionáveis pelo usuário.

O botão no circuito é conectado a RESET e GND. Isso é exatamente o que o botão de reinicialização integrado faz. Como não encapsulo tudo em uma caixa de plástico, estou usando o botão de reset no Arduino para controlar o programa. Adicionar um botão de acordo com a imagem funcionará exatamente como o botão de reset da placa. O programa funciona lembrando-se de qual programa leve foi usado na última vez em que o programa foi executado. Assim, cada reinicialização avançará para o próximo programa de luz.

As fotos mostram como os novos cabos saem da ponte, como coloquei o IC do transistor e os resistores na placa de ensaio e como os fios do jumper se conectam ao Arduino Mega. Cortei 4 fios de jumper macho-macho em 8 meios fios, que soldou aos 8 cabos que saíam da ponte de velas. Dessa forma, posso simplesmente inserir os cabos na placa de ensaio.

Alternativa sem transistores

Na etapa anterior, preparei um fio '+' comum para as velas e fios '-' separados, que vão do IC do transistor para o solo. Quando um pino de dados fica alto, o fio '-' correspondente é aterrado através de seu transistor e o LED acende.

Conectar os fios '-' diretamente aos pinos de dados do Arduino também funcionaria, mas lembre-se de quanta corrente os pinos de dados podem suportar! Essa abordagem precisaria de uma mudança em meu programa. Seria necessário que os pinos de dados baixassem para ligar as velas. Para usar meu programa como ele está, você precisa trocar '+' e '-' nas velas. Tenha um fio comum '-' para as velas, que vai para GND no Arduino. E os fios separados passam entre o fio '+' da vela e um pino de dados do Arduino.

Etapa 4: Os programas leves

Meu programa, que apresento na próxima etapa, passa por 9 programas leves. Pressionar o botão apagará as luzes por um segundo e, em seguida, o seguinte programa de luzes será iniciado. Os programas são os seguintes:

1. Cintilação forte. As velas tremeluzem aleatoriamente. Isso parece muito irritante quando você olha para eles de perto, mas pode parecer bom à distância e talvez atrás de uma janela gelada do sótão. Porém, seu vizinho pode chamar o corpo de bombeiros.
2. Cintilação suave. Parece muito bom. Como velas de verdade em uma sala sem corrente de ar.
3. Cintilação variável. As velas alternam suavemente entre oscilações fortes e suaves em intervalos de 30 segundos.
4. Cintilação variável. Como a # 3, mas cada vela varia em seu próprio ritmo entre 30 se 60 s.
5. Cintilação rápida. As velas brilham em um nível esmaecido estático e cintilam aleatoriamente. Em média, há um brilho a cada segundo.
6. Cintilação lenta. Como no 5, mas em um ritmo muito mais lento.
7. Onda rápida da vela superior do meio para as inferiores.
8. Onda lenta da vela superior do meio para as inferiores.
9. Luz brilhante estática. Tive que incluir isso, não queria me livrar da função original.

Etapa 5: O Código

/*

FLICKERING CANDLE BRIDGE * / // Declara a variável de modo para manter o estado // por meio de uma operação de redefinição _attribute _ ((section (". Noinit"))) modo int sem sinal; // Quando o programa é iniciado após um reset, esta parte // da memória não é inicializada, mas mantém o valor // que tinha antes do reset. Na primeira vez que o // programa é executado, ele mantém um valor aleatório. / * * A classe candle contém tudo o que é necessário * para calcular o nível de luz para * uma vela tremeluzente. * / class candle {private: long maxtime; long mintime; maxlite longo; long minlite; long meanlite; longa origmaxtime; longo origmintime; origmaxlite longa; origminlita longa; long origmeanlite; long deltamaxtime; long deltamintime; deltamaxlite longo; deltaminlita longa; deltameanlite longo; lforate longo; long evenout; início longo; alvo longo; float phactor; longo tempo de destino; tempo de início longo; long deltatime; void newtarget (void); longo onetarget (vazio); público: vela (tapete longo, mit longo, mal longo, mil longo, mel longo, eo longo); longo nível agora (vazio); void initlfo (deltamat longo, deltamit longo, deltamal longo, deltamil longo, deltameano longo, taxa longa); void setlfo (void); }; vela:: vela (tapete longo, mit longo, mal longo, mil longo, mel longo, eo longo): maxtime (tapete), mintime (mit), maxlite (mal), minlite (mil), meanlite (mel), evenout (e o), origmaxtime (mat), origmintime (mit), origmaxlite (mal), origminlite (mil), origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () retorna o nível de luz que a vela deveria ter agora. * A função se encarrega de definir um novo nível de luz aleatório e * o tempo que deve levar para atingir esse nível. A mudança não é linear *, mas segue uma curva sigmóide. Quando não é hora de definir um novo * nível, a função simplesmente retorna o nível de luz. * / long candle:: levelnow (void) {long help, now; float t1, t2; agora = milis (); if (now> = targettime) {help = target; newtarget (); devolver ajuda; } else {// help = target * (millis () - starttime) / deltatime + start * (targettime - millis ()) / deltatime; t1 = float (targettime - now) / deltatime; t2 = 1. - t1; // Este é o cálculo sigmóide help = t1 * t1 * t1 * start + t1 * t1 * t2 * start * 3 + t1 * t2 * t2 * target * 3 + t2 * t2 * t2 * target; devolver ajuda; }} void candle:: newtarget (void) {long sum; soma = 0; para (longo i = 0; i <evenout; i ++) soma + = onetarget (); início = destino; alvo = soma / saída; hora de início = milis (); targettime = starttime + random (mintime, maxtime); deltatime = targettime - starttime; } long candle:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * O algoritmo para piscar "após a taxa em milissegundos": * Comece a verificar após a taxa / 2 milissegundos * Durante um período de taxa / 2 milissegundos, faça * a chance de uma centelha em 50%. * Se a taxa for 10.000 ms, durante 5.000 ms a moeda * é jogada 50 vezes. * 1/50 = 0,02 * If random (10000) starttime + rate / 2) {if (random (rate) targettime) return lowlite; return (start - lowlite) * (targettime - now) / (targettime - starttime) + lowlite; } void twinkler:: twink (void) {starttime = millis (); targettime = random (mintime, maxtime) + starttime; início = aleatório (minlite, maxlite); } void setup () {int led; // Leia a variável de modo mágico, que deve informar // qual programa de luz foi executado da última vez, incrementá-lo // e redefinir para zero em caso de estouro. modo ++; modo% = 9; // Isso cuida de qualquer que seja o valor // da primeira vez que o Arduino // executou este programa. / * * NOTA IMPORTANTE * ============== * * A coisa essencial que este programa faz é emitir sinais PWM * para luzes LED. Aqui eu defino os pinos 3 a 9 para * modo de saída. Em um Arduino Mega2560, esses pinos emitem * lindamente sinais PWM. Se você tiver outro Arduino, verifique * quais pinos (e quantos) você pode usar. Você sempre pode * reescrever o código para usar o software PWM, se o seu Arduino * não puder fornecer pinos de PWM de hardware suficientes. * * / pinMode (3, SAÍDA); pinMode (4, SAÍDA); pinMode (5, SAÍDA); pinMode (6, SAÍDA); pinMode (7, SAÍDA); pinMode (8, SAÍDA); pinMode (9, SAÍDA); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // Apenas desligue o irritante led vermelho na vela do Arduino * can [7]; // prepare-se para usar as velas tremeluzentes, quer você as use ou não twinkler * twink [7]; // prepare-se para usar as velas cintilantes… if (mode == 8) {for (int i = 3; i <10; i ++) analogWrite (i, 255); enquanto (verdadeiro); // Cada vez que este programa é executado, ele entra // neste tipo de loop infinito, até que o botão de reinicialização // seja pressionado. } if (modo <2) // piscando {long maxtime_; long mintime_; long maxlite_; long minlite_; long meanlite_; long even_; if (modo == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; par_ = 1; } se (modo == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; par_ = 1; } para (int i = 0; i <7; i ++) {can = nova vela (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // O loop infinito para velas piscando {for (int i = 0; i levelnow ()); }} if (mode <4) // lfo adicionado à oscilação {if (mode == 2) // mesmo lfo (30 s) para todas as velas {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // variando lfo: s para as velas {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); pode [1] -> initlfo (75, 50, 0, 50, 36, 25000); pode [2] -> initlfo (75, 50, 0, 50, 36, 30000); pode [3] -> initlfo (75, 50, 0, 50, 36, 35000); pode [4] -> initlfo (75, 40, 0, 50, 36, 40000); pode [5] -> initlfo (75, 30, 0, 50, 26, 45000); pode [6] -> initlfo (75, 20, 0, 50, 16, 50000); pode [7] -> initlfo (75, 10, 0, 50, 6, 55000);} enquanto (true) // O loop infinito para velas piscando com um lfo {long lastclock = 0; for (int i = 0; i levelnow ()); if (millis ()> lastclock + 4000) {lastclock = millis (); for (int i = 0; i setlfo ();}}} if (mode <6) // velas cintilantes {int speedo; if (mode == 4) speedo = 6000; senão speedo = 22000; for (int i = 0; i <7; i ++) twink = new twinkler (300, 295, 255, 250, speedo); while (true) {for (int i = 0; i levelnow ()); }} // Waves. // Esta seção começa com chaves apenas // para garantir que não haja nomes de variáveis conflitantes. // Nenhuma outra necessidade de colchetes, nenhuma necessidade de verificar // o valor do modo.{int lolite = 2; hilite int = 255; int mean; int ampl; float fasedelta = 2,5; fase de flutuação; int elong; float phactor; longo período; média = (lolite + hilite) / 2; ampl = hilite - média; se (modo == 6) período = 1500; senão período = 3500; factor = 6,28318530718 / período; enquanto (verdadeiro) {fase = fator * (milis ()% período); alongado = média + ampl * sen (fase); analogWrite (7, alongado); analogWrite (9, alongado); fase = fator * ((milis () + período / 4)% período); alongado = média + ampl * sen (fase); analogWrite (3, alongado); analogWrite (8, alongado); fase = fator * ((milis () + período / 2)% período); alongado = média + ampl * sen (fase); analogWrite (4, alongado); analogWrite (5, alongado); fase = fator * ((milis () + 3 * período / 4)% período); alongado = média + ampl * sen (fase); analogWrite (6, alongado); } // Ao conectar os fios das velas ao Arduino, // eu os misturei e nunca os coloquei em ordem. // A ordem é importante para a criação de padrões de onda, // então escrevi esta pequena tabela para mim: // // Vela # na ponte: 2 3 5 4 7 6 1 // Pino de dados no Arduino: 3 4 5 6 7 8 9}} void loop () {// Como cada programa light é seu próprio loop infinito, // escrevi todos os loops na seção begin () // e não deixei nada para esta seção loop (). }

Etapa 6: Sobre PWM

Os leds brilham muito quando alimentados com 3 V. Usando apenas 1,5 V eles não acendem de forma alguma. As luzes LED não desbotam bem com o desbotamento da voltagem, como acontece com as lâmpadas incandescentes. Em vez disso, eles devem ser ligados com tensão total e, em seguida, desligados. Quando isso acontece 50 vezes por segundo, eles brilham bem com 50% de brilho, mais ou menos. Se eles puderem estar ligados apenas 5 ms e desligados 15 ms, eles podem brilhar com um brilho de 25%. Essa técnica é o que torna a luz LED regulável. Essa técnica é chamada de modulação por largura de pulso ou PWM. Um microcontrolador como o Arduino geralmente tem pinos de dados, que podem enviar sinais liga / desliga. Alguns dos pinos de dados possuem recursos integrados para PWM. Mas se não houver pinos suficientes com PWM integrado, geralmente é possível usar bibliotecas de programação dedicadas para criar "pinos de PWM de software".

Em meu projeto, usei um Arduino Mega2560, que possui PWM de hardware nos pinos 3 - 9. Se você usar um Arduino UNO, terá apenas seis pinos PWM. Nesse caso, se você precisar de uma 7ª (ou até mais) vela, posso recomendar a biblioteca de software PWM de Brett Hagman, que você pode encontrar aqui.