Mikrocontroller. Programmierung in C. Jan Unger

Transkript

1 Mikrocontroller Programmierung in C Jan Unger Wuppertal,

2 II Inhaltsverzeichnis 1 Kapitel 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 Kapitel Variablen und Datentypen Variablen deklarieren und initialisieren Datentypen Mit Variablen arbeiten Sichtbarkeit und Lebensdauer von Variablen vers. Konstanten 10 3 ATmega88pa ATmega88PA Eckdaten AVR-Dragon In-System-Programming Fotos Avrdude Brennen und Testen mit avrdude readflash writeflash readeeprom writeeeprom readhfuse und readlfuse writefuseshex Quellcode Quellcode dummy001.c Makefile

3 Inhaltsverzeichnis Seite IIIvon Install unter Linux

4 1 1Kapitel 1.1 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 Tabelle = Ausgangspin auf High 0 = Ausgangspin auf Low Tabelle 1.1: Ports 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 ;

5 1 Kapitel Seite 2von bin - kein ISO-C 1 DDRB = 0 b ; 3. übersichtliche Schreibweise 1 DDRB = (1<< DDB4 ) (1 < < DDB5 ) (1 < < DDB7 ); 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

6 1 Kapitel Seite 3von 28 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 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

7 1 Kapitel Seite 4von 28 2 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 Tabelle 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

8 1 Kapitel Seite 5von 28 Tabelle 1.2: Pull-Up Widerstand 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 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.3 Tabelle 1.3: Binaer-Hexadezimalzahlen hex dez bin a b c d e f

9 1 Kapitel Seite 6von 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.4 Tabelle 1.4: Wahrheitstabelle E1 E2 UND ODER XOR NEG NAND NOR Tabelle 1.5 Tabelle 1.5: Bit-Operatoren OP Dezimal E E E1 & E E1 E E1 ˆ E ~ << << >>

10 1 Kapitel Seite 7von Maskieren von Bits // data = 0 x00 2 & // 0 x // Ergebnis // wenn data = 0 x08 6 & // 0 x // Ergebnis true

11 8 2Kapitel 2.1 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 2.1

12 2 Kapitel Seite 9von 28 Tabelle 2.1: Datentypen 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 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 }

13 2 Kapitel Seite 10von 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) 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;

14 2 Kapitel Seite 11von } 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 ); 51 return 0; 52 }

15 12 3ATmega88pa 3.1 ATmega88PA Eckdaten Features Tabelle 3.1: Eckdaten 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

16 3 ATmega88pa Seite 13von 28 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. Die Signale dieses Headers sind»level-converted«, erlauben also auch den Anschluß an Boards mit abweichender Stromversorgung (1,8V 5,5V) Fotos Abbildung 3.1 Abbildung 3.1: ATmega88-Architektur

17 3 ATmega88pa Seite 14von 28 Abbildung 3.2 Abbildung 3.2: ATmega88-Block-Diagramm Abbildung 3.3 Abbildung 3.3: ATmega88-Grundschaltung Abbildung 3.4 Abbildung 3.5

18 3 ATmega88pa Seite 15von 28 Abbildung 3.4: Spannungsstabilisierung Abbildung 3.5: ATmega88-Pins

19 3 ATmega88pa Seite 16von 28 Abbildung 3.6 Abbildung 3.6: ISP-Schnittstelle Abbildung 3.7 Abbildung 3.7: ATmega88-Schaltung1 Abbildung 3.8 Abbildung 3.9

20 3 ATmega88pa Seite 17von 28 Abbildung 3.8: ATmega88-Schaltung2 Abbildung 3.9: ATmega88-Lauflicht

21 18 4Avrdude 4.1 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.

22 4 Avrdude Seite 19von 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 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

23 4 Avrdude Seite 20von 28 Datei readhfuse.binaerzahl // Bit No. 2 fabrikneu : 0 b = 0 xdf 3 praxis : 0 b = 0 xdf // keine Ä nderung Tabelle 4.1 Tabelle 4.1: High Fuse Byte 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 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 Tabelle 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.

24 4 Avrdude Seite 21von 28 Tabelle 4.2: Low Fuse Byte 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

25 22 5Quellcode 5.1 Quellcode dummy001.c Programm 5.1 dummy001.c Listing 5.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

26 5 Quellcode Seite 23von # define LED PD0 34 int main ( void ){ 35 /* 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 }

27 5 Quellcode Seite 24von Makefile Programm 5.2 Makefile 1 # Makefile - Mikrocontroller C 2 # ju Jan -21 T14 :26 4 # ####################### 5 # Quellcode 7 ### C - Progammname 8 PROGNAME = dummy TARGETS =\ 11 $( PROGNAME ). hex \ Listing 5.2: Makefile 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 #

28 5 Quellcode Seite 25von 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 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

29 5 Quellcode Seite 26von 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. 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 "

30 5 Quellcode Seite 27von 28 "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 *.*~ *~ Install unter Linux Programm 5.3 gcc-avr avrdude 1 #!/ bin / bash -e 2 # chmod u+x 3 # gcc - avr avrdude Listing 5.3: gcc-avr avrdude 5 sudo apt - y update && sudo apt - y upgrade

31 5 Quellcode Seite 28von 28 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