Scheinwerfer

Das Joy-Car hat vier LED-Boards mit insgesamt 8 einzeln ansteuerbaren LEDs. Jede LED kann unabhängig gesteuert werden, was es ermöglicht, verschiedene Muster und Lichteffekte zu programmieren. Die LEDs können als Signale und Feedback genutzt werden, z.B. um Bewegungen oder Hindernisse anzuzeigen, wie bei einem richtigen Auto.

Die Steuerung der LEDs erfolgt über PWM (Pulsweitenmodulation). Wenn du mehr über die PWM-Technologie erfahren möchtest, findest du eine ausführliche Erklärung hier. Außerdem kannst du hier detaillierte Informationen über die technische Funktionsweise der LEDs abrufen. Diese Ressourcen helfen dir, die Steuerung und Funktionsweise der LEDs besser zu verstehen und optimale Ergebnisse in deinen Projekten zu erzielen.

Im folgenden Codebeispiel wirst du die verschiedenen Methoden kennenlernen, mit denen du die Scheinwerfer deines Joy-Cars ähnlich wie bei einem echten Auto steuern kannst. Du erfährst, wie du die Blinker korrekt einsetzen kannst, um Abbiegevorgänge oder Spurwechsel anzuzeigen. Außerdem lernst du, wie du das Warnblinklicht aktivierst, um in Notsituationen auf dein Fahrzeug aufmerksam zu machen. Darüber hinaus zeigt dir das Beispiel, wie du das Fernlicht einschaltest, um bei schlechten Lichtverhältnissen die Sicht zu verbessern. Alle diese Funktionen kannst du einfach und intuitiv umsetzen.

Scheinwerfer

Hiermit kontrollierst du die Scheinwerfer. Vorne wird hierbei ein weißes Licht aktiviert und hinten leuchtet ein rotes Licht.

Blinker

Kontrolliere den Blinker für eine Seite (Links/Rechts) des Joy-Cars. Dabei fangen jeweils die vorderen und hinteren Scheinwerfer auf der ausgewählten Seite an gelb zu blinken.

Warnblinker

Hiermit kontrollierst du das Warnlicht. Dabei fangen alle Scheinwerfer an gelb zu blinken.

Bremslicht

Hiermit kontrollierst du ein helleres, rotes Licht auf den hinteren Scheinwerfern deines Joy-Cars.

Rückfahrlicht

Kontrolliere hiermit das Rückfahrlicht. Dies lässt ein weißes Licht auf den hinteren Scheinwerfern aufleuchten.

Codebeispiel

In MakeCode findest du unter dem Menüpunkt Joy-Car > Beleuchtung alle Funktionen, die zur Steuerung der Scheinwerfer des Joy-Cars verfügbar sind. Im bereitgestellten Beispielcode werden diese Funktionen verwendet, um die verschiedenen Beleuchtungsoptionen des Joy-Cars zu demonstrieren. Du kannst sehen, wie die Blinker aktiviert, das Warnlicht eingeschaltet oder das Fernlicht genutzt wird, um die Steuerung der Scheinwerfer in der Praxis zu verstehen. Diese Beispiele zeigen dir, wie einfach es ist, die Beleuchtung deines Joy-Cars in deinem eigenen Code einzusetzen.

let current_time = 0
JoyCar.initJoyCar(RevisionMainboard.OnepThree)
basic.forever(function () {
    JoyCar.light(ToggleSwitch.On)
    basic.pause(5000)
    JoyCar.brakelight(ToggleSwitch.On)
    basic.pause(5000)
    JoyCar.brakelight(ToggleSwitch.Off)
    basic.pause(100)
    JoyCar.reversinglight(ToggleSwitch.On)
    basic.pause(5000)
    JoyCar.reversinglight(ToggleSwitch.Off)
    basic.pause(100)
    current_time = control.millis()
    while (current_time + 5000 > control.millis()) {
        JoyCar.indicator(ToggleSwitch.On, SensorLRSelection.Left)
    }
    JoyCar.indicator(ToggleSwitch.Off, SensorLRSelection.Left)
    basic.pause(100)
    current_time = control.millis()
    while (current_time + 5000 > control.millis()) {
        JoyCar.indicator(ToggleSwitch.On, SensorLRSelection.Right)
    }
    basic.pause(100)
    JoyCar.indicator(ToggleSwitch.Off, SensorLRSelection.Right)
    current_time = control.millis()
    while (current_time + 5000 > control.millis()) {
        JoyCar.hazardlights(ToggleSwitch.On)
    }
    basic.pause(100)
    JoyCar.hazardlights(ToggleSwitch.Off)
})

