* bijgewerkt * LED-toren "Hello", Vu-Meter geavanceerde Sensing muziek zonder IC's alleen met Ardurino en Interfacing met PC-Software voor Windows!

De grotere lichten ik bouwen, krijgt alleen op wanneer de muziek steeds meer intensiv.
met seriële Monitor ik erin geslaagd om het schrijven van een Windows App, die besturingselementen-Ardurino, Needet om te gebruiken het
gat toren als Main licht voor mijn woonkamer.

Bekijk het hier:

Wat u moet (Full Version):

-Ardurino Mega(Atmega1280)
-24 x blauwe LED's
-14 x witte LED's
-5 x Multicolor LED's
-2 x groene LED's
-2 X Bi-Color(Red/Blue) LED's
-2 x 40 Watt lampen
-2 x 12 Volt LED-Spot LED's
-2 x 5 Volt estafette
-1 X SMD rode Matrix
-45 x 220 Ohm weerstanden
-Draad
-1 x 3,5 Audio Jack
-1 x A Styropor of plexiglas lichaam

Wat u moet (Basic Version):

-Elke Ardurino Mikrocontrollers met X pinnen!
-X LED's
-X 220 Ohm weerstanden
-Draad
-3,5 audio Jack
-Een Styropor of plexiglas lichaam

Kijk de foto's:

Hoe het werkt?

Als u ooit muziek gemaakt zelf u weten over de lengte van de standart muziek patroon, en
dat is de sleutel tot dit, door het tellen van variabelen en compering hen. (zoals 16,32,64,128,256,512 enz...)

Stap 1:

-Het boren van gaten in je lichaam Styropor of plexiglas.
-Plaats uw LEDS zoals u wilt.

Stap 2:

-Draad uw LEDs met weerstanden en hen verbinden met een gratis pin op uw ardurino!.
-verbinding maken met een aantal LEDS met pwm pinnen
-Test uw LEDs met de fundamentele "Blink-schets"

Stap 3:

-een analoge pin verbinden met de audio-aansluiting en uw Audio-bron
-Testen met de fundamentele "AnalogRead-schets"

Stap 4:

ardurino software om het programma te openen het.

Deze code uploaden en bewerken van de Arrays met uw pins, en het aantal pinnen aan de var.

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

PIN of de sensor is aangesloten op de analoge 14 in mijn geval
Const int sensorPin = A14;

de 3 belangrijkste matrix met LED pinnen
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};

Dit zijn het aantal LED Attaced aan de 3 matrix
Const int pwmCOUNT = 9;
Const int ALLCOUNT = 22;
Const int notPWMCOUNT = 15;

Dit zijn de speciale Highlihts die verband houden met een Relais
Const int relayCh1 = 14;   2 x 40 Watt lampen
Const int relayCh2 = 15;   2 x 12 Volt LED-Spot LED's
Const int relayCh3 = 17;    licht 3

variabelen:
int incomingByte,jaodernein,schleifeEins,schleifeZwei,schleifeDrei,sensorMax,sensorValue,AudioIn,LANGERdelay,DelayValue,counterNull,counterEins,counterZwei,counterDrei,counterVier,counterFunf,counterSechs,counterSieben,nextLED,updown,thisPin = 0;         de waarde van de sensor
int sensorMin = 1023;        minimale sensor waarde

VOID Setup {}
Hiermee configureert u de spanning van de verwijzing gebruikt voor analoge ingang
analogReference(INTERNAL1V1);
Serial.begin(9600);
Serial.println ("LED TOWER 'Hello' door Mhonolog v: 13,5");

pinMode (relayCh1, OUTPUT);
pinMode (relayCh2, OUTPUT);
pinMode (relayCh3, OUTPUT);
pinMode (48, OUTPUT);
voor (thisPin = 0; thisPin < ALLCOUNT; thisPin ++) {}
pinMode (ALLLEDS [thisPin], uitvoer);
}
Serial.println("calibrateing...");
digitalWrite (7, hoge);
terwijl (millis() < 5000) {}
sensorValue = analogRead(sensorPin);
Als (sensorValue > sensorMax) {}
sensorMax = sensorValue;
}
Als (sensorValue < sensorMin) {}
sensorMin = sensorValue;
}
}
Serial.Print ("nieuwe min ingesteld op:");
Serial.Print(sensorMin);
Serial.Print ("\t nieuwe max instellen:");
Serial.println(sensorMax);
digitalWrite (7, laag);
}

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

