Roboterprogrammierung mit Hilfe eines ATMEL AVR-Prozessor ...

Besondere Lernleistung
im Bereich
Informatik
Roboterprogrammierung mit
Hilfe eines
ATMEL AVR-Prozessor
von Dominik Hufnagel
MSS12
Informatik (Ro)
2008/2009
Projektname:
HMMR
Home Made Mapping Robot

Inhaltsverzeichnis
1. Vorwort............................................................................................................................................1
2. Thema Beschreibung......................................................................................................................2
3. Die mechanischen Komponenten..................................................................................................4
3.1 Grundplatte............................................................................................................................4
3.2 Motoren.................................................................................................................................5
3.3 Räder.....................................................................................................................................6
3.4 Platinenbefestigung...............................................................................................................8
3.5 Akkuhalterung.......................................................................................................................8
3.6 Sensorenhalterung.................................................................................................................9
4. Die elektrischen Komponenten...................................................................................................10
4.1 Allgemein............................................................................................................................10
4.1.1 Der Schrittmotor.....................................................................................................10
4.1.2 Schaltplan und Layout............................................................................................11
4.1.3 Erstellung von Platinen...........................................................................................11
4.2 Schrittmotoransteuerung.....................................................................................................12
4.3 Hauptplatine........................................................................................................................16
4.4 Die Sensoren.......................................................................................................................20
4.5 Die Funkmodule..................................................................................................................22
5. Die Programmierung....................................................................................................................23
5.1 Allgemein............................................................................................................................23
5.2 Der Atmega.........................................................................................................................23
5.3 Die Fusebits.........................................................................................................................24
5.4 Der Bootloader....................................................................................................................24
5.5 Der Erste Test......................................................................................................................25
5.6 Aufbau der Firmware..........................................................................................................26
5.7 Die Funktionen der „myLib“..............................................................................................27
5.8 Die Funktion von fifo..........................................................................................................31
5.9 Der PC als Empfänger.........................................................................................................32
6 Anhang............................................................................................................................................36
6.1 Quellenverzeichnis..............................................................................................................36
6.2 Inhaltsverzeichnis der CD...................................................................................................36

1. Vorwort
Die Idee zu diesem Projekt entstand durch bereits vollendete Projekte mit einem AVR 1
Mikrocontroller. Das Interesse an elektronischen Schaltungen und an der Programmierung wird
durch Projekte mit Mikrocontrollern kombiniert. Durch die Softwarefirma meines Vaters kam es zu
frühen Kontakt mit Computern und somit wurde mein Interesse an der Programmierung geweckt.
Mein Interesse an elektrischen Schaltungen wurde bereits an meinem zehnten Geburtstag durch ein
gemeinsames Projekt mit meinem Vater geweckt. Ein weiterer Anstoß war der Wunsch eigene
Schaltungen für den Komfort bei der PC Bedienung zu bauen, zum Beispiel ein LC-Display oder
eine Lüftersteuerung. Zu den Mikrocontrollern kam ich schließlich vor ca. 3-4 Jahren, als mein
Bruder mit der Idee kam, ein großes Display aus vielen LEDs aufzubauen. Im Internet fand ich
jemanden, der mir bei vielen Schaltungen geholfen hatte und mir auch die
Mikrocontrollerprogrammierung näher brachte. Diese scheute ich immer, da ich diese immer für
sehr kompliziert hielt. Doch ich stellte fest, dass dies nicht so ist. Die ersten Schritte in der
Programmierung von Mikrocontrollern machte ich mit Assembler, dem sogenannten
Maschinencode. Assembler ist eine Hardwarenahe Programmiersprache, welche sich aus wenigen
Befehlen zusammensetzt. Der Vorteil durch diesen Einstieg war, dass ich den Mikrocontroller mit
seinen einzelnen Registern gut kennen lernte. Erst für spätere, komplexere Projekte stieg ich auf die
Hochsprache C um. Die Entscheidung für eine Besondere Lernleistung im Fach Informatik fiel, als
ich hörte, dass in der Schule mit dem Asuro-Roboter gearbeitet wird, welcher auch durch einen
AVR Mikrocontroller gesteuert wird. Zu dem endgültigen Thema der BLL kam es durch eines
meiner letzten Projekte, einen autonomen Rasenmäher, welcher jedoch nur per Zufall den Rasen
mäht. Darum soll es dem Roboter aus diesem Projekt möglich sein eine Karte seiner Umgebung zu
erstellen, um diese theoretisch für andere Zwecke nutzen zu können. Dieses Projekt dient auch dazu
neue Erfahrung zu machen und mein Wissen zu erweitern.
1 Laut ATMEL: Advanced Virtual RISC (Reduced Instruction Set Computing)
© (2008/2009) 1

Idee:
Planung:
2. Thema Beschreibung
Eine Roboterplattform fährt selbstständig in einem beliebigen Raum und kartographiert
diesen mit Hilfe eines AVR-Prozessors unter Zuhilfenahme verschiedener optischer
Sensoren.
Form: Der Roboter erhält eine runde Form. Die Räder werden mittig gesetzt
um das Drehen auf der Stelle zu ermöglichen.
Sensoren: Zur Abstandsmessung werden die Infrarotsensoren GP2D120 von Sharp
verwendet. Odometriesensoren werden aufgrund der Benutzung von
Schrittmotoren nicht verwendet.
Prozessor: Als Prozessor wird ein ATMEL Atmega644P verwendet, dieser bietet
ausreichend Programmspeicher.
Motoren: Als Antrieb werden 2 Schrittmotoren benutzt, welche über einen Treiber IC
im Halbschrittbetrieb angesteuert werden.
Verbindung: Der Roboter kann über den COM-Port mit dem Computer kommunizieren.
Hier wird evtl. die Kabelverbindung durch eine Funk Verbindung ersetzt.
Sonstiges: Die Platinen werden über den PC selbst entworfen und geätzt. Es werden evtl.
Ideen zur Umsetzung der Kartographie
SMD Halbleiter verwendet um Platz zu sparen.
Die Stromversorgung erfolgt über ein Akkupack aus NiMH oder LiPo Zellen.
Der Roboter startet in einem beliebigen Raum und legt diesen Punkt als P(0|0) in einem
Koordinatensystem fest. Trifft er auf ein Hindernis/ eine Wand, folgt er dieser mit einem
gleich bleibenden Abstand.
Probleme:
● Der Roboter wird nicht immer im 90° Winkeln drehen, daher muss die Schräge
(Steigung im Koordinatensystem) berechnet werden.
● Zum Folgen der Wand mit gleich bleibenden Abstand sind evtl. Sensoren
erforderlich, um die Korrektur zu errechnen (Abstanddifferenz). Idee: Man nimmt
nur ein angetriebenes Rad in der Mitte welches sich um 360° drehen kann →
verworfen, da der Roboter sich sonst unkontrolliert drehen kann
© (2008/2009) 2

Geplante Etappen
● Es muss eine Einheit für das Koordinatensystem festgelegt werden (z.B. 1cm oder
eine Radumdrehung..)
● Der Speicherbedarf der einzelnen Koordinaten könnte den Speicher des AVR
übersteigen.
● Planung und Bau der mechanischen Komponenten
● Planung und Bau der elektronischen Komponenten
● Programmierung der Grundriss Kartographie
● Programmierung der Hindernis Kartographie
Namensgebung:
Am 11.03.2009 wurde der Roboter in HMMR getauft. Diese Kombination steht für Home
Made Mapping Robot und drückt aus, dass dies ein selbstgebauter (home made)
Kartographieroboter (mapping robot) ist.
© (2008/2009) 3

