kramann.info
© Guido Kramann

DAY BY DAY zu AUT -- Entwicklung autonomer mobiler Systeme

(EN google-translate)

(PL google-translate)

Übersicht

Die vorliegende Seite stellt den Einstiegspunkt für diese Lehrveranstaltung dar und verzeichnet chronologisch die behandelten Inhalte.
Aber ein großer Teil der Inhalte findet sich nicht direkt hier, sondern die Seite hier verlinkt auf andere Bereiche von kramann.info.

Die Lehrveranstaltung Entwicklung autonomer mobiler Systeme wird als Wahlpflichtfach im Masterstudiengang Maschinenbau angeboten. In der Lehrveranstaltungen werden einerseits aktuelle und historische Konzepte zu autonom fahrenden Systemen behandelt. Andererseitsd sollen konkrete Entwicklungsaufgaben Bestandteil des Unterrichts sein.

Themen sind unter anderem:

FTS (Fahrerlose Transportsysteme in der Industrie)
Konzepte für Fahrassistenzsysteme
Entscheider
Agentensysteme
NASREM (Hierarchische Software-Architektur der NASA zur Beschreibung von Missionen)
Programmierung einer autonomen "Elektrokutsche"
Verwendung von GPUs (Jetson Nano von NVIDIA)

Untergeordnete Hilfsthemen sind:

Modellbildung und Simulation dynamischer Systeme
Eingebettete Echtzeitsysteme
Sensor-Fusion
Objektorientierte Programmierung (Vererbung, Schnittstellen, Kapselung, ...)
Java (Processing)
Erzeugen dynamischer Bibliotheken
KI / Selbst lernenende Systeme

Chronologisches Verzeichnis der im Verlauf des Semesters behandelten Themen

#1 Fr 18.03.2022

Motivation / Diskussion ... Grey Walter's tortoises 1949

https://www.moralmachine.net/hl/de -- Moral Machine

