Entwicklung einer mobilen Kleinstroboterplattform für die Anwendung in der Lehre und Forschung

Transkript

1 Entwicklung einer mobilen Kleinstroboterplattform für die Anwendung in der Lehre und Forschung Stefan Boneberg Kleiner Ausschnitt aus der Bachelorabschlussarbeit im Wintersemester 2012/2013

2 Inhaltsverzeichnis Der Korsel mit einem ATmega32 und drei Reflektionslichtschranken Benötigte Bauteile und Kosten ATmega Schaltplan Korsel mit ATmega Platine des Korsels mit ATmega Programmieren mit einem JTAGICE mkii Programmer Einstellungen im AVR-Studio um mit JTAGICE zu debuggen Die Fuses des Mikrocontrollers Das Programm des ATmega 32 mit drei Reflektionslichtschranken Implementieren der Bibliotheken Initialisieren der Variablen IO-Ports initialisieren ADC-Wandler initialisieren PWM initialisieren Hauptprogramm (MAIN) Die Sensoren des Korsels Grundlegende Funktionsweise unsere Sensoren Einstellungen des Analog-/Digital-Wandlers (ATmega32) Die Einstellung des Registers ADMUX Die Einstellung des Registers ADCSRA Die Einstellung des Registers SFIOR Batterie Spannungs-Berechnung Einstellungen der PWM (ATmeaga32) Die Einstellung des Registers TCCR1A Die Einstellungen des Registers TCCR1B Grundlegende Funktion der Bauteile, Korsel mit ATmega32 (drei Sensoren) Das digitale Regelsystem (Abtastregelung) Stefan Boneberg Seite 2 von 35

3 10. Literaturverzeichnis Abbildungsverzeichnis Stefan Boneberg Seite 3 von 35

4 4. Der Korsel mit einem ATmega32 und drei Reflektionslichtschranken ISP-Schnittstelle JATAG-Schnittstelle Taster (für folgende Erweiterungen) Schiebeschalter (Abruf von verschiedenen Programmen) UART-Schnittstelle ATmega 32 LED um den Status (ein/aus) anzuzeigen LED s um verschiedene Zustände anzuzeigen Stefan Boneberg Seite 4 von 35

5 4.1 Benötigte Bauteile und Kosten ATmega32 Anzahl Name Bezeichnung Bestellnummer und Liferant Kosten 2 Motor IGARASHI DC Kleinstmotor Conrad Bestell-Nr.: 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 ,11 3 Reflektionslichtschranke Typ CNY 70 Reichelt Bestell-Nr: CNY 70 0,70 1 Diode Typ 4148 Reichelt Bestell-Nr: SMD 1N ,02 1 Batterieclip Batterieclip für 9-Volt-Block Reichelt Bestell-Nr: CLIP HQ9V-T 0,24 Schaltregler ST Microelectronics L 78 L Spannungsregler Conrad Bestell-Nr.: ,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.: ,49 1 SMD-Widerstände Baugröße 1206 SMD 470 Ohm 0,10 2 SMD-Widerstände Baugröße 1206 SMD 8,2k Ohm 0,10 3 SMD-Widerstände Baugröße 1206 SMD 330 Ohm 0,10 1 SMD-Widerstände Baugröße 1206 SMD 4,7k Ohm 0,10 2 SMD-Widerstände Baugröße 1206 SMD 220 Ohm 0,10 2 Kondensatoren Baugröße 1206 SMD 100uF 0,45 1 Entstörkondensatoren AX 100/16 100uF 16V Reichelt B ,15 1 Entstörkondensatoren AX 220/16 220uF 16V Reichelt B ,16 3 LED LED 5mm Reichelt Artikel-Nr.: LED 5MM GN 0,06 1 Stiftleiste Stiftleisten 2,54 mm, 2X02, gerade Reichelt MPE ,10 1 9V Block energy Alkaline 9 V Block-Batterie Conrad Best.-Nr.: ,50 4 Messpunkte Lötnägel 1mm, versilbert Reihelt RTM ,01 Bungard Platinen-Basismaterial Cu- Grundplatine Conrad Best.-Nr.: ,25 Auflage 5,19 O-Ring: Innendurchmesser 20mm Dicke: Reifen 4 2mm BB-608-A ES (Kunststofflager Räder Kugellager 2 von IGUS) 1 Achse z.b. 8mm-Alu-Rohr aus dem Baumarkt Isolierte Drähte für den 4 Anschluss der Motoren Gesamt: 24,32 Stefan Boneberg Seite 5 von 35

