Entwicklung einer mobilen Kleinstroboterplattform für die...

Entwicklung einer mobilen Kleinstroboterplattform für die Anwendung in

der Lehre und Forschung

Stefan Boneberg

Bachelorabschlussarbeit im Wintersemester 2012/2013

Mobile Kleinstroboterplattform

Stefan Boneberg Seite 2 von 65

Studiengang Elektrotechnik Physik Plus

Verfasser Stefan Boneberg

Matrikel-Nr. 020495

Geburtsdatum 16. Mai 1984

Betreuer Hochschule Prof. Dr.-Ing. Konrad Wöllhaf

Betreuer Hochschule Dipl.-Ing. (FH) Joachim Fessler

Abgabetermin 24. September 2012



Erklärung

Die vorliegende Bachelorarbeit wurde von mir selbst verfasst und nur mit den angegebenen Quellen

und Hilfsmittel angefertigt.

Weingarten im September 2012

Stefan Boneberg



Danksagung

Diese Bachelorarbeit wurde in der Zeit vom 03.07.2012 bis 24.09.2012 an der Hochschule Ravens-

burg-Weingarten angefertigt. Für die Aufgabenstellung und die Bereitstellung des Arbeitsplatzes

möchte ich mich bei der HS-Weingarten bedanken.

Ein besonderer Dank gilt meinem Betreuer Herrn Prof. Dr.-Ing Konrad Wöllhaf für seine Unterstüt-

zung (insbesondere bei der Erstellung der Simulation). Ebenso möchte ich mich bei meinem Betreuer

Herrn Dipl.-Ing. Joachim Fessler, der mich während dieser Zeit unterstützt hat bedanken.

Weingarten im September 2012

_________________________

Stefan Boneberg



Inhaltsverzeichnis

1. Aufgabenstellung und Ziel der Bachelorarbeit .................................................................................... 7

2. Einleitung ............................................................................................................................................. 8

3. Der Korsel mit einem ATtiny26L und einer Reflektionslichtschranke ................................................. 9

3.1 Benötigte Bauteile und Kosten ATtiny26 .................................................................................... 10

3.2 Wirkungsweise der Bauteile, kurzer Überblick: .......................................................................... 11

3.3 Schaltplan Korsel mit ATtiny26 .................................................................................................... 12

3.4 Platine des Korsels ....................................................................................................................... 13

3.5 Installation des AVR Studios (Programmieren des Mikrocontrollers)......................................... 14

3.5.1 RN –CONTROL-Board oder andere Hardware ...................................................................... 14

3.6 Das Programm des ATtiny26L ..................................................................................................... 15

3.6.1 C Programm .......................................................................................................................... 15

3.7 Konfiguration der Ein- und Ausgänge .......................................................................................... 18

3.8 Konfiguration der Analog-Digital-Wandlung (AD Wandler) ........................................................ 19

3.8.1 Die Einstellung des Registers ADMUX .................................................................................. 19

3.8.2 Die Einstellung des Registers ADCSR .................................................................................... 20

3.9 Konfiguration der Puls Weitenmodulation der Motoren ............................................................ 20

3.9.1 Die Einstellung des Registers TCCR1A .................................................................................. 22

3.9.2 Die Einstellungen des Registers TCCR1B .............................................................................. 22

3.9.3 Die Register OCR1A und OCR1B ........................................................................................... 23

3.10 Vor- und Nachteile eines Korsels mit einer Reflektionslichtschranke und einem ATtiny26L ... 24

4. Der Korsel mit einem ATmega32 und drei Reflektionslichtschranken .............................................. 25

4.1 Benötigte Bauteile und Kosten ATmega32.................................................................................. 26

4.2 Schaltplan Korsel mit ATmega32 ................................................................................................. 27

4.3 Platine des Korsels mit ATmega32 .............................................................................................. 28

4.4 Programmieren mit einem JTAGICE mkII Programmer ............................................................... 29

4.4.1 Einstellungen im AVR-Studio um mit JTAGICE zu debuggen ................................................ 30

4.5 Die Fuses des Mikrocontrollers ................................................................................................... 33

4.6 Das Programm des ATmega 32 mit drei Reflektionslichtschranken ........................................... 34

4.6.1 Implementieren der Bibliotheken ........................................................................................ 34

4.6.2 Initialisieren der Variablen ................................................................................................... 34

4.6.3 IO-Ports initialisieren ............................................................................................................ 35



4.6.4 ADC-Wandler initialisieren ................................................................................................... 36

4.6.5 PWM initialisieren ................................................................................................................ 36

4.6.6 Hauptprogramm (MAIN) ...................................................................................................... 37

4.7 Die Sensoren des Korsels ............................................................................................................. 43

4.7.1 Grundlegende Funktionsweise unsere Sensoren ................................................................. 45

4.8 Einstellungen des Analog-/Digital-Wandlers (ATmega32) .......................................................... 46

4.8.1 Die Einstellung des Registers ADMUX .................................................................................. 46

4.8.2 Die Einstellung des Registers ADCSRA .................................................................................. 47

4.8. 3 Die Einstellung des Registers SFIOR..................................................................................... 47

4.9 Batterie Spannungs-Berechnung ................................................................................................. 48

4.10 Einstellungen der PWM (ATmeaga32) ...................................................................................... 49

4.10.1 Die Einstellung des Registers TCCR1A ................................................................................ 49

4.10.2 Die Einstellungen des Registers TCCR1B ............................................................................ 50

4.11 Grundlegende Funktion der Bauteile, Korsel mit ATmega32 (drei Sensoren) .......................... 51

4.12 Vor- und Nachteile eines Korsels mit einem ATmega 32 .......................................................... 52

5. Simulation des Korsels ....................................................................................................................... 53

5.1 Vorgehensweise um die Simulation zu starten ........................................................................... 53

5.2 Plausibilität der Simulation ......................................................................................................... 55

6. Das digitale Regelsystem (Abtastregelung) ....................................................................................... 56

7. Erreichte und angepasste Ziele ......................................................................................................... 59

8. Verbesserungsvorschläge und Ausblick ............................................................................................ 60

9. Inhalt der Daten-CD ........................................................................................................................... 62

10. Literaturverzeichnis ......................................................................................................................... 64

11. Abbildungsverzeichnis ..................................................................................................................... 65



1. Aufgabenstellung und Ziel der Bachelorarbeit

Ziel der Bachelorarbeit ist die Entwicklung einer mobilen Kleinstroboterplattform für Anwen-dungen in der Lehre und Forschung.

Die Plattform soll die Möglichkeit bieten, verschiedene Aufgaben aus der Lehre und For-schung an einer robusten und kostengünstigen Hardware zu behandeln. Wobei die Aufga-ben thematisch wie auch in der Komplexität unterschiedlich sein können. So soll diese Platt-form von Schulen wie auch von Hochschulen - je nach Aufgabenstellung und Wissens- stand - für Übungen oder Forschungen verwendet werden können. Hierbei gibt es drei Hauptschwerpunkte:

Hardware: Arbeiten mit Schaltplan- und Layoutprogrammen Auswahl und Positionierung von Sensorik Bestücken und Löten von Hardware sowie Auswahl der Hardware-Komponenten

Software: Erstellen eines Programms für einen Mikrocontroller Programmieren eines Mikrocontrollers über verschiedene Schnittstellen (ISP, JTAG)

Regelungstechnik / Simulation: Simulation der Hardware in Matlab Auslegung der Regelparameter

Die Plattform wird so entworfen, dass die Hard- und Software an neue Aufgabenstellungen und Anwendungsfälle angepasst werden kann.

In der Grundausführung besteht die Hardware aus einer Leiterplatte, die gleichzeitig das Chassis ist. Angetrieben wird die Plattform durch zwei DC-Motoren. Die Sensorik besteht aus Reflektionslichtschranken, die die Farbe des Untergrunds erkennen. Die Software bein-haltet die Ansteuerung der Motoren via PWM, das Einlesen der Sensoren sowie die Verar-beitung der dadurch gewonnenen Daten. In der Simulation wird das Modell der Hardware dargestellt.



2. Einleitung Es gibt jetzt schon eine Vielzahl mobiler Kleinstroboter wie z.B. den AREXX ASURO (Abb.1). Die Kos-

ten betragen allerdings ca. 50 €, auch ist der Aufbau mit diskreten Bauteilen realisiert. Der Zusam-

menbau und auch die Fehlersuche gestalten sich daher eher schwierig.

Abbildung 1 Asuro Abbildung 2 POB BOT

Auch gibt es Roboter wie den Lego MINDSTORM (200 €), der allerdings eher für Kinder gedacht ist.

Des weiteren gibt es Roboter wie den POB BOT, die Kosten liegen bei 500 US$.

Jetzt zum „KORSEL“

Der Korsel (Name des mobilen Kleinstroboters) konnte über eine Reflexionslichtschranke nur den

schwarzen oder den weißen Untergrund unterscheiden und gab diesen Wert dann an den Mikrocon-

troller in Form einer 1 oder 0 weiter. Dadurch konnte der Korsel seine Motoren nur ein- und ausschal-

ten. Die Folge davon war, dass der Korsel sehr „holprig“ seiner Bahn folgte. Da die Bauteile sehr

günstig sind, ist es nicht verwunderlich, dass die Motorleistungen stark schwanken - dies hatte zur

Folge, dass jeder Korsel der gebaut wurde, ein eigenes Programm benötigte, welches von Hand ein-

gestellt werden musste. Die Mechanik des Korsel war schon sehr gut und benötigte nur noch gering-

fügige Änderungen.



3. Der Korsel mit einem ATtiny26L und einer Reflektionslichtschranke

Abbildung 3Korsel ATtiny26

Abbildung 4 Korsel ATtiny 26



3.1 Benötigte Bauteile und Kosten ATtiny26

Anzahl Name Bezeichnung Bestellnummer und Lieferant Kosten

2 Motor IGARASHI DC Kleinstmotor 2025-02 Conrad Bestell-Nr: 244414 - V3 3,45 €

2 NPN Transistor BC 817-50 in SMD Bauform Reichelt Bestell-Nr: BC 817-40 SMD 0,04 €

1 Mikrocontroller ATtiny26L Reichelt ATTINY 26L8 SO20 2,10 €

2 Taster Typ Kurzhubtaster Reichelt Bestell-Nr: TASTER 3301 0,11 €

1 Reflektionslichtschranke Typ CNY 70 Reichelt Bestell-Nr: CNY 70 0,70 €

2 Freilauf-Diode Typ 4148 Reichelt Bestell-Nr: SMD 1N 4148 0,02 €

1 Batterieclip Batterieclip für 9-Volt-Block Reichelt Bestell-Nr: CLIP HQ9V-T 0,24 €

1 Spannungsregler Schaltregler ST Microelectronics L 78 L 05 Conrad Bestell-Nr.: 156058-62 0,23 €

1 Schalter Schiebeschalter 1 x Ein/Ein 50 V 0,5 A Conrad Best.-Nr.: 708054 - 62 0,49 €

1 SMD-Widerstände Baugröße 1206 SMD 4,7k Ohm 0,10 €


1 SMD-Widerstände Baugröße 1206 SMD 330 Ohm 0,10 €

1 SMD-Widerstände Baugröße 1206 SMD 12k Ohm 0,10 €



2 Kondensatoren Baugröße 1206 SMD 100nF 0,45 €

1 Entstör Kondensatoren AX 100/16 100uF 16V Reichelt B36-630 0,15 €

1 Entstör Kondensatoren AX 220/16 220uF 16V Reichelt B36-541 0,16 €

2 LED LED 5mm Reichelt Artikel-Nr.: LED 5MM GN 0,06 €

1 Stiftleiste Stiftleisten 2,54 mm, 2X02, gerade Reichelt MPE 087-2-004 0,10 €

1 9V Block energy Alkaline 9 V Block-Batterie Conrad Best.-Nr.: 658014 - 62 3,50 €

3 Messpunkte Lötnägel 1mm, versilbert Reichelt RTM 1-100 0,01 €

0,25 Grundplatine Bungard Platinen-Basismaterial Cu-Auflage Conrad Best.-Nr.: 523798 - 62 5,19 €

4 Reifen

O-Ring: Innendurchmesser 20mm Dicke:

2mm

2 Räder Kugellager

BB-608-A500-10-ES (Kunststoffla-

ger von IGUS)

1 Achse z.B. 8mm-Alu-Rohr aus dem Baumarkt

4

Isolierte Drähte für den

Anschluss der Motoren

Gesamt: 17,96 €

http://www.reichelt.de/Atmel-Attiny-AVRs/ATTINY-26L8-SO20/3/index.html?;ACTION=3;LA=446;ARTICLE=45904;GROUPID=2958;artnr=ATTINY+26L8+SO20;SID=13T-2B8n8AAAIAACmttgQ7a9c7f8f0e69334420fa8949785ce306



