Mobiler Rover

Das Mobile Rover-Projekt besteht aus einem programmierbaren Roboter, der mit MATLAB über Wi-Fi kommunizieren kann, um Operationen mit einem Bildverarbeitungsalgorithmus durchzuführen. Der Rover wird von einem Arduino MKR1000, dem Arduino MKR Carrier, zwei DC-Motoren mit Encodern, einem Mikro-Servomotor und einigen Sensoren gesteuert. Auf dem Rover installieren Sie einen farbcodierten Aufkleber, der als Markierung für den Bildverarbeitungsalgorithmus dient. Dieser erkennt mit Hilfe einer Webcam die Position und Ausrichtung des Roboters.

In diesem Projekt programmieren Sie den mobilen Rover für eine Vielzahl von Aufgaben, wie z.B. Folgen von Pfaden, Bewegen von Objekten mit dem Gabelstapler und Umgehen von Hindernissen. Sie lernen wichtige Robotik-Konzepte kennen, z.B. die Funktionsweise von Differentialantriebsrobotern und die Simulation ihres Verhaltens, die Kontrolle ihrer Position oder Geschwindigkeit sowie die Lokalisierung. Nach Abschluss des Projekts haben Sie genug Wissen, Ihre eigenen Roboter zu entwickeln und zu programmieren, um intelligent zu reisen und alle Arten von lustigen Aufgaben zu erledigen.

Wenn Sie bereit sind, mit der Codierung zu beginnen, sollten Sie den Rover gemäß den Anweisungen, die Sie unten finden, aufgebaut haben:

In den Übungen, aus denen sich dieses Projekt zusammensetzt, werden Sie folgendes lernen:

• Übung 1: Steuern Sie den Rover und Gabelstapler von MATLAB aus.

• Übung 2: Verwenden Sie kinematische Gleichungen, um die Roverbewegung zu simulieren und eine Steuerung im offenen Regelkreis durchzuführen.

• Übung 3: Führen Sie die Regelung des Rovers durch.

• Übung 4: Verwenden Sie Zustände, um a) Ihren Rover so zu programmieren, dass er der Sequenz folgt, und um b) stationäre Fehler und Überschreitungen Ihres geschlossenen Regelkreises zu beseitigen.

• Übung 5: Lokalisieren Sie den Rover mit Hilfe der Bildverarbeitung.

• Übung 6: Steuern Sie den Rover und den Gabelstapler, um das gewünschte Objekt aufzunehmen und abzusetzen.

• Übung 7: Aktivieren Sie die Wi-Fi-Kommunikation zwischen Rover und MATLAB.

Steuern Sie den Rover und den Gabelstapler von MATLAB# Der Mini-Mobil-Rover ist ein Differential-Antriebsroboter, der über separate DC Motoren verfügt, die jedes seiner Räder steuern. Sie können die Fahrtrichtung steuern, indem Sie die Geschwindigkeit der einzelnen Räder variieren, ohne dass eine separate Lenkung erforderlich ist. In dieser Übung lernen Sie, wie Sie den Rover fahren und den Gabelstapler mit MATLAB bedienen.

In dieser Übung lernen Sie Folgendes:

• Steuerung der Grundbewegung eines Differentialantriebsroboters.

• Verbinden von MATLAB mit dem Rover.

• Rover in gerader Linie fahren lassen.

• Rover im Kreis fahren lassen.

• Gabelstapler des Rovers steuern lassen.

Zunächst verbinden Sie den Arduino MKR1000 über das USB-Kabel mit Ihrem Computer:

Um zwischen MATLAB und Arduino zu kommunizieren, müssen Sie die Portnummer kennen, mit der Ihr Arduino verbunden ist. Sie können diese anhand der Schritte bestimmen, die in Abschnitt 2.1.3 Arbeiten mit digitalen Outputs in "2.1 Arduino Getting Started " beschrieben sind. Denken Sie daran, dass die Portnamen von Betriebssystem zu Betriebssystem unterschiedlich sind, d.h. sie unterscheiden sich für Windows (wo sie COM## genannt werden, wobei ## eine eindeutige numerische Kennung ist), OSX (/dev/tty.usbmodem###) und Linux (/dev/ttyACM##).

Sobald Sie die Portnummer kennen, geben Sie die folgenden Befehle mit der entsprechenden Portnummer ein, um (a) ein Arduino-Objekt mit den erforderlichen Bibliotheken und (b) ein separates Objekt für den Carrier zu erstellen:

In einer gerader Linie fahren

Sie wissen wahrscheinlich intuitiv, dass der Rover geradeaus fahren wird, wenn sich beide Räder mit gleicher Geschwindigkeit und in die gleiche Richtung drehen. Lassen Sie uns die DC-Motoren des Rovers mit der gleichen Geschwindigkeit drehen und beobachten, ob er wie erwartet geradlinig läuft. Geben Sie die folgenden Befehle ein, um die DC-Motoren an MATLAB anzuschließen:

Geben Sie nun an, dass die DC-Motoren mit 25% der maximalen Drehzahl drehen sollen:

Sobald Sie angegeben haben, wie schnell sich die Motoren drehen müssen, ist der nächste Schritt, sie zu drehen! Geben Sie die folgenden Befehle ein, um die Motoren 10 Sekunden lang mit dieser Geschwindigkeit zu betreiben:

Messen Sie, wie weit sich der Rover bei Verwendung dieser Befehle bewegt hat. Die Informationen, die von den an jedem der DC Motoren angeschlossenen Encoders kommen, werden noch nicht gelesen. Es gibt also keine Möglichkeit, sicherzustellen, dass sich der Rover entweder vollständig gerade bewegt (es kann leichte Unterschiede im Verhalten zwischen den Motoren geben) oder dass er sich bei jeder Ausführung des Programms gleich weit bewegt (mit der Zeit werden die Batterien immer weniger geladen und verhalten sich unterschiedlich).

Im Kreis fahren

Wenn Sie gefragt wurden, wie Sie den Rover in einem Kreis fahren lassen sollen, könnte Ihre Antwort lauten: a) nur das eine Rad zu drehen, aber nicht das andere oder b) beide Räder mit der gleichen Geschwindigkeit, aber in entgegengesetzte Richtungen zu drehen.

Beide Antworten sind korrekt, aber die Art und Weise, wie sich der Rover bewegt, ist unterschiedlich. Lassen Sie uns den ersten Fall analysieren:

Drehen Sie ein Rad, aber nicht das andere. Versuchen Sie die folgenden Befehle mit dem Rover:

Sie sollten beachten, dass sich der Rover im Kreis um sein linkes Rad dreht.

Der andere Fall erforderte, dass Sie beide Räder mit gleicher Geschwindigkeit, aber in entgegengesetzter Richtung drehen. Versuchen Sie, die Räder mit gleicher und entgegengesetzter Geschwindigkeit zu drehen, indem Sie den folgenden Code in MATLAB ausführen:

Sie sollten sehen, dass sich der Rover im Kreis um seine Mitte dreht.

Der Gabelstapler des Rovers wird von einem Standard-Servomotor gesteuert, der mit der MKR motor Carrier board verbunden ist; das bedeutet, Sie können den Winkel steuern, in dem sich der Motor dreht. Normalerweise können sich Standardservos zwischen 0 und 180 Grad drehen, aber es kann auch andere Typen geben.

In diesem Abschnitt bewegen Sie zunächst den Servo in die Position "Down", was einem Winkel von Null Grad entspricht. Sie verwenden dazu die writePosition(s,0);- Anweisung, die im folgenden Code gezeigt wird. Anschließend fahren Sie den Servo in die Position "Up", was einem Winkel von 125 Grad am eigentlichen Servomotor entspricht. Im zweiten Eingang der writePosition Funktion stellt 0 die minimal mögliche Position dar, die bei Standard-Servomotoren Null Grad ist, und 1 die maximal mögliche Position, die 180 Grad beträgt. Geben Sie die folgenden Befehle ein, um sich mit dem Servo zu verbinden und den Gabelstapler zwischen den Positionen Up und Down zu bewegen:

• Sie haben gelernt, wie man den Rover geradlinig und im Kreis fährt.

• Sie haben gelernt, wie man den Gabelstapler steuert, der in späteren Übungen zum Anheben des Ziels verwendet wird.

• Lassen Sie den Rover im Kreis mit unterschiedlichem Radius fahren, indem unterschiedliche Geschwindigkeiten an beide Räder gesendet werden.

• Lassen Sie den Rover in einer Reihenfolge fahren: vorwärts, dann um 90 Grad nach links und dann wieder nach vorne.

In Übung 1 haben Sie gelernt, wie Sie den Rover in einer Geraden und im Kreis fahren lassen. Um den Rover jedoch auf komplexeren Wegen zu bewegen, müssen Sie die zugrunde liegenden kinematischen Gleichungen verstehen, die die Geschwindigkeit jedes Rads mit der Geschwindigkeit und Fahrtrichtung des Rovers in Beziehung setzen. In dieser Lektion lernen Sie die grundlegenden kinematischen Gleichungen hinter Differentialantriebsrobotern und wie Simulink Ihnen helfen kann, die Bewegung des Rovers für verschiedene Eingänge zu visualisieren und zu simulieren. Sie werden dann das, was Sie durch diese Simulationen gelernt haben, anwenden, um den Rover in der realen Welt zu steuern.

In dieser Übung werden Sie Folgendes lernen:

• Verstehen Sie die kinematischen Gleichungen des Rovers.

• Simulieren Sie den Rover mit kinematischen Gleichungen.

• Modellieren und simulieren Sie die Roverbewegung mit Simulink.

• Steuern Sie den Rover mit Open-Loop.

• Verwenden Sie Simulink Modelle, um den eigentlichen Rover zu steuern.

Das folgende Diagramm zeigt die Grundkinematik des Rovers (oder eines beliebigen Differentialantriebsroboters):

Das Diagramm stellt einige wichtige Parameter vor, die mit differentiellen Antriebsrobotern verbunden sind, darunter Drehradius ($R$), Drehrate ($\omega_{l}$), momentaner Krümmungsmittelpunkt (ICC), Radgeschwindigkeiten ($v_{l}$, $v_{r}$), Roverlänge ($L$) und Vorwärtsgeschwindigkeit ($v$). Wenn Sie mehr über die in diesem Diagramm dargestellten Konzepte erfahren möchten, besuchen Sie bitte diese Seite.

Konzentrieren wir uns auf die Drehrate und die Vorwärtsgeschwindigkeit.

Drehrate: $\omega =\frac{v_{r}-v_{l}}{L}$

Vorwärtsgeschwindigkeit: $v=\frac{v_{r}+v_{l}}{2}$

Radgeschwindigkeiten ($v_{l}$, $v_{r}$) können basierend auf Radius ($r$) und Drehzahlen ($\omega_{l}$, $\omega_{r}$) berechnet werden:

$v_{l}= \omega_{l} \cdot r$

$v_{r}= \omega_{r} \cdot r$

Wenn man diese Werte in die vorherigen Gleichungen einfügt, erhält man die Ergebnisse:

$\omega =\frac{r\cdot \left( \omega _{r}- \omega _{l} \right) }{L}$

$v=\frac{r\cdot \left( \omega _{r}+ \omega _{l} \right) }{2}$

Umstellen dieser Gleichungen:

$\omega _{r}+ \omega _{l}=\frac{2v}{r}$

$\omega _{r}- \omega _{l}=\frac{L \omega }{r}$

Lösung für $\omega_{r}$ and $\omega_{l}$:

$\omega _{r}=\frac{v+ \left( \frac{L}{2} \right) \omega }{r}$

$\omega _{l}=\frac{v- \left( \frac{L}{2} \right) \omega }{r}$

In Matrixschreibweise:

$\left[ \begin{matrix} \omega _{l}\\ \omega _{r}\\ \end{matrix} \right] =\frac{1}{r}\cdot \left[ \begin{matrix} 1 & \frac{-L}{2}\\ 1 & \frac{L}{2}\\ \end{matrix} \right] \cdot \left[ \begin{matrix} v\\ \omega \\ \end{matrix} \right]$

