Das Ergebnis ist ein ziemlich lustiger Roboter, der Hindernisse vor sich sehen kann, die Situation analysiert und dann, nur die beste Route wählend, weitergeht. Der Roboter erwies sich als sehr wendig. Es kann um 180 Grad gedreht werden, und der Drehwinkel beträgt 45 und 90 Grad. Als Hauptcontroller verwendete der Autor Iteaduino, ein Analogon von Arduino.

Materialien und Werkzeuge zum Bau eines Roboters:
- Mikrocontroller (Arduino oder ähnliches Iteaduino);
- Ultraschallsensor;
- Halter für Batterien;
- Chinesisches Spielzeug zum Erstellen eines Radstands (Sie können fertig kaufen);
- Kabelschneider;
- Kleber;
- Leitungen;
- Motoren;
- Faserplatten;
- Puzzle;
- Transistoren (D882P).

Roboterherstellungsprozess:

Schritt eins. Erstellen eines Radstands
Um einen Radstand zu schaffen, kaufte der Autor zwei chinesische Spielzeugautos. Sie müssen sich darüber jedoch keine Gedanken machen, wenn Sie zusätzliches Geld haben, da Sie eine fertige Basis kaufen können. Mit Hilfe von Drahtschneidern wurden die Autos in zwei Teile geschnitten, um zwei Antriebsachsen zu bilden. Diese Teile wurden dann zusammengeklebt. In diesem Fall können Sie jedoch mit einem Lötkolben arbeiten, der Kunststoff ist perfekt gelötet.

Bei der Auswahl von Autos ist es am besten, Spielzeug mit gewöhnlichen Rädern mitzunehmen, da der Roboter laut Autor mit Stacheln wie seinen viel springt.

Es gibt einen weiteren solchen Moment, in dem Drähte von den Motoren ausgegeben werden. Bei einem von ihnen müssen Sie daran denken, die Polarität zu ändern.

Schritt zwei. Herstellung der oberen Abdeckung
Die obere Abdeckung des Roboters besteht aus Faserplatten, für diesen Zweck kann auch dicke Pappe verwendet werden. In der Abdeckung ist ein rechteckiges Loch zu sehen, das so angeordnet sein muss, dass die Achse des Servos, das darin eingesetzt wird, symmetrisch ist. Durch das Loch in der Mitte werden Drähte ausgegeben.

Schritt drei. Roboterfüllung
Verwenden Sie am besten ein separates Netzteil, um das Chassis anzuschließen, da der Controller 9 V benötigt, um ihn zu versorgen, und nur 3 V für die Motoren. Batteriehalter sind in der Regel bereits im Chassis solcher Maschinen verbaut, sie müssen nur noch parallel geschaltet werden.

Die Anbindung der Motoren an die Steuerung erfolgt über Transistoren vom Typ D882 P. Sie wurden aus der alten Maschinensteuertafel herausgezogen. Es ist natürlich am besten, Leistungstransistoren vom Typ TIP120B zu verwenden, aber der Autor hat einfach nach geeigneten Eigenschaften ausgewählt. Der gesamte elektronische Teil wird nach dem angegebenen Schema angeschlossen.

Nach der Firmware des Roboters ist dieser zum Testen bereit. Damit der Roboter Zeit hat, sich in einem bestimmten Winkel umzudrehen, müssen Sie den richtigen Zeitpunkt für den Betrieb der Motoren wählen.

Bei den Sensoren muss der Ultraschall an den 7. Digitalausgang des Mikrocontrollers angeschlossen werden. Der Servomotor wird mit dem 3. Digitaleingang verbunden, die Basis des Transistors des linken Motors wird mit dem 11. Pin verbunden und die Basis des rechten Motors mit dem 10. Pin.

Wenn Krona als Strom verwendet wird, wird Minus mit GND und Plus mit VIN verbunden. Sie müssen auch den Emitter des Transistors und den negativen Kontakt von der Stromversorgung des Roboterchassis mit GND verbinden.

Hallo an alle. Dieser Artikel ist eine kurze Geschichte darüber, wie tun Roboter ihr Hände. Warum eine Geschichte, fragen Sie? Alles aufgrund der Tatsache, dass für die Herstellung solcher Kunsthandwerk Es ist notwendig, eine beträchtliche Menge an Wissen zu verwenden, das in einem Artikel nur sehr schwer darzustellen ist. Wir gehen durch den Build-Prozess, werfen einen Blick auf den Code und erwecken schließlich die Erschaffung des Silicon Valley zum Leben. Ich rate Ihnen, sich das Video anzusehen, um eine Vorstellung davon zu bekommen, was am Ende passieren soll.

Bevor Sie fortfahren, beachten Sie bitte Folgendes, das in der Herstellung Kunsthandwerk verwendet einen Laserschneider. Sie können einen Laserschneider ablehnen, wenn Sie über ausreichende Erfahrung in der Arbeit mit Ihren Händen verfügen. Genauigkeit ist der Schlüssel zum erfolgreichen Abschluss eines Projekts!

Schritt 1: Wie funktioniert es?

Der Roboter hat 4 Beine mit jeweils 3 Servos, die es ihm ermöglichen, seine Gliedmaßen in 3 Freiheitsgraden zu bewegen. Er bewegt sich mit „schleichender Gangart“. Lass es langsam sein, aber eines der glattesten.

Zuerst müssen Sie dem Roboter beibringen, sich vorwärts, rückwärts, links und rechts zu bewegen, dann einen Ultraschallsensor hinzufügen, der hilft, Hindernisse / Hindernisse zu erkennen, und danach ein Bluetooth-Modul, dank dessen die Robotersteuerung ein neues Niveau erreicht.

Schritt 2: Erforderliche Teile

Skelett aus 2 mm starkem Plexiglas.

Der elektronische Teil des hausgemachten Produkts besteht aus:

• 12 Servos;
• Arduino Nano (kann durch jedes andere Arduino-Board ersetzt werden);

• Schild für Servosteuerung;
• Stromversorgung (im Projekt wurde ein 5V 4A Netzteil verwendet);

• Ultraschallsensor;
• hc 05 Bluetooth-Modul;

Um einen Schild zu machen, benötigen Sie:

• Leiterplatte (vorzugsweise mit gemeinsamen Leitungen (Bussen) von Strom und Masse);
• Pin-Anschlüsse zwischen den Platinen - 30 Stück;
• Steckdosen pro Platine - 36 Stück;

• Leitungen.

Werkzeug:

• Laserschneider (oder geschickte Hände);
• Sekundenkleber;
• Heißkleber.

Schritt 3: Skelett

Lassen Sie uns ein Grafikprogramm verwenden, um die Bestandteile des Skeletts zu zeichnen.

Danach schneiden wir auf jede verfügbare Weise 30 Teile des zukünftigen Roboters aus.

Schritt 4: Montage

Entfernen Sie nach dem Schneiden die Schutzpapierbeschichtung vom Plexiglas.

Als nächstes fahren Sie mit der Montage der Beine fort. In Teile des Skeletts eingebaute Befestigungselemente. Alles, was noch zu tun ist, ist, die Teile zusammenzusetzen. Die Verbindung ist ziemlich fest, aber für mehr Zuverlässigkeit können Sie einen Tropfen Sekundenkleber auf die Befestigungselemente auftragen.

Dann müssen Sie die Servos modifizieren (eine Schraube gegenüber den Servowellen kleben).

Mit dieser Verfeinerung machen wir den Roboter stabiler. Die Veredelung muss nur für 8 Servos durchgeführt werden, die restlichen 4 werden direkt an der Karosserie befestigt.

Wir befestigen die Beine am Verbindungselement (gekrümmter Teil) und es wiederum am Servo am Körper.

Schritt 5: Schild herstellen

Die Herstellung des Bretts ist ganz einfach, wenn Sie den im Schritt gezeigten Fotos folgen.

Schritt 6: Elektronik

Befestigen Sie die Servostifte auf der Arduino-Platine. Die Pins müssen in der richtigen Reihenfolge angeschlossen werden, sonst geht nichts!