3.2 Wirkungsweise der Bauteile, kurzer Überblick:

Der ATtiny26L ist ein 8bit Mikrocontroller aus der Atmelreihe. Er hat einen 2k Bytes Flasch Speicher

und was hier sehr wichtig war - einen internen Analog-Digital-Wandler. Programmiert wird er über eine

ISP-Schnittstelle. Um sicher zu arbeiten, benötigt er eine Spannung von 2,7 V bis 5,5 V. Das „L“ steht

für diesen Spannungsbereich. Seine maximale Taktfrequenz beträgt 8 MHz.

Die Energieversorgung wird über einen günstigen Nickel-Metall-Hydrid-Akkumulator mit einer Span-

nung von 8,4 V realisiert.

Die ATtiny26L steuert zwei Transistoren, welche dann die Motoren an- und abschalten. Für die Ener-

gieversorgung der Motoren wird der 9-V-Block direkt angeschlossen, zur Stabilisierung und Entstö-

rung der Spannung ist ein Kondensator mit 220 uF vorgesehen. Zum Entstören ist zusätzlich noch ein

100 nF Kondensator verbaut.

Die Spannung für die Reflektionslichtschranke sowie für den Mikrocontroller wird über den L78L05

(Festspannungsregler) bereitgestellt. Er liefert eine konstante Ausgangspannung von 5 V und einen

Strom von 0,1 A. Der Kondensator mit 100 uF und der Kondensator mit 100 nF glätten diese und sor-

gen dafür, dass die Spannung auch beim Einkoppeln von Störsignalen durch die Motoren konstant

bleibt und der Mikrocontroller sicher arbeiten kann.

Am Heck des Korsel´s ist ein Schalter montiert, mit dem man ihn komplett spannungslos schalten

kann. Eine LED, die links daneben angebracht ist, zeigt an ob der Korsel Spannung hat oder nicht.

Da die Motoren über eine PWM (Puls Weiten Modulation) angesteuert werden, benötigen sie auch

sogenannte „Freilaufdioden“ - diese übernehmen in den Pausenphasen der PWM den Strom der Mo-

toren. Würden diese Dioden falsch oder gar nicht eingebaut, könnten große Spannungsspitzen ent-

stehen, die andere Bauteile zerstören.

Der Kurzhubtaster sowie die zweite LED ist für diverse Abänderungen in der Zukunft gedacht.

Programmiert wird der ATtiny26 über einen AVR Atmel-Programmer (AVRISP mkII) - dies ist ein sehr

günstiges Programmiergerät (unter 40 €). Auch ist es einfach zu bedienen (sehr gut für die ersten

Schritte geeignet). Der große Nachteil des AVRISP mkII ist, dass es kein Debugging unterstützt.



3.3 Schaltplan Korsel mit ATtiny26



3.4 Platine des Korsels



3.5 Installation des AVR Studios (Programmieren des Mikrocontrollers) Mit der Software “AVR-Studio“, dem AVRISP USB - Programmer kann man eine große Anzahl von Mikrocontroller-Derivaten der Firma Atmel programmieren (brennen / “flashen“). Weiter bietet AVR-Studio eine IDE (Integrierte Entwicklungsumgebung) mit Assembler. Einen passenden C-Compiler erhält man durch die Installation der Software WINAVR. Das Software-Paket WINAVR ist eine IDE mit C-Compiler. Wenn AVR-Studio und WINAVR auf einem PC installiert sind, erkennt AVR-Studio den Compiler von WINAVR automatisch. Als Entwicklungsumgebung steht dann AVR-Studio mit folgenden Features zur Verfügung: IDE, Assembler, C-Compiler und Programmier- / Brennsoftware Folgender Weg für die Installation von AVR-Studio mit WINAVR und für das Anlegen eines Projekts hat sich als praktikabel erwiesen: 1. AVR Studio installieren (hierbei immer die neueste Version verwenden / www.atmel.com). 2. Programmiergeräte anschließen: Anschluss AVRISP-USB: Programmer via USB

anschliessen. Schwarzer Con-Button ( ) in der oberen Menüleiste klicken und den Programmer “AVRISP mkII“ auswählen. Eventuell verlangt AVR Studio ein Firmwareupdate für den USB-Programmer. Hierzu einfach den Anweisungen auf dem Bildschirm folgen.

Test: Schwarzer Con-Button ( ) in der oberen Menüleiste klicken und “ AVRISP“ auswählen. 3. WINAVR installieren (http://winavr.sourceforge.net). Nach der WINAVR–Installation erkennt AVR-Studio nun automatisch den gcc-Compiler von WINAVR und verwendet diesen. 4. Im Windows-Explorer ein Projektverzeichnis für ein neues Projekt anlegen. 5. Im AVR-Studio neues Projekt anlegen (angelegtes Projektverzeichnis wählen). 6. Make-File in das Projektverzeichnis kopieren (im Unterverzeichnis sample einer WinAVR Installa- tion findet man eine sehr brauchbare Vorlage). Make-File ggf. anpassen. Bei WINAVR gibt es auch das nützliche Tool Mfile.

( Fessler Joachim & Feucht Achim)

3.5.1 RN –CONTROL-Board oder andere Hardware Es besteht auch die Möglichkeit zur Programmierung eines ATMega-Controller die ISP-Schnittstelle zu verwenden. Diese kann über ein Programmierdongel an den Parallel-Port des PC´s angeschlossen werden. Hierbei kann AVR-Studio nicht mehr zum Flashen verwendet werden. Alternativen: • AVRDUDE Bestandteil von WINAVR. Programmierung über Konsole • Pony Prog mit grafischer Oberfläche. Zu finden unter www.lancos.de

Weitere Infos sind zu finden unter http://www.kreatives-chaos.com/index.php?seite=avrgcc ( Fessler Joachim & Feucht Achim)

Abbildung 5 AVR Programmer

http://www.atmel.com/

http://www.lancos.de/

http://www.kreatives-chaos.com/index.php?seite=avrgcc



3.6 Das Programm des ATtiny26L

3.6.1 C Programm //************************************************************************************ //einbinden der Bibliotheken //************************************************************************************ #include <io.h> #define F_CPU 1000000UL #include <util/delay.h> #include <stdint.h> //************************************************************************************ //Definition der Variablen //************************************************************************************ uint16_t x = 0; //Analogwert zur Berechnung der Motoren PWM (Wert der Analog Digital-wandlung, halbiert) uint16_t y = 0; //Analogwert zur Berechnung der Motoren PWM (Spiegelung das ADC Werts) uint16_t r = 0; //Analogwert zur Berechnung der Motoren PWM (Motor rechts) uint16_t l = 0; //Analogwert zur Berechnung der Motoren PWM (Motor links) #define Motor_links OCR1A //OCR1A heißt jetzt Motor_links #define Motor_rechts OCR1B //OCR1B heißt jetzt Motor_rechts

Abbildung 6 Korsel mit Programmer



//************************************************************************************ //IO-Ports initialisieren //************************************************************************************ void init_io(void) { //Motor links DDRB = 0xFF; //Port B als Ausgang PORTB &= ~(1 << PB1); //PB1 auf low //Motor rechts PORTB &= ~(1 << PB3); //PB5 auf low PORTB |= (1 << PB6); //PB6 auf high PORTA |= (1 << PA2); //PA7 als Eingang mit Pull-up (Taster) PORTA |= (1 << PA7); //PA7 als Eingang mit Pull-up (Reflektionslichtschranke) DDRA &= ~(1 << PA2); //PA7 als Eingang (Taster) DDRA &= ~(1 << PA7); //PA7 als Eingang (Reflektionslichtschranke) DDRA |=(1 << PA6); //PA6 als Ausgang (LED) PORTA &= ~(1 << PA6); //PA6 auf low (LED) } //************************************************************************************ //Einstellen der ADC Wandlung //************************************************************************************ void ADC_Init(void) { //Einstellen des AD Wandlers ADMUX = 0b00000110; //Verwenden der internen Referenzspannung Datenblatt S.8 //und Einstellen des ADC´s 6 Port 7 ADCSR = 0b11100110; //Einstellen des Freilaufs und Aktivierung des ADC´s

//Freilauf bedeutet ununterbrochene Konvertierung (muss nicht extra gestartet werden)

} //************************************************************************************ //PWM initialisieren //************************************************************************************ void pwm (void) {

DDRB |= (1<<PB1); // Einstellen welcher Ausgang über PWM angesteuert werden soll

DDRB |= (1<<PB3); // Einstellen welcher Ausgang über PWM angesteuert werden soll

TCCR1A = 0b01010011; // Einstellen der PWM A und B mit Modusauswahl TCCR1B = 0b00000011; // Teiler von 4 einstellen jetzt (CK/4) OCR1C = 255; // oberstes PWM Limit setzen (wichtig beim ATtiny 26) OCR1B = 200; OCR1A = 200; PLLCSR = (1<<PLLE); // Asynchrones PLL benutzen, 64MHz Taktquelle }



1.6.1.1 Hauptprogramm (MAIN) //************************* MAIN ************************* int main (void) { init_io(); //IOs Konfigurieren ADC_Init(); //Analog-Digitalwandler konfigurieren pwm(); //Ausgänge für die Motoren als PWM initialisieren while (1) { // Start der Endlosschleife

x = ADC/2; // der Wert der Analogdigitalwandlung beträgt maximal 1023 (10Bit)(nur ein theoretischer Wert, der nie erreicht wird)

y = 500-x; // Spiegelung des halbierten ADC Wertes

if(x>250){ // wenn die AD-Wandlung einen größeren Wert als 500 liefert, befindet sich der Sensor des Korsels eher auf schwarzem Untergrund

l = 255; // schwarzer Untergrund bedeutet linker Motor volle Leistung (wenn in dem Register OCR1A 255 steht, findet keine PWM mehr statt) r = 20+y; // rechter Motor drosseln (20 ist ein Offset um den

Motor ruhiger laufen zu lassen) }

if(x<250){ // wenn die AD-Wandlung einen kleineren Wert als 500 liefert, befindet sich der Sensor des Korsels eher auf weißem Untergrund

r = 255; //rechter Motor volle Leistung l = 20+x; //linker Motor drosseln (20 ist ein Offset um den

Motor ruhiger laufen zu lassen) } if ((r>255) ) {

r=255; //die PWM der Motoren darf keinen größeren Wert als 255 (8Bit)bekommen

} if ((l>255) ) {

l=255; //die PWM der Motoren darf keinen größeren Wert als 255 (8Bit)bekommen

} if ((r<0) ) {

r=0; //die PWM der Motoren darf keinen kleineren wert als 0 bekommen

} if ((l<0) ) {

l=0; //die PWM der Motoren darf keinen kleineren wert als 0 bekommen

}

Motor_links = l/10*5; //da auf dem ATtiny nur einfache Programme zum Einsatz kommen können, müssen wir hier die Motoren noch einmal etwas ver-langsamen

Motor_rechts = r/10*5; }//Ende der Endlosschleife return (0); }



3.7 Konfiguration der Ein- und Ausgänge Ein ausführliches Tutoriell finden sie auf der Seite http://www.mikrocontroller.net/articles/AVR-GCC-

Tutorial#Zugriff_auf_IO-Ports

Grundsätzlich ist es so, dass ein Mikrocontroller erst einmal wissen muss, ob seine Pins Eingänge

oder Ausgänge sind. Dafür sind die Register DDRX da. In diesem Programm werden beispielsweise

alle Bits des Registers DDRB auf 1 gesetzt. Um dies zu erreichen gibt es mehrere Möglichkeiten. Hier

wird eine hex Zahl in das Registers geschrieben (DDRB = 0xFF).

Eine andere Möglichkeit ist einzelne Bits einzustellen. Auch dies wurde in diesem C – Programm ge-

macht. Möchte man beispielsweise den Ausgang PB1 auf Low setzen, so kann man dafür folgenden

Befehl benutzen:

Der gesamte Befehl lautet daher: Schiebe eine 1 um eins nach links, negiere diese 1, mache eine Bit-

weise und Verknüpfung mit PORTB, schreibe das Ergebnis in PORTB. An der Stelle 1 des Registers

PORTB wurde jetzt eine 0 geschrieben. Die anderen Bits des Registers PORTB wurden nicht verän-

dert.

Ähnlich kann man es auch machen, wenn man eine 1 in das Register schreiben will. Dies würde dann

so aussehen: PORTB |= (1 << PB1). Mit diesem Befehl kann man an die Stelle von PB1 eine 1 in das

Register PORTB schreiben. Diese Schreibweisen bedeutet zwar einen etwas höheren Arbeitsaufwand,

aber auch mehr Transparenz und Übersichtlichkeit.

PORTB &= ~(1 << PB1);

