Praktikum Lego Mindstorms - Exam

Aufgabe 1)

Gegeben sei ein zweigelenkiger Roboterarm, der in der Ebene arbeitet. Der Roboter besteht aus zwei starren Gliedern mit Längen l₁ und l₂, die durch rotatorische Gelenke miteinander verbunden sind. Die Gelenkwinkel sind θ₁ und θ₂. Der Endeffektor befindet sich am Ende des zweiten Gliedes.

a)

1. Vorwärtskinematik: Bestimme die Position des Endeffektors in kartesischen Koordinaten (x,y) in Abhängigkeit von den Gelenkwinkeln θ₁ und θ₂ sowie den Längen l₁ und l₂. Schreibe die entsprechenden Gleichungen auf.

Lösung:

Vorwärtskinematik eines zweigelenkigen Roboterarms

Um die Position des Endeffektors in kartesischen Koordinaten (\textit{x}, \textit{y}) zu bestimmen, müssen wir die Positionen der einzelnen Gelenke analysieren. Der Roboterarm besteht aus zwei Gliedern mit den Längen l₁ und l₂ sowie den Gelenkwinkeln θ₁ und θ₂. Der Endeffektor befindet sich am Ende des zweiten Gliedes.

• Position des ersten Gelenks: Da das erste Gelenk am Ursprung fixiert ist, ist die Position des ersten Gelenks (0,0).
• Position des zweiten Gelenks: Die Position des zweiten Gelenks ergibt sich aus der Länge des ersten Gliedes und dem Winkel θ₁.
• Position des Endeffektors: Die Position des Endeffektors wird durch den Winkel θ₂ und die Länge des zweiten Gliedes beeinflusst.

Die Gleichungen für die Position des Endeffektors in kartesischen Koordinaten lauten daher wie folgt:

• x-Koordinate:

• y-Koordinate:

Mit diesen Gleichungen kannst Du die Position des Endeffektors in Abhängigkeit von den Gelenkwinkeln θ₁, θ₂ und den Längen l₁, l₂ berechnen.

Zusammenfassung:

• Die Position des Endeffektors in kartesischen Koordinaten (x, y) kann durch die folgenden Gleichungen beschrieben werden:

Damit hast Du nun die grundlegenden Gleichungen der Vorwärtskinematik für einen zweigelenkigen Roboterarm.

b)

2. Rückwärtskinematik: Angenommen, der Endeffektor muss die Position (x,y) erreichen. Bestimme die Gelenkwinkel θ₁ und θ₂, die erforderlich sind, um diese Position zu erreichen. Sei präzise in deiner Herleitung und benutze trigonometrische Identitäten.

Lösung:

Rückwärtskinematik eines zweigelenkigen Roboterarms

Um die Gelenkwinkel θ₁ und θ₂ zu bestimmen, die erforderlich sind, um den Endeffektor zu einer gegebenen Position (x, y) zu bewegen, müssen die Vorwärtskinematik-Gleichungen umgekehrt werden. Dazu verwenden wir trigonometrische Identitäten und lösen die Gleichungen schrittweise.

Zur Erinnerung, die Vorwärtskinematik-Gleichungen sind:

• x-Koordinate: \[ x = l_1 \, \cos(θ_1) + l_2 \, \cos(θ_1 + θ_2) \]
• y-Koordinate: \[ y = l_1 \, \sin(θ_1) + l_2 \, \sin(θ_1 + θ_2) \]

Um diese Gleichungen umzudrehen, führen wir die Rückwärtskinematik in zwei Schritten durch: Berechnung von θ₂ und anschließend von θ₁.

Schritt 1: Berechnung von θ₂

Wir verwenden den Kosinussatz für das Dreieck, das durch die Position des Endeffektors und die Armsegmente definiert wird. Zunächst berechnen wir den Abstand r:

• \[ r = \sqrt{x^2 + y^2} \]

Dann verwenden wir den Kosinussatz, um θ₂ zu berechnen:

• \[ \cos(θ_2) = \frac{x^2 + y^2 - l_1^2 - l_2^2}{2 \, l_1 \, l_2} \]
• \[ θ_2 = \arccos \left( \frac{x^2 + y^2 - l_1^2 - l_2^2}{2 \, l_1 \, l_2} \right) \]

Schritt 2: Berechnung von θ₁

Nun berechnen wir θ₁ unter Verwendung der Atan2-Funktion:

• \[ θ_1 = \atan2(y, x) - \atan2\left( l_2 \, \sin(θ_2), l_1 + l_2 \, \cos(θ_2) \right) \]

Damit hast Du nun die grundlegenden Gleichungen zur Bestimmung der Gelenkwinkel θ₁ und θ₂ basierend auf der gewünschten Endeffektorposition (x, y).

Zusammenfassung:

• Die Gelenkwinkel zur Erreichung der Position (x, y) können mit den folgenden Gleichungen berechnet werden:
• \[ θ_2 = \arccos \left( \frac{x^2 + y^2 - l_1^2 - l_2^2}{2 \, l_1 \, l_2} \right) \]
• \[ θ_1 = \atan2(y, x) - \atan2\left( l_2 \, \sin(θ_2), l_1 + l_2 \, \cos(θ_2) \right) \]

Diese Herleitungen und Formeln ermöglichen es Dir, die erforderlichen Gelenkwinkel zu bestimmen, um die angegebene Position des Endeffektors zu erreichen.

c)

3. Newton-Euler-Gleichungen: Bestimme die Kräfte und Momente, die auf den Roboterarm wirken, wenn der Endeffektor eine konstante Beschleunigung α in y-Richtung erfährt. Benutze die Newton-Euler-Gleichungen und nimm an, dass die Massen der beiden Glieder m₁ und m₂ sind, und die Trägheitsmomente I₁ und I₂.

Lösung:

Bestimmung der Kräfte und Momente mit den Newton-Euler-Gleichungen

Um die Kräfte und Momente zu bestimmen, die auf den zweigelenkigen Roboterarm wirken, wenn der Endeffektor eine konstante Beschleunigung α in der y-Richtung erfährt, verwenden wir die Newton-Euler-Gleichungen. Angenommen, die Massen der beiden Glieder sind m₁ und m₂, und die Trägheitsmomente sind I₁ und I₂.

Newton-Euler-Gleichungen

Die Newton-Euler-Gleichungen bestehen aus zwei Teilen: den Newton'schen Bewegungsgleichungen (für die Translation) und den Euler'schen Gleichungen (für die Rotation).

Schritt 1: Bestimmung der Beschleunigungen

• Translation: Die Bewegungsgleichungen für die Translation lauten:

• \[ \textbf{F} = m \textbf{a} \]

Da der Endeffektor nur in y-Richtung beschleunigt wird, haben wir:

• \[ F_y = m_2 \, α \]

Schritt 2: Aufstellen der Euler-Gleichungen für die Glieder

Die Euler-Gleichungen für die Gieder lauten:

• \[ \tau = I \, \frac{dω}{dt} \]

Angenommen, die Winkelbeschleunigungen θ₁ und θ₂ sind α₁ und α₂, dann haben wir die Drehmomente an den beiden Gelenken:

• Für Glied 1:

• \[ \tau_1 = I_1 \, α_1 \]

• Für Glied 2:

• \[ \tau_2 = I_2 \, α_2 \]

Schritt 3: Berechnung der Kräfte und Momente

In diesem Schritt berechnen wir die resultierenden Kräfte und Momente, die aus der konstanten Beschleunigung des Endeffektors resultieren.

• Die statische Gleichgewichtsgleichung für die Kräfte in y-Richtung, wobei die Gravitationskräfte vernachlässigt werden:

• \[ F_y = F_j + m_2 \, α \]

Wobei F_j die inneren Kräfte zwischen den Gliedern darstellen.

Die Momentengleichungen sind:

• Für das erste Gelenk:

• \[ \tau_1 = r_1 \times F_1 + r_{12} \times F_j \]

• Für das zweite Gelenk:

• \[ \tau_2 = r_2 \times F_y \]

Die vollständige Berechnung hängt stark von der Geometrie und den genauen Dimensionen der Roboterglieder ab, aber die allgemeine Lösungsschritte und Formeln folgen aus den oben aufgeführten Gleichungen.

Zusammenfassung:

• Benutze die Newton'schen Gleichungen für die Kraft:

• \[ F_y = m_2 \, α \]

• Benutze die Euler-Gleichungen für die Drehmomente:

• Für das erste Gelenk:

• \[ \tau_1 = I_1 \, α_1 \]

• Für das zweite Gelenk:

• \[ \tau_2 = I_2 \, α_2 \]

Mithilfe dieser Gleichungen kannst Du die Kräfte und Momente berechnen, die auf die einzelnen Glieder wirken, wenn der Endeffektor eine konstante Beschleunigung in der y-Richtung erfährt.