6 4.2 Schaltplan Korsel mit ATmega32 Stefan Boneberg Seite 6 von 35

7 4.3 Platine des Korsels mit ATmega32 Stefan Boneberg Seite 7 von 35

8 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 hineinzuschauen. 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. Abbildung 1 JTAGICE mkii Mit diesem schon bekannten AVR-Studio mit WINAVR kann man auch über den JTAG- Programmer programmieren. Zusätzlich kann man Debugging betreiben und dadurch Entwicklungszeit sparen. JTAGICE mkii Programmer JATG-Schnittstelle USB-Anschluss (reicht um zu programmieren und zu debuggen) Abbildung 2 JTAG Programmiergerät Stefan Boneberg Seite 8 von 35

9 4.4.1 Einstellungen im AVR-Studio um mit JTAGICE zu debuggen Abbildung 3 Debug Als erstes kann man über Debug -> Select Platform and Device unseren JTAG-Programmer und den Mikrocontroller auswählen. Abbildung 4 JTAG platform Standardmäßig ist der AVR-Simulator ausgewählt, dieser führt eine Simulation durch, liefert aber nicht die echten Werte des Mikrocontrollers. Stefan Boneberg Seite 9 von 35

10 Als nächstes kann man den Compiler richtig einstellen - das können wir über Project -> Konfiguration Options machen. Abbildung 5 Configuration Options 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 verwendeten Mikrocontrollers und erstellt danach ein darauf optimiertes Programm. Die Optimierungsstufe löscht hierbei alle Befehle, die nicht mit einem Ein- oder Ausgang direkt oder indirekt zusammenhä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 6 Compiler Optimierung Stefan Boneberg Seite 10 von 35

11 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 funktioniert 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. Abbildung 7.elf File 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 8 Variablen Stefan Boneberg Seite 11 von 35

12 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ßerdem 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 9 Fuses ATmega32 Stefan Boneberg Seite 12 von 35

13 4.6 Das Programm des ATmega 32 mit drei Reflektionslichtschranken Implementieren der Bibliotheken //**************************Implementieren der Bibliotheken******************* #include <avr/io.h> #define F_CPU UL #include <stdint.h> 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; int y = 0; int r = 0; int l = 0; int KP = 0; int KI = 0; int KD = 0; int e = 0; int esum = 0; int a = 0; int ealt = 0; // Motor PWM Berechnung // Motor PWM Berechnung // Motor PWM Berechnung // Motor PWM Berechnung // Proportionaler Wert der Regelung (P Anteil) // Integralwert der Regelung (I Anteil) // Differentialwert der Regelung (D Anteil) // Regeldifferenz // auf Summation der Regelabweichung // Regelabweichung // Letzter berechneter Wert #define Motor_links OCR1B // OCR1B heißt jetzt Motor_links #define Motor_rechts OCR1A // OCR1A heißt jetzt Motor_rechts Stefan Boneberg Seite 13 von 35

14 4.6.3 IO-Ports initialisieren //************************************************************************* // IO-Ports initialisieren //************************************************************************* void init_io(void) { DDRD = 0x00; PORTD = 0xFF; // Port D als Eingang (hex. Schreibweise geht auch) // Port D als pull-up (hex. Schreibweise geht auch) PORTC = (1 << PC6); PORTB = (1 << PB4); DDRC &= ~(1 << PC6); DDRB &= ~(1 << PB4); DDRB =(1 << PB1); DDRB =(1 << PB2); DDRB =(1 << PB0); // PC6 als Eingang mit pull-up // PB4 als Eingang mit pull-up // PC6 als Eingang // PB4 als Eingang // PB1 als Ausgang // PB2 als Ausgang // PB0 als Ausgang DDRA &= ~(1 << PA0); PORTA = (1 << PA3); DDRA &= ~(1 << PA3); PORTA = (1 << PA4); DDRA &= ~(1 << PA4); PORTA = (1 << PA5); DDRA &= ~(1 << PA5); // PA0 als Eingang für AD Messung (ADC0 Spannungsteiler Batteriespannung) // PA3 als Eingang mit pull-up für AD-Messung (ADC3 Sensor in Fahrtrichtung rechts) // PA3 als Eingang // PA4 als Eingang mit pull-up für AD-Messung (ADC4, Sensormitte) // PA4 als Eingang // PA5 als Eingang mit pull-up für AD-Messung (ADC5, Sensor in Fahrtrichtung links) // PA5 als Eingang PORTB &= ~(1 << PB1); PORTB &= ~(1 << PB2); PORTB =(1 << PB0); // auf low LED ausschalten // auf low LED ausschalten // Sensoren LED s einschalten //*****************************Ansteuerung H-Brücke*********************************** DDRB =(1 << PA1); DDRB =(1 << PA2); DDRB =(1 << PA6); DDRB =(1 << PA7); PORTA &= ~(1 << PA2); PORTA &= ~(1 << PA7); PORTA =(1 << PA1); PORTA =(1 << PA6); // PA1 als Ausgang // PA2 als Ausgang // PA6 als Ausgang // PA7 als Ausgang // auf low (für Vorwärtsfahrt als Starteinstellung) // auf low (für Vorwärtsfahrt als Starteinstellung) // auf high (für Vorwärtsfahrt als Starteinstellung) // auf high (für Vorwärtsfahrt als Starteinstellung) Stefan Boneberg Seite 14 von 35