PB1 = 1 (wir könnten statt PB1 auch eine 1 schreiben,

für den Compiler ist das gleichbedeutend)

Das ist ein Schiebebefehl, d.h. schiebe eine 1 um eins nach links

Negation

Bitweise UND Verknüpfung

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports



3.8 Konfiguration der Analog-Digital-Wandlung (AD Wandler)

Abbildung 7 AD-Wandler Funktion

(Wirth, 2011)

Die grundlegende Funktion des AD-Wandlers ist, zu einem bestimmten Zeitpunkt (Ta) einen be-

stimmten Wert der analogen Messgröße einem Binärwert zuzuordnen - wie in Abbildung 5 ersicht-

lich. Bei diesem ATtiny 26 kann man die Abtastzeit (Ta) verändern, indem man das Register ADCSR

verändert. An sich ist ein schnelles Abtasten immer besser, aber es kostet Rechenzeit und man muss

mit den konvertierten Werten auch etwas anfangen können. Der ATtiny 26 besitzt einen echten AD

Wandler, der auf verschiedene Eingänge geschaltet werden kann.

Grundlegende Formel zum Berechnen des ADC Wertes:

Unsere Schaltung hat also eine Auflösung von

, was mehr als ausreichend ist.

3.8.1 Die Einstellung des Registers ADMUX = 0b00000110

(ATMEL, Datenblatt ATtiny26)

00 = an der Stelle 7 und 6 (REFS1, REFS0) steht eine 00. Hiermit kann man die Vergleichsquelle

einstellen, hier wurde als Referenzspannung AVCC gewählt. Um einen genaueren Wert zu bekom-

men, muss an diesen Pin ein 100nF-Kondensator angeschlossen werden. AVCC ist an 5 V ange-

schlossen, das ist jetzt unsere Obergrenze, d.h. 5 V = 1024 (10Bit Konvertierung).

0 = an der Stelle 5 (ADLAR) ist eine 0. Das bedeutet, das lsb ist bei dem Register ADC (im ADC-

Register steht das Ergebnis der AD-Umwandlung) auf der rechten Seite.



00110 = an den Stellen 0,1,2,3 und 4 (MUX0 bis MUX4) ist eine 00110. Hier kann man den zu konver-

tierenden Eingang festlegen. In diesem Programm ist das der Eingang ADC 6 (PA7)

3.8.2 Die Einstellung des Registers ADCSR

=0b11100001

(ATMEL, Datenblatt ATtiny26)

1 = an der Stelle 7 (ADEN) steht eine 1. Hiermit aktiviert man den AD-Wandler.

1 = an der Stelle 6 (ADSC) steht eine 1. Da dieser AD-Wandler im „Free running Mode“ laufen gelassen wird,

muss hier eine 1 stehen um die erste Konvertierung zu starten.

1 = an der Stelle 5 (ADFR) steht eine 1. Hier wird der „Free running Mode“ eingestellt.

0 = an der Stelle 4 (ADIF) steht eine 0. Hier könnte man Interrupts abfragen, immer wenn eine Konvertierung

vollständig ist wird ADIF auf 1 gesetzt (in unserem Programm ohne Bedeutung).

0 = an der Stelle 3 (ADIE) steht eine 0. Hier könnte man die Interrupt-Funktion einschalten.

001 = an den Stellen 0,1,2 (ADPS2, ADPS1, ADPS0) steht eine 001. Hiermit könnte man die Geschwindigkeit des

AD-Wandlers einstellen. Hier ist ein Teiler von 2 eingestellt, d.h.

Mit diesen Einstellungen hat man jetzt einen AD-Wandler der ununterbrochen die Spannung am Pin PA7 mit 5 V vergleicht und daraus eine Zahl zwischen 0 und 1024 generiert. Dieses Ergebnis wird in die Register ADCH und ADCL geschrieben. Man kann diese beiden Register auch mit ADC auslesen, da das Register ADC, ADCH und ADCL also 16 Bit enthält.

3.9 Konfiguration der Puls Weitenmodulation der Motoren

Im folgenden Abschnitt wird die grundsätzliche Funktionsweise der PWM von der I-Net Seite Robo-netz beschrieben: “Die Pulsweitenmodulation (oft mit PWM abgekürzt) wird vornehmlich zum Ansteu-ern größerer Lasten, wie z.B. Motoren verwendet. Mikrocontroller haben daher oft bereits spezielle PWM-Ausgänge integriert. Bei der Pulsweitenmodulation werden Impulse mit voller Spannung aber variabler Breite an die Last gesendet. Ein Rechtecksignal mit konstanter Frequenz wird also mit einem bestimmten Tastverhältnis moduliert. Eine PWM ist also charakterisiert durch ihre Frequenz und

ihr Tastverhältnis (duty cycle).

Vorteil dieser Ansteuerung ist, dass weniger Leistung verbraucht wird, da nicht permanent eine Ein-

gangsspannung anliegt, die von einer Elektronik auf die gewünschte Motorspannung heruntergeregelt

wird, sondern der Motor durch die Breite der Schaltimpulse gesteuert wird.

http://www.rn-wissen.de/index.php/Microcontroller



Diese drei Skizzen demonstrieren, wie ein Motor mit unterschiedlicher Pulsweite in drei verschiedenen

Geschwindigkeiten geregelt wird. In der Praxis ist die Pulsweite oft in 255 Schritten (8 Bit) und mehr

regelbar. Gut zu erkennen ist in der Skizze, dass die eigentliche Grundfrequenz bei der Pulsweiten-

modulation nicht verändert wird, sondern lediglich das Verhältnis der Ein- und Ausschaltzeit pro Welle

(Ton und Toff). Die Modulationsfrequenz kann dabei variieren.

“ (RoboterNETZ, 2012)

Der ATtiny 26 kann über die Timer (Timer_Counter_0 und Timer_Counter_1) zwei interne PWM-

Signale erzeugen. Von Atmel wird empfohlen, auch diese beiden Timer für die Erzeugung eines

PWM-Signals zu nutzen (ein PWM Signal kann auch an jedem anderen Ausgang über ein entspre-

chendes Programm realisiert werden). Man verwendet den Timer_Counter_1. Um ein PWM-Signal

erzeugen zu lassen, muss man als erstes die Register TCCR1A und TCCR1B einstellen. In den bei-

den Registern wird die Arbeitsweise des Timers festgelegt.



3.9.1 Die Einstellung des Registers TCCR1A

= 0b01010011;

(ATMEL)

0b = die Abkürzung steht für eine binäre Zahlenfolge

01 = an der Stelle 7 und 6 (COM1A1, COM1A0) steht eine 01. Dies bedeutet, er soll bei dem

Registerwert von OC1A schalten.

01 = an der Stelle 5 und 4 (COM1B1, COM1B0) steht eine 01. Dies bedeutet, er soll bei dem

Registerwert von OC1B schalten.

00 = an der Stelle 3 und 2 (FOC1A, FOC1B) steht eine 00. Durch das Einstellen auf den

PWM-Modus haben diese beiden Nullen keine Bedeutung.

11 = an der Stelle 1 und 0 (PWM1A, PWM1B) steht eine 11. Hier wird die PWM des

Timers1 A und B eingeschaltet.

3.9.2 Die Einstellungen des Registers TCCR1B

= 0b00000011

(ATMEL)

0 = an der Stelle 7 (CTC1) steht eine 0. Dies bedeutet, dass der Timer beim Vergleich von OCR1A

und OCR1B mit OCR1C nicht auf 0 zurückgesetzt wird.

0 = an der Stelle 6 (PSR1) steht eine 0. Hier kann man den Teiler des Timers zurücksetzen wenn man

eine 1 in das Register schreibt – hier im PWM-Modus ohne Effekt.

0011 = an den Stellen 0,1,2 und 3 (CS10, CS11, CS12, CS13) kann man den Teiler der PWM

einstellen, d.h. CK / Teiler = Frequenz der PWM. Hier wurde ein Teiler von 4 eingestellt,

dadurch erhält man eine PWM mit einer Frequenz von 2 kHz.

Die richtige Auswahl der PWM -Frequenz hängt maßgeblich vom verwendeten Motor ab. Der Vorteil

einer hohen Frequenz, ca. 15 kHz bis 18 kHz, ist ein ruhiger (glatter) Lauf der Motoren. Außerdem ist

man schon fast im nicht mehr hörbaren Bereich (menschliches Gehör maximal bis 20 kHz). Der Motor

kommt dem Menschen leiser vor. Die Nachteile von hohen Frequenzen sind höhere Schaltverluste in

den Bauteilen, höhere Ummagnetisierungsverluste in den Motoren sowie mehr Störungen auf der

Platine. Da man hier sehr günstige Motoren verwenden, die sowieso schon Störungen auf andere

Bauteile einkoppeln, möchte man keine derart hohen Frequenzen. Auch ist die etwas größere Geräu-

schentwicklung bei den „kleinen“ Motoren vernachlässigbar. Bei diesem Korsel ist eine PWM-

Frequenz von 0,5 kHz bis 5 kHz zielführend.



3.9.3 Die Register OCR1A und OCR1B Der Wert der Register OCR1A und OCR1B beeinflusst die Pulslänge der PWM:

Abbildung 8 PWM Register OCR1A

Abbildung 9 PWM Register OCR1B

Wie man an den Grafiken (Abb. 8,9) erkennen kann, kann man durch Erhöhen der Registerwerte

OCR1A und OCR1B die Einschaltdauer erhöhen und dadurch den Mittelwert der Spannung ebenfalls

erhöhen.



3.10 Vor- und Nachteile eines Korsels mit einer Reflektionslichtschranke

und einem ATtiny26L

Vorteile:

- Einfacher und robuster Aufbau

- Geringe motorische Fähigkeiten beim Löten erforderlich

- Geringe Anzahl an verschiedenen Bauelementen

- Einfach zu programmieren

- Geringe Gesamtkosten des Projekts (ohne Programmer ca. 20€ pro Korsel)

- Lange Laufzeit 2,5 h (Akku mit 8,4 V und 200 mA)

- Klein, leicht und wendig

- Durch das sehr kleine und einfache Programm braucht der ATtiny26 nur 0,5ms

um das gesamte Programm einmal abzuarbeiten

- Die PWM arbeitet mit einer Frequenz von 2 kHz (damit ist es zwar im hörbaren Be-

reich, aber sie koppelt nicht so viele Störungen ein wie eine schnellere PWM), d.h. er

ist robuster

Nachteile:

- Da der interne Speicher recht klein ist, ist es nicht möglich größere Programme laufen

zu lassen

- Wegen des begrenzten Speichers ist es nicht möglich einen Differential-Regler zu im-

plementieren und dadurch den I-Anteil des Systems zu kompensieren

- Da der ATtiny keine JATAG-Schnittstelle besitzt, ist ein on-chip-Debugging nicht mög-

lich (kein Auslesen der Sensorenwerte, d.h. keine exakten Berechnungen möglich)

- Mit nur einer Reflektionslichtschranke sind nur kleine Regelabweichungen erkennbar

- Die Spannung der günstigen Akkumulatoren schwankt stark (je nach Ladezustand),

deshalb schwankt auch die Motorleistung stark. Eine Lösung ist das Schreiben eines

Programmes, welches die Spannungsschwankungen der Batterie kompensiert. Leider

hat der ATtiny dafür zu wenig Speicher. Auch die Rechenzeit würde sich durch eine

zusätzliche AD-Wandlung erhöhen

- Zusätzliche Schiebeschalter, mit denen man z. B. verschiedene Programme abrufen

kann, sind auch nicht möglich oder sinnvoll (zu geringer Speicher)

Fazit: Der Korsel mit einem ATtiny 26 ist sehr gut für Schüler geeignet, stößt aber schnell an seine

Grenzen. Deshalb hat man sich hier dazu entschieden einen weiteren Korsel zu bauen - dieser sollte

mehr Schnittstellen haben (ISP, UART, JTAG). Mit JTAG kann auch ein Debugging realisiert werden.

Außerdem sollte er mehr Sensoren bekommen und auch einige Schiebeschaler enthalten.

Der Korsel mit einem ATtiny26 ist bereits im Stande einer Linie zu folgen. Allerdings ist seine Ge-

schwindigkeit nicht sehr hoch, sobald die Geschwindigkeit erhöht wir hat er Probleme seiner Bahn zu

folgen, das soll auch eines der Ziele für den nächsten Korsel darstellen.



4. Der Korsel mit einem ATmega32 und drei Reflektionslichtschran-

ken

ISP-Schnittstelle

JATAG-Schnittstelle

UART-Schnittstelle

LED´s um verschiedene

Zustände anzuzeigen

Taster (für folgende

Erweiterungen)

Schiebeschalter (Abruf von

verschiedenen Program-

men)

ATmega 32

LED um den Status (ein/aus) anzuzeigen



