Grundlagen der Systemnahen Programmierung in C (GSPiC)

Referenzen
Grundlagen der Systemnahen
Programmierung in C (GSPiC)
[1]
ATmega32 8-bit AVR Microcontroller with 32K Bytes In-System
Programmable Flash. 8155-AVR-07/09. Atmel Corporation. July 2009.
[2]
Manfred Dausmann, Ulrich Bröckl, Dominic Schoop, et al. C als erste
Programmiersprache: Vom Einsteiger zum Fortgeschrittenen. (Als E-Book aus
dem Uninetz verfügbar; PDF-Version unter /proj/i4gspic/pub).
Vieweg+Teubner, 2010. ISBN: 978-3834812216. URL:
http://www.springerlink.com/content/978-3-8348-12216/#section=813748&page=1.
Lehrstuhl für Informatik 4
Verteilte Systeme und Betriebssysteme
[3]
Brian W. Kernighan and Dennis MacAlistair Ritchie. The C Programming
Language. Englewood Cliﬀs, NJ, USA: Prentice Hall PTR, 1978.
Friedrich-Alexander-Universität
Erlangen-Nürnberg
[4]
Brian W. Kernighan and Dennis MacAlistair Ritchie. The C Programming
Language (2nd Edition). Englewood Cliﬀs, NJ, USA: Prentice Hall PTR, 1988.
ISBN: 978-8120305960.
[5]
Dennis MacAlistair Ritchie and Ken Thompson. “The Unix Time-Sharing
System”. In: Communications of the ACM 17.7 (July 1974), pp. 365–370. DOI:
10.1145/361011.361061.
Sommersemester 2014
http://www4.cs.fau.de/Lehre/SS14/V_GSPIC
V_GSPIC_handout
V_GSPIC_handout
Daniel Lohmann
c dl
Referenzen
[GDI]
[6]
Veranstaltungsüberblick
(Forts.)
Volkmar Sieh and Frank Bauer. Grundlagen der Informatik. Vorlesung.
(Referenzen beziehen sich auf Druckversion). Friedrich-Alexander-Universität
Erlangen-Nürnberg, Department Informatik, 2012 (jährlich). URL:
https://gdi.cs.fau.de/w12/material.
9 Funktionen
1 Einführung
10 Variablen
2 Organisation
11 Präprozessor
Teil B: Einführung in C
3 Java versus C – Erste Beispiele
Teil C: Systemnahe Softwareentwicklung
Jim Turley. “The Two Percent Solution”. In: embedded.com (Dec. 2002).
4 Softwareschichten und Abstraktion
12 Programmstruktur und Module
5 Sprachüberblick
13 Zeiger und Felder
6 Einfache Datentypen
14 µC-Systemarchitektur
7 Operatoren und Ausdrücke
15 Nebenläuﬁgkeit
8 Kontrollstrukturen
16 Speicherorganisation
http://www.embedded.com/story/OEG20021217S0039, visited 2011-04-08.
V_GSPIC_handout
c dl
Teil A: Konzept und Organisation
David Tennenhouse. “Proactive Computing”. In: Communications of the ACM
(May 2000), pp. 43–45.
V_GSPIC_handout
[7]
GSPiC (SS 14)
GSPiC (SS 14)
Überblick: Teil A Konzept und Organisation
Grundlagen der Systemnahen
Programmierung in C (GSPiC)
Teil A Konzept und Organisation
Daniel Lohmann
Friedrich-Alexander-Universität
Erlangen-Nürnberg
V_GSPIC_handout
V_GSPIC_handout
Lehrstuhl für Informatik 4
Verteilte Systeme und Betriebssysteme
Sommersemester 2014
http://www4.cs.fau.de/Lehre/SS14/V_GSPIC
Lernziele
Vertiefen
1 Einführung
1.1 Ziele der Lehrveranstaltung
1.2 Warum µ-Controller?
1.3 Warum C?
1.4 Literatur
2 Organisation
2.1 Vorlesung
2.2 Übung
2.3 Lötabend
2.4 Prüfung
2.5 Semesterüberblick
Motivation: Eingebettete Systeme
des Wissens über Konzepte und Techniken
der Informatik für die Softwareentwicklung
Ausgangspunkt:
Schwerpunkt:
Omnipräsent:
Grundlagen der Informatik (GdI)
Systemnahe Softwareentwicklung in C
98–99 Prozent aller Prozessoren wurden im Jahr
2000 in einem eingebetteten System verbaut [6]
Kostensensitiv: 70–80 Prozent aller produzierten Prozessoren sind
DSPs und µ-Controller, 8-Bit oder kleiner [6, 7]
Entwickeln von Software in C für einen µ-Controller (µC)
V_GSPIC_handout
Verstehen
der technologischen Sprach- und Hardwaregrundlagen
für die Entwicklung systemnaher Software
Die Sprache C verstehen und einschätzen können
Umgang mit Nebenläuﬁgkeit und Hardwarenähe
c dl
GSPiC (Teil A, SS 14)
1 Einführung | 1.1 Ziele der Lehrveranstaltung
1–1
01-02-Konzept: 2014-04-03
SPiCboard-Lehrentwicklungsplattform mit ATmega-µC
Praktische Erfahrungen in hardwarenaher Softwareentwicklung machen
Marktanteil (Umsatz/Stückzahl) im Jahr 2002 [7]
c dl
GSPiC (Teil A, SS 14)
1 Einführung | 1.2 Warum µ-Controller?
1–2
Motivation: Eingebettete Systeme
Omnipräsent:
Motivation: Die ATmega-µC-Familie (8-Bit)
98–99 Prozent aller Prozessoren wurden im Jahr
2000 in einem eingebetteten System verbaut [6]
Kostensensitiv: 70–80 Prozent aller produzierten Prozessoren sind
DSPs und µ-Controller, 8-Bit oder kleiner [6, 7]
25 Prozent der Stellenanzeigen für EE-Ingenieure
enthalten die Stichworte embedded oder automotive (http://stepstone.com, 4. April 2011)
Die Veröﬀentlichungen [6, 7] sind um die 10 Jahre alt!
Man kann dennoch davon ausgehen, dass die
relativen Größenordnungen nach wie vor stimmen
2014 liegt der Anteil an 8-Bittern (vermutlich) noch über 50 Prozent
4-Bitter dürften inzwischen jedoch weitgehend ausgestorben sein
c dl
GSPiC (Teil A, SS 14)
1 Einführung | 1.2 Warum µ-Controller?
UART
I²C
AD
1/-
-
-
-
0.31
64 B
6
1/-
-
-
4*10
0.66
2 KiB
128 B
18
1/1
1
1
-
1.06
ATMEGA4820
4 KiB
512 B
23
2/1
2
1
6*10
1.26
ATMEGA8515
8 KiB
512 B
35
1/1
1
-
-
2.04
ATMEGA8535
8 KiB
512 B
32
2/1
1
1
-
2.67
4.03
1 KiB
ATTINY13
1 KiB
ATTINY2313
SRAM
Price (e)
ATMEGA169
16 KiB
1024 B
54
2/1
1
1
8*10
ATMEGA64
64 KiB
4096 B
53
2/2
2
1
8*10
5.60
ATMEGA128
128 KiB
4096 B
53
2/2
2
1
8*10
7.91
Sichtbar wird: Ressourcenknappheit
Flash (Speicher für Programmcode und konstante Daten) ist knapp
RAM (Speicher für Laufzeit-Variablen) ist extrem knapp
Wenige Bytes „Verschwendung” ; signiﬁkant höhere Stückzahlkosten
c dl
1–2
GSPiC (Teil A, SS 14)
1 Einführung | 1.2 Warum µ-Controller?
Motivation: Die Sprache C
Motivation: GSPiC – Stoﬀauswahl und Konzept
Systemnahe Softwareentwicklung erfolgt überwiegend in C
Lehrziel:
Warum C?
Laufzeiteﬃzienz (CPU)
Übersetzter C-Code läuft direkt auf dem Prozessor
Keine Prüfungen auf Programmierfehler zur Laufzeit
Code und Daten lassen sich sehr kompakt ablegen
Keine Prüfung der Datenzugriﬀe zur Laufzeit
Für Vorlesung und Übung eigentlich zu wenig
Veranstaltung soll trotzdem einen hohen praktischen Anteil haben
Direktheit (Maschinennähe)
C erlaubt den direkten Zugriﬀ auf Speicher und Register
Ansatz:
Es gibt für jede Plattform einen C-Compiler
C wurde „erfunden” (1973), um das Betriebssystem
UNIX portabel zu implementieren [3, 5]
C ist die lingua franca der systemnahen Softwareentwicklung!
GSPiC (Teil A, SS 14)
1 Einführung | 1.3 Warum C?
1–4
V_GSPIC_handout
Portabilität
c dl
Systemnahe Softwareentwicklung in C
Herausforderung: Umfang der Veranstaltung (nur 2,5 ECTS)
Platzeﬃzienz (Speicher)
;
1–3
Das ist ein sehr umfangreiches Feld: Hardware-Programmierung,
Betriebssysteme, Middleware, Datenbanken, Verteilte Systeme,
Übersetzerbau, . . .
Dazu kommt dann noch das Erlernen der Sprache C selber
(und nicht Java/Cobol/Scala/<Lieblingssprache>)
C steht für eine Reihe hier wichtiger Eigenschaften
01-02-Konzept: 2014-04-03
Timer 8/16
6
Flash
ATTINY11
ATmega-Varianten (Auswahl) und Großhandelspreise (DigiKey 2006)
Bei den oberen Zahlen ist gesunde Skepsis geboten
01-02-Konzept: 2014-04-03
01-02-Konzept: 2014-04-03
Relevant:
IO
Type
Konzentration auf die Domäne µ-Controller
Konzepte und Techniken an kleinen Beispielen lehr- und erfahrbar
Hohe Relevanz für die Zielgruppe (EEI)
c dl
GSPiC (Teil A, SS 14)
1 Einführung | 1.3 Warum C?
1–5
Vorlesungsskript
Literaturempfehlungen
[2] Für den Einstieg empfohlen:
Das Handout der Vorlesungsfolien wird online und als
4 × 1-Ausdruck auf Papier zur Verfügung gestellt
Manfred Dausmann, Ulrich Bröckl, Dominic Schoop,
et al. C als erste Programmiersprache: Vom Einsteiger zum Fortgeschrittenen. (Als E-Book aus dem Uninetz verfügbar; PDF-Version unter /proj / i4gspic /
pub). Vieweg+Teubner, 2010. ISBN: 978-3834812216.
URL: http://www.springerlink.com/content/978-
Ausdrucke werden vor der Vorlesung verteilt
Online-Version wird vor der Vorlesung aktualisiert
Handout enthält (in geringem Umfang) zusätzliche Informationen
Das Handout kann eine eigene Mitschrift nicht ersetzen!
3-8348-1221-6/#section=813748&page=1
01-02-Konzept: 2014-04-03
01-02-Konzept: 2014-04-03
[4] Der „Klassiker” (eher als Referenz geeignet):
c dl
GSPiC (Teil A, SS 14)
1 Einführung | 1.4 Literatur
Brian W. Kernighan and Dennis MacAlistair Ritchie.
The C Programming Language (2nd Edition). Englewood Cliﬀs, NJ, USA: Prentice Hall PTR, 1988. ISBN:
978-8120305960
c dl
1–6
1 Einführung | 1.4 Literatur
Vorlesung
Übungen
Inhalt und Themen
Kombinierte Tafel- und Rechnerübung (jeweils im Wechsel)
Ausgabe und Erläuterung der Programmieraufgaben
Gemeinsame Entwicklung einer Lösungsskizze
Besprechung der Lösungen
Unterschiede zu Java
Modulkonzept
Zeiger und Zeigerarithmetik
Rechnerübungen
Softwareentwicklung auf „der nackten Hardware“ (ATmega-µC)
selbstständige Programmierung
Umgang mit Entwicklungswerkzeug (AVR Studio)
Betreuung durch Übungsbetreuer
Termin: D0 12:15–13:45, H9
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.1 Vorlesung
֒→
2–7
2–1
01-02-Konzept: 2014-04-03
Abbildung Speicher ↔ Sprachkonstrukte
Unterbrechungen (interrupts) und Nebenläuﬁgkeit
insgesamt 9 Vorlesungstermine
1–7
Tafelübungen
Grundlegende Konzepte der systemnahen Programmierung
Einführung in die Programmiersprache C
V_GSPIC_handout
GSPiC (Teil A, SS 14)
Termin: Initial 10 Gruppen zur Auswahl
Anmeldung über Waﬀel (siehe Webseite): Heute, 18:00 – Fr, 18:00
Bei zu wenigen Teilnehmern behalten wir uns eine Verteilung auf andere
Gruppen vor. Ihr werdet in diesem Fall per E-Mail angeschrieben.
Zur Übungsteilnahme wird ein gültiges Login in Linux-CIP gebraucht!
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.2 Übung
2–2
Programmieraufgaben
Übungsplattform: Das SPiCboard
Praktische Umsetzung des Vorlesungsstoﬀs
Lösungen mit Abgabeskript am Rechner abgeben
2)
LED−Reihe (active low)
LED 0 (Red 0, PD7)
LED 1 (Yellow 0, PC0)
Stromversorgung
LED 2 (Green 0, PC1)
LED 3 (Blue 0, PC6)
LED 4 (Red 1, PC7)
LED 5 (Yellow 1, PA7)
7−Segment−Anzeigen
LED 6 (Green 1, PA6)
Einer (Connector PD1)
LED 7 (Blue 1, PA5)
Zehner (Connector PD0)
PB4
Potentiometer (POTI) an ADC1
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.2 Übung
01-02-Konzept: 2014-04-03
Teilnahme an den Übungen dringend empfohlen!
SPiCboard-Lötabend
PB0
Ausleihe zur Übungsbearbeitung möglich
Oder noch besser ֒→ selber Löten
c dl
2–3
(active low)
PB2
PB1
Fotowiderstand
an ADC0
PB6
01-02-Konzept: 2014-04-03
ISP−Anschluss
★ Abgabe der Übungsaufgaben ist freiwillig;
֒→ 2–6
es kann jedoch eine Notenverbesserung bis 0,7 Notenpunkte
für die Prüfungsklausur erarbeitet werden!
Unabhängig davon ist die
PB5
Lösung wird durch Skripte überprüft
Wir korrigieren und bepunkten die Abgaben und geben sie zurück
Eine Lösung wird vom Teilnehmer an der Tafel erläutert
(impliziert Anwesenheit!)
JTAG−Anschluss
PB3
ATmega32-µC
JTAG-Anschluss
8 LEDs
2 7-Seg-Elemente
2 Taster
1 Potentiometer
1 Fotosensor
2–7
T
(e ast
nt er
pr 0
el
lt,
PD
֒→
T
(p ast
re er
llt 1
,P
D
3)
Fünf Programmieraufgaben (Abgabe ca. alle 14 Tage)
Bearbeitung wechselseitig alleine / mit Übungspartner
GSPiC (Teil A, SS 14)
2 Organisation | 2.2 Übung
2–4
Prüfung und Modulnote
Prüfung (Klausur)
Termin: voraussichtlich Ende Juli / Anfang August
Dauer: 60 min
Inhalt:
Fragen zum Vorlesungsstoﬀ + Programmieraufgabe
Die Fachschaften (EEI / ME) bieten einen „Lötabend“ an
Termine:
14.–16. und 23.–25. April, 18:15–21:00
Anmeldung:
über Waﬀel (ab Mi. 18:00, siehe Webseite)
Klausurnote 7→ Modulnote
Bestehensgrenze (in der Regel): 50% der möglichen Klausurpunkte (KP)
Falls bestanden ist eine Notenverbesserung möglich
durch Bonuspunkte aus den Programmieraufgaben
Kostenbeitrag: SPiCBoard: 2 EUR (subventioniert)
Progger:
30 EUR (optional!)
01-02-Konzept: 2014-04-03
01-02-Konzept: 2014-04-03
Teilnahme ist freiwillig
(Erste) Löterfahrung sammeln beim Löten eines eigenen SPiCboards
Die Progger (ISPs) können ggfs. auch gebraucht erworben werden.
Thread im EEI-Forum: http://eei.fsi.fau.de/forum/post/3208
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.3 Lötabend
2–5
Basis (Minimum): 50% der möglichen Übungspunkte (ÜP)
Jede weiteren 7,14% der möglichen ÜP 7→ −0, 1 Klausurnote
; 100% der möglichen ÜP 7→ −0, 7 bei der Klausurnote
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.4 Prüfung
2–6
Mo
Di
Mi
Do
Fr
07.04.
08.04.
09.04.
10.04.
11.04.
VL 1
VL 2
15
Semesterplanung
01-02-Konzept: 2014-04-03
22.04.
17.04.
23.04.
24.04.
29.04.
30.04.
01.05.
06.05.
07.05.
08.05.
13.05.
14.05.
09.05.
15.05.
A3 (Spiel)
19.05.
20.05.
16.05.
21.05.
Zeiger
22.05.
23.05.
VL 6
26.05.
22
27.05.
28.05.
29.05.
A4 (LED)
02.06.
03.06.
Funktionen (Forts.), Variablen, Präprozessor,
Programmstruktur, Module
VL 5
21
Mikrocontroller-Systemarchitektur, volatile,
Verbundtypen (struct, union)
30.05.
Himmelf.
04.06.
05.06.
23
06.06.
Interrupts, Nebenläufigkeit
VL 7
09.06.
10.06.
11.06.
12.06.
13.06.
19.06.
20.06.
Pfingsten/Berg
16.06.
25
02.05.
VL 4
12.05.
24
Ausdrücke, Kontrollstrukturen, Funktionen
Tag der
Arbeit
19
20
25.04.
VL 3
A2 (Snake)
05.05.
18.04.
Gründonnerstag/
Karfreitag
Ostern
28.04.
18
16.04.
A1 (Blink)
21.04.
17
15.04.
17.06.
18.06.
A5 (Ampel)
23.06.
24.06.
Fronleich.
25.06.
26
26.06.
01.07.
07.07.
08.07.
27
02.07.
Dozenten Vorlesung
Daniel Lohmann
Speicherorganisation, Zusammenfassung
03.07.
04.07.
10.07.
11.07.
Jürgen Kleinöder
Organisatoren des Übungsbetriebs
27.06.
VL 8
30.06.
Beteiligte Personen, LS Informatik 4
Einführung, Organisation, Java nach C
Abstraktion, Sprachüberblick, Datentypen
01-02-Konzept: 2014-04-03
14.04.
16
Se
Themen
http://www4.cs.fau.de/Lehre/SS14/V_GSPIC
KW
Rainer Müller
Moritz Strübe
Wiederholung
28
09.07.
Fragestunde
VL 9
c dl
Beteiligte Personen, LS Informatik 4
GSPiC (Teil A, SS 14)
2 Organisation | 2.5 Semesterüberblick
Beteiligte Personen, LS Informatik 4
(Forts.)
2–8
(Forts.)
Übungsleiter
Techniker (Ausleihe SPiCboard und Debugger)
Maximilian Deckelmann
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.5 Semesterüberblick
Jonas Fuchs
Lucas Grunenberg
Christian Hintea
Felix Kreyß
Markus Müller
Lars Schneider
Andreas Tschaftari
Daniel Christiani
01-02-Konzept: 2014-04-03
Christian Preller
01-02-Konzept: 2014-04-03
Harald Junggunst
Michael Dzierza
2–9
Florian Huber
c dl
GSPiC (Teil A, SS 14)
2 Organisation | 2.5 Semesterüberblick
2–10
Überblick: Teil B Einführung in C
Grundlagen der Systemnahen
Programmierung in C (GSPiC)
3 Java versus C – Erste Beispiele
4 Softwareschichten und Abstraktion
Teil B Einführung in C
5 Sprachüberblick
6 Einfache Datentypen
Daniel Lohmann
8 Kontrollstrukturen
Friedrich-Alexander-Universität
Erlangen-Nürnberg
9 Funktionen
V_GSPIC_handout
V_GSPIC_handout
7 Operatoren und Ausdrücke
Lehrstuhl für Informatik 4
Verteilte Systeme und Betriebssysteme
Sommersemester 2014
http://www4.cs.fau.de/Lehre/SS14/V_GSPIC
10 Variablen
11 Präprozessor
Das erste C-Programm
Das erste C-Programm – Vergleich mit Java
Das berühmteste Programm der Welt in C
Das berühmteste Programm der Welt in C
#include <stdio.h>
int main(int argc, char** argv) {
// greet user
printf("Hello World!\n");
return 0;
}
1
2
#include <stdio.h>
3
int main(int argc, char** argv) {
// greet user
printf("Hello World!\n");
return 0;
}
4
5
6
7
Das berühmteste Programm der Welt in Java
lohmann@latte:~/src$ gcc -o hello hello-linux.c
lohmann@latte:~/src$ ./hello
Hello World!
lohmann@latte:~/src$
c dl
GSPiC (Teil B, SS 14)
03-04-ErsteSchritte: 2014-04-03
03-04-ErsteSchritte: 2014-04-03
Übersetzen und Ausführen (auf einem UNIX-System)
Gar nicht so
schwer :-)
3 Java versus C – Erste Beispiele | 3.1 Ausgabe
3–1
1
2
3
4
5
6
7
8
import java.lang.System;
class Hello {
public static void main(String[] args) {
/* greet user */
System.out.println("Hello World!");
return;
}
}
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.1 Ausgabe
3–2
Das erste C-Programm – Erläuterungen
Das erste C-Programm für einen µ-Controller
[Handout]
C-Version zeilenweise erläutert
„Hello World“ für AVR-ATmega (SPiCboard)
1 Für die Benutzung von printf() wird die Funktionsbibliothek stdio.h mit
der Präprozessor-Anweisung #include eingebunden.
3 Ein C-Programm startet in main(), einer globalen Funktion vom Typ int,
die in genau einer Datei deﬁniert ist.
5 Die Ausgabe einer Zeichenkette erfolgt mit der Funktion printf(). (\n ;
Zeilenumbruch)
6 Rückkehr zum Betriebssystem mit Rückgabewert. 0 bedeutet hier, dass
kein Fehler aufgetreten ist.
#include <avr/io.h>
void main() {
// initialize hardware: LED on port D pin 7, active low
DDRD |= (1<<7); // PD7 is used as output
PORTD |= (1<<7); // PD7: high --> LED is off
// greet user
PORTD &= ~(1<<7); // PD7: low --> LED is on
// wait forever
while(1){
}
03-04-ErsteSchritte: 2014-04-03
1 Für die Benutzung der Klasse out wird das Paket System mit der
import-Anweisung eingebunden.
2 Jedes Java-Programm besteht aus mindestens einer Klasse.
3 Jedes Java-Programm startet in main(), einer statischen Methode vom
Typ void, die in genau einer Klasse deﬁniert ist.
5 Die Ausgabe einer Zeichenkette erfolgt mit der Methode println() aus
der Klasse out aus dem Paket System.
[֒→ GDI, 13-18]
6 Rückkehr zum Betriebssystem.
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.1 Ausgabe
03-04-ErsteSchritte: 2014-04-03
Java-Version zeilenweise erläutert
Übersetzen und Flashen (mit AVR Studio)
Ausführen (SPiCboard):
c dl
3–3
Das erste C-Programm für einen µ-Controller
µ-Controller-Programmierung
ist „irgendwie anders“.
}
GSPiC (Teil B, SS 14)
; Übung
(rote LED leuchtet)
3 Java versus C – Erste Beispiele | 3.1 Ausgabe
µ-Controller-Programm – Erläuterungen
3–4
[Handout]
„Hello World“ für AVR ATmega (vgl. ֒→ 3–1 )
1
2
#include <avr/io.h>
3
void main() {
// initialize hardware: LED on port D pin 7, active low
DDRD |= (1<<7); // PD7 is used as output
PORTD |= (1<<7); // PD7: high --> LED is off
5
6
7
// greet user
PORTD &= ~(1<<7); // PD7: low --> LED is on
8
9
10
// wait forever
while(1){
}
11
03-04-ErsteSchritte: 2014-04-03
12
13
14
03-04-ErsteSchritte: 2014-04-03
4
µ-Controller-Programm zeilenweise erläutert
(Beachte Unterschiede zur Linux-Version ֒→ 3–3 )
}
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.1 Ausgabe
3–5
1 Für den Zugriﬀ auf Hardware-Register (DDRD, PORTD, bereitgestellt als
globale Variablen) wird die Funktionsbibliothek avr/io.h mit #include
eingebunden.
3 Die main()-Funktion hat keinen Rückgabewert (Typ void). Ein
µ-Controller-Programm läuft endlos ; main() terminiert nie.
5-6 Zunächst wird die Hardware initialisiert (in einen deﬁnierten Zustand
gebracht). Dazu müssen einzelne Bits in bestimmten Hardware-Registern
manipuliert werden.
9 Die Interaktion mit der Umwelt (hier: LED einschalten) erfolgt ebenfalls
über die Manipulation einzelner Bits in Hardware-Registern.
12-13 Es erfolgt keine Rückkehr zum Betriebssystem (wohin auch?). Die
Endlosschleife stellt sicher, dass main() nicht terminiert.
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.1 Ausgabe
3–6
Das zweite C-Programm – Eingabe unter Linux
Das zweite C-Programm – Eingabe mit µ-Controller
Benutzerinteraktion (Lesen eines Zeichens) unter Linux:
Benutzerinteraktion (Warten auf Tasterdruck) auf dem SPiCboard:
#include <stdio.h>
1
2
#include <avr/io.h>
int main(int argc, char** argv){
3
void main() {
// initialize hardware: button on port D pin 2
DDRD &= ~(1<<2); // PD2 is used as input
PORTD |= (1<<2); // activate pull-up: PD2: high
4
printf("Press key: ");
int key = getchar();
5
printf("You pressed %c\n", key);
return 0;
8
6
7
// initialize hardware: LED on port D pin 7, active low
DDRD |= (1<<7); // PD7 is used as output
PORTD |= (1<<7); // PD7: high --> LED is off
9
10
11
}
// wait until PD2 -> low (button is pressed)
while(PIND & (1<<2))
;
Die getchar()-Funktion liest ein Zeichen
von der Standardeingabe (hier: Tastatur).
Sie „wartet“ gegebenenfalls, bis ein Zeichen
verfügbar ist. In dieser Zeit entzieht das Betriebssystem den Prozessor.
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.2 Eingabe
Warten auf Tasterdruck – Erläuterungen
03-04-ErsteSchritte: 2014-04-03
03-04-ErsteSchritte: 2014-04-03
12
13
14
15
17
18
20
21
22
3
4
5
6
7
3–9
3 Java versus C – Erste Beispiele | 3.2 Eingabe
import java.lang.System;
import javax.swing.*;
import java.awt.event.*;
public class Input implements ActionListener {
private JFrame frame;
3–8
10
11
12
13
// add button to frame
input.frame.add(button);
input.frame.setSize(400, 400);
input.frame.setVisible(true);
14
15
16
17
18
// register input as listener of button events
button.addActionListener(input);
19
20
21
22
}
23
public void actionPerformed(ActionEvent e) {
System.out.println("Knopfdruck!");
System.exit(0);
}
24
25
26
27
Eingabe als „typisches“
Java-Programm
(objektorientiert, graﬁsch)
public static void main(String[] args) {
// create input, frame and button objects
Input input = new Input();
input.frame = new JFrame("Java-Programm");
JButton button = new JButton("Klick mich");
8
9
03-04-ErsteSchritte: 2014-04-03
03-04-ErsteSchritte: 2014-04-03
Benutzerinteraktion mit SPiCboard zeilenweise erläutert
3 Java versus C – Erste Beispiele | 3.2 Eingabe
GSPiC (Teil B, SS 14)
Zum Vergleich: Benutzerinteraktion als Java-Programm
[Handout]
2
GSPiC (Teil B, SS 14)
}
c dl
1
c dl
// wait forever
while(1)
;
19
3–7
5 Wie die LED ist der Taster mit einem digitalen IO-Pin des µ-Controllers
verbunden. Hier konﬁgurieren wir Pin 2 von Port D als Eingang durch
Löschen des entsprechenden Bits im Register DDRD.
6 Durch Setzen von Bit 2 im Register PORTD wird der interne
Pull-Up-Widerstand (hochohmig) aktiviert, über den VCC anliegt ; PD2 =
high.
13-14 Aktive Warteschleife: Wartet auf Tastendruck, d. h. solange PD2 (Bit 2
im Register PIND) high ist. Ein Tasterdruck zieht PD2 auf Masse ; Bit 2
im Register PIND wird low und die Schleife verlassen.
// greet user
PORTD &= ~(1<<7); // PD7: low --> LED is on
16
}
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.2 Eingabe
3–10
Benutzerinteraktion als Java-Programm – Erläuterungen
Ein erstes Fazit: Von Java → C (Syntax)
[Handout]
Syntaktisch sind Java und C sich sehr ähnlich
(Syntax: „Wie sehen gültige Programme der Sprache aus?“)
Das Programm ist mit der C-Variante nicht unmittelbar vergleichbar
Es verwendet das in Java übliche (und Ihnen bekannte)
objektorientierte Paradigma.
Dieser Unterschied soll hier verdeutlicht werden.
C-Syntax war Vorbild bei der Entwicklung von Java
; Viele Sprachelemente sind ähnlich oder identisch verwendbar
Blöcke, Schleifen, Bedingungen, Anweisungen, Literale
Werden in den folgenden Kapiteln noch im Detail behandelt
5 Um Interaktionsereignisse zu empfangen, implementiert die Klasse Input
ein entsprechendes Interface.
10-12 Das Programmverhalten ist implementiert durch eine Menge von Objekten
(frame, button, input), die hier bei der Initialisierung erzeugt werden.
20 Das erzeugte button-Objekt schickt nun seine Nachrichten an das
input-Objekt.
23-26 Der Knopfdruck wird durch eine actionPerformed()-Nachricht
(Methodenaufruf) signalisiert.
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.2 Eingabe
Wesentliche Sprachelemente aus Java gibt es in C jedoch nicht
Klassen, Pakete, Objekte, Ausnahmen (Exceptions), . . .
03-04-ErsteSchritte: 2014-04-03
03-04-ErsteSchritte: 2014-04-03
Benutzerinteraktion in Java zeilenweise erläutert
c dl
3–11
3 Java versus C – Erste Beispiele | 3.3 Erstes Fazit
Ein erstes Fazit: Von Java → C (Idiomatik)
Ein erstes Fazit: Von Java → C (Philosophie)
Idiomatisch gibt es sehr große Unterschiede
(Idiomatik: „Wie sehen übliche Programme der Sprache aus?“)
Philosophisch gibt es ebenfalls erhebliche Unterschiede
(Philosophie: „Grundlegende Ideen und Konzepte der Sprache“)
Java: Sicherheit und Portabilität durch Maschinenferne
Java: Objektorientiertes Paradigma
Bereichsüberschreitungen, Division durch 0, . . .
Problemnahes Speichermodell
Nur typsichere Speicherzugriﬀe, automatische Bereinigung zur Laufzeit
C: Eﬃzienz und Leichtgewichtigkeit durch Maschinennähe
03-04-ErsteSchritte: 2014-04-03
C: Imperatives Paradigma
Zentrale Frage: Aus welchen Aktivitäten besteht das Problem?
Gliederung der Problemlösung in Funktionen und Variablen
Hierarchiebildung durch Untergliederung in Teilfunktionen
Programmablauf durch Aufrufe zwischen Funktionen
Wiederverwendung durch Funktionsbibliotheken
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.3 Erstes Fazit
3–12
Übersetzung für virtuelle Maschine (JVM)
Umfangreiche Überprüfung von Programmfehlern zur Laufzeit
Zentrale Frage: Aus welchen Dingen besteht das Problem?
Gliederung der Problemlösung in Klassen und Objekte
Hierarchiebildung durch Vererbung und Aggregation
Programmablauf durch Interaktion zwischen Objekten
Wiederverwendung durch umfangreiche Klassenbibliothek
03-04-ErsteSchritte: 2014-04-03
GSPiC (Teil B, SS 14)
3–13
Übersetzung für konkrete Hardwarearchitektur
Keine Überprüfung von Programmfehlern zur Laufzeit
Einige Fehler werden vom Betriebssystem abgefangen – falls vorhanden
Maschinennahes Speichermodell
Direkter Speicherzugriﬀ durch Zeiger
Grobgranularer Zugriﬀsschutz und automatische Bereinigung
(auf Prozessebene) durch das Betriebssystem – falls vorhanden
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.3 Erstes Fazit
3–14
Ein erstes Fazit: µ-Controller-Programmierung
Abstraktion durch Softwareschichten: SPiCboard
Hardwaresicht
Problemnähe
C 7→ Maschinennähe 7→ µC-Programmierung
Die Maschinennähe von C zeigt sich insbesondere
auch bei der µ-Controller-Programmierung!
Es läuft nur ein Programm
Button
LED
8
Wird bei RESET direkt aus dem Flash-Speicher gestartet
Softwareschichten
2
libspicboard: abstrahiert
von µC und Verschaltung
SPiCboard
Muss zunächst die Hardware initialisieren
<led.h> <button.h>
...
03-04-ErsteSchritte: 2014-04-03
Direkte Manipulation von einzelnen Bits in Hardwareregistern
Detailliertes Wissen über die elektrische Verschaltung erforderlich
Keine Unterstützung durch Betriebssystem (wie etwa Linux)
Allgemein geringes Abstraktionsniveau ; fehleranfällig, aufwändig
Ansatz: Mehr Abstraktion durch problemorientierte Bibliotheken
c dl
GSPiC (Teil B, SS 14)
3 Java versus C – Erste Beispiele | 3.3 Erstes Fazit
Programm läuft nur auf ATmega32. Es
verwendet ATmega32-spezifische Registeradressen (wie 0x12) und Merkmale:
ATmega32Programm
...
(*(unsigned char*)(0x11)) |= (1<<7);
(*(unsigned char*)(0x12)) &= ~(1<<7);
GSPiC (Teil B, SS 14)
GSPiC (Teil B, SS 14)
ATmega64
Register, . . .
Register, . . .
ATmega32
Register, . . .
...
<avr/io.h>
<avr/interrupt.h>
ATmega64
Register, . . .
...
···
Register, . . .
4 Softwareschichten und Abstraktion | 4.1 Funktionsbibliotheken
4–2
4–1
#include <led.h>
#include <button.h>
void main() {
// wait until Button0 is pressed
while(sb_button_getState(BUTTON0)
!= BTNPRESSED) {
}
// greet user
sb_led_on(RED0);
// wait until PD2: low --> (button0 pressed)
while(PIND & (1<<2)) {
}
avr-libc: abstrahiert von ATmegaAusprägung und Register-Adressen
···
Register, . . .
Nun: Entwicklung mit libspicboard
// button0 on PD2
DDRD &= ~(1<<2);
PORTD |= (1<<2);
// LED on PD7
DDRD |= (1<<7);
PORTD |= (1<<7);
libspicboard: abstrahiert
von µC und Verschaltung
<led.h> <button.h>
...
4 Softwareschichten und Abstraktion | 4.1 Funktionsbibliotheken
#include <avr/io.h>
SPiCboard-Programm
ATmegaProgramm
<avr/interrupt.h>
ATmega32
Bisher: Entwicklung mit avr-libc
03-04-ErsteSchritte: 2014-04-03
Problemnähe
Maschinennähe
03-04-ErsteSchritte: 2014-04-03
#include <avr/io.h>
...
DDRD |= (1<<7);
PORTD &= ~(1<<7);
c dl
ATmega64
void main() {
// initialize hardware
Programm läuft auf jedem µC der ATmega-Serie.
Es verwendet symbolische Registernamen der
avr-libc (wie PORTD) und allgemeine Merkmale:
Schalte LED RED0 auf
SPiCboard an:
ATmega32
<avr/io.h>
Abstraktion durch Softwareschichten: Vollständiges Beispiel
#include <led.h>
...
sb_led_on(RED0);
Ziel:
avr-libc: abstrahiert von ATmegaAusprägung und Register-Adressen
«abstract»
ATmega
c dl
3–15
Abstraktion durch Softwareschichten: LED → on im Vergleich
Programm läuft nur auf dem SPiCboard. Es verwendet Funktionen (wie sb_led_on()) und Konstanten (wie RED0) der libspicboard, welche die konkrete Verschaltung von LEDs,
Tastern, usw. mit dem µC repräsentieren:
Maschinennähe
Die Problemlösung ist maschinennah implementiert
03-04-ErsteSchritte: 2014-04-03
Darf nie terminieren (z. B. durch Endlosschleife in main())
// greet user (red LED)
PORTD &= ~(1<<7); // PD7: low --> LED is on
// wait forever
while(1) {
}
(vgl. ֒→
GSPiC (Teil B, SS 14)
}
Hardwareinitialisierung entfällt
Programm ist einfacher und verständlicher
durch problemspeziﬁsche Abstraktionen
}
c dl
// wait forever
while(1){
}
3–8
)
Setze Bit 7 in PORTD
7 sb_set_led(RED0)
→
Lese Bit 2 in PORTD
7 sb_button_getState(BUTTON0)
→
4 Softwareschichten und Abstraktion | 4.1 Funktionsbibliotheken
4–3
Softwareschichten im Allgemeinen
Ausgabe-Abstraktionen (Auswahl)
Diskrepanz: Anwendungsproblem ←→ Abläufe auf der Hardware
LED-Modul (#include <led.h>)
LED ausschalten: sb_led_off(BLUE0)
Alle LEDs ein-/ausschalten:
sb_led_set_all_leds(0x0f)
7-Seg-Modul (#include <7seg.h>)
Ganzzahl n ∈ {−9 . . . 99} ausgeben:
Eingabe-Abstraktionen (Auswahl)
;
;
R0 Y0 G0 B0 R1 Y1 G1 B1
0
1
2
3
4
5
6
7
;
Button-Modul (#include <button.h>)
Button-Zustand abfragen:
sb_button_getState(BUTTON0)
ADC-Modul (#include <adc.h>)
7→
{BTNPRESSED,
7→
{0. . . 1023}
BTNRELEASED}
Potentiometer-Stellwert abfragen:
sb_adc_read(POTI)
c dl
GSPiC (Teil B, SS 14)
4 Softwareschichten und Abstraktion | 4.1 Funktionsbibliotheken
CAD-System
Java-Programm
Klassenbibliotheken
Übersetzung
Java Byte-Code
Interpretation
JVM
C-Programm
Funktionsbibliotheken
Übersetzung
Assemblerprogr.
Übersetzung
Maschinenprogr.
Interpretation von Systemaufrufen
Ausführung
Prozessor
Betriebssystem
C-Programm
Grafik-Workstation
Maschinennähe
03-04-ErsteSchritte: 2014-04-03
sb_7seg_showNumber(47)
;
03-04-ErsteSchritte: 2014-04-03
LED einschalten: sb_led_on(BLUE0)
Problemnähe
Abstraktionen der libspicboard: Kurzüberblick
Ziel: Ausführbarer Maschinencode
¤
c dl
4–4
4 Softwareschichten und Abstraktion | 4.2 Allgemein
Die Rolle des Betriebssystems
Die Rolle des Betriebssystems
Anwendersicht:
Systemsicht:
Umgebung zum Starten, Kontrollieren und
Kombinieren von Anwendungen
Datenaustausch zwischen Anwendungen und Anwendern
z. B. über Dateien
Softwareschicht zum Multiplexen der
Hardware (֒→ Mehrbenutzerbetrieb)
Isolation von Programminstanzen durch Prozesskonzept
Automatische Speicherbereinigung bei Prozessende
Erkennung/Vermeidung von Speicherzugriﬀen auf fremde Prozesse
Anwendungssicht: Funktionsbibliothek mit Abstraktionen zur
Vereinfachung der Softwareentwicklung
03-04-ErsteSchritte: 2014-04-03
Generische Ein-/Ausgabe von Daten
z. B. auf Drucker, serielle Schnittstelle, in Datei
Permanentspeicherung und Übertragung von Daten
z. B. durch Dateisystem, über TCP/IP-Sockets
Verwaltung von Speicher und anderen Betriebsmitteln
z. B. CPU-Zeit
GSPiC (Teil B, SS 14)
(Forts.)
Virtueller Speicher
֒→ eigener 32-/64-Bit-Adressraum
Virtueller Prozessor
֒→ wird transparent zugeteilt und entzogen
Virtuelle Ein-/Ausgabe-Geräte ֒→ umlenkbar in Datei, Socket, . . .
z. B. bash, Windows
c dl
4–5
Parallele Abarbeitung von Programminstanzen durch Prozesskonzept
Shell, graﬁsche Benutzeroberﬂäche
03-04-ErsteSchritte: 2014-04-03
GSPiC (Teil B, SS 14)
Partieller Schutz vor schwereren Programmierfehlern
Erkennung einiger ungültiger Speicherzugriﬀe (z. B. Zugriﬀ auf Adresse 0)
Erkennung einiger ungültiger Operationen (z. B. div/0)
µC-Programmierung ohne Betriebssystemplattform ; kein Schutz
Ein Betriebssystem schützt weit weniger vor Programmierfehlern als z. B. Java.
Selbst darauf müssen wir jedoch bei der µC-Programmierung i. a. verzichten.
Bei 8/16-Bit-µC fehlt i. a. die für Schutz erforderliche Hardware-Unterstützung.
4 Softwareschichten und Abstraktion | 4.2 Allgemein
4–6
c dl
GSPiC (Teil B, SS 14)
4 Softwareschichten und Abstraktion | 4.2 Allgemein
4–7
Beispiel: Fehlererkennung durch Betriebssystem
Linux: Division durch 0
SPiCboard: Division durch 0
#include <stdio.h>
#include <7seg.h>
#include <avr/interrupt.h>
3 Java versus C – Erste Beispiele
int main(int argc, char** argv) {
int a = 23;
int b = 0;
void main() {
int a = 23;
int b = 0;
sei();
b = 4711 / (a-23);
sb_7seg_showNumber(b);
4 Softwareschichten und Abstraktion
2
3
4
5
6
7
b = 4711 / (a-23);
printf("Ergebnis: %d\n", b);
8
9
10
return 0;
11
03-04-ErsteSchritte: 2014-04-03
12
7 Operatoren und Ausdrücke
}
Übersetzen und Ausführen ergibt:
Ausführen ergibt:
gcc error-linux.c -o error-linux
./error-linux
Floating point exception
8 Kontrollstrukturen
; Programm setzt
Berechnung fort
mit falschen Daten.
; Programm wird abgebrochen.
GSPiC (Teil B, SS 14)
6 Einfache Datentypen
while(1){}
}
c dl
5 Sprachüberblick
4 Softwareschichten und Abstraktion | 4.2 Allgemein
9 Funktionen
V_GSPIC_handout
1
Überblick: Teil B Einführung in C
10 Variablen
11 Präprozessor
4–8
Struktur eines C-Programms – allgemein
2
3
4
5
6
7
8
9
10
11
12
05-Sprachueberblick: 2012-03-07
13
// include files
#include . . .
14
15
16
17
18
// global variables
. . . variable1 = . . .
// subfunction 1
. . . subfunction_1(. . .) {
// local variables
. . . variable1 = . . .
// statements
}
...
1
// subfunction n
. . . subfunction_n(. . .) {
2
3
4
...
19
20
}
5
6
21
// main function
. . . main(. . .) {
9
22
23
24
25
26
7
8
10
...
11
12
}
13
05-Sprachueberblick: 2012-03-07
1
Struktur eines C-Programms – am Beispiel
Ein C-Programm besteht (üblicherweise) aus
Menge von globalen Variablen
Menge von (Sub-)Funktionen
Menge von lokalen Variablen
Menge von Anweisungen
Der Funktion main(), in der die Ausführung beginnt
c dl
GSPiC (Teil B, SS 14)
5 Sprachüberblick | 5.1 Grundstruktur eines C-Programms
5–1
// include files
#include <led.h>
14
// global variables
LED nextLED = RED0;
17
18
15
16
// subfunction 1
LED lightLED(void) {
if (nextLED <= BLUE1) {
sb_led_on(nextLED++);
}
return nextLED;
}
19
20
21
22
23
24
25
26
// subfunction 2
void wait() {
volatile unsigned int i;
for (i=0; i<0xffff; i++)
;
}
// main function
void main() {
while (lightLED() < 8) {
wait();
}
}
Ein C-Programm besteht (üblicherweise) aus
Menge von globalen Variablen
Menge von (Sub-)Funktionen
Menge von lokalen Variablen
Menge von Anweisungen
nextLED, Zeile 5
wait(), Zeile 15
i, Zeile 16
for-Schleife, Zeile 17
Der Funktion main(), in der die Ausführung beginnt
c dl
GSPiC (Teil B, SS 14)
5 Sprachüberblick | 5.1 Grundstruktur eines C-Programms
5–2
Bezeichner
2
3
4
5
6
7
8
9
10
11
12
05-Sprachueberblick: 2012-03-07
13
// include files
#include <led.h>
14
15
16
// global variables
LED nextLED = RED0;
17
18
// subfunction 1
LED lightLED(void) {
if (nextLED <= BLUE1) {
sb_led_on(nextLED++);
}
return nextLED;
}
19
20
21
22
23
24
25
26
// subfunction 2
void wait() {
volatile unsigned int i;
for (i=0; i<0xffff; i++)
;
}
1
2
3
4
5
6
7
// main function
void main() {
while (lightLED() < 8) {
wait();
}
}
8
9
10
11
12
13
Vom Entwickler vergebener Name für ein Element des Programms
Element: Typ, Variable, Konstante, Funktion, Sprungmarke
Aufbau: [ A-Z, a-z, _ ] [ A-Z, a-z, 0-9, _ ] ∗
Buchstabe gefolgt von Buchstaben, Ziﬀern und Unterstrichen
Unterstrich als erstes Zeichen möglich, aber reserviert für Compilerhersteller
Ein Bezeichner muss vor Gebrauch deklariert werden
c dl
GSPiC (Teil B, SS 14)
Schlüsselwörter
5 Sprachüberblick | 5.2 Syntaktische Grundelemente
Schlüsselwörter in C99
05-Sprachueberblick: 2012-03-07
1
[=Java]
// include files
#include <led.h>
14
15
16
// global variables
LED nextLED = RED0;
17
18
// subfunction 1
LED lightLED(void) {
if (nextLED <= BLUE1) {
sb_led_on(nextLED++);
}
return nextLED;
}
19
20
21
22
23
24
25
26
// subfunction 2
void wait() {
volatile unsigned int i;
for (i=0; i<0xffff; i++)
;
}
// main function
void main() {
while (lightLED() < 8) {
wait();
}
}
Reservierte Wörter der Sprache
(; dürfen nicht als Bezeichner verwendet werden)
Eingebaute (primitive) Datentypen
Typmodiﬁzierer
Kontrollstrukturen
Elementaranweisungen
c dl
5–3
GSPiC (Teil B, SS 14)
unsigned int, void
volatile
for, while
return
5 Sprachüberblick | 5.2 Syntaktische Grundelemente
Literale
[Handout]
Referenz: Liste der Schlüsselwörter (bis einschließlich C99)
1
2
3
auto, _Bool, break, case, char, _Complex, const, continue, default,
do, double, else, enum, extern, float, for, goto, if, _Imaginary,
inline, int, long, register, restrict, return, short, signed,
sizeof, static, struct, switch, typedef, union, unsigned, void,
volatile, while
4
5
6
7
8
9
10
11
12
05-Sprachueberblick: 2012-03-07
13
05-Sprachueberblick: 2012-03-07
[≈Java]
5–4
[=Java]
// include files
#include <led.h>
14
// global variables
LED nextLED = RED0;
17
18
15
16
// subfunction 1
LED lightLED(void) {
if (nextLED <= BLUE1) {
sb_led_on(nextLED++);
}
return nextLED;
}
19
20
21
22
23
24
25
26
// subfunction 2
void wait() {
volatile unsigned int i;
for (i=0; i<0xffff; i++)
;
}
// main function
void main() {
while (lightLED() < 8) {
wait();
}
}
(Darstellung von) Konstanten im Quelltext
Für jeden primitiven Datentyp gibt es eine oder mehrere Literalformen
Bei Integertypen: dezimal (Basis 10: 65535), hexadezimal (Basis 16,
führendes 0x: 0xffff), oktal (Basis 8, führende 0: 0177777)
Der Programmierer kann jeweils die am besten geeignete Form wählen
0xffff ist handlicher als 65535, um den Maximalwert einer vorzeichenlosen
16-Bit-Ganzzahl darzustellen
c dl
GSPiC (Teil B, SS 14)
5 Sprachüberblick | 5.2 Syntaktische Grundelemente
5–5
c dl
GSPiC (Teil B, SS 14)
5 Sprachüberblick | 5.2 Syntaktische Grundelemente
5–6
Anweisungen
2
3
4
5
6
7
8
9
10
11
12
05-Sprachueberblick: 2012-03-07
13
// include files
#include <led.h>
14
// global variables
LED nextLED = RED0;
17
18
15
16
// subfunction 1
LED lightLED(void) {
if (nextLED <= BLUE1) {
sb_led_on(nextLED++);
}
return nextLED;
}
19
20
21
22
23
24
25
26
// subfunction 2
void wait() {
volatile unsigned int i;
for (i=0; i<0xffff; i++)
;
}
1
2
3
4
5
6
7
// main function
void main() {
while (lightLED() < 8) {
wait();
}
}
8
9
10
11
12
13
Beschreiben den eigentlichen Ablauf des Programms
Werden hierarchisch komponiert aus drei Grundformen
Einzelanweisung – Ausdruck gefolgt von ;
einzelnes Semikolon 7→ leere Anweisung
Block – Sequenz von Anweisungen, geklammert durch {. . . }
Kontrollstruktur, gefolgt von Anweisung
c dl
GSPiC (Teil B, SS 14)
Ausdrücke
05-Sprachueberblick: 2012-03-07
1
[=Java]
5 Sprachüberblick | 5.2 Syntaktische Grundelemente
// include files
#include <led.h>
14
// global variables
LED nextLED = RED0;
17
18
Überblick: Teil B Einführung in C
15
16
// subfunction 1
LED lightLED(void) {
if (nextLED <= BLUE1) {
sb_led_on(nextLED++);
}
return nextLED;
}
19
20
21
22
23
24
25
26
// subfunction 2
void wait() {
volatile unsigned int i;
for (i=0; i<0xffff; i++)
;
}
// main function
void main() {
while (lightLED() < 8) {
wait();
}
}
Gültige Kombination von Operatoren, Literalen und Bezeichnern
„Gültig“ im Sinne von Syntax und Typsystem
Vorrangregeln für Operatoren legen die Reihenfolge fest,
in der Ausdrücke abgearbeitet werden
֒→
7–14
Auswertungsreihenfolge kann mit Klammern ( ) explizit bestimmt werden
Der Compiler darf Teilausdrücke in möglichst eﬃzienter Folge auswerten
c dl
5–7
[=Java]
GSPiC (Teil B, SS 14)
5 Sprachüberblick | 5.2 Syntaktische Grundelemente
Was ist ein Datentyp?
5–8
[֒→ GDI, 02-13]
Datentyp := (<Menge von Werten>, <Menge von Operationen>)
4 Softwareschichten und Abstraktion
Literal
Konstante
Variable
5 Sprachüberblick
Funktion
3 Java versus C – Erste Beispiele
6 Einfache Datentypen
10 Variablen
11 Präprozessor
5–6
Datentyp legt fest
06-Datentypen: 2013-04-15
V_GSPIC_handout
9 Funktionen
֒→
; Literale, Konstanten, Variablen, Funktionen haben einen (Daten-)Typ
7 Operatoren und Ausdrücke
8 Kontrollstrukturen
Wert im Quelltext
Bezeichner für einen Wert
Bezeichner für Speicherplatz,
der einen Wert aufnehmen kann
Bezeichner für Sequenz von Anweisungen,
die einen Wert zurückgibt
Repräsentation der Werte im Speicher
Größe des Speicherplatzes für Variablen
Erlaubte Operationen
Datentyp wird festgelegt
Explizit, durch Deklaration, Typ-Cast oder Schreibweise (Literale)
Implizit, durch „Auslassung“ (; int schlechter Stil!)
c dl
GSPiC (Teil B, SS 14)
6 Einfache Datentypen | 6.1 Einführung
6–1
Primitive Datentypen in C
Integertypen
Ganzzahlen/Zeichen char, short, int, long, long long (C99)
Integertyp
Wertebereich: implementierungsabhängig
Es gilt: char ≤ short ≤ int ≤ long ≤ long long
[6=Java]
short [int]
int
long [int]
long long [int]
float, double, long double
void
Wertebereich: ∅
Boolescher Datentyp _Bool (C99)
Wertebereich: {0, 1} (←֓ letztlich ein Integertyp)
Bedingungsausdrücke (z. B. if(. . .)) sind in C vom Typ int!
c dl
GSPiC (Teil B, SS 14)
[6=Java]
6 Einfache Datentypen | 6.1 Einführung
[6= Java]
char
short
int
long
≥8
≥ 16
≥ 16
≥ 32
≥ 64
8
16
32
32
64
−(2Bits−1 −1)
0
−→
−→
GSPiC (Teil B, SS 14)
6 Einfache Datentypen | 6.2 Ganzahltypen: int und Co
GSPiC (Teil B, SS 14)
=
=
=
=
’A’;
0x41;
0L;
22UL;
//
//
//
//
char-Variable, Wert 65 (ASCII: A)
int-Konstante, Wert 65 (Hex: 0x41)
long-Variable, Wert 0
unsigned-long-Variable, Wert 22
6 Einfache Datentypen | 6.2 Ganzahltypen: int und Co
6–3
Breite (; Wertebereich) der C-Standardtypen ist
7→ Maschinennähe
implementierungsspeziﬁsch
7→ Problemnähe
Integertyp deﬁnierter Größe
Code unabhängig von Compiler und Hardware halten (; Portierbarkeit)
Lösung:
Modul stdint.h
Deﬁniert Alias-Typen: intn_t und uintn_t
Wird vom Compiler-Hersteller bereitgestellt
֒→ 3–14
Die interne Repräsentation der Integertypen ist deﬁniert durch die Hardware
(Registerbreite, Busbreite, etc.). Das führt im Ergebnis zu eﬃzientem Code.
c dl
char a
const int b
long c
unsigned long int d
Register deﬁnierter Breite n bearbeiten
+(2Bits−1 − 1)
+(2Bits − 1)
Hier zeigt sich die C-Philosophie: Eﬃzienz durch Maschinennähe
-
Wertebereich sicher, aber möglichst kompakt darstellen
8
16
16
32
64
Der Wertebereich berechnet sich aus der Bitbreite
signed
unsigned
U
Beispiele (Variablendeﬁnitionen)
Oft benötigt:
gccAVR
8
16
32
64
64
Literal-Suﬃx
Typ ist vorzeichenbehaftet (Normalfall)
Typ ist vorzeichenlos
Variable des Typs kann nicht verändert werden
Problem:
06-Datentypen: 2013-04-15
06-Datentypen: 2013-04-15
long long
16
16
32
32
-
Datentyp-Breite in Bit
C-Standard gccIA32 gccIA64
kleine Ganzzahl oder Zeichen ’A’, 65, 0x41, 0101
Ganzzahl (int ist optional)
s. o.
Ganzzahl „natürlicher Größe“
s. o.
große Ganzzahl
65L, 0x41L, 0101L
sehr große Ganzzahl
65LL, 0x41LL, 0101LL
Integertypen: Maschinennähe −→ Problemnähe
Die interne Darstellung (Bitbreite) ist implementierungsabhängig
Java
signed
unsigned
const
c dl
6–2
Integertypen: Größe und Wertebereich
Literalformen
Typ-Modiﬁzierer werden vorangestellt
06-Datentypen: 2013-04-15
06-Datentypen: 2013-04-15
Wertebereich: implementierungsabhängig
[6=Java]
Es gilt: float ≤ double ≤ long double
Ab C99 auch als _Complex-Datentypen verfügbar (für komplexe Zahlen)
Leerer Datentyp
Verwendung
char
Jeweils als signed- und unsigned-Variante verfügbar
Fließkommazahlen
[≈Java][֒→ GDI, 02-14]
6–4
uint8_t
uint16_t
uint32_t
uint64_t
c dl
0
0
0
0
→
→
→
→
für n ∈ {8, 16, 32, 64}
Wertebereich stdint.h-Typen
255
int8_t
−128
65.535
int16_t
−32.768
4.294.967.295 int32_t −2.147.483.648
> 1, 8 ∗ 1019
int64_t
< −9, 2 ∗ 1018
GSPiC (Teil B, SS 14)
→
→
→
→
6 Einfache Datentypen | 6.2 Ganzahltypen: int und Co
+127
+32.767
+2.147.483.647
> +9, 2 ∗ 1018
6–5
Typ-Aliase mit typedef
[6= Java]
Typ-Aliase mit typedef
Mit dem typedef-Schlüsselwort deﬁniert man einen Typ-Alias:
typedef Typausdruck Bezeichner ;
Typ-Aliase ermöglichen einfache problembezogene Abstraktionen
Register ist problemnäher als uint8_t
Bezeichner ist nun ein alternativer Name für Typausdruck
Kann überall verwendet werden, wo ein Typausdruck erwartet wird
// stdint.h (avr-gcc)
typedef unsigned char uint8_t;
typedef unsigned int uint16_t;
···
; Spätere Änderungen (z. B. auf 16-Bit-Register) zentral möglich
uint16_t ist problemnäher als unsigned char
uint16_t ist sicherer als unsigned char
// stdint.h (x86-gcc, IA32)
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
Deﬁnierte Bitbreiten sind bei der µC-Entwicklung sehr wichtig!
···
Große Unterschiede zwischen Plattformen und Compilern
; Kompatibilitätsprobleme
// main.c
#include <stdint.h>
···
// global 16-bit counter, range 0-65535
typedef uint8_t Register; // Registers on this machine are 8-bit
···
c dl
GSPiC (Teil B, SS 14)
6 Einfache Datentypen | 6.3 Typ-Pseudonyme: typedef
Aufzählungstypen mit enum
Um Speicher zu sparen, sollte immer der kleinstmögliche
Integertyp verwendet werden
06-Datentypen: 2013-04-15
06-Datentypen: 2013-04-15
uint16_t counter = 0;
Regel:
c dl
6–6
[≈Java]
typedef enum { BUTTON0 = 4, BUTTON1 = 8 } BUTTON;
// enum necessary here!
Man kann sie verwenden wie ints (z. B. mit ihnen rechnen)
Deﬁnition:
typedef enum eLED {RED0, YELLOW0, GREEN0, BLUE0,
RED1, YELLOW1, GREEN1, BLUE1} LED;
Verwendung:
LED myLed = YELLOW0;
// LED --> enum eLED
6 Einfache Datentypen | 6.4 Aufzählungstypen: enum
6–8
06-Datentypen: 2013-04-15
06-Datentypen: 2013-04-15
[6= Java]
Es ist auch möglich, Werte direkt zuzuweisen
Vereinfachung der Verwendung durch typedef
GSPiC (Teil B, SS 14)
6–7
typedef enum { RED0,
// value: 0
YELLOW0,
// value: 1
GREEN0,
// value: 2
· · · } LED;
sb_led_on(BLUE1);
c dl
6 Einfache Datentypen | 6.3 Typ-Pseudonyme: typedef
enum-Konstanten werden von 0 an durchnummeriert
enum eLED {RED0, YELLOW0, GREEN0, BLUE0,
RED1, YELLOW1, GREEN1, BLUE1};
Verwendung: · · ·
GSPiC (Teil B, SS 14)
Technisch sind enum-Typen Integers (int)
Beispiel
enum eLED myLed = YELLOW0;
Bei der systemnahen Programmierung werden
Typen aus stdint.h verwendet!
enum 7→ int
Mit dem enum-Schlüsselwort deﬁniert man einen Aufzählungstyp
über eine explizite Menge symbolischer Werte:
enum Bezeichneropt { KonstantenListe } ;
Deﬁnition:
[6= Java]
(Forts.)
sb_led_on(RED0 + 2); // -> LED GREEN0 is on
sb_led_on(1);
// -> LED YELLOW0 is on
for( int led = RED0, led <= BLUE1; led++ )
// turn off all LEDs
sb_led_off(led);
// Also possible...
_
_
sb led on(4711);
// no compiler/runtime error!
; Es ﬁndet keinerlei Typprüfung statt!
c dl
GSPiC (Teil B, SS 14)
Das entspricht der
C-Philosophie! ֒→ 3–14
6 Einfache Datentypen | 6.4 Aufzählungstypen: enum
6–9
Fließkommatypen
Fließkommatyp
[≈Java][֒→ GDI, 02-18]
Verwendung
float
double
long double
Zeichen 7→ Integer
Literalformen
einfache Genauigkeit (≈ 7 St.)
doppelte Genauigkeit (≈ 15 St.)
„erweiterte Genauigkeit“
Zeichen sind in C ebenfalls Ganzzahlen (Integers)
100.0, 1.0E2
Repräsentation erfolgt durch den ASCII-Code
100.0L 1.0E2L
„Eﬃzienz durch
Maschinennähe“ ֒→
3–14
06-Datentypen: 2013-04-15
06-Datentypen: 2013-04-15
Oft keine Hardwareunterstützung für float-Arithmetik
; sehr teure Emulation in Software (langsam, viel zusätzlicher Code)
Speicherverbrauch von float- und double-Variablen ist sehr hoch
; mindestens 32/64 Bit (float/double)
c dl
Bei der µ-Controller-Programmierung ist
auf Fließkommaarithmetik zu verzichten!
GSPiC (Teil B, SS 14)
6 Einfache Datentypen | 6.5 Fließkommazahltypen: ﬂoat und double
Tabulator
Zeilentrenner
Backslash
GSPiC (Teil B, SS 14)
ETX
03
VT
0B
DC3
13
ESC
1B
#
23
+
2B
3
33
;
3B
C
43
K
4B
S
53
[
5B
c
63
k
6B
s
73
{
7B
EOT
04
NP
OC
DC4
14
FS
1C
$
24
,
2C
4
34
<
3C
D
44
L
4C
T
54
\
5C
d
64
l
6C
t
74
|
7C
ENQ
05
CR
0D
NAK
15
GS
1D
%
25
2D
5
35
=
3D
E
45
M
4D
U
55
]
5D
e
65
m
6D
u
75
}
7D
ACK
06
SO
0E
SYN
16
RS
1E
&
26
.
2E
6
36
>
3E
F
46
N
4E
V
56
^
5E
f
66
n
6E
v
76
~
7E
6 Einfache Datentypen | 6.6 Zeichen und Zeichenketten
BEL
07
SI
0F
ETB
17
US
1F
’
27
/
2F
7
37
?
3F
G
47
O
4F
W
57
_
5F
g
67
o
6F
w
77
DEL
7F
’\\’
;
char b = ’A’ + 1;
man kann mit Zeichen rechnen
// b: ’B’
int lower(int ch) {
return ch + 0x20;
}
// lower(’X’): ’x’
GSPiC (Teil B, SS 14)
6 Einfache Datentypen | 6.6 Zeichen und Zeichenketten
6–11
[6= Java]
Ein String ist in C ein Feld (Array) von Zeichen
Repräsentation:
Folge von Einzelzeichen, terminiert durch
(letztes Zeichen): NUL (ASCII-Wert 0)
(Länge + 1) Bytes
char[] oder char* (synonym)
Speicherbedarf:
Datentyp:
Spezielle Literalform durch doppelte Hochkommata:
"Hi!" 7→
’H’
’i’
’!’
0 ←− abschließendes 0-Byte
Beispiel (Linux)
06-Datentypen: 2013-04-15
06-Datentypen: 2013-04-15
SPiC
c dl
STX
02
NL
0A
DC2
12
SUB
1A
"
22
*
2A
2
32
:
3A
B
42
J
4A
R
52
Z
5A
b
62
j
6A
r
72
z
7A
’\n’
Zeichenketten (Strings)
American
ASCII 7→
AmericanStandard
StandardCode
CodeforforInformation
InformationInterchange
Interchange(ASCII)
SOH
01
HT
09
DC1
11
EM
19
!
21
)
29
1
31
9
39
A
41
I
49
Q
51
Y
59
a
61
i
69
q
71
y
79
’\t’
Zeichen 7→ Integer
c dl
6–10
ASCII-Code-Tabelle (7 Bit)
NUL
00
BS
08
DLE
10
CAN
18
SP
20
(
28
0
30
8
38
@
40
H
48
P
50
X
58
‘
60
h
68
p
70
x
78
֒→ 6–12
7-Bit-Code 7→ 128 Zeichen standardisiert
(die verbleibenden 128 Zeichen werden unterschiedlich interpretiert)
Spezielle Literalform durch Hochkommata
’A’ 7→ ASCII-Code von A
Nichtdruckbare Zeichen durch Escape-Sequenzen
Fließkommazahlen + µC-Plattform = $$$
Regel:
֒→ 6–3
char gehört zu den Integer-Typen (üblicherweise 8 Bit = 1 Byte)
100.0F, 1.0E2F
Genauigkeit / Wertebereich sind implementierungsabhängig [6= Java]
Es gilt: float ≤ double ≤ long double
long double und double sind auf
vielen Plattformen identisch
[≈Java]
6–12
D.20
#include <stdio.h>
char[] string = "Hello, World!\n";
int main(){
printf(string);
return 0;
}
c dl
GSPiC (Teil B, SS 14)
Zeichenketten brauchen vergleichsweise viel Speicher und „größere“ Ausgabegeräte (z. B. LCD-Display).
; Bei der µC-Programmierung spielen sie nur eine untergeordnete Rolle.
6 Einfache Datentypen | 6.6 Zeichen und Zeichenketten
6–13
Ausblick: Komplexe Datentypen
Überblick: Teil B Einführung in C
Aus einfachen Datentypen lassen sich (rekursiv) auch
komplexe(re) Datentypen bilden
Felder (Arrays)
֒→ Sequenz von Elementen gleichen Typs
int intArray[4];
intArray[0] = 0x4711;
Zeiger
int a
int *b
int c
*b
0x4711;
&a;
*b;
23;
Strukturen
//
//
//
//
4 Softwareschichten und Abstraktion
[6=Java]
a: 0x4711
b: -->a (memory location of a)
pointer dereference (c: 0x4711)
pointer dereference (a: 23)
֒→ Verbund von Elementen bel. Typs
6 Einfache Datentypen
7 Operatoren und Ausdrücke
[6=Java]
struct Point { int x; int y; };
struct Point p;
// p is Point variable
p.x = 0x47;
// set x-component
p.y = 0x11;
// set y-component
Wir betrachten diese detailliert in späteren Kapiteln
c dl
GSPiC (Teil B, SS 14)
5 Sprachüberblick
6 Einfache Datentypen | 6.7 Ausblick: Felder und Zeiger, Verbundtypen
Arithmetische Operatoren
8 Kontrollstrukturen
V_GSPIC_handout
06-Datentypen: 2013-04-15
// allocate array with 4 elements
// set 1st element (index 0)
֒→ veränderbare Referenzen auf Variablen
=
=
=
=
3 Java versus C – Erste Beispiele
[≈Java]
Addition
Subtraktion
Multiplikation
Division
negatives Vorzeichen (z. B. −a)
positives Vorzeichen (z. B. +3)
Zusätzlich nur für Ganzzahltypen:
[=Java]
Inkrement-/Dekrement-Operatoren [=Java][֒→ GDI, 02-34]
Linksseitiger Operator (Präﬁx)
7 Operatoren und Ausdrücke | 7.1 Arithmetische Operatoren
++x bzw. --x
Erst wird der Inhalt von x verändert
Dann wird der (neue) Inhalt von x als Ergebnis geliefert
; Multiplikation mit −1
; kein Eﬀekt
Rechtsseitiger Operator (Postﬁx)
x++ bzw. x--
Erst wird der (alte) Inhalt von x als Ergebnis geliefert
Dann wird der Inhalt von x verändert
Modulo (Rest bei Division)
GSPiC (Teil B, SS 14)
Inkrement (Erhöhung um 1)
Dekrement (Verminderung um 1)
++
−−
07-Operatoren: 2013-07-19
c dl
11 Präprozessor
Stehen für Ganzzahltypen und Zeigertypen zur Verfügung
07-Operatoren: 2013-07-19
%
10 Variablen
6–14
Stehen für alle Ganzzahl- und Fließkommatypen zur Verfügung
+
−
⋆
/
unäres −
unäres +
9 Funktionen
7–1
Beispiele
a = 10;
b = a++;
c = ++a;
c dl
// b: 10, a: 11
// c: 12, a: 12
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.1 Arithmetische Operatoren
7–2
Vergleichsoperatoren
[=Java][֒→ GDI, 02-38]
Logische Operatoren
Vergleichen von zwei Ausdrücken
Verknüpfung von Wahrheitswerten (wahr / falsch), kommutativ
kleiner
kleiner gleich
größer
größer gleich
gleich (zwei Gleichheitszeichen!)
ungleich
<
<=
>
>=
==
!=
Beachte:
Ergebnis ist vom Typ int
[6= Java]
falsch 7→ 0
wahr 7→ 1
Man kann mit dem Ergebnis rechnen
07-Operatoren: 2013-07-19
07-Operatoren: 2013-07-19
Ergebnis:
Beispiele
if (a >= 3) {· · ·}
if (a == 3) {· · ·}
return a * (a > 0);
c dl
GSPiC (Teil B, SS 14)
// return 0 if a is negative
7 Operatoren und Ausdrücke | 7.2 Relationale Operatoren
Logische Operatoren – Auswertung
[=Java]
←−
wird nicht ausgewertet, da der
erste Term bereits falsch ergibt
07-Operatoren: 2013-07-19
07-Operatoren: 2013-07-19
// func() will not be called
7 Operatoren und Ausdrücke | 7.2 Relationale Operatoren
wahr || wahr → wahr
wahr || falsch → wahr
falsch || falsch → falsch
!
„nicht“
(Negation, unär)
Beachte:
! wahr → falsch
! falsch → wahr
Operanden und Ergebnis sind vom Typ int
Operanden
(Eingangsparameter):
Ergebnis:
[6= Java]
0→
7 falsch
6 0→
=
7 wahr
falsch →
7 0
wahr →
7 1
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.2 Relationale Operatoren
7–4
[=Java]
Abgekürzte Schreibweise zur Modiﬁkation des Variablenwerts
Beispiel:
a += 23 ist äquivalent zu
a = a + 23
Allgemein: a op = b ist äquivalent zu a = a op b
für op ∈ { +, −, ⋆, %, <<, >>, &, ˆ, | }
Kann überraschend sein, wenn Teilausdrücke Nebeneﬀekte haben
GSPiC (Teil B, SS 14)
„oder“
(Disjunktion)
Arithmetische Zuweisungsoperatoren (+=, −=, . . . )
0
c dl
||
Zuweisung eines Wertes an eine Variable
Beispiel:
a = b + 23
wird nicht ausgewertet, da der
erste Term bereits wahr ergibt
int a = 5; int b = 3; int c = 7;
if ( a > c && !func(b) ) {· · ·}
wahr && wahr → wahr
wahr && falsch → falsch
falsch && falsch → falsch
Allgemeiner Zuweisungsoperator (=)
1
a| {z
> c} && a| {z
> b}
0
?
|
{z
}
„und“
(Konjunktion)
Zuweisungsoperatoren
Sei int a = 5; int b = 3; int c = 7;
←−
&&
c dl
7–3
Die Auswertung eines logischen Ausdrucks wird abgebrochen,
sobald das Ergebnis feststeht
a| {z
> b} || |a {z
> c}
1
?
|
{z
}
[≈Java][֒→ GDI, 02-39]
7–5
Beispiele
int a = 8;
a += 8;
a %= 3;
c dl
// a: 16
// a: 1
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.3 Zuweisungsoperatoren
7–6
Zuweisungen sind Ausdrücke!
Bitoperationen
Zuweisungen können in komplexere Audrücke geschachtelt werden
Bitweise Verknüpfung von Ganzzahltypen, kommutativ
Das Ergebnis eines Zuweisungsausdrucks ist der zugewiesene Wert
int a, b, c;
a = b = c = 1;
07-Operatoren: 2013-07-19
07-Operatoren: 2013-07-19
/ 7→ wahr
In C sind Wahrheitswerte Integers: 0 7→ falsch, 0
Typischer „Anfängerfehler“ in Kontrollstrukturen:
if (a = 6) {· · ·} else {· · ·} // BUG: if-branch is always taken!!!
Compiler beanstandet das Konstrukt nicht, es handelt sich um
einen gültigen Ausdruck! ; Fehler wird leicht übersehen!
GSPiC (Teil B, SS 14)
Bitoperationen
7 Operatoren und Ausdrücke | 7.3 Zuweisungsoperatoren
(Forts.)
[=Java][֒→ GDI, 02-41]
1 | 1 → 1
1 | 0 → 1
0 | 0 → 0
∧
bitweises „Exklusiv-Oder“
(Bit-Antivalenz)
1∧1 → 0
1∧0 → 1
0∧0 → 0
˜
bitweise Inversion
(Einerkomplement, unär)
˜1 → 0
˜0 → 1
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.4 Bitoperatoren
7 6 5 4 3 2 1 0
x=156
1 0 0 1 1 1 0 0
0x9c
~x
0 1 1 0 0 0 1 1
0x63
7
0 0 0 0 0 1 1 1
0x07
x | 7
1 0 0 1 1 1 1 1
0x9f
x & 7
0 0 0 0 0 1 0 0
0x04
x ^ 7
1 0 0 1 1 0 1 1
0x9B
x << 2
0 1 1 1 0 0 0 0
0x70
x >> 1
0 1 0 0 1 1 1 0
0x4e
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.4 Bitoperatoren
7–8
Durch Verknüpfung lassen sich gezielt einzelne Bits setzen/löschen
07-Operatoren: 2013-07-19
07-Operatoren: 2013-07-19
bitweises „Oder“
(Bit-Vereinigungsmenge)
Bit#
7 6 5 4 3 2 1 0
PORTD
? ? ? ? ? ? ? ?
Bit 7 soll verändert werden, die
anderen Bits jedoch erhalten bleiben!
0x80
1 0 0 0 0 0 0 0
PORTD |= 0x80
1 ? ? ? ? ? ? ?
Setzen eines Bits durch Ver-odern mit
Maske, in der nur das Zielbit 1 ist
~0x80
0 1 1 1 1 1 1 1
PORTD &= ~0x80
0 ? ? ? ? ? ? ?
0x08
0 0 0 0 1 0 0 0
PORTD ^= 0x08
? ? ? ? ¿ ? ? ?
(x sei vom Typ uint8_t)
Bit#
c dl
|
Bitoperationen – Anwendung
bitweises Linksschieben (rechts werden 0-Bits „nachgefüllt“)
bitweises Rechtsschieben (links werden 0-Bits „nachgefüllt“)
Beispiele
1&1 → 1
1&0 → 0
0&0 → 0
c dl
7–7
Schiebeoperationen auf Ganzzahltypen, nicht kommutativ
<<
>>
bitweises „Und“
(Bit-Schnittmenge)
// Value of a and b?
Besonders gefährlich: Verwendung von = statt ==
c dl
&
// c: 1, b: 1, a: 1
Die Verwendung von Zuweisungen in beliebigen Ausdrücken führt
zu Nebeneﬀekten, die nicht immer oﬀensichtlich sind
a += b += c;
[=Java][֒→ GDI, 02-41]
7–9
c dl
GSPiC (Teil B, SS 14)
Löschen eines Bits durch Ver-unden
mit Maske, in der nur das Zielbit 0 ist
Invertieren eines Bits durch Ver-xodern
mit Maske, in der nur das Zielbit 1 ist
7 Operatoren und Ausdrücke | 7.4 Bitoperatoren
7–10
Bitoperationen – Anwendung
Bedingte Auswertung
(Forts.)
Bitmasken werden gerne als Hexadezimal-Literale angegeben
Bit#
0x8f
Formulierung von Bedingungen in Ausdrücken
Ausdruck1 ? Ausdruck2 : Ausdruck3
7 6 5 4 3 2 1 0
1 0 0 0 1 1 1 1
|
{z
8
}|
{z
f
}
Zunächst wird Ausdruck1 ausgewertet
Jede Hex-Ziﬀer repräsentiert genau ein
Halb-Byte (Nibble) ; Verständlichkeit
Ausdruck1 =
6 0 (wahr )
Ausdruck1 = 0 (falsch)
Für „Dezimal-Denker“ bietet sich die Linksschiebe-Operation an
PORTD |= (1<<7);
PORTD &= ~(1<<7);
Beispiel
#include <led.h>
void main() {
uint8_t mask = (1<<RED0) | (1<<RED1);
while(1) ;
0
1
2
3
4
5
6
07-Operatoren: 2013-07-19
07-Operatoren: 2013-07-19
Zusammen mit der Oder-Operation auch für komplexere Masken
;
7
R0 Y0 G0 B0 R1 Y1 G1 B1
}
c dl
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.4 Bitoperatoren
Sequenzoperator
int abs(int a) {
// if (a<0) return -a; else return a;
return (a<0) ? -a : a;
}
c dl
7–11
[6= Java]
1
Zunächst wird Ausdruck1 ausgewertet
; Nebeneﬀekte von Ausdruck1 werden sichtbar
Ergebnis ist der Wert von Ausdruck2
2
3
4
5
6
7
8
9
10
11
12
13
14
15
07-Operatoren: 2013-07-19
07-Operatoren: 2013-07-19
Verwendung des Komma-Operators ist selten erforderlich!
(Präprozessor-Makros mit Nebeneﬀekten)
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.5 Weitere Operatoren
GSPiC (Teil B, SS 14)
7–13
7 Operatoren und Ausdrücke | 7.5 Weitere Operatoren
Vorrangregeln bei Operatoren
Reihung von Ausdrücken
Ausdruck1 , Ausdruck2
c dl
; Ergebnis ist Ausdruck2
; Ergebnis ist Ausdruck3
?: ist der einzige ternäre (dreistellige) Operator in C
// set bit 7: 1<<7 --> 10000000
// mask bit 7: ~(1<<7) --> 01111111
sb_led_set_all_leds (mask);
[≈Java][֒→ GDI, 02-44]
c dl
[≈Java][֒→ GDI, 02-45]
Klasse
Operatoren
Assoziativität
Funktionsaufruf, Feldzugriﬀ
Strukturzugriﬀ
Post-Inkrement/-Dekrement
Prä-Inkrement/-Dekrement
unäre Operatoren
Adresse, Verweis (Zeiger)
Typkonvertierung (cast)
Typgröße
Multiplikation, Division, Modulo
Addition, Subtraktion
Bitweises Schieben
Relationaloperatoren
Gleichheitsoperatoren
Bitweises UND
Bitweises OR
Bitweises XOR
Konjunktion
Disjunktion
Bedingte Auswertung
Zuweisung
Sequenz
x() x[]
x.y x->y
x++ x--
links → rechts
++x --x
+x -x ~x !x
& *
(<Typ>)x
sizeof(x)
rechts → links
* / %
+ -
links → rechts
>> <<
links → rechts
GSPiC (Teil B, SS 14)
7–12
< <= > >=
== !=
&
|
^
&&
||
?:=
= op =
,
7 Operatoren und Ausdrücke | 7.6 Ausdrücke
links → rechts
links → rechts
links → rechts
links → rechts
links → rechts
links → rechts
links → rechts
links → rechts
rechts → links
rechts → links
links → rechts
7–14
Typumwandlung in Ausdrücken
Typumwandlung in Ausdrücken
Ein Ausdruck wird mindestens mit int-Wortbreite berechnet
Fließkomma-Typen gelten dabei als „größer“ als Ganzzahl-Typen
short- und signed char-Operanden werden implizit „aufgewertet“
int8_t a=100, b=3, res;
(֒→ Integer Promotion)
Erst das Ergebnis wird auf den Zieldatentyp abgeschnitten/erweitert
res
|{z}
=
int8_t: 75
int8_t a=100, b=3, c=4, res;
= a * b / c;
| {z }
int: 300
|
{z
int: 75
// promotion to int: 300 fits in!
}
07-Operatoren: 2013-07-19
int8_t a=100, b=3, res;
int32_t c=4;
=
int8_t: 75
c dl
a * b
| {z }
/ c;
int32_t: 300
|
{z
int32_t: 75
GSPiC (Teil B, SS 14)
֒→ 6–3
// range: -128 --> +127
// range: -2147483648 --> +2147483647
// promotion to int32_t
}
7 Operatoren und Ausdrücke | 7.6 Ausdrücke
= s < (int) u ;
// cast u to int
s
|{z}
< u;
unsigned: 65535
|
{z
// promotion to unsigned: -1 --> 65535
}
unsigned: 0
; Überraschende Ergebnisse bei negativen Werten!
; Mischung von signed- und unsigned-Operanden vermeiden!
GSPiC (Teil B, SS 14)
7 Operatoren und Ausdrücke | 7.6 Ausdrücke
6 Einfache Datentypen
7 Operatoren und Ausdrücke
int: 1
GSPiC (Teil B, SS 14)
=
5 Sprachüberblick
8 Kontrollstrukturen
V_GSPIC_handout
c dl
7 Operatoren und Ausdrücke | 7.6 Ausdrücke
}
// range: -32768 --> +32767
// range: 0 --> 65535
4 Softwareschichten und Abstraktion
// range: -32768 --> +32767
// range: 0 --> 65535
07-Operatoren: 2013-07-19
|
| {z }
int: 1
{z
}
double: 75.0
3 Java versus C – Erste Beispiele
(Typ) Ausdruck
res
|{z}
; // promotion to double
Überblick: Teil B Einführung in C
Durch den Typ-Cast-Operator kann man einen Ausdruck
gezielt in einen anderen Typ konvertieren
int: 1
res
|{z}
int: 0
c dl
7–15
Typumwandlung in Ausdrücken – Typ-Casts
int s = -1, res;
unsigned u = 1;
{z
4.0
|{z}
double: 4.0
int s = -1, res;
unsigned u = 1;
Generell wird die größte beteiligte Wortbreite verwendet
res
|{z}
|
/
// range: -128 --> +127
unsigned-Typen gelten dabei als „größer“ als signed-Typen
07-Operatoren: 2013-07-19
res
|{z}
int8_t: 75
// range: -128 --> +127
* b
}
|a {z
double: 300.0
(Forts.)
7–17
9 Funktionen
10 Variablen
11 Präprozessor
7–16
Bedingte Anweisung
[=Java][֒→ GDI, 03-11]
Fallunterscheidung
switch-Anweisung (Fallunterscheidung)
if-Anweisung (bedingte
Anweisung)
Bedingte Anweisung
if ( Bedingung )
Anweisung ;
Alternative zur if-Kaskade bei Test auf Ganzzahl-Konstanten
verschiedene Fälle in Abhängigkeit von einem ganzzahligen Ausdruck
Bedingung
ja
nein
ganzzahliger Ausdruck = ?
Anweisung
if-else-Anweisung (einfache Verzweigung)
08-Kontrollstrukturen: 2014-04-03
Anweisung2 ;
Bedingung
ja
Anweisung_1
nein
Anweisung_2
if-else-if-Kaskade (mehrfache Verzweigung)
if ( Bedingung1 )
Anweisung1 ;
else if ( Bedingung2 )
Anweisung2 ;
else
Anweisung3 ;
c dl
GSPiC (Teil B, SS 14)
Bedingung_1
ja
nein
Bedingung_2
ja
Anweisung_1
nein
Anweisung_2
Anweisung_3
8 Kontrollstrukturen | 8.1 Verzweigungen
Wert2
Anw. 2
sonst
Anw. n
···
case Wertn :
Anweisungn ;
break;
default:
Anweisungx ;
}
GSPiC (Teil B, SS 14)
8 Kontrollstrukturen | 8.1 Verzweigungen
Abweisende und nicht-abweisende Schleife [=Java]
Zählende Schleife
Abweisende Schleife
Nicht-abweisende Schleife
[֒→ GDI, 03-26]
[֒→ GDI, 03-27]
for-Schleife (Laufanweisung)
while-Schleife
do-while-Schleife
Null- oder mehrfach ausgeführt
Ein- oder mehrfach ausgeführt
for ( Startausdruck ;
Endausdruck ;
c dl
GSPiC (Teil B, SS 14)
Anweisung
Startausdruck
Bedingung
Anweisung ;
while( Bedingung );
do {
· · · // do at least once
} while (
sb_button_getState(BUTTON0)
== BTNRELEASED
);
8–3
08-Kontrollstrukturen: 2014-04-03
do
8 Kontrollstrukturen | 8.2 Schleifen
v ← Startausdruck (Inkrement) Endausdruck
Endausdruck
Inkrement
Beispiel (übliche Verwendung: n Ausführungen mit Zählvariable)
Bedingung
while (
sb_button_getState(BUTTON0)
== BTNRELEASED
) {
· · · // do unless button press.
}
8–2
[=Java][֒→ GDI, 03-19]
Inkrement −Ausdruck )
Anweisung ;
Anweisung
Anweisung
while( Bedingung )
Anweisung ;
Anw. x
switch ( Ausdruck ) {
case Wert1 :
Anweisung1 ;
break;
case Wert2 :
Anweisung2 ;
break;
c dl
8–1
Bedingung
08-Kontrollstrukturen: 2014-04-03
Wert1
Anw. 1
Ausdruck
08-Kontrollstrukturen: 2014-04-03
if ( Bedingung )
Anweisung1 ;
else
[=Java][֒→ GDI, 03-15]
uint8_t sum = 0; // calc sum 1+...+10
for (uint8_t n = 1; n < 11; n++) {
sum += n;
}
_
sb 7seg_showNumber( sum );
Anmerkungen
Die Deklaration von Variablen (n) im Startausdruck
ist erst ab C99 möglich
Die Schleife wird wiederholt, solange Endausdruck 6= 0 (wahr )
; die for-Schleife ist eine „verkappte“ while-Schleife
c dl
GSPiC (Teil B, SS 14)
8 Kontrollstrukturen | 8.2 Schleifen
8–4
Schleifensteuerung
[=Java][֒→ GDI, 03-23]
Überblick: Teil B Einführung in C
Die continue-Anweisung beendet den aktuellen Schleifendurchlauf
; Schleife wird mit dem nächsten Durchlauf fortgesetzt
0
1
2
3
4
5
6
4 Softwareschichten und Abstraktion
7
5 Sprachüberblick
R0 Y0 G0 B0 R1 Y1 G1 B1
6 Einfache Datentypen
Die break-Anweisung verlässt die (innerste) Schleife
; Programm wird nach der Schleife fortgesetzt
for( uint8_t led=0; led < 8; ++led ) {
if( led == RED1 ) {
break;
// break at RED1
}
sb_led_on(led);
}
c dl
GSPiC (Teil B, SS 14)
0
1
2
7 Operatoren und Ausdrücke
8 Kontrollstrukturen
3
4
5
6
7
R0 Y0 G0 B0 R1 Y1 G1 B1
8 Kontrollstrukturen | 8.2 Schleifen
V_GSPIC_handout
08-Kontrollstrukturen: 2014-04-03
for( uint8_t led=0; led < 8; ++led ) {
if( led == RED1 ) {
continue;
// skip RED1
}
sb_led_on(led);
}
3 Java versus C – Erste Beispiele
[֒→ GDI, 04-10]
Funktion (Abstraktion) sb_led_set_all_leds()
#include <led.h>
void main() {
sb_led_set_all_leds( 0xaa );
while(1) {}
}
Funktionen sind elementare Programmbausteine
Gliedern umfangreiche Aufgaben in kleine, beherrschbare Komponenten
Ermöglichen die einfache Wiederverwendung von Komponenten
Ermöglichen den einfachen Austausch von Komponenten
Verbergen Implementierungsdetails (Black-Box-Prinzip)
֒→ 4–1
Bezeichner und Parameter abstrahieren
Vom tatsächlichen Programmstück
Von der Darstellung und Verwendung von Daten
Ermöglicht schrittweise Abstraktion und Verfeinerung
9 Funktionen | 9.1 Einführung
Implementierung in der libspicboard
void sb_led_set_all_leds(uint8_t setting)
{
09-Funktionen: 2013-04-15
09-Funktionen: 2013-04-15
Funktion 7→ Abstraktion
GSPiC (Teil B, SS 14)
11 Präprozessor
Beispiel
Programmstück (Block) mit einem Bezeichner
Beim Aufruf können Parameter übergeben werden
Bei Rückkehr kann ein Rückgabewert zurückgeliefert werden
c dl
10 Variablen
8–5
Was ist eine Funktion?
Funktion := Unterprogramm
9 Funktionen
9–1
uint8_t i = 0;
for (i = 0; i < 8; i++) {
if (setting & (1<<i)) {
sb_led_on(i);
} else {
sb_led_off(i);
}
Sichtbar:
Bezeichner und
formale Paramter
Unsichtbar:
Tatsächliche
Implementierung
}
}
c dl
GSPiC (Teil B, SS 14)
9 Funktionen | 9.1 Einführung
9–2
Funktionsdeﬁnition
Typ Bezeichner ( FormaleParamopt ) {Block}
Typ des Rückgabewertes der Funktion,
void falls kein Wert zurückgegeben wird
[=Java]
Bezeichner
Name, unter dem die Funktion
aufgerufen werden kann
֒→ 5–3
[=Java]
FormaleParamopt
Liste der formalen Parameter:
Typ1 Bez1 opt , . . ., Typn Bezn opt
(Parameter-Bezeichner sind optional)
void, falls kein Parameter erwartet wird
09-Funktionen: 2013-04-15
{Block}
Implementierung; formale Parameter
stehen als lokale Variablen bereit
int max( int a, int b ) {
if (a>b) return a;
return b;
}
GSPiC (Teil B, SS 14)
Generelle Arten der Parameterübergabe
Call-by-value
Call-by-reference
GSPiC (Teil B, SS 14)
Beispiele:
int x = max( 47, 11 );
Aufruf der max()-Funktion. 47 und 11 sind
die tatsächlichen Parameter, welche nun
den formalen Parametern a und b der max()Funktion (֒→ 9–3 ) zugewiesen werden.
char[] text = "Hello, World";
int x = max( 47, text );
Fehler: text ist nicht int-konvertierbar (
tatsächlicher Parameter 2 passt nicht zu
formalem Parameter b ֒→ 9–3 )
max( 48, 12 );
Der Rückgabewert darf ignoriert werden
(was hier nicht wirklich Sinn ergibt)
c dl
[6= Java]
[֒→ GDI, 04-26]
9–5
9 Funktionen | 9.3 Aufruf
9–4
[=Java]
Funktionen können sich auch selber aufrufen (Rekursion)
int fak( int n ) {
if (n > 1)
return n * fak(n-1);
return 1;
}
Die formalen Parameter sind Verweise (Referenzen)
auf die tatsächlichen Parameter. Änderungen in den
formalen Parametern betreﬀen auch die tatsächlichen Parameter.
In C nur indirekt über Zeiger möglich. ֒→ 13–5
9 Funktionen | 9.3 Aufruf
GSPiC (Teil B, SS 14)
Funktionsaufruf – Rekursion
Die formalen Parameter sind Kopien der tatsächlichen Parameter. Änderungen in den formalen Parametern gehen mit Verlassen der Funktion verloren.
Dies ist der Normalfall in C.
[=Java]
[6=Java]
[=Java]
Liste der tatsächlichen Parameter (übergebene [=Java]
Werte, muss anzahl- und typkompatibel sein
zur Liste der formalen Parameter)
[=Java]
Des weiteren gilt
c dl
TatParam
9–3
Arrays werden in C immer by-reference übergeben
Die Auswertungsreihenfolge der Parameter ist undeﬁniert!
Name der Funktion,
in die verzweigt werden soll
[6=Java]
void wait( void ) {
volatile uint16_t w;
for( w = 0; w<0xffff; w++ ) {
}
}
9 Funktionen | 9.2 Deﬁnition
[=Java]
Bezeichner ( TatParam )
Bezeichner
[=Java]
Beispiele:
Funktionsaufruf – Parameterübergabe
09-Funktionen: 2013-04-15
Syntax:
09-Funktionen: 2013-04-15
Typ
c dl
Funktionsaufruf
Rekursive Deﬁnition der Fakultätsfunktion.
Ein anschauliches, aber mieses Beispiel
für den Einsatz von Rekursion!
Rekursion 7→ $$$
Rekursion verursacht erhebliche Laufzeit- und Speicherkosten!
Pro Rekursionsschritt muss:
Speicher bereit gestellt werden für Rücksprungadresse,
Parameter und alle lokalen Variablen
09-Funktionen: 2013-04-15
Syntax:
[≈Java]
Parameter kopiert und ein Funktionsaufruf durchgeführt werden
Regel:
c dl
Bei der systemnahen Softwareentwicklung wird
möglichst auf Rekursion verzichtet!
GSPiC (Teil B, SS 14)
9 Funktionen | 9.3 Aufruf
9–6
Funktionsdeklaration
[6= Java]
Funktionsdeklaration
Funktionen müssen sollten vor ihrem ersten Aufruf im Quelltext
deklariert (7→ bekannt gemacht) worden sein
Funktionen müssen vor ihrem ersten Aufruf im Quelltext
deklariert (7→ bekannt gemacht) worden sein
Eine voranstehende Deﬁnition beinhaltet bereits die Deklaration
Ansonsten (falls die Funktion „weiter hinten“ im Quelltext oder in einem
anderen Modul deﬁniert wird) muss sie explizit deklariert werden
Syntax:
Achtung: C erzwingt dies nicht!
Es ist erlaubt nicht-deklarierte Funktionen aufzurufen
(֒→ implizite Deklaration)
Derartige Aufrufe sind jedoch nicht typsicher
Bezeichner ( FormaleParam ) ;
Beispiel:
void main() {
int z = max( 47, 11 );
}
c dl
GSPiC (Teil B, SS 14)
void main() {
int z = max( 47, 11 );
}
int max( int a, int b) {
if(a > b) return a;
return b;
}
9 Funktionen | 9.4 Deklaration
Funktionsdeklaration
Compiler kennt die formale Parameterliste nicht
; kann nicht prüfen, ob die tatsächlichen Parameter passen
Man kann irgendwas übergeben
// Explizite Deklaration
int max( int, int );
(Forts.)
c dl
9–7
[6= Java]
int main() {
double d = 47.11;
foo( d );
return 0;
}
5
6
7
8
09-Funktionen: 2013-04-15
9
10
11
#include <stdio.h>
void foo(); // "open" declaration
5 Funktion foo() ist nicht deklariert ; der Compiler warnt, aber akzeptiert
beliebige tatsächliche Parameter
9 foo() ist deﬁniert mit den formalen Parmetern (int, int). Was immer an
tatsächlichen Parametern übergeben wurde, wird entsprechend interpretiert!
10 Was wird hier ausgegeben?
GSPiC (Teil B, SS 14)
[6= Java]
(Forts.)
Beispiel:
void foo( int a, int b) {
printf( "foo: a:%d, b:%d\n", a, b);
}
c dl
9–8
Eine Funktion, die mit leerer formaler Parameterliste deklariert
wurde, akzeptiert ebenfalls beliebige Parameter ; keine Typsicherheit
In diesem Fall warnt der Compiler nicht! Die Probleme bleiben!
9 Funktionen | 9.4 Deklaration
9–8
09-Funktionen: 2013-04-15
3
4
9 Funktionen | 9.4 Deklaration
Funktionen müssen sollten vor ihrem ersten Aufruf im Quelltext
deklariert (7→ bekannt gemacht) worden sein
Beispiel:
#include <stdio.h>
GSPiC (Teil B, SS 14)
Funktionsdeklaration
Funktionen müssen sollten vor ihrem ersten Aufruf im Quelltext
deklariert (7→ bekannt gemacht) worden sein
1
2
Moderne Compiler generieren immerhin eine Warnung
; Warnungen des Compilers immer ernst nehmen!
09-Funktionen: 2013-04-15
09-Funktionen: 2013-04-15
// Deklaration durch Definition
int max( int a, int b) {
if(a > b) return a;
return b;
}
[6= Java]
(Forts.)
int main() {
double d = 47.11;
foo( d );
return 0;
}
void foo( int a, int b) {
printf( "foo: a:%d, b:%d\n", a, b);
}
c dl
GSPiC (Teil B, SS 14)
Funktion foo wurde mit leerer
formaler Parameterliste deklariert
; dies ist formal ein gültiger
Aufruf!
9 Funktionen | 9.4 Deklaration
9–9
Funktionsdeklaration
(Forts.)
[6= Java]
Überblick: Teil B Einführung in C
Funktionen müssen sollten vor ihrem ersten Aufruf im Quelltext
deklariert (7→ bekannt gemacht) worden sein
3 Java versus C – Erste Beispiele
Eine Funktion, die mit leerer formaler Parameterliste deklariert
wurde, akzeptiert ebenfalls beliebige Parameter ; keine Typsicherheit
In diesem Fall warnt der Compiler nicht! Die Probleme bleiben!
4 Softwareschichten und Abstraktion
5 Sprachüberblick
6 Einfache Datentypen
Achtung: Verwechslungsgefahr
In Java deklariert void foo() eine parameterlose Methode
In C muss man dafür void foo(void) schreiben
֒→
7 Operatoren und Ausdrücke
9–3
8 Kontrollstrukturen
09-Funktionen: 2013-04-15
In C deklariert void foo() eine oﬀene Funktion
Regel:
c dl
V_GSPIC_handout
Das macht nur in (sehr seltenen) Ausnahmefällen Sinn!
Schlechter Stil ; Punktabzug
Funktionen werden stets vollständig deklariert!
GSPiC (Teil B, SS 14)
9 Funktionen | 9.4 Deklaration
Variablendeﬁnition
[≈Java]
10-Variablen: 2011-10-11
[≈Java]
auto, static, oder leer
Typ der Variable,
int falls kein Typ angegeben wird
(7→ schlechter Stil!)
[=Java]
[6=Java]
Bezi
Name der Variable
[=Java]
Ausdri
Ausdruck für die initiale Wertzuweisung;
wird kein Wert zugewiesen so ist der Inhalt
von nicht-static-Variablen undeﬁniert
[6=Java]
c dl
GSPiC (Teil B, SS 14)
10 Variablen | 10.1 Einführung
(Forts.)
Variablen können an verschiedenen Positionen deﬁniert werden
10–1
Global
außerhalb von Funktionen,
üblicherweise am Kopf der Datei
Lokal
zu Beginn eines { Blocks },
direkt nach der öﬀnenden Klammer
C89
Lokal
überall dort, wo eine Anweisung stehen darf
C99
int a = 0;
int b = 47;
10-Variablen: 2011-10-11
Typ
11 Präprozessor
Variablendeﬁnition
Syntax (Variablendeﬁnition):
SKopt Typopt Bez1 [ = Ausdr1 ]opt [, Bez2 [ = Ausdr2 ]opt , . . .]opt ;
Speicherklasse der Variable,
10 Variablen
9–9
Variable := Behälter für Werte (7→ Speicherplatz)
SKopt
9 Funktionen
// a: global
// b: global
void main() {
int a = b;
//
printf("%d", a);
int c = 11;
//
for(int i=0; i<c; i++) { //
int a = i;
//
}
//
}
a: local to function, covers global a
c: local to function (C99 only!)
i: local to for-block (C99 only!)
a: local to for-block,
covers function-local a
Mit globalen Variablen beschäftigen wir uns noch näher
im Zusammenhang mit Modularisierung ֒→ 12–5
c dl
GSPiC (Teil B, SS 14)
10 Variablen | 10.1 Einführung
10–2
Überblick: Teil B Einführung in C
Der C-Präprozessor
[6= Java]
3 Java versus C – Erste Beispiele
Bevor eine C-Quelldatei übersetzt wird, wird sie zunächst durch
einen Makro-Präprozessor bearbeitet
4 Softwareschichten und Abstraktion
5 Sprachüberblick
Historisch ein eigenständiges Programm (CPP = C PreProcessor)
Heutzutage in die üblichen Compiler integriert
6 Einfache Datentypen
Der CPP bearbeitet den Quellcode durch Texttransformation
7 Operatoren und Ausdrücke
Automatische Transformationen („Aufbereiten“ des Quelltextes)
Kommentaren werden entfernt
Zeilen, die mit \ enden, werden zusammengefügt
···
11-Praeprozessor: 2011-09-28
V_GSPIC_handout
8 Kontrollstrukturen
9 Funktionen
10 Variablen
11 Präprozessor
Steuerbare Transformationen (durch den Programmierer)
Präprozessor-Direktiven werden evaluiert und ausgeführt
Präprozessor-Makros werden expandiert
c dl
Präprozessor-Direktiven
[6= Java]
#define Makro Ersetzung
Makrodefinition: Deﬁniert ein Präprozessor-Makro
Makro. In der Folge wird im Token-Strom jedes
Auftreten des Wortes Makro durch Ersetzung
substituiert. Ersetzung kann auch leer sein.
Bedingte Übersetzung: Die folgenden Code-Zeilen werden
in Abhängigkeit von Bedingung dem Compiler überreicht
oder aus dem Token-Strom entfernt.
#ifdef Makro,
#ifndef Makro
Bedingte Übersetzung in Abhängigkeit davon, ob Makro
(z. B. mit #define) deﬁniert wurde.
#error Text
Abbruch: Der weitere Übersetzungsvorgang wird mit der
Fehlermeldung Text abgebrochen.
Der Präprozessor deﬁniert letztlich eine eingebettete Meta-Sprache.
Die Präprozessor-Direktiven (Meta-Programm) verändern das
C-Programm (eigentliches Programm) vor dessen Übersetzung.
GSPiC (Teil B, SS 14)
11 Präprozessor | 11.1 Einführung
11–1
[6= Java]
Präprozessor-Anweisungen
werden nicht mit einem
Strichpunkt abgeschlossen!
Leeres Makro (Flag)
#define USE_7SEG
Quelltext-Konstante
#define NUM_LEDS (4)
„Inline“-Funktion
#define SET_BIT(m,b) (m | (1<<b))
Verwendung
#if(Bedingung),
#elif, #else, #endif
c dl
Einfache Makro-Deﬁnitionen
11–2
#if( (NUM_LEDS > 8) || (NUM_LEDS < 0) )
# error invalid NUM_LEDS
// this line is not included
#endif
11-Praeprozessor: 2011-09-28
11-Praeprozessor: 2011-09-28
Inklusion: Fügt den Inhalt von Datei an der aktuellen
Stelle in den Token-Strom ein.
11 Präprozessor | 11.1 Einführung
Präprozessor – Verwendungsbeispiele
Präprozessor-Direktive := Steueranweisung an den Präprozessor
#include <Datei>
GSPiC (Teil B, SS 14)
void enlighten(void) {
uint8_t mask = 0, i;
for (i = 0; i < NUM_LEDS; i++) {
mask = SET_BIT(mask, i);
}
sb_led_set_all_leds( mask );
#ifdef USE_7SEG
sb_show_HexNumber( mask );
#endif
// NUM_LEDS --> (4)
// SET_BIT(mask, i) --> (mask | (1<<i))
// -->
// -->
}
c dl
GSPiC (Teil B, SS 14)
11 Präprozessor | 11.2 Verwendung
11–3
Präprozessor – Gefahren
[6= Java]
Funktionsähnliche Makros sind keine Funktionen!
Parameter werden nicht evaluiert, sondern textuell eingefügt
Das kann zu unangenehmen Überraschungen führen
#define POW2(a) 1 << a
n = POW2( 2 ) * 3
<< hat geringere Präzedenz als *
; n = 1 << 2 * 3
Einige Probleme lassen sich durch korrekte Klammerung vermeiden
#define POW2(a) (1 << a)
n = POW2( 2 ) * 3
11-Praeprozessor: 2011-09-28
Aber nicht alle
; n = (1 << 2) * 3
#define max(a,b) ((a > b) ? a : b)
a++ wird ggf. zweimal ausgewertet
n = max( x++, 7 )
; n = ((x++ > 7) ? x++ : 7)
Eine mögliche Alternative sind inline-Funktionen
C99
Funktionscode wird eingebettet ; ebenso eﬃzient wie Makros
inline int max(int a, int b) {
return (a > b) ? a : b;
}
c dl
GSPiC (Teil B, SS 14)
11 Präprozessor | 11.3 Gefahren
11–4