83_AV -- Einführung (Walter Gray's Turtle-robots / Fahrassistenz / FTS / Elektrokutsche)

https://www.automobil-industrie.vogel.de/was-sind-fahrerassistenzsysteme-a-890482/

https://www.youtube.com/watch?v=5TWKFHsvseo -- mercedes level 3 autonomy

https://www.youtube.com/watch?v=P9gZC1yGTRc -- Der Mercedes-Benz EQS darf in Deutschland autonom fahren! So funktioniert der ELECTRIC DRIVE PILOT!

83_AV/02_Architekturen -- Architekturen

74_EmbSyst/03_Echtzeitprogrammierung -- Echtzeitprogrammierung

Beispiele

80_Robuste_Systemintegration/30_Dreirad

80_Robuste_Systemintegration/31_Gleiter

83_AV/03_Umsetzung/05_TURTLE

83_AV/05_SUMO

Einachser
Einachser ferngesteuert
Elektrokutsche

JetBot

https://jfrog.com/connect/post/installing-cuda-on-nvidia-jetson-nano/

https://maker.pro/nvidia-jetson/tutorial/introduction-to-cuda-programming-with-jetson-nano --CUDA

https://www.sparkfun.com/products/18486

https://www.youtube.com/watch?v=mrIjtBdDQ5A

https://www.youtube.com/watch?v=zOCSRzDUI-Y

https://www.youtube.com/watch?v=MY_Fe7EN6ro

https://www.youtube.com/watch?v=9Wv9A6C6U5w

ÜBUNG 1 -- angepasst an parallel laufenden Bachelorkurs zu selbstlernenden Systemen

Teil 1: Theorie zu Unüberwachtem Lernen am Beispiel der Kohonen-Netze -- SOM -- Self Organizing Maps

Gemeinsames Lesen und Verstehen des nachfolgend dargestellten Verfahrens:

https://de.wikipedia.org/wiki/Selbstorganisierende_Karte

Im Kurs entstandene Quelltexte:


Kohonen kh;
Kohonen kh2;

public void setup()
{
     kh = new Kohonen(10,10,3,0.0,255.0);
     kh.show();
     
     println("Zweites kleines Kohonen-Netz:");
     kh2 = new Kohonen(3,3,2,0.0,1.0);
     kh2.show();
     size(500,500);
}

public void draw()
{
    background(255,0,0);
    fill(0,255,0);
    ellipse(100,100,50,50);
}

Code 0-1: Hauptprogramm on Processing

import java.util.Random;

public class Kohonen
{
     double[][][] v;
     Random zufall = new Random(System.currentTimeMillis());
     public Kohonen(int rasterhoehe, int rasterbreite, int vektordimension, double vmin, double vmax)
     {
          v = new double[rasterhoehe][rasterbreite][vektordimension];
          for(int i=0;i<v.length;i++)
              for(int k=0;k<v[i].length;k++)
                   for(int w=0;w<v[i][k].length;w++)
                       v[i][k][w] = zufall.nextDouble()*(vmax-vmin) + vmin;
     }
     
     public void show()
     {
          for(int i=0;i<v.length;i++)
          {
              for(int k=0;k<v[i].length;k++)
              {
                   print("zeile="+i+" spalte="+k+" Komponenten = [");
                   for(int w=0;w<v[i][k].length;w++)
                       print(v[i][k][w]+" ");
                   println("]");    
              }         
          }             
     }
}

Code 0-2: Vom Hauptprogramm benutzte Klasse Kohonen

KohonenNeu001.zip -- Gesamter Sketch

#2 Fr 25.03.2022

Themen:

Fortsetzung Implementierung eines Kohonen-Netzes
Einführung zu Jetson Nano

Fortsetzung Implementierung eines Kohonen-Netzes

Vorübungen zu Processing / Java / OOP

Grundstruktur von Processing
Anlegen von Klassen in Tabs
Zusammenhang zwischen Klassen und Objekten

https://processing.org/

78_Processing

30_Informatik3

Übung 1

public void setup()
{
    size(500,400); //Breite, Höhe eines Fensters
    frameRate(30); //draw() wird 30mal pro Sek. aufgerufen
}
int xpos=0;
public void draw()
{
    int ROT = 255;
    int GRUEN = 127;
    int BLAU = 255;
    background(ROT,GRUEN,BLAU);
    fill(0,255,0);
    stroke(0,0,0);
    ellipse(xpos, height/2, height/5, height/5);
    xpos++;
    xpos%=width; //Modulo Funktion x%y liefert Rest von x/y, ist also [0..y-1]
}

Code 0-3: Uebung001

Bild 0-1: Screenshot zu Übung 1.

Übung 2

public void setup()
{
    size(500,400); //Breite, Höhe eines Fensters
    frameRate(30); //draw() wird 30mal pro Sek. aufgerufen
    
    Vektor v1 = new Vektor(1.0,2.0);
    Vektor v2 = new Vektor(3.0,4.0);
    
    println("v1:");
    v1.show();
    println("v1*5:");
    v1.malSkalar(5.0);
    v1.show();
    println("v2:");
    v2.show();
    println("v1 = v1 + v2");
    v1.add(v2);
    println("v1:");
    v1.show();
}
public void draw()
{
}

Code 0-4: Haupttab von Uebung2

public class Vektor
{
     double x,y;
     public Vektor(double x, double y)
     {
         this.x = x;
         this.y = y;
     }
     
     public void malSkalar(double s)
     {
          this.x = this.x * s;
          y*=s;
     }
     
     /** addiere zu diesem Vektor die Komponenten eines anderen hinzu */
     public void add(Vektor v) 
     {
          x = x + v.x;
          y = y + v.y;
     }
     
     public void show()
     {
          println("x="+x+" y="+y);
     }
}

Code 0-5: Tab Vektor in Sketch Uebung2

Bild 0-2: Screenshot zu Übung 2.

Uebung002.zip -- Projekt Uebung2 als zip-File

Uebung003.zip -- Länge eines Vektors als Objektmethode

Die objektorientierte Implementierung einer SOM auf der Basis eines Kohonen-Netzes soll fortgesetzt werden. Als Parameter sollen folgende Werte verwendet werden:

Zwischenstand:

KohonenNeu002.zip

Bild 0-3: Die Vektoren == Gewichte im Rasternetz werden als farbige Rechtecke dargestellt.

         deltmin = 0.1;
         deltmax = 0.5*Math.sqrt( (double)(zeilen*zeilen) + (double)(spalten*spalten) );
         epsmin = 0.0005;  
         epsmax = 0.05;

Code 0-6: Parameter -- vergl. Darstellung auf Wikipedia.

Nähere Spezifikation:

Das Netz soll RGB-Werte (Rot,Grün,Blau-Werte) von Farbvektoren mit drei Komponenten klassifizieren.
Dazu werden dem SOM in der Lernphase zufällige Vektoren [0..255,0..255,0..255] präsentiert.
Aufgrund dessen entstehen Gebiete ähnlicher Vektoren.
Nach dem Lernen können Testvektoren einer Stelle in dem zweidimensionalen Gebiet zugeordnet werden.

Einführung zu Jetson Nano

Ziel u.a.:

Reinforced Learning in Simulation und real umsetzen

Beispiel bestärkendes Lernen: Neural network racing cars around a track https://www.youtube.com/watch?v=wL7tSgUpy8w

Learning Cars -- https://www.youtube.com/watch?v=Aut32pR5PQA

Was ist ein neuronales Netz? -- https://www.youtube.com/watch?v=aircAruvnKk

Herangehensweise:

Modellierung eines rudimentären dynamischen Systems, das ein Fahrzeug repräsentiert
Simulationsumgebung für Fahrzeuge mit Processing auf Jetson
NN-Part schon dort auf GPUs übertragen
Kamera erkennt Fahrbahn in realer Umwelt

Sparkfun bietet ein Kit an, das ein AV auf der Basis eines Rasperry-Pi ähnliuchen Boards an, das aber eine NVIDIA Grafikkarte enthält, dessen 128 GPUs für paralleles Rechnen verwendet werden können:

https://www.sparkfun.com/products/18486

Von diesen Jetson-Bots stehen drei zur Verfügung. Zunächst wird vermittelt, wie die Board programmiert werden können, später werden sie zu Autonomen Vehikeln erweitert:

84_Jetson

#3 Fr 01.04.2022

Themen:

Fortsetzung SOM (Self Organizing Maps)
Erste Schritte mit Jetson Nano

Teil 1: Fortsetzung SOM (Self Organizing Maps)

Eine Beispiellösung findet sich hier:

79_Deep_Learning/03_Unueberwachtes_Lernen

..sie soll im Verlauf der Lehrveranstaltung analysiert, nachgebaut und variiert werden.

Teil 2: Erste Schritte mit Jetson Nano

Für den Umgang mit dem Jetson Nano Board existiert nun diese Seite:

84_Jetson

Es sollen nun praktisch die hier aufgelisteten Tests durchgeführt werden, die die Steuerung von GPIO und GPU über Processing/Java ermöglichen sollen.

ÜBUNG

Analysieren Sie, wie eine Library zur Ansteuerung einer LED für Processing erstellt wurde:

84_Jetson/05_GPIO_und_JNI

Erstellen Sie eine eigene Library, die auf einem anderen Pin eine LED steuern kann
Messen Sie mit System.currentTimeMillis() die Dauer eines Aufrufs beim Ansteuern der LED
Erweitern Sie die Library so, dass auf beliebigen GPIO geschrieben und gelesen werden kann.

#4 Fr 08.04.2022

Thema: Entwurf, Modellbildung und Simulation eines Testfahrzeugs

Hilfs-Beispiele:

78_Processing/06_Snippets/13_Animation -- Animation mit Processing

30_Informatik3/16_Nuetzliches/03_RungeKutta -- Formel des Runge-Kutta-Integrators

78_Processing/06_Snippets/15_Simulation -- Simulationsmodell mit Processing unter Verwendung des Runge-Kutta-Integrators

80_Robuste_Systemintegration/30_Dreirad -- Früheres komplettes Beispiel

MECHANIK

Bild 0-4: AV

Bild 0-5: Geometrie und Kräfte

Bild 0-6: Geometrie und Kräfte

Bild 0-7: Mögliche Regegelung

UMSETZUNG IN PROCESSING

Schritt 1: Koordinatensystem passend transformieren -- AV001_Koordinatensystem.zip

Schritt 2: Visualisierung des Fahrzeugs -- AV002_Koordinatensystem.zip

Schritt 3 (unvollständig): Simulation und Animation bei konstanten Antriebskräften.

Schritt 4, vollständig, aber ohne Radquerkraft schleudert das Fahrzeug: AV004_FirstExperiment.zip

Schritt 5, Querkraft entlang L-R implementiert: AV005_Querkraft.zip

Schritt 6, Darstellung der Trajektorie: AV006_SavePath.zip

Schritt 7, Lenkregelung, um das Fahrzeug auf einer Kreisbahn zu halten: AV007_FeedbackControl.zip

Bild 0-8: Screenshot zu AV007.

#5 Fr 22.04.2022

Inhalte heute, siehe:

84_Jetson/07_Linienverfolgung

#6 Fr 29.04.2022

Themen heute:

Agentensysteme und NASREM
Fahrsteuerung über Wegmarkierungen
Fortsetzung Linienverfolgung

Thema 1: Agentensysteme und NASREM

83_AV/02_Architekturen

83_AV/05_SUMO/10_Umsetzung --NASREM orientierter Entwurf.

Thema 2: Fahrsteuerung über Wegmarkierungen

Mit den bisher verfügbaren Mitteln kann über mehrere Stufen ein Fahrzeug umgesetzt werden, das selber erlernt, sein Verhalten anhand Fahrbefehle symbolisierender Wegmarkierungen anzupassen.

In einer ersten Annäherung sollen die Möglichkeiten, die sich hier bieten diskutiert werden.

84_Jetson/08_Wegmarkierungen

Thema 3: Fortsetzung Linienverfolgung

84_Jetson/07_Linienverfolgung -- siehe Umsetzung weiter unten.

Übung 1

Kapseln Sie die Motorbefehle in einer Klasse "Motor".
Überlegen Sie sinnvolle Zugriffsmethoden für den Anwendungsprogrammierer.

Übung 2

Die aktuelle Umsetzung ist zu langsam für die Generierung von PWM-Signalen.

Suchen und testen Sie Strategien, das Ansteuern der Motoren zu beschleunigen.
Setzen Sie im Erfolgsfall eine neue Library für Prozessing um.

#7 Fr 06.05.2022

Siehe:

84_Jetson/09_Mehr_Rot_bitte

#8 Fr 13.05.2022

Pause vom Jetson ;-)

