Mikrocontroller. Projekt. August update: 27. August 2017 um 15:20

Transkript

1 Mikrocontroller Projekt August 2017 update: 27. August 2017 um 15:20 cbea

2

3 Inhaltsverzeichnis 1 Mikrocontroller ATmega88PA Eckdaten AVR-Dragon In-System-Programming Fotos Brennen und Testen mit avrdude readflash writeflash readeeprom writeeeprom readhfuse und readlfuse writefuseshex IO Port D Data Register Port D Data Direction Register Port D Input Pins Address Einführung Ports Schreibweisen für das setzen und löschen von Bits Registerinhalte verändern Richtungsregister DDRx - Datenrichtungsregister Pull-Up u. Pull-Down Widerstände Binärzahlen von 1 bis Bit-Operatoren Maskieren von Bits Variablen und Datentypen Variablen deklarieren und initialisieren Datentypen Mit Variablen arbeiten Sichtbarkeit und Lebensdauer von Variablen vers. Konstanten Quellcode dummy001.c Makefile Install unter Linux III

4 1Mikrocontroller 1.1 ATmega88PA Eckdaten Tabelle 1.1 Features ATmega88PA Pin Count 28/32 Flash (Bytes) 8K SRAM (Bytes) 1K EEPROM (Bytes) 512 Interrupt Vector Size (instruction word/vector) 1 General Purpose I/O Lines 23 SPI 2 TWI (I2C) 1 USART 1 ADC 10-bit 15kSPS ADC Channels 8 8-bit Timer/Counters 2 16-bit Timer/Counters AVR-Dragon Der AVR-Dragon unterstützt aktuell die folgenden Protokolle: In-System-Programming (ISP) über ISP Header High Voltage Programming (HVSP) über HVPROG Header Parallel Programming (PP) über HVPROG Header JTAG Programming (JTAG) über JTAG Header debugwire In-System-Programming ISP Header Der ISP Header nutzt das 6-polige AVR ISP Pin-Layout zur Verbindung mit externen Boards. Das ermöglicht die Verwendung bereits vorhandener Kabel. Die externen Boards sollten daher ebenfalls einen 6-poligen ISP-Anschluß verwenden. 1

5 1 Mikrocontroller Die Signale dieses Headers sind»level-converted«, erlauben also auch den Anschluß an Boards mit abweichender Stromversorgung (1,8V 5,5V) Fotos Abbildung 1.1 Abbildung 1.2 2

6 1.1 ATmega88PA Abbildung 1.3 Abbildung 1.4 Abbildung 1.5 Abbildung 1.6 3

7 1 Mikrocontroller Abbildung 1.7 Abbildung 1.8 Abbildung 1.9 4

8 1.2 Brennen und Testen mit avrdude 1.2 Brennen und Testen mit avrdude 1 PROGNAME = led_ blink01 2 CPU = atmega88p 3 PROGRAMMER = dragon_ isp 4 PORT = usb readflash readflash 1 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :r: readflash. hex :i Der Flash-Speicher des Mikrocontrollers wird in die Datei ausgelesen writeflash writeflash 1 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :w:$( PROGNAME ). hex :i 3 oder 5 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :w: readflash. hex :i Die mit readflash ausgelesenen Daten können mit writeflash zurück geschrieben werden. Das braucht man zum Beispiel, um Kopien von Mikrocontrollern herzustellen, ohne auf den Quelltext zurückzugreifen readeeprom readeeprom 1 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U eeprom :r: readeeprom. hex :i Wirkt wie readflash, nur dass der EEPROM-Speicher gelesen wird. 5

