Muchos tuvieron este juguete en la infancia; lo controlamos con dos botones giratorios. Incluso entonces, fue posible conectar dos motores de CC con engranajes y controlarlos desde los botones. Y ahora para esto es posible adaptar los joysticks. Que es lo que hizo el autor de Instructables bajo el apodo millerman4487.
Pero se tuvieron que imprimir dos partes idénticas: estos son adaptadores para conectar engranajes a los mangos de Magic Screen. Se parece a cualquiera de los adaptadores:
Y entonces se conecta a la caja de cambios (quizás esto requerirá calentar ligeramente el adaptador con un secador de pelo):
Archivo STL.
Solo hay un componente incomprensible: el chip L293D. Contiene dos llamados puentes H, cada uno de los cuales puede invertir el motor conectado a él. Debajo del tablero se muestra qué conclusiones
Conecte cuál de los pines del conector del joystick Wii Nunchuck. El siguiente boceto se puede reescribir para trabajar con cualquier otro tipo de joysticks, en su forma actual será necesario.
#include
#if (ARDUINO & gt; = 100)
#include
#else
#include
// # define Wire.write (x) Wire.send (x)
// # define Wire.read () Wire.receive ()
#endif
estático uint8_t nunchuck_buf [6]; // matriz para almacenar datos nunchuck,
// Utiliza los pines del puerto C (entrada analógica) como alimentación y tierra para Nunchuck
static nulluck_setpowerpins vacío () {
#define pwrpin PORTC3
#define gndpin PORTC2
DDRC | = _BV (pwrpin) | _BV (gndpin);
PORTC & = ~ _BV (gndpin);
PORTC | = _BV (pwrpin);
retraso (100); // espera a que las cosas se estabilicen
}
// inicializa el sistema I2C, únete al bus I2C,
// y dile al nunchuck que le estamos hablando
static void nunchuck_init () {
Wire.begin (); // únete al bus i2c como maestro
Wire.beginTransmission (0x52); // transmitir al dispositivo 0x52
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x40); // envía la dirección de memoria
Wire.write ((uint8_t) 0x00); // envía un cero enviado.
#else
Wire.send ((uint8_t) 0x40); // envía la dirección de memoria
Wire.send ((uint8_t) 0x00); // envía un cero enviado.
#endif
Wire.endTransmission (); // deja de transmitir
}
// Enviar una solicitud de datos al nunchuck
// era "send_zero ()"
static void nunchuck_send_request () {
Wire.beginTransmission (0x52); // transmitir al dispositivo 0x52
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x00); // envía un byte
#else
Wire.send ((uint8_t) 0x00); // envía un byte
#endif
Wire.endTransmission (); // deja de transmitir
}
// Codificar datos para formatear que la mayoría de los controladores wiimote excepto
// solo es necesario si usa uno de los controladores wiimote normales
char estático nunchuk_decode_byte (char x) {
x = (x ^ 0x17) + 0x17;
volver x;
}
// Reciba datos del nunchuck,
// devuelve 1 en lectura exitosa. devuelve 0 en caso de falla
static int nunchuck_get_data () {
int cnt = 0;
Wire.requestFrom (0x52, 6); // solicitar datos de nunchuck
while (Wire.available ()) {
// recibir byte como un entero
#if (ARDUINO & gt; = 100)
nunchuck_buf [cnt] = nunchuk_decode_byte (Wire.read ());
#else
nunchuck_buf [cnt] = nunchuk_decode_byte (Wire.receive ());
#endif
cnt ++;
}
nunchuck_send_request (); // enviar solicitud para la siguiente carga de datos
// Si recibimos los 6 bytes, entonces imprímalos
if (cnt & gt; = 5) {
retorno 1; // éxito
}
devuelve 0; // fracaso
}
// Imprime los datos de entrada que hemos recibido
// los datos de aceleración tienen 10 bits de longitud
// entonces leemos 8 bits, luego tenemos que agregar
// en los últimos 2 bits. Por eso yo
// multiplícalos por 2 * 2
static void nunchuck_print_data () {
estática 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 para los botones zyc
// también contiene los bits menos significativos para los datos del acelerómetro
// así que tenemos que verificar cada bit de salida de byte [5]
if ((nunchuck_buf [5] & gt; & gt; 0) & 1)
z_button = 1;
if ((nunchuck_buf [5] & gt; & gt; 1) & 1)
c_button = 1;
if ((nunchuck_buf [5] & gt; & gt; 2) & 1)
accel_x_axis + = 1;
if ((nunchuck_buf [5] & gt; & gt; 3) & 1)
accel_x_axis + = 2;
if ((nunchuck_buf [5] & gt; & gt; 4) & 1)
accel_y_axis + = 1;
if ((nunchuck_buf [5] & gt; & gt; 5) & 1)
accel_y_axis + = 2;
if ((nunchuck_buf [5] & gt; & gt; 6) & 1)
accel_z_axis + = 1;
if ((nunchuck_buf [5] & gt; & gt; 7) & 1)
accel_z_axis + = 2;
Serial.print (i, DEC);
Serial.print ("\ t");
Serial.print ("alegría:");
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 ("pero:");
Serial.print (z_button, DEC);
Serial.print (",");
Serial.print (c_button, DEC);
Serial.print ("\ r \ n"); // nueva línea
i ++;
}
// devuelve el estado del botón z: 1 = presionado, 0 = no presionado
static int nunchuck_zbutton () {
return ((nunchuck_buf [5] & gt; & gt; 0) & 1)? 0-1 // vudú
}
// devuelve el estado del botón z: 1 = presionado, 0 = no presionado
static int nunchuck_cbutton () {
return ((nunchuck_buf [5] & gt; & gt; 1) & 1)? 0-1 // vudú
}
// devuelve el valor del joystick del eje x
static int nunchuck_joyx () {
devuelve nunchuck_buf [0];
}
// devuelve el valor del joystick del eje y
static int nunchuck_joyy () {
return nunchuck_buf [1];
}
// devuelve el valor del acelerómetro del eje x
static int nunchuck_accelx () {
return nunchuck_buf [2]; // FIXME: esto deja fuera 2 bits de los datos
}
// devuelve el valor del acelerómetro del eje y
static int nunchuck_accely () {
return nunchuck_buf [3]; // FIXME: esto deja fuera 2 bits de los datos
}
// devuelve el valor del acelerómetro del eje z
static int nunchuck_accelz () {
return nunchuck_buf [4]; // FIXME: esto deja fuera 2 bits de los datos
}
int loop_cnt = 0;
byte joyx, joyy, zbut, cbut, accx, accy, accz;
vacío _print () {
Serial.print ("\ tX Joy:");
Serial.print (mapa (joyx, 15, 221, 0, 255));
Serial.print ("\ tY Joy:");
Serial.println (mapa (joyy, 29, 229, 0, 255));
}
int joyx1 = 129; // 15 - 221
int joyy1 = 124; // 29 - 229
configuración nula () {
Serial.begin (9600);
nunchuck_setpowerpins ();
nunchuck_init (); // envía el apretón de manos de inicialización
Serial.println ("Listo para Wii Nunchuck");
pinMode (3, SALIDA);
pinMode (5, SALIDA);
pinMode (6, SALIDA);
pinMode (9, SALIDA);
// type ();
}
bucle vacío () {
if (loop_cnt & gt; 10) {// cada 100 ms se obtienen nuevos datos
loop_cnt = 0;
nunchuck_get_data ();
zbut = nunchuck_zbutton ();
joyx = nunchuck_joyx (); // 15 - 221
joyy = nunchuck_joyy (); // 29 - 229
_print ();
}
loop_cnt ++;
if (zbut == 1) {
tipo ();
zbut = 0;
}
más {
if (joyx & gt; (joyx1 + 20)) {
int speed1 = map (joyx - joyx1, 0, 80, 40, 255);
velocidad1 = restricción (velocidad1, 0, 255);
analogWrite (6, 0);
analogWrite (9, velocidad1);
}
si no (joyx & lt; (joyx1-20)) {
int speed2 = map (joyx1 - joyx, 0, 90, 40, 255);
velocidad2 = restricción (velocidad2, 0, 255);
analogWrite (6, velocidad2);
analogWrite (9, 0);
}
más {
analogWrite (6, 0);
analogWrite (9, 0);
}
if (joyy & gt; (joyy1 + 20)) {
int speed3 = map (joyy - joyy1, 0, 80, 40, 255);
velocidad3 = restricción (velocidad3, 0, 255);
analogWrite (3, 0);
analogWrite (5, velocidad3);
}
si no (joyy & lt; (joyy1-20)) {
int speed4 = map (joyy1 - joyy, 0, 90, 40, 255);
velocidad4 = restricción (velocidad4, 0, 255);
analogWrite (3, velocidad 4);
analogWrite (5, 0);
}
más {
analogWrite (3, 0);
analogWrite (5, 0);
}
}
retraso (1);
}
tipo vacío () {
int rltime = 200;
// digitalWrite (6, 1); // origen
// digitalWrite (9, 0);
// digitalWrite (3, 1);
// digitalWrite (5, 0);
// retraso (1000);
// H ===============
// digitalWrite (3, 0); // espera
// digitalWrite (5, 0);
// digitalWrite (6, 0);
// digitalWrite (9, 0);
// retraso (250);
// digitalWrite (3, 0); // arriba
digitalWrite (5, 1);
retraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (3, 1); // abajo
// digitalWrite (5, 0);
retraso (250);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
// digitalWrite (6, 0); // derecha
digitalWrite (9, 1);
retraso (tiempo de ejecución);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
// digitalWrite (3, 0); // arriba
digitalWrite (5, 1);
retraso (250);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (3, 1); // abajo
// digitalWrite (5, 0);
retraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
// digitalWrite (6, 0); // derecha
digitalWrite (9, 1);
retraso (tiempo de ejecución);
// I ==========================
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (3, 0); // arriba
digitalWrite (5, 1);
retraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (6, 0); // derecha
digitalWrite (9, 1);
retraso (100);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (6, 1); // izquierda
digitalWrite (9, 0);
retraso (tiempo de ejecución);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (6, 0); // derecha
digitalWrite (9, 1);
retraso (100);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (3, 1); // abajo
digitalWrite (5, 0);
retraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (6, 0); // derecha
digitalWrite (9, 1);
retraso (100);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
digitalWrite (6, 1); // izquierda
digitalWrite (9, 0);
retraso (tiempo de ejecución);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retraso (250);
}
Después de encenderlo, un dispositivo correctamente ensamblado comienza a funcionar de inmediato. Nunchuck es un joystick analógico, por lo que puede controlar no solo la dirección, sino también la velocidad de movimiento. Arduino se hace cargo del control de velocidad PWM. Si el movimiento a lo largo de cualquiera de los ejes ocurre en la dirección opuesta, el motor correspondiente debe invertirse. Al colocar el cursor aproximadamente en el centro de la pantalla y presionar el botón Z, puede hacer que el dispositivo escriba automáticamente la palabra HI.
