* uppdaterad * LED-torn "Hej", Vu-mätare avancerad Sensing musik utan IC endast med Ardurino och gränssnitt med PC Windows Software!

Hej, alla.

Vad som gör detta projekt så cool är, som dess avkänning musik, till skillnad från traditionella
VU-mätare eller Equalizer som visar nivån av inkommande ljudet av byta LED är på,
Min LED Tower, ser ut som det vet när rasten eller släpp eller vad någonsin i låten är comnming.

Större lampor jag bygga i, blir bara på när musiken blir mer intensiv.
med Serial Monitor lyckades jag skriva en Windows App, som styr Ardurino, Needet att använda den
hål Tower som Main ljus för mitt vardagsrum.

Kolla in här:

Vad du behöver (Full Version):

-Ardurino Mega(Atmega1280)
-24 x blå LED
-14 x vita LED
-5 x Multicolor LED
-2 x grön LED
-2 X Bi-Color(Red/Blue) lysdioder
-2 x 40 w lampor
-2 x 12 volts LED-Spot LED
-2 x 5 volts relä
-1 X SMD röd matris
-45 x 220 Ohm motstånd
-Wire
-1 x 3,5 Audio Jack
-1 x A Styropor eller plexiglas kropp

Vad du behöver (basversion):

-Alla Ardurino Mikrocontroller med X stift!
-X LED
-X 220 Ohm motstånd
-Wire
-3,5 audio Jack
-Ett organ Styropor eller plexiglas

Kolla gärna in bilderna:

Hur fungerar det?

Om du någonsin gjort musik själv du, vet om längder av standart musik mönster, och
Det är nyckeln till detta, genom att räkna upp variabler och compering dem. (som 16,32,64,128,256,512 etc...)

Steg 1:

-Borra hål i kroppen Styropor eller plexiglas.
-Placera din lysdioder som du vill.

Steg 2:

-Tråd din lysdioder med motstånd och ansluta dem till någon gratis stift på din ardurino!.
-Anslut ett par lysdioder med pwm stift
-Testa din lysdioder med den grundläggande "Blink-Sketch"

Steg 3:

-Anslut en analog pin med audio domkraft och din Audio Källa
-Testa det med den grundläggande "AnalogRead-skissen"

Steg 4:

Öppna ardurino programvara till programm det.

Ladda upp denna kod och redigera matriser med din stift, och räkningen av stiften för att var.

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

PIN att sensorn är kopplad till analoga 14 i mitt fall
CONST int sensorPin = A14;

3 Main matrisens med LED stift
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}.

Detta är antalet LED Attaced till 3 matrisens
CONST int pwmCOUNT = 9;
CONST int ALLCOUNT = 22.
CONST int notPWMCOUNT = 15.

Detta är den särskilda Highlihts i samband med ett relä
CONST int relayCh1 = 14. 2 x 40 w lampor
CONST int relayCh2 = 15. 2 x 12 volts LED-Spot LED
CONST int relayCh3 = 17; Licht 3

variabler:
int incomingByte,jaodernein,schleifeEins,schleifeZwei,schleifeDrei,sensorMax,sensorValue,AudioIn,LANGERdelay,DelayValue,counterNull,counterEins,counterZwei,counterDrei,counterVier,counterFunf,counterSechs,counterSieben,nextLED,updown,thisPin = 0; sensor värdet
int sensorMin = 1023; minsta sensorn värde

void setup() {
Konfigurerar den referensspänningen används för analog ingång
analogReference(INTERNAL1V1);
Serial.BEGIN(9600);
Serial.println ("LED TOWER"Hej"av Mhonolog v: 13,5");

pinMode (relayCh1, produktionen);
pinMode (relayCh2, produktionen);
pinMode (relayCh3, produktionen);
pinMode (48, OUTPUT);
för (thisPin = 0; thisPin < ALLCOUNT; thisPin ++) {
pinMode (ALLLEDS [thisPin], OUTPUT);
}
Serial.println("calibrateing...");
digitalWrite (7, hög).
samtidigt (millis() < 5000) {
sensorValue = analogRead(sensorPin);
om (sensorValue > sensorMax) {
sensorMax = sensorValue;
}
om (sensorValue < sensorMin) {
sensorMin = sensorValue;
}
}
Serial.Print ("inställd på nytt min:");
Serial.Print(sensorMin);
Serial.Print ("\t inställd nya max:");
Serial.println(sensorMax);
digitalWrite (7, låg).
}

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

Här väntar ett seriella kommando. Du kan skriva in din seriekonsoll Monitor eller använda min programvara
Kommandon:
A: För Start
E: För stopp
L: Lamporna på
K: Lights OFF
//
vill du inte använda denna Ersätt "void-loop" med:
/*
void loop() {
ReadIt();
MainCounter();
}
*/
void startstop() {
om (Serial.available() > 0) {
Läs den äldsta byten i //Serial buffert:
incomingByte = Serial.read();
om (incomingByte == "A") {/ / Anfang
jaodernein = 1;
Serial.println ("startat Visualisierung...");
}
om (incomingByte == "E") {/ / Ende
AllLedsOFF();
jaodernein = 0;
Serial.println ("Stoppe Visualisierung...");
}
om (incomingByte == "L") {/ / Nur Lampe
jaodernein = 0;
digitalWrite (relayCh3, hög);

digitalWrite (relayCh2, hög);
Serial.println ("Licht en...");
}
om (incomingByte == "K") {/ / Keine Lampe
jaodernein = 0;
digitalWrite (relayCh3, låg);
digitalWrite (relayCh2, låg);
Serial.println ("Aus Licht...");
}
}
}

