Erste Schritte

In diesem Kapitel erfahren Sie, wie Sie die Grundfunktionen von Arduino, MATLAB und Simulink nutzen können, um die Projekte in diesem Kit zum Erfolg zu führen. Außerdem sind diese Tools weit verbreitet, so dass Sie alles, was Sie in diesem Kapitel lernen, auf alle Ihre zukünftigen Projekte anwenden können!

In diesem Abschnitt lernen Sie:

• Wie man die Arduino IDE installiert und konfiguriert.
• Das Arduino MKR1000 Board kennen.
• Wie man digitale Ein-/Ausgänge und serielle Kommunikation mit Arduino verwendet.
• Wie man Arduino Carrier zusammen mit Arduino Boards verwendet.
• Den Arduino MKR Motorträger kennen.
• Wie man einen Motor mit dem Arduino MKR Motorträger bewegt.

Im Laufe der Jahre hat Arduino eine Vielzahl von boards entwickelt, die jeweils unterschiedliche Fähigkeiten und Funktionalitäten aufweisen. So gibt es beispielsweise für jedes Kommunikationsprotokoll ein anderes MKR Board, wie z.B. Wi-Fi, Bluetooth, LoRa, SigFox, GSM und so weiter. Das beliebteste Board für Anfänger ist das Arduino UNO. Basierend auf dem ATmega328P-Prozessor von ATMEL ist es das meistgenutzte und robusteste Board der gesamten Arduino-Familie, perfekt geeignet für den Einstieg zum Basteln an der Plattform.

Boards, die nach dem UNO bis 2017 freigegeben wurden, verfügen über fortschrittlichere Prozessoren mit mehr Speicher und erweiterten Ein-/Ausgabefunktionen, verwenden aber größtenteils die gleichen Pinbelegungen und arbeiten mit bestehenden Add-On Boards, den sogenannten Shields oder Carriern, und verschiedenen Add-On-Komponenten wie Sensoren, Kommunikations-Chipsätzen und Aktoren.

Im Jahr 2017 brachte Arduino das MKR1000 Board auf den Markt, ein völlig neues Design, das einen neuen Standard in Bezug auf Pinbelegung, Form und Betriebsspannung (3,3 V) setzt. Danach wurden mehrere Boards nach diesem neuen Standard veröffentlicht, um eine neue Teilmenge von Arduino Boards namens MKR-Familie zu erstellen. Wie bereits erwähnt, ist diese Familie von Boards für diejenigen gedacht, die ein spezifisches digitales Kommunikationsprotokoll benötigen (Wi-Fi, Lora, SigFox, etc.), ohne die Benutzerfreundlichkeit der klassischen Arduino Boards zu beeinträchtigen.

Das Arduino MKR1000 ist ein leistungsstarkes Board basierend auf dem Atmel ATSAMW25 SoC, das entwickelt wurde, um eine praktische und kostengünstige Lösung für Hersteller zu bieten, die ihre Projekte um drahtlose Wi-Fi-Konnektivität erweitern möchten.

Das MKR1000 ist das erste seiner Familie, ein vielseitiges Board: Es beinhaltet eine LiPo-Ladeschaltung, die es ermöglicht, mit Batterien zu arbeiten, ein Wi-Fi-Modul mit einem Krypto-Chip für eine sichere Kommunikation und es kann konfiguriert werden, um den Stromverbrauch zu begrenzen und es über einen längeren Zeitraum zu betreiben.

Wi-Fi-Konnektivität macht es zum perfekten Board für jedes Projekt im Zusammenhang mit dem Internet der Dinge. Es ermöglicht die Kommunikation mit Hunderten von Online-Diensten, die RESTful-APIs anbieten, wie Twitter, GitHub, IFTTTT oder Telegramm, um nur einige zu nennen. Das Board kann auch als Wi-Fi-Zugangspunkt verwendet werden, um ein lokales Netzwerk aufzubauen, das einen kleinen Webserver betreiben kann, der Websites und Online-Schnittstellen hostet.

Das MKR1000 Board hat 28 Pins, von denen einige feste Funktionalitäten haben und andere konfigurierbare Funktionalitäten. Zu den Pins mit fester Funktionalität gehören GND und 5V, die den Zugang zu den Masse- bzw. 5-Volt-Bezugsspannungsleitungen des Boards ermöglichen. Die mit A0 bis A6 gekennzeichneten Pins sind analoge Pins. Diese Pins können Spannungswerte zwischen 0 und 3,3 Volt, bezogen auf GND, senden oder empfangen. Schließlich sind die mit 0 bis 14 gekennzeichneten Pins digitale Pins. Wenn diese Pins Daten übertragen, können sie nur Spannungswerte von 0 oder 3,3 Volt, bezogen auf GND, übertragen. Wenn sie Daten empfangen, wird die Spannung als HIGH oder LOW interpretiert, bezogen auf einen Schwellenwert zwischen 0 und 3,3 Volt. Beachten Sie, dass Sie niemals mehr als 3,3 Volt an die digitalen und analogen Pins des Boards anlegen dürfen. Beim Anschluss von Sensoren und Aktoren ist darauf zu achten, dass diese Grenze von 3,3 Volt nicht überschritten wird. Das Anschließen von Signalen mit höherer Spannung, wie sie bei den anderen Arduino Boards üblich sind, führt zu Schäden am MKR1000.

Die Pins auf den Arduino Boards können zur Steuerung und Kommunikation mit externen Komponenten wie LEDs, Motoren oder Sensoren verwendet werden. Die Pins können entweder als INPUT oder OUTPUT konfiguriert werden. Pins, die als INPUT konfiguriert sind, ermöglichen es der Platine, Werte von externen Komponenten zu lesen, die an den Pin angeschlossen sind, wie beispielsweise die Lichtintensität eines Fototransistors oder den Zustand einer Taste. Wenn die Pins als OUTPUT konfiguriert sind, kann das Board die Aktoren steuern und mit ihnen kommunizieren, eine LED leuchten lassen oder einen Ton auf einem Summer wiedergeben.

Pins, die als OUTPUT konfiguriert sind, befinden sich in einem niederohmigen Zustand. In dieser Konfiguration kann der Pin anderen Schaltungen Strom zuführen. Ausgangspins im MKR1000 können bis zu 7 mA (Milliampere) Strom pro I/O-Pin an andere Geräte und Schaltungen liefern. Das bedeutet, dass Sie z.B. einen Motor nicht direkt von einem Stift aus antreiben können, da der Strom nicht ausreicht. Sie müssen den Einsatz von Treibern verschiedener Typen in Betracht ziehen, um unterschiedliche Aufgaben wie das Aufleuchten von Hochleistungs-LEDs, das Antreiben von Motoren oder das Aktivieren von Relais zu erfüllen.

Digitale Pins können nur zwei Zustände haben, EIN und AUS oder, wie in der Programmiersprache Arduino bezeichnet, HIGH und LOW. Wir verwenden die digitalWrite() funktion, um einen Pin in den gewünschten Zustand zu versetzen, indem wir zwischen den Klammern angeben, auf welchen Pin wir reagieren wollen und in welchem Zustand wir ihn haben wollen.

Um das im Kit enthaltene MKR1000 Board zu testen, müssen Sie die Arduino IDE installieren. Es gibt zwei verschiedene Versionen der IDE: die klassische Offline-Java-IDE und die neuere Cloud-basierte Create IDE. Zum jetzigen Zeitpunkt ist die Interaktion zwischen MATLAB und Arduino nur über die klassische IDE möglich, weshalb die folgenden Erläuterungen zur Konfiguration dieses spezifischen Tools dienen. Die klassische Arduino IDE kann unter folgendem link heruntergeladen werden. Wählen Sie die Version, die dem Betriebssystem Ihres Computers entspricht, und folgen Sie den Anweisungen. Auf dieser Seite im Arduino-Server finden Sie weitere Informationen zu diesem Prozess.

Die klassische Arduino IDE ist ein relativ kleiner Download (ca. 100 MB) und wurde auf die Bedürfnisse traditioneller Arduino-Anwender zugeschnitten, die typischerweise ein Arduino UNO-, Nano- oder Mikroboard besitzen. Die Arduino MKR-Familie benötigt jedoch eine andere Toolchain, den Werkzeugsatz, um binäre ausführbare Dateien für Arduino aus Code zu erzeugen, der viel schwerer ist und separat heruntergeladen werden muss. Diese Operation ist sehr einfach und kann direkt aus der IDE heraus durchgeführt werden. Der gesamte Vorgang ist in Arduino's Erste Schritte Anleitung zum MKR1000 beschrieben, die Sie hier finden.

Durch die Installation der notwendigen Dateien zur Kompilierung von Programmen für das MKR1000 installieren Sie auch die Treiber, die für Ihren Computer erforderlich sind, um das Board zu identifizieren und mit ihm zu kommunizieren. Die drei Hauptbetriebssysteme Windows, Linux und Mac OSX behandeln den Anschluss neuer USB-Geräte unterschiedlich. Unter Windows werden Arduino Boards typischerweise als serielle Schnittstellen aufgelistet und mit dem Begriff COM gefolgt von einer Zahl gekennzeichnet. Unter Linux werden die Boards als Peripherie unter dem Ordner /dev/ angezeigt, genauer gesagt /dev/ttyACM und eine Zahl. Schließlich erkennt Mac OSX Arduino Boards unter dem Deskriptor /dev/tty.usbmodem (ebenfalls gefolgt von einer Zahl). Für detailliertere Erklärungen zur Behebung möglicher Probleme, die beim Versuch, die Boards zu erkennen, auftreten können, lesen Sie bitte die Anleitung zur Inbetriebnahme des MKR1000 erneut oder wenden Sie sich an den Arduino-Support, wenn Sie weitere Hilfe benötigen.

Lassen Sie uns sicherstellen, dass die Installation der IDE und der Treiber erfolgreich war, indem wir das einfachste Beispiel der Arduino IDE ausprobieren. Das sogenannte Blink-Beispiel (zu öffnen unter File>Examples>Basics>Blink), wird die On Board-LED in einer Endlosschleife ein- und ausschalten.

Alle Arduino Boards verfügen über eine On Board-LED, die an einen der digitalen Pins angeschlossen ist, wobei die Position von Board zu Board variieren kann. Beim MKR1000 wird die LED an Pin 6 angeschlossen, während sie beim klassischen Arduino UNO Board an Pin 13 angeschlossen ist. Die Arduino-Programmierumgebung verfügt über eine Systemkonstante namens LED_BUILTIN, die den LED-Pin für das zu programmierende Board darstellt. Lassen Sie uns einen kurzen Blick auf den Code für dieses Beispiel werfen:

Die Funktion setup() enthält Anweisungen, die nur einmal ausgeführt werden müssen, um das Board zu konfigurieren. Darin setzen wir den an die LED angeschlossenen Pin als OUTPUT mit der Funktion pinMode().

Die Funktion loop() enthält Anweisungen, die nacheinander durchlaufen werden. Wie Sie sehen können, schalten wir zuerst die LED ein, indem wir den Pin in den Zustand HIGH versetzen und dann ausschalten, indem wir den Pin auf LOW versetzen.

Zwischen diesen beiden Pin-Schreiboperationen stoppt die delay() funktion die Ausführung des Programms für die in den Klammern angegebene Zeitspanne von Millisekunden. Dies ermöglicht es uns, den Änderungszustand der LED zu sehen, da die Änderung sonst zu schnell wäre, um vom menschlichen Auge wahrgenommen zu werden. Laden Sie das Blink-Beispiel auf das Board hoch, um das Ergebnis zu sehen. Anstatt die eingebaute LED zu verwenden, können Sie eine externe LED anschließen und jeden beliebigen digitalen Pin verwenden.

Arduino-Pins sind standardmäßig als INPUT konfiguriert. Die so konfigurierten Pins befinden sich in einem hochohmigen Zustand. Eingangspins könnten so modelliert werden, als hätten sie einen 100-MOhm-Widerstand in Reihe vor dem Pin. Das bedeutet, dass es sehr wenig Strom benötigt, um den Eingangspin von einem Zustand zum anderen zu ändern. Pins, wenn sie als Eingänge konfiguriert sind, sind nützlich, um Werte von Tasten, Schaltern und ganz allgemein all jenen Sensoren zu lesen, die nur zwei Zustände haben: EIN oder AUS.

Um Werte von einem als INPUT konfigurierten Pin zu lesen, verwenden wir die digitalRead() funktion, die zwischen den Klammern anzeigt, von welchem Pin wir Werte lesen wollen. Die Funktion gibt einen Wert zurück, der entweder HIGH oder LOW sein kann (was den ganzen Zahlen 1 oder 0 entspricht). Öffnen Sie das Button-Beispiel in der Arduino IDE (zu finden im Menü File>Examples>Digital>Button) und sehen sie es sich an. Das folgende Bild zeigt das in der IDE geöffnete Beispiel.

In diesem Beispiel deklarieren wir zuerst die Variablen, die wir verwenden werden, wie buttonPin und ledPin; dies sind nur menschenlesbare Namen, die wir den mit der Taste verbundenen Pins und der LED geben können. Es gibt eine dritte Variable, buttonState genannt, die verwendet wird, um den Wert zu speichern, der vom Lesen des mit der Taste verbundenen Pins zurückgegeben wird.

Hinweis: Um den Code auszuprobieren, schlagen wir vor, dass Sie eine Schaltung erstellen. Um der Schaltung zu entsprechen, müssen Sie den Code ändern. In der folgenden Abbildung wird die Taste mit Pin 6 verbunden, so dass Sie die anfängliche Deklaration von buttonPin entsprechend diesem Fall ändern müssen. Wir lesen dann den Zustand der Schaltfläche und speichern ihn im buttonState, wie Sie im folgenden Code-Ausschnitt sehen können:

Mit einer if-Anweisung, können wir dann die LED je nach Zustand der Taste EIN oder AUS schalten, EIN bei gedrückter Taste und AUS bei fehlender Taste.

Arduino Boards kommunizieren mit Computern und anderen Geräten über die serielle Schnittstelle. Alle Arduino Boards verfügen über mindestens eine serielle Schnittstelle (auch bekannt als UART oder USART). Serielle Daten bestehen aus einer Reihe von 1's und 0's, die mit einer bestimmten Geschwindigkeit über das USB-Kabel gesendet werden. Daten können sowohl von der Karte zum Computer als auch umgekehrt übertragen werden.

Sowohl die Arduino IDE als auch der Create Editor verfügen über eine Funktion, den Serial Monitor, die beim Debuggen von Sketch eine große Hilfe ist. (Sketch ist die Art und Weise, wie wir Arduino-Programme aufrufen.) Der Serial Monitor ist ein Popup-Fenster in der klassischen IDE, das als separates Terminal fungiert, das durch Empfangen und Senden serieller Daten kommuniziert; Sie rufen es auf, indem Sie auf das Lupensymbol auf der rechten Seite der Symbolleiste auf der IDE drücken. Der Create Editor hat den Serial Monitor als Layer implementiert, der einen Teil des Editors überlagert, der für die Anzeige der Dateinavigation vorgesehen ist.

Um die serielle Kommunikation mit Arduino zu nutzen, müssen wir sie zunächst durch Aufruf der Funktion Serial.begin() initialisieren. Zwischen den Klammern geben wir die Baudrate ein, d.h. die Datenrate in Bit pro Sekunde (Baud) für die serielle Datenübertragung. Die am häufigsten verwendete Baudrate ist 9600. Sie sollten sich bewusst sein, dass verschiedene Geräte und Systeme mit unterschiedlichen Geschwindigkeiten kommunizieren, so dass Sie beide Enden der Kommunikation (Sender und Empfänger) so konfigurieren müssen, dass sie mit dem gleichen Verhältnis von Bits pro Sekunde arbeiten.

Probieren Sie anhand eines Beispiels aus, wie die serielle Schnittstelle funktioniert. Öffnen Sie das Beispiel DigitalReadSerial (File>Examples>Basics>DigitalReadSerial) und überprüfen Sie den Code.

