Je commence avec cette instructable
Quand j’ai fini, j’ai une question qui fonctionne comme suit :
-composer un nombre ou une suite de nombres
-Appuyez sur le gros bouton rouge pour tester cette séquence.
-l’arduino va jouer une chanson basée sur le premier chiffre de la séquence composé.
- Mais si la séquence correcte est composée, dans ce cas le nom de mes filles, l’arduino jouera la chanson « joyeux anniversaire », faites tourner l’écran métallique et allumer les leds UV. Cela révélera le "message joyeux anniversaire, que j’ai écrit sur l’écran avec le stylo encre invisible.
vidéo à suivre
Donc en gros ce que j’ai est :
L’Arduino enregistre l’entrée téléphone à cadran sous forme de chaîne et le code vérifie ensuite pour une chaîne particulière.
Si elle n’est pas cette chaîne, il joue ensuite un des 5 chansons qui sont codés dans le sketch.
Si c’est la chaîne correcte puis l’arduino instruit le servo de tourner et s’allume les lumières UV et joue la chanson d’anniversaire.
Le code suivante :
J’ai trouvé des morceaux de celui-ci ici et là. La fonction de tonalité est utilisée avec un fichier pitches.h.
/ * 21/03/12 - a commencé à faire des projets avec cadran rotatif
-à utiliser pour le cadeau d’anniversaire pour Christine
-idée :
numéros de composition vont jouer une chanson différente
composant son nom s’allume les LEDs qui montreront le messgae de joyeux anniversaire
ou l’aniversity heureux pour Harrie et Riek
-commençant par le code de la batphonev1
-besoin de faire beaucoup de changements
-v2 - commencer la recherche à watys d’avoir beaucoup de chansons ou de notes
*/
#include < Servo.h >
#include « pitches.h »
Joyeux Anniversaire
int melodybd [] = {NOTE_C4, NOTE_C4, NOTE_D4, NOTE_C4, NOTE_F4, NOTE_E4, NOTE_C4, NOTE_C4,
NOTE_D4, NOTE_C4, NOTE_G4, NOTE_F4, NOTE_C4, NOTE_C4,
NOTE_C5, NOTE_A4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_B4, NOTE_B4, NOTE_A4,
NOTE_F4, NOTE_G4, NOTE_F4} ;
int noteDurationsbd [] = {3, 16, 4, 4, 4, 2, 3, 16, 4, 4, 4,2, 3, 16, 4,4,4,4,4,3,16,4,4,4,2} ;
int numNotesbd = 25 ;
aniversary
Voici la mariée
int melodyanv [] = {NOTE_A3, NOTE_C4, NOTE_C4, NOTE_C4, NOTE_A3, NOTE_D4, NOTE_B3, NOTE_C4, NOTE_A3, NOTE_C4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_C4, NOTE_B3, NOTE_C4, NOTE_D4} ;
Notez les durées: 4 = noire, 8 = croche, etc.. :
int noteDurationsanv [] = {2,3,8,1,2,3,8,1,2,3,8,2,3,8,2,3,8,1} ;
int numNotesanv = 18 ;
1, starwars
int melody1 [] = {NOTE_G5, NOTE_G5, NOTE_G5, NOTE_DS5, NOTE_AS5, NOTE_G5, NOTE_DS5, NOTE_AS5, NOTE_G5} ;
int noteDurations1 [] = {3, 3, 3, 4, 8, 3, 4, 8, 2} ;
int numNotes1 = 9 ;
// 2. chose de deux bits
int melody2 [] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4} ;
int noteDurations2 [] = {4,8,8, 4,4,4,4,4} ;
int numNotes2 = 8 ;
3 pop va la belette
int melody3 [] = {}
NOTE_C4, NOTE_C4, NOTE_D4, NOTE_D4, NOTE_E4,
NOTE_G4, NOTE_E4, NOTE_C4, NOTE_C4, NOTE_C4,
NOTE_D4, NOTE_D4, NOTE_D4, NOTE_E4, NOTE_C4, 0,
NOTE_C4, NOTE_C4, NOTE_D4, NOTE_D4, NOTE_E4,
NOTE_G4, NOTE_E4, NOTE_C4, 0, NOTE_A4,
NOTE_D4, NOTE_F4, NOTE_E4, NOTE_C4, 0} ;
int noteDurations3 [] = {4, 8, 4, 8, 8, 8, 8, 4, 8, 4, 8, 4, 8, 3, 4, 8, 4, 8, 4, 8, 8, 8, 8, 4, 4, 2, 4, 4, 4, 4, 4} ;
int numNotes3 = 31 ;
4 batman
int melody4 [] = {NOTE_A3, NOTE_A3, NOTE_GS3, NOTE_GS3, NOTE_G3, NOTE_G3, NOTE_GS3, NOTE_GS3, NOTE_A3, NOTE_A3, NOTE_GS3, NOTE_GS3, NOTE_G3, NOTE_G3, NOTE_GS3, NOTE_GS3, NOTE_A3, NOTE_A3, NOTE_GS3, NOTE_GS3, NOTE_G3, NOTE_G3, NOTE_GS3, NOTE_GS3, NOTE_A3, NOTE_A3, NOTE_GS3, NOTE_GS3, NOTE_G3, NOTE_G3 NOTE_GS3, NOTE_GS3, NOTE_E4, NOTE_E4} ;
int noteDurations4 [] = {8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4} ;
int numNotes4 = 32 ;
5 familier classique
int melody5[]= {NOTE_E4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_E4,NOTE_D4,NOTE_C4,NOTE_C4,NOTE_D4,NOTE_E4,NOTE_E4,NOTE_D4,NOTE_D4,NOTE_E4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_E4,NOTE_D4,NOTE_C4,NOTE_C4,NOTE_D4,NOTE_E4,NOTE_D4,NOTE_C4,NOTE_C4 ,NOTE_D4,NOTE_D4,NOTE_E4,NOTE_C4,NOTE_D4,NOTE_E4,NOTE_F4,NOTE_E4,NOTE_C4,NOTE_D4,NOTE_E4,NOTE_F4,NOTE_E4,NOTE_D4,NOTE_C4,NOTE_D4,NOTE_G3,NOTE_E4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_E4,NOTE_D4,NOTE_C4,NOTE_C4,NOTE_D4,NOTE_E4,NOTE_D4,NOTE_C4 NOTE_C4} ;
Notez les durées: 4 = noire, 8 = croche, etc.. :
int noteDurations5 [] = {4,4,4,4,4,4,4,4,4,4,4,4,2,8,2,4,4,4,4,4,4,4,4,4,4,4,4,2, 4,4,4,4,4,8,8,4,4,4,8,8,4,4,4,4,2,4,4,4,4,4,4,4,4,4,4,4,4,2,8,2} ;
int numNotes5 = 62 ;
int needToPrint = 0 ;
int count ;
mine
const int try_it = 3 ;
const int in_from_dial = 2 ;
const int lightOn = 11 ;
buttonState int = 0 ; variable pour la lecture de l’état de bouton poussoir
int firstnum = 0 ;
char a joué = ' n ' ;
mine de fin
int lastState = faible ;
int trueState = faible ;
long lastStateChangeTime = 0 ;
autorisé d’int = 0 ;
constantes
int dialHasFinishedRotatingAfterMs = 100 ;
int debounceDelay = 10 ;
chaînes
String nouvelleChaine ;
char de Carrie [] = "227743" ;
Char [Daniel] = "326435" ;
Char [] Big50 = "1" ;
Char [] Harrie = "2" ;
servo
Servo myservo ; Créez l’objet servo pour contrôler un servo
int pos = 0 ; variable pour stocker la position du servo
// --------------------------------------------
void setup()
{
Serial.Begin(9600) ;
pinMode (in_from_dial, entrée) ; 2
pinMode (try_it, entrée) ; 3
pinMode (lightOn, sortie) ; 11
pinMode (13, sortie) ; 12
myservo.Attach(6) ; attache le servo sur la broche 6 à l’objet de servo
}
void loop() {}
digitalWrite (13, HIGH) ; la valeur de la LED sur
/*
l’utilisateur va composer des numéros jusqu'à ce qu’ils ont frappé le buttonb « essayer »
donc besoin de créer la chaîne jusqu'à ce que le bouton est enfoncé
*/
lire l’état du bouton tryit
digitalWrite (lightOn, faible) ;
buttonState = digitalRead(try_it) ;
try_it = élevé ;
Si (buttonState == faible) {}
lecture int = digitalRead(in_from_dial) ;
Si ((millis()-lastStateChangeTime) > dialHasFinishedRotatingAfterMs) {}
le cadran n’est pas composé, ou vient de terminer le composé.
Si {(needToPrint)
Si c’est à peine fini composé, il faut envoyer le numéro dans la série
ligne et réinitialisez le compte. Nous mod le comptage par 10 parce que « 0 » enverra 10 impulsions.
Serial.println (Nbre % 10, DEC) ;
faut maintenant ajouter le comte à la chaîne de test et puis testez-le contre la
Chaîne requise pour prendre son pied
NewString.Concat(Count) ;
needToPrint = 0 ;
Count = 0 ;
effacée = 0 ;
}
}
Si (lecture! = lastState) {}
lastStateChangeTime = millis() ;
}
Si ((millis()-lastStateChangeTime) > debounceDelay) {}
Debounce - cela arrive une fois qu’il est stabilisé
Si (lecture! = trueState) {}
Cela signifie que le commutateur soit juste allé de fermé a -> ouvrir ou vice versa.
trueState = lecture ;
Si (trueState == HIGH) {}
incrémenter le compteur d’impulsions si il est allé en haut.
Count ++ ;
needToPrint = 1 ; Nous aurons besoin d’imprimer ce nombre (une fois le cadran rotatif)
}
}
}
lastState = lecture ;
}
d’autre
{
l’utilisateur veut maintenant tester sa composition
//
joué = ' n ' ;
Serial.println(NewString) ;
test_it() ;
nouvelleChaine = "" ;
}
}
// --------------------- my functions -------------------------
// ------------------------------------------------------------
allumer les leds
Sub turnon_Leds()
{
digitalWrite (lightOn, HIGH) ;
}
// --------------------------------------------------
tester la chaîne
Sub test_it()
{
Serial.println(NewString) ;
Serial.println(firstnum) ;
Delay(2000) ;
/*
Si « BIG50 » puis jouer joyeux anniversaire, servo, allumer les Leds
Si « HARRIE » puis joue la chanson anv, trun servo allumer LED
*/
Si (newstring.equals(Carrie)) {}
tourner le servo
pour (pos = 0; pos < 180; pos += 1) / / va de 0 degrés à 180 degrés
{/ / par incréments de 1 degré
myservo.Write(POS) ; dire de servo pour aller à positionner dans la variable « pos »
Delay(15) ; attend 15 ms pour le servo atteindre la position
}
turnon_Leds() ;
pour (int thisNote = 0; thisNote < numNotesbd ; thisNote ++) {}
int noteDuration = 1000/noteDurationsbd [thisNote] ;
ton (8, melodybd[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,4 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
Delay(2000) ;
}
//-----------------------------------------
Si (newstring.equals(Daniel)) {}
tourner le servo
pour (pos = 180; pos > = 15; pos-= 1) / / va de 0 degrés à 180 degrés
{/ / par incréments de 1 degré
myservo.Write(POS) ; dire de servo pour aller à positionner dans la variable « pos »
Delay(15) ; attend 15 ms pour le servo atteindre la position
}
turnon_Leds() ;
pour (int thisNote = 0; thisNote < numNotesbd ; thisNote ++) {}
int noteDuration = 1000/noteDurationsbd [thisNote] ;
ton (8, melodybd[thisNote],noteDuration) ;
int pauseBetweenNotes = noteDuration * 1,4 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
nouvelleChaine = "" ;
Delay(2000) ;
}
Serial.println ("got here1") ;
Delay(500) ;
besoin de difgit premier et ensuite les cas d’utilisation d’interpréter la chanson
Serial.println("here2") ;
Serial.println(NewString) ;
Delay(1000) ;
Si (joué == ' n ') {}
1 0or 9
Si ((newstring.startsWith("1")) || (newstring.startsWith("9"))) {
itérer sur les notes de la mélodie :
pour (int thisNote = 0; thisNote < numNotes1 ; thisNote ++) {}
int noteDuration = 1000/noteDurations1 [thisNote] ;
ton (8, melody1[thisNote],noteDuration) ;
int pauseBetweenNotes = noteDuration * 1.30 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
Delay(500) ;
nouvelleChaine = "" ;
}
commence par 2 ou 8
Si ((newstring.startsWith("2")) || (newstring.startsWith("8")))
{
itérer sur les notes de la mélodie :
pour (int thisNote = 0; thisNote < numNotes2 ; thisNote ++) {}
int noteDuration = 1000/noteDurations2 [thisNote] ;
ton (8, melody2[thisNote],noteDuration) ;
int pauseBetweenNotes = noteDuration * 1.30 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
Delay(500) ;
nouvelleChaine = "" ;
}
commence par 3 ou 7
Si ((newstring.startsWith("3")) || (newstring.startsWith("7")))
{
itérer sur les notes de la mélodie :
pour (int thisNote = 0; thisNote < numNotes3 ; thisNote ++) {}
int noteDuration = 1000/noteDurations3 [thisNote] ;
ton (8, melody3[thisNote],noteDuration) ;
int pauseBetweenNotes = noteDuration * 1.30 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
Delay(500) ;
}
commence with4 ou 6
Si ((newstring.startsWith("4")) || (newstring.startsWith("6")))
{
itérer sur les notes de la mélodie :
pour (int thisNote = 0; thisNote < numNotes4 ; thisNote ++) {}
int noteDuration = 1000/noteDurations4 [thisNote] ;
ton (8, melody4[thisNote],noteDuration) ;
int pauseBetweenNotes = noteDuration * 1.30 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
Delay(500) ;
}
commence par 5 ou 0
Si ((newstring.startsWith("5")) || (newstring.startsWith("0")))
{
itérer sur les notes de la mélodie :
pour (int thisNote = 0; thisNote < numNotes5 ; thisNote ++) {}
int noteDuration = 1000/noteDurations5 [thisNote] ;
ton (8, melody5[thisNote],noteDuration) ;
int pauseBetweenNotes = noteDuration * 1.30 ;
Delay(pauseBetweenNotes) ;
arrêter la lecture de ton :
noTone(8) ;
}
joué = « Y » ;
Delay(500) ;
}
}
fin de boucle
}
