Motoren

Jetzt beginnen wir mit den Motoren, die den Antrieb des Joy-Cars darstellen. Mit den Motoren kannst du das Joy-Car sowohl vorwärts als auch rückwärts bewegen. Außerdem kannst du die Geschwindigkeit individuell anpassen, das Fahrzeug in verschiedene Richtungen lenken und es bei Bedarf abbremsen. Die Motoren bieten dir somit die volle Kontrolle über die Bewegungen deines Joy-Cars, sodass du sowohl präzise Manöver als auch dynamisches Fahren umsetzen kannst.

Mehr Informationen zu den Motoren findest du hier.

Im folgenden Codebeispiel werden die möglichen Bewegungen des Joy-Cars ausführlich dargestellt. Das Joy-Car kann sich nicht nur in den Grundrichtungen vorwärts, rückwärts, nach rechts und nach links bewegen, sondern auch in einem festgelegten Radius fahren. Dies ermöglicht dem Joy-Car komplexere Fahrmanöver, indem es sanfte Kurven und Wendungen vollziehen kann. Die Steuerung der Bewegung erfolgt dabei über spezifische Befehle, die jeweils die gewünschte Richtung und gegebenenfalls den Radius der Kurve definieren. So kann das Joy-Car flexibel und präzise durch verschiedene Umgebungen navigiert werden.

Fahren

Fahre vorwärts oder rückwärts. Die Geschwindigkeit kannst du zusätzlich in Prozent zwischen 0 (kein Antrieb) und 100 (maximaler Antrieb) wählen.

Bremsen

Bremse das Joy-Car bis zum Stillstand. Du kannst hier zusätzlich wählen zwischen einer harten Vollbremsung oder einem sanften Bremsen, bei dem das Joy-Car langsam ausrollt.

Kurven

Fahre eine Links- oder Rechtskurve. Auch hier kannst du die Geschwindigkeit in Prozent einstellen. Zusätzlich kannst du das Radius-Level der Kurve von 0 - 5 angeben (0 = Enge Kurve, 5 = Weite Kurve).

PWM-Signal

Die Motoren können auch direkt über PWM-Signale angesteuert werden. Dazu kann an jeden Kanal ein PWM-Wert zwischen 0 und 255 gesendet werden.

Codebeispiel

JoyCar.initJoyCar(RevisionMainboard.OnepThree)
basic.forever(function () {
    JoyCar.drive(FRLRDirection.Forward, 100)
    basic.pause(2000)
    JoyCar.drive(FRLRDirection.Reverse, 100)
    basic.pause(2000)
    JoyCar.turn(
    FRDirection.Forward,
    LRDirection.Left,
    100,
    0
    )
    basic.pause(2000)
    JoyCar.turn(
    FRDirection.Forward,
    LRDirection.Right,
    100,
    0
    )
    basic.pause(2000)
    JoyCar.stop(StopIntensity.Intense)
    basic.pause(2000)
    JoyCar.turn(
    FRDirection.Forward,
    LRDirection.Left,
    50,
    4
    )
    basic.pause(1000)
    JoyCar.turn(
    FRDirection.Reverse,
    LRDirection.Right,
    50,
    2
    )
    basic.pause(1000)
})

Vorbereitung für Motoren

Zunächst aktivieren wir die Motorensteuerung, indem wir die entsprechenden Befehle über die I2C-Schnittstelle senden.

Dies ermöglicht die Kommunikation zwischen dem Mikrocontroller und den Motoren. Um die Motoren präzise und effizient anzusteuern, nutzen wir die Variablen biasL und biasR. Diese Variablen dienen dazu, die Drehgeschwindigkeiten der linken und rechten Motoren in Prozent zu justieren. Dies ist besonders wichtig, um Abweichungen auszugleichen, die durch Verschleiß, Fertigungstoleranzen oder andere Einflüsse entstehen können, und sorgt dafür, dass das Joy-Car geradeaus fährt oder präzise Manöver durchführen kann.

# PWM-Controller initialisieren
i2c.write(0x70, b'\x00\x01')
i2c.write(0x70, b'\xE8\xAA')

# die Verzögerung einer Motorverzögerung kann verwendet werden, um unterschiedliche Motordrehzahlen zu kompensieren
biasR = 0  # Verzögerung des rechten Motors in Prozent
biasL = 0  # Verzögerung des linken Motors in Prozent