Dieses Beispiel veranschaulicht, wie man Werte von einer Taste liest, die an Pin Nr. 2 angeschlossen ist, und diese Werte mit der Funktion Serial.println() auf dem seriellen Monitor ausgibt.

Je nachdem, ob die Taste gedrückt wird, wird eine 0 oder eine 1 auf der Konsole gedruckt. Die Schaltungskonfiguration ist die gleiche wie das zuvor im Kapitel verwendete Tastenbeispiel.

Shields/Carrier sind Platinen, die auf oder unter ein Arduino Board gesteckt werden können, um dessen Möglichkeiten zu erweitern. Sie werden im Allgemeinen verwendet, um den Anschluss von Sensoren und Aktoren zu vereinfachen, die entweder eine hohe Anzahl von Elektronikkomponenten erfordern, die nur als oberflächenmontierte Komponenten existieren oder sehr häufig verwendet werden.

Da es verschiedene Arduino Boards mit unterschiedlichen Pinouts und Formen gibt, gibt es auch verschiedene Shields/Carrier. Der Hauptunterschied besteht zwischen der alten Arduino-Familie (basierend auf dem UNO-Pinout) und der neuen MKR-Familie. Es ist auch möglich, die für die älteren Boards angefertigten Abschirmungen mit den neueren Boards zu verwenden, indem man ein einfaches adapter Shield verwendet. Ein Beispiel für ein für die MKR1000-Familie hergestelltes Shield ist das MKR Relay Proto Shield, das Sie im folgenden Bild sehen können:

Das MKR Relay Shield kann unter jede Platine der MKR-Familie gesteckt werden, so dass Sie zwei Relais ohne Verdrahtungsaufwand einfach steuern können. Andere Shields erweitern die Kommunikationsmöglichkeiten der Boards. Mit dem GSM Shield kann das Arduino Board beispielsweise telefonieren, SMS-Nachrichten versenden und sich mit dem Internet verbinden.

Eine weitere Art von Shield, die manchmal nützlich ist, ist das MKR Proto Shield. Dies ist ein Shield, das Platz zum Auflöten von Bauteilen bietet, was das Projekt kompakter und robuster macht.

Einige der oben dargestellten Shields bieten die Möglichkeit, Sensoren oder Aktoren einfacher zu verbinden. Andere beinhalten komplexe Element für die die zusätzliche Codeblöcke notwendig sind, um sie zu nutzen. So benötigen einige Shields (wie z.B. das GSM) neuen Codebibliotheken, die der IDE hinzugefügt werden müssen. Unter dem folgenden link können Sie mehr darüber lesen, wie Sie neue Bibliotheken für Ihre Arduino IDE finden und hinzufügen können.

Dieser Abschnitt hat Sie mit der Idee der Shields vertraut gemacht. Der nächste Abschnitt stellt den MKR Motor Carrier vor - eine Platine, die speziell für dieses Engineering Kit entwickelt wurde.

Der MKR Motor Carrier (auch bekannt als MKR Motor Carrier Board) ist ein MKR Add-on Board zur Steuerung von Servo-, Gleichstrom- und Schrittmotoren. Der Carrier kann auch zum Anschluss anderer Aktoren und Sensoren über eine Reihe von 3-poligen Pinleisten (Male Headers) verwendet werden.

Die Zusammenfassung der Funktionen ist unten dargestellt:

• Kompatibel mit allen Boards der MKR-Familie

• Vier gleichzeitige Servomotorausgänge

• Bis zu vier gleichzeitige Gleichstrommotoren (zwei leistungsstarke + zwei Standard leistungsstarke)

• Zwei gleichzeitige Schrittmotoren (alternativ zu den Gleichstrommotoren)

• Erfassung der Stromrückführung für die Hochleistungsmotoren

• Zwei Eingänge für Gebersensoren

• Vier Eingänge für analoge Sensoren (3-)Pin-kompatibel)

• Möglichkeit, den Status der Batterien abzulesen

• EIN-AUS-Schalter mit Power ON-LED

• LiPo-Akkustecker (2S- oder 3S-kompatibel) und Leistungsklemmenleiste für alternative Stromquellen

• LEDs zur optischen Anzeige der Drehrichtung der Gleichstrommotoren

• Integrierter Prozessor zur automatischen Steuerung einiger Ausgänge

• I2C-Stecker als 4-polige Pinleiste

Der MKR Motor Carrier verfügt über zwei MC33926 Motortreiber für eine leistungsstarke DC-Motorsteuerung mit direktem Anschluss an den MKR1000, Stromrückführung und einer Kapazität von bis zu 5 Ampere (Spitze). Zusätzlich gibt es zwei DRV8871-Treiber, die von einem SAMD11-Mikrocontroller gesteuert werden, der mit dem MKR1000 über I2C kommuniziert (SPI optional). Das SAMD11 wird auch zum Steuern der Servos, zum Auslesen der Encoder und zum Auslesen der Batteriespannung verwendet. Es gibt eine Interruptleitung, die das SAMD11 (auf PA27) und das MKR Board verbindet.

Elektrische Eigenschaften:

• Verpolungsschutz in den Power-Pins

• Max. Strom MC33926: 5 Ampere Spitzenstrom, Effektivstrom abhängig vom vorgesehenen Kühlkörpergrad

• Max. Strom DRV8871: 3 Ampere Spitze, Strombegrenzung durch Strommesswiderstand

• Nennspannung: 6,5V bis 20V

Beachten Sie, dass für den erweiterten Einsatz oder Hochstrommotoren ein zusätzlicher Kühlkörper (und eventuell ein Lüfter) für die Treiber erforderlich sein kann. Für die in diesem Kit enthaltenen Beispiele und Projekte ist dies nicht erforderlich. An verschiedenen Stellen in der Dokumentation wird es spezifische Erläuterungen zum sicheren Betrieb des Motor Carriers geben, wenn Sie diese nicht befolgen, sind der Motor Carrier, die Motoren und schließlich der MKR1000 gefährdet.

Wenn Sie den MKR1000 auf den Motor Carrier aufstecken, stehen Ihnen einige der Pins nicht mehr zur Verfügung, um sie in Ihrem Code zu verwenden, da sie zur Steuerung einiger der Funktionen des Trägers benötigt werden. So wird beispielsweise die Stromrückführung der beiden MC33926-Treiber direkt mit einigen der analogen Pins des MKR1000 verbunden. Die folgende Liste erklärt, welche Pins des MKR1000 zur Steuerung des Motor Carriers verwendet werden:

• Analog Pin A3 für Stromrückführung von Motor3

• Analog Pin A4 für Stromrückführung von Motor4

• Digitaler Pin D2 für IN2-Signal für Motor3

• Digitaler Pin D3 für IN1-Signal für Motor3

• Digitaler Pin D4 für IN2-Signal für Motor4

• Digitaler Pin D5 für IN1-Signal für Motor4

• Digitaler Pin D6 für Interruptsignal von SAMD11 bis MKR1000

• Digitaler Pin D11 für das SDA-Signal (I2C)

• Digitaler Pin D12 für das SCL-Signal (I2C) Außerdem können einige Pins optional über eine Lötbrücke oder einen 0 Ohm Widerstand angeschlossen werden. Diese Pins sind:

• Digitaler Pin D1 für das SF-Signal der MC33926-Treiber (optional)

• Digitaler Pin D7 für das SPI SS-Signal (optional)

• Digitaler Pin D8 für das SPI MOSI-Signal (optional)

• Digitaler Pin D9 für das SPI SCK-Signal (optional)

• Digitaler Pin D10 für das SPI MISO-Signal (optional)

Um den Motor Carrier zu verwenden, müssen Sie eine MKR Board (MKR1000, MKR Zero oder ähnliches) auf die Pinleisten in der Mitte der Platine stecken. Vergewissern Sie sich, dass das MKR Board in der richtigen Richtung aufgesteckt ist. Das ist dann der Fall, wenn die auf der Seite des Motor Headers aufgedruckten Informationen mit den auf dem MKR Board aufgedruckten übereinstimmen.

Sobald das Board ordnungsgemäß mit dem Motorträger verbunden ist, können Sie mit der Programmierung der Karte beginnen. Um die Motoren zu steuern, müssen Sie die MKR Motor Carrier Library importieren. Weitere Informationen über die Bibliothek finden Sie hier. Wenn Sie mehr darüber erfahren möchten, wie man eine Bibliothek installiert, folgen Sie diesem link.

Wenn Sie mit Motoren arbeiten, benötigen Sie eine externe Stromversorgung für die Motortreiber und zum Betrieb der Motoren. Sie können dies tun, indem Sie einen LiPo-Akku an den Akkustecker anschließen oder eine externe Stromquelle verwenden und ihn an den VIN-Eingang an der Klemmleiste anschließen. Es wird empfohlen, diese Vorgänge mit dem Netzschalter in der Position OFF durchzuführen. Sobald die externe Stromversorgung an das Board angeschlossen ist, kann der Netzschalter eingeschaltet werden.

In den Projekten dieses Engineering Kits werden wir den Motor Carrier mit einem MKR1000 verwenden, da dieses Board über Wi-Fi verfügt. Dank einer speziellen Konfiguration in MATLAB kann das Board direkt mit der Software kommunizieren, solange sich beide im selben drahtlosen Netzwerk befinden.

Der Motor Carrier wird in den drei Projekten eingesetzt:

• Selbstbalancierendes Motorrad: Beim selbstbalancierenden Motorrad wird der Motor Carrier verwendet, um das Schwungrad in der Mitte des Motorrads zu steuern. Es steuert auch den Getriebemotor im Hinterrad, der sich vorwärts oder rückwärts bewegt, und ein Servo im Vorderrad, um das Motorrad zu lenken. Der Ultraschallsensor und der Hall-Sensor werden ebenfalls über einige der 3-poligen Stecker mit dem Carrier verbunden. Der Halleffekt-Sensor wird verwendet, um die Geschwindigkeit des Trägheitsrades zu überwachen. Mit dem Ultraschallsensor werden Hindernisse detektier um zu verhindern, dass das Motorrad beim Vorwärtsfahren mit Gegenständen kollidiert.

• Mobile Rover: Im Rover wird der MKR Motor Carrier zur Steuerung der beiden DC-Getriebemotoren und der Encoder verwendet, welche an die Räder des Rovers angeschlossen sind. Darüber hinaus wird der Motor Carrier verwendet, um einen Servomotor in der Vorderseite des Fahrzeugs zu steuern, der den Rover mit einem Hubmechanismus ausstattet. Zur Hindernisvermeidung wird ebenfalls ein Ultraschallsensor an den Motor Carrier angeschlossen.

• Zeichenroboter: Im Zeichenroboter wird der Motor Carrier verwendet, um die beiden DC-Getriebemotoren mit Encoder zu steuern und um den Roboter auf dem Whiteboard zu lokalisieren. Darüber hinaus wird er zur Steuerung eines Servomotors verwendet, der ebenfalls an der Änderung der Markerfarbe beteiligt ist.

Lesen Sie mehr über den MKR Motor Carrier im Arduino Store, wo Sie weitergehende Dokumentationen über den Aufbau, Datenblätter und andere Informationen finden.

Um Ihnen MATLAB, Simulink und die Arduino Support Packages näher zu bringen, werden Sie in den Abschnitten 2.2 und 2.3 ein kurzes Projekt abschließen, das sowohl MATLAB als auch Simulink verwendet, um das Arduino Board und einige der im Arduino Engineering Kit enthaltenen Peripheriegeräte anzusprechen. In diesem kurzen Projekt geht es darum, das Verhältnis zwischen der Drehzahl eines Gleichstrommotors und der angelegten Spannung zu bestimmen. Sie werden lernen, wie Sie diese Beziehung nutzen können, um eine Geschwindigkeitsregelungsanwendung zu entwickeln, die Sie auf das Arduino MKR1000 Board hochladen werden. Sie verwenden einen Encoder, um die Winkelverschiebung des Motors gegenüber einem Bezugswinkel zu messen, und verwenden aufeinanderfolgende Winkelmessungen, um die Motordrehzahl zu berechnen. Um mehr über Encoder zu erfahren, siehe 3.3 Encoder in Kapitel 3.

Das oben genannte Projekt wird in den folgenden Abschnitten vorgestellt und veranschaulicht:

• Navigieren Sie durch die MATLAB-Benutzeroberfläche.
• Geben Sie MATLAB-Befehle ein.
• Erstellen, ändern und greifen Sie auf Daten zu.
• Führen Sie Berechnungen mit Daten durch.
• Visualisieren Sie Daten.
• Schreiben Sie Skripte und Funktionen.
• Erstellen und simulieren Sie ein Simulink Modell.

MATLAB ist eine leistungsstarke Software, die es Ihnen ermöglicht, komplexe Berechnungen an großen Datensätzen durchzuführen. MATLAB hat eine eigene textuelle Programmiersprache mit Anweisungen, die in Skripten zusammengefasst werden können. Sie können sich MATLAB wie eine Befehlszeilenschnittstelle für mathematische Operationen vorstellen: Sie können Befehle direkt auf einer terminalähnlichen Schnittstelle ausführen oder Batch-Skripte erstellen, die vom gleichen Terminal aus aufgerufen werden können.

Mit MATLAB können Sie Bildmengen aufnehmen und verschiedene Arten von Filtern auf sie anwenden, um Histogramme zu zeichnen, große Datenmatrizen zu multiplizieren oder Dialoge zur manuellen Dateneingabe zu erstellen. Sie können auch mit Arduino Boards kommunizieren, um Sensorinformationen live in Ihre Programme einzubringen oder Stellglieder zu steuern, die an das Board angeschlossen sind.

Da dieses Kit darauf zielt, Konzepte auf sehr empirische Weise einzuführen, werden wir schnell mit Hard- und Software vertraut sein. Im vorherigen Abschnitt haben wir erklärt, wie man Arduino separat installiert und wie man es in ein paar einfachen Beispielen anwendet, in denen man seinen Code eingeben musste.

MATLAB und Simulink ermöglichen eine andere Art der Programmierung von Arduino Boards mit einer visuellen Programmiersprache (kurz VPL), wie wir Ihnen in den folgenden Abschnitten zeigen werden. Hinweis: Arduino wird als Plugin zu MATLAB installiert. Das bedeutet, dass Sie es auch nach der Installation erneut installieren müssen, wenn Sie die Arduino-bezogenen Werkzeuge zu Ihrer MATLAB-Installation hinzufügen.

Installieren Sie MATLAB, Simulink und alle anderen Erweiterungen, die Sie benötigen. Weitere Informationen dazu finden Sie in "1.3 Tools" und bei der Registrierung mit den mit diesem Kit gelieferten Codes. Verwenden Sie bei der Installation der Software Ihre offiziellen MATLAB-Registrierungscodes. Sobald Sie die Programme installiert haben, können Sie die im weiteren Verlauf dieses Kapitels vorgestellten Beispiele ausprobieren.

In diesem Abschnitt werden Sie lernen:

• Wie man die Kernkomponenten der MATLAB-Desktopumgebung identifiziert.
• Wie man MATLAB-Befehle im Command Window ausgibt.
• Wie man skalare und vektorielle Variablen erstellt und Funktionen und arithmetische Operationen auf bestehende Variablen anwendet.
• Wie man auf die in Vektoren gespeicherten Daten zugreift und sie manipuliert.
• Wie man Liniendiagramme von Vektordaten erstellt und beschriftet.
• Wie man MATLAB-Daten auf und von der Festplatte speichert und lädt.

Beginnen wir damit, uns mit der MATLAB-Umgebung vertraut zu machen. In diesem Abschnitt lernen Sie das MATLAB Command-Fenster und die Syntax der MATLAB-Sprache kennen, außerdem das Erstellen, Ändern und Analysieren von MATLAB-Variablen und das Erstellen von informativen Visualisierungen Ihrer Daten. Schließlich werden Sie die Techniken in diesem Abschnitt verwenden, um Input-Testfälle für Arduino zu entwickeln und die Ergebnisse von Arduino-Peripheriegeräten zu analysieren und zu visualisieren.

