* actualizado * LED-torre "Hola", Vu-metro detección música avanzada sin IC sólo con Ardurino e interfaz con Software para Windows PC.

Las luces más grande de construir, sólo se obtiene cuando la música consigue más intensivo.
con el Monitor Serial he conseguido escribir una aplicación de Windows, que Ardurino controles, Sarcoptiosis utilizar la
Torre del agujero como luz principal para mi sala de estar.

Echa un vistazo aquí:

Lo que necesitas (versión completa):

-Mega(Atmega1280) Ardurino
-24 x LED azul
-14 x LED blanco
-5 x LED Multicolor
-2 x LED verde
-2 X Bi-Color(Red/Blue) de LED
-2 x 40 vatios lámparas
-2 x LED del 12 voltios-Spot LED
-2 x relé de 5 Volt
-Rojo X SMD 1 matriz
-45 x 220 Ohm resistencias
-Alambre
-1 x Audio 3,5 Jack
-1 x cuerpo A poliestireno expandible o plexiglás

Lo que necesitas (versión básica):

Pins-Ardurino Mikrocontroller con X!
-X LED
-X resistencias de 220 ohmios
-Alambre
-Audio 3.5 Jack
-Un cuerpo de poliestireno expandible o plexiglás

Por favor revise los cuadros:

¿Cómo funciona?

Si alguna vez hiciste música usted mismo, conoces la longitud del patrón de la música del standart, y
esa es la clave para esto, contando variables y rendirles. (como 16,32,64,128,256,512, etc...)

Paso 1:

-Perforaciones en su cuerpo de poliestireno expandible o plexiglás.
-Coloque el LED como usted quiere.

Paso 2:

-Tus LEDs con resistencias de alambre y conectar a cualquier pin libre en su ardurino!.
-conectar un par de LED con pwm pins
-Prueba tus LEDs con el básico "Blink-bosquejo"

Paso 3:

-conectar un pin analógico con conector de sonido y su fuente de Audio
-Prueba con el básico "bosquejo AnalogRead"

Paso 4:

ardurino software al programa abierto.

Añadir este código y modificar las matrices con sus pernos y la cuenta de pines a la var.

/*
https://DL.Dropbox.com/u/3917871/ardurino/LEDTOWER.exe
*/

PIN que el sensor está colocado en analógico 14 en mi caso
const int sensorPin = A14;

de los 3 principales matriz con pasadores LED
const int ALLLEDS [] = {}
6,22,8,26,53,24,48,10,5,42,31,32,33,23,25,9,27,7,44,12,50,34};
const int notPWMLEDS [] = {}
22,26,53,24,5,42,31,32,33,23,25,27,50,34};
const int pwmLEDS [] = {}
6,8,5,9,44,10,7,12,48};

Estos son el número de LED Attaced en la matriz 3
const int pwmCOUNT = 9;
const int ALLCOUNT = 22;
const int notPWMCOUNT = 15;

Estos son los Highlihts especial conectado con un relé
const int relayCh1 = 14;   Lámparas 2 x 40 vatios
const int relayCh2 = 15;   LED del 2 x 12 voltios-Spot LED
const int relayCh3 = 17;    Licht 3

variables:
int incomingByte,jaodernein,schleifeEins,schleifeZwei,schleifeDrei,sensorMax,sensorValue,AudioIn,LANGERdelay,DelayValue,counterNull,counterEins,counterZwei,counterDrei,counterVier,counterFunf,counterSechs,counterSieben,nextLED,updown,thisPin = 0;         el valor del sensor
int sensorMin = 1023;        valor de la sonda de mínima

void setup() {}
Configura el voltaje de referencia usado para entradas analógicas
analogReference(INTERNAL1V1);
Serial.Begin(9600);
Serial.println ("torre LED 'Hola' por Mhonolog v: 13.5");