3.1 Grundplatte:
Überlegungen:
Form:
Fertigung:
Material:
3. Die mechanischen Komponenten
Die Form des Chassis wurde rund gewählt um das Drehen auf der Stelle zu
ermöglichen. Bei der Wahl des Durchmessers musste man die Breite der
Motoren beachten. Ein Motor misst von der Rückplatte bis zum Ende der
Motorwelle ca. 6cm. Somit musste der Durchmesser mindestens 12cm
betragen. Um genug Platz für Sensoren etc. zu haben sollte der Durchmesser
ca. 15cm betragen. Das Chassis wurde in mehreren Ebenen aufgebaut um den
Platz bestmöglich zu nutzen.
Es war zunächst geplant Aluminium oder Edelstahl zu verwenden. Da diese
Materialien aber schwer zu beschaffen und zu verarbeiten sind, wurde auf
Plexi-Glas als Alternative zurückgegriffen. Dies ist in jedem Baumarkt
erhältlich und leicht zu verarbeiten.
Als Grundplatte diente eine 4mm Plexiglasscheibe welche mittels einer Oberfräse
ausgefräst wurde. Der Durchmesser beträgt ca. 15,5cm. Damit die Achse der
Motoren mittig im Kreis sitzt, wurde in die Mitte ein Loch für die Befestigung der
Motoren gebohrt.
Abbildung 1: Die Grundplatte mit der
Mittelwand für die Motorbefestigung
© (2008/2009) 4

3.2 Motoren:
Die ersten Motoren wurden mit einem U-Aluprofil aneinander geschraubt und auf der
Grundplatte befestigt. Die neuen Motoren haben die Befestigungslöcher jedoch Diagonal
angeordnet, weswegen eine neue Befestigungsmöglichkeit der Motoren auf der Grundplatte
notwendig wurde. Geplant war, eine 15mm dicke Aluplatte zu verwenden, jedoch war eine
solche nicht beschaffbar. Die Ersatzlösung besteht aus 3 übereinander geschraubten 4-Kant
Alu Profilen welche den Vorteil des geringen Gewichtes haben. In der Werkstatt der
Wärmeverwertung Karlsruhe in Minderslachen, in welche ich durch meinen Nachbarn
Zutritt bekam, wurden die Löcher für die Motoren in einer Standbohrmaschine gebohrt. Die
Motoren wurden dann mit einer M3 Gewindestange und Muttern daran befestigt. In die
Aluprofile konnte aufgrund der geringen Wandstärke kein Gewinde geschnitten werden,
weswegen die Befestigung auf der Grundplatte durch Schrauben mit Muttern erfolgt.
• Bei dem Versuch ein Zahnrad, welches auf den Schrittmotorwellen aufgepresst ist,
abzuziehen ging ein Motor kaputt. Um einen gleichmäßigen geradeaus Lauf zu
erreichen sind jedoch 2 gleiche Motoren notwendig. Da kein identischer Motor
auffindbar war, wurde in einem spezialisierten Shop 2 2 neue Motoren gekauft. Auf
Anfrage wurde dort ein Rabatt von 10% ausgehandelt, da es sich um ein
Schulprojekt handelt.
Abbildung 2: Die ersten Motoren mit dem U-
Profil
2 Http://www.mir-elektronik.de
Abbildung 3: Die neuen Motoren an der 4-Kant
Alu Konstruktion
© (2008/2009) 5

3.3 Räder:
Überlegungen:
Die Anfangs verwendeten Schrittmotoren stammten aus einem alten Laserdrucker,
weshalb es keine Datenblätter zu diesen Motoren gab. Es wurde aufgrund eines
Tests, bei dem durch Anlegen von Spannung an den Motor dieser um 25 Schritte
bewegt wurde und sich die Achse etwa um ein 8tel drehte, angenommen, dass sie
1,8°/Schritt drehen, also 200 Schritte pro Umdrehung benötigen. Die Motoren haben
die Abmessungen 4,2x4,2cmx3,6cm. Aufgrund dieser Abmessungen muss der
Raddurchmesser > 5cm sein. Die neuen Motoren (siehe unten) besitzen die gleichen
Eigenschaften wie die alten, jedoch sind sie durch ein Datenblatt dokumentiert. Es
wird ein Rad gesucht, das mit einer bestimmten Anzahl von Schritten möglichst
genau 1cm zurücklegt. Dazu verwendet man einfach die Formeln zur
Kreisberechnung: U =2⋅�⋅r . Um aus dem Umfang auf den Weg zu schließen,
welchen der Roboter dann in einem Schritt zurücklegt, muss man den Umfang durch
die Anzahl der Schritte pro Umdrehung, hier 200, teilen. Diese Formel löst man nach
dem Radius auf und kann dann den Radius für die gewünschte Auflösung (Weg pro
Schritt) ermitteln. r= 200⋅Weg
2⋅�
Verschiedene Auflösungen
Auflösung: 0,1cm/Schritt Radius: 3,183cm Durchmesser: 6,366cm
Auflösung: 0,125cm/Schritt Radius: 3,979cm Durchmesser: 7,958cm
Auflösung: 0,2cm/Schritt Radius: 6,366cm Durchmesser: 12,732cm
(Die Auflösungen wurden so gewählt, dass sie durch 1 ohne Rest Teilbar sind)
Es wurde die Auflösung 0,1cm/Schritt gewählt, da der Durchmesser des Rades
passend scheint. Bei dieser Auflösung werden also 10 Schritte für einen cm benötigt.
© (2008/2009) 6

Fertigung:
Als Lösung für die Räder wurden zunächst alte Räder eines Modellbauflugzeugs in
eine Bohrmaschine gespannt und mittels Schleifpapier abgeschliffen. Mit einer
digitalen Schieblehre wurde der Durchmesser öfters geprüft. Diese
Räderkonstruktion stellte sich jedoch als nicht verwendbar raus, da es keine
Möglichkeit gab, sie an den Motoren zu befestigen. Deshalb wurden in der Werkstatt
der Wärmeverwertung Karlsruhe Räder aus Teflon, nach eigenen Zeichnungen,
gedreht. Teflon ist ein glattes Material und rutscht leicht auf dem Untergrund. Damit
der Roboter nicht ständig ausrutscht wurde ein Stück alter Fahrradschlauch auf die
Räder aufgezogen. Die gedrehten Räder können mit einer M3 Madenschraube an den
Motorwellen befestigt werden.
• Bei der Befestigung der Räder an den Motoren kam es zu einer großen
Unwucht eines Rades. Der Fehler wurde in der Madenschraube gefunden,
welche nicht gerade abgeschliffen war. Diese wurde ersetzt.
• Der Fahrradschlauch auf den Rädern hatten ein wenig Schlupf weswegen es
zu Abweichungen von den berechneten Strecken kam. Der Fahrradschlauch
wurde mit doppelseitigen Klebeband befestigt.
Abbildung 4: Die erste Lösung für die Räder,
welche sich jedoch als nicht verwendbar
herausstellte
Abbildung 5: Die neuen Räder wurden an eine
Drehbank entsprechend den Berechnungen
gedreht
© (2008/2009) 7

