Intelligentie voor zelfrijdende auto’s

Lesverloop

1. 1

   Stap 1: Introductie

   Vandaag werken leerlingen in teams om het besluitvormingsproces van een zelfrijdende auto na te bootsen. Met de Ozobot Editor programmeren ze een fiets en een auto die over een parcours rijden. Het programma gebruikt een camera die is verbonden met de Ozobot Editor om te bepalen of de fiets de straat oversteekt. Leerlingen stellen het LLM een vraag en gebruiken het antwoord van de AI, waar of onwaar, om te bepalen of de auto moet stoppen of doorrijden. Zo verkennen ze met een vereenvoudigde simulatie hoe visuele gegevens, AI en logica de beslissingen van een voertuig kunnen sturen.

2. 2

   Stap 2: Uitleg

   Een zelfrijdende auto is een voertuig dat zonder menselijke bediening kan rijden. Met sensoren, camera’s, kunstmatige intelligentie en computersystemen neemt de auto zijn omgeving waar, neemt hij beslissingen en bestuurt hij zichzelf. Deze auto’s zijn ontworpen om hun omgeving te begrijpen, verkeersregels te volgen, obstakels te vermijden en passagiers veilig te vervoeren, zonder menselijke bestuurder.

   Laat korte video’s of demonstraties zien van bedrijven zoals Waymo, Tesla of Cruise om de belangstelling te wekken. Vraag je klas:

   • Heb je ooit in een zelfrijdende auto gezeten? Zo ja, hoe was dat?
   • Wat maakt een zelfrijdende auto veilig?
   • Hoe weet de auto wanneer hij moet stoppen voor een voetganger?
   • Welke soorten sensoren zou de auto kunnen gebruiken?

   Deze vragen leiden naar de kern van deze les: begrijpen hoe voertuigen met AI gegevens en logica gebruiken om direct beslissingen te nemen.

   Bespreek enkele van de volgende technologieën waarmee moderne zelfrijdende voertuigen hun omgeving voortdurend in kaart brengen en begrijpen:

   1. LIDAR (lichtdetectie en afstandsmeting) zendt laserpulsen uit om een 3D-kaart van de omgeving van de auto te maken.
   2. Radar meet de snelheid en afstand van voorwerpen in de buurt. Zo weet de auto hoe snel andere voertuigen of mensen bewegen.
   3. Camera’s werken als ogen. Ze helpen het voertuig belangrijke visuele details te herkennen, zoals verkeersborden, verkeerslichten, rijstrookmarkeringen en voetgangers.
   4. Beeldherkenning is het vermogen van een computer of robot om beelden of video’s van een camera te bekijken en te begrijpen.
   5. Kunstmatige intelligentie (AI) houdt in dat computers of machines zijn ontworpen om te denken, te leren en beslissingen te nemen op een manier die lijkt op die van mensen. Met AI en algoritmen kan een zelfrijdende auto voorwerpen herkennen, beweging waarnemen en op basis van wat hij ziet bepalen wat hij moet doen.
3. 3

   Beroepsoriëntatie

   Stap 3: Beroepsoriëntatie: AI-ingenieurs en autonome systemen

   Leg leerlingen uit dat ze vandaag nabootsen hoe een zelfrijdende auto op fietsers reageert. Ze gebruiken daarvoor een vereenvoudigde versie van wat ingenieurs doen bij het ontwikkelen van systemen voor zelfrijdende voertuigen. Laat de werkkaart zien. Wijs erop dat deze een weg voorstelt die auto’s en fietsers samen gebruiken en waar ze rekening met elkaar moeten houden.

   1. De ene robot is de zelfrijdende auto en de andere robot is de fietser.
   2. Beide robots bewegen tegelijkertijd over hetzelfde parcours.
   3. Een camera boven het parcours bootst het zichtsysteem van het voertuig na.

   Hoe werken de camera en het LLM samen in ons programma?

   Leg stap voor stap uit wat er gebeurt als we de camera en het LLM-blok in onze code gebruiken:

   1. De camera kijkt: een camera die is aangesloten op je programmeerapparaat maakt een foto van je werkkaart. Dit noemen we beeldherkenning: computers ‘zien’ en analyseren beelden.
   2. De afbeelding gaat naar het LLM: de foto wordt verstuurd naar een AI-hulpmiddel dat een LLM heet, een groot taalmodel. Daarvoor gebruiken we een model dat ook beeldinvoer ondersteunt. Het analyseert de afbeelding op basis van de opdracht die we geven.
   3. Je stelt de AI een vraag: in je code schrijf je een heel gerichte vraag. In deze les vragen we: ‘Is de rode lijn zichtbaar?’
   4. Het LLM kijkt en antwoordt: het LLM analyseert de afbeelding om je vraag te beantwoorden. Het antwoord kan een woord, een getal of een antwoord met waar of onwaar zijn.
   5. Het programma reageert: je code gebruikt dat antwoord om Ozobot iets te laten doen, zoals stoppen, praten, draaien of een afbeelding tonen.

   Opmerking voor de docent: dit is een vereenvoudigd voorbeeld van beeldherkenning in de praktijk. Hoeveel beelden echte systemen per seconde analyseren, verschilt per systeem. Ook daar worden visuele gegevens gebruikt om beslissingen te nemen, zoals stoppen of doorrijden.