pinMode (relayCh1, salida);
pinMode (relayCh2, salida);
pinMode (relayCh3, salida);
pinMode (48, salida);
para (thisPin = 0; thisPin < ALLCOUNT; thisPin ++) {}
pinMode (ALLLEDS [thisPin], salida);
}
Serial.println("calibrateing...");
digitalWrite (7, alto);
mientras (millis() < 5000) {}
sensorValue = analogRead(sensorPin);
Si (sensorValue > sensorMax) {}
sensorMax = sensorValue;
}
Si (sensorValue < sensorMin) {}
sensorMin = sensorValue;
}
}
Serial.Print ("establecer min nuevo en:");
Serial.Print(sensorMin);
Serial.Print ("\t establece nuevo max en:");
Serial.println(sensorMax);
digitalWrite (7, bajo);
}

void loop() {}
startstop();
Si (jaodernein == 1) {}
ReadIt();
MainCounter();
}
}

Esto espera un comando serie. Usted puede tipo en su consola de Monitor serie o utilizar el Software
Comandos:
: Para empezar
E: Para parar
L: Luces
K: Apagado de las luces
//
Si no desea utilizar este bucle reemplazar"vacío" con:
/*
void loop() {}
ReadIt();
MainCounter();
}
*/
void startstop() {}
Si (Serial.available() > 0) {}
leer el byte más antigua en el buffer de //Serial:
incomingByte = Serial.read();
Si (incomingByte == 'A') {/ / Anfang
jaodernein = 1;
Serial.println ("ARRA Visualisierung...");
}
Si (incomingByte == 'E') {/ / Ende
AllLedsOFF();
jaodernein = 0;
Serial.println ("trayecto Visualisierung...");
}
Si (incomingByte == 'L') {/ / Nur Lampe
jaodernein = 0;
digitalWrite (relayCh3, HIGH);

digitalWrite (relayCh2, HIGH);
Serial.println ("Licht un...");
}
Si (incomingByte == 'K') {/ / Keine Lampe
jaodernein = 0;
digitalWrite (relayCh3, bajo);
digitalWrite (relayCh2, bajo);
Serial.println ("Aus Licht...");
}
}
}

void ReadIt() {}
AudioIn = analogRead(sensorPin);
Si (AudioIn > sensorMax) {}
sensorMax = AudioIn;
}
Si (AudioIn < sensorMin) {}
sensorMin = AudioIn;
}
AudioIn = mapa (AudioIn, sensorMin, 1023, 0, sensorMax);
sensorValue = mapa (AudioIn, sensorMin, sensorMax, 0, 255);
sensorValue = restringir (sensorValue, 0, 255);
DelayValue = mapa (AudioIn, sensorMin, sensorMax, (AudioIn*3)/100,(AudioIn*10)/100);
}

void MainCounter() {}
Si (AudioIn == 0 || AudioIn < 50) {}
AllLedsOFF();
counterNull--;
counterEins--;
}
otra cosa
{
Si (updown == 0) {}
nextLED ++;
}
Si (updown == 1) {}
nextLED--;
}
Si (AudioIn > 50 & AudioIn < 100) {}
counterEins = counterEins + 2;
counterNull--;
counterZwei ++;
counterDrei ++;
}
Si (AudioIn > 100 & AudioIn < 200) {}
counterVier ++;
}
Si (AudioIn > 200 & AudioIn < 300) {}
counterFunf ++;
}
Si (AudioIn > 400 y AudioIn < 500) {}
counterSieben--;
}
Si (AudioIn > 500 y AudioIn < 700) {}
counterSieben = counterSieben + 3;
}
Si (AudioIn > 707) {}
digitalWrite (48, bajo);
}

