Vumeter gigante con Netduino


El autor como la mayoría de  los que se acercan a Netduino , empezó con el famoso  proyecto de led  parpadeante  proyecto blinky Netduino y para mejorarlo pensó en hacer un circuito que pueda leer una señal analógica de una línea de 3,5 mm y visualizarlo sobre  una matriz de diodos LED’s.  

Puede ver los resultados en el siguiente video:

A continución vamos a ver como lo hizo.

Hardware

Adquirió tiras de LED multicolores que soporte SPI.(buscando por algo así como “1 m direccionable tira de LED RGB” en Amazon o puede obtenerlos a través de Adafruit).

El bus de interfaz periférico serial (SPI) es realmente impresionante para la gestión de LED. Si  ha hecho configuraciones multi-led más tradicionales, tienes que usar el PWM para gestionar el color de cada LED y cada LED de alambre a su propio módulo PWM / bus. Este es un dolor y terminas con circuitos súper complicados. Como el autor se confiesa no ser un ingeniero eléctrico o diseñador de sistemas embebidos, esto generalmente resulta en una bola gigante soldadura en lugar de un circuito apropiado y tampoco  puede depurar hardware muy bien. Con SPI, usted obtiene una interfaz DIGITAL y puede individualmente ver explosión es de  bytes RGB en una dirección y  hermosos colores.

Suponemos que ideas mejores  que  SPI,(Arduino, Netduino) tienen un puerto SPI con hardware acelerado,así, puede interactuar con estas tiras de LED y obtner un rendimiento grande en el  hardware.

El enfoque genérico que llevé a la interfaz del controlador era para conectar el puerto de reloj (ck) SPI para el SPI reloj pin (13 en el netduino) y la línea de datos SPI (sd) al pin de datos (11 en el netduino) . Masa esté conectada a tierra y el pasador de 5v para alimentar directamente del escudo de netduino. Visualmente, así:

steup-pins

Como puede ver, no es ciencia del cohete, que es maravilloso para el autor porque es más feliz en el código con un teclado que en un circuito con un soldador. Después de configurar las cosas así, escribió un pequeño código para probar los LEDs. Como se menciona más adelante, este circuito el autor lo mejorara. La tira de  LEDs debe ser alimentado a través de una fuente de alimentación a diferencia de  Arduino y debe estar usando resistencias en serie para estabilizar el circuitoSin embargo el  autor se arriesgo….

Hay que romper cosas

El autor  comenzó un proyecto de GitHub para Netduino que hace a todo tipo de gestión LED para las tiras de SPI-basado

 

 

20130715_204055

 

Estaba haciendo algo mal en la foto  donde estaba conduciendo el LED se ilumina directamente a través de la Netduino usando los 5V y GND pasadores. Porque era poca energía para el circuito, los LEDs  lucian más tenues como parecía más abajo de la tira, el circuito menos estable y poder no eran disponible para las tiras de LED en el extremo de la línea. En la anterior demo, limitó el número de LEDs dirigidas para la estabilidad.

Con el fin de “impulsar” el circuito,  añadió una nueva fuente de alimentación directamente al circuito que los LEDs encendidos. Así que… Procedió a soplar un número de tiras de LED ejecutando el voltaje en una cadena de 5M de tiras (whoopsiedaisy.) y luego mothballed el proyecto por el momento.

Rescató algunos de los módulos para  reiniciar el proyecto.

Blinky revisitada

Después de un rato, regresó al proyecto con dos tiras de LED de trabajo en la mano. Entonces uso  blinky demo para cerciorarse de que funcionaria .Después de conseguir las cosas que funcionase, actualizó el proyecto con un toque adicional: conectó una línea estéreo a las entradas analógicas y luego utiliza la señal para variar las imágenes que fueron atraídas a las tiras.

Los pasadores de izquierda/derecha analógicos fueron conectados a los puertos analógicos 3 y 0 (espaciado más fácil) y luego la línea estéreo fue castigada con el conector de tierra adicional en el tablero. La foto siguiente muestra la increíble habilidad tablero de conexión

IMG_20140107_155311