Aufgabe 2)

Du entwickelst einen Algorithmus zur Steuerung und Navigation eines LEGO Mindstorms Roboters, der in einem unbekannten Labyrinth den Ausgang finden muss. Dabei soll der Roboter Hindernisse erkennen, umfahren und regelmäßig seine Position anpassen, um sicherzustellen, dass er den effizientesten Weg findet. Du hast Zugang zu einem LEGO Mindstorms EV3 Roboter mit Ultraschallsensor, Lichtsensor und Gyroskopsensor. Die Programmierung erfolgt in der EV3-Entwicklungsumgebung.

a)

Entwickle einen Algorithmus, um den Roboter durch das Labyrinth zu navigieren. Der Roboter soll mit Hilfe seines Ultraschallsensors Hindernisse erkennen und vermeiden sowie mithilfe seines Gyroskopsensors geradeaus fahren. Schreibe den entsprechenden Pseudocode oder EV3-G Programmablauf. Implementiere dabei einen einfachen Regelkreis zur Richtungsjustierung basierend auf den Sensordaten. Zeige in deinem Programmablauf explizit, wie die Sensordaten erfasst und verarbeitet werden, um die Steuerbefehle für den Roboter zu erzeugen.

Lösung:

Um den LEGO Mindstorms EV3 Roboter durch ein Labyrinth zu navigieren, ohne gegen Hindernisse zu stoßen, und um kontinuierlich seine Richtung mittels gyroskopischer Anpassungen zu korrigieren, kann folgender Algorithmus verwendet werden. Dieser Algorithmus ist in Pseudocode geschrieben, aber er kann leicht in die EV3-Entwicklungsumgebung übertragen werden.

• Initialisierung:Stelle sicher, dass du die Sensoren (Ultraschall, Licht, Gyroskop) korrekt konfiguriert hast und dass sie Daten lesen können.

setultraschallsensor(EV3_ULTRASONIC_SENSOR)setlichsensor(EV3_COLOR_SENSOR)setgyrosensor(EV3_GYRO_SENSOR)reset_gyro()

• Hinderniserkennung und Umgehung mit Ultraschallsensor:Erfasse kontinuierlich die Entfernung zu möglichen Hindernissen und weiche aus, wenn ein Hindernis erkannt wird.

while not goal_achieved:\t# Lese die Entfernung von Hindernissen\tentfernung = get_ultraschall_daten()\t\tif entfernung < 20:\t\t# Hindernis erkannt, weiche aus\t\tstop_motor()\t\tdrehe_rechts(90) # Drehe den Roboter um 90 Grad nach rechts\telse:\t\t# Kein Hindernis, fahre geradeaus\t\tfahre_geradeaus(50)

• Richtungsjustierung mit Gyroskopsensor:Messe die Neigung des Roboters und korrigiere seine Richtung, um sicherzustellen, dass er geradeaus fährt.

while fahren == True:\t# Lese die neigung vom Gyrosensor\tneigung = lese_gyro_daten()\t\tif neigung > 0:\t\t# Roboter dreht sich nach rechts, korrigiere nach links\t\tkorrigiere_gyro_link(5)\telif neigung < 0:\t\t# Roboter dreht sich nach links, korrigiere nach rechts\t\tkorrigiere_gyro_rechts(5)\t\t# Weiter geradeaus fahren\tfahre_geradeaus()

• Komplettes Programm:Das vollständige Programm kombiniert die Hinderniserkennung und -umgehung mit der Richtungsjustierung.

setultraschallsensor(EV3_ULTRASONIC_SENSOR)setlichsensor(EV3_COLOR_SENSOR)setgyrosensor(EV3_GYRO_SENSOR)reset_gyro()while not goal_achieved:\tentfernung = get_ultraschall_daten()\tneigung = lese_gyro_daten()\t\tif entfernung < 20:\t\tstop_motor()\t\tdrehe_rechts(90)\telse:\t\tif neigung > 0:\t\t\tkorrigiere_gyro_link(5)\t\telif neigung < 0:\t\t\tkorrigiere_gyro_rechts(5)\t\tfahre_geradeaus()

Dieser Algorithmus ermöglicht es dem Roboter, Hindernisse zu erkennen und zu umgehen, während er seine Richtung kontinuierlich anpasst, um sicherzustellen, dass er effizient durch das Labyrinth navigiert.