MATLAB über das Startmenü oder durch Doppelklick auf die ausführbare Datei starten. Für Windows-Benutzer heißt die ausführbare Datei matlab.exe und befindet sich in der Regel unter C:\Program Files\MATLAB\R2018a\bin, wobei 2018a die Versionsnummer der verwendeten Software angibt. Hinweis: Dieses Kit ist für MATLAB Version 2018a oder neuer vorgesehen.

Sobald Sie den MATLAB Desktop gestartet haben, werden Sie vier Felder im MATLAB Desktop sehen, mit denen Sie sich vertraut machen sollten. Sie heißen Current Folder, Command Window, Workspace, und Toolstrip.

Auf der linken Seite verhält sich das Fenster Current Folder genau wie Ihr Datei-Explorer: Es zeigt Ihren aktuellen Standort in der Dateistruktur des Computers und seinen Inhalt an. Das Command Window ist die Befehlszeilenschnittstelle (kurz CLI), in der Sie mit Befehlen in der MATLAB-Sprache experimentieren können, bevor Sie sie zu einem MATLAB-Programm hinzufügen. Der Workspace zeigt eine Liste der vorhandenen MATLAB-Variablen und einiger ihrer Eigenschaften an. Oben auf dem MATLAB-Desktop befindet sich der farbenfrohe Toolstrip, das Schaltflächen für grundlegende Dateioperationen, grundlegende MATLAB-Operationen und Einstellungen der Softwareumgebung enthält.

Direkt unter dem Toolstrip sehen Sie einen horizontalen weißen Balken, der den aktuellen Standort in Ihrem Dateisystem anzeigt. Es ist wichtig, auf Ihren aktuellen Ordner zu achten (den Ordner, aus dem Sie MATLAB-Befehle ausführen), da verschiedene Operationen in MATLAB und Simulink Dateien im aktuellen Ordner erzeugen. Es ist nützlich, ein bestimmtes „Work“-Ordner-Verzeichnis zu haben, um Ihre Arbeit zu speichern und alle erzeugten Dateien an einem Ort zu speichern.

Navigieren Sie zum Ordner "Work", indem Sie den folgenden Befehl im MATLAB-Command Window eingeben und die Taste Enter betätigen.

Lassen Sie uns nun an eine grundlegende MATLAB-Syntax gewöhnen. Geben Sie im Command Window den folgenden Befehl ein, um eine neue Variable a:

Erstellen Sie nun eine Variable namens b, indem Sie ihr einen Wert zuweisen.

Sie können frühere Befehle erneut aufrufen, indem Sie die UP-Taste auf Ihrer Tastatur verwenden. Drücken Sie die UP -Taste, bis Sie zu Ihrem ursprünglichen Befehl a=7 zurückkehren, und drücken Sie die Eingabetaste. Wiederholen Sie nun den gleichen Befehl und ändern dabei aber den Variablennamen in c. Diese Operationen erzeugen drei Variablen ( a, b, und c), die Ihnen nun zur Verfügung stehen. Es ist jetzt möglich, Operationen durchzuführen die die Variablen als Teil von Gleichungen, Vektordeklarationen usw. nutzen.

Wie Sie sehen können, ist der Leerraum um die Operatoren herum für die MATLAB-Ausführung irrelevant. Allerdings ist es oft einfacher, Code zu lesen, in dem Operatoren und Operanden voneinander getrennt sind.

Wenn Sie einfach eine Codezeile ausführen möchten, ohne das Ergebnis im Command Window zu sehen, können Sie die Zeile mit einem Semikolon (;) abschließen.

Schauen Sie in den Workspace. Sie sehen dort die drei MATLAB-Variablen a, b und c. Standardmäßig wird der Value jeder Variablen angezeigt, sofern sie nicht zu groß ist, um im Workspace angezeigt zu werden. Sie können verschiedene andere Attribute Ihrer Variablen anzeigen, indem Sie mit der rechten Maustaste auf die Spaltenüberschriften im Workspace klicken.

Klicken Sie mit der rechten Maustaste auf die Spaltenüberschriften, die eine Reihe von Optionen in einer Liste anzeigen; suchen Sie die Spalte Size und klicken Sie darauf, um sie zu aktivieren. Dadurch wird der Schnittstelle eine neue Spalte hinzugefügt, die die Größen der Variablen anzeigt.

In MATLAB gibt die Größe einer Variablen ihre Abmessungen in einem Zeilen-x-Spaltenformat an. Wie Sie sehen können, sind alle Ihre aktuellen Variablen 1 x 1 oder Skalare. Lassen Sie uns einen weiteren Skalar erstellen. Geben Sie den folgenden Befehl ein, und untersuchen Sie dann den Workspace:

>> A = 1.23;

Sie sehen, dass die Variablen A und a in MATLAB unterschiedlich sind. Mit anderen Worten, MATLAB ist eine Programmiersprache, die Große- und Kleinschreibung unterscheidet. Probieren Sie die folgenden Befehle aus, aber schauen Sie diesmal noch nicht in den Workspace:

>> B = 4.56;
        >> A = B;
        >> B = 3.14;

Was, denken Sie, ist der Wert von A? Überprüfen Sie den Workspace, um zu sehen, ob Sie richtig lagen.

Die richtige Antwort lautet: Der Wert von A ist 4,56. Wie Sie sehen können, speichern MATLAB-Variablen nur Werte. Sie stellen keine Beziehungen zu anderen Variablen her, die möglicherweise ursprünglich verwendet wurden. Wenn Sie möchten, dass A den neuen Wert von B widerspiegelt, geben Sie jetzt den Befehl A = B ein.

Nun löschen wir einige Variablen. Der Befehl clear löscht eine Teilmenge oder alle Variablen aus dem Workspace. Löschen Sie die Variablen a und b, indem Sie den folgenden Befehl eingeben, und untersuchen Sie dann den Workspace:

>> clear a b

Sie können alle Variablen löschen, indem Sie den folgenden Befehl eingeben:

>> clear

Obwohl wir mit Skalaren viel erreichen können, bestehen die aussagekräftigsten Daten aus einem 1-dimensionalen Array von Zahlen, genannt Vektor. Ein Vektor kann als Zeilen- oder Spaltenvektor ausgerichtet sein. Erstellen Sie einen Zeilenvektor v1 der Länge 7, indem Sie den folgenden Befehl eingeben, und untersuchen Sie dann Ihren Workspace:

>> v1 = [1 3 2 6 4 4 9]

Erstellen Sie nun einen Spaltenvektor v2 der Länge 5 wie folgt und untersuchen Sie Ihrenr Workspace:

>> v2 = [2;5;7;1;2]

Wenn Sie Variablen haben, die größer als ein Skalar sind, müssen Sie möglicherweise auf eine Teilmenge dieser Variablen zugreifen. Dies wird als Indizierung bezeichnet. Geben Sie die folgenden Befehle ein, um in einen 1x1 Abschnitt der Vektorvariablen v1 und v2 zu indizieren:

>> x = v1(3)
        >> x = v2(5)
        >> x = v2(end)

Ebenso können Sie die Variablenindexierung verwenden, um einen Teil einer bestehenden nicht-skalaren Variable zu ändern. Geben Sie den folgenden Befehl ein, um einen Wert in v2 zu ändern:

>> v2(2) = -1

Sie können einen Vektor als Spalte oder Zeile mit dem Transpose-Operator (') neu ausrichten. Geben Sie den folgenden Befehl ein, um v2 als Zeilenvektor neu auszurichten:

>> v2 = v2'

Vorher haben Sie eckige Klammern ([]) mit Komma (,) oder Semikolon (;) als Trennzeichen verwendet, um Zeilen- bzw. Spaltenvektoren zu erzeugen. Diese Syntax ist nützlich, um kurze Vektoren mit beliebigen Werten zu erstellen. Was ist mit viel längeren Vektoren? Häufig benötigen Sie einen Vektor mit gleichmäßig verteilten Werten, um eine Reihe von periodischen Zeitwerten oder eine geometrische Koordinate darzustellen. Andere lange Vektoren können mit einer Reihe von Sensorwerten gefüllt werden, die zu diesen Zeiten oder Koordinaten gemessen wurden. Wieder andere Vektoren können das Ergebnis einer gewissen Verarbeitung der Rohmessungen sein. Lassen Sie uns vorerst nur Vektoren mit gleichmäßig verteilten Werten erzeugen. Versuchen Sie die folgenden Befehle:

>> v3 = 0:6
        >> v4 = 0:0.5:6

Sie sehen, dass Sie im ersten Fall einen Zeilenvektor v3 mit einer Schrittweite von 1 zwischen den beiden Endpunkten 0 und 6 erzeugt haben. Der resultierende Vektor hat die Länge 7, im zweiten Fall haben Sie einen Vektor v4 mit einer vorgegebenen Schrittweite von 0,5 zwischen den gleichen Endpunkten erzeugt. Der resultierende Vektor hat die Länge 13. Was ist, wenn man einen Spaltenvektor erzeugen möchte? Wiederholen Sie den vorherigen Befehl, wenden Sie aber den Transponier-Operator auf den gesamten Ausdruck an:

>> v4 = (0:0.5:6)'

Erstellen wir nun einen Vektor mit einer gewissen Relevanz in der realen Welt:

>> theta = -2*pi:pi/10:2*pi;

Der Vektor theta stellt einen Winkel dar, der in Bogenmaß ausgedrückt wird und zwei volle Umdrehungen umfasst. Wir werden diesen Vektor im folgenden Unterabschnitt verwenden.

MATLAB verfügt über eine umfangreiche Bibliothek von integrierten Dienstprogrammen, den sogenannten Funktionen (functions), die mit Ihren Daten arbeiten können, um aussagekräftige Ergebnisse zu erzielen. Versuchen Sie die sin Funktion mit der folgenden Syntax:

>> y = sin(pi/2)

Die sin Funktion und die anderen eingebauten trigonometrischen Funktionen arbeiten mit Winkeln, die in Bogenmaß ausgedrückt werden. Versuchen Sie nun, den Sinus aus vielen Winkeln zugleich zu erfassen, und untersuchen Sie ihn dann in Ihrem Workspace:

>> y = sin(theta);

Wenn Sie einen Vektor in eine Funktion eingeben und die Ausgabe ein Vektor gleicher Größe ist, gilt die Funktion als vektorisiert. Die Vektorisierung ist ein wesentliches Merkmal der MATLAB-Sprache und ermöglicht es Ihnen, einfache, prägnante Codezeilen zu schreiben, die viele Operationen auf einmal ausführen und die mathematischen Ausdrücken sehr ähnlich sind. Sie können mehrere Operationen und Funktionsaufrufe in einer einzigen Zeile MATLAB-Code eingeben. Geben Sie die folgende Anweisung ein, um einen Phasenversatz, eine Frequenzskalierung, eine Verstärkung und eine Amplitudenvorspannung auf die Sinuswelle anzuwenden:

>> y = 3*sin(2*theta + pi/2) - 1.5;

MATLAB hat viele eingebaute Funktionen, die Ausgaben beliebiger Abmessungen erzeugen. Manchmal ist es sinnvoll, ein Array einer bestimmten Größe zu erzeugen, das Sie später mit aussagekräftigen Daten füllen werden. Versuchen Sie die folgenden Befehle, um zweidimensionale Matrizen von allen Einsen und allen Nullen zu erzeugen:

>> z = ones(3,4)
        >> z = zeros(4,3)

Da ein bestimmter MATLAB-Ausdruck unter vielen verschiedenen Umständen funktionieren kann, müssen Sie möglicherweise bestimmte Eigenschaften Ihrer Daten bestimmen, bevor Sie damit arbeiten können. Verwenden Sie die folgenden Befehle, um die Größe von y, z und theta zu bestimmen:

>> size(y)
        >> size(z)
        >> size(theta)

Lassen Sie uns nun diese Informationen nutzen, um ein Array a zuzuordnen, das die gleiche Größe wie Theta hat:

>> a = zeros(size(theta));

Eine weitere Funktion, die ähnlich wie Nullen und Einsen funktioniert, ist randn, die ein Array von normalverteilten Zufallszahlen mit einem Mittelwert von Null und einer Standardabweichung von 1 erzeugt. Versuchen Sie, eine Liste von 20 solcher Zahlen zu erstellen, indem Sie die folgende Funktion aufrufen:

>> randn(20,1)

Kombinieren Sie schließlich die vorherigen Techniken, um Ihrer Sinuswelle etwas Zufallsrauschen hinzuzufügen und um einen neuen Vektor z zu erzeugen:

>> z = y + 0.3*randn(size(theta));

Der schnellste Weg, um Einblick in Ihre Daten zu gewinnen, ist, sie mit Hilfe einer Art von Plot zu visualisieren. In dieser Einführung erstellen Sie einfache Liniendiagramme Ihrer Vektordaten. Verwenden Sie den folgenden Befehl, um die Werte im Vektor y zu visualisieren:

>> plot(y)

Wie Sie sehen können, wenn Sie einen einzelnen Vektor zeichnen, wird dieser als eine kontinuierliche Linie wiedergegeben, die die diskreten Werte in diesem Vektor verbindet. Die x-Achse stellt die Indizes dieses Vektors von 1 bis N dar. Lassen Sie uns nun den Vektor y gegen eine sinnvollere Variable, in diesem Fall das angle Theta, plotten:

>> plot(theta,y)

Wenn Sie zwei Vektoren in die plot Funktion eingeben, werden die entsprechenden geordneten Paare gezeichnet und durch gerade Linien verbunden. Beachten Sie auch, dass der neue Plot den alten Plot überschrieben hat. Angenommen, Sie möchten einen Plot im figure window behalten, aber eine neue Linie darüber zeichnen. Dafür müssen Sie den Plot mit hold halten, um ihn nicht zu überschreiben. Probieren Sie die folgenden Befehle aus, um eine neue Linie (aus der Variable z) auf der Sinuskurve zu zeichnen:

>> hold on
        >> plot(theta,z)

Abschließend fügen wir der Figur einige Bezeichnungen hinzu, damit sie besser verstanden werden kann. Damit Sie die beiden Zeilen in der Darstellung unterscheiden können, verwenden Sie die folgenden Befehle, axis labels um Achsen zu beschriften, title um einen Titel und legend um eine Legende hinzuzufügen:

>> xlabel('Phase (radians)')
        >> ylabel('Amplitude')
        >> title('Ideal vs. Noisy Oscillations')
        >> legend('Ideal','Noisy')

Beachten Sie, wie die legend Funktion funktioniert. Sie weist die Bezeichnungen den aufgezeichneten Linien in der gleichen Reihenfolge zu, in der sie gezeichnet wurden.

Sie haben nun mehrere Variablen in Ihrem Workspace. Angenommen, Sie müssen MATLAB beenden und herunterfahren. Wenn Sie MATLAB beenden, werden alle Ihre Workspace Daten gelöscht. Sie können wichtige Daten auf der Festplatte speichern. Verwenden Sie den folgenden Befehl, um die Variablen theta, a, y und z zu speichern:

>> save myData theta a y z

Untersuchen Sie nun das Fenster Current Folder auf dem MATLAB-Desktop. Sie werden sehen, dass MATLAB eine neue Datei mit dem Namen myData.mat angelegt hat:

Lassen Sie uns Ihre neue MAT-Datei testen. Löschen Sie mit den folgenden Befehlen alle Variablen aus dem Workspace und laden Sie sie dann mit dem Befehl load neu:

>> clear
        >> load myData

Sie werden nun sehen, dass der Workspace nur die zuvor genannte Liste der vier Variablen enthält und dass alle anderen verschwunden sind.

Im vorherigen Abschnitt haben Sie sich mit Variablentypen, die in MATLAB verwendet werden können, der Verwendung von Funktionen und der Visualisierung von Daten beschäftigt. Der nächste Schritt besteht darin, zu lernen, wie Sie Ihr Arduino Board dazu bringen können, sich mit MATLAB zu verbinden. Außerdem erfahren Sie genügend MATLAB-Grundlagen, um sich mit der Software selbst umzugehen.

In diesem Abschnitt werden Sie verstehen:

• Wie man die nativen Funktionalitäten der Pins des Arduino MKR1000 identifiziert.
• Wie man die Funktionalitäten des MKR1000 Motor Carriers nutzt.
• Wie die Signalstruktur der Pulsweitenmodulation (PWM) aussieht und wie sie zum Antreiben eines Gleichstrommotors und anderer Vorrichtungen verwendet werden kann.
• Wie der Encoder funktioniert und wie damit ein Drehwinkel gemessen werden kann.
• Wie Sie MATLAB mit dem Arduino MKR1000 verbinden.
• Wie man digitale Pins am Arduino MKR1000 konfiguriert und manipuliert.
• Wie man einen Gleichstrommotor aus MATLAB konfiguriert und betreibt.
• Wie man Daten von eines Encoders in MATLAB konfiguriert, liest und verarbeitet.

In diesem Abschnitt verwenden Sie das MATLAB Support Package for Arduino, um auf das Arduino MKR1000 Board und zwei der externen Geräte des Arduino Engineering Kits zuzugreifen: den 100:1-Getriebemotor und den Magnet-Encoder, der bereits mit der Antriebswelle des Motors verbunden ist. In der MATLAB-Umgebung lernen Sie, wie Sie den Motor mit bestimmten Spannungen antreiben und die Drehbewegung des Motors über den Encoder erfassen.

Als nächstes richten Sie das MKR1000 Board in MATLAB ein. Geben Sie den folgenden Befehl ein, um zu starten:

>> arduinosetup

Dies öffnet das Fenster Hardware Setup. Für den größten Teil dieser Lektion werden Sie zwischen Ihrem Computer und dem MKR1000 Board über eine USB-Verbindung kommunizieren. Daher sollten Sie USB aus den verfügbaren Optionen auswählen und auf Next klicken.

Als nächstes wählen Sie Ihren Arduino Board-Typ aus, den Port, über den Sie mit ihm kommunizieren, und die externen Geräte, auf die Sie Zugriff haben müssen. Für dieses Beispiel benötigen Sie den MKR Motor Carrier. Wie bereits erläutert, können mit dem Board den MKR1000 mit bis zu vier Gleichstrommotoren, bis zu zwei Encodern und bis zu vier Servomotoren zu verbinden. In unserem Beispiel verwenden wir einen Gleichstrommotor und einen Encoder.

I2C ist ein digitales Kommunikationsprotokoll, das es einem Gerät ermöglicht, Daten zu und von mehreren anderen Geräten zu übertragen. Wenn der MKR1000 Gleichstrommotore über den MKR Motor Carrier ansteuert, kann er Motorsteuerbefehle über die I2C-Kommunikation senden (zwei der Gleichstrommotoren sind mit einem Treiber verbunden, der direkt auf die MKR-Platine geht, während die beiden anderen von einem Prozessor auf dem MKR Motor Carrier gesteuert werden). Ebenso senden die Encoder die Winkelpositionsdaten über I2C an das MKR1000 Board zurück. Mit der Auswahl von I2C laden Sie die entsprechenden Ressourcen auf das MKR1000 Board, um eine solche Kommunikation zu ermöglichen.

Wählen Sie als Board das MKR1000 Board. Setzen Sie Ihren Kommunikationsport auf den COM- oder ttyACM- oder usbmodem-Port (abhängig vom Betriebssystem), den Sie zuvor gefunden identifiziert haben. Wählen Sie Arduino/MKRMotor Carrier und RotaryEncoder aus und klicken Sie auf Program.

Nachdem die Bibliotheken erfolgreich auf das MKR1000 Board geladen wurden, klicken Sie auf Next und füllen Sie den Rest des Dialogs aus. Sie laden die Firmware auf das MKR Board hoch, damit es mit Ihrem Computer kommunizieren kann und MATLAB Befehle mit Hilfe der von den Sensoren erfassten Informationen ausführen und über den gleichen Kommunikationskanal an die Aktoren zurücksenden wird.

Nachdem die benötigten Ressourcen auf das MKR1000 Board geladen wurden, können wir aus MATLAB auf MKR1000 und die Geräte zugreifen. Geben Sie die folgenden Befehle ein, um Ihren Workspace zu löschen und ein "arduino"-Objekt zu erstellen:

>> clear
        >> a = arduino

Im Gegensatz zu den Variablen im vorherigen Abschnitt (numerische Skalare, Vektoren und Matrizen) ist die neue Variable a ein MATLAB-Objekt vom Typ arduino. MATLAB-Objekte sind spezialisierte Variablen mit festen Eigenschaften (properties), die aussagekräftige Werte innerhalb des Objekts sind. methods, sind die Funktionen die auf Objekten dieses Typs angewendet werden. Wir werden in Kürze auf einige dieser Eigenschaften und Methoden zugreifen und sie aufrufen. Während das Arduino-Objekt (oder ein abgeleitetes Objekt) in Ihrem Workspace, vorhanden ist, ist MATLAB über ein Serverprogramm mit dem Arduino Board verbunden. Wenn Sie diesen MATLAB-Server von Arduino freigeben möchten, damit Sie ein anderes Programm auf Arduino ausführen können (z.B. aus der Arduino-Software oder Simulink), müssen Sie das Arduino-Objekt in MATLAB löschen. Geben Sie die folgenden Befehle ein, um Arduino von MATLAB zu trennen und die Verbindung wiederherzustellen:

>> clear a
        >> a = arduino

Als nächstes müssen Sie auf den MKR Motor Carrier zugreifen, damit Sie den DC-Motor und den Encoder nutzen können. In diesem Abschnitt wird davon ausgegangen, dass Sie die Teile aus dem Bausatz noch nicht in einem der Projekte montiert haben. Wenn Sie ein vorgefertigtes Projekt haben, a) Zeichenroboter, b) Mobiler Rover oder c) Selbstbalancierendes Motorrad, treffen Sie bitte Vorsichtsmaßnahmen. Stellen Sie beispielsweise den Rover auf einen Sockel und stellen Sie sicher, dass sich die Räder frei drehen können, während Sie die Motor- und Encoderexperimente in den nächsten beiden Abschnitten durchführen.

