Embedded C und C++ S. Arlt/K. Pahnke - TU Ilmenau
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
' $
embedded C und C++
S. Arlt/K. Pahnke
Fakultät EI
Fachbereich Elektronische Schaltungen und Systeme
emsys GmbH
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 1' $
Inhalt I
& %
' $
Teil I Programmiersprache C
1. Grundlagen
• Einführung
• Syntax
• Programmstruktur
• Konstanten, Variablen (Basistypen, abgeleitet)
• Operatoren
• Ablaufsteuerung
• Arbeit mit Zeigern
2. Funktionen der ANSI-C Library
• Ein–/Ausgabe, Filearbeit
• String–Funktionen
• Arbeit mit dem Freispeicher
3. Werkzeuge
• make
• ctags, etags
• compiler, linker, assembler
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 2' $
Inhalt II
& %
' $
Teil II Praktische Algorithmen in C
1. Einführung
2. Elementare Datenstrukturen
• verkettete Listen (einfach / doppelt)
• Stapel (Stack)
• Schlangen (Queue)
• dynamische Felder (Arrays)
3. Bäume
• binäre Bäume
• allgemeine Bäume
• ausgeglichene Bäume
• Traversierung mittels Rekursion
4. Suchalgorithmen und gestreute Speicherung
• elementare Suchverfahren (Binärsuche)
• Hashing
• assoziative Speicherung (Dictionaries)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 3' $
Inhalt III
& %
' $
Teil III Object Oriented Programming
1. C++ Basics
• Data Abstraction
• Inheritance
2. Object Oriented Programming for Embedded Systems
• C++ as better C
• Embedded C++
• Embedded C++ Library
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 4' $
Inhalt IV
& %
' $
Teil IV Accessing and Modelling Hardware in C/C++
1. C++ Basics
• Basics of Hardware Manipulation using C/C++
• Common Techniques for Controlling Devices written in ANSI-C/C++
• Portability
• Blinking LED in C
• Blinking LED in C++
2. Programming EVA Board LPCEB2000
• Hardware
• Software
• Program Samples
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 5' $
Inhalt V
& %
' $
Teil V Embedded OS
1. Basic Concepts of Embedded (RT)OS
• Tasks as basic blocks
• Task synchronisation (Mutex/Semaphore)
• Task communication (Message Queue)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 6' $
Literatur
& %
' $
Einsteiger:
Lowes/Paulik Programmieren mit C“, Teubner Stuttgart, 1992
”
Kernighan, B.; Ritchie, D. The C Programming Language“
”
Wollenstein; Florian C++ Programmierung für Anfänger“, Books on Demand GmbH
”
2004
Fortgeschrittene:
Clauß/Fischer Programmieren mit C“ Reihe Technische Informatik, Verlag Technik GmbH
”
Berlin 1988
Stroustrup; Bjarne Die C++ Programmiersprache“, Addison-Wesley
”
Barr; Michael Programming Embedded Systems“, O‘Reiley 1999
”
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 7' $
Einführung I
& %
' $
“I think there is a world market for maybe five computers”
Thomas Watson, Chairman of IBM, 1943
“There is no reason anyone would want a computer in their home”
Ken Olsen, President of Digital Equipment Corporation, 1977
Begriff:
Bei Embedded Systems handelt es sich um einen oder mehrere durch Software kontrollier-
te(n) Computer oder Mikrocontroller, die Teil eines größeren Systems sind und deren primäre
Funktionen, meist steuerungstechnischer Art, für definierte Aufgaben fixiert sind. Anwen-
dungen finden sich z.B. im Automobilbau (Motorsteuerung, Navigation, ABS, Bedienung),
im Haushalt (Waschmaschine, Heizung, Mikrowelle, Hausbus, ...) und in peripheren einheiten
der Computer (Festplatte, Netzwerkkarte, CD, ...)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 8' $
Einführung II
& %
' $
1. Entstehung von C
• Bell-LABs Entwicklung der Sprache B aus BCPL
• 1972: Kernighan/Ritchie Sprache C
2. Eigenschaften
• Hochsprache, für maschinennahe Arbeit geeignet
• leistungsfähig und effizient
• kurz, für ,,schreibfaule” Programmierer
• keine E/A-Konstrukte und dadurch portabel
3. Verbreitung
• Betriebssystem UNIX in C geschrieben
• neben COBOL und FORTRAN ein Industriestandard
4. Weiterentwicklung
• ANSI–Standard
• Objektorientierte Programmierung C++
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 9' $
Programmstruktur
& %
' $
C–Programm := Menge von Funktionen
Die verschiedenen Funktionen können auf mehrere Dateien verteilt sein. Funk-
tionen dürfen nicht verschachtelt sein (vgl. PASCAL).
Die Abarbeitung eines Programms beginnt in der Funktion main().
int main(void) /* Ausgabe: Mein erstes C-Programm */
{
printf(’’Mein erstes C-Programm \n ’’);
return 0;
}
int main(void) /* Ausgabe: Mein erstes C-Programm */
{
printf(’’Mein erstes’’);
printf(’’C-Programm\n ’’);
return 0;
}
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 10' $
Aufbau einer Funktion
& %
' $
• Funktionsname
muß mit Buchstaben oder beginnen
• Parameterliste
in runde Klammern eingeschlossen, kann leer sein
• Anweisungsblock
in geschweifte Klammern eingeschlossen, kann leer sein
Beispiel des einfachsten Programms:
main() { }
Beispiel einer Funktion:
int max(int a, int b) /* Kopf mit formalen Parametern */
{ /* Anweisungsblock */
if( a > b )
return a;
else
return b;
}
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 11' $
Schlüsselworte in C
& %
' $
auto default for short union
assert do goto signed unsigned
break double if sizeof void
case enum int static volatile
char extern long struct while
const else register switch
continue float return typedef
Trennzeichen:
• Leerzeichen
• Tabulator
• Newline
• Kommentar /* Text... */
Es sind keine geschachtelten Kommentare zugelassen !
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 12' $
Grunddatentypen
& %
' $
Speicherplatzbedarf:
Typ 16 Bit 32 Bit Wertevorrat Beispiel
char 8 8 −27 ...27 − 1 char c, *cptr;
int 16 32 min.−215 ...215 − 1 int i, *iptr;
short 16 16 −215 ...215 − 1 short s, *sptr;
long 32 32 −231 ...231 − 1 long l, *lptr;
unsigned 16 32 min.0...216 − 1 unsigned u, *uptr;
float 32 32 float f, *fptr;
double 64 64 double d, *dptr;
Achtung:
unsigned steht für unsigned int,
und ist weiterhin kombinierbar mit
unsigned short
unsigned long
unsigned char
long double (nur ANSI–C–Compiler)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 13' $
Konstanten
& %
' $
1. Integer
• dezimal
123,
123L, 123456 /* long */
• hexadezimal
0x0f3,
0xffe3f /* long */,
• oktal
017,
017L /* long */
2. Real
12., 1E+12, 1.0E+12, 0.23, .23
Achtung:
alle Real-Konstanten sind grundsätzlich vom Typ double.
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 14' $
Zeichenkonstanten
& %
' $
Eine Zeichenkonstante wird in Apostrophe eingeschlossen.
Ihr Wert entspricht dem verwendeten Zeichensatz (z.Bsp. ASCII).
Buchstaben und Zeichen:
’A’ /* Buchstabe A, Wert=65 */
’0’ /* Ziffer 0, Wert=48 */
’@’ /* Zeichen @, Wert=64 */
Ersatzdarstellungen nicht darstellbarer Zeichen:
’\a’ /* bell */
’\n’ /* Newline */
’\r’ /* Carrige return */
’\t’ /* Tabulator */
’\b’ /* Backspace */
’\v’ /* Vertikaltabulator */
’\\’ /* Backslash */
’\0’ /* (ASCII)0 */
’\377’ /* Bitmuster oktal */
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 15' $
Zeichenkettenkonstanten
& %
' $
Zeichenketten werden in Quoten (” ”) eingeschlossen.
Beispiel:
”Mein erstes C–Programm”
Jede Zeichenkette ist durch eine (ASCII)Null abgeschlossen, die bei der Re-
präsentation berücksichtigt werden muß!
Somit ist die Zeichenkettenkonstante:
”Datum”
identisch zu
’D’ ’a’ ’t’ ’u’ ’m’ ’\0’
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 16' $
Variablen
& %
' $
Variablen sind durch Typ und Speicherklasse beschriebene Bezeichner.
(Zeichenvorrat: [ A-Za-z][ A-Za-z0-9]*)
Je Compiler sind 8 bis 32 Zeichen relevant.
• Variablentyp:
Basistyp oder abgeleiteter Typ
• Speicherklasse:
auto
static
extern
register
Hinweis:
Deklaration
Ein Bezeichner wird mit einem Typ versehen (bekannt gemacht), aber nicht
physisch angelegt.
Definition
Wie Deklaration und zusätzlich reservieren von Speicherplatz.
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 17' $
Typkonvertierungen
& %
' $
char
int
unsigned char
short
unsigned int
unsigned short
long
unsigned long
float double
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 18' $
Operatoren
& %
' $
1. Deklarationsoperatoren
* Zeiger
[] Vektor
() Funktion
2. unäre Operatoren
+ Vorzeichen (nur Exponent)
– Vorzeichen
* Zeigeroperator (dereferenziert Zeiger)
& Adreßoperator (liefert Adresse einer Instanz)
++ Inkrement–Operator
–– Dekrement–Operator
sizeof Größe eines Objektes/Typs in Byte ermitteln
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 19' $
Operatoren
& %
' $
3. binäre Operatoren
• arithmetisch
% Modulo, Rest der ganzzahligen Division
* Multiplikation (Integer und Real)
/ Division (Integer und Real)
+ Addition
– Subtraktion
• Vergleichsoperatoren
>, >= größer, größer gleich' $
Operatoren
& %
' $
• bitorienterte Operatoren
& UND (z.Bsp Maskieren von Bits)
| ODER (z.Bsp Setzen von Bits)
ˆ Exklusiv-ODER
> Bit-shift rechts
˜ Einerkomplement (unär)
• logische Operatoren
&& logisches UND
|| logisches ODER
! logische Negation (unär)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 21' $
Entscheidungsoperator
& %
' $
Sollte bei der Ermittlung eines Wertes nach einer Entscheidung verwendet
werden.
Syntax:
ausdruck1 ? ausdruck2 : ausdruck3
Der Wert des Gesamtausdrucks ist vom Wahrheitswert des
ausdruck1 abhängig.
Beispiel:
if( a > b )
max = a;
else
max = b;
kann verkürzt werden zu
max = a > b ? a : b;
auch als Return-Wert verwendbar
int abs(int x) /* Absolutwert */
{
return ( x > 0 ? x : -x);
}
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 22' $
spezielle Operatoren
& %
' $
Komma-Operator
Syntax: ausdruck1 , ausdruck2
• Auswertung von links nach rechts
• Typ und Wert werden durch rechten Ausdruck bestimmt
x = 1, y += x /* Wert des Ausdrucks ist y */
Inkremet-Operator
int x = 0, y;
y = x++; /* y = x; x = x + 1; */
y = ++x; /* x = x + 1; y = x; */
Dekremet-Operator
int x = 0, y;
y = x--; /* y = x; x = x - 1; */
y = --x; /* x = x - 1; y = x; */
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 23' $
Vorrang und Assoziativität
& %
' $
Es ist vom konkreten Compiler abhängig, in welcher Reihenfolge die Auswer-
tung von gleichberechtigten Operanden erfolgt:
x = f(y++) + g(y);
() ] -> . L
! ++ -- * & - sizeof(typcast) R
* / % L
+ - L
> L
< >= L
== != L
& L
^ L
| L
&& L
|| L
? : R
= op= R
, L
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 24' $
Ablaufsteuerung
& %
' $
Block := Folge von Anweisungen
• Vereinbarungen nur am Blockanfang
• nach schließender Klammer kein Semikolon
• Block wird als eine Anweisung betrachtet
• anstelle einer Anweisung kann also ein Block stehen
• Schachteln von Blöcken ist möglich
int main(void) /* Ablauf ohne Verzweigung */
{
int i; /* Definition der Variablen i */
char c;
...
i = 0; /* Anweisung */
...
return 0;
}
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 25' $
Entscheidung
& %
' $
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 26' $
switch–Anweisung
& %
' $
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 27' $
Schleifen
& %
' $
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 28' $
for–Anweisung
& %
' $
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 29' $
unbedingte Sprünge
& %
' $
1. goto
• Vereinbarung einer (Ziel-)Marke notwendig
• Sprünge nur innerhalb einer Funktion möglich
• sinnvoll zum schnellen Verlassen mehrfach geschachtelter Schleifen
Beispiel:
marke: /* Endlosschleife */
goto marke;
2. return
• zurück an übergeordnetes Programm
• Wertübergabe ist möglich (Ausnahme void)
• zum vorzeitigen Verlassen von ,,main” ist der
Exit-Handler mit
exit(parameter);
zu rufen
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 30' $
Zeiger
& %
' $
• uneingeschränkte Verwendung möglich
• Zeigerkonzept besonders gut unterstützt
• zwei sinnvolle Werte für Zeiger:
– (Hauptspeicher-)Adresse eines Objekts vom gleichen Typ
– NULL
• Operatoren:
– & lvalue Zeiger auf Objekt, “Adresse von ...”
– * zeiger indirekter Zugriff, “Inhalt von ...”
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 31' $
Zeiger-Arithmetik
& %
' $
Folgende Operationen sind zugelassen:
Zeiger + Integer Ergebnis Zeiger
Zeiger − Integer Ergebnis Zeiger
Zeiger − Zeiger Ergebnis Integer
Vergleich
Zeiger mit N U LL
Achtung:
Die Integerwerte sind als Feld-Indizees zu interpretieren !
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 32' $
Standard-Bibliothek
& %
' $
Leistungen:
• Ein/Ausgabe zeilen– und zeichenweise
• formatgesteuerte Ein/Ausgabe
• Dateizugriff
• dynamische Speicherverwaltung
• Stringmanipulationen
• Klassifizierung von Zeichen (upper, lower, ...)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 33' $
Formatgesteuerte Ausgabe
& %
' $
int printf(char *format, ...);
Ausgabe auf stdout
int sprintf(char *buf, char *format, ...);
Ausgabe in Hauptspeicher
int fprintf(FILE *fp, char *format, ...);
Ausgabe auf Datei oder stderr
Formatstring:
1. darstellbare, nicht zu interpretierende Zeichen werden kopiert
2. nicht darstellbare Zeichen lösen Steuervorgänge aus
3. interpretierbare Zeichen repräsentieren Konvertierungen
Aufbau:
% [f lags] [ [0] F eldbreite ] [.[Genauigkeit] ] [ l ]konv.Zeichen
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 34' $
Dateifunktionen
& %
' $
1. Datei eröffnen
FILE *fopen(char *filename, char *mode);
mode Zugriffsrechte existiert existiert nicht
”r” read ok Fehler
”w” write löschen Eröffnen
”a” append ok Eröffnen
”r+” read + write ok Fehler
”w+” write + read löschen Eröffnen
Achtung:
Unter MS–Win werden CR-LF in Texten als Newline verwendet. Die Defaultein-
stellung eröffnet eine Datei im Textmodus, was zu einer Konvertierung dieser
Zeichenkombination führt.
Binärmodus:
”rb”,”r+b”,”wb”,”w+”,”ab”
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 35' $
Dateifunktionen
& %
' $
2. Datei schließen
int fclose(FILE *fp);
leeren des Dateipuffers und schließen der Datei.
int fcloseall();
schließen aller Dateien.
3. Dateipuffer leeren
int fflush(FILE *fp);
Ausgabe aller gepufferten Daten erzwingen.
4. Positionieren in Datei
long ftell(FILE *fp);
Liefert Offset von Dateianfang in Byte
int fseek(FILE *fp, long offset, int mode);
Setzen des Dateizeigers auf bestimmte Position
SEEK SET zum Dateianfang
SEEK CUR zur aktuellen Position
SEEK END zum Dateiende
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 36' $
Stringfunktionen (Auswahl)
& %
' $
int strlen(char *s);
ermittelt die Länge der Zeichenkette in Byte (ohne 0 \00 )
int strcmp(char *s1, char *s2);
vergleicht zwei Zeichenketten lexikographisch.
int strncmp(char *s1, char *s2, int n);
vergleicht ’n’ Zeichen zweier Zeichenketten lexikographisch.
char *strcat(char *s1, char *s2);
hängt Zeichenkette s2 an s1 an (Achtung: Speicherplatz !)
char *strncat(char *s1, char *s2, int n);
hängt ’n’ Zeichen von s2 an s1 an
char *strcpy(char *s1, char *s2);
kopieren von s2 auf s1 an (Achtung: Speicherplatz !)
char *strncpy(char *s1, char *s2, int n);
’n’ Zeichen von s2 auf s1 kopieren
char *strchr(char *s, char c);
Suche des Zeichens ’c’ in ’s’ (von vorn)
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 37' $
Memoryfunktionen
& %
' $
char *memcpy(char *dest, char *source, int anz bytes);
Kopieren von Speicherbereichen (Vorsicht bei Überlappung)
char *memccpy(char *dest, char *source, int c, int anz bytes);
Kopiert bis einschließlich ’c’ (Adresse zurück)
char *memchr(char *buf, int c, int anz bytes);
Suche von ’c’ (Adresse zurück)
char *memset(char *buf, int c, int anz bytes);
Initialisieren mit ’c’
int memcmp(char *s1, char *s2, int anz bytes);
Vergleich zweier Speicherbereiche
Die Benutzung dieser Funktionen ergibt sehr schnelle Programme.
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 38' $
Speicherverwaltung
& %
' $
1. Speicher anfordern
char *malloc(int anz bytes);
allocieren von anz Bytes
char *calloc(int block anz, int size);
allocieren von block anz Blöcken der Größe size
2. Speicher verändern
char *realloc(char *oldbuf, int anz bytes);
Grösse von oldbuf auf anz Bytes verändern
3. Speicher freigeben
void free(char *buf );
Rückgabe des angeforderten Speichers
Hinweise:
• immer den Rückgabewert mit NULL vergleichen
• nur abgeforderten Speicher wieder freigeben (sonst Beule ! )
• nicht kleckern, sondern klotzen !
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 39' $
Preprozessor
& %
' $
• wird vor jedem Compilerlauf gestartet
• verarbeitet Zeilen mit ’#’ an erster Position
Befehle
#include < datei >
#define M akroname
#undef M akroname
Bedingte Compilierungg
#ifdef M akroname
#ifndef M akroname
#else
#endif
Weitere Preprozessor-Befehle:
#line Konstante ”dateiname”
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 40' $
ANSI–C Preprozessor
& %
' $
Erweiterung der bedingten Compilierung:
#if defined (M akroname)
#elif defined (M akroname)
#else
#endif
implementierungsabhängige Aktionen:
#pragma (Sequenz)
• eingebaute Makros:
LINE Nummer der aktuellen Quelltextzeile
FILE Name der aktuell compilierten Datei
DATE aktuelles Datum der Form ”Mmm dd yyy”
TIME aktuelle Uhrzeit der Form ”hh:mm:ss”
STDC Konstante (Wert 1), wenn ANSI-kompatibel
• Bildung von Zeichenketten, wenn Ersatzsymbolfolge mit ’#’ beginnt
• Verkettung von Symbolen mittels ’##’
• vor dem ’#’ dürfen Lerrzeichen/Tabulatoren stehen
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 41' $
allgemeine Hinweise
& %
' $
• Include Dateien
– eine für Projekt − > keine Wiederverwendung von Teilen
+ Module nach ,,Objekten” bilden, (ev. mit Testrahmen)
• Variablen
– globale sind zur Kommunikation unübersichtlich
+ Lokalität bietet Abgeschlossenheit, als Parameter übergeben
• Kommantare
– zukommentiertes Programm, undokumentierte Seiteneffekte
+ selbstkommentierende Symbolnamen, Modul/Fkt.kommentar
• Strukturierung
– keine oder freie
+ Blockbildung mit Tabulatoren
• Codegestaltung
– Spaghetti-Code (elend lange Funktionen...)
+ Eine Funktion nicht länger als eine Bildschirmseite
• Namenskonventionen
– bunt gemischt
+ symbol. Konstanten groß, Variablen klein, Funktionsname dürfen Groß-
buchstaben als Worttrenner enthalten,
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 42' $
Tools
& %
' $
• make
– Automatische Generierung von Programmen (compile, link)
– build“-Kriterium ≡ time stamps“
” ”
– Vermeidung von Redundanz
• ctags/etags
– Generierung eines tag- (index-) files“- tags/TAGS für vi(vim)/emacs
”
– Auffinden von Deklarationen und Definitionen durch
– cross references“
”
& %
Arlt/Pahnke TUI/EI/ESS emsys eC CPP-I 43Sie können auch lesen
