* aktualisiert * LED-Tower "Hello", Vu-Meter Advanced Sensing Musik ohne IC nur mit Ardurino und Schnittstellen mit PC-Windows-Software!

Die größere Lichter, ich baue in, wird nur auf, wenn die Musik immer mehr Intensiv.
mit Serial Monitor ich es geschafft, eine Windows-Anwendung, die Steuerelemente Ardurino benötigte verwenden schreiben die
Loch-Turm als Main Licht für mein Wohnzimmer.

Schauen Sie sich hier:

Was Sie benötigen (Vollversion):

-Ardurino Mega(Atmega1280)
-24 x blaue LED
-14 x weiße LED
-5 x Multicolor LED
-2 x grüne LED
-2 X Bi-Color(Red/Blue) LED's
-2 x 40 Watt Lampen
-2 x 12 Volt LED-Spot LED
-2 x 5 Volt Relais
-1 X SMD Red Matrix
-45 x 220 Ohm Widerstände
-Draht
-1 x 3,5 Audio Jack
-1 x A Styropor oder Plexiglas Körper

Was Sie benötigen (Basisversion):

-Jede Ardurino Mikrocontroller mit X Pins!
-X LED
-X 220 Ohm Widerstände
-Draht
-3,5 Audio Jack
-Ein Styropor oder Plexiglas Körper

Bitte schaut euch die Bilder:

Wie funktioniert es?

Wenn Sie schon einmal Musik gemacht selbst, kennen Sie die Längen der Standart Musik Muster und
Das ist der Schlüssel dazu, indem Sie Variablen gezählt und compering sie. (wie 16,32,64,128,256,512 Etc...)

Schritt 1:

-Bohren Sie die Löcher im Styropor oder Plexiglas Körper.
-Legen Sie Ihre LEDS wie Sie wollen.

Schritt 2:

-Draht Ihre LEDs mit Widerständen und schließen Sie sie an jedem freien Pin auf Ihre Ardurino!.
-ein paar LEDS mit Pwm Pins zu verbinden
-Testen Sie Ihre LEDs mit der grundlegenden "Blink-Skizze"

Schritt 3:

-verbinden Sie eine analoge Pin mit der Audiobuchse und Ihre Audio-Quelle
-Testen Sie es mit der grundlegenden "AnalogRead-Skizze"

Schritt 4:

Öffnen Sie Ardurino Software zu programmieren sie.

dieser Code hochladen und Bearbeiten von Arrays mit Ihre Pins und die Anzahl der Pins, die var.

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

PIN, dass der Sensor analog 14 in meinem Fall angebracht ist
const Int SensorPin = A14;

3 Main des Arrays mit LED-pins
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};

Dies sind die Anzahl der LED außen auf das 3-Array
const Int PwmCOUNT = 9;
const Int ALLCOUNT = 22;
const Int NotPWMCOUNT = 15;

Dies sind die besonderen Highlights verbunden mit einem Relais
const Int relayCh1 = 14;   2 x 40 Watt Lampen
const Int relayCh2 = 15;   2 x 12 Volt LED-Spot LED
const Int relayCh3 = 17;    Licht 3

Variablen:
int incomingByte,jaodernein,schleifeEins,schleifeZwei,schleifeDrei,sensorMax,sensorValue,AudioIn,LANGERdelay,DelayValue,counterNull,counterEins,counterZwei,counterDrei,counterVier,counterFunf,counterSechs,counterSieben,nextLED,updown,thisPin = 0;         der Sensorwert
Int SensorMin = 1023;        minimale Sensorwert

void setup() {}
Konfiguriert die Referenzspannung verwendet für Analogeingang
analogReference(INTERNAL1V1);
Serial.Begin(9600);
Serial.println ("LED-TOWER 'Hallo' von Mhonolog v: 13,5");

PinMode (relayCh1, Ausgang);
PinMode (relayCh2, Ausgang);
PinMode (relayCh3, Ausgang);
PinMode (48, OUTPUT);
für (ThisPin = 0; ThisPin < ALLCOUNT; ThisPin ++) {}
PinMode (ALLLEDS [ThisPin], OUTPUT);
}
Serial.println("calibrateing...");
DigitalWrite (7, HIGH);
während (millis() < 5000) {}
SensorValue = analogRead(sensorPin);
Wenn (SensorValue > SensorMax) {}
SensorMax = SensorValue;
}
Wenn (SensorValue < SensorMin) {}
SensorMin = SensorValue;
}
}
Serial.Print ("legen Sie neue min. auf:");
Serial.Print(sensorMin);
Serial.Print ("\t neue Max gesetzt:");
Serial.println(sensorMax);
DigitalWrite (7, LOW);
}

void loop() {}
startstop();
Wenn (Jaodernein == 1) {}
ReadIt();
MainCounter();
}
}

Dies wartet auf einen seriellen Befehl. Sie können geben Sie Ihre seriellen Monitor-Konsole oder meine Software
Befehle:
A: Für Start
E: Für Stop
L: Leuchtet auf
K: Licht aus
//
Wenn Sie nicht möchten dieses ersetzen "leere-Loop" mit:
/*
void loop() {}
ReadIt();
MainCounter();
}
*/
void startstop() {}
Wenn (Serial.available() > 0) {}
das älteste Byte in den //Serial-Puffer zu lesen:
IncomingByte = Serial.read();
Wenn (IncomingByte == 'A') {/ / Anfang
Jaodernein = 1;
Serial.println ("Starte Visualisierung...");
}
Wenn (IncomingByte == 'E') {/ / Ende
AllLedsOFF();
Jaodernein = 0;
Serial.println ("Abkürzungknöpfe Visualisierung...");
}
Wenn (IncomingByte == 'L') {/ / Nur Lampe
Jaodernein = 0;
DigitalWrite (relayCh3, HIGH);

DigitalWrite (relayCh2, HIGH);
Serial.println ("Licht eine...");
}
Wenn (IncomingByte == 'K') {/ / Keine Lampe
Jaodernein = 0;
DigitalWrite (relayCh3, LOW);
DigitalWrite (relayCh2, LOW);
Serial.println ("Licht Aus...");
}
}
}