Trennen Sie das USB-Kabel zwischen dem MKR1000 und Ihrem Computer, stellen Sie sicher, dass sich der Schalter des Motorträgers in der Position OFF befindet und befestigen Sie den MKR Motor Carrier dann an der MKR1000-Platine. Dies geschieht, indem Sie die entsprechenden Pinbezeichnungen in Übereinklang bringen und die MKR1000-Platine fest andrücken. Es wird dringend empfohlen, dass Sie bei der Montage oder Demontage von Teilen aus der Schaltung diese immer von beiden Stromquellen (Akku und USB-Kabel) trennen.

Nun richten wir den DC 100:1 Getriebemotor ein. Zuerst untersuchen wir die Kabel, die aus dem Motor kommen.

Der mitgelieferte Motor verfügt über einen vorinstallierten Encoder (Sie können mehr über Encoder in Kapitel 3 lesen), basierend auf einer integrierten Schaltung, auf die wir später noch eingehen werden. Der rotierende Encoder-Chip hat einen Anschluss mit 6 Leitern:

Die vier Leitungen GND, OUT A, OUT B und VCC beziehen sich auf den Encoder selbst. Die beiden mit M+ und M- gekennzeichneten Drähte werden direkt mit den Motorantriebsleitungen verbunden, die unter dem Encoderchip verborgen sind. Suchen Sie die Enden der beiden Motorantriebsdrähte.

Das Drehmoment wird am Motor erzeugt, indem eine Spannung über diese beiden Drähte angelegt wird. Die Größe der Spannung entspricht der Höhe des angelegten Drehmoments. Das Vorzeichen der Spannung ist analog zur Richtung des angelegten Drehmoments.

Suchen Sie auf dem Motorträger die Anschlüsse für den Gleichstrommotor M3. Sie sollten die Bezeichungen M3+ und M3- auf der MKR Motor Carrier Platine neben den entsprechenden Schraubklemmen sehen.

Stecken Sie mit einem kleinen Flachkopfschraubendreher den mit M+ markierten rechten Draht vom DC-Getriebemotor in die Schraubklemme M3+ und ziehen Sie die Schraube an, bis der Draht fest sitzt (ziehen Sie vorsichtig am Draht, zu sehe, ob eine sichere Verbindung besteht). Ebenso befestigen Sie den zweiten rechten Draht mit der Bezeichnung M- vom DC-Getriebemotor in der Schraubklemme M3+.

Als nächstes suchen Sie den Netzschalter am Motorträger und stellen Sie sicher, dass er auf OFF steht.

Suchen Sie nun Ihren LiPo (Lithium Polymer)-Akku und befestigen Sie ihn wie Batterieanschlüssen des Motor Carriers. Achten Sie darauf, dass der schwarze Draht mit GND und der rote mit VIN verbunden ist, um die korrekte Polarität zu gewährleisten:

Schließen Sie das USB-Kabel wieder an, schalten Sie den Netzschalter des Motorträgers auf EIN und stellen Sie sicher, dass die LED in der Nähe leuchtet:

Da Sie die Stromquelle des MKR1000 Boards von USB- auf LiPo-Akku umgestellt haben, müssen Sie Ihre MATLAB-Verbindung zu Arduino wieder herstellen. Führen Sie dazu die folgenden Befehle aus:

>> clear a
        >> a = arduino

Jetzt erstellen wir ein zweites MATLAB-Objekt, um Zugriff auf den MKR Motor Carrier zu erhalten. Verwenden Sie den folgenden Befehl, um ein Motor Carrier Objekt im MATLAB-Workspace zu erstellen, das dem Arduino-Objekt a zugeordnet ist:

>> carrier = addon(a, 'Arduino/MKRMotorCarrier')

So wie der MKR Motor Carrier eine physikalische Schnittstelle zwischen der Motorantriebsverdrahtung und dem MKR1000 Board bereitstellt, ist das carrier Objekt ein Vermittler zwischen dem Arduino-Objekt und den DC- und Servomotoren, die wir verbinden können.

Der MKR Motor Carrier ermöglicht es Ihnen, Ihre Motoren mit einer relativ starken Batterie zu betreiben. Dies kann viel größere Ströme liefern als das Arduino Board selbst, das seine gesamte Energie aus der USB-Verbindung zu Ihrem Computer bezieht. Der USB-Anschluss kann nicht genügend Strom liefern, um Motoren mit der erforderlichen Spannung zu betreiben, und es kann gefährlich sein, dies zu versuchen.

Erstellen wir nun ein drittes Objekt, um Ihnen die Kontrolle über den an M3 angeschlossenen Motor in MATLAB zu ermöglichen. Verwenden Sie den folgenden Befehl, um ein DC-Motor-Objekt zu erstellen, das dem Carrier-Objekt zugeordnet ist, und untersuchen Sie die angezeigten Objekteigenschaften im Command Window :

>> dcm = dcmotor(carrier,3)

Nun können Sie den Motor antreiben. Sie können sehen, dass das Objekt DC-Motor drei Eigenschaften MotorNumber, DutyCycle und IsRunning hat. Sie können die DutyCycle-Eigenschaft direkt ändern, indem Sie Werte zwischen -1 und 1 zuweisen und die Eigenschaft IsRunning mit den Methoden start und stop steuern. Versuchen Sie die folgenden Befehle, um die Motordrehzahl zu steuern:

>> start(dcm)
        >> dcm.DutyCycle = 0.5;
        >> dcm.DutyCycle = 0.3;
        >> dcm.DutyCycle = -0.3;
        >> dcm.DutyCycle = -0.1;
        >> dcm.DutyCycle = -0.05;
        >> dcm.DutyCycle = -0.01;
        >> dcm.DutyCycle = -0.3;
        >> stop(dcm)
        >> start(dcm)
        >> stop(dcm)
        >> dcm.DutyCycle = -0.5;
        >> start(dcm)
        >> stop(dcm)

Die am Gleichstrommotor anliegende Spannung wird durch ein PWM-Signal gesteuert (mehr über PWM-Signale erfahren Sie in Kapitel 3). Die Größe von dcm.DutyCycle gibt das Tastverhältnis des PWM-Signals an. Wenn dcm.DutyCycle positiv ist, wird die Potentialdifferenz der Batterie mit dem PWM-Signal multipliziert, um einen positiven Bruchteil der Batteriespannung zu erzeugen. Wenn dcm.DutyCycle negativ ist, erfolgt die gleiche Multiplikation, aber die Spannungen "Referenz" und "Masse" werden in der Schaltung umgekehrt. Dadurch wird ein negativer Bruchteil der Batteriespannung an den Motor angelegt und ein negatives Drehmoment erreicht.

Möglicherweise haben Sie beobachtet, dass es eine Totzone (dead band )gibt, wenn dcm.DutyCycle sehr nahe bei 0 liegt, da das aufgebrachte Drehmoment nicht groß genug ist, um die Haftreibung in den verschiedenen Achsen im Getriebe zu überwinden. Dies ist etwas, das bei der Entwicklung einer Motorsteuerung berücksichtigt werden sollte.

Lassen Sie uns (metaphorisch) den Gang wechseln und über Sensoren sprechen. Im Kapitel Konzepte in Abschnitt 3.3 können Sie lesen, wie ein Encoder zwei digitale Signale verwendet, um Änderungen der Drehbewegung zu bestimmen und im Laufe der Zeit zu akkumulieren. Lassen Sie uns anschauen, wie es hier umgesetzt wird.

Es gibt zwei Hardwarekomponenten, die an der Messung des Drehwinkels des Motors beteiligt sind. Zunächst besteht die an der Motorwelle befestigte Encoderhardware aus einer integrierten Schaltung, die stationär bleibt, und einer Magnetplatte, die sich zusammen mit der Motorwelle dreht. Da sich die Magnetpole relativ zum Chip drehen, wirken sie auf zwei Elektromagnete innerhalb des Chips, so dass sie zwei digitale Signale A und B mit der später im Kapitel Konzepte beschriebenen Quadraturform erzeugen. Diese Signale entsprechen den Drähten OUT A und OUT B auf dem Encoderchip, wie in der Abbildung unten gezeigt. Die Leitungen GND und VCC sind für den Erdungs- bzw. Spannungseingang vorgesehen. Sie werden an eine Versorgungsspannungsquelle angeschlossen, so dass Strom zur Erzeugung der A- und B-Signale bereitgestellt werden kann. Bestimmen Sie als Übung diese vier Drähte an Ihrem MKR Motorträger.

Zweitens enthält der MKR Motor Carrier für jeden der beiden Encoderanschlüsse einen Datenpuffer. Jedes Mal, wenn sich das A- oder B-Signal vom Geberchip ändert, wird der Wert im Datenpuffer um eins erhöht oder verringert. Der resultierende ganzzahlige Wert ist die Encoderzahl, die wir jederzeit ablesen können.

Schalten Sie die Stromversorgung des MKR Motor Carriers auf AUS und trennen Sie das USB-Kabel. Schließen Sie die Encoderleitungen an die entsprechenden Schraubklemmen für den Encoderanschluss 1 (gekennzeichnet mit 5V, HB1, HA1 und GND) an.

Schließen Sie das USB-Kabel und die Stromversorgung des MKR Motor Carriers an und erstellen Sie dann ein MATLAB-Objekt, um mit den folgenden Befehlen auf den Encoderzählpuffer am Geberanschluss 1 zuzugreifen:

>> clear a
        >> a = arduino
        >> carrier = addon(a, 'Arduino/MKRMotorCarrier')
        >> dcm = dcmotor(carrier,3)
        >> enc = rotaryEncoder(carrier,1)

Um den Encoderzählpuffer zu lesen, verwenden Sie den folgenden Befehl und notieren Sie das Ergebnis:

>> readCount(enc)

Die Geometrie dieses Encoders ist so gewählt, dass es drei volle Quadraturzyklen gibt, wenn die Motorwelle eine volle Umdrehung macht. Erinnern Sie sich daran, dass die Quadratursignale in einem vollständigen Zyklus vier Gesamtänderungen erfahren. Das bedeutet, dass es pro Umdrehung 12 Quadratursignaländerungen für die Motorwelle gibt. So können wir die Winkelposition der Motorwelle mit einer Auflösung von 30 Grad messen, wenn wir die Encoderzahl kennen. Drehen Sie die Magnetplatte manuell um eine volle Umdrehung im Uhrzeigersinn (wenn Sie auf die Magnetplatte schauen), und lesen Sie die Encoderzahl erneut ab:

