Étape 12 : Canon de Machine de guerre
Vous voulez être la Machine de guerre ? Cet exemple est basé sur le canon de prédateur mais utilise un moteur relié à un transistor pour tourner les fûts de Canon. Le moteur s’allume lorsque vous appuyez sur le bouton du feu. Il y a une diode 1N4004 afin d’éviter une tension arrière du moteur, endommageant la broche de sortie du contrôleur.
Un canon de Machine de guerre est nettement plus important que d’un canon de prédateur et nécessiterait des servos plus grands, plus puissants et j’ai donc individuels transistors TIP 120 montrés sur le schéma de câblage.
Pour monter le Canon Servocity vend des mécanismes de pan/tilt qui seraient parfaits pour cette application :
http://www.servocity.com/html/spt200_pan___tilt_system.html
/*
* Exemple 8
* Iron Man War Machine Cannon
* Cela utilise un nunchuck Wii modifiée comme une tête de geolocalisation d’entrée pour contrôler un animatronic cannon Iron Man Machine de guerre
* Adafruit vague bouclier est utilisé pour les effets sonores
* Honus 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
int controlPin1 = 7 ; Broche de commande pour Conseil d’effets sonores à l’aide de la touche z
int transistorPin1 = 13 ; Broche de commande pour LED Canon à l’aide de la touche z
int transistorPin2 = 12 ; Broche de commande pour l’utilisation de servo 1 bouton c
int transistorPin3 = 11 ; Broche de commande pour servo 2 en utilisant le bouton c
int transistorPin4 = 10 ; Broche de commande pour moteur de Canon à l’aide de la touche z
int servoPin1 = 9 ; 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 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) ;
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
}
else {}
digitalWrite (transistorPin2, basse) ; désactiver la broche transistor 2
digitalWrite (transistorPin3, basse) ;
}
Si (nunchuck_zbutton())
{
Si (! button_down) / / si la touche a été enfoncée juste faire cela
{
digitalWrite (controlPin1, HIGH) ; Allumez effet sonore
button_down = true ;
Démarrer = millis() ;
}
ElseIf (millis() - Démarrer > 1200) / / si la minuterie s’est écoulé le faire
{
digitalWrite (transistorPin1, HIGH) ; cannon LED s’allume
digitalWrite (transistorPin4, HIGH) ; mettre en marche le moteur Canon
}
}
else / / si le bouton est vers le haut de faire cela
{
button_down = false ;
digitalWrite (controlPin1, basse) ; désactiver les effets sonores
digitalWrite (transistorPin1, basse) ; couper Canon LED
digitalWrite (transistorPin4, basse) ; Éteignez le moteur Canon
}
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
}
