Ulrich Gabor, Christoph Borchert - TU Dortmund€¦ · Software ubiquitärer Systeme: 1. Übung 3 technische universität dortmund embedded system software Übungen zu SuS 1 SWS „Tafel“übung

Software ubiquitärer Systeme

Übung 1: Einführung

http://ess.cs.tu-dortmund.de/DE/Teaching/SS2016/SuS/

Ulrich Gabor, Christoph Borchert

http://ess.cs.tu-dortmund.de/~ug

AG Eingebettete SystemsoftwareInformatik 12, TU Dortmund

Software ubiquitärer Systeme: 1. Übung 2

technische universität dortmund

embedded system software

Überblick● Organisatorisches● Mark Weiser● C++ Crashkurs● LCD-Programmierung




Übungen zu SuS● 1 SWS „Tafel“übung (hier :-)) und 1 SWS Rechnerübung

– wöchentlich abwechselnd (je 2 SWS)

● Die Tafelübung vermittelt...

– Grundlagen der MSP430-Hardware-Architektur

– Grundwissen zur Bearbeitung der Rechnerübungen

– C++-Programmierkenntnisse

● Die Rechnerübung (OH12 Poolräume) ...

– dient zum Bearbeiten der Rechneraufgaben

– ist zum Fragenstellen da




SuS: Aufgaben● Rechneraufgaben

– alle 2 Wochen, insgesamt 5 Aufgaben

– Bearbeitung in 2er/3er-Gruppen

– MSP430-Microcontroller programmieren

● Theoretische Aufgaben

– alle 2 Wochen, insgesamt 5 Aufgaben

– Lesen von Aufsätzen

– Verstehen von Konzepten (vorlesungsbegleitend)

● Jede Woche eine neue Aufgabe!








Ubiquitous Computing● Mark Weiser: Pionier des Ubiquitous Computing

– Erste Ideen Anfang der 90er Jahre

– Wissenschaftler bei Xerox PARC, der Heimat von...● grafischen Benutzeroberflächen, Ethernet, aspektorientierter

Programmierung, …

– Wegweisender Aufsatz: “The Computer for the 21st Century”● Wird permanent zitiert




The Computer for the 21st Century1. Welche Klassen von Geräten werden vorgestellt?

2. Was waren die Visionen für „heute“ (2016)?

3. Was sind die wesentlichen Thesen des Aufsatzes?

4. Fallbeispiel für ubiquitous Computing?








SuS: Einführung C++● Grundlage für die Rechnerübungen

● Voraussetzungen:

– Programmierkenntnisse in einer objektorientierten Sprache (z.B. Java)

● Wir konzentrieren uns auf die Unterschiede zwischen Java und C++

– ...und die kleinen Eigenheiten, auf die man achten muss, wenn man C++ für Systemprogrammierung einsetzt...




Literatur● Es gibt jede Menge Bücher und Tutorials zu C++...

● Eine gute Einführung (€ 17,95) ist

– Marko Meyer: „C++ programmieren im Klartext“Pearson Verlag, ISBN 3-8273-7093-0

● Kostenlos und gut – Folien und Skript von Prof. Ring, Uni Siegen:

– http://www.math.uni-siegen.de/ring/cpp.html

● … und außerdem der Kurs „Von Java nach C++“von Prof. Müller und Frank Weichert

– die Basis für diese Folien

– http://ess.cs.tu-dortmund.de/Teaching/WS2015/BSB/Downloads/Java2C.pdf

http://ess.cs.tu-dortmund.de/Teaching/WS2015/BSB/Downloads/Java2C.pdf




C++● Wie so üblich: „Hello, World“ in C++

● Java-Version:

#include <iostream>int main() {

std::cout << "Hello, world" << std::endl;return 0;

}

import whatever.u.like.*;class Test { public static void main(String[] argv) { System.out.println("Hello, world"); }}




C++-Konzepte● Kontrollstrukturen und Variablentypen in C++

● Komplexe Datentypen (structs)

● Zeiger (Pointer) und Referenzen

● Quelltextorganisation

● Vererbung und Mehrfachvererbung

● Virtuelle Funktionen




Kontrollstrukturen und Variablentypen ● bedingte Anweisungen, Schleifen, Verbundanweisungen

(Blöcke)