4.1 Benötigte Bauteile und Kosten ATmega32

Anzahl Name Bezeichnung Bestellnummer und Liferant Kosten

2 Motor IGARASHI DC Kleinstmotor 2025-02 Conrad Bestell-Nr.: 244414 - V3 3,45 €

1 H - Brücke 4-Ch-Driver mit Diode, SO-20 SMD Reichelt L 293 DD 2,75 €

1 Micro-Controller ATmega32 Reichelt ATMEGA32-16PU 3,90 €

2 Taster Typ Kurzhubtaster Reichelt Bestell-Nr: TASTER 3301 0,11 €

3 Reflektionslichtschranke Typ CNY 70 Reichelt Bestell-Nr: CNY 70 0,70 €

1 Diode Typ 4148 Reichelt Bestell-Nr: SMD 1N 4148 0,02 €

1 Batterieclip Batterieclip für 9-Volt-Block Reichelt Bestell-Nr: CLIP HQ9V-T 0,24 €

1 Spannungsregler

Schaltregler ST Microelectronics L 78 L

05 Conrad Bestell-Nr.: 156058-62

0,23 €

1 Schalter Dip-Schalter, stehend, 4-polig Reichelt NT 04 0,24 €

1 Schalter Schiebeschalter 1 x Ein/Ein 50 V 0,5 A Conrad Best.-Nr.: 708054 - 62 0,49 €






2 Kondensatoren Baugröße 1206 SMD 100uF 0,45 €

1 Entstörkondensatoren AX 100/16 100uF 16V Reichelt B36-630 0,15 €

1 Entstörkondensatoren AX 220/16 220uF 16V Reichelt B36-541 0,16 €

3 LED LED 5mm Reichelt Artikel-Nr.: LED 5MM GN 0,06 €

1 Stiftleiste Stiftleisten 2,54 mm, 2X02, gerade Reichelt MPE 087-2-004 0,10 €

1 9V Block energy Alkaline 9 V Block-Batterie Conrad Best.-Nr.: 658014 - 62 3,50 €

4 Messpunkte Lötnägel 1mm, versilbert Reihelt RTM 1-100 0,01 €

0,25 Grundplatine

Bungard Platinen-Basismaterial Cu-

Auflage Conrad Best.-Nr.: 523798 - 62

5,19 €

4 Reifen

O-Ring: Innendurchmesser 20mm Dicke:

2mm

2 Räder Kugellager

BB-608-A500-10-ES (Kunststofflager

von IGUS)

1 Achse z.B. 8mm-Alu-Rohr aus dem Baumarkt

4

Isolierte Drähte für den

Anschluss der Motoren

Gesamt: 24,32 €

http://www.reichelt.de/Atmel-Attiny-AVRs/ATTINY-26L8-SO20/3/index.html?;ACTION=3;LA=446;ARTICLE=45904;GROUPID=2958;artnr=ATTINY+26L8+SO20;SID=13T-2B8n8AAAIAACmttgQ7a9c7f8f0e69334420fa8949785ce306



4.2 Schaltplan Korsel mit ATmega32



4.3 Platine des Korsels mit ATmega32



4.4 Programmieren mit einem JTAGICE mkII Programmer Der AVR JATAGICE mkII Programmer kostet ca. 300 €

und ist damit ca. 6 mal so teuer wie der ISP Programmer

von AVR. Diese Kosten sind allerdings gerechtfertigt - mit

ihm hat man die Option direkt in den Microcontroller hineinzu-

schauen. Man kann den Mikrocontroller anhalten und alle

Variablen auslesen und hat dadurch die Möglichkeit ein

umfangreiches Debugging durchzuführen. Dazu benötigt der

Mikrocontroller allerdings auch eine JTAG-Schnittstelle.

Einen JTAG-Anschluss haben z. B.

ATmega128, 64, 323, 32, 16, 162 und noch viele weitere.

Auch kann man breakpionts setzen und dadurch gezielt

bestimmte Teile eines Programms beobachten.

Mit diesem schon bekannten AVR-Studio mit WINAVR kann man auch über den JTAG-

Programmer programmieren. Zusätzlich kann man Debugging betreiben und dadurch Entwicklungs-

zeit sparen.

Abbildung 10 JTAGICE mkII

JTAGICE mkII Programmer

JATG-Schnittstelle

USB-Anschluss (reicht um zu programmieren und zu debuggen)

Abbildung 11 JTAG Programmiergerät



4.4.1 Einstellungen im AVR-Studio um mit JTAGICE zu debuggen

Als erstes kann man über Debug -> Select Platform and Device… unseren JTAG-Programmer und den Mikrocontroller auswählen.

Standardmäßig ist der AVR-Simulator ausgewählt, dieser führt eine Simulation durch, liefert aber nicht die echten Werte des Mikrocontrollers.

Abbildung 13 JTAG platform

Abbildung 12 Debug



Als nächstes kann man den Compiler richtig einstellen - das können wir über Project -> Konfiguration Options machen.

Zur Auswahl gibt es im AVR-Studio 4 Optimierungsstufen und zwar –O0, -O1, -O2, -O3, -Os. Die Stufe Os ist standardmäßig eingestellt. Der Compiler berücksichtigt hierbei den Aufbau des ver-wendeten Mikrocontrollers und erstellt danach ein darauf optimiertes Programm. Die Optimierungsstu-fe löscht hierbei alle Befehle, die nicht mit einem Ein- oder Ausgang direkt oder indirekt zusammen-hängen und kann dadurch ein Programm erstellen das ca. 5 mal kleiner ist als ein Programm ohne Optimierungsstufe. Leider kann man diese Optimierungsstufe für den Debugmodus nicht benützen, da der Debugger die Variablen nicht mehr findet und immer eine 0 anzeigt. Man muss die Einstellung –O0 verwenden. Der Compiler übersetzt das C-Programm jetzt quasi 1 zu 1.

Abbildung 15 Compiler Optimierung

Abbildung 14 Configuration Options



Nach diesen Einstellungen können wir den Mikrocontroller flaschen. Beim ISP-Programmer hat man

dies durchgeführt, indem man das .hex File auf den Mikrocontroller geladen hat. Meistens funktio-

niert das beim JTAG-Programmer auch. Manchmal zeigt er aber mit dem .hex File nicht alle Variablen

an. ATMEL sagt deshalb, dass es besser ist das .elf File zu flaschen - es enthält mehr Informationen

über die Variablen.

Wenn man das Programm auf den Mikrocontroller geschrieben hat, schließt man das Fenster und

kann über den Play( ) Button das Debugging starten. Im jetzigen Zustand ist der Mikrocontroller

gestoppt. Man kann ihn über den Run( )Button starten. Wenn man jetzt den Pause( ) Button

betätigt, kann man die Variablen anzeigen lassen.

Abbildung 17 Variablen

Abbildung 16 .elf File



4.5 Die Fuses des Mikrocontrollers Über die Fuses kann man die Geschwindigkeit des Mikrocontrollers einstellen. Aber Achtung, stellt

man auf einen externen CK, dann benötigt man auch einen externen CK. Hat man keinen, kann der

Mikrocontroller auch nicht mehr zurückgesetzt werden - d.h. er ist nicht mehr funktionsfähig! Außer-

dem kann man hier JTAGEN ein- und ausschalten. Um neue Einstellungen vorzunehmen, gehen wir

auf den Button „AVR“ und dann auf Fuses. Der Mikrocontroller muss angeschlossen sein. Jetzt auf

„Read“ um den momentanen Zustand abzufragen.

JTAGEN muss aktiviert sein

Einstellen der Prozessor-Geschwindigkeit (int.)

Abbildung 18 Fuses ATmega32



4.6 Das Programm des ATmega 32 mit drei Reflektionslichtschranken

4.6.1 Implementieren der Bibliotheken //**************************Implementieren der Bibliotheken******************* #include <avr/io.h> #define F_CPU 4000000UL #include <stdint.h>

4.6.2 Initialisieren der Variablen //**************************************************************************** //Initialisieren der Variablen //**************************************************************************** int Sensor_rechts_1 = 0; // Analogwert int Sensor_mitte_2 = 0; // Analogwert int Sensor_links_3 = 0; // Analogwert int Sensoren = 0; // Analogwert int Batterie_Spannung = 0; // Berechnet über einen Spannungsteiler die

Batteriespannung int Batterie_PWM1 = 0; // Wird vom PWM Signal abgezogen Motor links int Batterie_PWM2 = 0; // Wird vom PWM Signal abgezogen Motor rechts int motorr = 0; // Endgültiger Wert der auf Motor_rechts geschrieben

wird int motorl = 0; // Endgültiger Wert der auf Motor_links geschrieben

wird int x = 0; // Motor PWM Berechnung int y = 0; // Motor PWM Berechnung int r = 0; // Motor PWM Berechnung int l = 0; // Motor PWM Berechnung int KP = 0; // Proportionaler Wert der Regelung (P Anteil) int KI = 0; // Integralwert der Regelung (I Anteil) int KD = 0; // Differentialwert der Regelung (D Anteil) int e = 0; // Regeldifferenz int esum = 0; // auf Summation der Regelabweichung int a = 0; // Regelabweichung int ealt = 0; // Letzter berechneter Wert #define Motor_links OCR1B // OCR1B heißt jetzt Motor_links #define Motor_rechts OCR1A // OCR1A heißt jetzt Motor_rechts



4.6.3 IO-Ports initialisieren //************************************************************************* // IO-Ports initialisieren //************************************************************************* void init_io(void) {

DDRD = 0x00; // Port D als Eingang (hex. Schreibweise geht auch) PORTD = 0xFF; // Port D als pull-up (hex. Schreibweise geht auch) PORTC |= (1 << PC6); // PC6 als Eingang mit pull-up PORTB |= (1 << PB4); // PB4 als Eingang mit pull-up DDRC &= ~(1 << PC6); // PC6 als Eingang DDRB &= ~(1 << PB4); // PB4 als Eingang DDRB |=(1 << PB1); // PB1 als Ausgang DDRB |=(1 << PB2); // PB2 als Ausgang DDRB |=(1 << PB0); // PB0 als Ausgang

DDRA &= ~(1 << PA0); // PA0 als Eingang für AD Messung (ADC0 Spannungs- teiler Batteriespannung)

PORTA |= (1 << PA3); // PA3 als Eingang mit pull-up für AD-Messung (ADC3

Sensor in Fahrtrichtung rechts) DDRA &= ~(1 << PA3); // PA3 als Eingang

PORTA |= (1 << PA4); // PA4 als Eingang mit pull-up für AD-Messung (ADC4, Sensormitte)

DDRA &= ~(1 << PA4); // PA4 als Eingang

PORTA |= (1 << PA5); // PA5 als Eingang mit pull-up für AD-Messung (ADC5, Sensor in Fahrtrichtung links)

DDRA &= ~(1 << PA5); // PA5 als Eingang PORTB &= ~(1 << PB1); // auf low LED ausschalten PORTB &= ~(1 << PB2); // auf low LED ausschalten PORTB |=(1 << PB0); // Sensoren LED´s einschalten //*****************************Ansteuerung H-Brücke*********************************** DDRB |=(1 << PA1); // PA1 als Ausgang DDRB |=(1 << PA2); // PA2 als Ausgang DDRB |=(1 << PA6); // PA6 als Ausgang DDRB |=(1 << PA7); // PA7 als Ausgang PORTA &= ~(1 << PA2); // auf low (für Vorwärtsfahrt als Starteinstellung) PORTA &= ~(1 << PA7); // auf low (für Vorwärtsfahrt als Starteinstellung) PORTA |=(1 << PA1); // auf high (für Vorwärtsfahrt als Starteinstellung) PORTA |=(1 << PA6); // auf high (für Vorwärtsfahrt als Starteinstellung) }



4.6.4 ADC-Wandler initialisieren //************************************************************************************ // ADC-Wandler einstellen //************************************************************************************ void ADC_Init(void) {

ADMUX = 0b01000000; // Verwenden der internen Referenzspannung mit externem Kondensator Datenblatt S.212 // genauer ist eine externe Referenzspannung (ist hier aber nicht so wichtig)

ADCSRA = 0b10000001; // Einstellen der ADC-Wandlung Teilungsfaktor 2

(höchste Geschwindigkeit der AD-Wandlung)

SFIOR = 0b00000000; // Single Conversion mode (führt nur dann eine Konvertierung aus, wenn ADSC auf 1 gesetzt wird)

ADCSRA |=(1 << ADSC); // Starten einer Konvertierung while (!ADCSRA & (1<<ADSC)) {} // auf Abschluss der Konvertierung warten

Sensor_links_3 = ADC; // beim Auslesen von ADC wird das Bit ADSC wieder auf null gesetzt, deshalb hier auslesen um den Wert zu löschen

}

