Étape 4: Électronique et programmation
Maintenant que j’ai eu la mécanique faite j’avais besoin pour la faire bouger. J’ai utilisé un Arduino Pro Mini pour gérer les entrées et les mouvements du servo et et un Pro de l’Arduino avec un bouclier de vague Adafruit à gérer les effets sonores. Il y a une petite planche qui a trois transistors sur it-les transistors allument le viseur laser casque et déclenchent le Canon LED et effets sonores. Le Conseil a également 3.3V régulateur pour alimenter la vue de laser de casque.
Le canon de LED est une Luxeon bleu vif qui est conduite par un chauffeur de « Buck Toot » courant constant. Afin d’éviter tout problème de bruit de servo les Arduinos sont alimentés par une pile 9V et tout le reste est alimenté par quatre piles alcalines « AA ». J’aurais pu utiliser les batteries NiCd, NiMH ou LiPo, mais puisque nous étions sur un tel calendrier serré je ne voulais pas les gars d’avoir à vous soucier de batteries spécialisées ou long charge fois-qu’ils pouvaient obtenir des piles de rechange dans n’importe quel magasin d’épicerie.
Entrées de commande serait trois commutateurs tactiles pointe de petit doigt. Les commutateurs sont on/off donc si Jamie a poussé l’un d’eux un bruit se répétait encore et encore jusqu'à ce qu’elle a été désactivée. De même le Canon continueraient à se déplacer à travers elle a programmée séquence jusqu'à ce qu’elle a été désactivée. Les commutateurs de bout de doigt étaient connectés pour le sac à dos à l’aide d’un câble ethernet qui doit être exécuté sur toute la longueur du bras de Jamie et les commutateurs seraient asseyait à l’intérieur des doigts de gant.
L’électronique ont été montés sur une 1/8" épais en aluminium à l’aide d’entretoises en plastique et vis 4-40.
Le schéma de câblage complet est donné et j’ai inclus le son des fichiers et un son est pour le Canon, on est le prédateur « cliquettement » et le dernier son est le rugissement de prédateur.
Les Arduinos sont programmés à l’aide d’une évasion de base FTDI. J’ai écrit un guide pour la programmation de l’Arduino ici-
Voici le code pour l’Arduino Pro Mini- c’est la commande les mouvements du canon :
#include < Servo.h > / / inclure la bibliothèque de servo
Servo servo1 ; crée une instance de l’objet de servo pour contrôler un servo
Servo servo2 ;
Servo servo3 ;
int servoPin1 = 9 ; broche de commande pour servo
int servoPin2 = 8 ;
int servoPin3 = 7 ;
int ledPin1 = 11 ; broche de commande pour LED
int ledPin2 = 12 ; broche de commande pour visée laser
int soundPin1 = 10 ; broche de commande pour son Conseil d’administration
void setup() {}
SERVO1.Attach(servoPin1) ; attache le servo sur la broche à l’objet de servo
Servo2.Attach(servoPin2) ;
servo3.Attach(servoPin3) ;
pinMode (ledPin1, sortie) ; définit l’axe de la LED en sortie
pinMode (ledPin2, sortie) ;
pinMode (soundPin1, sortie) ; définit l’axe de son en sortie
digitalWrite (ledPin1, basse) ; définit l’axe LED faible (elle s’éteint)
digitalWrite (ledPin2, basse) ;
digitalWrite (soundPin1, basse) ;
}
void loop() {}
digitalWrite (ledPin2, HIGH) ; définit l’axe LED haute (il allume)
servo3.Write(170) ; bras Canon soulève
SERVO1.Write(140) ; fait pivoter le canon vers le haut
Delay(2000) ;
Servo2.Write(40) ; fait pivoter le canon de la tête
Delay(2000) ;
Servo2.Write(110) ; fait pivoter le canon vers la tête
digitalWrite (ledPin1, HIGH) ;
digitalWrite (soundPin1, HIGH) ;
Delay(10) ;
digitalWrite (ledPin1, basse) ;
digitalWrite (soundPin1, basse) ;
Delay(4000) ;
Servo2.Write(60) ; fait pivoter le canon de la tête
SERVO1.Write(120) ; fait pivoter le canon vers le haut
Delay(1000) ;
digitalWrite (ledPin1, HIGH) ;
digitalWrite (soundPin1, HIGH) ;
Delay(10) ;
digitalWrite (ledPin1, basse) ;
digitalWrite (soundPin1, basse) ;
Delay(3000) ;
Servo2.Write(120) ; fait pivoter le canon vers la tête
SERVO1.Write(150) ; fait pivoter le canon vers le bas
Delay(2000) ;
digitalWrite (ledPin1, HIGH) ;
digitalWrite (soundPin1, HIGH) ;
Delay(10) ;
digitalWrite (ledPin1, basse) ;
digitalWrite (soundPin1, basse) ;
Delay(1000) ;
SERVO1.Write(140) ;
Delay(3000) ;
SERVO1.Write(170) ;
Delay(500) ;
Servo2.Write(90) ;
Delay(1000) ;
servo3.Write(10) ;
digitalWrite (ledPin2, basse) ;
Delay(5000) ;
}
Voici le code pour la vague bouclier - (avec la permission de Adafruit)
#include < FatReader.h >
#include < SdReader.h >
#include < avr/pgmspace.h >
#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 100 / / bouton debouncer
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) ;
putstring_nl ("WaveHC avec 6 boutons") ;
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) ;
activez les résistances de pull-up sur les broches commutateur (entrées analogiques)
digitalWrite (14, HIGH) ;
digitalWrite (15, HIGH) ;
digitalWrite (16, HIGH) ;
digitalWrite (17, HIGH) ;
digitalWrite (18, HIGH) ;
digitalWrite (19, haute) ;
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!") ;
}
void loop() {}
putstring(".") ; Décommentez pour voir si la boucle n’est pas en cours d’exécution
commutateur (check_switches()) {}
cas 1 :
playcomplete ("SOUND1. « « « WAV ») ;
rupture ;
cas 2 :
playcomplete ("SOUND2. « « « WAV ») ;
rupture ;
cas 3 :
playcomplete "(solide3. « « « WAV ») ;
rupture ;
cas 4 :
playcomplete "(SOUND4. « « « WAV ») ;
rupture ;
cas no 5 :
playcomplete "(SOUND5. « « « WAV ») ;
rupture ;
cas 6 :
playcomplete "(SOUND6. « « « WAV ») ;
}
}
check_switches() octets
{
public static octet précédent [6] ;
public static long temps [6] ;
octet lu ;
octet pressé ;
index de l’octet ;
pressé = 0 ;
pour (indice d’octet = 0; index < 6; ++ index) {}
lecture = digitalRead (14 + index) ;
Si (lecture == LOW & & précédent [index] == HIGH & & millis() - temps [index] > DEBOUNCE)
{
interrupteur enfoncé
temps [index] = millis() ;
pressé = index + 1 ;
rupture ;
}
précédent [index] = lecture ;
}
retourner l’interrupteur numéro (1-6)
retour (pressé) ;
}
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() ;
}