Beaucoup ont eu ce jouet dans l'enfance, nous l'avons contrôlé avec deux boutons rotatifs. Même alors, il était possible d'y attacher deux moteurs à courant continu avec des engrenages et de les contrôler à partir des boutons. Et maintenant, pour cela, il est devenu possible d'adapter les joysticks. C'est ce qu'a fait l'auteur d'Instructables sous le surnom de millerman4487.
Mais deux pièces identiques ont dû être imprimées - ce sont des adaptateurs pour connecter les engrenages aux poignées Magic Screen. Il ressemble à l'un des adaptateurs:
Et donc il se connecte à la boîte de vitesses (cela nécessitera peut-être un peu de réchauffement de l'adaptateur avec un sèche-cheveux):
Fichier STL.
Il n'y a qu'un seul composant incompréhensible dessus - la puce L293D. Il contient deux soi-disant ponts en H, dont chacun peut inverser le moteur qui lui est connecté. Sous le tableau, il est montré quelles conclusions
Connectez laquelle des broches du connecteur du joystick Wii Nunchuck. Le croquis ci-dessous peut être réécrit pour fonctionner avec tout autre type de joysticks, dans sa forme actuelle, il sera nécessaire.
#include
#if (ARDUINO & gt; = 100)
#include
#else
#include
// # définir Wire.write (x) Wire.send (x)
// # définir Wire.read () Wire.receive ()
#endif
uint8_t statique nunchuck_buf [6]; // tableau pour stocker les données nunchuck,
// Utilise les broches du port C (entrée analogique) comme alimentation et masse pour Nunchuck
statique void nunchuck_setpowerpins () {
#define pwrpin PORTC3
#define gndpin PORTC2
DDRC | = _BV (pwrpin) | _BV (gndpin);
PORTC & = ~ _BV (gndpin);
PORTC | = _BV (pwrpin);
retard (100); // attendre que les choses se stabilisent
}
// initialiser le système I2C, rejoindre le bus I2C,
// et dis au nunchuck qu'on en parle
static void nunchuck_init () {
Wire.begin (); // rejoindre le bus i2c en tant que maître
Wire.beginTransmission (0x52); // transmettre au périphérique 0x52
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x40); // envoie l'adresse mémoire
Wire.write ((uint8_t) 0x00); // envoie un zéro.
#else
Wire.send ((uint8_t) 0x40); // envoie l'adresse mémoire
Wire.send ((uint8_t) 0x00); // envoie un zéro.
#endif
Wire.endTransmission (); // arrête de transmettre
}
// Envoie une demande de données au nunchuck
// était "send_zero ()"
vide statique nunchuck_send_request () {
Wire.beginTransmission (0x52); // transmettre au périphérique 0x52
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x00); // envoie un octet
#else
Wire.send ((uint8_t) 0x00); // envoie un octet
#endif
Wire.endTransmission (); // arrête de transmettre
}
// Encode les données au format que la plupart des pilotes wiimote sauf
// nécessaire uniquement si vous utilisez l'un des pilotes wiimote habituels
char statique nunchuk_decode_byte (char x) {
x = (x ^ 0x17) + 0x17;
return x;
}
// Reçoit les données du nunchuck,
// renvoie 1 en cas de lecture réussie. renvoie 0 en cas d'échec
static int nunchuck_get_data () {
int cnt = 0;
Wire.requestFrom (0x52, 6); // demande des données à nunchuck
while (Wire.available ()) {
// reçoit l'octet sous forme d'entier
#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 (); // envoie une demande pour la prochaine charge utile de données
// Si nous avons reçu les 6 octets, alors allez les imprimer
si (cnt & gt; = 5) {
retour 1; // succès
}
retourner 0; // échec
}
// Imprimer les données d'entrée que nous avons reçues
// les données d'accel ont une longueur de 10 bits
// donc on lit 8 bits, alors il faut ajouter
// sur les 2 derniers bits. Voilà pourquoi je
// multipliez-les par 2 * 2
statique void nunchuck_print_data () {
statique 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;
// octet nunchuck_buf [5] contient des bits pour les boutons z et c
// il contient également les bits les moins significatifs pour les données de l'accéléromètre
// nous devons donc vérifier chaque bit de octet 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 ("joie:");
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 ("mais:");
Serial.print (z_button, DEC);
Serial.print (",");
Serial.print (c_button, DEC);
Serial.print ("\ r \ n"); // nouvelle ligne
i ++;
}
// retourne l'état zbutton: 1 = pressé, 0 = non pressé
static int nunchuck_zbutton () {
return ((nunchuck_buf [5] & gt; & gt; 0) & 1)? 0-1 // vaudou
}
// retourne l'état zbutton: 1 = pressé, 0 = non pressé
static int nunchuck_cbutton () {
return ((nunchuck_buf [5] & gt; & gt; 1) & 1)? 0-1 // vaudou
}
// renvoie la valeur du joystick de l'axe des x
static int nunchuck_joyx () {
return nunchuck_buf [0];
}
// renvoie la valeur du joystick de l'axe y
static int nunchuck_joyy () {
return nunchuck_buf [1];
}
// renvoie la valeur de l'accéléromètre de l'axe des x
static int nunchuck_accelx () {
return nunchuck_buf [2]; // FIXME: cela laisse de côté 2 bits des données
}
// renvoie la valeur de l'accéléromètre de l'axe y
static int nunchuck_accely () {
return nunchuck_buf [3]; // FIXME: cela laisse de côté 2 bits des données
}
// renvoie la valeur de l'accéléromètre de l'axe z
static int nunchuck_accelz () {
return nunchuck_buf [4]; // FIXME: cela laisse de côté 2 bits des données
}
int loop_cnt = 0;
octet joyx, joyy, zbut, cbut, accx, accy, accz;
void _print () {
Serial.print ("\ tX Joy:");
Serial.print (carte (joyx, 15, 221, 0, 255));
Serial.print ("\ tY Joy:");
Serial.println (carte (joyy, 29, 229, 0, 255));
}
int joyx1 = 129; // 15 - 221
int joyy1 = 124; // 29 - 229
void setup () {
Serial.begin (9600);
nunchuck_setpowerpins ();
nunchuck_init (); // envoie la poignée de main d'initialisation
Serial.println ("Wii Nunchuck Ready");
pinMode (3, SORTIE);
pinMode (5, SORTIE);
pinMode (6, SORTIE);
pinMode (9, SORTIE);
// type ();
}
boucle vide () {
if (loop_cnt & gt; 10) {// toutes les 100 ms obtiennent de nouvelles données
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;
}
sinon {
if (joyx & gt; (joyx1 + 20)) {
int speed1 = map (joyx - joyx1, 0, 80, 40, 255);
speed1 = contrainte (speed1, 0, 255);
analogWrite (6, 0);
analogWrite (9, speed1);
}
sinon si (joyx & lt; (joyx1 - 20)) {
int speed2 = map (joyx1 - joyx, 0, 90, 40, 255);
speed2 = contrainte (speed2, 0, 255);
analogWrite (6, speed2);
analogWrite (9, 0);
}
sinon {
analogWrite (6, 0);
analogWrite (9, 0);
}
if (joyy & gt; (joyy1 + 20)) {
int speed3 = map (joyy - joyy1, 0, 80, 40, 255);
speed3 = contrainte (speed3, 0, 255);
analogWrite (3, 0);
analogWrite (5, speed3);
}
sinon si (joyy & lt; (joyy1 - 20)) {
int speed4 = map (joyy1 - joyy, 0, 90, 40, 255);
speed4 = contrainte (speed4, 0, 255);
analogWrite (3, speed4);
analogWrite (5, 0);
}
sinon {
analogWrite (3, 0);
analogWrite (5, 0);
}
}
retard (1);
}
void type () {
int rltime = 200;
// digitalWrite (6, 1); // origine
// digitalWrite (9, 0);
// digitalWrite (3, 1);
// digitalWrite (5, 0);
// délai (1000);
// H ===============
// digitalWrite (3, 0); // attendre
// digitalWrite (5, 0);
// digitalWrite (6, 0);
// digitalWrite (9, 0);
// retard (250);
// digitalWrite (3, 0); // haut
digitalWrite (5, 1);
retard (500);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (3, 1); // vers le bas
// digitalWrite (5, 0);
retard (250);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
// digitalWrite (6, 0); // droite
digitalWrite (9, 1);
retard (rltime);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
// digitalWrite (3, 0); // haut
digitalWrite (5, 1);
retard (250);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (3, 1); // vers le bas
// digitalWrite (5, 0);
retard (500);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
// digitalWrite (6, 0); // droite
digitalWrite (9, 1);
retard (rltime);
// I ==========================
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (3, 0); // up
digitalWrite (5, 1);
retard (500);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (6, 0); // droite
digitalWrite (9, 1);
retard (100);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (6, 1); // gauche
digitalWrite (9, 0);
retard (rltime);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (6, 0); // droite
digitalWrite (9, 1);
retard (100);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (3, 1); // vers le bas
digitalWrite (5, 0);
retard (500);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (6, 0); // droite
digitalWrite (9, 1);
retard (100);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
digitalWrite (6, 1); // gauche
digitalWrite (9, 0);
retard (rltime);
digitalWrite (3, 0); // attendre
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
retard (250);
}
Après la mise sous tension, un appareil correctement assemblé commence à fonctionner immédiatement. Nunchuck est un joystick analogique, vous pouvez donc contrôler non seulement la direction, mais aussi la vitesse de déplacement. Arduino prend le contrôle de la vitesse PWM. Si un mouvement le long de l'un des axes se produit dans la direction opposée, le moteur correspondant doit être inversé. En plaçant le curseur approximativement au milieu de l'écran et en appuyant sur le bouton Z, vous pouvez faire écrire automatiquement le mot HI par l'appareil.
