Simon le poulpe (2 / 4 étapes)

Étape 2: Code

- Nous avons utilisé le buzzer, LEDs, et boutons qui ont été inclus avec la Tranquillity.

Afin d’obtenir le buzzer à y travailler sont deux appels dont vous avez besoin : tone() et noTone().
Comme une note rapide, la fonction tone() interfère avec la sortie PWM sur les broches 3 et 11 sauf sur le Mega.
La définition de la fonction de tonalité est :
ton (pin, fréquence) ou la tonalité (pin, fréquence, durée)
Si la durée n’est pas spécifiée que le ton va continuer de jouer jusqu'à ce que la fonction noTone() est appelée
appliquée à la broche. La définition de fonction de noTone() est tout simplement noTone(pin).
Vous ne pouvez pas jouer un ton sur la broche à la fois, ce n’était pas un problème pour nous, parce que
Nous avons seulement utilisé un ton chaque patte.

Notre idée de départ était d’utiliser chaque jambe pour une note différente dans la tonalité d’ut et ont
un ensemble octive. Malheureusement, nous n’avons pas utilisé tous les 8 jambes pour cela, mais avec la
matériel adéquat, que vous devez juste faire quelques changements de centre commercial pour le code ci-dessous
pour avoir ce travail.

Il y a un fichier d’en-tête gentil qui est inclus dans le package arduino qui définit
toutes les fréquences à la correspondante note de nom. Une fois ce fichier d’en-tête
inclus tout ce que vous devez faire appel NOTE_C4 pour avoir le buzzer jouer milieu C ou
Si vous avez besoin d’une forte il suffit d’insérer les de ' entre le nom de la note et le numéro c'est-à-dire
NOTE_GS4.

Dans notre code ci-dessous, vous remarquerez que nous utilisons une broche analogique pour l’un de la
boutons de la jambe. Nous avons dû faire ceci basé sur la mise en page Tranquillity ainsi que le total
nombre de codes confidentiels que nous utilisions. Nous avions besoin de faire quelques petits hacks pour obtenir ce
travailler comme les broches numériques en que vous pouvez juste vérifier pour voir si la broche est élevé ou bas tout
les sorties analogiques sa tension.

Pour chaque étape, il y a un bouton et une lumière. Lorsque le bouton est enfoncé l’assigné
Remarque est activée via la broche sonore et diffusent le vibreur aussi bien
comme le LED dans l’éclairage de la jambe vers le haut.

Quand vous gagnez la première partie du jardin de la pieuvre Beatles joue suivie
la lettre V. La chanson a été faite en plaçant les notes dans un tableau et une boucle sur
ce tableau quand le moment sera venu.

Le jeu est relativement simple. Au début de chaque cycle, nous vérifions tous les boutons
pour voir si aucune d'entre elles sont pressées. Nous l’avons fait avec les appels à digitalRead(). Nous avons ensuite « boucle »
grâce aux boutons et s’il y a un bouton qui est actif, nous avons mis une variable qui
stocke la broche plus récente. Nous il suffit de cocher l’un après l’autre donc, si vous aviez des pins
1 et 4 enfoncée en même temps qu'il fixerait la variable à la borne 4.

Nous avons ensuite prendre cette information et passez-la dans une instruction switch qui active
la lumière et le son associé à la touche enfoncée. En raison de la façon dont nous
Set tout ce qu’il ne sera pas allumer plusieurs jambes ou jouer des sons multiples. Que
serait une belle amélioration à ce projet. Si vous avez ajouté 3 buzzers, que vous pourriez
jouer des accords majeurs et mineurs base en appuyant sur des pieds différents. Cela ajouterait un
faire l’aspect à la pieuvre de la musique en temps réel. Aussi avec 8 pieds, vous avez tous
les notes que vous auriez besoin de jouer des chansons de base dans la clé de C.

Pour l’aspect jeu du code après chaque itération de la boucle principale, nous vérifions
que nous sommes en mode de simon et que l’état du bouton a changé (un bouton avait été
pressé). Il vérifie la valeur de la touche et le compare à la valeur enregistrée dans un tableau
qui décrit la séquence de jeu jusqu'à présent. Si les valeurs correspondent il ajoute une nouvelle valeur
à la fin de la séquence et joue toute la mise à jour séquence depuis le début.
Si les valeurs ne correspondent pas, il entre alors dans la boucle « Vous perdez » qui joue un perdant
séquence de la lumière et réinitialise le jeu.

