Fortgeschrittener ferngesteuerter Greifer-Roboter für präzises Handling

Komponenten und Zubehör

Runt Rover Half-pint Chassis

Arduino UNO

V5 Shield

Female/Female Jumper Wires

L9110S

90° Einzelfach-Winkelprofil (585424)

Leichter Servo-Hub, Futaba

Standard Greifer Kit A (637094)

MG995

Standard Servo Platte

90° Einzelfach-Winkelprofil

5-fach AA Halter

AA Wiederaufladbare Akkus

.750" 8-32 Nylon-Distanzhülsen

.500" 6-32 Schrauben mit Muttern

.3125" 6-32 Schrauben

Apps und Online-Dienste

Arduino IDE

Über dieses Projekt

Vor einigen Monaten bat mich mein Sohn, ihm einen ferngesteuerten Bot zu bauen. Er gab mir eine Liste seiner Wünsche, und wir haben sie auf ein machbares Maß reduziert :) Das ist das Ergebnis...

UNO und V5 Sensor Shield zusammenstecken.
Das verbundene UNO/Sensor-Board in den Clip-Halter in der Mitte des Bots einsetzen.
Doppelseitiges Klebeband verwenden, um den Motortreiber an der linken Innenwand und den Bluetooth-Adapter an der rechten Wand zu befestigen.

Für dieses Projekt können Sie Ihr eigenes Chassis bauen oder ein anderes wählen – die Wahl liegt bei Ihnen.

Schritt 1: Benötigte Software

Folgende Downloads sind nötig:

Arduino IDE
Python 2.7 (Vollinstallation mit tkinter)
pySerial Library
L9110S Motortreiber Library (angehängte .zip-Datei, siehe Dateien in diesem Schritt)
Roboter-Code (unten oder angehängte .zip, siehe Dateien in diesem Schritt)
Python Fernsteuerungs-Anwendung (siehe Dateien in diesem Schritt)

Schritt 2: Hardware-Stückliste

Runt Rover Half-pint Chassis oder passender 4WD-geschlossener Ersatz
Arduino Uno oder ähnliches Board mit USB-Kabel
V5 Sensor Shield
L9110S Motortreiber (ein paar Stück besorgen, sind günstig)
MG995 Servo oder passender Ersatz ×2
HC-05 oder HC-06 Bluetooth-Adapter ×1
Standard Servo Platte B ×1
90° Winkel ×1
Einzelfach-Winkel ×2
Leichter Servo-Hub (525125 für Futaba) ×1
Standard Greifer Kit A ×1
Female-to-Female Jumper Wires
5 wiederaufladbare AA-Akkus (NiMH) und Ladegerät
Doppelseitiges Klebeband und kleine Kabelbinder
5-fach 'AA' Batteriehalter (falls AA-Akku-Option gewählt)
6V NiMH oder 7,4V Li-Ion Akkupack und Ladegerät
1,250" 6-32 Schrauben ×2
.750" 8-32 Nylon-Distanzhülsen ×2
.500" 6-32 Schrauben mit Muttern ×8
.3125" 6-32 Schrauben ×8

Viele Teile beziehen Sie über eBay oder direkt bei Händlern wie Sparkfun, Adafruit und ServoCity.

Nach Kauf, Sammlung und Download aller Teile können Sie mit dem Bau beginnen.

Schritt 3: Zusammenbau – Das Chassis

Zuerst das Chassis gemäß der beiliegenden Anleitung oder Video zusammenbauen. Danach sollte es wie auf dem Bild aussehen. Wenn Sie die Platte für den Controller auf dem Bot platzieren, nutzen Sie die mittleren Löcher. So bleibt Platz vorne und hinten.

HINWEIS: Bevor Sie weitermachen, bitte alle 4 Räder abnehmen, um die Motoren beim Einbau der anderen Komponenten nicht zu beschädigen!

Schritt 4: Greifer zusammenbauen

Greifer gemäß Anleitung in diesem Video zusammenbauen. Das Ergebnis sollte wie auf dem Bild aussehen.