Thema:

Automatische Verbesserung des Fahrverhaltens bei einem simulierten Fahrzeug mittels eines evolutionären Algorithmus'

Gemeinsam soll aufsetzend auf der Fahrzeugsimulation in Processing vom 08.04.2022 eine automatische evolutionäre Parameterverbesserung implementiert werden. Dies war der letzte Stand von damals:

Schritt 7, Lenkregelung, um das Fahrzeug auf einer Kreisbahn zu halten: AV007_FeedbackControl.zip

Bild 0-9: Screenshot zu AV007.

Das Ganze soll in folgenden Schritten erfolgen:

Modularisierung des aktuellen Software-Stands.
Entwurf und Implementierung einer Fehlerfunktion.
Implementierung eines einfachen modifizierten Gradientenverfahrens.
Objektorientierter Entwurf und Implementierung eines allgemein benutzbaren genetischen Algorithmus'.
Adaption und Test des genetischen Algorithmus' mit dem Fahrzeugsimulationsprogramm.

AV009_Fehlerfunktion.zip -- Zwischenstand 1, bei dem die Fehlerfunktion leicht aufrufbar ist.

AV009_Fehlerfunktion_stud.zip -- studentische Lösung zum Gradientenverfahren.

AV010_Fehlerfunktion_Gradientenverfahren.zip -- OOP-Umsetzung

