Immer und Immer wieder...
Schleifen stehen für sich wiederholende Anweisungen. Dabei werden bestimmte Anweisungen so lange immer wieder ausgeführt, bis eine bestimmte Bedingung nicht mehr erfüllt ist. Schleifen sind ein wesentliches Konzept in der Programmierung, da sie es ermöglichen, Aufgaben effizient und mit weniger Code zu erledigen.
Es gibt zwei Haupttypen von Schleifen:
Eine während-Schleife wiederholt eine Anweisung oder einen Block von Anweisungen, solange eine bestimmte Bedingung wahr ist. Diese Schleife ist nützlich, wenn die Anzahl der Wiederholungen nicht im Voraus bekannt ist und von einer Bedingung abhängt, die während der Ausführung des Programms geändert werden kann.
Eine für-Schleife wiederholt eine Anweisung oder einen Block von Anweisungen eine bestimmte Anzahl von Malen. Sie wird oft verwendet, um eine Sequenz (wie eine Liste, ein Tupel oder einen Bereich) zu durchlaufen.
Schleifen sind besonders nützlich in Situationen, in denen Aufgaben mehrfach ausgeführt werden müssen, wie z.B. das Durchlaufen von Listen, das Verarbeiten von Daten in einer Tabelle oder das Wiederholen von Berechnungen bis zur Erfüllung einer bestimmten Bedingung. Indem du Schleifen in deinen Programmen verwendest, kannst du deinen Code effizienter und verständlicher machen.
während-Schleife
Es gibt eine sogenannte während-Schleife (auch while-Schleife oder while loop genannt).
Hierbei wird zunächst auf die Bedingung geprüft. In diesem Fall ist dies die Prüfung des linken und des rechten Hindernissensors. Solange also der Sensor etwas erkennt, werden alle Anweisungen ausgeführt, die sich darunter im mache-Bereich befinden.
Zusammengefasst wird hier also immer, solange die Hindernissensoren ein Hindernis erkennen, das Licht des Joy-Cars eingeschaltet.
Doch das Licht jedes Mal einzuschalten macht wenig Sinn, wenn es nicht auch irgendwann wieder ausgeht. Setzen wir nach unserer Schleife noch die Anweisung, das Licht auszuschalten, so lässt sich direkt beobachten, wie zwischen den beiden Zuständen gewechselt wird. Solange ein Hindernis erkannt wird, wird der Anweisungsblock innerhalb der Schleife immer wieder ausgeführt und nicht verlassen. Erst wenn die Bedingung nicht mehr zutrifft, wird die Schleife wieder verlassen, der dauerhaft-Block wieder von vorne ausgeführt und das Licht ausgeschaltet.
Am Anfang wird wieder im beim Start-Block die Revisionsnummer des Joy-Cars definiert.
JoyCar.initJoyCar(RevisionMainboard.OnepThree)
basic.forever(function () {
while (JoyCar.obstacleavoidance(SensorLRSelection.Left) || JoyCar.obstacleavoidance(SensorLRSelection.Right)) {
JoyCar.light(ToggleSwitch.On)
basic.pause(1000)
}
JoyCar.light(ToggleSwitch.Off)
})Der Beispielcode in MicroPython ist da, weil es ihn auch in MakeCode gibt. Das ist super praktisch, denn wenn du schon mit MakeCode klar kommst, kannst du viel leichter mit MicroPython loslegen. Indem wir Beispielcodes in beiden Umgebungen haben, kannst du ohne große Unterbrechung weiterlernen. So verstehst du besser, wie Programmierung funktioniert und kannst sehen, wie man dieselben Sachen in verschiedenen Programmiersprachen macht.
# Notwendige Bibliotheken importieren
from microbit import *
import neopixel
# Definiere deine Joy Car Mainboard Revision
joycar_rev = 1.3
# Objekt für die LEDs definieren
np = neopixel.NeoPixel(pin0, 8)
# Initialisierung der I2C-Schnittstelle für das Joy Car Mainboard
i2c.init(freq=400000, sda=pin20, scl=pin19)
# 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()
# alle Sensordaten abrufen
def fetchSensorData():
# Da die zfill-Funktion nicht in micro:bit Micropython enthalten ist,
# muss sie als Funktion eingefügt werden
def zfill(s, width):
return '{:0>{w}}'.format(s, w=width)
# Hexadezimale Daten lesen und in binäre Daten umwandeln
data = "{0:b}".format(ord(i2c.read(0x38, 1)))
# Füllen Sie die Daten bei Bedarf auf 8 Stellen auf.
data = zfill(data, 8)
# bol_data_dict as dictionary deklarieren
bol_data_dict = {}
# Zähler für die Schleife, die die Daten aus data in bol_data_dict einträgt
bit_count = 7
# Übertragen Sie die Daten von data nach bol_data_dict
for i in data:
if i == "0":
bol_data_dict[bit_count] = False
bit_count -= 1
else:
bol_data_dict[bit_count] = True
bit_count -= 1
# Ab Mainboard-Revision 1.3 sind die Geschwindigkeitssensoren auf separaten Pins
if joycar_rev >= 1.3:
bol_data_dict[8], bol_data_dict[9] = bol_data_dict[0], bol_data_dict[1]
bol_data_dict[0] = bool(pin14.read_digital())
bol_data_dict[1] = bool(pin15.read_digital())
# Bit 0 = GeschwindigkeitLinks, Bit 1 = GeschwindigkeitRechts, Bit 2 = LineTrackerLinks,
# bit 3 = LineTrackerMitte, bit 4 = LineTrackerRechts,
# bit 5 = HindernisLinks, bit 6 = HindernisRechts, bit 7 = freier Pin(7)
# (bit 8 = frei (pin0) bit 9 = frei (pin1)) - nur mit Revision 1.3 oder neuer
return bol_data_dict
# eine Endlosschleife
while True:
# Sensordaten vom Mainboard lesen
sensor_data = fetchSensorData()
# Eintritt in die Schleife, wenn kein Hindernis mit den Hindernissensoren erkannt wird
while not sensor_data[5] or not sensor_data[6]:
# Abblendlicht anschalten
lights()
# 1 Sekunde lang warten
sleep(1000)
# Sensordaten vom Mainboard lesen
sensor_data = fetchSensorData()
lights(on = False)für-Schleife
Es gibt jedoch nicht nur während-Schleifen, sondern auch die sogenannten für-Schleifen (auch for-Schleife oder for-loop genannt). Bei den für-Schleifen werden die Anweisungen für eine bestimmte Anzahl an Durchläufen ausgeführt.
Hier werden zwei für-Schleifen mit jeweils 8 Durchläufen durchlaufen, um alle LEDs des Joy-Cars nacheinander anzusteuern. Hierzu wird direkt auf die Index-Variable der Schleife zugegriffen, um den aktuellen Durchlaufwert zu erhalten und verwenden zu können.
Im folgenden Programm wird im beim Start-Block, nachdem die Revisionsnummer des Joy-Cars definiert wurde, ein LED-Strip unter dem Namen strip mit 8 LEDs an Pin 0 initialisiert. Im Block dauerhaft werden dann in der ersten für-Schleife nach einander die LEDs 0-7 (die Adressierung der LEDs beginnt bei 0) in der Farbe Rot eingeschaltet. Nach jedem Schleifendurchlauf wird eine Pause von 100 ms (0,1 Sekunden) gemacht. Ist die Schleife mit der Zahl 7 durchgelaufen, startet die zweite Schleife. In dieser werden die LEDs der Reihe nach auf die Farbe Schwarz geschaltet. Schwarz heißt im Fall von LEDs aus. Ist auch diese Schleife mit der Zahl 7 durchgelaufen, beginnt der dauerhaft-Block wieder von vorne.
Weitere Informationen zum Thema Nutzung der LEDs findet ihr im Kapitel Scheinwerfer.
JoyCar.initJoyCar(RevisionMainboard.OnepThree)
let strip = neopixel.create(DigitalPin.P0, 8, NeoPixelMode.RGB)
basic.forever(function () {
for (let Index = 0; Index <= 7; Index++) {
strip.setPixelColor(Index, neopixel.colors(NeoPixelColors.Red))
strip.show()
basic.pause(100)
}
for (let Index = 0; Index <= 7; Index++) {
strip.setPixelColor(Index, neopixel.colors(NeoPixelColors.Black))
strip.show()
basic.pause(100)
}
})Der Beispielcode in MicroPython ist da, weil es ihn auch in MakeCode gibt. Das ist super praktisch, denn wenn du schon mit MakeCode klar kommst, kannst du viel leichter mit MicroPython loslegen. Indem wir Beispielcodes in beiden Umgebungen haben, kannst du ohne große Unterbrechung weiterlernen. So verstehst du besser, wie Programmierung funktioniert und kannst sehen, wie man dieselben Sachen in verschiedenen Programmiersprachen macht.
# Notwendige Bibliotheken importieren
from microbit import *
import neopixel
# Definiere deine Joy Car Mainboard Revision
joycar_rev = 1.3
# Objekt für die LEDs definieren
np = neopixel.NeoPixel(pin0, 8)
# eine Endlosschleife definieren
while True:
# Schleife mit Index 1 bis 7 (8 nicht eingeschlossen)
for index in range(0,8):
# LED mit Index rot setzen
np[index] = (255, 0, 0)
# Farbe auf der LED anzeigen
np.show()
# 100 ms warten
sleep(100)
# Schleife mit Index 1 bis 7 (8 nicht eingeschlossen)
for index in range(0,8):
# LED mit Index schwarz setzen
np[index] = (0, 0, 0)
# Farbe auf der LED anzeigen
np.show()
# 100 ms warten
sleep(100)