9 1 Mikrocontroller writeeeprom writeeeprom 1 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U eeprom :w: readeeprom. hex :i Das Tool schreibt die mit readflash gelesenen Daten zurück. Auch dieser Vorgang gehört zum Herstellen von Kopien readhfuse und readlfuse readhfuse und readlfuse 1 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -u -U hfuse :r: readhfuse. binaerzahl :b -U lfuse :r: readlfuse. binaerzahl :b Diese beiden Tools lesen das High-Fuse-Byte bzw. das Low-Fuse-Byte des Mikrocontrollers jeweils in die Datei. Die Fuse-Bytes enthalten die Fuse-Bits, die für grundlegende Funktionen stehen. Ganz wichtig: Eine Null bedeutet, dass die mit dem Bit verbundene Funktion (siehe Datenblatt), aktiviert ist. Das Bit wird auch als programmiert bezeichnet. Die Eins bedeutet: Funktion ist deaktiviert. Das ist entgegen der Gewohnheit und hat wohl damit zu tun, dass Bits im gelöschten Flash-Speicher im Zustand 1 sind. unprogrammed=1; programmed=0 Die Datei enthält beispielsweise nach dem Aufruf von readhfuse beim fabrikneuen ATmega88PA die folgenden Zeichen: Fuse High Byte Datei readhfuse.binaerzahl // Bit No. 2 fabrikneu : 0 b = 0 xdf 3 praxis : 0 b = 0 xdf // keine Ä nderung Low Fuse Byte CKDIV8 deaktivieren, damit der Mikrocontroller mit einer Taktfrequenz von 8 MHz arbeitet. Datei readlfuse.binaerzahl // Bit No. 2 fabrikneu : 0 b = 0 x62 3 praxis : 0 b = 0 xe2 // CKDIV8 deaktivieren 6

10 1.2 Brennen und Testen mit avrdude Tabelle 1.2 High Fuse Byte Bit Description Default Value RSTDISBL 7 External Reset Disable 1 DWEN 6 debugwire Enable 1 SPIEN 5 SPI programming enabled 0 WDTON 4 Watchdog Timer Always On 1 EESAVE 3 EEPROM memory is preserved through 1 BODLEVEL2 2 Brown-out Detector trigger level 1 BODLEVEL1 1 Brown-out Detector trigger level 1 BODLEVEL0 0 Brown-out Detector trigger level 1 Tabelle 1.3 Low Fuse Byte Bit Description Default Value CKDIV8 7 Divide clock by 8 0 CKOUT 6 Clock output 1 SUT1 5 Select start-up time 1 SUT0 4 Select start-up time 0 CKSEL3 3 Select Clock source 0 CKSEL2 2 Select Clock source 0 CKSEL1 1 Select Clock source 1 CKSEL0 0 Select Clock source 0 7

11 1 Mikrocontroller writefuseshex Hexadezimalzahl ANPASSEN!!! 1 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U hfuse :w:0 xdf :m 2 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U lfuse :w:0 xe2 :m Der Aufruf schreibt die Fuse-Bits in Hexadezimaler Schreibweise. 1.3 IO Port D Data Register PORTD Tabelle 1.4 Bit PORTD7 PORTD6 PORTD5 PORTD4 PORTD3 PORTD2 PORTD1 PORTD Port D Data Direction Register DDRD Tabelle 1.5 Bit DDRD7 DDRD6 DDRD5 DDRD4 DDRD3 DDRD2 DDRD1 DDRD Port D Input Pins Address PIND Tabelle 1.6 Bit PIND7 PIND6 PIND5 PIND4 PIND3 PIND2 PIND1 PIND0 8

12 1.4 Einführung 1.4 Einführung Ports Datenrichtungsregister DDRD, DDRB, DDRC 1 = Ausgang 0 = Eingang Eingaberegister PIND, PINB, PINC 1 = High-Signal 0 = Low-Signal Ausgaberegister PORTD, PORTB, PORTC 1 = Ausgangspin auf High 0 = Ausgangspin auf Low Tabelle 1.7 PIN ˆx bin hex B Schreibweisen für das setzen und löschen von Bits PIN = BIN = HEX = B0 1. hex - ISO-C 1 DDRB = 0 xb0 ; 2. bin - kein ISO-C 1 DDRB = 0 b ; 3. übersichtliche Schreibweise 1 DDRB = (1<< DDB4 ) (1 < < DDB5 ) (1 < < DDB7 ); 9

13 1 Mikrocontroller Registerinhalte verändern gesamte Register wird überschrieben! 1 DDRD = 0 xff ; // Richtungsregister PORTD auf ( ) 2 PORTD = 0 x0f ; // untersten Bits auf High ( ) 4 PIND = 0 x0f ; // ( ) Eingabe 1= High, 0= Low 5 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 6 PORTD = 0 x0f ; // ( ) Ausgabe 1= High, 0= Low 1 Bit setzen 1 PORTD = (1 < < PD7 ); oberste Bit von PORTD auf High setzen 3 PIND = 0 x8f ; // ( ) Eingabe 1= High, 0= Low 4 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 5 PORTD = 0 x8f ; // ( ) Ausgabe 1= High, 0= Low mehrere Bits setzen 1 PORTD = (1<< PD6 ) (1 < < PD5 ) (1 < < PD4 ); Bits von PORTD auf High setzen 3 PIND = 0 xff ; // ( ) Eingabe 1= High, 0= Low 4 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 5 PORTD = 0 xff ; // ( ) Ausgabe 1= High, 0= Low 1 Bit löschen 1 PORTD &= ~(1 < < PD0 ); unterste Bit l ö schen 3 PIND = 0 xfe ; // ( ) Eingabe 1= High, 0= Low 4 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 5 PORTD = 0 xfe ; // ( ) Ausgabe 1= High, 0= Low mehrere Bits löschen 1 PORTD &= ~((1 < < PD3 ) (1 < < PD2 )); Bits PD3 u. PD2 lö schen 3 PIND = 0 xf2 ; // ( ) Eingabe 1= High, 0= Low 4 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 5 PORTD = 0 xf2 ; // ( ) Ausgabe 1= High, 0= Low 10