Si (AudioIn < 200 & (counterFunf > counterVier) & (counterSechs < counterFunf) & (counterVier < counterDrei) || (schleifeEins < schleifeZwei & schleifeEins < schleifeDrei)) {
schleifeEins ++;
digitalWrite (notPWMLEDS [counterFunf], HIGH);

analogWrite (pwmLEDS [6], sensorValue);
digitalWrite (pwmLEDS [6], HIGH);
digitalWrite (48, bajo);
digitalWrite (ALLLEDS [nextLED], alto);
Si ((AudioIn > 333) & (counterNull == -64 || counterNull == -32)) {}
counterSieben = 0;
digitalWrite(relayCh2,HIGH);
counterSieben = 0;
LANGERdelay = 1;
}
Else {}
LANGERdelay = 0;
}

Si (LANGERdelay == 0) {}
Delay(DelayValue*2);
Delay(DelayValue);
}
Else {}
Delay(64+DelayValue);
LANGERdelay = 0;
}
}

Si ((counterFunf > counterVier || counterFunf < counterVier) || (schleifeZwei < schleifeEins & schleifeZwei < schleifeDrei)) {
schleifeZwei ++;
digitalWrite (notPWMLEDS [counterFunf], HIGH);
digitalWrite (ALLLEDS [1], alto);
analogWrite (pwmLEDS [counterSechs], sensorValue);
para (thisPin = sensorValue; thisPin > 0; thisPin--) {}
sensorValue = sensorValue-5;
}

Si ((AudioIn > 333) & (counterNull == -64 || counterNull == -16)) {}
counterSieben = 0;
digitalWrite(relayCh1,HIGH);
LANGERdelay = 1;
}
Else {}
LANGERdelay = 0;
}

Si (LANGERdelay == 0) {}
Delay(DelayValue);
}
Else {}
Delay(64+DelayValue);
LANGERdelay = 0;
}
}

Si ((AudioIn > 200) &(counterNull < counterEins) & (counterSechs < counterFunf) & (counterVier < counterDrei) || (schleifeDrei < schleifeEins & schleifeDrei < schleifeZwei)) {
digitalWrite (notPWMLEDS [counterFunf], HIGH);
schleifeDrei ++;
digitalWrite (ALLLEDS [2], alto);
digitalWrite (48, alto);
digitalWrite (pwmLEDS [6], LOW);
para (thisPin = 0; thisPin / / digitalWrite (notPWMLEDS [thisPin], HIGH);
Delay(DelayValue);
digitalWrite (notPWMLEDS [thisPin], LOW);

//     }
Si ((AudioIn > 333) & (counterNull == -64 || counterNull == -8)) {}
counterSieben = 0;
digitalWrite(relayCh3,HIGH);
LANGERdelay = 1;
}
Else {}
LANGERdelay = 0;
}

Si (LANGERdelay == 0) {}
Delay(DelayValue);
}
Else {}
Delay(64+DelayValue);
LANGERdelay = 0;
}
}

Si (nextLED > = ALLCOUNT) {}
UPDOWN = 1;
}
else if (nextLED < = 0) {}
UPDOWN = 0;
}
Si {} (counterZwei > 256)
counterSechs ++;
counterZwei = 0;
}
Si (counterDrei > 512) {}
counterDrei = 0;
schleifeEins = 0;
schleifeZwei = 0;
schleifeDrei = 0;
digitalWrite (pwmLEDS [6], HIGH);

}
Si {} (counterVier > 32)
counterVier = 0;
sensorMax = 0;
digitalWrite (48, alto);

}
Si (counterFunf > = notPWMCOUNT) {}
counterFunf = 0;
}
Si (counterSechs > = pwmCOUNT) {}
counterSechs = 0;
}
Si (counterNull > = 64 || counterEins > = 64 || counterNull < = -64 || counterEins < = -64) {}
counterNull = 0;
counterEins = 0;
}
}
}
void AllLedsOFF() {}
digitalWrite (relayCh1, bajo);
digitalWrite (relayCh2, bajo);
digitalWrite (relayCh3, bajo);

para (thisPin = 0; thisPin < ALLCOUNT; thisPin ++) {/ / inicializar en un bucle
digitalWrite (ALLLEDS [thisPin], LOW);
}
}