Paso 11: Cañón depredador
Usando una tabla modificada de nunchuck Wii podemos hacer un sistema de "seguimiento de cabeza" para controlar un animatronic cañón de depredador. Este sistema fue diseñado para parecerse al mecanismo de cañón en la primera película de depredador.
La Junta nunchuck se retira de su caso, se elimina el joystick y el tablero se coloca el nivel en la parte superior del casco Predator Bio. Los cables se extienden para los botones por lo que pueden ser utilizados como botones de la yema del dedo para activar el cañón y activar la secuencia de disparo.
Para quitar la placa de circuito del Wii nunchuck caso necesitarás un destornillador tri-wing-
http://www.Play-Asia.com/paOS-13-71-1E-49-en-70-1FE.html
El efecto de sonido se maneja igual que el repulsor de Iron Man en ejemplo 4 con el protector de la onda de Adafruit. Puesto que el código de protector de la onda puede apoyar seis sonidos individuales puede añadir otros cinco sonidos de depredadores y activarlos usando interruptores prolijo de la punta de los dedos!
Hay un servo que se orienta 4:1 que levanta el brazo de cañón-en el código se puede ver esto como el servo gira 180 grados, 45 grados elevando el brazo de cañón. Los otros dos servos apuntan el cañón usando las entradas de acelerómetro. Hay transistores que encienda los servos que apunta y mira láser cuando se presiona un botón. Si los servos puntería estaban siempre en el cañón girar aun cuando estaba en la posición bajada, así que necesitan una manera de ser apagada cuando se baja el cañón.
Así que empuje uno levanta un botón y el cañón, activar los servos con el objetivo y la mira láser se enciende. Presione el segundo botón y los transistores de dos fuegos de cañón encender el cañón LED y activan el sonido del disparo. Tres LEDs de color rojo se pueden utilizar en lugar de la mira láser. El cañón de LED puede ser de varios pequeños LEDs que un LED Luxeon de alta potencia. Cuando usando un LED Luxeon de alta potencia Asegúrese de utilizar un conductor actual constante de energía.
Servos pueden dibujar un poco de energía para que utilizar un transistor TIP 120 para activar los servos con el objetivo.
El mecanismo de cañón del prototipo fue construido utilizando trozos de plástico Delrin y correas y engranajes de impresoras de escritorio viejo y fotocopiadoras que he encontrado en la basura. Cuando construyo la versión final para el traje de depredador probablemente será enteramente engranes para que sea más compacto y limpiador.
Para depredador vestuario info Echale un vistazo http://www.thehunterslair.com
Las personas interesadas en la obtención de un cañón de resina del bastidor deben póngase en contacto con mi amigo Carl aquí - http://www.accurizedhunterparts.com/
El trabajo de Carl es absolutamente brillante cheque las fotos por debajo del depredador mochila arcilla sculpt que creó para este proyecto. Eso es un montón de barro! Cuando Carl por favor sea paciente mientras él está muy ocupado y tiene una gran acumulación de trabajo.
Aquí está el código-
/*
* Ejemplo 7
* Cañón depredador
* Utiliza un nunchuck Wii modificada como un cabezal de entrada dispositivo de seguimiento para el control de un animatronic cañón de depredador
* Protector de la onda de Adafruit se utiliza para efectos de sonido
* Honus 2007, actualizado 2010
* Wii nunchuck leyendo el código modificado/ampliado de nunchuck código por Tod E. Kurt y Windmeadow Labs
* 2007 Tod E. Kurt, http://todbot.com/blog/
* El Wii Nunchuck código de lectura se toma de los laboratorios de Windmeadow, http://www.windmeadow.com/node/42
*/
#include "Wire.h" / / incluir la biblioteca de alambre
#include "Servo.h" / / incluye la librería servo
Servo servo3; crea una instancia del objeto servo para controlar un servo
int controlPin1 = 6; Pin de control de panel de efectos de sonido usando botón z
int transistorPin1 = 13; Pin de control usando el botón z del LED
int transistorPin2 = 12; Pin de control de láser de la vista utilizando el botón c
int transistorPin3 = 11; Pin de control para el uso de servo 1 botón c
int transistorPin4 = 10; Pin de control para el uso de servo 2 botón c
int servoPin1 = 7; Pin de control de servo 1 usando acelerometro eje x
int servoPin2 = 8; Pin de control para el uso de servo 2 eje del acelerómetro
int servoPin3 = 9; pin de control de servo de brazo
int pulseWidth1 = 0; Cantidad para el servo 1
int pulseWidth2 = 0; Cantidad de pulsos del servo 2
int refreshTime = 20; el tiempo en millisecs necesitaba entre pulsos del servo
largo lastPulse1;
largo lastPulse2;
int minPulse = 700; anchura de pulso mínima de servo
int loop_cnt = 0;
Boolean button_down = false;
Inicio largo sin firmar;
void setup()
{
Serial.Begin(19200);
servo3.Attach(servoPin3); se fija el servo en el pin 9 al objeto servo
pinMode (controlPin1, salida); Configurar control pin 1 como salida
pinMode (transistorPin1, salida); Configurar transistor pin 1 como salida
pinMode (transistorPin2, salida); Configurar pin de transistor 2 como salida
pinMode (transistorPin3, salida); Configurar pin de transistor 3 como salida
pinMode (transistorPin4, salida); Configurar pin de transistor 4 como salida
pinMode (servoPin1, salida); Configurar servo pin 1 como salida
pinMode (servoPin2, salida); Configurar servo pin 2 como salida
pulseWidth1 = minPulse; Ajuste la posición del servo en el mínimo
pulseWidth2 = minPulse; Ajuste la posición del servo en el mínimo
nunchuck_init(); enviar el protocolo de inicialización
Serial.Print ("NunchuckServo ready\n");
}
void loop()
{
checkNunchuck1();
updateServo1(); actualizar posición servo 1
checkNunchuck2();
updateServo2(); actualizar posición del servo 2
Si (nunchuck_cbutton()) {}
digitalWrite (transistorPin2, HIGH); activar pin transistor 2 si se presiona el botón c
digitalWrite (transistorPin3, HIGH); activar pin transistor 3 si se presiona el botón c
digitalWrite (transistorPin4, HIGH); activar pin transistor 4 Si se presiona el botón c
servo3.Write(180);
}
Else {}
digitalWrite (transistorPin2, bajo);
digitalWrite (transistorPin3, bajo);
digitalWrite (transistorPin4, bajo);
servo3.Write(0);
}
Si (nunchuck_zbutton())
{
Si (! button_down) / / si solo se presiona el botón
{
digitalWrite (controlPin1, HIGH);
button_down = true;
Start = millis();
}
else if (millis() - Inicio > 1200) / / si el contador de tiempo transcurrido
{
digitalWrite (transistorPin1, HIGH);
}
}
Else / / si el botón es por hacer esto
{
button_down = false;
digitalWrite (controlPin1, bajo);
digitalWrite (transistorPin1, bajo);
}
Delay(1); Esto está aquí para dar un tiempo conocido por loop
}
void checkNunchuck1()
{
Si (loop_cnt > 100) {/ / bucle () s es cada 1 mseg, cada 100msec
nunchuck_get_data();
nunchuck_print_data();
inclinación del flotador = nunchuck_accelx(); eje x, en este caso va de ~ 70 - ~ 185
inclinación = (tilt - 70) * 1.5; Convertir ángulo en grados, más o menos
pulseWidth1 = (inclinación * 9) + minPulse; Convertir ángulo a microsegundos
loop_cnt = 0; reajuste para
}
loop_cnt ++;
}
llama cada loop().
utiliza variables globales servoPin, anchura de impulso, lastPulse y refreshTime
void updateServo1()
{
pulso del servo nuevo si ha pasado el tiempo de refresco de rhe (20 ms):
Si (millis() - lastPulse1 > = refreshTime) {}
digitalWrite (servoPin1, HIGH); Encienda el servo
delayMicroseconds(pulseWidth1); Longitud del pulso establece la posición del servo
digitalWrite (servoPin1, bajo); Apague el servo
lastPulse1 = millis(); ahorrar el tiempo de la última pulsación
}
}
void checkNunchuck2()
{
Si (loop_cnt > 100) {/ / bucle () s es cada 1 mseg, cada 100msec
nunchuck_get_data();
nunchuck_print_data();
inclinación del flotador = nunchuck_accely(); eje y, en este caso va de ~ 70 - ~ 185
inclinación = (tilt - 70) * 1.5; Convertir ángulo en grados, más o menos
pulseWidth2 = (inclinación * 9) + minPulse; Convertir ángulo a microsegundos
loop_cnt = 0; reajuste para
}
loop_cnt ++;
}
llama cada loop().
utiliza variables globales servoPin, anchura de impulso, lastPulse y refreshTime
void updateServo2()
{
pulso del servo nuevo si ha pasado el tiempo de refresco de rhe (20 ms):
Si (millis() - lastPulse2 > = refreshTime) {}
digitalWrite (servoPin2, HIGH); Encienda el servo
delayMicroseconds(pulseWidth2); Longitud del pulso establece la posición del servo
digitalWrite (servoPin2, bajo); Apague el servo
lastPulse2 = millis(); ahorrar el tiempo de la última pulsación
}
}
//
Funciones del nunchuck
//
nunchuck_buf estática uint8_t [6]; array para almacenar los datos del nunchuck,
inicializar el sistema I2C, Únete al bus I2C,
y Dile el nunchuck que estamos hablando de que
void nunchuck_init()
{
Wire.Begin(); a bus i2c como maestro
Wire.beginTransmission(0x52); transmitir al dispositivo 0x52
Wire.Send(0x40); envía la dirección de memoria
Wire.Send(0x00); envía envía un cero.
Wire.endTransmission(); interrumpir la transmisión
}
Enviar una solicitud de datos para el nunchuck
fue "send_zero()"
void nunchuck_send_request()
{
Wire.beginTransmission(0x52); transmitir al dispositivo 0x52
Wire.Send(0x00); envía un byte
Wire.endTransmission(); interrumpir la transmisión
}
Recibir datos del nunchuck,
devuelve 1 lectura exitosa. devuelve 0 en caso de error
int nunchuck_get_data()
{
int cnt = 0;
Wire.requestFrom (0x52, 6); solicitud datos del nunchuck
mientras que (Wire.available ()) {}
recibe byte como un número entero
nunchuck_buf [cnt] = nunchuk_decode_byte(Wire.receive());
CNT ++;
}
nunchuck_send_request(); enviar solicitud para la siguiente carga de datos
Si hemos recibido los bytes de 6, y luego ir imprimir
Si (cnt > = 5) {}
retorno 1; éxito
}
return 0; falta
}
Imprimir los datos que hemos recibido
datos de Accel están largo 10 bits
así leemos 8 bits, entonces tenemos que añadir
en los últimos 2 bits. Es por eso
multiplicar por 2 * 2
void nunchuck_print_data()
{
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;
byte nunchuck_buf [5] contiene bits de botones z y c
también contiene los bits menos significativos de los datos del acelerómetro
así que tenemos que comprobar cada bit del byte telefonía [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"); nueva línea
i ++;
}
Codificar los datos para el formato que la mayoría conductores de wiimote excepto
sólo es necesario si utilizas uno de los pilotos regulares de wiimote
char nunchuk_decode_byte (char x)
{
x = (x ^ 0x17) + 0x17;
return x;
}
Devuelve el estado de zbutton: 1 = pulsado, 0 = notpressed
int nunchuck_zbutton()
{
¿regresar ((nunchuck_buf [5] >> 0) & 1)? 0: 1; Voodoo
}
Devuelve el estado de zbutton: 1 = pulsado, 0 = notpressed
int nunchuck_cbutton()
{
¿regresar ((nunchuck_buf [5] >> 1) & 1)? 0: 1; Voodoo
}
Devuelve valor de palanca de mando de eje x
int nunchuck_joyx()
{
volver nunchuck_buf [0];
}
Devuelve valor de palanca de mando de eje y
int nunchuck_joyy()
{
volver nunchuck_buf [1];
}
Devuelve el valor del acelerómetro de eje x
int nunchuck_accelx()
{
volver nunchuck_buf [2]; FIXME: Esto deja fuera a 2 bits de los datos
}
Devuelve el valor del acelerómetro de eje y
int nunchuck_accely()
{
volver nunchuck_buf [3]; FIXME: Esto deja fuera a 2 bits de los datos
}
Devuelve el valor del acelerómetro z
int nunchuck_accelz()
{
volver nunchuck_buf [4]; FIXME: Esto deja fuera a 2 bits de los datos
}
