Stap 2: Code
Om de zoemer om daar te werken twee telefoontjes die u moet zijn: tone() en noTone().
Als een snelle notitie verstoort de tone() functie het PWM-uitgang op pinnen 3 en 11 behalve op de Mega.
De functie-definitie van Toon is:
Toon (pin, frequentie) of Toon (pin, frequentie, duur)
Als u de duur niet opgeeft dat de Toon zal blijven spelen tot wordt de noTone()-functie aangeroepen
toegepast op de pin. De functie-definitie van noTone() is gewoon noTone(pin).
Kunt u slechts één Toon op de pin spelen tegelijk, dit was geen probleem voor ons omdat
We gebruikten alleen één Toon per been.
Onze oorspronkelijke idee was om elk been gebruiken voor een verschillende nota in de toonsoort C en hebben
een hele octive. Helaas, we gebruikten niet alle 8 poten voor dit maar met de
juiste hardware u gewoon moet zou een paar mall wijzigingen aanbrengen in de code hieronder
dat die werken.
Er is een mooi headerbestand dat deel uitmaakt van de arduino-pakket waarin
alle frequenties aan de corresponderende Noteer naam. Zodra dit headerbestand is
inclusief alle u hoeft te doen is bellen NOTE_C4 dat de zoemer spelen centrale C of
wenst u een scherpe u enkel plaatst de ' tussen de opmerking naam en nummer d.w.z.
NOTE_GS4.
In onze code hieronder zult u merken dat wij een analoge pin voor één van gebruikt de
knoppen been. We moesten doen dit op basis van de lillypad lay-out evenals het totaal
het aantal pinnen die we gebruikten. We moesten een paar kleine hacks om dit te doen
werken als de digitale pennen die u gewoon controleren kunt om te zien of de pin hoog of laag terwijl is
de analoge uitgangen zijn spanning.
Voor elk been is er een knop en een licht. Wanneer de knop wordt ingedrukt de toegewezen
Opmerking wordt geactiveerd via de correcte pin en speelt via de zoemer evenals
Als de LED in de verlichting van de been omhoog.
Als je het eerste deel van wint speelt de Beatles Octopus's Garden gevolgd door
de letter V. Het liedje werd gedaan door de notities in een matrix te plaatsen en via een lus
deze array wanneer de tijd rijp is.
Het spel is relatief eenvoudig. Aan het begin van elke cyclus controleren we alle knoppen
om te zien als een van hen worden ingedrukt. We deden dit met aanroepen van digitalRead(). Wij vervolgens lus' '
via de knoppen en als er een knop die actief zetten we een variabele die
de meest recente pin worden opgeslagen. Wij gewoon controleren achter elkaar dus als je had een spelden
1 en 4 ingedrukt op hetzelfde moment die het zou de variabele ingesteld op pin 4.
We nemen die informatie en het overgaan in een instructie switch die activeert
het licht en geluid is gekoppeld aan de knop ingedrukt. Vanwege de manier waarop wij
Stel het alles zal niet meerdere benen licht of meerdere geluiden afspelen. Dat
zou een aardige verbetering aan dit project. Als u toegevoegd 3 zoemers kun je
spelen basis akkoorden van primaire en secundaire door te drukken op verschillende poten. Dit zou daaraan willen toevoegen een
Real-time muziek maken aspect aan de octopus. Ook met 8 poten hebt u alle
de notities die u moeten zou fundamentele om nummers te spelen in de sleutel van C.
Voor het spel aspect van de code na elke iteratie door de hoofdlus controleren we
dat we in de simon-modus en dat de status van de knop veranderd (een knop was geweest
ingedrukt). Het controleert de knop-waarde en vergelijkt het met de waarde die is opgeslagen in een array
die beschrijving van het spel reeks tot nu toe. Als de waarden het overeenkomen voegt een nieuwe waarde
aan het einde van de sequentie en speelt de hele bijgewerkt volgorde vanaf het begin.
Als de waarden niet overeenkomen met het treedt in de 'U verliezen' lus die een verliezer speelt
licht van de reeks en stelt opnieuw in het spel.
#include "pitches.h"
int modus = 0; 0-Simon... 1-geluiden/lights
Const int leg0B = A4;
Const int leg0L = 13;
Const int leg1B = 2;
Const int leg1L = 3;
Const int leg2B = 12;
Const int leg2L = 11;
Const int leg3B = 6;
Const int leg3L = 7;
Const int soundPin = 9;
int buttonState0 = 0;
int buttonState1 = 0;
int buttonState2 = 0;
int buttonState3 = 0;
int pauseBetweenNotes = 300;
int playTime = 500; bij het afspelen van de simon-volgorde
int pinsUsed = 4;
int lastPin = 0;
int currentPin = -1;
int lastLight = 0;
Const int maxTurns = 50;
int spel [maxTurns];
int draaien = 0;
int arrayCounter = 0;
Const int turnsToWin = 4;
unsigned long loseTime;
unsigned long currentTime;
unsigned long delayAllowed = 10000; Druk op een knop binnen 4 seconden of je verliest
noten in de melodie:
Scherpe F G C D
int melodie [] {} =
NOTE_B4, NOTE_B4, NOTE_CS4, NOTE_B4, NOTE_B0,
NOTE_GS4, NOTE_GS4, NOTE_A4, NOTE_GS4,
NOTE_GS4, NOTE_FS4, NOTE_E4, NOTE_E4, NOTE_E4,
NOTE_CS4, NOTE_B4, NOTE_GS4, NOTE_E4, NOTE_GS4,
NOTE_FS4
};
Opmerking de duur: 4 = kwartnoot, 8 = achtste noot, enz.:
int noteDurations [] {} =
4, 4, 4, 1, 4,
4, 4, 4, 1,
8, 8, 4, 4, 4,
4, 4, 2, 8, 8, 1};
VOID Setup {}
/*
voor (int thisNote = 0; thisNote < 20; thisNote ++) {}
voor het berekenen van de duur van de opmerking, neem één seconde
gedeeld door het type opmerking.
bijvoorbeeld kwartnoot = 1000 / 4, achtste noot = 1000/8, enz.
int noteDuration = 1000/noteDurations [thisNote];
Toon (soundPin, melody[thisNote],noteDuration);
om te onderscheiden van de notities, stel een minimuminterval tussen hen.
de nota's duur + 30% schijnt goed te werken:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
Stop het afspelen van de Toon:
noTone(soundPin);
}
*/
Serial.begin(9600);
Millis(); Initialiseer de legxB-pinnen als een input:
pinMode (leg0B, INPUT);
pinMode (leg1B, INPUT);
pinMode (leg2B, INPUT);
pinMode (leg3B, INPUT);
pinMode (leg4B, INPUT);
pinMode (leg5B, INPUT);
pinMode (leg6B, INPUT);
pinMode (leg7B, INPUT);
Initialiseer de LEDs als uitgang:
pinMode (leg0L, OUTPUT);
pinMode (leg1L, OUTPUT);
pinMode (leg2L, OUTPUT);
pinMode (leg3L, OUTPUT);
pinMode (leg4L, OUTPUT);
pinMode (leg5L, OUTPUT);
pinMode (leg6L, OUTPUT);
pinMode (leg7L, OUTPUT);
Initialiseer de correcte pin als output:
pinMode (soundPin, OUTPUT);
om te onderscheiden van de notities, stel een minimuminterval tussen hen.
de nota's duur + 30% schijnt goed te werken:
int pauseBetweenNotes = noteDuration * 1.30;
spel [0] = -1;
}
void loop {}
detecteren van de knop ingedrukt
buttonState0 = analogRead(leg0B);
Serial.println(buttonState0);
buttonState1 = digitalRead(leg1B);
buttonState2 = digitalRead(leg2B);
buttonState3 = digitalRead(leg3B);
/*
buttonState4 = digitalRead(leg4B);
buttonState5 = digitalRead(leg5B);
buttonState6 = digitalRead(leg6B);
buttonState7 = digitalRead(leg7B);
*/
var gebaseerd op de ingedrukte knop instellen
currentPin = -1; -1 als geen knoppen
if(buttonState0 == High)
if(buttonState0 > 200)
currentPin = 0;
if(buttonState1 == High)
currentPin = 1;
if(buttonState2 == High)
currentPin = 2;
if(buttonState3 == High)
currentPin = 3;
Serial.println(currentPin);
/*
if(buttonState4 == High)
currentPin = 4;
if(buttonState5 == High)
currentPin = 5;
if(buttonState6 == High)
currentPin = 6;
if(buttonState7 == High)
currentPin = 7;
*/
currentTime = millis();
loseTime = millis() + delayAllowed;
Als (modus == 0 & & currentTime > loseTime)
{
gameLost(0);
}
Als (modus == 0 & & spel [0] == -1)
{
Serial.println ("START spel");
Draai = 0;
addRound();
}
Als (currentPin! = lastPin)
{
digitalWrite (lastLight, laag);
Als (modus == 0 & & currentPin! = -1) //simon-modus
{
Als (spel [arrayCounter]! = currentPin)
{
gameLost(1);
currentPin = -1;
}
anders
{
arrayCounter ++;
currentTime = millis();
loseTime = millis() + delayAllowed;
}
}
schakelaar (currentPin) {}
Case -1:
noTone(soundPin);
Serial.println ("case -1");
breken;
Case 0:
Serial.println ("0 case");
geluid in been 0 evenals licht op het been
digitalWrite (leg0L, hoge);
lastLight = leg0L;
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
breken;
Case 1:
Serial.println ("case 1");
geluid in 1 been, alsmede licht op het been
digitalWrite (leg1L, hoge);
lastLight = leg1L;
Toon (soundPin, NOTE_D4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg1L, laag);
breken;
Case 2:
Serial.println ("case 2");
geluid in been 2 evenals licht op het been
digitalWrite (leg2L, hoge);
lastLight = leg2L;
Toon (soundPin, NOTE_E4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg2L, laag);
breken;
Case 3:
Serial.println ("geval 3");
geluid in been 3 evenals licht op het been
digitalWrite (leg3L, hoge);
lastLight = leg3L;
Toon (soundPin, NOTE_F4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg3L, laag);
breken;
/*
Case 4:
geluid in been 4 evenals licht op het been
digitalWrite (leg4L, hoge);
lastLight = leg4L;
Toon (soundPin, NOTE_G4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg4L, laag);
breken;
Case 5:
geluid in been 5 evenals licht op het been
digitalWrite (leg5L, hoge);
lastLight = leg5L;
Toon (soundPin, NOTE_A4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg5L, laag);
breken;
Case 6:
geluid in been 6 evenals licht op het been
digitalWrite (leg6L, hoge);
lastLight = leg6L;
Toon (soundPin, NOTE_B4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg6L, laag);
breken;
Case 7:
geluid in been 7, alsmede licht op het been
digitalWrite (leg7L, hoge);
lastLight = leg7L;
Toon (soundPin, NOTE_C5);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg7L, laag);
breken;
*/
standaard:
Als niets anders overeenkomt met, doen de standaard
Standaard is optioneel
}
lastPin = currentPin;
Als (arrayCounter > = beurt)
{
delay(500);
digitalWrite (lastLight, laag);
noTone(soundPin);
delay(1000);
addRound();
}
}
delay(100);
}
VOID playSequence()
{
Serial.println("playSequence");
int seqCounter = 0;
int waarde = spel [seqCounter];
int noteLength = 1000-(100*turn);
if(noteLength < 500)
{
noteLength = 500;
}
terwijl (waarde! = -1)
{
schakelaar (waarde) {}
Case 0:
geluid in been 0 evenals licht op het been
digitalWrite (leg0L, hoge);
Toon (soundPin, NOTE_C4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg0L, laag);
breken;
Case 1:
geluid in 1 been, alsmede licht op het been
digitalWrite (leg1L, hoge);
Toon (soundPin, NOTE_D4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg1L, laag);
breken;
Case 2:
geluid in been 2 evenals licht op het been
digitalWrite (leg2L, hoge);
Toon (soundPin, NOTE_E4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg2L, laag);
breken;
Case 3:
geluid in been 3 evenals licht op het been
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_F4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg3L, laag);
breken;
/*
Case 4:
geluid in been 4 evenals licht op het been
digitalWrite (leg4L, hoge);
Toon (soundPin, NOTE_G4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg4L, laag);
breken;
Case 5:
geluid in been 5 evenals licht op het been
digitalWrite (leg5L, hoge);
Toon (soundPin, NOTE_A4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg5L, laag);
breken;
Case 6:
geluid in been 6 evenals licht op het been
digitalWrite (leg6L, hoge);
Toon (soundPin, NOTE_B4);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg6L, laag);
breken;
Case 7:
geluid in been 7, alsmede licht op het been
digitalWrite (leg7L, hoge);
Toon (soundPin, NOTE_C5);
delay(noteLength);
noTone(soundPin);
digitalWrite (leg7L, laag);
breken; * /
}
seqCounter ++;
waarde = spel [seqCounter];
delay(pauseBetweenNotes);
}
}
VOID addRound()
{
Serial.Print ("TURN toevoegen");
Serial.println(Turn);
lang daarna = random(pinsUsed);
if(Turn > turnsToWin)
{
gameWon();
currentPin = -1;
lastPin = -1;
}
anders
{
spel [beurt] = next;
spel [beurt + 1] = -1;
beurt ++;
playSequence();
arrayCounter = 0;
currentTime = millis();
loseTime = currentTime + delayAllowed;
Serial.Print ("Lose tijd en dergelijke -");
Serial.println(loseTime);
Serial.Print ("huidige tijd -");
Serial.println(currentTime);
}
}
VOID gameWon()
{
voor (int thisNote = 0; thisNote < 20; thisNote ++) {}
voor het berekenen van de duur van de opmerking, neem één seconde
gedeeld door het type opmerking.
bijvoorbeeld kwartnoot = 1000 / 4, achtste noot = 1000/8, enz.
int noteDuration = 1000/noteDurations [thisNote];
Toon (soundPin, melody[thisNote],noteDuration);
om te onderscheiden van de notities, stel een minimuminterval tussen hen.
de nota's duur + 30% schijnt goed te werken:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
Stop het afspelen van de Toon:
noTone(soundPin);
}
delay(10);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
delay(3000);
gameReset();
}
VOID gameLost(int i)
{
S
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
O
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
S
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
digitalWrite (leg0L, hoge);
digitalWrite (leg1L, hoge);
digitalWrite (leg2L, hoge);
digitalWrite (leg3L, hoge);
Toon (soundPin, NOTE_C4);
delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, laag);
digitalWrite (leg1L, laag);
digitalWrite (leg2L, laag);
digitalWrite (leg3L, laag);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(pauseBetweenNotes);
delay(3000);
gameReset();
}