Definition der Scheinwerfer

Die Scheinwerfer des Joy-Cars sind hintereinander angeordnet und folgen somit einer festen Reihenfolge, die von 0 bis 7 durchnummeriert ist, da jede Platine zwei LEDs besitzt. Im nächsten Schritt wird im Code festgelegt, welche dieser LEDs als Blinker (äußere LEDs) verwendet werden sollen und welche für das Abblendlicht (innere LEDs) zuständig sind.

Im Anschluss definieren wir die Farben, die auf den Scheinwerfern angezeigt werden sollen, indem wir verschiedene RGB-Farben (Rot, Grün, Blau) festlegen. So können wir für die verschiedenen Funktionen wie Blinker und Abblendlicht spezifische Farbwerte zuweisen, um die Beleuchtung des Joy-Cars entsprechend anzupassen.

# Werte für die Lichter definieren
# welche LEDs aktiviert werden sollen
headlights = (0, 3)
backlights = (5, 6)
indicator_left = (1, 4)
indicator_right = (2, 7)
indicator_warning = (1, 2, 4, 7)

# welche Farbe auf den LEDs angezeigt werden soll
led_white = (60, 60, 60)
led_red = (60, 0, 0)
led_off = (0, 0, 0)
led_red_br = (255, 0, 0)
led_orange = (100, 35, 0)

Abblendlicht

Die folgende Methode ermöglicht es uns, das Abblendlicht des Joy-Cars ein- und auszuschalten. Die Variable on entscheidet beim Aufruf der Methode, ob das Abblendlicht aktiviert oder deaktiviert wird. Standardmäßig ist on auf True gesetzt, sodass das Abblendlicht eingeschaltet wird, wenn keine andere Angabe erfolgt.

Innerhalb der Methode werden die zuvor definierten LEDs für das Abblendlicht je nach Zustand entweder auf die Farbe Weiß oder Rot gesetzt, um das Abblendlicht zu simulieren, oder auf Schwarz, um die LEDs auszuschalten. Damit wird das Ein- und Ausschalten des Abblendlichts im Code klar strukturiert und ermöglicht eine flexible Steuerung der Lichtfunktion des Joy-Cars.

# Methode zum Aktivieren/Deaktivieren von Lichtern
def lights(on = True):
    if on:
        for x, y in zip(headlights, backlights):
            # Weiß für die Scheinwerfer definieren
            np[x] = led_white
            # Dunkelrot für die Rücklichter definieren
            np[y] = led_red
    else:
        for x, y in zip(headlights, backlights):
            # Schwarz für die Scheinwerfer und Rücklichter definieren
            np[x] = led_off
            np[y] = led_off
    np.show()

Bremslicht

Die folgende Methode funktioniert ähnlich wie die Methode für das Abblendlicht, ist jedoch speziell für die äußeren Rückleuchten des Joy-Cars vorgesehen, um ein Bremslicht zu simulieren. Wenn die Bremslichter aktiviert sind, werden die äußeren Rückleuchten auf ein helles Rot gesetzt. Die Variable on wird dabei wieder verwendet, um zu definieren, ob die Bremslichter an- oder ausgeschaltet werden sollen.

Diese Methode bietet eine einfache Möglichkeit, das Bremslicht flexibel zu steuern und an die Fahrbedingungen des Joy-Cars anzupassen.

# Methode zum Aktivieren/Deaktivieren des Bremslichts
def lightsBreak(on = True):
    if on:
        for x in backlights:
            # helles Rot für die Rücklichter definieren
            np[x] = led_red_br
    else:
        for x in backlights:
            # Schwarz für die Rücklichter definieren
            np[x] = led_off
    np.show()