AV010_Fehlerfunktion_EVOopt.zip -- Entwurf (unvollständig)

#9 Fr 20.05.2022 (TAG DER OFFENEN TÜR)

Themen:

Musterlösung: Evolutionärer Algorithmus zur Optimierung des AV
Kohonen-Netz zur Kategorisierung von Untergründen

Musterlösung: Evolutionärer Algorithmus zur Optimierung des AV

AV013_EVOopt_Musterloesung_BessereFehlerfunktion.zip

Bild 0-10: UML-Diagramm der Abhängigkeiten der Klassen unteinander.

Bild 0-11: UML-Klassendiagramme zu AV013.

Kohonen-Netz zur Kategorisierung von Untergründen

https://de.wikipedia.org/wiki/Selbstorganisierende_Karte

Neuster Stand:

Kohonenneuneuneu011.zip

ÜBUNG

Die vorliegende Kohonennetz-Implementierung soll für die neue Aufgabe angepasst werden.
Statt RGB-Werte, sollen die zu lernenden Vektoren eine andere Bedeutung bekommen.
Aus Bildern mit verschiedenen Untergründen sollen Vektoren mit drei Komponenten zu deren Charakterisierung gebildet werden.
Im Unterricht wird diskutiert, welche Eigenschaften das sein könnten und wie deren Bestimmung implementiert werden könnte.