b)

Simuliere mathematisch die Laufzeitoptimierung Deines Algorithmus. Gegeben sei ein Labyrinth in Form eines Gitters von 10x10 Feldern, wobei jedes Feld eine Größe von 1x1 Metern hat. Der Roboter startet in der linken unteren Ecke (Position (0,0)) und der Ausgang befindet sich in der rechten oberen Ecke (Position (9,9)). Berechne die optimale Laufzeit ohne Hindernisse, wenn der Roboter 1 Meter pro Sekunde fährt. Berechne zusätzlich die Zeit, die bei einer geschätzten Umgehung von durchschnittlich 3 Hindernissen mit einer zusätzlichen Strecke von jeweils 2 Metern hinzukommen würde. Formuliere alle Berechnungen mit den entsprechenden Formeln in LaTeX.

Lösung:

Um die Laufzeitoptimierung des Algorithmus mathematisch zu simulieren, erfolgen die Berechnungen Schritt für Schritt. Wir berechnen zuerst die optimale Zeit ohne Hindernisse und danach die Zeit unter Berücksichtigung von Hindernissen.

• Gegeben:
• Labyrinthgröße: 10x10 Felder
• Feldgröße: 1x1 Meter
• Startposition: (0,0)
• Endposition: (9,9)
• Geschwindigkeit des Roboters: 1 Meter pro Sekunde
• Optimale Laufzeit ohne Hindernisse:

Die ideale Strecke führt den Roboter durch 9 horizontale und 9 vertikale Felder:

\begin{equation}\text{Optimale Strecke} = 9 \text{ Meter horizontal} + 9 \text{ Meter vertikal} = 18 \text{ Meter}\end{equation}

Die Zeit ergibt sich aus:

\begin{equation}\text{Optimale Zeit} = \frac{\text{Optimale Strecke}}{\text{Geschwindigkeit}} = \frac{18 \text{ Meter}}{1 \text{ Meter/Sekunde}} = 18 \text{ Sekunden}\end{equation}

• Berücksichtigung von Hindernissen:

Wir gehen davon aus, dass der Roboter durchschnittlich 3 Hindernissen ausweichen muss, wobei jede Umgehung eine zusätzliche Strecke von 2 Metern erfordert:

\begin{equation}\text{Zusätzliche Strecke pro Hindernis} = 2 \text{ Meter}\end{equation}

Insgesamt ergibt sich für 3 Hindernisse:

\begin{equation}\text{Zusätzliche Strecke} = 3 \times 2 \text{ Meter} = 6 \text{ Meter}\end{equation}

Die Gesamtstrecke mit Hindernissen ist daher:

\begin{equation}\text{Gesamtstrecke} = \text{Optimale Strecke} + \text{Zusätzliche Strecke} = 18 \text{ Meter} + 6 \text{ Meter} = 24 \text{ Meter}\end{equation}

Die Laufzeit mit Hindernissen berechnet sich als:

\begin{equation}\text{Gesamtzeit} = \frac{24 \text{ Meter}}{1 \text{ Meter/Sekunde}} = 24 \text{ Sekunden}\end{equation}

Die zusätzliche Zeit durch die Umgehung von Hindernissen ergibt sich aus:

\begin{equation}\text{Zusätzliche Zeit} = \text{Gesamtzeit} - \text{Optimale Zeit} = 24 \text{ Sekunden} - 18 \text{ Sekunden} = 6 \text{ Sekunden}\end{equation}

Zusammengefasst ergeben sich folgende Laufzeiten:

• Optimale Zeit ohne Hindernisse: 18 Sekunden
• Gesamtzeit mit Hindernissen: 24 Sekunden
• Zusätzliche Zeit durch Hindernisse: 6 Sekunden

Aufgabe 3)

Integration von Sensoren in Roboter: In dieser Aufgabe wirst du Sensoren in deinen Lego Mindstorms-Roboter einbauen und deren Daten nutzen, um spezifische Aufgaben zu lösen. Du musst den Roboter so programmieren, dass er Daten von den Sensoren in Echtzeit verarbeitet und entsprechend reagiert. Du kannst NXT-G, Java oder Python zur Programmierung verwenden. Achte darauf, die Sensoren vor Gebrauch zu kalibrieren, um präzise Messungen zu gewährleisten. Typische Aufgaben könnten die Linienverfolgung oder Hindernisvermeidung umfassen.

a)