Motorensteuerung

Die Methode drive ermöglicht die Steuerung der beiden Motoren des Joy-Cars. Dabei steuern die PWM-Signale PWM0 und PWM1 den linken Motor, während PWM2 und PWM3 für den rechten Motor zuständig sind. Innerhalb der Methode werden die Eingabewerte zunächst skaliert, um die Motoren aneinander anzupassen, falls Unterschiede in den Drehgeschwindigkeiten auftreten. Diese Skalierung berücksichtigt die zuvor definierten Korrekturfaktoren wie biasL und biasR.

Am Ende der Methode wird die berechnete Motorengeschwindigkeit über die I2C-Schnittstelle an den Motorcontroller gesendet, der die Adresse 0x70 verwendet. Dies stellt sicher, dass die Steuerbefehle präzise umgesetzt werden und die Motoren entsprechend der gewünschten Geschwindigkeit arbeiten.

# Motoren mit dem PWM-Controller steuern
# PWM0 und PWM1 für den linken Motor und PWM2 und PWM3 für den rechten Motor
def drive(PWM0, PWM1, PWM2, PWM3):
    # Die Skalierungsfunktion wird verwendet, um die Bias-Variablen 
    # für die Berechnung der Motordrehzahl skaliert
    def scale(num, in_min, in_max, out_min, out_max):
        return (num - in_min) * (out_max - out_min) / (in_max - in_min) + out_min

    # Skalierung des Verzögerungswertes auf den Wert in Prozent
    PWM0 = int(PWM0 * (scale(biasR, 0, 100, 100, 0) / 100))
    PWM1 = int(PWM1 * (scale(biasR, 0, 100, 100, 0) / 100))
    PWM2 = int(PWM2 * (scale(biasL, 0, 100, 100, 0) / 100))
    PWM3 = int(PWM3 * (scale(biasL, 0, 100, 100, 0) / 100))

    # Wert für PWM-Kanal (0-255) an PWM-Controller übertragen
    # 0x70 ist die I2C-Adresse des Controllers
    # das Byte mit dem PWM-Wert wird zu dem Byte für den Kanal addiert
    i2c.write(0x70, b'\x02' + bytes([PWM0]))
    i2c.write(0x70, b'\x03' + bytes([PWM1]))
    i2c.write(0x70, b'\x04' + bytes([PWM2]))
    i2c.write(0x70, b'\x05' + bytes([PWM3]))

Kurven fahren

Die Methode turn ermöglicht es, das Joy-Car präzise Kurven fahren zu lassen. Dabei werden vier Parameter verwendet:

orientation: Gibt die Fahrtrichtung an, z. B. vorwärts oder rückwärts.
direction: Gibt die Richtung der Kurve an, z. B. links oder rechts.
speed: Bestimmt die Geschwindigkeit des Fahrzeugs auf einer Skala von 0 bis 255.
radius: Gibt den Radius der Kurve an, wobei kleinere Werte engere Kurven bedeuten.

In der Methode wird zunächst überprüft, ob der angegebene Radius größer als Null ist. Anschließend wird die Geschwindigkeit des inneren Rades (innerWheelSpeed) berechnet, um die Kurve entsprechend des Radius anzupassen. Dies wird durch eine Skalierung der Geschwindigkeit realisiert, wobei das äußere Rad mit der vollen Geschwindigkeit fährt und das innere Rad entsprechend verlangsamt wird.

Abschließend wird die Methode drive mit den berechneten Geschwindigkeitswerten für die beiden Motoren aufgerufen. Dies sorgt dafür, dass das Joy-Car die gewünschte Kurve in der angegebenen Fahrtrichtung und Geschwindigkeit fährt.

# Methode zum Drehen mit Orientierung, Richtung, Geschwindigkeit und Radius
def turn(orientation, direction, speed, radius):
    # radius: 0-5
    if radius > 0:
        # Berechnung der inneren Radgeschwindigkeit
        innerWheelSpeed = (speed * 0.7) * (radius / 5)
    else:
        return

    # die Motoren entsprechend einstellen
    if orientation == "forward":
        if direction == "left":
            drive(0, speed, 0, innerWheelSpeed)
        elif direction == "right":
            drive(0, innerWheelSpeed, 0, speed)
    elif orientation == "backwards":
        if direction == "left":
            drive(speed, 0, innerWheelSpeed, 0)
        elif direction == "right":
            drive(innerWheelSpeed, 0, speed, 0)

