Puente de vela parpadeante: 6 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Este instructivo muestra cómo convertir un simple puente de velas con luz estática en una agradable luz ambiental brillante con infinitas variaciones de luces parpadeantes, parpadeos, patrones de ondas y todo eso. Compré en After Christmas Sales un puente de velas por 8 €. Tiene 7 luces led y algún adaptador de pared de 33 V 3 W. Brilla con un color blanco brillante y cálido y quedará perfecto para este proyecto, donde pondré un Arduino para hacer parpadear las velas. El Arduino más popular es el Arduino Uno. En este proyecto, usaré un Arduino Mega 2560.

Voy a deshacerme de la fuente de alimentación de 30 V y usaré un banco de energía simple de 5 V destinado a teléfonos móviles como fuente de alimentación.

Algo que hay que saber sobre los bancos de energía es que tienen un circuito interno, que transforma la batería de 3.7 V a 5 V. Debido a que el proceso consume algo de energía, el banco de energía se apaga solo, si no se usa. Si el banco de energía se usa para dispositivos de bricolaje basados en Arduino, el dispositivo no puede simplemente ponerse en modo de suspensión de ahorro de energía y comenzar de nuevo después de unos minutos. Eso apagará el banco de energía. Este puente de velas parpadeantes no tiene modo de suspensión. Utiliza energía constantemente, manteniendo el banco de energía activo, hasta que se desconecta el cable de alimentación.

El video muestra el puente de la vela en modo estático y en pleno parpadeo. El parpadeo completo es realmente bastante molesto para los ojos, mientras que el video lo suaviza un poco. Una vez que se ha reparado el hardware, incluido el corte de cables, la soldadura de nuevas conexiones y la adición de algunos componentes, todos los patrones de luz deseados se crean escribiendo código para Arduino. Los patrones que incluyo en este instructivo son:

• 4 luces parpadeantes diferentes que imitan velas reales
• 2 parpadeos diferentes (parpadeo aleatorio de luces estáticas)
• 2 patrones de ondas diferentes
• luz estática simple

El cambio de patrones ocurre a través de un botón, el elemento de interfaz de usuario único. Cuantos más patrones desee y mayor capacidad de ajuste desee, más botones y perillas tendrá que agregar. Pero la belleza radica en la sencillez. Mantenga bajo el número de patrones seleccionables. Elija la mejor configuración mientras codifica y prueba, no agregando muchos controles al hardware.

Suministros

• 1 puente vela LED con 7 bombillas. Asegúrese de que sea un modelo de CC de bajo voltaje, ya sea con baterías o con una fuente de alimentación de montaje en pared, que transforma los letales 110 - 240 V CA en unos 6 - 30 V CC. Así que es perfectamente seguro piratear el puente de las velas.
• 1 Arduino Mega (cualquier otro microcontrolador servirá, solo asegúrate de poder programarlo)
• 1 tablero de prototipos
• cables de puente y otros cables
• herramienta de soldadura
• multimetro
• 7 resistencias, 120 Ω
• 1 pulsador (te mostraré cómo puedes usar el botón integrado en un Arduino en su lugar)
• Un IC de transistor darlington para 7 transistores, ULN2803AP servirá (si usa un Arduino Uno o Meaga, realmente no lo necesita)
• Un banco de energía de 5 V destinado a teléfonos móviles

Paso 1: Examina lo que tienes

Averigüe con qué voltaje opera cada LED y cuánta corriente fluye.

1. Abra la parte inferior del puente de velas. Encuentra los dos cables que van a una vela.
2. Quite un poco de aislamiento de los cables dejando al descubierto los alambres de cobre sin cortar los alambres de cobre.
3. Encienda las luces (relájese, son solo unos pocos voltios) y mida el voltaje sobre los cables de cobre revelados.
4. Cortar el cable en uno de los puntos de medición (en este punto las luces se apagan, por supuesto), quitar un poco de aislamiento (3-4 mm) en ambos extremos. Mide la corriente que pasa. Lo que debe hacer es volver a conectar el cable cortado con su multímetro, dejando que toda la corriente fluya a través de su multímetro, que ahora le indica la cantidad de corriente.

Mis lecturas

El voltaje sobre una vela (paso 3): 3,1 V

Tenga en cuenta que la fuente de alimentación del puente de la vela era de 33 V. Por lo tanto, siete veces 3,1 V son solo 21,7 V. En algunas de las velas debe haber una resistencia adicional. Si hubiera medido el voltaje de la vela, debió haber tenido que ser de unos 11 V.

La corriente que fluye cuando se enciende la vela (paso 4): 19 mA