Arbeitsschritte:

Generierungsmethode für Untergrundbilder.
Methode zur Extraktion der Eigenschaftsvektoren aus den Untergründen
Kombination mit Kohonen-Netz
Test von Lernphase und Kategorisierungsphase

Modifizierte Übung: Vervollständigen Sie den evolutionären Algorithmus mit Hilfe der Klasse Evoopt:

ReinforcedLearning001.zip

ReinforcedLearning002.zip -- Musterlösung.

#10 Fr 03.06.2022

Themen

Musterlösung/Beispiel Reinforced Learning für simuliertes AV
Lernender Jetbot
Staubsaugroboter

1. Musterlösung/Beispiel Reinforced Learning für simuliertes AV

Idee hinter dieser Implementierung: Ein Fahrzeug soll Merkmale auf einem Weg erkennen und daraufhin die richtige Richtung einschlagen.

Die richtige Richtung wird hier durch ein Referenzfahrzeug vorgegeben und zu jedem Zeitschritt kann der Abstand des Testfahrzeugs vom Referenzfahrzeug berechnet werden.

Der Sensor-Input für das neuronale Netz ist hier das 2x2-Muster (Parkett). Je Fliese gibt es einen Neuroneneingang.

Ausgang sind auch vier Neuronen, die die vier möglichen Bewegungsrichtungen repräsentieren:

Bild 0-12: Programmstruktur: Wie aus einer Kachelung eine Bewegungsrichtung resultiert.

ReinforcedAV002.zip -- Teillösung

ReinforcedAV003.zip -- Vollständige Lösung

Bild 0-13: Schwarzer Rahmen: Referenz-Fahrzeug, türkiser Rahmen: Testfahrzeug.

Aufgabe:

Speichern Sie das Programm unter einem anderen Namen ab.
Sorgen Sie dafür, dass jeder Schritt einen ganzen 2x2-Kasten weiter geht und nicht nur einen halben.
Setzen Sie die Farben der Wegkacheln so, dass der Weg theoretisch wirklich gelernt werden kann.
Lassen Sie den genetischen Algorithmus den Weg lernen.

2. Lernender Jetbot

Als Ausgangspunkt wird ein Sketch vorgegeben, der das Fahrzeug eine rote Linie verfolgen läßt und das immer für eine Weile anhält, wenn es bei einer blauen Markierung ankommt:

https://youtu.be/qYchHY61vWk -- Kreisfahrt mit Haltepunkt.

Bild 0-14: Kreisfahrt mit Haltepunkt.

JETSON.zip -- Ausgangspunkt


Files in JETSON.zip:
sketchbook/TestneuJetsonMotor_Kamera_NEU006
sketchbook/libraries/jetson
opt/jetsonmotor.so

Der Sketch "TestneuJetsonMotor_Kamera_NEU006" kommt in das home-Verzeichnis
in das sketchbook:
~/sketchbook/TestneuJetsonMotor_Kamera_NEU006

Die Library "jetson" (ganzer Ordner) kommt nach:
~/sketchbook/libraries/jetson

Die dynamische Bibliothek (File) kommt nach:
/opt/jetsonmotor.so

Code 0-7: Files in JETSON.zip

AUFGABEN

Ausgehend von Sketch TestneuJetsonMotor_Kamera_NEU006 sollen nach und nach verschiedene Aufgaben erfüllt werden.

Aufgabe 1 -- Ausgangssketch testen

Bringen Sie TestneuJetsonMotor_Kamera_NEU006 auf Ihrem Fahrzeug zum Laufen.

Aufgabe 2 -- Rundendauer abspeichern und anzeigen

Nützliche Methoden in Processing:

long T = System.currentTimeMillis(); //Systemzeit seit 1977 in Millisekunden
String[] arr = {"1.0","3.0"};        //String-Array anlegen
arr[0] = ""+3.567;                   //Double-Wert in String umwandeln und ablegen.
saveStrings("name.txt",arr);         //String-Array speichern.
String[] arr = loadStrings("name.txt"); // Textfile mit Zeilen laden.
double x = Double.parseDouble("3.56");  // String in Zahl umwandeln.

Code 0-8: Nützliche Methoden in Processing.

Speichern Sie den Sketch unter Gruppe_GRUPPENNAME_Aufgabe2. Bitte GRUPPENNAME untereinander abstimmen.

In der Wartephase soll die Dauer der letzten Runde in Millisekunden angezeigt werden-

Außerdem soll nach jeder Runde eine Textdatei abgespeichert werden, die im Namen die Rundendauer trägt und die wichtigsten Parameter als Wert enthält.

Aufgabe 3 -- Grandientenverfahren implementieren und testen

Speichern Sie den Sketch unter Gruppe_GRUPPENNAME_Aufgabe3.

Nun soll ein modifiziertes Gradientenverfahren nach und nach die Parameter verbessern.

Implementieren und Testen Sie ein solches Verfahren.

Überlegen Sie sich zunächst, wie Sie die Fehlerfunktion definieren möchten.
Machen Sie dann die Parameter einwenig schlechter, damit der Lernfortschritt gut sichtbar wird.
Versuchen Sie eine Variante hinzubekommen, bei der der Lernfortschritt am Fahrverhalten gut erkennbar ist.
Werten Sie nach einigen Runden die gespeicherten Dateien aus, um zu prüfen, ob das Verfahren gut funktioniert.

Nach jeder Runde soll nun in der gespeicherten Datei eine Liste aller Parametervarianten und dem jeweiligen Fehler stehen. Am Ende soll immer gesondert der bislang beste Parametersatz und der zugehörige Fehler stehen.

Aufgabe 4 -- NN offline trainieren und dann am realen System testen

Zeichnen Sie über einen gewissen Zeitraum die Kombination zwischen Schwerpunktlage und zugehörigen PWM-Werten auf.
Implementieren und belernen Sie dann ein neuronales Netz mit diesen Daten offline.
Testen Sie das neuronale Netz, indem Sie den bisherigen Regler durch das Netz ersetzen.

3. Staubsaugroboter