>> readCount(enc)

Wie hat sich die Encoderzahl verändert? Wenn Ihr Encoder wie angewiesen verdrahtet war, sollten Sie den Zähleranstieg zwischen den Messwerten gesehen haben. Wenn die Pins outA und outB am Encoder umgekehrt verdrahtet wären, wäre die Anzahl zwischen den Messungen zurückgegangen. Rein elektrisch gesehen gibt es keinen richtigen oder falschen Weg, den Geber zu verdrahten; man muss sich nur dieser Tatsache bewusst sein und sie bei der Kalibrierung des Sensors berücksichtigen.

Nur um zu bestätigen, dass alles wie erwartet funktioniert, drehen Sie die Magnetplatte um eine volle Umdrehung gegen den Uhrzeigersinn. Wie hoch ist die Änderung der Encoderzahl? Noch einmal, wenn der Encoder wie angewiesen verdrahtet wurde, würden die Werte zwischen den Messungen abnehmen; wenn die Verdrahtung umgekehrt wäre, würden die Werte steigen. Wenn Ihre Anwendung nur Änderungen der Rotation über einen bestimmten Zeitraum verwendet, spielt es keine Rolle, was der Anfangswert im Encoderzählpuffer ist. Wenn Ihre Anwendung jedoch vom Beginn der Ausführung an Kenntnisse über die absolute Drehung benötigt, ist es sinnvoll, den Zählerstand auf Null zurückzusetzen. Geben Sie die folgenden Befehle ein, um die aktuelle Encoderzahl zu lesen, den Puffer zurückzusetzen und die Zahl erneut zu lesen:

>> readCount(enc)
        >> resetCount(enc)
        >> readCount(enc)

Die gewählte Encoderhardware arbeitet mit einer Auflösung von 12 Zählwerten pro Motorwellenumdrehung (siehe technische Daten unter diesem link). Somit können Sie die Geberzahl der Motorwelle wie folgt in den physikalischen Winkel der Motorwelle in Grad umrechnen:

>> shaftAngle = readCount(enc)*360/12

TDieser Gleichstrommotor hat ein Übersetzungsverhältnis von 100,37:1 (siehe technische Daten hier) zwischen der Motorwelle und der Abtriebswelle, die an der von Ihnen angetriebenen Vorrichtung, wie beispielsweise einem Rad, befestigt ist. Verwenden Sie die folgenden Befehle, um den Drehwinkel der Abtriebswelle in Grad zu ermitteln und ihn dann auf den Bereich von 0 bis 360 Grad zu normieren:

>> axleAngle = readCount(enc)*360/12/100.37
        >> axleAngleNorm = mod(axleAngle,360)

Jetzt wird die Abtriebswelle mit Hilfe des Gleichstrommotors anstelle der manuellen Drehung angetrieben und der Drehwinkel errechnet:

>> dcm.DutyCycle = 0.5;
        >> start(dcm)
        >> readCount(enc)
        >> readCount(enc)
        >> readCount(enc)
        >> stop(dcm)

Jetzt sind Sie in der Lage den Drehwinkel der Motorwelle und der Abtriebswelle bestimmen und damit die Winkeländerungen über einen längeren Zeitraum zu betrachten. Um die Winkelgeschwindigkeit zu erhalten, benötigen Sie auch die Dauer dieses Intervalls. In MATLAB können Sie die verstrichene Zeit mit den Funktionen tic und toc messen. Der erste Befehl, tic, startet einen Timer, wenn er ausgegeben wird. Der zweite Befahl, toc, liest die verstrichene Zeit seit dem letzten Aufruf von tic. Versuchen Sie, die folgenden Befehle einzugeben, um zu verstehen, wie tic und toc funktionieren:

>> tic
        >> toc
        >> toc
        >> dt = toc
        >> tic
        >> toc
        >> toc

Nun versuchen wir folgendes: Während wir die Änderung der Encoderzahl messen, lassen Sie den Motor laufen. Es ist wichtig, dass wir den Startwinkel messen und den Timer gleichzeitig starten. Dazu starten wir den Motor und führen dann beide Aktionen in einem einzigen MATLAB-Befehl durch:

dcm.DutyCycle = 0.5;
        start(dcm)
        startCount = readCount(enc);tic

Als nächstes lesen wir die Encoderzahl erneut aus, während wir gleichzeitig die verstrichene Zeit messen, und stoppen dann den Motor.

stopCount = readCount(enc); dt = toc
        stop(dcm)

Jetzt bestimmen wir die Drehzahl für die Abtriebswelle, zuerst in Zählungen pro Sekunde und dann in Grad pro Sekunde. Verwenden Sie die folgenden Befehle:

>> speed = (stopCount - startCount)/dt
        >> convSpeed = (stopCount - startCount)*360/dt/12/100.37

In diesem Abschnitt schreiben Sie ein MATLAB-Programm, das automatisch die Motordrehzahl misst und gleichzeitig viele verschiedene PWM-Befehle zur Charakterisierung der Reaktion des 100:1 DC-Getriebemotors ausgibt. Später werden Sie diese Beobachtungen nutzen, um den erforderlichen PWM-Befehl zu bestimmen, damit der Motor mit einer gewünschten Drehzahl arbeitet. Mit dem Live Editor erstellen Sie ein MATLAB-live skript, das die folgenden Aufgaben erfüllt:

In diesem Abschnitt werden Sie lernen:

• Wie man Prozesse in MATLAB mit einem Skript automatisiert.
• Wie man Codeabschnitte verwendet, um Skripte in kleinere Teile zu unterteilen.
• Wie man For-Loops verwendet, um Codeblöcke zu wiederholen.
• Wie man Textbeschriftungen und Kommentare verwendet, um MATLAB-Skripte zu organisieren und zu dokumentieren.
• Wie man eine MATLAB-Funktion erstellt und aufruft.

Bis zu diesem Punkt haben Sie Befehle direkt auf der Kommandozeile von MATLAB eingegeben. Wenn Sie bestimmte Operationen mehrmals ausführen, kann es sinnvoll sein, diese Codezeilen in Skripte zu gruppieren, welche Sie bei Bedarf einfach aufrufen können. Diese werden im Fachjargon von MATLAB als live scripts bezeichnet. Beginnen Sie mit dem Öffnen des Live Editor Fensters. Klicken Sie im MATLAB Toolstrip auf New live Script.

Im Fenster des Live Editor können Sie die gleichen MATLAB-Befehle eingeben wie im Command Window und diese dann in Serie ausführen. Starten Sie Ihr live Script, indem Sie ein paar einfache Zeilen Code eingeben:

a = 17
        b = -2
        x = 0:0.5:4
        y = sqrt(x)

Führen Sie Ihr live skript aus, indem Sie auf Run klicken:

Ihre Befehle werden sequentiell ausgeführt. Die Zuweisungsausdrücke ändern die Variablen im MATLAB-Workspace. Untersuchen Sie den Workspace und suchen Sie die neuen Variablen. Wie Sie sehen können, werden die Ergebnisse von Ausdrücken mit nicht unterdrückter Ausgabe in der rechten Spalte angezeigt:

Unterdrücken Sie nun die Ausgabe (die aus dem Hinzufügen eines Strichpunktes am Ende des Befehls besteht) und zeichnen Sie y gegen x, indem Sie den Code Bold gedruckt hinzufügen:

a = 17;
        b = -2;
        x = 0:0.5:4;
        y = sqrt(x);
        
        plot(x,y)
        title('Square roots')

Führen Sie das Skript aus und untersuchen Sie die eingebettete Zahl in der Ausgabespalte. Löschen Sie dann Ihren Workspace im Command Window:

>> clear

Jetzt führen Sie Ihr live skript erneut aus:

Den Workspace untersuchen. Sie sehen, welche Informationen an die Befehlszeile zurückgeschickt werden und welche nicht, je nachdem, ob die Variablen unterdrückt werden oder nicht. Nachdem Sie nun gelernt haben, wie man live skripte verwendet, um eine Reihe von Befehlen mehrmals auszuführen, können wir dieses Wissen nutzen, um mit Gleichstrommotoren zu arbeiten und ihr Verhalten in Bezug auf das an sie angelegte PWM-Signal zu charakterisieren.

Lassen Sie uns mit dem Schreiben unseres Motorcharakterisierungsprogramms beginnen. Löschen Sie den vorhandenen Code in Ihrem live skript und geben Sie die folgenden Zeilen ein, um Ihre Test PWM-Befehlswerte zu definieren:

maxPWM = 1.00;
        incrPWM = 0.05;
        PWMcmdRaw = (-maxPWM:incrPWM:maxPWM)';

Führen Sie Ihr live skript aus und untersuchen Sie Ihren Workspace. Sie haben einen Vektor erstellt, der eine Reihe von Zahlen im Bereich von -1 bis 1 mit Schritten von 0,05 enthält. Das wird verwendet, um das PWM-Signal zu erzeugen, das wir auf den DC-Motor anwenden, um sein Verhalten zu charakterisieren.

Fügen wir nun etwas Code hinzu, um die vier Geräteobjekte zu erstellen und/oder zu initialisieren, die wir für dieses Experiment benötigen: Arduino (a), der Gleichstrommotor (dcm), der Motor Carrier (carrier) und der Encoder (enc). Fügen Sie die folgenden fettgedruckten Codezeilen zu Ihrem live skript hinzu:

maxPWM = 1.00;
        incrPWM = 0.05;
        PWMcmdRaw = (-maxPWM:incrPWM:maxPWM)';
        clear a dcm carrier enc
        a = arduino;
        carrier = addon(a,'Arduino/MKRMotorCarrier');
        dcm = dcmotor(carrier,3);
        enc = rotaryEncoder(carrier,1);
        resetCount(enc);

Führen Sie Ihr live skript erneut aus, um ein korrektes Verhalten sicherzustellen; Sie können die Ergebnisse überprüfen, indem Sie sich den Workspace ansehen. Wenn alles wie erwartet verlaufen ist, enthält Ihr live skript nun alle Objekte, die für die Durchführung des Tests benötigt werden.

Bevor wir mit dem Testen fortfahren, lassen Sie uns das Skript für jemanden, der weniger vertraut mit dem Programm ist, verständlicher machen. Zunächst können Sie das Programm in Abschnitte gliedern, um es in logische Schritte zu unterteilen. Um Ihren Code zu unterteilen platzieren Sie den Textcursor unmittelbar vor dem Befehl clear und klicken Sie auf Section Break.

Als nächstes fügen wir den Abschnitten des live skripts einige Bezeichnungen hinzu, um zu erklären, was jeder einzelne tut. Platzieren Sie Ihren Textcursor am Anfang des Dokuments und klicken Sie auf Text:

Nun können Sie für jeden Abschnitt einen Titel und eine Erklärung hinzufügen. Fügen Sie die folgenden Beschriftungen mit Klartext im Live Editor hinzu. Verwenden Sie die Formatierungsschaltflächen im Textbereich des Toolstrips.

1. Create test data

maxPWM = 1.00;

incrPWM = 0.05;

PWMcmdRaw = (-maxPWM:incrPWM:maxPWM)';

2. Create and initialize device objects

clear a dcm carrier enc

a = arduino;

carrier = addon(a,'Arduino/MKRMotorCarrier');

dcm = dcmotor(carrier,3);

enc = rotaryEncoder(carrier,1);

resetCount(enc);

Alle Teile Ihres live skript, die im Klartext geschrieben sind, haben keinen Einfluss darauf, wie das Skript ausgeführt wird.

Wenn Sie ein live skript in Abschnitte unterteilen, können Sie jeden Abschnitt einzeln ausführen. Dies kann nützlich sein, wenn Sie nur einen Abschnitt testen möchten, ohne das gesamte live skript auszuführen. Sie können auch Abschnitt für Abschnitt durch Ihren Code gehen, um Zwischenergebnisse anzuzeigen und zu analysieren. Platzieren Sie Ihren Textcursor im ersten Abschnitt und klicken Sie auf Run and Advance.

Klicken Sie erneut auf Run and Advance (oder klicken Sie auf Run Section oder Run to End), um die Ausführung des live skripts abzuschließen. Löschen Sie nun Ihren Workspace, und führen Sie Ihren live skript Abschnitt für Abschnitt aus, wobei Sie den Workspace nach der Ausführung jedes Abschnitts überprüfen. Sie können auch Kommentare zu einzelnen Codezeilen hinzufügen, wenn Sie weitere Erklärungen auf einer niedrigeren Ebene hinzufügen möchten. Sie können einen Kommentar direkt im MATLAB-Code beginnen, indem Sie das Prozentzeichen (%) verwenden. Alles, was auf % folgt, wird im live skript nicht ausgeführt. Fügen Sie die folgenden Kommentare zu bestehenden Codezeilen hinzu:

1. Create test data

maxPWM = 1.00;% maximum duty cycle

incrPWM = 0.05;% PWM increment

PWMcmdRaw = (-maxPWM:incrPWM:maxPWM)';% column vector of duty cycles from -1 to 1

2. Create and initialize device objects

clear a dcm carrier enc% delete existing device objects

a = arduino;

carrier = addon(a,'Arduino/MKRMotorCarrier');

dcm = dcmotor(carrier,3);

enc = rotaryEncoder(carrier,1);

resetCount(enc);

Nach diesem kurzen Exkurs, in der Sie gelernt haben, wie Sie Ihren Code besser kommentieren können, um sich leichter zu merken, was jeder Teil des Codes tut, ist es Zeit, das Verhalten des Motors zu testen. MATLAB hilft bei der Automatisierung von Tests. Zuvor haben Sie den Code vorbereitet, indem Sie die Objekte erstellt haben, die mit Arduino, dem Motor Carrier und dem Encoder verbunden sind.

Nun fügen Sie einen neuen Codeabschnitt hinzu, der den Motor mit einem PWM-Wert startet, die Encoderzahl zu zwei verschiedenen Zeiten liest, die Drehzahl ableitet und den Motor stoppt. Fügen Sie den folgenden Abschnitt zu Ihrem live skript hinzu, um die Geschwindigkeit für den ersten PWM-Wert zu messen:

3. Measure raw motor speed for each PWM command

dcm.DutyCycle = 0;

start(dcm)% turn on motor

resetCount(enc);

startCount = readCount(enc);

tic;

dcm.DutyCycle = PWMcmdRaw(1);

pause(1)% wait for steady state

stop(dcm);% turn off motor

dt = toc;

endCount = readCount(enc);

speedRaw(1) = (endCount - startCount) / dt;% calculate speed (cts/s)

dcm.DutyCycle = 0;

Versuchen Sie, diesen Abschnitt mit unterschiedlichen Indexwerten von PWMcmdRaw und speedRaw auszuführen. Im Beispielcode ist der Index 1. Wir nehmen den ersten Index von PWMcmdRaw, senden ihn an den Motor, machen zwei Messungen und speichern die aus der Berechnung resultierende Geschwindigkeit im ersten Element von speedRaw. Untersuchen Sie die Ergebnisse im MATLAB Workspace.

Sie haben jetzt ein live skript, mit dem Sie Geschwindigkeitsmessungen für jeden PWM-Befehlswert erhalten können. Lassen Sie uns diesen Abschnitt des Skripts so verallgemeinern, dass er die Geschwindigkeit für alle Werte im Vektor PWMcmdRaw misst. Sie können Teile Ihres Codes mit einer for-loop wiederholen. Eine for-Schleife ist ein Codeblock, der eine bekannte Anzahl von Ausführungsschritten, die sogenannten Iterationen, durchführt. Um eine for-Schleife zu erstellen, benötigen Sie einen Header (der die Anzahl der Iterationen definiert) und das Endschlüsselwort (das das Ende des sich wiederholenden Codes definiert). Eine for-loop überprüft den Wert einer Indexvariablen, um zu entscheiden, ob die Bedingung, die Schleife zu verlassen, erfüllt ist. Der Index zeigt die aktuelle Iteration an. Hier ist ein einfaches Beispiel für eine for-loop:

for idx = 1:10

y(idx) = (2 + idx) / idx;

end

Diese for-loop wird für 10 Iterationen ausgeführt, und die Indexvariable idx nimmt während jeder Iteration einen neuen Einzelwert von 1 bis 10 an.

In unserem Fall möchten Sie alle Elemente des PWMcmdRaw durchlaufen und bei jeder Iteration eine neue Geschwindigkeitsmessung durchführen. Das Ergebnis sollte ein Vektor sein, der die gleiche Größe wie PWMcmdRaw hat. Fügen Sie wie unten gezeigt Ihrem Code einen for-loop-Header und ein end keyword hinzu. Denken Sie daran, die Kennzahlen in PWMcmdRaw und speedRaw auf die Indexvariable ii zu aktualisieren.

3. Measure raw motor speed for each PWM command

dcm.DutyCycle = 0;

start(dcm)% turn on motor

for ii = 1:length(PWMcmdRaw)

resetCount(enc);

startCount = readCount(enc);

tic;

dcm.DutyCycle = PWMcmdRaw(ii);

start(dcm)% turn on motor

pause(1)% wait for steady state

stop(dcm); % turn off motor

dt = toc;

endCount = readCount(enc);

speedRaw(ii) = (endCount - startCount) / dt;% calculate speed (cts/s)

pause(1);

end

stop(dcm) % turn off motor

dcm.DutyCycle = 0;

Führen Sie den Abschnitt aus und stellen Sie sicher, dass alle möglichen PWM-Werte in PWMcmdRaw getestet werden. An dieser Stelle sollte das live editor Fenster eine Warnung bei der Zuordnung zu speedRaw(ii) anzeigen. Fahren Sie mit der Maus über die speedRaw-Variable im Live Editor-Fenster, um Details zur Warnung zu sehen:

Die Warnung erscheint, weil das Skript Werte für steigende Kennzahlen von speedRaw zuweist und speedRaw daher bei jeder Iteration seine Größe erhöht, um das neue Element aufzunehmen. In einigen Fällen kann dies zu Performance-Problemen führen, da der Speicher der Variablen möglicherweise mehrfach neu aktiviert werden muss. Sie können dieses Problem lösen, wenn Sie wissen, wie groß das Array sein wird, indem Sie den Vektor im Voraus definieren.

Bevor Sie ein Array innerhalb einer for-loop zuweisen, sollten Sie den Array Speicher zuweisen. Dadurch vermeiden Sie, dass innerhalb der Schleife die Größe des Array-Speichers verändert werden muss. To this purpose will frequent the function zero used. Fügen Sie die folgende fett gedruckte Codezeile ein, um Platz für speedRaw zu reservieren, bevor Sie Werte zuordnen:

3. Measure raw motor speed for each PWM command

speedRaw = zeros(size(PWMcmdRaw)); % Pre-allocate vector for speed measurements

dcm.DutyCycle = 0;

start(dcm)% turn on motor

for ii = 1:length(PWMcmdRaw)

resetCount(enc);

startCount = readCount(enc);

tic;

dcm.DutyCycle = PWMcmdRaw(ii);

start(dcm)% turn on motor

pause(1)% wait for steady state

stop(dcm);% turn off motor

dt = toc;

endCount = readCount(enc);

speedRaw(ii) = (endCount - startCount) / dt;% calculate speed (cts/s)

pause(1);

end

stop(dcm)% turn off motor

dcm.DutyCycle = 0;

Jetzt sind in Ihrem Workspace einige echte Geschwindigkeitsmessungen möglich. Lassen Sie uns diese mit Hilfe des Befehls plot, in Bezug auf den entsprechenden PWM-Befehlswert grafisch darstellen. Den plot Befehl haben Sie bereits kennengelernt. Fügen Sie den folgenden Abschnitt zu Ihrem live skript hinzu, um die Rohdaten zu zeichnen und zu kommentieren:

4. Graph raw data

plot(PWMcmdRaw,speedRaw)% raw speed measurements

title('100:1 Gearbox Motor Steady State Response')

xlabel('PWM Command')

ylabel('Measured Speed (counts/sec)')

Führen Sie den Abschnitt aus und untersuchen Sie die Abbildung in der Ausgabespalte des Live Editors:

Beachten Sie einige interessante Merkmale der Geschwindigkeit-PWM-Beziehung, die Sie aus der Grafik ableiten können. Es gibt eine "Totzone" um PWM=0, in der die Drehzahl gleich Null für PWM-Befehle ungleich Null ist. Darüber hinaus kann es einige nicht-monotone Abschnitte der Kurve geben, in denen die gemessene Geschwindigkeit mit zunehmendem PWM-Befehl nicht zunimmt. Dies geschieht typischerweise um PWM = +/-1. Das kann aber auch auf experimentelle Fehler zurückzuführen sein.

Das Sammeln dieser Daten wird später relevant sein, wenn Sie eine komplexere Maschine mit mehreren Motoren modellieren wollen. Später werden Sie in Simulink ein Motorsteuerungssystem erstellen, in dem ein Benutzer eine Motordrehzahl in Umdrehungen pro Sekunde anfordert. Das System berechnet den erforderlichen PWM-Befehl, um den Motor mit dieser Geschwindigkeit zu betreiben und sendet ihn an das Arduino Board. Um diesen Vorgang korrekt durchzuführen, benötigt die Steuerung den direkten Zusammenhang (1:1) zwischen Motordrehzahlen und PWM-Befehlen. Das bedeutet, dass es nur einen PWM-Befehl pro Geschwindigkeit geben kann, so dass Sie wiederholte Werte und nicht steigende Werte aus den Daten entfernen müssen. Zuerst müssen Sie feststellen, welche Werte von speedRaw nicht in aufsteigender Reihenfolge sind. Untersuchen Sie speedRaw im Command Window :

>> speedRaw

Suchen Sie die Nullen in den Geschwindigkeitsmessungen und suchen Sie nach nicht steigenden Werten.

Es ist nicht leicht zu erkennen, wo die nicht steigenden Werte liegen, also lassen Sie uns einen Unterschied erster Ordnung machen. Geben Sie den folgenden Befehl ein:

>> diff(speedRaw)

Dies wird mit einem weiteren Vektor beantwortet, der die Unterschiede zwischen den Wertepaaren im Array anzeigt. Um nicht steigende Werte in speedRaw zu entfernen, müssen Sie die Kennzahlen kennen, bei denen diff(speedRaw) nicht positiv ist. Dazu können Sie mit Hilfe von Vergleichsoperatoren eine logische Bedingung erstellen. Geben Sie die folgenden logischen Ausdrücke ein und interpretieren Sie das Ergebnis:

>> pi > 3
        >> pi >= 3
        >> pi == 3
        >> pi < 3
        >> x = 1:5
        >> x == 3
        >> x < 3
        >> y = x < 3

Für die erste Hälfte der vorherigen Befehle (alle, die sich auf pi beziehen) ergeben die Operationen ein anderes Ergebnis, basierend auf der Ebene der Wahrheit der Aussage.

Für den zweiten Satz von Operationen (diejenigen, die sich auf die Variablen x und y beziehen) sind die Ergebnisse unterschiedlich, da x ein Array mit den Zahlen 1 bis 5 ist. Untersuchen Sie x und y in Ihrem Workspace. Der numerische Vektor x hat die gleiche Größe wie der logische Indexvektor y. Sie können einen logischen Indexausdruck oder eine Variable verwenden, um in eine Variable der gleichen Größe zu indizieren. Versuchen Sie die folgenden Befehle:

>> x(y)
        >> x(~y)
        >> z = rand(1,5)
        >> z(y)

Jetzt bekommen wir die logischen Kennzahlen und Werte von speedRaw, wo es stätisch anwächst. Geben Sie die folgenden Befehle ein:

>> idx = diff(speedRaw) > 0
        >> speedMono = speedRaw(idx);

Wie ist die Größe von speedMono im Vergleich zu speedRaw? Sie sind unterschiedlich. Überlegen Sie, warum dies der Fall ist. Hinweis: Um Hilfe zu den integrierten MATLAB-Funktionen wie diff, rand und tic zu erhalten, verwenden Sie den Befehl doc, um auf die Dokumentation zuzugreifen. Zum Beispiel:

>> doc diff

Die Dokumentation zu jeder Funktion zeigt Ihnen die verschiedenen Aufrufmöglichkeiten der Funktion und Beispiele für jede Syntax.

Soweit haben Sie eine gleichmäßige Version der Geschwindigkeitsmessungen gemacht. Das birgt aber einige Probleme. Erstens, wie richten Sie nun die PWM-Befehlswerte auf den neuen Geschwindigkeitsvektor aus, wenn sie unterschiedlich groß sind? Sie können den gleichen logischen Index verwenden, um die entsprechenden PWM-Werte zu isolieren. Verwenden Sie den folgenden Befehl, um die PWM-Werte zu filtern und sowohl die Roh- als auch die gefilterten Werte darzustellen:

>> PWMcmdMono = PWMcmdRaw(idx);

>> plot(PWMcmdRaw,speedRaw,PWMcmdMono,speedMono)

Um ein zweites Problem zu veranschaulichen, das bei der Nachbearbeitung der vom Motor erhaltenen Informationen auftritt, geben Sie die folgenden Befehle ein:

>> speedMono == 0

>> PWMcmdMono(speedMono == 0)

Aufgrund der Art und Weise, wie wir die nichtstätischen Punkte herausgefiltert haben, soll eine Geschwindigkeit von Null durch einen PWM-Wert von ungleich Null erreicht werden. Obwohl das Anweisen eines ausreichend kleinen PWM-Wertes aufgrund von Reibung zu einer Stillstand des Motors führt, würde es Energie verschwenden. Das tritt insbesondere dann auf, wenn das System lange Zeit mit einer Drehzahl von Null beaufschlagt wird. Daher sollten Sie den Wert von PWMcmdMono auf 0 ändern, was zum gleichen Ergebnis führt. Geben Sie den folgenden Befehl ein:

 :

>> PWMcmdMono(speedMono == 0) = 0;

Lassen Sie uns die Nachbearbeitung in das live skript integrieren. Fügen Sie einen neuen Abschnitt vor dem Abschnitt mit der Bezeichnung Graph Raw Data hinzu und geben Sie den folgenden Code ein:

4. Post-process and save data

idx = (diff(speedRaw) > 0);% find indices where vector is increasing

speedMono = speedRaw(idx);% Keep only increasing values of speed

PWMcmdMono = PWMcmdRaw(idx);% Keep only corresponding PWM values

PWMcmdMono(speedMono == 0) = 0;% enforce zero power for zero speed

save motorResponse PWMcmdMono speedMono% save post-processed measurements

Aktualisieren Sie nun den Abschnitt Graph Raw Data, um sowohl die Rohdaten als auch die nachbearbeiteten Daten aufzunehmen. Fügen Sie die Bold-gedruckten Codezeilen wie folgt hinzu:

5. Graph raw and post-processed data

plot(PWMcmdRaw,speedRaw)% raw speed measurements

hold on

plot(PWMcmdMono,speedMono)% non-monotonic measurements filtered out

title('100:1 Gearbox Motor Steady State Response')

xlabel('PWM Command')

ylabel('Measured Speed (counts/sec)')

legend('Raw Data','Monotonic Data')

Löschen Sie schließlich alle Geräteobjekte, um das MKR1000 Board für den Einsatz in anderen Prozessen freizugeben. Fügen Sie den folgenden Abschnitt am Ende Ihres live skript hinzu:

6. Delete device objects

clear a dcm carrier enc

Sie haben jetzt ein voll funktionsfähiges live skript, das automatisch eine Reihe von Messungen durchführt, diese Messungen nachbearbeitet, die experimentellen Daten auf Festplatte speichert und die Ergebnisse darstellt. Möglicherweise möchten Sie diese Analyse mehrmals für den gleichen Motor oder vielleicht für andere Gleichstrommotoren wiederholen. Sie können Ihr live skript als .mlx Datei speichern, so dass Sie es später erneut ausführen oder mit anderen MATLAB-Benutzern teilen können. Speichern Sie Ihr live skript als myMotorCharacterization.mlx. Eine .mlx Datei enthält nicht nur Ihre Code- und Textanmerkungen, sondern auch alle numerischen oder grafischen Ergebnisse, die in der Ausgabespalte angezeigt wurden. So ist Ihr live skript ein aktiver Bericht über Ihre Analysen und Ergebnisse. Erinnern Sie sich daran, dass Sie Ihr live skript in seiner Gesamtheit ausführen können, indem Sie die Schaltfläche Run im Live Editor Fenster verwenden:

Sie können das live skript auch direkt im Command Window ausführen, indem Sie seinen Namen als Befehl verwenden. Versuchen Sie, Ihr live skript auszuführen:

>> myMotorCharacterization

Betrachten Sie Ihren Workspace. Welche der vorhandenen Variablen sind für Sie nützlich? Welche Variablen sind Zwischenwerte aus Ihrem live skript, die Sie nicht mehr benötigen?

Sie können Teile Ihres MATLAB-Programms in Funktionen unterteilen, so dass die Zwischenberechnungen ausgeblendet werden und Sie nur die Ein- und Ausgänge verwalten müssen.

Betrachtet man Ihr live skript, so sind die ersten beiden Abschnitte spezifisch für den Gleichstrommotor, Encoder und Testfall (PWMcmdRaw). Die folgenden drei Abschnitte (Messung der Rohmotordrehzahl für jeden PWM-Befehl, Nachbearbeitung und Speicherung von Daten und grafische Darstellung von Roh- und Nachbearbeitung) können für jeden Gleichstrommotor, Encoder und Testfall verallgemeinert werden. Lassen Sie uns eine MATLAB-Funktion für diesen Code erstellen. Sie starten im Fenster des Live Editor, indem Sie auf New>Live Function klicken.

Als nächstes müssen Sie bestimmen, was die Ein- und Ausgaben Ihrer Funktion sind. Abschnitt 3 Ihres live skripts erfordert den Testvektor PWMcmdRaw, das DC-Motorobjekt dcm und das Encoderobjekt enc

Die nächste Codezeile ist ein Beispiel für einen möglichen Funktions-Header. Platzieren Sie die Eingaben in Klammern ( () ) mit den drei oben aufgeführten Variablen:

function z = Untitled(PWMcmdRaw,dcm,enc)

NÜberlegen Sie sich nun, auf welche Variablen Sie über den Algorithmus zur Motorcharakterisierung zugreifen möchten. Die einzigen sinnvollen Variablen, die in diesen Abschnitten erstellt werden, sind PWMcmdMono und speedMono. Listen Sie diese beiden Variablen in der Funktions-Header als Ausgaben in eckigen Klammern ([]) auf.

function [PWMcmdMono,speedMono] = Untitled(PWMcmdRaw,dcm,enc)

Abschließend benennen wir die Funktion so, dass wir wissen, wie man sie im MATLAB-Code aufruft. Ersetzen Sie den Funktionsnamen durch myMotorFunction:

function [PWMcmdMono,speedMono] = myMotorFunction(PWMcmdRaw,dcm,enc)

Nun füllen ergänzen sie den Algorithmus durch Ausschneiden und Einfügen der Abschnitte 3, 4 und 5 aus Ihrem live skript in Ihre live-Funktion, zwischen dem Funktions-Header und dem end-Schlüsselwort.

function [PWMcmdMono,speedMono] = myMotorFunction (PWMcmdRaw,dcm,enc)

3. Measure raw motor speed for each PWM command

speedRaw = zeros(size(PWMcmdRaw));% Preallocate vector for speed measurements

dcm.DutyCycle = 0;

start(dcm)% turn on motor

for ii = 1:length(PWMcmdRaw)

resetCount(enc);

startCount = readCount(enc);

tic;

dcm.DutyCycle = PWMcmdRaw(ii);

start(dcm)% turn on motor