Schritt 7: Programmierung

Es ist Zeit, Frankenstein zum Leben zu erwecken. Laden Sie zuerst das Programm legs_init und stellen Sie sicher, dass sich der Roboter in der im Bild gezeigten Position befindet. Laden Sie als Nächstes quattro_test, um zu sehen, ob der Roboter auf grundlegende Bewegungen wie Vorwärts, Rückwärts, Links und Rechts reagiert.

WICHTIG: Sie müssen der Arduino-IDE eine zusätzliche Bibliothek hinzufügen. Der Link zur Bibliothek ist unten angegeben:

Der Roboter muss 5 Schritte nach vorne, 5 Schritte zurück, 90 Grad nach links und 90 Grad nach rechts gehen. Wenn Frankenstein alles richtig macht, bewegen wir uns in die richtige Richtung.

P. S: Installieren Sie den Roboter auf dem Becher als Ständer, damit er ihn nicht jedes Mal auf den ursprünglichen Punkt setzt. Sobald die Tests den normalen Betrieb des Roboters gezeigt haben, können wir den Test fortsetzen, indem wir ihn auf den Boden / Boden stellen.

Schritt 8: Inverse Kinematik

Inverse Kinematik ist das, was den Roboter tatsächlich steuert (wenn Sie nicht an der mathematischen Seite dieses Projekts interessiert sind und es eilig haben, das Projekt abzuschließen, können Sie diesen Schritt überspringen, aber zu wissen, was den Roboter antreibt, wird immer nützlich sein).

Einfach ausgedrückt ist die inverse Kinematik oder kurz IK der "Teil" der trigonometrischen Gleichungen, die die Position des scharfen Endes des Beins, den Winkel jedes Servos usw. bestimmen, was letztendlich ein paar Voreinstellungen bestimmt. Zum Beispiel die Länge jedes Schritts des Roboters oder die Höhe, auf der sich der Körper während der Bewegung / Ruhe befinden wird. Unter Verwendung dieser vordefinierten Parameter extrahiert das System den Betrag, um den jeder Servo bewegt werden muss, um den Roboter mit gegebenen Befehlen zu steuern.

Sie fangen an, Arduino zu lernen, indem sie einfache Roboter bauen. Heute werde ich über den einfachsten Roboter auf Arduino Uno sprechen, der wie ein Hund Ihrer Hand oder jedem anderen Objekt folgt, das Infrarotlicht reflektiert. Außerdem wird dieser Roboter die Kinder amüsieren. Mein 3-jähriger Neffe spielte bereitwillig mit dem Roboter :)

Ich beginne mit der Auflistung der Teile, die beim Bau benötigt werden - Arduino UNO;

Infrarot-Entfernungsmesser;

- 3-Volt-Motoren mit Getrieben und Rädern;

- Anschlüsse für 3A-Batterien;

-Batterie (wenn nicht genügend Batterien vorhanden sind);

- Relais zur Steuerung von Motoren;

Nun, und andere Materialien, die im Erstellungsprozess benötigt werden.
Zuerst machen wir die Basis. Ich beschloss, es aus Holz zu machen. Ich habe ein Holzbrett so gesägt, dass die Motoren perfekt in den Schlitzen sitzen

Dann klemme ich die Motoren mit einem Holzbrett fest und schraube diese Stange fest

Weiter auf dem Gehäuse platzierte ich ein Arduino, ein Relais, ein Brainboard, Entfernungsmesser und unter der Chassisbasis einen rotierenden

Jetzt verbinden wir alles nach dem Schema

Am Ende laden wir den folgenden Sketch in Arduino:

Konstante Ganzzahl R = 13; // Pins, an die IR-Entfernungsmesser angeschlossen sind const int L = 12; int Motor L = 9; // Pins, an die das Relais angeschlossen ist Int motorR = 11; int buttonState = 0; void setup() ( pinMode(R,INPUT); pinMode(L,INPUT); pinMode(motorR,OUTPUT); pinMode(motorL,OUTPUT); ) void loop() ( ( buttonState = digitalRead(L); if (buttonState == HIGH)( digitalWrite(motorR,HIGH); ) else (digitalWrite(motorR,LOW); ) ) (( buttonState = digitalRead(R); if (buttonState == HIGH)( digitalWrite(motorL,HIGH); ) else (digitalWrite(motorL,LOW); ) ) ) )

Das Funktionsprinzip ist sehr einfach. Der linke Entfernungsmesser ist für das rechte Rad zuständig und der rechte für das linke

Um es klarer zu machen, können Sie sich ein Video ansehen, das den Erstellungsprozess und die Aktion des Roboters zeigt

Dieser Roboter ist sehr einfach und jeder kann ihn herstellen. Es wird Ihnen helfen zu verstehen, wie Module wie Relais und IR-Entfernungsmesser funktionieren und wie Sie sie am besten verwenden.

Ich hoffe, Sie haben dieses Handwerk genossen, denken Sie daran, dass Handwerk cool ist!

Schönen Tag! Vor Ihnen, meine Lieben, befindet sich ein Kunstroboter, der verschiedene kugel- oder eiförmige Objekte mit einer Größe von 4 bis 9 cm bemalen kann.

Um es herzustellen, benötigen Sie einen 3D-Drucker, eine Reihe von Standardwerkzeugen und Arduino.

Hinweis: Geben Sie Projekte, die einen 3D-Drucker verwenden, nicht auf. Auf Wunsch finden Sie immer einen Ort oder eine Methode, wo Sie den Druck der für das Projekt erforderlichen Details bestellen können.

Schritt 1: Ein wenig über den Roboter

Kunstroboter - zweiachsig hausgemacht, das auf den meisten sphärischen Oberflächen drucken kann. Der Roboter ist für eine bestimmte Art von Objekt konfiguriert (Tischtennisbälle, Weihnachtsschmuck, Glühbirnen und Eier (Ente, Gans, Huhn ...).

Hochpräzise Schrittmotoren mit hohem Drehmoment werden verwendet, um das kugelförmige Objekt zu drehen und den Manipulator zu bewegen, und ein leiser und zuverlässiger SG90-Servoantrieb wird verwendet, um den Griffmechanismus anzuheben.

Schritt 2: Erforderliche Teile

Zu machen handwerk zum selber machen wir brauchen:

• 2x Lager 623;
• Haarnadel mit einem Durchmesser von 3 mm und einer Länge von 80-90 mm;
• 1x Feder (Länge 10 mm und Durchmesser 4,5 mm);
• 2x NEMA 17 Schrittmotoren (Drehmoment 4,4 kg/cm);
• Kabel für Motoren (Länge 14 + 70 cm);
• USB-Kabel;
• 1x SG90-Servo;
• ArduinoLeonardo;
• Schild JJRobots;

• 2xA4988 Schrittmotortreiber;
• Stromversorgung 12V / 2A;
• 11x M3 6mm Schrauben;
• 4x M3 16mm Schrauben;
• 4x Muttern M3;
• 2x 20mm Saugnäpfe;
• 1x Flügelmutter M3;
• 1x Markierung;

Schritt 3: Allgemeines Schema

Als "Spickzettel" können Sie dieses Schema verwenden.

Schritt 4: Fangen wir an!

Der Roboter bewegt einen Manipulator mit einem daran befestigten Marker, der von einem Schrittmotor angetrieben wird. Ein weiterer Schrittmotor ist für die Drehung des Objekts zuständig, auf dem die Zeichnung angebracht ist (Ei, Kugel ...). Zwei Saugnäpfe werden verwendet, um den Artikel an Ort und Stelle zu halten, einer am Schrittmotor und der andere auf der gegenüberliegenden Seite des Artikels. Eine kleine Feder drückt auf den Saugnapf, um ihm zu helfen, den Gegenstand zu halten. Das SG90-Servo wird zum Anheben/Absenken des Markers verwendet.

Schritt 5: Manipulator

Setzen Sie die Mutter in das dafür vorbereitete Loch ein und ziehen Sie die 16-mm-Schraube fest. Machen wir dasselbe für den Gegenstandshalter (rechts im Bild oben). Bei der Erstellung des Scharniers für den Manipulator wurden 2 16-mm-Schrauben verwendet. Dieses Scharnier sollte sich nach dem Anziehen der Schrauben frei drehen.

Schritt 6: Saugnäpfe

Setzen Sie einen der Saugnäpfe in das Loch im Objekthalter ein.

Schritt 7: Anbringen von Schrittmotoren

Befestigen Sie beide Schrittmotoren mit 8 Schrauben am Hauptrahmen.

Schritt 8: Rotationsachse

Lassen Sie uns alle Elemente wie im Bild oben gezeigt platzieren.

• Saugnapf;
• Schraube;
• Oberer Teil;
• Frühling;
• Lager 623 (sollte in die linke Schale eingebaut werden);
• Linke Tasse;
• Freiraum für den Hauptrahmen;
• Rechte Tasse;
• Lager 623;
• Trennring;
• Flügelmutter (M3).

Schritt 9: Alles an Ort und Stelle bringen

Setzen Sie den zusammengebauten Manipulator auf die Achse des Schrittmotors.

Installieren Sie die linke Stütze auf der Achse des Schrittmotors.

Der Marker und das Ei werden als Beispiel gesetzt (Sie müssen sie jetzt nicht platzieren).

HINWEIS: Das Servo muss angepasst werden. Sie müssen den Winkel während des Kalibrierungsprozesses neu einstellen.

Schritt 10: Elektronik

Befestigen Sie die Elektronik mit Schrauben (2 reichen aus) auf der Rückseite des Hauptrahmens.

Schließen wir die Kabel an.

Wenn Sie beim Anschluss von Schrittmotoren die Polarität umpolen, drehen sie einfach in die entgegengesetzte Richtung, aber mit einem Servo ist die Situation nicht so harmlos! Überprüfen Sie daher vor dem Anschließen die Polarität!

Schritt 11: Programmierung des Arduino Leonardo

Lassen Sie uns den Arduino Leonardo mit der Arduino IDE-Softwareumgebung (v 1.8.1) programmieren.

• Laden Sie Arduino IDE (v 1.8.1) herunter und installieren Sie das Programm;
• Lassen Sie uns die Software ausführen. Wählen Sie das Arduino Leonardo Board und den entsprechenden COM-PORT im Menü "Tools->Board" aus;
• Lassen Sie uns den Sphere-O-Bot-Code öffnen und herunterladen. Lassen Sie uns alle Dateien in einen Ordner entpacken und ihn "Ejjduino_ARDUINO" nennen.

Schritt 12: Der Art Robot ist bereit, Kunstwerke zu erstellen

Schritt 13: Robotersteuerung

Software Inkscape. Laden Sie die Inkscape-Software herunter und installieren Sie sie (ich empfehle die stabile Version 0.91).

Laden Sie die EggBot Control-Erweiterung herunter und installieren Sie sie (Version 2.4.0 wurde vollständig getestet).

Die EggBot Control-Erweiterung für Inkscape ist ein Tool zum Testen und Kalibrieren des EggBot und zum Übertragen von Zeichnungen auf das Ei. Zuerst müssen Sie Inkscape starten. Nach dem Start von Inkscape erscheint das Menü „Erweiterungen“, in dem Sie bereits das Untermenü „Eggbot“ auswählen müssen. Wenn Sie das Eggbot-Untermenü nicht sehen, haben Sie die Erweiterungen nicht richtig installiert. Sichern Sie die Anweisungen zum Installieren von Erweiterungen und befolgen Sie diese sorgfältig.

Das ist alles, vielen Dank für Ihre Aufmerksamkeit!)

Es ist sehr einfach, verschiedene Autos mit Fernbedienung, einfachen Sensoren und Logik auf Arduino zu bauen. Daher ist diese Linie unglaublich beliebt. Viele kompatible Sensoren und Erweiterungsplatinen werden verkauft. Das Internet ist gefüllt mit vorgefertigten Softwarebibliotheken und Open-Source-Projekten für alle Gelegenheiten. Fast alle Fragen, die Sie beim Beherrschen von Arduino haben werden, wurden bereits von jemandem gestellt, und Sie werden immer die Antwort finden.

Fangen wir mit etwas an, sollen wir? Das Hauptproblem ist die Wahl des Controllers. Es gibt viele Überarbeitungen von Arduino sowie Klone von Drittanbietern, die aus diesen Überarbeitungen erstellt wurden. Hier sind vielleicht die zwei interessantesten Klassen für uns:

• Arduino Uno ist die beste Wahl für Anfänger, das einfachste, günstigste und am weitesten verbreitete Board. Es basiert auf einem ATmega328-Chip mit einer Taktfrequenz von 16 MHz, 32 KB Flash-Speicher, 2 KB RAM und 1 KB EEPROM. Uno verfügt über 14 digitale Ein-/Ausgänge, die zur Steuerung von Sensoren, Servos und anderen Geräten verwendet werden können;

• Das Arduino Mega / Mega 2560 ist ein Board, das sich als nützlich erweisen wird, wenn Sie im Voraus wissen, dass das Projekt schwierig sein wird. Der Hauptunterschied besteht in mehr Ein-/Ausgängen (48 bei Mega, 54 bei Mega 2560). Auch hier gibt es viel mehr Speicher: 8 KB RAM, 4 KB EEPROM und Flash-Speicher von 128 und 256 KB (bei Mega bzw. Mega 2560). Untereinander unterscheiden sich die Boards auch in Chip, USB-Geschwindigkeit und einigen anderen Eigenschaften.

Natürlich gibt es auch Arduino Pro, Arduino LilyPad und viele andere. Aber jetzt konzentrieren wir uns auf die ersten beiden Modelle. In unserem Fall ist alles ganz einfach: Mega braucht man für einen Roboter mit vielen Beinen.

Erster Code

Lassen Sie uns zuerst die Arduino IDE (arduino.cc) installieren – dies ist eine kostenlose plattformübergreifende Entwicklungsumgebung. Wenn wir nun unseren Arduino anschließen, können wir versuchen, den ersten Code am einfachsten Beispiel zu schreiben: dem blinkenden LED-Programm. Die meisten Arduino-Controller haben es und sind mit Pin 13 verbunden. Übrigens werden Programme in der Arduino-Welt allgemein als Sketche bezeichnet. Hier ist der Text der Skizze mit Kommentaren:

// Geben Sie diesem Pin den Namen LED: const int LED = 13; void setup() ( // Initialisiere den digitalen Pin // für die Ausgabe: pinMode(LED, OUTPUT); ) void loop() ( // Setze einen logischen Eins-Pegel // auf Pin 13 (beleuchte die LED): digitalWrite(LED , HIGH) ; // Anhalten der Skizze // für eine Sekunde: delay(1000); // Anlegen eines logischen Nullpegels // an Pin 13 (Schalten Sie die LED aus): digitalWrite (LED, LOW); // Anhalten der Skizzieren Sie erneut für eine Sekunde: delay(1000); )

Beachten Sie die Setup- und Loop-Funktionen. Sie müssen in jeder Arduino-Skizze vorhanden sein. Setup wird einmal aufgerufen, wenn der Controller eingeschaltet wird oder nachdem der Controller neu gestartet wurde. Wenn Sie möchten, dass der Code nur einmal ausgeführt wird, sollte er hier platziert werden. Meistens sind dies alle Arten von Initialisierungsverfahren für etwas. Unsere Skizze ist da keine Ausnahme: Digitale Pins von Arduino können sowohl als Ein- als auch als Ausgänge fungieren. In der Setup-Funktion sagen wir, dass Pin 13 als digitaler Ausgang des Controllers arbeiten wird.