Ein Staubsaugroboter kann als Agent betrachtet werden, der die Mission hat, möglichst viel Fläche abzufahren, ohne mehrmals die gleiche Fläche zu überfahren.
Ein Gen mit 100 Integerzahlen, die die Werte 0,1,2,3 haben können legt fest, in welche Richtung ein Roboter zu jedem Zeitschritt sich weiterbewegt.
0=links, 1=rechts, 2=oben, 3=unten.
Der aufgrund des Gens abgefahrene Weg soll möglichst wenig wiederholte Positionen aufweisen und bei Start in der Mitte nie über den Rand einer 11x11 großen Rasterfläche hinauslaufen.
Schreiben Sie einen genetischen Optimierer mit Visualisierung, der einen optimalen Staubsaugroboter produziert.

#11 Fr 10.06.2022

Neuer Ausgangspunkt:

Das nachfolgende .zip-File enthält ein verbessertes Projekt für den Jetson Bot.

Blaue Striche werden nun eindeutiger erfasst.
Vier Parameter werden als globale Variablen zur späteren Optimierung definiert.
Ein Optimierer ist vorbereitet und enthält eine Anleitung zur Implementierung des Gradientenverfahrens.
Nach jeder Runde werden die Rundenparameter und die Rundenzeit gespeichert.

TestneuJetsonMotor_Kamera_NEU007.zip -- mit Speicherung der Rundenzeiten und -daten.

AUFGABEN in den Gruppen

Aufgabe 1 -- Neuen Parcours erstelle und neues Script testen.

Erstellen Sie eine eigenen Parcours mit roter Führungslinie und blauen Stopp-Linien, nicht zu groß, aber so, dass die Kurven zu schaffen sind.
Kleben Sie in die Mitte die Nummer Ihres Jetsons auch mit Isolierklebeband.
Fügen Sie TestneuJetsonMotor_Kamera_NEU007 in Ihr Sketchbook ein, testen und passen es so an, dass es auf dem eigenen Parcours gut funktioniert.
Lassen Sie den Jetson ein paar Runden fahren und kontrollieren Sie dann data.txt, ob die erfassten Daten Sinn machen.

Aufgabe 2 -- Gradientenverfahren implementieren und zeigen, dass es funktioniert

Speichern Sie TestneuJetsonMotor_Kamera_NEU007 unter Test_GRUPPE_..._Gradient
Arbeiten Sie in der Kopie des Projektes weiter.
In optimierer.step(...) gibt es am Ende einen Kommentar, der beschreibt, wie ein Gradientenverfahren ergänzt werden kann.
Folgen Sie diesen Anweisungen und implementieren Sie es.
Testen Sie das Gradientenverfahren dann über mehrere Runden und prüfen Sie den Erfolg.
Legen Sie insbesondere sinnvoll fest, in welchem Zahlenbereich die einzelnen Parameter verändert werden dürfen.

Machen Sie ein Video, in dem die Parameterverbesserung erkennbar ist.

Erzeugen Sie von dem funktionierenden Projekt ein .zip-File und laden es bei Moodle im Kurs bei SketchAufgabe2 hoch.

Aufgabe 3 -- Vorhandensein der roten Linie als Kriterium hinzufügen

Speichern Sie Test_GRUPPE_..._Gradient unter Test_GRUPPE_..._Rot ab.
Arbeiten Sie weiter in dieser Kopie.
Wieviel der roten Linie wird in einer Runde "gesehen"?
Überlegen Sie sich in der Gruppe eine Definition dafür und implementieren diese.
Menge an rot soll genau so wie die Rundenzeit in jeder Runde erfasst und ebenfalls gespeichrt werden.
Passen Sie das Gradientenverfahren so an, dass nun eine Kombination aus Rundezeit und Menge an rot benutzt wird.
Überprüfen Sie, ob die Implementierung funktioniert und verbessern sie nötigenfalls.

Quiz (mündliche Prüfung) -- können Sie selber untereinander besprechen und nachfragen, wenn die richtige Antwort nicht klar ist.

