Webgesteuerter Rover - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

Das Bauen und Spielen mit Robotern ist mein Hauptvergnügen im Leben. Andere spielen Golf oder Ski, aber ich baue Roboter (da ich weder Golf noch Ski spielen kann:-). Ich finde es entspannend und macht Spaß! Um die meisten meiner Bots herzustellen, verwende ich Chassis-Kits. Die Verwendung von Kits hilft mir, das zu tun, was ich mehr mag, die Software und die Elektronik, und sorgt auch für ein besseres Chassis für mein reines Selbst.

In diesem Instructable werden wir uns ansehen, was es braucht, um einen einfachen, aber robusten Wifi / webgesteuerten Rover zu machen. Als Chassis kommt der Actobotics Schwanenhals zum Einsatz. Ich habe es wegen seiner Größe, Erweiterbarkeit und Kosten ausgewählt, aber Sie können jedes andere Chassis Ihrer Wahl verwenden.

Für ein Projekt wie dieses benötigen wir einen guten soliden Einplatinencomputer und für diesen Bot habe ich mich für den Raspberry Pi (RPI) entschieden, einen Linux-basierten Computer. Das RPI (und Linux) bietet uns viele Codierungsoptionen und Python wird für die Codierungsseite verwendet. Für das Webinterface verwende ich Flask, ein leichtes Webframework für Python.

Für den Antrieb der Motoren habe ich mich für einen RoboClaw 2x5a entschieden. Es ermöglicht eine einfache serielle Kommunikation für die Steuerung und funktioniert gut mit dem RPI und den Motoren am Schwanenhals.

Schließlich verfügt es über eine Webcam für Video-Feedback vom Typ POV, um es aus der Ferne zu steuern. Auf jedes Thema werde ich später noch genauer eingehen.

Schritt 1: Benötigte Hardware

• Actobotics Schwanenhals-Chassis oder ein passender Ersatz Ihrer Wahl
• Raspberry Pi Ihrer Wahl (oder Klon) - Bei diesem Bot wird ein RPI-Modell B verwendet, aber jeder mit mindestens zwei USB-Anschlüssen funktioniert
• Standard-Servoplatte B x1
• 90° Einzelwinkel-Kanalhalterung x1
• RoboClaw 2x5a-Motortreiber
• S3003 oder ähnliches Servo in Standardgröße
• Kleines Steckbrett oder Mini-Steckbrett
• Überbrückungsdrähte von Buchse zu Buchse
• Stecker-zu-Buchse-Überbrückungsdrähte
• Webcam (optional) - Ich verwende eine Logitech C110 und hier ist eine Liste der unterstützten Cams für den RPI
• 5V-6V Stromquelle für Servostrom
• 7,2 V-11,1 V Batterie zur Stromversorgung des Antriebsmotors
• 5V 2600mAh (oder höher) USB-Powerbank für den RPI
• USB-WLAN-Adapter

Auf meinem Bot verwende ich 4 -Räder, um es etwas mehr All-Terrain-Indoor zu machen. Für diese Option benötigst du:

• 4" Hochleistungsrad x2
• 4mm Bohrung Stellschraubennabe (0.770 Zoll) x2

Schritt 2: Zusammenbau des Chassis

Montieren Sie zuerst das Chassis gemäß den Anweisungen, die dem Chassis oder dem Video beiliegen. Nach Abschluss sollten Sie so etwas wie das Bild haben. HINWEIS: Lassen Sie bei der Montage des Halsteils einfach die Montagehalterung weg.

Bei meinem Bot habe ich mich entschieden, die Räder, mit denen das Chassis geliefert wurde, durch 4 -Schwerlasträder zu ersetzen. Dies ist optional und nicht erforderlich, es sei denn, Sie möchten dasselbe.

Schritt 3: Montage der Elektronik

Der Schwanenhals bietet viel Platz und Möglichkeiten zur Montage Ihrer Elektronik. Ich gebe Ihnen diese Bilder als Richtlinie, aber Sie können wählen, wie Sie alles auslegen möchten. Sie können Abstandshalter, doppelseitiges Klebeband, Klett- oder Servoband verwenden, um das Board und die Batterien zu montieren.

Schritt 4: Hinzufügen der Webcam

Nehmen Sie für diesen Schritt die 90-Grad-Halterung, die leichte Servonabe und vier (4) der 0,3125-Zoll-Schrauben:

• Nehmen Sie die Servonabe und legen Sie sie auf eine Seite der Halterung und befestigen Sie sie mit den 0,2125" Schrauben wie abgebildet
• Als nächstes montieren Sie das Servo in die Servohalterung
• Befestigen Sie die 90-Grad-Halterung mit dem Servohorn an der Wirbelsäule des Servos und verwenden Sie die mit dem Servo gelieferte Hornschraube, um sie miteinander zu verbinden
• Montieren Sie nun die Servo-in-Halterung oben auf dem Schwanenhals mit den restlichen Schrauben
• Montieren Sie die Kamera mit Kabelbindern oder doppelseitigem Klebeband an der 90-Grad-Halterung