Codebeispiel

# Notwendige Bibliotheken importieren
from microbit import *

# Definiere deine Joy Car Mainboard Revision
joycar_rev = 1.3

# Initialisierung der I2C-Schnittstelle für das Joy Car Mainboard
i2c.init(freq=400000, sda=pin20, scl=pin19)

# PWM-Controller initialisieren
i2c.write(0x70, b'\x00\x01')
i2c.write(0x70, b'\xE8\xAA')

# die Verzögerung einer Motorverzögerung kann verwendet werden, um unterschiedliche Motordrehzahlen zu kompensieren
biasR = 0  # Verzögerung des rechten Motors in Prozent
biasL = 0  # Verzögerung des linken Motors in Prozent

# Motoren mit dem PWM-Controller steuern
# PWM0 und PWM1 für den linken Motor und PWM2 und PWM3 für den rechten Motor
def drive(PWM0, PWM1, PWM2, PWM3):
    # Die Skalierungsfunktion wird verwendet, um die Bias-Variablen 
    # für die Berechnung der Motordrehzahl skaliert
    def scale(num, in_min, in_max, out_min, out_max):
        return (num - in_min) * (out_max - out_min) / (in_max - in_min) + out_min

    # Skalierung des Verzögerungswertes auf den Wert in Prozent
    PWM0 = int(PWM0 * (scale(biasR, 0, 100, 100, 0) / 100))
    PWM1 = int(PWM1 * (scale(biasR, 0, 100, 100, 0) / 100))
    PWM2 = int(PWM2 * (scale(biasL, 0, 100, 100, 0) / 100))
    PWM3 = int(PWM3 * (scale(biasL, 0, 100, 100, 0) / 100))

    # Wert für PWM-Kanal (0-255) an PWM-Controller übertragen
    # 0x70 ist die I2C-Adresse des Controllers
    # das Byte mit dem PWM-Wert wird zu dem Byte für den Kanal addiert
    i2c.write(0x70, b'\x02' + bytes([PWM0]))
    i2c.write(0x70, b'\x03' + bytes([PWM1]))
    i2c.write(0x70, b'\x04' + bytes([PWM2]))
    i2c.write(0x70, b'\x05' + bytes([PWM3]))

# Methode zum Drehen mit Orientierung, Richtung, Geschwindigkeit und Radius
def turn(orientation, direction, speed, radius):
    # radius: 0-5
    if radius > 0:
        # Berechnung der inneren Radgeschwindigkeit
        innerWheelSpeed = (speed * 0.7) * (radius / 5)
    else:
        return

    # die Motoren entsprechend einstellen
    if orientation == "forward":
        if direction == "left":
            drive(0, speed, 0, innerWheelSpeed)
        elif direction == "right":
            drive(0, innerWheelSpeed, 0, speed)
    elif orientation == "backwards":
        if direction == "left":
            drive(speed, 0, innerWheelSpeed, 0)
        elif direction == "right":
            drive(innerWheelSpeed, 0, speed, 0)

while True:
    # mit voller Kraft vorwärts fahren
    drive(0, 255, 0, 255)
    sleep(2000)

    # Mit voller Kraft rückwärts fahren
    drive(255, 0, 255, 0)
    sleep(2000)

    # Mit voller Kraft nach links fahren
    drive(0, 255, 255, 0)
    sleep(2000)

    # Mit voller Kraft nach rechts fahren
    drive(255, 0, 0, 255)
    sleep(2000)

    # stop
    drive(0, 0 , 0, 0)
    sleep(2000)

    # eine Linkskurve vorwärts mit 50% Geschwindigkeit und Radius 4 machen
    turn("forward", "left", 128, 4)
    sleep(1000)

    # mache eine Rechtskurve rückwärts mit 50% Geschwindigkeit und Radius 2
    turn("backwards", "right", 128, 2)
    sleep(1000)

Zum nächsten Kapitel

Motoren

MakeCode

Fahren

Bremsen

Kurven

PWM-Signal

Codebeispiel

MicroPython

Vorbereitung für Motoren

Motorensteuerung

Kurven fahren

Codebeispiel