Intelligenz für selbstfahrende Autos

Ablauf der Lektion

1. 1

   Schritt 1: Einführung

   Heute arbeiten die Schüler*innen in Teams und bilden den Entscheidungsprozess eines selbstfahrenden Autos nach. Mit dem Ozobot Editor programmieren sie ein Fahrrad und ein Auto, die sich auf einer Strecke bewegen. Das Programm nutzt eine mit dem Ozobot Editor verbundene Kamera, um zu erkennen, ob das Fahrrad die Straße überquert. Die Schüler*innen stellen dem LLM eine Frage und nutzen die Antwort der KI – wahr oder falsch –, um zu entscheiden, ob das Auto anhalten oder weiterfahren soll. So erkunden sie anhand einer vereinfachten Simulation, wie visuelle Daten, KI und Logik die Entscheidungen eines Fahrzeugs steuern können.

2. 2

   Schritt 2: Erklärung

   Ein selbstfahrendes Auto ist ein Fahrzeug, das ohne menschliche Steuerung fahren kann. Mithilfe von Sensoren, Kameras, künstlicher Intelligenz und Computersystemen nimmt es seine Umgebung wahr, trifft Entscheidungen und steuert sich selbst. Diese Autos sind darauf ausgelegt, ihre Umgebung zu verstehen, Verkehrsregeln zu befolgen, Hindernissen auszuweichen und Fahrgäste sicher zu befördern – ohne eine Person am Steuer.

   Zeige kurze Videos oder Vorführungen von Unternehmen wie Waymo, Tesla oder Cruise, um das Interesse zu wecken. Frage deine Klasse:

   • Bist du schon einmal in einem selbstfahrenden Auto mitgefahren? Wenn ja, wie war das?
   • Was macht ein selbstfahrendes Auto sicher?
   • Woher weiß das Auto, wann es für eine Person zu Fuß anhalten muss?
   • Welche Arten von Sensoren könnte das Auto verwenden?

   Diese Fragen führen zum Kern dieser Lektion: verstehen, wie Fahrzeuge mit KI Daten und Logik nutzen, um unmittelbar Entscheidungen zu treffen.

   Besprich einige der folgenden Technologien, mit denen moderne selbstfahrende Fahrzeuge ihre Umgebung fortlaufend erfassen und verstehen:

   1. LIDAR (Lichterkennung und Abstandsmessung) sendet Laserpulse aus, um eine 3D-Karte der Umgebung des Autos zu erstellen.
   2. Radar misst die Geschwindigkeit und Entfernung von Objekten in der Nähe. So erkennt das Auto, wie schnell sich andere Fahrzeuge oder Menschen bewegen.
   3. Kameras funktionieren wie Augen. Sie helfen dem Fahrzeug, wichtige sichtbare Merkmale wie Verkehrsschilder, Ampeln, Fahrbahnmarkierungen und Menschen zu Fuß zu erkennen.
   4. Bilderkennung ist die Fähigkeit eines Computers oder Roboters, Bilder oder Videos einer Kamera zu betrachten und zu verstehen.
   5. Künstliche Intelligenz (KI) bedeutet, dass Computer oder Maschinen so entwickelt werden, dass sie auf ähnliche Weise wie Menschen denken, lernen und Entscheidungen treffen. Mit KI und Algorithmen kann ein selbstfahrendes Auto Objekte erkennen, Bewegungen wahrnehmen und anhand dessen, was es sieht, entscheiden, was es tun soll.
