Lumières de Noël de l’Arduino (14 / 14 étapes)

Étape 14 : logiciel

Je dirai que j’ai obtenu mon départ de cette chronologie de quelques autre pages Web. Je ne trouve pas où je l’ai eu, et dû faire beaucoup de changements de toute façon, donc je suis charger ici. Une fois que vous avez cela c’est très facile de créer un programme pour n’importe quelle chanson... mais si vous êtes comme moi vous mieux à la technique câblage et la programmation que vous rapprochez dansent lumières de la musique... donc avoir un point de départ est une grande aide.

Voici donc le code. Encore une fois, c’est le code pour la joie dans le fichier de monde. La version que j’ai téléchargé est MP3, mais si vous utilisez le bouclier de la vague, elle devra être converti en WAV.

Aussi, je suis fatigué de traiter avec le code très long pour les lumières dans la boucle, alors j’ai fait une fonction, appelée « joy() ».
Voici le code de l’Arduino :

Par : Tre' Landrum
#include
#include
#include
#include « WaveUtil.h »
#include « WaveHC.h »

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 DEBOUNCE 5 / / bouton debouncer

Il s’agit pour la joie de pendant de lumières dansant dans le monde
Si vous utilisez le Uno place le méga vous devrez changer ces broches. Si vous utilisez le WaveShield, vous aurez seulement quelques épingles avaialbe... 6-9, du haut de ma tête.
int light1 = 22 ;
light2 int = 24 ;
int light3 = 26 ;
light4 int = 28 ;
int light5 = 30 ;
int light6 = 32 ;
light7 int = 34 ;
int light8 = 36 ;
int s = 150 ;
int ds = 225 ;
int e = 300 ;
int de = 450 ;
int q = 600 ; 600
int dq = 900 ;
int h = 0 ; 1200
int dh = 1800 ;
int start ;
int fin ;
int temps ;
int maintenant ;

Variables vont changer :

Voici où nous définissons les boutons que nous allons utiliser. bouton « 1 » est le premier, touche « 6 » est le 6ème, etc.
boutons de Byte [] = {14, 15, 16, 17, 18, 19} ;
Cette macro pratique nous permet de déterminer comment le tableau vers le haut au-dessus est grande, en vérifiant la taille
#define NUMBUTTONS sizeof(buttons)
nous permettra de suivre si un bouton est pressé juste, juste sorti ou « pressé » (l’état actuel
volatil octet appuyé sur [NUMBUTTONS], justpressed [NUMBUTTONS], justreleased [NUMBUTTONS] ;

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() {}
octet i ;

mettre en place le port série
Serial.Begin(9600) ;
putstring_nl ("WaveHC avec") ;
Serial.Print (NUMBUTTONS, DEC) ;
putstring_nl("buttons") ;

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) ;

pin13 LED
pinMode (13, sortie) ;

Faire entrée et activez les résistances de pull-up sur les broches commutateur
pour (i = 0; i < NUMBUTTONS; i ++) {}
pinMode (boutons [i], entrée) ;
digitalWrite (boutons [i], HIGH) ;
}

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 <
TIMER2 débordement Interrupt Enable
TIMSK2 | = 1 <
pinMode (light1, sortie) ;
pinMode (light2, sortie) ;
pinMode (light3, sortie) ;
pinMode (light4, sortie) ;
pinMode (light5, sortie) ;
pinMode (light6, sortie) ;
pinMode (light7, sortie) ;
pinMode (light8, sortie) ;

les SainSmart sont hors haute
digitalWrite(light1,HIGH) ;
digitalWrite(light2,HIGH) ;
digitalWrite(light3,HIGH) ;
digitalWrite(light4,HIGH) ;
digitalWrite(light5,HIGH) ;
digitalWrite(light6,HIGH) ;
digitalWrite(light7,HIGH) ;
digitalWrite(light8,HIGH) ;
Serial.Begin(9600) ;

} //void setup()

{SIGNAL(TIMER2_OVF_vect)}
check_switches() ;
}

Sub check_switches()
{
previousstate static ubyte [NUMBUTTONS] ;
currentstate static ubyte [NUMBUTTONS] ;
index de l’octet ;

pour (indice = 0; index < NUMBUTTONS ; index ++) {}
CurrentState [index] = digitalRead(buttons[index]) ; lire le bouton

/*
Serial.Print (index, DEC) ;
Serial.Print (": cstate =") ;
Serial.Print (currentstate [index], DEC) ;
Serial.Print («, pstate = ") ;
Serial.Print (previousstate [index], DEC) ;
Serial.Print (", appuyez sur =") ;
*/

Si (currentstate [index] == {previousstate[index])}
Si ((pressé [index] == faible) & & (currentstate [index] == faible)) {}
juste pressé
justpressed [index] = 1 ;
}
ElseIf ((pressé [index] == HIGH) & & (currentstate [index] == HIGH)) {}
vient de paraître
justreleased [index] = 1 ;
}
appuie sur [index] =! currentstate [index] ; n’oubliez pas, digital haute signifie ne pas pressé
}
Serial.println (pressé [index], DEC) ;
previousState [index] = currentstate [index] ; garder une fiche de contrôle des boutons
}
}

