Arduino kontrollerade blinkande Fairy julbelysningen med Jingle Bells (7 / 12 steg)

Steg 7: Starta och stoppa med en knapp

• Mini tryckknapp
• 10 K ohm motstånd (färgmarkering: brun, svart, orange, guld)
• 3 * bygelstift
• USB-kabel

Koppla upp din knapp - The Arduino knappen tutorial finns här

1. Koppla USB från Arduino
2. Placera på knappen på bakbord mittlinje - du kommer att märka knappen passar ett sätt men inte det andra.
3. Ansluta ett av benen till den röda positiva linjen med hjälp av en bygel stift
4. Ansluta det 10K motståndet från det andra benet på samma sida, se till att det är parallellt med de röda och blå linjerna (se bilden ovan)
5. Anslut den andra sidan av motståndet blå negativa line
6. På andra sidan av knappen, Anslut benet på den på samma rad som motståndet till stift 2 på Arduino
7. Kopiera och klistra in koden i en ny Arduino fil
8. Anslut USB-kabeln till Arduino
9. Ladda upp filen

#define C 2100
#define D 1870
#define E 1670
#define f 1580 / / verkar inte gillar versalt F
#define G 1400
Definiera en särskild anmärkning, "R", som representerar en vila
#define R 0

// SETUP ============================================
Ställ in högtalare på en PWM stift (digital 9, 10 eller 11)
int speakerOut = 9;
int ledde = 13.
int buttonPin = 2;

void setup() {
pinMode (speakerOut, produktionen);
pinMode ledde (, OUTPUT);
pinMode (buttonPin, ingång);
}

KNAPPEN

Variabler som ändras:
int å = låg; det aktuella läget för utgångsstiftet
int buttonState; den nuvarande behandlingen från ingångsstiftet
int lastButtonState = låg; den föregående behandlingen från ingångsstiftet

följande variabler är lång eftersom tiden, i millisekunder,
kommer snabbt att bli ett större antal än kan lagras i en int.
lång lastDebounceTime = 0; sista gången utgångsstiftet var växlas
lång debounceDelay = 50; debounce tiden; öka om utdata flimrar

MELODI och TIMING ===
Melody [] är en matris av anteckningar, tillsammans med beats [],
som sätter varje ton relativa längd (högre #, längre anteckning)
int melodi [] = {E, E, E, R,
E, E, E, R,
E, G, C, D, E, R,
f, f, f, f, f, E, E, E, E, D, D, E, D, R, G, R,
E, E, E, R,
E, E, E, R,
E, G, C, D, E, R,
f, f, f, f, f, E, E, E, G, G, f, D, C, R};

int MAX_COUNT = sizeof(melody) / 2; Melody längd, för looping.

Ange övergripande tempo
långa tempo = 10000;
Ange längden på paus mellan anteckningar
int paus = 1000;
Loop variabel att öka resten längd
int rest_count = 30.

Initiera core variabler
int tone_ = 0;
int slå = 0;
lång varaktighet = 0;

// PLAY TONE ==============================================
Puls talaren att spela en ton för en viss varaktighet
void playTone() {
lång elapsed_time = 0;
om (tone_ > 0) {/ / om detta inte är en resten beat, medan tonen har
digitalWrite (ledde, högt);
spelat mindre långt än "varaktighet", puls högtalare hög och låg
medan (elapsed_time < varaktighet) {

digitalWrite(speakerOut,HIGH);
delayMicroseconds(tone_ / 2);

NED
digitalWrite (speakerOut, låg);
delayMicroseconds(tone_ / 2);

Hålla reda på hur länge vi pulsade
elapsed_time += (tone_);
}
digitalWrite (ledde, låg);

}
annat {/ / resten slå, loop gånger försenar
för (int j = 0; j < rest_count; j ++) {/ / se anmärkning på rest_count
delayMicroseconds(duration);
}
}
}

void jingleBells(int i) {
Ställ in en räknare för att dra från melody [] och [slag]
tone_ = melodi [i];
slå = 50;
längd = beat * tempo; Ställ in timing
playTone();
En paus mellan anteckningar...
delayMicroseconds(pause);
}

void checkOn (int läsning) {
Kontrollera om du bara tryckt på knappen
(dvs. indata gick från låg till hög), och du har väntat
tillräckligt länge sedan den senaste pressen att ignorera något buller:

Om växeln ändras, på grund av buller eller trycka:
om (läsa! = lastButtonState) {
nollställa debouncing timern
lastDebounceTime = millis();

växlar mellan variabeln ledState varje gång knappen trycks
om (buttonState == hög) {
on =!.
}
}

om ((millis()-lastDebounceTime) > debounceDelay) {
oavsett läsning är på, har det varit där för längre
än debounce förseningen, så ta det som det faktiska nuvarande läget:
buttonState = behandlingen.
}
}

LÅT VILDA BRÅK BÖRJA ===
void loop() {
Läs statligt av växeln till en lokal variabel:
int läsa = digitalRead(buttonPin);

checkOn(reading);

IF(on) {
för (int jag = 0; jag < MAX_COUNT; i ++) {
int loopReading = digitalRead(buttonPin);
jingleBells(i);
om (loopReading! = läsning) {
on =!.
bryta;
}
}
}

Spara behandlingen. Nästa gång genom öglan,
det blir lastButtonState:
lastButtonState = behandlingen.
}