3.4 Platinenbefestigung:
Um die Platinen auf der Grundplatte zu befestigen wurde aus Plexiglas und Aluwinkeln eine
U-Förmige Plattform gebaut, auf welcher die Schrittmotortreiber und die Hauptplatine Platz
finden. Die Aluwinkel wurden mit 2 Komponenten Epoxyd Harz an das Plexiglas geklebt
und mit der Grundplatte verschraubt. Die Platinen sind über Gummis an der Konstruktion
befestigt.
Abbildung 7: Die Plattform: Die Teile müssen
während der Aushärtung des Klebers mit Druck
aneinander gepresst werden
3.5 Akkuhalterung:
Der Akku wurde auf einer Plattform oberhalb der Hauptplatine befestigt. Dazu wurden
Abstandshalter von PC Mainboards übereinander geschraubt und darauf eine Plexiglasplatte
befestigt. Wie auch die Platinen wird der Akku von Gummis gehalten.
Abbildung 8: Die Akkuhalterung bildet eine 2.
Ebene oberhalb der Hauptplatine
Abbildung 6: Die Platinen sind auf der
Plattform mit Haushaltsgummis befestigt. Dies
sorgt für ausreichend Halt
© (2008/2009) 8

3.6 Sensorenhalterung:
Vorne:
Seite:
Um die Sensoren vorne zu befestigen wurde ein Stück Alublech ausgeschnitten und
gewinkelt. Der Abstand der Sensoren zueinander beträgt 10cm. Die Sensoren wurden
an das Alublech geschraubt, welches ebenfalls mit Schrauben auf der Grundplatte
befestigt ist.
Abbildung 9: Die Sensoren auf dem Chassis:
Die hervorstehenden Ecken der Halterung
wurden nachträgich noch entfernt
Die Sensoren an der Seite wurden ähnlich den Sensoren vorne befestigt. Jedoch
wurde das Alublech an die Akkuplatte geschraubt. Der Abstand der Sensoren
zueinander beträgt nur 9cm.
Abbildung 10: Die Sensoren an der Seite hängen
ca. 10cm über dem Boden
© (2008/2009) 9

4.1 Allgemein:
4.1.1 Der Schrittmotor:
4. Die elektrischen Komponenten
Ein Schrittmotoren ist ein Synchronmotor, welcher ganz anders als ein
Gleichstrommotor arbeitet. Durch die spezielle Wicklung legt er, für eine bestimmte
Kombination an den Wicklungen angelegten Spannungen, einen festen Winkel
zurück. Dadurch eignet er sich gut zum Einsatz im Kartographie Roboter, da durch
ihn Odometriesensoren entfallen können. Aufgrund der Genauigkeit von
Schrittmotoren finden sie in vielen Bereichen Anwendung, wie z.B. in Drucker,
CNC-Fräsen uvm. Ein Nachteil ist jedoch, dass er auch Strom benötigt, wenn er sich
nicht dreht. Der sogenannte Haltestrom sorgt dafür, dass der Motor nicht von Hand
oder durch zu viel Schwung weiter gedreht wird. Man kann einen Schrittmotor auf
zwei verschiedenen Arten ansteuern, bipolar und unipolar. Hier wird nur auf die
bipolare Ansteuerung eingegangen, da sie in diesem Projekt verwendet wird und der
Motor durch sie mehr Kraft entwickelt.
Webseiten: http://www.roboternetz.de/wissen/index.php/Schrittmotoren
http://www.strz.uni-giessen.de/amp/pcprak/versuch6/intro6.html
Zeichnung 1: Hier erkennt man gut wie ein Schrittmotor
arbeitet (Zusammenhang zwischen Spannung und
Drehwinkel)
(Quelle: Roboternetz.de)
© (2008/2009) 10

4.1.2 Schaltplan und Layout:
Die Schaltpläne und Layouts für die einzelnen Platinen wurden selbst entworfen.
Dabei wurde auf schon vorhandene Schaltpläne oder das Datenblatt der einzelnen
ICs 3 zurückgegriffen. Zum Erstellen von Schaltplänen und Platinenlayouts wurde die
Software Eagle verwendet. Die Freeware Version erlaubt eine Platinengröße von
100x80mm und 2 Layer 4 und kann von der Herstellerseite 5 bezogen werden.
Im Schaltplan war es wichtig darauf zu achten, dass man bei der Bauteilwahl auch
auf die richtige Gehäuseform bzw. das richtige Rastermaß 6 der Bauteile achtet, sonst
wäre es später bei dem Layout zu Problemen gekommen wäre. Die größte
Schwierigkeit beim Layout war, die Bauteile sinnvoll zu platzieren, so dass die
Leiterbahnen möglichst einfach zu verlegen sind. Eagle verfügt zwar über einen
sogenannten „Autorouter“, welcher die Leiterbahnen im Layout automatisch verlegt,
dieser arbeitet jedoch erst bei 2 Layern effizient. Somit wurden in den Layouts alle
Leiterbahnen von „Hand“ verlegt. Dabei war darauf zu achten, dass die Abstände
zwischen 2 Leiterbahnen nicht zu klein wurden und Leiterbahnen, auf welchen viel
Strom fließt, die entsprechende Breite aufwiesen.
4.1.3 Erstellung von Platinen:
Die Platinen wurden über das Belichtungs-Ätzverfahren erstellt, für welches speziell
mit Fotolack beschichtete Platinen notwendig sind. Dabei wurde zuerst das fertige
Layout aus Eagle auf eine spezielle Laserdruckerfolie gedruckt und auf die Platinen
aufgelegt, welche dann mittels UV-Licht belichtet wurde. Der Abstand der UV-Röhre
und die Belichtungsdauer waren aus früheren Projekten bekannt. Nach dem
Belichten wurde der Fotolack der Platine in einer Natriumhydroxid Lösung
entwickelt und anschließend in einem Natriumpersulfat Ätzbad das überschüssige
Kupfer entfernt. Abschließend wurden in einer Standbohrmaschine die Löcher für die
Pins der Bauteile gebohrt.
3 Integrated Circuit - Halbleiterbaustein
4 Lagen: Platinenoberseite bzw Platinenunterseite
5 http://cadsoft.de/
6 Abstand der Pins zueinander: Hier 2,54mm
© (2008/2009) 11

4.2 Schrittmotoransteuerung:
Überlegungen:
Um bipolare Schrittmotoren anzusteuern sind spezielle IC Treiber nötig. In diesem
Projekt wurde eine Kombination der ICs L297 und L298 verwendet. Zunächst war
geplant, die Treiber ICs der Schrittmotoren aus dem Drucker auszulöten. Da die
Beschaltung jedoch nicht erprobt war und es keine näheren Referenzen zu diesen ICs
gab, wurde diese Idee verworfen. Der IC L297 ist der eigentliche Schrittmotortreiber,
welcher den Strom an den einzelnen Phasen umkehrt und dafür sorgt, dass die
Schrittreihenfolge eingehalten wird. Der IC L298 ist eine H-Brücke welche eine
höhere Stromstärke liefert als der L297 alleine. Die Schrittmotortreiber sollten beide
auf einer Platine untergebracht werden, was jedoch aufgrund des Platinenlayouts
nicht möglich war. Beim Verlegen der Leiterbahnen wäre es zu vielen
Überschneidungen gekommen, weswegen jeder Schrittmotortreiber auf einer eigenen
Platine untergebracht ist.
Datenblatt L297: http://www.st.com/stonline/products/literature/ds/1334.pdf
Datenblatt L298: http://www.st.com/stonline/products/literature/ds/1773.pdf
Zwischenüberlegungen
Schaltplan:
7 Elektolytkondensator
Zwischendurch wurde überlegt den L298 durch einen L6205 zu ersetzen, da dieser
mehr Strom verträgt und keine externen Dioden benötigt. Doch der Kostenfaktor war
hier ausschlaggebend für die Entscheidung den L298 zu verwenden, welcher alle
Anforderungen erfüllt.
Der Schaltplan der Motorsteuerung wurde zum Großteil aus dem Datenblatt des
L297 übernommen. Es wurde auch im Internet nach Schaltungen gesucht und Ideen
übernommen bzw. abgeändert. Von jeder Platine führt ein 10-Poliger Pfostenstecker
an die Hauptplatine, auf welcher dann gemeinsamen Verbindungen wie die
Strombegrenzung, der Halb-/Vollschrittjumper und die gemeinsamen Anschlüsse
zusammengeführt werden. Um Spannungseinbrüche in der Stromversorgung zu
vermeiden, wurden 4700µF Elkos 7 als Puffer eingeplant.
© (2008/2009) 12

