Bachelorarbeit - HS-OWL

Hochschule Ostwestfalen-Lippe
Fachbereich Elektrotechnik und Technische Informatik
Bachelorarbeit
des Herrn
Daniel Klose
Matr.-Nr.: 1522 2039
gemäß Bachelorprüfungsordnung für den Studiengang Elektrotechnik
in der Fassung der Bekanntmachung
vom 30. September 2008
(Verkündungsblatt der Hochschule 2008/Nr. 16).
Thema:
Programmierung eines mobilen Roboters
1. Prüfer/-in:
2. Prüfer/-in:
Prof. Dr.-Ing. Rolf Hausdörfer
Prof. Dr.-Ing. Thomas Korte
Die Bachelorarbeit umfasst 37 Seiten.
Erklärung
II
Ich erkläre, dass ich die vorliegende Bachelorarbeit selbstständig angefertigt habe.
Zur Anfertigung der Bachelorarbeit benutzte ich keine anderen als die angegebenen
Quellen und Hilfsmittel.
Die Ausfertigung als CD-ROM liegt bei.
Lemgo, den 23.11.2012
___________________________________
(Unterschrift des Autors)
Bachelorarbeit
WS12/13
Daniel Klose
Kurzfassung / Abstract
III
Kurzfassung
Die vorliegende Bachelorarbeit behandelt die Entwicklung einer Software für einen
mobilen Roboter, dessen Grundlage der c’t-Bot der gleichnamigen Zeitschrift ist. Die
Software ist in der Programmiersprache C geschrieben und läuft auf einen Mikrocontroller des Typs 68HCS12, der den Roboter steuert. Neben dem Aufbau der
Software werden in der Bachelorarbeit die Methoden und die Strategien beschrieben,
die zur Fortbewegung und zum Steuern des Roboters nötig sind. Dabei versucht die
Software den Stromverbrauch zu reduzieren, wenn der Roboter nicht genutzt wird.
Der Roboter kann von Studenten und Schülern genutzt werden, um an die hardwarenahe Programmierung herangeführt zu werden und vorhandene Kenntnisse zu vertiefen. Dazu können viele Funktionen der Software weiter genutzt werden und erleichtern das Erstellen von Anwendungen für den Roboter.
Abstract
The thesis explains the processing of a software for a robot, which is based on the
c’t-Bot of the so-called magazine c’t. The software is programmed with the programming language C and runs on a 68HCS12 microcontroller, which controls the
robot. The thesis also describes the structure of the software, but especially the methods and strategies to move and control the robot. The software tries to reduce the
energy consumption if the robot is not being used. Students can utilize the robot to
learn hardware-oriented programming and get practical experience. Many of the
software’s functions can be useful to extend it and allow creating new applications
for the robot.
Bachelorarbeit
WS12/13
Daniel Klose
Inhaltsverzeichnis
IV
Inhaltsverzeichnis
Kurzfassung/Abstract .............................................................................................. III
Inhaltsverzeichnis .................................................................................................... IV
Abbildungsverzeichnis............................................................................................. VI
Abkürzungsverzeichnis ..........................................................................................VII
1 Einleitung..................................................................................................................1
1.1 Einführung...........................................................................................................1
1.2 Ziele .....................................................................................................................1
2 Motorregelung ..........................................................................................................3
2.1 Modellbildung des Motors ..................................................................................3
2.2 Regelstreckenbildung ..........................................................................................6
2.3 Quasikontinuierlicher Reglerentwurf ..................................................................7
2.4 Diskretisierung der Regelung ..............................................................................9
2.5 Regelung im Programm ....................................................................................11
3 Fernbedienung .......................................................................................................12
3.1 RC5-Code ..........................................................................................................12
3.2 Entschlüsselung des RC5-Codes im Programm ................................................13
4 Positionsberechnung ..............................................................................................15
4.1 Daten des Positionssensors................................................................................15
4.2 Berechnung der Positionsdaten .........................................................................16
5 Distanzberechnung der Distanzsensoren .............................................................19
6 Transportfunktion .................................................................................................21
6.1 Hardwaremodifikation für den Antrieb der Klappe ..........................................21
6.2 Steuerung der Transportklappe .........................................................................22
7 Programmierte Anwendungen .............................................................................24
7.1 Freie Fahrt (free_drive) .....................................................................................24
7.2 Linienverfolgung (follow_line) .........................................................................25
7.3 Umgebung abfahren (area_ride)........................................................................27
7.4 Quadrat abfahren (square_drive) .......................................................................28
Bachelorarbeit
WS12/13
Daniel Klose
Inhaltsverzeichnis
V
7.5 Gegenstand suchen und aufnehmen (look_for_item)........................................29
7.6 An einer Linie anhalten und umdrehen (stop_at_line) ......................................30
7.7 Weitere Anwendungen ......................................................................................30
8 Energiesparoptionen ..............................................................................................31
8.1 Energiesparoptionen des Mikrocontrollers 68HCS12 ......................................31
8.2 Energiesparfunktion der Software .....................................................................31
9 Programmübersicht ...............................................................................................33
10 Aufgaben für das Praktikum ..............................................................................36
11 Zusammenfassung und Ausblick........................................................................37
12 Anhang ..................................................................................................................38
A
Funktionen der Programm-Module.................................................................38
Literaturverzeichnis .................................................................................................51
Bachelorarbeit
WS12/13
Daniel Klose
Abbildungsverzeichnis
VI
Abbildungsverzeichnis
Abbildung 1: Ersatzschaltbild einer permanenterregten Gleichstrommaschine ...........3
Abbildung 2: Wirkungsplandarstellung der Gleichstrommaschine ..............................4
Abbildung 3: Wirkungsplandarstellung des Motors .....................................................5
Abbildung 4: Vereinfachtes Regelstreckenmodell .......................................................7
Abbildung 5: Simulation des quasikontinuierlichen Entwurfs .....................................9
Abbildung 6: Simulation des diskreten Reglers mit den Regelparametern aus 2.3 ....10
Abbildung 7: Simulation des diskreten Reglers mit angepassten Parametern............10
Abbildung 8: Aufbau des RC5-Codes ........................................................................12
Abbildung 9: Beispielsignal eines RC5-Codes mit zugehörigen Bits .......................13
Abbildung 10: Entschlüsselung der Bitflanken des RC5-Codes ................................14
Abbildung 11: Empfangen und Senden eines Bytes vom/an Sensor ..........................15
Abbildung 12: Winkelposition nach dem Start...........................................................17
Abbildung 13: Berechnung der x- und y-Position (mit α = Winkelposition) .............17
Abbildung 14: Gegenüberstellung der approx. Kennlinie mit der Sensorkennlinie ..20
Abbildung 15: Strombegrenzungsschaltung für den Servo-Antrieb...........................21
Abbildung 16: Prozedur für das Aufnehmen und Ablegen eines Gegenstands ..........23
Abbildung 17: Tastenbelegung für die freie Fahrt des Roboters ................................25
Abbildung 18: Fuzzifizierung der Sensorwerte ..........................................................25
Abbildung 19: Ablaufdiagramm der Linienverfolgung ..............................................27
Abbildung 20: Zustandsdiagramm des Programms area_ride ...................................28
Abbildung 21: Zustandsdiagramm der Anwendung look_for_item ...........................29
Bachelorarbeit
WS12/13
Daniel Klose
Abkürzungsverzeichnis
VII
Abkürzungsverzeichnis
A
Amper
AD
Analog-Digital
AH-Glied
Abtast-Halte-Glied
B
Byte
CAN
Controller Area Network
CCD
Charge-Coupled Device
CCR
Condition Code Register
dpi
dots per inch
g
Gramm
H
Henry
Hz
Hertz
IR
Infrarot
IRQ
Interrupt Request
LED
Light Emitting Diode
m
Meter
N
Newton
PWM
Pulsweitenmodulation
r
Radius
s
Sekunde
SDIO
Serial Data Input Output
v
Geschwindigkeit
V
Volt
ω
Winkelgeschwindigkeit
Ω
Ohm
°
Grad
Bachelorarbeit
WS12/13
Daniel Klose
1 Einleitung
1
1
Einleitung
1.1 Einführung
Roboter erhalten in der modernen Gesellschaft einen wachsenden Stellenwert. In der
industriellen Welt nehmen sie zunehmend dem Menschen die Arbeit ab und erhöhen
die Produktivität eines Unternehmens, da sie in vielen Bereichen dem Menschen
überlegen sind. Roboter können meist Tätigkeiten schneller und präziser ausführen
und werden dabei nicht müde. Sie können schwere Teile bewegen und in Umgebungen arbeiten, die für einen Menschen gefährlich sind, und sie sind auf Dauer sogar
kostengünstiger.
In den letzten Jahren ist die Komplexität der Aufgaben für Roboter immer weiter
gewachsen. Erkennbar macht das auch die zunehmende Anzahl an Drohnen, die z.B.
vom Militär oder von der Polizei für Beobachtungen eingesetzt werden. Aufsehen
erregen auch immer die Mars Missionen, bei denen Roboter auf dem Mars landen
und zur Erforschung des erdnahen Planeten eingesetzt werden. Erst in diesem Jahr
hat der Mars-Rover „Curiosity“ spektakuläre Bildaufnahmen vom Mars geschickt
und bringt neue Erkenntnisse über den roten Planeten. Gesteuert werden solche Roboter von einer Software, die oft Aufgaben autonom erledigt, die für einen Menschen
trivial wären, aber für einen Roboter eine große Herausforderung sind. Diese Bachelorarbeit behandelt den Entwurf einer solchen Software, die einen Roboter teils autonom steuern soll, so dass bestimmte Aufgaben erledigt werden können.
1.2 Ziele
Im vorangegangen Praxisprojekt [1] ist die Hardware eines Roboters verbessert und
vor allem für einen anderen Mikrocontroller geändert worden. Als Grundlage hat der
c’t-Bot von der gleichnamigen Zeitschrift zur Verfügung gestanden, der als offenes
Projekt zur Verfügung steht. In dieser Arbeit soll die Software für den im Praxisprojekt umgebauten mobilen Roboter entwickelt werden, welche die Daten der Sensoren
verarbeitet und die Bewegung des Roboters steuert. Das Programm soll für den MikBachelorarbeit
WS12/13
Daniel Klose
1 Einleitung
2
rocontroller 68HCS12 entwickelt werden, der den Roboter steuern soll, und in der
Programmiersprache C geschrieben werden. Die Software soll dem Roboter ermöglichen, dass er Aufgaben, wie auf einer Linie fahren, ein Quadrat abfahren oder einen
Gegenstand aufnehmen, autonom bewältigen kann. Zudem muss sie die Anweisung
einer Fernsteuerung auswerten, so dass sich der Roboter dadurch bedienen lässt und
auch ein freies Fahren mittels der Fernbedienung ermöglicht wird. Da der Roboter
meist von Akkus betrieben wird, sollen auch die Energiespar-Optionen des Mikrocontrollers untersucht werden und in die Software integriert werden. Der Roboter
soll in Zukunft in Praktika für Studenten zur Verfügung stehen, die einige Funktionen selbst erarbeiten sollen, aber vor allem Funktionen dieser Software nutzen sollen,
um auf die Peripherie des Roboters zuzugreifen. Welche Funktionen des Programms
von Studenten selbst im Praktikum erarbeitet werden können, soll ein kleiner Randpunkt dieser Arbeit sein.
Bachelorarbeit
WS12/13
Daniel Klose
2 Motorregelung
2
3
Motorregelung
Der c’t-Bot besitzt zwei separate Gleichstrommotoren für den Antrieb seiner beiden
Räder. Angesteuert werden beide Motoren durch ein PWM-Signal
PWM Signal mit einer
eine Frequenz von 32 kHz, um die Motoren nicht zu sehr zu belasten und ein besseres FahrFah
verhalten zu erlangen [22].
]. Da beide Motoren nicht exakt gleich sind und einer
ei
der
Motoren immer eine andere Drehrichtung hat als der andere, fährt der Roboter bei
demselben PWM-Signal
Signal nicht geradeaus. Damit der Roboter geradeaus fährt, müssen
beide Räder mit gleicher Drehzahl laufen. Eine Drehzahlregelung hält die Drehzahl
eines Motors auf einen vorgegebenen Sollwert. Grundvoraussetzung für eine RegeReg
lung ist eine Messung der
de Ausgangsgröße, also der Drehzahl, die im
m Fall des Roboters durch die Radencoder Sensoren aufgenommen werden können. Durch den VerVe
gleich des Ist-Werts
Werts am Ausgang mit dem Soll-Wert
Soll Wert kann eine Abweichung berechberec
net werden, die ein entsprechendes Handeln
Hand
der Regelung ermöglicht.
ermöglicht Die Regelung
verhindert auch, dass sich die sinkende Akkuspannung auf das PWM-Signal
PWM
und
somit die Drehzahl der Räder auswirkt. Ohne eine Regelung ist die Steuerung des
Roboters schwierig, so dass die Erstellung einer Regelung fast unumgänglich ist.
2.1 Modellbildung des Motors
Um die Regelstrecke für die Motorregelung beschreiben zu können, wird das in AbA
bildung 1 gezeigte vereinfachte Ersatzschaltbild einer permanenterregten Gleichstrommaschine herangezogen.
Abbildung 1: Ersatzschaltbild einer permanenterregten Gleichstrommaschine
Gleichstrommas
(vgl. [3][4])
Bachelorarbeit
WS12/13
Daniel Klose
2 Motorregelung
4
Aus dem Ersatzschaltbild (Abb. 1) ergibt sich die Spannungsgleichung (1), die zu der
Übertragungsfunktion (2) führt. Wie aus (2) ersichtlich, handelt es sich bei der Übertragungsfunktion um ein Verzögerungsglied erster Ordnung (PT1-Glied).
∙
∙
∙
∙ ∙
(1)
L
⟺ 1
∙
1
1
∙
,
(2)
Abbildung 2: Wirkungsplandarstellung der Gleichstrommaschine
Uq(t) - Ankerspannung
Rq
- Anschlusswiderstand
Ui(t)
- induzierte Gegenspannung
Lq
- Anschlussinduktivität
Iq(t)
- Ankerstrom
Ta
- Zeitkonstante
Bei einer permanenterregten Gleichstrommaschine ist der Erregerfluss konstant und
wird durch den Faktor der Motorkonstante km beschrieben. Die Proportionalität der
Konstanten mit dem Strom iq(t) ergibt das Drehmoment MM(t) des Motors (3). Desweiteren ergibt sich aus der Drehmomentbilanz die Bewegungsdifferenzialgleichung
(4) für starr gekoppelte Schwungmassen mit der Winkelgeschwindigkeit ω(t). Da die
Drehung des Rotors im konstanten Erregerfeld die gegeninduktive Spannung ui(t)
erzeugt, kann diese Spannung durch den proportionalen Zusammenhang mit der
Drehzahl n durch (5) beschrieben werden. [3][4]
Bachelorarbeit
WS12/13
Daniel Klose
2 Motorregelung
5
∙
(3)
L
∙
(3)
MM(t) - Drehmoment des Motors
km
- Motorkonstante
!∙
"
#
(4)
#
(4)
L
! ∙ ∙ Ω s
1
∙
!∙
⟺ Ω
J
- Trägheitsmoment des Motors
ω(t)
- Winkelgeschwindigkeit
#
ML(t) - Lastmoment
∙ 2' ∙ (
∙)
(5)
L
∙Ω
(5)
Aus den Formeln ergibt sich der in Abbildung 3 zusammenhängende Wirkungsplan
für den Motor, bei dem das Lastmoment zur Vereinfachung zu Null idealisiert ist.
Abbildung 3: Wirkungsplandarstellung des Motors
Bachelorarbeit
WS12/13
Daniel Klose
2 Motorregelung
6
2.2 Regelstreckenbildung
Aus dem in Kapitel 2.1 aufgestellten Signalfluss kann die Übertragungsfunktion (6)
für den Motor erstellt werden und ergibt den ersten Teil der Regelstrecke.
⟹ Ω s
1
∙
!
⟺ Ω
1
! ∙
1
1 ! ∙
∙
1
∙
1
1
+
∙
∙1
1
Ω
⟺ ,
1
+-
!
∙
1
∙1
1
∙Ω
1
.
∙
!
-
(6)
.
Um die Regelstrecke zu komplettieren, müssen noch das Stellglied und die Messeinrichtung betrachtet werden. Die Ankerspannung wird aus einem PWM-Signal des
Mikrocontrollers gebildet, wodurch die Spannung verändert werden kann. Denn die
Nutzspannung, mit der der Motor arbeitet, ergibt sich aus dem Tastverhältnis des
PWM-Signals (siehe (7)).
/
∙
0120
3
/
∙ 4 5678ä: ( ,
; <;
=>?
(7)
Das Einstellen des PWM-Signals im Programm erfolgt durch die Angabe der Pulsbreite thigh mit einem digitalen Wert von 0 bis 255. Dieser Wert ist die Stellgröße des
späteren digitalen Reglers und legt die maximale Periode T des Tastverhältnisses auf
255 fest. Die Eingangsspannung Ue ist die maximale Spannung, die eingestellt werden kann, und ist durch die Betriebsspannung (Akkuspannung) definiert. Die Akkuspannung liegt etwa bei 6 V, was auch der Nennspannung des Motors entspricht. Die
Ankerspannung Uq ergibt sich daher aus der Stellgröße y mit der Gleichung (8).
B
6A ∙ +CC ∙ D
(8)
Durch die optischen Radencoder Sensoren kann die Geschwindigkeit des Rads ermittelt werden. Die Geschwindigkeit ist auch die Sollgröße, auf die geregelt werden soll.
Bachelorarbeit
WS12/13
Daniel Klose
2 Motorregelung
7
Um aus der Winkelgeschwindigkeit ω des Motors die Geschwindigkeit v des Rads
zu berechnen, reicht eine Multiplikation mit dem Radius r des Rads. Für die Geschwindigkeit in mm/s erfolgt die Umrechnung mittels Gleichung (9).
E
5
FGH/I
∙)
, 7 (
(9)
Damit ist das vereinfachte Regelstreckenmodell vollständig und wird in Abbildung 4
dargestellt sowie durch (10) beschrieben. Mit der Regelstrecke ist eine Berechnung
des digitalen Reglers möglich und wird in Kapitel 2.3 betrachtet.
E
,H
FG
F
∙,
∙ +CC
JH ∙ ,
,
E∙F
JH
FG∙+CC
(10)
Abbildung 4: Vereinfachtes Regelstreckenmodell
2.3 Quasikontinuierlicher Reglerentwurf
Um einen digitalen Regler zu berechnen, wird in der Praxis häufig die Regelung als
eine „quasi zeitkontinuierliche“ Regelung betrachtet, damit die Berechnung nicht
unnötig komplex wird. Denn ein quasikontinuierlicher Entwurf, in der das AbtastHalte-Glied (AH-Glied) approximiert wird, reicht oft schon aus, um ein geeignetes
Regelverhalten zu erzielen. Das AH-Glied wird wegen seines Frequenzgangs als
Totzeitglied approximiert und kann mit der Potenzreihenentwicklung der e-Funktion
vereinfacht durch ein PT1-Glied beschrieben werden (siehe (11)). [5]
,KL
Bachelorarbeit
1
3
M 6 NH+
1
B
+ B
+
2
WS12/13
⋯
M
1
1
B
,
B
2
(11)
Daniel Klose
2 Motorregelung
8
Das Verhalten des AH-Glieds wird in den Regelkreis eingefügt und damit berücksichtigt. Der offene Regelkreis kann nun mit (12) beschrieben werden.
,>
,H
∙ ,KL
∙ ,P
(12)
Für die Regelung wird ein PI-Regler verwendet, durch dessen Übertragungsfunktion
(13) sich der offene Regelkreis zu (14) ergibt und der geschlossene Regelkreis (15)
aufgestellt werden kann.
,P
,>
,?
S
!
B R
T
R
!
JQ ∙
JQ JH 1
R
+
B
Z[
Z[
UHa 3V
HW 3X 3V 3Y
\] \^ _`
\] \^ _`
a4
1
BUH3V
3Y U3X UHb R
(13)
R
!
R-
B
.
(14)
R
cV Z[
_
d
U3X e` fUH3V - ` UB.UB
\] \^ _`
\] \^
a3
a1
a2
(15)
a0
Zur Berechnung der Regelparameter wird das Betragsoptimum herangezogen, welches das Ziel anstrebt, den Betrag der Führungsübertragungsfunktion Gw(s) für möglichst viele Frequenzen an den Betrag „1“ anzunähern. Der Zähler der Übertragungsfunktion wird durch einen vorgeschalteten Führungsfilter (16) kompensiert. Durch
Bildung des Nenner-Betrags ergeben sich die Forderungen aus (17) und (18), um den
Nenner bei möglichst vielen Frequenzen um ω = 0 mit den zwei freien Parametern
des PI-Reglers an den Betrag „1“ anzuschmiegen. [4]
,g
|i j) |+
Betrag des Nenners:
4G +
)+ 4B +
24G 4+
)S 4+ +
i j) ∙ i
24G 4S
(16)
R
24B 4T
j)
)F 4T +
24+ 4S
)k 4S +
=0
=0
4+ +
Bachelorarbeit
1
1
4B +
24G 4S
24G 4+
24B 4T
WS12/13
0
0
(17)
(18)
Daniel Klose
2 Motorregelung
9
Mit (17) und (18) lassen sich die beiden Reglerparameter für Verstärkung Kp und
Nachstellzeit Tn berechnen und erhält mit den folgenden Werten des Faulhaber Motors 2619 006 SR
Rq = 8,2 Ω
Lq = 465 µH
J = 0,68 gcm2
km = 8,59 mNm/A
und einer Abtastzeit von T = 0,25 s die Werte:
Kp1 ≈ 6,4
(Kp2 ≈ 1789,5)
Tn1 ≈ 0,013
(Tn2 ≈ 0,00005)
Die Simulation zeigt ein gutes und schnelles Regelverhalten mit den beiden Parametern (siehe Abb. 5).
Abbildung 5: Simulation des quasikontinuierlichen Entwurfs
2.4 Diskretisierung der Regelung
Im Programm muss der Regler und auch der Führungsfilter diskret implementiert
werden. Mit der Trapezregel ergibt sich für den PI-Regler die Summenformel (19)[5]
und für den Führungsfilter die Form (20).
De
JQ ∙ 6e
Dm,e
De
Bachelorarbeit
, Dm,e
3
3U+3V
∙ 6e
Dm,eNB
6eNB
WS12/13
3
JQ ∙ +3 ∙ 6e
3N+3V
3U+3V
V
∙ DeNB
6eNB
(19)
(20)
Daniel Klose
2 Motorregelung
10
Die Simulation der diskreten Regelung mit den aus Kapitel 2.3 berechneten Werten
für den Regler ergibt das in Abbildung 6 gezeigte Verhalten. Der Regler übersteuert
aufgrund der relativ hohen Abtastzeit von 0,25 Sekunden.
Abbildung 6: Simulation des diskreten Reglers mit den Regelparametern aus 2.3
Die Berechnung der Regelparameter mit dem digitalen Betragsoptimum würde sehr
komplex werden und den Rahmen sprengen. Die empirische Ermittlung aus dem
vorhandenen System verspricht eine schnellere und einfachere Lösung. Durch Herabsetzen der Verstärkung Kp und etwas Erhöhen der Nachstellzeit Tn lässt sich ein
gutes Regelverhalten in der diskreten Simulation erzielen. Abbildung 7 zeigt das
Regelverhalten des Modells mit den folgenden Werten:
Kp = 0,2
Tn = 0,1
Abbildung 7: Simulation des diskreten Reglers mit angepassten Parametern
Bachelorarbeit
WS12/13
Daniel Klose
2 Motorregelung
11
2.5 Regelung im Programm
In den vorangegangenen Kapiteln ist der Roboter mit seinem Antriebssystem durch
ein Modell beschrieben worden, welches natürlich nicht ganz der Realität entspricht.
In ersten Tests der Regelung sind die Parameter daher dem realen System angepasst
worden, wobei vor allem die Nachstellzeit Tn etwas erhöht worden ist. Dadurch ist
die Regelung zwar träger, aber verbessert die Fahreigenschaften des Roboters und
eine extra Anfahrtsprozedur ist ebenfalls nicht nötig. Der Regler arbeitet auf dem
68HCS12 nun mit den Parametern
Kp = 0,3 und Tn = 0,8.
Um das Verhalten der Regelung weiter zu verbessern, wird die Ist-Größe durch den
Mittelwert von mehreren Messungen gebildet. Jeder Interrupt, der durch die RadEncoder Sensoren ausgelöst wird, entspricht einer zurückgelegten Strecke des Rades
von 3 mm. Diese Eigenschaft macht die Messung schon nicht besonders exakt. Hinzu kommt, dass durch äußere Einflüsse wie Streulicht oder ähnliches, eine Kante der
Encoder-Scheibe gelegentlich nicht erkannt wird und dadurch die Messung verfälscht wird. Die Geschwindigkeit, die alle 100 ms aus der gefahrenen Strecke des
Rades aufgenommen wird, wird für die Regelung aus den letzten drei Messwerten
ermittelt, wodurch das Verhalten der Regelung während der Fahrt ruhiger wird.
Die Regelung wird im Programm von der Funktion speed_control gesteuert. Als
Eingangswerte bekommt die Funktion die Soll-Geschwindigkeitswerte (in mm/s) für
den rechten und linken Motor. Die Funktion muss in einer Schleife immer wieder
aufgerufen werden, jedoch wird die Funktion erst durch Erreichen der Abtastzeit
durchlaufen. Bedingung für die Funktion der Regelung ist die Aktivierung der RadEncoder Sensoren über die enable Funktion, da ohne die Sensoren die Geschwindigkeit nicht berechnet werden kann. Die Richtung des Rads wird durch die Vorzeichen
der Geschwindigkeitssollwerte bestimmt, wobei eine negative Sollgeschwindigkeit
eine Rückwärtsdrehung des Rads bewirkt. Durch die Motorregelung ist die Steuerung des Roboters vereinfacht und verbessert worden, wodurch die Grundlage für
das weitere Programm geschaffen worden ist.
Bachelorarbeit
WS12/13
Daniel Klose
3 Fernbedienung
3
12
Fernbedienung
3.1 RC5-Code
Zur Übertragung benutzen die meisten Fernbedienungen den RC5-Code
RC5
als Verschlüsselung. Der RC5--Code
Code besteht aus 14 Bits und ist wie in Abbildung 8 aufgeaufg
baut.
Abbildung 8: Aufbau des RC5-Codes
RC5
[6]
Neben 5 Adressbits und 6 Kommandobits besteht der RC5-Code
RC5 Code noch
noc aus 2 Startbits
und einem Togglebit. Wenn das zweite Startbit nicht als siebtes Kommandobit agiert,
um die Befehlszahl zu erhöhen, sind die ersten beiden Bits des RC5-Codes
RC5
immer
„1“. Das Togglebitt ändert bei jedem Tastendruck seinen Zustand, wodurch ein neuer
Tastendruck erkannt wird. Wird eine Taste auf der Fernbedienung gedrückt gehalten,
behält das Togglebit den Zustand. Durch die Adressbits erkennt das Gerät, ob der
Befehl verarbeitet werden muss oder der Befehl für ein anderes Gerät bestimmt ist.
In den Kommandobits ist die Information enthalten, welche Taste gedrückt wurde.
Der RC5-Code ist, ähnlich wie der bekannte Manchester-Code,
Manchester
taktflankengesteuert;
d.h., dass die Richtung einer Flanke im Signal darüber entscheidet, ob der Zustand
des Bits „1“ oder „0“ ist. Bei dem RC5-Code
Code steht eine fallende Flanke für eine logilog
sche „1“ und eine steigende Flanke für eine logische „0“. Abbildung 9 zeigt ein BeiBe
spielsignal mit der entsprechenden Auswertung der Bits.
Bachelorarbeit
WS12/13
Daniel Klose
3 Fernbedienung
13
Abbildung 9: Beispielsignal eines RC5-Codes mit zugehörigen Bits [7]
3.2 Entschlüsselung des RC5-Codes im Programm
Das RC5-codierte Signal wird von einem Pin des Ports T aufgenommen und durch
den Timer-Baustein des Mikrocontrollers ausgewertet. Jede Flanke löst einen Interrupt aus, so dass zu jeder Zeit ein Kommando der Fernbedienung entgegen genommen werden kann. Da durch die Selbsttaktung nicht jede Flanke des Signals zu einem Bit gehört, ist der Zeitabstand zwischen den Flanken von großer Bedeutung, um
das Signal auswerten zu können. Wie in [1] beschrieben und in Abbildung 8 ersichtlich, dauert die Übertragung eines Bits 1,778 ms. Die Flanken, die zwischen den Bits
nach der Hälfte der Zeit aufkommen können, müssen ignoriert werden. Durch eine
Zeitbasis, die mit dem Modulus Down Counter des Timer-Bausteins vom Mikrocontroller erzeugt wird, werden nur Flanken bearbeitet, die nach 1,5 ms erkannt werden.
Daher ist die Zeitbasis des Modulus Down Counter auf 500 µs festgelegt worden,
wodurch sich die Zeitbasis von 1 ms für beispielsweise die Geschwindigkeitsberechnung der Räder berechnen lässt. Die erste Flanke des Signals ist immer bereits die
fallende Flanke des Startbits, weil das Signal durch einen Pull-Up Widerstand im
Empfänger Sensor auf High-Status liegt (vgl. Datenblatt TSOP34836). Diese Flanke
dient als Referenz dafür, welche Flanken durch die Zeit ignoriert werden und welche
ausgewertet werden. Nach dieser Vorauswahl werden die Bits gemäß Abbildung 10
entschlüsselt. Wird eine Taste dauerhaft gedrückt, wiederholt sich das Signal nach
etwa 113 ms. Daher wird in der Auswertung alles zurückgesetzt, wenn die letzte
Flanke vor mehr als 30 ms ausgelöst wurde. Ein Zähler sorgt dafür, dass die Bits an
die richtige Stelle des Datenworts gesetzt werden und das Ende der Übertragung erkannt wird. Ob es sich bei dem ausgelösten Interrupt um eine fallende oder steigende
Flanke handelt, wird durch die Abfrage des Pegels am Portpin nach dem Interrupt
festgestellt. Erst wenn ein Befehl komplett übertragen wird, übernimmt das ProBachelorarbeit
WS12/13
Daniel Klose
3 Fernbedienung
14
gramm ihn in eine entsprechende Variable,
Variable, die im weiteren Programm verwendet
und ausgewertet werden kann. [6][7]
Abbildung 10: Entschlüsselung der Bitflanken des RC5-Codes
RC5 Codes
Bachelorarbeit
WS12/13
Daniel Klose
4 Positionsberechnung
4
15
Positionsberechnung
4.1 Daten des Positionssensors
Der aus einer Lasermaus stammende Positionssensor liefert Daten zur Bewegung.
Durch einen CCD-Kamerachip wird die Bewegung des Untergrunds erkannt und als
Daten in Register abgelegt. Die Daten für die x- und y-Bewegung können über eine
SDIO-Schnittstelle vom Sensor ausgelesen werden (siehe [1]). Abbildung 11 zeigt
wie das Senden und Empfangen der Datenbytes realisiert ist.
Abbildung 11: Empfangen (links) und Senden (rechts) eines Bytes vom/an Sensor
Bachelorarbeit
WS12/13
Daniel Klose
4 Positionsberechnung
16
Bei einer fallenden Flanke wird das Datenbit geändert und bei folgender steigender
Flanke wird das Bit übernommen. Für das Empfangen eines Bytes heißt das, dass der
Port bei einem High-Zustand des Takts ausgelesen werden muss und für das nächste
Bit der Takt einmal gewechselt werden muss. Wenn ein Byte gesendet werden soll,
muss das nächste Bit im Low-Status des Takts auf die Datenleitung gelegt werden,
damit es beim Taktwechsel vom Sensor übernommen wird. Dadurch können Register
des Sensors ausgelesen werden oder Daten in Register geschrieben werden.
Die x- und y-Bewegungen speichert der Sensor in zwei dafür vorgesehene Register.
Um die Register auslesen zu können, muss vorher das Motion-Bit des Motion_Status
Registers ausgelesen werden. Das Motion-Bit gibt ebenfalls Aufschluss darüber, ob
überhaupt eine Bewegung stattgefunden hat. Wenn das Motion-Bit „1“ ist, hat eine
Bewegung stattgefunden und beide Register (X- und Y-Register) müssen ausgelesen
werden. Das Auslesen der Register löscht gleichzeitig auch den Inhalt, so dass ein
doppeltes Abfragen der gleichen Bewegung ausgeschlossen ist. Die Werte der Register liegen zwischen -128 und +127 und sind noch keine Distanzmaße. Die Distanzumrechnung hängt von der Auflösung des Sensors ab, die sich durch die höhere
Montage des Sensors im Vergleich zur Maus verändert hat. Durch Messungen ist der
Umrechnungsfaktor der Werte bei etwa 0,0287 mm festgelegt worden. Damit ist dies
die kleinstmögliche Bewegung, die der Sensor aufnimmt und die Auflösung des Sensors beträgt dadurch etwa 900 dpi. [1]
4.2 Berechnung der Positionsdaten
Durch die x- und y-Daten des Positionssensors kann die aktuelle Position sowie der
Drehwinkel des Roboters ermittelt werden. Nach einer Umrechnung der Daten des
Sensors ergeben sich für eine Vorwärtsbewegung positive y-Distanzwerte und für
eine Rechtsbewegung positive x-Distanzwerte. Da der Positionssensor nicht zentral
unter dem Roboter sitzt, erfasst der x-Wert jede Rotationsbewegung. Mit dem Abstand des Sensors zum Mittelpunkt des Roboters ergibt sich der Radius des Kreises,
den der Sensor bei einer Drehung des Roboters abfährt. Mit dem sich aus dem Radius ergebenden Umfang und der zurückgelegten Strecke (x-Wert) lässt sich näherungsweise der Drehwinkel berechnen, den der Roboter zurücklegt. Der Winkel des
Bachelorarbeit
WS12/13
Daniel Klose
4 Positionsberechnung
17
Roboters steht in der
er Variablen bot_angle,, wodurch der Roboter seine aktuelle BlickBlic
richtung kennt (siehe Abb. 12).
1
Abbildung 12: Winkelposition nach dem Start
Mit dem Drehwinkel lässt sich die x- und y-Position bestimmen, denn die Positionen
beziehen sich wie in einem Koordinatensystem auf den Ursprungspunkt – dem Startpunkt. Mit dem y-Wert
Wert des Positionssensors und der Trigonometrie lassen sich so die
Veränderungen auf
uf der xx und y-Achse berechnen. [8]
y
D
q
s
∙ cos p
(21)
∙ sin p
(22)
α
x
Abbildung 13: Berechnung der x- und y-Position (mit α = Winkelposition)
Bachelorarbeit
WS12/13
Daniel Klose
4 Positionsberechnung
18
Das Nutzen des Positionssensors für die zurückgelegte Strecke, die Berechnung der
Position und des Drehwinkels hat viele Vorteile und kann für verschiedene Aufgaben
genutzt werden. Jedoch ist die Positionsberechnung mit Toleranzen verbunden, die
sich besonders bei immer größer werdenden Strecken, die der Roboter zurücklegt,
bemerkbar machen. Die Fehler summieren sich immer weiter auf, so dass die Position ungenau wird und irgendwann nicht mehr zu gebrauchen ist. Wie bei Computermäusen üblich, können auch unterschiedliche Untergründe die Messung verfälschen
oder sogar unmöglich machen. Dennoch ist der Positionssensor eine große Bereicherung und macht z.B. Distanzfahrten zuverlässiger und genauer als es die Odometrie
könnte. Die Variablen für die x- und y-Position sowie dem Drehwinkel stehen der
kompletten Software zur Verfügung und werden lediglich durch die Funktion update_position aktualisiert, die immer wieder aufgerufen werden muss, wenn sich der
Roboter bewegt.
Bachelorarbeit
WS12/13
Daniel Klose
5 Distanzberechnung der Distanzsensoren
5
19
Distanzberechnung der Distanzsensoren
Die Distanzsensoren Sharp GP2Y0A21YK, die die Front des Roboters nach Hindernissen abtasten, liefern eine analoge Spannung, die ein Analog/Digital-Umsetzer des
Mikrocontroller 68HCS12 aufnimmt und verarbeitet. Die Ausgangsspannung der
Sensoren verhält sich nicht proportional zur Entfernung (siehe [1]), wodurch eine
spezielle Umrechnung erforderlich ist, die die Ausgangskurve approximiert. Mit der
Näherungsformel (23) können Teile der Ausgangsspannung/Distanzkennlinie nachgebildet werden, denn eine komplette Approximation der Kennlinie ist nicht möglich. Aufgrund der Ungleichheit der Sensoren wird die Näherung für beide Sensor
einzeln berechnet. [9]
t
q
4
(23)
u
d – Distanz
a – Steigungskonstante
b – Offsetkonstante
x – AD-Wert des Sensors
Durch Messungspunkte werden die Konstanten berechnet, wodurch sich zwei Funktionen für die Distanzbereiche von 7 cm-15 cm und 15 cm-30 cm ergeben. Der dritte
Abschnitt ab 30 cm wird durch eine lineare Funktion approximiert, da die Kurve ab
dieser Entfernung enorm abflacht und die Messungen der Sensoren ab dieser Distanz
recht ungenau werden. In Abbildung 14 ist die approximierte Kurve für den rechten
Distanzsensor mit der Ausgangskennlinie des Datenblatts gegenübergestellt. Eine
Approximation für größere Distanzen ist nicht behandelt worden, da die Sensoren in
diesen Bereichen unzuverlässig arbeiten. Besonders der linke Sensor hat bei größeren
Distanzen Probleme, da er um 180° gedreht ist und dadurch nahe über den Boden
schaut. Das hat zur Folge, dass ab einer Distanz von etwa 40 cm beim linken Sensor
keine Messung mehr möglich ist. Bei unglücklichen Verhältnissen kann es auch
vorkommen, dass der linke Sensor durch Streulicht vom Boden beeinflusst wird und
die Messwerte verfälscht. Der rechte Sensor hat diese Probleme weniger, dennoch
sind Messungen auf größeren Distanzen nicht besonders zuverlässig. Da die primäre
Aufgabe der Sensoren das Verhindern eines Zusammenpralls mit einem Hindernis
Bachelorarbeit
WS12/13
Daniel Klose
5 Distanzberechnung der Distanzsensoren
20
ist, sind größere Entfernung auch weniger interessant. Das Erkennen eines kleineren
Objektes, das für das Suchen eines Gegenstandes verwendet wird, ist dadurch mit
diesen Sensoren nur begrenzt möglich. Im Programm wird vorwiegend mit einem
Distanzbereich von kleiner als 20 cm gearbeitet, da die Sensoren in diesem Bereich
zuverlässig arbeiten. Damit der Roboter gegen kein Hindernis fährt, reicht es aus,
wenn Distanzen kleiner als 15 cm berücksichtigt werden.
Abbildung 14: Gegenüberstellung der approximierten Kennlinie mit der Sensorkennlinie [10]
Bachelorarbeit
WS12/13
Daniel Klose
6 Transportfunktion
6
21
Transportfunktion
6.1 Hardwaremodifikation für den Antrieb der Klappe
Für die Nutzung der Transportklappe ist eine Schaltungsänderung vorgenommen
geworden. Im Akkubetrieb verursacht der Servo-Antrieb bei seiner Nutzung ein Abstürzen des Mikrocontrollers. Verursacht wird das Problem durch eine sehr hohe
Stromspitze beim Anlauf des Antriebs, welche durch den Innenwiderstand der Akkus
die Spannung für einen kurzen Moment so weit einbrechen lässt, dass die Spannungsversorgung für den Mikrocontroller zusammenbricht. Durch den Betrieb über
ein strombegrenzendes Netzteil ist die Höhe der Stromspitze auf etwa 800 mA eingegrenzt worden. Das Fehlersignal, welches bei größeren Strömen des ServoAntriebs ausgelöst wird, kann in der kurzen Zeit nicht ausgelesen werden und würde
nicht hilfreich sein, da der Fehler bei jedem Anlauf des Antriebs ausgelöst wird. Aus
diesem Grund ist eine Strombegrenzungsschaltung (siehe Abb. 15) eingefügt worden, die durch zwei NPN-Transistoren den Strom auf maximal 270 mA begrenzt.
Versorgungsspannung des
Servo-Antriebs
5V Spannungsversorgung
Abbildung 15: Strombegrenzungsschaltung für den Servo-Antrieb
Die Begrenzung des Stroms verhindert das Abstürzen des Mikrocontrollers und lässt
den Servo-Antrieb auch langsamer in Position fahren, jedoch hat er dadurch auch
weniger Stellkraft. Der Eingriff in die Schaltung wurde mittels einer kleinen Lochrasterplatine realisiert, jedoch kann die Schaltung ohne Probleme in das Layout der
Hauptplatine integriert werden. Es gibt keine Informationen darüber, ob das Problem
mit dem Servostrom auch bei anderen Nutzern des c’t-Bots vorgekommen ist, jedoch
Bachelorarbeit
WS12/13
Daniel Klose
6 Transportfunktion
22
kann ausgeschlossen werden, dass das Problem an der neuen Beschaltung aus dem
Praxisprojekt [1] liegt.
6.2 Steuerung der Transportfunktion
Für die Steuerung der Klappe wird der Servo-Antrieb mit einem PWM-Signal von
50 Hz vom Mikrocontroller betrieben. Die Pulsdauer der 20 ms langen Periode entscheidet über die Winkelposition des Servo-Antriebs und beträgt für den ersten Anschlag 1 ms und für den zweiten Anschlag, der um 180° zum ersten Anschlag gedreht ist, 2 ms. Für die Klappe wird nicht der komplette Drehwinkel des ServoAntriebs benötigt, wodurch sich für die Positionen für „Klappe Offen“ und „Klappe
Geschlossen“ jeweils eine Pulsdauer zwischen 1 ms und 2 ms ergibt. [1]
Ob die Transportbox leer ist oder sich etwas in der Box befindet oder ob die Transportklappe geöffnet oder geschlossen ist, kann über Sensoren abgefragt werden. Für
diese Anwendungen enthält das Modul transport entsprechende Funktionen, die den
Status der Klappe oder Box zurückgeben. Durch die Strombegrenzung aus Kapitel
6.1 ist die vorgesehene Fehlermeldung für die zu große Stromaufnahme des ServoAntriebs nicht mehr aussagekräftig, da der Servo-Antrieb über eine Zeit den maximalen Strom der Schaltung nutzt. Eine maximale Zeit, die das Fehlersignal anliegen
darf, kann als Sicherheitsfunktion genutzt werden, falls der Servo-Antrieb beispielsweise blockiert ist und abgeschaltet wird. Im Programm ist jedoch eine generelle
Zeitschaltung vorhanden, die nach 3 Sekunden betrieb den Servo-Antrieb ausschaltet, so dass das Fehlersignal nicht nötig ist.
Des Weiteren sind im Programm zwei Funktionen vorhanden, die für das Aufnehmen und Ablegen eines Gegenstandes zuständig sind. Beide Prozeduren funktionieren anwendungsorientiert, so dass ein Gegenstand auch nur dann abgelegt wird,
wenn sich eines in der Transportbox befindet oder wenn sich nach einer bestimmten
Distanz kein Gegenstand in der Transportbox befindet, der Vorgang abgebrochen
wird. Ein Ablaufplan für das Aufnehmen und Ablegen eines Gegenstandes ist in Abbildung 16 dargestellt.
Bachelorarbeit
WS12/13
Daniel Klose
6 Transportfunktion
23
Abbildung 16: Prozedur für das Aufnehmen (links) und Ablegen (rechts)
eines Gegenstands
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
7
24
Programmierte Anwendungen
Nach dem Start des Roboters kann mit der Fernbedienung zwischen 6 Programmen
gewählt werden, die unterschiedliche Aufgaben erledigen. Durch einen Tastendruck
auf den Zahlentasten 1-6 kann das gewünschte Programm gewählt werden. Nachfolgend sind die programmierten Anwendungen mit der zugehörigen Tastennummer
aufgelistet:
1. Freie Fahrt (ferngesteuertes Fahren)
2. Linienverfolgung
3. Umgebung abfahren
4. Quadrat abfahren
5. Gegenstand suchen und aufnehmen
6. An einer Linie anhalten und umdrehen
Zudem kann über die Power Taste der Fernbedienung der Roboter in einen Power
Down Modus versetzt werden. Erhält der Roboter nach dem Start oder nach Beendigung eines der oben genannten Programme länger als 5 Minuten keinen neuen Befehl für eine Anwendung, wird ebenfalls der Power Down Modus aktiviert, um
Strom zu sparen.
7.1 Freie fahrt (free_drive)
Im Modus der freien Fahrt kann der Roboter ferngesteuert werden und handelt nach
den Anweisungen der Fernbedienung. Das Handling ist jedoch etwas anders als bei
einem gewöhnlichen ferngesteuerten Auto. Wird eine Taste einmal gedrückt, führt
der Roboter diese Bewegung aus bis eine andere Taste gedrückt wird. Wenn also der
Roboter vorwärts fährt und die Taste zur Linksfahrt gedrückt wird, fährt der Roboter
so lange eine Linkskurve bis die Taste für die Vorwärtsfahrt gedrückt wird. Ein dauerhafter Tastendruck hat dadurch keine Auswirkungen auf das Verhalten des Roboters. In Abbildung 17 ist die Tastenbelegung auf der Fernbedienung dargestellt, die
zum Steuern des Roboters im Programm der freien Fahrt benötigt wird.
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
25
Transportklappe schließen
Vorwärts
Transportklappe öffnen
Rechts
Links
Rückwärts
Programm verlassen
Stopp/Anhalten
Geschwindigkeit
erhöhen (+)
verringern (-)
Drehung auf der Stelle
(+) linksherum
(-) rechtsherum
Abbildung 17: Tastenbelegung für die freie Fahrt des Roboters [11]
7.2 Linienverfolgung (follow_line)
Im Modus der Linienverfolgung soll der Roboter auf einer schwarzen Linie fahren
und diese nicht verlassen. Dafür stehen ihm zwei Sensoren unterhalb des Roboters
zur Verfügung, die durch Reflexionseigenschaften des Untergrunds eine analoge
Spannung erzeugen, welche der AD-Umsetzer des Mikrocontrollers in Werte für das
Programm umwandelt. Für eine gute Fahrt auf der Linie ist im ersten Versuch eine
Fuzzy-Regelung entworfen worden, die die Werte der Sensoren verarbeitet und
durch das Prinzip der Fuzzy-Logik einen Stellwert für die Motoren erzeugt.
µ
1
wenig
mittel
viel
Sensorwert
Abbildung 18: Fuzzifizierung der Sensorwerte (vgl. [12])
Die Bildung eines Fuzzy-Reglers durchläuft 3 wesentliche Schritte. Bei der Fuzzifizierung mittels Fuzzy-Mengen (siehe Abb. 18) wird die Regeldifferenz bzw. hier
der Sensorwert einer Funktion zugeordnet, die aus „wenig“, „mittel“ und „viel“ an
Abweichung besteht. Der daraus resultierende Erfüllungsgrad µ wird in der Inferenz
weiterverarbeitet und ergibt durch festgelegte Regeln einen Erfüllungsgrad für die
Stellgrößen-Fuzzy-Mengen. Daraus wird in der Defuzzifizierung die Stellgröße für
die beiden Motoren berechnet. Der Vorgang einer Fuzzy-Regelung ist sehr rechenin-
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
26
tensiv, scheint aber für diese Anwendung die optimale Lösung zu sein. Dennoch ist
das Ergebnis der Regelung nicht nutzbar. Da es schwierig ist eine Fuzzy-Regelung
anzupassen und zu verfeinern, ist die Methode der Fuzzy-Regelung nach einigen
Versuchen verworfen worden. [12]
Im zweiten Versuch ist die Regelung mit einem konventionellen Regler entworfen
worden. Das Problem bei dem Entwurf des konventionellen Reglers ist die Erzeugung einer Regeldifferenz aus den Sensorwerten. Durch Differenzbildung der beiden
Sensorwerte, wodurch der Sollwert mitten auf der Linie „0“ wäre, ist ein Regler entworfen worden, der den Roboter zunächst auf einer gerade Linie hält. Jedoch bekommt der Regler bereits bei einer geraden Linie Probleme sobald der Roboter die
Linie zu weit verlässt, da der Untergrund komplett weiß ist und keine entsprechende
Regeldifferenz gebildet werden kann. Die Regelung mit einem konventionellen Regler auf einer etwas gebogenen Linie ist vollkommen gescheitert, so dass die Idee einer Regelung verworfen wurde, da die Sensoren dazu nicht geeignet sind.
Die Verwendung eines Farbverlaufs kann es ermöglichen, das der Roboter mit einer
Regelung eine vorgegebene Streck folgt. Denn das Problem der Regelung auf einer
schwarzen Linie besteht darin, dass die Sensoren keine gute Regeldifferenz liefern
können. Dieses Problem könnte durch eine breitere Linie gelöst werden, die aus einem Farbverlauf (schwarz zu weiß) besteht. Die Sensoren liefern dadurch besser zu
regelnde Werte und die breitere Linie gibt mehr Spielraum für die Regelung. Im Programm ist bereits eine Regelung für einen Farbverlauf integriert worden, jedoch
konnte die Regelung durch eine fehlende Strecke bisher nicht getestet und eingestellt
werden.
Damit der Roboter doch noch einer schwarzen Linie folgt, ist ein einfacher Algorithmus entworfen worden, der jederzeit prüft, ob sich einer der Sensoren nicht mehr
auf der Linie befindet. Wenn ein Sensor die Linie verlässt, hält der Roboter sofort an
und korrigiert mit einer entsprechenden Drehung bis der Sensor wieder auf der Linie
ist. Die aus Kapitel 2 entworfene Motorregelung kann hier aufgrund der Abtastzeit
nicht verwendet werden, weil der Roboter zu spät reagieren würde. Da der Roboter
auf der Linie fahren soll und nicht unbedingt möglichst genau geradeaus, werden die
Motoren direkt über das PWM-Signal angesteuert. Durch die Stopp-Taste hält der
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
27
Roboter an und das Programm wird beendet. Das folgende Diagramm (Abbildung
19) zeigt den Ablauf des Programms für die Linienverfolgung.
Abbildung 19: Ablaufdiagramm der Linienverfolgung
7.3 Umgebung abfahren (area_ride)
In diesem Programm fährt der Roboter in einem durch schwarze Linien abgegrenzten
Feld ohne es zu verlassen. Dabei sucht der Roboter in einem zufälligen System mit
der Zeit das ganze Feld ab. Findet der Roboter mit den Distanzsensoren ein Hindernis, prüft er dieses auf einen Gegenstand, den er mitnehmen könnte. Wenn es kein
Gegenstand ist, z.B. eine Wand, weicht der Roboter dem Hindernis aus. Das Programm kann auch als Alternative zum Suchprogramm aus Kapitel 7.5 gesehen werden, da es auch Gegenstände findet, die sich in einem Feld befinden und aufgenommen werden können. In Tests ist diese Art der Suche effektiver gewesen als die aus
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
28
Kapitel 7.5, allerdings hat das Programm den Nachteil, dass der Gegenstand nicht
erkannt werden kann, wenn der Roboter genau auf den Gegenstand zufährt, da er
sich dann zwischen den beiden Distanzsensoren befindet. Das Programm kann jederzeit durch die Stopp-Taste beendet werden. Das folgende Zustandsdiagramm (Abbildung 20) zeigt den groben Ablauf des Programms.
Abbildung 20: Zustandsdiagramm des Programms area_ride
7.4 Quadrat abfahren (square_drive)
Der Roboter fährt ein Quadrat ab, in dem er viermal nacheinander eine bestimmte
Strecke vorwärts fährt und sich nach jeder Strecke um 90° nach links dreht. Im optimalen Fall erreicht der Roboter am Ende wieder den Startpunkt. Für diese Anwendung spielt der Positionssensor eine wichtige Rolle, durch den neben der Distanz
auch die Drehung berechnet wird. Um möglichst genau am Ursprungsort wieder anzukommen, wird die aus Kapitel 4.2 berechnete x- und y-Position für die Fahrt herangezogen. Mit dem Programm wird der Startpunkt meist mit einer leichten Abweichung erreicht, die aufgrund der in Kapitel 4.2 beschriebenen Toleranzen zu erklären
ist. Falls die Fahrt vorzeitigt gestoppt werden soll, kann das Programm durch die
Stopp-Taste jederzeit beendet werden, ansonsten beendet sich das Programm nach
erreichen der Startposition.
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
29
7.5 Gegenstand suchen und aufnehmen (look_for_item)
Die Anwendung versucht einen Gegenstand in der Umgebung des Roboters zu finden, um ihn dann aufzunehmen und zu transportieren. Dazu dreht sich der Roboter in
kleinen Schritten um die eigene Achse und prüft mit dem linken Distanzsensor, ob
sich etwas in der näheren Umgebung befindet. Der rechte Distanzsensor eignet sich
weniger für die Suche, da er kleinere Gegenstände nicht erkennt und über sie hinweg
schaut. Der linke Sensor ist um 180° gedreht montiert und erkennt daher auch tiefer
liegende Hindernisse. Trotzdem ist der Suchradius eingeschränkt, weil besonders der
linke Distanzsensor von Reflektionen der Oberfläche beeinflusst wird. Die Distanzsensoren, die primär der Kollisionsverhinderung dienen, sind für die Suche daher nur
begrenzt nutzbar. Nachdem der Roboter in seiner unmittelbaren Umgebung keinen
Gegenstand gefunden hat, fährt er 20 cm und beginnt eine neue Suche. Falls der Roboter auf eine schwarze Linie trifft, die das Feld begrenzt, hält der Roboter an, dreht
sich und leitet eine neue Suche ein. Hat der Roboter einen aufnehmbaren Gegenstand
gefunden, transportiert er den Gegenstand 20 cm und legt ihn dann wieder ab. Nach
dem Ablegen des Gegenstands oder durch das Drücken der Stopp-Taste wird das
Programm beendet. Dieser Suchmodus dauert sehr viel Zeit, vor allem wenn der Gegenstand irgendwo in einem begrenzten Feld platziert wird. Daher ist der „Suchmodus“ aus Kapitel 7.3 effektiver und schneller. Das Zustandsdiagramm in Abbildung
21 zeigt das grobe Prinzip der Anwendung.
Abbildung 21: Zustandsdiagramm der Anwendung look_for_item
Bachelorarbeit
WS12/13
Daniel Klose
7 Programmierte Anwendungen
30
7.6 An einer Linie anhalten und umdrehen (stop_at_line)
Eine kurze und schnelle Anwendung, die auch im Praktikum programmiert werden
könnte und nur die Aufgabe erfüllt, dass der Roboter in einem durch schwarze Linien
abgegrenzten Feld bleibt. Der Roboter fährt solange bis er auf eine Kante stößt und
dreht sich daraufhin um. Dabei entscheiden die Kantensensoren, ob links- oder
rechtsherum gedreht wird. Zudem fährt der Roboter ein kurzes Stück wieder zurück,
nachdem er eine Linie oder Kante entdeckt hat, damit der Teflon-Stift, der hinten als
„Standbein“ montiert ist, nicht an der Kante oder dem Isolierband, welches als Linie
dient, hängen bleibt. Beendet wird diese Anwendung durch Betätigung der StoppTaste auf der Fernbedienung.
7.7 Weitere Anwendungen
In dem Modul applications befindet sich neben den genannten Anwendungen noch
eine Funktion für die in Kapitel 7.2 erwähnte Linienverfolgung für einen Farbverlauf, die allerdings bisher nicht getestet wurde. Des Weiteren befindet sich in dem
Modul eine Funktion, die den Roboter zum Startpunkt fahren lässt, die jedoch aufgrund der Fehleraufsummierung nach größeren Distanzen fehlerhaft arbeitet. Das
Modul applications enthält auch Funktionen zur Energiesparverwaltung, welche in
Kapitel 8 näher erläutert sind.
Bachelorarbeit
WS12/13
Daniel Klose
8 Energiesparoptionen
8
31
Energiesparoptionen
8.1 Energiesparoptionen des Mikrocontrollers 68HCS12
Der 68HCS12 Mikrocontroller stellt drei Modi zur Verfügung, die Einfluss auf den
Stromverbrauch haben. Neben dem Run-Modus, der die normale Betriebsart des
Mikrocontrollers darstellt, existieren ein Wait-Modus und ein Stop-Modus, die den
Stromverbrauch reduzieren. Im Wait-Modus bleibt der Takt aktiv, während die CPU
abgeschaltet wird. In diesem Modus können einzelne Peripherieelemente durch das
Setzen von Bits aktiviert oder deaktiviert werden, wodurch auch festgelegt wird,
welche Schnittstelle die CPU wieder aufwecken kann. Der Wait-Modus wird von
jedem Interrupt unterbrochen und wird einfach durch den Assembler-Befehl „WAI“
aktiviert. Der Stop-Modus ist der stromsparendste Modus, den der 68HCS12 Controller besitzt. In diesem Modus wird neben CPU und Peripherie auch der Takt abgeschaltet, wodurch der Mikrocontroller zum Stillstand kommt und nur einen sehr geringen Strom verbraucht. Der Stop-Modus kann jedoch nur durch einen Reset oder
durch den externen IRQ-Pin des 68HCS12 Controllers aufgehoben werden. Außerdem kann das CAN-Modul mit entsprechender Konfiguration den Stop-Modus aufheben. Um in den Stop-Modus zu gelangen, muss vor dem Assembler-Befehl
„STOP“ das Stoppbit (S-Bit) im Condition Code Register (CCR) auf „0“ gesetzt
werden, welches nach jedem Reset „1“ ist und die Stopp-Instruktion sperrt. [13]
8.2 Energiesparfunktion der Software
Die Schaltung mit dem Mikrocontroller verbraucht im normalen Betrieb (ohne Sensoren und Ansteuerung der Motoren) etwa 90-95 mA. Durch die Power-Taste auf der
Fernbedienung kann der Mikrocontroller in den Stop-Modus versetzt werden, wodurch sich der Stromverbrauch der Schaltung auf unter 70 mA reduziert. Wird die
blaue Indikator-LED auf dem Mikrocontroller-Modul deaktiviert und wird der Positionssensor in den Power-Down Modus versetzt, reduziert sich der Stromverbraucht
auf unter 50 mA. Mit etwa 45 mA ist damit der Energiebedarf der Schaltung halbiert
Bachelorarbeit
WS12/13
Daniel Klose
8 Energiesparoptionen
32
worden und verlängert die Akkulaufzeit. Der Wait-Modus spart weniger Energie und
wird zudem durch den Modulus-Down-Counter immer wieder unterbrochen. Da der
Modulus-Down-Counter für das Auslesen der Fernsteuerungsbefehle gebraucht wird,
ist ein Abschalten des Counters nicht sinnvoll. Daher wurde neben dem manuellen
Aktivieren des Stop-Modus noch ein selbstständiges Aktivieren aus der Hauptschleife programmiert, so dass nach 5 Minuten Inaktivität der Mikrocontroller automatisch
den Stop-Modus aktiviert und die Indikator-LED und den Positionssensor deaktiviert.
Bachelorarbeit
WS12/13
Daniel Klose
9 Programmübersicht
9
33
Programmübersicht
Die Software für den Roboter ist in mehrere Module aufgeteilt, die jede eine Aufgabe der Software übernehmen und das Programm übersichtlich gestalten. Die einzelnen Module der Software werden im Folgenden kurz erläutert. Eine Übersicht über
die Funktionen, die jedes Modul beinhaltet, befindet sich im Anhang.
Modul applications
Für die unterschiedlichen Aufgaben, die der Roboter erledigen kann, enthält das Modul applications Funktionen mit Abläufen, die über die Main-Funktion aufgerufen
werden.
Modul akku
Das Modul akku enthält eine Funktion zur Überwachung der Akkuspannung. Das
Fehlersignal an Port B, welches eine Hardware-Schaltung auslöst (siehe [1]), wird
dort ausgewertet und die rote LED auf der Hauptplatine wird bei geringer Spannung
eingeschaltet.
Modul control
Im Modul control stehen Funktionen zur Verfügung, die für die Steuerung und Fortbewegung des Roboter von Nutzen sind. Das Modul beinhaltet ebenfalls die Regelung der beiden Motoren, die für die Bewegung des Roboters eine wichtige Rolle
spielen.
Modul decode_rc5
Allein für die Entschlüsselung des RC5-Codes der Fernbedienung ist das Modul
decode_rc5 zuständig. Die einzelnen Bits des ankommenden Signals werden in der
Funktion ausgewertet und zu dem Kommando-Befehl zusammengesetzt.
Bachelorarbeit
WS12/13
Daniel Klose
9 Programmübersicht
34
Modul enable
Die zwei Funktionen des Moduls schalten Distanzsensoren, Liniensensoren, Kantensensoren, Radencoder, Transportlichtschranke und Klappensensor sowie die rote
LED ein bzw. aus.
Modul init
Das Modul init beinhaltet die Funktion zur Initialisierung des Roboters. Die Ports
und Module des Programms werden eingerichtet und gegebenenfalls mit Startwerten
versehen.
Modul main
Die zum Start des Programms nötige Main-Funktion befindet sich in einem extra
dafür vorgesehenen Modul. Von dort werden weitere Unterprogramme und Funktionen aufgerufen.
Modul motion
Das Modul motion kümmert sich um alle Ansteuerungen der Motoren. Die Funktionen des Moduls kümmern sich um ein entsprechendes PWM-Signal für Antrieb- und
Servo-Motoren.
Modul position
Im Modul position werden die Daten für die Positionsbestimmung berechnet und
verwaltet. Mit Hilfe des Positionssensors wird die Winkelposition sowie die aktuelle
x- und y-Position des Roboters ermittelt und zur Verfügung gestellt.
Modul positionsensor
Für die Kommunikation mit dem Positionssensor ist das Modul positionsensor zuständig. Das Modul stellt Funktionen zum Auslesen und Steuern des Sensors bereit
und nimmt den anderen Modulen die direkte Kommunikation über die SDIO Schnittstelle zum Sensor ab.
Bachelorarbeit
WS12/13
Daniel Klose
9 Programmübersicht
35
Modul sensors
Die analogen Sensoren des Roboters werden im Modul sensors ausgelesen und teilweise verarbeitet, damit außerhalb des Moduls die Werte der Sensoren entsprechend
ihrer Funktion zur Verfügung stehen.
Modul speed_measure
Das Modul speed_measure kümmert sich um die Berechnung der Geschwindigkeit
der beiden Räder, die vorwiegend für die Motorregelung genutzt wird.
Modul timer
Das Modul timer behandelt die Interrupt Funktionen, die durch den Timer-Baustein
erzeugt werden. Welche Interrupt Funktionen des Timers aktiv sind, wird in der Vektor-Tabelle des Moduls vect festgelegt.
Modul transport
Im Modul transport sind Funktionen für alle Transport-Aufgaben implementiert.
Dazu gehört die Behandlung der Sensoren für Transportklappe und Transportfach
sowie fertige Funktionen zum Aufnehmen und Ablegen einen Gegenstandes.
Modul vect
Die Vektor-Tabelle für die Interrupt Behandlung des 68HCS12 ist im Modul vect
aufgeführt. Die Auswertung der Interrupts erfolgt im Modul timer.
Bachelorarbeit
WS12/13
Daniel Klose
10 Aufgaben für das Praktikum
36
10 Aufgaben für das Praktikum
In einer Vielzahl von Möglichkeiten kann der Roboter in einem Praktikum verwendet werden. Mit dem PWM-Modul können Studenten zu Beginn den Roboter zum
Leben erwecken und können später schwierigere Funktionen wie z.B. das Entschlüsseln der Kommandos der Fernbedienung schreiben. Neben solchen vom Programm
unabhängigen Funktionen, können auch mithilfe einiger Funktionen aus der vorliegenden Software Anwendungen geschrieben werden, die kleinere Probleme lösen.
Einfachere Anwendungen wie z.B. das Durchfahren eines kleinen Labyrinths oder
das Folgen einer Straße, welche durch schwarze Linien oder Hindernisse begrenzt
sind, erfordern das Auslesen von analogen Sensoren und gibt den Studenten einen
Einblick in die Mobilität des Roboters. Daraus folgen auch Anwendungen wie das
Anhalten an Linien und das Befahren eines abgesteckten Bereichs. Mit den Distanzsensoren können die Studenten den Roboter vor Hindernissen anhalten lassen und
mit den Daten des Positionssensors können Distanzen gefahren werden, wodurch
auch Anwendungen wie das Fahren eines Quadrats erstellt werden können. Als weitere Funktion ist das Aufnehmen oder Ablegen eines Gegenstands von Interesse der
Studenten, wobei mehrere Funktionen und Anwendungen genutzt werden. Es gibt
eine Vielzahl von Anwendungen, die Studenten erstellen können, aber der zeitliche
Rahmen ist dabei immer begrenzt und auch der Schwierigkeitsgrad muss angemessen sein.
Bachelorarbeit
WS12/13
Daniel Klose
11 Zusammenfassung und Ausblick
37
11 Zusammenfassung und Ausblick
In dieser Bachelorarbeit ist eine Software für den mobilen Roboter der Zeitschrift c‘t,
dessen Hardware zuvor im Praxisprojekt [1] überarbeitet worden ist, entwickelt worden, die das Auslesen der Sensoren und das Nutzen der Motoren ermöglicht. Durch
entwickelte Methoden und Strategien können Module und Funktionen der Software
auch für weitere Softwareprojekte genutzt werden. Ohne einige Methoden, wie die
Motorregelung oder die Berechnung des Drehwinkels, ist die Funktionsweise des
Roboters eingeschränkt, wodurch sich viele Anwendungen nicht realisieren lassen.
Die Grundlage für Anwendungen, wie einer Linienfahrt oder eine bestimmte Strecke
zu fahren, ist mit der Software geschaffen worden. Durch die einfache Steuerung
über die Fernbedienung ist das Aufrufen von Anwendungen ermöglicht worden. Mit
den Energiesparoptionen des Mikrocontrollers 68HCS12 versucht die Software den
Stromverbrauch gering zu halten. Auf Basis der neu entwickelten Software können
Studenten arbeiten und ihr Interesse an der hardwarenahen Programmierung wecken.
Dis Software des Roboters deckt die wichtigen Bereiche wie Auslesen der Sensoren
und Steuerung der Aktoren ab, jedoch kann der Roboter für viele weitere Anwendungen genutzt werden. Die Aufgaben, die der Roboter erledigen kann, sind vielfältig und steigern die Praxiserfahrung der Studenten. Einen wissenschaftlichen Nutzen
hat dieses Projekt nicht und die Hardware stößt auch oft bereits an ihre Grenzen. Daher begrenzt sich die Nutzung des Roboters auf Lehreinrichtungen wie Hochschulen
oder Schulen, jedoch kann es auch Interessierte an den Bereich der Elektrotechnik
und Informatik heranbringen. Wenn es eine entsprechende Strecke für die Verfolgung einer Linie mit Farbverlauf gibt, ist die Entwicklung der Regelung, die bereits
vorprogrammiert wurde, eine interessante Anwendung. In einigen Bereichen wie z.B.
der Verarbeitung der Sensordaten kann die Genauigkeit möglicherweise noch etwas
erhöht werden, aber die Möglichkeiten der Hardware sind begrenzt.
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
A
38
Funktionen der Programm-Module
Modul akku
Funktionen:
void check_akku (void)
Prüft das Fehlersignal der Akkuüberwachungsschaltung und aktiviert die rote LED,
wenn das Fehlersignal länger anliegt.
Modul applications
Funktionen:
void follow_line_gradient (void)
Führt die Anwendung zur Verfolgung einer Linie mit Farbverlauf aus.
void follow_line (void)
Führt die Anwendung zur Verfolgung einer schwarzen Linie aus.
void square_drive (void)
Führt die Anwendung zum Abfahren eines Quadrats aus.
void free_drive (void)
Führt die Anwendung zu einer freien Fahrt aus.
void back_to_start (void)
Lässt den Roboter zur Startposition zurückfahren.
void area_ride (void)
Führt die Anwendung zum Abfahren seiner Umgebung aus.
void look_for_item (void)
Führt die Anwendung zur Suche und zum Transport eines Gegenstands aus.
void stop_at_line (void)
Führt die Anwendung zum Anhalten an einer schwarzen Linie aus.
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
39
void power_down (void)
Bringt den Roboter in einen energiesparenden Modus.
void bot_timeout (void)
Bringt den Roboter nach einer festgelegten Zeit selbstständig in einen energiesparenden Modus.
Modul control
Funktionen:
void speed_control (int set_speed_left_local, int set_speed_right_local)
Regelt den rechten und linken Motor auf die gewünschte Geschwindigkeit. Durch
negative Soll-Geschwindigkeiten dreht sich der Motor rückwärts.
Bedingung:
aktivierte Rad-Encoder (enable Funktion)
Inputs:
Soll-Geschwindigkeit für rechten und linken Motor
int pi_control_motor_left (int set_speed_local)
Berechnet die Stellgröße des Reglers für den linken Motor.
Bedingung:
aktivierte Rad-Encoder (enable Funktion)
Input:
Soll-Größe (Geschwindigkeit) des linken Motors
Output:
Stellgröße für den linken Motor
int pi_control_motor_right (int set_speed_local)
Berechnet die Stellgröße des Reglers für den rechten Motor.
Bedingung:
aktivierte Rad-Encoder (enable Funktion)
Input:
Soll-Größe (Geschwindigkeit) des rechten Motors
Output:
Stellgröße für den rechten Motor
int get_direction (int set_speed_local)
Prüft die Soll-Geschwindigkeit auf Negativität und gibt die entsprechende Drehrichtung des Motors zurück.
Input:
Soll-Geschwindigkeit des Motors
Output:
Drehrichtung des Motors
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
40
void bot_turn_right (int degree_local)
Dreht den Roboter um einen gewünschten Winkel (in Grad) auf der Stelle nach links.
Bedingung:
Power Up des Positionssensors, aktivierte Rad-Encoder (enable Fkt.)
Input:
Der gewünschte Winkel (in Grad), um der sich der Roboter nach links
drehen soll
void bot_turn_left (int degree_local)
Dreht den Roboter um einen gewünschten Winkel (in Grad) auf der Stelle nach
rechts.
Bedingung:
Power Up des Positionssensors, aktivierte Rad-Encoder (enable Fkt.)
Input:
Der gewünschte Winkel (in Grad), um der sich der Roboter nach
rechts drehen soll
void bot_turn_to_zero_angle (void)
Dreht den Roboter auf kürzestem Weg in die Ursprungsblickrichtung (Winkel 0)
Bedingung:
Power Up des Positionssensors, aktivierte Rad-Encoder (enable Fkt.)
void bot_full_stop (void)
Stoppt beide Räder des Roboters. (Bremse)
Bedingung:
aktivierte Rad-Encoder (enable Funktion)
void bot_drive_backward_mm (int distance_local)
Lässt den Roboter um eine gewünschte Distanz rückwärts fahren.
Bedingung:
Power Up des Positionssensors, aktivierte Rad-Encoder (enable Fkt.)
Input:
Distanz, die der Roboter rückwärts fahren soll (in mm)
void bot_drive_forward_mm (int distance_local)
Lässt den Roboter um eine gewünschte Distanz vorwärts fahren.
Bedingung:
Power Up des Positionssensors, aktivierte Rad-Encoder (enable Fkt.)
Input:
Distanz, die der Roboter vorwärts fahren soll (in mm)
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
41
int pid_gradient_line_control (double ek_local)
Berechnet die Stellgröße für die Linienfahrt auf einem Farbverlauf aus der Regeldifferenz.
Input:
Regeldifferenz aus Soll- und Ist-Größe, der Sensoren
Output:
Stellgröße für Motoren
void gradient_line_control (void)
Bedingung:
aktivierte Liniensensoren (enable Funktion)
Regelt die Fahrt auf einer Linie mit Farbverlauf.
Modul decode_rc5
Funktionen:
void decode_rc5 (int time, short int level)
Entschlüsselt den Befehl der Fernbedienung aus den Flanken des RC5-Signals.
Inputs:
Zeit der letzten Flanke und Pegel des Pins nach dem Interrupt
externe Variablen:
extern long int rc5_command
Letzter Befehl der Fernbedienung
Modul enable
Funktionen:
void enable (int enable_local)
Aktiviert die Sensoren und die rote LED.
Input:
Das Element, welches aktiviert werden soll.
void disbale (int disable_local)
Deaktiviert die Sensoren und die rote LED.
Input:
Bachelorarbeit
Das Element, welches deaktiviert werden soll.
WS12/13
Daniel Klose
12 Anhang
42
externe Variablen:
extern Port_ab* pa_ptr
Pointer des Ports A (Digital Out)
extern Port_ab* pb_ptr
Pointer des Ports B (Digital In)
Modul init
Funktionen:
void init (void)
Initialisiert die Ports des Mikrocontrollers und versetzt den Roboter in den Startzustand.
Modul main
Funktionen:
void main (void)
Enthält die Main-Funktion mit der Hauptschleife, aus der die Anwendungen gestartet
werden können.
Modul motion
Funktionen:
void motor_left (int direction_local, int duty_local)
Steuert den linken Motor mit einem PWM-Signal an. Die Funktion entscheidet über
die Drehrichtung und Geschwindigkeit des Motors.
Inputs:
Drehrichtung des linken Motors und Pulslänge des PWM-Signals
void motor_right (int direction_local, int duty_local)
Steuert den rechten Motor mit einem PWM-Signal an. Die Funktion entscheidet über
die Drehrichtung und Geschwindigkeit des Motors.
Inputs:
Bachelorarbeit
Drehrichtung des rechten Motors und Pulslänge des PWM-Signals
WS12/13
Daniel Klose
12 Anhang
43
void open_flap_gate (void)
Steuert den Servo-Antrieb mit einem PWM-Signal an, welches ihn in eine Stellung
fahren lässt, die die Transportklappe öffnet.
void close_flap_gate (void)
Steuert den Servo-Antrieb mit einem PWM-Signal an, welches ihn in eine Stellung
fahren lässt, die die Transportklappe schließt.
void stop_flap_gate (void)
Stoppt den Servo-Antrieb und die Transportklappe.
void flap_gate_timeout (void)
Stoppt den Servo-Antrieb der Transportklappe nach einer Zeit, um Strom zu sparen.
externe Variablen:
extern Port_h* ph_ptr
Pointer des Ports H (Digital Out)
extern PWMmodule* pwm_ptr
Pointer des PWM-Moduls
extern int direction_left
Drehrichtung des linken Motors
extern int direction_right
Drehrichtung des rechten Motors
Modul position
Funktionen:
void update_position (void)
Berechnet die neue Position durch die Positionsänderungsdaten des Positionssensors.
Bedingung:
Bachelorarbeit
Power Up Positionssensor
WS12/13
Daniel Klose
12 Anhang
44
void set_bot_angle (float dx_mm_local)
Berechnet die Winkelposition des Roboters aus der Bewegung der x-Achse des Positionssensors.
Bedingung:
Power Up Positionssensor
Input:
Bewegung der x-Achse, die der Positionssensor aufgenommen hat
float check_angle_range(float angle_local)
Prüft und korrigiert die Winkelgröße, wenn sie kleiner als 0 oder größer als 2π ist.
Input:
Der Winkel, der geprüft werden soll
Output:
Der korrigierte Winkel, der einen Wert zwischen 0 und 2π hat
float degree_to_radiant (int degree_local)
Rechnet einen Winkel von Grad in Radiant um.
Input:
Winkel in Grad
Output:
Winkel in Radiant
int radiant_to_degree (float radiant_local)
Rechnet einen Winkel von Radiant in Grad um.
Input:
Winkel in Radiant
Output:
Winkel in Grad
float get_distance_to_start (void)
Berechnet die direkte Distanz zum Startpunkt des Roboters.
Bedingung:
gespeicherte Positionsdaten
Output:
Die Distanz zum Startpunkt (in mm)
int get_bot_angle_to_start (void)
Berechnet den Winkel zwischen der Winkelposition 0 und dem Startpunkt des Roboters.
Bedingung:
gespeicherte Positionsdaten
Output:
Drehwinkel zwischen Winkelposition 0 und dem Startpunkt
externe Variablen:
extern double y_position
y-Position des Roboters
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
45
extern double x_position
x-Position des Roboters
extern double y_movement
Zurückgelegte Distanz in Vorwärts- bzw. Rückwärtsrichtung seit dem letzten Abfragen des Positionssensors.
extern float bot_angle
Aktuelle Winkelposition des Roboters.
Modul positionsensor
Funktionen:
char rx_positionsensor (void)
Empfängt ein Byte über die serielle Schnittstelle vom Positionssensor.
Bedingung:
Power Up Positionssensor
Output:
Das Byte, welches Empfangen wurde
void tx_positionsensor (char data_local)
Sendet ein Byte über die serielle Schnittstelle zum Positionssensor.
Bedingung:
Power Up Positionssensor
Input:
Das Byte, welches zum Sensor gesendet werden soll
void wait (int counts_local)
Nutzt eine Schleife, um eine Zeit abzuwarten.
Input:
Die Anzahl der Schleifendurchläufe
void get_delta_movement_mm (float* dx_ptr, float* dy_ptr)
Liest die X- und Y-Register des Positionssensors aus und berechnet die Bewegung in
mm. Die Bewegungsdistanz wird an die Variablen übergeben, dessen Adressen
übergeben wurden.
Bedingung:
Power Up Positionssensor
Inputs:
Adressen der Variablen, in der die aktuelle Bewegungsdistanz gespeichert werden soll
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
46
void reset_positionsensor (void)
Startet die SDIO Schnittstelle des Positionssensors neu und löscht X- und YRegister.
void clear_register_positionsensor (void)
Leert die X- und Y-Register des Positionssensors.
void power_down_positionsensor (void)
Versetzt den Positionssensor in den Energiesparmodus (Power-Down Modus).
externe Variablen:
extern Port_k* pk_ptr
Pointer des Ports K (SDIO)
Modul sensors
Funktionen:
short int read_sensor_analog (int sensor_local)
Liest einen analogen Sensor aus und gibt den AD-Wert des Sensors zurück.
Bedingung:
Sensor ist aktiviert (enable Funktion)
Input:
Der Sensor, dessen Wert abgefragt werden soll
Output:
Der AD-Wert des Sensors
int get_distance_left (void)
Gibt den Distanzwert des linken Distanzsensors zurück.
Bedingung:
Distanzsensoren sind aktiviert (enable Funktion)
Output:
Dis Distanz, die der linke Sensor misst.
int get_distance_right (void)
Gibt den Distanzwert des rechten Distanzsensors zurück.
Bedingung:
Distanzsensoren sind aktiviert (enable Funktion)
Output:
Dis Distanz, die der rechte Sensor misst.
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
47
int calculate_distance (int value_local, int sensor_local)
Berechnet aus einem AD-Wert eines Distanzsensors einen Distanzwert.
Input:
Der AD-Wert und der Distanzsensor, zu dem der AD-Wert gehört
Output:
Die berechnete Distanz in cm
int check_left_edge (void)
Prüft, ob sich der linke Kantensensor über einer Kante oder schwarzen Linie befindet.
Bedingung:
Kantensensoren sind aktiviert (enable Funktion)
Output:
Das Ergebnis der Prüfung (Kante oder keine)
int check_right_edge (void)
Prüft, ob sich der rechte Kantensensor über einer Kante oder schwarzen Linie befindet.
Bedingung:
Kantensensoren sind aktiviert (enable Funktion)
Output:
Das Ergebnis der Prüfung (Kante oder keine)
externe Variablen:
extern AnalogToDigital* atd0_ptr
Pointer des Ports ATD0 (AD-Port)
Modul speed_measure
Funktionen:
void update_speed (void)
Berechnet die Geschwindigkeit beider Räder aus den letzten Messwerten.
Bedingung:
Rad-Enconder sind aktiviert (enable Funktion)
void speed_measure (int movement_left_local, int movement_right_local)
Berechnet die Geschwindigkeit aus der zurückgelegten Distanz des Rades über eine
Zeit.
Inputs:
Zurückgelegte Distanz des linken und rechten Rads seit der letzten
Messung
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
48
externe Variablen:
extern int speed_motor_right
Die Geschwindigkeit des rechten Rads, welche durch mehrere Messwerte mit update_speed berechnet wurde.
extern int speed_motor_left
Die Geschwindigkeit des linken Rads, welche durch mehrere Messwerte mit update_speed berechnet wurde.
Modul timer
Funktionen:
@interrupt void timer0_isr (void)
Wird durch Flanken des linken Rad-Encoders ausgeführt und berechnet den dadurch
zurückgelegten Weg des linken Rads.
@interrupt void timer1_isr (void)
Wird durch Flanken des rechten Rad-Encoders ausgeführt und berechnet den dadurch zurückgelegten Weg des rechten Rads.
@interrupt void timer2_isr (void)
Wird durch Flanken des von der Fernsteuerung kommenden RC5-Signals ausgelöst
und leitet die relevanten Flanken zur Auswertung an die Entschlüsselungsfunktion
weiter.
@interrupt void modulus_counter_isr (void)
Wird nach einer konstanten Zeit immer wieder ausgeführt und schafft eine Zeitbasis
für verschiedene Anwendungen. Berechnet die Zurückgelegte Strecke jedes Rads
nach einer Zeit für die Geschwindigkeitsberechnung.
@interrupt void ISR_TRAP (void)
Wird bei unerwarteten Interrupts ausgeführt. (ohne Funktion)
@interrupt void SWI_TRAP (void)
Wird bei Software-Interrupts ausgeführt. (ohne Funktion)
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
49
externe Variablen:
extern TIMERmodule* timer_ptr
Pointer des Timer-Moduls
extern Port_t* pt_ptr
Pointer des Ports T (Digital In)
extern unsigned int control_time
Zeitbasis für die Motorregelung.
extern unsigned long int timeout_time
Zeitbasis für die Timeoutfunktion der Transportklappe und der selbstständigen Energiespar-Funktion.
Modul transport
Funktionen:
int status_flap_gate (void)
Gibt den Status des Transportklappensensors zurück.
Bedingung:
Klappensensor ist aktiviert (enable Funktion)
Output:
Status der Transportklappe (Offen oder Geschlossen)
int status_transportbox (void)
Gibt den Status der Lichtschranke im Transportfach zurück.
Bedingung:
Lichtschranke für Transportbox ist aktiviert (enable Funktion)
Output:
Status des Transportfachs (Leer oder Gegenstand im Fach)
int error_flap_gate (void)
Prüft das Fehlersignal des Servo-Antriebs und gibt den Status der Stromüberwachung zurück.
Output:
Status der Stromüberwachung des Servo-Antriebs (Fehler oder kein
Fehler)
Bachelorarbeit
WS12/13
Daniel Klose
12 Anhang
50
void pickup_item (void)
Führt eine Anwendung aus, in der ein Gegenstand, der vor dem Fach liegt, aufgenommen wird.
void place_item (void)
Führt eine Anwendung aus, in der ein Gegenstand, der sich im Transportfach befindet, abgelegt wird.
Bachelorarbeit
WS12/13
Daniel Klose
Literaturverzeichnis
51
Literaturverzeichnis
[1]
Daniel Klose, „Hardwareerweiterung für einen mobilen Roboter“, Hochschule Ostwestfalen-Lippe, 26.07.2012.
[2]
Heise Zeitschriften Verlag, „Aktuatoren des c’t-Bots – Motoren/Motorregelung“.
http://www.heise.de/ct/projekte/machmit/ctbot/wiki/ct-Bot-Software-
Aktuatoren [Stand: 10.10.2012]
[3]
Dierk Schröder, „Elektrische Antriebe – Grundlagen“, Springer Verlag, 4.
Auflage, 2009.
[4]
Otto Föllinger, „Regelungstechnik“, Hüthig Buch Verlag Heidelberg, 6. Auflage, 1990.
[5]
Frank Dörrscheidt, Wolfgang Latzel, „Grundlagen der Regelungstechnik“,
B.G. Teubner Stuttgart, 2. Auflage, 1993.
[6]
Sprut.de, „IR-Fernbedienung – der RC-5 Code“, 16.07.2009.
http://www.sprut.de/electronic/ir/rc5.htm, [Stand: 02.11.2012]
[7]
rn-wissen.de, „RC5-Code“, 09.05.2012.
http://www.rn-wissen.de/index.php/RC5-Code, [Stand: 04.11.2012]
[8]
Torsten Evers, „Wo bin ich?“, c’t Magazin 13/2006, S.226, Heise Zeitschriften Verlag, 2006.
[9]
kreatives-chaos.com, „Infrarot Entfernungsmesser“, 16.03.2007.
http://www.kreatives-chaos.com/artikel/infrarot-entfernungsmesser,
[Stand: 20.10.2012]
[10]
SHARP: Datenblatt GP2Y0A21YK, Sharp Corporation, 2005.
[11]
wiki.ctbot.de, „RC Univers29 “, 29.10.2012.
http://wiki.ctbot.de/index.php/RC_Univers_29, [Stand: 05.11.2012]
[12]
Heinz Mann, Horst Schiffelgen, Rainer Froriep, „Einführung in die Regelungstechnik“, Carl Hanser Verlag München, 11. Auflage, 2009.
Bachelorarbeit
WS12/13
Daniel Klose
Literaturverzeichnis
[13]
52
Harald Kreidl, Gerald Kupris, Oliver Thamm, „Mikrocontroller-Design“, Carl
Hanser Verlag München Wien, 2003.
[14]
RRZN / Leibniz Universität Hannover, „Die Programmiersprache C“, 16.
Auflage, 2007.
[15]
Joachim Goll, „C als erste Programmiersprache“, Teubner Verlag, 6. Auflage,
2008.
Bachelorarbeit
WS12/13
Daniel Klose