14 1.4 Einführung 1 Bit invertieren 1 PORTD ^= PORTD ; gesamte PORTD invertieren ( toggeln ) 3 PIND = 0 x0d ; // ( ) Eingabe 1= High, 0= Low 4 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 5 PORTD = 0 x0d ; // ( ) Ausgabe 1= High, 0= Low 7 PORTD ^= (1 < < PD0 ); Portbit D0 invertieren ( toggeln ) 9 PIND = 0 x0c ; // ( ) Eingabe 1= High, 0= Low 10 DDRD = 0 xff ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 11 PORTD = 0 x0c ; // ( ) Ausgabe 1= High, 0= Low 1 Bit verschieben 1 PORTD = (1 < < PD1 ); // Bit D1 setzen PORTD = ( PORTD < <4); // PORTD um 4 Stellen nach links PORTD = ( PORTD < <2); // PORTD um 2 Stellen nach rechts Richtungsregister DDRx - Datenrichtungsregister 0 im DDR = Portpin als Eingang 1 im DDR = Portpin als Ausgang 1 DDRD = (1 < < PD0 ); // Richtungsregister PORTD PinD0 auf Ausgang setzen - > PD0 = 1 2 DDRD &= ~(1 < < PD1 );// Richtungsregister PORTD PinD1 auf Eingang setzen - > PD1 = 0 1 DDRD = 0 xf0 ; // PORTD.7 Ausgang - > DDRB.7 = 1 4 PORTD.6 Ausgang - > DDRB.6 = 1 5 PORTD.5 Ausgang - > DDRB.5 = 1 6 PORTD.4 Ausgang - > DDRB.4 = 1 7 PORTD.3 Eingang <- DDRB.3 = 0 8 PORTD.2 Eingang <- DDRB.2 = 0 9 PORTD.1 Eingang <- DDRB.1 = 0 10 PORTD.0 Eingang <- DDRB.0 = Pull-Up u. Pull-Down Widerstände Datenleitung auf ein ein eindeutiges Pozential (+3,3V o. +5V) bzw. gegen Masse ziehen. externer Pull-Up Widerstand 10kOhm - 20KOhm. interner Pull-Up Widerstand 11

15 1 Mikrocontroller Tabelle 1.8 DDRx Portx Zustand I/O-Pins 0 0 Eingang 0 1 Eingang mit int. Pull-Up Widerstand 1 0 Ausgang auf Low 1 1 Ausgang auf High 1 DDRD = 0 xf0 ; // Richtungsregister PORTD = PORTD = (1<< PD1 ) (1 < < PD0 ); // Pull -Up Widerstand für PD1 u. PD0 aktivieren 3 PORTD = (1<< PD7 ) (1 < < PD6 ); // PD7 u. PD6 auf High setzen 5 PIND = 0 xc0 ; // ( ) Eingabe 1= High, 0= Low 6 DDRD = 0 xf0 ; // ( ) Datenrichtungsregister 1= Ausgang, 0= Eingang 7 PORTD = 0 xc0 ; // ( ) Ausgabe 1= High, 0= Low Binärzahlen von 1 bis 15 Tabelle 1.9 hex dez bin a b c d e f