Schritt 5: Greifer montieren – Schritt 1

Für diesen Schritt benötigen Sie: 90° Winkel, leichten Servo-Hub und vier (4) .3125"-Schrauben.

Servo-Hub auf eine Seite des Winkels legen und mit den .3125"-Schrauben befestigen (wie abgebildet), beiseitelegen
Muttern auf die beiden kürzeren Schrauben aufsetzen und festziehen
Nun die beiden Einzelfach-Winkel, die 1.250"-Schrauben, zwei .500"-Schrauben mit Muttern, 2 Nylon-Distanzhülsen und die Servo-Platte B nehmen
Einen Einzelfach-Winkel innen im Half-pint-Bot platzieren und die beiden 1.250"-Schrauben durch die linken Löcher (von innen) und die beiden .500"-Schrauben auf der rechten Seite führen. Alle Schraubenköpfe liegen innen am Bot
Zweiten Einzelfach-Winkel auf die Schrauben außen am Bot setzen
Nylon-Distanzhülsen auf die längeren (1.250") hervorstehenden Schrauben stecken und die Servo-Platte auf die langen Schrauben schrauben
Schrauben zur Servo-Platte mit passendem Inbusschlüssel oder Schraubendreher festziehen

Bei Bedarf die Bilder als Referenz nutzen.

Schritt 6: Greifer montieren – Schritt 2

Verbleibenden Servo in die Servo-Halterung mit dem Wellenende nach oben setzen. Mit 4 der .3125"-Schrauben befestigen.
90° Winkel mit Servo-Hub nehmen und Greifer mit 4 der .500"-Schrauben darauf montieren, wobei 2 der 8-32-Muttern als Distanzstücke zwischen Winkel und Greifer dienen (wie abgebildet). Mit weiterer Mutter oben auf dem Greifer sichern (oder unter dem Winkel, falls Schrauben andersherum eingesetzt).
Greifer-Montage auf den Servo setzen und Servoschraube (aus Servo-Paket) verwenden, um ihn fest zu fixieren.

Zum Schluss die beiden Servokabel durch das Loch in der flachen Platte ins Innere des Bots führen.

Details und Referenzen in den Bildern.

Schritt 7: Elektronik montieren

UNO und V5 Sensor Shield zusammenstecken.
Verbundenes UNO/Sensor-Board in den Clip-Halter in der Mitte des Bots einsetzen.
Doppelseitiges Klebeband verwenden: Motortreiber an linker Innenwand, Bluetooth-Adapter an rechter Wand befestigen.

Schritt 8: Verkabelung – Die Motoren

A-1A Pin am Motortreiber → Pin 5 am Sensor Shield
A-1B Pin am Motortreiber → Pin 6 am Sensor Shield
B-1A Pin am Motortreiber → Pin 3 am Sensor Shield
B-1B Pin am Motortreiber → Pin 11 am Sensor Shield

Mit der Roboterfront von Ihnen wegweisend, die Kabel auf der LINKEN Seite nehmen und:

Beide SCHWARZEN Kabel links an den ersten Ausgangsschraubklemmen für Motor A anschließen
Beide ROTEN Kabel links an die zweite Ausgangsschraubklemme für Motor A anschließen

Kabel auf der RECHTEN Seite nehmen und:

Beide SCHWARZEN Kabel links an den ersten Ausgangsschraubklemmen für Motor B anschließen
Beide ROTEN Kabel links an die zweite Ausgangsschraubklemme für Motor B anschließen

Die Servos:

Y-Servo-Kabel an Pin-Leiste 2 am Sensor Shield anschließen. Das weiße oder orangene Kabel ist immer das Signalkabel.
X (Greifer) Servo-Kabel an Pin-Leiste 7 am Sensor Shield anschließen. Das weiße oder orangene Kabel ist immer das Signalkabel.

Schritt 9: Bluetooth-Modul verdrahten

Bluetooth-Adapter Tx → Sensor Shield Pin 0
Bluetooth-Adapter Rx → Sensor Shield Pin 1

Schritt 10: Stromversorgung anschließen

Stromkabel vom 5er 'AA' (oder anderem 6V-Pack) Batteriehalter an die Strom-Schraubklemme des Sensor Shields anschließen:

Rot an Vcc
Schwarz an GND
Jumper auf dem V5 Sensor Shield auf den Jumper-Pins belassen
GND-Pin am L9110S Treiber an einen GND-Pin am Sensor Shield anschließen
Pluspol vom 6V oder 7,2V Motor-Akku (oder anderer gewählter Akku) an Vcc-Pin am L9110S Motortreiber anschließen
Minuspol (GND) vom Motor-Akku an einen GND-Pin am Motortreiber anschließen

Schritt 11: HC05/HC06 Bluetooth-Modul konfigurieren

Nun müssen Sie in die Bluetooth-Geräteeinstellungen Ihres PCs über die „Systemsteuerung“ oder „Systemeinstellungen“ des Betriebssystems gehen oder Google zur Hilfe nehmen.

Mögliche OS-Bluetooth-Setup-Infos:

Windows
Linux (ich nutze blueman auf Linux Mint, aber schauen Sie in Ihre Distribution)
Mac

Notieren Sie den seriellen Port-Gerätenamen oder die Nummer, die ihm zugewiesen wurde.

Schritt 12: Code hochladen

Nach gründlichem Prüfen der Verkabelung ist es Zeit, den Code hochzuladen. Folgen Sie den Anweisungen auf der Arduino-Website zur Installation der Arduino IDE.

Nach Installation der IDE als Nächstes die L9110 Motortreiber-Library installieren: Die in SCHRITT 1 enthaltene ZIP-Datei L9110Driver.zip herunterladen und in Ihren Arduino-Libraries-Ordner entpacken oder diesen Anweisungen folgen, wie man eine Library hinzufügt.

Nun, da IDE und Motortreiber-Library installiert sind, den Roboter-Code in die Arduino IDE laden – aus der ZIP-Datei in SCHRITT 1 namens blue_t_slave.zip. Diese Dateien sind auch in diesem Schritt enthalten.

PC und Arduino per USB-Kabel verbinden. Board im Menü Werkzeuge → Board auswählen (Uno für dieses Projekt; anderes Board wählen, falls abweichend). Im Menü Werkzeuge → Port Ihren COM-Port wählen. Dann auf Hochladen klicken. Wenn alles klappt, wurde der Code geladen; sonst hier nach Hilfe zur IDE und verwandten Problemen suchen.

Schritt 13: Python-Steuerungsanwendung starten

Um die Python-Fernsteuerungsanwendung zu starten, die ZIP-Datei aus diesem Schritt herunterladen und an den gewünschten Ort entpacken. Dann eine Kommandozeile (Terminal, cmd.exe, etc.) öffnen und in das Verzeichnis navigieren, in das Sie die Datei entpackt haben. Nun eingeben: python rover.py und ein Fenster wie im Bild sollte auftauchen. Falls nicht, nach Python-Fehlern suchen und beheben (fehlende Libraries etc.) – die Python-Website kann helfen.

Sobald die App läuft, sind Sie startklar.

Bot einschalten. Dann den COM-Port Ihres Adapters eingeben und auf „Verbinden“ klicken. Nach wenigen Sekunden sollten die anderen Steuerelemente aktiviert und der Verbinden-Button deaktiviert sein – Sie sind mit dem Roboter verbunden. Falls keine Verbindung zum Bluetooth-Adapter möglich ist, hilft Google weiter!

Die Steuerungsanwendung ist einfach zu bedienen und erlaubt Maus- oder Tastatursteuerung.

Tastaturbefehle:

Pfeiltasten: Vorwärts, Rückwärts, Links 90°, Rechts 90°
a – Links 45°
s – Rechts 45°
h – Halt (Stopp)
y – Greifer Y-Achse setzen
u – Greifer Öffnen/Schließen setzen
c – Greifer Home-Position

Vorwärts- und Rückwärtsbefehle sind konstant – der Bot bewegt sich weiter, bis ein neuer Richtungsbefehl oder Halt gesendet wird.

Die 90°- und 45°-Drehungen sind temporär – nach einer Verzögerung stoppt der Bot.

Die Greifer-Schieberegler setzen den Greifer nicht automatisch. Sie müssen den entsprechenden „Set“-Button oder die Taste drücken, um die Ausführung auszulösen.

Slider-Werte reichen von 0–180.

Greifer Y-Achse: 0 = ganz oben, 180 = ganz unten
Greifer Öffnen/Schließen: 0 = ganz geschlossen, 180 = ganz offen

„Trennen“-Button nutzen, um das Programm zu beenden. Dies sendet Stopp-Befehle an den Bot und fährt den Greifer in Home-Position.

Code

Python Driver GUI Python

#!/usr/bin/env python
# Für Linux, BSD oder Mac OSX: chmod +x auf dieses Script, um es ausführbar zu machen
###########
# Rover Steuerungs-App
# Geschrieben von Scott Beasley - 2015
# Frei zur Nutzung oder Modifikation. Viel Spaß.
###########
import sys
import serial
import time
from Tkinter import *
import tkFont
import tkMessageBox

# Fenster für die Anwendung erstellen
class App(Frame):
    def createWidgets(self):
        self.connected = False
        self.message = StringVar()
        
        # Kleine Schrift für Greifer-Set-Buttons
        helv6 = tkFont.Font(family='Helvetica', size=6, weight='normal')
        
        self.frame = Frame(self.master)
        self.frame.pack()
        
        # Verbindungsbereich
        self.f1 = Frame(self.frame)
        self.l1 = Label(self.f1, text="Comm Port: ")
        self.l1.pack(side=LEFT)
        self.comm_entry = Entry(self.f1, bd=5, name="comm_entry")
        self.comm_entry.pack(side=LEFT)
        self.connectButton = Button(self.f1, text="Connect", command=self.SerialConnect, name="b_connect")
        self.connectButton.pack(side=LEFT)
        self.disconnectButton = Button(self.f1, text="Disconnect", command=self.SerialDisconnect, name="b_disconnect")
        self.disconnectButton.pack(side=RIGHT)
        self.f1.grid(row=0, column=0)
        
        # Steuerungsbereich
        self.f2 = LabelFrame(self.frame, bd=3, relief="groove", text="Ground Control")
        
        # Greifer Y-Achse (vertikal)
        self.g_vert_fm = Frame(self.f2)
        self.grip_vert = Scale(self.g_vert_fm, from_=0, to=180)
        self.grip_vert.grid(row=0, column=0, rowspan=4, sticky=W)
        self.grip_vert_set = Button(self.g_vert_fm, text="Set", command=self.GripperY, name="b_grip_vert_set", width=1, height=2, font=helv6)
        self.grip_vert_set.grid(row=5, column=0, sticky=W)
        self.master.bind("", self.GripperY)
        self.g_vert_fm.grid(row=0, column=0, rowspan=4, sticky=W)
        
        # Bewegungstasten
        self.leftforwardButton = Button(self.f2, text="\\", command=self.TurnLeft45, name="b_left_forward")
        self.leftforwardButton.grid(row=0, column=1)
        self.master.bind("", self.TurnLeft45)
        
        self.leftButton = Button(self.f2, text="<", command=self.TurnLeft, name="b_left")
        self.leftButton.grid(row=1, column=1)
        self.master.bind("", self.TurnLeft)
        
        self.rightforwardButton = Button(self.f2, text="/", command=self.TurnRight45, name="b_right_forward")
        self.rightforwardButton.grid(row=0, column=3)
        self.master.bind("", self.TurnRight45)
        
        self.haltButton = Button(self.f2, text="Halt!", command=self.Halt, name="b_halt")
        self.haltButton.grid(row=1, column=2)
        self.master.bind("", self.Halt)
        
        self.rightButton = Button(self.f2, text=">", command=self.TurnRight, name="b_right")
        self.rightButton.grid(row=1, column=3)
        self.master.bind("", self.TurnRight)
        
        self.upButton = Button(self.f2, text="^", command=self.Forward, name="b_forward")
        self.upButton.grid(row=0, column=2)
        self.master.bind("", self.Forward)
        
        self.leftdownButton = Button(self.f2, text="/", command=self.TurnRight45, name="b_left_down")
        self.leftdownButton.grid(row=2, column=1)
        
        self.downButton = Button(self.f2, text="V", command=self.Reverse, name="b_reverse")
        self.downButton.grid(row=2, column=2)
        self.master.bind("", self.Reverse)
        
        self.rightdownButton = Button(self.f2, text="\\", command=self.TurnLeft45, name="b_right_down")
        self.rightdownButton.grid(row=2, column=3)
        
        # Greifer X-Achse (horizontal)
        self.g_horz_fm = Frame(self.f2)
        self.grip_horz = Scale(self.g_horz_fm, from_=0, to=180, orient=HORIZONTAL)
        self.grip_horz.grid(row=0, column=0, columnspan=7, sticky=E)
        self.grip_horz_set = Button(self.g_horz_fm, text="Set", command=self.GripperX, name="b_grip_horz_set", width=1, height=2, font=helv6)
        self.grip_horz_set.grid(row=0, column=8)
        self.master.bind("", self.GripperX)
        self.g_horz_fm.grid(row=4, column=0, columnspan=7, sticky=E)
        self.master.bind("", self.GripperHome)
        
        # Statuszeile
        self.f3 = Frame(self.frame)
        self.l2 = Label(self.f3, text="Last action: ")
        self.l2.pack(side=LEFT)
        self.l3 = Label(self.f3, text=" ", textvariable=self.message)
        self.l3.pack(side=RIGHT)
        self.f3.grid(row=3, column=0, pady=8)
    
    # Zustand der Bot-Steuertasten setzen
    def CtrlButtonsState(self, bstate):
        self.leftforwardButton.config(state=bstate)
        self.leftButton.config(state=bstate)
        self.rightforwardButton.config(state=bstate)
        self.rightButton.config(state=bstate)
        self.upButton.config(state=bstate)
        self.leftdownButton.config(state=bstate)
        self.downButton.config(state=bstate)
        self.rightdownButton.config(state=bstate)
        self.haltButton.config(state=bstate)
        self.disconnectButton.config(state=bstate)
        self.grip_horz.config(state=bstate)
        self.grip_vert.config(state=bstate)
        self.grip_horz_set.config(state=bstate)
        self.grip_vert_set.config(state=bstate)
    
    # Zustand der Comm-Port-Eingabe setzen
    def ConnCtrlsState(self, bstate):
        self.connectButton.config(state=bstate)
        self.comm_entry.config(state=bstate)
    
    # Mit Comm-Port verbinden
    def SerialConnect(self):
        try:
            # Baudrate hier ändern, falls abweichend von 9600
            self.ser = serial.Serial(self.comm_entry.get(), 9600)
        except IOError:
            tkMessageBox.showerror("Invalid comm port", "Comm port not found.")
            return
        self.ConnCtrlsState(DISABLED)
        self.CtrlButtonsState(NORMAL)
        self.message.set("SerialConnect")
        self.connected = True
        time.sleep(3)  # Warten auf Verbindungsaufbau
    
    # Vom Bot trennen (Comm-Port schließen)
    def SerialDisconnect(self):
        try:
            # Halt-Befehl senden, falls Bot noch fährt
            self.send_cmd('h', "Halt!")
            time.sleep(1)
            self.ser.close()
        except IOError:
            print("Could not close port...")
        self.message.set("SerialDisconnect")
        self.ConnCtrlsState(NORMAL)
        self.CtrlButtonsState(DISABLED)
        self.connected = False
        time.sleep(2)  # Warten auf Trennung
    
    # Befehl an offenen Comm-Port senden
    def send_cmd(self, action, msg):
        if self.connected == True:
            for val in action:
                self.ser.write(val)
            self.ser.flush()
            self.message.set(msg)
    
    # Links-Drehung senden
    def TurnLeft(self, event=None):
        self.send_cmd('a', "Left")
    
    # Links-45°-Drehung senden
    def TurnLeft45(self, event=None):
        self.send_cmd('q', "Left45")
    
    # Rechts-Drehung senden
    def TurnRight(self, event=None):
        self.send_cmd('s', "Right")
    
    # Rechts-45°-Drehung senden
    def TurnRight45(self, event=None):
        self.send_cmd('e', "Right45")
    
    # Vorwärts senden
    def Forward(self, event=None):
        self.send_cmd('w', "Up")
    
    # Rückwärts senden
    def Reverse(self, event=None):
        self.send_cmd('z', "Down")
    
    # Halt senden
    def Halt(self, event=None):
        self.send_cmd('h', "Halt!")
    
    # Greifer X (horizontal) setzen
    def GripperX(self, event=None):
        # Slider-Wert lesen und an Bot-Controller senden
        # Hinweis: 0 = ganz geschlossen, 180 = ganz offen
        grp_change = ('>', chr(self.grip_horz.get()), chr(255))
        self.send_cmd(grp_change, "Gripper X")
    
    # Greifer Y (vertikal) setzen
    def GripperY(self, event=None):
        # Slider-Wert lesen und an Bot-Controller senden
        # Hinweis: 0 = ganz oben, 180 = ganz unten
        grp_change = ('^', chr(self.grip_vert.get()), chr(255))
        self.send_cmd(grp_change, "Gripper Y")
    
    # Greifer in Home-Position
    def GripperHome(self, event=None):
        self.send_cmd(('c', chr(255)), "Gripper Home")

    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.pack()
        self.createWidgets()
        self.CtrlButtonsState(DISABLED)

# GUI (Tk) starten, Fenstergröße und Titel setzen
def main():
    root = Tk()
    root.geometry("450x350")
    root.wm_title("Rover Control Center (RCC)")
    app = App(master=root)
    app.mainloop()

if __name__ == '__main__':
    main()

Rover Code Arduino

/* Bluetooth Rover. Ziel im Leben... Folgt Ihren Befehlen, die magisch durch die Luft gesendet werden! Oder per USB :)
   Geschrieben von Scott Beasley - 2015
   Frei zur Nutzung oder Modifikation. Viel Spaß. */
/* Nutzt die L9110S Library. Funktioniert mit L9110S H-Brücke.
   Download von https://github.com/jscottb/L9110Driver
   Oder ZIP von https://github.com klonen und '-master' vom Archivnamen entfernen, um Library hinzuzufügen */
#include <L9110Driver.h>
#include <Servo.h>

#define SERVO_Y 2        // Pin Greifer Y-Servo
#define SERVO_CLAW 7     // Pin Greifer Greifer-Servo
#define pinAIN1 5        // I1 Interface definieren
#define pinAIN2 6        // I2 Interface definieren
#define pinBIN1 3        // I3 Interface definieren
#define pinBIN2 11       // I4 Interface definieren

// Geschwindigkeits-Defines
#define MAXFORWARDSPEED 225   // Max Geschwindigkeit vorwärts
#define MAXBACKWARDSPEED 225  // Max Geschwindigkeit rückwärts
#define TOPSPEED 255          // Für besseres Drehen auf Teppich/rauen Oberflächen

// Zeitverzögerungen für Fahren und Servo
#define TURNDELAY 475
#define TURNDELAY45 235
#define BACKUPDELAY 400
#define SERVOMOVEDELAY 200
#define SERVOSEARCHDELAY 85

/* Globale Variablen */
// Motor- und Servo-Objekte erstellen
L9110_Motor motor_left(pinAIN1, pinAIN2);   // Linkes Motor-Objekt
L9110_Motor motor_right(pinBIN1, pinBIN2);  // Rechtes Motor-Objekt
Servo grip_y_servo;                         // Servo-Objekt für Greifer Y-Achse
Servo grip_servo;                           // Servo-Objekt für Greifer-Klaue

void setup() {
  Serial.begin(9600);  // Baudrate hier ändern, falls abweichend von 9600
  grip_y_servo.attach(SERVO_Y);
  grip_y_servo.write(90);
  grip_servo.attach(SERVO_CLAW);
  grip_servo.write(90);
  delay(500);
}

void loop() {
  byte command = 0, val = 0;
  if (Serial.available() > 0) {
    command = Serial.read();
  }
  switch (command) {
    case 'w': go_forward(); break;
    case 'z': go_backward(); break;
    case 'a': go_left(); delay(TURNDELAY); halt(); break;
    case 's': go_right(); delay(TURNDELAY); halt(); break;
    case 'q': go_left(); delay(TURNDELAY45); halt(); break;
    case 'e': go_right(); delay(TURNDELAY45); halt(); break;
    case 'h': halt(); break;
    case '>':  // Greifer X Bewegung sendet Servo-Sollwert
      val = Serial.read();
      grip_servo.write(constrain(val, 64, 179));
      break;
    case '^':  // Greifer Y Bewegung sendet Servo-Sollwert
      val = Serial.read();
      grip_y_servo.write(constrain(val, 53, 179));
      break;
    case 'c':  // Greifer Home
      grip_y_servo.write(90);
      grip_servo.write(90);
      break;
    case 255:  // Nach allen Greifer-Befehlen gesendet
      Serial.flush();
      break;
  }
  Serial.flush();
  delay(125);
}

void go_forward() {
  ramp_it(MAXFORWARDSPEED, FORWARD, FORWARD);
  motor_left.setSpeed(MAXFORWARDSPEED);
  motor_right.setSpeed(MAXFORWARDSPEED);
  motor_left.run(FORWARD|RELEASE);
  motor_right.run(FORWARD|RELEASE);
}

void go_backward() {
  ramp_it(MAXBACKWARDSPEED, BACKWARD, BACKWARD);
  motor_left.setSpeed(MAXBACKWARDSPEED);
  motor_right.setSpeed(MAXBACKWARDSPEED);
  motor_left.run(BACKWARD|RELEASE);
  motor_right.run(BACKWARD|RELEASE);
}

void go_left() {
  ramp_it(TOPSPEED, BACKWARD, FORWARD);
  motor_left.setSpeed(TOPSPEED);
  motor_right.setSpeed(TOPSPEED);
  motor_left.run(BACKWARD|RELEASE);
  motor_right.run(FORWARD|RELEASE);
}

void go_right() {
  ramp_it(TOPSPEED, FORWARD, BACKWARD);
  motor_left.setSpeed(TOPSPEED);
  motor_right.setSpeed(TOPSPEED);
  motor_left.run(FORWARD|RELEASE);
  motor_right.run(BACKWARD|RELEASE);
}

void halt() {
  motor_left.setSpeed(0);
  motor_right.setSpeed(0);
  motor_left.run(BRAKE);
  motor_right.run(BRAKE);
}

void ramp_it(uint8_t speed, uint8_t lf_dir, uint8_t rt_dir) {
  uint8_t ramp_val = 0, step_val = 0;
  step_val = abs(speed / 4);
  if (!speed) step_val = -step_val;
  for (uint8_t i = 0; i < 4; i++) {
    ramp_val += step_val;
    motor_left.setSpeed(ramp_val);
    motor_right.setSpeed(ramp_val);
    motor_left.run(lf_dir|RELEASE);
    motor_right.run(rt_dir|RELEASE);
    delay(25);
  }
}

L9110 Treiber

L9110 Motortreiber für Arduino: GitHub Repository

Custom Parts und Gehäuse

4wdgripperbt2.fzz

Schaltpläne

4wdgripperbt2.fzz

IoT-Thermometer mit Python bauen: Kompletter Leitfaden u-blox LEA-6H 02 GPS-Modul: Arduino & Python Integrationsanleitung

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik