Arduino animatörerna-gör din awesome kostymer mer awesome! (11 / 15 steg)

Steg 11: Rovdjur kanon

Med hjälp av en modifierad Wii nunchuck ombord kan vi göra en "head tracking" system för att styra en animatronic Predator kanon. Detta system var utformad som kanon mekanismen i den första filmen Rovdjuret.

Nunchuck styrelsen tas bort från dess fall, styrspaken tas bort och styrelsen är placerad nivå i toppen av Predator Bio hjälmen. Kablar utökas för knapparna så att de kan användas som fingertoppen knappar att aktivera kanonen och utlösa den bränning sekvensen.

Ta bort kretskortet från Wii nunchuck fallet behöver du en tri-wing skruvmejsel-
http://www.Play-Asia.com/paOS-13-71-1e-49-en-70-1fe.html

Ljudeffekten hanteras precis som Iron Man repulsor i exempel 4 med Adafruit Wave sköld. Eftersom Wave sköld koden används kan stödja sex enskilda ljud du kan lägga till fem andra rovdjur ljud och aktivera dem med fingertoppen växlar-snyggt!

Det finns en servo som är inriktad på 4:1 som höjer kanon arm-i koden du kan se detta som servo rotera 180 grader, därmed höja kanon armen 45 grader. De andra två servon mål kanonen med hjälp av accelerometer ingångarna. Det finns transistorer som slår på syftar servon och lasersikte när en knapp trycks. Om syftar servon var alltid på skulle kanonen rotera även när det var i nedfällt läge, så de behöver ett sätt att vara avstängd när kanonen sänks.

Så trycker man en knapp och kanonen väcker upp, sikta servon slå på och lasersikte tänds. Skjut den andra knappen och kanon bränder-två transistorer slå på kanonen LED och aktivera bränning ljudet. Tre röda lysdioder kan användas i stället för lasersikte. Kanonen LED kan vara allt från flera små ljusdioder till en hög effekt Luxeon LED. När du använder en hög effekt måste Luxeon LED du använda en konstant aktuell drivrutin för att driva den.

Servon kan dra en hel del makt så använder jag en spets 120 transistor aktivera syftar servon.

Den prototyp kanon mekanismen byggdes med Delrin plast scraps och kuggremmar och redskap från gamla skrivare och kopieringsmaskiner hittade jag i papperskorgen. När jag bygger den slutliga versionen för Predator kostym kommer det förmodligen helt redskap driven att göra det mer kompakt och renare.

För Predator costuming info kolla in http://www.thehunterslair.com

De personer som är intresserad av att få en kåda kanon gjutning bör kontakta min vän Carl här - http://www.accurizedhunterparts.com/

Carls arbete är absolut lysande-kolla in bilderna nedan från rovdjur ryggsäck lera skulptera att han skapade för detta projekt. Det är en hel del lera! När du kontaktar Carl ha tålamod som han är mycket upptagen och han har en stor eftersläpning av arbete.

Här är koden-

/*
* Exempel 7
* Predator kanon
* Detta används en modifierad Wii nunchuck som en head tracking enhet för att styra en animatronic Predator kanon
* Adafruit Wave sköld används för ljudeffekter
* Honus 2007, uppdaterad 2010
* Wii nunchuck läsa koden ändrade och utökade från nunchuck kod av Tod E. Kurt och Windmeadow Labs
* 2007 Tod E. Kurt, http://todbot.com/blog/
* Wii Nunchuck läsa koden tas från Windmeadow Labs, http://www.windmeadow.com/node/42
*/

#include "Wire.h" / / include tråd biblioteket
#include "Servo.h" / / include servo biblioteket

Servo servo3; skapar en instans av objektet servo att styra en servo

int controlPin1 = 6; Kontroll stift för ljudeffekter styrelsen med z-knappen
int transistorPin1 = 13. Kontroll stift för LED med z-knappen
int transistorPin2 = 12; Kontroll stift för lasersikte med c-knappen
int transistorPin3 = 11; Kontroll stift för servo 1 med c-knappen
int transistorPin4 = 10; Kontroll stift för servo 2 med c-knappen
int servoPin1 = 7. Kontroll stift för servo 1 med hjälp av accelerometer x-axeln
int servoPin2 = 8; Kontroll stift för servo 2 med hjälp av accelerometer y-axeln
int servoPin3 = 9; kontroll stift för arm servo

int pulseWidth1 = 0; Belopp till puls servo 1
int pulseWidth2 = 0; Belopp till puls servo 2

int refreshTime = 20; tiden i millisecs behövs mellan servo pulser
lång lastPulse1;
lång lastPulse2;

int minPulse = 700; minsta servo bredd för synkpuls
int loop_cnt = 0;

booleska button_down = false;
osignerade långa start;

void setup()
{
Serial.BEGIN(19200);

servo3.attach(servoPin3); tillmäter objektet servo servo på pin 9

pinMode (controlPin1, produktionen); Ange kontroll stift 1
pinMode (transistorPin1, produktionen); Ange transistor stift 1
pinMode (transistorPin2, produktionen); Ange transistor stift 2
pinMode (transistorPin3, produktionen); Ange transistor stift 3
pinMode (transistorPin4, produktionen); Ange transistor stift 4
pinMode (servoPin1, produktionen); Ange servo stift 1
pinMode (servoPin2, produktionen); Ange servo stift 2

pulseWidth1 = minPulse; Ange servo position till ett minimum
pulseWidth2 = minPulse; Ange servo position till ett minimum

nunchuck_init(); Skicka initilization handslag
Serial.Print ("NunchuckServo ready\n");
}

void loop()
{
checkNunchuck1();
updateServo1(); uppdatera servo 1 position
checkNunchuck2();
updateServo2(); uppdatera servo 2 position

om (nunchuck_cbutton()) {
digitalWrite (transistorPin2, hög); slå på transistorn stift 2 om c knapp trycks
digitalWrite (transistorPin3, hög); slå på transistorn stift 3 om c knapp trycks
digitalWrite (transistorPin4, hög); slå på transistorn stift 4 om c knapp trycks

servo3.write(180);
}
annat {
digitalWrite (transistorPin2, låg);
digitalWrite (transistorPin3, låg);
digitalWrite (transistorPin4, låg);
servo3.write(0);
}

om (nunchuck_zbutton())
{
om (! button_down) / / om knappen trycktes bara göra detta
{
digitalWrite (controlPin1, hög);
button_down = sant;
Start = millis();
}
annars om (millis() - start > 1200) / / om timern har förflutit gör detta
{
digitalWrite (transistorPin1, hög);
}
}
annat / / om knappen är gör detta
{
button_down = false;
digitalWrite (controlPin1, låg);
digitalWrite (transistorPin1, låg);
}

Delay(1); Detta är här att ge en känd tid per slinga
}

void checkNunchuck1()
{
om (loop_cnt > 100) {/ / loop () s är varje 1msec, detta är varje 100msec

nunchuck_get_data();
nunchuck_print_data();

flyta tilt = nunchuck_accelx(); x-axeln, i detta fall sträcker sig från ~ 70 - ~ 185
lutning = (tilt - 70) * 1,5; konvertera till vinkeln i grader, ungefär
pulseWidth1 = (luta * 9) + minPulse; konvertera vinkel till mikrosekunder

loop_cnt = 0; återställa för
}
loop_cnt ++;

}

kallas varje loop().
använder globala variabler servoPin, pulsewidth, lastPulse och refreshTime
void updateServo1()
{
puls servo igen om rhe uppdateringstid (20 ms) har gått:
om (millis() - lastPulse1 > = refreshTime) {
digitalWrite (servoPin1, hög); Aktivera servo
delayMicroseconds(pulseWidth1); Längden på pulsen anger servo
digitalWrite (servoPin1, låg); Inaktivera servo
lastPulse1 = millis(); Spara tiden för den sista pulsen
}
}

void checkNunchuck2()
{
om (loop_cnt > 100) {/ / loop () s är varje 1msec, detta är varje 100msec

nunchuck_get_data();
nunchuck_print_data();

flyta tilt = nunchuck_accely(); y-axeln, i detta fall sträcker sig från ~ 70 - ~ 185
lutning = (tilt - 70) * 1,5; konvertera till vinkeln i grader, ungefär
pulseWidth2 = (luta * 9) + minPulse; konvertera vinkel till mikrosekunder

loop_cnt = 0; återställa för
}
loop_cnt ++;

}