Verwenden Sie die Bilder bei Bedarf als Leitfaden.

Schritt 5: Alles verdrahten

Die Verkabelung ist für diesen Roboter ziemlich eng.

Die Motoren:

Lötanschlüsse an beiden Motoren, falls noch nicht geschehen

Wenn die Roboterfront (das Ende mit dem Schwanenhals) von Ihnen abgewandt ist:

• Verbinden Sie die Motorkabel des linken Motors mit den Kanälen M1A und M1B
• Verbinden Sie die Motorkabel des rechten Motors mit den Kanälen M2A und M2B

Masse (GND) Anschlüsse:

• Verbinden Sie einen Erdungsstift des RoboClaw mit der Erdungsbrückenplatine. Die Erdungsstiftlinie der RoboClaw ist der Mitte am nächsten (Siehe Bild)
• Verbinden Sie PIN 6 des RPI mit der Steckbrücke. Siehe das RPI-Header-Bild für die Pinbelegung.
• Verbinden Sie den GND vom Servo-Akku mit einem der Pins auf der Jumper-Platine.
• Führen Sie ein Überbrückungskabel von der Überbrückungsplatine zum GND-Kabel des Servos.

RPI zu RoboClaw:

Verbinden Sie den RPI GPIO14 TXD-Pin mit dem RoboClaw S1-Pin

Leistung:

• Verbinden Sie das POS-Kabel vom Servoakku mit dem POS-Kabel des Servos
• Verbinden Sie das POS-Kabel vom Motorakku mit POS (+) des RoboClaw-Motorstromeingangsanschlusses. Wir werden die GND-Klemme vorerst getrennt lassen.

Schritt 6: Einrichten des RPI

Ich gehe davon aus, dass der Benutzer hier etwas über Linux und das RPI weiß. Ich behandle nicht, wie man ein Setup oder eine Verbindung zu einem herstellt. Wenn Sie dabei Hilfe benötigen, verwenden Sie die folgenden Seiten.

Um Ihr RPI-Setup zu erhalten, werfen Sie einen Blick auf die folgenden Seiten:

• RPI-Grundeinstellungen
• RPI-Kurzanleitung
• NOOBS-Setup-Gilde

Für allgemeine Jump-Off-Seiten sind die RPI-Hauptseite und die eLinux-Seiten gute Ausgangspunkte.

Unter diesem Link finden Sie die allgemeine RPI-WLAN-Einrichtung.

Wenn Sie vorhaben, eine Art Kamera oder Webcam für den Bot zu verwenden, sehen Sie sich diese Seiten an, um die grundlegenden benötigten Dateien zu erhalten.

• RPI-Cam-Setup
• eLinix RPI-Cam-Setup

Video streamen:

Es gibt einige Möglichkeiten, Videostreaming mit einem RPI zum Laufen zu bringen, aber die Methode, die ich bevorzuge, ist die Verwendung von Motion.

Um es auf Ihrem RPI zu installieren, führen Sie Folgendes aus: sudo apt-get install motion

Diese instructable geht über die Einrichtung für das Streaming als auch.

Schritt 7: Konfigurieren des seriellen RPI-Ports

Wir müssen den Linux-Konsolenmodus für die Verwendung von RX und TX deaktivieren, da wir über diesen Port mit dem RoboClaw-Motorcontroller kommunizieren möchten. Dazu können Sie diese Methode oder dieses Tool verwenden. Bei der Methode haben Sie die Wahl, da beide am Ende dasselbe tun.

Schritt 8: Installieren der Python-Module

Sie benötigen Python, das auf dem RPI installiert ist, sowie das Python-Paketinstallationsprogramm pip.

Um pip zu installieren, gehen Sie wie folgt vor:

1. sudo apt-get install python-setuptools
2. sudo easy_install pip

Dann:

1. sudo pip install kolben
2. sudo pip install pyserial
3. sudo pip installieren RPIO

Dies sind alle Module, die für die Ausführung des Codes erforderlich sind.

Schritt 9: Einrichten der RoboClaw

Ich habe den Robotercode, der mit dem RoboClaw im seriellen Standardmodus bei 19200 Baud spricht.

Um die RoboClaw dafür einzurichten, gehen Sie wie folgt vor:

1. Drücken Sie die Taste "MODE" auf der RoboClaw
2. Drücken Sie die Set-Taste, bis die LED zwischen den Verzögerungen 5 (fünf) Mal blinkt
3. Drücken Sie die "LIPO"-Taste, um zu speichern
4. Als nächstes drücken Sie die "SET"-Taste, bis die LED zwischen den Verzögerungen 3 (drei) Mal blinkt
5. Drücken Sie die LIPO-Taste, um zu speichern