#include « pitches.h »

mode d’int = 0 ; 0-Simon... 1-sons/lumières

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 ;
playTime int = 500 ; lors de la lecture de la séquence de simon

int pinsUsed = 4 ;
int lastPin = 0 ;
int currentPin = -1 ;

int lastLight = 0 ;

const int maxTurns = 50 ;
jeu int [maxTurns] ;
Tournez int = 0 ;
int arrayCounter = 0 ;

const int turnsToWin = 4 ;

unsigned long loseTime ;
unsigned long currentTime ;
unsigned long delayAllowed = 10000 ; Appuyez sur un bouton dans les 4 secondes tu perdras

Notes de la mélodie :
Forte F G C D
la mélodie d’int [] = {}
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
};

Notez les durées: 4 = noire, 8 = croche, etc.. :
int noteDurations [] = {}
4, 4, 4, 1, 4,
4, 4, 4, 1,
8, 8, 4, 4, 4,
4, 4, 2, 8, 8, 1} ;

void setup() {}
/*
pour (int thisNote = 0; thisNote < 20 ; thisNote ++) {}

pour calculer la durée de la note, prendre une seconde
divisé par le type de note.
par exemple la note noire = 1000 / 4, note croche = 1000/8, etc..
int noteDuration = 1000/noteDurations [thisNote] ;
ton (soundPin, melody[thisNote],noteDuration) ;

pour distinguer les notes, fixer une durée minimale entre eux.
Durée + 30 % de la note semble bien fonctionner :
int pauseBetweenNotes = noteDuration * 1.30 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(soundPin) ;

}
*/

Serial.Begin(9600) ;
Millis() ; initialiser les broches legxB comme une entrée :
pinMode (leg0B, entrée) ;
pinMode (leg1B, entrée) ;
pinMode (leg2B, entrée) ;
pinMode (leg3B, entrée) ;
pinMode (leg4B, entrée) ;
pinMode (leg5B, entrée) ;
pinMode (leg6B, entrée) ;
pinMode (leg7B, entrée) ;
initialiser les LED en tant que sortie :
pinMode (leg0L, sortie) ;
pinMode (leg1L, sortie) ;
pinMode (leg2L, sortie) ;
pinMode (leg3L, sortie) ;
pinMode (leg4L, sortie) ;
pinMode (leg5L, sortie) ;
pinMode (leg6L, sortie) ;
pinMode (leg7L, sortie) ;
initialiser la broche sonore en sortie :
pinMode (soundPin, sortie) ;
pour distinguer les notes, fixer une durée minimale entre eux.
Durée + 30 % de la note semble bien fonctionner :
int pauseBetweenNotes = noteDuration * 1.30 ;

jeu [0] = -1 ;
}

void loop() {}

détecter le bouton pressé
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) ;
*/
la valeur de var basé sur la touche
currentPin = -1 ; -1 si aucun bouton
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 ;

Si (mode == 0 & & currentTime > loseTime)
{
gameLost(0) ;
}

Si (mode == 0 & & jeu [0] == -1)
{
Serial.println ("START GAME") ;
tourner = 0 ;
addRound() ;
}