void ReadIt() {
AudioIn = analogRead(sensorPin);
om (AudioIn > sensorMax) {
sensorMax = AudioIn;
}
om (AudioIn < sensorMin) {
sensorMin = AudioIn;
}
AudioIn = karta (AudioIn, sensorMin, 1023, 0, sensorMax);
sensorValue = karta (AudioIn, sensorMin, sensorMax, 0, 255);
sensorValue = begränsa (sensorValue, 0, 255);
DelayValue = karta (AudioIn, sensorMin, sensorMax, (AudioIn*3)/100,(AudioIn*10)/100);
}

void MainCounter() {
om (AudioIn == 0 || AudioIn < 50) {
AllLedsOFF();
counterNull--;
counterEins--;
}
annat
{
om (updown == 0) {
nextLED ++;
}
om (updown == 1) {
nextLED--;
}
om (AudioIn > 50 & AudioIn < 100) {
counterEins = counterEins + 2.
counterNull--;
counterZwei ++;
counterDrei ++;
}
om (AudioIn > 100 & AudioIn < 200) {
counterVier ++;
}
om (AudioIn > 200 & AudioIn < 300) {
counterFunf ++;
}
om (AudioIn > 400 & AudioIn < 500) {
counterSieben--;
}
om (AudioIn > 500 & AudioIn < 700) {
counterSieben = counterSieben + 3.
}
om (AudioIn > 707) {
digitalWrite (48, låg).
}

om (AudioIn < 200 & (counterFunf > counterVier) & (counterSechs < counterFunf) & (counterVier < counterDrei) || (schleifeEins < schleifeZwei & schleifeEins < schleifeDrei)) {
schleifeEins ++;
digitalWrite (notPWMLEDS [counterFunf], hög);

analogWrite (pwmLEDS [6], sensorValue);
digitalWrite (pwmLEDS [6], hög);
digitalWrite (48, låg).
digitalWrite (ALLLEDS [nextLED], hög);
om ((AudioIn > 333) & (counterNull ==-64 || counterNull == -32)) {
counterSieben = 0;
digitalWrite(relayCh2,HIGH);
counterSieben = 0;
LANGERdelay = 1;
}
annat {
LANGERdelay = 0;
}

om (LANGERdelay == 0) {
Delay(DelayValue*2);
Delay(DelayValue);
}
annat {
Delay(64+DelayValue);
LANGERdelay = 0;
}
}

om ((counterFunf > counterVier || counterFunf < counterVier) || (schleifeZwei < schleifeEins & schleifeZwei < schleifeDrei)) {
schleifeZwei ++;
digitalWrite (notPWMLEDS [counterFunf], hög);
digitalWrite (ALLLEDS [1], hög);
analogWrite (pwmLEDS [counterSechs], sensorValue);
för (thisPin = sensorValue; thisPin > 0; thisPin--) {
sensorValue = sensorValue-5;
}

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

om (LANGERdelay == 0) {
Delay(DelayValue);
}
annat {
Delay(64+DelayValue);
LANGERdelay = 0;
}
}

om ((AudioIn > 200) &(counterNull < counterEins) & (counterSechs < counterFunf) & (counterVier < counterDrei) || (schleifeDrei < schleifeEins & schleifeDrei < schleifeZwei)) {
digitalWrite (notPWMLEDS [counterFunf], hög);
schleifeDrei ++;
digitalWrite (ALLLEDS [2], hög);
digitalWrite (48, hög).
digitalWrite (pwmLEDS [6], låg);
för (thisPin = 0; thisPin / / digitalWrite (notPWMLEDS [thisPin], hög);
Delay(DelayValue);
digitalWrite (notPWMLEDS [thisPin], låg);

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

om (LANGERdelay == 0) {
Delay(DelayValue);
}
annat {
Delay(64+DelayValue);
LANGERdelay = 0;
}
}

om (nextLED > = ALLCOUNT) {
UpDown = 1;
}
annars om (nextLED < = 0) {
UpDown = 0;
}
om (counterZwei > 256) {
counterSechs ++;
counterZwei = 0;
}
om (counterDrei > 512) {
counterDrei = 0;
schleifeEins = 0;
schleifeZwei = 0;
schleifeDrei = 0;
digitalWrite (pwmLEDS [6], hög);

}
om (counterVier > 32) {
counterVier = 0;
sensorMax = 0;
digitalWrite (48, hög).

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

för (thisPin = 0; thisPin < ALLCOUNT; thisPin ++) {/ / initiera alla i en loop
digitalWrite (ALLLEDS [thisPin], låg);
}
}