Voy a alimentar todo con una batería de 5 V 2 A. Para las velas, necesito bajar el voltaje de 5 V a 3 V. Necesito una resistencia, que bajará el voltaje 2 V a una corriente de 19 mA.

2 V / 0,019 A = 105 Ω

El poder que se disipa es:

2 V * 19 mA = 38 mW

Eso es insignificante. Mucho más podría hacer explotar la propia resistencia. Sin embargo, sin una resistencia de 105 Ω, podría apagar el LED. Tengo resistencias de 100 Ω y 120 Ω. Yo voy con 120 Ω. Da más protección.

Probar las 7 velas con 3 V dio una luz brillante, excepto una vela, que solo tenía una luz muy tenue, con solo unos 0,8 mA pasando. Esta era mi vela con la resistencia extra. Resultó que las otras velas no tenían resistencias en absoluto. ¡Las luces LED utilizadas en la lámpara de araña están diseñadas simplemente para 3 V! La vela con la resistencia adicional tuvo que abrirse con violencia leve, pero nada se rompió. La resistencia se encontró justo debajo del pequeño LED dentro de la bombilla de vela de plástico. Tuve que desoldarlo y volver a soldar los cables. Fue un poco desordenado, ya que el soldador calentó un poco de pegamento caliente, que se había utilizado para el montaje.

Así que ahora sé que sea cual sea la fuente de energía que use, sea cual sea el voltaje, tengo que bajar el voltaje a 3 V permitiendo que pasen 19 mA.

Si hubiera estado más familiarizado con la tecnología LED, habría reconocido el tipo de LED utilizado y habría sabido que necesitaba 3 V.

Paso 2: algo de soldadura

En este paso, conecto todos los cables positivos (+) de las 5 velas a un cable. Luego agrego un cable negativo (-) separado para cada vela. Una luz LED solo se enciende cuando el '+' y el '-' van a la derecha. Dado que solo tiene dos extremos de cable idénticos de cada vela, debe probar cuál es '+' y cuál es '-'. Para ello necesita una fuente de alimentación de 3 V. Tenía un paquete de pilas pequeño que incluía dos pilas AAA. Una batería de botón de 3 V también funciona muy bien para realizar pruebas.

El puente de vela necesita 8 cables para pasar entre el Arduino y el puente. Si encuentra un cable con 8 alambres aislados, sería genial. Un cable debe contener 120 mA, el resto solo transporta 20 mA como máximo. Elegí usar 4 cables de doble hilo, que tenía.

La primera imagen muestra cómo preparé un cable común para conectar todos los cables '+' de las velas. Quite un poco de aislamiento del cable común de cada vela. Agregue un trozo de tubo de aislamiento retráctil (la tira amarilla en la imagen) para cada unión y póngalo en el lugar correcto del cable común. Suelde el cable '+' de cada vela a su unión, cubra la unión con el tubo retráctil y encoja. Por supuesto, una simple cinta adhesiva también está bien, todo estará cubierto al final.

La segunda imagen muestra los cables '-' que necesita cada vela. El cable '+' común va directamente al pin de 5 V del Arduino (o quizás a través de la placa de pruebas). Cada cable '-' va a su propio pin del transistor IC (nuevamente, probablemente a través de la placa).

Un Arduino a menudo se denomina placa de creación de prototipos. Una placa de pruebas también es algo que se usa en los prototipos. Lo que describo en este instructivo es un prototipo. No lo convertiré en un producto elegante y brillante con todo escondido en bonitos estuches de plástico. Llevarlo del prototipo al siguiente nivel significaría reemplazar la placa con una placa de circuito impreso y componentes soldados e incluso reemplazar el Arduino con un simple chip microcontrolador (en realidad, ese chip es el cerebro del Arduino). Y tener todo encajado en una caja de plástico o dentro del puente de la vela pirateada.

Paso 3: las conexiones

Acerca de Arduinos, tomado de esta página:

• Corriente máxima total por pin de entrada / salida: 40 mA
• Suma de las corrientes de todos los pines de entrada / salida combinados: 200 mA

Mis velas consumen 19 mA cada una, cuando se alimentan con 3 V. Hay siete de ellas, lo que produce 133 mA. Entonces podría alimentarlos directamente desde los pines de salida. Sin embargo, tengo algunos circuitos integrados de transistores Darlington de repuesto. Entonces pensé, ¿por qué no? Mi circuito hace las cosas de la manera correcta: los pines de datos son solo para señales, no para energía. En su lugar, uso el pin de 5 V en el Arduino para encender las luces LED. Cuando se ejecuta la prueba, tengo mi computadora portátil conectada al Arduino. Todo se alimenta desde el USB de la computadora portátil, que da 5 V. El Arduino Mega tiene un fusible propio, que se quema a 500 mA para proteger la computadora. Mis velas dibujan 133 mA como máximo. El Arduino probablemente mucho menos. Todo funciona bien, cuando se alimenta con la computadora portátil, por lo que usar una batería de 5 V conectada al puerto USB del Arduino está bien.