Das ist es, um den Motorcontroller einzurichten. Weitere Informationen finden Sie bei Bedarf im oben verlinkten pdf.

Schritt 10: Installation des Rover-Programms/der Rover-Dateien

Laden Sie die Datei rover.zip herunter und kopieren Sie sie in Ihr RPI in Ihrem pi-Benutzerverzeichnis.

Wenn Sie Linux oder einen Mac verwenden, können Sie dazu 'scp' verwenden:

scp ~/location/of/the/file/rover.zip pi@your_rpi_ip:/~

Für Windows können Sie pscp herunterladen und verwenden und dann Folgendes tun:

pscp /location/of/the/file/rover.zip pi@your_rpi_ip:/~

Sobald die ZIP-Datei in das RPI kopiert wurde, melden Sie sich als pi-Benutzer an.

Führen Sie nun aus:

rover.zip entpacken

Dadurch werden die Dateien in einen Ordner namens 'rover' entpackt und enthalten Folgendes unter diesem Ordner:

• restrover.py (Der Python-Code für den Roboter)
• statisch (hält die Bilddateien für die Schaltflächen auf der Steuerungsseite)
• Vorlagen (enthält die Datei index.htlm, die Kontrollwebseite)

Wenn Sie eine Webcam verwenden, ändern Sie die Zeile am unteren Rand der Datei index.html im Vorlagenordner. Ändern Sie die URL in der Zeile IFRAME so, dass sie mit der src-URL für Ihren Videostream übereinstimmt.

Schritt 11: Starten des Bots

Verbinden Sie die USB-Stromversorgung mit dem RPI.

Um den Bot-Code zu starten, melden Sie sich als pi-Benutzer an und führen Sie Folgendes aus:

• CD-Rover
• sudo python restrover.py

Wenn alles in Ordnung war, sollten Sie einen Bildschirm ähnlich dem Bild in diesem Schritt sehen

Wenn Sie Fehler oder Probleme sehen, müssen Sie diese beheben, bevor Sie fortfahren.

Verbinden Sie nun das GND (-)-Kabel mit dem NEG (-)-Anschluss am RoboClaw-Motorstromeingang.

Schritt 12: Zugriff auf die Bot-Steuerungsseite

Nachdem das Python-Skript des Roboters ausgeführt wurde, schalten Sie den RoboClaw ein und navigieren Sie dann zur IP Ihres RPI wie:

your_rpi_ip

Sie sollten die Websteuerungsseite wie in den Bildern sehen. Wenn nicht, überprüfen Sie Ihr RPI-Ausgangsterminal, suchen Sie nach Fehlern und korrigieren Sie diese.

Sobald Sie sich auf der Seite befinden, können Sie den Bot steuern.

Der Roboter startet in der Einstellung "Med run" und mit mittlerer Geschwindigkeit.

Der Bot kann über die Schaltflächen auf der Seite oder über Tasten auf der Tastatur gesteuert werden.

Die Schlüssel sind:

• w - vorwärts
• z - rückwärts/rückwärts
• a - lange Linkskurve
• s - lange Rechtskurve
• q - kurze Linkskurve
• e - kurze Rechtskurve
• 1 - Kamera nach links schwenken
• 2 - Kamera nach rechts schwenken
• 3 - Pfanne ganz links
• 4 - ganz rechts schwenken
• / - Home-/Center-Kamera
• h - Roboter anhalten/stoppen

Es gibt einen Verzögerungspuffer von einer halben Sekunde zwischen gesendeten Befehlen. Ich habe dies getan, um unerwünschte wiederholte Befehle zu vermeiden. Sie können dies natürlich aus dem Code entfernen, wenn Sie möchten (in index.html)

Die restlichen Bedienelemente und deren Steuerung sollten selbsterklärend sein.

Schritt 13: Der Python / Flask-Code

Dieser Bot verwendet Python und das Flask-Webframework. Bei Interesse können Sie hier mehr über Flask erfahren.

Der große Unterschied zu einer Flask-App und einem normalen Python-Skript besteht darin, dass @app.route class/method für die URI-Behandlung verwendet wird. Ansonsten ist es zum größten Teil ganz normales Python.

#!/usr/bin/env python