//**********************************************************************************************************
//**********************************************************************************************************

void loop() {}
octet i ;

Assurez-vous que vous modifiez le nom du fichier à ce que vous voulez
playfile ("la joie. « « « WAV ») ;

Joy() ; C’est la fonction qui joue la joie au monde

} //void loop() {}

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)
ne rien faire pendant sa lecture
}
maintenant sa fait jouer
}

void playfile(char *name) {}
voir si l’objet vague est en train de faire quelque chose
Si (wave.isplaying) {/ / déjà jouer quelque chose, alors arrêtez d’elle !
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() ;
}

Fonction pour faire les différents brins lumière différentes
void joy() {}

putstring_nl ("commencer de Joy to the World") ;

Démarrer = millis() ;
digitalWrite (light1, basse) ;
digitalWrite (light8, basse) ;
Delay(q) ;
digitalWrite (light1, HIGH) ;
digitalWrite (light8, HIGH) ;

digitalWrite (light2, faible) ;
digitalWrite (light7, faible) ;
Delay(de) ;
digitalWrite (light2, HIGH) ;
digitalWrite (light7, HIGH) ;

digitalWrite (light3, basse) ;
digitalWrite (light6, basse) ;
mentionnés ;
digitalWrite (light3, HIGH) ;
digitalWrite (light6, HIGH) ;

digitalWrite (light4, faible) ;
digitalWrite (light5, basse) ;
Delay(1050) ;
digitalWrite (light4, HIGH) ;
digitalWrite (light5, HIGH) ;

digitalWrite (light1, basse) ;
digitalWrite (light8, basse) ;
mentionnés ;
digitalWrite (light1, HIGH) ;
digitalWrite (light8, HIGH) ;

digitalWrite (light2, faible) ;
digitalWrite (light7, faible) ;
Delay(q) ;
digitalWrite (light2, HIGH) ;
digitalWrite (light7, HIGH) ;

digitalWrite (light3, basse) ;
digitalWrite (light6, basse) ;
Delay(q) ;
digitalWrite (light3, HIGH) ;
digitalWrite (light6, HIGH) ;

digitalWrite (light4, faible) ;
digitalWrite (light5, basse) ;
Delay(DQ) ;
digitalWrite (light4, HIGH) ;
digitalWrite (light5, HIGH) ;

digitalWrite (light1, basse) ;
digitalWrite (light2, faible) ;
digitalWrite (light7, faible) ;
digitalWrite (light8, basse) ;
Delay(e) ;
digitalWrite (light1, HIGH) ;
digitalWrite (light2, HIGH) ;
digitalWrite (light7, HIGH) ;
digitalWrite (light8, HIGH) ;

digitalWrite (light2, faible) ;
digitalWrite (light3, basse) ;
digitalWrite (light6, basse) ;
digitalWrite (light7, faible) ;
Delay(DQ) ;
digitalWrite (light2, HIGH) ;
digitalWrite (light3, HIGH) ;
digitalWrite (light6, HIGH) ;
digitalWrite (light7, HIGH) ;

digitalWrite (light3, basse) ;
digitalWrite (light4, faible) ;
digitalWrite (light5, basse) ;
digitalWrite (light6, basse) ;
Delay(DQ) ;
digitalWrite (light3, HIGH) ;
digitalWrite (light4, HIGH) ;
digitalWrite (light5, HIGH) ;
digitalWrite (light6, HIGH) ;

digitalWrite (light1, basse) ;
digitalWrite (light2, faible) ;
digitalWrite (light3, basse) ;
digitalWrite (light4, faible) ;
digitalWrite (light5, basse) ;
digitalWrite (light6, basse) ;
digitalWrite (light7, faible) ;
digitalWrite (light8, basse) ;
Delay(DQ) ;
digitalWrite (light1, HIGH) ;
digitalWrite (light2, HIGH) ;
digitalWrite (light3, HIGH) ;
digitalWrite (light4, HIGH) ;
digitalWrite (light5, HIGH) ;
digitalWrite (light6, HIGH) ;
digitalWrite (light7, HIGH) ;
digitalWrite (light8, HIGH) ;
8100

digitalWrite (light8, basse) ;
Delay(e) ;
digitalWrite (light8, HIGH) ;

digitalWrite (light1, basse) ;
Delay(e) ;
digitalWrite (light1, HIGH) ;

digitalWrite (light7, faible) ;
Delay(e) ;
digitalWrite (light7, HIGH) ;

digitalWrite (light2, faible) ;
Delay(e) ;
digitalWrite (light2, HIGH) ;

digitalWrite (light6, basse) ;
Delay(e) ;
digitalWrite (light6, HIGH) ;

digitalWrite (light3, basse) ;
Delay(de) ;
digitalWrite (light3, HIGH) ;

digitalWrite (light5, basse) ;
mentionnés ;
digitalWrite (light5, HIGH) ;

digitalWrite (light4, faible) ;
Delay(e) ;
digitalWrite (light4, HIGH) ;