Los pines de datos D3 - D9 van al IC ULN2803APGCN. Los LED funcionan con 3 V. Cada bombilla está conectada a la fuente de 5 V y, además, a una resistencia de 120 Ω. Además de un canal del IC, que finalmente conecta el circuito a tierra a través de un transistor darlington en el IC.

Se agrega un botón pulsador al circuito para permitir alguna acción del usuario. Por tanto, el puente de velas podría tener algunos programas seleccionables por el usuario.

El pulsador del circuito está conectado a RESET y GND. Esto es exactamente lo que hace el botón de reinicio integrado. Como no encapsulo todo en una caja de plástico, estoy usando el botón de reinicio en el Arduino para controlar el programa. Agregar un botón de acuerdo con la imagen funcionará exactamente como el botón de reinicio de la placa. El programa funciona recordando qué programa de luz se utilizó la última vez que se ejecutó. Por lo tanto, cada reinicio avanzará al siguiente programa de luces.

Las fotos muestran cómo los nuevos cables salen del puente, cómo coloqué el transistor IC y las resistencias en la placa de pruebas y cómo los cables de puente se conectan al Arduino Mega. Corté 4 cables de puente macho-macho en 8 medios cables, que soldé a los 8 cables que salían del puente de la vela. De esta manera puedo simplemente pegar los cables en la placa de pruebas.

Alternativa sin transistores

En el paso anterior, preparé un cable '+' común para las velas y cables '-' separados, que atraviesan el circuito integrado del transistor hasta el suelo. Cuando un pin de datos pasa a alto, el cable '-' correspondiente se conecta a tierra a través de su transistor y el LED se enciende.

Conectar los cables '-' directamente a los pines de datos del Arduino también funcionaría, ¡pero siempre tenga en cuenta la cantidad de corriente que pueden soportar los pines de datos! Este enfoque necesitaría un cambio en mi programa. Necesitaría que los pines de datos bajen para encender las velas. Para usar mi programa tal como está, debe cambiar '+' y '-' en las velas. Tenga un cable '-' común para las velas, que va a GND en el Arduino. Y los cables separados corren entre el cable '+' de la vela y un pin de datos del Arduino.

Paso 4: los programas de luz

Mi programa, que presento en el siguiente paso, pasa por 9 programas de luz. Al presionar el botón se apagarán las luces por un segundo, luego se iniciará el siguiente programa de luces. Los programas son los siguientes:

1. Fuerte parpadeo. Las velas parpadean al azar. Esto se ve muy molesto cuando los miras de cerca, pero puede verse bien desde la distancia y quizás detrás de una ventana helada del ático. Sin embargo, su vecino podría llamar a los bomberos.
2. Parpadeo suave. Se ve muy bien. Como velas de verdad en una habitación sin corriente.
3. Parpadeo variable. Las velas alternan suavemente entre un parpadeo fuerte y suave en intervalos de unos 30 segundos.
4. Parpadeo variable. Como la # 3, pero cada vela varía a su propio ritmo entre 30 sy 60 s.
5. Brillo rápido. Las velas brillan a un nivel atenuado estático y centellean aleatoriamente. En promedio, hay un centelleo por segundo.
6. Brillo lento. Como el n. ° 5, pero a un ritmo mucho más lento.
7. Onda rápida desde la vela superior media a la inferior.
8. Onda lenta desde la vela superior media a la inferior.
9. Luz brillante estática. Tuve que incluir esto, no quería deshacerme de la función original.

Paso 5: el código