Rückfahrlicht

Die folgende Methode funktioniert nach dem gleichen Prinzip wie die zuvor beschriebenen Methoden für das Abblend- und Bremslicht, ist jedoch für das Rückfahrlicht des Joy-Cars konzipiert. Hierbei wird die hintere linke äußere LED auf ein helles Weiß gesetzt, um das Rückfahrlicht zu simulieren. Die Steuerung erfolgt erneut über die Variable on, die bestimmt, ob das Rückfahrlicht aktiviert oder deaktiviert wird.

Diese Methode ermöglicht eine präzise Steuerung des Rückfahrlichts und erhöht die Sicherheit bei Rückwärtsfahrten.

# Aktivieren/Deaktivieren des Lichts für das Rückwärtsfahren
def lightsBack(on = True):
    if on:
        # Linke Rückleuchte auf weiß setzen
        np[backlights[0]] = led_white
        np.show()
    else:
        # Linke Rückleuchte auf schwarz setzen
        np[backlights[0]] = led_off
        np.show()

Blinker & Warnblinklicht

Die folgende Methode funktioniert ähnlich wie die vorherigen, ist jedoch etwas komplexer, da sie das Blinken der Blinker und Warnblinker simuliert. Um das Blinken zu steuern, ohne den gesamten Programmablauf zu unterbrechen, wird eine Zeitmessung durchgeführt. Dadurch kann der Blinkeffekt erzeugt werden, ohne dass das Programm anhalten muss.

Hierfür wird die Variable last_ind_act verwendet. Sie speichert den Zeitpunkt der letzten Zustandsänderung des Blinkers. Jedes Mal, wenn der Blinker seinen Zustand (ein/aus) ändern soll, überprüft die Methode, ob seit der letzten Änderung mindestens 400 Millisekunden vergangen sind. Wenn dies der Fall ist, wird der Zustand des Blinkers umgeschaltet, und last_ind_act wird auf die aktuelle Laufzeit gesetzt. Wie bei den anderen Methoden steuert auch hier die Variable on, ob die Blinker aktiviert oder deaktiviert sind.

# Methode zum Aktivieren/Deaktivieren der Blinker.
# Variable für die Methode, um zu vergleichen, wann die Lichter zuletzt aktiv waren.
last_ind_act = running_time()
def lightsIndicator(direction, on = True):
    # um die globale Variable ändern zu können
    global last_ind_act
    # Garbage Collector aktivieren
    gc.collect()

    # wenn Sie die Blinker ausschalten wollen
    if on is False:
        # LEDs deaktivieren
        for x in direction:
            np[x] = led_off
        np.show()
        # Schließen der Methode
        return

    # Aktivierung/Deaktivierung der Blinker nach 400 ms
    if running_time() - last_ind_act >= 400:
        # LEDs aktivieren, wenn die LEDs aus sind
        if np[direction[0]] == led_off:
            for x in direction:
                np[x] = led_orange
        # Deaktivieren Sie die LEDs, wenn sie eingeschaltet sind
        else:
            for x in direction:
                np[x] = led_off
        np.show()
        # Globale Variable auf aktuelle Laufzeit setzen
        last_ind_act = running_time()

Codebeispiel

In MicroPython sind die verschiedenen Funktionen der Scheinwerfer in separate Methoden ausgelagert, sodass du sie bei Bedarf problemlos in deinen Code integrieren kannst. Wenn du beispielsweise die Blinker, das Warnlicht oder das Fernlicht steuern möchtest, kannst du einfach die entsprechende Methode aufrufen. Jede Funktion wird unabhängig gesteuert, und durch den Einsatz eines booleschen Werts on kannst du die jeweilige Funktion ein- und ausschalten, ohne dass andere Scheinwerferfunktionen davon beeinflusst werden. Dies ermöglicht eine flexible und modulare Steuerung der Scheinwerfer, ohne dass Konflikte zwischen den verschiedenen Lichtmodi auftreten.

# Notwendige Bibliotheken importieren
from microbit import *
import neopixel
import gc

# 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)

# Objekt für die LEDs definieren
np = neopixel.NeoPixel(pin0, 8)