4.6.5 PWM initialisieren //************************************************************************************ // PWM initialisieren //************************************************************************************ void pwm (void) { DDRD |= (1<<PD4); // auf Ausgang setzen für PWM DDRD |= (1<<PD5); // auf Ausgang setzen für PWM PORTD &= ~(1 << PA4); // auf low PORTD &= ~(1 << PA5); // auf low TCCR1A = 0b10100001; // Einstellen der PWM A und B mit Modusauswahl

TCCR1B = 0b00001010; // Teiler von 8 einstellen, zu kleiner Teiler bringt zu viele HF Störungen auf die restliche Elektronik

TCNT1 = 255; // Anfangswert setzten (dort beginnt er beim ersten

Mal zu zählen) OCR1A = 100; // Register für den Vergleichswert (dieses Register wird

später von der eigentlichen Regelung immer überschrieben) OCR1B = 100; // Register für den Vergleichswert (dieses Register wird

später von der eigentlichen Regelung immer überschrieben) }



4.6.6 Hauptprogramm (MAIN) //************************* MAIN ***************************************************** int main (void) { init_io(); // IOs konfigurieren ADC_Init(); // Analog-Digitalwandler konfigurieren pwm(); // PWM initialisieren while (1) // Start Endlosschleife {

4.6.6.1 Sensoren auslesen //************************************************************************************ // Sensoren auslesen //************************************************************************************ //*********************** Sensor 1 *************************************************** while (ADMUX !=67) { // Abfrage auf port ADC3 ADMUX = 0b01000011; // Warten bis ADMUX eingerastet ist } ADCSRA |=(1 << ADSC); // Starten einer Konvertierung while (ADCSRA & (1<<ADSC)) {} // auf Abschluss der Konvertierung warten

Sensor_rechts_1 = ADC; // Wert von ADC in den Speicher Sensor_mitte_2 schreiben

//********************** Sensor 2 **************************************************** while (ADMUX!=68) { // Abfrage auf port ADC4 ADMUX = 0b01000100; // Warten bis ADMUX eingerastet ist } ADCSRA |=(1 << ADSC); // Starten einer Konvertierung while (ADCSRA & (1<<ADSC)) {} // auf Abschluss der Konvertierung warten

Sensor_mitte_2 = ADC; // Wert von ADC in den Speicher Sensor_mitte_2 schreiben

//********************* Sensor 3 **************************************************** while (ADMUX !=69) { // Abfrage auf port ADC5 ADMUX = 0b01000101; // Warten bis ADMUX eingerastet ist } ADCSRA |=(1 << ADSC); // Starten einer Konvertierung while (ADCSRA & (1<<ADSC)) {} // auf Abschluss der Konvertierung warten

Sensor_links_3 = ADC; // Wert von ADC in den Speicher Sensor_mitte_2 schreiben

Sensoren = Sensor_rechts_1+Sensor_mitte_2+Sensor_links_3; // Gesamtwert der Sensoren berechnen



if ((Sensoren>3069) ) {

Sensoren=3069; // die Sensorwerte dürfen nie einen größeren Wert als 3069 haben } if ((Sensoren<0) ) { Sensoren=0; // die Sensorwerte dürfen keinen kleineren Wert als 0 haben }

4.6.6.2 An gleich der Batteriespannung //************************************************************************************ // Abfrage der Batteriespannung //************************************************************************************ while (ADMUX !=64) { // Abfrage auf port ADC0 ADMUX = 0b01000000; // Warten bis ADMUX eingerastet ist } ADCSRA |=(1 << ADSC); // Starten einer Konvertierung while (ADCSRA & (1<<ADSC)) {} // auf Abschluss der Konvertierung warten Batterie_Spannung = ADC; // den Wert von ADC in Batteriespannung speichern // Da die Abnahme der Batteriespannung nicht linear ist, ist es einfacher den Verlauf der Batteriespannung über mehrere if-Bedingungen zu realisieren. Die Werte wurden durch Messungen mit verschiedenen Batterien und Motoren ermittelt if(Batterie_Spannung<=585){ //Batterie ist fast leer Batterie_PWM1=0; Batterie_PWM2=0; PORTB |=(1 << PB1); // PB1 auf high = LED an (zeigt an wenn die Batterie fast leer ist) } else{ PORTB &= ~(1 << PB1); // PB1 auf low = LED aus } if((Batterie_Spannung>585)&&(Batterie_Spannung<590)){ Batterie_PWM1=0; Batterie_PWM2=0; } if((Batterie_Spannung>=590)&&(Batterie_Spannung<695)){ Batterie_PWM1=2; Batterie_PWM2=2; } if((Batterie_Spannung>=595)&&(Batterie_Spannung<600)){ Batterie_PWM1=3; Batterie_PWM2=3; } if((Batterie_Spannung>=600)&&(Batterie_Spannung<605)){ Batterie_PWM1=5; Batterie_PWM2=5; } if((Batterie_Spannung>=605)&&(Batterie_Spannung<610)){ Batterie_PWM1=7; Batterie_PWM2=7; } if((Batterie_Spannung>=610)&&(Batterie_Spannung<615)){



Batterie_PWM1=10; Batterie_PWM2=10; } if((Batterie_Spannung>=615)&&(Batterie_Spannung<620)){ Batterie_PWM1=14; Batterie_PWM2=14; } if((Batterie_Spannung>=620)&&(Batterie_Spannung<625)){ Batterie_PWM1=18; Batterie_PWM2=18; } if((Batterie_Spannung>=625)&&(Batterie_Spannung<635)){ Batterie_PWM1=25; Batterie_PWM2=25; } if((Batterie_Spannung>=635)&&(Batterie_Spannung<640)){ Batterie_PWM1=31; Batterie_PWM2=31; } if((Batterie_Spannung>=640)&&(Batterie_Spannung<650)){ Batterie_PWM1=36; Batterie_PWM2=36; } if((Batterie_Spannung>=650)&&(Batterie_Spannung<660)){ Batterie_PWM1=39; Batterie_PWM2=39; } if((Batterie_Spannung>=660)&&(Batterie_Spannung<670)){ Batterie_PWM1=42; Batterie_PWM2=42; } if((Batterie_Spannung>=670)&&(Batterie_Spannung<680)){ Batterie_PWM1=47; Batterie_PWM2=47; } if((Batterie_Spannung>=680)&&(Batterie_Spannung<690)){ Batterie_PWM1=52; Batterie_PWM2=52; } if((Batterie_Spannung>=690)&&(Batterie_Spannung<700)){ Batterie_PWM1=62; Batterie_PWM2=62; } if((Batterie_Spannung>=700)&&(Batterie_Spannung<710)){ Batterie_PWM1=70; Batterie_PWM2=70; } if((Batterie_Spannung>=710)&&(Batterie_Spannung<720)){ Batterie_PWM1=75; Batterie_PWM2=75; } if((Batterie_Spannung>=720)&&(Batterie_Spannung<730)){ Batterie_PWM1=81; Batterie_PWM2=81; } if((Batterie_Spannung>=730)&&(Batterie_Spannung<740)){ Batterie_PWM1=85; Batterie_PWM2=85; } if((Batterie_Spannung>=740)){ Batterie_PWM1=90; Batterie_PWM2=90; }



4.6.6.3 Einstellen des Differentialanteils //************************************Einstellen des D-Anteils************************ if ((PIND & 0b11001000) == 0b11001000) { // wenn (PDIND3 = 1 und PIND6 = 1 und PIND7 = 1) dann gehe in if KD=0; } if ((PIND & 0b11001000) == 0b11000000) { // wenn (PDIND3 = 0 und PIND6 = 1 und PIND7 = 1) dann gehe in if KD=30; } if ((PIND & 0b11001000) == 0b01001000) { // wenn (PDIND3 = 1 und PIND6 = 1 und PIND7 = 0) dann gehe in if KD=60; } if ((PIND & 0b11001000) == 0b01000000) { // wenn (PDIND3 = 0 und PIND6 = 1 und PIND7 = 0) dann gehe in if KD=90; } if ((PIND & 0b11001000) == 0b10001000) { // wenn (PDIND3 = 1 und PIND6 = 0 und PIND7 = 1) dann gehe in if KD=120; } if ((PIND & 0b11001000) == 0b10000000) { // wenn (PDIND3 = 0 und PIND6 = 0 und PIND7 = 1) dann gehe in if KD=150; } if ((PIND & 0b11001000) == 0b00001000) { // wenn (PDIND3 = 1 und PIND6 = 0 und PIND7 = 0) dann gehe in if KD=180; } if ((PIND & 0b11001000) == 0b00000000) { // wenn (PDIND3 = 0 und PIND6 = 0 und PIND7 = 0) dann gehe in if KD=250; } // Mit dem Schiebeschalter an PIND kann man jetzt den Wert von KD verändern

4.6.6.4 Der PID Regler //******************************Regler mit PID**************************************** KP = 2; KI = 0; // Die Strecke an sich hat bereits einen I-Anteil, d.h. mit zusätzlichem I ist sie instabil, KD wird über die Schiebeschalter eingestellt x = Sensoren; y = 3000-x; // x+y=3000 d.h. wenn x kleiner wird, wird y größer, wir benötigen x und y für die Fahrt nach rechts und nach links if(x>1500){ // Korsel Bewegung nach rechts (hier y) l = 255; // Linker Motor volle Leistung e = 1500-y; // Regeldifferenz esum = esum + e; // Integration I-Anteil a=(KP*e)+(KI*1*esum)+((KD/1)*(e-ealt)); //Regler ealt = e; // Differential D-Anteil