Nachdem die Setup-Funktion ihre Arbeit abgeschlossen hat, wird automatisch eine geschlossene Schleife gestartet, in der die Schleifenfunktion aufgerufen wird. Wir müssen schreiben, was wir dort machen wollen. Und wir wollen einen logischen Eins-Pegel (5 V) an Pin 13 anlegen, d. h. die LED zum Leuchten bringen, dann eine Sekunde warten (1000 in Millisekunden), dann einen logischen Null-Pegel (0 V) anlegen und erneut eine Sekunde warten. Beim nächsten Aufruf von Loop wird alles wiederholt.

Jetzt „laden“ wir unseren Sketch auf den Controller hoch. Nein, wir brauchen keinen Programmierer. Arduino-Controller enthalten zusätzlich zu unseren Skizzen ein spezielles Programm - Bootloader, das insbesondere das Laden von Code von einem Computer steuert. Um den Sketch hochzuladen, benötigen wir also nur ein USB-Kabel und den Menüpunkt Datei → Hochladen (Strg + U) in der Arduino IDE.

Schlüsselfrage

Wie viele Beine brauchen wir eigentlich? Lassen Sie uns in einer Vielzahl von Konfigurationen von Laufrobotern definieren. Nach Anzahl der Beine:

• zweibeinig - zweibeinig (Prototyp - Mann);
• vierbeinig - vierbeinig (Prototyp - die meisten Säugetiere);
• Hexapod - sechsbeinig (Prototyp - die meisten Insekten);
• Octopod - achtbeinig (Prototyp - Spinnen, Skorpione, Krabben und andere Arthropoden).

Neben der Anzahl der Beine ist auch deren Konfiguration wichtig. Das Hauptmerkmal des Beins ist die Anzahl der Freiheitsgrade oder Freiheitsdimensionen (DOF). Der Freiheitsgrad ist die Fähigkeit, sich um eine Achse zu drehen oder zu biegen (seltener, sich entlang dieser vorwärts zu bewegen). Wenn es nur einen Freiheitsgrad gibt, werden Sie mit einem solchen Bein natürlich nicht weit kommen. Beine mit zwei Freiheitsgraden (2DOF) erlauben es bereits mehrbeinigen Robotern, sich zu bewegen, obwohl 2DOF die freie Bewegung der Beinspitze nur in einer Ebene erlaubt. Und das 3DOF-Bein bewegt den „Fuß“ im 3D-Raum (sofern natürlich nicht alle drei Achsen parallel sind). Es gibt auch 4DOF-Beine, die einfach die Flexibilität und Bewegungsfreiheit des Beins erhöhen. Insekten haben meistens 4DOF-Beine.

Was bedeutet das für uns? Bei billigen Hobbyrobotern wird jeder Freiheitsgrad durch einen Motor, genauer gesagt einen Servoantrieb oder Serv, realisiert. Die Konfiguration der Beine bestimmt eindeutig, wie viele dieser Servos benötigt werden. Ein 3DOF-Hexapod würde also 18 Servos benötigen, und eine 4DOF-Spinne würde 32 benötigen. Lassen Sie sich nicht von den Zahlen einschüchtern, die kleinen Servos, die in Amateur-RC-Modellen verwendet werden, sind sehr billig. In Online-Shops finden sie auf Anfrage Mikroservo.

Um Servos zu programmieren, reicht es zu wissen, dass sie bereits einen Controller haben, der die Hauptarbeit übernimmt. Und alles, was benötigt wird, ist die Stromversorgung und ein digitales Signal, das der Steuerung mitteilt, in welche Position wir die Antriebswelle drehen wollen. Es ist einfach, Informationen über ihr Design zu finden. Ihr Protokoll ist das einfachste aller digitalen Kommunikationsprotokolle: Pulsweitenmodulation - PWM (PWM auf Englisch). Alle einfachen Servos haben einen dreipoligen Anschluss: Masse, +5V (Spannung kann je nach Größe und Leistung variieren) und einen Signaleingang. Arduino-Controller können dieses Signal auf zwei verschiedene Arten erzeugen. Das erste ist Hardware-PWM, das der Chip selbst an mehreren seiner digitalen I/O-Pins ausgeben kann. Das zweite ist Software. Mit Software können Sie gleichzeitig mehr verschiedene PWM-Signale empfangen als mit Hardware. Unter Arduino wird dafür ein praktischer Wrapper zur Verfügung gestellt - die Servo-Bibliothek. Es ermöglicht Ihnen, 12 Servos gleichzeitig auf den meisten kleinen Controllern (Uno, Due, Nano) und 48 Servos auf Arduino Mega und dergleichen zu verwenden. Der Signalstift des Servos ist mit dem digitalen Stift des Arduino verbunden. Masse und Strom - offensichtlich können Masse und Strom von allen Servos geteilt werden. In dreiadrigen Servoschleifen ist schwarz oder braun Masse, normalerweise rot +5 V in der Mitte und schließlich weiß oder gelb Signal. Aus Software-Sicht ist die Steuerung denkbar einfach:

Servo myservo; // Servo auf Arduino Pin 9 myservo.attach (9); // Auf Position 90º drehen myservo.write (90);

Die meisten Servos können die Welle um 180° drehen, und für sie ist 90° die mittlere Position. Um den Anschluss von Servos an das Arduino-Board zu vereinfachen, gibt es eine Reihe von Lösungen. Das kanonischste ist das Sensors Shield. Indem Sie es auf dem Uno installieren und die Klemmen für die Servos mit Strom versorgen, können Sie deren Anschlüsse direkt daran anschließen.

Batterie

Ein weiteres wichtiges Thema ist die Ernährung. Wenn Sie über ein fortschrittliches Board verfügen, mit dem Sie das gesamte System über eine Stromleitung versorgen können (und die Servomotoren den Betrieb des Controllers nicht stören), können Sie mit einer Quelle auskommen. Die Auswahl ist riesig, am besten natürlich Li-Ion / Li-Po Briketts für Funkmodelle. Aber sie brauchen auch die passenden Ladegeräte. Wenn Sie einen einfacheren Controller (Uno / Due / Nano) haben, können Sie ihn beispielsweise mit einem 9-Volt-Krona separat mit Strom versorgen und die Servos an den leistungsstarken Hauptakku anschließen. Die Servos werden also definitiv genug Power haben. Bei Lithiumbatterien müssen Sie die Spannung noch sorgfältiger als üblich überwachen, damit es nicht zu einer Tiefentladung kommt (die zulässigen Spannungen sollten für einen bestimmten Batterietyp geklärt werden). Dazu wird am Sleipnir-Roboter noch ein kleines digitales Voltmeter angeschraubt, auf das noch eingegangen wird.

Robobug selbst machen

Bausatz

• Arduino Uno-Controller: 1150 Rubel
• Drei Servomotoren. Ich habe HXT500, 200 r verwendet. ein Stück
• Batteriefach für "Krona" mit Schalter: 50 Rubel.
• Batterie "Krona": 145 Rubel.
• IR-Empfänger: 90 $
• Stahldraht mit einem Durchmesser von ca. 1,5 mm. Zum Beispiel habe ich einen kaputten Schneebesen benutzt

Gesamt: 2035 S.

DmitryDzz: Ich möchte Sie einladen, einen kleinen ferngesteuerten sechsbeinigen Roboterkäfer basierend auf dem Arduino Uno-Controller zu bauen. Die Pfoten haben einen Freiheitsgrad, die Steuerung erfolgt über eine herkömmliche TV-Fernbedienung.

Ich muss sagen, dass dies die Preise teurer Moskauer Geschäfte sind. In chinesischen Online-Shops kostet das alles doppelt so viel. In Anbetracht des Versands. Richtig, Sie müssen meiner Erfahrung nach zwei Wochen bis drei Monate warten.

Ein einfacherer Weg ist es, ein Konstruktor-Set zu nehmen, da in den ersten Schritten ein Controller nicht ausreichen wird. Mittlerweile bieten viele Shops solche Sets an. Zum Beispiel gibt es einen wunderbaren Online-Shop "Amperka". Hier werden Ihnen mehrere ähnliche Designer angeboten, die sich in Fülle und natürlich im Preis unterscheiden. Mir reichte das Einfachste - "Matroschka X". Es enthält einen Arduino Uno-Controller, ein USB-Kabel zum Anschließen an einen Computer, ein Prototyping-Board (unverzichtbar!), einen Satz Jumper, LEDs, Widerstände und andere Kleinigkeiten.