void ReadIt() {}
AudioIn = analogRead(sensorPin);
Wenn (AudioIn > SensorMax) {}
SensorMax = AudioIn;
}
Wenn (AudioIn < SensorMin) {}
SensorMin = AudioIn;
}
AudioIn = Karte (AudioIn, SensorMin, 1023, 0, SensorMax);
SensorValue = Karte (AudioIn, SensorMin, SensorMax, 0, 255);
SensorValue = (SensorValue, 0, 255) beschränken;
DelayValue = Karte (AudioIn, SensorMin, SensorMax, (AudioIn*3)/100,(AudioIn*10)/100);
}

void MainCounter() {}
Wenn (AudioIn == 0 || AudioIn < 50) {}
AllLedsOFF();
CounterNull--;
CounterEins--;
}
anderes
{
Wenn (Updown == 0) {}
NextLED ++;
}
Wenn (Updown == 1) {}
NextLED--;
}
Wenn (AudioIn > 50 & AudioIn < 100) {}
CounterEins = CounterEins + 2;
CounterNull--;
CounterZwei ++;
CounterDrei ++;
}
Wenn (AudioIn > 100 & AudioIn < 200) {}
CounterVier ++;
}
Wenn (AudioIn > 200 & AudioIn < 300) {}
CounterFunf ++;
}
Wenn (AudioIn > 400 & AudioIn < 500) {}
CounterSieben--;
}
Wenn (AudioIn > 500 & AudioIn < 700) {}
CounterSieben = CounterSieben + 3;
}
Wenn (AudioIn > 707) {}
DigitalWrite (48, LOW);
}

Wenn (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, LOW);
DigitalWrite (ALLLEDS [NextLED], hoch);
Wenn ((AudioIn > 333) & (CounterNull ==-64 || CounterNull ==-32)) {}
CounterSieben = 0;
digitalWrite(relayCh2,HIGH);
CounterSieben = 0;
LANGERdelay = 1;
}
Else {}
LANGERdelay = 0;
}

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

Wenn ((CounterFunf > CounterVier || CounterFunf < CounterVier) || (SchleifeZwei < SchleifeEins & SchleifeZwei < SchleifeDrei)) {
SchleifeZwei ++;
DigitalWrite (NotPWMLEDS [CounterFunf], HIGH);
DigitalWrite (ALLLEDS [1], hoch);
AnalogWrite (PwmLEDS [CounterSechs], SensorValue);
für (ThisPin = ThisPin--, SensorValue; ThisPin > 0) {}
SensorValue = SensorValue-5;
}

Wenn ((AudioIn > 333) & (CounterNull ==-64 || CounterNull ==-16)) {}
CounterSieben = 0;
digitalWrite(relayCh1,HIGH);
LANGERdelay = 1;
}
Else {}
LANGERdelay = 0;
}

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

Wenn ((AudioIn > 200) &(counterNull < counterEins) & (CounterSechs < CounterFunf) & (CounterVier < CounterDrei) || (SchleifeDrei < SchleifeEins & SchleifeDrei < SchleifeZwei)) {
DigitalWrite (NotPWMLEDS [CounterFunf], HIGH);
SchleifeDrei ++;
DigitalWrite (ALLLEDS [2], hoch);
DigitalWrite (48, HIGH);
DigitalWrite (PwmLEDS [6], LOW);
für (ThisPin = 0; ThisPin / / DigitalWrite (NotPWMLEDS [ThisPin], HIGH);
Delay(DelayValue);
DigitalWrite (NotPWMLEDS [ThisPin], LOW);

//     }
Wenn ((AudioIn > 333) & (CounterNull ==-64 || CounterNull ==-8)) {}
CounterSieben = 0;
digitalWrite(relayCh3,HIGH);
LANGERdelay = 1;
}
Else {}
LANGERdelay = 0;
}

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

Wenn (NextLED > = ALLCOUNT) {}
UpDown = 1;
}
ElseIf (NextLED < = 0) {}
UpDown = 0;
}
Wenn (CounterZwei > 256) {}
CounterSechs ++;
CounterZwei = 0;
}
Wenn (CounterDrei > 512) {}
CounterDrei = 0;
SchleifeEins = 0;
SchleifeZwei = 0;
SchleifeDrei = 0;
DigitalWrite (PwmLEDS [6], HIGH);

}
Wenn (CounterVier > 32) {}
CounterVier = 0;
SensorMax = 0;
DigitalWrite (48, HIGH);

}
Wenn (CounterFunf > = NotPWMCOUNT) {}
CounterFunf = 0;
}
Wenn (CounterSechs > = PwmCOUNT) {}
CounterSechs = 0;
}
Wenn (CounterNull > = 64 || CounterEins > = 64 || CounterNull < =-64 || CounterEins < =-64) {}
CounterNull = 0;
CounterEins = 0;
}
}
}
void AllLedsOFF() {}
DigitalWrite (relayCh1, LOW);
DigitalWrite (relayCh2, LOW);
DigitalWrite (relayCh3, LOW);

für (ThisPin = 0; ThisPin < ALLCOUNT; ThisPin ++) {/ / alle in einer Schleife initialisieren
DigitalWrite (ALLLEDS [ThisPin], LOW);
}
}