Viele hatten dieses Spielzeug in der Kindheit, wir haben es mit zwei Drehknöpfen gesteuert. Schon damals war es möglich, zwei Gleichstrommotoren mit Zahnrädern daran anzuschließen und über die Tasten zu steuern. Und jetzt ist es möglich geworden, die Joysticks anzupassen. Welches ist, was der Autor von Instructables unter dem Spitznamen millerman4487 getan hat.
Es mussten jedoch zwei identische Teile gedruckt werden - dies sind Adapter zum Anschließen von Zahnrädern an die Magic Screen-Griffe. Es sieht aus wie einer der Adapter:
Und so wird es mit dem Getriebe verbunden (möglicherweise muss der Adapter mit einem Haartrockner leicht erwärmt werden):
STL-Datei.
Es gibt nur eine unverständliche Komponente - den L293D-Chip. Es enthält zwei sogenannte H-Brücken, von denen jede den daran angeschlossenen Motor umkehren kann. Unterhalb der Tafel wird gezeigt, welche Schlussfolgerungen gezogen werden
Verbinden Sie die Stifte des Wii Nunchuck-Joystick-Anschlusses. Die folgende Skizze kann umgeschrieben werden, um mit anderen Arten von Joysticks zu arbeiten. In der aktuellen Form ist sie erforderlich.
#include
#if (ARDUINO & gt; = 100)
#include
#else
#include
// # Wire.write (x) definieren Wire.send (x)
// # definiere Wire.read () Wire.receive ()
#endif
statisch uint8_t nunchuck_buf [6]; // Array zum Speichern von Nunchuck-Daten,
// Verwendet Port C (Analog In) Pins als Power & Ground für Nunchuck
statische Leere nunchuck_setpowerpins () {
#define pwrpin PORTC3
#define gndpin PORTC2
DDRC | = _BV (pwrpin) | _BV (gndpin);
PORTC & = ~ _BV (gndpin);
PORTC | = _BV (pwrpin);
Verzögerung (100); // warte bis sich die Dinge stabilisiert haben
}}
// I2C-System initialisieren, I2C-Bus anschließen,
// und sag dem Nunchuck, dass wir mit ihm reden
statische Leere nunchuck_init () {
Wire.begin (); // i2c Bus als Master beitreten
Wire.beginTransmission (0x52); // an Gerät 0x52 senden
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x40); // sendet die Speicheradresse
Wire.write ((uint8_t) 0x00); // sendet eine gesendete Null.
#else
Wire.send ((uint8_t) 0x40); // sendet eine Speicheradresse
Wire.send ((uint8_t) 0x00); // sendet eine gesendete Null.
#endif
Wire.endTransmission (); // Übertragung beenden
}}
// Sende eine Datenanforderung an das Nunchuck
// war "send_zero ()"
statische Leere nunchuck_send_request () {
Wire.beginTransmission (0x52); // an Gerät 0x52 senden
#if (ARDUINO & gt; = 100)
Wire.write ((uint8_t) 0x00); // sendet ein Byte
#else
Wire.send ((uint8_t) 0x00); // sendet ein Byte
#endif
Wire.endTransmission (); // Übertragung beenden
}}
// Daten codieren, um die meisten Wiimote-Treiber außer zu formatieren
// wird nur benötigt, wenn Sie einen der regulären Wiimote-Treiber verwenden
statisches Zeichen nunchuk_decode_byte (char x) {
x = (x ^ 0x17) + 0x17;
return x;
}}
// Daten vom Nunchuck zurückerhalten,
// gibt bei erfolgreichem Lesen 1 zurück. Gibt bei einem Fehler 0 zurück
static int nunchuck_get_data () {
int cnt = 0;
Wire.requestFrom (0x52, 6); // Daten von Nunchuck anfordern
while (Wire.available ()) {
// Byte als Ganzzahl empfangen
#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 (); // Anfrage für nächste Datennutzlast senden
// Wenn wir die 6 Bytes erhalten haben, drucken Sie sie aus
if (cnt & gt; = 5) {
return 1; // Erfolg
}}
return 0; // Fehler
}}
// Drucke die Eingangsdaten, die wir erhalten haben
// Beschleunigungsdaten sind 10 Bit lang
// Also lesen wir 8 Bits, dann müssen wir hinzufügen
// auf den letzten 2 Bits. Deshalb ich
// multipliziere sie mit 2 * 2
statische Leere nunchuck_print_data () {
statisch 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] enthält Bits für die Schaltflächen z und c
// Es enthält auch die niedrigstwertigen Bits für die Beschleunigungsmesserdaten
// also müssen wir jedes Bit von Byte outbuf [5] überprüfen
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 ("Freude:");
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 ("aber:");
Serial.print (z_button, DEC);
Serial.print (",");
Serial.print (c_button, DEC);
Serial.print ("\ r \ n"); // Newline
i ++;
}}
// gibt den Zbutton-Status zurück: 1 = gedrückt, 0 = nicht gedrückt
static int nunchuck_zbutton () {
return ((nunchuck_buf [5] & gt; & gt; 0) & 1)? 0-1 // Voodoo
}}
// gibt den Zbutton-Status zurück: 1 = gedrückt, 0 = nicht gedrückt
static int nunchuck_cbutton () {
return ((nunchuck_buf [5] & gt; & gt; 1) & 1)? 0-1 // Voodoo
}}
// gibt den Wert des x-Achsen-Joysticks zurück
statisch int nunchuck_joyx () {
return nunchuck_buf [0];
}}
// gibt den Wert des Joysticks der y-Achse zurück
static int nunchuck_joyy () {
return nunchuck_buf [1];
}}
// gibt den Wert des Beschleunigungsmessers der x-Achse zurück
static int nunchuck_accelx () {
return nunchuck_buf [2]; // FIXME: Dies lässt 2-Bit der Daten weg
}}
// gibt den Wert des Beschleunigungsmessers der y-Achse zurück
static int nunchuck_accely () {
return nunchuck_buf [3]; // FIXME: Dies lässt 2-Bit der Daten weg
}}
// gibt den Wert des Beschleunigungsmessers der Z-Achse zurück
static int nunchuck_accelz () {
return nunchuck_buf [4]; // FIXME: Dies lässt 2-Bit der Daten weg
}}
int loop_cnt = 0;
Byte joyx, joyy, zbut, cbut, accx, accy, accz;
void _print () {
Serial.print ("\ tX Joy:");
Serial.print (Karte (joyx, 15, 221, 0, 255));
Serial.print ("\ tY Joy:");
Serial.println (Karte (joyy, 29, 229, 0, 255));
}}
int joyx1 = 129; // 15 - 221
int joyy1 = 124; // 29 - 229
void setup () {
Serial.begin (9600);
nunchuck_setpowerpins ();
nunchuck_init (); // Sende den Initilisierungs-Handshake
Serial.println ("Wii Nunchuck Ready");
PinMode (3, OUTPUT);
PinMode (5, OUTPUT);
PinMode (6, OUTPUT);
PinMode (9, OUTPUT);
// type ();
}}
void loop () {
if (loop_cnt & gt; 10) {// alle 100 ms erhalten neue Daten
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) {
Typ ();
zbut = 0;
}}
sonst {
if (joyx & gt; (joyx1 + 20)) {
int speed1 = map (joyx - joyx1, 0, 80, 40, 255);
Geschwindigkeit1 = Einschränkung (Geschwindigkeit1, 0, 255);
analogWrite (6, 0);
analogWrite (9, speed1);
}}
sonst wenn (joyx & lt; (joyx1 - 20)) {
int speed2 = map (joyx1 - joyx, 0, 90, 40, 255);
Geschwindigkeit2 = Einschränkung (Geschwindigkeit2, 0, 255);
analogWrite (6, speed2);
analogWrite (9, 0);
}}
sonst {
analogWrite (6, 0);
analogWrite (9, 0);
}}
if (joyy & gt; (joyy1 + 20)) {
int speed3 = map (joyy - joyy1, 0, 80, 40, 255);
Geschwindigkeit3 = Einschränkung (Geschwindigkeit3, 0, 255);
analogWrite (3, 0);
analogWrite (5, speed3);
}}
sonst wenn (joyy & lt; (joyy1 - 20)) {
int speed4 = map (joyy1 - joyy, 0, 90, 40, 255);
Geschwindigkeit4 = Einschränkung (Geschwindigkeit4, 0, 255);
analogWrite (3, speed4);
analogWrite (5, 0);
}}
sonst {
analogWrite (3, 0);
analogWrite (5, 0);
}}
}}
Verzögerung (1);
}}
void type () {
int rltime = 200;
// digitalWrite (6, 1); // Ursprung
// digitalWrite (9, 0);
// digitalWrite (3, 1);
// digitalWrite (5, 0);
// delay (1000);
// H ===============
// digitalWrite (3, 0); // warte
// digitalWrite (5, 0);
// digitalWrite (6, 0);
// digitalWrite (9, 0);
// delay (250);
// digitalWrite (3, 0); // up
digitalWrite (5, 1);
Verzögerung (500);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (3, 1); // down
// digitalWrite (5, 0);
Verzögerung (250);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
// digitalWrite (6, 0); // richtig
digitalWrite (9, 1);
Verzögerung (Zeit);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
// digitalWrite (3, 0); // up
digitalWrite (5, 1);
Verzögerung (250);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (3, 1); // down
// digitalWrite (5, 0);
Verzögerung (500);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
// digitalWrite (6, 0); // richtig
digitalWrite (9, 1);
Verzögerung (Zeit);
// I ==========================
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (3, 0); // up
digitalWrite (5, 1);
Verzögerung (500);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (6, 0); // rechts
digitalWrite (9, 1);
Verzögerung (100);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (6, 1); // left
digitalWrite (9, 0);
Verzögerung (Zeit);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (6, 0); // rechts
digitalWrite (9, 1);
Verzögerung (100);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (3, 1); // down
digitalWrite (5, 0);
Verzögerung (500);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (6, 0); // rechts
digitalWrite (9, 1);
Verzögerung (100);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
digitalWrite (6, 1); // left
digitalWrite (9, 0);
Verzögerung (Zeit);
digitalWrite (3, 0); // warte
digitalWrite (5, 0);
digitalWrite (6, 0);
digitalWrite (9, 0);
Verzögerung (250);
}}
Nach dem Einschalten funktioniert ein korrekt montiertes Gerät sofort. Nunchuck ist ein analoger Joystick, mit dem Sie nicht nur die Richtung, sondern auch die Bewegungsgeschwindigkeit steuern können. Arduino übernimmt die PWM-Geschwindigkeitsregelung. Wenn eine Bewegung entlang einer der Achsen in die entgegengesetzte Richtung erfolgt, muss der entsprechende Motor umgekehrt werden. Wenn Sie den Cursor ungefähr in der Mitte des Bildschirms platzieren und die Z-Taste drücken, kann das Gerät das Wort HI automatisch schreiben.