Im selben Geschäft gibt es einen "Wiki"-Bereich, in dem Sie sogar wunderbare kurze Video-Tutorials finden, die ins Russische übersetzt wurden. Achten Sie darauf, sie zu überprüfen. Und natürlich gibt es ein Forum, wo sie wahrscheinlich versuchen werden, Ihnen zu helfen.

Was Sie von den Tools benötigen:

• Lötkolben und alles was man zum Löten braucht. Sie müssen nicht viel löten und brauchen nicht viel Geschick;
• Heißklebepistole und Stangen dazu;
• Zange zum Arbeiten mit Draht.

Wenn Sie alles haben, fangen wir an!

Kontrolle

Kommen wir zum ersten Schritt: Wir müssen lernen, mit der Fernbedienung zu interagieren und die Codes für das Drücken einiger ihrer Tasten herauszufinden. Diese Codes werden dann für die Robotersteuerungsskizze nützlich sein.

Zu diesem Zeitpunkt benötigen Sie auch einen IR-Empfänger, und es wäre schön, ein Prototyping-Board zu haben. Die überwiegende Mehrheit der IR-Fernbedienungen arbeitet mit Trägerfrequenzen von 36 kHz, 38 kHz oder 40 kHz (Panasonic, Sony). Die Ausnahmen sind Sharp (56 kHz), Bang & Olufsen (455 kHz) und vielleicht jemand anderes, der exotischer ist. Daher ist jeder IR-Empfänger bei 36, 38 oder 40 kHz für uns gut geeignet. Die Frequenz stimmt möglicherweise nicht exakt mit der Trägerfrequenz des Signals überein. In diesem Fall nimmt die Empfindlichkeit des Empfängers ab, aber in der Praxis habe ich bei Verwendung des IR-Empfängers TSOP2136 (36 kHz - die letzten beiden Ziffern - Frequenz) und der Sony-Fernbedienung (40 kHz) keine Beschwerden festgestellt.

Daher sind die IR-Empfänger TSOP21xx, TSOP22xx, TSOP312xx für die meisten Fernbedienungen geeignet. Die letzten beiden Ziffern können 36, 37, 38 oder 40 sein. Überprüfen Sie vor dem Einschalten des IR-Empfängers die Pinbelegung seiner Pins - es gibt nur drei davon: + 5 V (Strom), GND (Masse), Vs (Ausgang) . Lassen Sie uns die Schaltung wie in der Abbildung zusammenbauen (Verdrahtung für TSOP2136).

Wie Sie sehen können, haben wir den Ausgang des IR-Empfängers mit dem analogen Eingang des A0-Controllers verbunden.

So sieht der Sketch-Code aus:

#include "IRremote.h" // Analoger Eingang des Controllers // an dem der IR-Empfänger angeschlossen ist: const int IR_PIN = A0; // Erstellen Sie ein IR-Empfängerobjekt: IRrecv irrecv (IR_PIN); void setup() (Serial.begin(9600); Serial.println("ready"); // Starten Sie das Abhören von IR-Signalen: irrecv.enableIRIn(); ) void loop() ( // Beschreiben Sie die Strukturergebnisse, / / wo // empfangene und dekodierte // IR-Befehle platziert werden: decode_results result; // Wenn der IR-Befehl akzeptiert und // erfolgreich dekodiert wird, dann gib // den empfangenen Code an die // serielle Schnittstelle des Controllers aus: if ( irrecv.decode (&results)) ( Serial.println(results.value); irrecv.resume(); ) )

Der Sketch verwendet eine spezielle Bibliothek IRremote.h, die die Signale verschiedener IR-Fernbedienungen dekodiert. Diese Bibliothek ist ein offenes Projekt, Sie können es von https://github.com/shirriff/Arduino-IRremote herunterladen. Und um es mit unserem Projekt zu verbinden, müssen Sie drei Schritte ausführen:

• Kopieren Sie das Bibliotheksverzeichnis in das Bibliotheksverzeichnis, das sich wiederum im Installationsverzeichnis der Arduino IDE befindet.
• IDE neu starten;
• Fügen Sie am Anfang unserer Skizze die Zeile #include "IRremote.h" hinzu.

Jetzt sind die IR-Decodierungsfunktionen in der Skizze verfügbar. Aber um die resultierenden Codes zu sehen, werden wir immer noch das Serial-Objekt verwenden. Mit seiner Hilfe übertragen wir die Codes über die serielle Schnittstelle (gleiches USB-Kabel) auf den Computer. In der Setup-Funktion initialisieren wir das Serial-Objekt. "9600" ist 9600 Baud - die Rate, die für die Datenübertragung verwendet wird. Nach der Initialisierung können wir mit der Funktion println auf die serielle Schnittstelle schreiben. Um das Ergebnis dieser Ausgabe auf dem Rechner in der Arduino IDE anzusehen, wählen Sie den Menüpunkt Tools → Serial Monitor (Strg + Shift + M). Stellen Sie einfach sicher, dass es auf 9600 Baud eingestellt ist.

Der Controller wird also über ein USB-Kabel mit Strom versorgt und überträgt Daten darüber. Wir laden die Skizze, starten den Serial Monitor und beginnen mit dem Drücken der Tasten auf der Fernbedienung. Codes sollten im Serial Monitor-Fenster erscheinen. Fernbedienungsprotokolle sind unterschiedlich, manchmal kann es ein Code sein, manchmal mehrere. In jedem Fall können Sie jeder Taste auf der Fernbedienung immer eindeutige Codes zuweisen.

Wir brauchen 13 Fernbedienungstasten. Ich habe folgendes verwendet:

• 1 - glatte Drehung nach links;
• 2 - vorwärts gehen;
• 3 - glatte Drehung nach rechts;
• 4 - an der Stelle links abbiegen;
• 5 - Stopp;
• 6 - an der Stelle rechts abbiegen;
• 7 - Bewegung zurück mit einer Drehung nach rechts;
• 8 - Rückwärtsbewegung;
• 9 - Bewegung zurück mit einer Drehung nach links;
• blaue Taste - sehr langsam;
• gelb - langsam;
• grün - schnell;
• rot - sehr schnell.

Notieren Sie sich die Codes für diese Schaltflächen, Sie werden sie später für die Robotersteuerungsskizze benötigen.

Bewegungsalgorithmus

Die Robotersteuerungsskizze ist auf unserer Projektseite (bit.ly/1dEwNDC) verfügbar. Vergessen Sie nicht, die Werte der Konstanten der Codes der gedrückten Fernbedienungstasten auf die Codes Ihrer Fernbedienung zu ändern (die IR_COMMAND_XXX_CODES-Konstanten in der Datei ir_command_codes.h).

Wir werden die Skizze nicht im Detail analysieren, ich denke, Kommentare im Code reichen aus, aber eine Frage ist dennoch eine Überlegung wert.

Insektenbewegungen sind sehr interessant. Und obwohl alle diese Käfer sehr nah am Boden fallen, sind sie aus irgendeinem Grund immer stabil: Zu jedem Zeitpunkt stehen mindestens drei Beine (zwei auf der einen Seite und eines auf der anderen) auf der Oberfläche. Und während diese Beine den Käfer zu einem seiner angetriebenen Ziele ziehen, werden die anderen drei nach oben gezogen, um diese Bewegung zu wiederholen. Unser Ziel ist es, etwas Ähnliches zu tun.