3. 3

   Berufsorientierung

   Schritt 3: Berufsorientierung: KI-Entwicklung und autonome Systeme

   Erkläre den Schüler*innen, dass sie heute nachstellen, wie ein selbstfahrendes Auto auf Radfahrende reagiert. Dazu nutzen sie eine vereinfachte Version dessen, was Ingenieur*innen bei der Entwicklung selbstfahrender Fahrzeuge tun. Zeige das Arbeitsblatt. Weise darauf hin, dass es eine Straße darstellt, die Autos und Fahrräder gemeinsam nutzen und auf der sie aufeinander Rücksicht nehmen müssen.

   1. Ein Roboter ist das selbstfahrende Auto, der andere stellt eine Person auf dem Fahrrad dar.
   2. Beide Roboter bewegen sich gleichzeitig über dieselbe Strecke.
   3. Eine Kamera über der Strecke simuliert das Sichtsystem des Fahrzeugs.

   Wie arbeiten Kamera und LLM in unserem Programm zusammen?

   Erkläre Schritt für Schritt, was passiert, wenn wir die Kamera und den LLM-Block in unserem Code verwenden:

   1. Die Kamera sieht: Eine Kamera, die an dein Programmiergerät angeschlossen ist, macht ein Foto von deinem Arbeitsblatt. Das nennen wir Computer Vision: Computer „sehen“ und analysieren Bilder.
   2. Das Bild wird an das LLM gesendet: Das Foto wird an ein KI-Tool namens LLM gesendet, ein großes Sprachmodell. Dafür verwenden wir ein Modell, das auch Bildeingaben unterstützt. Es analysiert das Bild anhand der Aufgabe, die wir ihm stellen.
   3. Du stellst der KI eine Frage: In deinem Code formulierst du eine ganz konkrete Frage. In dieser Lektion fragen wir: „Ist die rote Linie sichtbar?“
   4. Das LLM schaut und antwortet: Das LLM analysiert das Bild, um deine Frage zu beantworten. Die Antwort kann ein Wort, eine Zahl oder „wahr“ bzw. „falsch“ sein.
   5. Das Programm reagiert: Dein Code nutzt die Antwort, um Ozobot etwas tun zu lassen, zum Beispiel anhalten, sprechen, sich drehen oder ein Bild anzeigen.

   Hinweis für die Lehrkraft: Dies ist ein vereinfachtes Beispiel für Bilderkennung in der Praxis. Wie viele Bilder echte Systeme pro Sekunde analysieren, hängt vom jeweiligen System ab. Auch dort werden visuelle Daten genutzt, um Entscheidungen zu treffen, etwa anzuhalten oder weiterzufahren.

4. 4

   Schritt 4: Aufbau

   Für diese Lektion brauchst du 2 Ozobots. Du kannst 1 Ari und 1 Evo, 2 Ari-Roboter oder 2 Evo-Roboter verwenden. Der bereitgestellte Code zeigt den Aufbau mit 1 Ari als Auto und 1 Evo als Fahrrad.

   Hilf den Schüler*innen, ihre Roboter und die Kamera mit dem Ozobot Editor zu verbinden:

   • Mit Evo: Schalte Evo ein und klicke auf Geräte > +Evo.
   • Mit Ari: Schalte Ari ein und öffne die Blockly-App im Ordner Informatik. Klicke im Editor auf Geräte > +Ari.
   • Kamera: Schließe die Kamera an das Gerät an, mit dem du programmierst. Wir empfehlen eine USB-Dokumentenkamera, die du an einen Laptop anschließt. Klicke im Editor auf +Kamera und wähle deine Kamera aus der Liste aus.

   Richte die Kamera auf dein Arbeitsblatt, sodass die Straße und die Roboter gut zu sehen sind. Prüfe die Kameravorschau im Editor. Achte darauf, dass das Kamerabild der Ansicht entspricht, die die Schüler*innen vom Papier auf ihrem Tisch haben. Ist das nicht der Fall? Drehe das Papier oder ändere Winkel oder Position der Kamera, bis links und rechts übereinstimmen.

   Die Schüler*innen müssen außerdem das LLM über Geräte > LLM_Bot hinzufügen.

   Die Schüler*innen können das Bild des Fahrrads ausschneiden und mit Klebeband an dem Roboter befestigen, der das Fahrrad darstellt.

