Étape 3: Téléchargez le code sur l’Arduino
Vous avez besoin d’une bibliothèque appelée WaveHC pour le bouclier de vague que vous rencontrerez lorsque vous suivez le tutoriel Ladyada.
La première chose est de mettre en place une connexion série avec l’Imp électrique afin que tous les signaux reçus peuvent être utilisés.
Ensuite, le code traite un signal reçu sur une des broches Imp comme s’il s’agissait d’un bouton. Cela provoque à son tour un fichier son à jouer de la carte SD via la bibliothèque de bouclier de la vague.
Copiez le code ci-dessous et collez-le dans l’IDE Arduino et transférez-le au Conseil d’administration :
/*
Ce code établit une connexion série pour un Imp électrique et déclencheurs des fichiers audio à lire depuis une carte SD quand un signal est reçu de l’Imp.
Il s’agit essentiellement d’un mashup de l’exemple de boutons de bouclier de vague et l’exemple de base arduino imp électrique
Broches :
8,9 pour imp
Broches 13, 12 et 11 sont utilisés pour parler de la carte SD et ne peut pas être modifiés.
Le reste des goupilles, cependant, sont plus souples.
2 -> LCS
3 -> CLK
4 -> DI
5 -> LAT
10 -> CCS
0 = onwayhome.wav
6 = friday.wav
7 = WAV
*/
Vous avez besoin de la bibliothèque de WaveHC
#include < FatReader.h >
#include < SdReader.h >
#include < avr/pgmspace.h >
#include « WaveUtil.h »
#include « WaveHC.h »
#include < SoftwareSerial.h >
mettre en place un conncetion série pour l’Imp
SoftwareSerial impSerial (8, 9) ; RX 8, TX sur 9
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
Voici où nous définissons les « boutons » que nous allons utiliser - dans ce cas ils sont raccordés aux broches sur l’Imp électrique
boutons de Byte [] = {6,0,7} ;
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(19200) ;
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) ;
définir le débit de données pour le port de SoftwareSerial
impSerial.begin(19200) ;
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 << CS22 | 1 << CS21 | 1 << CS20 ;
TIMER2 débordement Interrupt Enable
TIMSK2 | = 1 << TOIE2 ;
}
{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() {}
Envoyer des données depuis le logiciel serial
Si (impSerial.available())
Serial.Write(impSerial.Read()) ; pour le matériel de série
Envoyer des données série du matériel
Si (Serial.available())
impSerial.write(Serial.read()) ; le logiciel serial
octet i ;
Si (justpressed[0]) {}
justpressed [0] = 0 ;
Serial.println ("pin 6 déclenchée") ;
playcomplete("Home.wav") ;
}
Si (justpressed[1]) {}
justpressed [1] = 0 ;
Serial.println ("pin 0 déclenchée ») ;
playcomplete("Friday.wav") ;
}
Si (justpressed[2]) {}
justpressed [2] = 0 ;
Serial.println ("pin 7 déclenchée ») ;
playcomplete("Tea.wav") ;
}
/*
Si (justpressed[3]) {}
justpressed [3] = 0 ;
playcomplete ("votre Song.wav") ;
}
Si (justpressed[4]) {}
justpressed [4] = 0 ;
playcomplete ("votre Song.wav") ;
}
Si (justpressed[5]) {}
justpressed [5] = 0 ;
playcomplete ("votre Song.wav") ;
}
*/
}
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() ;
}