# Werte für die Lichter definieren
# welche LEDs aktiviert werden sollen
headlights = (0, 3)
backlights = (5, 6)
indicator_left = (1, 4)
indicator_right = (2, 7)
indicator_warning = (1, 2, 4, 7)

# welche Farbe auf den LEDs angezeigt werden soll
led_white = (60, 60, 60)
led_red = (60, 0, 0)
led_off = (0, 0, 0)
led_red_br = (255, 0, 0)
led_orange = (100, 35, 0)

# Methode zum Aktivieren/Deaktivieren von Lichtern
def lights(on = True):
    if on:
        for x, y in zip(headlights, backlights):
            # Weiß für die Scheinwerfer definieren
            np[x] = led_white
            # Dunkelrot für die Rücklichter definieren
            np[y] = led_red
    else:
        for x, y in zip(headlights, backlights):
            # Schwarz für die Scheinwerfer und Rücklichter definieren
            np[x] = led_off
            np[y] = led_off
    np.show()

# Methode zum Aktivieren/Deaktivieren des Bremslichts
def lightsBreak(on = True):
    if on:
        for x in backlights:
            # helles Rot für die Rücklichter definieren
            np[x] = led_red_br
    else:
        for x in backlights:
            # Schwarz für die Rücklichter definieren
            np[x] = led_off
    np.show()

# Aktivieren/Deaktivieren des Lichts für das Rückwärtsfahren
def lightsBack(on = True):
    if on:
        # Linke Rückleuchte auf weiß setzen
        np[backlights[0]] = led_white
        np.show()
    else:
        # Linke Rückleuchte auf schwarz setzen
        np[backlights[0]] = led_off
        np.show()

# Methode zum Aktivieren/Deaktivieren der Blinker.
# Variable für die Methode, um zu vergleichen, wann die Lichter zuletzt aktiv waren.
last_ind_act = running_time()
def lightsIndicator(direction, on = True):
    # um die globale Variable ändern zu können
    global last_ind_act
    # Garbage Collector aktivieren
    gc.collect()

    # wenn Sie die Blinker ausschalten wollen
    if on is False:
        # LEDs deaktivieren
        for x in direction:
            np[x] = led_off
        np.show()
        # Schließen der Methode
        return

    # Aktivierung/Deaktivierung der Blinker nach 400 ms
    if running_time() - last_ind_act >= 400:
        # LEDs aktivieren, wenn die LEDs aus sind
        if np[direction[0]] == led_off:
            for x in direction:
                np[x] = led_orange
        # Deaktivieren Sie die LEDs, wenn sie eingeschaltet sind
        else:
            for x in direction:
                np[x] = led_off
        np.show()
        # Globale Variable auf aktuelle Laufzeit setzen
        last_ind_act = running_time()

while True:
    # Abblendlicht anschalten
    lights()
    sleep(5000)

    # Bremslicht anschalten
    lightsBreak()
    sleep(5000)

    # Bremslicht ausschalten und Abblendlicht wieder anschalten
    lightsBreak(on = False)
    lights()
    sleep(5000)

    # Rückfahrlicht anschalten
    lightsBack()
    sleep(5000)

    # Rückfahrlicht ausschalten und Abblendlicht wieder anschalten
    lightsBack(on = False)
    lights()

    # Schalten Sie den Blinker nach rechts für 5 Sekunden an
    current_time = running_time()
    while(current_time + 5000 > running_time()):
        lightsIndicator(indicator_right)

    # Blinker nach rechts ausschalten
    lightsIndicator(indicator_right, on = False)

    # Schalten Sie den Blinker nach links für 5 Sekunden an
    current_time = running_time()
    while(current_time + 5000 > running_time()):
        lightsIndicator(indicator_left)

    # Blinker nach links ausschalten
    lightsIndicator(indicator_left, on = False)

    # 5 Sekunden lang die Warnblinkanlage einschalten
    current_time = running_time()
    while(current_time + 5000 > running_time()):
        lightsIndicator(indicator_warning)

    # alle Lichter ausschalten
    lightsIndicator(indicator_warning, on = False)
    lights(on = False)
    sleep(5000)

Zum nächsten Kapitel