Für unseren Rover, $L$ = 8,8 cm und $r$ = 4,5 cm. Unter Verwendung dieser Werte und der obigen Gleichungen berechnen wir, wie schnell jedes Rad gedreht werden muss, um den Rover mit einer gewünschten Vorwärtsgeschwindigkeit und Drehrate zu bewegen. Betrachten wir zwei einfache Szenarien:

1. Fahren Sie den Rover geradeaus mit 10 cm/s ($v$ = 10 cm/s, $\omega$ = 0 deg/s) $\omega_{r}$ = $\omega_{l}$ = 127.3 deg/s (einschließlich Einheitenumrechnungen)
2. Drehen Sie den Rover 180 Grad in 10 Sekunden mit null Vorwärtsgeschwindigkeit ($v$ = 0 cm/s, $\omega$ = 18 deg/s)

$\omega _{r} = 17.6 deg/s$, $\omega _{l} = -17.6 deg/s$ (includes unit conversions)

Das Ziel dieses Beispiels ist es, Sie bei der Implementierung der oben dargestellten Gleichungen mit Simulink zu unterstützen, die dann zum Antreiben des Rovers verwendet werden können. Wir haben ein Modell vorbereitet, in dem eine Reihe von Blöcken miteinander verbunden ist. Sie führen die in den obigen Gleichungen dargestellten Matrixoperationen aus und berechnen die Winkelgeschwindigkeiten für jeden der Motoren ($\omega_{r}$ und $\omega_{rl}$), die eine gewünschte lineare und Winkelgeschwindigkeit des gesamten Rovers aufweisen. Öffnen Sie das Modell, indem Sie den folgenden Befehl in MATLAB eingeben:

>> basicKin_sim

Die Blöcke auf der linken Seite sind konstante Blöcke, in denen Sie die gewünschte Rover-Geschwindigkeit und Drehrate angeben können. Die Blöcke auf der rechten Seite sind Anzeigeblöcke und zeigen die resultierenden $\omega_l$ und $\omega_{r}$ Werte.

Aber bevor Sie sich das Subsystem convToWheelVel ansehen, beachten Sie, dass L, r, und TS im Workspace definiert wurden.

Simulink verfolgt das Konzept der Model Callbacks. Diese werden verwendet, um MATLAB-Skripte oder Funktionen zu verschiedenen Zeiten aufzurufen. Dieses Modell verwendet den Callback PostLoadFcn, um ein MATLAB-Skript direkt nach dem Laden des Simulink Modells in den Speicher aufzurufen. Das hier aufgerufene Skript ist paramsBasicKinematics, und diese Variablen (L, r, und TS) sind in diesem Skript als konstante Werte definiert.

L und r sind die Abmessungen unseres Rovers, und TS ist die Probezeit des Modells. Die Samplezeit ist ein Parameter, der angibt, wann Ausgaben des Simulink Modells erzeugt werden sollen und gegebenenfalls, wann Blöcke während der Simulation aktualisiert werden sollen.

Sie können die Modellrückrufe anzeigen, indem File > Model Properties > Model Properties auswählen. Klicken Sie im Fenster Modelleigenschaften auf Click Callbacks, die wie unten gezeigt angezeigt wurden.

Öffnen wir nun das convToWheelVel Subsystem durch Doppelklick.

Hier sehen Sie die inports ($v$ und $\omega$) auf der linken Seite und die outports ($\omega_{l} (deg/s)$ und $\omega_{r} (deg/s)$) auf der rechten Seite. Der D2R Block neben dem Inport w wandelt Grad in Bogenmaß um, während die R2D Blöcke den umgekehrten Vorgang ausführen, bevor sie die resultierenden Daten an die Outports senden. Die dicken schwarzen Linien sind Mux- und Demux Blöcke; sie ermöglichen es uns, die Daten in Vektoren anzuordnen und bei Bedarf wieder in Skalare zu trennen. Dies ermöglicht es uns, eine Matrixmultiplikation mit dem ersten dreieckigen Gain Block (K*u) auf dem Vektor durchzuführen. Der zweite Gain Block multipliziert die Komponenten des resultierenden Vektors mit 1/r.

Dieses Subsystem berechnet $\omega_{l}$ und $\omega_{r}$ für eine bestimmte gewünschte Geschwindigkeit und Drehrate. Die in diesem Subsystem implementierten Gleichungen werden innerhalb des Modells als Referenz angezeigt. Dies ist eine Funktion in Simulink, mit der Sie Dokumentation in die Modelle selbst einbinden können. Das macht es einfacher, Ihre Arbeit mit anderen zu teilen.

Gehen wir zurück zum obersten Modell, indem wir wie unten gezeigt auf basicKin_sim klicken.

Versuchen Sie beispielsweise $v$ = 10 cm/s and $\omega$ = 0 deg/s und klicken Sie auf das Run-Symbol wie unten gezeigt. Simulink führt dann die Berechnung durch und aktualisiert das Display einmal alle 0,01 Sekunden, wie durch die Abtastzeit TS angegeben. Auf dem Display sollten Sie Ergebnisse sehen, die mit den zuvor berechneten Werten übereinstimmen, in diesem Fall: $\omega_{l} = \omega_{r}=127.3 deg/s$

Versuchen Sie es noch einmal mit v = 0 cm/s und w = 18 deg/sec und starten Sie das Modell erneut. Die Ergebnisse sind wieder konsistent und in diesem Fall:

$\omega _{l}=-17.6\frac{deg}{s}; \omega _{r}=17.6\frac{deg}{s}$

Im vorherigen Abschnitt wurde Simulink verwendet, um grundlegende kinematische Gleichungen des Rovers zu implementieren, aber das Modell berücksichtigte nicht die Position des Rovers in realen Koordinaten. Die Position (x, y) und Richtung ($\theta$) des Rovers in einem X-Y-Koordinatensystem kann mit den folgenden Gleichungen beschrieben werden:

$\theta \left( t \right) = \int _{0}^{t} \omega \left( t \right) dt~~ x \left( t \right) = \int _{0}^{t}v \left( t \right) \cdot cos\theta \left( t \right) dt~~~~~ y \left( t \right) = \int _{0}^{t}v \left( t \right) \cdot sin ⁡\theta \left( t \right) dt$

Schauen wir uns nun an, wie man mit Simulink diese Gleichungen implementiert und die Bewegung des Rovers im Laufe der Zeit simuliert. Öffnen Sie zunächst das kinEq_sim Modell aus MATLAB:

In diesem Modell sehen Sie, dass es anstelle einfacher konstanter Eingaben, die im Vorgängermodell vorhanden waren, jetzt Signal builder Blocks mit der Bezeichnung $v (cm/s)$ und $\omega (deg/s)$ gibt. Diese liefern Signale, die sich im Laufe der Zeit ändern zu convToWheelVel subsystem. Anstatt die Ergebnisse einfach anzuzeigen, werden sie als Eingang an das Rover Simulation subsystem weitergegeben, das das Verhalten des Rovers mathematisch modelliert und eine visuelle Simulation des Rovers erstellt, der sich um eine 100 cm x 100 cm "Arena" bewegt.

Doppelklicken Sie auf den v (cm/s) Block, um zu sehen, wie das Signal aussieht.

Das Signal sieht aus wie ein Schritt, der für die ersten fünf Sekunden eine Größe von 5 cm/s hat und dann auf 0 cm/s absinkt.

Das Signal für w (deg/s) ist ein Rechtecksignal, das zwischen 5 und 10 Sekunden eine Größe von 18 Grad/s und zu allen anderen Zeiten Null aufweist.

Da die Eingangssignale nach 10 Sekunden beide Null sind, wird die Simulationsstoppzeit wie unten gezeigt auf 11 Sekunden eingestellt.

Öffnen Sie das Rover Simulation subsystem. Es gibt zwei inports um die Winkelgeschwindigkeit jedes Rades einzubringen, und es gibt hier drei Subsysteme: die Encoder simulation, die Vehicle kinematics (Fahrzeugkinematik) und die Robot path plotter (Roboter-Pfadplotter) Modelle.

Das Encoder-Simulation subsystem wandelt die gewünschten Raddrehzahlen von Grad/s in Grad um, die vom Rad gedreht werden, um den Encoder auf Ihrem Rover nachzubilden. Um mehr über den tatsächlich verwendeten Encoder und sein Verhalten zu erfahren, lesen Sie bitte den Abschnitt 2.3.2.2.3.Lesen der Encoder in "2.3 Simulink Getting Started" zählt.

Das Subsystem Vehicle kinematics implementiert die zuvor vorgestellten Gleichungen für $\theta$(t), x(t) und y(t). Öffnen Sie dieses Subsystem. An dieser Stelle wissen Sie genug über Simulink, um mehr Informationen über jeden einzelnen der Blöcke zu finden. Lassen Sie sich so viel Zeit wie nötig, um zu verstehen, wie sich die Gleichungen in die folgenden Blockdiagramme umsetzen lassen. Im Wesentlichen werden Sie sehen, dass die outports das Ergebnis von Integrationsoperationen sind, und die outports sind die Ausrichtung des Rovers und seiner x- und y-Koordinaten.

Im vehiclePath MATLAB Funktions Block sehen Sie, wie die Gleichungen hier umgesetzt werden. Ein MATLAB FunktionsBlock ermöglicht die Integration von MATLAB-Code in Simulink Modelle.

Navigieren Sie zurück zur Subsystem Rover Simulation und öffnen Sie das Subsystem Robot path plotter.

Sie werden sehen, dass es neben den Eingängen einen konstanten Block gibt, der den Wert 5 an den MATLAB Funktions Block sendet. Hiermit wird die Trajektorie des Roboters gezeichnet. Öffnen Sie den plotRobot MATLAB Funktions Block, um zu sehen, wie man den Pfad des Roboters x, y und $\theta$ mit der Zeit ändert.

Sobald Sie mit der Funktionsweise des Modells vertraut sind, klicken Sie auf Run.

Sie werden sehen, wie sich der Rover 11 Sekunden lang in der 100 cm x 100 cm großen Arena bewegt. Die Simulation basiert auf einer Ausgangsposition von StartX = 50 cm, StartY = 20 cm und StartTheta = 90 deg. Diese Variablen wurden früher im Workspace durch das Modell Callback PostLoadFcn definiert, wie Sie es im Vorgängermodell gesehen haben. Insgesamt bewegte sich der Rover 25 cm in y-Richtung und drehte sich dann um 90 Grad, basierend auf den Eingängen des Signal Builder.

Sobald Sie die Simulation ausprobiert haben, ist es an der Zeit, den Rover dazu zu bringen, das gleiche Manöver in der realen Welt durchzuführen. Wir haben für Sie ein Simulink Modell vorbereitet, um schnell zu sehen, wie das funktionieren könnte. Öffnen Sie das Modell roverOpenloop_hw aus MATLAB:

Dieses Modell ähnelt dem im vorherigen Abschnitt. Allerdings werden die Ausgänge nicht an ein mathematisches Modell des Rovers gesendet, sondern an die Motoren, die auf dem realen Rover montiert sind.

Die Eingangssignale und das Subsystem convToWheelVel sind die gleichen wie beim Vorgängermodell, aber die Drehzahlen werden direkt an die eigentlichen Motoren gesendet, die als Blöcke im Modell dargestellt werden.

Die Blöcke LeftMotor and RightMotor stammen aus der Bibliothek Simulink Support for Arduino MKR Motor Carrier, wie unten gezeigt.