pause(1)% wait for steady state

stop(dcm);% turn off motor

dt = toc;

endCount = readCount(enc);

speedRaw(ii) = (endCount - startCount) / dt;% calculate speed (cts/s)

pause(1);

end

stop(dcm)% turn off motor

dcm.DutyCycle = 0;

4. Post-process and save data

idx = (diff(speedRaw) > 0);% find indices where vector is increasing

speedMono = speedRaw(idx);% Keep only increasing values of speed

PWMcmdMono = PWMcmdRaw(idx);% Keep only corresponding PWM values

PWMcmdMono(speedMono == 0) = 0;% enforce zero power for zero speed

save motorResponse PWMcmdMono speedMono% save post-processed measurements

5. Graph raw and post-processed data

plot(PWMcmdRaw,speedRaw)% raw speed measurements

hold on

plot(PWMcmdMono,speedMono)% non-monotonic measurements filtered out

title('100:1 Gearbox Motor Steady State Response')

xlabel('PWM Command')

ylabel('Measured Speed (counts/sec)')

legend('Raw Data','Monotonic Data')

end

Speichern Sie die Datei unter myMotorFunction.mlx. Jetzt haben Sie eine funktionierende MATLAB-Funktion, die Sie aus jeder MATLAB-Code-Umgebung aufrufen können. Lassen Sie uns versuchen, es von Ihrem live skript aus aufzurufen. Geben Sie im leeren Abschnitt Ihres live skripts den Aufruf Ihrer Funktion ein:

1. Create test data

maxPWM = 1.00;% maximum duty cycle

incrPWM = 0.05;% PWM increment

PWMcmdRaw = (-maxPWM:incrPWM:maxPWM)';% column vector of duty cycles from -1 to 1

2. Create and initialize device objects

clear a dcm carrier enc% delete existing device objects

a = arduino;

carrier = addon(a,'Arduino/MKRMotorCarrier');

dcm = dcmotor(carrier,3);

enc = rotaryEncoder(carrier,1);

resetCount(enc);

3-5. Call motor characterization function

[PWMcmdMono,speedMono] = myMotorFunction(PWMcmdRaw,dcm,enc);

6. Delete device objects

clear a dcm carrier enc

Führen Sie nun Ihr live skript aus und stellen Sie sicher, dass es weiterhin wie bisher funktioniert.

Um die Vorteile der MATLAB-Funktionen besser zu verstehen, löschen Sie Ihren Workspace im Command Window und führen Sie Ihr live skript erneut aus.

>> clear

>> myMotorCharacterization

Untersuchen Sie Ihren Workspace. Die Liste der Variablen sollte nun übersichtlicher sein. Es gibt noch eine weitere Sache, die man in dieser Funktion verallgemeinern möchte. Das wäre der Name der MAT-Datei, die wir im Save-Befehl verwenden. Ab sofort werden die Analysedaten bei jedem Aufruf der Funktion in der gleichen MAT-Datei, motorResponse.mat, gespeichert. Dies ist nicht sehr sinnvoll, wenn Sie mehrere DC-Motoren charakterisieren möchten. Fügen wir deshalb der Funktion für den Dateinamen eine neue Eingabe hinzu. Setzen Sie das in der live-Funktion mit einem neuen Eintrag wie unten gezeigt um:

function [PWMcmdMono,speedMono] = myMotorFunction(PWMcmdRaw,dcm,enc,filename)

Verwenden wir nun die neue Eingabe im Speicherbefehl. Schreiben Sie den Speicherbefehl wie folgt neu:

save(filename,'PWMcmdMono','speedMono')% save post-processed measurements

Schließlich müssen wir den Funktionsaufruf ändern, da sich der Funktions-Header geändert hat. Ändern Sie im live skript den Funktionsaufruf wie folgt:

[PWMcmdMono,speedMono] = myMotorFunction(PWMcmdRaw,dcm,enc,'motorResponse');

Nun können Sie die Analysedaten bei jedem Aufruf von myMotorFunction in einer beliebigen MAT-Datei speichern. Versuchen Sie, Ihr live skript noch einmal aufzurufen:

>> myMotorCharacterization

MATLAB ermöglicht es Ihnen, eine ganze Reihe von Operationen an Daten mit Code als Schnittstelle durchzuführen. Simulink bietet eine Visual Programming Language (VPL), um Daten zu routen, zu verarbeiten, zu speichern und die Ergebnisse an andere Programme, an MATLAB-Skripte und sogar Arduino Boards zu senden. Simulink basiert auf der Verwendung eines Fluss-Diagramm-Programmierparadigmas.

Eine der aufregendsten Funktionen der Simulink VPL ist die Möglichkeit, Programme zu entwerfen, die direkt aus der MATLAB IDE heraus auf Arduino Boards hochgeladen werden können. In diesem Abschnitt erhalten Sie eine kurze Einführung in Simulink und die Handhabung.

In diesem Abschnitt werden Sie lernen:

• Wie man ein Simulink Modell erstellt, simuliert und speichert.
• Wie man Blöcke in einem Simulink Modell hinzufügt und entfernt.
• Wie man Blöcke in einem Blockdiagramm verbindet.
• Wie man Blöcke und Signale kennzeichnet.
• Wie man Blockparameterwerte setzt.
• Wie man Simulationsdaten in der Simulink-Umgebung visualisiert.
• Wie man die Abtastrate des Blocks in einem Simulink Modell einstellt.
• Wie man einem Simulink Modell mit Subsystemen eine Blockhierarchie hinzufügt.

Sie haben nun experimentelle Daten, die das Verhältnis zwischen der Drehzahl des 100:1-Getriebemotors und der angelegten Spannung über den PWM-Befehl definieren. Beginnen wir mit dem Entwurf einer Motorsteuerung, die die gewünschte Drehzahl des Benutzers als Eingabe nimmt und den notwendigen PWM-Befehl bestimmt, um diese Drehzahl zu erreichen. Sie werden Simulink verwenden, um dieses System zu modellieren und zu simulieren. Im nächsten Abschnitt werden Sie Ihr Simulink Modell direkt auf dem MKR1000 Board ausführen. Lassen Sie uns visualisieren, wie dieses Steuerungssystem funktionieren wird:

In diesem Diagramm stellen die Blöcke eine bestimmte Funktionalität oder einen Prozess und die Pfeile stellen den Datenfluss dar. Die Richtungsabhängigkeit der Pfeile gibt an, welcher Prozess die Daten erzeugt und wo die Daten verwendet werden. Mit Simulink können Sie Ihren Algorithmus als Blockdiagramm erstellen und über einen längeren Zeitraum ausführen.

Starten wir die Simulink-Umgebung. Klicken Sie im MATLAB-Desktop auf die Schaltfläche Simulink:

Klicken Sie im Fenster Simulink Start Page auf Blank Model, um den Simulink Editor zu öffnen:

Nun fügen wir einige Blöcke zum Modell-Bereich hinzu. Sie können alle eingebauten Simulink-Blöcke mit dem Simulink Library Browser finden.Öffnen Sie wie unten gezeigt den Simulink Library Browser, indem Sie auf die Schaltfläche Library Browser in der Symbolleiste klicken:

Im linken Bereich zeigt der Simulink Library Browser eine Liste der Add-On-Produkte an, in denen jeweils eine Reihe von libraries zur Verfügung gestellt werden. Während der gesamten Projekte im Arduino Engineering Kit verwenden Sie Blöcke aus mehreren Bibliotheken, darunter grundlegende Simulink blocks und Simulink Support Package for Arduino Hardware. Untersuchen Sie die Sources Bibliothek unter Simulink.

Diese Blöcke dienen als Eingänge zu einem Simulink Blockdiagramm. Beachten Sie, dass sie alle dreieckige Ports auf ihrer rechten Seite haben. Diese werden als outports bezeichnet und ermöglichen es Ihnen, Signale an ihrem Ursprung zu verbinden. Um Ihr Motorsteuerungssystem zu testen, verwenden Sie eine Sinuswelle, um die eingegebene Drehzahl zu simulieren. Suchen Sie den Sine Wave Block und ziehen Sie ihn aus dem Simulink Library Browser Fenster in das Simulink Editor Fenster.

Als nächstes müssen Sie das Geschwindigkeitssignal des Benutzers aus dem Sine Wave Block in ein PWM-Signal zwischen -1 und 1 umwandeln, indem Sie eine Nachschlagetabelle verwenden, die mittels interpolation zwischen bekannten Datenpunkten einen Ausgabewert für einen beliebigen Eingangswert ermittelt. Wir werden das in Kürze näher erläutern. Suchen Sie den Block 1-D Lookup Table block in Simulink > Lookup Tables und ziehen Sie ihn in das Fenster Simulink Editor.

Der Lookup Table gibt PWM-Befehlswerte zwischen -1 und 1 aus. Abschließend übermitteln Sie der DC-Motorhardware die Größe des Tastverhältnisses über 8-Bit Integer im Bereich von 0 bis 255. Um sich auf diese Skalierung vorzubereiten, benötigen Sie einen Gain Block. Ein Gain Block multipliziert ein Simulink-Signal mit einem konstanten Wert. Fügen Sie einen Gain Block aus Simulink > Math Operations hinzu:

Fügen Sie nun einen Block hinzu, um die Ausgabe der Lookup-Tabelle zu visualisieren. Untersuchen Sie die Simulink > Sinks Bibliothek.

Diese Blöcke stellen Ausgänge in Ihrem Blockdiagramm dar. Beachten Sie, dass diese Blöcke im Allgemeinen einen dreieckigen Port nach innen auf der linken Seite haben, der als inport bekannt ist. Block Inports ermöglichen Ihnen, ein Signal zu beenden (terminate). Ziehen Sie einen Scope Block in Ihr Modell:

Nun müssen Sie die Blöcke über signals verbinden. Klicken Sie mit der linken Maustaste auf den outport und ziehen Sie ihn in den inport, und wenn die signals Verbindung eine feste Verbindung herstellt, haben Sie das Signal angeschlossen und können das Klicken und Ziehen stoppen.

Konfigurieren wir nun die Blöcke, um Ihren spezifischen Algorithmus auszuführen. Der Sine Wave Block muss Geschwindigkeitswerte in Zählungen pro Sekunde erzeugen. Überprüfen Sie den Drehzahlbereich, den Sie für den Motor gemessen haben; schauen Sie sich dazu die Datendateien an, die Sie im Abschnitt MATLAB dieses Kapitels erzeugt haben, indem Sie die folgenden Befehle im command window ausführen:

>> load motorResponse

>> min(speedMono)

>> max(speedMono)

Hinweis: Wenn Sie die Datei motorResponse.mat nicht generiert haben, führen Sie den Befehl >> arduinosetup aus. Konfigurieren Sie dann den MKR1000 wie in "Konfiguration von Arduino-Bibliotheken" beschrieben und führen Sie den Befehl >> characterizeMotorScript aus, um die Motorreaktion zu charakterisieren. Führen Sie dann die obigen Befehle aus. Doppelklicken Sie auf den Sine Wave Block, um den block parameter dialog zu öffnen. Konfigurieren Sie die Sinuswelle so, dass sie eine Amplitude von 6000 hat, um den Bereich der gemessenen Geschwindigkeiten abzudecken. Klicken Sie dann auf OK:

Richten wir nun den lookup table ein, um die Geschwindigkeiten den PWM-Befehlen zuzuordnen. Während der Simulation verwendet der Block lineare Interpolation, um den Wert des PWM-Befehls für eine beliebige Geschwindigkeit zu schätzen:

Doppelklicken Sie auf den Block 1-D Lookup Table, um den Blockparameterdialog zu öffnen. Setzen Sie Table data auf PWMcmdMono und Breakpoints auf speedMono. Klicken Sie dann auf OK:

Sobald Sie die lookup table Daten gesetzt haben, zeigt der Block eine Grafik Ihrer lookup table vectors an:

Lassen Sie uns nun das PWM-Tastverhältnis auf einen Bereich von -255 bis 255 erweitern, um später mit dem Motortreiber kompatibel zu sein. Doppelklicken Sie auf den Gain Block und stellen Sie Gain auf 255. Klicken Sie dann auf OK:

Somit haben Sie ein Simulink Modell erstellt, das ein Signal erzeugen kann, das Sie später an die MKR-Platine senden können, um die Drehzahl eines mit dem MKR Motor Carrier verbundenen Motors zu steuern.

Lassen Sie uns den Algorithmus simulieren, den Sie gerade erstellt haben. Klicken Sie auf die Schaltfläche Run:

Doppelklicken Sie nach Abschluss der Simulation auf den Block Scope, um die skalierten PWM-Werte anzuzeigen:

Sie sollten damit rechnen, eine vertikal verzerrte Version einer Sinuswelle zu sehen, wenn der Geschwindigkeitsbefehl in den entsprechenden PWM-Wert umgewandelt wird. Noch informativer wäre es, gleichzeitig die Eingangsdrehzahl und den PWM-Befehl anzuzeigen. Sie müssen das Geschwindigkeitseingangssignal an den Scope weiterleiten, unterhalb des vorhandenen Inports. Dazu müssen Sie das Drehzahleingangssignal verzweigen (branch). Klicken Sie mit der rechten Maustaste auf die Signalleitung des Geschwindigkeitseingangs und halten Sie die rechte Maustaste gedrückt, und ziehen Sie sie dann auf den Block Scope. Ein zweiter inport wird automatisch für Sie erstellt:

Gehen Sie zum Scope Fenster und klicken Sie auf View > Layout, und stellen Sie das Achsenlayout auf 2 x 1 ein, wie in der Abbildung unten gezeigt:

Zurück zum Fenster Simulink Editor:

Führen Sie das Modell erneut aus und untersuchen Sie den Zusammenhang zwischen PWM-Befehl und Eingangsgeschwindigkeit:

Genau wie Sie Ihr live skript kommentiert haben, um zu kommunizieren, wie Ihr Programm funktioniert, können Sie auch ein Simulink Modell kommentieren, um es anderen zu erklären. Zuerst lassen Sie uns die Blöcke beschriften. Standardmäßig zeigen Blöcke keinen Blocknamen an. Klicken Sie auf den Sine Wave Block und ändern Sie dessen Bezeichnung in speedInput:

Beschriften Sie auch die nächsten beiden Blöcke wie im folgenden Bild gezeigt:

Sie können auch Signale beschriften, um anzugeben, welche Menge sie darstellen. Doppelklicken Sie auf jede Signalleitung und fügen Sie die folgenden Bezeichnungen hinzu:

Die Simulation läuft derzeit in kontinuierlicher Zeit. Das bedeutet, dass alle Signale als kontinuierlich variierende Werte behandelt werden. Visualisierungen wie des Scope Blocks zeigen Signale als glatte Kurven an (obwohl es sich eigentlich um eine Reihe von diskreten Punkten handelt, die durch gerade Linien verbunden sind). Bald werden Sie diesen Algorithmus hochladen und auf dem Arduino Board ausführen, das in diskreter Zeit ausgeführt wird. Das heißt, die Signalwerte werden in regelmäßigen Abständen berechnet und aktualisiert. Lassen Sie uns das Modell so anpassen, dass es in diskreter Zeit simuliert, so dass wir verstehen, wie es später auf dem MKR1000 Board funktionieren wird. Dazu stellen Sie im Dialogfeld für die Parameter des Sine Wave Blocks die Sample time auf Ts ein und klicken Sie auf OK:

Definieren Sie nun Ts im Command Window:

>> Ts = 0.1;

Führen Sie die Simulation aus und untersuchen Sie den scope:

Beachten Sie, dass die Signale nun als flache Werte angezeigt werden, die für die gesamte Abtastzeit von 0,1 Sekunde gelten. Bei der Modellierung mit diskreten Abtastzeiten in Simulink ist es hilfreich, das Modell nach Abtastrate farblich zu kodieren. Klicken Sie dazu auf Anzeigen > Sample Time > Colors:

Drücken Sie Crtl+J im Modellfenster, um eine Legende der Farben der Sample time anzuzeigen. Beachten Sie, dass dieses Modell nur eine diskrete Rate hat und vollständig aus der Sample Time Eigenschaft des Sine Wave Blocks abgeleitet ist. In diesem Unterabschnitt haben Sie gelernt, wie man ein Modell in kontinuierlichen und diskreten Zeiten simuliert. Dies ist notwendig, um zu verstehen, wie der von Ihnen für Simulink erstellte Code später auf einem Arduino Board ausgeführt wird.

Um diese Lektion abzuschließen, lassen Sie uns das Modell organisieren. Sie können ein Blockdiagramm in kleinere Einheiten, sogenannte subsystems, unterteilen. Dies ist wichtig, wenn die Komplexität Ihres Modells zunimmt, damit es besser lesbar ist. Die bisher hinzugefügten Blöcke umfassen die Motorsteuerung (controller). Später werden wir der Steuerung mehr Komplexität verleihen, aber im Moment können wir sie in einen einzigen Subsystem Block packen. Klicken Sie mit der linken Maustaste und ziehen Sie ein Kästchen über den Block Lookup Table und den Gain Block:

Klicken Sie nun mit der rechten Maustaste auf einen der ausgewählten Blöcke und wählen Sie Create Subsystem from Selection. Ändern Sie die Größe des Blocks, so dass die Port-Bezeichnungen sichtbar sind:

Schließlich benennen Sie den subsystem Block um in Controller:

Beachten Sie, dass die Port-Labels von den ursprünglichen Signal-Labels abgeleitet wurden. Doppelklicken Sie auf den Block Controller, um den Inhalt anzuzeigen:

Klicken Sie nun auf den Modellnamen in der linken oberen Ecke, um zur obersten Ebene des Modells zurückzukehren:

Führen Sie das Modell aus und betrachten Sie den Scope, um zu bestätigen, dass er sich weiterhin wie zuvor verhält.

Speichern Sie nun Ihr Modell als myDCMotorControl.slx .

Während Sie C-Code schreiben können, um ihn auf Arduino Boards hochzuladen, bietet Simulink eine großartige Schnittstelle, um Boards direkt aus seiner UI heraus zu programmieren. Die Simulink-Blöcke können in Code übersetzt werden, der kompiliert und auf das Board hochgeladen werden kann. Diese Funktion, die wir hier vorstellen, wird später in den Projekten genutzt. In diesem Abschnitt werden Sie lernen:

• Wie man externe Sensoren und Aktoren in einem Simulink Modell implementiert.
• Wie man grundlegende mathematische und diskrete Dynamiken in Simulink modelliert.
• Wie man Signale in einem Simulink Modell so konditioniert, dass sie mit Ein- und Ausgabeformaten externer Geräte kompatibel sind.
• Wie man eine funktionierende Arduino-Anwendung aus einem Simulink Modell erstellt und ausführt.
• Wie man Modellparameter anpasst, während die Anwendung auf Arduino läuft, und die Ergebnisse interpretiert.
• Den Unterschied zwischen Open-Loop- und Closed-Loop-Regelung.
• Wie man eine Arduino-Anwendung als eigenständiges Programm außerhalb von Simulink ausführt.

In dieser Lektion werden Sie Ihrem Simulink Modell Gerätetreiberblöcke hinzufügen, um mit dem Getriebemotor DC 100:1 und dem magnetischen Encoder zu kommunizieren. Sie führen Ihre Anwendung direkt auf der MKR1000 Hardware aus und kommunizieren mit dem Board über Ihr Simulink Modell.

In diesem Abschnitt werden Sie die Steuermechanismen von offenen und geschlossenen Regelkreisen für Motoren untersuchen. Wenn Sie eine kurze Einführung in diese benötigen, gehen Sie nach unten zu Abschnitt 2.3.2.2.3, wo wir die Konzepte vorstellen werden. Sie können dies auch in den verschiedenen Projekten anschauen, in denen diese Controller in spezifischeren Szenarien implementiert sind.

Beginnen Sie, indem Sie Ihr Motorsteuerungsmodell aus der vorherigen Lektion öffnen (falls es nicht bereits geöffnet ist) und Ihre Analysedaten laden:

>> myDCMotorControl

>> load motorResponse

>> Ts = 0.1;

Werfen wir nun einen Blick auf die Arduino Device Driver Blöcke. Navigieren Sie im Simulink Library Browser zu Simulink Support for Arduino MKR Motor Carrier und betrachten Sie die enthaltenen Blöcke:

Beginnen wir mit der Kommunikation mit dem Gleichstrommotor. Suchen Sie den Block M3M4DCMotors in der Simulink Support for Arduino MKR Motor Carrier Bibliothek und ziehen Sie ihn in Ihr Modell:

Der M3M4DCMotors Block benötigt ein Eingangssignal, d.h. den Antriebsbefehl, ausgedrückt als Wert zwischen -255 und 255. Doppelklicken Sie auf den Block M3M4DCMotors und konfigurieren Sie ihn wie in der folgenden Abbildung gezeigt:

Die Eigenschaft motor port bildet den Block auf einen von zwei markierten DC-Motorports (M3 oder M4) am Motorträger ab. Erstellen Sie einen neuen Zweig des driveCmd Signals, indem Sie mit der rechten Maustaste klicken und die Maus von der Signalleitung ziehen, und leiten Sie das Signal in den Block M3M4DCMotors:

Sie sind fast soweit, den Software Controller auf dem MKR1000 Board zu betreiben! Zuerst müssen Sie das Modell so konfigurieren, dass es auf Arduino läuft. Öffnen Sie das Fenster Configuration Parameters, indem Sie auf die Schaltfläche "gear" klicken:

Configuration Parameters bieten eine Reihe von Optionen, mit denen Sie Ihre Simulation konfigurieren können, wie sie ablaufen soll, auf welcher Hardware Sie sie ausführen und wie der Modellalgorithmus mit verschiedenen Laufzeitbedingungen umgehen soll. Navigieren Sie zum Bereich Hardware Implementation und stellen Sie Hardware Board auf Arduino MKR1000 ein:

Gehen Sie zu Target hardware resources > External mode > Communication interface und wählen Sie wie die Option Serial

Wenn Sie das Modell so einstellen, dass es auf einer bestimmten Platine läuft, werden einige der anderen Optionen unter Configuration Parameters bei Bedarf automatisch eingestellt. Klicken Sie auf OK, um zum Modellfenster zurückzukehren. Bisher haben Sie Ihr Modell im Normalmodus (normal mode) simuliert. Im Normalmodus wird Ihr Modell mit der Standardeinstellung auf dem Computer ausgeführt, ohne mit externer Hardware zu kommunizieren. Im Normalmodus können Sie nachweisen, dass Ihr System konzeptionell funktioniert, bevor Sie sich mit den Details der Implementierung auf Hardware befassen.

Um das Modell auf dem MKR1000 Board auszuführen, verwenden Sie den external mode. Im externen Modus erstellt Simulink aus Ihrem Modell eine ausführbare Datei (executable)und lädt sie auf das externe Hardwareboard hoch. Wenn die ausführbare Datei auf dem externen Hardwareboard ausgeführt wird, können Sie mit der laufenden Anwendung über das Simulink Modell interagieren. Auf diese Weise können Sie interessante Signale überwachen und Parameterwerte im Modell ändern, während es auf der Hardware läuft.

Ändern Sie im Modellfenster die Stoppzeit der Simulation auf Inf, damit sie unbegrenzt läuft. Stellen Sie den Simulationsmodus auf Extern, indem Sie das Dropdown-Menü rechts neben der stop time verwenden:

Schalten Sie die Batterie ein, indem Sie den ON-OFF-Schalter auf der Trägerplatine verwenden. Klicken Sie nun auf die Schaltfläche Run. Sie müssen warten, bis Simulink die ausführbare Datei erstellt und dann die Infrastruktur für den externen Modus initialisiert hat.

Sobald die Anwendung läuft, untersuchen Sie die oszillierende Bewegung des Motors und des magnetischen Encoders. Schwingt die Drehzahl mit der gleichen Geschwindigkeit wie der Eingangsdrehzahlbefehl? Stoppen Sie die Simulation und schalten Sie dann die Stromversorgung des Motorträgers aus.

Sie haben jetzt ein funktionales Steuerungssystem, das den Motor theoretisch mit der gewünschten Drehzahl antreibt. Aber woher wissen Sie, dass es richtig funktioniert? Richten wir das Modell so ein, dass es die Anzahl der magnetischen Encoder liest, so dass Sie die Drehzahl berechnen und sehen können, wie gut sie mit der vorgegebenen Drehzahl übereinstimmt. Fügen Sie einen Encoder Block aus der* Simulink Support for Arduino MKR Motor Carrier* Bibliothek hinzu:

Öffnen Sie den Blockdialog und stellen Sie die Encodernummer auf 1 ein:

Lassen Sie uns den Encoder Block isoliert testen. Fügen Sie einen temporären Scope Block (aus Simulink>Sinks) an die Ausgabe an.

Schalten Sie nun den Netzschalter des Motorträgers ein (ON) und starten Sie das Modell. Beobachten Sie die Encoderzahl im Scope Block.

Als nächstes berechnen wir die Winkelgeschwindigkeit. Fügen Sie in der obersten Ebene des Modells drei Blöcke ein: einen Summenblock (Simulink > Math Operations) mit Vorzeichenliste '|+-', einen Unit Delay Block (Simulink > Discrete) und einen Gain Block mit einer Verstärkung von 1/Ts.

Verknüpfen Sie die neuen Blöcke wie oben gezeigt und benennen Sie das Ausgangssignal vom Gain Block als speedFromEncoder. Dadurch wird die Zähländerung dividiert durch die Abtastzeit Ts berechnet. Dies entspricht der Berechnung der Motordrehzahl im vorherigen Kapitel.

Leiten Sie das speedFromEncoder-Signal an den Scope Block weiter und erzeugen Sie einen dritten Eingang:

Vergewissern Sie sich, dass die Stromversorgung des MKR Motor Carriers eingeschaltet ist, und führen Sie die Anwendung auf dem MKR1000 Board aus. Betrachten Sie den Scope:

Wie verhält sich die gemessene Geschwindigkeit im Vergleich zur Sollgeschwindigkeit? Versuchen Sie, den sich drehenden Motor mit dem Finger zu verlangsamen.

Wie verhält sich der Regelalgorithmus, wenn eine externe Drehmomentbelastung aufgebracht wird? Stoppen Sie das Modell

Stoppen Sie das Modell. Um die performance der Steuerung zu messen, müssen Sie den Fehler (error) anschauen. Als Fehler wird die Differenz zwischen dem Sollwert und dem Istwert (oder Messwert) einer Größe definiert. Um den Fehler der Motordrehzahl zu erhalten, fügen Sie einen Sum Block aus Simulink > Math Operations mit einer Liste der Vorzeichen '|+-' hinzu. Verzweigen und routen Sie die Signale so, dass Sie das speedFromEncoder-Signal vom speedCmd-Signal subtrahieren, wie unten gezeigt:

Ziehen Sie das Ausgangssignal vom Sum Block auf den Scope Block und erstellen Sie einen neuen inport an Position 2, wie hier gezeigt:

Kennzeichnen Sie das neue Signal Error. Gehen Sie nun in den Scope Block und klicken Sie auf View > Layout, und stellen Sie die Achsenabmessungen auf 3x1 ein:

Führen Sie das Modell aus und untersuchen Sie die Signale im Scope Fenster:

Was Sie gerade implementiert haben, ist die Open-Loop-Control. In der Motorsteuerung mit offenem Regelkreis haben Sie einen Algorithmus, der bestimmt, welchen Fahrbefehl Sie an den Motor senden sollen, und dieser Fahrbefehl hängt nicht vom aktuellen Zustand des Systems ab. Mit anderen Worten, Sie berücksichtigen bei der Bestimmung des Fahrbefehls nicht die tatsächliche Drehzahl des Motors. Die open-loop Steuerung ist nützlich, wenn Sie ein sehr genaues Modell Ihrer Betriebsumgebung haben. In diesem Fall werden die Betriebsbedingungen im Block Lookup Table zusammengefasst. Wenn jedoch ein unmodifiziertes Drehmoment auf den Motor wirkt, Sie eine Last hinzufügen (z.B. ein Rad oder Getriebe) oder die Batterie nicht mit der gleichen Spannung arbeitet wie bei der Erzeugung der Testdaten, ist die Steuerung nicht ausreichend.

Wie können Sie die Genauigkeit der Motorsteuerung verbessern? Dies ist die Frage, die wir im folgenden Abschnitt behandeln werden, wo wir einen geschlossenen loop implementieren werden.

Um die Leistung der Steuerung zu verbessern, wenn die Betriebsbedingungen von den Versuchsbedingungen abweichen, müssen Sie bei der Berechnung des motor drive Befehls die Drehzahlmessung berücksichtigen.

Schließen wir den Regelkreis, indem wir die speedFromEncoder Messung in das Controller Subsystem einleiten. Verzweigen Sie das speedFromEncoder Signal und leiten Sie es an das Controller Subsystem weiter, wodurch ein zweiter inport entsteht:

Als nächstes greifen wir auf den Geschwindigkeitsfehler zu. Gehen Sie in das Controller Subsystem und fügen Sie einen Subtract Block hinzu (aus Simulink > Math Operations), und routen Sie dann die Signale wie unten gezeigt:

Wir werden dem Fahrbefehl einen Korrekturterm hinzufügen, der proportional zum Geschwindigkeitsfehler ist. Fügen Sie dem Controller Subsystem einen Gain Block hinzu und setzen Sie den Gain Wert auf 0,01 (Sie werden diesen Wert später anpassen):

Nun erstellen wir den abschließenden Antriebsbefehl. Löschen Sie das driveCmd Signal:

Fügen Sie nun einen Sum Block hinzu und routen und beschriften Sie die Signale wie in der Abbildung unten gezeigt:

Lassen Sie es uns ausprobieren! Führen Sie das Modell auf dem MKR1000 Board aus und untersuchen Sie dann den scope:

Wie sieht die Performance im Vergleich zu früher aus?

Während die Anwendung auf der Hardware läuft, gehen Sie zurück zum Gain Block innerhalb des Controller Subsystems. Probieren Sie verschiedene Werte der Verstärkung aus. Klicken Sie auf Apply, um den Gain Wert von Arduino zu aktualisieren:

Welcher Gain Wert ergibt die beste Genauigkeit, höher oder niedriger?

Fahren Sie mit der Ausführung der Anwendung auf Arduino fort. Gehen Sie nun in den Sine Wave Block und ändern Sie die Wellenform-Parameter. Versuchen Sie, die Frage zu beantworten: Wie robust ist Ihr Controller bei höheren Sinusfrequenzen?

Was Sie jetzt tun, nennt man parameter tuning. Durch die Anpassung der Parameterwerte im Modell, während die Anwendung auf der Zielhardware läuft, können Sie wertvolle Einblicke gewinnen, wie sich Ihr System unter verschiedenen Umständen verhält und wie Sie den Algorithmus für eine möglichst robuste Leistung am besten parametrieren können.

Sobald Sie mit dem Verhalten Ihrer Anwendung im externen Modus zufrieden sind, werden Sie Ihr Modell letztendlich als eigenständige Anwendung einsetzen, die ohne Verbindung zu Ihrem Computer ausgeführt werden kann. Um eine eigenständige Anwendung zu erstellen, klicken Sie auf die Schaltfläche Deploy to Hardware in der Toolstrip des Modellfensters:

Sobald der Build-Prozess abgeschlossen ist, startet die Anwendung sofort auf dem Arduino. Beachten Sie, dass die Simulation diesmal nicht im Modellfenster läuft. Sie können nun das USB-Kabel zwischen dem MKR1000 Board und Ihrem Computer trennen. Die Anwendung wird weiterhin ausgeführt. Schließen Sie nun das USB-Kabel wieder an, um weiterzuarbeiten.

Sie haben vielleicht bemerkt, dass die Ausführung einer Anwendung im Standalone-Modus den Prozessor von dem mit dem externen Modus verbundenen Performance-Overhead befreit und zu einer besseren Leistung führt.