/*

PUENTE DE VELA PARPADEANTE * / // Declara la variable de modo para mantener el estado // a través de una operación de reinicio _attribute _ ((section (". Noinit"))) unsigned int mode; // Cuando el programa se inicia después de un reinicio, esta // pieza de memoria no se inicializa, pero mantiene el valor // que tenía antes del reinicio. La primera vez que // se ejecuta el programa, tiene un valor aleatorio. / * * La clase de velas contiene todo lo necesario * para calcular un nivel de luz para * una vela parpadeante. * / clase vela {privado: largo tiempo máximo; mintime largo; maxlite largo; minlite largo; media larga; tiempo de origen largo; tiempo de origen largo; origmaxlite largo; origminlita larga; origmeanlita larga; deltamaxtime largo; deltamintime largo; deltamaxlite largo; deltaminlita larga; deltameanlita larga; lforato largo; larga noche comienzo largo objetivo largo factor flotante; tiempo objetivo largo; tiempo de inicio largo; tiempo delta largo; void newtarget (vacío); long onetarget (vacío); público: vela (tapete largo, mit largo, mal largo, mil largo, mel largo, eo largo); nivel largo ahora (vacío); void initlfo (deltamat largo, deltamit largo, deltamal largo, deltamil largo, deltamean largo, velocidad larga); void setlfo (vacío); }; vela:: vela (tapete largo, mit largo, mal largo, mil largo, mel largo, eo largo): maxtime (mat), mintime (mit), maxlite (mal), minlite (mil), meanlite (mel), evenout (eo), origmaxtime (mat), origmintime (mit), origmaxlite (mal), origminlite (mil), origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () devuelve el nivel de luz que debería tener la vela en este momento. * La función se encarga de definir un nuevo nivel de luz aleatorio y * el tiempo que debería tardar en alcanzar ese nivel. El cambio no es lineal, * sino que sigue una curva sigmoidea. Cuando no es el momento de definir un nuevo * nivel, la función simplemente devuelve el nivel de luz. * / vela larga:: levelnow (void) {ayuda larga, ahora; flotador t1, t2; ahora = millis (); if (ahora> = tiempo objetivo) {ayuda = objetivo; newtarget (); devolver ayuda; } else {// help = target * (millis () - starttime) / deltatime + start * (targettime - millis ()) / deltatime; t1 = float (targettime - ahora) / deltatime; t2 = 1. - t1; // Esta es la ayuda de cálculo sigmoide = t1 * t1 * t1 * inicio + t1 * t1 * t2 * inicio * 3 + t1 * t2 * t2 * objetivo * 3 + t2 * t2 * t2 * objetivo; devolver ayuda; }} vela void:: newtarget (void) {suma larga; suma = 0; for (long i = 0; i <evenout; i ++) sum + = onetarget (); inicio = objetivo; objetivo = suma / paridad; hora de inicio = milis (); targettime = starttime + random (mintime, maxtime); deltatime = targettime - hora de inicio; } vela larga:: onetarget (void) {if (aleatorio (0, 10) última comprobación + 100) {última comprobación = ahora; / * * El algoritmo para parpadear "después de milisegundos de frecuencia": * Comience a verificar después de la frecuencia / 2 milisegundos * Durante un período de frecuencia / 2 milisegundos, haga * que la probabilidad de un parpadeo sea del 50%. * Si la tasa es de 10000 ms, durante 5000 ms la moneda se * lanza 50 veces. * 1/50 = 0.02 * Si es aleatorio (10000) hora de inicio + tasa / 2) {if (tiempo objetivo aleatorio (tasa)) return lowlite; return (inicio - lowlite) * (targettime - ahora) / (targettime - starttime) + lowlite; } void twinkler:: twink (void) {hora de inicio = millis (); targettime = random (mintime, maxtime) + starttime; inicio = aleatorio (minlite, maxlite); } configuración vacía () {int led; // Leer la variable del modo mágico, que debería decir // qué programa de luz se ejecutó la última vez, incrementarlo // y restablecerlo a cero si se desborda. modo ++; modo% = 9; // Esto se ocupa del valor // que fue la primera vez que Arduino // ejecutó este programa. / * * NOTA IMPORTANTE * ============== * * Lo esencial que hace este programa es enviar señales PWM * a luces LED. Aquí configuro los pines 3 a 9 en modo de salida *. En un Arduino Mega2560, estos pines emiten * muy bien señales PWM. Si tiene otro Arduino, verifique * qué pines (y cuántos) puede usar. Siempre puede * reescribir el código para usar el software PWM, si su Arduino * no puede proporcionar suficientes pines de hardware PWM. * * / pinMode (3, SALIDA); pinMode (4, SALIDA); pinMode (5, SALIDA); pinMode (6, SALIDA); pinMode (7, SALIDA); pinMode (8, SALIDA); pinMode (9, SALIDA); pinMode (LED_BUILTIN, SALIDA); analogWrite (LED_BUILTIN, 0); // Simplemente apague el molesto led rojo de la vela Arduino * can [7]; // prepárate para usar las velas parpadeantes, ya sea que las uses o no twinkler * twink [7]; // prepárate para usar las velas centelleantes… if (mode == 8) {for (int i = 3; i <10; i ++) analogWrite (i, 255); mientras (verdadero); // Cada vez que se ejecuta este programa, // entra en este tipo de bucle sin fin, hasta que se presiona el // botón de reinicio. } if (modo <2) // parpadeando {long maxtime_; long mintime_; long maxlite_; long minlite_; long meanlite_; largo even_; if (modo == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; even_ = 1; } if (modo == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; even_ = 1; } for (int i = 0; i <7; i ++) {can = nueva vela (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (verdadero) // El bucle sin fin de velas parpadeantes {for (int i = 0; i levelnow ()); }} if (mode <4) // lfo agregado al parpadeo {if (mode == 2) // mismo lfo (30 s) para todas las velas {for (int i = 0; i initlfo (75, 50, 0), 50, 36, 30000);}} if (modo == 3) // variando lfo: s para las velas {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); can [1] -> initlfo (75, 50, 0, 50, 36, 25000); can [2] -> initlfo (75, 50, 0, 50, 36, 30000); can [3] -> initlfo (75, 50, 0, 50, 36, 35000); can [4] -> initlfo (75, 40, 0, 50, 36, 40000); can [5] -> initlfo (75, 30, 0, 50, 26, 45000); can [6] -> initlfo (75, 20, 0, 50, 16, 50000); can [7] -> initlfo (75, 10, 0, 50, 6, 55000);} while (true) // El ciclo sin fin para velas parpadeantes con un lfo {long lastclock = 0; for (int i = 0; i levelnow ()); if (millis ()> lastclock + 4000) {lastclock = millis (); for (int i = 0; i setlfo ();}}} if (modo <6) // velas centelleantes {int speedo; if (mode == 4) speedo = 6000; else 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 ()); } } // Ondas. // Esta sección comienza con llaves // solo para garantizar que no haya nombres de variables en conflicto. // No hay otra necesidad de corchetes, no es necesario verificar // el valor de modo.{int lolite = 2; int hilite = 255; int mean; int ampl; flotador fasedelta = 2.5; fase de flotación; int elong; factor flotante; período largo; media = (lolita + hilita) / 2; ampl = hilite - media; si (modo == 6) período = 1500; si no período = 3500; factor = 6.28318530718 / período; while (verdadero) {fase = factor * (milis ()% período); elong = media + ampl * sin (fase); analogWrite (7, alargado); analogWrite (9, alargado); fase = factor * ((milis () + período / 4)% período); elong = media + ampl * sin (fase); analogWrite (3, alargado); analogWrite (8, alargado); fase = factor * ((milis () + período / 2)% período); elong = media + ampl * sin (fase); analogWrite (4, alargado); analogWrite (5, alargado); fase = factor * ((milis () + 3 * período / 4)% período); elong = media + ampl * sin (fase); analogWrite (6, alargado); } // Mientras conectaba los cables de las velas al Arduino, // los mezclé y nunca los puse en orden. // El orden es importante para crear patrones de onda, // así que acabo de escribir esta pequeña tabla para mí: // // Número de vela en el puente: 2 3 5 4 7 6 1 // Pin de datos en Arduino: 3 4 5 6 7 8 9}} void loop () {// Dado que cada programa de luz es su propio bucle infinito, // escribí todos los bucles en la sección begin () // y no dejé nada para esta sección loop (). }

Paso 6: Acerca de PWM

Los leds brillan intensamente cuando se alimentan con 3 V. Con solo 1,5 V no se encienden en absoluto. Las luces LED no se desvanecen bien con la disminución del voltaje, como lo hacen las luces incandescentes. En su lugar, deben encenderse a pleno voltaje y luego apagarse. Cuando esto sucede 50 veces por segundo, brillan muy bien con un 50% de brillo, más o menos. Si se les permite estar encendidos solo 5 ms y apagados 15 ms, podrían brillar con un brillo del 25%. Esta técnica es la que hace que la luz LED sea regulable. Esta técnica se llama modulación por ancho de pulso o PWM. Un microcontrolador como Arduino generalmente tiene pines de datos, que pueden enviar señales de encendido / apagado. Algunos de los pines de datos tienen capacidades integradas para PWM. Pero si no hay suficientes pines con PWM integrado, normalmente es posible utilizar bibliotecas de programación dedicadas para crear "pines de software PWM".

En mi proyecto, he usado un Arduino Mega2560, que tiene hardware PWM en los pines 3 - 9. Si usa un Arduino UNO, solo tiene seis pines PWM. En ese caso, si necesita una séptima vela (o incluso más), puedo recomendar la biblioteca de software PWM de Brett Hagman, que puede encontrar aquí.