Wie in Abschnitt 2.2.3 beschrieben, sollte der Eingang zu den Motorblöcken ein PWM-Signal und nicht eine Solldrehzahl sein. Innerhalb der Subsysteme LeftMotor and RightMotor werden also die vorgegebenen Drehzahlen mit neuen Motorcharakterisierungsdaten in PWM umgewandelt. Der Grund für die Notwendigkeit neuer Charakterisierungsdaten ist die Motorcharakterisierung in Abschnitt 2.2.3 in "2.2 MATLAB Getting Started". Diese wurde durchgeführt, als sich die Räder des Rovers frei in der Luft drehten. Die neue Motorcharakterisierung wurde ermittelt als sich der Rover auf dem Boden bewegte und der Akku mit vollem Ladegerät ausgestattet war. Die bereitgestellten Daten (Data.xlsx) für den Rover zeigen den Zusammenhang zwischen PWM-Wert und der vorgegebenen Motordrehzahl. Dies wird durch den Block Lookup table innerhalb der Subsysteme LeftMotor and RightMotor dargestellt.

Überprüfen Sie die Portnummern, die von den DC-Motorblöcken in den Subsystemen LeftMotor und RightMotor angegeben werden, um sicherzustellen, dass die Anschlüsse für den rechten und linken Motor Ihres Rovers mit den in diesen Blöcken angegebenen übereinstimmen. Das folgende Bild zeigt den DC-MotorBlock innerhalb des RightMotor Subsystems.

Wichtig: Verbinden Sie Ihren Rover über das USB-Kabel mit dem Computer, ohne den Akku einzuschalten.

Drücken Sie die Schaltfläche Deploy to Hardware im Modellfenster Toolstrip. Dadurch wird das Code-Äquivalent Ihres Modells erzeugt und auf den Arduino MKR1000 hochgeladen. So wird sichergestellt, dass der Rover den Code auf dem Board ausführen kann, selbst wenn er vom Computer getrennt ist.

Trennen Sie das USB-Kabel vom Rover und legen Sie den Rover auf den Boden oder eine andere Fläche, wo er genügend Platz zum Bewegen hat. Der Rover ist zerbrechlich, und er könnte beschädigt werden, wenn er von Ihrem Schreibtisch fällt.

Schalten Sie den Rover ein (mit der Batterie) und messen Sie die Entfernung, die er auf dem Boden zurücklegt. Ihr Ziel ist es, zu überprüfen, ob die realen experimentellen Bedingungen das wiederholen, was Sie zuvor im Modell simuliert haben.

Erinnern wir uns, dass sich der Rover in der Simulation um 25 cm in y-Richtung bewegt und dann um 90 Grad gedreht hat. Hat der echte Rover das Gleiche getan?

Sie werden wahrscheinlich sehen, dass er das nicht hat. Im Allgemeinen ist es sehr schwierig, Ihr System mit Hilfe der Open-Loop-Steuerung genau zu steuern, es sei denn, Sie haben ein sehr genaues Modell Ihres Motorverhaltens und Ihrer Betriebsumgebung. In unserem Fall war die Motorcharakterisierung nicht konsequent genug und es wurde eine einfache Beziehung zwischen PWM und Motordrehzahl verwendet. Selbst wenn die Charakterisierung konsequent wäre, gäbe es Probleme, wenn Sie den Rover auf einer anderen Oberfläche als der für die Motorcharakterisierung verwendeten Oberfläche betreiben wollen, oder wenn die Batterie nicht mit der gleichen Spannung arbeitet

In der nächsten Übung werden Sie sehen, wie die closed-loop Steuerung dazu beiträgt, die Einschränkungen zu beseitigen, die bei der open-loop Steuerung auftraten. Dadurch ermöglicht die closed-loop Steuerung eine wesentlich genauere Steuerung der Rover-Position.

• Wir haben gesehen, wie man kinematische Gleichungen und inverse Kinematik verwendet, um die Roverbewegung zu simulieren.

• Wir haben gesehen, wie man dieses Verständnis übersetzt, um den Rover in der realen Welt zu kontrollieren.

• Wir haben gesehen, dass die mathematische Modellierung optimiert werden muss, um den realen Bedingungen besser gerecht zu werden.

• basicKinsim.slx

• kinEqsim.slx

• roverOpenloophw.slx

• roverMotorshw.slx

• Data.xlsx

Versuchen Sie, die Eingangssignale im Signal Builder Block mit verschiedenen Kombinationen von v und w zu aktualisieren. Können Sie den Rover in einem Kreis bewegen oder einer bestimmten Bewegungsabfolge fahren lassen (z.B. nach vorne 20 cm in y-Richtung, nach vorne 90 Grad, nach vorne 20 cm in x-Richtung)?

In dieser Übung wird Simulink verwendet, um einen PI-Regler zu implementieren, der den vom Rover bewegten Abstand steuert. Sie werden lernen, wie Sie die Encoderdaten der Räder des Rovers lesen und diese Daten als Rückmeldung an Ihre Steuerung verwenden können. Sie werden auch lernen, wie Sie die PI-Werte des Reglers einstellen, um die Leistung zu optimieren.

In dieser Übung werden Sie außerdem Folgendes lernen:

• Grundlagen eines PI-Reglerdesigns und damit auch der PID-Regler.

• Lesen von Encoderdaten.

• Abstimmen der Parameter eines Controllers in Simulink.

• Implementieren einer Steuerung auf dem Rover.

Ein PID Regler (proportional-integral-derivative controller) ist ein Regelkreis-Rückführmechanismus, der in Systemen verwendet wird, die eine kontinuierlich modulierte Regelung erfordern. PID-Regler arbeiten mit dem Fehlerterm der Differenz zwischen tatsächlichem und gewünschtem Verhalten. Sie wenden eine Korrektur auf Ihr System an, die auf den mit dem Fehler verbundenen Proportional-, Integral- und Derivatbedingungen basiert. Dies hat den Effekt, dass Korrekturen für den vergangenen Fehler (I), den aktuellen Fehler (P) und den zukünftigen Fehler (D) vorgenommen werden. Die Korrektur wird durch die Gleichung beschrieben:

$u=Kp\cdot e+Ki\cdot \int _{}^{}e dt+Kd\cdot\frac{de}{dt}$

Wo Kp (im PID Controller Block von Simulink wird dies durch den Buchstaben P dargestellt), Ki (I) und Kd (D) sind Konstantenkoeffizienten, die das System definieren. In dieser Übung werden einige Konzepte vorgestellt, die mit der PID-Regelung im Rahmen des Mobile Rover-Projekts verbunden sind. Weitere Informationen finden Sie unter diesem link.

In Übung 2 wurden die Einschränkungen der Verwendung der Open-Loop-Steuerung zur Steuerung der Position des Rovers erwähnt. Lassen Sie uns sehen, wie die PID-Regelung im geschlossenen Regelkreis diese Einschränkungen beseitigen kann. Öffnen Sie zunächst das Modell distanceClosedloop_hw:

Die rechte Seite dieses Modells ist die gleiche wie das Modell roverOpenloop_hw aus der vorherigen Übung. Der Unterschied besteht darin, dass die Geschwindigkeitseingabe an das convToWheelVel Subsystem nun auf dem Fehlerterm zwischen dem tatsächlichen und dem gewünschten Abstand des Rovers basiert. Die Herausforderung besteht darin, den tatsächlichen Abstand mit Hilfe einer Abtastvorrichtung am Rover zu bestimmen. In diesem Fall können die DrehEncoder gleich verwendet werden, wie Sie später sehen werden.

Um das Steuerungsdesign in der Anfangsphase zu vereinfachen, betrachten wir den Rover, der sich in einer geraden Linie bewegt. In diesem Fall ist die vorgegebene Drehrate für den Rover Null. Im nächsten Abschnitt erfahren Sie, wie Sie den Drehwinkel des Rovers steuern können.

Der gewünschte Abstand wird mit dem Signal Builder Block festgelegt. Doppelklicken Sie auf diesen Block und öffnen Sie ihn. Beachten Sie, wie die angegebene Schritt-Eingabe von 25 cm bei 5 Sekunden erfolgt. Das folgende Bild zeigt das Zeitdiagramm für das Signal.

Wie bereits erwähnt, ist der Sensor, der die vom Rover zurückgelegte Strecke bestimmt, der Encoder. Der gemessene Abstand vom Messgerät wird in das Modell im Subsystem mit der Bezeichnung Actual distance eingelesen. Öffnen Sie dieses Subsystem und beobachten Sie die verschiedenen Blöcke, aus denen es besteht.

Es gibt zwei Subsysteme: RightEncoder und LeftEncoder. Die Ausgänge dieser Subsysteme werden in einem Vektor angeordnet. Dann werden sie mit einer Konstanten multipliziert, um die Encoderwerte in Entfernung umzuwandeln. Die Konstante basiert auf den Eigenschaften des Systems, nämlich dem Radius des Rades. Das Ergebnis wird zu einem Durchschnitt berechnet und an den Verzerrungsausgang gesendet.

Die Blöcke RightEncoder und LeftEncoder lesen Zähldaten von den Encodern des Rades und wandeln diese in Grad um. Um Encodergrade in den von den Rädern bewegten Abstand umzuwandeln, werden die folgenden Gleichungen verwendet:

$dr=\frac{ 2\cdot \pi \cdot r \cdot RWD}{360};dl=\frac{2\cdot \pi \cdot r\cdot LWD}{360}$

Hier bezeichnen $dr$ und $dl$ die Entfernung, die durch das rechte bzw. linke Rad bewegt wird, und r ist der Radradius.

Navigieren Sie zurück zum obersten distanceClosedloop_hw Modell und beobachten Sie, wie der Fehler als Differenz zwischen gewünschter und tatsächlicher Entfernung berechnet wird. Dieser wird als Eingang für den PID-Regler verwendet.

Öffnen Sie den Block PID Controller und beachten Sie, dass standardmäßig ein einfacher P controller verwendet wird, da die Integral- und Ableitungsbegriffe ($Ki$ und $Kd$) beide Null sind.

Sie werden dies auf dem Rover mit dem external mode von Simulink testen. Im externen Modus erstellt Simulink aus dem Modell eine ausführbare Datei und lädt sie auf den Arduino. Die Verbindung mit Simulink bleibt erhalten, da die ausführbare Datei auf der Hardware läuft, so dass Sie Parameter einstellen und interessante Signale mit Hilfe von Scope Blöcken überwachen können. Weitere Informationen zum externen Modus finden Sie unter 2.3.2.2.2 Betreiben eines DC Motors unter "2.3 Simulink Getting Started".

Stellen Sie sicher, dass der Simulationsmodus auf Extern eingestellt ist und die Stoppzeit der Simulation 30 Sekunden beträgt.

Für die Bequemlichkeit und um Ihnen zu helfen, einige der Konzepte hinter der PID-Regelung zu erlernen, setzen Sie zunächst den Rover auf das Ziel oder eine andere Plattform, die es ermöglicht, dass sich die Räder frei drehen können. Ihr Rover muss über das USB-Kabel mit dem Computer verbunden sein, d.h. er kann sich nicht weit bewegen. Schalten Sie die Rover-Batterie ein, da die Motoren dort ihre Energie herbekommen.

Führen Sie das Simulink Modell aus. Nach dem Herunterladen des Codes auf den Arduino öffnet sich der Scope Block automatisch. Dies trägt dazu bei, die gewünschte und aktuelle Position zu visualisieren während die Datei ausgeführt wird.

Das Ergebnis des Scopes zeigt in diesem Fall den gewünschten Abstand in Gelb und den tatsächlichen Abstand in Blau. Sie können sehen, dass es eine kleine Diskrepanz zwischen ihnen gibt. PID-Regler versuchen, diese Fehler zu kompensieren.

Vergrößern Sie die x-Achse, um einen genaueren Blick auf die Sprungantwort zu werfen. Klicken Sie dazu auf die Lupe in der Symbolleiste und wählen Sie den Bereich, den Sie vergrößern möchten, indem Sie auf die Grafik klicken und sie wie unten gezeigt ziehen.

Die Zeit, die benötigt wird, um 90% des Sollwertes zu erreichen, heißt Anstiegszeit . Für P = 1 beträgt die Anstiegszeit ca. 1,25 Sekunden. Angesichts der spezifischen Eigenschaften des Rovers wird eine langsamere Anstiegszeit bevorzugt. Sie können den Rover in kleinen Bereichen einsetzen und im Allgemeinen will man nicht, dass sich der Rover zu schnell bewegt, da er sonst vom Boden abheben könnte. Das können Sie üben, indem Sie selbst mit dem Rover experimentieren.