Baue einen Roboter, der eine definierte Linie auf dem Boden verfolgen kann. Verwende dazu einen Lichtsensor. Beschreibe Schritt für Schritt, wie du vorgehen würdest, um den Roboter aufzubauen, den Sensor zu kalibrieren und das Programm zu erstellen.

• Beschreibe, wie der Lichtsensor angeschlossen, kalibriert und programmiert wird.
• Erkläre den verwendeten Algorithmus zur Linienverfolgung, z.B. Proportionalregelung.
• Zeige den Code oder das NXT-G Diagramm, das du erstellen würdest, um die Aufgabe umzusetzen.

Lösung:

Integration von Sensoren in Roboter: In dieser Aufgabe wirst du Sensoren in deinen Lego Mindstorms-Roboter einbauen und deren Daten nutzen, um spezifische Aufgaben zu lösen. Du musst den Roboter so programmieren, dass er Daten von den Sensoren in Echtzeit verarbeitet und entsprechend reagiert. Du kannst NXT-G, Java oder Python zur Programmierung verwenden. Achte darauf, die Sensoren vor Gebrauch zu kalibrieren, um präzise Messungen zu gewährleisten. Typische Aufgaben könnten die Linienverfolgung oder Hindernisvermeidung umfassen. Aufgabe: Baue einen Roboter, der eine definierte Linie auf dem Boden verfolgen kann. Verwende dazu einen Lichtsensor.

• Schritt 1: Roboteraufbau Verbinde den Lichtsensor mit deinem Lego Mindstorms-Roboter. Befestige den Sensor an der Vorderseite des Roboters, so dass er nahe dem Boden ausgerichtet ist, um die Helligkeitswerte der Linie erkennen zu können. Achte darauf, dass der Sensor stabil montiert ist, um verlässliche Messungen zu gewährleisten.
• Schritt 2: Kalibrierung des Lichtsensors Kalibriere den Lichtsensor, indem du ihn über die Linie und die Umgebung (den Boden) hältst. Nimm die Helligkeitswerte für beide Zustände auf:
  • Bewege den Sensor über die Linie und notiere den Helligkeitswert.
  • Bewege den Sensor auf die Umgebung (den Boden) und notiere den Helligkeitswert.
  Verwende diese Werte, um deinen Programmcode zu kalibrieren, damit der Roboter die Linie von der Umgebung unterscheiden kann.
