Étape 11 : Canon de prédateur
À l’aide d’une planche de nunchuck Wii modifiée, nous pouvons faire un système « head tracking » pour contrôler une animatronique cannon Predator. Ce système a été conçu pour ressembler à du mécanisme de Canon dans le premier film de Predator.
Le jury de nunchuck est retiré de son étui, le joystick est supprimé et le jury est placer en position horizontale dans la partie supérieure du casque Predator Bio. Les fils sont étendus pour les boutons, donc ils peuvent être utilisés comme boutons du bout des doigts pour activer le Canon et déclencher la séquence de tir.
Pour retirer le circuit imprimé de la Wii nunchuck cas vous aurez besoin d’un tournevis tri-wing-
http://www.Play-Asia.com/paOS-13-71-1e-49-en-70-1FE.html
L’effet sonore est géré comme le repulsor Iron Man dans l’exemple 4 en utilisant le bouclier de vague Adafruit. Étant donné que le code de la vague bouclier utilisé peut prendre en charge six sons individuels, vous pouvez ajouter cinq autres sons de Predator et les activer à l’aide du doigt commutateurs-neat !
Il y a un servo qui vise 4:1, ce qui soulève le bras Canon-dans le code vous pouvez voir cela comme le servo rotation 180 degrés, ce qui levant le bras Canon 45 degrés. Les deux autres servos visent le canon en utilisant les entrées de l’accéléromètre. Il y a des transistors qui tourne sur les servos visées et laser vue lorsque vous appuyez sur un bouton. Si les servos visées étaient toujours sur le Canon serait tourner même quand elle était en position abaissée, ils ont besoin d’un moyen d’être éteint lorsque le Canon est abaissé.
Alors pousser un seul bouton et le soulève vers le haut, les servos visées s’allume et le viseur laser s’allume. Poussez le deuxième bouton et les transistors de deux feux de Canon le Canon LED s’allume et activer le son tir. Trois LEDs rouges peuvent être utilisés à la place de la visée laser. Le Canon LED peut être quelque chose de plusieurs petites LEDs à haute puissance LED Luxeon. Lorsque vous utilisez une puissance élevée LED Luxeon veillez à utiliser un conducteur de courant constant pour l’alimenter.
Servos peuvent tirer un peu juste du pouvoir j’utilise un transistor 120 astuce pour allumer les servos visées.
Le mécanisme de Canon de prototype a été construit à l’aide de bouts de plastique Delrin et courroies et engrenages de vieilles imprimantes et photocopieurs, que j’ai trouvé à la poubelle. Lorsque je construis la version finale pour le costume Predator il sera probablement entièrement gear driven pour le rendre plus compact et plus propre.
Pour Predator costumes d’informations, consultez http://www.thehunterslair.com
Les personnes intéressées à se procurer un canon de résine coulée devraient communiquer avec mon ami Carl ici - http://www.accurizedhunterparts.com/
Œuvre de Carl est absolument brillant-voir les photos ci-dessous du prédateur à dos argile sculpter qu’il a créé pour ce projet. C’est beaucoup d’argile ! Lorsque vous communiquez avec Carl s’il vous plaît soyez patient car il est très occupé et il a un important arriéré de travail.
Voici le code-
/*
* Exemple 7
* Prédateur Cannon
* Cela utilise un nunchuck Wii modifiée comme une tête de geolocalisation d’entrée pour contrôler un animatronic cannon Predator
* Adafruit vague bouclier est utilisé pour les effets sonores
* Honus 2007, mise à jour 2010
* Wii nunchuck lisant le code modifié/étendue de nunchuck code par Tod E. Kurt et Windmeadow Labs
* 2007 Kurt E. Tod, http://todbot.com/blog/
* Le Wii Nunchuck lisant le code est tiré de Windmeadow Labs, http://www.windmeadow.com/node/42
*/
#include « Wire.h » / / include de la bibliothèque de fils
#include « Servo.h » / / inclure la bibliothèque de servo
Servo servo3 ; crée une instance de l’objet de servo pour contrôler un servo
int controlPin1 = 6 ; Broche de commande pour Conseil d’effets sonores à l’aide de la touche z
int transistorPin1 = 13 ; Broche de commande de LED à l’aide de la touche z
int transistorPin2 = 12 ; Broche de commande pour la vue de laser à l’aide du bouton c
int transistorPin3 = 11 ; Broche de commande pour l’utilisation de servo 1 bouton c
int transistorPin4 = 10 ; Broche de commande pour servo 2 en utilisant le bouton c
int servoPin1 = 7 ; Broche de commande servo 1 utiliser l’accéléromètre axe x
int servoPin2 = 8 ; Broche de commande pour l’utilisation de servo 2 axes y accéléromètre
int servoPin3 = 9 ; broche de commande servo de bras
int pulseWidth1 = 0 ; Montant à impulsion servo 1
int pulseWidth2 = 0 ; Montant à impulsion le servo 2
int refreshTime = 20 ; le temps en millisecs nécessaires entre les impulsions de servo
long lastPulse1 ;
long lastPulse2 ;
int minPulse = 700 ; largeur d’impulsion servo minimale
int loop_cnt = 0 ;
button_down booléen = false ;
démarrage long non signé ;
void setup()
{
Serial.Begin(19200) ;
servo3.Attach(servoPin3) ; attache le servo sur la broche 9 à l’objet de servo
pinMode (controlPin1, sortie) ; Broche 1 en sortie de la commande Set
pinMode (transistorPin1, sortie) ; Définir la broche 1 de transistor en sortie
pinMode (transistorPin2, sortie) ; Broche 2 de transistor Set comme sortie
pinMode (transistorPin3, sortie) ; Définir la broche 3 de transistor en sortie
pinMode (transistorPin4, sortie) ; Broche 4 de transistor Set comme sortie
pinMode (servoPin1, sortie) ; Définir la broche 1 de servo comme sortie
pinMode (servoPin2, sortie) ; Axe servo 2 la valeur en sortie
pulseWidth1 = minPulse ; Définir la position du servo au minimum
pulseWidth2 = minPulse ; Définir la position du servo au minimum
nunchuck_init() ; Envoyer l’initialisation du handshake
Serial.Print ("NunchuckServo ready\n") ;
}
void loop()
{
checkNunchuck1() ;
updateServo1() ; mise à jour de la position du servo 1
checkNunchuck2() ;
updateServo2() ; mise à jour de la position du servo 2
Si {(nunchuck_cbutton())
digitalWrite (transistorPin2, HIGH) ; tourner sur la broche de transistor 2 touche c
digitalWrite (transistorPin3, HIGH) ; tourner sur la broche 3 de transistor, appuyer sur la touche c
digitalWrite (transistorPin4, HIGH) ; tourner sur la broche de transistor 4 touche c
servo3.Write(180) ;
}
else {}
digitalWrite (transistorPin2, basse) ;
digitalWrite (transistorPin3, basse) ;
digitalWrite (transistorPin4, basse) ;
servo3.Write(0) ;
}
Si (nunchuck_zbutton())
{
Si (! button_down) / / si la touche a été enfoncée juste faire cela
{
digitalWrite (controlPin1, HIGH) ;
button_down = true ;
Démarrer = millis() ;
}
ElseIf (millis() - Démarrer > 1200) / / si la minuterie s’est écoulé le faire
{
digitalWrite (transistorPin1, HIGH) ;
}
}
else / / si le bouton est vers le haut de faire cela
{
button_down = false ;
digitalWrite (controlPin1, basse) ;
digitalWrite (transistorPin1, basse) ;
}
Delay(1) ; C’est là pour donner un temps connu par boucle
}
Sub checkNunchuck1()
{
Si (loop_cnt > 100) {/ / loop () s est tous 1msec, il s’agit de chaque 100msec
nunchuck_get_data() ;
nunchuck_print_data() ;
flotteur tilt = nunchuck_accelx() ; axe des abscisses, dans ce cas varie de 70 ~ - ~ 185
inclinaison = (tilt - 70) * 1,5 ; convertir à peu près à l’angle en degrés,
pulseWidth1 = (inclinaison * 9) + minPulse ; convertir angle en microsecondes
loop_cnt = 0 ; remise à zéro des
}
loop_cnt ++ ;
}
appelée chaque loop().
utilise refreshTime, pulsewidth, lastPulse et servoPin de variables globales
Sub updateServo1()
{
impulsions le servo à nouveau si le temps d’actualisation rhe (20 ms) se sont écoulés :
Si (millis() - lastPulse1 > = refreshTime) {}
digitalWrite (servoPin1, HIGH) ; Allumez le servo
delayMicroseconds(pulseWidth1) ; Longueur de l’impulsion définit la position du servo
digitalWrite (servoPin1, basse) ; Désactiver le servo
lastPulse1 = millis() ; économiser le temps de la dernière impulsion
}
}
Sub checkNunchuck2()
{
Si (loop_cnt > 100) {/ / loop () s est tous 1msec, il s’agit de chaque 100msec
nunchuck_get_data() ;
nunchuck_print_data() ;
flotteur tilt = nunchuck_accely() ; axe des y, en l’occurrence varie de 70 ~ - ~ 185
inclinaison = (tilt - 70) * 1,5 ; convertir à peu près à l’angle en degrés,
pulseWidth2 = (inclinaison * 9) + minPulse ; convertir angle en microsecondes
loop_cnt = 0 ; remise à zéro des
}
loop_cnt ++ ;
}
appelée chaque loop().
utilise refreshTime, pulsewidth, lastPulse et servoPin de variables globales
Sub updateServo2()
{
impulsions le servo à nouveau si le temps d’actualisation rhe (20 ms) se sont écoulés :
Si (millis() - lastPulse2 > = refreshTime) {}
digitalWrite (servoPin2, HIGH) ; Allumez le servo
delayMicroseconds(pulseWidth2) ; Longueur de l’impulsion définit la position du servo
digitalWrite (servoPin2, basse) ; Désactiver le servo
lastPulse2 = millis() ; économiser le temps de la dernière impulsion
}
}
//
Fonctions Nunchuck
//
nunchuck_buf uint8_t statique [6] ; Tableau pour stocker les données de nunchuck,
initialiser le système I2C, de rejoindre le bus I2C,
et dire le nunchuck que nous parlons d’elle
Sub nunchuck_init()
{
Wire.Begin() ; rejoindre le bus i2c maître
Wire.beginTransmission(0x52) ; transmettre à un périphérique 0 x 52
Wire.Send(0x40) ; envoie l’adresse mémoire
Wire.Send(0x00) ; envoie a envoyé un zéro.
Wire.endTransmission() ; arrêter la transmission
}
Envoyer une demande de données pour le nunchuck
a « send_zero() »
Sub nunchuck_send_request()
{
Wire.beginTransmission(0x52) ; transmettre à un périphérique 0 x 52
Wire.Send(0x00) ; envoie un octet
Wire.endTransmission() ; arrêter la transmission
}
Recevoir des données remontant le nunchuck,
Retourne 1 en lecture réussie. retourne 0 si une erreur survient
int nunchuck_get_data()
{
cnt int = 0 ;
Wire.requestFrom (0 x 52, 6) ; données de demande du nunchuck
tandis que (Wire.available ()) {}
recevoir des octets en tant qu’entier
nunchuck_buf [cnt] = nunchuk_decode_byte(Wire.receive()) ;
CNT ++ ;
}
nunchuck_send_request() ; Envoyer demande de charge utile de données suivante
Si nous avons reçu les 6 octets, puis aller les imprimer
Si (cnt > = 5) {}
Return 1 ; succès
}
return 0 ; échec
}
Imprimer les données d’entrée, que nous avons reçu
données d’Accel sont 10 bits
donc nous lisons 8 bits, puis il faut ajouter
sur les 2 derniers bits. C’est pourquoi j’ai
multiplier par 2 * 2
Sub nunchuck_print_data()
{
public static int i = 0 ;
int joy_x_axis = nunchuck_buf [0] ;
int joy_y_axis = nunchuck_buf [1] ;
int accel_x_axis = nunchuck_buf [2] ; // * 2 * 2;
int accel_y_axis = nunchuck_buf [3] ; // * 2 * 2;
int accel_z_axis = nunchuck_buf [4] ; // * 2 * 2;
int z_button = 0 ;
int c_button = 0 ;
nunchuck_buf Byte [5] contient les bits pour les touches z et c
Il contient également les bits les moins significatifs pour les données de l’accéléromètre
Il faut donc vérifier chaque bit de l’octet outbuf [5]
Si ((nunchuck_buf [5] >> 0) & 1)
z_button = 1 ;
Si ((nunchuck_buf [5] >> 1) & 1)
c_button = 1 ;
Si ((nunchuck_buf [5] >> 2) & 1)
accel_x_axis += 2 ;
Si ((nunchuck_buf [5] >> 3) & 1)
accel_x_axis += 1 ;
Si ((nunchuck_buf [5] >> 4) & 1)
accel_y_axis += 2 ;
Si ((nunchuck_buf [5] >> 5) & 1)
accel_y_axis += 1 ;
Si ((nunchuck_buf [5] >> 6) & 1)
accel_z_axis += 2 ;
Si ((nunchuck_buf [5] >> 7) & 1)
accel_z_axis += 1 ;
Serial.Print(i,DEC) ;
Serial.Print("\t") ;
Serial.Print("Joy:") ;
Serial.Print(joy_x_axis,DEC) ;
Serial.Print(",") ;
Serial.Print (joy_y_axis, DEC) ;
Serial.Print ("\t") ;
Serial.Print("ACC:") ;
Serial.Print (accel_x_axis, DEC) ;
Serial.Print(",") ;
Serial.Print (accel_y_axis, DEC) ;
Serial.Print(",") ;
Serial.Print (accel_z_axis, DEC) ;
Serial.Print("\t") ;
Serial.Print("but:") ;
Serial.Print (z_button, DEC) ;
Serial.Print(",") ;
Serial.Print (c_button, DEC) ;
Serial.Print("\r\n") ; saut de ligne
i ++ ;
}
Encoder des données pour mettre en forme que la plupart des pilotes wiimote sauf
nécessaire uniquement si vous utilisez un des pilotes réguliers wiimote
nunchuk_decode_byte de char (char x)
{
x = (x ^ 0 x 17) + 0 x 17 ;
Return x ;
}
retourne l’état de zbutton: 1 = pressé, 0 = notpressed
int nunchuck_zbutton()
{
Return ((nunchuck_buf [5] >> 0) & 1) ? 0: 1 ; vaudou
}
retourne l’état de zbutton: 1 = pressé, 0 = notpressed
int nunchuck_cbutton()
{
Return ((nunchuck_buf [5] >> 1) & 1) ? 0: 1 ; vaudou
}
retourne la valeur du joystick de l’axe des abscisses
int nunchuck_joyx()
{
retour nunchuck_buf [0] ;
}
retourne la valeur du joystick de l’axe y
int nunchuck_joyy()
{
retour nunchuck_buf [1] ;
}
retourne la valeur de l’accéléromètre de l’axe des abscisses
int nunchuck_accelx()
{
retour nunchuck_buf [2] ; FIXME : cela laisse de côté 2-bits de données
}
retourne la valeur de l’accéléromètre de l’axe y
int nunchuck_accely()
{
retour nunchuck_buf [3] ; FIXME : cela laisse de côté 2-bits de données
}
retourne la valeur de l’accéléromètre de l’axe z
int nunchuck_accelz()
{
retour nunchuck_buf [4] ; FIXME : cela laisse de côté 2-bits de données
}