r=255-(a/6); // Berechnen der Motor-PWM des rechten Motors } if(r<0){ PORTA &= ~(1 << PA1); // auf high (für Rückwärtsfahrt) Motor rechts PORTA |=(1 << PA2); // auf low (für Rückwärtsfahrt) Motor rechts PORTB |=(1 << PB2); // PA6 auf high = LED an r=r*(-1); // PWM kann nur positive Werte verarbeiten } else{ PORTA &= ~(1 << PA2); // auf low (für Vorwärtsfahrt) Motor rechts PORTA |=(1 << PA1); // auf high (für Vorwärtsfahrt) Motor rechts PORTB &= ~(1 << PB2); // PA6 auf low = LED aus } if(x<=1500){ // Korsel Bewegung nach links (hier x) r = 255; // Motor rechts volle Leistung e = 1500-x; // Regeldifferenz esum = esum + e; // Integration I-Anteil a=(KP*e)+(KI*1*esum)+((KD/1)*(e-ealt)); //Regler ealt = e; // Differential D-Anteil l=255-(a/6); // Berechnen der Motor-PWM des linken Motors } if(l<0){ PORTA &= ~(1 << PA6); // auf high (für Rückwärtsfahrt) Motor links PORTA |=(1 << PA7); // auf low (für Rückwärtsfahrt) Motor links PORTB |=(1 << PB2); // PA6 auf high = LED an l = l * (-1); // PWM kann nur positive Werte verarbeiten } else{ PORTA &= ~(1 << PA7); // auf low (für Vorwärtsfahrt) Motor links PORTA |=(1 << PA6); // auf high (für Vorwärtsfahrt) Motor links PORTB &= ~(1 << PB2); // PA6 auf low = LED aus } if ((r>255) ) { r=255; // die PWM der Motoren darf keinen größeren Wert als 255 bekommen } if ((l>255) ) { l=255; // die PWM der Motoren darf keinen größeren Wert als 255 bekommen



} if(PIND & (1 << PIND2)){ // mit Einbeziehung der Batteriespannung

Schiebeschalter 1 eingeschaltet motorl = l-Batterie_PWM1; motorr = r-Batterie_PWM2; } else{ // hier fährt der Korsel immer mit voller Leistung (ohne eine Abschwächung durch die Batteriespannung) motorl = l; motorr = r; } if ((motorr<0) ) { motorr=0; // die PWM der Motoren darf keinen kleineren Wert als 0 bekommen } if ((motorl<0) ) { motorl=0; // die PWM der Motoren darf keinen kleineren Wert als 0 bekommen } Motor_links = motorl; // hier wird der endgültige Wert der PWM in das Register OCR1B geschrieben Motor_rechts = motorr; // hier wird der endgültige Wert der PWM in das Register OCR1A geschrieben }// while_ende return (0); }



4.7 Die Sensoren des Korsels Hier wird eine Reflektionslichtschranke (CNY70) mit einem Transistorausgang verwendet.

Funktionsweise:

Abbildung 19 Funktionsweise Sensor (VISHAY)

Eine LED strahlt infrarotes Licht aus. Je nach der Farbe des bestrahlten Mediums wird mehr (weiß)

oder weniger (schwarz) reflektiert. Dadurch schaltet der Transistor mehr oder weniger durch und man

kann diese Spannung mit unserem AD-Wandler messen.

Abbildung 20 Sensoren Kegel LED

In der Abbildung „Sensoren Kegel LED“ ist die Streuung des infraroten Lichts erkennbar. Dieses Licht

ist für das menschliche Auge nicht sichtbar, wir können es aber mit Hilfe einer Digitalkamera sichtbar

machen.



Der Abstand der Sensoren zum Untergrund beträgt 3,5 mm.

Abbildung 21 Abstand Sensoren

Man hat also einen Kollektorstrom von ca. 2,8 mA (dieser Wert an sich bringt keine große Aussage,

da es immer noch sehr auf das bestrahlte Medium ankommt, aber man weiß, dass der Sensor in die-

sem Bereich gut arbeiten kann).

Der Abstand zwischen den Sensoren beträgt 9 mm.

Abbildung 23 Abstand Sensoren zueinander

3,5 mm links und rechts der Sensoren beginnen die Sensoren mit dem Erkennen eines

schwarzen / weißen Untergrunds, ca. 2 mm also 9 mm-(2*3,5 mm) ist eine tote Zone - in diesem

Bereich erkennt der Korsel keine Änderungen.

Abbildung 22 CNY 70 (VISHAY)



4.7.1 Grundlegende Funktionsweise unsere Sensoren Auf weißem Untergrund wird der Transistor durchgesteuert und zieht den Eingang (pull-up) des Mikro-

controllers von 5 V auf ca. 0,2 V herunter. Unsere Analog- / Digitalwandlung liefert daher einen Wert

von

. Kommt man mit dem Sensor auf schwarzen Untergrund, wird der Transistor nur

sehr gering durchgesteuert und die Spannung geht auf ca. 4,5 V. Über die Analog- / Digitalwandlung

erhält man einen Wert von

. Dies sind nur sehr ungenaue Werte, da die verwendeten

Reflektionslichtschranken eine große Fertigungstoleranz haben (hat auf diese Steuerung keine große

Einwirkung).

Über das Programm des Mikrocontrollers werden die Werte der drei Reflektionslichtschranken zu-

sammenaddiert und man erhält einen Wert von ca. 3000 für schwarzen Untergrund und ca. 160 für

weißen Untergrund. Mit den drei Reflektionslichtschranken hat man über eine Strecke von ca. 43 mm

(was ungefähr der Bahnbreite entspricht) einen relativ kontinuierlichen Wert.



4.8 Einstellungen des Analog-/Digital-Wandlers (ATmega32) Allgemeines zum AD-Wandler siehe Kapitel „Konfiguration der Analog- / Digitalwandlung

(AD Wandler)

Auch der ATmega32 hat einen echten AD-Wandler, den man jetzt in diesem Programm auf die ver-

schiedenen Eingänge (drei Sensoren und Batteriespannungsmessung) schalten muss.

4.8.1 Die Einstellung des Registers ADMUX = 0b01000000

(ATMEL, Datenbalatt ATmega32)

01 = an der Stelle 7 und 6 (REFS1, REFS0) steht eine 01. Hiermit kann man die Vergleichsquelle

einstellen. Hier wurde als Referenzspannung AVCC gewählt. Um einen genaueren Wert zu bekom-

men muss an diesen Pin ein 100nF-Kondensator angeschlossen werden. AVCC ist an 5 V ange-

schlossen, das ist jetzt die Obergrenze, d.h. 5 V = 1024 (10Bit Konvertierung).

0 = an der Stelle 5 (ADLAR) steht eine 0, das bedeutet, dass lsb ist bei dem Register ADC (im ADC

Register steht das Ergebnis der AD-Umwandlung) auf der rechten Seite.

00000 = an den Stellen 0,1,2,3 und 4 (MUX0 bis MUX4) ist eine 00000, hier kann man den zu konver-

tierenden Eingang festlegen. In diesem Programm wird der zu konvertierende Eingang vor jeder AD-

Wandlung neu eingestellt.



4.8.2 Die Einstellung des Registers ADCSRA

= 0b10000001


1 = an der Stelle 7 (ADEN) steht eine 1, hiermit aktivieren wir den AD-Wandler.

0 = an der Stelle 6 (ADSC) steht eine 0. Da der AD-Wandler im „Single Conversion mode“ arbeitet,

kann man ihn starten, indem man hier eine 1 hineinschreibt.

0 = an der Stelle 5 (ADATE) steht eine 0. Hier kann man die Auto Triggerungsfunktion ausschalten.

Indem man eine 0 an diese Stelle schreiben ist sie eingeschaltet.

0 = an der Stelle 4 (ADIF) steht eine 0. Hier kann man Interrupts abfragen. Immer wenn eine Konver-

tierung vollständig ist, wird ADIF auf 1 gesetzt (in diesem Programm ohne Bedeutung).

0 = an der Stelle 3 (ADIE) steht eine 0. Hier kann man die Interrupt-Funktion einschalten. In diesem

Fall ist die Interrupt-Funktion ausgeschaltet.

001 = an den Stellen 0,1,2 (ADPS2, ADPS1, ADPS0) steht eine 001. Hiermit kann man die Ge-

schwindigkeit des AD-Wandlers einstellen. Hier ein Teiler von 2, d.h.

. Hier wur-

de die maximale Geschwindigkeit gewählt, da dieses Programm immer darauf wartet dass eine

Konvertierung abgeschlossen ist. Man würden es also stark verlangsamen wenn man einen höheren

Teilungsfaktor einstellen würde.

4.8. 3 Die Einstellung des Registers SFIOR

= 0b00000000

000 = an den Stellen 7,6,5 (ADTS2, ADTS1,ADTS0) steht eine 000. Hier kann man die Trigger-Quelle

einstellen (hier Free running Mode), in diesem Programm ohne Bedeutung.

00000 = an den Stellen 4,3,2,1,0 (-, ACME, PUD, PSR2, PSR10) steht eine 00000. Diese sind für

dieses Programm ohne Bedeutung, ATMEL empfiehlt aber hier 0 in das Register zu schreiben, damit

das Programm für spätere Mikrocontroller kompatibel bleibt.



Mit dem Einstellen der Register ADMUX (ADC Multiplexer Selection Register), ADCSRA (ADC Control

and Status Register A), SFIOR (Special Function I/O Register) hat man einen AD-Wandler, der jedes

Mal wenn man eine 1 in das Bit ADCS geschrieben habt eine sehr schnelle Konvertierung des analo-

gen Wertes in einen digitalen Wert startet. Außerdem kann man mit ADMUX einen Eingang auswäh-

len, der konvertiert werden soll. Der AD-Wandler vergleicht unseren Wert immer mit 5 V und führt

folgende Rechnung aus: [ ]

4.9 Batterie Spannungs-Berechnung Um einen Wert der Batteriespannung zu erhalten, muss man einen kleinen Trick anwenden. Die Bat-

teriespannung schwankt zwischen 6,5 V und 9,8 V. Der maximal Wert von diesem AD-Wandler ist

aber 5 V. Man benötigt also einen Spannungsteiler.

Abbildung 24 Batteriespannung

Man hat sich für einen gesamten Widerstand von 13,8 kOhm entschieden - der Strom beträgt dann

. Dieser Strom ist groß genug, um Störungen, die durch HF ein Kopplungen ent-

stehen, zu vernachlässigen und klein genug, um die Batterie nicht zusätzlich zu entladen. Auf den 9 V

der Batteriespannung sind durch die Motoren viele Störsignale und es ist für den Mikrocontroller sehr

schwierig eine AD-Wandlung durchzuführen. Der Mikrocontroller benötigt eine kurze Zeit, in der die

Spannung während der AD-Wandlung konstant ist (sampel und hold Schaltung), dafür hat er einen

internen Kondensator. Wenn die Spannung aber zu sehr schwankt, reicht der interne Kondensator

nicht mehr und man muss einen externen dazuschalten, der die Schwankungen etwas glättet. Dies

wurde hier mit dem Kondensator C6 realisiert. Jetzt kann man über die Spannungsteiler-Formel:

die Spannung am Pin6 ausrechnen, z.B. für Ubatt = 9 V, U an Pin6 = 3,65 V.

Unser AD-Wandler berechnet dann einen Wert von

. So kann man dann die Bedingun-

gen für die if-Anweisungen festlegen.



4.10 Einstellungen der PWM (ATmeaga32) Die grundsätzliche Funktionsweise der PWM ist in dem Kapitel „Konfiguration der PWM der Motoren“

nachzulesen.

Bei diesem Mikrocontroller (ATmega32) hat man sich für den 16 Bit Timer/Zähler 1 entschieden. So

wie bereits beim ATtiny26 kann man mit diesem beide PWM-Ausgänge der Motoren ansteuern.

4.10.1 Die Einstellung des Registers TCCR1A

=0b10100001


10 = an den Stellen 7 und 6 (COM1A1, COM1A0) steht eine 10. Diese Einstellung bewirkt, dass die

Ausgänge OC1A/OC1B bei den Werten von den Registern OCR1A/OCR1B auf low geschaltet wer-

den.

10 = an den Stellen 5 und 4 (COM1B1, COM1B0) steht eine 10. Diese Einstellung bewirkt, dass die

Ausgänge am Ende des Zählregisters (255) wieder auf high geschaltet werden.

00 = an den Stellen 3 und 2 (FOC1A, FOC1B) steht eine 00. Diese Bits sind im PWM-Modus ohne

Bedeutung

01 = an den Stellen 1 und 0 (WGM11, WGM10) steht eine 01. Hier kann man einstellen, ob die PWM

mit 8, 9 oder 10 Bit arbeitet. Die Einstellung hier ist 8 Bit. (Für diese PWM sind 255 Schritte mehr als

ausreichend.)



4.10.2 Die Einstellungen des Registers TCCR1B =0b00001010


0 = an der Stelle 7 (ICNC1) steht eine 0. Hier kann man eine Filterung einbauen. Für diesen Modus

ohne Bedeutung.

0 = an der Stelle 6 (ICES1) steht eine 0. Hier kann eingestellt werden, wann der Zähler zählen soll (bei

steigender oder fallender Flanke). Die Einstellung hier zählt bei einer negativen Flanke.

01 = an den Stellen 4 und 3 (WGM13, WGM12) steht eine 01. Hier kann man die Arbeitsweise des

Timers einstellen. Die Einstellung hier ist fast PWM.

010 = an den Stellen 2, 1 und 0 (CS12, CS11, CS10) steht eine 010. Hier kann man den Teilungsfaktor

einstellen, d.h. mit welcher Frequenz die PWM arbeiten soll. Die Einstellung hier hat einen

Teilungsfaktor von 8, d.h.

. Man erhält eine PWM mit einer Frequenz von 0,5 kHz.

Durch diese Einstellungen hat man einen PWM, der kontinuierlich arbeitet. Über die Register OCR1A

und OCR1B kann man die Einschalt- und Pausendauer festlegen.

Die Arbeitsweise der Register OCR1A und OCR1B, sowie die Gründe für die Auswahl der PWM-

Frequenz ist in dem Kapitel „Konfiguration der PWM der Motoren“ nachzulesen.



4.11 Grundlegende Funktion der Bauteile, Korsel mit ATmega32 (drei Sen-

soren) Der ATmega32 ist ein 8bit Microcontroller aus der Atmelreihe. Er hat einen 32k Bytes Flash-Speicher

und was hier sehr wichtig war, eine JTAG-Schnittstelle. Man kann ihn über ISP oder JTAG program-

mieren. Ein Debugging ist mit einem JTAGICE mkII Programmer auch möglich. Um sicher zu arbeiten

benötigt er eine Spannung von 4,5 V bis 5,5 V. Seine maximale Taktfrequenz beträgt 16 MHz. Man

betreibt ihn mit 1 MHz.

Die Energieversorgung wird über einen günstigen Nickel-Metall-Hydrid-Akkumulator mit einer Span-

nung von 8,4 V realisiert.

Dir ATmega32 steuert zwei H-Brücken (L 293 DD, in diesem Bauteil sind beide H-Brücken enthalten),

welche dann die Motoren an- und abschalten. Über die H-Brücke kann man die Motoren vorwärts und

rückwärts laufen lassen sowie bei leichtem Rückwärtslauf auch abbremsen. Die Freilaufdioden sind in

der H-Brücke schon enthalten. Für die Energieversorgung der Motoren wird der 9 V-Block direkt an-

geschlossen. Zur Stabilisierung und Entstörung der Spannung ist ein Kondensator mit 220 uF vorge-

sehen. Zum Entstören ist zusätzlich noch ein 100 nF-Kondensator verbaut.

Die Diode, welche in der Nähe der Anschlussdrähte des Akkumulators angebracht ist, erfüllt zwei

Aufgaben, zum einen den Verpolungsschutz und zum anderen eine Art Sicherung. Der Maximal-

dauerstrom beträgt 150 mA. Bei einem Kurzschluss ist die Diode das Bauelement, welches als erstes

zerstört wird. Da die Diode sehr günstig ist (0,02 €), ist das auch gut so. Auch das Auswechseln der

Diode geht sehr schnell.

Die Spannung für die Reflektionslichtschranken sowie für den Mikrocontroller wird über den L78L05

(Festspannungsregler) bereitgestellt - er liefert eine konstante Ausgangsspannung von 5 V und einen

Strom von 0,1 A. Der Kondensator mit 100 uF und der Kondensator mit 100 nF glätten diese und sor-

gen dafür, dass die Spannung auch beim Einkoppeln von Störsignalen durch die Motoren konstant

bleibt und der Mikrocontroller sicher arbeiten kann.

Am Heck des Korsels ist ein Schalter montiert, mit dem man ihn komplett spannungslos schalten

kann. Eine LED, die links daneben angebracht ist, zeigt an ob der Korsel Spannung hat oder nicht.

Die Kurzhubtaster sind für diverse Abänderungen in der Zukunft gedacht.

Über die Dip-Schalter können wir den Differentialanteil der Regelung einstellen.

Die linke LED zeigt an, wenn der Akkumulator fast leer ist (sie leuchtet dann auf).

Die rechte LED leuchtet wenn einer der Motoren abgebremst wird.



4.12 Vor- und Nachteile eines Korsels mit einem ATmega 32

Nachteile:

- Der Aufbau ist etwas komplizierter (mehr Bauteile), mit etwas Übung jedoch gut

machbar

- Etwas schwieriger zu programmieren

- Etwas höhere Kosten des Projekts (ohne Programmer ca. 25 € pro Korsel)

- Kürzere Laufzeit von ca. 0,5 h (Akku mit 8,4 V und 200 mA)

- Das größere Programm benötigt länger um alle Befehle abzuarbeiten. Ein Programm-

durchlauf benötigt 2,5 ms, mit einer maximalen Geschwindigkeit von 1,2 m/s fährt der

Korsel ca. 3 mm, bevor er die nächste Messung mit Umwandlung und die damit ver-

bundene Änderung der PWM durchführt.

Vorteile:

- Mit dem großen internen Speicher können auch etwas aufwendigere Programme ge-

schrieben werden.

- Mit dem größeren Programmspeicher kann ein Differentialregler implementiert wer-

den, der den Integralanteil kompensiert und dadurch ein genaueres Fahren ermöglicht

- Der ATmega32 ermöglicht mit seiner JTAG-Schnittstelle ein on chip debugging. Da-

her kann man jetzt die Sensorwerte exakt auslesen und die Entwicklungszeit verkürzt

sich stark.

- Mit den drei Reflektionslichtschranken kann man größere Regelabweichungen erken-

nen und dadurch besser regeln

- Die Spannung der günstigen Akkumulatoren schwankt stark (je nach Ladezustand),

deshalb schwankt auch die Motorleistung stark. Eine Lösung ist das Schreiben eines

Programmes, welches die Spannungsschwankungen der Batterie kompensiert. Dies

ist jetzt mit dem ATmega32 möglich und wurde auch realisiert.

- Durch die Mehrzahl an Ein- / Ausgängen kann man zusätzliche DIP-Schalter anbrin-

gen und so bestimmte Programme ein- und ausschalten. In diesem Modell kann der

Differentialanteil verändert werden.

- Für weitere Erweiterungen besitzt er eine UART Schnittstelle.

Fazit:

Der Korsel mit einem ATmega32 und drei Reflektionslichtschranken ermöglicht ein schnelleres und

exakteres Fahren auf der Kante des vorgegebenen Pfades. Mit der UART-Schnittstelle ist er leicht

erweiterbar und für diverse wissenschaftliche Zwecke gut einsetzbar. Für Schüler ist er wegen des

komplexen Aufbaues eher weniger geeignet.



5. Simulation des Korsels Eine Simulation des mechanischen Models des Korsels wurde mit Hilfe von Matlab erstellt. In dieser

Simulation kann man einen Weg vorgeben, den der Korsel abfährt. Man kann durch das Verändern

der Parameter feststellen, ob die Regelabweichung geringer oder größer wird. Diese Simulation wurde

von Herrn Prof. Dr.-Ing. Konrad Wöllhaf erstellt, an diese Stelle möchte ich mich nochmals dafür be-

danken.

5.1 Vorgehensweise um die Simulation zu starten Um die Simulation auszuführen benötigt man folgende Dateien:

- simmod2d1.mdl (Simulik Model)

- compute_signal.m (MATLAB M-file)

- drow_robot.m (MATLAB M-file)

- gen_path.m (MATLAB M-file)

- init_sim.m (MATLAB M-file)

- next_path.m (MATLAB M-file)

- norm_angel.m (MATLAB M-file)

- run_pol1.m (MATLAB M-file)

- run_pol2.m (MATLAB M-file)

- show_result_diff2.m (MATLAB M-file)

Als erstes wird die Datei gen_path.m aufgerufen, mit dieser kann man einen Weg festlegen, den der

Korsel später abfahren soll. Mit dem Butten Run ( ) kann man das M-file ausführen. Durch Klicken

innerhalb des Bereichs +32, -32 (Y-Achse) und +42, -42 (x-Achse) wird Schritt für Schritt ein Weg gene-

riert. Durch einen Mausklick außerhalb des Bereichs wird das Programm beendet.

Abbildung 25 path



Als nächstes kann man show_result_diff2.m starten. Dieses M-file ruft init_sim.m und simmod2.mdl

auf, simmod2.mdl ruft dann compute_signal.m und next_path.m auf. Mit einem Klick auf Run ( ) in

show_result.m zeigt das Programm das mit diesen Einstellungen verbundene Ergebnis.

Im Graph wird nochmal der gezeichnete Weg dargestellt.

Abbildung 26 Graph Abbildung 27 Graph1

Im Graph1 wird der berechnete Weg des Korsels dargestellt.

Abbildung 28 Figure 1

In der Abbildung Figur 1 wird der Korsel dargestellt und wie er versucht der Linie zu folgen.

In dem M-file show_result gibt es die Variaben kp, kd und v_robot.

Mit kp kann man den proportionalen Anteil der Regelung einstellen.

Mit kd kann man den Differentialteil der Regelung einstellen.

Mit v_robot kann man die Geschwindigkeit des Korsels einstellen.



5.2 Plausibilität der Simulation

Die Übertragungsfunktion wurde mit Hilfe des Simulationsmodels erstellt. Bei y2 ist zu erkennen, dass

ein s unter dem Bruchstrich steht, daher hat die Strecke in der Simulation ein integrierendes Verhal-

ten. Das trifft schon mal auf die Praxis zu – wenn man in diesem Korsel einen reinen P-Regler pro-

grammieren, ist dieser stationär genau und das ist nur möglich, wenn die Strecke an sich schon ein I

Verhalten mitbringt.

Um die Simulation weiter zu testen, hat man die Geschwindigkeit des Korsels Schritt für Schritt erhöht,

bis dieser seiner Bahn nicht mehr folgen konnte. Danach wurde ein Differentialanteil in die Regelstre-

cke implementiert und der Simulationskorsel konnte der Bahn wieder folgen. Dies konnte man auch in

der Praxis feststellen - der Differentialanteil stabilisiert den Korsel, die Regelabweichung wird kleiner,

die Geschwindigkeit höher und man kann ihn schneller fahren lassen.

Auch in der Regelungstechnik ist dies zu erkennen - wird ein Einheitssprung auf eine PI-

Übertragungsfunktion gegeben, so benötigt diese länger als ein PID-Glied um den Endwert zu errei-

chen. Aber Achtung, zu viel D-Anteil (Differentialanteil) führt zu einem Aufschwingen und das

System wird instabil.

Abbildung 29 Übertragungsfunktion



6. Das digitale Regelsystem (Abtastregelung)

Die prinzipielle Arbeitsweise von diesem digitalen Regler:

Als erstes muss man feststellen, wie hoch die Regelabweichung ist. Bei diesem Modell wird diese

Regelabweichung über die Sensoren erfasst. Jeder Sensor kann einen Wert von 0 bis 1024 aus-

geben, da wir drei Sensoren haben ist der theoretisch maximale Wert bei 3072. In der Praxis kann

man auch 3000 annehmen. Ist der Sensor auf weiß hat er einen Wert von 0, ist er auf schwarz hat er

einen Wert von 1024.

Abbildung 30 Sensoren

Wert Sensoren = 1200 Wert Sensoren = 1500 Wert Sensoren = 1800

Falls der Sensorenwert unter 1500 liegt, gilt folgende Formel zur Berechnung der Regelabweichung:

Regelabweichung = 1500 (Sollwert) – Wert der Sensoren Der I-Anteil (den man in diesem Modell nicht benötigt, da die Strecke (der Korsel selbst) bereits einen I-Anteil enthält und ein zusätzlicher Integralanteil das System nur instabil machen würde) kann man folgendermaßen berechnen: Summe der Regelabweichung = Summe der Regelabweichung + Regelabweichung (Aufsummation der Regelabweichung) Die Reglergleichung: Y = Wert der die PWM der Motoren steuert Y = Einstellbarer Wert * Regelabweichung + (P) Einstellbarer Wert * Summe der Regelabweichung + (I) Einstellbarer Wert * (Regelabweichung - Regelabweichung alt) (D) Um den D (Differential)-Anteil zu berechnen, müssen wir die letzte Messung der Regelabweichung mit der jetzigen vergleichen. Das Programm muss also irgendwo diesen letzten Wert der Regelabwei-chung speichern. Regelabweichung alt = Regelabweichung



Ein entscheidender Faktor wurde in dieser vereinfachten Formel der Reglergleichung vernachlässigt und zwar die Abtastzeit Ta. Ta ist die Zeit zwischen einer Messung der Regelabweichung und der nächsten Messung der Regelabweichung. Wirkungsweise von Ta: Ist Ta groß legt der Korsel große Strecken zwischen den einzelnen Messungen zurück. Auch die Dif-ferenz der Regelabweichungen ergibt dann einen großen Wert. Um dies zu kompensieren wird Kd durch Ta dividiert. Der Integralteil ist eher klein, da nicht so oft aufsummiert wird. Um dies zu kompen-sieren wird Ki mit Ta multipliziert. Wenn wir Ta mit einbeziehen, lautet die Reglergleichung folgendermaßen: E = Regelabweichung esum = Summe der Regelabweichung ealt = Regelabweichung alt Kp = Fester Wert für die Proportionale Regelung Ki = Fester Wert für die Integral Regelung Kd = Fester Wert für die Differential Regelung Ta = Abtastzeit Y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt) Die Zeit Ta kann leicht mit einem Oszilloskop gemessen werden. Dazu muss nur ein Ausgang des Mikrocontrollers nach jedem Programmdurchlauf ein- oder ausgeschaltet werden. Die Zeit zwischen den Schaltvorgängen ist die Zeit Ta.