Die folgende Referenztabelle zeigt, wie sich die Erhöhung der Gewinne P (Kp), I (Ki) und D (Kd) auf die wichtigsten Merkmale der Systemantwort auswirkt.

Bitte beachten Sie, dass weder kein overshoot noch steady-state error(Überschwingen oder Schrittzustandsfehler )eingeführt wurde. Sie werden in den folgenden Abschnitten diskutiert.

Basierend auf der vorherigen Tabelle sollten Sie zur Erhöhung der rise time den P-Wert verringern. Ändern Sie den P-Wert im Controller Block auf 0. 01, wählen Sie OK und drücken Sie dann Run.

Dadurch wurde die Anstiegszeit auf 9 Sekunden erhöht und gleichzeitig der steady-state error (Schrittzustandsfehler) signifikant erhöht. Diese ist als Differenz zwischen Soll- und Istwert einer Variablen definiert, wenn das System ein Gleichgewicht erreicht hat.

Basierend auf der Tabelle hilft das Hinzufügen eines Integral Terms zum Controller, den stationären Fehler zu verringern. Öffnen Sie den PID-Regler Block, wählen Sie PI in der Dropdown-Liste Regler und geben Sie einen integralen Verstärkungswert (I) von 0 ein. 002 . Es ist eine gute Faustregel, immer darauf zu achten, dass der P-Wert höher als der I-Wert ist.

Klicken Sie auf Apply und dann auf Run your Simulink model. Ihr Bereich sollte so aussehen.

Die Einführung des I-Wertes reduzierte stationäre Fehler signifikant, aber Sie können sehen, dass es noch einen weiteren Effekt eingeführt hat, genannt overshoot. Dieser overshoot wird auf ca. 6 cm gemessen. Dies ist in unserem Fall unerwünscht, da der Rover an der Zielposition vorbeifährt und dann beim Versuch, seine Position zu korrigieren, schwingt.

Unter Bezugnahme auf die Tabelle können Sie den P- und I-Wert erhöhen, um overshoot zu vermeiden.

Versuchen Sie, die P- und I-Werte mit Trial-and-Error zu erhöhen, bis Sie ein gutes Gleichgewicht zwischen rise time, Schrittzustand Fehler und oversthoot in Ihrem Modell erreichen.

Trennen Sie nun das an den PC angeschlossene USB-Kabel und bewegen Sie Ihren Rover auf den Boden, um zu überprüfen, wie die Steuerung funktioniert. Schließen Sie den Akku an und messen Sie, wie weit er sich bewegt. Bewegt er sich die erwarteten 25 cm?

Sie werden wahrscheinlich feststellen, dass es sich um eine Bewegung von 25 cm handelt, aber Sie müssen die PID-Werte an die neuen Betriebsbedingungen anpassen (d.h. die Räder sind nicht frei drehbar, wenn sie auf dem Boden stehen). Die genauen Werte hängen von der von Ihnen verwendeten Oberfläche ab. Bei mehreren Tests auf relativ harten, teppichbeschichteten Oberflächen wurde festgestellt, dass P = 0,2 und I = 0,001 einen guten Ausgangspunkt darstellen. In einigen Tests gaben diese Werte einen overshoot und Schrittzustand Fehler von jeweils etwa 0,2 cm an.

In der nächsten Übung werden Sie sehen, wie Sie Überschwemmungen und Schrittzustandsfehler durch logikbasierte Programmierung und Zustandsübergänge beseitigen können.

Dieser Abschnitt ergänzt den vorherigen, in dem es darum ging, dass sich der Rover über eine bestimmte Strecke in einer bestimmten Zeitspanne über eine Linie bewegt. In diesem Fall werden Sie sich darauf konzentrieren, eine ähnliche Kontrolle über die Drehbewegung des Rovers zu erlangen.

In der vorherigen Übung sahen Sie die Gleichungen, um Encodergrade in die zurückgelegte Entfernung umzuwandeln:

$dr=\frac{ 2\cdot \pi \cdot r \cdot RWD}{360};dl=\frac{2\cdot \pi \cdot r\cdot LWD}{360}$

Die Gleichung, um den vom Rover verschobenen Winkel zu erhalten, ist:

$angle=\frac{dr-dl}{L}$

Um den PI-Regler für den Drehwinkel des Rovers zu konstruieren, können Sie den gleichen Ansatz verwenden, der auch für die Steuerung der vom Rover bewegten Strecke verwendet wurde. Öffnen Sie das Modell angleClosedloop_hw:

Sie können die Analogie zwischen diesem Modell und dem vorherigen sehen. In diesem Fall wird die Lineargeschwindigkeit konstant gehalten (Null), während die Drehgeschwindigkeit mit dem Block PID Controller gesteuert wird. Diesmal wird nicht der Abstand als Eingang verwendet, sondern der Winkel des Rovers. Diese Daten werden auch vom Encodersensor unter Verwendung der obigen Gleichung erhalten. Wenn Sie mehr darüber erfahren möchten, wie die Daten erfasst werden, öffnen Sie das Subsystem Actual angle und schauen Sie es sich genauer an.

Öffnen Sie den Block PID-Regler und notieren Sie die PI-Werte. Diese Werte von P = 3 und I = 1 waren ein guter Ausgangspunkt für die Tests, die wir bei der Versuchsplanung durchgeführt haben. In unserem Fall bewegte sich der Rover auf einer relativ harten, mit Teppichen ausgelegten Oberfläche. Beim Einsatz sollte sich der Rover in einem Kreis um sich selbst drehen und versuchen, 90 Grad zu erreichen.

Führen Sie das Modell mit Ihrem Rover auf dem Boden aus und stimmen Sie die PI-Werte nach Bedarf ab, bis Sie mit der Leistung unter den Bedingungen Ihres Versuchsaufbaus zufrieden sind, wie im vorherigen Abschnitt.

• Wir haben gesehen, wie man PID-Regler entwickelt, um die Position und den Winkel des Rovers zu steuern.

• Wir haben gesehen, wie man den externen Modus verwendet, um die Verstärkung von P, I und D durch Trial-and-Error in Simulink einzustellen und die Ergebnisse mit dem Scope Block zu überwachen.

• distanceClosedloophw.slx

• angleClosedloophw.slx

Implementieren Sie einen PID-Regler und verstehen Sie, wie sich der Differentialterm auf Ihre Reglerleistung auf verschiedenen Oberflächen auswirkt.

Nachdem Sie nun gelernt haben, wie man einen geschlossenen PID-Regler auf dem Rover implementiert, lassen Sie uns sehen, wie man den Rover dazu bringt, einer Reihe von Pfadanweisungen zu folgen. Simulink und Stateflow werden verwendet, um den Rover anzuweisen, eine bestimmte Strecke vorwärts zu fahren und sich um eine bestimmte Gradzahl zu drehen. Wir werden auch sehen, wie die Zustandslogik unerwünschte Effekte wie steady state error und overshoot Ihrer Steuerung beseitigen kann.

In dieser Übung werden Sie Folgendes lernen:

• Verwenden Sie bestimmte Zustände, um Ihren Rover so zu programmieren, dass er einer Reihe von Pfadanweisungen folgt.

• Verwenden Sie die Zustandslogik, um steady state error und overshoot Ihres PI-Reglers zu vermeiden.

• Verstehen Sie die Logik des Zustands.

Damit Sie mit dem Experimentieren beginnen können, wird ein Modell mit der Zustandslogik zur Verfügung gestellt, das zur Steuerung des Rovers erforderlich ist. Öffnen Sie zunächst das Modell kinEq_states_sim.slx:

Dieses Modell führt eine Simulation der Bewegung des Rovers durch. Es hat die Subsysteme convToWheelVel und Rover Simulation sowie das StateLogic Diagramm. Die Ausgänge der Rover-Simulation, Entfernung und Winkel werden der Zustandslogik im Modell zugeführt, wodurch eine Rückkopplungsschleife entsteht.

Dieses Modell verwendet das gleiche convToWheelVel Subsystem aus früheren Übungen, um Radgeschwindigkeiten basierend auf der gewünschten Rover-Geschwindigkeit und Drehrate zu berechnen, die aus dem StateLogic Diagramm bereitgestellt werden.

Das Subsystem Rover Simulation hat eine Modifikation gegenüber den vorherigen Übungen. Funktionell ist es immer noch gleich, aber jetzt gibt es auch Werte für Roverabstand und Winkel aus.

Diese Werte (Abstand und Winkel) werden in das Stateflow Chart eingegeben, das durch das StateLogic Chart dargestellt wird. Dieses berechnet die Geschwindigkeit und die Rotationsrate des Rovers.

Bevor Sie das Diagramm öffnen, sollten Sie sich mit Stateflow vertraut machen. Stateflow ist ein Softwarepaket, das MATLAB und Simulink um Werkzeuge zur Modellierung von Logik und ereignisgesteuerten Systemen erweitert. Dieses Beispiel stellt wesentliche Aspekte von Stateflow im Rahmen des Rover-Projekts vor. Wenn Sie Stateflow weiter erkunden möchten, können Sie sich das Stateflow Übersichtsvide und andere dazugehörige Videos.

Öffnen Sie das StateLogic Diagramm mit einem Doppelklick. Sie werden eine andere Art von Blockdiagramm sehen, in dem die verschiedenen Schritte, die auf dem Rover auszuführen sind, in abgerundeten Kästen angezeigt werden. Diese werden states genannt und werden sequentiell angezeigt. Sie haben eine Übergangsbedingung, die durch einen Pfeil am Ausgang jeder Box angezeigt wird. Diese verschiedenen Ereignisse können entweder zeitlicher Natur sein (z.B. Verlassen des Blocks nach einer bestimmten Zeit) oder boolesche Anweisungen (z.B. Vergleich verschiedener Variablen mit einer Konstanten).

Dieses Stateflow Diagramm hat fünf Zustände, die jeweils einer Betriebsart des Rovers entsprechen. Wenn activ, wird der Inhalt des Zustands sequentiell ausgeführt.

Der Rover befindet sich zu Beginn der Simulation im Zustand StopFirst. In diesem Zustand werden die Rover-Geschwindigkeit und -Drehzahl auf Null gesetzt, so dass sich der Rover nicht bewegt.

Dieser Zustand wird inaktiv, wenn die Übergangsbedingung erfüllt ist, in diesem after(1, sec). Die Übergangsbedingung wird bei jedem Zeitschritt der Simulation getestet, der durch die Abtastzeit gekennzeichnet ist.

Eine Sekunde nach der Simulation geht der Rover in den Zustand MoveForward über, wo er eine bestimmte Strecke vorwärts fährt. Der entry Aktion wird unmittelbar nach Eintritt in diesen Zustand ausgeführt, und hier wird der desDist auf 30 cm gesetzt. Die Eingangsbedingung kann als "Setup"-Code für jeden Zustand betrachtet werden; der entry Code läuft vor allem anderen in der Grafik angeführten, sobald der Zustand aktiv wird.

Nach der entry Phase und solange dieser Zustand aktiv ist, werden die Befehle in der Aktion during ausgeführt. Der Code für during kann als Basis einer "for"Loop betrachtet werden. Wenn der Zustand dann inaktiv wird, werden die Exit-Befehle ausgeführt. Die Simulink Function distCtrl wird aufgerufen, die den in der vorherigen Übung entwickelten PI-Regler implementiert. Eine Simulink Funktion ist eine Funktion, die über Simulink Blöcke definiert ist und zu jedem Zeitpunkt aus Stateflow Diagrammen oder anderen Simulink Modellen aufgerufen werden kann.

Zum Übergang aus dem MoveForward Zustand muss die nächste Übergangsbedingung erfüllt sein: abs(desDist - dist) < 0.1