Welcher Typ an Agentensystem stellt das in Aufgabe 2 und 3 erstellte System dar?
Was sind Heuristiken?
Welche Probleme sehen Sie, wenn statt des Gradientenverfahrens ein evolutionärer Algorithmus im Fahrzeug implementiert wird?

Aufgabe 4

Schreiben Sie einen Java-Sketch mit einer Methode, die bei einem mit 1 und 0 gefüllten 32x32-Array ein Maß für die Spielgelsymmetrie bzgl. der Hochachse berechnet.

Ergänzen Sie einen Optimierer, der durch zufällige Vertauschungen zweier Matrixelemente und unter Verwendung der Symmetriefunktion nach und nach das Array möglichst symmetrisch werden läßt.

Während es Optimierungsprozesses soll die Matrix visualisiert werden.

Aufgabe 5 -- Theoretischer Entwurf eines erweiterten autonomen Vehikels

Ein Jetson-Nano-Bot soll als FTS (Fahrerloses Trasportsystem) eingesetzt werden. Dazu fährt es entlang einer geschlossenen Führungslinie.

Kleine Dinge sollen von einer von drei Stationen an jede andere mit dem Bot geschickt werden können.

Es soll drei Stationen geben, an denen der Bot alleine hält, wenn er unkonfiguriert ist, sobald er eine der Stationen erreicht.

Hat der Bot gehalten, so kann er an der aktuellen Station konfiguriert werden. Die Konfiguration legt fest, an welcher Station der Bot als nächstes halten soll. Das bedeutet: Hält der Bot an Station 1, so kann dort bestimmt werden, ob er als nächstes bei Station 1, 2 oder wieder bei 3 halten soll.

Auf diese Weise können kleine Dinge von jeder Station an jede andere mit dem Bot geschickt werden.

Entwickeln Sie ein möglichst konkretes Konzept zur Realisierung dieser Aufgabe und präsentieren es am Ende der Lehrveranstaltung.

#12 Fr 17.06.2022

Wichtig: Heute ist die LV von 8:30Uhr bis 11:45Uhr, kommende Woche ab 8:30Uhr Prüfung.

Themen

Ausführliche Besprechung und/oder Entwicklung der Lösungen zu den Aufgaben von letzter Woche.
In dem Zusammenhang werden hilfreiche Programmiertechniken und Vorgehensweisen bei der Softwareentwicklung vertieft.
Vorbesprechung der Prüfung in der kommenden Woche.

Studentische Lösung zu Aufgabe 4.

Musterlösung.

Musterlösung2.

Musterlösung3.

Snippets zur Lösung diverser Aufgaben beim Programmieren

Im Unterricht soll evaluiert werden, welche Teilaspekte besonders schwer zu programmieren waren und passende Codeschnipsel im Kurs entwickelt und hier zur Verfügung gestellt werden.

Fragen dazu:

Wie fängt man sinnvollerweise an, wenn eine Aufgabe wie Aufgabe 4 gelöst werden soll?
Wie generiert man einen Plot der gewonnenen Daten?
Wie kann ermittelt werden, über welchen Anteil der Fahrstrecke die rote Linie im Sichtfeld der Kamera ist?

Neue kleine Programmieraufgabe

Schreiben Sie ein Programm, das mit Hilfe des Kamerabildes die Bewegungsrichtung erkennt, in die diese bewegt wird.

Visualisieren Sie die Ergebnisse in geeigneter Weise.

Es dürfen behelfsmäßig Markierungen am Boden/auf dem Tisch verwendet werden.

Diskutieren Sie dazu zunächst mögliche Lösungsansätze.
Bereiten Sie dann ein Grundgerüst des Programms vor.
Suchen Sie eine Lösung, von der sie denken, dass sie sehr sicher funktionieren wird.Versuchen Sie auch noch die Bewegungsgeschwindigkeit zu ermitteln.

Versuchen Sie diese Aufgabe als Prüfungsvorbereitung zu Hause umzusetzen.

50_Simulationstechnik/01_Systemtheorie/07_scilab -- Beispiel mit plot und Scilab.