# # Wifi/Web-gesteuerter Rover # # Geschrieben von Scott Beasley - 2015 # # Verwendet RPIO, pyserial und Flask # import time import serial from RPIO import PWM from bottle import Flask, render_template, request app = Flask (_name_, static_url_path = '') # Verbinden Sie sich mit dem Comm-Port, um mit dem Roboclaw-Motorcontroller zu sprechen. Versuchen Sie: gefunden") sys.exit (0) # Drehzahl- und Antriebsregelvariablen last_direction = -1 speed_offset = 84 turn_tm_offset = 0.166 run_time = 0.750 # Servo-Neutralstellung (Home) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Eine kleine Pause, um die Zeit herunterzufahren time.sleep (3) # # URI-Handler - alle Aktionen der Bot-Seite werden hier ausgeführt # # Senden Sie die Bots-Kontrollseite (Homepage) @app.route ("/") def index (): return render_template ('index.html', name = None) @app.route ("/forward") def forward (): global last_direction, run_ti me print "Forward" go_forward () last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Wenn nicht kontinuierlich, dann halt nach Verzögerung if run_time > 0: last_direction = -1 halt () return "ok" @ app.route ("/backward") def rückwärts (): global last_direction, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Wenn nicht kontinuierlich, dann nach Verzögerung anhalten if run_time > 0: last_direction = -1 halt () return "ok" @app.route ("/left") def left (): global last_direction, turn_tm_offset print "Left" go_left () last_direction = -1 # sleep @1 /2 Sekunden time.sleep (0.500 - turn_tm_offset) # stop halt () time.sleep (0.100) return "ok" @app.route ("/right") def right (): global last_direction, turn_tm_offset print "Right" go_right () # sleep @1/2 Sekunde time.sleep (0.500 - turn_tm_offset) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/ltforward") def ltforward (): global last_direction, turn_t m_offset print "Left forward turn" go_left () # sleep @1/8 Sekunde time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/rtforward") def rtforward (): global last_direction, turn_tm_offset print "Rechts vorwärts abbiegen" go_right () # sleep @1/8 Sekunde time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/stop") def stop (): global last_direction print "Stop" halt () last_direction = -1 # sleep 100ms time.sleep (0.100.)) return "ok" @app.route ("/panlt") def panlf (): global servo_pos print "Panlt" servo_pos -= 100 if servo_pos 2500: servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms Zeit. sleep (0.150) return "ok" @app.route ("/home") def home (): global servo_pos print "Home" servo_pos = 1250 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/panfull_lt") def panfull_lt (): global servo_pos print "Pan full l eft" servo_pos = 500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/panfull_rt") def panfull_rt (): global servo_pos print "Pan full right" servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/speed_low") def speed_low (): global speed_offset, last_direction, turn_tm_offset speed_offset = 42 turn_tm_offset = 0.001 # Aktuelle Richtung aktualisieren, um neue Geschwindigkeit zu erhalten if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/speed_mid") def speed_mid (): global speed_offset, last_direction, turn_tm_offset speed_offset = 84 turn_tm_offset = 0.166 # Aktuelle Richtung aktualisieren, um neue Geschwindigkeit zu erhalten if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150.)) return "ok" @app.route ("/speed_hi") def speed_hi (): global speed_offset, last_direction, turn_tm_offset speed_offset = 126 Tur n_tm_offset = 0.332 # Aktuelle Richtung aktualisieren, um neue Geschwindigkeit zu erhalten if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/continuous ") def Continuous (): global run_time print "Continuous run" run_time = 0 # sleep 100ms time.sleep (0.100) return "ok" @app.route ("/mid_run") def mid_run (): global run_time print "Mid run" run_time = 0,750 halt () # sleep 100ms time.sleep (0,100) return "ok" @app.route ("/short_time") def short_time (): global run_time print "Short run" run_time = 0,300 halt () # sleep 100ms time.sleep (0.100) return "ok" # # Motorantriebsfunktionen # def go_forward (): global speed_offset if speed_offset != 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 +.) speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_backward (): global speed_offset if speed_offset != 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.wri te (chr (255 - speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 + speed_offset)) def go_left (): global speed_offset if speed_offset != 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_right (): global speed_offset if speed_offset != 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) def halt (): roboclaw.write (chr (0)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Wenn Sie keine Debug-Informationen von Flask wünschen oder benötigen, setzen Sie debug in der app.run-Zeile auf 'false'.

if _name_ == "_main_":

app.run (host = '0.0.0.0', port = 80, debug = False)

Sie können hier auch den Port ändern, auf dem der Flask-HTTP-Server lauscht.

Schritt 14: Andere Hardware verwenden

Wenn Sie andere Hardware verwenden möchten, z. B. eine andere Art von SBC (Single Board Computer), sollten Sie kleine Probleme haben, Python und Flask auf anderen Boards wie Beagle Bone, PCDuino usw. zum Laufen zu bringen. Sie müssen den Code ändern, damit er dem GPIO entspricht Layout und nutzen Sie die Servoantriebsfunktionen des neuen Boards.

Um einen anderen Motortreibertyp zu verwenden, müssen Sie nur die Funktionen go_forward, go_backward, go_left, go_right und halt ändern, um das zu tun, was auch immer der Ersatzmotortreiber benötigt, damit der Motor diese bestimmte Funktion ausführt.