Dies legt fest, dass der Rover, wenn er innerhalb von 0,1 cm des gewünschten Abstandes liegt, in den nächsten Zustand übergehen soll. Beachten Sie, dass, wenn Ihr PID-Regler overshoot im Abstandsverhalten des Rovers erzeugt, diese eliminiert wird, da der Rover beim ersten Mal, wenn er innerhalb von 0,1 cm zum gewünschten Abstand kommt, in den nächsten Zustand übergeht, und jegliches Schwingungsverhalten eliminiert wird.

Nach 30 cm vorwärts ist der nächste Zustand des Rovers Pause. Der Rover ist in diesem Zustand stationär, aber nur für 1 Sekunde, wenn die nächste Übergangsbedingung erfüllt ist.

Nach Pause geht der Rover in den Kurvenzustand. Dieser Zustand ist wie der MoveForward Zustand, nur dass der Rover anstatt 30 cm vorwärts zu fahren, angewiesen wird, sich um 180 Grad zu drehen. Dieser Zustand verwendet die Simulink Function angCtrl, die den PI-Regler implementiert, der im Modell angleClosedloop_hw entworfen wurde. Sobald der Rover-Winkel innerhalb von 0,1 Grad des gewünschten Winkels liegt, wechselt der Rover in den Stop Zustand.

Führen Sie eine Simulation des Modells durch, um zu sehen, wie der Rover durch die Zustände voranschreitet. Klicken Sie dazu im Diagramm StateLogic auf die Schaltfläche Ausführen in der Symbolleiste, wie in der folgenden Abbildung dargestellt.

Zu Beginn der Simulation sehen Sie die verschiedenen Zustände hervorgehoben, wenn sie aktiv werden.

Nachdem Sie das Verhalten des Rovers simuliert haben, um der Reihenfolge der Anweisungen zu folgen, stellen wir die Anwendung auf den aktuellen Rover um. Verbinden Sie Ihren Rover über das USB-Kabel mit dem PC und öffnen Sie das Modell roverClosed_states_hw.slx, indem Sie Folgendes eingeben:

Diesmal hat das Modell die Motoren auf der rechten Seite und die Winkel- und Abstandsinformationen werden in das Stateflow Diagramm auf der linken Seite des Diagramms eingegeben.

Dieses Modell ist wie das Simulationsmodell, hat aber einige wesentliche Unterschiede:

• Die Eingabe in das StateLogic Diagramm ist nun der tatsächliche Abstand und Winkel des Rovers, gemessen von den Encodern.
• Die im Subsystem convToWheelVel berechneten Drehzahlen ($\omega_l$ ,$\omega_r$) sind die Eingaben für die eigentlichen Motoren.

Bevor Sie dieses Modell auf dem Rover betreiben, passen Sie die PI controller gains inside StateLogic an Ihre Designs aus der vorherigen Übung an.

Klicken Sie auf die Schaltfläche Deploy to Hardware, um den Code auf den Arduino MKR1000 zu laden.

Sobald die Übertragung abgeschlossen ist, stellen Sie den Rover auf den Boden und schalten Sie ihn mit den Batterien ein. Beobachten Sie, wie genau Ihr Rover die im Diagramm StateLogic angegebene Reihenfolge einhält.

Wir haben ein vorgefertigtes Modell zur Verfügung gestellt, das zeigt, wie man beide Controller aktiviert. Um dieses Modell zu öffnen, geben Sie roverClosedBoth_states_hw.slx im MATLAB Command Window ein. In diesem Modell untersuchen Sie die Zustände MoveForward und Turn im StateLogic Diagramm, um die Implementierung zu verstehen. Denken Sie daran, dass Sie auch den externen Modus verwenden können, um jedes Problem zu debuggen, auf das Sie stoßen.

• Wir haben gesehen, wie man Zustände verwendet, damit Ihr Rover einer Pfadsequenz folgt.

• Wir haben gesehen, wie man Zustände verwendet, um Ihren Controller zu deaktivieren, wodurch Überschwinger und stationäre Fehler des Controllers beseitigt werden.

• kinEq_statessim.slx

• roverClosed_states_hw.slx

• roverClosedBoth_states_hw.slx

Erweitern Sie die im StateLogic Chart angegebenen Pfadanweisungen und beobachten Sie, wie sich der Rover verhält.

Bei der Arbeit mit Rovern ist es oft wichtig, deren Standort zu kennen, während sie sich bewegen. Diese Übung zeigt, wie man eine Webcam mit einem Lokalisierungsalgorithmus verwendet, um die Position und den Kurs des Rovers zu berechnen. Um sicherzustellen, dass der Rover im Sichtfeld der Webcam bleibt, wird die Bewegung des Rovers innerhalb einer bestimmten "Arena" eingeschränkt. Beginnen Sie mit dem Bau der Arena und führen Sie dann einige Kalibrierschritte durch, um die für Ihre Einrichtung spezifischen Bedingungen zu berücksichtigen (z.B. Beleuchtung oder Standort der Webcam in Bezug auf die Arena). Dann werden Sie lernen, wie der Lokalisierungsalgorithmus funktioniert und ihn verwenden, um die Position und den Kurs des Rovers innerhalb der Arena zu berechnen. Dies wird auch verwendet, um das Ziel zu lokalisieren, das der Rover mit seinem Gabelstapler bewegt.

In dieser Übung werden Sie Folgendes lernen:

• Richten Sie die Betriebsumgebung des Rovers ein und kalibrieren Sie sie.

• Verwenden Sie die Lokalisierung, um die Position und Ausrichtung des Rovers zu berechnen.

Das folgende Bild zeigt eine exemplarische Arena für den Rover, die aus einem Whitepaper und einem schwarzen Marker besteht. Auf dem Bild sehen Sie auch den Rover. Dies kann Ihnen eine Vorstellung von den Proportionen geben und darüber, wie groß oder klein Ihre Arena sein kann.

Die Hauptanforderung an Ihre Arena ist, dass sie einen weißen Hintergrund haben muss. Sie können mit einem weißen Poster oder mit mehreren zusammengehefteten Blättern bauen.

Die Größe der Arena ist flexibel, muss aber in das Sichtfeld Ihrer Webcam passen. Der Lokalisierungsalgorithmus erfordert, dass die Webcam mindestens 100 cm (ca. 3,5 Fuß) über der Arena platziert wird. Richten

Sie Ihre Webcam über dem Bereich ein, in dem Sie Ihre Arena bauen. In Matlab rufen Sie den Videofeed auf, indem Sie die folgenden Befehle ausführen:

Passen Sie die Position der Webcam sowie die Größe und Platzierung der Arena an, bis sie in das Sichtfeld passt, wie im Bild unten gezeigt.

Sie können größere Arenen aufnehmen, wenn Sie die Webcam weiter weg bewegen. Jedoch wird zu einem bestimmten Zeitpunkt die Genauigkeit des Lokalisierungsalgorithmus beeinträchtigt. Aus früheren Tests ging hervor, dass eine Arenengröße von 75 cm x 75 cm, die sich innerhalb von 450 cm (ca. 15 Fuß) von der Webcam befindet, gut funktioniert.

Wenn Sie Ihre Arena bauen, achten Sie darauf, dass der weiße Hintergrund über die tatsächliche Größe der Arena hinausgeht. Nach unseren Erfahrungen ist für den Bildverarbeitungsalgorithmus ein zusätzlicher Rand von ca. 5 cm erforderlich. Dadurch wird sichergestellt, dass zwischen dem Fußboden und der Arena ein gewisser Puffer vorhanden ist.

Markiere die Ecken der Arena, die Mittelpunkte aller Kanten und den gesamten Mittelpunkt mit einem X, das aus mindestens 100 cm Entfernung sichtbar ist (wie im Bild gezeigt). Hier wurde ein schwarzer Marker verwendet.

Vergewissern Sie sich noch einmal, dass sich die Webcam mindestens 100 cm über der Arena befindet und sich die gesamte Arena im Sichtfeld befindet. Der nächste Schritt ist die Kalibrierung des Bildverarbeitungsalgorithmus.

Das roverCalibration Skript besteht aus fünf Schritten, um die vom Lokalisierungsalgorithmus benötigte Kalibrierung durchzuführen. Öffnen Sie das Skript und führen Sie die einzelnen Schritte aus.

Der Abschnitt "Step 1: Prepare the MATLAB Workspace" des Skripts hilft beim Löschen vorhandener Variablen und beim Schließen offener Figuren. Klicken Sie auf Ausführen und Erweitern, um diesen Code auszuführen und zum nächsten Abschnitt zu gelangen.

Damit die Kalibrierung funktioniert, muss der Algorithmus die Abmessungen der Arena kennen. Geben Sie die Höhe und Breite Ihrer Arena in " Step 2: Enter the arena's dimensions " wie unten gezeigt ein. Die Einheiten müssen in Zentimetern angegeben werden.

Klicken Sie nach der Eingabe der Abmessungen auf Run und Advance.

In " Step 3: Initialize the webcam and compute the transformation that gives the orthogonal view, " wird die Webcam initialisiert. Später wird die Transformation berechnet, die die orthogonale Ansicht des Rovers ergibt. Um Ihre Webcam auszuwählen, können Sie die diese im Live-Skript wie unten gezeigt auswählen.

Betrachten wir nun den Transformationsabschnitt dieses Schrittes. Normalerweise ist es schwierig, die Webcam direkt über der Arena zu platzieren, und stattdessen wird die Kamera dort platziert, wo sie Bilder aus einem gewissen Abwärtswinkel aufnimmt. Die Bildverarbeitung kann verwendet werden, um das Bild zu korrigieren. Das macht es unseren Lokalisierungsalgorithmus einfacher, die Position zu berechnen. Führen Sie diesen Abschnitt aus, indem Sie auf die Schaltfläche Run und Advance klicken, um zu sehen, welche Auswirkungen dies auf das Bild hat. Befolgen Sie die Anweisungen im MATLAB Command Window.

Das Webcam-Bild wird angezeigt. Um die Transformation des Bildes zu berechnen, klicken Sie auf die vier Ecken der Arena im Bild.

Wichtig: Stellen Sie sicher, dass sich der Rover in der Arena befindet. Wenn nicht, müssen Sie diesen Abschnitt des Codes noch einmal mit dem Rover in der Arena ausführen.

Wenn Sie sich das transformierte Bild ansehen möchten, führen Sie in MATLAB den folgenden Befehl aus:

Da die Webcam Bilder aus einem Winkel aufnimmt, ändert sich die Höhe des Rovers über verschiedene Entfernungen unterschiedlich. Schritt 4 wurde in "Step 4a Compute the location offset for the rove " (Berechnen des Positionsversatzes für den Rover) und "Step 4b: Compute the location offset for the target" (Berechnen Sie den Positionsversatz für das Ziel) aufgeteilt. In Schritt 4a werden Sie Bilder des Rovers an den vier Rändern der Arena (TOP, BOTTOM, LINKS und RECHTS, wie in der folgenden Bildserie gezeigt) aufnehmen, um dies zu berücksichtigen.

OBEN

UNTEN

LINKS

RECHTS

Führen Sie den ersten Abschnitt von Schritt 4a des Live-Skripts aus, indem Sie auf Run Section klicken, und platzieren Sie den Rover dann wie in den in MATLAB angezeigten Eingabeaufforderungen beschrieben.

Im nächsten Abschnitt des Codes arbeitet die Funktion calibrateLocationOffset mit den Bildern, die Sie gerade aufgenommen haben. Das aufklappende Bild zeigt eine klare Visualisierung, wie die Höhenunterschiede zwischen den verschiedenen Bildtiefen der Kamera ausgeglichen werden. Klicken Sie auf die in den Popup-Figuren angegebenen Punkte (Mitte des Rovers und Mitte der Scheibe), um die Offsets zu berechnen.

Klicken Sie nun auf den Abschnitt " Compute the offsets of the rover“ (Berechnen der Offsets des Rovers) und dann auf Run and Advance, um alle notwendigen Aufgaben auszuführen.

