Abschlussprojekt Kameragesteuerte XY

Transcrição

Abschlussprojekt
Kameragesteuerte
X-Y-Regelung
Dominik Lönarz, Martin Wilbert
Fachschule Elektrotechnik
Carl Benz Schule Koblenz
Abgabe: 09.04.2013
Kameragesteuerte x-y-Regelung
Erklärung
Wir versichern, dass wir diese Projektarbeit ohne fremde Hilfe selbstständig verfasst
und nur die angegebenen Quellen und Hilfsmittel benutzt haben. Wörtlich oder dem
Sinn nach aus anderen Werken entnommene Stellen sind unter Angabe der Quellen
kenntlich gemacht.
09.04.2013
…...............................................................................................................
Datum
Martin Wilbert
Dominik Lönarz
Inhaltsverzeichnis
1 Einleitung.....................................................................4
2 Projektauftrag...............................................................5
3 Projektablaufplan.........................................................5
4 Hardware......................................................................6
4.1 Aufbau..................................................................................................................6
4.2 Problematiken bei der verwendeten Hardware....................................................7
5 Bildverarbeitungsalgorithmus.......................................8
5.1 Beschreibung.......................................................................................................8
5.2 Probleme............................................................................................................11
6 Der Arduino UNO R3 .................................................15
6.1 Hardware............................................................................................................16
6.1.1 Technische Daten........................................................................................16
6.1.2 Anschlussbelegung Arduino UNO R3..........................................................16
6.1.3 Anschluss der Servomotoren.......................................................................16
6.2 Software.............................................................................................................16
6.2.1 Installieren/Programmieren der Arduino Plattform .....................................17
6.2.1 Einbinden Der Arduino Plattform in Labview...............................................17
7 Labview......................................................................17
7.1 Testprogramm zur Ansteuerung der Servomotoren ..........................................17
7.2 Bedienungsanleitung Kameragesteuerte X-Y-Regelung...................................18
7.2.1 Voraussetzungen:........................................................................................18
7.2.2 Inbetriebnahme:...........................................................................................18
7.2.3 Bedienung:...................................................................................................19
7.3 Funktionsweise der Lab View Anwendung........................................................23
7.4 Problematiken der Lab View Anwendung..........................................................28
8 Fazit...........................................................................30
3
9 Englische Zusammenfassung....................................31
10 Verzeichnisse...........................................................32
10.1 Quellenverzeichnis...........................................................................................32
10.3 Tabellenverzeichnis..........................................................................................32
10.2 Abbildungsverzeichnis......................................................................................33
11 Anhang.....................................................................34
11.1 Puls-Weiten-Modulation (PWM).......................................................................34
11.2 Der PID - Regler...............................................................................................35
11.2.1 Zweipunkt-Regler.......................................................................................35
11.2.2 Proportionalregler......................................................................................35
11.2.3 Integralregler..............................................................................................36
11.2.4 Differentialregler.........................................................................................36
4
1 Einleitung
Bilderkennung ist jedem von uns vertrauter als wir denken. Jede Sekunde wertet
unser Gehirn Bilder aus und lässt uns entsprechend reagieren. Es ist für uns
selbstverständlich, einen Gegenstand zu greifen oder sogar zu fangen. Für einen
Computer stellen diese für uns einfachen Abläufe ein Problem dar. Ein Computer
benötigt hierzu eine Reihe von Sensoren und Aktoren, die perfekt miteinander
arbeiten müssen, um solche für uns alltäglichen Aufgaben zu lösen.
Heutzutage sind Bilderkennungssysteme in der Industrie nicht mehr wegzudenken.
So übernehmen Bildverarbeitungssysteme Aufgaben, wozu früher eine Reihe teurer
Sensoren nötig gewesen wäre. Bilderkennungssysteme können eine Vielzahl an
Aufgaben übernehmen, deshalb werden sie zum Beispiel zur Lageerkennung oder
zur Prüfung der Maßhaltigkeit eingesetzt.
„Bis zum heutigen Tag bildet die Industrielle-Bildverarbeitung immer nur
kleinste Teile der menschlichen Intelligenz ab. Und dann auch nur nach den
programmierten Vorgaben. Ein Mensch entscheidet immer auf Grund seines
ganzen
Wissens!
Sortiert
man
Industriegüter,
dann
findet
ein
Bildverarbeitungssystem nur die trainierten Fehler oder die Abweichungen
zum dem ihm beigebrachten Kriterien. Kommt ein unbekannter Fehler, der
auch in die guten Kriterien passt, wird er übersehen. Der Mensch hat durch
seine allgemeine Erfahrung die Möglichkeit zu entscheiden, was gut oder
schlecht ist.
Stichwort: Ästhetik
Allerdings hat die Industrielle-Bildverarbeitung auch entscheidende Vorteile.
Bei gleichen Bildern entscheidet sie immer gleich. Unabhängig von Gefühlen
oder
Müdigkeit. Außerdem
erreicht
sie
auf
dem
speziellen
Gebiet
Geschwindigkeiten, die kein Mensch mehr leisten kann.“ 1
1 Industrielle Bildverarbeitung von Prof. Dr. Matthias Franz, Hochschule Konstanz Technik,
http://www-home.fh-konstanz.de/~mfranz/ibv_files/lect00_Einleitung.pdf
5
Die wichtigsten Komponenten sind dabei die Bilderfassung, die Bildauswertung und
die Regelung, welche einen Hauptbestandteil der vorliegenden Abschlussarbeit
darstellen.
Ziel ist es, eine Kugel, die sich auf einer beweglichen Plattform befindet, mittels einer
Kamera zu erkennen und durch die Auswertung des Bildes die Plattform
auszuregeln. Die Neigung der Plattform, über 2 Achsen, soll mit Hilfe von
Servomotoren realisiert werden. Diese werden über ein Arduino UNO R3
Entwicklungsboard angesprochen. Die Bilder, welche durch eine in Vision Builder AI
2012 erstellte Inspectionfile ausgewertet werden, liefert eine Microsoft LifeCam
Studio. Die Reglungsaufgaben übernimmt das Labview 2012 Entwicklungssystem
von National Instruments.
Im ersten Teil der Arbeit wird auf die Realisierbarkeit und die Auswahl der Hardware
eingegangen und begründet, warum welche Komponenten ausgewählt werden.
Anschließend wird der Hardware Aufbau und damit verbundene Problemstellungen
erläutert. Im Kapitel 5 gehen wir auf die Struktur des Bildverarbeitungsalgorithmus
ein. Im weiteren Ablauf wird das Labview Programm sowie die Arduino
Programmierung erklärt.
6
2 Projektauftrag
Tabelle : Projektauftrag
Projektauftrag
Projektname:
FSE 11 Modul 14
Auftraggeber:
BBS-Technik Koblenz
Datum:
19.08.13
Projektteam:
Dominik Lönarz
Martin Wilbert
Projektthema: Kameragesteuerte x-y-Regelung
Projektziele: Bewegung einer Kugel auf einer x-y-Platte mit Hilfe von Lab-View und einer Webcam
Sachziel:
Kostenziel:
Möglichst günstige Komponentenwahl (Webcam)
Terminziel:
09.04.2013
Hauptaufgaben:
-Herstellen der x-y-Platte, verwendet wird ein Holzlabyrinth, dieses wird mit Servomotoren in
seinen zwei Achsen gesteuert.
-Die Bewegung der Kugel wird mittels Labview/Webcam ausgewertet.
-Ansteuerung der Servos über einen Mikrocontroller/Lab View.
-Stabilisierung der Kugel auf der Platte, Vergleich verschiedener Regler (P, PID etc.)
-Mögliche Erweiterung: Formen nachbilden (Kreis, Rechteck)
Organisation:
Auftraggeber:
BBS-Technik-Koblenz
Industriepartner:
-
Projektressourcen:
Projektbudget:
€ 200,-
Sonstige Ressourcen: Microsoft LifeCam Studio (Schule) Software-Lizenzen von National Instruments
Auftragsbedingungen:
Termine:
Projektstart:
ZwischenPräsentation:
DokumentationsAbgabe:
Präsentation/
Kolloquium:
28.01.13
21.02.13
09.04.13
06/07.06.13
3 Projektablaufplan
7
Abbildung : Projektablaufplan
8
4 Hardware
4.1 Aufbau
Als Grundgerüst kommt ein Holz-Spielzeug-Labyrinth zum Einsatz. Das Labyrinth
besteht aus einem 9cm hohen Holzrahmen, in diesem sind zwei weitere Rahmen
montiert. Ein Rahmen ist in der X-Achse, der andere in der Y-Achse gelagert. Am
inneren Rahmen ist die Grundplatte angebracht. Die Bodenplatte, die ursprünglich
für den Kugelauswurf sorgte, wurde entfernt sowie das Gestänge mit den Seilzügen,
die für die Plattenbewegung zuständig waren. Zusätzlich wurde das Original
„Labyrinth“ entfernt und durch eine Holzplatte ersetzt. Die Holzplatte wurde mit
schwarzem Tonpapier beklebt (siehe Abbildung ).
Abbildung : Grundrahmen
Außerdem wurde der innere Rahmen an der Innenseite schwarz lackiert. Somit wird
gewährleistet, dass die Kugel, wenn sie am Rand liegt, von der Kamera sicher als
Objekt erkannt wird und optisch ein Abstand zwischen Kugel und Rahmen entsteht.
Das schwarze Tonpapier hat den Vorteil, dass einfallendes Licht nur wenig reflektiert
wird und so ein hoher Kontrast zur Stahlkugel entsteht. Der restliche Rahmen wurde
hell gelassen, damit auch hier hohe Kontrastwerte zur verwendeten Holzplatte
entstehen.
9
Abbildung : Aluminiumprofil und Kamera
An den Grundrahmen wurde an einer Seite mittig ein Aluminiumprofil befestigt. Wie
in Abbildung
zu sehen ist, wurde das Aluminiumprofil an der Rahmenoberseite
abgewinkelt, sodass das Ende des 46cm langen Profils mittig über der Platte
zentriert ist. Dort wurde die Microsoft LifeCam Studio-Webcam mittels des
Stativanschlusses befestigt. Dadurch ist die Kamera stabil und fest mit dem Rahmen
verbunden,
kann
aber
über
(siehe Abbildung ).
10
den
Kugelkopf
dennoch
justiert
werden
Für die Steuerung der Platte wurden zwei Modellbau-Servomotoren verwendet. Einer
der beiden Servomotoren ist am Grundgerüst befestigt und wird über das Servo-Horn
mittels zwei Kugelgelenken und einer Gelenkstange an der ersten beweglichen
Platte befestigt. Der zweite Servo ist direkt an der beweglichen Platte montiert. Über
das Gestänge ist der Servo ebenfalls mit dem mittleren Rahmen verbunden
(siehe Abbildung ).
Abbildung : Servomotoren
Mittels des Arduino-Mikrocontroller-Boards werden die Servos mittels einer PulsWeiten-Modulation
(PWM)
angesteuert.
Die
Spannungsversorgung
der
Servomotoren erfolgt über ein externes Schaltnetzteil, der Arduino wird direkt über
USB versorgt.
4.2 Problematiken bei der verwendeten Hardware
Als erstes Problem stellte sich die Farbwahl der Platte heraus. Eine helle Platte hat
den Vorteil, dass der Kontrast zur Kugel höher ist als bei einer dunklen Platte. Ein
Nachteil der hellen Platte ist der Schattenwurf, da helle Flächen weniger Licht als
dunkle Flächen absorbieren. Bei der Verwendung der schwarzen Platte stellte sich
die Art der Schwarzfärbung als Problem dar. Vor der Verwendung des Tonpapiers
wurde versucht, die Platte schwarz zu lackieren. Dies hatte den Nachteil, dass die
Lackierung zu stark glänzte und so das einfallende Licht reflektiert wurde. Dies
wiederum führte dazu, dass die Reflektion als helle Fläche im Kamerabild erscheint
und fälschlicherweise als Objekt erkannt wird. Daher wurde versucht, die lackierte
Fläche anzuschleifen um so eine rauere Oberfläche zu schaffen, sodass das
einfallende Licht weniger reflektiert wird.
11
Aber auch dies brachte keinen Erfolg. Letztendlich konnte das Problem mittels des
verwendeten Tonpapiers behoben werden, da dies generell matt ist. Außerdem hat
es den Vorteil, dass kleine Unebenheiten in der weichen Pappelholzplatte
ausgeglichen werden.
Eine weitere Problematik ist die maximale Neigung der Platte. Durch die begrenzte
Höhe
des
Aufbaus
und
der
darin
verbauten
Servomotoren
sind
die
Maximalneigungen und damit die Winkel der Platte begrenzt, was wiederum die
Maximalgeschwindigkeit der Kugel beeinflusst. Nachfolgende Berechnungen zeigen
die Zeiten, die die Kugel benötigt, um von einer zur anderen Seite zu rollen
(siehe Tabelle ).
Verwendete Formeln2:
sin a=
Gegenkat h ete Hö h en untersc h ied der Platte(h)
=
Hypotenuse
Länge der Platte ( s)
s=0,5× a × t² t=
⇒
√
2×s
a
v=a × t
g=9,81
F =m × g ×sin α
a=
F
m
m
s²
Tabelle : Bewegung der Kugel
Bewegung in der Y-Achse
Höhe
Länge
Beschleunigung
(h)
(l)
(a)
6cm
23cm
2,56m/s³
5cm
23cm
2,13m/s²
Bewegung in der X-Achse
Höhe
Länge
Beschleunigung
(h)
(l)
(a)
4cm
27cm
1,45m/s²
3cm
27cm
1,09m/s²
Zeit
(t)
0,43s
0,47s
Geschwindigkeit
(v)
1,10m/s
1,00m/s
Zeit
(t)
0,61s
0,70s
Geschwindigkeit
(v)
0,89m/s
0,76m/s
Da keine Rollreibungswerte für Stahl auf Papier ermittelt werden konnten, aber
ähnliche, bekannte Rollreibungswerte nur geringe Änderungen bei den hier
verwendeten Werten aufweisen würden und Toleranzen in der messtechnischen
2
Formeln entnommen aus dem Buch: Physik für Ingenieure von Hering, Martin und Stohrer, 10.
Auflage, 2007, Springer-Verlag
12
Erfassung der Höhenunterschiede und Längen der Platte auftreten, können die
Rollreibungswerte vernachlässigt werden.
Weitere Probleme verursachten die verwendeten Servomotoren. Hierbei handelt sich
um Standard-Modellbau-Servomotoren älterer Generation. Genaue technische Daten
konnten nicht ermittelt werden, daher werden Standard Daten angenommen. Bei
günstigen Standardservomotoren beträgt die Stellzeit ca. 200ms für 60° bei 4,8V.
Erhöht man die Spannung auf 6V, so beträgt die Stellzeit noch ca. 150ms. 3 Da wir
das Arduino-Board per USB versorgen, benutzen wir ein externes Steckernetzteil für
die Servomotoren, so liegt unsere Versorgungsspannung bei 6,3V DC. Außerdem
werden die Servos nicht bis 60° sondern bis ca. 150° gefahren, so beträgt die
Stellzeit ca. 500ms. Dies ist gegenüber der Lab View-Schleifenzeit ein Faktor von
ungefähr zehn. So ist es nicht möglich, die Kugel schnell genug zu bewegen, um
geringe Aussteuerzeiten zu erreichen. Erfolg hierbei brachte allerdings das ArduinoBoard. Für die ersten Testzwecke wurde die MyDAQ-Messbox benutzt, hier waren
die Schleifenzeiten wesentlich höher und die Ansteuerung der Servos war nicht so
flüssig. Die Erläuterungen zum Arduino werden in einem extra Kapitel behandelt.
Als letzte hardwareseitige Problematik sei die verwendete Holzplatte anzuführen. Da
das verwendete Labyrinth schon etwas älter ist, sind die Rahmen nicht mehr eben
und die Pappelholzplatte ist dadurch leicht verzogen. Dies hat den Nachteil, dass die
Kugel zu den Rändern hin rollt und nicht wie erwartet 2„steht“.
3
Es handelt sich um Werte von vergleichbaren Servomotoren, zu finden unter
http://www.servodatabase.com.
13
5 Bildverarbeitungsalgorithmus
5.1 Beschreibung
Als Software für den Bildverarbeitungsalgorithmus kommt Vision Builder for
Automated Inspection von National Instruments zum Einsatz. Zusätzlich wird noch
folgende Software benötigt: Vision Acquisition Software, Vision Development Module,
NI IMAQ-Treiber.
Die Vision Acquisition Software und der NI IMAQ-Treiber ermöglichen den Bildimport
von einer USB-Kamera. Wobei der NI IMAQ-Treiber die USB Unterstützung
bereitstellt und die Vision Acquisition Software den generellen Kamera Import. Das
Vision Development Module wird zur Bildverarbeitung benötigt und stellt den Vision
Assistent zur Verfügung.
Die Vision Builder for Automated Inspection File gliedert sich in sieben Stufen
(siehe Abbildung ).
Abbildung : Vision Builder AI Inspection
Der erste Schritt in der Kette ist der Bildimport (Acquire Image (USB)). Als Bildquelle
dient eine Microsoft LifeCam Studio USB Webcam. Das Bild wird kontinuierlich mit
einer Auflösung von 640x480 Pixeln bei 30fps (frames per second) aufgenommen.
Die Farbtiefe beträgt 24bit (RGB). Dies bedeutet, dass alle 33,3ms ein neues Bild zur
Verfügung
steht.
Bei
höheren
Auflösungen
(1280x720
Pixel)
sinkt
die
Bildwiederholrate auf 10fps. Dies hat zur Folge, dass nur alle 100ms ein neues Bild
zur Verfügung steht.
14
Messungen mit der Benchmark-Funktion haben ergeben, dass die Inspection-Zeit
(Zeit für einen kompletten Durchlauf) im Durschnitt 37ms beträgt (siehe Abbildung ).
Daher ist es notwendig, die Auflösung entsprechend zu senken, damit beim nächsten
Durchlauf der Inspection ein aktuelles Bild zur Verfügung steht.
Abbildung : Inspection Benchmark - Durschnittliche Iterationszeit
Im zweiten Schritt der Ablaufkette findet die Bildverarbeitung statt. Hierfür kommt die
Vision
Assistent
Software
als
ein
Schritt
zum
Einsatz.
Aufgabe
des
Bearbeitungsschrittes ist es, das 24bit Farbbild in ein 8bit Graustufenbild zu
konvertieren, indem der Farbkanal entfernt wird.
Der dritte Schritt beinhaltet eine der beiden Objekterkennungen. Diese dient zur
Erkennung
der
Platte,
auf
der
sich
die
Kugel
bewegt.
In
dem
Objekterkennungsbaustein ist ein Tresholdfilter (Schwellwertfilter) enthalten, dieser
ist so eingestellt, dass er nach dunklen Bereichen im gesamten Bild sucht. Der
Schwellwert (0-255) wird über eine globale Variable von Lab View bereitgestellt. Die
Objekterkennung ist so konfiguriert, dass maximal ein Objekt mit einer minimalen
Größe von 150.000 Quadratpixeln erkannt wird.
Mit Hilfe des erkannten Objektes, welches in Schritt drei erfasst wurde, wird nun ein
Koordinatensystem erstellt. Das Koordinatensystem hat seinen Ursprung im
Objektmittelpunkt. Dieses ist notwendig, da der nächste Schritt nur auf ein
Koordinatensystem aufsetzen kann.
Wie im vorangegangenen Schritt beschrieben, setzt der Schritt „Plattenbereich“ auf
das im Schritt zuvor erstellte Koordinatensystem auf. Es wird ein Rechteck erstellt,
das seinen Mittelpunkt im Ursprung des Koordinatensystems hat. Die Höhe und
Breite des Rechtecks bezieht sich auf die Höhe und Breite des erkannten Objektes.
15
Da nun der Bereich, in dem sich die Kugel bewegen kann, festgelegt ist, geht es jetzt
zur eigentlichen Kugelerkennung. Dies geschieht durch die zweite Objekterkennung
mit Tresholdfilter. Dieser sucht, im Gegensatz zum ersten Filter, nach hellen
Objekten. Der Schwellwert wird durch dieselbe globale Variable vorgegeben. Der
Initialwert der Variable beträgt 150 und wird solange verwendet, bis der Benutzer
diesen Wert ändert. Die Objekterkennung bezieht sich in diesem Fall nicht auf das
gesamte Bild, sondern auf den in den vorangegangenen Schritten festgelegten
Bereich. Dadurch, dass der Rand der Platte ebenfalls schwarz lackiert ist, werden
Objekte, die den Rand berühren, ignoriert. Dies ist notwendig, da das festgelegte
Rechteck sich nicht genau mit der Platte deckt und es so zu Fehlerkennungen
kommen kann. Des Weiteren werden erneut Grenzen für eine maximale
Objektanzahl von eins bei einer minimalen Objektgröße von 50 Quadratpixeln
gesetzt.
Abschließend werden im siebten Schritt die ermittelten Werte in globale Variablen
geschrieben. Es werden die Stati für sechs Schritte geschrieben (Import,
Bearbeitung,
Plattenerkennung,
Koordinatensystem,
Bereichserstellung
und
Kugelerkennung). Des Weiteren werden Positionsdaten übertragen (Kugel X, Kugel
Y, Platte H, Platte B, Plattenmitte X und Plattenmitte Y). Außerdem werden noch
folgende Parameter übertragen: Counter, Bild und Schwellwert.
16
5.2 Probleme
Die ersten Probleme sind bei den verwendeten Tresholdfiltern aufgetreten. Hierbei
stehen verschiedene Filterarten zur Verfügung. Neben dem manuellen Filter gibt es
auch automatische Filter, bei denen Grenzwerte eingestellt werden können. Für
unsere Problemstellung stellte sich heraus, dass der „Auto Treshold: ClusteringFilter“ gute Dienste erwies. Da sich aber zeigte, dass bei beiden Filtern
unterschiedliche Werte eingestellt werden müssen und so drei zusätzliche Variablen
entstünden, wurde hier auf einen automatischen Filter verzichtet und stattdessen der
manuelle Filter gewählt. Hierbei hat sich ergeben, dass beide Tresholdfilter mit
denselben Werten zuverlässig arbeiten. Da bei verschiedenen Lichtverhältnissen
unterschiedliche Schwellwerte eingestellt werden müssen, wurde hierfür eine
Variable erstellt, damit dieser Wert im laufenden Betrieb geändert werden kann. Der
Standardwert dieser Variable beträgt 150 und kann zwischen 0 und 255 variiert
werden. Im Lab-View-Programm kann die Variable in einem Bereich von 100 bis 255
eingestellt werden. Werte unter 100 werden ignoriert, da diese Werte keine
sinnvollen Ergebnisse liefern.
Dies ermöglichte uns auch auf eine zusätzliche Beleuchtung zu verzichten, wie es
uns zuvor in einem persönlichen Gespräch mit von National Instruments empfohlen
wurde.
Ein weiteres Problem bestand in der Farbwahl der Grundplatte. Hierzu wurden im
Vorfeld
mehrere Tests
mit
hellen
und
unterschiedlichen
dunklen
Flächen
vorgenommen. Als Material für die Grundplatte wurde eine Pappelholzplatte
verwendet, da das Grundgerüst ebenfalls aus Holz besteht. Die Verwendung von
Pappelholz hat den Vorteil, dass es leicht ist und sich einfach verarbeiten lässt. In
ersten Tests wurde eine Seite der Platte schwarz lackiert, die andere Seite blieb
unbehandelt. Hierbei hat sich ergeben, dass die unbehandelte, helle Platte,
zusammen mit der originalen Edelstahlkugel höhere Kontrastwerte aufweist als die
schwarze Platte mit der originalen Kugel. Hingegen ist die Verwendung einer
schwarzen Platte lichtunempfindlicher, da hier der Schattenwurf der Kugel nicht so
stark zum Tragen kommt.
17
Allerdings stellte sich heraus, dass die lackierte schwarze Platte nicht matt genug
war und deshalb einfallendes Licht zu sehr reflektiert wurde. So haben wir uns dafür
entschieden, die Platte mit schwarzem Tonpapier zu bekleben. Dies hat zum einen
den Vorteil, dass die Platte kaum reflektiert und zum anderen werden kleine
Unebenheiten in der Platte korrigiert.
Ein weiterer Vorteil der Verwendung der schwarzen Platte ist, dass wir eine gute
Abgrenzung zum verwendeten Rahmen haben, was uns eine einfache Verwendung
der Objekterkennung zur Plattenerkennung ermöglichte.
Als nächstes Problem stellte sich die Übertragung der ermittelten Werte heraus.
Nachdem der Bildverarbeitungsalgorithmus in Lab View migriert wurde, ist es uns
nicht gelungen, die Messwerte auszulesen. Zwar wurden die Daten korrekt in die
dazu erstellten Variablen geschrieben, allerdings fanden wir diese Variablen in Lab
View nicht wieder, so dass wir uns für globale Systemvariablen entschieden haben.
Um diesen globalen Zugriff zu ermöglichen, war es nötig, die vorhandenen
Inspection-Variablen in System-Variablen zu konvertieren. Dies wird durch den
Variablen-Manager ermöglicht. Zusätzlich mussten für die verwendeten Variablen die
Netzwerkfreigaben aktiviert werden, da so erst der Zugriff außerhalb von Vision,
möglich war. Für Lab View bedeutet dies, dass das Programm über ein Projekt
gestartet werden muss, da es nur in Projekten möglich ist, die freigegebenen
System-Variablen zu importieren. Die so in Lab View bereitgestellten Variablen
können dann in die Lab View Anwendung eingebunden und verarbeitet werden.
Außerdem ist es auch möglich, Bedien- oder Anzeigeelemente über die
Datenbindungsfunktion direkt mit den Variablen zu verknüpfen, so dass diese im
laufenden Betrieb, unabhängig ihrer Stelle im Programm, ständig aktualisiert werden.
18
Eine Funktion, die laut National Instruments in früheren Versionen von Lab View und
Vision Builder problematisch war, ist die Migration von Vision Builder nach Lab View.
Die hier auftretenden Probleme sollen in der aktuellen Version behoben sein. Doch
leider blieb uns diese Möglichkeit verwehrt. Der Fehler konnte zwar lokalisiert, aber
nicht behoben werden. Die Funktion „Migration nach Lab View“ wandelt die Vision
Builder AI Datei in eine ausführbare Lab View Anwendung. Es wird eine „main.vi“
Datei erzeugt mit einigen Sub-VIs. Durch den Aufruf der main.vi soll der in Vision
Builder gestaltete und nach Lab View migrierte Algorithmus gestartet werden. Dies
war auch im ersten Durchlauf der Software erfolgreich. Wurde die Anwendung
allerdings beendet, konnte kein neuer Vorgang gestartet werden. Erst nach einem
Neustart des Systems war dies wieder möglich. Die Fehlerhafte Komponente konnte
von uns lokalisiert werden. Es stellte sich heraus, dass die Fehlerbehandlung des
Tresholdfilters
der
ersten
Objekterkennung
den
Fehler
verursachte.
Nach
geringfügigen Änderungen im Programm trat der Fehler nicht mehr auf. Jedoch
führte dies dazu, dass nach einem erneuten Start der Anwendung keine Bilder mehr
verarbeitet wurden. Auch eine Kontaktaufnahme mit National Instruments führte zu
keinem
Erfolg,
also
entschieden
wir
uns
gegen
die
Verwendung
der
Migrationsfunktion von Vision Builder AI nach Lab View.
Eine weitere Möglichkeit ist die parallele Verwendung von Lab View und Vision
Builder AI. Dies bedeutet, dass beide Programme manuell geladen werden müssen,
so dass die Vision Builder AI Software mit dem Bildverarbeitungsalgorithmus
gestartet und anschließend die Lab View Anwendung ausgeführt werden kann. Dies
hat allerdings eine sehr hohe CPU- und Speicherauslastung zur Folge. Messungen
der Schleifenzeit in Lab View haben ergeben, dass diese dadurch über 100ms
beträgt, ein Wert, der so nicht akzeptiert werden kann.
So mussten wir einen anderen Weg wählen und entschieden uns für den Vision
Builder AI Server. Dieser ist im Vision Paket inbegriffen und kann direkt von Lab View
aus gestartet werden. Nachdem die „Local VBAI Engine“ geöffnet und gestartet
wurde, kann dort eine Vision Builder AI Datei ausgeführt werden (siehe Abbildung ).
19
Abbildung : Aufrufroutine für den Vision Builder AI Server
Der erste Objektbaustein in Abbildung öffnet die „Local VBAI Engine“, im zweiten
Baustein wird eine Verbindung zu dieser hergestellt. Objektbaustein drei öffnet
unseren Bildverarbeitungsalgorithmus, der im anschließenden Schritt vier gestartet
wird. Beim Start des Servers wird ein Fenster geöffnet (Abbildung ), in diesem
werden Statusinformationen zur Inspection angezeigt.
Abbildung : Vision Builder AI Server Luncher
Dargestellt wird der „Inspection Status“ (Pass, grün oder Fail, rot), die „Inspection
Iteration“ (Anzahl der Durchläufe) und es werden Informationen zum Server selbst,
wie zum Beispiel IP-Adresse und Initialisierungsstatus, übermittelt. Über den Button
„STOP“ kann der Server beendet werden. Dies wird aber nur im Fehlerfall benötigt,
da die Lab View Anwendung den Server automatisch beendet, wenn er nicht mehr
benötigt wird.
Im laufenden Betrieb der Anwendung zu verschiedenen Tageszeiten und somit bei
verschiedenen Lichtverhältnissen stellte sich heraus, dass die Zeit, die für einen
Durchlauf benötigt wird, stark von der Helligkeit abhängig ist. Daraufhin wurde eine
Möglichkeit gesucht, die Iterationszeit zu messen. Zuvor ermittelten wir die Zeit
20
dadurch, dass in der Lab View Anwendung die Schleifenzeit solange erhöht wurde,
bis bei jedem Durchlauf neue Bildinformationen vorhanden waren. Diese Methode
erwies sich jedoch als ungenau, wie wir im Nachhinein feststellten. Eine genaue
Ermittlung der Iterationszeit in Vision Builder AI wird durch die Benchmark-Funktion
bereitgestellt.
Es wurden drei Leistungsmessungen durchgeführt. Die erste Messung mit 1000
Iterationen unter realen Bedingungen, die zweite Messung mit 100 Iterationen bei
konstanter, geringer Beleuchtung und die dritte Messung mit 100 Iterationen bei
konstanter, normaler bis heller Beleuchtung.
Abbildung : Benchmark mit 1000 Iterationen
In Abbildung
sieht man die Ergebnisse der ersten Leistungsmessung. Um eine
möglichst genaue Aussage zu bekommen, wurden 1000 Durchgänge berücksichtigt.
Zusätzlich wurde auch ein Benchmark mit 5000 und 10000 Iterationen erstellt, jedoch
konnte das Ergebnis nicht richtig interpretiert werden, da das Benchmark-Fenster
einen Fehler aufweist und so die Ergebnisse fehlerhaft dargestellt werden. Die Grafik
oben rechts im Bild zeigt die Anzahl der Durchläufe bezogen auf die dafür benötigte
Zeit. Daraus lässt sich ablesen, dass ein Großteil der Iterationen (größer 60 Prozent)
für einen Durchlauf bis zu 35ms benötigt und nur noch wenige Durchgänge mehr als
35ms andauern.
In der Tabelle in Abbildung wird in der ersten Zeile ein Überblick der Zeiten, bezogen
auf die ganze Inspection, gegeben. Abgebildet sind die Anzahl der Iterationen, die
21
dafür benötigte Zeit, die durchschnittliche Zeit, die Standardabweichung, die kürzeste
und die längste Zeit. Des Weiteren werden in den Zeilen der Tabelle die einzelnen
Inspection-Schritte angezeigt.
So erhalten wir eine durchschnittliche Iterationszeit von ca. 37ms, dies spiegelt sich
auch im Ergebnis der ersten Methode wieder. Es wurde eine Schleifenzeit von ca.
50ms ermittelt.
Abbildung : Benchmark bei dunkler Umgebung
Abbildung : Benchmark bei heller Umgebung
22
Hier wird deutlich sichtbar, wie sich die Iterationszeit zwischen heller und dunkler
Umgebung stark ändert (Abbildung , Abbildung ).
So beträgt die Zeit bei normaler bis starker Beleuchtung 20ms bis 50ms. Bei
schwacher Beleuchtung hingegen beträgt die Iterationszeit 90ms bis 160ms. Aus den
beiden Diagrammen in den Bildern wird ersichtlich, wie die Verteilung der
Iterationszeiten liegt. So sind bei normaler bis heller Beleuchtung ca. 80 Prozent der
Iterationen nach 35ms abgearbeitet. Bei schlechter Beleuchtung hingegen verteilen
sich die Schleifenzeiten in einer größeren Spanne, hier liegen ca. 90 Prozent der
Iterationen zwischen 120ms und 160ms.
In der Tabelle in Abbildung können wir eine Durchschnittszeit von ca. 33ms ablesen.
In Abbildung hingegen beträgt die durchschnittliche Iterationszeit ca. 132ms. Damit
beträgt die mittlere Differenz zwischen dunkler und heller Umgebung knapp 100ms.
Außerdem wird aus der Tabelle ersichtlich, dass die meiste Zeit für den Bildimport
benötigt wird und dieser im Gegensatz zu der Bildverarbeitung (Bearbeitung,
Plattenerkennung, Koordinatensystem, Plattenbereich, Kugelerkennung, Variablen
I/O und Display) stark von der Beleuchtung abhängt.
Helle Umgebung
Bildimport
-> 19,63ms
Verarbeitung
-> 1,75ms
Dunkle Umgebung
Bildimport
-> 107,15ms Verarbeitung
-> 3,29ms
Differenz
-> 87,52ms
-> 1,54ms
Faktor
-> ca. 5,5
-> ca.1,9
Das Rechenbeispiel, mit den Werten aus Abbildung und Abbildung , zeigt deutlich
die prozentuale Änderung der durchschnittlichen Zeiten zwischen heller und dunkler
Umgebung. (angegeben für den Bildimport und für die Bildverarbeitung).
Dies lässt sich auf die Kamera und die damit aufgenommenen Bilder zurückführen.
Zum einen sinkt die Framerate bei zunehmender Dunkelheit und zum anderen sinkt
der Kontrast des zu verarbeitenden Bildes, somit wird mehr Rechnerleistung benötigt
und die Iterationszeit steigt.
Die sinkende Framerate lässt sich durch die Verschlusszeit der Kamera erklären. So
könnte diese theoretisch 33ms betragen, um noch 30 Bilder pro Sekunde
23
aufzuzeichnen. Wird die Umgebung abgedunkelt, fällt auch weniger Licht auf
Objektiv und somit auf den Sensor der Kamera. Um bei geringem Licht dennoch
ausreichend gute Bilder aufzunehmen, wird die Belichtungszeit erhöht. Dadurch sinkt
die Bilderrate und der Bildimport dauert länger.
Bezogen auf die gemessenen Werte könnte die maximale Belichtungszeit bei heller
Umgebung theoretisch 1/50sec, bei dunkler Umgebung 1/9sec betragen.
Dadurch, dass weniger Licht auf den Bildsensor einfällt, verschlechtert sich die
Bildqualität, das Bildrauschen nimmt zu. Somit wird mehr Rechenleistung benötigt,
um die Objekterkennung erfolgreich durchzuführen, das Verarbeiten der Bilder dauert
länger und sorgt so für die Differenz von ca. 100ms zwischen heller und dunkler
Umgebung.
24
6 Der Arduino UNO R3
Die Arduino UNO R3 Entwicklung Umgebung setzt sich aus zwei Teilen zusammen.
Sie besteht aus dem IO-Board und der Software zum Programmieren desselben.
Das IO-Board setzt sich aus einem Atmel AVR Mikrocontroller und allen notwendigen
Komponenten zum Programmieren des Mikrocontrollers zusammen. Das einfache
Programmieren wird durch den vorinstallierten Bootloader möglich. Das Board besitzt
einen USB zu RS-232 Adapterchip und nimmt so die Kommunikation zum Computer
auf. Es stehen 14 digitale Input/Output Anschlüsse zur Verfügung. 6 dieser
Anschlüsse können auch als PWM-Ausgänge benutzt werden. Des Weitern gibt es 6
analoge Eingänge. Die Syntax der Programmiersprache ist an C angelehnt.
Der Arduino stellt eine einfach zu programmierende Umgebung dar. Durch die eigene
Programmieroberfläche ist es sehr einfach, Änderungen an dem Programm
vorzunehmen. Das geänderte Programm lässt danach über eine USB-Verbindung in
den Mikrocontroller laden. Aufgrund des Aufbaus entfallen aufwendige und somit
zeitraubende Arbeiten wie z.B. der Entwurf der Mikrocontroller-Beschaltung und die
Programmierung desselben. Der Hauptgrund für die Wahl des Arduino war allerdings
die von uns erwartete kürzere Zykluszeit im Vergleich zur MYDAQ von National
Instruments. Die Entwicklungsplattform ist Open Source, was einen weiteren Vorteil
darstellt. Für eine Serienproduktion kommt die Plattform allerdings nicht in Frage, da
sie mit 24€ verhältnismäßig teuer ist.
25
6.1 Hardware
6.1.1 Technische Daten
Tabelle : Technische Daten Arduino
Microcontroller
Operating Voltage
Input Voltage
(recommended)
Input Voltage (limits)
ATmega328
5V
7-12V
Digital I/O Pins
Analog Input Pins
DC Current per I/O Pin
DC Current for 3.3V Pin
Clock Speed
6-20V
14 (of which 6 provide PWM
output)
6
40 mA
50 mA
16 MHz
6.1.2 Anschlussbelegung Arduino UNO R3
Abbildung : Anschlussbelegung Arduino
26
Wie auf Abbildung zu sehen ist, werden nur wenige Anschlüsse des Arduino für
unser Projekt verwendet. Benötigt werden lediglich die USB-Schnittstelle, die die
Spannungsversorgung und die Verbindung zu Labview gewährleistet, sowie Masse
5V+ und 2 PWM-Ausgänge (I/O Pin 3/5) zur Ansteuerung der Servo‘s.
6.1.3 Anschluss der Servomotoren
Für einen Standard Servo gilt in der Regel folgende Belegung: Auf der schwarzen
Ader liegt Masse. Auf der roten Ader liegen 5V+ und die gelbe oder graue Ader
überträgt das PWM-Signal.
Abbildung : Anschlussbelegung Servo
6.2 Software
Der Arduino wird mittels eigener Software programmiert. Diese ist Open Source und
kann auf der Herstellerseite heruntergeladen werden. Mit der Software werden
sogenannte „Sketches“ erstellt, die auf den Mikrokontroller übertragen werden. Die
Programmiersprache ist an C angelehnt. Wir benötigen die Software, um den
vorgefertigten Sketch von National Instruments zu übertragen und so die
Verwendung in Labview zu realisieren.
27
6.2.1 Installieren/Programmieren der Arduino Plattform
Als erstes muss der Treiber von der Herstellerseite installiert werden. Nach dem
Einstellen
(
des
Com-Ports
kann
nun
über
die
Arduino
Software
Abbildung ) der vorgefertigte Sketch von National Instruments auf
die Plattform geladen werden. Nach dem Aufspielen ist der Arduino bereit zum
Datenaustausch mit Labview.
Abbildung : Programmierumgebung Arduino
6.2.1 Einbinden Der Arduino Plattform in Labview
Labview stellt ein Interface für die Arduino UNO R3 Entwicklung Umgebung zur
Verfügung. Dieses Interface ermöglicht ein sehr leichtes Einbinden des Arduino in
das Labview 2012 Entwicklungssystem. Das erreicht man mit dem NI Labview
Interface for Arduino Toolkit, das man auf der Homepage von National Instruments
28
herunterladen kann. Es wird mittels VI Package Manager installiert, anschließend
stehen alle benötigten Programmbausteine zur Verfügung.
7 Labview
7.1 Testprogramm zur Ansteuerung der Servomotoren
Abbildung : Bsp. Programm zur Ansteuerung der Servomotoren
In
unserem Test-Programm
wird
der
Grundaufbau
der
Servo-Ansteuerung
veranschaulicht. Im 1. Bausteint wird festgelegt, an welchem Com-Port der Arduino
angeschlossen ist. Der 2. Baustein bestimmt, wie viele Servomotoren angesteuert
werden sollen. Der 3./4. Baustein gibt an, welchen Pin der jeweilige Servomotor
belegt. Baustein 5 und 6 übergeben die eingestellte Pulsweite in Mikrosekunden. an
den Arduino. Mit der Konstante wird der Ziel-Servo bestimmt. Baustein 6 und 8 lesen
die aktuelle Position des Servo aus und zeigen sie in einem Balkendiagramm an.
Wie bei den Bausteinen 5 und 6 wird der Ziel-Servo über eine Konstante bestimmt.
Über den Baustein 9 schließt man die aktive Verbindung zum Arduino.
Über das gezeigte Bedienfeld kann nun die Pulsweite für jeden Servo einzeln
geregelt werden. Die unteren Balkenanzeigen geben an, auf welcher Position der
Servo zurzeit steht.
29
7.2 Bedienungsanleitung Kameragesteuerte X-Y-Regelung
7.2.1 Voraussetzungen:
Software:
LabView 2012 Entwicklungssystem
Vision Acquisition Software 08/2012
Vision Development Module 2012
Vision Builder AI 2012
Arduino Software Toolkit
Arduino Treiber
NI IMAQ-Treiber
Hardware:
Arduino Mikrocontroller (Arduino UNO R3)
USB Webcam (Windows LifeCam Studio)
Hardware Aufbau balancierende Ebene
PC mit Windows Betriebssystem und für die Software ausreichende
Konfiguration
7.2.2 Inbetriebnahme:
Vor der Inbetriebnahme muss die nötige Software von National Instruments installiert
sein.
Außerdem
muss
sichergestellt
werden,
dass
die
Hardware
korrekt
angeschlossen ist.
Da ein Datenaustausch zwischen Lab View und der Vision Builder AI Software
stattfindet, ist es notwendig, dass die Projekt Datei X_Y_Regelung.lvproj gestartet
wird, da hier die Variablen, die für den korrekten Betrieb nötig sind, im System
registriert werden. Über das geöffnete Projekt kann nun die Virtual Instrument Datei
main.vi gestartet werden.
Ein anschließender Start der Software kann alternativ direkt über die Virtual
Instrument Datei erfolgen.
30
7.2.3 Bedienung:
Abbildung : Frontpanel der Hauptapplikation
Nach
dem
erfolgreichen
Start
der
Software
ist
das
Frontpanel
sichtbar
(Abbildung ). Dies zeigt die Grundeinstellung des Systems mit dem Kontrollpanel. Auf
der linken Seite werden die Statusmeldungen des Bildverarbeitungsalgorithmus
durch die grünen LEDs angezeigt. Darüber befindet sich der Schieberegler für den
Treshold-Filter. Daneben befindet sich die Auswahl für die Arduino-Schnittstelle.
Unterhalb der Statusanzeigen wird das aktuell zu verarbeitende Bild angezeigt. Ein
grünes Dreieck zeigt, dass dieser Wert durch eine globale Variable von der Vision
Builder AI Inspection beeinflusst wird. Weiterhin findet man hier die Bedienelemente,
um das Programm zu steuern.
31
Auf der rechten Seite des Frontpanels befindet sich das Kontroll- und EinstellungsPanel. Ersteres zeigt die aktuelle Lage der Platte über die vier Balken an (links,
oben, rechts, unten). Die zwei Schieberegler im oberen Bereich dienen zur
Steuerung der Servos im Handbetrieb. Die Elemente unterhalb der Lageanzeige
liefern Informationen über die Kugelposition und die Plattengröße.
Abbildung : Frontpanel der Hauptapplikation
Abbildung
zeigt das Frontpanel mit dem Einstellungsreiter. Hierüber kann im
laufenden Betrieb der Regler eingestellt werden. Es bieten sich Einstellmöglichkeiten
zur Optimierung der Schleifenzeit, der Grundregelung, der Verschiebung der
anzusteuernden Position und des PID Regelverhaltens.
Im oberen Bereich des Frontpanels befindet sich eine Menüleiste, worüber das
Programm
ebenfalls
gesteuert
werden
kann. Außerdem
Standardwerte geladen sowie eine Hilfe angezeigt werden.
32
können
hier
die
Vor dem Start der Anwendung muss sichergestellt werden, dass die richtige
Schnittstelle zum Arduino eingestellt ist.
Nach dem Klick auf den Button „System Initialisieren“ öffnet sich ein Dialog, der zur
Auswahl des Bildverarbeitungsalgorithmus auffordert. Als Standarddateiendung ist
hier .vbai, als Dateiname Bilderkennung_V1.0.vba gewählt. Das Standardverzeichnis
wird auf den Speicherort des VIs gesetzt.
Die Bestätigung der Auswahl der Vision Builder Inspection geschieht durch einen
Doppelklick oder durch Drücken des Buttons „Öffnen“.
In einem neuen Fenster sieht man, wie der Vision Builder AI Server gestartet wird
(Abbildung ).
Abbildung : Vision Builder AI Server Luncher
Nachdem der Server läuft, ist das System Betriebsbereit. Die Buttons „Stopp“ und
„Regelung aktivieren“ sind nun wählbar. Über die sechs LED-Anzeigen wird der
Vision Builder AI Inspection Status angezeigt. „LV_Import“ zeigt, ob die Kamera
arbeitet und Bilder aufzeichnet. Die Anzeige „LV_Bearbeitung“ signalisiert die
funktionierende Bildbearbeitung (Aus dem 32bit Farbbild muss ein 8Bit Graustufen
Bild generiert werden). „LV_Plattenerkennung“ ist aktiviert, wenn die Platte korrekt
erkannt wurde. Auf die Plattenerkennung folgt das Koordinatensystem, dieses wird
durch „LV_Koordinatensystem“ angezeigt. Auf das Koordinatensystem setzt die
Bereichserstellung auf, dessen Status mittels „LV_Bereichserstellung“ signalisiert
wird. Zuletzt wird die Kugelerkennung durch „LV_Kugelerkennung“ angezeigt.
33
Außerdem sollten das aktuelle Bild und der aktuell gewählte Algorithmus sichtbar
sein. Über den Button „Stopp“ kann nun jederzeit das System angehalten und der
Vision Builder Server beendet werden.
Wenn sich zu diesem Zeitpunkt eine Kugel im System befindet, kann der „Treshold
Filter“ (Schwellwert) so lange verändert werden, bis die Kugel sauber erkannt wird.
Ob
die
Kugel
richtig
erkannt
wurde,
„LV_Kugelerkennung“ angezeigt. Bei viel Licht
wird
durch
die
Statusmeldung
muss der Wert etwas nach oben
verschoben werden, bei wenig Licht etwas nach unten.
Die Werte im Kontrollpanel werden erst nach dem Betätigen von „Regelung
aktivieren“ aktualisiert. Wenn dies geschehen ist, fängt das System sofort an, die
Kugel in den Mittelpunkt der Platte zu regeln. Im Kontrollpanel ist unter „Position X“
und „Position Y“ die aktuelle Abweichung der Kugel zum Plattenmittelpunkt in
Prozent zu sehen. Die anderen dort angezeigten Parameter zeigen die Plattenmitte
(Plattenmitte X und Plattenmitte Y), die Position der Kugel (Kugel X und Kugel Y) und
die Größe der Platte (Platte B und Platte H) in Pixel. Über den Button „Handbetrieb“
wird die Regelung deaktiviert, nun kann das System manuel bedient werden. Dies
wird über die zwei Schieberegler ermöglicht (Servo X und Servo Y). Mit „Servo X“
kann das System zwischen -100 Prozent und +100 Prozent in der X-Achse bewegt
werden. Selbiges gilt für den Regler „Servo Y“ in der Y-Achse. Alternativ kann auch in
den nebenstehenden Zahlenfeldern direkt ein Wert eingetragen werden. Mittels des
Buttons „Null-Stellung“ wird das System in die Waagerechte gebracht.
Befindet man sich im Regelbetrieb und schaltet um auf den Einstellungsreiter,
können das Regelverhalten und diverse andere Einstellungen geändert werden.
In dem nun sichtbaren Panel kann die Schleifenzeit festgelegt werden, diese dient
zur Anpassung an die Schleifenzeit der Vision Builder AI Inspection. Die aktuelle
Schleifenzeit wird nebenstehend angezeigt. Über das Element „Leerschleifen“ wird
die Anzahl der Leerschleifen angezeigt, die durchlaufen werden, bis neue Daten vom
Vision Builder AI übertragen wurden. Ein Ändern der Schleifenzeit wirkt sich direkt
auf die Leerschleifen aus. Über das Anzeigeelement „LV_Counter“ wird die Anzahl
der bisher durchlaufenden Vision Builder AI Schleifen angezeigt.
34
Mittels den Parametern „Annäherung X“ und „Annäherung Y“ wird die Plattenneigung
in Abhängigkeit von der Kugelposition geändert. Je höher diese Werte sind, desto
weniger wird die Platte ausgesteuert. Erfahrungen haben gezeigt, dass diese Werte
zwischen zwei und drei liegen sollten.
Mit den Parametern „Gegensteuerung X“ und „Gegensteuerung Y“ wird angegeben,
wie stark die Kugel gebremst wird. Bewegt sich die Kugel schnell (Abstand der Kugel
zwischen
zwei
Messungen
hoch),
wird
die
Platte
entgegengesetzt
der
Bewegungsrichtung der Kugel geregelt. Erfahrungswerte liegen hier zwischen 0,2
und 0,3.
Die zwei Parameter „Verschiebung X“ und „Verschiebung Y“ stehen in Abhängigkeit
zu dem Button „Punkt“. Es kann eine Prozentuale Verschiebung zwischen +/- 100
Prozent eingestellt werden. Dies hat zur Folge, dass die Kugel nicht in der Mitte
positioniert wird, sondern um den eingetragenen Wert verschobenen wird. Positive
Werte lenken die Kugel nach oben beziehungsweise nach rechts ab. Negative Werte
hingegen lenken die Kugel nach unten und nach links.
Abbildung : Positionsverschiebung
35
Wird der Button „Punkt“ aktiviert, wird die Platte in Mittelposition gebracht. Jetzt kann
mit der Maus ein beliebiger Punkt im Bild angeklickt werden (siehe Abbildung grünes
Kreuz). Der rote Punkt im Bild zeigt den Plattenmittelpunkt, darunter befindet sich die
Kugel. Die Verschiebung wird links im Bild als Zahlenwert übernommen. Mit einem
weiteren Drücken auf den Button „Punkt“ wird der nun verschobene Punkt versucht
anzusteuern. Liegen die verschobenen Werte nahe der Plattengrenze oder gar
außerhalb, so wird es nicht möglich sein, die Kugel dort zu positionieren, da ein
Gegenregeln nur noch in eine Richtung möglich ist.
Weitere Einstellungsmöglichkeiten bietet der verwendete PID Regler. Hier kann über
die Parameter „P X“, „P Y“, „D X“, „D Y“, „I X“ und „I Y“ das Regelverhalten für die Xund Y-Achse separat eingestellt werden. Über den Button „Regler an“ kann der
Regler komplett ein- bzw. ausgeschaltet werden.
36
7.3 Funktionsweise der Lab View Anwendung
Die Lab View-Anwendung stellt das Herzstück dieser Arbeit dar, hier werden die vom
Bildverarbeitungsalgorithmus
bereitgestellten
Daten
verarbeitet
und
die
Servomotoren mittels des Arduino-Mikrocontroller-Boards gesteuert. Die ermittelten
Bildinformationen
müssen
in
rechenbare
Werte
umgesetzt
werden,
damit
anschließend die Regeleinheit diese Daten verarbeiten und an die Steuereinheit
weitergeben kann. Aufgabe der Steuereinheit ist es, diese Regeldaten in für den
Mikrocontroller verständliche Daten umzusetzen, damit diese an die Servomotoren
weitergegeben werden können. Die Servomotoren setzen diese elektrischen Impulse
in kinetische Energie um, so dass die zweidimensionale Ebene sich in ihren beiden
Achsen neigt, um die Kugel entsprechend zu bewegen.
Wie im Kapitel über den Bildverarbeitungsalgorithmus beschrieben, reicht es nicht
aus, ein einzelnes VI (Virtual Instrument-File) zu erstellen. Da die von Vision Builder
erfassten Daten mittels globalen Variablen übertragen werden, muss eine Lab View
Projektdatei erzeugt werden (siehe Abbildung ).
Abbildung : Lab View Projektdatei
37
Abbildung
zeigt die Projektdatei mit den dazugehörigen Dateien. Enthalten sind
unter anderem der Bildverarbeitungsalgorithmus „Bilderkennung_V1.0.vbai“, die
Datei „hilfe.pdf“ und „hilfe.vi“, zuständig für die Anzeige und den Aufruf der Hilfedatei,
das VI „ueber“ mit Informationen zur Anwendung und eine Bibliothek mit den
verwendeten Variablen (rechter Teil der Abbildung ). Kerndatei stellt die „main.vi“ dar,
mit dieser wird das eigentliche Programm gestartet.
Das VI „ueber“ kann im Hauptprogramm über den Menüpunkt „Hilfe“ aufgerufen
werden.
Dieses
enthält
Versionsinformation,
die Autoren
und
eine
kurze
Beschreibung. Mittels des Buttons „Hilfe“ wird das VI „hilfe“ ausgeführt, welches
wiederum die „hilfe.pdf“ einbettet. Die PDF-Datei beinhaltet die Bedienungsanleitung
des Hauptprogrammes.
Nach dem Öffnen der „main.vi“ wird das Frontpanel angezeigt und über den Reiter
„Fenster“,
„Blockdiagramm
anzeigen“
(Strg
+
E)
gelangen
wir
in
das
Programmierfenster, in welchem das Hauptprogramm angezeigt wird.
Die Anwendung ist sequenziell gestaltet, was über fünf flache Sequenzen erreicht
wird. Dies ermöglicht uns, das Programm Schritt für Schritt abzuarbeiten, was
wiederum zu geringeren Schleifenzeiten in der eigentlichen Regelung führt.
38
Abbildung : main.vi Initialisierung
In Fehler: Referenz nicht gefunden wird die erste Sequenz dargestellt, welche der
Initialisierung der Anwendung dient und in einer Endlosschleife (While-Schleife) läuft.
Es werden Einstellungen bezüglich der verwendeten Bedienelemente vorgenommen
sowie das Menü eingerichtet, über welches das Programm gesteuert werden kann.
Des Weiteren befindet sich in der Schleife eine Case-Anweisung, welche über das
Menü oder den Button „System Initialisieren“
aufgerufen wird. In der Case-
Anweisung wird ein Express-VI verwendet, das einen Dialog zur Auswahl der
Bildverarbeitungsdatei erzeugt. Das Express-VI wird mit folgenden Daten versorgt:
Dialogtext, Schaltflächenbeschriftung, Standarddateiendung, Standarddateiname,
Name der Dateiendung und Standardpfad. Vor der Sequenz in Abbildung sieht man
ein Teil der Bedienelemente, die mit den verwendeten globalen Variablen verknüpft
sind.
39
Abbildung : main.vi Serverstart
Nachdem der Bildverarbeitungsalgorithmus ausgewählt ist, wird dieser in der zweiten
Sequenz geöffnet. Hierzu muss zuerst der Vision Builder AI Server gestartet und eine
Verbindung hergestellt werden (Abbildung ). Nach dem Öffnen der Inspection wird
diese ausgeführt.
Abbildung : main.vi Reglervorbereitung
Im nächsten Schritt (Abbildung ) wird der Arduino Mikrocontroller initialisiert,
anschließend wird wieder eine Endlosschleife ausgeführt, welche über den Button
„Regelung aktivieren“ beendet wird. So springt das Programm in die Regelsequenz.
In Sequenz drei muss das Menü aktualisiert werden, damit auch von dort aus der
Regler aktiviert werden kann. Über den Button „Stopp“ kann das Programm beendet
werden. Hierfür wird eine Case-Anweisung ausgeführt, in welcher der Vision Builder
AI Server gestoppt und die Verbindung beendet wird. Außerdem wird der Button
„Stopp“ auf boolesches „false“ gesetzt, da dieser mehrfach verwendet wird und daher
nicht als Taster ausgeführt werden kann. Als weitere Maßnahme in dieser Sequenz
werden verschiedene Variablen (Abbildung rechte Seite) für den Regelbetrieb auf
„null“ gesetzt.
Die Regeleinrichtung wird in einer Sequenz abgebildet, allerdings besteht diese aus
mehreren verschachtelten Schleifen und Case-Anweisungen. An erster Stelle in der
40
Sequenz steht eine While-Schleife, diese sorgt dafür, dass das System durchgängig
läuft und die Kugel Schleife für Schleife ausbalanciert wird. In dieser Schleife wird
eine Case-Anweisung ausgeführt, diese wird boolesches „true“, wenn die Variable
„LV_Counter“ sich ändert. „LV_Counter“ repräsentiert den Schleifenzähler der Vision
Builder AI Inspection. Liefert diese Variable keine neuen Daten, das heißt die Lab
View Regelschleife läuft schneller als die Inspection-Schleife, wird eine „LeerSchleife“ ausgeführt. Diese „Leerschleife“ beinhaltet lediglich einen Zähler und einen
2ms-Timer. Der Timer dient zur Begrenzung der CPU-Last und es wird über den
Zähler dargestellt, wie oft diese „Leer-Schleife“ ausgeführt wird. Ist die CaseAnweisung allerdings „true“, wird eine dreifach gestapelte Sequenz ausgeführt. In der
ersten und letzten Sequenz wird jeweils die aktuelle Zeit ermittelt, diese werden
voneinander abgezogen und die Differenz ergibt die Zeit, welche die mittlere
Sequenz benötigt, um einmal durchzulaufen. Diese Sequenz beinhaltet die
eigentliche Regelung.
Im ersten Abschnitt kommt erneut eine Case-Anweisung zum Einsatz, diese dient der
Nullpunktverschiebung per Mausklick und wird durch den Button „Punkt“ aktiviert.
Abbildung : main.vi Koordinatenverschiebung per Maus
41
Mit der Funktion „ROI Image“(Region Of Interest), zu sehen in Abbildung , werden
die „ROI“ Informationen des Bildes abgefragt, welche die Koordinaten des mit der
Maus gesetzten Punktes enthalten. Die Daten liegen im Typ Cluster vor und müssen
erst gekapselt werden. Dies geschieht durch eine Aufschlüsselung des Clusters, so
erhalten wir Daten vom Typ Array, die wieder in ein Cluster umgewandelt und
aufgeschlüsselt werden. Das so entstandene Cluster wird wiederum aufgeschlüsselt
und umgewandelt, dadurch stehen die Koordinaten, angegeben in Pixeln, in zwei
Variablen vom Typ numerisch zur Verfügung. Diese Werte werden zuletzt noch in
Prozent umgerechnet und als direkte Verschiebung weitergeleitet.
Abbildung : main.vi Datenerfassung
Im folgenden Schritt (Abbildung ) werden die Positionsdaten für die X- und die YAchse mittels globalen Variablen erfasst und umgerechnet. Ermittelt werden die
Position der Kugel, die Mittelposition der Platte und die Breite und Höhe der Platte.
Die erfassten Werte werden absolut in Pixeln angegeben und vom Programm in
prozentuale
Werte
umgerechnet
(-100%
bis
+100%),
so
dass
die
Plattenmittelposition bei 0/0 Prozent liegt. Zusätzlich werden die ermittelten und
umgerechneten Werte im Kontroll-Reiter des Frontpanels angezeigt.
42
Nachdem die Position relativ zur Plattenmitte bestimmt wurde, werden diese Werte
an den Standardregler weitergegeben (siehe Abbildung ).
Abbildung : main.vi Standardregler
Über das Element „Verschiebung“ kann direkt die Verschiebung des Nullpunktes in
der X- und der Y-Achse angegeben werden (Angaben in Prozent). Das Element wird
zusätzlich als Variable für die Verschiebung mit der Maus verwendet. Die
Koordinaten des angeklickten Punktes werden direkt in das Anzeigeelement
eingetragen. Diese Verschiebung wird im nachfolgenden Schritt von der aktuellen
Kugelposition (Abbildung , Eingang Kugelposition) abgezogen und anschließend auf
ein Schieberegister gelegt. Das Schieberegister sorgt dafür, dass im nächsten
Schleifendurchgang die alte Kugelposition zur Verfügung steht. Des Weiteren wird
die „verschobene“ Kugelposition für die weitere Verarbeitung an den PID Regler
weitergeleitet (Abbildung , Ausgang PID). Über das Element „Annäherung“ wird
ähnlich einem P-Regler ein Faktor dazu gerechnet. In diesem Fall wird der
eingestellte Faktor von der angepassten Kugelposition dividiert, so dass wir einen
gedämpften Wert erhalten. Die „Annäherung“ sorgt dafür, dass die Platte
entsprechend der Kugelposition geneigt und so die Kugel Richtung Mitte gelenkt
wird. Je weiter die Kugel vom Mittelpunkt entfernt ist, desto stärker wird die Platte
geneigt. Die Dämpfung ist notwendig, damit die Kugel nicht zu stark beschleunigen
kann und somit das System anfängt zu schwingen.
43
Über das Schieberegister steht immer die letzte Position der Kugel zur Verfügung,
welche von der aktuellen Position subtrahiert wird. Dadurch erhalten wir die Differenz
der Kugelposition gegenüber dem vorherigen Schleifendurchgang. Diese Differenz
wird ebenfalls durch einen Faktor (Gegensteuerung) dividiert und zum Wert der
„Annäherung“ dazu addiert. Die Gegensteuerung bewirkt, dass, bei großer Differenz,
die Platte entgegengesetzt der Kugel geneigt wird und diese abbremst. Über die
Ausgangsleitung (siehe Abbildung , Ausgang) gelangt der angepasste Wert direkt an
die Steuereinheit, welche für den Arduino Mikrocontroller zuständig ist.
Abbildung : main.vi Vorbereitung zu Ansteuerung
Abbildung zeigt die Vorbereitung zur Ansteuerung der Servos. Mittels des Buttons
„Regler an“ kann zwischen dem PID-Regler und dem Standardregler gewechselt
werden. Dies geschieht mit dem „Select-Baustein“, welcher auf logisch „true“ prüft
und das entsprechende Signal weiterleitet. Mit dem Steuerungselement „Punkt“ wird
die zuvor beschriebene „Case-Struktur“ aktiviert, welche der Verschiebung mittels
der Maus dient. Zusätzlich wird die Platte in Mittelstellung gebracht, um
Verzerrungen zu vermeiden, welche bei der Aufnahme des Bildes entstehen könnten.
Außerdem wird über die negierte globale Variable „LV_Kugelerkennung“ das System
in Mittelstellung gebracht, sodass sich die Platte nicht unkoordiniert bewegt, sollte die
Kugel nicht erkannt werden. Des Weiteren findet hier die Umschaltung in den
Handbetrieb statt (Button „Hand“ in Abbildung ). Über den Schieberegler „Servo“
kann im Handbetrieb die Servomotor-Position verändert werden.
44
In die dazugehörige Variable werden stets die aktuellen Positionswerte eingetragen,
so dass diese mittels des Schieberegisters angezeigt werden. Zusätzlich erfolgt eine
Anzeige über die zwei Balkenanzeigen.
Die hier anstehenden prozentualen Werte werden anschließend umgerechnet, damit
sie vom Arduino verarbeitet werden können. Auf den Arduino und dessen
Ansteuerung wird hier nicht weiter eingegangen, da dieser in einem separaten
Kapitel behandelt wird.
Abbildung : PID-Regler
Der verwendete PID-Regler4 wird als SubVI eingefügt und stammt aus dem
deutschen Lab View-Forum5. Er wurde leicht modifiziert und um den Eingang „s“
erweitert, damit ist es möglich, den sogenannten „wind up“ Effekt zu umgehen, in
dem die Integration des I-Anteils zurückgesetzt wird. Der PID-Regler erhält über
Eingabeelemente die Werte für die Eingänge P, I und D. Über „upper limit“ und „lower
limit“ werden der obere und untere Grenzwert eingestellt. Der Anschluss „set point“
ist die Soll-Vorgabe und „process variable“ der Ist-Wert. Dieser Dateneingang ist
direkt mit der Kugelposition verknüpft. Der Ausgang „output value“ wird direkt an den
PID-Eingang in Abbildung weitergegeben.
Die letzte Sequenz dient der Beendigung des Vision Builder AI Servers, dem Arduino
und Lab View. Wie schon in Sequenz drei beschrieben, wird hier der Server gestoppt
und anschließend die Verbindung geschlossen. Ein Fehlerdialog weist auf mögliche
4
Erläuterungen zum Verständnis eines PID-Reglers werden im Anhang aufgeführt.
5
PID-Regler (http://www.labviewforum.de/attachment.php?aid=2923) bezogen von
http://www.labviewforum.de/Thread-Wo-ist-der-PID-Regler-Baustein.
45
Fehler hin. Wird diese Meldung bestätigt, wird die Anwendung beendet. Ist ein Fehler
aufgetreten, muss der Vision Builder AI Server eventuell manuell beendet und der
Arduino mittels der Reset-Taste zurückgesetzt werden.
7.4 Problematiken der Lab View Anwendung
Das erste Problem stellte der Aufruf der Bildverarbeitung dar. Dieses Problem
konnte, wie im Kapitel zum Bildverarbeitungsalgorithmus beschrieben, mittels des
Vision Builder AI Servers behoben werden.
Bis zum Zusammenfügen der Softwareelemente, wurden die Tests mit der MyDAQMessbox von National Instruments durchgeführt, dies führte aber zu einer erhöhten
Schleifenzeit von ca. 40ms. Dadurch war eine ruckel-freie Ansteuerung der
Servomotoren nicht möglich. Durch die Verwendung des Arduino Mikrocontroller
Boards verkürzte sich die Schleifenzeit auf ca. 10ms. Dies macht sich in der
Performance der Servomotoren stark bemerkbar.
Durch die Bewegung der Platte ändert sich dessen Winkel, dies hat zur Folge, dass
der Nullpunkt der Platte verschoben wird. Durch diese Problematik wird leider eine
genaue Ausregelung nicht möglich, so dass die Servomotoren nahe des Nullpunktes
immer wieder versuchen, die Kugel genau auf „Null“ zu positionieren. Dies führt
dazu, dass durch die Servomotoren die Platte etwas ruckelt, auch dann, wenn die
Kugel eigentlich schon „steht“.
Weitere Probleme bereitet die Integration des I-Anteils im verwendeten PID-Regler.
Wird der Regler nicht angesprochen, so läuft dieser Integralwert nach einiger Zeit
über und der PID-Regler verweigert seinen Dienst. Abhilfe brachte eine Modifizierung
des verwendeten Reglers. Es wurde ein Eingang zum Zurücksetzen des I-Anteils
hinzugefügt, so dass der Regler, wenn er nicht verwendet wird, zurückgesetzt wird.
Ein weiteres Problem bezüglich des PID-Reglers ist die Verzögerung in den
vorliegenden Daten. Zuerst muss das Bild erfasst und bearbeitet werden.
Anschließend werden die ermittelten Werte in die Variablen geschrieben, damit Lab
View diese aufgreifen und weiter verarbeiten kann. Zum Schluss werden die Daten
an den Arduino übertragen und die Servomotoren stellen die neuen Werte ein. Dies
kann je nach Tageslicht und Plattenneigung schon mal 400ms in Anspruch nehmen.
46
Im Kapitel über die Hardware haben wir dargestellt, dass die Zeit, welche die Kugel
benötigt, um in der Y-Achse von einer zur anderen Seite zu rollen, ca. 500ms beträgt.
Demnach befindet sich die Kugel schon auf einer anderen Position, wenn der Regler
auf die vorhandenen Daten reagiert. Hier könnte es von Vorteil sein, die
Kugelposition vektoriell zu betrachteten, um so die nächste Position der Kugel
vorherzusagen. Damit wäre der Regler einen Schleifenzyklus schneller.
Des Weiteren ist es nicht möglich, den Regler genau einzustellen, da sich die
Schleifenzeiten der Bildverarbeitung ständig ändern und so nicht immer aktuelle
Bildinformationen zur Verfügung stehen, was dazu führt, dass „Leerschleifen“
ausgeführt werden. Deswegen kann der PID-Regler nicht ordentlich integrieren und
differenzieren, sodass das gewünschte Regelverhalten ausbleibt.
Damit der Regler korrekt arbeiten kann, muss der Regler vollständig in die
Anwendung
eingebracht
werden.
Außerdem
müsste
das
Ausführen
der
„Leerschleifen“ so geändert werden, dass der Regler hiervon nicht beeinflusst wird.
Die relativ langen Schleifenzeiten der Bildverarbeitung, bezogen auf die Schleifenzeit
der Regelung, können durch Verwendung einer industriellen s/w-Kamera behoben
werden. Durch höhere Bildwiederholfrequenzen muss nicht auf ein neues Bild
gewartet werden. Da eine industrielle s/w-Kamera direkt ein 8Bit-Bild liefert, fiele
damit ein Schritt im Bildverarbeitungsalgorithmus weg, was wiederum zu geringeren
Iterationszeiten führen würde.
Erst wenn eine ausreichend schnelle und genaue Regelung realisiert ist, kann
versucht werden, eine Demofunktion zu entwickeln, welche es ermöglicht,
verschiedene geometrische Figuren „abzurollen“.
47
8 Fazit
Zusammenfassend lässt sich sagen, dass die Projektziele größtenteils erreicht
wurden. Es ist uns gelungen, mit Hilfe einer Webcam und zwei Servomotoren eine
Stahlkugel auf einer Holzplatte zu balancieren. Dabei kann ein nahezu beliebiger
Punkt auf der Platte angesteuert werden. Ein weiteres Ziel war die Demonstration
verschiedener Regler. Dies wurde insoweit erfüllt, dass eine eigene Regelstufe
erstellt und zusätzlich ein PID-Regler implementiert wurde, auf dessen Problematik in
diesem Abschlussprojekt eingegangen wurde. Auf das mögliche Erweiterungsziel,
das
Nachfahren
von
verschiedenen
geometrischen
Figuren,
konnte
nicht
eingegangen werden, da hierfür eine Optimierung der Geschwindigkeit nötig wäre.
Dazu wäre es von Vorteil, bessere Servomotoren zu verwenden und diese nicht am
Rand, sondern weiter Richtung Mitte zu platzieren, um den steuerbaren Weg der
Servomotoren zu verkürzen. Nach der Modifizierung der Hardware, könnte es
notwendig sein, den Regelkreis und den Bildverarbeitungsalgorithmus zu optimieren,
um die Software an die Hardware anzugleichen. Um die Rolleigenschaften der
Stahlkugel zu verbessen, müsste die Pappelholzplatte durch eine ebene Fläche, wie
zum Beispiel eine Metallplatte, ersetzt werden. Diese Maßnahmen würden es
ermöglichen, das nicht behandelte Sonderziel zu erreichen und so geometrischen
Figuren zu folgen. Eine weitere Möglichkeit zur Erweiterung dieser Arbeit bestünde
darin, Hindernisse einzubauen, die umfahren werden müssen.
Die beschriebenen Punkte bieten sich dazu an, in einem Anschlussprojekt
aufgegriffen und ausgebaut zu werden.
Abschließend ist zu sagen, dass die erreichten Ziele in der geforderten Zeit
hinreichend erfüllt wurden und die während der Arbeit auftretenden Probleme alle
thematisiert und im Rahmen der gegebenen Möglichkeiten behoben wurden.
48
9 Englische Zusammenfassung
This project is about image acquisition/recognition and the analysis of them. It is our
aim to balance a steel ball on a movable plate by use of a camera system. The steel
plate can be moved in all directions by two servo motors. These two motors will be
controlled by an Arduino UNO R3 development board and a personal computer with
LabView. The image recognition will be handled by the NI Vision Builder. The pictures
will be taken by a Microsoft LifeCam Studio.
We used the following Software:
LabView 2012 Development Environment
Vision Acquisition Software 08/2012
Vision Development Module 2012
Vision Builder AI 2012
Arduino Software Toolkit
Arduino driver
NI IMAQ-driver
In summary, it can be said that we reached our targets. We are able to balance the
steel ball on the movable plate to every position we want.
The main problem with the Hardware setup was to find the right surface for the
camera. On a bright surface the steel ball would cast to many shadows, but it had a
better contrast than a black one. We finally chose a black and matt surface, because
it was the better solution for the shadow problem. The servos we used have an
reaction time of 200ms for 60 degrees, which is too slow to control the steel ball
properly. It took a few seconds to get the steel ball under control. To reduce the circuit
time, we used the Arduino UNO R3 instead of the NI myDAQ. A too dark environment
caused trouble, too, because in the dark the Tresholdfilter needs other settings than it
needs on a bright environment. Also the fps rate will drop in a dark environment.
Other fields of application could be to place obstacles on the plate and steering the
steel ball around them or control the movement in geometrical figures like a triangle,
for example. Finally we can say that we reached all targets in time. All occurring
Problems were addressed and solved.
49
10 Verzeichnisse
10.1 Quellenverzeichnis
Physik für Ingenieure von Hering, Martin und Stohrer, Springer Verlag, 10. Auflage,
Berlin Heidelberg, 2007
Seite 12
Internetquellen (Stand: 05.04.2013):
http://www.physik.uni-augsburg.de/~sausemar/FP14/FP14.pdf
Seite 53
http://www.labviewforum.de/Thread-Wo-ist-der-PID-Regler-Baustein
Seite 45
http://www.servodatabase.com
Seite13
http://www-home.fh-konstanz.de/~mfranz/ibv_files/lect00_Einleitung.pdf
Seite 5
10.3 Tabellenverzeichnis
50
10.2 Abbildungsverzeichnis
51
11 Anhang
11.1 Puls-Weiten-Modulation (PWM)
Der Bewegungsradius des Servo wird durch ein Pulsweitenmoduliertes Signal
gesteuert. Die minimale Pulsdauer beträgt ca. 1ms (Linksanschlag). Rechtsanschlag
erreicht man mit einem ca. 2ms langen Signal. Bei Mittelstellung wird der Servo mit
einem ca. 1,5ms langen Puls angesteuert. Die gesamte Periodendauer beträgt 20ms
Millisekunden(siehe Abbildung ).
Abbildung : PWM-Signal
52
11.2 Der PID - Regler6
11.2.1 Zweipunkt-Regler
Die primitivste Form eines Reglers ist der sogenannte Zweipunktregler. Er kennt nur
zwei Zustände für die Stellgröße (z.B. Heizung ein/aus) und wird meist durch einen
Komparator mit Hysterese realisiert (z.B. Bimetallschalter). Diese Art der Regelung
führt zwangsläufig zu einer Oszillation der Regelgröße, ist dafür aber technisch
einfach zu realisieren und daher meist sehr billig.
11.2.2 Proportionalregler
Ein Proportional- (P-) Regler liefert eine kontinuierliche Stellgröße, die zur
Regelabweichung proportional ist. Da die Stellgröße immer durch einen maximalen
und minimalen Wert beschränkt ist, geht der P-Regler bei großer Regelabweichung
in Sättigung. Den linearen Bereich dazwischen nennt man „proportionale
Bandbreite“. Diese wird umso kleiner je größer die Proportionalverstärkung k gewählt
wird. k ist im Idealfall frequenzunabhängig. Das Problem des P-Reglers liegt darin,
dass er stets eine endliche Regelabweichung benötigt, um reagieren zu können (es
sei denn der Arbeitspunkt in der Mitte der Bandbreite liefert zufällig den gewünschten
Sollwert). Man könnte nun k möglichst groß wählen, um die dauerhafte
Regelabweichung entsprechend klein zu halten. Dem sind jedoch Grenzen gesetzt,
da zu hohen Frequenzen hin praktisch jede Regelstrecke durch ihr Tiefpassverhalten
eine Phasenverschiebung von 180° erreicht. An diesem Punkt tritt anstelle von
Gegenkopplung Mitkopplung auf und bei einer Schleifenverstärkung ≥1 hat dies eine
ungedämpfte Schwingung des Systems zur Folge, was es zu vermeiden gilt. Deshalb
muss die Verstärkung des P-Reglers so gering gehalten werden, dass bereits vor
Erreichen der Mitkopplung die Schleifenverstärkung <1 wird.
6
Das Kapitel PID-Regler wurde übernommen von der Internetquelle:
http://www.physik.uni-augsburg.de/~sausemar/FP14/FP14.pdf Stand: 05.04.2013
53
11.2.3 Integralregler
Das Problem der dauerhaften Regelabweichung des reinen P-Reglers kann durch
Hinzunahme eines Integrators weitgehend behoben werden. Der Integrator liefert
einen additiven Beitrag zur Stellgröße, der sich aus dem zeitlichen Integral der
Regelabweichung ergibt und erst dann stationär wird, wenn die Regelabweichung
verschwindet. Der Integrator besitzt eine Phasennacheilung von −90° und eine
Verstärkung proportional zum Kehrwert der Frequenz (Steigung −1 im BodeDiagramm). Die Grenzfrequenz des PI-Reglers, bei der die Verstärkung gleich der PVerstärkung wird, muss deutlich kleiner als die Eigenfrequenz des P-geregelten
Systems gewählt werden, um das Stabilitätskriterium nicht zu beeinflussen.
11.2.4 Differentialregler
Im Gegensatz zum Integrator arbeitet der Differentiator vorwiegend bei hohen
Frequenzen (Steigung +1 im Bode-Diagramm) und bei einer Phasenvoreilung von
+90°. Diese Eigenschaft führt dazu, dass eine zusätzliche Phasenreserve von 90°
zur Verfügung steht und deshalb eine größere Verstärkung auch bei hohen
Frequenzen möglich ist. Dadurch reagiert der Regler schneller und kann
Oszillationen beim Einschwingvorgang effektiv unterdrücken.
54

Abschlussprojekt Kameragesteuerte XY

Transcrição

Documentos relacionados

WILBERT Turmkrane GmbH - WILBERT TowerCranes GmbH

Zeitplan Sportfest SV Urmitz

2013-01-25 - WILBERT TowerCranes GmbH

T-Shirts selbst bedrucken Multitalent Arduino

Am Schriftzug unschwer zu erkennen, wem der Darmstädter

Arduino + Android Projects for the Evil Genius

Torwand bauen - Anleitung

meet the champions - Sportmanagement Marlo Zurhausen

Teil 13 Die Urform des Schachspiels

Anleitung Flugsimulator (Stand Juni 2015)

2007-03-29 Bauvorhaben WILBERT in Waldlaubersheim