Con los pernos analógicos conectados, podría leer los valores de las líneas y para actualizar las gráficas según corresponda. El código siguiente muestra la función de ecualizador completo que luego ya escapo de Blinky. El código no está toda la documentación, pero los comentarios en línea debe darle la esencia de lo que está pasando.

        void Equalizer()
        {
            // Set ports for the stereo lines
            Microsoft.SPOT.Hardware.AnalogInput pinA0 = new Microsoft.SPOT.Hardware.AnalogInput(Cpu.AnalogChannel.ANALOG_0);
            Microsoft.SPOT.Hardware.AnalogInput pinA2 = new Microsoft.SPOT.Hardware.AnalogInput(Cpu.AnalogChannel.ANALOG_2);

            // Loop forever and update the enabled LEDs based on the signal strength
            while (true)
            {
                var colors = new byte[3 * numLEDs];
                int lastLedsToColorL = 0;
                int lastLedsToColorR = 0;
                int highValue = 0;
                int highRefresh = 3;

                byte offset = 255;
                while (!changeMode)
                {
                    double valueL = pinA0.Read();
                    valueL *= 100;
                    valueL = (valueL >= 1) ? 1 : valueL;

                    double valueR = pinA2.Read();
                    valueR *= 100;
                    valueR = (valueR >= 1) ? 1 : valueR;

                    // Implements smoothing. By averaging between the current / last LED state,
                    // you can make the transitions less jumpy
                    int ledsToColorL = (int)( (((numLEDs/2) * (valueL))  + lastLedsToColorL) / 2);
                    lastLedsToColorL = ledsToColorL;

                    int ledsToColorR = (int)((((numLEDs / 2) * (valueR)) + lastLedsToColorR) / 2);
                    lastLedsToColorR = ledsToColorR;

                    if (offset > 255)
                    {
                        offset = 0;
                    }

                    // all pixels off
                    for (int i = 0; i < colors.Length; ++i) colors[i] = (byte)(0);

                    int numLEDsP = numLEDs/2;

                    // a progressive yellow/red blend
                    for (byte i = 0; i < ledsToColorL; ++i)
                    {
                        byte[] color = new byte[3];
                        if (i < (numLEDsP / 3))
                        {
                            color = utils.RGB(offset, 0, 0);
                        }
                        else if (i < ((numLEDsP * 2) / 3))
                        {
                            color = utils.RGB(0, offset, 0);
                        }
                        else
                        {
                            color = utils.RGB(0, 0, offset);
                        }
                        for (byte j = 0; j < 3; j++)
                        {
                            colors[(3 * i) + j] = color[j];
                        }
                    }

                    // a progressive yellow/red blend
                    for (byte i = 32; i < ledsToColorR + 32; ++i)
                    {
                        byte[] color = new byte[3];
                        if (i < (numLEDsP / 3) + 32)
                        {
                            color = utils.RGB(offset, 0, 0);
                        }
                        else if (i < ((numLEDsP * 2) / 3) + 32)
                        {
                            color = utils.RGB(0, offset, 0);
                        }
                        else
                        {
                            color = utils.RGB(0, 0, offset);
                        }
                        for (byte j = 0; j < 3; j++)
                        {
                            colors[(3 * i) + j] = color[j];
                        }
                    }
                    spi.Write(colors);
                    Thread.Sleep(32); // Good #'s 32, 128
                }
            }
        }

Mientras que los valores cambian desde la línea analógica, los LEDs de luz hacia arriba y hacia abajo  (desde luego muy ingenioso )

La demo

En la demo que mostró el autor  en la parte superior del artículo, conectó el VU-metro de la línea de auriculares para que coincida con el maestro. Los resultados no son perfectos, pero son lo suficientemente buenas para que pueda decir que los beats libremente se adaptan a las imágenes VUos a seguir

El autor tiene  una prueba de concepto en este punto que quiero hacer mejor con saltos VU más suaves y más colores personalizados (valores máximos flotante sería geniales también).

En primer lugar, los saltos VU… en su hipótesis inicial es que hay un montón de ruido en la línea provocando que la señal analógica que más me gustaría durante la lectura de los pines analógicos en la Netduino aleatorios.

Otra teoría es que allí está pasando aliasing donde la frecuencia de lecturas de las líneas analógicas de alguna manera está causando extrañas señales analógicas – esto es en realidad mucho más factible que el ruido y comprobable (otra vez, fallo a tierra electrónica y soldadura) podría ser capaz de crear una ventana deslizante para leen los valores de las líneas analógicas. Al hacer esto, mejor se puede suavizar los cambios de valor analógico aunque a un costo de frecuencia de actualización.

Siguiente, los valores máximos y colores. En este proyecto se utiliza una adaptación del código que genera mezclas de color super-awesome-mega-fantástico Adafruit colorwheel. Cambiando los valores rojo-amarillo-verde con algo más generativo sería fácil y probablemente es lo que hará el autor  a continuación.

 

Véase también

 

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s