© (2008/2009) 13

Erklärung des Schaltplans:
Über die Klemmen X5 wird die
Stromversorgung der Schrittmotoren
angeschlossen. C3 (Elko) ist zur Pufferung und
Ausgleich des Stroms. C4 (Kondensator) dient
zur Glättung der Spannung.
Das RC Glied bildet den Taktgeber für den IC
L297
Hier sieht man die Freilaufdioden für den L298.
Diese dienen dazu den Strom der Motoren
„abklingen“ zu lassen und eine Zerstörung des
ICs durch Induktion zu verhindern.
R2 und R3 bilden die Shunt 8 Widerstände zum
Messen der aktuellen Stromstärke der
Schrittmotoren.
Über den 10-Poliger Pfostenstecker wird die
Verbindung zu der Hauptplatine hergestellt und
die Schaltung mit Spannung versorgt.
8 Niederohmiger Widerstand an welchem der Spannungsabfall gemessen und daraus der fließende Strom errechnet
wird: U = R * I
© (2008/2009) 14

Layout und Erstellung
Probleme:
Bei der Erstellung des Layouts der Motortreiber kam es zu Überkreuzungen der
Leiterbahnen. Diese wurde jedoch mittels Lötbrücken, welche auf der Oberseite der
Platine verlaufen, behoben. In der ersten Version wurde eine Verbindung vergessen.
Da die Platine jedoch aufgrund eines Fehlers in der Herstellung noch einmal erstellt
werden musste, wurde diese Verbindung hinzugefügt. Jedoch fehlten auch in der 2.
Version noch zwei Widerstände welche kurzerhand über Lötbrücken auf der fertigen
Platine eingesetzt wurden.
• Bei der ersten Version der Platine wurde das Layout spiegelverkehrt auf die Platine
aufgelegt weswegen diese unbrauchbar wurde und eine zweite Version erstellt
werden musste.
Abbildung 11: Das Platinenlayout, erstellt mit
Eagle, in der 2. Version
• Durch die hohe Stromaufnahme der Motoren kam es zu einer starken Erhitzung des
© (2008/2009) 15

L298. Hier wurde mit einem kleinen Kühlkörper Abhilfe geschaffen, welcher aus
einem alten PC Netzteil entnommen und auf die richtige Größe angepasst wurde.
• Bei einem Test kam es zu einem Kurzschluss. Bei einem Motortreiber kam es zur
Ablösung zweier Leiterbahnen auf der Platine. Diese wurden durch Kabelbrücken
ersetzt.
4.3 Hauptplatine:
Überlegungen:
Schaltplan:
Die Hauptplatine wurde modular geplant, das heißt es ist möglich Erweiterungen
einfach über Stiftleisten anzuschließen. Auf der Hauptplatine wurden die Anschlüsse
der Schrittmotortreiber über je 10-Polige Steckerleisten realisiert. Für die
Schrittmotortreiber wurde ein Spannungsteiler für die Referenzspannung der
Strombegrenzung und ein Jumper für die Halb-/Vollschrittwahl eingeplant. Die
Haupteinheit ist ein Atmega644P mit einem 16MHZ Quarz. Zum Programmieren des
AVRs ist ein InSystemProgramming Anschluss herausgeführt worden um das
Programmieren in der Schaltung zu ermöglichen. Die Stromversorgung übernimmt
ein L7805 Spannungsregler mit Stabilisierungskondensatoren.Dieser wandelt die
Akkuspannung von 9,6V auf die Versorgungsspannung von 5V.
Die Erstellung des Schaltplans stellte kein Problem dar, da die Grundbeschaltung von
8-bit AVRs von früheren Projekten bekannt war. Der Schaltplan besteht im Groben
aus 3 Teilen: Der Stromversorgung, dem Mikrocontroller, und den Anschlüssen
sowie Einstellmöglichkeiten der Schrittmotoren.
© (2008/2009) 16

© (2008/2009) 17

Erklärung des Schaltplans:
Der IC 7805T stellt mit den 2 Kondensatoren
und dem Elko die Stromversorgung des AVR
und der anderen ICs dar. Er wandelt die 9,6V
Akkuspannung in 5V um.
Der Potentiometer R2 ist für die
Referenzspannung der Strombegrenzung
verantwortlich. R3 begrenzt die Spannung auf
maximal 3V.
Über den Jumper JP1 wird der
Schrittmodus der Schrittmotoren gewählt
(Halb-/Vollschritt). SV1 und SV2 stellen die
Steckerleisten für den Anschluss der
Motortreiber dar.
Die Kombination von C2, C3 und Q2 bildet die
Taktquelle eines 8-bit AVR Mikrocontrollers.
Diese ist bei den meisten identisch, die
Taktfrequenz kann jedoch über den Quarz Q2
verändert werden, hier 16MHZ.
Mit SV4 wird die Verbindung zu einem
Seriellen-ISP Programmierinterface hergestellt.
ISP steht für InSystemProgramming. Damit ist
es möglich den AVR auf der Platine zu
programmieren.
© (2008/2009) 18

Layout und Erstellung:
Bei der Erstellung des Layouts der Hauptplatine kam es lediglich zu zwei
Überkreuzungen, welche, wie bei den Schrittmotorplatinen auch, über Lötbrücken
behoben wurden. Um alle restlichen Leiterbahnen ohne weitere Überkreuzungen
verlegen zu können, wurden mehrere Bahnen durch IC Pins durchgeführt. Dies
führte bei der Erstellung der Platinen zu Kontakten zwischen den Pins und der
Leiterbahn, welcher jedoch mit einem scharfen Messer getrennt wurden. Da kein
externer Anschluss der Versorgungsspannung für Zusatzplatinen geplant war, wurde
dies mittels Lötbrücken nachgeholt.
Abbildung 12: Das Platinenlayout der Hauptplatine. Die Lötbrücken sind hier gut
zu sehen (rot)
© (2008/2009) 19

4.4 Die Sensoren:
Für die Abstandssensoren Sharp GP2D120 ist keine spezielle externe Beschaltung
notwendig. Sie benötigen lediglich 5V und GND und geben über einen Pin den Abstand in
Form einer Spannung zurück, welche zwischen 0,4V (30cm) und 2,8V (4cm) liegt. Um die
Spannungsversorgung des Mikrocontrollers gegen Spannungseinbrüche durch den hohen
Messstrom zu verhindern wurde eine eigene 5V Stromversorgung für die Sensoren erstellt.
Diese besteht, wie auch bei der Hauptplatine, aus einem Spannungsregler L7805, zwei
100nF Kondensatoren und einem 470µF Elko. Für diese Schaltung wurde weder Schaltplan
noch eine Platine erstellt, da es einfacher und schneller war sie auf ein Stück
Lochrasterplatine aufzubauen.
Datenblatt der Sensoren:
http://www.engr.ucsb.edu/~mdnip/me170c/datasheets/SHARPGP2D120.pdf
Der Sensor GP2D120 arbeitet mit Hilfe der Triangulation. Dabei wird vom Sender ein IR
Lichtstrahl ausgesandt. Je nach Entfernung trifft dieser an unterschiedlichen Stellen beim
Empfänger auf.
Abbildung 13: Das Schema des Infrarot
Entfernungssensor, Quelle: roboternetz.de
© (2008/2009) 20