4. 4

   Stap 4: Opstelling

   Voor deze les zijn 2 Ozobots nodig. Je kunt werken met 1 Ari en 1 Evo, 2 Ari-robots of 2 Evo-robots. De gedeelde code laat de opstelling zien met 1 Ari als auto en 1 Evo als fiets.

   Help leerlingen hun robots en de camera met de Ozobot Editor te verbinden:

   • Met Evo: zet Evo aan en klik op Apparaten > +Evo.
   • Met Ari: zet Ari aan en open de Blockly-app in de map Informatica. Klik in de Editor op Apparaten > +Ari.
   • Camera: sluit de camera aan op het apparaat waarop je programmeert. We raden een USB-documentcamera aan die je op een laptop aansluit. Klik in de Editor op +Camera en selecteer je camera in de lijst.

   Richt de camera op je werkkaart, zodat de weg en de robots duidelijk in beeld zijn. Controleer het cameravoorbeeld in de Editor. Zorg dat het camerabeeld overeenkomt met hoe leerlingen het papier op hun tafel zien. Is dat niet zo? Draai dan het papier of pas de hoek of positie van de camera aan totdat links en rechts overeenkomen.

   Leerlingen moeten ook het LLM toevoegen via Apparaten > LLM_Bot.

   Leerlingen kunnen de afbeelding van de fiets uitknippen en met plakband vastmaken op de robot die de fiets voorstelt.

5. 5

   Stap 5: Programmeren

   Met dit programma bootsen leerlingen een verkeerssituatie na waarin een zelfrijdende auto en een fiets een weg delen. Leerlingen gebruiken beeldherkenning en AI-logica om de auto in deze simulatie te laten oversteken of wachten.

   De fiets begint op de rode lijn, gericht naar de kruising in het midden. De auto begint op de blauwe lijn, ook gericht naar de kruising in het midden.

   De fiets blijft aan de linkerkant van de weg en rijdt door het park en het bos.

   De auto blijft aan de rechterkant van de weg en rijdt door de stad en de woonwijk.

   STAP 1: Maak de GPS-functie

   We maken een herbruikbare GPS-functie waarmee zowel de fiets als de auto een route aan de eigen kant van de weg kan rijden. (Deelcode: s47zfyz)

   1. Maak een nieuw functieblok en geef het de naam ‘GPS’.
   2. Voeg een blok stel variabele in toe en maak een nieuwe variabele met de naam ‘willekeurigGetal’.
   3. Gebruik een blok willekeurig geheel getal om ‘willekeurigGetal’ een waarde tussen 1 en 2 te geven.
   4. Maak vervolgens een reeks instructies waarmee de robots een rondje om één kwadrant van de kaart rijden: een herhaal 3 keer-lus met volg lijn tot volgende kruising en kies richting rechts, gevolgd door één blok volg lijn tot volgende kruising. Dupliceer deze reeks code en verander de richting in links.
   5. Maak een voorwaarde: als ‘willekeurigGetal’ even is, laat je de robot rechtsaf slaan. Anders laat je de robot linksaf slaan.
   6. Deze functie geeft een kans van 50/50 om rechtsaf of linksaf te slaan. De fiets en de auto komen zo weer terug bij hun startpunt.

   STAP 2: Programmeer de fiets

   De fiets blijft rondrijden aan de linkerkant van de weg. (Deelcode: y44mrj3)

   1. Gebruik een blok met apparaat en selecteer de robot die de fiets voorstelt.
   2. Stel de lijnvolgsnelheid in op 30 mm/s.
   3. Roep de GPS-functie aan om de route af te leggen.
   4. Plaats dit stuk code in een blok herhaal voor altijd.

   STAP 3: Programmeer de auto

   In deze simulatie gebruiken we de zichtbaarheid van de rode lijn als aanwijzing dat de oversteekplaats vrij is. We vragen het LLM of de rode lijn zichtbaar is op de camerafoto. Antwoordt het LLM met waar, dan laat het programma de auto doorrijden. Bij onwaar wacht de auto. Dit is een vereenvoudiging: het LLM kan zich vergissen en één zichtbare lijn op één foto bewijst niet dat oversteken veilig is. Deze controle is niet geschikt voor echt verkeer. (Deelcode: jjwboyf)

   1. Gebruik een blok met apparaat en selecteer de robot die de auto voorstelt. Maak daarin een variabele met de naam ‘oversteekControle’ en geef deze de waarde van een LLM-blok. Typ: ‘Is de rode lijn zichtbaar?’ Stel het uitvoertype in op booleaans, zodat het antwoord waar of onwaar is. Zorg dat ‘camera’ in het blok is aangevinkt.
   2. Voeg een blok druk af toe en koppel er een blok ‘oversteekControle’ aan om het antwoord in de console te zien.
   3. Maak een voorwaarde met een blok vergelijk en stel in dat ‘oversteekControle’ gelijk is aan waar.
   4. Als de voorwaarde waar is, neemt het programma aan dat de fiets niet bij de kruising staat. Voeg in het doe-gedeelte een blok druk bericht af toe met de tekst ‘Oversteekplaats is vrij’ en een blok verlaat lus.
   5. Als de voorwaarde onwaar is, neemt het programma aan dat de fiets bij de kruising staat. Voeg in het anders-gedeelte een blok druk bericht af toe met de tekst ‘Fietser steekt over, wacht’ en voeg een blok wacht 3 seconden toe.
   6. Plaats deze reeks code binnen met apparaat in een blok herhaal voor altijd. Dit is de binnenste controlelus: het programma vraagt telkens opnieuw of de rode lijn zichtbaar is. Bij waar verlaat verlaat lus alleen deze controlelus.
   7. Plaats na de binnenste controlelus, maar nog binnen met apparaat, de blokken om de lijnvolgsnelheid in te stellen op 80 mm/s en de GPS-functie aan te roepen. Plaats het hele blok met apparaat voor de auto in een buitenste blok herhaal voor altijd. Zo controleert de auto na elke route opnieuw de oversteekplaats.
   8. Plaats de code voor de fiets en de auto samen in een blok voer gelijktijdig uit.
