Lámpara LED de escritorio de música reactiva
Construcción de una lámpara al ritmo de la música, usando componentes simples y alguna programación básica de Arduino. Hace un efecto impresionante al estar de pie sobre el escritorio cuando el juego, la reproducción de música, y cualquier otra cosa se ejecuta.
Paso 1: |Suministros principales|
Lo primero es lo primero: ¿qué tipo de suministros necesitamos y qué cuestan? Bien, son en gran parte opcionales, y se pueden hacer con mucha improvisación. Aun así, algunos elementos clave son necesarios si desea seguir esta guía:
Arduino Nano (o cualquier tipo Arduino igualmente pequeño)
Módulo del detector sano (acoplamiento de AliExpress)
Fuente de alimentación de 5 voltios (o 12 voltios con este módulo de stepdown, como lo haré aquí)
Tiras individualmente direccionables LED 60 leds per. Meter (acoplamiento de AliExpress)
Dependiendo de la apariencia que desee, es posible que desee organizar las tiras de manera diferente o difundir la luz de otra manera. Aquí es donde puedes ser creativo. Si te gusta mi enfoque, he utilizado los siguientes elementos:
El tarro IKEA Droppar más alto
Una pequeña longitud de tubo de PVC.
Todas las cosas consideradas pasé alrededor de 30 $ dolares, donde las tiras de LED eran de lejos la parte más cara.
Paso 2: |Encendido de los componentes|
La estrella del espectáculo es el módulo detector de sonido. Esto proporcionará una señal analógica al Arduino, que podemos utilizar para (con suerte) inteligentemente iluminar las luces RGB. Para poder hacer esto, necesitamos alimentar ambos dispositivos. Afortunadamente, ambos requieren una entrada de 5 voltios. Estoy utilizando un módulo de paso hacia abajo de 12 voltios a 5 voltios, pero sería más fácil utilizar una fuente de alimentación de 5 voltios directamente. Conecte el VIN en el Arduino y en la placa del detector de sonido a la entrada positiva. Luego conecte el GND en el Arduino y el detector al negativo. Mira los cables negro y rojo en el esquema adjunto. También necesitamos conectar la entrada positiva y negativa en la tira de LED a la fuente de alimentación.
Paso 3: |Detector y tiras|
Después de haber conectado las tres partes a la energía, necesitamos conectarlas entre sí.
El módulo del detector de sonido se comunicará con el Arduino a través de los pines de entrada analógica. Estaré utilizando pin número 0, pero que no importa.
Las tiras LED necesitan un pulso digital para poder entender qué LED queremos abordar. Por lo tanto, necesitamos conectar un pin de salida digital al nano Arduino. Usaré el número 6.
Paso 4: |cargar el código|
[color=#000000]#include <FastLED.h>
/** BASIC CONFIGURATION **/
//The amount of LEDs in the setup
#define NUM_LEDS 150
//The pin that controls the LEDs
#define LED_PIN 6
//The pin that we read sensor values form
#define ANALOG_READ 0
/** Other macros */
//How many previous sensor values effects the operating average?
#define AVGLEN 5
//How many previous sensor values decides if we are on a peak/HIGH (e.g. in a song)
#define LONG_SECTOR 20
//Mneumonics
#define HIGH 3
#define NORMAL 2
//How long do we keep the "current average" sound, before restarting the measuring
#define MSECS 30 * 1000
#define CYCLES MSECS / DELAY
/*Sometimes readings are wrong or strange. How much is a reading allowed
to deviate from the average to not be discarded? **/
#define DEV_THRESH 0.8
//Arduino loop delay
#define DELAY 1
float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve);
void insert(int val, int *avgs, int len);
int compute_average(int *avgs, int len);
void visualize_music();
//How many LEDs to we display
int curshow = NUM_LEDS;
/*Not really used yet. Thought to be able to switch between sound reactive
mode, and general gradient pulsing/static color*/
int mode = 0;
//Showing different colors based on the mode.
int songmode = NORMAL;
//Average sound measurement the last CYCLES
unsigned long song_avg;
//The amount of iterations since the song_avg was reset
int iter = 0;
//The speed the LEDs fade to black if not relit
float fade_scale = 1.2;
//Led array
CRGB leds[NUM_LEDS];
/*Short sound avg used to "normalize" the input values.
We use the short average instead of using the sensor input directly */
int avgs[AVGLEN] = {-1};
//Longer sound avg
int long_avg[LONG_SECTOR] = {-1};
//Keeping track how often, and how long times we hit a certain mode
struct time_keeping {
unsigned long times_start;
short times;
};
//How much to increment or decrement each color every cycle
struct color {
int r;
int g;
int b;
};
struct time_keeping high;
struct color Color;
void setup() {
Serial.begin(9600);
//Set all lights to make sure all are working as expected
FastLED.addLeds<NEOPIXEL, LED_PIN>(leds, NUM_LEDS);
for (int i = 0; i < NUM_LEDS; i++)
leds[i] = CRGB(0, 0, 255);
FastLED.show();
delay(1000);
//bootstrap average with some low values
for (int i = 0; i < AVGLEN; i++) {
insert(250, avgs, AVGLEN);
}
//Initial values
high.times = 0;
high.times_start = millis();
Color.r = 0;
Color.g = 0;
Color.b = 1;
}
/*With this we can change the mode if we want to implement a general
lamp feature, with for instance general pulsing. Maybe if the
sound is low for a while? */
void loop() {
switch(mode) {
case 0:
visualize_music();
break;
default:
break;
}
delay(DELAY); // delay in between reads for stability
}
/**Funtion to check if the lamp should either enter a HIGH mode,
or revert to NORMAL if already in HIGH. If the sensors report values
that are higher than 1.1 times the average values, and this has happened
more than 30 times the last few milliseconds, it will enter HIGH mode.
TODO: Not very well written, remove hardcoded values, and make it more
reusable and configurable. */
void check_high(int avg) {
if (avg > (song_avg/iter * 1.1)) {
if (high.times != 0) {
if (millis() - high.times_start > 200.0) {
high.times = 0;
songmode = NORMAL;
} else {
high.times_start = millis();
high.times++;
}
} else {
high.times++;
high.times_start = millis();
}
}
if (high.times > 30 && millis() - high.times_start < 50.0)
songmode = HIGH;
else if (millis() - high.times_start > 200) {
high.times = 0;
songmode = NORMAL;
}
}
//Main function for visualizing the sounds in the lamp
void visualize_music() {
int sensor_value, mapped, avg, show_amount, longavg;
//Actual sensor value
sensor_value = analogRead(ANALOG_READ);
//If 0, discard immediately. Probably not right and save CPU.
if (sensor_value == 0)
return;
//Discard readings that deviates too much from the past avg.
mapped = (float)fscale(0.0, 737.0, 0.0, (float)737, (float)sensor_value, 2.0);
avg = compute_average(avgs, AVGLEN);
if (((avg - mapped) > avg*DEV_THRESH)) //|| ((avg - mapped) < -avg*DEV_THRESH))
return;
//Insert new avg. values
insert(mapped, avgs, AVGLEN);
insert(avg, long_avg, LONG_SECTOR);
//Compute the "song average" sensor value
song_avg += avg;
iter++;
if (iter > CYCLES) {
song_avg = song_avg / iter;
iter = 1;
}
longavg = compute_average(long_avg, LONG_SECTOR);
//Check if we enter HIGH mode
check_high(longavg);
if (songmode == HIGH) {
fade_scale = 3;
Color.r = 5;
Color.g = 3;
Color.b = -1;
}
else if (songmode == NORMAL) {
fade_scale = 2;
Color.r = -1;
Color.b = 2;
Color.g = 1;
}
//Decides how many of the LEDs will be lit
show_amount = (float)fscale(0.0, 737.0, 0.0, 255, (float)avg, 1.5);
curshow = fscale(0.0, 737.0, 0.0, (float)NUM_LEDS, (float)avg, -1);
/*Set the different leds. Control for too high and too low values.
Fun thing to try: Dont account for overflow in one direction,
some interesting light effects appear! */
for (int i = 0; i < NUM_LEDS; i++)
//The leds we want to show
if (i < curshow) {
if (leds[i].r + Color.r > 255)
leds[i].r = 255;
else if (leds[i].r + Color.r < 0)
leds[i].r = 0;
else
leds[i].r = leds[i].r + Color.r;
if (leds[i].g + Color.g > 255)
leds[i].g = 255;
else if (leds[i].g + Color.g < 0)
leds[i].g = 0;
else
leds[i].g = leds[i].g + Color.g;
if (leds[i].b + Color.b > 255)
leds[i].b = 255;
else if (leds[i].b + Color.b < 0)
leds[i].b = 0;
else
leds[i].b = leds[i].b + Color.b;
//All the other LEDs begin their fading journey to eventual total darkness
} else {
leds[i] = CRGB(leds[i].r/fade_scale, leds[i].g/fade_scale, leds[i].b/fade_scale);
}
FastLED.show();
}
//Compute average of a int array, given the starting pointer and the length
int compute_average(int *avgs, int len) {
int sum = 0;
for (int i = 0; i < len; i++)
sum += avgs[i];
return (int)(sum / len);
}
//Insert a value into an array, and shift it down removing
//the first value if array already full
void insert(int val, int *avgs, int len) {
for (int i = 0; i < len; i++) {
if (avgs[i] == -1) {
avgs[i] = val;
return;
}
}
for (int i = 1; i < len; i++) {
avgs[i - 1] = avgs[i];
}
avgs[len - 1] = val;
}
//Function imported from the arduino website.
//Basically map, but with a curve on the scale (can be non-uniform).
float fscale( float originalMin, float originalMax, float newBegin, float
newEnd, float inputValue, float curve){
float OriginalRange = 0;
float NewRange = 0;
float zeroRefCurVal = 0;
float normalizedCurVal = 0;
float rangedValue = 0;
boolean invFlag = 0;
// condition curve parameter
// limit range
if (curve > 10) curve = 10;
if (curve < -10) curve = -10;
curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output
curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function
// Check for out of range inputValues
if (inputValue < originalMin) {
inputValue = originalMin;
}
if (inputValue > originalMax) {
inputValue = originalMax;
}
// Zero Refference the values
OriginalRange = originalMax - originalMin;
if (newEnd > newBegin){
NewRange = newEnd - newBegin;
}
else
{
NewRange = newBegin - newEnd;
invFlag = 1;
}
zeroRefCurVal = inputValue - originalMin;
normalizedCurVal = zeroRefCurVal / OriginalRange; // normalize to 0 - 1 float
// Check for originalMin > originalMax - the math for all other cases i.e. negative numbers seems to work out fine
if (originalMin > originalMax ) {
return 0;
}
if (invFlag == 0){
rangedValue = (pow(normalizedCurVal, curve) * NewRange) + newBegin;
}
else // invert the ranges
{
rangedValue = newBegin - (pow(normalizedCurVal, curve) * NewRange);
}
return rangedValue;
}
[/color]
El principio principal es asignar el valor analógico que obtenemos del sensor, a una cantidad de LEDs para mostrar.
Podemos hacerlo usando la función de mapa. Esto nos permitirá mostrar una cierta cantidad de LEDs dados una entrada, pero nada más que eso. Hacer sólo esto podría darle una luz agitada y parpadeante. Decidí operar en el promedio de la cantidad X de lecturas para crear una transición más sana y más suave. También hice un seguimiento más avanzado de la canción / intensidad de sonido basada en promedios, para dejar que la luz cambie de color cuando la canción entra en un pico.
Paso 5: |Montaje|
Con todo el código y los componentes hechos, es el tiempo de montaje. El PVC es obviamente hueco, y aprovecharemos eso rellenando la electrónica en el interior. Cortaremos una rendija en la tubería de PVC para que podamos deslizar la tira sin obstruir la superficie del agujero de PVC. Después de eso, podemos pegar la tira de LED a la tubería de PVC. Algunos me han preguntado por qué he usado pegamento caliente, y no sólo el adhesivo en la parte posterior de la tira. Es simplemente porque mi experiencia con él es que se celebrará bien en superficies realmente limpias y rectas, pero en una curvatura como esta lo más probable es dejar ir en cuestión de días. Por lo tanto: pegamento caliente!
Paso 6: |El propio recipiente|
Primero pensé que la tapa estaba hecha de acrílico, así que traté de perforar un agujero en ella. Resulta que estaba hecho de vidrio, y se rompió. ¡Inteligente! Por lo tanto, es por eso que estoy cortando una esfera de acrílicos con el mismo diámetro que la tapa, con un agujero igual al tamaño de la tubería de PVC en el centro. Resultó bastante fresco, y me encanta el brillo del nuevo acrílico. Antes de poner el frasco IKEA helado, tenemos que pegar el palo de LED a la tapa.
Paso 7: |Terminando|
Podemos ver por el agujero, y la colocación de los componentes electrónicos, podemos llegar tanto a la interfaz Arduino USB y la entrada de energía desde abajo. Tomé un pequeño atajo en las piernas, y utilicé algunos mandos del potenciómetro que tenía tendido alrededor. Lo ideal es que quieras un poco de madera agradable o tal vez algunos de aluminio
Paso 8: |Listo|