Das folgende Diagramm, entnommen aus dem Datenblatt des Sharp GP2D120 zeigt die Relation
zwischen Spannung und Entfernung. Es ist zu sehen, dass das Verhältnis nicht linear ist. Somit muss
man für das Errechnen der Entfernung eine Formel verwenden, welche sich an die Kurve des
Diagramms annähert. Eine solche Formel findet man im Wissensbereich der Webseite
A
Roboternetz.de: Entferunung=
gemessenerSpannung− B
In der Formel sind A und B Konstanten, welche man durch Testmessungen bestimmen muss.
Dazu wählt man 2 Entfernungen und misst die anliegende Spannung an den Sensoren.
Hierbei wurden die Entfernungen 5cm und 10cm gewählt. Für A und B ergeben sich dann
folgende Formeln:
� X1− X2�⋅D1⋅D2
1) A=
D1− D2
2) B= X2⋅D2−X1⋅D1
D2− D1
Bei der Testmessung wurden die folgenden Werte ermittelt. Dabei wurde die Messung für
jeden Sensor einzeln durchgeführt, da es bei der Herstellung der Sensoren vom Hersteller zu
Abweichungen in kommen kann.
© (2008/2009) 21

Wertetabelle:
Sensor Entfernung 1
(D1)
Spannung 1
(X1)
Entfernung 2
(D2)
Spannung 2
(X2)
A B
Vorne Links 5 2,28V 10 1,29V 9,9 0,3
Vorne Rechts 5 2,28V 10 1,28V 9,9 0,3
Seite Vorne 5 2,34V 10 1,29V 10,5 0,24
Seite Hinten 5 2,24V 10 1,19V 10,5 0,14
4.5 Die Funkmodule:
Die Funkmodule HM-T868 und HM-R868 ersetzen zusammen die RS232 Schnittstelle über
Funk. Das Modul HM-T868 ist der Sender. Dieser ist an GND, 5V und an TXD des ersten
UART 9 am Mikrocontroller angeschlossen. HM-R868, der Empfänger ist an GND, 5V, RXD
und noch zusätzlich an einem freien Pin angeschlossen, um den Empfänger während des
Sendens abschalten zu können. Die Module besitzen eine Stiftleiste und somit mussten nur
entsprechende Kabel zu den jeweiligen Pins gelötet werden. Die Anschlussbelegung wurde
dem Datenblatt entnommen:
http://www.hoperf.com/pdf/HM-T_EN.pdf
http://www.hoperf.com/pdf/HM-R_EN.pdf
9 Universal Synchronous and Asynchronous serial Receiver and Transmitter
© (2008/2009) 22

5.1 Allgemein:
5. Die Programmierung
Die Programmierung des Mikrocontrollers erfolgte in der Programmier-Hochsprache C. Als
Programmieroberfläche wurde anfangs das AVR Studio verwendet, welches die Firma Atmel
kostenlos auf ihrer Webseite 10 anbietet. Das AVR Studio beinhaltet einen Simulator, um vor
der Programmierung des Mikrocontroller den Code testen zu können. Des weiteren bietet es
die direkte Programmiermöglichkeiten des AVRs mit spezieller Hardware. Da diese
Hardware in diesem Projekt fehlte, wurde der Mikrocontroller über das Programm PonyProg
programmiert. Diese unterstützt „minimal Programmieradapter“ welche aus wenigen
Bauteilen bestehen. PonyProg ist ebenfalls kostenlos und kann auf der Webseite des
Herstellers Lancos 11 bezogen werden. Im späteren Teil der Programmierung wurde mit
Eclipse 12 inklusive dem dafür notwendigen AVR Plugin 13 gearbeitet. Da für Mikrocontroller
ein eigener C Compiler notwendig ist, wurde zusätzlich WinAVR 14 installiert. Dies ist ein
Komplettpaket welches den Compiler und zusätzliche Tools beinhaltet. Mit diesen
Komponenten ist es möglich fast jeden AVR Mikrocontroller zu programmieren.
5.2 Der Atmega:
Der Atmega644P verfügt über einige Funktionen und Eigenschaften:
• 64kByte Flash Programmspeicher, 2kByte EEPROM, 4kByte SRAM
• bis zu 20MIPS (20 Millionen Instruktionen pro Sekunde)
• JTAG On Chip Debug Interface, InSystemProgramming (ISP)
• 3 Timer (2x 8bit; 1x 16bit), 6 PWM Kanäle, RealTimeClock
• 10-bit AD-Wandler (Analog-Digital)
• 2 USART Schnittstellen, Two-Wire Interface, SPI-Interface
• uvm...
Für dieses Projekt verwenden wir nur die Leistung von 16MIPS (16MHZ). Eine wichtige
Funktion ist der Analog-Digitalwandler, welcher die Spannungen der Sensoren in digitale
Werte umwandelt. Ein USART wird für die Funkverbindung zum PC verwendet. Das
InSystemProgramming Interface erlaubt es, den AVR auf der Hauptplatine zu
programmieren.
10 http://www.atmel.com/dyn/products/tools.asp?family_id=607#798
11 http://www.lancos.com/prog.html
12 http://www.eclipse.org/
13 http://sourceforge.net/projects/avr-eclipse/
14 http://winavr.sourceforge.net/
© (2008/2009) 23