– sind identisch in C++ und Java!

● In C++ sind „globale“ Funktionen möglich, in Java dagegen müssen Methoden immer innerhalb einer Klasse stehen

– insbesondere lassen sich in C++ auch „normale“ C- und Assembler-Funktionen aufrufen

– … und man kann C++-Funktionen als von C und Assembler aufrufbar deklarieren mittels extern “C” (wird für die Rechnerübungen aber nicht benötigt)

– eine wichtige globale Funktion ist die „main“-Funktion :-)




Kontrollstrukturen und Variablentypen ● Arrays (Felder) werden in C++

wie folgt definiert:

● Es findet keine Überprüfung der Array-Grenzen statt!

– Potentiell großes Sicherheitsproblem: „Buffer Overflows“, bei denen z.B. über die Grenzen von Arrays hinaus Werte (andere Variableninhalte, Rücksprungadressen auf dem Stack etc.) überschrieben werden.

● Variablen haben keine Default-Werte, müssen also immer explizit initialisiert werden. Erfolgt das nicht, generiert der Compiler eine Warnung (aber keinen error!).

● Die Speicherverwaltung muss durch den Programmierer erfolgen. Ein Garbage Collector wie in Java ist nicht vorhanden.

int a[4]; // oder mit Initialisierungint a[] = { 1, 2, 3 };




Typwandlung (type casting)● In C++ können Typen – wie in Java – explizit gewandelt werden:

– (Typ) Ausdruck, z.B.:

● Eine weitere Möglichkeit, die nur in C++ verfügbar ist:

– Typ(Ausdruck), z.B.:

int a = 3;double b = (double) a / 2; // b==1.5

int a = 3;double b = double(a) / 2; // b==1.5




Wertebereiche● In C++ existieren vorzeichenbehaftete und nicht vorzeichenbehaftete

Typen (char, short, int, long), z.B.:

– int von -2^15 bis 2^15-1

– unsigned int von 0 bis 2^16-1

● Bei arithmetischen Operationen erfolgtkeine Überprüfung auf Overflow bzw.Underflow! Sicherheitsproblem!→

● Die Wertebereiche sind maschinenabhängig!

– z.B. kann ein int 16, 32 oder 64 Bit „lang“ sein

● Mittels typedef lassen sichneue Namen für Datentypen definieren:

unsigned int i = 0;i = i – 1;// i==65535

typedef int Index;Index a = 3;




Komplexe Datentypen● enums: Aufzählungstypen

Oft Alternative zu #defines

● structs: Benutzerdefinierte zusammengesetzte Datentypen

● Verwendung:

enum { BUTTON_DOWN = (1<<0), BUTTON_UP = (1<<4) };

struct Rechteck { int xp, yp; int width, height; int color; ...};

Rechteck r;r.xp = 100; r.yp = 200; r.width = 20; r.height = 40;




Klassen in C++● Eine Klasse in C++ besteht aus

– Deklaration in Headerdatei (z.B. lcd.h)

– und Implementierungsdatei (lcd.cc)

– Name der .h/.cc-Files und Name der Klasse müssen nicht übereinstimmen!

class LCD { ... };

#include "machine/lcd.h"...




Aufbau der Headerdatei● Ausschnitt aus lcd.h:

class LCD {private: unsigned char mode; // Attribute ... public: LCD(); // Konstruktor ~LCD(); // Destruktor

void clear(); // Methoden void show_number(int line, int number);};




Aufbau der Headerdatei● Beginn der Klassendefinition mit Schlüsselwort „class“

● Klassen sind immer public

● Attribute

– (Instanz-)Variablen dürfen bei der Deklaration nicht initialisiert werden

● Konstruktoren und Destrukturen

– Konstruktoren: Instanziierung von Objekten

– Destruktoren: Löschen instanziierter Objekte● Deklaration von Methoden

● Klassendefinition wird mit Semikolon beendet!




Aufbau der Implementierungsdatei● Einbinden der Header-Datei mit #include

● Durch den Klassennamen und den Bereichsoperator „::“ wird die Zugehörigkeit zur Klasse gekennzeichnet:

#include "lcd.h"

LCD::LCD() { ...}

LCD::~LCD() {}

void LCD::clear() { ...}




Pointer (Zeiger)● Jede Speicherstelle, die einem Objekt (einer Variablen)

zugeordnet ist, hat eine eindeutige Adresse

– Bei der Systemprogrammierung kann dies auch die Speicherstelle sein, an der ein bestimmtes Gerät Speicher oder Kontrollregister einblendet — z.B. der Bildschirmspeicher

● Ein Pointer ist eine Variable, deren Wert die Speicheradresse einer Variablen, einer Struktur oder eines Objekts ist

● Pointer sind typisiert, z.B. Typ “Zeiger auf int”

● Zeiger-Typen sind durch das Symbol „*“ gekennzeichnet:

int a; // kein Pointerint *int_zeiger; // Zeiger auf Integer-Variable




Pointer (Zeiger)● Der Inhalt eines Zeigers ist der Wert, der an einer

referenzierten Speicherstelle gespeichert ist

● Die Größe des Inhalts (in Bytes) ist vom jeweiligen zugeordneten Datentyp abhängig

– z.B. 1 Byte für char, 2 Byte für short usw.

– Diese Größen sind in C/C++ architektur- und compilerabhängig, also nicht portabel!




Pointer (Zeiger)Es existieren zwei Operatoren zu Pointern:

● Adressoperator „&“

– Liefert die zu einer Variablengehörende Speicheradresse

● Dereferenzierungsoperator „*“

– Gibt den Wert zurück, der an derAdresse gespeichert ist, auf diedie Pointervariable zeigt(den Inhalt)

int_zeiger = &a;

*int_zeiger = 42;




Pointer (Zeiger): BeispielUmwandlung einer konstanten Adresse in einen ZeigerUmwandlung einer konstanten Adresse in einen Zeiger

Anlegen einer Zeigervariablen LCD_BASE (Zeiger auf char)Anlegen einer Zeigervariablen LCD_BASE (Zeiger auf char)

Zeigerarithmetik: 'pos' zeigt nun auf die Speicherstelle, in der der Zeichencode des Zeichens an Position x abgelegt ist.

Zeigerarithmetik: 'pos' zeigt nun auf die Speicherstelle, in der der Zeichencode des Zeichens an Position x abgelegt ist.

Dereferenzierung: Das Zeichen an Position x wird durch eine 0 überschrieben.

Dereferenzierung: Das Zeichen an Position x wird durch eine 0 überschrieben.

char *LCD_BASE = (char *)0x0a00;char *pos;int offset=0x20, x=1;pos = LCD_BASE + offset + x;*pos = 0;




Referenzen als Parameter● Neben den Zeigern gibt es in C++ auch „Referenzen“. Diese

werden häufig für Funktionsparameter benutzt:

● Dies entspricht einem „call by reference“, d.h. es wird eine Referenz auf die entsprechende Variable übergeben und auch zurückgegeben. Der Aufruf erfolgt dann so:

int& max(int& a, int& b) { if (a > b) return a; else return b;}

int a = 5, b = 7;max(a, b)++; // erhöht b um 1!




Systemprogrammierung in C++● Keine Laufzeitumgebung vorhanden!

– man muss alles selber von Hand bauen ...

● Damit sind auch keine Objekte dynamisch instanziierbar!

– kein „new“ und „delete“ möglich ...

– … woher soll auch die passende Speicherverwaltung dazu kommen?

● Für Spezialisten ... das geht auch nicht:– Exceptions, Assertions, runtime type information

● Ein falscher Pointer kann das Ende sein ...

– der Microcontroller hängt und das war's

– keine „segmentation violation“, keine core dumps








LCD-Controller● Direkte Kontrolle von LCDs

● Anzeigespeicher

● Autom. Signalerzeugung und -wiederholung

● Autom. Blinken

● Software-Kontrastkontrolle




LCD-Controller (2)● „Bildschirm-“Speicher

für Segmentinhalte

– Kein permanenter Refresh in

Software notwendig!

– Memory-mapped I/O

char *LCD_BASE = (char *)0x0a00;char *pos;int offset=0x20, x=1;pos = LCD_BASE + offset + x;*pos = 0;

Documents

Ulrich Gabor, Christoph Borchert - TU Dortmund€¦ · Software ubiquitärer Systeme: 1. Übung 3 technische universität dortmund embedded system software Übungen zu SuS 1 SWS „Tafel“übung