Unser Roboterkäfer hat drei Servomotoren, die senkrecht zur Bewegung in einer Reihe angeordnet sind. Beim linken und rechten Servomotor zeigt die Wellenachse nach oben, beim mittleren nach vorne. Die Aufgabe des linken Servos besteht beispielsweise darin, zwei Beine gleichzeitig zu pumpen: das linke vordere und das linke hintere. Sie sind übrigens starr miteinander verbunden und mit der Wippe dieses Servos verklebt. Die Aufgabe des zentralen Servos besteht darin, die linke Seite des Käfers anzuheben, dann die rechte. Daher sind die zentralen linken und rechten Beine an der Schwinge dieses Motors befestigt, die ein einziges U-förmiges Teil sind.

Die Skizze sollte sicherstellen, dass sich der Roboter vorwärts und rückwärts bewegt, sanfte Drehungen in Bewegung macht und sich auf der Stelle dreht. Und ich möchte auch die Geschwindigkeit des Käfers kontrollieren. Um diese Bewegungen programmatisch zu beschreiben, brauchen wir Mathematik. Sehen Sie sich das Diagramm an.

Die blauen Kreise zeigen die Beine des Roboterkäfers an, die auf der Oberfläche stehen, und die weißen Kreise sind die in der Luft. Bitte beachten Sie, dass sich der linke und der rechte Stellmotor beim Vorwärts- oder Rückwärtsfahren genau gleich bewegen müssen. Und beim Drehen auf der Stelle sollten sich die Motoren in verschiedene Richtungen (symmetrisch) drehen. Interessant ist auch, dass sich die Vorwärts- und Rückwärtsbewegung nur in der Phase des zentralen Stellmotors unterscheiden.

Wie wird es also umgesetzt? Wir erinnern uns, dass der Controller ständig die Schleifenfunktion aufruft. In diese Funktion müssen wir also den Code einfügen, der die aktuelle Position der Servos bestimmt und sie auf diese Position setzt. Jeder Stellmotor muss schwingen. Die Position des Servomotors zum Zeitpunkt t können wir mit folgender Formel berechnen:

X = A sin(2πt/T),

wobei X die gewünschte Position des Servomotors ist, A die Schwingungsamplitude ist, T die Schwingungsdauer ist.

Abhängig vom Zeitpunkt t erhalten wir also eine Änderung des Werts von X im Bereich von -A bis +A. Die Stellmotoren können im Bereich von 0 bis 180° positionieren. Daher ist es für uns besser, um die „Null“-Position bei 90 ° zu oszillieren. Und wenn wir Schwingungen mit einer Periode von 1 s um die Position von 90 ° mit einer Amplitude von 30 ° bereitstellen möchten, wird die Formel in die folgende Form umgewandelt:

X = 90 + 30 sin(2πt/1000),

wobei t die Zeit in Millisekunden seit Beginn der Schwingung ist. Um die Geschwindigkeit des Robocalls zu steuern, können wir die Oszillationsperiode ändern. Je größer es ist, desto niedriger ist die Geschwindigkeit.

Und jetzt kehren wir wieder zu unserem Schema zurück, denn die oben geschriebene Formel ist noch nicht vollständig. Wie wird sichergestellt, dass die synchrone, dann die gegenläufige Bewegung des linken und rechten Stellmotors? Wie ändere ich die Phase des zentralen Stellmotors? Wir müssen die Schwingungsphase zu unserer Formel hinzufügen. Wenn Sie beispielsweise das Sinusargument um π verschieben, wird der rechte Motor gegenphasig zum linken arbeiten, dh so, wie wir auf der Stelle drehen müssen. So sieht unsere Formel jetzt aus:

X = 90 + 30 sin(2πt/1000 + Φ),

wobei Φ die Phase der Schwingungen ist, der Wert zwischen 0 und 2π liegt.

Sehen Sie sich die Tabelle an, um zu verstehen, wie die Oszillationsphasen der Servomotoren für jede Art von Bewegung sein sollten.

Montage

Lassen Sie uns nun den Roboter auf dem Prototyping-Board zusammenbauen und die Steuerungsskizze ausfüllen.

Dies ist ein sehr wichtiger Schritt vor der Montage. Versuchen Sie, das USB-Kabel zu trennen und die Anlage über die Krona-Batterie mit Strom zu versorgen. Überprüfen Sie alle Phasen der Bewegung und stellen Sie sicher, dass alles funktioniert. Nach dem Zusammenbau des Roboters ist es schwieriger, etwas zu ändern (z. B. einen defekten Servomotor auszutauschen).

Kommen wir nun zur Montage selbst. Das Hauptlagerelement ist das Batteriefach. Ich rate Ihnen, ein geschlossenes Typfach und immer einen Schalter zu verwenden.

Am einfachsten lassen sich die Details des Käfers mit Heißkleber fixieren. Beginnen Sie mit Servomotoren. Entfernen Sie unnötige Befestigungsösen und verbinden Sie die Autos miteinander. Kleben Sie dann diese Baugruppe aus drei "Servos" auf die Batterieabdeckung. Vergessen Sie nicht, dass sich das Batteriefach zum Batteriewechsel frei öffnen muss.

Der einfachste Weg ist, den Controller an den Schacht zu kleben, aber diese Option gefällt mir nicht wirklich, da ich den Arduino Uno für immer dem Fehler überlassen muss. Daher können Sie Ihr Leben erschweren und die Arduino-Anschlüsse verwenden, um das Batteriefach zu befestigen. Kleben Sie einen Stiftverbinder auf den Boden des Fachs mit einem Abstand von 2,54 mm zwischen den Stiften. Er sollte so angeordnet sein, dass er im Bereich der digitalen Ausgänge 8-11 in die Controller-Buchse eintritt. Wir brauchen sie trotzdem nicht. Wenn der Stecker nicht zur Hand ist, reicht eine U-förmig gebogene Büroklammer.

Die vom Batteriefach kommenden Leitungen müssen mit den Vin-Klemmen und dem daneben liegenden GND verbunden werden. Nicht umpolen! Plus "Krona" auf Vin, minus auf GND. Um einen zuverlässigen Kontakt der Drähte mit den Arduino-Anschlüssen zu gewährleisten, kann man die Drahtspitze einfach dicker verzinnen, als Stecker habe ich aber eine kurze Büroklammer verwendet. Und die Lötstelle wurde mit Schrumpfschlauch verschlossen.

Die Stecker von den Servokabeln sollten abgeschnitten werden, die Stromkabel (+5 V - normalerweise rot und GND - schwarz oder braun) sollten kombiniert und mit den 5-V-Buchsen und dem angrenzenden GND am Controller verbunden werden. Wir werden uns etwas später verbinden. Die Steuersignalleitungen (normalerweise gelb) werden an die digitalen Ausgänge der Steuerung ausgegeben: Der linke Stellmotor liegt an Pin 2, der mittlere an Pin 4, der rechte an Pin 7.

Die „+“ und „-“ des IR-Empfängers können einfach in den Arduino-Anschluss (5V und angrenzender GND) gesteckt werden. Es stimmt, sie biegen sich in zwei Hälften und verdoppeln ihre Dicke. Wir löten die zuvor angeschlossenen Stromkabel an die Servomotoren an die gleichen Leistungsbeine des IR-Empfängers. Es ist unwahrscheinlich, dass der Signalausgang des IR-Empfängers den analogen Eingang des A0-Controllers erreicht, und Sie müssen ihn mit einem Kabel erhöhen.

Ein paar Tipps für die Herstellung von Beinen. Bereiten Sie zuerst die linken und rechten „Vorder-Rücken“-Beine vor. Stellen Sie sicher, dass sie symmetrisch sind (achten Sie sowohl auf die Längen als auch auf die Winkel der Biegungen). Beginnen Sie mit dem Verkleben der Beine erst, nachdem Sie sich vergewissert haben, dass die Servomotoren auf die "Null"-Position (90°) eingestellt sind.

Platzieren Sie das mittlere Beinpaar zuletzt. Ich rate Ihnen, zuerst die Mittelbeine länger zu machen und sie dann nach der Installation auf die gewünschte Länge zu schneiden. In der „Null“-Position sollten alle sechs Füße auf der Oberfläche sein. Das Abrollen der Mittelbeine mit einer Amplitude von 15° sollte die Vorwärts-Rückwärts-Drehungen nicht stören.