Funktionsweise des proportionalen Reglers:

Abbildung 31 P-Anteil

Die Sensoren stellen also einen Wert der Regelabweichung fest, dieser Wert wird mit einem Faktor

multipliziert und dann an die PWM der Motoren weitergegeben.

Funktionsweise des Differentialreglers:

Abbildung 32 D-Anteil

Die Sensoren erkennen eine Regelabweichung. Dieser Wert wird gespeichert. Als nächstes wird nach

der Zeit Ta eine erneute Messung durchgeführt, jetzt wird die alte Regelabweichung von der neuen

Regelabweichung abgezogen und mit einem festen Wert multipliziert. Durch diese Vorgehensweise

kann der D–Regler sehr schnell auf starke Änderungen reagieren.

Weitere Informationen hierzu finden Sie im „Taschenbuch der Regelungstechnik“, 8. Auflage, ab

Seite 477.

Position Sensoren

zu folgende Linie

Messen des Abstandes

(Regelabweichung )

Position Sensoren

zu folgende Linie Messen des Abstandes

(Regelabweichung )

Position Sensoren nach der Zeit Ta



7. Erreichte und angepasste Ziele

Das Ziel der Bachelorarbeit war die Entwicklung einer mobilen Kleinstroboterplattform für Anwen-dungen in der Lehre und Forschung. Die Kosten sollten möglichst gering sein. Dieses Ziel wurde in zwei Teilabschnitte aufgeteilt:

1. Der Korsel mit einem ATtiny26, der wegen seiner geringen Komplexität sehr gut geeignet ist für die Lehre, z.B. Studenten im 1. und 2. Semester sowie Technische Gymnasien oder ähnliches. Die Kos-ten für die Hardware belaufen sich auf nur 18 €.

