Étape 8: l’Arduino esquisse
Je voulais vraiment une diseuse de bonne aventure qui aurait plus de personnalité que la machine moyenne, alors j’ai décidé que je le ferais afin que l’utilisateur peut sélectionner l’humeur de la diseuse de bonne aventure. Dans l’esquisse, les fichiers wave sont divisés en différentes sections. Vous devrez nommer vos fichiers sonores après que les noms de fichier répertoriés dans le sketch ou renommer les noms dans le sketch après vos fichiers. Ainsi, par exemple, les fortunes normales sont nommés 1-14 (cas no 1-14). Les fortunes sarcastiques sont nommés 15 s-29 (cas 15-29), ainsi de suite et ainsi de suite. Lorsque vous chargez votre carte SD avec les fichiers audio, vous devrez renommer vos fichiers en conséquence. Donc si vous deviez utiliser cette esquisse, afin de rendre un juke-box de Beatles, vous devrez renommer Hey Jude "1" (c’est 1, pas de 1.wav).Vous aurez besoin du bouclier de la vague, l’Arduino et une carte SD. Vous aurez également besoin d’installer la bibliothèque de WaveHC. Il y a des instructions sur le site Adafruit sur comment faire pour convertir correctement vos fichiers audio au format approprié pour le bouclier de la vague. J’ai utilisé Audacity pour ce faire, puisqu’il y a beaucoup d’options pour changer le son des fichiers dans Audacity et aussi parce que je ne voulais vraiment pas la diseuse de bonne aventure au son comme moi.
Il y a seulement quelques broches numériques disponibles parce que le bouclier de la vague a besoin de certains des broches pour communiquer avec l’Arduino. Dans mon croquis, j’ai utilisé des pins 6,7,8 et 9, ainsi que des broches analogiques 5. L’esquisse utilise le bruit des broches analogiques 0 pour une sélection audio plus aléatoire. Mon projet utilise deux différentes sources de lumière. Dans l’esquisse, ce sont les leduvPin & ledstrobePin. Il utilise également un code confidentiel pour la commande de moteur (broche 9) & une broche pour la fente (broche 8), un bouton étiqueté dans le sketch. Le pot est raccordée à la broche analogique 5.
#include < FatReader.h >
#include < SdReader.h >
#include < avr/pgmspace.h >
#include « WaveUtil.h »
#include « WaveHC.h »
int ledstrobePin = 7 ;
int leduvPin = 6 ;
int delayPeriod = 20 ;
Carte de SdReader ; Cet objet conserve les informations de la carte
Vol FatVolume ; Il conserve les informations pour la partition sur la carte
FatReader racine ; Il conserve les informations pour le système de fichiers sur la carte
FatReader f ; Il conserve les informations pour le fichier que nous allons jouer
WaveHC vague ; C’est le seul objet (audio) de la vague, puisque nous allons jouer seulement un à la fois
#define moteur 9
#define touche 8
#define LED 13
int val = 0 ;
int potvalue = 0 ;
long randNum ;
Cette fonction pratique retournera le nombre d’octets actuellement libres en RAM, grand pour le débogage !
int freeRam(void)
{
extern int __bss_end ;
extern int * __brkval ;
int free_memory ;
Si ((int) __brkval == 0) {}
free_memory = ((int) & free_memory)-((int) & __bss_end) ;
}
else {}
free_memory = ((int) & free_memory)-((int) __brkval) ;
}
Return free_memory ;
}
Sub sdErrorCheck(void)
{
Si (! card.errorCode()) retourner ;
putstring ("\n\rSD I/O erreur:") ;
Serial.Print(Card.ErrorCode(), HEX) ;
putstring (",") ;
Serial.println(Card.ErrorData(), HEX) ;
while(1) ;
}
void setup() {}
mettre en place le port série
Serial.Begin(9600) ;
pinMode (entrée, bouton) ;
pinMode (LED, sortie) ;
pinMode (leduvPin, sortie) ;
pinMode (ledstrobePin, sortie) ;
randomSeed(analogRead(0)) ;
digitalWrite (bouton, élevé) ;
pinMode (moteur, sortie) ;
putstring ("RAM libre:") ; Ce qui peut aider avec le débogage, manquer de RAM est mauvais
Serial.println(freeRam()) ; s’il s’agit moins de 150 octets Il peut épeler ennuis !
Définissez les broches de sortie pour le contrôle de la DAC. Ce broches sont définis dans la bibliothèque
pinMode (sortie 2) ;
pinMode (3, sortie) ;
pinMode (sortie 4) ;
pinMode (5, sortie) ;
Si (! card.init(true)) {//play avec 4 MHz spi si 8MHz ne fonctionne pas pour vous
Si (! card.init()) {//play avec spi 8 MHz (par défaut plus rapide!)
putstring_nl ("carte init. a échoué!") ; Quelque chose a mal tourné, permet d’imprimer les raisons pour lesquelles
sdErrorCheck() ;
while(1) ; puis « arrêter » - ne rien faire !
}
Enable optimiser la lecture - certaines cartes peuvent timeout. Désactiver si vous rencontrez des problèmes
card.partialBlockRead(true) ;
Maintenant, on va chercher une partition FAT !
uint8_t partie ;
pour (partie = 0; partie < 5; partie ++) {/ / nous avons jusqu'à 5 emplacements de regarder dans
Si (vol.init (carte, partie))
rupture ; Nous avons trouvé un, laisse en liberté sous caution
}
Si (partie == 5) {/ / si nous avons fini ne pas trouver un:(
putstring_nl ("aucun FAT partition valide!") ;
sdErrorCheck() ; Quelque chose a mal tourné, permet d’imprimer les raisons pour lesquelles
while(1) ; puis « arrêter » - ne rien faire !
}
Permet d’indiquer à l’utilisateur sur ce que nous avons trouvé
putstring ("partition à l’aide") ;
Serial.Print (partie, DEC) ;
putstring (", est de type FAT") ;
Serial.println(vol.fatType(),DEC) ; FAT16 ou FAT32 ?
Essayez d’ouvrir le répertoire racine
Si (! root.openRoot(vol)) {}
putstring_nl ("Impossible d’ouvrir le répertoire racine!") ; Quelque chose a mal tourné,
while(1) ; puis « arrêter » - ne rien faire !
}
Ouf ! Nous avons passé les parties difficiles.
putstring_nl("Ready!") ;
/ * TCCR2A = 0 ;
TCCR2B = 1 << CS22 | 1 << CS21 | 1 << CS20 ;
TIMER2 débordement Interrupt Enable
TIMSK2 | = 1 << TOIE2 ;
*/
}
void loop()
{
Val = digitalRead(BUTTON) ;
potvalue = analogRead(5) ;
Serial.println (potvalue, DEC) ;
Si (val == HIGH & & potvalue > = 0 & & potvalue < = 4)
{
randNum = aléatoire (1, 14) ;
Delay(1000) ;
commutateur (randNum)
{
cas 1 :
Serial.println(1) ;
playcomplete("1.wav") ;
rupture ;
cas 2 :
Serial.println(2) ;
playcomplete("2.wav") ;
rupture ;
cas 3 :
Serial.println(3) ;
playcomplete("3.wav") ;
rupture ;
cas 4 :
Serial.println(4) ;
playcomplete("4.wav") ;
rupture ;
cas no 5 :
Serial.println(5) ;
playcomplete("5.wav") ;
rupture ;
cas 6 :
Serial.println(6) ;
playcomplete("6.wav") ;
rupture ;
cas 7 :
Serial.println(7) ;
playcomplete("7.wav") ;
rupture ;
cas 8 :
Serial.println(8) ;
playcomplete("8.wav") ;
rupture ;
cas 9 :
Serial.println(9) ;
playcomplete("9.wav") ;
rupture ;
cas no 10 :
Serial.println(10) ;
playcomplete("10.wav") ;
rupture ;
cas no 11 :
Serial.println(11) ;
playcomplete("11.wav") ;
rupture ;
cas 12 :
Serial.println(12) ;
playcomplete("12.wav") ;
rupture ;
case 13 :
Serial.println(13) ;
playcomplete("13.wav") ;
rupture ;
cas no 14 :
Serial.println(14) ;
playcomplete("14.wav") ;
rupture ;
par défaut :
rupture ;
}
}
Si (val == HIGH & & potvalue > = 5 & & potvalue < = 15)
{
randNum = random (15, 29) ;
Delay(1000) ;
commutateur (randNum)
{
case 15 :
Serial.println(15) ;
playcomplete "(15 ans. « « « WAV ») ;
rupture ;
case 16 :
Serial.println(16) ;
playcomplete "(16 ans. « « « WAV ») ;
rupture ;
cas 17 :
Serial.println(17) ;
playcomplete "(17 ans. « « « WAV ») ;
rupture ;
Case 18 :
Serial.println(18) ;
playcomplete (18 s ». « « « WAV ») ;
rupture ;
case 19 :
Serial.println(19) ;
playcomplete "(19 s. « « « WAV ») ;
rupture ;
case 20 :
Serial.println(20) ;
playcomplete "(20 ans. « « « WAV ») ;
rupture ;
No 21 :
Serial.println(21) ;
playcomplete "(21 s. « « « WAV ») ;
rupture ;
case 22 :
Serial.println(22) ;
playcomplete "(22 s. « « « WAV ») ;
rupture ;
Case 23 :
Serial.println(23) ;
playcomplete "(23 s. « « « WAV ») ;
rupture ;
No 24 :
Serial.println(24) ;
playcomplete "(24 s. « « « WAV ») ;
rupture ;
case 25 :
Serial.println(25) ;
playcomplete "(25 ans. « « « WAV ») ;
rupture ;
case 26 :
Serial.println(26) ;
playcomplete "(26 s. « « « WAV ») ;
rupture ;
case 27 :
Serial.println(27) ;
playcomplete (27 s ». « « « WAV ») ;
rupture ;
case 28 :
Serial.println(28) ;
playcomplete "(28 s. « « « WAV ») ;
rupture ;
case 29 :
Serial.println(29) ;
playcomplete "(29 s. « « « WAV ») ;
rupture ;
par défaut :
rupture ;
}
}
Si (val == HIGH & & potvalue > = 16 & & potvalue < = 22)
{
randNum = random (30, 44) ;
Delay(1000) ;
commutateur (randNum)
{
case 30 :
Serial.println(30) ;
playcomplete ("30m. « « « WAV ») ;
rupture ;
case 31 :
Serial.println(31) ;
playcomplete ("31m. « « « WAV ») ;
rupture ;
No 32 :
Serial.println(32) ;
playcomplete ("32m. « « « WAV ») ;
rupture ;
case 33 :
Serial.println(33) ;
playcomplete ("33m. « « « WAV ») ;
rupture ;
Case 34 :
Serial.println(34) ;
playcomplete ("34m. « « « WAV ») ;
rupture ;
décision 35 :
Serial.println(35) ;
playcomplete ("35m. « « « WAV ») ;
rupture ;
No 36 :
Serial.println(36) ;
playcomplete ("36m. « « « WAV ») ;
rupture ;
Case 37 :
Serial.println(37) ;
playcomplete ("37m. « « « WAV ») ;
rupture ;
No 38 :
Serial.println(38) ;
playcomplete ("38m. « « « WAV ») ;
rupture ;
Case 39 :
Serial.println(39) ;
playcomplete ("39m. « « « WAV ») ;
rupture ;
case 40 :
Serial.println(40) ;
playcomplete ("40m. « « « WAV ») ;
rupture ;
No 41 :
Serial.println(41) ;
playcomplete ("41m. « « « WAV ») ;
rupture ;
boitier 42 :
Serial.println(42) ;
playcomplete ("42m. « « « WAV ») ;
rupture ;
case 43 :
Serial.println(43) ;
playcomplete ("43m. « « « WAV ») ;
rupture ;
case 44 :
Serial.println(44) ;
playcomplete (« 44m. « « « WAV ») ;
rupture ;
par défaut :
rupture ;
}
}
Si (val == HIGH & & potvalue > = 23 & & potvalue < = 1023)
{
randNum = random (45, 60) ;
Delay(1000) ;
commutateur (randNum)
{
Case 45 :
Serial.println(45) ;
playcomplete("45.wav") ;
rupture ;
No 46 :
Serial.println(46) ;
playcomplete ("46F. « « « WAV ») ;
rupture ;
No 47 :
Serial.println(47) ;
playcomplete ("47F. « « « WAV ») ;
rupture ;
No 48 :
Serial.println(48) ;
playcomplete (« 48F. « « « WAV ») ;
rupture ;
No 49 :
Serial.println(49) ;
playcomplete (« 49e. « « « WAV ») ;
rupture ;
case 50 :
Serial.println(50) ;
playcomplete ("50e. « « « WAV ») ;
rupture ;
cas 51 :
Serial.println(51) ;
playcomplete "(51e. « « « WAV ») ;
rupture ;
No 52 :
Serial.println(52) ;
playcomplete ("52e. « « « WAV ») ;
rupture ;
cas 53 :
Serial.println(53) ;
playcomplete ("53e. « « « WAV ») ;
rupture ;
cas 54 :
Serial.println(54) ;
playcomplete "(54e. « « « WAV ») ;
rupture ;
case 55 :
Serial.println(55) ;
playcomplete ("55e. « « « WAV ») ;
rupture ;
cas 56 :
Serial.println(56) ;
playcomplete ("56F. « « « WAV ») ;
rupture ;
case 57 :
Serial.println(57) ;
playcomplete ("57e. « « « WAV ») ;
rupture ;
décision 58 :
Serial.println(58) ;
playcomplete "(58e. « « « WAV ») ;
rupture ;
No 59 :
Serial.println(59) ;
playcomplete "(59e. « « « WAV ») ;
rupture ;
Case 60 :
Serial.println(60) ;
playcomplete ("60F. « « « WAV ») ;
rupture ;
par défaut :
rupture ;
}
}
}
Lit un fichier complet de bout en bout avec aucune pause.
void playcomplete(char *name) {}
Appelez notre aide pour trouver et jouer ce nom
playfile(Name) ;
alors que {(wave.isplaying)
digitalWrite (moteur, élevé) ;
Flash (20, delayPeriod) ;
digitalWrite (moteur, faible) ;
ne rien faire pendant sa lecture
}
maintenant sa fait jouer
}
Sub flash (int numFlashes, int d)
{
pour (int i = 0; i < numFlashes ; j’ai ++)
{
digitalWrite (ledstrobePin, HIGH) ;
digitalWrite (leduvPin, basse) ;
retard (d) ;
digitalWrite (ledstrobePin, basse) ;
digitalWrite (leduvPin, HIGH) ;
retard (d) ;
digitalWrite (ledstrobePin, basse) ;
digitalWrite (leduvPin, basse) ;
}
}
void playfile(char *name) {}
voir si l’objet vague est en train de faire quelque chose
Si {(wave.isplaying)
Flash (20, delayPeriod);// déjà jouer quelque chose, alors l’arrêter !
Wave.Stop() ; Arrête
}
Regardez dans le répertoire racine et ouvrir le fichier
Si (! f.open (racine, nom)) {}
putstring ("Impossible d’ouvrir le fichier") ; Serial.Print(Name) ; retour ;
}
OK, lire le fichier et le transformer en un objet vague
Si (! wave.create(f)) {}
putstring_nl ("pas un valide" WAV") ; retour ;
}
OK le temps de jouer ! Démarrer la lecture
Wave.Play() ;
}
