Arduino animatronics-Vérifiez vos costumes génial plus impressionnants ! (11 / 15 étapes)

Étape 11 : Canon de prédateur

Example 7- Predator cannon

À 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
}

Articles Liés

Danse de Dave dans un un Arduino basée mouvement sensible costume clair

Danse de Dave dans un un Arduino basée mouvement sensible costume clair

Un Arduino basé mouvement sensible costume clairIl peut également afficher les patrons et autres même si c'est juste la détection de mouvement dans la vid. Il utilise un accéléromètre ADXL335 pour détecter le mouvement des porteurs. Mon ami Dave aima
Vérifiez vos vieilles chaussures brillent à nouveau

Vérifiez vos vieilles chaussures brillent à nouveau

Rendre vos vieilles chaussures nouveau avec quelques paillettes scintillantes !Étape 1: Matériaux de Gather Matériel nécessaire :Vieilles espadrillesCouvercle en plastique ou la paletteColleRuban adhésif de peintreRubanCiseauxPinceau épongePaillettes
Vérifiez vos fléchettes longshot aller plus loin

Vérifiez vos fléchettes longshot aller plus loin

dans ce instructable (mon premier seul) je vais vous montrer comment faire votre Nerf streamline fléchettes aller plus loin par environ 3 à 5 pieds (non mesurés)... au moins ils l'ont fait sur mon longshot. Vos longshot tire 3 pieds en face de vous,
Costume de double-FACE impressionniste !

Costume de double-FACE impressionniste !

Ayant eu un certain succès quelques années en arrière avec mon Costume de Joker impressionniste, pour 2013, j'ai décidé de prendre une fissure à un autre méchant de Batman, Double-Face.  Une de mes raisons pour prendre cette route est que j'ai lassés
Comment rendre votre site génial encore plus impressionnant en le rendant accessible

Comment rendre votre site génial encore plus impressionnant en le rendant accessible

partie 0: IntroductionChaque fois que possible, essayez de concevoir un site Web pour être utilisable par autant de personnes que possible.  Il peut s'agir de personnes qui ne peuvent voir, entendre ou déplacent leur souris bien, ou même du tout.  Vo
Jazzez vos câbles (et plus) avec des bandes de Loom Rainbow

Jazzez vos câbles (et plus) avec des bandes de Loom Rainbow

dans ce instructable nous allons décorer câbles et autres choses, créant une bande standard « queue de poisson » métier à tisser autour d'eux.Un jour férié la caravane des pluies la semaine dernière ma fille de sept ans m'a montré comment faire des b
Capteur de température de l’Arduino entoilage (LM35). LA façon la plus simple

Capteur de température de l’Arduino entoilage (LM35). LA façon la plus simple

Un capteur de température simple à l'aide d'une sonde de température LM35 précision et Arduino. Le circuit enverra série d'informations sur la température que vous pouvez utiliser sur votre ordinateur.Étape 1: matériauxVous aurez besoin :Arduino Uno
Puissance suivi utilisant Arduino et ouvrez une session dans la feuille de Google

Puissance suivi utilisant Arduino et ouvrez une session dans la feuille de Google

Depuis ces dernières semaines, je pensais à faire un projet qui peut m'aider à garder une piste sur mon usages d'énergie quotidienne. Dans ce projet, j'utilise un Conseil de surveillance actuel 30 a. ce Conseil a 6 capteur de courant qui peut lire le
Lumière d’intensité de calcul à l’aide de BH1715 et Arduino Nano

Lumière d’intensité de calcul à l’aide de BH1715 et Arduino Nano

Hier que nous avons travaillé sur l'écran LCD affiche et tout en travaillant sur eux, nous avons réalisé l'importance du calcul de l'intensité lumineuse. L'intensité lumineuse est importante non seulement dans le domaine physique de ce monde, mais il
Mesure de l’accélération à l’aide de H3LIS331DL et Arduino Nano

Mesure de l’accélération à l’aide de H3LIS331DL et Arduino Nano

H3LIS331DL, un accéléromètre linéaire de 3 axes de haute performance de faible puissance est appartenant à la famille de « nano », avec interface numérique I²C. H3LIS331DL a échelles complet sélectionnables de l'utilisateur de ±100g/±200g/±400g et il
Température et humidité suivi à l’aide de SHT25 et Arduino Nano

Température et humidité suivi à l’aide de SHT25 et Arduino Nano

Nous avons récemment travaillé sur divers projets nécessitant la surveillance de l'humidité et température, et puis nous avons réalisé que ces deux paramètres jouent effectivement un rôle essentiel d'avoir une estimation de l'efficacité de fonctionne
Android / Arduino - contrôle d’accès BLUETOOTH porte serrure électrique Strike Lock

Android / Arduino - contrôle d’accès BLUETOOTH porte serrure électrique Strike Lock

Bonjour tout le monde! Aujourd'hui, j'ai fait un soft pour verrouiller et déverrouiller une serrure électrique à l'aide d'un relais, protégé par un mot de passe. L'app est disponible open source ! Il suffit de me contacter ! Contact suivez l'étape su
Thermomètre à matrice de LED

Thermomètre à matrice de LED

Quelques mises à jour ! Le code a été modifié après la virgule est donc dans l'emplacement correct. J'ai aussi ajouté une étape, que j'ai oublié dans la section soddering.Projet en bref :En utilisant une matrice de LED conseil comme un capteur de tem
Self Balancing Scooter Ver 2.0

Self Balancing Scooter Ver 2.0

01/11/2013******************************************************************************************************************Malheureusement la portion de frites IDG500/ADXL335 sur l'accelometer est hors d'usage.Alors ils seront n'est plus la fabricat