2. Der Korsel mit einem ATmega32 ist durch seine erhöhte Anzahl an Sensoren, seinem größeren Speicher sowie der Möglichkeit ihn rückwärtsfahren zu lassen, die leichte Erweiterbarkeit über die Uart-Schnittstelle und den verschiedenen Tastern und Schaltern sehr gut für weitere Projekte in der Forschung geeignet. Trotz seiner Komplexität belaufen sich die Kosten auf nur 25 €.

Das Ziel, dass der Korsel einer vorgegebenen Strecke möglichst exakt und schnell folgt, wurde voll-ständig erreicht. Mit der Regelung, die in dem Korsel (ATmega32) implementiert ist, ist dieser in der Lage auch schwierige Bahnen exakt und schnell abzufahren.

Die Ziele der Hardware: Arbeiten mit Schaltplan- und Layoutprogrammen: Mit Hilfe von Eagle wurde ein Schaltplan erstellt, mit dessen Hilfe wurde ein Layout für eine Platine erstellt. Auswahl und Positionierung von Sensorik: Als Sensor wurde eine CN70-Reflektionslichtschranke ausgewählt, diese ist sehr kostengünstig und für diese Zwecke absolut ausreichend. Um die Reich-weite zu testen, wurden Messungen im Labor durchgeführt. Danach konnten die Sensoren optimal platziert werden. Bestücken und Löten von Hardware sowie Auswahl der Hardware-Komponenten: Die Bauteile wurden auf den errechneten auftretenden Strom und der auftretenden Spannung hin ausgewählt. Außerdem wurde versucht möglichst kostengünstige Bauteile zu verwenden. Nach dem Aufbau des Prototyps wurden die errechneten Werte durch Messungen bestätigt.

Die Ziele der Software: Erstellen eines Programms für einen Mikrocontroller: Es wurden Programme für zwei Mikrocontroller erstellt, den ATtiny26 und den ATmega32. Programmieren eines Mikrocontrollers über verschiedene Schnittstellen (ISP, JTAG): Der ATtiny wurde über eine ISP-Schnittstelle programmiert, der ATmega wurde über eine JTAG-Schnittstelle programmiert.

Die Ziele der Regelungstechnik und der Simulation: Simulation der Hardware in Matlab: Durch das von Herrn Prof. Dr.-Ing. Konrad Wöllhaf erstellte Simu-lationsprogramm konnte die Hardware simuliert werden. Auslegung der Regelparameter: Durch das Simulationsprogramm konnte man erkennen, dass der Korsel ein integrierendes Verhalten aufweist, welches durch einen Differentialanteil kompensiert werden konnte. Dies schaffte die Grundlage für die schnelle und exakte Regelung des Korsels.



8. Verbesserungsvorschläge und Ausblick - Größerer Akku, z. B. LiPo mit 11,1 V: Größer heißt in diesem Fall mit einer höheren Spannung,

dadurch kann man die Geschwindigkeit der Motoren erhöhen (die Maximalgeschwindigkeit des Kor-

sels wird erhöht). Die H-Brücke und alle Bauteile können den dadurch erhöhten Strom ohne Probleme

führen. Nur die Diode (D3) ist auf 150 mA ausgelegt, diese muss ausgewechselt werden (es ist ziel-

führend eine Diode zu wählen, die möglichst genau den benötigten Strom in Durchlassrichtung führen

kann). Momentan begrenzt diese Spannung die Geschwindigkeit des Korsels.

- Den ATmega mit seinen fiuses auf eine höhere Taktfrequenz einstellen, z. B. 8 oder 16 MH. Mit der

jetzigen Hardware bewirkt dies keine nennenswerte Verbesserung. Wird jedoch ein Akkupack mit

einer höheren Spannung verwendet, ist es auch wichtig, dass die Regelung schneller arbeitet.

- Da mit einer höheren Taktfrequenz auch die Zeit Ta verkürzt wird, muss der Regler neu ausgelegt

werden. Normalerweise geschieht dies indem man einfach die neue Zeit an der Stelle Ta einträgt (bei

höherer Taktfrequenz wird Ta kleiner). Damit der Mikrocontroller weniger rechnen muss, wurde der

D- und P-Anteil mit Ta verrechnet, so dass jetzt ein konstanter Wert an der Stelle steht. Deshalb muss

dieser konstante Wert neu berechnet werden.

- Die Räder sollten aus RHM (rutschhemmende Materialien) sein, z. B. Silikon. Der Korsel gerät auch

jetzt schon oft an seine Grenzen. Die Steuerung bremst die Räder ab, jedoch tritt der gewünschte

Effekt nicht sofort ein, da die Räder ihre Bodenhaftung verlieren. Jetzt gibt es nur zwei Möglichkeiten,

entweder die Geschwindigkeit drosseln oder die Haftung der Räder erhöhen (µ erhöhen).

- Der Akku sollte direkt auf der Hinterachse liegen, dadurch ergibt sich ein geringeres Trägheitsmo-

ment. Die Drehachse des Korsels ist der Mittelpunkt der Radachse. Eine vereinfachte Formel des

Trägheitsmoments (J) lautet: . Hier kann man erkennen, dass es wichtig ist r (r = Abstand

zur Drehachse) möglichst klein zu halten, damit das Trägheitsmoment ebenfalls klein wird und es

leicht ist einen Körper in eine Drehbewegung zu versetzen. Am meisten Masse (m) hat bei unserem

Korsel der Akku, deshalb sollte man ihn im Zentrum der Rotationsbewegung platzieren. Der Korsel

wird dadurch wendiger. Als Nebeneffekt wird der Druck auf die Räder erhöht und man erhält mehr

Haftung. H

- Die jetzige Schwachstelle ist der Reißnagel. Bei einem häufigen Gebrauch des Korsels wird dieses

Bauteil als erstes verschlissen (der PVC-Überzug wird abgerieben). Um dies zu verhindern, könnte

man beispielsweise ein Stück eines Tischtennisballs an den Reißnagel kleben - die Lebensdauer des

Tischtennisballs ist um ein vielfaches höher als die des Reißnagels.

- Die ISP-Schnittstelle sollte auch mit einem Wannenstecker ausgerüstet werden, damit ein Ver-

polungsschutz gewährleistet ist. Die Kosten eines Wannensteckers belaufen sich auf ca. 0,20 €.



-Man könnte die Sensoren ca. 2-3 mm näher zusammenführen, momentan gibt es noch kleine Berei-

che, in denen sich die Sensorwerte nur geringfügig ändern. Auch ist es möglich die Auflösung mit

einer höheren Anzahl von Sensoren zu erhöhen. Dies ist allerdings nur dann zielführend, wenn die

Genauigkeit des Korsels erhöht werden soll, um z. B. einer kleineren Linie zu folgen.

- Statt ATmega32, der einen Spannungsbereich von 4,5 V bis 5,5 V hat, könnte man einen ATme-

ga32L einsetzen, dieser hat einen Spannungsbereich von 2,7 V bis 5,5 V. Der Vorteil hierbei ist, dass

der Kondensator (C5) dadurch etwas kleiner gewählt werden kann und dadurch ein paar Cent einge-

spart werden können. Die maximale Taktfrequenz des ATmega32L beträgt 8 kHz, die des ATmega32

beträgt 16 kHz. Wenn man also Wert auf einen schnellen Prozessor legt, ist der ATmega32L keine

Alternative.

- Ein sehr großer Vorteil für die Regelung des Korsels würde sich daraus ergeben, wenn man die Ge-

schwindigkeit exakt kennen würde. Man könnte dann alle Korsels mit exakt derselben Geschwindig-

keit fahren lassen und zwar unabhängig von den Fertigungstoleranzen der Motoren sowie des Akku-

mulators und sonstiger Effekte. Realisierbar wäre dies durch z. B. einen Winkelentcoder, welcher di-

rekt auf den Rädern angebracht ist.



9. Inhalt der Daten-CD

- Bilder_Korsel (Bilder vom Korsel, Unter- und Oberseite)

- Doku_Bachelorarbeit

1. Die Bachelorarbeit als Word-2010-Dokument

2. Die Bachelorarbeit als PDF-Dokument

- Korsel_mit_ATmega32

1. Datenblätter

Motordriver 29x

Datenblatt der CN70-Reflektionslichtschranken

Atmega32

2. Eagle

Die .brb Datei (Bord)

Die .sch Datei (Schaltplan)

3. Fräsdaten

Alle erforderlichen Daten, um die Platine mit einem Fräsbohrplatter zu

erstellen

4. Programme

Ein einfaches Programm mit einem P Regler (leichter zu verstehen)

Das Endprogramm ist in dem Ordner Korsel_10Atmega_PD…

- Korsel_mit_ATtiny26

1. Datenblätter

Datenblatt der CN70-Reflektionslichtschranken

Datenblatt des ATtiny26

2. Eagel

Die .brb Datei (Bord)

Die .sch Datei (Schaltplan)

3. Fräsdaten

Alle erforderlichen Daten, um die Platine mit einem Fräsbohrplatter zu

erstellen

4. Programme

Verschiedene Programme, bei denen man erkennen kann wie das

eigentliche Programm entstanden ist.

Das fertige Programm liegt in dem Ordner „Korsel_04mit P-Regler“



- Matlap_Simulation

1. compute_signal

2. drow_robot

3. gen_path

4. lnit_sim

5. next_path

6. norm_angle

7. p_path

8. run_pol1

9. run_pol2

10. show_result

11. show_result_diff2

12. simmod2

13. simmod2d1

- Tutorials

1. AVR und WINAVR installieren

2. Robotik-Skript_07-08

3. Links_wichtige_Seiten (ein paar Links, in denen das Thema Mikrocontroller

näher erklärt wird )

- Videos_Korsel

1. Korsel_auf_der_Innenbahn

2. Korsel_mit_ATtiny26

3. Korsel_mit_PD_richtig_eingestellt

4. Korsel_mit_zu_wenig_P_Anteil_und_keinem_D_Anteil

5. Vergleich_alter_Korsel_neuer_Korsel



10. Literaturverzeichnis Fessler Joachim & Feucht Achim.

RoboterNETZ. (14. 07 2012). Abgerufen am 14. 07 2012 von Roboter, Elektronik, Mikrokontroller:

http://www.rn-wissen.de/index.php/Pulsweitenmodulation

ATMEL. Datenbalatt ATmega32.

ATMEL. Datenblatt ATtiny26.

VISHAY. Reflektionslichtschranke CNY70.

Wirth, P. D. (5. 1 2011). Mikroprozessortechnik. Abgerufen am 14. 7 2012 von http://mit.eit.h-

da.de/VorlesungenBeispiele_Wirth_WS1011/0900_ADC.pdf



11. Abbildungsverzeichnis Abbildung 1 Asuro Abbildung 2 POB BOT .......................................................................................... 8

Abbildung 3Korsel ATtiny26 .................................................................................................................... 9

Abbildung 4 Korsel ATtiny 26 .................................................................................................................. 9

Abbildung 5 AVR Programmer .............................................................................................................. 14

Abbildung 6 Korsel mit Programmer ..................................................................................................... 15

Abbildung 7 AD-Wandler Funktion ....................................................................................................... 19

Abbildung 8 PWM Register OCR1A ....................................................................................................... 23

Abbildung 9 PWM Register OCR1B ....................................................................................................... 23

Abbildung 10 JTAGICE mkII ................................................................................................................... 29

Abbildung 11 JTAG Programmiergerät .................................................................................................. 29

Abbildung 12 Debug .............................................................................................................................. 30

Abbildung 13 JTAG platform ................................................................................................................. 30

Abbildung 14 Configuration Options ..................................................................................................... 31

Abbildung 15 Compiler Optimierung .................................................................................................... 31

Abbildung 16 .elf File ............................................................................................................................. 32

Abbildung 17 Variablen ......................................................................................................................... 32

Abbildung 18 Fuses ATmega32 ............................................................................................................. 33

Abbildung 19 Funktionsweise Sensor (VISHAY) .................................................................................... 43

Abbildung 20 Sensoren Kegel LED ......................................................................................................... 43

Abbildung 21 Abstand Sensoren ........................................................................................................... 44

Abbildung 22 CNY 70 (VISHAY) .............................................................................................................. 44

Abbildung 23 Abstand Sensoren zueinander ........................................................................................ 44

Abbildung 24 Batteriespannung ............................................................................................................ 48

Abbildung 25 path ................................................................................................................................. 53

Abbildung 26 Graph Abbildung 27 Graph1 ................................................................................ 54

Abbildung 28 Figure 1 ........................................................................................................................... 54

Abbildung 29 Übertragungsfunktion ..................................................................................................... 55

Abbildung 30 Sensoren ......................................................................................................................... 56

Abbildung 31 P-Anteil ............................................................................................................................ 58

Abbildung 32 D-Anteil ........................................................................................................................... 58

Entwicklung einer mobilen Kleinstroboterplattform für die...

Documents

Transcript of Entwicklung einer mobilen Kleinstroboterplattform für die...