• Schritt 3: Programmierung Algorithmus zur Linienverfolgung: Wir verwenden eine einfache Proportionalregelung, bei der der Roboter Korrekturen auf der Grundlage der Abweichung vom Sollwert (Linie) vornimmt. Hier ist eine Schritt-für-Schritt-Erklärung:
  • 1. Sensordaten einlesen: Liest die aktuellen Lichtsensorwerte ein.
  • 2. Fehlerberechnung: Berechnet den Unterschied zwischen dem aktuellen Sensorwert und dem Sollwert (Referenzwert für die Linie).
  • 3. Proportionalregelung: Bestimmt die Korrektur des Roboters proportional zum Fehler.
  • 4. Motorsteuerung: Passt die Geschwindigkeit der Räder basierend auf der Korrektur an.
  Python-Code: Hier ist ein Beispielcode in Python.

   import time from nxt.locator import find_one_brick from nxt.motor import Motor, PORT_B, PORT_C from nxt.sensor import Light, PORT_3  # Initialisierung brick = find_one_brick() light = Light(brick, PORT_3) motor_left = Motor(brick, PORT_B) motor_right = Motor(brick, PORT_C)  # Kalibrierungswerte line_value = 40  # Helligkeitswert der Linie (Beispiel) background_value = 60  # Helligkeitswert des Bodens (Beispiel) threshold = (line_value + background_value) / 2  kp = 0.5  # Proportionalitätskonstante  while True:     light_value = light.get_lightness()  # Sensordaten einlesen     error = threshold - light_value  # Fehlerberechnung     correction = kp * error  # Proportionalregelung     motor_left.run(75 + correction)     motor_right.run(75 - correction)     time.sleep(0.01) 

  NXT-G Diagramm: Für NXT-G musst du die folgenden Blöcke verwenden:
  • Start Block
  • Loop Block
  • Light Sensor Block (mit Kalibrierung)
  • Mathematik Blöcke für Fehlerberechnung und Proportionalregelung
  • Motor Blöcke für die Steuerung der Motoren
  Stelle sicher, dass du alle Blöcke korrekt verbindest, um den Algorithmus zu implementieren. Dies sollte dir helfen, einen Roboter zu bauen und zu programmieren, der eine Linie auf dem Boden verfolgen kann. Viel Erfolg!

  b)

  Erweitere den zuvor gebauten Roboter mit einem Ultraschallsensor, um Hindernisse zu vermeiden. Schreibe ein Programm, das den Roboter dazu bringt, bei Erkennung eines Hindernisses (d.h. wenn der Abstand kleiner als 20 cm ist) anzuhalten und einen Umgehungsmanöver durchzuführen.

  • Beschreibe, wie der Ultraschallsensor angeschlossen und kalibriert wird.
  • Erkläre die Logik für das Anhalten und Umgehen des Hindernisses.
  • Füge den Code oder das NXT-G Diagramm hinzu, das diese Logik implementiert.

  Lösung:

  Integration von Sensoren in Roboter: In dieser Aufgabe wirst du Sensoren in deinen Lego Mindstorms-Roboter einbauen und deren Daten nutzen, um spezifische Aufgaben zu lösen. Du musst den Roboter so programmieren, dass er Daten von den Sensoren in Echtzeit verarbeitet und entsprechend reagiert. Du kannst NXT-G, Java oder Python zur Programmierung verwenden. Achte darauf, die Sensoren vor Gebrauch zu kalibrieren, um präzise Messungen zu gewährleisten. Typische Aufgaben könnten die Linienverfolgung oder Hindernisvermeidung umfassen. Aufgabe: Erweitere den zuvor gebauten Roboter mit einem Ultraschallsensor, um Hindernisse zu vermeiden.

  • Schritt 1: Anschluss und Kalibrierung des Ultraschallsensors Verbinde den Ultraschallsensor mit dem entsprechenden Port deines Lego Mindstorms-Roboters, beispielsweise PORT_4. Der Sensor sollte an der Vorderseite des Roboters angebracht werden, um Hindernisse erkennen zu können. Eine spezielle Kalibrierung ist für den Ultraschallsensor normalerweise nicht erforderlich, da er bereits werkseitig eingestellt ist.
  • Schritt 2: Logik für das Anhalten und Umgehen des Hindernisses Wenn der Ultraschallsensor ein Hindernis erkennt, muss der Roboter die folgende Logik ausführen:
    • Den Abstand zum Hindernis kontinuierlich messen.
    • Wenn der Abstand kleiner als 20 cm ist, den Roboter anhalten.
    • Einen Umgehungsmanöver durchführen, indem der Roboter zum Beispiel rückwärts fährt, sich dreht und eine neue Route sucht.
    Hier ist ein Beispiel für die Umsetzung der Logik:
    • 1. Ultraschalldaten einlesen: Liest den aktuellen Abstandswert vom Ultraschallsensor ein.
    • 2. Abstandskontrolle: Prüft, ob der Abstand kleiner als ein Schwellenwert (z.B. 20 cm) ist.
    • 3. Anhalten: Stoppt die Motoren, wenn ein Hindernis erkannt wurde.
    • 4. Umgehungsmanöver: Fährt rückwärts, dreht sich und fährt dann weiter.
    Python-Code: Hier ist ein Beispielcode in Python.

     import time from nxt.locator import find_one_brick from nxt.motor import Motor, PORT_B, PORT_C from nxt.sensor import Ultrasonic, PORT_4  # Initialisierung brick = find_one_brick() ultrasonic = Ultrasonic(brick, PORT_4) motor_left = Motor(brick, PORT_B) motor_right = Motor(brick, PORT_C)  # Schwellenwert distance_threshold = 20  # in cm  while True:     distance = ultrasonic.get_sample()  # Ultraschalldaten einlesen     if distance < distance_threshold:         motor_left.brake()  # Anhalten         motor_right.brake()         time.sleep(1)  # Kurz warten         motor_left.run(-75)  # Rückwärts fahren         motor_right.run(-75)         time.sleep(1)         motor_left.run(75)  # Sich drehen         motor_right.run(-75)         time.sleep(0.5)     else:         motor_left.run(75)  # Weiter fahren         motor_right.run(75)     time.sleep(0.01) 

    NXT-G Diagramm: Für NXT-G musst du die folgenden Blöcke verwenden:
    • Start Block
    • Loop Block
    • Ultraschallsensor Block
    • Vergleichsblock (für die Abstandskontrolle)
    • Switch Block (für das Anhalten und Umgehen des Hindernisses)
    • Motor Blöcke für die Steuerung der Motoren (für Anhalten, Rückwärtsfahren, Drehen und Fortsetzen)
    Stelle sicher, dass du alle Blöcke korrekt verbindest, um die Logik zu implementieren. Dies sollte dir helfen, den Roboter zu erweitern und zu programmieren, um Hindernisse zu vermeiden. Viel Erfolg!

    Aufgabe 4)

    Steuerung von Aktoren zur Erzeugung von Bewegungen: Die Steuerung von Aktoren zur Bewegungserzeugung abstrahiert die mechanischen Komponenten in programmierbare Einheiten zur Bewegungssteuerung. Du hast Zugriff auf verschiedene Funktionen zur Motorsteuerung wie On, Off, SetPower(p) und RotateBy(degrees). Es stehen auch PID-Regler (Proportional, Integral, Derivat) und Methoden zur Synchronisation von Motoren zur Verfügung. Zusätzlich solltest Du Sensordaten integrieren können, um die Bewegungen der Aktoren in Echtzeit anzupassen.

    a)

    Implementiere eine Funktion in Python für einen LEGO Mindstorms Roboter, um eine gerade Linie von 1 Meter zu fahren. Nutze die Funktion SetPower(p), um die Geschwindigkeit der Motoren zu kontrollieren und On und Off, um die Motoren zu starten und zu stoppen. Hierbei soll ein PID-Regler verwendet werden, um eine präzise Bewegung sicherzustellen. Kommentiere den Code ausführlich, um jeden Schritt und die Funktionsweise des PID-Reglers zu erklären.

    Lösung:

    Lösung: Hier ist eine implementierte Funktion in Python für einen LEGO Mindstorms Roboter, der eine gerade Linie von 1 Meter fährt, unter Verwendung eines PID-Reglers zur präzisen Steuerung der Motoren:

    import time # PID-Klasse zur Steuerungclass PIDController:    def __init__(self, kp, ki, kd):        self.kp = kp # Proportionaler Term        self.ki = ki # Integraler Term        self.kd = kd # Differentieller Term         self.pre_error = 0        self.integral = 0     def update(self, target, current):        # Fehler berechnen        error = target - current         # Proportionaler Term        P = self.kp * error         # Integraler Term        self.integral += error        I = self.ki * self.integral         # Differentieller Term        derivative = error - self.pre_error        D = self.kd * derivative         # PID Ausgabe        output = P + I + D         # Fehler für den nächsten Zyklus speichern        self.pre_error = error         return output # Dummy-Funktionen, die Lego Mindstorms Funktionen simulierendef SetPower(p):    # Setzt die Leistung des Motors    print(f'SetPower: {p}') def On():    # Motoren einschalten    print('Motoren eingeschaltet') def Off():    # Motoren ausschalten    print('Motoren ausgeschaltet') # Funktion zum Fahren einer geraden Linie von 1 Meterdef drive_straight_1_meter(target_distance=100):    motor_diameter = 0.056 # Annahme: Raddurchmesser ist 56mm    wheel_circumference = motor_diameter * 3.14159265359 # Umfang des Rades    rotations_to_travel = target_distance / wheel_circumference # Ziel-Rotationen     pid = PIDController(1.0, 0.1, 0.01) # Initialisierung des PID-Reglers     current_rotation = 0 # Aktuelle Rotation    tolerance = 0.01 # Toleranzwert     On() # Motoren einschalten     while abs(current_rotation - rotations_to_travel) > tolerance:        power = pid.update(rotations_to_travel, current_rotation)        SetPower(power)         # Simuliere die tatsächlich zurückgelegte Strecke (hier einfach um 0.01 inkrementiert)        time.sleep(0.01)        current_rotation += 0.01     Off() # Motoren ausschalten # Hauptfunktion aufrufendrive_straight_1_meter() 

    • Der Code benutzt die PID-Klasse zur Steuerung der Motoren.
    • Die SetPower-Funktion setzt die Geschwindigkeit der Motoren.
    • Die On und Off-Funktion schalten die Motoren ein und aus.
    • Die Funktion drive_straight_1_meter berechnet die notwendigen Rotationen, um 1 Meter geradeaus zu fahren.
    • Der PID-Regler passt die Motorleistung in Echtzeit an, um eine präzise Bewegung zu gewährleisten.

    c)

    Beschreibe ein Szenario, in dem die Synchronisation von Motoren notwendig ist, und entwirf einen Algorithmus, der dies umsetzt. Der Roboter soll einer vorgegebenen Kurve folgen und dabei Metrikdaten der zurückgelegten Strecke basierend auf Sensordaten in Echtzeit speichern und anpassen. Erläutere, wie du die Synchronisation zwischen den Motoren sicherstellst und wie Sensordaten integriert werden, um die Bewegung anzupassen.

    Lösung:

    Szenario:

    Stell Dir vor, Du möchtest, dass Dein LEGO Mindstorms Roboter einer komplexen vorgegebenen Kurve folgt, wie zum Beispiel einem Slalom-Parcours. In diesem Fall ist es notwendig, die Synchronisation der Motoren zu gewährleisten, damit der Roboter sich präzise entlang der Kurve bewegt. Zudem sollen Metrikdaten der zurückgelegten Strecke in Echtzeit basierend auf Sensordaten gespeichert und Anpassungen vorgenommen werden.

    Algorithmus zur Motorensynchronisation:

    Um die Synchronisation der Motoren zu erreichen und Sensordaten zu nutzen, schlage ich den folgenden Algorithmus vor:

    import time # Dummy-Funktionen zur Motorsteuerungdef SetPowerLeft(p):    print(f'SetPowerLeft: {p}') def SetPowerRight(p):    print(f'SetPowerRight: {p}') def On():    print('Motoren eingeschaltet') def Off():    print('Motoren ausgeschaltet') # Sensor-Dummy-Funktiondef getSensorData():    # Hier wird ein Pseudo-Sensordatenwert zurückgegeben    return {'distance': 50, 'angle': 0.2} # PID-Klasseclass PIDController:    def __init__(self, kp, ki, kd):        self.kp = kp        self.ki = ki        self.kd = kd         self.pre_error = 0        self.integral = 0     def update(self, target, current):        error = target - current        self.integral += error        P = self.kp * error        I = self.ki * self.integral        D = self.kd * (error - self.pre_error)        self.pre_error = error         return P + I + D # Algorithmus zur Synchronisation und Anpassungdef follow_curve():    On() # Motoren einschalten    distance_pid = PIDController(1.0, 0.01, 0.1)    angle_pid = PIDController(1.0, 0.01, 0.1)     target_distance = 100 # Zielentfernung in cm    target_angle = 0 # Zielwinkel in Radiant # Variablen für die tatsächliche Position    actual_distance = 0    actual_angle = 0 # Schleife, bis das Ziel erreicht ist    while actual_distance < target_distance:        sensor_data = getSensorData() # Sensordaten abrufen         distance_correction = distance_pid.update(target_distance, sensor_data['distance'])        angle_correction = angle_pid.update(target_angle, sensor_data['angle']) # Steuerung der Motoren basierend auf den PID-Korrekturen        SetPowerLeft(distance_correction - angle_correction)        SetPowerRight(distance_correction + angle_correction) # Aktualisierung der tatsächlichen Position basierend auf den Sensordaten        actual_distance += sensor_data['distance'] * time.sleep(0.1)        actual_angle += sensor_data['angle'] * time.sleep(0.1)     Off() # Motoren ausschalten 

    • Der Algorithmus verwendet zwei PID-Regler, einen für die Entfernung und einen für den Winkel.
    • Sensordaten werden in Echtzeit abgerufen, um die aktuelle Position des Roboters zu bestimmen.
    • Die PID-Korrekturen werden verwendet, um die Leistung der linken und rechten Motoren anzupassen und so die Synchronisation sicherzustellen.
    • Die Motorleistungen werden basierend auf der Differenz zwischen der Ziel- und der Ist-Position angepasst, wobei der Winkelkorrekturwert hinzugefügt oder subtrahiert wird, um Drehungen zu ermöglichen.
    • Die tatsächliche Position des Roboters wird kontinuierlich aktualisiert und mit den Zielwerten abgeglichen, um präzise Änderungen der Motorleistungen vorzunehmen.
    Integration von Sensordaten:In diesem Szenario werden die Sensordaten verwendet, um die aktuelle Entfernung und den Winkel des Roboters im Verhältnis zur Zielkurve zu bestimmen. Diese Daten werden kontinuierlich an die PID-Regler übergeben, um die Motorleistung dynamisch anzupassen und so sicherzustellen, dass der Roboter der vorgegebenen Kurve präzise folgt.