Embedded Software Engeneeringmit dem Raspberry Pi

Übersicht

● Rasperry Pi– Betriebssystem

– Hardware

● ARM● Μ-Controller vs. Μ-Prozessor vs. SoC● Embedded Software Engineering

vs. Software Engineering● Fazit

Raspberry Pi

Software

Raspbian: Debian Linux-Port

Pidora: Fedora-Port

Arch: Arch Linux-Port

...

Raspbian

● Basiert auf Debian 7 (Wheezy)● Graphische Oberfläche: LXDE● Softwarepakete aus Debian verfügbar

Hardware

● SoC: Broadcom BCM2835– CPU: ARM1176JZF-S (700 MHz)

– GPU: Broadcom VideoCore IV

● RAM: 512 MB● USB 2.0 (2x)● Video: HDMI, FBAS● Audio: HDMI, 3,5-mm-Klinkenstecker● Netzwerk: LAN9512 (100MBit)

SoC

● Broadcom VideoCore IV– FullHD-fähig– Spezifikation nicht offen ;-(

– Closed-Source-Treiber für Linux verfügbar

● ARM1176JZF-S– ARM7-Familie

– Taktung● Standard: 700Mhz● Übertaktung: bis zu 1Ghz und mehr

(Kühler notwendig!)

ARM

● ARM: Advanced RISC Machines● RISC-Architektur (Reduced Instruction Set Computer)

– Relativ wenige Befehle

– Pro Taktzyklus ein Befehl (typischerweise)

– Load-Store-Architektur

– Viele GP-Register

● 32-Bit (ARMv8: 64-Bit)

ARM - Einsatzbereich

● Smartphones● Tablet-Computer● DSL-Router● Waschmaschinen, Kühlschränke, Hausautomatisierung● Unterhaltungselektronik (TV, Receiver, DVD-Player, ...)● Autos, Flugzeuge● Medizintechnik● Industriesteuerungen● …

Softwareausführung in Eingebetteten Systemen

● Microcontroller– Meist 8- oder 32-Bit

● Microprozessoren– Eher selten

● SoCs (System-on-a-Chip)– Bei komplexen Aufgaben

dominierend

8-Bit-Microcontroller

● Chip umfasst:– Prozessor

– Arbeitsspeicher

– Datenspeicher (häufig)

– Peripheriefunktionen (SPI, I²C, CAN, ...)

● Geringe Resourcen– 256 Byte bis 512 kb RAM

– 0 Byte bis 4 kb Datenspeicher

– 1 kb bis 32 kb Programmspeicher

● Taktung: 1 – 20 Mhz

8-Bit-Microcontroller

● Geignet für simple Aufgaben und einfache Berechnungen

● Software– Meist in C geschrieben

– Relativ simple Programme

– Kein Betriebssystem

● Kostengünstig● Werden zum Teil von 32-Bit-Microcontrollen

verdrängt

Microprozessoren

● Chip umfasst: nur Recheneinheit● Hohe Taktraten: bis zu 4 Ghz● Externe Komponenten notwendig:

– Arbeitsspeicher

– Peripheriekomponenten (SPI, I²C, CAN, …)

– ...

● Sehr flexibel einsetzbar● kostenintensiv

SoCs

● Chip umfasst:– Prozessor

– Arbeitsspeicher

– Peripheriefunktionen (SPI, I²C, CAN, …)

– Viele weitere Komponenten möglich● GPU● Ethernet-Netzwerk● ...

● Taktraten: bis zu mehreren Ghz● Arbeitsspeicher: bis zu meheren Gb● Hohe Anzahl verschiedener SoCs erhältlich● Kostengünstig

Programmiersprache

● Heute meist C, seltener C++● Wenn Performance kritisch ist: Assembler● Bei unkritischen Anwendungen

(Webschnittstelle) auch Skripte

Programmierungeingebetteter Anwendungen

● µ-Controllern: kein Betriebssystem● µ-Prozessor und SoCs:

Betriebssystem vorhanden– Programmierung daher ähnlich wie bei PCs

– Aber Achtung:Andere Anforderungen an die Software

Embedded Software Engineering

● Unterschiede zum Software Engineering:– Wechselwirken mit physikalischen Prozessen

– Erhöhte Anforderungen an die Zuverlässigkeit● Fehlfunktion kann tötlich sein● Echtzeitanforderungen

Echtzeitsystem

● Echtzeitfähig bedeutet:Eine korrektes Ergebnis innerhalb eines vorbestimmten Zeitintervalls bereitzustellen.

● Echtzeitfähig != schnell● Weitere Differenzierung

– Hart echtzeitfähig:Zeitintervall wird garantiert eingehalten

– Weich echtzeitfähig:Zeitintervall wird in der Regel eingehalten

Echtzeitfähigkeit

● Ist ein „normaler“ PC echtzeitfähig?● Ist der Raspberry Pi echtzeitfähig?

Echtzeitfähigkeit

● Ist ein „normaler“ PC echtzeitfähig?● Ist der Raspberry Pi echtzeitfähig?

● Antwort (auf beide Fragen): kommt drauf an!

Echtzeitfähigkeitvon Betriebssystemen

● Probleme:– Multitasking

– Speicherverwaltung (Swapping)

– Locks auf Resourcen

– …

● Lösungen:– Echtzeitbetriebssystem

(VxWorks, QNX, LynxOS, …)

– Erweiterung von „normalen“ Betriebssystemen

– Zusätzliche Hardware

RTAI(Real Time Application Interface)

● Echtzeitfähiger Microkernel unter Linux

RTAI(Real Time Application Interface)

● Pro:– Harte Echtzeitfähigkeit

– Einfaches Konzept

● Contra:– Linux-Kernel kann nicht in Echtzeittasks genutzt

werden

– Nicht vollständig auf ARM portiert

Echtzeitfähigkeit von Linux

● Linux ist (ab 2.6.23.1) weich echtzeitfähig● Notwendig:

– Kernelparameter CONFIG_PREEMPT_RT setzen

– High-Resolution-Timer aktivieren

– ACPI und APM deaktivieren (nur x86)

● Scheduler:– SCHED_OTHER

– SCHED_RR

– SCHED_FIFO

Echtzeitfähigkeit von Linux

● Vorgehen:– Setzen des Schedulers auf SCHED_FIFO

(alternativ SCHED_RR)

– Setzten der Priorität– Locken des Speichers– Resevieren von Speicher auf dem Stack

● Prozess wird nur unterbrochen durch– I/O-Anfragen

– Prozess mit höherer Priorität

– Aufruf von sched_yield

Echtzeitfähigkeit von Linux

int main(int argc, char* argv[]) {

struct timespec t;

struct sched_param param;

int interval = 50000; /* 50us */

param.sched_priority = MY_PRIORITY;

if(sched_setscheduler(0, SCHED_FIFO, &param) == -1) exit(-1);

if(mlockall(MCL_CURRENT|MCL_FUTURE) == -1) exit(-2);

stack_prefault(); /* Stack reservieren */

clock_gettime(CLOCK_MONOTONIC, &t);

while(1) {

do_work(); /* Arbeit durchführen */

t.tv_nsec += interval;

while (t.tv_nsec >= NSEC_PER_SEC) {t.tv_nsec -= NSEC_PER_SEC; t.tv_sec++;}

clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &t, NULL);

}

}

Echtzeitfähigkeit von Linux

● Pro:– Läuft mit einem Standardkernel

(sofern RT-PREEMPT aktiviert ist)

– Kernel und Treiber prinzipiel nutzbar● Contra:

– „Nur“ weiche Echtzeitfähigkeit

– High-Resolution-Timer u.U. nicht verfügbar

– Gefahr von verdecktem I/O-Anfragen (mmap)

Fazit

● Echtzeitanforderungen– mit Linux umsetzbar

– mit Raspberry Pi umsetzbar

● Realisierung aber nicht trivial