5.3 Die Fusebits:
Ein AVR Mikrocontroller besitzt sogenannte Fusebits. Mit ihnen können Features aktiviert
und deaktiviert werden, die Frequenz des Quarzes eingestellt werden oder der Code gegen
auslesen gesichert werden. Mit Setzen dieser Fusebits kann man den Mikrocontroller jedoch
auch unbrauchbar machen. Für dieses Projekt musste die Debugschnittstelle JTAG
deaktiviert werden, die Frequenz auf 16MHZ extern gesetzt werden, und der Bootloader
aktiviert werden.
5.4 Der Bootloader:
Der ausgesuchte Mikrocontroller bietet 64kBytes Flash Speicher für das Programm. Durch
diesen großen Speicher dauert jedoch auch das Programmieren über die
InSystemProgramming Schnittstelle sehr lange, weswegen eine besondere Eigenschaft des
AVRs genutzt wurde. Viele AVR-Mikrocontroller sind in der Lage sich selbst neu zu
programmieren. Dazu wird einfach das Programm in einen Speicherteil übertragen, welcher
nicht programmiert werden kann. Anschließend programmiert sich der AVR neu.
Ein Bootloader ist nun ein Programm, welches beim Initialisieren des AVRs ausgeführt wird,
über die serielle Schnittstelle das neue Programm überträgt und den AVR neu programmiert.
In diesem Projekt wurde auf einen fertigen Bootloader zurückgegriffen, da das
Programmieren eines Bootloaders eine komplexe Aufgabe ist. Der Bootloader besteht aus 2
Teilen, einem Programm auf dem AVR, welches beim Initialisieren ausgeführt wird, und
einem Gegenstück auf dem PC, welches dem Programm auf dem AVR das zu
programmierende Programm sendet. Der Bootloader wurde aus der Codesammlung eines
Forums entnommen (http://www.mikrocontroller.net/topic/73196). Bei diesem Bootloader
ist es möglich die Pins, über welche der AVR mit dem PC kommuniziert, beliebig
festzulegen. Dies macht es möglich, die InSystemProgramming Schnittstelle auch für den
Bootloader zu verwenden. Somit ist kein eigener Stecker nötig. Für den Bootloader wurde
ein kleines Kabel gebaut, welches eine 9-polige Sub-D Buchse für den ComPort des PCs
besitzt und einen 10-poligen Pfostenstecker für den ISP Anschluss, welcher nun als
„Bootloader Anschluss“ verwendet wurde. Da der ComPort mit +-12V als Signal arbeitet,
der AVR jedoch nur mit 5V, wurde in das Kabel ein MAX232 Schnittstellentreiber
eingebaut.
© (2008/2009) 24

5.5 Der Erste Test:
Nachdem alle Kabelverbindung verlegt waren, wurde der Mikrocontroller zum ersten Mal
programmiert. Zum ersten Test wurde nur eine einfache Ansteuerung der Schrittmotoren
verwirklicht, welche die Motoren einfach in eine Richtung drehen lässt. Hierzu muss man
sich auf das Datenblatt des L297 beziehen. Hier eine kleine Übersicht der Pins des L297 und
deren Bedeutungen:
Name Pin an L297 Pin an AVR Bedeutung
CW/CCW 17 Motor1: PC1
Motor2: PC2
Clock 18 Motor1: PD4
Motor2: PD5
Enable 10 Motor1: PC0
Motor2: PC0
VRef 15 Potentiomete
r auf der
Hauptplatine
Half/Full 19 Jumper auf
Hauptplatine
Mit diesem Pin wird die Richtung des Motors bestimmt.
Durch einen Flanke von Low auf High auf diesem Pin
führt der Motor einen Schritt aus
Mit diesem Pin wird der Motorstrom ein- (Pin auf High)
oder ausgeschaltet (Pin auf Low)
Mit dem Trimmer auf der Hauptplatine kann eine
Referenzspannung eingestellt werden, welche der
Strombegrenzung gleich ist (Hier 0,7V → 0,7A
Strombegrenzung pro Motor)
Mit diesem Jumper kann zwischen Halb- und
Vollschrittbetrieb der Motoren gewechselt werden
Um die Motoren nun um eine Umdrehung in eine Richtung drehen zu können, muss zuerst
Enable auf High, dann die Richtung der beiden Motoren gesetzt werden und schließlich 200
Impulse an Clock angelegt werden. Da die Motoren entgegengesetzt eingebaut sind, müssen
die Richtungspins jeweils den gegenteiligen Zustand haben um gerade aus zu fahren. Das
Programm im Folgenden mit Kommentaren zu jeder Programmzeile:
© (2008/2009) 25

#define F_CPU 16000000UL //Die CPU Frequenz wird als 16MHZ definiert
#include //Die AVR Bibliothek wird eingebunden
#include //Eine delay Bibliothek wird eingebunden
int main()
{
uint16_t i; //i wird als Integer ohne Vorzeichen definiert
DDRC=0xFF; //Die Pins des Port C werden als Ausgang definiert
DDRD=0xFF; //Die Pins des Port D werden als Ausgang definiert
PORTD=0x00; //Die Pins des Port D werden alle auf LOW gesetzt
PORTC|=(1

Die „myLib.h“ Header Datei beinhaltet alle notwendigen Definitionen für die „myLib.c“
Datei, welche die Programmierung übersichtlicher machen. Zum Beispiel steht nun in der
„myLib.c“ Datei für „LEFT“ die Zahl 2 oder für FWD die Zahl 0 usw.
5.7 Die Funktionen der „myLib“ :
init(void):
In der Funktion init werden die Ports des Atmega644P konfiguriert. Die ADC Ports werden
als Eingänge gesetzt und die Ports zur Steuerung der Schrittmotoren als Ausgänge.
Desweiteren wird ein Timer gestartet welcher für verschiedene Funktionen, dazu mehr in der
jeweiligen Funktion, verwendet wird. Auch werden die globalen Interrupts aktiviert.
funk_init(void):
Die funk_init Funktion initialisiert die Funkmodule. Zur Zeit wird jedoch nur das
Sendemodul verwendet, da das Empfangsmodul viel „Funkmüll“, das heißt unbrauchbare
Zeichen, empfängt. Da es für die eigentliche Funktion des Roboters nicht von Nöten ist,
wird dieses eventuell später einmal eingebunden. Zuerst wird ein FIFO 15 Buffer initialisiert,
welcher sich hinter den Dateien „fifo.h“ und „fifo.c“ verbirgt und komplett selbst
programmiert ist. Dann werden die Register des USART gesetzt und dieser aktiviert. Die
Baudrate beträgt 9600baud. Aufgrund der Funkmodule ist es notwendig in gewissen
Zeitabständen ein Byte zum PC zu senden, um die Funkverbindung zu erhalten. Aus diesem
Grund wird der Timer, welcher in der init() Funktion angesprochen wurde, verwendet. Da
dies über Interrupts geschieht, bleibt in der Zwischenzeit genug Zeit für die anderen
Rechenoperationen.
getCharArray( unsigned short number, unsigned char *numchar, unsigned char length)
Mit der Funktion getCharArray werden Ganzzahlige Nummern (unsigned short number)
in ein Char Array (unsigned char *numchar) umgewandelt, um diese über Funk zu
versenden. Dabei wird die Länge der Zahl über unsigned char length übergeben, welche
wiederum meist über die Funktion unsigned char getNumberLength ermittelt wird. Da
unsigned char *numchar nur ein Zeiger auf ein Char Array ist, erfolgt in diesem Array die
Rückgabe.
15 First In First Out - Ringbuffer
© (2008/2009) 27

unsigned char getNumberLength( unsigned short number)
Die Funktion getNumberLength ermittelt, wie bereits oben erwähnt, die Länge einer Zahl
und gibt diese als unsigned char zurück.
double
getSensor( unsigned char sensor)
Diese Funktion ist für die Ermittlung der Entfernung eines Sensors zuständig. Welcher
Sensor gemessen werden soll wird über unsigned char sensor übergeben. In ihr wird
zunächst der ADC 16 eingestellt und eine „Dummymessungen“ durchgeführt. Diese wird
nicht berücksichtigt da meist die ersten Werte einer AnalogDigital Wandlung große
Differenzen aufweisen. Danach werden 4 Messungen aufaddiert und durch
Rechtsverschiebung durch 4 geteilt, um einen Durchschnittswert zu errechnen. Mithilfe der
Formel aus Kapitel 4.4 wird nun für jeden Sensor einzeln die Entfernung errechnet. Die
Entfernung wird schließlich als Gleitkommazahl zurückgegeben.
double
getWinkel( unsigned char dir)
Mit der Funktion getWinkel lässt sich der Winkel zwischen den 2 vorderen oder 2 seitlichen
Entfernungssensoren berechnen. Welche 2 Sensoren gewählt sind, wird mittels unsigned
char dir übergeben. Die Berechnung geschieht über den Arcus Tangens: �=atan� �d
b � ,
wobei �d gleich die Differenz der Entfernung beider Sensoren, und b gleich der Abstand
beider Sensoren zueinander ist. Bei den vorderen Sensoren beträgt b=10cm und bei den
seitlichen b=9cm. Da C in Bogenmaß arbeitet, wird muss noch in Grad umgerechnet
werden. Der Rückgabewert ist eine Gleitkommazahl, welche auch negative Werte annehmen
kann. Negative Werte werden dann benötigt, wenn �d negativ ist. Dies kann eintreten, da
�d = vorneLinks
vorneRechts
16 Analog Digital Converter
ist. Bei einem Winkel kleiner 90° wird �d dann negativ.
© (2008/2009) 28

Abbildung 15: Winkel < 90° Abbildung 14: Winkel > 90°
void setMotoren( unsigned char Status)
Die Funktion setMotoren schaltet den Haltestrom der Schrittmotoren An/Aus. Der
gewünschte Zustand wird über unsigned char Status übergeben.
unsigned short setParallel()
Mit dieser Funktion ist es möglich, den Roboter, wenn er vor einer Wand steht, zu dieser
parallel auszurichten. Hierzu wird zunächst der Winkel der vorderen Sensoren zur Wand
ermittelt, um diesen gedreht und mit Hilfe der seitlichen Sensoren korrigiert der Roboter
seine Ungenauigkeiten der ersten Drehung. Die erste Drehung um den Winkel der vorderen
Sensoren geschieht immer nach links, da nur rechts seitliche Sensoren angebracht sind. Bei
der zweiten Drehung findet eine Unterscheidung statt, welche zwischen positiven und
negativen Winkel unterscheidet (siehe Funktion getWinkel).
void doCreateOutlineMap()
Wird diese Funktion aufgerufen, erstellt der Roboter eine Karte der Außenwände und schickt
diese an den PC. In dieser Funktion wird fast ausschließlich auf die externen Funktionen
zurückgegriffen. Der Roboter kann an einem beliebigen Punkt im Raum starten. Er sucht
sich dann zunächst eine Wand, an welcher er sich parallel ausrichtet. Dann fährt er zur
nächsten Wand. An dieser Wand wird er zwangsweise am Anfang ankommen, weswegen er
sich zunächst parallel ausrichtet und erst danach mit der eigentlichen Kartographie beginnt.
In einer Schleife fährt er nun immer zur nächsten Wand und misst die Strecke. Diese schickt
er dann per Funk zum PC und richtet sich parallel zur neuen Wand aus. Auch den gedrehten
Winkel übermittelt er per Funk an den PC. Dies wird so lange wiederholt, bis er sich
© (2008/2009) 29

insgesamt um die Winkelsumme in dem Polygonzug gedreht hat. Zum Beispiel: Dreieck:
180°; Viereck: 360°; Fünfeck: 540°.. Diese Winkelsumme muss immer im Programm
geändert werden.
void
doSendChar( unsigned char zeichen)
Mit dieser Funktion wird ein Zeichen über Funk an den PC übertragen. Dazu wird das
Zeichen in den FIFO Buffer geladen. Über den Timer, welcher in der Funktion init()
gestartet wurde, wird in regelmäßigen Abständen geprüft, ob sich ein Zeichen im FIFO
befindet und dieses gesendet.
void
doSendNumber( unsigned short number, unsigned char length)
Die Funktion doSendNumber sendet eine Zahl über Funk an den PC. Dazu wird die Zahl
über getCharArray in Zeichen umgewandelt und über doSendChar einzeln versendet.
double
doSearchWall( unsigned short distance, unsigned char checkAngle)
Wird diese Funktion aufgerufen fährt der Roboter solange bis er auf eine Wand trifft. Dabei
hält er bei einer Distanz an, welche man mit unsigned short distance übergibt. In einer
Schleife fährt der Roboter immer wieder 3cm vorwärts, bis er eine Distanz von dem
übergebenen Wert + 10 unterschritten hat. Danach hält er kurz an, misst über die Sensoren
die geringste Entfernung zur Wand, zieht davon die gewünschte Distanz zur Wand ab und
fährt die Differenz vorwärts, sodass er genau in der übergebenen Distanz vor der Wand steht.
Wird über unsigned char checkAngle eine 1 übergeben testet der Roboter alle 3cm über die
seitlichen Sensoren, ob er noch parallel zur Wand steht und korrigiert falls dies nicht der Fall
ist. Die Strecke, die er bis dahin gefahren ist, gibt er als Fließkommazahl zurück.
void
doSleep( unsigned short time)
Die Funktione doSleep versetzt den Roboter in einen kurzen „Schlaf“. Die Zeit, die gewartet
werden soll, wird in Millisekunden über unsigned short time übergeben. Auch für diese
Funktion wird der in der init Funktion gestartete Timer verwendet. Dieser ist genau so
eingestellt, dass genau jede Millisekunde ein Interrupt ausgelöst wird.
© (2008/2009) 30

void doSteps( unsigned char dir, unsigned short anzahl)
Durch diese Funktion kann der Roboter vorwärts und rückwärts fahren, oder sich auf der
Stelle nach links oder rechts drehen. Dies funktioniert theoretisch wie im ersten Versuch
(Kap 5.5). Wird ein Impuls ausgegeben, drehen die Räder um einen Schritt bzw. 1,8°. Da die
Räder einen entsprechenden Radius besitzen, entspricht ein Schritt 0,1cm. In der Funktion
werden je nach übergebener Richtung durch unsigned char dir die Pins am Motortreiber
gesetzt bzw. gelöscht. Dann wird ein weiterer Timer gestartet, welcher den Puls regelt und
dafür sorgt, dass die Motoren sich um einen Schritt drehen bis die gewünschte Anzahl
erreicht ist.
void
doTurn( double alpha, unsigned char dir)
Mithilfe dieser Funktion ist es dem Roboter möglich, sich einen bestimmten Winkel um sich
selbst zu drehen. Für diese Funktion ist der Abstand beider Räder zueinander von
Bedeutung. Mit einer Schieblehre wurden 125,5mm gemessen von welchen noch 10mm
aufgrund der Breite beider Räder abgezogen werden. Der Umfang beträgt dann
U =�⋅d =361,91mm
Für einen Teilwinkel gilt: U �= �⋅d⋅�
360
Teilt man nun noch durch den Weg, welcher ein Rad pro Schritt zurücklegt, hat man die
Anzahl der benötigten Schritte.
�⋅d⋅�
Schritte=
WegproSchritt⋅360
Fasst man alle Konstanten zusammen, muss man nur den Winkel � mit einer einzigen
Konstante multiplizieren. Die Funktion berechnet also die Anzahl der Schritte und ruft die
Funktion doSteps auf.
5.8 Die Funktion von fifo:
Wie auch in der myLib.h stehen in der fifo.h Datei wieder nur Definitionen und Prototypen.
Die Dateien „fifo.c“ und „fifo.h“ beinhalten den FIFO Buffer. In der „fifo.h“ befindet sich
eine Typendefinition welche den Typ fifoBuffer definiert. Hinter dem fifoBuffer verbirgt
sich ein Char Array, ein Leseindex und ein Schreibindex:
typedef struct{
unsigned char data[FIFO_BUFFER_SIZE+1];
unsigned char readindex;
unsigned char writeindex;
}fifoBuffer;
© (2008/2009) 31

void fifo_init( fifoBuffer *f)
Bei Aufruf dieser Funktion wird der übergebene FIFO, fifoBuffer *, initialisiert. Das heißt
Lese- und Schreibindex werden auf 0 gesetzt.
unsigned char
fifo_add( fifoBuffer *f, unsigned char fdata)
Mit dieser Funktion wird ein Char, unsigned char fdata, dem FIFO, fifoBuffer *f,
hinzugefügt. Dabei wird gleichzeitig der Schreibindex um eins erhöht. Ist der FIFO voll,
gibt die Funktion eine 0 zurück, andernfalls eine 1.
unsigned char
fifo_read( fifoBuffer *f, unsigned char *readByte)
Diese Funktion dient dem Auslesen eines Char aus dem FIFO fifoBuffer *f. Das
ausgelesene Char wird durch das übergebenen unsigned char *readByte zurückgegeben.
In der Funktion wird desweiteren der Leseindex erhöht. Bei einem leeren FIFO gibt die
Funktion eine 0 zurück. Befinden sich jedoch noch Daten im FIFO gibt sie eine 1 zurück.
unsigned char
fifo_test( fifoBuffer *f)
Mit dieser Funktion lässt sich überprüfen, ob der FIFO fifoBuffer *f noch Daten beinhaltet
oder leer ist. Befinden sich noch Daten im FIFO gibt diese Funktion eine 1, andernfalls eine
0 zurück.
5.9 Der PC als Empfänger:
In diesem Projekt dient der PC als Empfänger der Daten des Roboters. An den PC sind die
selben Funkmodule wie auf dem Roboter an die Serielle Schnittstelle angeschlossen. Über
ein Programm kann der PC dann die Informationen über Weg und Winkel, welche er vom
Roboter erhält, in eine Karte umwandeln. Alle benötigten Informationen erhält der PC über
eine speziell kodierte Zeichenkette vom Roboter welche wie Folgt aussehen kann:
„D549A87D683A69D429A90“
Durch den Buchstabe „D“ weiß der PC dass die darauf folgenden Zahlen die Distanz
angeben, welche der Roboter zurückgelegt hat bis er auf eine Wand gestoßen ist. Das „A“
sagt dem PC, um welchen Winkel sich der Roboter danach gedreht hat, um wieder parallel
zur nächsten Wand zu stehen.
Dem PC ist es nun möglich diese Daten über die Winkelfunktionen in Linien umzuwandeln
und auf dem Bildschirm auszugeben. Das Programm mit dem dies alles geschieht ist
© (2008/2009) 32

ebenfalls eine Eigenentwicklung und wurde in Visual Basic 6 geschrieben, da der zugriff auf
die serielle Schnittstelle hier sehr einfach zu Handhaben ist. Da es, wie schon oben
beschrieben, bei den Empfangsmodulen zu sehr viel Störungen kommt, sortiert das
Programm direkt alle Zeichen aus, welche nicht „D“,“A“ oder eine Zahl sind. Wenn die
Zeichenkette komplett übertragen wurde, spaltet das Programm die Zeichenkette so, dass sie
die einzelnen Zahlen auslesen kann. Die Berechnung für die neuen Koordinaten sie wie
Folgt aus:
GesamtWinkel=Gesamtwinkel−�180− Angle�
Hierbei ist Angle der Winkel der aktuell gedreht wurde. Dieser wird von 180 subtrahiert, da
der Roboter den Innenwinkel misst, für die Berechnungen mit Sinus und Cosinus aber der
Außenwinkel benötigt wird. Dieser Winkel wird von GesamtWinkel, einer Variablen die den
insgesamt gedrehten Winkel speichert, abgezogen.
X neu=cos� GesamtWinkel⋅2⋅�
�⋅distance� X alt
360
Die neue X-Koordinate wird über den Cosinus des Gesamtwinkels errechnet. Hierbei muss,
wie in C auch, der Winkel in das Bogenmaß umgerechnet werden. Distance steht hier für die
Hypothenuse, somit lässt sich also durch cos���∗Hypothenuse die Gegenkathete, also
die „Höhe“ des Dreiecks berechnen. Dieser Punkt muss dann um den aktuellen X-Wert
verschoben um den neue X-Wert zu erhalten.
© (2008/2009) 33

Der Y-Wert lässt sich über den Sinus berechnen:
sin���= Gegenkathete
Hypothenuse
yneu =sin � gesamtWinkel⋅2⋅�
�⋅distance� yalt 360
Start: Startet den Funkempfang
Stop: Beendet den Funkempfang
Print Map: Zeichnet Karte
Clear Map: Löscht Karte
=> Gegenkathete=Hypothenuse⋅sin ���
© (2008/2009) 34

6. Fazit – Ausblick
Da der Zeitraum der Besonderen Lernleistung nach einem Schuljahr nun zu Ende ist, möchte ich
noch ein paar Abschließende Worte schreiben. Aus der Idee, einen Roboter sich in einem
unbekannten Raum zu orientieren zu können, ist eine Projektarbeit entstanden, welche viel Nerven,
Arbeit und auch Geld kostete. Nichts desto trotz war diese Arbeit sehr lehrreich und hat viel Spaß
gemacht. Eine Idee zu realisieren bedarf viel Zeit und Überlegungen. Die erste Phase, der
Erstellung der mechanischen Komponenten, welche sehr schnell abgeschlossen wurde, folgte die
zweite Phase der elektrischen Komponenten. Hier gab es hin und wieder einige Rückschläge,
welche das Budget in die Höhe trieben und mich manchmal zur Verzweiflung brachten, doch
wurden diese letztendlich auch alle überwunden. Dank vieler Vorprojekte brachte auch die
Programmierung, trotz mehrerer schlafloser Nächte, viel Spaß mit sich. Letztendlich reagiert der
Roboter, welcher HMMR getauft wurde, wie gedacht, arbeitet zuverlässig und erstellt
reproduzierbare Karten von ihm unbekannten Räumen. Sicherlich sind diese Karten noch mit
Ungenauigkeiten behaftet, welche sich jedoch in einem angemessenem Rahmen bewegen. Mit
einem vielfach höheren Budget ist es natürlich möglich diese Ungenauigkeiten so zu minimieren,
dass sie keine Rolle mehr spielen. Da es sich hierbei jedoch um ein Schulprojekt und nicht um eine
Forschungsarbeit an einer Universität handelt bin ich mit den Ergebnissen überaus zufrieden. Leider
konnten nicht alle Überlegungen oder Ziele in die Realität umgesetzt werden, da die Zeit gegen
Ende doch knapper wurde als anfangs vermutet. So ist zum Beispiel die Kartographie von
Hindernissen im Raum nicht verwirklicht. Auch kann der Roboter keine Winkel über 180° messen,
was jedoch nur durch die bisherige Firmware beschränkt ist, da die Hardware, die zwei seitlichen
Infrarotsensoren, vorhanden ist. Ebenfalls nicht realisiert ist die Kommunikation von PC zum
Roboter, da die Funkmodule sehr viele unbrauchbare Daten empfangen. Dies ließe sich jedoch über
verschiedene Verfahren in den Griff bekommen. Am Ende kam auch noch die Idee auf, die
Ungenauigkeiten mittels mehreren Kartographie-Durchgängen zu minimieren. Hierbei fährt der
Roboter den Raum mehrfach ab und errechnet den Durchschnittswert aller Durchgänge.
Auch in der Endphase des Projekts konnte ich viele neue Erfahrungen machen. Zum Beispiel habe
ich mein Projekt in der Projektwoche der Schule drei Studenten der Hochschule Karlsruhe
präsentieren können. Auch an dem Projekttag der Schule konnte ich meine Vortagsweise bei den
Vorführungen im Projekt von Herr Roth, welche gut besucht waren, trainieren. Auch nach
Abschluss dieser Besonderen Lernleistung werde ich mich weiter an dem Roboter versuchen und
die Programmierung ausbauen um die besagten Ziele eventuell doch noch realisieren zu können.
© (2008/2009) 35

6.1 Quellenverzeichnis:
7. Anhang
Robotikforum und Wissensbereich: http://www.roboternetz.de
Elektronikforum und Wissensbereich: http://www.mikrocontroller.net
Bezugsquelle der Schrittmotoren: http://www.mir-eletronik.de
Bezugsquelle der Sensoren http://www.roboter-teile.de
Software Eagle http://www.cadsoft.de
Software PonyProg http://www.lancos.com
Software AVR Studio http://www.atmel.de
Software Eclipse-IDE http://www.eclipse.org/
AVR-Plugin für Eclipse http://avr-eclipse.sourceforge.net
Softwarepaket WinAVR http://winavr.sourceforge.net/
6.2 Inhaltsverzeichnis der CD:
• Präsentationsfilm
• Dokumentation in digitaler Form
• Diashow
• Filme
• Bilder
• PC Software
• Firmware Sourcecode
• Bootloader Sourcecode
• PC Software Sourcecode
• Datenblätter aller ICs und Sensoren