16 1.5 Bit-Operatoren 1.5 Bit-Operatoren 1 c = ( a & b); // bitweise UND, Bits l ö schen, ( Maskierung von Bits ) 2 c = ( a b); // bitweise ODER. Bits setzen 3 c = ( a ^ b); // bitweise XOR exclusiv Oder, einzelne Bits umschalten 4 c = ~ a; // bitweise Negation, Bits invertieren 5 c = ( a << n); // Linksshift, Bits um n- Stellen verschieben, Multiplikation mit einer 2 er - Potenz = 2^ n 6 c = ( a >> n); // Rechtsshift, Bits um n- Stellen verschieben, Division mit einer 2 er - Potenz = 2^ n 7 c =!(a && b); // NAND, negierten UND 8 c =!(a b); // NOR, negierten ODER Tabelle 1.10 E1 E2 UND ODER XOR NEG NAND NOR Tabelle 1.11 OP Dezimal E E E1 & E E1 E E1 ˆ E ~ << << >> Maskieren von Bits // data = 0 x00 2 & // 0 x // Ergebnis // wenn data = 0 x08 6 & // 0 x // Ergebnis true 13

17 1 Mikrocontroller 1.6 Variablen und Datentypen Variablen deklarieren und initialisieren Deklaration Datentyp u. Variable dem Compiler bekannt machen 1 int z; // Deklaration u. Definition Definition Speicherplatz reservieren Initialisierung Variablen einen Wert zuweisen 1 int z = 4; // Deklaration u. Definition mit Initialisierung Trennung von Deklaration und Definition Anwendung: Programm mit mehreren C-Dateien 1 extern int y; // nur eine Deklaration 3 int y; // Definition erfolgt in einer anderen C- Datei Datentypen Tabelle 1.12 Typ Bit Wertebereich int8_t 8 char uint8_t 8 unsigned char int16_t 16 short, int uint16_t 16 unsigned short, int int32_t 32 long uint32_t 32 unsigned long int64_t 64 long long uint64_t 64 unsigned long long

18 1.6 Variablen und Datentypen Mit Variablen arbeiten 1 # include <avr /io.h> 2 uint8_ t a =2, b =3, hilf ; // Deklaration globaler Variablen 3 int main ( void ){ 4 hilf = a; 5 a = b; 6 b = hilf ; 7 } Werden Variablen nicht global deklariert, optimiert der Compiler sie einfach weg. (Speicherplatz sparen) Möglichkeiten, um die Optimierung zu umgehen Optimierungsgrad des Compilers reduzieren volatile vor die Variable setzen Schlüsselwort volatile bedeutet, die Variable wird bei jedem Lesevorgang neu aus dem Speicher gelesen. Anwendung: Interrupt Service Routinen (ISR) 1 # include <avr /io.h> 2 int main ( void ){ 3 volatile uint8_ t a =2, b =3, hilf ; // lokale Variablen mit dem Schl ü sselwort volatile 4 hilf = a; 5 a = b; 6 b = hilf ; 7 } Sichtbarkeit und Lebensdauer von Variablen vers. Konstanten vers. Globale Variablen Lokale Variablen Statische Variablen Gedächtnis einer Funktion (behält den Wert im Speicher) Konstante (nicht veränderbar) define - Makro (ersetzen) 15

19 1 Mikrocontroller 1 /* ju variablen. c */ 2 /* Variablen : global, lokal, statisch ; Konstante, define */ 3 # include <stdio.h> 4 # include <math.h> 5 # include < stdlib.h> 6 # include < stdbool.h> 7 # include < stdint.h> // int8_t, uint8_t 9 // Datentyp bool 10 typedef int bool ; 11 # define true 1 12 # define false 0 14 const double PI = ; // Konstante ( nicht ver ä nderbar ) 16 // Makro ( ersetzen ) 17 # define LED1 PB0 // Portpin PB0 18 # define LED2_ ON ( PORTB = (1 < < PB1 )) // Portpin PB1 HIGH 19 # define LED2_ OFF ( PORTB &= ~(1 < < PB1 )) // Portpin PB1 LOW 21 uint8_ t z1, z2; // Deklaration globaler Variablen 23 uint8_ t zaehler1 ( void ){ // Funktion 24 uint8_ t i = 1; // Deklaration lokaler Variablen 25 i ++; 26 z1=i; 27 return z1; 28 } 30 uint8_ t zaehler2 ( void ){ // Funktion 31 static uint8_ t i = 1; // Deklaration statische Variable 32 i ++; 33 z2=i; 34 return z2; 35 } 37 int main ( void ){ 38 // variablen 39 uint8_ t ergebnis = 0; 40 printf ("\ nvariablen : global, lokal, statisch \n"); 42 // Funktionsaufruf 43 ergebnis = zaehler1 (); printf ("Zä hler1 = %d\n",ergebnis ); 44 ergebnis = zaehler1 (); printf ("Zä hler1 = %d\n",ergebnis ); 45 ergebnis = zaehler1 (); printf ("Zä hler1 = %d\n",ergebnis ); 47 ergebnis = zaehler2 (); printf ("Zä hler2 = %d\n",ergebnis ); 48 ergebnis = zaehler2 (); printf ("Zä hler2 = %d\n",ergebnis ); 49 ergebnis = zaehler2 (); printf ("Zä hler2 = %d\n",ergebnis ); 16

