Wenn es ein Spiel gibt, das süchtig macht, dann ist es das Labyrinth, bei dem man einen Ball über eine mehr oder weniger schwierige Strecke tragen muss und dabei vermeiden muss, in die Löcher zu fallen, die verhindern, dass man sein Ziel erreicht und die Strecke von vorne beginnen muss. Egal wie schwierig der Weg ist, du willst immer ans Ziel kommen und wirst es immer wieder versuchen, bis du die Strecke geschafft hast. Ball-Labyrinthe gab es schon immer, in allen Formaten, groß und klein, bei dieser Gelegenheit werden wir eines machen, das Elektronik und Herausforderung kombiniert.
Diese Art von Spiel ist ideal für das Spielen mit der Familie und insbesondere für die jüngsten Mitglieder des Haushalts, da es die Konzentration fördert, um das Ziel zu erreichen, da sie den Weg verfolgen müssen, ohne in die Löcher zu fallen, und die Hand-Augen-Koordination entwickelt. Es fördert auch die Ausdauer und Geduld, um das Ziel zu erreichen.
Die benötigten Materialien sind:
- 3 mm dickes Balsaholz und Weißholzleim
Die erforderliche Software ist:
-
Arduino IDE
-
Servo.h library (download from arduino.cc)
Schaltung und Beschreibung der verwendeten Module
Die Schaltung dieses Projekts ist sehr einfach, da das KY-023-Joystick-Modul verwendet wird, um die Bewegung des Labyrinths mit Hilfe der beiden MG995-Servomotoren zu steuern, wobei jeder Servomotor einen der Rahmen bewegt und die gesamte Baugruppe durch den NANO-Mikrocontroller gesteuert wird. Für die Stromversorgung wurde das MB-102-Netzteil gewählt.
Beschreibung der Funktionsweise des Projekts und Skizze
Die Funktionsweise dieses Labyrinths ist sehr einfach, es wird vollständig horizontal sein, wenn es nicht durch den Joystick interagiert wird, die Ausgangsposition in Grad der beiden Servomotoren wird 90 Grad betragen und wenn mit dem Joystick interagiert wird, werden die Servomotoren die Position des Labyrinths in Richtung der mit dem Joystick angegebenen Position ändern, um die Kugel in Richtung der gewählten Position zu lenken. Es ist zu beachten, dass die Bewegungsgrade des Labyrinths nicht sehr groß sein sollten, zwischen 87 und 93 Grad für beide Servomotoren, um die Kugel angemessen steuern zu können. In diesem Projekt wurden die Freiheitsgrade auf insgesamt 6 Bewegungsgrade in jeder Achse festgelegt, die auf Wunsch angepasst werden können.
Der mechanische Aufbau des Labyrinths besteht aus zwei quadratischen Ringen, der Basisträger enthält den ersten Servomotor, der den ersten Ring auf einer seiner Achsen bewegt, dieser erste Ring enthält auch einen weiteren Servomotor, der den zweiten Ring antreibt, der sich im Inneren des ersten Rings befindet. Der zweite Ring wurde mit L-Winkeln konstruiert, damit der Weg des Labyrinths leicht geändert werden kann, so dass die mechanische Baugruppe immer zur Verfügung steht und wir durch Änderung des Weges im Inneren des kleineren Rings einen neuen Weg erhalten.
Die Funktionsweise der elektronischen Schaltung dieses Projekts ist wie folgt: Damit sich die Servomotoren bewegen, muss das Joystick-Modul KY-023 betätigt werden, das zwei interne Potentiometer enthält, eines für jede Achse. Die Spannung, die die analogen Ports des Mikrocontrollers empfangen, an denen die Pins VRx und VRy angeschlossen sind, variiert je nach Position des Joystick-Hebels zwischen 0 Volt und 5 Volt Spannung. Der Mikrocontroller soll das analoge Signal der empfangenen Spannung in ein digitales Signal umwandeln. Der AZ-Nano V3 Mikrocontroller hat eine Auflösung von 10 Bit für die Umwandlung von analogen Signalen in digitale Signale, was bedeutet, dass er analoge Signale von 0 bis 5 Volt der Position jeder Achse des Joysticks in digitale Werte von 0 bis 1023 umwandeln muss. Andererseits beträgt der Verfahrweg der Servomotoren 180 Grad, so dass wir die möglichen digitalen Werte des Joysticks von 0 bis 1023 auf Werte zwischen 0 und 180 Grad der Servomotoren skalieren und den Wert der aktuellen Joystickposition auf den entsprechenden Wert der Servomotorengrade abbilden müssen, d. h. den Wert auf einer Skala an einen ähnlichen Wert auf einer anderen Skala anpassen. Wir beginnen mit der Analyse der Skizze.
Die einzige enthaltene Bibliothek ist Servo.h , diese Bibliothek enthält die notwendigen Methoden für den Mikrocontroller, um die Servomotoren zu verwenden. Ein Objekt aus dieser Bibliothek ist auch für jeden der Servomotoren implementiert, die die Achsen bewegen werden, durch diese Objekte werden wir den Servomotor steuern, der notwendig ist.
#include <Servo.h>
Servo servo_x_axis_movement;
Servo servo_y_axis_movement;
In den folgenden Zeilen werden die Variablen definiert, die für die Arbeit mit dem Joystick verwendet werden sollen. Die ersten beiden zu definierenden Variablen werden verwendet, um die analogen Ports anzugeben, an denen die Pins der X- und Y-Achsen des Joysticks angeschlossen sind. Der analoge Port, an dem jede Achse des Joysticks angeschlossen ist, wird als Wert zugewiesen, an den analogen Port 0 wird der VRx-Pin des Joysticks angeschlossen und an den analogen Port 1 wird der VRy-Pin angeschlossen.
int X_pin = 1;
int Y_pin = 0;
Um die aktuellen Werte der X- und Y-Achsen des Joysticks zu speichern, wird für jede Achse eine Variable definiert, die nicht mit einem Wert initialisiert wird.
int val_x_axis;
int val_y_axis;
Wie oben erläutert, variieren die Werte jeder Joystick-Achsenposition von 0 bis 1023, wodurch Variablen für die Mindest- und Höchstwerte jeder Joystick-Achse definiert werden, die mit den entsprechenden Werten initialisiert werden.
int x_axis_max_value = 1023;
int x_axis_min_value = 0;
int y_axis_max_value = 1023;
int y_axis_min_value = 0;
Mit der Definition der vier vorhergehenden Variablen ist der Variablendefinitionsblock abgeschlossen, mit dem die Methode setup() implementiert wird. In dieser Methode werden nur die digitalen Ports definiert, an denen die einzelnen Servomotoren angeschlossen sind; für die Bewegung der X-Achse wurde der Servomotor an den digitalen Port 2 angeschlossen und der Servomotor, der die Y-Achse bewegen wird, an den digitalen Port 3.
servo_x_axis_movement.attach(2);
servo_y_axis_movement.attach(3);
Zu Beginn der loop()-Methode wird zunächst die Spannung der Pins jeder Achse des KY-023-Moduls mit dem Befehl analogRead(axis_pin) über die analogen Ports des Mikrocontrollers gelesen, dann wird intern die empfangene analoge Spannung zwischen 0 und 5 VDC in einen digitalen Wert zwischen 0 und 1023 umgewandelt und in der entsprechenden val_name_axis-Variable jeder Achse gespeichert. Die Zeilen des Codes sind:
val_x_axis = analogRead(X_pin);
val_y_axis = analogRead(Y_pin);
Sobald der analoge Wert in einen digitalen Wert umgewandelt wurde, werden doppelte Bedingungen if - else if implementiert, um den Wert jeder Achse zu überprüfen. Wie in der obigen Abbildung des Joysticks zu sehen ist, befindet sich der Joystick im Ruhezustand in der Mitte jeder Achse und hat digitale Werte von ungefähr 511 auf jeder Achse. In der Bedingung wenn wird mit dem Ausdruck val_x_axis > 511 geprüft, ob der gelesene und in der Variablen val_x_axis gespeicherte Wert größer als der Mittelpunkt der digitalen Skala ist. Wenn dieser Ausdruck wahr ist, wird der Befehlsblock in seinen Tasten ausgeführt.
if (val_x_axis > 511) {
. . .
. . .
}
Die erste Zeile des Blocks ändert den Wert der Variablen x_axis_max_value des maximalen Wertes der Skala der digitalen Werte der X-Achse, dies geschieht, um die Reaktion der Bewegung des X-Achsen-Servomotors in Richtung seiner neuen Position zu beschleunigen, je höher der Wert der Joystick-Position ist, desto niedriger ist die maximale Grenze, an die wir uns erinnern, 1023, so dass die für die Konvertierung und das Mapping erforderliche Zeit geringer ist. Wir subtrahieren den digitalen Wert der Variablen val_x_axis, der der aktuelle Wert der X-Achse des Joysticks ist, vom maximalen Wert der digitalen Skala, der 1023 ist, und addieren den Durchschnittswert (511) der digitalen Skala. Der neue Wert der oberen Grenze wird in der Variablen x_axis_max_value gespeichert. In der zweiten Zeile des Blocks wird der untere Grenzwert auf Null gesetzt, da sich der Servomotor der X-Achse nicht in diese Richtung bewegen soll, da die aktuelle Position des Servomotors nicht abnehmen soll.
x_axis_max_value = 1023 - val_x_axis + 511;
x_axis_min_value = 0;
Wenn die Bedingung if falsch ist, wird ihr Anweisungsblock nicht ausgeführt und die else if Anweisungsprüfung wird durchgeführt, die prüft, ob der Wert der X-Achsenposition, der in der Variablen val_x_axis gespeichert ist, kleiner ist als 511 mit val_x_axis < 511, wenn diese Bedingung wahr ist, wird der Anweisungsblock innerhalb seiner geschweiften Klammern ausgeführt.
else if (val_x_axis < 511) {
. . .
. . .
}
Innerhalb des Befehlsblocks wird in der ersten Zeile in der Variablen x_axis_max_value die obere Grenze der digitalen Skala mit ihrem Maximalwert von 1023 gespeichert. Da der aktuelle Wert der X-Achsenposition des Joysticks unter dem Skalenmittelpunkt liegt, wird der aktuelle Wert in der Variablen x_axis_value vom Skalenmittelpunkt (511) subtrahiert, wodurch der Wert der unteren Grenze erhöht wird, weniger Zeit für die Umwandlung und das Mapping zur Verfügung steht und die Reaktionszeit des X-Achsen-Servomotors beschleunigt wird. Der Wert der neuen unteren Grenze wird in der Variable x_axis_min_value gespeichert.
x_axis_max_value = 1023;
x_axis_min_value = 511 - val_x_axis;
Die Schritte zur Änderung der Position des Servomotors der Y-Achse, wenn der Joystick in dieser Achse bewegt wird, sind ähnlich wie bei der X-Achse, ändern Sie einfach die Namen der Variablen in val_y_axis, y_axis_max_value e y_axis_min_value
if (val_y_axis > 511) {
y_axis_max_value = 1023 - val_y_axis + 511;
y_axis_min_value = 0;
} else if (val_y_axis < 511) {
y_axis_max_value = 1023;
y_axis_min_value = 511 - val_y_axis;
}
Nachdem die Werte der Joystick-Position und die oberen und unteren Grenzen der Joystick-Achsen ermittelt wurden, müssen sie in gültige Werte für die Servomotoren umgewandelt werden, also müssen die Werte der Joystick-Skalengrenzen skaliert und der Wert der Joystick-Position in seinen Achsen in gültige Werte für die Position der Servomotoren abgebildet werden, d.h. die digitalen Werte der Joystick-Position in die Werte in Grad der Servomotorpositionen umwandeln, alles Erklärte wird mit der Funktion map (Joystickpositionswert, minimale Joystickgrenze, maximale Joystickgrenze, minimale Servomotorposition, maximale Servomotorposition) erledigt und der resultierende Wert dieser Funktion ist die Position in Grad, in der der Servomotor positioniert werden muss, diese wird in der Variablen val_x_axis gespeichert, um sie als Parameter in der Funktion servo_x_axis_movement.write Sie den Servomotor, um sich zu positionieren. Der Minimal- und Maximalwert des Joysticks sind die Werte, die durch die Bedingungen in Bezug auf die Position des Joysticks erhalten werden, während der Minimal- und Maximalwert des Servomotors die Werte sind, zwischen denen sich die Servomotoren bewegen.
Wie bereits erwähnt, wird der Befehl servo_x_axis_movement.write (val_x_axis) verwendet, um den Servomotor in die Position in Grad zu bewegen, die der Joystickposition entspricht, wobei der Wert von val_x_axis die Gradzahl der Position ist, in die sich der Servomotor bewegen muss.
val_x_axis = map (val_x_axis, x_axis_min_value, x_axis_max_value, 87, 93);
servo_x_axis_movement.write (val_x_axis);
Wir haben die Skalierung und das Mapping für die Bewegung der X-Achse analysiert, für die Y-Achse wird es auf ähnliche Weise gemacht, man muss nur die Namen der Variablen ändern, um den Servomotor der Y-Achse in die entsprechende Position zu bringen, sein Code ist wie folgt.
val_x_axis = map (val_x_axis, x_axis_min_value, x_axis_max_value, 87, 93);
servo_x_axis_movement.write (val_x_axis);
VIDEO
Wir hoffen, dass Sie viel Spaß beim Bau dieses Projekts haben und die Route des Labyrinths verändern und den Schwierigkeitsgrad erhöhen oder verringern können.
1 Kommentar
Uwe
Statt Pappe einen 3D Druck?