Dit wacht op een seriële commando. U kunt Type in uw seriële Console met Monitor of mijn Software te gebruiken
Commando's:
A: Voor de Start
E: Voor Stop
L: Lichten op
K: Lichten uit
//
Als u niet gebruiken deze vervangen "leegte-loop" wilt met:
/*
void loop {}
ReadIt();
MainCounter();
}
*/
ongeldig startstop() {}
Als (Serial.available() > 0) {}
Lees de oudste bytes in de buffer van de //Serial:
incomingByte = Serial.read();
Als (incomingByte == 'A') {/ / Anfang
jaodernein = 1;
Serial.println ("Starte Visualisierung...");
}
Als (incomingByte == 'E') {/ / Ende
AllLedsOFF();
jaodernein = 0;
Serial.println ("Stoppe Visualisierung...");
}
Als (incomingByte == 'L') {/ / Nur Lampe
jaodernein = 0;
digitalWrite (relayCh3, hoge);

digitalWrite (relayCh2, hoge);
Serial.println ("Licht een...");
}
Als (incomingByte == 'K') {/ / Keine Lampe
jaodernein = 0;
digitalWrite (relayCh3, laag);
digitalWrite (relayCh2, laag);
Serial.println ("Licht Aus...");
}
}
}

VOID ReadIt() {}
AudioIn = analogRead(sensorPin);
Als (AudioIn > sensorMax) {}
sensorMax = AudioIn;
}
Als (AudioIn < sensorMin) {}
sensorMin = AudioIn;
}
AudioIn = kaart (AudioIn, sensorMin, 1023, 0, sensorMax);
sensorValue = kaart (AudioIn, sensorMin, sensorMax, 0, 255);
sensorValue = beperken (sensorValue, 0, 255);
DelayValue = kaart (AudioIn, sensorMin, sensorMax, (AudioIn*3)/100,(AudioIn*10)/100);
}

VOID MainCounter() {}
Als (AudioIn == 0 || AudioIn < 50) {}
AllLedsOFF();
counterNull--;
counterEins--;
}
anders
{
Als (updown == 0) {}
nextLED ++;
}
Als (updown == 1) {}
nextLED--;
}
Als (AudioIn > 50 & AudioIn < 100) {}
counterEins = counterEins + 2;
counterNull--;
counterZwei ++;
counterDrei ++;
}
Als (AudioIn > 100 & AudioIn < 200) {}
counterVier ++;
}
Als (AudioIn > 200 & AudioIn < 300) {}
counterFunf ++;
}
Als (AudioIn > 400 & AudioIn < 500) {}
counterSieben--;
}
Als (AudioIn > 500 & AudioIn < 700) {}
counterSieben = counterSieben + 3;
}
Als (AudioIn > 707) {}
digitalWrite (48, laag);
}

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

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

Als (LANGERdelay == 0) {}
delay(DelayValue*2);
delay(DelayValue);
}
else {}
delay(64+DelayValue);
LANGERdelay = 0;
}
}

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

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

Als (LANGERdelay == 0) {}
delay(DelayValue);
}
else {}
delay(64+DelayValue);
LANGERdelay = 0;
}
}

Als ((AudioIn > 200) &(counterNull < counterEins) & (counterSechs < counterFunf) & (counterVier < counterDrei) || (schleifeDrei < schleifeEins & schleifeDrei < schleifeZwei)) {
digitalWrite (notPWMLEDS [counterFunf], hoge);
schleifeDrei ++;
digitalWrite (ALLLEDS [2], hoge);
digitalWrite (48, hoge);
digitalWrite (pwmLEDS [6], laag);
voor (thisPin = 0; thisPin / / digitalWrite (notPWMLEDS [thisPin], hoge);
delay(DelayValue);
digitalWrite (notPWMLEDS [thisPin], laag);

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

Als (LANGERdelay == 0) {}
delay(DelayValue);
}
else {}
delay(64+DelayValue);
LANGERdelay = 0;
}
}

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

}
Als (counterVier > 32) {}
counterVier = 0;
sensorMax = 0;
digitalWrite (48, hoge);

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

voor (thisPin = 0; thisPin < ALLCOUNT; thisPin ++) {/ / initialiseren in een lus
digitalWrite (ALLLEDS [thisPin], laag);
}
}