20 1.7 Quellcode 51 return 0; 52 } 1.7 Quellcode dummy001.c Programm 1.1 dummy001.c Listing 1.1: Quellcode in C, dummy001.c 1 /* dummy001.c */ 2 /* ** 3 Titel : : dummy 4 Funktion : Led ein aus 5 Schaltung : LED verbinden mit Port D.0 6 Hardware : AVR Dragon 7 CPU = atmega88p 8 PROGRAMMER = dragon_ isp 9 PORT = usb 10 flashen : avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :w:$( PROGNAME ). hex :i 11 Prozessor : ATmega88PA mit 8 MHz = Sprache : C 13 Datum : ** */ 16 # define F_ CPU UL // Taktfrequenz : 8 MHz = # include <avr /io.h> 18 # include <util / delay.h> // definiert _delay_ms () 20 // eig. C- Funktionsbibliothek 21 // Funktionsaufruf : int a = potenziere (2,3) ; // basis, exponent 22 //# include " meinefkt.h" 24 // Datentyp bool 25 typedef int bool ; 26 # define true 1 27 # define false 0 29 // const double PI = ; 31 // Portpin 32 # define LED PD0 34 int main ( void ){ 35 /* 17

21 1 Mikrocontroller 36 DDRD = (1 < < PD0 ); // Richtungsregister PORTD PIND0 Pin2 auf Ausgang setzen 37 // 0 b > 0 b ; -- > setzen 38 */ 39 DDRD = (1<< LED ); // DDRD = DDRD (1<< LED ); 42 while (1) { 44 /* 45 // Version 1 46 PORTD = (1 < < PD0 ); // Portpin PD0 setzen = HIGH 47 // 0 b > 0 b ; -- > setzen 48 _delay_ms (1000) ; // 1s warten 49 PORTD &= ~(1 < < PD0 ); // Portpin PD0 loeschen = LOW 50 // 0 b > 0 b ; --> loeschen 51 _delay_ms (1000) ; // 1s warten 52 */ 54 /* 55 // Version 2 56 PORTD = (1 < < LED ); // Portpin PD0 setzen = HIGH 57 _delay_ms (1000) ; // 1s warten 58 PORTD &= ~(1 < < LED ); // Portpin PD0 loeschen = LOW 59 _delay_ms (1000) ; // 1s warten 60 */ 62 // Version 3 63 PORTD ^= (1 < < LED ); // Portpin PD0 toggeln HIGH / LOW 64 _delay_ms (1000) ; // 1s warten 67 } 68 } Makefile Programm 1.2 Makefile 1 # Makefile - Mikrocontroller C 2 # ju Jan -21 T14 :26 4 # ####################### 5 # Quellcode 7 ### C - Progammname 8 PROGNAME = dummy001 Listing 1.2: Makefile 18

22 1.7 Quellcode 10 TARGETS =\ 11 $( PROGNAME ). hex \ 14 # ####################### 15 # Variablen 17 ### linux 18 CXX := avr -g++ 19 CC := avr - gcc 21 ### Hardware : AVR Dragon 22 # lsusb o. dmesg 23 # ATmega88PA 24 CPU = atmega88p 25 PROGRAMMER = dragon_ isp 26 PORT = usb 27 ### Hardware : myavr Board MK2 USB 28 # CPU = atmega8 29 # PROGRAMMER = avr # PORT =/ dev / ttyusb0 31 # 32 ### Compileroptimierung : 0, 1, 2, 3, s ( Ressourcen einsparen u. Lauftzeit optimieren ; 0= min s = max ) 33 OPTI =-O0 34 # 35 CXXFLAGS =- mmcu =$( CPU ) -Wall -g -Wextra -std =c ++14 $( OPTI ) -Wno - missing - field - initializers 36 CXXLIBS = meinefkt.c -lm 37 # 38 CFLAGS =- mmcu =$( CPU ) -Wall -g -Wextra -std = c11 $( OPTI ) -Wno - missing - field - initializers 39 CLIBS = meinefkt.c -lm 41 # ####################### 42 # Compilieren 44 all : $( TARGETS ) 47 %. hex : %. cpp 48 avr -g++ $( CXXFLAGS ) $( PROGNAME ). cpp $( CXXLIBS ) -o $( PROGNAME ). elf 49 avr - objcopy $( PROGNAME ). elf -O ihex $( PROGNAME ). hex 51 %. hex : %.c 52 avr - gcc $( CFLAGS ) $( PROGNAME ).c $( CLIBS ) -o $( PROGNAME ). elf 53 avr - objcopy $( PROGNAME ). elf -O ihex $( PROGNAME ). hex 19