5. 5

   Schritt 5: Programmieren

   Mit diesem Programm simulieren Schüler*innen eine Verkehrssituation, in der sich ein selbstfahrendes Auto und ein Fahrrad eine Straße teilen. Die Schüler*innen nutzen Bilderkennung und KI-Logik, um das Auto in dieser Simulation die Kreuzung überqueren oder warten zu lassen.

   Das Fahrrad startet auf der roten Linie und ist auf die Kreuzung in der Mitte ausgerichtet. Das Auto startet auf der blauen Linie und ist ebenfalls auf die Kreuzung in der Mitte ausgerichtet.

   Das Fahrrad bleibt auf der linken Straßenseite und fährt durch den Park und den Wald.

   Das Auto bleibt auf der rechten Straßenseite und fährt durch die Stadt und das Wohngebiet.

   SCHRITT 1: Erstelle die GPS-Funktion

   Wir erstellen eine wiederverwendbare GPS-Funktion, mit der sowohl das Fahrrad als auch das Auto eine Route auf der eigenen Straßenseite fahren kann. (Teilcode: s47zfyz)

   1. Erstelle einen neuen Funktionsblock und nenne ihn „GPS“.
   2. Füge einen Block Variable setzen hinzu und erstelle eine neue Variable namens „willekeurigGetal“.
   3. Verwende einen Block zufällige ganze Zahl, um „willekeurigGetal“ einen Wert zwischen 1 und 2 zuzuweisen.
   4. Erstelle dann eine Abfolge von Anweisungen, mit der die Roboter eine Runde um einen Quadranten der Karte fahren: eine 3-mal-wiederholen-Schleife mit Linie bis zur nächsten Kreuzung folgen und Richtung rechts wählen, gefolgt von einem Block Linie bis zur nächsten Kreuzung folgen. Dupliziere diese Codefolge und ändere die Richtung zu links.
   5. Erstelle eine Bedingung: Wenn „willekeurigGetal“ gerade ist, lässt du den Roboter rechts abbiegen. Andernfalls lässt du ihn links abbiegen.
   6. Mit dieser Funktion beträgt die Wahrscheinlichkeit, rechts oder links abzubiegen, jeweils 50 %. So kehren das Fahrrad und das Auto zu ihrem Startpunkt zurück.

   SCHRITT 2: Programmiere das Fahrrad

   Das Fahrrad fährt immer wieder auf der linken Straßenseite im Kreis. (Teilcode: y44mrj3)

   1. Verwende einen Block mit Gerät und wähle den Roboter aus, der das Fahrrad darstellt.
   2. Stelle die Linienfolgegeschwindigkeit auf 30 mm/s ein.
   3. Rufe die GPS-Funktion auf, um die Route abzufahren.
   4. Setze diesen Codeabschnitt in einen Block für immer wiederholen.

   SCHRITT 3: Programmiere das Auto

   In dieser Simulation nutzen wir die Sichtbarkeit der roten Linie als Hinweis darauf, dass die Überquerungsstelle frei ist. Wir fragen das LLM, ob die rote Linie auf dem Kamerafoto zu sehen ist. Antwortet das LLM mit „wahr“, lässt das Programm das Auto weiterfahren. Bei „falsch“ wartet das Auto. Das ist eine Vereinfachung: Das LLM kann sich irren, und eine einzelne sichtbare Linie auf einem Foto beweist nicht, dass das Überqueren sicher ist. Diese Prüfung ist für den echten Straßenverkehr nicht geeignet. (Teilcode: jjwboyf)

   1. Verwende einen Block mit Gerät und wähle den Roboter aus, der das Auto darstellt. Erstelle darin eine Variable namens „oversteekControle“ und weise ihr den Wert eines LLM-Blocks zu. Gib ein: „Ist die rote Linie sichtbar?“ Stelle den Ausgabetyp auf boolesch, damit die Antwort wahr oder falsch ist. Achte darauf, dass „Kamera“ im Block aktiviert ist.
   2. Füge einen Block ausgeben hinzu und verbinde ihn mit einem „oversteekControle“-Block, um die Antwort in der Konsole zu sehen.
   3. Erstelle eine Bedingung mit einem Block vergleichen und stelle ein, dass „oversteekControle“ gleich wahr ist.
   4. Wenn die Bedingung wahr ist, geht das Programm davon aus, dass das Fahrrad nicht an der Kreuzung steht. Füge im Dann-Teil einen Block Nachricht ausgeben mit dem Text „Überweg ist frei“ und einen Block Schleife verlassen hinzu.
   5. Wenn die Bedingung falsch ist, geht das Programm davon aus, dass das Fahrrad an der Kreuzung steht. Füge im Sonst-Teil einen Block Nachricht ausgeben mit dem Text „Fahrrad fährt über den Überweg, warten“ und einen Block 3 Sekunden warten hinzu.
   6. Platziere diese Codefolge innerhalb von mit Gerät in einem Block für immer wiederholen. Das ist die innere Prüfschleife: Das Programm fragt immer wieder, ob die rote Linie sichtbar ist. Wenn die Antwort wahr ist, verlässt Schleife verlassen nur diese Prüfschleife.
   7. Platziere nach der inneren Prüfschleife, aber noch innerhalb von mit Gerät, die Blöcke, um die Linienfolgegeschwindigkeit einzustellen auf 80 mm/s und die GPS-Funktion aufzurufen. Platziere den gesamten Block mit Gerät für das Auto in einem äußeren Block für immer wiederholen. So überprüft das Auto nach jeder Runde erneut den Überweg.
   8. Platziere den Code für das Fahrrad und das Auto gemeinsam in einem Block gleichzeitig ausführen.