6. 6

   Stap 6: Uitvoeren en problemen oplossen

   Zet de fiets en de auto op hun aangegeven startpunten op de werkkaart: de rode en blauwe lijn. Plaats de camera boven het parcours, zodat beide robots en het parcours duidelijk in beeld zijn. Voer daarna het programma uit en zie je verkeerssimulatie tot leven komen!

   Werkt je programma niet zoals bedoeld? Controleer dan het volgende:

   1. Het LLM-blok is ingesteld op booleaans met 1 camera.
   2. De logica van ‘oversteekControle’ zorgt ervoor dat het programma alleen de binnenste controlelus verlaat wanneer de waarde gelijk is aan waar.
   3. De blokken met apparaat voor de fiets en de auto staan elk in een eigen herhaal voor altijd-lus, zodat ze blijven rondrijden. Bij de auto staat binnen met apparaat eerst de binnenste controlelus en daarna de code voor het rijden van de route.
   4. Beide robots op het parcours zijn duidelijk zichtbaar in het camerabeeld.
   5. Plaats de sensoren aan de onderkant iets voorbij de rode en blauwe lijn, zodat de robot deze bij het vooruitrijden niet als kruising leest.
7. 7

   Stap 7: Uitbreiding

   We willen een realistische oversteekplaats nabootsen waar voetgangers of fietsers niet altijd evenveel tijd nodig hebben om over te steken.

   Soms duurt dat maar 3 seconden, maar een andere keer kan het 20 seconden duren. De auto moet dan langer wachten. Daarom voegen we variatie toe aan het moment waarop de fiets terugkeert bij de kruising. (Deelcode: gig87p3)

   1. Maak een variabele met de naam ‘oversteektijd’.
   2. Stel de variabele ‘oversteektijd’ in op een willekeurig geheel getal tussen 1 en 3.
   3. Voeg een voorwaardelijke instructie toe:
      • Als ‘oversteektijd’ = 1, wacht 3 seconden
      • Als ‘oversteektijd’ = 2, wacht 10 seconden
      • Als ‘oversteektijd’ = 3, wacht 20 seconden

   Gebruik je Ari? Dan kun je de meldingen op het scherm van Ari laten verschijnen. Voeg druk bericht af toe met de volgende meldingen:

   ‘Oversteekplaats is vrij’ en ‘Fietser steekt over, wacht’. (Deelcode: iwcf3ws)

8. 8

   Afsluiting

   Stap 8: Afsluiting van de les

   Sluit de les af door te bespreken wat de leerlingen hebben gebouwd:

   1. De robot die de zelfrijdende auto voorstelt, gebruikte beeldherkenning en AI om een mogelijk gevaar te herkennen.
   2. Het LLM gaf een booleaanse uitkomst op basis van wat het ‘zag’.
   3. De auto reageerde op dat antwoord. Met als/anders-logica en gelijktijdig programmeren bootste het programma bewegingen in het verkeer na.

   Laat leerlingen als afsluitende reflectie de volgende vragen bespreken:

   • Hoe bepaalt het programma of Ozobot doorrijdt, en waarom bewijst dat niet dat oversteken veilig is?
   • Welke gegevens gebruikten de camera en het LLM om een beslissing te nemen?
   • Hoe gebruiken echte zelfrijdende auto’s vergelijkbare technologie?
   • Wat zou er gebeuren als het LLM een verkeerd antwoord gaf? Hoe zou een auto veilig kunnen reageren?
   • Welke ethische afwegingen spelen een rol als we machines vertrouwen om deze beslissingen te nemen?
   • Hoe zouden zelfrijdende voertuigen onze toekomst kunnen veranderen? Welke beroepen zouden nodig kunnen zijn om ervoor te zorgen dat ze veilig en verantwoord werken?