23 1 Mikrocontroller 56 # ####################### 57 # Brennen und Testen mit avrdude 59 ### Vorrausetzung : gruppe dialout : Serielle Ger ä te benutzen 60 ### sudo usermod - ag dialout jan 61 ### writeflash = brennen = flashen 62 flashen : 63 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :w:$( PROGNAME ). hex :i echo " Flash - Speicher = Programmspeicher = Quellcode ; ca x beschreibbar " 66 readflash : 67 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :r: readflash. hex :i echo " Flash - Speicher = Programmspeicher = Quellcode auslesen " 70 writeflash : echo " Flash - Speicher = Programmspeicher = Quellcode ; ca x beschreibbar " 72 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U flash :w: readflash. hex :i 74 readeeprom : 75 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U eeprom :r: readeeprom. hex :i echo " EEPROM - Speicher = Festwertspeicher auslesen " 78 writeeeprom : 79 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U eeprom :w: readeeprom. hex :i echo " EEPROM - Speicher = Festwertspeicher ; ca x beschreibbar " 82 readfuse : 83 avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -u -U hfuse :r: readhfuse. binaerzahl :b -U lfuse :r: readlfuse. binaerzahl :b echo " Fuse - Bits wurde in Datei readhfuse. binaerzahl u. readlfuse. binaerzahl geschrieben." 86 # writefuse : 87 ### siehe AVR Datenblatt_ATmega88PA_komplett. pdf 88 ### Fuse High Byte 89 ### // Bit No. 90 ### fabrikneu : 0 b = 0 xdf 91 ### praxis : 0 b = 0 xdf // keine Ä nderung 92 ### Low Fuse Byte 93 ### CKDIV8 deaktivieren, damit der Mikrocontroller mit einer Taktfrequenz von 8 MHz arbeitet. 94 ### // Bit No. 20

24 1.7 Quellcode 95 ### fabrikneu : 0 b = 0 x62 96 ### praxis : 0 b = 0 xe2 // CKDIV8 deaktivieren 97 writefuse : echo " Achtung : Fuse High Byte u. Fuse Low Byte siehe AVR Datenblatt_ATmega88PA_komplett. pdf " echo " Befehle sind deaktiviert!" 100 # avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U hfuse :w:0 xdf :m 101 # avrdude -p $( CPU ) -c $( PROGRAMMER ) -P $( PORT ) -U lfuse :w:0 xe2 :m 103 # ####################### 104 # Info 106 info : echo " Info : Makefile - Mikrocontroller C; ju Jan -21 T14 :26 " "avr - gcc " echo " Hardware : AVR Dragon " " AVR Datenblatt_ATmega88PA_komplett. pdf " " CPU = atmega88p " echo " PROGRAMMER = dragon_ isp " " PORT = usb " 116 # ####################### 117 # Hilfe 119 hilfe : " make " echo " make clean " echo " make flashen " echo " make readflash " echo " make writeflash " echo " make readeeprom " echo " make writeeeprom " echo " make readfuse " echo " make writefuse // Achtung : Befehle sind deaktiviert!" echo " make hilfe " echo " make info " 132 # ####################### 133 # clean 135 clean : 136 rm -f $( TARGETS ) *. hex 137 rm -f $( TARGETS ) *. elf 138 rm -f $( TARGETS ) *.o *.*~ *~ 21

25 1 Mikrocontroller Install unter Linux Programm 1.3 gcc-avr avrdude 1 #!/ bin / bash -e 2 # chmod u+x 3 # gcc - avr avrdude Listing 1.3: gcc-avr avrdude 5 sudo apt - y update && sudo apt - y upgrade 7 sudo apt - y install gcc - avr 8 sudo apt - y install binutils - avr 9 sudo apt - y install avr - libc 10 sudo apt - y install avrdude 11 # sudo usermod - ag dialout jan 13 sudo apt autoremove 22