Als nächstes wiederholen wir diese Aufgaben für das Target in Schritt 4b. Klicken Sie erneut auf die Schaltfläche Run and Advance und folgen Sie den in MATLAB angezeigten Anweisungen.

Führen Sie den nächsten Abschnitt mit dem Titel "Compute the location offset for the target“ aus, wo Sie den Rover gemäß den Anweisungen im MATLAB Command Window an verschiedenen Stellen platzieren und dann auf die Stellen klicken, an denen das Target platziert wurde, gefolgt von der Mitte des Targets im Bild. Die Lokalisierungsergebnisse hängen stark von diesen Schritten ab und können zu Problemen führen, wenn die Kalibrierung nicht korrekt durchgeführt wird. In diesem Abschnitt des Live-Skripts wird ein Beispielbild angeboten.

In "Step 5: Calibrate the color threshold of the disc“ (Kalibrieren des Farbschwellenwertes der Disc) sehen Sie, wie Sie die Beleuchtung berücksichtigen können. Klicken Sie auf diesen Abschnitt des Codes, wählen ihn aus und klicken Sie auf Run this section of code. Achten Sie darauf, dass Sie auf dem angezeigten Bild in der folgenden Reihenfolge auf die Kreise klicken: Zuerst rot, dann grün und dann blau.

Damit haben Sie nun die Parameter kalibriert, um eine orthogonale Ansicht des Rovers zu erhalten, um eventuelle Positionsversätze innerhalb dieser Ansicht zu korrigieren und zu berücksichtigen, wie die Beleuchtung die RGB-Werte für Farben beeinflussen kann. Alle Kalibrierdaten werden gespeichert und bei der Ausführung der Lokalisierungsskripte wiederverwendet.

Nachdem Sie die Kalibrierung abgeschlossen haben, sehen wir, wie wir mit dem Lokalisierungsalgorithmus die Position und den Kurs des Rovers innerhalb der Arena in fünf einfachen Schritten berechnen können. Öffnen Sie das Live-Skript roverLocalization.mlx:

Lassen Sie uns "Step 1: Prepare the MATLAB Workspace" dieses Live-Skripts ausführen, um den Workspace zu bereinigen und die zuvor erzeugten Kalibrierdaten zu laden.

Geben Sie die Abmessungen Ihrer Arena in "Step 2: Enter the arena's dimension and calculate conversion factor" (Abmessungen der Arena und Berechnung des Umrechnungsfaktors) und führen Sie diesen Codeabschnitt aus. Der in diesem Abschnitt berechnete Umrechnungsfaktor bezieht sich auf die realen Abmessungen der Arena in Zentimetern und die Anzahl der Pixel im Bild. Dies wird erreicht, indem man die physikalischen Arena-Messungen mit der entsprechenden Anzahl von Pixeln aus dem Bild teilt.

Wählen Sie unter "Step 3: Initialize the webcam" die entsprechende Webcam aus den vorgeschlagenen aus und führen Sie diesen Codeabschnitt zur Initialisierung der Webcam aus.

Der folgende Abschnitt, genannt "Schritt 4a: Get the location and heading of the rover," verwendet die Kalibrierdaten, um die Position und den Kurs des Rovers innerhalb des Bildes zu bestimmen. Nachfolgend ein Ablaufplan dargestellt, der einen Überblick über den Lokalisierungsalgorithmus selbst gibt.

Um die Rover-Position und die Richtung aus dem orthogonalen Bild zu erhalten, haben wir die Funktion roverPosAng erstellt.

Weitere Informationen finden Sie unter roverPosAng und getLocation Funktionen. Lassen Sie uns Run und vorankommen.

In "Step 4b: Get the location of the target" (Ermitteln der Position des Ziels) wird die Position des Ziels anhand der Kalibrierdaten berechnet. Lassen Sie uns diesen Codeabschnitt ausführen.

Nachdem Sie nun die Standort- und Kursinformationen von Rover und Ziel haben, führen Sie "Step 5: Visualize Results" (Ergebnisse visualisieren) aus, um die Ergebnisse zu veranschaulichen, die das eigentliche Bild überlagern.

Wenn Sie diesen Code ausführen, sollten Sie ein Bild sehen, das die gesamte Szene mit dem Rover, dem Ziel und der Arena anzeigt:

Bei der Kalibrierung der RGB-Werte in der roverCalibration kann es dazu kommen, dass obwohl Sie Sie die Punkte in der richtigen Reihenfolge auswählen, der Algorithmus vorgibt, dass die Reihenfolge falsch ist. Versuchen Sie in dem Fall, das Live-Skript unter verschiedenen Lichtverhältnissen erneut auszuführen. Wenn das Bild in MATLAB übersättigt oder extrem hell/dunkel erscheint, kann dies die RGB-Farbkalibrierung beeinträchtigen.

Verwenden Sie den folgenden Dokumentationslink, um weitere Informationen darüber zu finden, wie Sie die Eigenschaften des Webcam-Objekts anpassen und die Bildqualität verbessern können: https://www.mathworks.com/help/supportpkg/usbwebcams/ug/set-properties-for-webcam-acquisition.html

Wenn Sie bei der Ausführung von roverLocalization eine Fehlermeldung wie die folgende erhalten, konnte der Algorithmus keinen Schwerpunkt für den Rover finden.

Um dies zu überwinden, gibt es folgende Möglichkeiten:

• Führen Sie den letzten Abschnitt des Kalibrieralgorithmus erneut aus, um neue RGB-Schwellenwerte zu erhalten. Schlechte Lichtverhältnisse oder plötzliche Änderungen der Beleuchtung können die Leistung des Algorithmus beeinflussen.

• Passen Sie die Größe des strel Objekts auf Zeile 5 der roverPosAng Funktion an.

Wenn Sie eine ähnliche Fehlermeldung von der Funktion targetPos erhalten, versuchen Sie Folgendes:

• Anpassung der Konstanten, mit denen das Bild auf Zeile 18 von targetPos eingestellt wird. Bestimmte Lichtverhältnisse können dazu führen, dass ein akzeptabler Schwellenwert für schwarze Objekte höher oder niedriger als die voreingestellten Werte sein müssen.

• Anpassen der Größe des Strel-Objekts auf Zeile 5 der targetPos Funktion.

Wenn die Koordinaten des Rovers oder Ziels in der RoverLokalisierung nicht korrekt sind, stellen Sie sicher, dass die von Ihnen eingegebenen Werte arenaHeight und arenaWidth korrekt sind. Wenn die Abmessungen nicht übereinstimmen, können Sie die richtigen Koordinaten in Pixeln, aber falsche Koordinaten in Zentimetern erhalten.

• Wir haben gesehen, wie man die Arena einrichtet und für verschiedene Parameter kalibriert.

• Wir haben gesehen, wie man die Lokalisierung durchführt, um die Position und Ausrichtung des Rovers zu berechnen.

• roverCalibration.mlx

• roverLocalization.mlx

Führen Sie die RoverCalibration aus und beobachten Sie, wie sich die Offsetwerte der Position auf die Genauigkeit des Lokalisierungsalgorithmus auswirken. Versuchen Sie, Punkte auszuwählen, die etwas von den gewünschten Punkten entfernt sind.

Versuchen Sie, die Größe des Strel Objekts zu ändern, das von der Funktion targetPos und roverPosAng verwendet wird. Um zu verstehen, wie die Strel Funktion in unseren Algorithmen hilft, geben Sie den folgenden Befehl in MATLAB ein:

Um die Genauigkeit zu verbessern, muss die Größe dieses Objekts je nach Konfiguration geändert werden. Der Datencursor macht das Messen der Pixelgröße verschiedener Objekte im Bild sehr einfach, da er den genauen Wert des Pixels liefert. Sie können den Datencursor aktivieren, indem Sie auf die Schaltfläche klicken, die im Screenshot unten gezeigt wird.

In der letzten Übung haben Sie mit einem Lokalisierungsalgorithmus die Position und Ausrichtung des Rovers und die Position des Ziels berechnet. Sie integrieren nun diese Informationen in ein Simulink Modell und programmieren den Rover so, dass er vom Startpunkt über den Zielort bis hin zum Endpunkt sich bewegt.

Sie werden auch lernen, wie Sie den Gabelstapler von Simulink aus steuern, so dass Sie das Ziel aufnehmen und am Endpunkt ablegen können. Nach Abschluss dieser Übung können Sie den Rover so programmieren, dass er zwischen beliebig vielen Wegpunkten fährt.

In dieser Übung werden Sie Folgendes lernen:

• Nutzung von Zustandslogik, um den Weg des Rovers zwischen beliebig vielen Wegpunkten zu planen.

• Steuerung des Gabelstapler, um das Ziel aufzunehmen und am Endpunkt abzusetzen.

In Übung 5 haben Sie gelernt, wie Sie die Webcam mit einem Lokalisierungsalgorithmus verwenden, um die Anfangspositionen des Rovers und des Ziels in Ihrer Arena zu ermitteln. Lassen Sie uns sehen, wie Sie diese Informationen in Simulink integrieren und den Rover so programmieren, dass er zwischen bestimmten Wegpunkten navigiert. Beginnen wir mit dem Öffnen von planPath_sim.slx.

Das Modell, das die Bewegung des Rovers simuliert und einen Constant Block mit den Wegpunkten verwendet, sollte nun in Simulink dargestellt werden. Der Block wird im Modell als Waypoints bezeichnet. Diese Koordinatenpaare werden vom Rover verwendet, um seinen Weg zu berechnen. Der Waypoints Block stellt dem Stateflow Diagramm planPathLogic zusätzlich zu Entfernung und Winkel, Daten in einer state machine zur Verfügung, um die den Rover steuert. Das RoverSimulation Subsystem wurde ebenfalls so modifiziert, dass es die Wegpunkte als Eingabe übernimmt.

Dieses Modell verwendet das gleiche convToWheelVel Subsystem aus früheren Übungen, um Radgeschwindigkeiten basierend auf Rover-Geschwindigkeit und Drehrate zu berechnen.

Das Subsystem RoverSimulation ist, wie frühere Übungen, außer dass es jetzt eine zusätzliche Eingabe benötigt: eine Matrix, die den Startplatz des Rovers in der ersten Reihe, den Standort des Objekts in der zweiten Reihe und den Endpunktplatz in der dritten Reihe (x, y) bereitstellt. Das Subsystem verwendet diese Informationen, um die Wegpunkte in der von ihm erstellten Animation darzustellen.

Diese drei Standorte werden auch als Eingang für das planPathLogic Diagramm verwendet, das die Pfadplanung für den Rover übernimmt. Öffnen wir planPathLogic, um zu sehen, wie es funktioniert.

Das Diagramm hat vier Zustände, die den Betriebsarten des Rovers entsprechen: StopFirst, Turn, MoveForward, und Stop.

Wenn die Simulation beginnt, befindet sich der Rover im Zustand StopFirst. Der Rover befindet sich für 1 Sekunde in diesem Zustand und bewegt sich während dieser Zeit nicht.

Nach dem Zustand StopFirst geht der Rover in den Zustand Turn. Hier dreht er sich um den entsprechenden Betrag, bis er dem nächsten Wegpunkt zugewandt ist. Dann geht der Rover in den Zustand MoveForward, wo er die entsprechende Strecke vorwärts fährt, um diesen Wegpunkt zu erreichen.

Turn ruft die Funktion calcAngle auf, um zu berechnen, wie viel der Rover drehen soll, basierend auf der aktuellen Position und der Position des nächsten Wegpunktes.

Öffnen Sie calcAngle und erkunden Sie den Code, um zu verstehen, wie er funktioniert. Durch das Bestimmen der Abstände zwischen Rover und Wegpunkten kann der gewünschte Kurs mittels Trigonometrie berechnet werden. Beachten Sie, wie der Quadrant des nächsten Wegpunktes in Bezug auf die aktuelle Position des Rovers identifiziert wird. Dies ist notwendig bei Verwendung der inversen Tangentenfunktionen (atand).