Was weiter?

Robobug ist eine fertige mobile Plattform, die auf einem der beliebtesten und erschwinglichsten Controller basiert. Das Projekt ist offen: https://github.com/beetle-ringo/arduino . Erstellen Sie einen Fork (Zweig) in GitHub und fügen Sie Ihre Funktionalität hinzu. Lassen Sie Ihrer Fantasie freien Lauf - fügen Sie eine IR-LED hinzu und der Roboter ist bereit für den Roboterkampf. Verbinden Sie Entfernungsmesser, taktile Sensoren, ein Gyroskop ... Bringen Sie dem Roboter bei, Hindernisse zu umgehen oder entlang einer Linie zu gehen, versuchen Sie, eine Webcam darauf zu installieren. Es kann eine Million Ideen geben, und Sie können immer die interessanteste auswählen.

Roboter Sleipnir

Bausatz

• Arduino Uno Dagu Spider-Roboter-Controller: 2530 $
• Servoantriebe SG90 9g (16 Stück) 1150 р.
• LiPo-Akkupack, 7,4 V, 1800 mAh 4,99 $
• Funkmodul 4 Pin Bluetooth RF Transceiver 270 р.
• Spannungsanzeige (optional) DC 3,3-30 V Rotes LED-Panel Meter $ 100
• Ecke aus Aluminium. Im nächsten Baumarkt 135 Rubel.
• Schrauben und Muttern. Auf dem nächsten Flohmarkt 35 Rubel.

Gesamt: 4710 R.

*Komponenten wurden zu unterschiedlichen Zeitpunkten eingekauft und viele Positionen können optimiert werden

poconoco: Versuchen wir, eine nicht standardmäßige Konfiguration zusammenzubauen - einen achtbeinigen 2DOF-Roboter. 2DOF-Beine sind viel einfacher zu programmieren, außerdem habe ich einen Haufen unbenutzter Servos auf Lager. Und vor allem wird es möglich sein, es zu Ehren des achtbeinigen Pferdes des Gottes Odin Sleipnir zu benennen (immer davon geträumt!).

Unser Sleipnir hat vier Beine mit zwei Scharnieren auf jeder Seite. Jedes Gelenk ist ein Servo, also acht Servos pro Seite. Der Einfachheit halber drehen sich alle acht Scharniere einer Seite des Pferdes in derselben Ebene. Obwohl dies überhaupt nicht notwendig ist. Außerdem, wenn die Beine auf einer Seite in ein kleines "Schach" gestellt werden, so dass sich zwei benachbarte Beine nicht berühren können, wird es noch besser, es wird Ihnen erlauben, einen breiteren Schritt zu machen und zu galoppieren.

Eine saubere und funktionale, aber bei weitem nicht die billigste Lösung ist die Verwendung einer nicht standardmäßigen Steuerplatine, die für den Anschluss von Servos in großer Zahl optimiert ist. Ich bin auf einen Dagu Spider Robot Controller gestoßen - das ist derselbe Arduino Mega, aber auf einer Platine mit vorgelöteten 3-Pin-Pin-Anschlüssen, an die Sie sofort dieselben 48 Servos ohne Abschirmungen anschließen können. Ideal für mehrbeinige Arduino-Roboter.

Kontrolle

Wir werden über Bluetooth gesteuert. Hierfür gibt es verschiedene Hardwarelösungen. Dies sind Abschirmungen und separate Schals mit einer seriellen UART-Schnittstelle (wie ein normaler COM-Port, nur mit 5-V-Signalpegeln). Am praktischsten schien mir ein kleiner Schal mit UART-Schnittstelle zu sein. Wird mit den entsprechenden UART/Serial-Pins am Arduino-Port verbunden. Wir stellen zwei Nuancen fest: Es gibt nur einen solchen Port bei Uno / Due / Nano und dergleichen, und er wird auch zum Flashen über USB verwendet. Daher müssen Sie möglicherweise das Bluetooth-Modul während der Firmware ausschalten. Und die zweite Nuance - vergessen Sie nicht, dass der RX-Pin des Moduls mit dem TX-Pin des Arduino und TX - mit RX verbunden ist. Solche Dinge sind im UART.

Bluetooth-Programmierung ist nicht schwieriger als Servos, Daten können Byte für Byte gelesen werden, was wir verwenden werden:

Charcmd; Serial.begin (9600); if (Serial.available ()) cmd = Serial.read ();

Wenn Arduino Mega verwendet wird und Bluetooth mit dem zweiten Port verbunden ist, wird Serial1 anstelle von Serial geschrieben. Bemerkenswert ist, dass man kein Bluetooth nutzen kann, sondern den Roboter direkt per USB steuern kann. Und am obigen Code ändert sich nichts! Es funktioniert nur mit einer seriellen Schnittstelle, und ob dort ein BT-Sender oder ein USB-Seriell-Konverter hängt, ist uns egal.

Die andere Seite von Bluetooth

Am bequemsten stellen Sie eine Verbindung über Standard-Linux-Dienstprogramme her. Zum Arbeiten benötigen wir das sdptool, die rfcomm-Dienstprogramme (im bluez-Paket in den Ubuntu-Repositories enthalten) sowie minicom (das Paket heißt so). Anweisungen zur Verwendung dieser Dienstprogramme finden Sie im Internet.

Bewegungsalgorithmus

Für einen Hexapod ist die einfachste Gangart die folgende: Die Beine sind in zwei Gruppen von drei Beinen unterteilt, und eine der Gruppen ist vollständig auf dem Boden, die andere in der Luft, neu angeordnet nach vorne. Dies ist bei weitem nicht die einzig mögliche Gangart. Sie können nur zwei Pfoten in der Luft halten, oder sogar eine, und die restlichen vier oder fünf auf dem Boden. Für einen Octapod gibt es auch viele Gangarten. Wir nehmen das einfachste, ebenfalls mit zwei Gruppen von vier Beinen.

Was müssen wir also tun, um mit 16 Servos und einer gewählten Gangart zu arbeiten? Die richtige Antwort ist, über inverse Kinematik (IK) zu lesen. Das Volumen des Artikels erlaubt es nicht, das Thema weit zu erweitern, aber es gibt viele Materialien im Internet. Kurz gesagt, IR löst das Problem, die notwendigen Steuersignale zu finden, damit das System die gewünschte Position im Raum einnimmt. Für das Bein bedeutet dies, dass je nach Koordinaten des Auftreffpunktes des Fußes die Winkel der dafür einzustellenden Servos bestimmt werden müssen. Und indem Sie die Koordinaten der Füße steuern, können Sie die Position des Körpers steuern. Wir haben 2DOF-Beine, die Achsen sind parallel, sodass sich der Fuß immer in der gleichen Ebene bewegt. Das IR-Problem wird in diesem Fall auf einen 2D-Raum reduziert, was es stark vereinfacht.

Der lokale Ursprung O sei für jedes Bein der Schaft des oberen Servos, also der Oberschenkel. Und wir haben die Koordinaten von Punkt A, wo der Fuß treffen muss. Dann ist leicht zu erkennen, dass es notwendig ist, das Problem zu lösen, die Schnittpunkte zweier Kreise zu finden (siehe das Diagramm der Schenkel einer Seite, dies ist dort am rechten Schenkel dargestellt). Nachdem Sie den Punkt B des Schnittpunkts der Kreise gefunden haben (einen davon auswählen), ist es einfach, die gewünschten Winkel zu berechnen, indem Sie kartesische Koordinaten in Polarkoordinaten umwandeln. Im Code sieht die Lösung für dieses Problem folgendermaßen aus:

Float A = -2*x; Schwimmer B = -2 * y; float C = sqr(x) + sqr(y) + sqr(hipLength) - sqr(shinLength); float X0 = -A * C / (sqr(A) + sqr(B)); float Y0 = -B * C / (sqr(A) + sqr(B)); float D = sqrt(sqr(hipLength) - (sqr(C) / (sqr(A) + sqr(B)))); float mult = sqrt(sqr(D) / (sqr(A) + sqr(B))); schweben Axt, ay, bx, durch; ax = X0 + B*mult; bx = X0 – B*mult; ay = Y0 - A*mult; durch = Y0 + A*mult; // oder bx für einen anderen Schnittpunkt float jointLocalX = ax; // oder by für einen anderen Schnittpunkt float jointLocalY = ay; float hipPrimaryAngle = polarAngle (jointLocalX, jointLocalY); float hipAngle = hipPrimaryAngle - hipStartAngle; float shinPrimaryAngle = polarAngle(x - jointLocalX, y - jointLocalY); float shinAngle = (shinPrimaryAngle - hipAngle) - shinStartAngle;

wobei x und y die Koordinaten des Punktes sind, den Sie mit Ihrem Fuß erreichen müssen; hipStartAngle - der Winkel, um den die "Hüfte" anfänglich gedreht wird (mit dem Servo in der mittleren Position), ähnlich - shinStartAngle. Übrigens sind bei diesen Berechnungen die Winkel offensichtlich im Bogenmaß angegeben und müssen an Servo-Objekte bereits in Grad übertragen werden. Der vollständig funktionierende Firmware-Code, einschließlich dieses Teils, wird auf GitHub veröffentlicht, siehe den Link am Ende des Artikels. Dies ist ein Stück IC, aber außerdem benötigen Sie ziemlich einfachen Code, um dieses IC auf allen Beinen zu verwenden (siehe Funktionen legsReachTo(), legWrite()). Sie benötigen auch Code, der den Gang tatsächlich implementiert - die Bewegung einer Beingruppe "zurück" (so dass sich der Roboter vorwärts bewegt), während sich die andere Beingruppe erhebt und für den nächsten Schritt vorwärts bewegt, siehe stepForward () Funktion. Sie macht einen Schritt mit den vorgegebenen Parametern. Diese Parameter können übrigens trotz des Namens der Funktion einen Schritt zurücktreten. Wenn diese Funktion in einer Schleife aufgerufen wird, geht der Roboter einen Schritt nach vorne.

Jetzt Empfangen von Befehlen und deren Interpretation. Fügen wir dem Programm einen Status hinzu:

Enum State ( STOP, FORWARD, BACKWARD, FORWARD_RIGHT, FORWARD_LEFT );

Und in der Hauptausführungsschleife von loop() sehen wir uns den aktuellen Zustand (Zustandsvariable) an und ziehen stepForward(), wenn wir uns vorwärts bewegen (mit oder ohne Drehung), und wieder stepForward(), aber mit einem negativen xamp-Argument , wenn wir rückwärts gehen müssen . Drehungen werden dann in legWrite() behandelt, und für eine Rechtsdrehung bleiben die Beine auf der rechten Seite stehen (während die linken Reihen). Hier ist so ein Pferdepanzer. Brutal, aber sehr einfach und funktioniert. Sanftes Drehen ist nur mit 3DOF-Beinen möglich, ein Beispiel dafür ist im Buggybug-Repo zu sehen.

Schalter (Zustand) ( case FORWARD: case FORWARD_RIGHT: case FORWARD_LEFT: stepForward(h, dh, xamp, xshift); break; case BACKWARD: stepForward(h, dh, - xamp, xshift); break; )

Char-Befehl; Während (Serial1.available ()) Befehl = Serial1.read (); switch (command) ( case "w": state = FORWARD; break; case "s": state = BACKWARD; break; case "d": state = FORWARD_RIGHT; break; case "a": state = FORWARD_LEFT; break; default : Zustand = STOP; )

Damit sind die Hauptpunkte der Firmware erledigt, der Rest sind Kleinigkeiten. Obwohl es noch einen vielleicht wichtigen Punkt gibt - die Möglichkeit, die Servos fein abzustimmen. Selbst bei sorgfältigster Montage, wenn alle Servos angewiesen werden, sich um 90° zu drehen, werden sich einige von ihnen immer noch als leicht schief herausstellen. Deshalb müssen Sie in der Lage sein, es anzupassen. Sie können sehen, wie ich es in den hipsWrite()- und shinsWrite()-Methoden und in den hipsTune- und shinsTune-Feinabstimmungs-Arrays gemacht habe.

Montage

Für solche Strukturen ist nichts Besonderes erforderlich: Eine Plexiglasscheibe geeigneter Dicke (vom nächsten Haushaltsflohmarkt) und eine Stichsäge oder Metallsäge reichen aus, um die Details auszuschneiden. Und natürlich eine Bohrmaschine zum Bohren von Löchern. Anstelle von Plexiglas können Sie Sperrholz verwenden (dann können Sie mit einem Brenner noch eine Gedenkinschrift auf dem endgültigen Design anbringen). Es können auch Aluminiumbleche oder -ecken verwendet werden. Bei Sleipnir bin ich einfach den Weg gegangen, eine Aluminiumecke mit 1 cm Rippen zu verwenden (habe ich irgendwo in einem Baumarkt gekauft).

Die Basis wird ein rechteckiger Rahmen sein. Gliedmaßen - 4-Zentimeter-Streifen. Es lohnt sich auch, sich mit vielen kleinen Schrauben und Muttern einzudecken. Wir schneiden die Ecke in die notwendigen Stücke, schneiden Nuten für Servos aus, bohren Löcher für Befestigungsbolzen und Schrauben. Das Design ist besser zu zeigen als zu beschreiben. Die Größen können beliebig sein, Roboter sollten verschieden sein. Aber denken Sie daran: Je länger die Beine, desto mehr Hebelkraft muss das Servo drücken und desto größer ist die Belastung. Bis hin zur Unmöglichkeit sich umzudrehen und sogar zu brechen. Aber 4–5 cm sind kein Problem.

Bei preisgünstigen Leichtbaurobotern wird oft auf ein separates Schwenken der Gliedmaßen verzichtet und die gesamte Last fällt vollständig auf die Servowelle. Bei einem geringen Gewicht ist dies überhaupt nicht kritisch. Und bei mehr Gewicht sollte man an Servos mit Metallgetriebe und kugelgelagerter Welle denken.

Jedes Servo wird normalerweise mit ein paar Schrauben und einem Satz Bits geliefert, die für eine Vielzahl von Anwendungen auf die Welle geschraubt werden können. Am besten eignet sich für uns ein einzelnes "Horn" (bzw. Horn), mit dem Sie eine Stange am Servo anbringen können. Die Achsen von zwei Servos werden also an einer Stange befestigt, und die Stange wird zu einem „Schenkel“. In diesem Fall wird ein Serv am Körper befestigt und der andere wird Teil des Unterschenkels. Es lohnt sich, eine weitere Stange daran zu schrauben, nur um das Glied zu verlängern oder interessanter zu machen. Ein wenig harte Arbeit - und die Plattform ist fertig (handliche Sets aus Schraubendrehern, Schraubenschlüsseln, Pinzetten, Drahtschneidern usw. beschleunigen den Vorgang erheblich).

Was weiter?

Das gesamte Projekt ist unter https://github.com/poconoco/sleipnir verfügbar. Ich habe eine der unpraktischsten Konfigurationen beschrieben - viele 2DOF-Beine, groß, schmal, fallen leicht auf die Seite. Versuchen Sie, einen besseren Roboter mit 3DOF-Beinen zu bauen. Mit 4DOF-Beinen. Mit Krallen oder Kiefern. Als Beispiel für inverse 3DOF-Kinematik können Sie auf das Buggybug-Repository verweisen - es gibt eine Hexapod-Firmware. Sie können auch nicht gesteuerte, aber intelligente Roboter bauen, indem Sie Abstandssensoren anstelle von Bluetooth einsetzen und dem Roboter beibringen, Wände und Hindernisse zu umgehen. Setzt man einen solchen Sensor auf einen Servoantrieb und dreht ihn, dann kann man den Bereich fast wie mit einem Sonar abtasten.