kallas varje loop().
använder globala variabler servoPin, pulsewidth, lastPulse och refreshTime
void updateServo2()
{
puls servo igen om rhe uppdateringstid (20 ms) har gått:
om (millis() - lastPulse2 > = refreshTime) {
digitalWrite (servoPin2, hög); Aktivera servo
delayMicroseconds(pulseWidth2); Längden på pulsen anger servo
digitalWrite (servoPin2, låg); Inaktivera servo
lastPulse2 = millis(); Spara tiden för den sista pulsen
}
}

//
Nunchuck funktioner
//

statisk uint8_t nunchuck_buf [6]. matrisen att lagra nunchuck data,

initiera I2C systemet, gå med I2C bussen,
och berätta nunchuck vi pratar till den
void nunchuck_init()
{
Wire.BEGIN(); gå med i2c bussen som master
Wire.beginTransmission(0x52); överföra till enhet 0x52
Wire.send(0x40); skickar minnesadress
Wire.send(0x00); skickar skickade en nolla.
Wire.endTransmission(); stoppa överföring
}

Skicka en begäran om data till nunchuck
var "send_zero()"
void nunchuck_send_request()
{
Wire.beginTransmission(0x52); överföra till enhet 0x52
Wire.send(0x00); skickar en byte
Wire.endTransmission(); stoppa överföring
}

Få data tillbaka från nunchuck,
Returnerar 1 om framgångsrika read. returnerar 0 om fel
int nunchuck_get_data()
{
int cnt = 0;
Wire.requestFrom (0x52, 6); begäran data från nunchuck
medan (Wire.available ()) {
ta emot byte som ett heltal
nunchuck_buf [cnt] = nunchuk_decode_byte(Wire.receive());
CNT ++;
}
nunchuck_send_request(); skicka begäran om nästa datanyttolasten
Om vi fått 6 byte, gå sedan skriva ut dem
om (cnt > = 5) {
tillbaka 1. framgång
}
Return 0; misslyckande
}

Skriva ut indata har vi fått
accel data är 10 bitar lång
så vi läsa 8 bitar, då måste vi lägga till
på de sista 2 bitarna. Det är därför jag
multiplicera dem med 2 * 2
void nunchuck_print_data()
{
statisk int jag = 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;

byte nunchuck_buf [5] innehåller bitar för z- och c-knapparna
den innehåller också de minst signifikanta bitarna för accelerometer data
så vi måste kontrollera varje bit av byte outbuf [5]
om ((nunchuck_buf [5] >> 0) & 1)
z_button = 1;
om ((nunchuck_buf [5] >> 1) & 1)
c_button = 1;

om ((nunchuck_buf [5] >> 2) & 1)
accel_x_axis += 2.
om ((nunchuck_buf [5] >> 3) & 1)
accel_x_axis + = 1;

om ((nunchuck_buf [5] >> 4) & 1)
accel_y_axis += 2.
om ((nunchuck_buf [5] >> 5) & 1)
accel_y_axis + = 1;

om ((nunchuck_buf [5] >> 6) & 1)
accel_z_axis += 2.
om ((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"); newline
i ++;
}

Koda data om du vill formatera som de flesta wiimote förare utom
behövs endast om du använder en av de regelbundna wiimote förarna
char nunchuk_decode_byte (char x)
{
x = (x ^ 0x17) + 0x17;
återvändande x;
}

Returnerar zbutton stat: 1 = pressad, 0 = notpressed
int nunchuck_zbutton()
{
tillbaka ((nunchuck_buf [5] >> 0) & 1)? 0: 1; Voodoo
}

Returnerar zbutton stat: 1 = pressad, 0 = notpressed
int nunchuck_cbutton()
{
tillbaka ((nunchuck_buf [5] >> 1) & 1)? 0: 1; Voodoo
}

Returnerar värdet på x-axeln joystick
int nunchuck_joyx()
{
återgå nunchuck_buf [0];
}

Returnerar värdet på y-axeln joystick
int nunchuck_joyy()
{
återgå nunchuck_buf [1].
}

Returnerar värdet för x-axeln accelerometer
int nunchuck_accelx()
{
återgå nunchuck_buf [2]. FIXME: detta lämnar ut 2-bitar av data
}

Returnerar värdet för y-axeln accelerometer
int nunchuck_accely()
{
återgå nunchuck_buf [3]. FIXME: detta lämnar ut 2-bitar av data
}

Returnerar värdet på z-axeln accelerometer
int nunchuck_accelz()
{
återgå nunchuck_buf [4]. FIXME: detta lämnar ut 2-bitar av data
}