Um die Quadranten im Zusammenhang mit dem Rover besser zu verstehen, sehen Sie sich bitte das folgende Bild an.

Nachdem berechnet wurde, wie weit sich der Rover drehen soll, wird die Simulink Funktion angCtrl aufgerufen, um den Rover zu drehen, genau wie in Übung 4. Dabei wird der Rover mit einem PI Regler gedreht, bis die Übergangsbedingung erfüllt ist (d.h. der Rover liegt innerhalb von 0,5 Grad des angegebenen Winkels).

Der Rover sollte nun dem nächsten Wegpunkt zugewandt sein und geht in den Zustand MoveForward über. In diesem Zustand fährt der Rover die entsprechende Strecke vor, um den Wegpunkt zu erreichen. Öffnen Sie die MATLAB Funktion calcDistance, bei der dieser Abstand mit dem Satz des Pythagoras berechnet wird.

Nach der Berechnung, wie weit sich der Rover bewegen soll, wird die Simulink Funktion distCtrl aufgerufen, um den Rover um den angegebenen Abstand mit einer Genauigkeit von 0,1 cm zu bewegen.

Sobald diese Übergangsbedingung erfüllt ist, verlässt der Rover den MoveForward Status und erreicht dann eine Verzweigung (junction) im Stateflow.

Verzweigungen werden verwendet, wenn Sie sich zwischen zwei verschiedenen Zuständen entscheiden müssen, in diesem Fall Stop oder Turn. Die nextWPIndex Variable wird jedes Mal erhöht, wenn der Rover den MoveForward Status verlässt. Sobald der Indexwert der Anzahl der Wegpunkte entspricht, ist die Sequenz abgeschlossen und der Rover geht in den Stop Zustand. Bis dahin kehrt der Rover in den Turn Status zurück und der Prozess beginnt für den nächsten Wegpunkt von vorne.

Betrachten Sie für dieses Beispiel die einfache Sequenz, in der sich der Rover von seiner Ausgangsposition zum Ziel und dann vom Ziel zum endgültigen Endpunkt bewegt. Das StateLogic Diagramm ist jedoch generisch aufgebaut, so dass es den Weg des Rovers für eine beliebige Anzahl von Wegpunkten planen kann.

Überprüfen Sie den Workspace und Sie werden feststellen, dass nur drei Variablen definiert sind: L, r und TS. Für die Durchführung verschiedener Simulationen sind jedoch andere Variablen erforderlich, wie z.B. die Ursprungskoordinaten und die anfängliche Ausrichtung des Rovers.

Definieren Sie den Rest der benötigten Variablen, nämlich die Rover-Koordinaten StartX und StartY und die Überschrift StartTheta, indem Sie Folgendes im Command Window eingeben.

Zur erinnerung: das RoverSimulation Subsystem verwendet diese Variablen, um den Roverstandort in der Animation darzustellen.

Klicken Sie auf Ausführen, um zu sehen, wie sich der Rover in Simulationen verhält. Sie sollten in der Lage sein, sowohl die Animation des Rovers als auch das Stateflow Diagramm gleichzeitig zu sehen.

Jetzt da Ihr Pfadfolgealgorithmus in der Simulation funktioniert, lassen Sie uns die Anwendung auf dem eigentlichen Rover übertragen. Öffnen Sie zunächst das Modell roverPlanPath_hw.slx.

Dieses Modell verwendet den gleichen Pfadfolgealgorithmus wie das Simulationsmodell, aber die Eingaben in das Modell sind nun die tatsächliche Entfernung und der tatsächliche Winkel des Rovers, gemessen von den Encodern. Außerdem werden die im Subsystem convToWheelVel berechneten Drehzahlen ($\omega_l$, $\omega_r$) in die aktuellen Motoren eingegeben.

Aktualisieren Sie den Waypoints Block so, dass die erste Zeile die anfängliche Roverposition darstellt, die zweite Zeile die Zielposition und die dritte Zeile die gewünschte Endpunktposition. Verwenden Sie die realen Ergebnisse, die Sie in Übung 5 erhalten haben. Wenn Sie den Standort des Rovers und/oder des Ziels geändert haben, wiederholen Sie den Vorgang roverLocalization.mlx.

Zum Beispiel - wenn Sie die cmPlate Werte auf [10 10] und cmTarget Werte auf [30 40] gesetzt haben und wenn Sie möchten, dass der Rover bei [50 50] stoppt, dann geben Sie [10 10; 30 40; 50 50] als Ihre Waypoints Matrix ein.

Define the rover location variables to match the heading and x, y location of your rover from the localization results by typing the following:

Stellen Sie sicher, dass der Akku ausgeschaltet ist und verbinden Sie den Rover mit dem Computer über das USB-Kabel und klicken Sie auf die Schaltfläche Deploy to Hardware, um den Code auf Arduino zu laden.

Sobald die Übertragung abgeschlossen ist, entfernen Sie das USB-Kabel. Bevor Sie Ihren Rover einschalten, denken Sie daran, das Ziel zu entfernen und diesen Punkt auf Ihrer Arena zu markieren. Denn Ihr erstes Experiment besteht darin, den Rover einfach dazu zu bringen, sich von seinem ursprünglichen Standort zum Standort des Ziels zu bewegen.

Stellen Sie den Rover wieder auf die Arena und schalten Sie ihn ein. Beobachten Sie, wie nah Ihr Rover zum Ziel und zur endgültigen Endpunktposition navigiert. Beheben Sie Probleme mit Ihrem Experiment, bis die Ergebnisse zufriedenstellend sind. Denken Sie daran, wenn der Rover dem Pfad nicht genau folgt, können Sie beide Controller für die Roverbewegung aktivieren, wie Sie es mit dem Modell roverClosedBoth_states_hw in Aufgabe 4 getan haben.

Nun, da Sie gelernt haben, wie Sie den Rover zwischen den Wegpunkten navigieren, lassen Sie uns sehen, wie Sie den Gabelstapler bedienen, damit er schließlich zum Aufnehmen und Bewegen des Ziels verwendet werden kann.

Der erste Schritt besteht darin, zu lernen, wie man den Gabelstapler von Simulink aus steuert. Hierfür haben wir ein Modell namens testForklift_hw. vorbereitet. Öffnen Sie dieses Modell, indem Sie Folgendes eingeben:

Im Modell sehen Sie ein Stateflow Diagramm und einen ServoMotor Block. Die Idee ist, dass der Gabelstapler angehoben und abgesenkt wird, indem der Servomotor über ein Logikdiagramm gesteuert wird. Es werden auch ähnliche Techniken in das Modell integriert, um die Bewegung des Rovers zu steuern.

Dieses Modell verwendet ein Stateflow Diagramm, um die Logik zum Heben und Senken des Gabelstaplers zu definieren. Der Gabelstapler wird von einem Standard-Servomotor gesteuert, dessen Winkel von 0 bis 125 Grad reicht. Das Diagramm gibt den Winkel des Servos aus, wobei 0 Grad die DOWN Position und 125 Grad die UP Position ist.

Der Servo Motor Block stammt aus der Bibliothek "Simulink Support for Arduino MKR Motor Carrier"

Wählen Sie die Portnummer aus, je nachdem, wo der Servomotor mit dem MKR Motor Carrier verbunden ist. Ausgehend von der empfohlenen Montageanleitung sollte dies Port Nummer 1 sein.

Werfen wir einen genaueren Blick auf die StateLogic Darstellung, die den Stapler von UP nach DOWN und zurück nach UP bewegt.

Dieses Diagramm enthält zwei Hauptzustände, DropForkLift und LiftForkLift, und einige Zwischenzustände, in denen keine Maßnahmen ergriffen werden.

Im Zustand DropForkLift wird der Servowinkel bei jedem Zeitschritt um 0,5 Grad verkleinert, bis er die Position DOWN erreicht, die für 0 Grad steht.

Im Zustand LiftForklift wird der Servowinkel bei jedem Zeitschritt um 0,5 erhöht, bis er die Position UP oder 125 Grad erreicht.

Bevor Sie diese Anwendung auf dem Rover einsetzen, stellen Sie sicher, dass sich der Gabelstapler in der UP Position befindet, wie in der Abbildung unten gezeigt. Dies ist die empfohlene Position für allgemeine Situationen, in denen sich der Rover in der Arena bewegt.

Klicken Sie auf die Schaltfläche Deploy to Hardware, um den Code auf den Rover zu laden.

Schalten Sie den Rover ein, um zu sehen, wie der Gabelstapler funktioniert. Der Rover wird sich nicht bewegen, da das Modell nur den Servomotor steuert und nicht die DC Motoren, die die Räder antreiben.

Der nächste Schritt besteht darin, die Stapleraktion in unsere frühere Aufgabe der Navigation zwischen Wegpunkten zu integrieren. Das heißt, Sie müssen das forklift chart mit dem path planning chart zusammenführen.

Um diese Aufgabe zu vereinfachen, wird ein Modell bereitgestellt, das diesen Vorgang für Sie durchführen kann. Öffnen Sie das Modell roverPlanPath_Forklift_hw.slx und erkunden Sie die aktualisierte Stateflow Logik. Übertragen Sie das aktualisierte Modell auf Ihrem Rover und sehen Sie, wie er sich in der aktuellen Arena verhält. Denken Sie daran, den Rover und das Ziel wieder an den gleichen Anfangspositionen zu platzieren. Wenn nicht müssen Sie das roverLocalization Live-Skript erneut ausführen und den Waypoints Block in diesem Modell aktualisieren.

• Wir haben gesehen, wie der Rover seinen eigenen Weg von jedem Startpunkt bis zu einem Endpunkt planen kann.

• Wir haben gesehen, wie man das Ziel mit dem Gabelstapler anhebt und diese in den Pfadplanungsalgorithmus einbezieht.

• planPath_sim.slx

• roverPlanPath_hw.slx

• testForklift_hw.slx

• roverPlanPath_Forklift_hw.slx

Probieren Sie verschiedene Kombinationen von Rover-Startpositionen und Objektpositionen aus und sehen Sie, wie genau Ihr Rover zu den gewünschten Wegpunkten navigiert. Wenn die Genauigkeit nicht zufriedenstellend ist, versuchen Sie, die Verstärkung Ihres PI Reglers anzupassen.

Versuchen Sie, zusätzliche Wegpunkte hinzuzufügen und sehen Sie, wie genau Ihr Rover zwischen ihnen navigiert.

In der vorherigen Übung haben Sie gesehen, wie Sie einen Lokalisierungsalgorithmus anwenden können, um die anfängliche Position und Ausrichtung des Rovers zu berechnen, und wie Sie diese Informationen in den Wegplanungsalgorithmus integrieren können. Im Allgemeinen ist es auch wünschenswert, die Lokalisierung in regelmäßigen Abständen durchzuführen, während sich der Rover bewegt, um die aus den Encoderdaten berechneten Standortinformationen zu ergänzen.

Diese Übung zeigt, wie Sie Ihr Simulink Modell so konfigurieren, dass es Daten von MATLAB über Wi-Fi empfängt. Sie erfahren auch, wie Sie Daten aus MATLAB an Ihren Rover senden können. Diese Daten basieren dann auf der aktuellen Position des Rovers, die über die Lokalisierung berechnet wurde. Dadurch können Sie mit einem Rover arbeiten, dessen Wegpunkte sich im Laufe der Zeit ändern können, wenn Sie die von der Kamera erhaltenen Lokalisierungsinformationen berücksichtigen. Mit anderen Worten, Sie müssten den Rover nicht jedes Mal neu programmieren, wenn sich die Ausgangsbedingungen ändern, da er mit der Kamera den Algorithmus in Echtzeit speist.

In dieser Übung werden Sie Folgendes lernen:

• Senden von Anweisungen aus MATLAB per Wi-Fi an den Rover.

• Aufbau einer Wi-Fi-Kommunikation zwischen Rover und MATLAB.

• Nutzung der Lokalisierung, um die Position des Rovers zu berechnen, während er sich bewegt.

