Paso 12: Cañón máquina de guerra
¿Quieres ser la máquina de guerra? En este ejemplo se basa en el cañón del depredador pero utiliza un motor conectado a un transistor para hacer girar los barriles del cañón. Al pulsar el botón se enciende el motor. Hay un diodo 1N4004 para prevenir la tensión posterior del motor, dañar el pin de salida del controlador.
Un cañón de la máquina de guerra es substancialmente más grande que un cañón de depredador y requeriría servos más grandes y más potentes para tener individuales transistores TIP 120 que se muestra en el diagrama de cableado.
Para montar el cañón Servocity vende mecanismos pan/tilt que serían perfectos para esta aplicación,
http://www.servocity.com/html/spt200_pan___tilt_system.html
/*
* Ejemplo 8
* Hierro hombre guerra máquina cañón
* Utiliza un nunchuck Wii modificada como un cabezal de entrada dispositivo de seguimiento para el control de un animatronic de cañón de la máquina de guerra de hombre de hierro
* Protector de la onda de Adafruit se utiliza para efectos de sonido
* Honus 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
int controlPin1 = 7; Pin de control de panel de efectos de sonido usando botón z
int transistorPin1 = 13; Pin de control de LED de cañón usando el botón z
int transistorPin2 = 12; Pin de control para el uso de servo 1 botón c
int transistorPin3 = 11; Pin de control para el uso de servo 2 botón c
int transistorPin4 = 10; Pin de control de motor de cañón usando botón z
int servoPin1 = 9; 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 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);
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
}
Else {}
digitalWrite (transistorPin2, bajo); Apagar pin transistor 2
digitalWrite (transistorPin3, bajo);
}
Si (nunchuck_zbutton())
{
Si (! button_down) / / si solo se presiona el botón
{
digitalWrite (controlPin1, HIGH); activar efectos de sonido
button_down = true;
Start = millis();
}
else if (millis() - Inicio > 1200) / / si el contador de tiempo transcurrido
{
digitalWrite (transistorPin1, HIGH); Encienda el cañón de LED
digitalWrite (transistorPin4, HIGH); encender motor cañón
}
}
Else / / si el botón es por hacer esto
{
button_down = false;
digitalWrite (controlPin1, bajo); Desactivar efectos de sonido
digitalWrite (transistorPin1, bajo); Apague el cañón LED
digitalWrite (transistorPin4, bajo); Apague el motor del cañón
}
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
}