15 4.6.4 ADC-Wandler initialisieren //************************************************************************************ // ADC-Wandler einstellen //************************************************************************************ void ADC_Init(void) { ADMUX = 0b ; // Verwenden der internen Referenzspannung mit externem Kondensator Datenblatt S.212 // genauer ist eine externe Referenzspannung (ist hier aber nicht so wichtig) ADCSRA = 0b ; // Einstellen der ADC-Wandlung Teilungsfaktor 2 (höchste Geschwindigkeit der AD-Wandlung) SFIOR = 0b ; // Single Conversion mode (führt nur dann eine Konvertierung aus, wenn ADSC auf 1 gesetzt wird) ADCSRA =(1 << ADSC); while (!ADCSRA & (1<<ADSC)) { Sensor_links_3 = ADC; // Starten einer Konvertierung // auf Abschluss der Konvertierung warten // beim Auslesen von ADC wird das Bit ADSC wieder auf null gesetzt, deshalb hier auslesen um den Wert zu löschen PWM initialisieren //************************************************************************************ // PWM initialisieren //************************************************************************************ void pwm (void) { DDRD = (1<<PD4); DDRD = (1<<PD5); PORTD &= ~(1 << PA4); PORTD &= ~(1 << PA5); // auf Ausgang setzen für PWM // auf Ausgang setzen für PWM // auf low // auf low TCCR1A = 0b ; TCCR1B = 0b ; TCNT1 = 255; // Einstellen der PWM A und B mit Modusauswahl // Teiler von 8 einstellen, zu kleiner Teiler bringt zu viele HF Störungen auf die restliche Elektronik // Anfangswert setzten (dort beginnt er beim ersten Mal zu zählen) OCR1A = 100; OCR1B = 100; // Register für den Vergleichswert (dieses Register wird später von der eigentlichen Regelung immer überschrieben) // Register für den Vergleichswert (dieses Register wird später von der eigentlichen Regelung immer überschrieben) Stefan Boneberg Seite 15 von 35

16 4.6.6 Hauptprogramm (MAIN) //************************* MAIN ***************************************************** int main (void) { init_io(); ADC_Init(); pwm(); // IOs konfigurieren // Analog-Digitalwandler konfigurieren // PWM initialisieren while (1) // Start Endlosschleife { Sensoren auslesen //************************************************************************************ // Sensoren auslesen //************************************************************************************ //*********************** Sensor 1 *************************************************** while (ADMUX!=67) { // Abfrage auf port ADC3 ADMUX = 0b ; // 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 = 0b ; // 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 = 0b ; // 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 Stefan Boneberg Seite 16 von 35

17 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 An gleich der Batteriespannung //************************************************************************************ // Abfrage der Batteriespannung //************************************************************************************ while (ADMUX!=64) { // Abfrage auf port ADC0 ADMUX = 0b ; // 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_PWM1=0; Batterie_PWM2=0; PORTB =(1 << PB1); else{ //Batterie ist fast leer PORTB &= ~(1 << PB1); 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)){ // PB1 auf high = LED an (zeigt an wenn die Batterie fast leer ist) // PB1 auf low = LED aus Stefan Boneberg Seite 17 von 35

18 Stefan Boneberg Seite 18 von 35 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;

19 Einstellen des Differentialanteils //************************************Einstellen des D-Anteils************************ if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 1 und PIND6 = 1 und PIND7 = 1) dann gehe in if KD=0; if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 0 und PIND6 = 1 und PIND7 = 1) dann gehe in if KD=30; if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 1 und PIND6 = 1 und PIND7 = 0) dann gehe in if KD=60; if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 0 und PIND6 = 1 und PIND7 = 0) dann gehe in if KD=90; if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 1 und PIND6 = 0 und PIND7 = 1) dann gehe in if KD=120; if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 0 und PIND6 = 0 und PIND7 = 1) dann gehe in if KD=150; if ((PIND & 0b ) == 0b ) { // wenn (PDIND3 = 1 und PIND6 = 0 und PIND7 = 0) dann gehe in if KD=180; if ((PIND & 0b ) == 0b ) { // 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 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; esum = esum + e; // Regeldifferenz // Integration I-Anteil a=(kp*e)+(ki*1*esum)+((kd/1)*(e-ealt)); //Regler ealt = e; // Differential D-Anteil Stefan Boneberg Seite 19 von 35

20 r=255-(a/6); // Berechnen der Motor-PWM des rechten Motors if(r<0){ PORTA &= ~(1 << PA1); PORTA =(1 << PA2); PORTB =(1 << PB2); // auf high (für Rückwärtsfahrt) Motor rechts // auf low (für Rückwärtsfahrt) Motor rechts // PA6 auf high = LED an else{ r=r*(-1); PORTA &= ~(1 << PA2); PORTA =(1 << PA1); PORTB &= ~(1 << PB2); // PWM kann nur positive Werte verarbeiten // auf low (für Vorwärtsfahrt) Motor rechts // auf high (für Vorwärtsfahrt) Motor rechts // PA6 auf low = LED aus if(x<=1500){ // Korsel Bewegung nach links (hier x) r = 255; // Motor rechts volle Leistung e = 1500-x; esum = esum + e; // Regeldifferenz // Integration I-Anteil a=(kp*e)+(ki*1*esum)+((kd/1)*(e-ealt)); //Regler ealt = e; l=255-(a/6); // Differential D-Anteil // Berechnen der Motor-PWM des linken Motors if(l<0){ PORTA &= ~(1 << PA6); PORTA =(1 << PA7); PORTB =(1 << PB2); // auf high (für Rückwärtsfahrt) Motor links // auf low (für Rückwärtsfahrt) Motor links // PA6 auf high = LED an else{ l = l * (-1); // PWM kann nur positive Werte verarbeiten 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 Stefan Boneberg Seite 20 von 35

21 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; if ((motorl<0) ) { motorl=0; // die PWM der Motoren darf keinen kleineren Wert als 0 bekommen // 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); Stefan Boneberg Seite 21 von 35

22 4.7 Die Sensoren des Korsels Hier wird eine Reflektionslichtschranke (CNY70) mit einem Transistorausgang verwendet. Funktionsweise: Abbildung 10 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 11 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. Stefan Boneberg Seite 22 von 35

23 Der Abstand der Sensoren zum Untergrund beträgt 3,5 mm. Abbildung 12 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 diesem Bereich gut arbeiten kann). Der Abstand zwischen den Sensoren beträgt 9 mm. Abbildung 13 CNY 70 (VISHAY) Abbildung 14 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. Stefan Boneberg Seite 23 von 35

24 4.7.1 Grundlegende Funktionsweise unsere Sensoren Auf weißem Untergrund wird der Transistor durchgesteuert und zieht den Eingang (pull-up) des Mikrocontrollers 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 zusammenaddiert und man erhält einen Wert von ca 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. Stefan Boneberg Seite 24 von 35

25 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 verschiedenen Eingänge (drei Sensoren und Batteriespannungsmessung) schalten muss Die Einstellung des Registers ADMUX = 0b (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 bekommen muss an diesen Pin ein 100nF-Kondensator angeschlossen werden. AVCC ist an 5 V angeschlossen, 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 = an den Stellen 0,1,2,3 und 4 (MUX0 bis MUX4) ist eine 00000, hier kann man den zu konvertierenden Eingang festlegen. In diesem Programm wird der zu konvertierende Eingang vor jeder AD- Wandlung neu eingestellt. Stefan Boneberg Seite 25 von 35

26 4.8.2 Die Einstellung des Registers ADCSRA = 0b (ATMEL, Datenbalatt ATmega32) 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 Konvertierung 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 Geschwindigkeit des AD-Wandlers einstellen. Hier ein Teiler von 2, d.h.. Hier wurde 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 Die Einstellung des Registers SFIOR = 0b = 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 = an den Stellen 4,3,2,1,0 (-, ACME, PUD, PSR2, PSR10) steht eine 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. Stefan Boneberg Seite 26 von 35

27 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 analogen Wertes in einen digitalen Wert startet. Außerdem kann man mit ADMUX einen Eingang auswählen, 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 Batteriespannung 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 15 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 entstehen, 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 Bedingungen für die if-anweisungen festlegen. Stefan Boneberg Seite 27 von 35

28 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 Die Einstellung des Registers TCCR1A =0b (ATMEL, Datenbalatt ATmega32) 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 werden. 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.) Stefan Boneberg Seite 28 von 35

29 Die Einstellungen des Registers TCCR1B =0b (ATMEL, Datenbalatt ATmega32) 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. Stefan Boneberg Seite 29 von 35

30 4.11 Grundlegende Funktion der Bauteile, Korsel mit ATmega32 (drei Sensoren) 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 programmieren. 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 Spannung 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 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 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 Maximaldauerstrom 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 sorgen 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. Stefan Boneberg Seite 30 von 35

31 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 ausgeben, da wir drei Sensoren haben ist der theoretisch maximale Wert bei 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 Abbildung 16 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 + Einstellbarer Wert * Summe der Regelabweichung + Einstellbarer Wert * (Regelabweichung - Regelabweichung alt) (P) (I) (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 Regelabweichung speichern. Regelabweichung alt = Regelabweichung Stefan Boneberg Seite 31 von 35

32 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 Differenz 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 kompensieren 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. Stefan Boneberg Seite 32 von 35

33 Funktionsweise des proportionalen Reglers: Position Sensoren Messen des Abstandes (Regelabweichung ) zu folgende Linie Abbildung 17 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: Position Sensoren Position Sensoren nach der Zeit Ta zu folgende Linie Messen des Abstandes (Regelabweichung ) Abbildung 18 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. Stefan Boneberg Seite 33 von 35

34 10. Literaturverzeichnis Fessler Joachim & Feucht Achim. RoboterNETZ. ( ). Abgerufen am von Roboter, Elektronik, Mikrokontroller: ATMEL. Datenbalatt ATmega32. ATMEL. Datenblatt ATtiny26. VISHAY. Reflektionslichtschranke CNY70. Wirth, P. D. ( ). Mikroprozessortechnik. Abgerufen am von Stefan Boneberg Seite 34 von 35

35 11. Abbildungsverzeichnis Abbildung 1 Asuro Abbildung 2 POB BOT... Fehler! Textmarke nicht definiert. Abbildung 3Korsel ATtiny26... Fehler! Textmarke nicht definiert. Abbildung 4 Korsel ATtiny Fehler! Textmarke nicht definiert. Abbildung 5 AVR Programmer... Fehler! Textmarke nicht definiert. Abbildung 6 Korsel mit Programmer... Fehler! Textmarke nicht definiert. Abbildung 7 AD-Wandler Funktion... Fehler! Textmarke nicht definiert. Abbildung 8 PWM Register OCR1A... Fehler! Textmarke nicht definiert. Abbildung 9 PWM Register OCR1B... Fehler! Textmarke nicht definiert. Abbildung 10 JTAGICE mkii... 8 Abbildung 11 JTAG Programmiergerät... 8 Abbildung 12 Debug... 9 Abbildung 13 JTAG platform... 9 Abbildung 14 Configuration Options Abbildung 15 Compiler Optimierung Abbildung 16.elf File Abbildung 17 Variablen Abbildung 18 Fuses ATmega Abbildung 19 Funktionsweise Sensor (VISHAY) Abbildung 20 Sensoren Kegel LED Abbildung 21 Abstand Sensoren Abbildung 22 CNY 70 (VISHAY) Abbildung 23 Abstand Sensoren zueinander Abbildung 24 Batteriespannung Abbildung 25 path... Fehler! Textmarke nicht definiert. Abbildung 26 Graph Abbildung 27 Graph1... Fehler! Textmarke nicht definiert. Abbildung 28 Figure 1... Fehler! Textmarke nicht definiert. Abbildung 29 Übertragungsfunktion... Fehler! Textmarke nicht definiert. Abbildung 30 Sensoren Abbildung 31 P-Anteil Abbildung 32 D-Anteil Stefan Boneberg Seite 35 von 35