Lassen Sie uns zunächst roverReceive_hw.slx öffnen:

Dies ist ein einfaches Modell, das zeigt, wie Sie Anweisungen an den Rover über Wi-Fi senden können. Es verwendet Subsysteme und Blöcke, mit denen Sie vertraut sind, zur Berechnung von Radgeschwindigkeiten und zur Ansteuerung von Motoren.

Neu ist jedoch, dass dieses Modell Daten zur Steuerung des Rovers verwendet, die über Wi-Fi eingehen. Dabei ist es egal ob er vorwärts oder rückwärts fahren oder anhalten und ob er den Gabelstapler bewegen soll oder nicht. Die Blöcke moveForward und FLangle steuern die drahtlose Kommunikation zum und vom Rover. Öffnen Sie den mit moveForward bezeichneten Block, um zu sehen, wie dies konfiguriert ist.

Dieser Block ermöglicht die Eingabe von Daten vom Typ Data type und von der Größe Data size (N) am Lokalen IP-Port. Die Daten werden in Abständen von 0,01 Sekunden gelesen, wie durch die Sample time bestimmt. Der hier verwendete Lokale IP Port Wert ist der Standardwert. Da es mehrere Wi-Fi Blöcke gibt, werden diese mit unterschiedlichen Werten gesetzt.

Daten, die an diesen Block gesendeten sind, sind entweder 0 oder 1. Wenn der Eingang 1 ist, bewegt sich der Rover mit 10 cm/s vorwärts. Er bewegt sich nicht, wenn der Eingang 0 ist.

Der andere Wi-Fi receive Block mit der Bezeichnung FLangle steuert den Stapler, um von der UP-Position nach DOWN zu fahren.

Es gibt noch einen letzten Schritt zur Wi-Fi-Konfiguration, bevor Sie dieses Modell auf dem Rover einsetzen. Sie müssen die Wi-Fi-Eigenschaften dieses Modells so konfigurieren, dass der Rover eine IP-Adresse erhält, die zur Kommunikation verwendet werden kann. Klicken Sie dazu auf das Zahnradsymbol.

Öffnet den Dialog Configuration Parameters. Um Ihr Modell zu konfigurieren, klicken Sie auf Hardware Implementation > Target hardware resources > WiFi properties.

Geben Sie die SSID und das WPA-Passwort des drahtlosen Netzwerks ein. Diese sind die gleichen wie die, die Sie verwenden würden, um Ihren Laptop oder Ihr Smartphone mit dem Wi-Fi-Netzwerk zu verbinden. Sie benötigen dazu natürlich ein funktionierendes Wi-Fi-Netzwerk, das in dem Raum arbeitet, in dem Sie experimentieren. An dieser Stelle ist es nicht möglich, die Access-Point Funktionalität des MKR 1000 in Ihrem Kit zu nutzen, um ein eigenes Netzwerk aufzubauen.

Das Modell ist nun so eingerichtet, dass der Rover Befehle über Wi-Fi von MATLAB empfangen kann. Lassen Sie uns zu MATLAB übergehen, um zu sehen, wie man Befehle über Wi-Fi sendet.

Beginnen Sie mit dem Öffnen von commandRover.mlx:

Lassen Sie uns den Code analysieren, um zu sehen, wie er funktioniert. Einige der Code-Abschnitte sollten erst nach der Bereitstellung der Simulink-Anwendung auf dem Rover ausgeführt werden, also lassen Sie uns vorerst einfach verstehen, was der Code tut. Später dann kann er in der Übung ausgeführt werden.

Die ersten drei Schritte führen die notwendigen Einstellungen für den Lokalisierungsalgorithmus durch, einschließlich des Ladens von Kalibrierungsdaten, der Eingabe von Arena-Informationen und der Initialisierung der Webcam. Sie können auf die vorherigen Übungen zurückgreifen, wenn Sie weitere Informationen über ihre Funktionsweise benötigen. Diese wurden da ausführlich erklärt.

In "Step 4: Get the location of the Rover" wird der Lokalisierungsalgorithmus aufgerufen, um den Standort und die Richtung des Rovers zu berechnen und die Ergebnisse in cmRoverInitial zu speichern. Die gewünschte y-Lage des Rovers ist als Anfangsposition plus 30 cm angegeben.

Nachdem Sie die Anfangsposition des Rovers und die gewünschte Endposition festgelegt haben, können Sie die Wi-Fi-Kommunikation mit dem Rover einrichten. Erstellen Sie zunächst mit der Funktion tcpip Objekte, die die Verbindung zwischen MATLAB und den IP-Ports darstellen, die den Blöcken moveForward und FLangle in roverReceive_hw.slx entsprechen.

Im Abschnitt "Step 6: Move forward and drop the forklift" werden die Daten von MATLAB an die eingesetzte Simulink-Anwendung über Wi-Fi gesendet. Dieser Schritt beginnt mit der Definition einer Variablen moveFlag, die als Eingabe für den moveForward Block verwendet wird. Wenn moveFlag gleich 1 ist, bewegt sich der Rover vorwärts in y-Richtung mit 10 cm/s, und wenn es gleich 0 ist, bewegt sich der Rover nicht.

moveFlag wird zunächst auf 1 gesetzt und mit Hilfe einer bedingten Logik wird der Rover angewiesen, weiter vorwärts zu fahren, bis die y-Lage des Rovers (berechnet durch den Lokalisierungsalgorithmus, der einmal pro Sekunde läuft) näher als 1 cm von an der gewünschten y-Lage liegt

Sobald das Kriterium erfüllt ist, passieren zwei Dinge:

• moveFlag wird auf 0 gesetzt, so dass der Rover nicht mehr vorwärts fährt.

• Eine for-Schlaufe wird verwendet, um den Gabelstapler von der Position UP (125 Grad) in die Position DOWN (0 Grad) zu bewegen.

Zusammenfassend lässt sich sagen, dass der MATLAB-Code über Wi-Fi-Kommunikation den Rover anweist, sich zum gewünschten y-Punkt zu bewegen und dann den Gabelstapler abzusenken.

Nachdem Sie sich mit den Simulink Modellen und dem MATLAB-Code vertraut gemacht haben, beginnen wir nun mit der Steuerung des Rovers aus MATLAB.

Als erstes entscheiden Sie sich für einen Ort, an dem Sie den Rover auf die Arena stellen können. Von dieser Stelle aus muss er sich mindestens 30 cm in y-Richtung vorwärts können.

Wichtig: Wie üblich, wenn sich Teile Ihres Setups geändert haben (z.B. Webcam oder Standort der Arena, Beleuchtung), müssen Sie neu kalibrieren.

Verteilen Sie roverReceive_hw.slx auf den Rover. Wenn die Codegenerierung abgeschlossen ist, klicken Sie auf View Diagnostics, um die IP-Adresse Ihres Rovers abzurufen.

Notieren Sie sich im öffnenden Diagnostics Viewer die IP-Adresse des Rovers.

Öffnen Sie jetzt CommandRover.mlx und führen Sie die ersten vier Schritte aus. Denken Sie daran, allen Anweisungen im Live-Skript zu befolgen.

Geben Sie die IP-Adresse Ihres Rovers in "Step 5: Create objects to connect to the IP ports on the rover" ein und klicken Sie auf Run and Advance.

Sie werden feststellen, dass sich der Rover für ca. 1 Sekunde bewegt und dann stoppt. MATLAB ruft den Lokalisierungsalgorithmus auf, um die aktuelle y-Lage des Rovers zu berechnen und zeigt sie im Output Window an.

Sobald sich der Rover 30 cm in y-Richtung von seinem Ausgangspunkt entfernt hat, senkt sich der Gabelstapler ab. An dieser Stelle ist die Bewerbung abgeschlossen.

Wir haben gesehen, wie man über Wi-Fi von MATLAB zum Rover kommuniziert und dieser Anweisungen erhält.

• roverReceive_hw.slx

• commandRover.mlx

Fügen Sie einen weiteren Wi-Fi Block zu Ihrem Simulink Modell hinzu und aktualisieren Sie Ihren MATLAB-Code entsprechend, so dass Sie den Rover bei Bedarf drehen lassen können.

In diesem Kapitel wurden Sie mit einer Reihe von Themen vertraut gemacht:

Die Steuerung eines Differentialantriebsroboters. Sie mussten einen einfachen zweirädrigen Rover bauen, der einen Mechanismus (Gabelstapler) zum Heben und Senken von Gegenständen trägt.

Um den Rover zu bewegen, haben Sie als zwei mögliche Strategien Open-loop und Closed-loop kennengelernt. Nachdem Sie den Open-Loop-Regler verwendete nur Informationen aus dem Modell der Motoren unter nicht optimalen Bedingungen. Diesen haben Sie dann verworfen. Dafür haben Sie gelernt, wie Sie einen Closed-Loop-Regler mit einem PID-Regler mit Simulink implementieren können. Obwohl diese Strategie viel besser war als der Open-Loop-Controller, zeigte sie dennoch zwei unerwünschte Nebeneffekte: stationäre Fehler und Überschwingen.

Es gibt jedoch eine Möglichkeit, diese beiden Effekte zu vermeiden In unserem Fall durch die Verwendung einer mit Stateflow implementierten Zustandsmaschine. Stateflow ist eine Toolbox innerhalb der MATLAB-Suite. Stateflow war auch nützlich, um ein einfaches Programm zur Steuerung des Gabelstaplers auf dem Rover zu erstellen. Dieses ermöglicht, anspruchsvollere Aufgaben zu realisieren, die sowohl das Bewegen des Rovers, das Suchen nach einem Objekt an einem gewünschten Ort als auch das Umsetzen des Objektes an einen anderen Ort beinhalten. Die Ausgangsbedingungen des Systems waren jedoch noch unbekannt: Wo befand sich der Rover zum Zeitpunkt des Starts unseres MATLAB Live Script?

Dieses letzte Problem wird mit einer Kamera und einem Bildverarbeitungsalgorithmus gelöst, der nach dem RGB-Marker des Rovers sucht. Das ermöglicht den Rover mit ziemlich hoher Genauigkeit auf einer Arena einer vorgegebenen Größe zu finden. Wir haben gesehen, dass dies ein komplexes Kalibrierungsverfahren erfordert, was bei jeder Änderung der Bedingungen durchgeführt werden muss.

Schließlich ist es mit Hilfe der drahtlosen Kommunikation möglich, den Rover im gleichen Wi-Fi-Netzwerk wie den Computer zu betreiben, auf dem MATLAB läuft. Dadurch kann der Rover direkt mit Simulink kommunizieren und so die Möglichkeit eines dynamischen Konfigurationsmechanismus zu eröffnen.

Nach all den Erfahrungen in diesem Kapitel sind wir nun bereit, eine Herausforderung zu formulieren, die alle Komponenten dieses Moduls beinhaltet.

In den vorangegangenen Übungen haben Sie gesehen, wie der Rover seinen Weg von einem Startpunkt zum Ziel und schließlich zu einem bestimmten Endpunkt planen kann. Ein Vorbehalt bei diesem Ansatz ist, dass es außer den Encoderdaten keine Rückmeldung über die Roverposition gibt. Wenn die Räder zu rutschen beginnen oder die Encoderdaten verrauscht sind, werden Sie Probleme bekommen.

Es wäre gut, wenn mehrere Sensoren Daten über die Position des Rovers liefern könnten. Damit lassen sich die potenziellen Probleme weitgehend überwinden. Wie Sie in Übung 7 gesehen haben, können Sie Signale von Ihrem MATLAB Computer an ein deploytes SimulinkModell über Wi-Fi Blöcke senden. Als letzte Aufgabe implementieren Sie einen Wegplanungsalgorithmus auf dem Rover, der den Lokalisierungsalgorithmus aus Übung 5 verwendet. Dieser Lokalisierungsalgorithmus liefert dann ein noch weitergehendes Feedback.

Das ist Ihre letzte Herausforderung. Erstellen Sie einen fantastischen mobilen Rover!