6. 6

   Schritt 6: Ausführen und Probleme beheben

   Setze das Fahrrad und das Auto auf ihre markierten Startpunkte auf dem Arbeitsblatt: die rote und die blaue Linie. Positioniere die Kamera über der Strecke, sodass beide Roboter und die Strecke gut im Bild zu sehen sind. Starte dann das Programm und sieh zu, wie deine Verkehrssimulation zum Leben erwacht!

   Funktioniert dein Programm nicht wie geplant? Überprüfe Folgendes:

   1. Der LLM-Block ist auf boolesch mit 1 Kamera eingestellt.
   2. Die Logik von „oversteekControle“ sorgt dafür, dass das Programm die innere Prüfschleife nur verlässt, wenn der Wert wahr ist.
   3. Die Blöcke mit Gerät für das Fahrrad und das Auto stehen jeweils in einer eigenen Für-immer-wiederholen-Schleife, damit sie weiterfahren. Beim Auto steht innerhalb von mit Gerät zuerst die innere Prüfschleife und danach der Code zum Abfahren der Strecke.
   4. Beide Roboter auf der Strecke sind im Kamerabild gut sichtbar.
   5. Platziere die Sensoren an der Unterseite etwas hinter der roten und der blauen Linie, damit der Roboter diese beim Losfahren nicht als Kreuzung erkennt.
7. 7

   Schritt 7: Erweiterung

   Wir wollen einen realistischen Überweg nachbilden, bei dem Personen zu Fuß oder auf dem Fahrrad nicht immer gleich viel Zeit zum Überqueren brauchen.

   Manchmal dauert das nur 3 Sekunden, ein anderes Mal aber 20 Sekunden. Das Auto muss dann länger warten. Deshalb variieren wir den Zeitpunkt, zu dem das Fahrrad zur Kreuzung zurückkehrt. (Teilcode: gig87p3)

   1. Erstelle eine Variable mit dem Namen „oversteektijd“.
   2. Setze die Variable „oversteektijd“ auf eine zufällige ganze Zahl zwischen 1 und 3.
   3. Füge eine bedingte Anweisung hinzu:
      • Wenn „oversteektijd“ = 1, warte 3 Sekunden
      • Wenn „oversteektijd“ = 2, warte 10 Sekunden
      • Wenn „oversteektijd“ = 3, warte 20 Sekunden

   Verwendest du Ari? Dann kannst du die Meldungen auf dem Bildschirm von Ari anzeigen lassen. Füge Nachricht ausgeben mit den folgenden Meldungen hinzu:

   „Der Übergang ist frei“ und „Radfahrer*in überquert die Straße, warte“. (Teilcode: iwcf3ws)

8. 8

   Abschluss

   Schritt 8: Abschluss der Lektion

   Schließe die Lektion ab, indem ihr besprecht, was die Schüler*innen gebaut haben:

   1. Der Roboter, der das selbstfahrende Auto darstellt, nutzte Bilderkennung und KI, um eine mögliche Gefahr zu erkennen.
   2. Das LLM lieferte auf Grundlage dessen, was es „sah“, einen booleschen Wert.
   3. Das Auto reagierte auf diese Antwort. Mit Wenn-sonst-Logik und gleichzeitiger Programmierung bildete das Programm Bewegungen im Straßenverkehr nach.

   Lass die Schüler*innen zum Abschluss über folgende Fragen nachdenken und sprechen:

   • Wie entscheidet das Programm, ob Ozobot weiterfährt, und warum beweist das nicht, dass das Überqueren der Straße sicher ist?
   • Welche Informationen nutzten die Kamera und das LLM, um eine Entscheidung zu treffen?
   • Wie nutzen echte selbstfahrende Autos ähnliche Technologien?
   • Was würde passieren, wenn das LLM eine falsche Antwort gäbe? Wie könnte ein Auto sicher darauf reagieren?
   • Welche ethischen Fragen spielen eine Rolle, wenn wir Maschinen solche Entscheidungen anvertrauen?
   • Wie könnten selbstfahrende Fahrzeuge unsere Zukunft verändern? Welche Berufe könnten nötig sein, um sicherzustellen, dass sie sicher und verantwortungsvoll funktionieren?