El autor como la mayoria de los que se acercan a Netduino , empezo con el famoso proyecto de lede parapadeante proyecto blinky Netduino y pensó en hacer un circuito para leer una señal analógica de una línea de 3,5 mm y visualizarlo.
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ónes 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í:
Como puede ver, no es ciencia del cohete, que es maravilloso para el autor porque esmás feliz en el código con un teclado que en un circuito con un soldador. Después de configurar las cosas así, escribióo un pequeño código para probar los LEDs. Como se menciona más adelante, este circuito es subóptima (una buena manera de decir que es un circuito mal y no tengo idea lo que estoy haciendo). El LED debe ser alimentado a través de una fuente de alimentación a diferencia de la Arduino y debe estar usando resistencias en serie para estabilizar el circuito. Sin embargo el autor se arriesgo….
Hay que romper cosas
El autor comenzo un proyecto de GitHub para Netduino que hace a todo tipo de gestión LED para las tiras de SPI-basado.
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… Procedó 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 funcionarna Después de conseguir las cosas funcionen, actualizódo 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
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 qautor 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.
Puzzle Bobble
Karate Blazers
Puzzle De Bloques
Magical Cat Adventure