Muitos tiveram esse brinquedo na infância, nós o controlamos com dois botões rotativos. Mesmo assim, era possível conectar dois motores DC com engrenagens e controlá-los a partir dos botões. E agora, para isso, tornou-se possível adaptar os joysticks. Foi o que o autor de Instructables fez com o apelido millerman4487.
Mas duas peças idênticas tiveram que ser impressas - são adaptadores para conectar as engrenagens às alças do Magic Screen. Parece com qualquer um dos adaptadores:
E, portanto, ele se conecta à caixa de velocidades (talvez isso exija um pouco de aquecimento do adaptador com um secador de cabelo):
Arquivo STL.
Existe apenas um componente incompreensível - o chip L293D. Ele contém duas chamadas pontes H, cada uma das quais pode reverter o motor conectado a ela. Abaixo do quadro, são mostradas as conclusões
Ligue qual dos pinos do conector do joystick do Wii Nunchuck. O esboço abaixo pode ser reescrito para funcionar com qualquer outro tipo de joysticks, na sua forma atual será necessário.
#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]; // array para armazenar dados nunchuck,
// Usa pinos da porta C (entrada analógica) como fonte de alimentação e terra para o Nunchuck
estático nunchuck_setpowerpins () {
#define pwrpin PORTC3
#define gndpin PORTC2
DDRC | = _BV (pwrpin) | _BV (gndpin);
PORTC & = ~ _BV (gndpin);
PORTC | = _BV (pwrpin);
atraso (100); // aguarde que as coisas se estabilizem
}
// inicialize o sistema I2C, entre no barramento I2C,
// e diga ao nunchuck que estamos falando com ele
static void nunchuck_init () {
Wire.begin (); // ingressa no barramento i2c como mestre
Wire.beginTransmission (0x52); // transmite para o dispositivo 0x52
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x40); // envia endereço de memória
Wire.write ((uint8_t) 0x00); // envia enviado um zero.
#else
Wire.send ((uint8_t) 0x40); // envia o endereço de memória
Wire.send ((uint8_t) 0x00); // envia enviado um zero.
#endif
Wire.endTransmission (); // para de transmitir
}
// Envia uma solicitação de dados para o nunchuck
// era "send_zero ()"
static void nunchuck_send_request () {
Wire.beginTransmission (0x52); // transmite para o dispositivo 0x52
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x00); // envia um byte
#else
Wire.send ((uint8_t) 0x00); // envia um byte
#endif
Wire.endTransmission (); // para de transmitir
}
// Codifica dados para formatar a maioria dos drivers wiimote, exceto
// necessário apenas se você usar um dos drivers normais do wiimote
char estático nunchuk_decode_byte (char x) {
x = (x ^ 0x17) + 0x17;
retornar x;
}
// Receba dados de volta do nunchuck,
// retorna 1 na leitura bem-sucedida. retorna 0 em caso de falha
static int nunchuck_get_data () {
int cnt = 0;
Wire.requestFrom (0x52, 6); // solicita dados do nunchuck
while (Wire.available ()) {
// recebe byte como um número inteiro
#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 (); // envia solicitação para a próxima carga útil de dados
// Se recebemos os 6 bytes, imprima-os
if (cnt & gt; = 5) {
retornar 1; // sucesso
}
retornar 0; // falha
}
// Imprime os dados de entrada que recebemos
// os dados de aceleração têm 10 bits
// então lemos 8 bits, então temos que adicionar
// nos últimos 2 bits. É por isso que eu
// multiplique por 2 * 2
estático 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] contém bits para os botões z e c
// também contém os bits menos significativos para os dados do acelerômetro
// então temos que verificar cada bit de byte outbuf [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 ("alegria:");
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"); // nova linha
i ++;
}
// retorna o estado do botão z: 1 = pressionado, 0 = não pressionado
static int nunchuck_zbutton () {
return ((nunchuck_buf [5] & gt; & gt; 0) & 1)? 0-1 // voodoo
}
// retorna o estado do botão z: 1 = pressionado, 0 = não pressionado
static int nunchuck_cbutton () {
return ((nunchuck_buf [5] & gt; & gt; 1) & 1)? 0-1 // voodoo
}
// retorna o valor do joystick do eixo x
static int nunchuck_joyx () {
return nunchuck_buf [0];
}
// retorna o valor do joystick do eixo y
static int nunchuck_joyy () {
return nunchuck_buf [1];
}
// retorna o valor do acelerômetro do eixo x
static int nunchuck_accelx () {
return nunchuck_buf [2]; // FIXME: isso exclui 2 bits dos dados
}
// retorna o valor do acelerômetro do eixo y
static int nunchuck_accely () {
return nunchuck_buf [3]; // FIXME: isso exclui 2 bits dos dados
}
// retorna o valor do acelerômetro do eixo z
static int nunchuck_accelz () {
return nunchuck_buf [4]; // FIXME: isso exclui 2 bits dos dados
}
int loop_cnt = 0;
byte joyx, joyy, zbut, cbut, accx, accy, accz;
void _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
configuração nula () {
Serial.begin (9600);
nunchuck_setpowerpins ();
nunchuck_init (); // envia o handshake de inicialização
Serial.println ("Wii Nunchuck Ready");
pinMode (3, SAÍDA);
pinMode (5, SAÍDA);
pinMode (6, SAÍDA);
pinMode (9, SAÍDA);
// type ();
}
loop vazio () {
if (loop_cnt & gt; 10) {// a cada 100 msecs obtém novos dados
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) {
type ();
zbut = 0;
}
mais {
if (joyx & gt; (joyx1 + 20)) {
int speed1 = mapa (joyx - joyx1, 0, 80, 40, 255);
velocidade1 = restrição (velocidade1, 0, 255);
analogWrite (6,0);
analogWrite (9, velocidade1);
}
caso contrário, se (joyx & lt; (joyx1 - 20)) {
int speed2 = mapa (joyx1 - joyx, 0, 90, 40, 255);
velocidade2 = restrição (velocidade2, 0, 255);
analogWrite (6, velocidade2);
analogWrite (9,0);
}
mais {
analogWrite (6,0);
analogWrite (9,0);
}
if (alegre & gt; (alegre1 + 20)) {
int speed3 = mapa (joyy - joy1, 0, 80, 40, 255);
velocidade3 = restrição (velocidade3, 0, 255);
analogWrite (3, 0);
analogWrite (5, velocidade3);
}
caso contrário, se (alegre & lt; (alegre 1-20)) {
int speed4 = mapa (joyy1 - joyy, 0, 90, 40, 255);
velocidade4 = restrição (velocidade4, 0, 255);
analogWrite (3, velocidade4);
analogWrite (5, 0);
}
mais {
analogWrite (3, 0);
analogWrite (5, 0);
}
}
atraso (1);
}
tipo vazio () {
int tempo = 200;
// digitalWrite (6, 1); // origem
// digitalWrite (9, 0);
// digitalWrite (3, 1);
// digitalWrite (5, 0);
// delay (1000);
// H ===============
// digitalWrite (3, 0); // espera
// digitalWrite (5, 0);
// digitalWrite (6, 0);
// digitalWrite (9, 0);
// delay (250);
// digitalWrite (3, 0); // up
digitalWrite (5, 1);
atraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (3, 1); // para baixo
// digitalWrite (5, 0);
atraso (250);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
// digitalWrite (6, 0); // direita
digitalWrite (9, 1);
atraso (tempo de espera);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
// digitalWrite (3, 0); // up
digitalWrite (5, 1);
atraso (250);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (3, 1); // para baixo
// digitalWrite (5, 0);
atraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
// digitalWrite (6, 0); // direita
digitalWrite (9, 1);
atraso (tempo de espera);
// I ==========================
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (3, 0); // up
digitalWrite (5, 1);
atraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (6, 0); // direita
digitalWrite (9, 1);
atraso (100);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (6, 1); // esquerda
digitalWrite (9,0);
atraso (tempo de espera);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (6, 0); // direita
digitalWrite (9, 1);
atraso (100);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (3, 1); // para baixo
digitalWrite (5, 0);
atraso (500);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (6, 0); // direita
digitalWrite (9, 1);
atraso (100);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
digitalWrite (6, 1); // esquerda
digitalWrite (9,0);
atraso (tempo de espera);
digitalWrite (3, 0); // espera
digitalWrite (5, 0);
digitalWrite (6,0);
digitalWrite (9,0);
atraso (250);
}
Depois de ligar, um dispositivo montado corretamente começa a funcionar imediatamente. O Nunchuck é um joystick analógico, para que você possa controlar não apenas a direção, mas também a velocidade do movimento. O Arduino assume o controle de velocidade PWM. Se o movimento ao longo de qualquer um dos eixos ocorrer na direção oposta, o motor correspondente deverá ser revertido. Ao colocar o cursor aproximadamente no meio da tela e pressionar o botão Z, você pode fazer com que o dispositivo escreva automaticamente a palavra HI.