Si (currentPin! = lastPin)
{
digitalWrite (lastLight, basse) ;
Si (mode == 0 & & currentPin! = -1) //simon mode
{
Si (jeu [arrayCounter]! = currentPin)
{
gameLost(1) ;
currentPin = -1 ;
}
d’autre
{
arrayCounter ++ ;
currentTime = millis() ;
loseTime = millis() + delayAllowed ;

}
}

Switch (currentPin) {}
case -1 :
noTone(soundPin) ;
Serial.println (« affaire -1") ;
rupture ;
case 0 :
Serial.println ("case 0") ;
jouer des sons dans la jambe 0 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg0L, HIGH) ;
lastLight = leg0L ;
ton (soundPin, NOTE_C4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
rupture ;
cas 1 :
Serial.println ("case 1") ;
jouer des sons dans la jambe 1 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg1L, HIGH) ;
lastLight = leg1L ;
ton (soundPin, NOTE_D4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg1L, basse) ;
rupture ;
cas 2 :
Serial.println ("case 2") ;
jouer des sons dans l’Etape 2 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg2L, HIGH) ;
lastLight = leg2L ;
ton (soundPin, NOTE_E4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg2L, basse) ;
rupture ;
cas 3 :
Serial.println ("case 3") ;
jouer des sons dans la jambe 3 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg3L, HIGH) ;
lastLight = leg3L ;
ton (soundPin, NOTE_F4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg3L, basse) ;
rupture ;
/*
cas 4 :
jouer des sons dans la jambe 4 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg4L, HIGH) ;
lastLight = leg4L ;
ton (soundPin, NOTE_G4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg4L, basse) ;
rupture ;
cas no 5 :
jouer des sons dans le pied 5 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg5L, HIGH) ;
lastLight = leg5L ;
ton (soundPin, NOTE_A4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg5L, basse) ;
rupture ;
cas 6 :
jouer un son en pied 6 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg6L, HIGH) ;
lastLight = leg6L ;
ton (soundPin, NOTE_B4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg6L, basse) ;
rupture ;
cas 7 :
jouer des sons dans la jambe 7 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg7L, HIGH) ;
lastLight = leg7L ;
ton (soundPin, NOTE_C5) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg7L, basse) ;
rupture ;
*/
par défaut :
Si correspond à rien d’autre, faire la valeur par défaut
valeur par défaut est facultatif
}
lastPin = currentPin ;

Si (arrayCounter > = Tour)
{
Delay(500) ;
digitalWrite (lastLight, basse) ;
noTone(soundPin) ;
Delay(1000) ;
addRound() ;
}
}
Delay(100) ;
}

Sub playSequence()
{
Serial.println("playSequence") ;
int seqCounter = 0 ;
int valeur = jeu [seqCounter] ;
int noteLength = 1000-(100*turn) ;
if(noteLength < 500)
{
noteLength = 500 ;
}
tandis que (valeur! = -1)
{
commutateur (valeur) {}
case 0 :
jouer des sons dans la jambe 0 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg0L, HIGH) ;
ton (soundPin, NOTE_C4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
rupture ;
cas 1 :
jouer des sons dans la jambe 1 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg1L, HIGH) ;
ton (soundPin, NOTE_D4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg1L, basse) ;
rupture ;
cas 2 :
jouer des sons dans l’Etape 2 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg2L, HIGH) ;
ton (soundPin, NOTE_E4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg2L, basse) ;
rupture ;
cas 3 :
jouer des sons dans la jambe 3 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg3L, HIGH) ;
ton (soundPin, NOTE_F4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg3L, basse) ;
rupture ;
/*
cas 4 :
jouer des sons dans la jambe 4 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg4L, HIGH) ;
ton (soundPin, NOTE_G4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg4L, basse) ;
rupture ;
cas no 5 :
jouer des sons dans le pied 5 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg5L, HIGH) ;
ton (soundPin, NOTE_A4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg5L, basse) ;
rupture ;
cas 6 :
jouer un son en pied 6 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg6L, HIGH) ;
ton (soundPin, NOTE_B4) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg6L, basse) ;
rupture ;
cas 7 :
jouer des sons dans la jambe 7 ainsi que la lumière vers le haut de la jambe
digitalWrite (leg7L, HIGH) ;
ton (soundPin, NOTE_C5) ;
Delay(noteLength) ;
noTone(soundPin) ;
digitalWrite (leg7L, basse) ;
casser; * /
}
seqCounter ++ ;
valeur = jeu [seqCounter] ;
Delay(pauseBetweenNotes) ;
}
}

Sub addRound()
{
Serial.Print ("TURN ajoutant") ;
Serial.println(Turn) ;
longtemps next = random(pinsUsed) ;
if(Turn > turnsToWin)
{
gameWon() ;
currentPin = -1 ;
lastPin = -1 ;
}
d’autre
{
jeu [tour] = next ;
jeu [tour + 1] = -1 ;
tour ++ ;
playSequence() ;
arrayCounter = 0 ;
currentTime = millis() ;
loseTime = currentTime + delayAllowed ;
Serial.Print ("perdre temps et autres -") ;
Serial.println(loseTime) ;
Serial.Print ("l’heure actuelle -") ;
Serial.println(CurrentTime) ;
}
}

Sub gameWon()
{

pour (int thisNote = 0; thisNote < 20 ; thisNote ++) {}

}
Delay(10) ;

digitalWrite (leg0L, HIGH) ;
digitalWrite (leg1L, HIGH) ;
digitalWrite (leg2L, HIGH) ;
digitalWrite (leg3L, HIGH) ;
ton (soundPin, NOTE_C4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
digitalWrite (leg1L, basse) ;
digitalWrite (leg2L, basse) ;
digitalWrite (leg3L, basse) ;
Delay(pauseBetweenNotes) ;

digitalWrite (leg0L, HIGH) ;
digitalWrite (leg1L, HIGH) ;
digitalWrite (leg2L, HIGH) ;
digitalWrite (leg3L, HIGH) ;
ton (soundPin, NOTE_C4) ;
Delay(pauseBetweenNotes) ;
Delay(pauseBetweenNotes) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
digitalWrite (leg1L, basse) ;
digitalWrite (leg2L, basse) ;
digitalWrite (leg3L, basse) ;
Delay(pauseBetweenNotes) ;
Delay(3000) ;
gameReset() ;

}

Sub gameLost(int i)
{
S
digitalWrite (leg0L, HIGH) ;
digitalWrite (leg1L, HIGH) ;
digitalWrite (leg2L, HIGH) ;
digitalWrite (leg3L, HIGH) ;
ton (soundPin, NOTE_C4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
digitalWrite (leg1L, basse) ;
digitalWrite (leg2L, basse) ;
digitalWrite (leg3L, basse) ;
Delay(pauseBetweenNotes) ;

O
digitalWrite (leg0L, HIGH) ;
digitalWrite (leg1L, HIGH) ;
digitalWrite (leg2L, HIGH) ;
digitalWrite (leg3L, HIGH) ;
ton (soundPin, NOTE_C4) ;
Delay(pauseBetweenNotes) ;
Delay(pauseBetweenNotes) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
digitalWrite (leg1L, basse) ;
digitalWrite (leg2L, basse) ;
digitalWrite (leg3L, basse) ;
Delay(pauseBetweenNotes) ;

S
digitalWrite (leg0L, HIGH) ;
digitalWrite (leg1L, HIGH) ;
digitalWrite (leg2L, HIGH) ;
digitalWrite (leg3L, HIGH) ;
ton (soundPin, NOTE_C4) ;
Delay(pauseBetweenNotes) ;
noTone(soundPin) ;
digitalWrite (leg0L, basse) ;
digitalWrite (leg1L, basse) ;
digitalWrite (leg2L, basse) ;
digitalWrite (leg3L, basse) ;
Delay(pauseBetweenNotes) ;

}

Voir l'étape

Articles Liés

Créer votre propre jeu de Simon Says avec la pâte Electro DIY Arduino !

Construire un 7 pied casse-noisette de Pots de fleurs un casse-noisette grandeur nature de construction ne peut pas être le décor de vacances moins cher vous faites pour Noël ...
BRICOLAGE fleur Satin Hair Clips Tissu satin a été vraiment utile pour faire des bijoux, comme-boucles d'oreilles, bagues, fleur collier. Cette fois, j'é ...
Cookies aux pépites de chocolat géante Cookies aux pépites de chocolat géante !Donne suffisamment de pâte pour cookie de taille 32 pouces pizza pan plus un 3 d ...
Lubrifier une chaîne de vélo à l’aide de paraffine si vous êtes correctement configuré, vous pouvez utiliser la cire de paraffine pour graisser votre chaîne de vélo. Les p ...
Asiatique-esque Improv (soupe de nouilles) jamais avoir un tas d'ingrédients asiatiques assis autour de diverses expériences de recette et sont complètement désill ...