Embedded Systems Engineering 1 V2.00 Release 0.81 WS … · Die eingebetteten Systeme übernehmen komplexe Steuerungs-, Regelungs- und Datenverarbeitungsaufgaben für bzw. in diesen

Embedded Systems Engineering 1

V2.00 Release 0.81

WS 2014/2015

Prof. Dr. Christian Siemers

TU Clausthal, Institut für Prozess- und Produktionsleittechnik

Inhaltsverzeichnis

1 Einführung in die Thematik ................................................................................. 1 1.1 Allgemeines ................................................................................................. 1 1.2 Aufbau der Vorlesung ................................................................................. 2

2 Kurzeinführung zu Mikrocontrollern und zum ATmega8 ................................... 3 2.1 Von-Neumann-Rechnermodell .................................................................... 3

2.1.1 Grundkonzept ................................................................................... 3 2.2 Sequenzielle Befehlsausführung und Befehlstypen ..................................... 5

2.2.1 Sequenzielle Befehlsausführung ....................................................... 5 2.2.2 Befehlsgruppen ................................................................................. 7

2.3 Datentypen und Datenrepräsentation ......................................................... 10 2.3.1 Polyadische Zahlensysteme ............................................................ 10 2.3.2 Umrechnung zwischen Zahlensystemen ......................................... 10 2.3.3 Zahlen- und Informationsdarstellung im Rechner .......................... 11

2.4 Ein kurzes Beispiel zu der (imperativen) Sprache C und der Programmierung von Mikrocontrollern ............................................................. 15

2.4.1 Kurzeinführung in C ....................................................................... 15 2.4.2 Beispielprogramm ........................................................................... 16 2.4.3 Die Einbindung der Peripherie ....................................................... 19

3 Speichertechnologien und –bausteine................................................................ 21 3.1 Dynamische RAMs (DRAM) .................................................................... 21 3.2 Statische RAMs (SRAM) .......................................................................... 28 3.3 Nur-Lesespeicher (PROM, EPROM, EEPROM) ...................................... 32 3.4 Nichtflüchtige RAMs (Non-Volatile RAMs) ............................................ 36

3.4.1 NVRAMs ........................................................................................ 36 3.4.2 Ferroelektrische RAMs (FRAM, FeRAM) ..................................... 38 3.4.3 Magnetoresistive RAMs (MRAM) ................................................. 39

3.5 Zusammenfassung der verschiedenen Speichertechnologien .................... 40

4 Der Mikroprozessor Atmel ATmegaXXX ........................................................ 42 4.1 Allgemeines zu Bussystemen bei Mikroprozessoren ................................ 42 4.2 Synchrone, semi-synchrone und asynchrone Systembusse ....................... 44

4.2.1 Der synchrone Systembus ............................................................... 44 4.2.2 Der semi-synchrone Systembus ...................................................... 46 4.2.3 Der asynchrone Systembus ............................................................. 48

4.3 Der Mikroprozessor ATmega2560 ............................................................ 49 4.3.1 Das Pinout des ATmega2560 ......................................................... 50 4.3.2 Der externe Bus-Modus (External Memory Interface) ................... 51

II Embedded Systems Engineering 1

4.3.3 Speicherbelegung im ATmegaXXX ............................................... 53 4.3.4 Zugriff auf das EEPROM ............................................................... 55

4.4 Aufbau eines Rechnersystems auf Basis ATmega2560 ............................ 56 4.4.1 Aufbau der Hardware ..................................................................... 56 4.4.2 Konfiguration in der Software ........................................................ 61

5 Einführung in die ATmega8-Assemblersyntax ................................................. 62 5.1 Das Programmiermodell der ATmega8-CPU ............................................ 62 5.2 Speichermodell und Einbindung der Peripherie ........................................ 65 5.3 Das Stack-Konzept .................................................................................... 68 5.4 Die Adressierungsmodi ............................................................................. 70

5.4.1 Adressierungsmodi für Datenoperationen ...................................... 70 5.4.2 Adressierungsmodi für Kontrollflussbefehle .................................. 73

5.5 Die Assemblernotation für die ATmega8-Familie .................................... 74 5.5.1 Transferbefehle ............................................................................... 74 5.5.2 Bitverarbeitungsbefehle .................................................................. 75 5.5.3 Befehle zur logischen Verknüpfung ............................................... 76 5.5.4 Arithmetische Verarbeitungsbefehle .............................................. 76 5.5.5 Sprungbefehle ................................................................................. 77 5.5.6 Unterprogrammbefehle ................................................................... 79 5.5.7 Sonstige Befehle ............................................................................. 80

6 Serielle und parallele Interfaces in Mikrorechnern ............................................ 81 6.1 Einleitung und Unterteilung ...................................................................... 81 6.2 General-Purpose Interfaces........................................................................ 82

6.2.1 GPIOs im ATmegaXXX ................................................................. 82 6.2.2 Der Parallel-Input-Output-Baustein 8255 ....................................... 85 6.2.3 Allgemeine parallele Interfacebausteine ......................................... 90

6.3 Serielle I/O-Systeme: Von RS232 bis SPI................................................. 92 6.3.1 RS 232 ............................................................................................ 92 6.3.2 EIA-485 .......................................................................................... 98 6.3.3 I²C-Bus ......................................................................................... 100 6.3.4 Serial Peripheral Interface (SPI) ................................................... 103

6.4 Timer in Mikrorechnern .......................................................................... 106 6.4.1 Allgemeines zu Timern ................................................................. 106 6.4.2 Timer im ATmega2560 ................................................................ 107

6.5 Interrupt-Requests ................................................................................... 107 6.5.1 Die Integration von IRQs im ATmega2560 .................................. 109 6.5.2 Anwendungen von Interrupt Requests .......................................... 112 6.5.3 Weiterentwicklung des IRQ-Managements .................................. 114

Literatur 121

Inhaltsverzeichnis III

Sachwortverzeichnis ............................................................................................. 122

1 Einführung in die Thematik

1.1 Allgemeines

Eingebettete Systeme, engl. Embedded Systems, sind in der Praxis außerordentlich häufig anzutreffen. Praktisch jedes elektronische System wird durch mindestens einen Mikrocontroller gesteuert, geregelt oder unterstützt, so dass die Anzahl der Mikrocontroller in eingebetteten Systemen diejenige der Mikroprozessoren in Rechnern, engl. so genannten Self-Contained Systems, bei weitem übersteigt.

Doch was sind eingebettete Systeme überhaupt? Unter einem eingebetteten System versteht man ein elektronisches System, das aus Hardware und Software besteht und in komplexe technische Umgebungen eingebettet sind [Sch05]. Diese Umge-bungen sind meist maschinelle Systeme, in denen das eingebettete System mit Interaktion durch einen Benutzer arbeitet oder auch vollautomatisch (autonom) agiert. Die eingebetteten Systeme übernehmen komplexe Steuerungs-, Regelungs- und Datenverarbeitungsaufgaben für bzw. in diesen technischen Systemen.

Die nächste Frage ist den Mikroprozessoren und Mikrocontrollern gewidmet. Unter einem Prozessor versteht man die Central Processing Unit (CPU) aus dem Von-Neumann-Modell, ein Mikroprozessor ist die monolithisch integrierte Varian-te, also diejenige, bei dem die komplette CPU auf einem Chip integriert ist.

Ein Mikrocontroller besteht aus mindestens einem Mikroprozessor, auch als Core bezeichnet, und einem weiteren Teil des Von-Neumann-Modells, also Speicher oder Input/Output (Peripherie). Mikrocontroller führen daher die Integration auf einem Chip noch weiter als Mikroprozessoren.

Das wesentliche Merkmal von eingebetteten Systemen ist die enge Verknüpfung des Mikrocontrollers/Mikroprozessors mit der umgebenden Maschine. Hieraus resultiert, dass das eingebettete System Randbedingungen erfüllen muss, die durch die Maschine vorgegeben sind, häufig z.B. Echtzeitverhalten, besondere Zuverläs-sigkeit etc.. Dies stellt besondere Anforderungen an den Entwicklungsprozess, sowohl Hard- als auch Software betreffend.

Im Rahmen des gesamten Curriculums der Informatik an der TU Clausthal wird für die Entwicklung eingebetteter Systeme eine dreiteilige Veranstaltung angeboten. Diese Vorlesung mit dem Titel Embedded Systems Engineering 1 ist als Einfüh-rung konzipiert und behandelt exemplarisch das Design solcher Systeme am Bei-spiel von 8-Bit-Mikrocontrollern. Die zweite Vorlesung wird im Master angeboten und beinhaltet die systematische Entwicklung für eingebettete Systeme einschließ-lich Test, Verifikation und Optimierung. Die dritte Vorlesung Embedded Systems Engineering 3 ist Hard- und Softwareoptimierungen gewidmet, also dem Engi-neering, um an gegebene Randbedingungen anzupassen.

2 Embedded Systems Engineering 1

1.2 Aufbau der Vorlesung

Die zahlenmäßig am häufigsten eingesetzten Mikrocontroller sind 8-Bit-Mikrocon-troller. Die Preise hierfür bewegen sich etwa im Segment von 1 bis 10 €, sie sind damit häufig billiger als mechanische Komponenten wie Kabel, Steckverbinder usw. Komplexere Geräte wie Mobiltelefone enthalten durchaus mehrere Mikro-controller, auch in deren Spezialform als Digitaler Signalprozessor (DSP).

In der Klasse der 8-Bit-Mikrocontroller – mit der Angabe 8 bit wird die intrin-sische Datenverarbeitungsbreite angegeben, also diejenige Breite, die in einem Durchgang berechnet werden kann – zählen die Derivate der Atmel ATmega8-Baureihe zu den häufigsten.

Diese Vorlesung befasst sich nun mit Hard- und Software, exemplarisch an einem Mitglied der ATmega8-Familie, um zu zeigen, wie mithilfe dieser Mikrocontroller Applikationen gebaut werden können. Während sich in der Vorlesung die Themen Hardwarearchitektur, Hardware/Software-Interface und Software die Waage hal-ten, liegt der Schwerpunkt im Praktikum auf der Erstellung von Applikationen, also der Entwicklung hardwarenaher Software.

Um diesem Praktikum eine Basis zu geben, wird im ersten Teil der Vorlesung ein Abschnitt eingefügt, der sich mit dem Von-Neumann-Modell, der Ausführung von Befehlen, Zahlendarstellungen, Übersetzungsvorgang usw. befasst. Dies ist in Ka-pitel 2 dieses Skripts konzentriert.

Kapitel 3 befasst sich mit den Speichertechnologien und den zugehörigen Baustei-nen. Diese Speicherbausteine sollen binärwertige digitale Werte speichern können, und dies bei diversen Randbedingungen wie Preis, Verlustleistung, Datenerhalt, Zuverlässigkeit usw.. Wichtigste Vertreter sind dynamische und statische RAMs sowie die EPROMs in diversen Ausführungsformen.

Kapitel 4 ist der Hardware der ATmega8-Mikrocontrollerfamilie gewidmet, speziell dem Mikroprozessorkern (auch als Core bezeichnet) und beginnt mit den Bussystemen. Weitere Themen sind das Speichermodell und dessen praktische Auswirkung auf die Gestaltung eines kompletten Mikrorechners und der Ablauf einiger Maschinenbefehle.

Kapitel 5 gibt eine (kurzgehaltene) Einführung in die Assemblerprogrammierung der ATmega8-CPU und behandelt damit das so genannte Hardware-Software-In-terface (HSI). Hinzu gehören auch Themen wie Stack und Interrupt Request Behandlung.

Kapitel 6 schließlich behandelt die Schnittstellen zur parallelen und seriellen Schnittstelle, zum Timer, Interrupt-Request-Controller und zu weiteren Kompo-nenten, die zur Peripherie gezählt werden.

2 Kurzeinführung zu Mikrocontrollern und zum ATmega8

2.1 Von-Neumann-Rechnermodell

2.1.1 Grundkonzept Die kennzeichnenden Merkmale eines Rechners nach dem Von-Neumann-Prinzip sind:

1. Ein (zentralgesteuerter) Rechner ist aus den drei Grundbestandteilen

• Zentraleinheit (Central Processing Unit, CPU)

• Speicher (Memory)

• Ein-/Ausgabeeinheit (Input/Output Unit)

aufgebaut. Hinzu kommen noch Verbindungen zwischen diesen Teileinheiten, die als Busse bezeichnet werden. Die CPU übernimmt innerhalb dieser Dreitei-lung die Ausführung von Befehlen und enthält die dafür notwendige Ablauf-steuerung. Im Speicher werden sowohl die Daten als auch die Programme in Form von Bitfolgen abgelegt. Die Ein-/Ausgabeeinheit stellt die Verbindung zur Außenwelt in Form des Austausches von Programmen und Daten her.

2. Die Struktur des Rechners ist unabhängig von dem zu bearbeitenden speziellen Problem. Die Anpassung an die Aufgabenstellung erfolgt durch Speicherung eines eigenständigen Programms für jedes neue Problem im Speicher des Rech-ners. Dieses Programm enthält die notwendigen Informationen für die Steu-erung des Rechners. Dieses Grundkonzept der Anpassung hat zu der Bezeich-nung ‘programmgesteuerter Universalrechner’ (engl. ‘stored-program mach-ine’) geführt.

3. Der Speicher besteht aus Plätzen fester Wortlänge, die einzeln mit Hilfe einer festen Adresse angesprochen werden können. Innerhalb des Speichers befinden sich sowohl Programmteile als auch Daten, zwischen denen – als Speicherinhalt – grundsätzlich nicht unterschieden wird.

Dem Speicher kommt im Von-Neumann-Modell eine zentrale Bedeutung zu, da sowohl Daten als auch Programminformationen darin gehalten werden. Wie in Bild 2.2 dargestellt, ist die Hardware dieses Rechners eigentlich fixiert. Die Auswahl der momentanen Aktion erfolgt durch den Kontrollfluss (die Instruktion), und diese Aktion wirkt auf den Datenfluss.


Zentraleinheit(Central Processing Unit, CPU)

Steuerwerk(Control Unit, CU)

Rechenwerk(Arithmetical

Logical Unit, ALU)

Verbindungssystem(Bussystem)

Speicher(Memory)

Ein-/Ausgabe(Input/Output)

Bild 2.1: Prinzipieller Aufbau eines Von-Neumann-Rechners

Aus den genannten Grundprinzipien können die wesentlichen Charakteristika des Von-Neumann-Rechners abgeleitet werden:

1. Zu jedem Zeitpunkt führt die CPU exakt einen Befehls aus. Die Steuerung der Bearbeitung liegt im Steuerwerk (Control Unit, CU), das in der Lage sein muss, alle notwendigen Schritte zur vollständigen Behandlung einleiten zu können. Innerhalb eines Befehls kann höchstens ein Datenwert bearbeitet, d.h. neu berechnet werden. Dieses Prinzip wird Single Instruction - Single Data (SISD) genannt.

Hardware:Fixiert

Algorithmus:Variabel

Eingangsdaten Ergebnis

Kon

trol

lflus

s

Bild 2.2: Ablaufprinzip des Von-Neumann-Rechners

2 Kurzeinführung zu Mikrocontrollern und zum ATmega8 5

2. Alle Inhalte von Speicherzellen, im Folgenden Speicherwörter genannt, sind prinzipiell als Daten oder Befehle interpretierbar. Die Daten wiederum können als ‘eigentliche’ Daten oder als Referenzen auf andere Speicherzellen (Adres-sen) genutzt werden. Die jeweilige Verwendung eines Speicherinhalts richtet sich allein nach dem momentanen Kontext des laufenden Programms.

3. Als Konsequenz aus der vorgenannten Eigenschaft können Daten und Befehle nicht gegen ungerechtfertigten Zugriff geschützt werden, da sie gemeinsam ohne Unterscheidungsmöglichkeit im Speicher untergebracht sind.

2.2 Sequenzielle Befehlsausführung und Befehlstypen

2.2.1 Sequenzielle Befehlsausführung Ein Von-Neumann-Rechner zeigt unter den beschriebenen Voraussetzungen einen typischen Verlauf einer Befehlsbearbeitung. Exemplarisch ist in Bild 2.3 der Ab-lauf, insbesondere der Signale auf dem Bussystem, für einen Transferbefehl zwischen Speicher und Register (”ST“, store) dargestellt. Die Befehlsnotation in der Assemblersprache könnte etwa

ST Z, R18

lauten. Die korrekte Interpretation dieses Befehls lautet: Kopiere den Inhalt des Registers R18 an diejenige Stelle im Speicher, auf die Z (als Pointerregister) zeigt.

Im Rahmen dieser Befehlsbearbeitung können zwei grobe Phasen identifiziert werden. In der Phase 1 lädt die CPU, gesteuert durch Abläufe in dem Steuerwerk CU, das Befehlswort aus dem Speicher einschließlich aller benötigten Zusatzinfor-mationen wie Operanden, die in diesem Fall aus der (Daten-)Speicheradresse bestehen. Die Codeadresse, an der dieses Befehlswort steht, wird im Programm-zähler (Program Counter, PC, auch Instruction Pointer, IP) festgelegt. Diese Phase wird auch mit Fetch bezeichnet.

Diese Phase zeigt sich am Bussystem, indem zwei lesende Zugriffe – je einer für das Befehlswort und den Operanden – zeitlich sequentiell ablaufen. Das Steuer-werk speichert die Inhalte in dafür vorgesehene Befehlsregister und interpretiert sie für die weiteren Aktionen.

In der zweiten Befehlsphase wird nun der Inhalt des Registers, hier mit R18 bezeichnet, in die adressierte Speicherzelle kopiert. Das oder die Register gehören zur CPU, können aber wie Datenspeicher beliebige Datenwerte (zwischen-)spei-chern.

Für diesen Vorgang wird der Inhalt aus dem Registerblock des Rechenwerks auf den Datenbus kopiert, während der Adressbus die Information über die gewünschte


Speicherzelle trägt (aus Z). Adress- und Datenbus sind Teilsysteme der Verbin-dungseinrichtung im Von-Neumann-Rechner.

Steuerwerk

Program Counter

Rechenwerk

Register

BlockALU

Ablaufsteuerung

Befehlsregister

Opcode Adressfeld

Adressbus

CPU

1

2

DatenbusSteuerbus

2

1

Status

Register

Speicher

Input/Output

2

Bild 2.3: Befehlsablauf im Von-Neumann-Rechner

Das hier exemplarisch gezeigte Verfahren zweier Phasen in der Befehlsbearbeitung ist die technische Lösung für das grundsätzliche Problem des Von-Neumann-Rech-ners, nur eine Verbindungseinrichtung zu zwei verschiedenen Speicherinhalten –


Programm und Daten – zu besitzen. Im Allgemeinen gilt hier folgendes Konzept des zeitlichen Multiplex des Bussystems:

1. In der sogenannten Fetch- und Interpretationsphase wird aufgrund der durch den Befehlszähler angezeigten Adresse der Inhalt einer Speicherzelle geladen und als Befehl interpretiert. Zu dieser Phase zählt im Allgemeinen auch das Laden von Operanden, zumeist von Adressen oder unmittelbaren Daten. Dieser Vorgang wird durch die Interpretation des Befehls gesteuert.

2. In der darauffolgenden Ausführungsphase wird der Befehl nunmehr vollständig interpretiert und ausgeführt. Die Ausführung kann verschiedene Teile der CPU und des Bussystems sowie der angeschlossenen Einheiten in Anspruch nehmen, dies wird durch das Steuerwerk entsprechend gesteuert. Gemeinsam ist diesen Vorgängen, dass alle Speicherzelleninhalte, auch aus dem Ein-/Ausgabesystem, als Daten interpretiert werden.

Dieser zweistufige Ablauf muss für einen Befehl streng sequentiell ablaufen, da eine Abhängigkeit zwischen den verschiedenen Phasen existiert. Spätere Variatio-nen der Von-Neumann-CPU, z.B. die RISC-Architekturen, beinhalten ein Phasen-pipelining, das eine scheinbare Parallelität der Aktionen zueinander bewirkt. Dies stellt keinesfalls einen Widerspruch zu dem bisher Gesagten dar, denn die Paralle-lität im Phasenpipelining bezieht sich auf verschiedene Befehle, während die Bearbeitung eines Befehls weiterhin streng sequentiell bleibt.

Der Zeitmultiplex der Busnutzung ist notwendig geworden, da – wie aus dem Beispiel bereits ersichtlich wurde – das Bussystem für den Zugriff auf mehrere Arten von Speicherzelleninhalten genutzt wird. Dies wiederum hat seine Ursache darin, dass der gleiche Speicher fast immer im Mittelpunkt der Operationen steht, unabhängig davon, ob es Programm- oder Dateninhalte sind, auf die zugegriffen werden soll. Die CPU-Speicherkommunikation wird daher die Leistungsfähigkeit des Gesamtsystems entscheidend beeinflussen, was auch als Von-Neumann-Flaschenhals (von Neuman bottleneck) bezeichnet wird.

Das von Neumann-Rechnermodell kann als optimal im Sinn von minimal bezeichnet werden. Die in- und externen Ressourcen, die hierbei zur Anwendung kommen, sind nicht weiter minimierbar, ohne eine sehr wesentliche Einschränkung der Funktionalität bis hin zur Sinnlosigkeit des Einsatzes hinzunehmen.

2.2.2 Befehlsgruppen Die im vorletzten Abschnitt bereits verkündete Universalität des Von-Neumann-Rechners (und auch des Harvard-Rechners, dessen Unterschied in der Trennung von Code- und Datenbereich liegt) kann natürlich nur gelten, wenn entsprechende Instruktionen existieren, um alle Algorithmen auszuführen. Es lässt sich nun nachweisen, dass ein einziger Befehl

SUBBEQ X, Y, Z


(subtract and branch if equal) für diesen Zweck genügt. Dieser Befehl wird so ausgeführt, dass X = X-Y zugewiesen und an die Programmstelle Z gesprungen wird, wenn das Ergebnis 0 ist.

Als einzige arithmetisch/logische Operation ist also die Subtraktion erforderlich, daneben muss es die Möglichkeit geben, den Programmfluss zu ändern (so genann-te Sprünge). Beide Aktionen sind in obigem, nicht Praxis-relevanten Beispiel ver-einigt, ein solcher Befehl würde als komplex bezeichnet werden. Andere notwen-dige Operationen wie die Wertzuweisung an eine Variable können auf diese Basisoperationen zurückgeführt werden.

In der Praxis wird ein Mikroprozessor bzw. Mikrocontroller mit mehr Befehlen versehen, weil dies zu kürzeren, schnelleren und auch verständlicheren Program-men führt. Folgende Befehlsgruppen und weitere Details sind in Mikroprozessoren zu finden:

• Interne Rechen- und Zwischenregister. Alle Berechnung können zwar auf Spei-cherinhalten durchgeführt werden, dies ist aber sehr aufwendig (durch viele Buszyklen). CPU-interne Register mindern den Aufwand stark. Das Register-modell für die ATmega8-CPU ist in Bild 2.4 dargestellt.

Bild 2.4 Registermodell ATmega8

• Befehlsgruppe der Transferbefehle: Diese Befehle kopieren Daten zwischen Registern, zwischen Register und Speicher und ggf. sogar zwischen verschie-denen Speicherstellen. Beispiele im ATmega8: mov R0, R2; Kopie von R2 in R0


lds R1, $12; (load Direct from SRAM), Lade den Inh alt der ; Speicherzelle $12 (dezimal 18) in R1

st Y, R6; Speicher den Inhalt von R6 an die Stelle im SRAM, ; deren Adresse in Y (R28/29) steht

• Befehlsgruppe der arithmetischen und logischen Befehle: Hier sind die arithme-tischen (Addition, Subtraktion, meist Multiplikation, seltener Division) und die logischen (bitweises AND, OR, XOR) sowie die Shift- und Rotations-Ope-rationen integriert. Beispiele hierfür sind: adiw R8, 5; (Add immediate to word): Addiere die K onstante

; 5 zum Registerpaar R8/R9. Die Flags C, Z, N, V ; und S sind anschließend gesetzt/gelösch t, ; abhängig vom Ergebnis

sbc R6, R7; (subtract with carry): Subtrahiere mit Berück ; sichtigung des Carry-Bits (R6) – (R7) u nd ; schreibe das Ergebnis in R6.

or R17, R21; logisches OR von (R17) und (R21), Erg ebnis ; nach R17

lsl R5; Logischer Shift nach links, um 1 bit

• Befehlsgruppe der Kontrollflussbefehle: Hier sind alle bedingten und unbeding-ten Sprungbefehle zusammengefasst, deren Aktion die Beeinflussung des Program Counters beinhaltet. Beispiele: ijmp;

Jump indirect to location in Z (R30/31): Dies ist ein unbedingter Sprungbefehl an die (16-bit-)Stelle, di e im Registerpaar R30/31 (= Z) steht.

brne Label2;

Branch if Z-Flag (zero) is zero: Springe, wenn das Zero-Flag 0 ist (ein Vergleich also Ungleichheit festste llt), an die bezeichnete Stelle.

rcall Routine1;

Relative call: Rufe ein Unterprogramm auf, dessen Einsprungstelle relativ zum aktuellen PC-Wert gegeb en ist.

ret;

Subroutine return, springe an die gespeicherte Rüc ksprung-adresse zurück und bearbeite das Programm dort weit er.

Wie deutlich zu sehen ist, sind hier nur einfache Befehle zu finden. Eine ausführ-lichere Darstellung des Befehlssatzes der ATmega8-CPU ist in Kapitel 5 dieses Skripts zu finden.


2.3 Datentypen und Datenrepräsentation

2.3.1 Polyadische Zahlensysteme Zunächst jedoch einige grundsätzliche Anmerkungen zum verwendeten Zahen-system. Das Dezimalsystem gehört zur allgemeinen Klasse der polyadischen Zah-lensysteme, in denen eine beliebige Zahl n in der Form

2},0{,0

≥∈⋅=∑=

BNBbmitBbn ii

K

ii U (2.1)

darstellbar ist. B heißt dabei Basis des Zahlensystems, wobei B = 10 als Dezi-malsystem, B = 8 als Oktalsystem, B = 2 als Dualsystem und B = 16 als Hexa-dezimal- oder (richtiger) Sedezimalsystem bezeichnet wird.

Die Koeffizienten bi können nur zwischen 0 und B-1 variieren, dies ist die jeweils gültige Menge der Ziffern pro Zahlensystem. Im Fall des Hexadezimalsystems können zwar 10 bis 15 als gültige Ziffern angesehen werden, zur Vermeidung von Problemen beim Lesen werden hier jedoch die Ziffern {0,...9, A, B, C, D, E, F} gewählt.

Als allgemein übliche Konventionen bei der Darstellung von Zahlen gelten:

1. das Fortlassen von führenden Nullen

2. keine Kennzeichnung der Basis

Falls das Fortlassen zu Interpretationsproblemen führt, wird die Basis üblicherwei-se eingeklammert und als tiefgestellter Index am Schluss beigefügt. Programmier-sprachen enthalten jeweils eindeutige Darstellungen der Zahlenbasis.

2.3.2 Umrechnung zwischen Zahlensystemen

n/B = q0+ r0

q0/B = q1

+ r1

q1/B = q2

+ r2

q2/B = q3

+ r3

...

qK-1/B = 0 + rK

Zahlendarstellung zur Basis B

Bild 2.5 Algorithmus zur Berechnung der Zahlendarstellung


Die Umrechnung von einem Zahlensystem in ein anderes polyadisches System kann grundsätzlich in zwei Schritten erfolgen. Gleichung (2.1) kann zunächst benutzt werden, um den dezimalen Wert der Zahlendarstellung zu berechnen. Um hieraus dann die Zahlendarstellung zur Basis B zu gewinnen, wird die ganzzahlige Division (im Dezimalsystem) benötigt:

2.3.3 Zahlen- und Informationsdarstellung im Rechne r Während die Darstellung von Daten im Rechner immer in binärer Form erfolgen wird, müssen verschiedene Datentypen unterschieden werden. Die Interpretation der Datendarstellung im Rechner ist hierdurch vom Kontext abhängig.

Zu den grundlegenden (intrinsischen) Datentypen zählen Zeichen, natürliche und ganze Zahlen, Gleitkommazahlen (den rationalen Zahlen entsprechend) und boole-sche Größen. Während die binäre Codierung im Speicher zwischen den einzelnen Datentypen nicht zu unterscheiden ist, werden diese im Hochsprachenprogramm sehr wohl unterschieden. Die Sprache C bietet beispielsweise char, int, unsigned int und float (neben anderen) als grundlegende Datentypen an.

2.3.3.1 Zeichen

Die Zeichen werden zumeist verwendet, um Texte darzustellen. Ein Text entspricht demzufolge aus einer Folge von Zeichen eines Alphabets.

0x00 NUL DLE SP 0 @ P ‘ p0x01 SOH DC1 ! 1 A Q a q0x02 STX DC2 „ 2 B R b r0x03 ETX DC3 # 3 C S c s0x04 EOT DC4 $ 4 D T d t0x05 ENQ NAK % 5 E U e u0x06 ACK SYN & 6 F V f v0x07 BEL ETB ´ 7 G W g w0x08 BS CAN ( 8 H X h x0x09 HT EM ) 9 I Y i y0x0A LF SUB * : J Z j z0x0B VT ESC + ; K [ k {0x0C FF FS , < L \ l |0x0D CR GS - = M ] m }0x0E SO RS . > N ↑ n ∼0x0F SI US / ? O ← o DEL

High 0x00 0x10 0x20 0x30 0x40 0x50 0x60 0x70Low

Tabelle 2.1 ASCII-Tabelle zur Interpretation als alphanumerische Werte


Die (nahezu) einfachste Definition eines zur Textdarstellung geeigneten Alphabets ist in Tabelle 2.1 dargestellt. Der ASCII-Code benötigt 7 Bits, um alle definierten Zeichen zu codieren, das 8. Bit (8 Bits werden üblicherweise zu einem Byte zu-sammengefasst) könnte als Zeichensatzerweiterung oder als Paritätsbit genutzt werden.

Um allen gebräuchlichen Alphabeten gerecht zu werden, wurde der 32-Bit Unicode [unicode] eingeführt. Zurzeit sind hier ca. 110000 Zeichen definiert.

NUL NULL valueSOH Start Of HeadingSTX Start of TextETX End of TextEOT End of TransmissionENQ EnquiryACK Acknowledge

BEL BellBS BackspaceHT Horizontal TabulationLF Line FeedVT Vertical TabulationFF Form FeedCR Carriage ReturnSO Shift-Out

SI Shift-In

DLE Data Link EscapeDC Device ControlNAK Negative AcknowledgeSYN Synchronous IdleETB End of Transmission BlockCAN CancelEM End of Medium

SUB Substitute CharacterESC EscapeFS File SeparatorGS Group SeparatorRS Record SeparatorUS Unit SeparatorSP Space

DEL Delete

Tabelle 2.2 ASCII Steuerzeichen

2.3.3.2 Festkommazahlen Die Verknüpfung eines Stellenwerts mit den Stellen im Binärwort ermöglicht die Darstellung von Festkommazahlen, bei denen die Stellung des Kommas fest definiert ist. Die allgemein gängige Interpretation ist jedoch diejenige, bei denen ausschließlich ganze Zahlen bzw. Integer-Zahlen dargestellt werden. Hierzu wird dem niederwertigsten Bit die Wertigkeit 1 (= 20), den nächstfolgenden 21, 22 usw. zugeordnet, so dass bei k Bits der darstellbare Bereich 0 .. 2k-1 beträgt, für 8 Bit Wortbreite als 0 .. 255. Diese Darstellung wird auch als UINT8, UINT16 bzw. UINT32 bezeichnet, um unsigned integer mit entsprechender Bitbreite zu kenn-zeichnen. Während diese Interpretation noch sehr eingängig erscheint, ist die Einführung vorzeichenbehafteter Zahlen auf mehrere Arten denkbar. Die einfachste Variante, das höchstwertige Bit als Vorzeichen zu interpretieren und den Betrag der Integer-zahl durch die verbliebenen Bits zu bestimmen, führt einerseits zu einer doppelten Darstellung der Zahl 0, andererseits zu einer komplexen Arithmetik im Prozessor,


die mit Hilfe von Fallunterscheidungen sowie verschiedenen Schaltnetzen für Addition und Subtraktion die Operationen durchführen kann (siehe hierzu [Sie99]).

0 1 0 1 1 1 0 0

27 26 25 24 23 22 21 20

Bitvektor:

Wertigkeit:

0 + 64 + 0 + 16 + 8 + 4 + 0 + 0 = 92Ergebnis:

Bild 2.6 Interpretation des Bitvektors ‘01011100’ als ganze Zahl 92

Für die vorzeichenbehaftete Darstellung und Arithmetik ist es sehr vorteilhaft, eine andere Variante auszuwählen, die mit der Komplementdarstellung von Bitvektoren arbeitet:

Definition 2.1

Sei X = (xk-1, ... x0)2 ∈ Bk eine k-stellige Binärzahl. Dann gilt mit Hilfe der binären Antivalenzoperation ^ (XOR):

1. K1(X) = (xk-1 ^ 1, ... x0 ^ 1)2 heißt Einer-Komplement (One’s Complement) von X.

2. K2(X) = (xk-1 ^ 1, ... x0 ^ 1)2 + 1 heißt Zweier-Komplement (Two’s Complement) von X.

Das Zweier-Komplement einer (positiven) Zahl in Binärdarstellung wird nunmehr als die Darstellung der zugehörigen negativen Zahl gewählt. Um Überschneidun-gen der beiden Bereiche zu vermeiden, werden die positiven Integerzahlen auf den Bereich mit höchstem Bit = 0 beschränkt, wodurch sich automatisch die Darstel-lung für negative Zahlen mit höchstem Bit = 1 ergibt.

0 1 0 1 1 1 0 0Bitvektor:

Einer-Komplement:

Zweier-Komplement:

1 0 1 0 0 0 1 1

1 0 1 0 0 1 0 0

(dezimal 92)

(dezimal -92)

01011100 (92)+ 10100100 (-92)

(1) 00000000 (0 mit Übertragsflag)

Bild 2.8 Vorzeichenbehaftete Addition

Bild 2.7 Einer- und Zweier-Komplement der Zahl 92


Mit der hier gewählten Darstellung für negative Zahlen wird eine eindeutige Darstellung der 0 sowie eine vereinheitlichte Implementierung der Arithmetik im Prozessor erreicht. Die binäre Addition der Darstellungen für 92 und -92 beispiels-weise liefert bis auf den Übertrag den (erwarteten) Wert 0, wie in Bild 2.8 dar-gestellt ist. Hieraus ergibt sich die Schlussfolgerung, dass für vorzeichenbehaftete Arithmetik nach wie vor eine Fallunterscheidung für die Interpretation der Flags durchzuführen ist.

2.3.3.3 Darstellung von Gleitkommazahlen Die Interpretation von Binärzahlen als ganze Zahlen lässt sich ohne großen Auf-wand auf rationale Zahlen mit feststehendem Komma erweitern, indem die Lage des Kommas definiert wird. Dies bedeutet, dass das niederwertigste Bit nicht eine Wertigkeit von 20 besitzt, sondern von 2w, wobei w < 0 eine negative ganze Zahl darstellt. Diese Interpretation wird als Festkommaformat bezeichnet.

Der dynamische Bereich der Zahlendarstellung, d.h. das Verhältnis zwischen (Be-trags-) kleinster (ungleich Null) und größter darstellbarer Zahl wird durch die Ein-führung eines Festkommas nicht verändert. Um hier eine Erhöhung zu erreichen, muss innerhalb der Darstellung der Exponent, auf den sich die eigentliche Zahl bezieht, eingetragen werden. Diese Interpretation wird Gleitkommaformat genannt und ist nach IEEE-754 für 32, 64 und 80 Bit genormt.

8-Bit 23-Bit

s e m

Bild 2.9 32-Bit-Gleitkommadarstellung nach IEEE-754

Das Sign-Bit s gibt hierbei das Vorzeichen der Zahl an (0 = positiv, 1 = negativ). Die Zahl selbst ist in der Mantisse m in einer sogenannten normalisierten Form gespeichert, die als höchstwertiges Bit eine ‘1’ führt. Da dies für alle Zahlen mit Ausnahme der Null möglich ist, wird dieses Bit fortgelassen und als hidden bit automatisch zur Mantisse hinzugezählt, woraus sich die effektive Anzahl von 24 Bit für die Darstellung ergibt.

Der Exponent e wird bezüglich der Basis 2 angegeben. Der zulässige Wertebereich für e ist 1 ≤ e ≤ 254, der tatsächliche Wert wird durch e - 127 berechnet. Diese Darstellung ist für alle Zahlen im zulässigen Bereich mit Ausnahme der Null möglich. Die Null wird durch eine nicht normalisierte Gleitkommazahl angegeben, bei der die Mantisse den Wert Null annimmt. Mit Ausnahme der Null nimmt also die gemäß IEEE-754 gebildete Zahl den Wert

z = (-1)s ⋅ 2e-127 ⋅ (1.0 + 0.m)

an. Dies entspricht dem darstellbaren (absoluten) Bereich von


( ) 12723

1

12623 2212211 ⋅

+≤≤⋅⋅+ ∑=

−−−

k

kz

In der Gleitkommadarstellung sind mit Hilfe der möglichen, aber normalerweise unzulässigen Werte für den Exponenten folgende Ausnahmen der normalen Inter-pretationsregel vorgesehen:

• m ≠ 0, e = 255: Die dargestellte Zahl ist keine gültige Gleitkommazahl (NaN, Not a Number) und wird z.B. zur Darstellung des Divisionsüberlaufes (Division durch 0) gewählt.

• m = 0, e = 255: Überlauf des darstellbaren Zahlenbereichs (Overflow), z = ±∞ (mit Vorzeichenbit s)

• m ≠ 0, e = 0: Darstellung einer nicht normalisierbaren Gleitkommazahl (Underflow).

• m = 0, e = 0: Darstellung der Null.

2.4 Ein kurzes Beispiel zu der (imperativen) Sprache C und der Programmierung von Mikrocontrollern

An dieser Stelle soll versucht werden, einen ersten Einblick in die Programmierung von Mikrocontrollern zu geben. Hierzu wird sehr häufig die Sprache C genutzt, die sich allein durch das imperative Programmierparadigma deutlich von objektorien-tierten Konzepten wie Java unterscheidet. Eine ausführlichere Beschreibung der Syntax und der Semantik ist z.B. in [Sie12, Kap. 7] gegeben. Dieses Skript kann vom Server der Informatik heruntergeladen werden.

2.4.1 Kurzeinführung in C Ausgehend von objektorientierter Programmierung kann man ein Programm in C so beschreiben, dass es lediglich eine einzige Klasse gibt und von dieser Klasse auch nur eine Instanz (das gesamte Programm nämlich). Innerhalb dieser Klasse gibt es dementsprechend Daten (und zwar Programm-globale und Funktions-lokale mit einigen Untertypen) und Funktionen (= Methoden) auf diesen Daten.

Ein C-Programm hat demnach den in Bild 2.10 gezeigten Aufbau.


#include ... /* Hier werden fertige Programmdateien eingebunden, die z.B. Deklarationen enthalten */ char a; /* Globale Variable */ int b; main() /* Main() muss immer vorhanden sein un d kann auch Parameter sowie Rückgabewert beinha lten */ { char c; /* Funktions-lokale Variablen */ .../* Jetzt folgt der Algorithmus, der z.B. den Auf ruf weiterer Funktionen beinhalten kann */ }

Bild 2.10 Aufbau eines Programms in C

2.4.2 Beispielprogramm Zur weiteren Darstellung sei ein Beispielprogramm und dessen Übersetzung im Detail diskutiert. Listing 2.1 zeigt den Sourcecode, geschrieben in C.

Das Programm selbst hat wenig Gehalt, hier werden drei char-Variablen deklariert, von denen zweien ein konstanter Initialwert, der bei jedem Durchgang um 1 erhöht wird, zugewiesen wird und der dritten dann die Summe der beiden ersten Variab-len. Zwei wichtige Details sollen an diesem Beispiel gezeigt werden: Ein (beispiel-hafter) Tool-Fluss und ein Assemblerbeispiel.

#include <stdio.h> int main(void) { char a = 3, b = 4, c; while(1) { a++, b++; c = a + b; printf( "%d ", c ); } }

Listing 2.1 Beispielprogramm zur Addition zweier Zahlen, geschrieben in C


Der erste Teil der Übersetzung führt vom C-Code zum Assemblercode mit Zusatz-informationen. In Listing 2.2 ist der Assemblercode (im Auszug) gezeigt, der sich aus dem obigen Beispielcode ergibt. Hier sind die Variablen a, b und c noch in symbolischer Form enthalten, ebenso die im Programm benutzte Funktion printf().

0000012a <main>: 12a: cf 93 push r28 12c: df 93 push r29 12e: 00 d0 rcall .+0 ; 0x130 <main+0x 6> 130: cd b7 in r28, 0x3d ; 61, SP low 132: de b7 in r29, 0x3e ; 62, SP high (r28/ r29 == Y) 134: 83 e0 ldi r24, 0x03 ; 3 (Wert für a) 136: 89 83 std Y+1, r24 ; Variable a, auf S tack 138: 84 e0 ldi r24, 0x04 ; 4 (Wert für b) 13a: 8a 83 std Y+2, r24 ; Variable b, auf S tack 13c: 99 81 ldd r25, Y+1 ; a 13e: 8a 81 ldd r24, Y+2 ; b 140: 89 0f add r24, r25 ; a + b 142: 8b 83 std Y+3, r24 ; Ergebnis in c, au f Stack 144: 8b 81 ldd r24, Y+3 ; c 146: 28 2f mov r18, r24 ; c in r18 148: 30 e0 ldi r19, 0x00 ; 0 in r19 14a: 00 d0 rcall .+0 ; 0x14c <main+0x 22> 14c: 0f 92 push r0 14e: 8d b7 in r24, 0x3d ; 61, SP low 150: 9e b7 in r25, 0x3e ; 62, SP high 152: 01 96 adiw r24, 0x01 ; SP-Kopie + 1 154: 40 e0 ldi r20, 0x00 ; 0 156: 52 e0 ldi r21, 0x02 ; 2 158: fc 01 movw r30, r24 ; r24/25 in r30/31 (Z) 15a: 51 83 std Z+1, r21 ; Parameter auf Sta ck 15c: 40 83 st Z, r20 ; 15e: fc 01 movw r30, r24 ; 160: 33 83 std Z+3, r19 ; Kopie von c auf S tack 162: 22 83 std Z+2, r18 ; 164: 0e 94 b9 00 call 0x172 ; <printf> aufrufen 168: 0f 90 pop r0 ; Stack bereinigen 16a: 0f 90 pop r0 16c: 0f 90 pop r0 16e: 0f 90 pop r0 170: e5 cf rjmp .-54 ; 0x13c <main+0x1 2>

Listing 2.2 Assemblerübersetzung des Programm aus Listing 2.1 für den Atmel AVR (ohne Optimierung, Auszug aus .lss-File)

Das Programm selbst folgt exakt dem C-Sourcecode, weil keine Optimierung zu-gelassen ist. So werden die Variablen, die in einem späteren Teil der Übersetzung auf Speicheradressen abgebildet werden, mit konstanten Werten belegt, dann die Variable a in den Akkumulator A geladen und mit dem Inhalt der Variable b addiert. Das Additionsergebnis im Akkumulator wird zuletzt in die c entsprechende Speicherstelle geschrieben, und dann beginnt die Ausgabe.


Die Ausgabe nutzt die im C-Standard definierte printf()-Funktion und wird mit zwei Parametern aufgerufen, die beide auf dem Stack landen (Formatierung, Wert von c)

Der Output dieser Phase in ein Object-File (*.o), in dem die feststehenden Teile des Listfiles in Binärcode übersetzt sind. Der anschließend arbeitende Linker bindet dann die genutzten Funktionen aus einer Bibliothek ein (link) und gibt den Symbolen konkrete Adressen (locate). Das Ergebnis ist dann z.B. ein Hex-File (Listing 2.3), das dann als Input für ein Programm zur Übertragung auf den Mikrocontroller dient.

:100100000BBF02C007900D92A430B107D9F712E0DF :10011000A4E0B2E001C01D92AA30B107E1F70E944D :1001200095000C9472030C940000CF93DF9300D0E1 :10013000CDB7DEB783E0898384E08A8399818A81A1 :10014000890F8B838B81282F30E000D00F928DB7E1 :100150009EB7019640E052E0FC0151834083FC01D0 :10016000338322830E94B9000F900F900F900F905D :10017000E5CFCF93DF93CDB7DEB7FE013696619121 :1001800071918091060290910702AF010E94CB000D :10019000DF91CF9108952F923F924F925F926F928D :1001A0007F928F929F92AF92BF92CF92DF92EF9207 :1001B000FF920F931F93CF93DF93CDB7DEB72D97A9 :1001C0000FB6F894DEBF0FBECDBF3C017D876C87B4 :1001D0005A01FC0117821682838181FFC8C12E015A :1001E0000894411C511CF3019381EC85FD8593FD1E :1001F000859193FF8191FD87EC87882309F4B3C132 :10020000853241F493FD859193FF8191FD87EC87C1 :10021000853229F490E0B3010E94E802E4CFFF2484 :10022000EE2410E01032B0F48B3269F08C3228F4F6 :10023000803251F0833271F40BC08D3239F080334B :1002400049F411602CC01260146029C0186027C0E6 :10025000106125C017FD2EC0282F20532A3098F496 :1002600016FF08C08F2D880FF82EFF0CFF0CF80E1C :10027000F20E15C08E2D880FE82EEE0CEE0CE80E57 :10028000E20E10620CC08E3221F416FD6CC11064B7 :1002900006C08C3611F4106802C0883659F4EC851B :1002A000FD8593FD859193FF8191FD87EC878823E0 :1002B00009F0B8CF982F9554933018F0905293309E

Listing 2.3 Hex-File (Auszug) für das Programm in Listing 2.1, Zielsystem Atmel AVR

Verwendet man anstatt char- nun int-Variablen, so werden diese als Variablen mit 16-bit-Breite interpretiert und der Assemblercode ändert sich. Jetzt werden alle Verknüpfungen mit 16 Bit durchgeführt, einschließlich der Wertzuweisung von Konstanten an die Variablen.


0000012a <main>: 12a: cf 93 push r28 12c: df 93 push r29 12e: 00 d0 rcall .+0 ; 0x130 <main+0x 6> 130: 00 d0 rcall .+0 ; 0x132 <main+0x 8> 132: cd b7 in r28, 0x3d ; 61, SP low 134: de b7 in r29, 0x3e ; 62, SP high 136: 83 e0 ldi r24, 0x03 ; Initialwert für a, jetzt 138: 90 e0 ldi r25, 0x00 ; auf Wortbreite 13a: 9a 83 std Y+2, r25 ; a speichern 13c: 89 83 std Y+1, r24 ; 13e: 84 e0 ldi r24, 0x04 ; 4 ist Initialwer t für b 140: 90 e0 ldi r25, 0x00 ; 142: 9c 83 std Y+4, r25 ; b speichern 144: 8b 83 std Y+3, r24 ; 146: 29 81 ldd r18, Y+1 ; a laden 148: 3a 81 ldd r19, Y+2 ; 14a: 8b 81 ldd r24, Y+3 ; b laden 14c: 9c 81 ldd r25, Y+4 ; 14e: 82 0f add r24, r18 ; c = a + b 150: 93 1f adc r25, r19 ; mit Carry! 152: 9e 83 std Y+6, r25 ; c speichern 154: 8d 83 std Y+5, r24 ; 0x05 156: 00 d0 rcall .+0 ; 0x158 <main+0x 2e> 158: 0f 92 push r0 ...

Listing 2.4 Assemblerübersetzung des Programm aus Listing 2.1, modifiziert für Integer-Variable, für den Atmel AVR (ohne Optimierung, Auszug aus .lss-File)

Eine Abschlussbemerkung bezüglich des Interfaces zur printf()-Funktion: Die Art, wie die Daten übergeben werden, wechselt von CPU zu CPU, manchmal sogar von Compiler zu Compiler. Das allgemein gültige Interface nutzt hierzu den Stack, al-lerdings zeigt diese Variante Laufzeitnachteile. Im Fall der Interfaces per Register und Speicher ist dies wesentlich schneller, ggf. ist aber die Routine nicht reentrantfähig.

Weiterhin nutzt printf() weitere Funktionen, was aber hier – aus Platzgründen – nicht dargestellt ist.

2.4.3 Die Einbindung der Peripherie Die peripheren Elemente – Network-IC für Ethernet, einfache General-Purpose Ports etc. – werden über Register eingebunden. Aus Sicht des Programms sehen sie wie Speicher aus, in denen Werte hinterlassen oder herausgelesen werden können. Allerdings ist im Normalfall eine Hardwarefunktion mit den Werten verbunden, z.B. eine Konfiguration eines Netzwerkbausteins oder ein Wert, der übertragen werden soll.

In der Praxis bedeutet dies, dass man gewöhnliche Variablen durch den Compiler verwalten lassen kann und nur die Größe (in Bits) und den Wert angeben muss. Wo


der Compiler bzw. der Linker/Locator diese Werte dann speichert ist für den Pro-grammentwurf unwesentlich.

Bei Werten, die in Zusammenhang mit peripheren Bauteilen stehen, ist das jedoch komplett anders. Der Ort, sprich die Adresse des Registers, kann nicht geändert werden und muss unbedingt eingehalten werden. Dies erfordert einen besonderen C-Code, weil nunmehr ein Zeiger mit konstantem Wert verwendet werden muss.

Derartige Werte sind meist vordefiniert, in der Atmel AVR-Architektur und der Entwicklungsumgebung AVR Studio in den Include-Dateien <io.h> und den damit verbundenen weiteren Dateien.

3 Speichertechnologien und –bausteine

In jedem Computersystem spielen Programm- und Datenspeicher eine entschei-dende Rolle, wobei diese nicht als externe Bausteine ausgeführt sein müssen, sondern durchaus integriert sein können (Mikrocontroller, siehe auch Kapitel 2 und 4).

Der in einem Ein-Chip-Computer zur Verfügung stehende Speicherplatz wird indes immer beschränkt sein, so dass eine komplette Ablösung der diskreten Speicher-bausteine vollkommen ausgeschlossen werden kann. In diesem Kapitel werden somit die Technologien und Organisationsformen dynamischer RAMs (DRAM), statischer RAMs (SRAM), EPROMs und besonderer Speicherbausteine behandelt.

Diese Speichertechnologien können - mit entsprechenden Vereinfachungen - wie in Bild 3.1 dargestellt aufgefasst werden:

Speicher-ICs

Nur-Lesespeicher(Read-Only Memory)

Masken-ROM

Lese-/Schreibspeicher(Read/Write Memory)

PROM EEPROMEPROM DRAMSRAM

(NVRAM)Pseudo-SRAM

MRAM

PCRAM

FeRAM

Bild 3.1 Speicherbausteinfamilie und –technologien

Als gute Zusammenfassung dieses Gebietes sei [SS07, Kapitel 11] empfohlen.

3.1 Dynamische RAMs (DRAM)

RAMs, die Abkürzung steht – etwas missverständlich – für "Random Access Read/Write Memory", sollen die Fähigkeit besitzen, einen Speicherinhalt durch einen Schreibvorgang zu definieren und diesen bei jedem Lesevorgang ent-sprechend auszugeben, bis die Speicherung durch einen erneuten Schreibvorgang verändert wurde. Im Gegensatz zu den Programmiervorgängen bei EPROMs und EEPROMs verlaufen Lese- und Schreibvorgängen in vergleichbaren – meist sogar identischen – Zeiten ab.


Diese Eigenschaft besagt noch nichts über das Einschaltverhalten bzw. eventuelle Datenverluste bei Spannungsausfall, gewöhnliche RAMs verlieren jedoch ihr "Ge-dächtnis" und zeigen beim Einschalten der Versorgungsspannung ein undefinierten Zustand.

Die einfachste Methode zur Speicherung eines Binary-Digit-(BIT-)Werts ist die der Ladungsspeicherung in einem Kondensator. Dieses Verfahren wird in größtem Maß dadurch angewandt, dass der Kondensator durch einen MOS-Transistor eben mit ladungsspeichernder Wirkung ersetzt wird. Bild 3.2 zeigt das Prinzip:

CS

Datenleitung

Wortleitung

Bild 3.2 Prinzip der DRAMs

Der Speicherkondensator CS wird durch die Kapazität der Drainzone mit der Sub-stratschicht gebildet. Die dabei erzielten Kapazitäten liegen im Bereich 10-15 Farad (fF, femtoFarad), wobei ein geladener Kondensator den Wert 1, ein ungeladener den Wert 0 repräsentieren soll.

Die Speicherzelle wird mittels der Wortleitung angesprochen, die eine Lese- wie Schreibkopplung zwischen der Datenleitung und dem Kondensator herstellt. Im Lesezyklus "treibt" der Kondensator die Datenleitung bei entsprechender Ladung, im Schreibzyklus wird die vorhandene Ladung überschrieben. Dieses Treiben bedeutet die Erzeugung eines Stromimpulses in einem Leseverstärker, der diesen in eine zuverlässige 0/1-Information umsetzen muss; der Stromimpuls (bei vorhandener Ladung) ist schwach ausgeprägt und wird mit zunehmender Integrationsdichte (> 1 GBit-Chips!) durch die parasitären Leitungskapazitäten bei geringer werdenden Kapazitäten der MOS-Strukturen immer schwächer, so dass der Aufwand für den Leseverstärker nicht unerheblich ist.

Konstruktionsbedingt verliert die Speicherzelle ihre Ladung und damit Information auf zwei Arten:

• Der Lesevorgang bewirkt zwar ein Treiben der Datenleitung, dies bedeutet jedoch zugleich den Abfluss der Ladung (“zerstörendes Lesen“).

3 Speichertechnologien und -bausteine 23

• Leckströme lassen eine Ladung auch ohne Lesevorgang abfließen.

Als Konsequenz daraus muss die Information in den Speicherzellen ständig erneu-ert werden, also durch ein Rückschreiben der Ladung unmittelbar nach dem Auslesen sowie ständig (im Bereich 100 µs - ms) durch einen zyklischen Vorgang, Refresh genannt. Aus diesem dauernden Lese-/Schreibvorgang resultiert auch der Name der ICs, dynamische RAMs.

Der externe Aufbau von DRAMs ist beispielhaft in Bild 3.3 dargestellt. Es sei dabei darauf verwiesen, dass der hier gewählte Typ eines 1-Mbit-Bausteins veral-tert ist, allerdings gilt die hieran dargestellte Struktur nach wie vor.

Din

/RASTFA0A1

/WE

A2

VCCA3

GND

/CASA9A8A7

Dout

A6

A4A5

Bild 3.3 Pinout eines 1M * 1-Bit DRAM 21010

Die Bedeutung der Pins im Einzelnen:

A0 bis A9 gestatten das Anlegen einer 10.Bit Adresse, die, da zur Adressierung von 1 Mbit 20 Adressleitungen notwendig sind, zweifach angelegt werden muss. Die dafür notwendigen Steuersignale lauten

RAS und CAS,

die Row Address Strobe (Zeilenadressteil, zumeist zuerst übertragen) und Column Address Strobe (Spaltenadressteil) bedeuten und teilweise die Übernahme in Zwischenregister innerhalb der Bausteins bewirken..

/WE signalisiert im aktiv low Zustand einen Schreibvorgang,

Din und Dout sind die Datenleitungen für Schreiben und Lesen einer Speicherzelle im IC.

TF bedeutet Test Function, hat also keine Relevanz im Betrieb und kann offengelassen werden.

VCC und GND


stellen die entsprechenden Versorgungspins für den IC dar.

Intern sind DRAMs in einer Matrix-artigen Form für das sogenannte Speicher-zellenfeld aufgebaut, was aus dem Blockschaltbild in Bild 3.4 hervorgeht:

DRAM-

Steue-rung

/RAS

/CAS

/WE

Adreß-

puffer

Speicher-

Adresse

Zeilen-

deko-

der

Speicherzellenfeld

Vorladeschaltkreis

LeseverstärkerI/O-Gatter

Spaltendekoder

Daten-

pufferDin Daten-

pufferDout

Bild 3.4 Blockschaltbild DRAM

Das Speicherzellenfeld besteht aus individuell adressierbaren ("Random Access") Speicherzellen meist á 1- oder 4- Bit. Wie bereits erwähnt, wird für einen Baustein mit 1M Speicherzellen (1 048 576) hierfür 20 Adressenleitungen benötigt, die beim DRAM in 2 * 10 mit sukzessiver Übertragung aufgeteilt sind.

Der zeitliche Verlauf ist in qualitativer Form in Bild 3.5 dargestellt. Zunächst wird die Zeile (Row) adressiert und mittels des /RAS-Signals in den internen Puffer übernommen. Mit dem anschließenden zweiten Adressteil und dem /CAS-Signal beginnt der Lese- oder Schreibvorgang, je nach Signal /WE.

Die in Bild 3.5 angegebenen Zeiten, tRAS für die gesamte Zugriffszeit auf eine Speicherzelle, tCAS für den Zugriffsabschnitt für die Spalte und tPR für die Vor-ladezeit des Row Address Strobes (Preload), haben eine große Bedeutung für den gesamten Zugriff eines Prozessors auf den Speicherinhalt. Die gesamte Zykluszeit beträgt dabei

tCyc = tRAS + tPR


während die Herstellerangaben für den Zugriff zumeist nur tRAS betreffen. Da als Faustregel tPR etwa 80% von tRAS beträgt, ist die gesamte Zykluszeit eines Lese- oder Schreibvorgangs etwa das 1,8fache der angegebenen Zugriffszeit. Für die angegebene Zugriffszeit von 70 ns bedeutet dies somit eine Zykluszeit von 126 ns; rechnet man hierzu eine Signallaufzeit, bedingt durch Gatterlaufzeiten etc. von ca 20 ns, so ergibt sich eine maximale Frequenz von ca 14 MHz, mit der ein 80x86-Prozessor (!) mit zwei Takten Zugriffszeit ohne Wartezyklen betrieben werden dürfte, bzw. von ca. 20 MHz bei einem Wartezyklus usw.

/RAS

/CAS

A0..9

Dout

tCAS

tRAS

tPR

Bild 3.5 Qualitative zeitliche Verläufe beim DRAM-Zugriff (lesend)

Diese drastische Reduzierung der Prozessorgeschwindigkeit bei Speicherzugriffen ist der entscheidende Grund für beschleunigende Maßnahmen, von denen im Fol-genden drei behandelt werden sollen:

• Page Mode,

• Static Column und

• Interleaving

Unter Page Mode wird eine (lesende oder schreibende) Zugriffsart verstanden, die nicht mehr bei jedem Zugriff die Zeilen- und Spaltenadresse in das DRAM lädt, um dann eine Speicherzelle auszulesen, sondern nur noch die Spaltenadresse, während die Zeilenadresse konstant und damit auch das /RAS-Signal aktiv bleiben. Dieses Prinzip funktioniert natürlich nur unter mehreren Voraussetzungen:

• Die DRAMs müssen diesen Mode unterstützen, d.h., sie müssen den verkürzten Zugriff selbständig erkennen und nicht jedes Mal einen vollständigen Zyklus erwarten.

• Die Steuerung der DRAMs - der Prozessor kann unter diesen Umständen und auch aus anderen Gründen, s.u., nicht direkt auf die DRAMs zugreifen - muss einen Zugriff mit identischer Seitennummer bzw. Zeilenadresse erkennen und den Zugriff entsprechend steuern.


• Das Programm bzw. Programmteile müssen innerhalb der Page ablaufen (Lokalitätsprinzip, auch Daten und Code gemischt!), was aber durch empirische Messungen mit großer Wahrscheinlichkeit bestätigt wurde. Die Seitengröße eines Page-Mode-DRAM mit einer Kapazität von 1 MBit beträgt 1024 Adressen, bei einem 16 MBit-DRAM bereits 16384 Adressen, worin hinrei-chend Platz für die Lokalität (mit eventueller Ausnahme von Datenzugriffen) liegt.

Die Reduzierung der Zugriffszeit für jeden sukzessiven Zugriff beträgt ca. 50%, für die Zykluszeit ca 70%. Diese bedeutet, dass alle nachfolgenden Zugriffe auf die erwähnten 70 ns DRAMs mit einem Prozessortakt von 33 MHz ohne Waitstates ablaufen können. Die Anzahl der Zugriffe mit konstanter Zeilenadresse ist durch interne Vorgänge im DRAM begrenzt, die Grenze liegt bei ca. 20 (Baustein-abhängig), wobei dann ein kompletter Zugriff wiederum notwendig wird.

Im Static-Column-Mode geht man noch einen Schritt weiter, indem auf die /CAS-Steuerung noch verzichtet und lediglich die Spaltenadresse jeweils für den näch-sten Zugriff geändert wird. Es obliegt damit der internen DRAM-Steuerung, die Änderungen zu erkennen, Zwischenspeicherung etc. mittels des /CAS-Signals und deren Laufzeiten werden eingespart, wobei der neuerliche Gewinn nicht mehr so drastisch zu bewerten ist.

Interleaving wird eine aus dem Großrechnerbereich übertragene Aufspaltung des Speicherbereichs in mehrere Speicherbänke genannt. Der Vorteil dieses Verfahrens ist darin zu sehen, dass der einzelne Zugriff auf eine Bank mit der normalen Geschwindigkeit ablaufen kann, während der nachfolgende, sofern er eine andere Bank betrifft, bereits beginnen kann. Im PC-Bereich wird häufig das 2-Wege-Interleaving genutzt, was bedeutet, dass sich zwei Speicherbänke im PC befinden und dass man hofft, zwei aufeinanderfolgende Speicherzugriffe (für Daten oder Code) betreffen nacheinander die beiden Speicherbänke.

Bild 3.6 fasst die drei beschriebenen Zugriffsverfahren im Vergleich zum normalen Zugriff zusammen.

In modernen Systemen werden mittlerweile Speichersubsysteme eingesetzt, deren Aufgabe in der Verdeckung der Speicherlatenzzeiten besteht. Der erste Zugriff dauert hierbei immer noch so lang wie bislang, die Folgezugriffe hingegen werden wesentlich beschleunigt bis hin zu Werten um 1 Datum/Takt.

Neben dem Lese- bzw. Schreibzugriff ist noch der bereits erwähnte Refresh, also das ständige Auffrischen der Ladungsinhalte und somit der Informationen, zu be-handeln. Dieser Refresh wird zusätzlich – auch mit der Gefahr der Zugriffsbehin-derung der CPU – zu den normalen Zugriffe durchgeführt. Die dabei gebräuch-lichste Art ist der RAS-only-Refresh, bei dem eine Zeilenadresse angelegt und dem DRAM mittels /RAS mitgeteilt wird, der angedeutete Zugriff aber durch Ausblei-ben der Spaltenadresse und vor allem des /CAS-Signals nicht beendet wird. Die interne Logik des DRAM leitet dann ein Auslesen und Wiedereinschreiben aller


Werte der Refreshzeile (also im Beispiel des 1 MBit DRAM von 1024 Zellinhal-ten) ein, eben den Refresh.

/RAS

/CAS

Adr.

Dat. gültig gültiggültig

Zeile Sp. Sp.Sp.Zeile Zeile

Normalmodus

/RAS

/CAS

Adr.

Dat. gültig gültiggültig

Zeile Sp. Sp.

Page-Mode

/RAS

/CAS

Adr.

Dat. gültig gültig

Zeile Spalte

Static-Column-Mode

/RAS0

/CAS0

Adr0

Dat0

2-Wege-Interleaving

Sp. Sp.

gültig

Spalte Spalte Spalte Spalte Spalte

gültig gültig gültig gültig

/RAS1

/CAS1

Adr1

Dat1

gültig gültiggültig


gültig gültiggültig


Bild 3.6 Zugriffsverfahren bei DRAM


/RAS

/CAS

A0..9

Refresh-Zykl.

Refresh Refresh

Refresh-Zykl.

Bild 3.7 RAS-only-Refresh bei DRAM

Diese Art des Refresh muss für einen kompletten Durchgang 1024mal ausgeführt werden, z.B. innerhalb des Zeitraums von 2 Millisekunden, was in einem 80x86-System bei 10 MHz Prozessortakt und Zugriffen ohne Wait States, also mit 2 Taktzyklen, zu einer Busbelastung von 1% führt.

Trotz der erwähnten, konstruktionsbedingten Nachteile gerade im Bereich der Zugriffszeiten werden dynamische RAMs heute als der Standardspeicher in den meisten Computern eingesetzt. Die Gründe dafür sind:

• Baulich kleine Form durch gemultiplexten Adressbus

• Intern geringer Aufwand durch 1 Transistor pro Speicherzelle, daher größte Kapazität pro Technologieschritt

Die Ausführung in Computern erfolgt zumeist in der Breite des Datenbus' der CPU, ergänzt durch Paritätsbits, die – gemäß der Hamming-Distanz von 2 – bei einfacher Parität die Erkennung von Fehlern, nicht aber deren Korrektur erlauben. SIMM und SIP-Module in PCs sind ein gutes Beispiel für diese Technologie, sie werden in der Organisationsform 1M * 9 bzw. 4M * 9 usw. angeboten, also in 9 Bit Breite.

Bei aktuellen Systemen ist man allerdings von der Fehlererkennung zur Fehlerkor-rektur mittels so genannter Error Correction Codes (ECC) übergegangen, da auf-grund der ständig verkleinerten Strukturen die Wahrscheinlichkeit eines Fehler durch Höhen- oder radioaktive Strahlung stark gestiegen ist. ECCs vermögen die Korrektur von Einzelbitfehlern und oft sogar Mehrbitfehlern sowie die Erkennung von Mehrbitfehlern bis hin zu Bursts.

3.2 Statische RAMs (SRAM)

Während die DRAMs quasi zu den Massenprodukten unter den Schreib-/Lese-speichern gehören, sind SRAMs – technologiebedingt – teurer, in vielen Einsatz-fällen aber unabdingbar. Der interne Aufbau von SRAMs besteht aus Daten-Flipflops, einer speziellen Version von RS-Flipflops mit einer entsprechenden Zugriffslogik.


>1

>1 Q

/Q&

&

C

D

Bild 3.8 D-Flipflop mit Zustandssteuerung

+Ub

T0

T1

T2

T3

T5

/A

T4

A

WL

DL2DL1

Q /Q

Bild 3.9 SRAM-Speicherzelle, CMOS-Technologie

Bild 3.8 zeigt den Aufbau eines Daten-FF mittels AND-, NOT- und NOR-Gattern; die tatsächliche Implementierung besteht natürlich aus Transistoren direkt (Bild 3.9), weniger aus der Zusammenschaltung von Gattern:

Das zentrale Flipflop, auch bistabile Kippstufe genannt, befindet sich an der rech-ten Seite und wird von den beiden NOR-Gattern gebildet. Bezeichnet man die Ein-gänge mit S und R, so sind folgende Wertepaare zulässig und führen zu folgenden Ausgängen:


S R Q /Q 0 0 (Zustand bleibt erhalten) 1 0 1 0 0 1 0 1 1 1 (Instabil, daher nicht erlaubt)

Tabelle 3.1: Zustände und Übergänge beim RS-Basisflipflop

Im zustandsgesteuerten Daten-FF wird das nicht-erlaubte Eingangswertepaar '11' durch die Beschaltung S = /R unterdrückt. Dies würde für sich genommen aber niemals einen zeitinvarianten Zustand am Ausgang ergeben, Q folgte ohne weitere Zusätze ständig dem Dateneingang D.

Die zeitliche Invarianz ergibt sich durch den Freigabeeingang C, der mittels seines Zustands das Verhalten des Basisflipflops steuert. Solange C den Wert 0 annimmt, kann das RS-FF seine Ausgänge nicht verändern; mit C = 1 wird der Ausgang Q transparent auf den Wert von D geschaltet, /Q (zumeist nicht herausgeführt) ent-sprechend auf /D. Diese Speicherzelle benötigt – solange kein Versorgungsspan-nungsabfall eintritt – keinerlei Refresh, worin einer der wesentlichen Vorteile der SRAMs liegt.

Die Blockstruktur von SRAMs, die zumeist als 4- (Nibble), 8- (Byte), 16- (Word) oder 32-Bit- (Doubleword) SRAMs organisiert sind, ist in Bild 3.10 dargestellt:

Die eingezeichneten Adressen A0 bis A14 werden innerhalb des SRAMs nicht mehr zwischengespeichert, sondern müssen gleichzeitig - und über die Zugriffs-dauer stabil - am IC anliegen. Je nach Zugriffsrichtung werden dann Ausgangs- oder Eingangspuffer aktiv geschaltet, so dass die entsprechende Operation ablaufen kann.

Die nicht-gemultiplexten Adressen bewirken, dass diese auch am Pinout sichtbar sein müssen. Bild 3.11 gibt für die 32 Kbyte (32k * 8 Bit) Bausteine einen Über-blick zum Pinout, wobei die scheinbar unsortierte Anordnung insbesondere des Adressenteils historische Gründe hat. Ein 32 Kbyte SRAM wird z.B. im 28poligen DIP-Gehäuse geliefert und hat dann wesentlich größere Ausmaße im Vergleich zu DRAMs.


...

A5 - A9,

A11 - A14

X-

Decoder

512 * 512-

Matrix

(1 aus

512)

...

...

Y-Decoder

(8 aus 512)

8 In-/Outputs

A0-A4, A10

I/O-

Puffer

I/O 0

I/O 7

...

/WE

/OE

/CS

Bild 3.10 Blockschaltbild SRAM 62256

A14

A7A6A5A4

A12

A3

A1A2

VCC

A13A8A9

/WE

A11

A10/OE

A0I/O0

I/O2I/O1

GND

/CS

I/O6I/O7

1234567891011121314

2827262524232221201918171615

I/O4I/O5

I/O3

Bild 3.11: Pinout des SRAM 62256


Die Bedeutungen in Bild 3.11 der Abkürzungen lauten:

A0 bis A14 stellen den Adressbus dar, wobei zur Adressierung von 32 kByte 15 Adressleitun-gen auch tatsächlich notwendig sind.

I/O0 bis I/O7 häufig auch mit D0 bis D7 bezeichnet, werden mit dem Datenbus verbunden und zeigen ein Input- oder Output-Verhalten, je nach Belegung von /WE.

/CS selektiert den Baustein, unabhängig von der Zugriffsrichtung (Chip Select)

/OE signalisiert in Zusammenhang mit /CS einen Lesevorgang (Output Enable)

/WE entspricht in Zusammenhang mit /CS einem Schreibvorgang (Write Enable)

SRAMs benötigen in der tatsächlichen Realisierung pro Speicherzelle mindestens 5, meist 6 Transistoren, DRAMs nur einen. Hinzu kommt, dass die bei SRAM verwendeten CMOS-Transistorpaare je einen PMOS-Transistor besitzen, die – um die gleiche Leitfähigkeit zu haben – eine dreifache Größe gegenüber den NMOS-Varianten besitzen. Dies erklärt, warum SRAMs in der jeweiligen Technologiestu-fe immer um einen Faktor von ca. 4 weniger Speicherkapazität bieten und somit entsprechend teurer sind, zumindest pro Speicherzelle.

Andererseits bieten SRAMs deutliche Vorteile:

• mit Ausnahme der Dekodierung werden keine externen Zusatzschaltkreise wie Refreshgeneratoren benötigt

• Batteriepufferung zur Langzeitspeicherung von Daten ist möglich

• Deutlich schnellere Zugriffs- und Zykluszeiten bis zu 10 ns sind möglich, da kein Adressmultiplexing auftritt und die SRAMs aufgrund ihres internen Aufbaus wesentlich stärkere Speichersignale mit schnelleren Ansprechzeiten der Puffer bieten

Die Vorteile zeigen bereits die Einsatzgebiete von SRAMs:

• Kleine Einplatinencomputer mit möglichst geringem Hardwareaufwand

• Zusatzspeicher zur batteriegepufferten Speicherung von Konfigurationsdaten

• Schnelle Speicher, z.B. für Cache-Speicher zur Beschleunigung von Programm-abläufen.

3.3 Nur-Lesespeicher (PROM, EPROM, EEPROM)

Ein ROM, ein Read-Only-Memory, hat seinen Namen durch die Eigenschaft in Computersystemen, nur auslesbar, aber nicht beschreibbar zu sein, bekommen.


Diese Eigenschaft impliziert natürlich sofort, dass der Speicherinhalt zu jedem Zeitpunkt, also auch bei Verlust der Versorgungsspannung, eindeutig definiert sein muss, ansonsten wären diese Bausteine unbrauchbar.

Reine ROMs, die also bei der Herstellung bereits den späteren Inhalt mitgeteilt bekommen, sind aus einem leicht ersichtlichen Grund sehr selten geworden:

Der Herstellungsprozess, es handelt sich schließlich um einen Anwender-spezi-fischen IC, ist für Einzelexemplare zu teuer, eine gewisse Serie muss sofort aufgelegt werden. Das Programm, das in solche ICs produziert wird, muss aber außerordentlich gut ausgetestet sein und es muss zudem absehbar sein, dass keine Zusätze in absehbarer Zukunft hinzukommen sollen (Fehlerfreiheit und Zukunfts-sicherheit). Beide Probleme sind aber in Zusammenhang mit Computern schwer lösbare Probleme.

Nicht-löschbare ROMs werden daher heutzutage als Masken-ROMs (mit einer Metallmaske, die erst im letzten Herstellungsgang einer ansonsten für alle ROMs einheitlichen Fertigung) bei Massenproduktion oder als PROMs, die also nach der Herstellung einmal programmierbar sind, gefertigt. Diese PROMs, meist in bipolarer Technologie aufgebaut, haben intern Schmelzsicherungen eingebaut, die einmalig per Überspannung durchgebrannt werden können:

O

I2

I0I1

Bild 3.12 Aufbau ODER-Zelle mit pnp-Multi-Emitter-Transistor

Die in Bild 3.12 dargestellte ODER-Verknüpfung von maximal 3 Eingängen(Ix) bewirkt einen High Pegel am Ausgang O, falls einer der Eingänge auf high liegt und dessen Sicherung intakt ist, ansonsten low. Im ersten Fall wird die Basis-Emitter-Diode leitend und der Transistor schaltet durch, so dass das Potential vor dem Inverter auf high liegt. Dies ist exakt das Prinzip der PROMs, wobei die Sicherungen während des Programmiervorgangs durchgebrannt werden.

Sehr häufig im Einsatz sind seit einigen Jahren EPROMs, Flash-EPROMs und EEPROMs (Erasable Programmable Read Only Memory bzw. Electrically Erasable Programmable Read Only Memory). Diese Speicher-ICs beruhen auf einer gemeinsamen Technologie, dem sog. Floating Gate; innerhalb eines MOS-


Transistors stellt dies ein zusätzliches Gate dar, das im Prinzip isoliert angebracht ist, auf dem aber während des Programmiervorgangs Ladungen aufgebracht werden können (insbesondere durch den sogenannten Tunneleffekt). Bild 3.13 zeigt eine solche EPROM-Zelle im unprogrammierten Zustand, Bild 3.14 während des Programmiervorgangs:

Drain n+Source n+

Substrate

Select Gate

Floating Gate

Selektierungssignal

Produktzeile

Eingangs-

signal

Bild 3.13 EPROM-Zelle (FAMOS-Transistor) im unprogrammierten Zustand

Diese Transistorzelle wird auch als FAMOS (Floating-Gate Avalanche MOS-Transistor) bezeichnet.

Pinch Off

Depletion

Region

Drain n+Source n+

Substrate

Select Gate

Floating Gate - - -

VD

VPP

Bild 3.14 EPROM-Zelle während des Programmiervorgangs

Während des Programmiervorgangs wird durch eine (bei EPROMs extern ange-legte, bei EEPROMs intern erzeugte) Überspannung VPP (z.B. 12,5 V) ein elek-trisches Feld erzeugt, das in der Lage ist, Elektronen mit einer gewissen Wahr-


scheinlichkeit durch die das Floating Gate isolierende Umgebung diffundieren zu lassen und so dort Ladung anzusammeln (Avalanche-Effekt).

Nach der Programmierung bewirkt ein geladenes (also programmiertes) Floating Gate, dass keine Kopplung zwischen Source und Drain via Select Gate stattfindet; dies ist genau die Wirkung einer gelöschten Fuse, die ein Eingangssignal ebenfalls nicht durchlässt und somit am Ausgang – für sich genommen – nur ein '0'-Signal mitliefert.

Das Löschen der Programmierung geschieht auf dreierlei Weisen, hierin unter-scheiden sich die drei Bausteintypen:

• Bei EPROMs wird mittels UV-Licht bei 253,7 nm (Hg-Linie) gelöscht, sie besitzen daher ein Quarzfenster. Das UV-Licht beschleunigt die Elektronen so stark, dass sie das Floating Gate wieder verlassen können (lichtelektrischer Effekt)

• Bei EEPROMs, die intern sehr viel komplizierter und auch größer aufgebaut sind, werden die Ladungen durch 'umgepolte' elektrische Felder aus dem Floating Gate abgezogen, und zwar auf Zellenbasis. Die hierzu variierten Spei-cherzellen werden mit FLOTOX (Floating Gate Tunnel Oxide-Transistor) bezeichnet, zusätzlich kommt pro Zelle ein NMOS-Schalttransistor hinzu.

• Flash-EPROMs sind ähnlich zu EPROMs aufgebaut, gleichwohl werden sie elektrisch gelöscht, allerdings nur blockweise oder sogar im gesamten IC, da die individuellen Schalttransistoren durch die blockweise Beschaltung abgelöst werden.

VPP

A7A6A5A4

A12

A3

A1A2

VCC

A13A8A9

A14

A11

A10/OE

A0O0

O2O1

GND

/CS

O6O7

1234567891011121314

2827262524232221201918171615

O4O5

O3

Bild 3.15 Pinout des EPROM 27256


Trotz der Wiederbeschreibbarkeit gelten - im Gegensatz zu SRAMs - die EPROMs und EEPROMs nicht als Schreib-/Lesespeicher, da die Programmierung einen erheblich anderen Betriebsmodus mit wesentlich längeren Zugriffszeiten im Vergleich zum normalen Lesen darstellt.

Die drei erwähnten Festwertspeicher haben gemeinsam, dass sie sowohl program-mierbar als auch löschbar sind. Daneben gibt es sie in identischen Bauformen und Anschlussbelegungen; ein typisches EPROM, 27256, organisiert als 32k * 8 Bit, ist in Bild 3.15 dargestellt:

Man beachte bei der Darstellung der Bausteinform die geringen, aber merklichen Unterschiede zum SRAM 62256!

3.4 Nichtflüchtige RAMs (Non-Volatile RAMs)

Seit langem wird dahingehend geforscht, einen einheitlichen Speicher für die wesentlichen Anwendungen im Lese-/Schreibbetrieb (Anwendungsfall: Daten) wie im Nur-Lesebetrieb (Anwendungsfall: Programm) zu haben. Grundvoraussetzung ist hierfür der langfristige Datenerhalt bei Verlust der Betriebsspannung bzw. Fortfall jeglicher Energieversorgung. Hierfür existieren mehrere Ansätze, alle unter dem Stichwort Non-Volatile RAM zusammen gefasst.

Die Bezeichnung Non-Volatile RAM zeigt bereits, wohin diese Bausteinklasse zielt: Gesucht ist eine RAM-Technologie, die nicht flüchtig ist, aber dennoch mit gleicher Geschwindigkeit beschrieben wie gelesen werden kann. Die einfachste Lösung, ein Batterie-gepuffertes RAM zu nehmen, ist für Einzelfälle sicher zuläs-sig, bei massenhaftem Einsatz jedoch nicht.

3.4.1 NVRAMs Ein möglicher, bereits frühzeitig genutzter Ansatz ist die Kombination von Fest-wertspeicher und Schreib-/Lese-Speicher in einem Baustein. Bei diesen ICs ist jede Speicherzelle doppelt ausgelegt, und zwar einerseits als statische RAM-Zelle, andererseits als EEPROM-Zelle. Während im normalen Betrieb der Baustein wie ein RAM benutzt werden kann, erlaubt es eine Steuerschaltung, den gesamten RAM-Inhalt in das EEPROM zu übertragen und von dort zu laden.

Die NVRAM-Speicherzelle ist damit die komplexeste Speicherzelle aller hier beschriebenen Speicherbausteine (→ Bild 3.16). Zusätzlich zu den 6 Transistoren der statischen RAM-Speicherzelle werden ein Transistor zur Kopplung (T6), einer zum Löschen (T8) und ein spezieller EEPROM-Transistor (FLOTOX, T7) benötigt, wodurch im Herstellungsprozess sowohl die Anzahl als auch die Unterschiedlichkeit der Transistoren berücksichtigt werden müssen:

Die Funktionsweise dieser sehr interessanten Speicherzelle sei im Folgenden genauer erklärt:


/Q Q

DL1 DL0

/AA

WL

UB

T5 T

1T

3T

2T

4T

0

T6

T7

UTransmit

UProgram

T8

UClear

Bild 3.16 NVRAM-Speicherzelle

Die SRAM-Speicherzelle entspricht der normalen Zelle, also dem Aufbau als bistabiler Kippstufe. Die Transistoren T4 und T5 trennen das eigentliche Flipflop von den Bitleitungen DL0 und DL1.

T7 ist als EEPROM-Transistor ausgeführt. Zum Löschen dieses FLOTOX-Tran-sistors werden die Gate-Eingänge auf die Potentiale UTransmit = 0V, UProgram = 0V und UClear = 21V gezogen. Dadurch sperrt T6, T8 wird leitend, und eventuelle Ladungen können von dem Floating Gate abfließen. T7 ist anschließend selbstleitender Transistor und ergibt beim Lesen eine '1'.

Beim Speichern der Informationen der RAM-Zelle in die EEPROM-Zelle werden die Betriebsspannung der RAM-Zelle (!) sowie die Gate-Potentiale der Tran-sistoren T6 und T7 auf 21 V gesetzt. Dadurch kann die Information am Punkt A der RAM-Zelle als Programmierung in das Floating Gate des Transistors T7 übertragen werden, die Spannungen reichen dazu aus, dass bei einem '0' Potential am Punkt A sich ein leitender Kanal im FLOTOX-Transistor ausbildet (siehe auch 3.2, EPROM-Programmierung) und Ladungen zum Floating Gate fließen, so dass T7 anschließend selbstsperrend ist, während eine '1' in der RAM-Zelle zu keinen ausreichenden Spannungsdifferenzen und somit zu keinem Leitungskanal führt. Das Gate von T8 liegt während dieses Vorgangs auf low, so dass T8 sperrt.

Der Auslesevorgang schließlich überträgt bei normalen Potentialen eine '1' in eine zuvor gelöschte RAM-Zelle, indem das Potential UClear = 5V durch den selbstleitenden Transistor T7 auf A geschaltet wird, während ein selbstsperrender Transistor T7 die '0' belässt.

NVRAMs können also als RAM-Baustein mit Speichermatrix und Hintergrund-Speichermatrix angesehen werden:


...

A0 - Ax

DecoderSRAM-Matrix

...

...

8 In-/OutputsI/O-

Puffer

I/O 0

I/O 7

...

/WE

/OE

/CS

...

Decoder ...

EEPROM-Matrix

Matrix-

Steuerung

STORE

RECALL

Programmier-

Spannung

/NE

Bild 3.17 Blockschaltbild NVRAM

Der Steuerpin /NE (NV Enable) steuert dabei, ob ein Schreib- oder Lesevorgang sich auf eine einzelne Zelle im SRAM (/NE = 1) oder auf die gesamte EEPROM-Matrix (/NE = 0) bezieht. Dieser Pin kann durch verschiedene externe Beschal-tungen, z.B. mit Spannungswächtern oder mit speziellen Portpins dazu benutzt werden, das NVRAM zu steuern und an die speziellen Gegebenheiten im Mikro-computer anzupassen.

NVRAMs sind – wenn überhaupt noch lieferbar – als 2k * 8 Bit-Bausteine erhält-lich.

3.4.2 Ferroelektrische RAMs (FRAM, FeRAM) Eine bereits seit 1987 bekannte Bauform von Speicher ist in der Zwischenzeit auch lieferbar geworden: Ferroelektrische RAMs [Hab96]. Bei dieser Bausteinfamilie beruht der Speichereffekt nicht auf Ladungsträger, sondern auf dem ferroelektri-schen Effekt, der ähnlich wie ein ferromagnetischer Effekt („Dauermagnet“) wirkt.


Dieser Effekt, der nur in wenigen Materialien nachweisbar ist, liegt in der Eigen-schaft von Kristallstrukturen begründet, die eine durch ein äußeres elektrisches Feld hervorgerufene Polarisierung (Ausrichtung) auch nach dem Abschalten beibe-hält. Diese Ausrichtung wird als idealer Informationsspeicher genutzt, da nunmehr die Speicherung auch bei vollständigem Verlust der Betriebsspannung erhalten bleibt und trotzdem jederzeit änderbar ist. Dies ist durch eine entsprechende Kristallstruktur möglich.

Bild 3.18 zeigt den Aufbau der 2T/2C-FRAM-Zellstruktur. Diese Doppelstruktur ist zwar prinzipiell nicht notwendig, zur Zeit jedoch in Gebrauch. Im Unterschied zur DRAM-Struktur liegt der Kondensator hier nicht auf Masse, sondern auf eine Plateline, um die Umprogrammierung zu ermöglichen.

BL: BitleitungWL: WordleitungPL: Plateleitung

WL

BLBL

PL

Bild 3.18: Aufbau FRAM/FeRAM-Zelle

3.4.3 Magnetoresistive RAMs (MRAM) Magnetische Effekte werden seit langem zur Speicherung von Daten in Rechner-systemen genutzt, so z.B. auf Magnetbändern oder in Festplatten. Diese Speicher dienen jedoch als Massenspeicher mit sequenziellem Zugriff, d.h., die Zugriffs-reihenfolge auf Daten ist nicht beliebig.

Der magnetoresistive Effekt hingegen ist erst in den 1990er Jahren entdeckt und seitdem weiterentwickelt worden. Der tunnelmagnetoresistive Effekt (TMR) beruht darauf, dass der Ladungstransport abhängig von dem magnetischen Feld ist.


Masse

Io

Steuerleitung

Leseleitung

Bild 3.19 Zweischichtenaufbau einer TMR-Zelle

Bild 3.19 zeigt den Aufbau einer solchen Zelle. Eine magnetisch harte Schicht (in Bild 3.19 oben) ist grundsätzlich in einer Richtung magnetisiert, die andere kann durch einen Stromimpuls auf der Steuerleitung umgeschaltet werden. Der Strom durch die Leseleitung ist nun abhängig davon, ob die beiden Schichten parallel (niedrigerer Widerstand) oder antiparallel (höherer Widerstand) magnetisiert sind. Derzeit sind in Bausteinen ca. 50% Widerstandsänderung realisierbar, im Labor ca. 600%.

Die Vorteile der Bausteine liegen in der Vereinigung der positiven Eigenschaften von SRAM, DRAM und EEPROM: Nicht-Flüchtigkeit, Schnelligkeit und die Ein-Transistor-Zelle. Der wesentliche Nachteil besteht in der Verwendung exotischer Materialien, die während der Herstellung in Reinsträumen Probleme ergeben.

Seit 2006 sind kommerzielle Bausteine verfügbar [Lee06], derzeit mit einer Kapa-zität von 4 Mbit.

3.5 Zusammenfassung der verschiedenen Speichertechnologien

Die Suche nach dem idealen Speicher ist immer noch aktuell. Die Eigenschaften dieses Speichers wären etwa wie folgt beschrieben:

● Lese- und Schreibgeschwindigkeit identisch, < 1 ns

● Energie zum Schreiben und Lesen < 1 pW

● Datenerhalt ohne Energieversorgung > 20 Jahre

● Anzahl Lese- und Schreibzyklen ∞

● Einfache Herstellung im CMOS-Prozess

● Höchstintegrierbar (Herstellungsprozess)

● > 1 bit/Transistor

● Unempfindlichkeit gegen Höhenstrahlung, elektromagnetische Wellen


● …

Dagegen fällt die Realität geringfügig ab:

MRAM FRAM DRAM SRAM Flash EEPROM

Größe in F² < 4 ca. 4-8 8 100-150 4-10 ca. 20 (F: Feature Size) (NOR/NAND)

Nicht-Flüchtigkeit Ja Ja - (Pufferbat.) Ja Ja

Schreibgeschwindigkeit < 5 ns (Zelle) 150-200 ns 50-100 ns 5-100 ns 10-1000 µs 5-10 ms (pro Byte)

Anzahl Zyklen ∞ 1010-1013 ∞ ∞ <106 <106 (W/R) (W) (W)

Wesentl. Eigenschaft hohe Festig- geringe hohe Dichte Geschwin- Große Kleine nicht- keit gegen Leistungs- digkeit Speicher flüchtige Strahlung aufnahme Speicher

Tabelle 3.2 Vergleich Speichertechnologien

4 Der Mikroprozessor Atmel ATmegaXXX

Während der tägliche Einsatz von PCs – quasi unbewusst – jeden Nutzer 32- und 64-Bit-Technologie anwenden lässt, kann der Hardwaredesigner bzw. -ingenieur die Grundprinzipien des Mikroprozessoreinsatzes bereits bei 4- oder 8-Bit-CPUs studieren, da – sieht man einmal von echten 32-Bit-Systemen mit Hardware-Unterstützung von Multitasking und Multiuserfähigkeit sowie einem intensiven Memory Management ab – ausschließlich eine Verbreiterung von Bussystemen von 4 auf 32 oder 64 Bit prinzipiell keine neuen Erkenntnisse bringen.

Dies ist der Grund, zunächst eine 8-Bit-CPU einzuführen, um in diesem Kapitel die Grundzüge der Mikroprozessortechnik (als Basis von Embedded Systems) zu erkennen. Die Wahl fiel dabei auf die ATmega8-CPU und deren Derivate, da

• sie sehr weit verbreitet ist, also viele neue Einsatzfälle findet und

• der interne Aufbau sowie der Makrobefehlssatz recht klar gegliedert sind.

In diesem Kapitel werden also zunächst die äußeren Anschlusssysteme, die Bus-systeme, von Mikroprozessoren näher betrachtet; anschließend wird das Pinout einer Version der ATmega8-Familie (ATmega2560) eingeführt, und schließlich werden einige Makrobefehle in ihrem Busverhalten näher erläutert.

Der komplette Makrobefehlssatz einschließlich des Programmiermodells ist Thema des Kapitels 5.

4.1 Allgemeines zu Bussystemen bei Mikroprozessoren

Der Aufbau des von-Neumann-Rechners beinhaltet neben der Central Processing Unit (CPU), dem Speicher und dem Input/Output noch die Verbindungswege zwischen all diesen Einheiten innerhalb des Rechners (→ Kapitel 2.1, Bild 2.1). Diese Verbindungen sollen den Transport von Informationen symbolisieren, ohne dass dadurch gleich die Realisierung, also der physikalische Aufbau festgelegt sein muss.

Grundsätzlich unterscheidet man jedoch zwischen drei Arten von Informationen, für die üblicherweise auch getrennte Verbindungswege aufgebaut werden:

• Daten; hierzu zählen die Befehle, die Operanden und die Resultate

• Adressen zur Anwahl von Speicherzellen und Registern und

• Signale zur Steuerung des Informationsaustausches zwischen den einzelnen Komponenten.

Die daraus resultierenden drei Bussysteme, der Datenbus, der Adressbus und der Steuerbus, sind damit Ausdruck der internen Vorgänge im Mikroprozessor.

4 Der Mikroprozessor Atmel ATmegaXXX 43

Adreßpuffer

+1

Programmzähler

AdreßbustreiberDatenbuspuffer

InternerDatenbus

InternerAdreßbus

ExternerDatenbus

ExternerAdreßbus

InternerSteuerbus

Bus-Steuerung

Bild 4.1 Die Systembus-Schnittstelle

Der Adressbus ist ein unidirektionaler, meist mit Tristate-Treibern versehener Bus, dessen Quelle innerhalb des Mikroprozessors aus dem Programmzähler (Program Counter, Instruction Pointer, bei Zugriffen auf Code) oder aus einem Adresspuffer (bei Zugriffen auf Daten als Interpretation des Befehlscodes) stammt. Dieser Pro-grammzähler wird bei sequentiellen Programmen ständig um '1' (genauer: Um eine Datenbusbreite) erhöht, bei Sprüngen mit einem neuen Wert (dem 'Sprungziel') geladen.

Das Adresspufferregister dient zunächst als Ziel der internen Adressberechnungen der CPU, dies insbesondere bei einigen, z.B. indirekten Adressierungsarten. Ist die für die gewünschten Daten korrekt berechnete Adresse fertig, dann kann via externen Adressbus, nunmehr nicht mehr vom Programmzähler, sondern vom Adressregister getrieben, zugegriffen werden.

Der Adressbus wird mit Tristate-Puffer, die also in einen hochohmigen Zustand ohne bestimmtes Potential gehen können ausgestattet, falls er abschaltbar sein soll, so dass andere Busmaster wie DMA-Controller ohne Störung zugreifen können.

Der in Bild 4.1 ausgeführte Datenbuspuffer kann sowohl als reine Treiberfunktion als auch mit Zwischenpufferungen ausgeführt sein. Es dient der Kopplung zwi-


schen in- und externem Datenbus, also den Verbindungen, über die die Werte aus den verschiedenen Speichern tatsächlich transportiert werden, was eine Vielzahl von Aufgaben mit sich bringt:

• Schreiben von Daten nach außen

• Lesen von Daten aus externen Speichern

• ggf. Zwischenpufferfunktionen

• Abschalten der Bustreiber nach außen, um anderen Busteilnehmern den Zugriff zu gewähren

Ein solcher bidirektionaler Datenbustreiber – ohne Registerfunktion – ist in Bild 4.2 dargestellt.

& &

1

G

DIR

E A

Bild 4.2 Bidirektionaler Datenbustreiber

Die internen Steuersignale G und DIR steuern dabei die generellen Freigabe und die Datenrichtung; ähnliche Anordnungen finden man in bidirektionalen Puffer-bausteinen (74xx245 o.ä.), während die Herausführung der internen Steuersignale von der generellen Struktur des Systembus' (synchron, semi-synchron, asynchron) abhängt, wie im nächsten Unterkapitel behandelt werden wird.

4.2 Synchrone, semi-synchrone und asynchrone Systembusse

4.2.1 Der synchrone Systembus Bild 4.3 zeigt das Timing für einen Lese und einen Schreibzugriff mittels eines typischen, synchronen Systembus'. Der angenommene Taktzyklus kann z.B. 100 ns dauern, was einem Takt von 10 MHz entspräche.


Die Zeitspanne für eine Systembusoperation, d.h., Lesen oder Schreiben eines Datums, wird häufig als Buszyklus T bezeichnet, wobei dieser bei dem betrachte-ten Prozessor aus zwei Taktzyklen besteht.

Adresse

Daten

Takt

Ax

Dx

Ta Tb

T

/RD

/WR

Lesen

DatenDx

/RD

/WR

Schreiben

Tristateirrelevant

Legende:

Bild 4.3 Zeitliche Abläufe auf einem synchronen Systembus

Zu Beginn der positiven Halbwelle (Zeitspanne Ta) werden für beide Zugriffs-formen, lesend wie schreibend die Adressen und die Steuerleitung R//W auf den Adressbus bzw. die Steuerleitung gelegt. Die weiteren Operationen unterscheiden sich nun:

• Bei einer Leseoperation (/RD = low) erwartet der Prozessor, dass irgendwann während der Zeit Tb das adressierte Speicher- oder Peripheriegerät antwortet und die gültigen Datenbits auf dem Datenbus zur Übernahme, die mit dem Ende von Tb erfolgt, zur Verfügung stellt.

• Beim Schreibvorgang (/WR = low) legt der Prozessor spätestens bei Beginn der negativen Halbwelle des Takts (Phase Ta) die gültigen Werte auf den Datenbus, um dem adressierten Element entsprechende Zeit zur Übernahme zu lassen. Die Datenübernahme muss mit der positiven Flanke an /WR erfolgen.

Dieser Systembus zeichnet sich dadurch aus, dass alle Vorgänge vollständig syn-chron zum Taktzyklus ablaufen (müssen), Abweichungen davon sind nicht mög-


lich. Die Steuerbussignale beschränken sich auf das Taktsignal und die /RD sowie /WR-Leitung, zuzüglich natürlich weiterer Signale für Reset, IRQ usw.

Diese Systembusform wird bei 8-Bit-Prozessoren (6502, 6809, 68HC11, 8051 und ATmega8) eingesetzt. Sie ist besonders einfach, auch in der Implementierung auf einer CPU-Platine, hat jedoch den Nachteil, dass der maximal zulässige Takt durch den langsamsten Busteilnehmer bestimmt wird, der schließlich auch noch korrekt reagieren soll.

4.2.2 Der semi-synchrone Systembus Für interne Vorgänge im Mikroprozessor selbst kann der Systemtakt erheblich höher gesetzt werden, als dies für den Buszyklus T möglich ist, da sich dieser nach den äußeren Gegebenheiten richten muss. Dies bedeutet zunächst, dass Bus- und Taktzyklus nicht mehr übereinstimmen müssen, sondern mit unterschiedlichen Werten (meist in ganzzahligem Verhältnis) versehen sind.

Bild 4.4 zeigt die zeitlichen Abläufe auf einem semi-synchronen Systembus bei einem Taktverhältnis 2:1, d.h., ein Buszyklus dauert (ohne Sondermaßnahmen) 2 Taktzyklen lang.

Adresse

Daten

Takt

Ax

Dx

Ta Tb

T

/RD

/WR

Lesen

/Ready

Tristateirrelevant

Legende:

Bild 4.4 Zeitliche Abläufe auf einem semi-synchronen Systembus

Nach Beginn einer Speicheroperation legt der Prozessor möglichst frühzeitig zu Beginn des Zustands ("State") Ta die Adresse auf den Adressbus. Die Auswahl der


Übertragungsrichtung wird wiederum durch die Steuerleitungen /RD und /WR (es ist auch eine Kombination R/ /W möglich) vorgenommen.

Bei einer Leseoperation mit hinreichend schnellem Speicher erscheinen während des letzten Taktzyklus von Tb die Daten auf dem Datenbus und können dann mit der aufsteigenden Taktflanke des nächsten Buszyklus in den Prozessor übernom-men werden.

Bei einer Schreiboperation folgen zu Beginn der zweiten Hälfte von Ta die Daten auf dem Datenbus. Auch hier gelingt die Übertragung, wenn der externe IC eine genügend kleine Zugriffszeit besitzt.

Adresse

Daten

Takt

Ax

Dx

Ta Tb

T'

/RD

/WR

Schreiben

/Ready

Tristateirrelevant

Legende:

TW

Bild 4.5 Zeitliche Abläufe auf einem semi-synchronen Systembus bei Zugriffsverlängerung

Voraussetzung für beide Übertragungen ist die Signalisierung am Eingang /Ready des hypothetischen Prozessors, und zwar vor der letzten fallenden Flanke des Taktzyklus innerhalb von Tb. Liegt dieses Signal zu diesem Zeitpunkt auf high dann muss der Prozessor annehmen, dass das IC, auf das zugegriffen wird, lang-samer ist, als es dem Buszyklus entspräche, und legt wie in Bild 4.5 Wartezyklen (TW) ein. Dieses Instrument ermöglicht es dem Prozessor, im Prinzip mit belie-bigem Speicher oder Peripherie zu interagieren, was beim synchronen Systembus unmöglich war.

Die /Ready-Leitung wird gelegentlich auch prinzipiell auf low gelegt und nur beim Zugriff auf langsame ICs auf high zum Einfügen von Wartezyklen angehoben. Die semi-synchronen Systembusse laufen in der Vielzahl der Zugriffe entsprechend den synchronen ab, also mit festgelegter Zugriffsdauer. Diese Busse lassen sich


sofort durch Festlegen des /Ready-Eingangs auf Masse zu synchronen Systembus-sen umstrukturieren, wobei dann allerdings die Fähigkeit des Zugriffs auf langsame ICs verloren geht.

Der semi-synchrone Systembus stellt die modernste Art des Systembus dar; insbe-sondere bei Hochgeschwindigkeits-CPUs (ab 80386, 68040) hat sich diese Art sehr bewährt.

4.2.3 Der asynchrone Systembus Der asynchrone Systembus, beispielsweise in den Motorola CPUs 68000, 68010, 68020 und 68030 realisiert, geht nicht mehr von einem normalen, taktgebundenen Verhalten und außerplanmäßigen Zugriffsverlängerung aus, sondern beherbergt eine andere Philosophie: Dem Busteilnehmer wird seitens der CPU das Vorliegen einer gültigen Adresse mitgeteilt, er selbst muss der CPU das Vorliegen der Daten (beim Lesen) oder das Übernehmen der Daten (beim Schreiben) mitteilen, ohne dass irgendeine getaktete Zeitspanne dazwischen vergehen müsste. Im Prinzip kann ein solcher Bustransfer beliebig lange dauern.

Bild 4.6 zeigt die maßgeblichen Signalverläufe:

irrelevant Tristate

Daten

Daten

Adresse

Takt

Ax

/AS

/DTACK

Dx Lesen

R/ /W

Dx Schreiben

R/ /W

Legende:

Bild 4.6 Zeitliche Abläufe auf einem asynchronen Systembus

Die für den Handshake maßgeblichen Signale heißen /AS (Address Strobe), das das Anliegen der gültigen Adresse und im Fall der Schreibens von Daten auch der Daten am Datenbus abgibt, und /DTACK (Data Transfer ACKnowledge), das sei-tens des Speicher- oder peripheren ICs das Ende des Datentransfers ankündigt.

Der Handshake verläuft dann so:


• Die CPU belegt die Adressen und ggf. die Datenleitungen mit den gültigen Werten und setzt /AS aktiv (low)

• Der angesprochene Speicherbaustein wird durch die Dekodierung selektiert und beginnt seinerseits mit den Aktionen, für die er beliebig viel Zeit bekommt.

• Ist der Baustein fertig, also sind z.B. beim Lesen die Datenleitungen richtig gesetzt, dann setzt er (oder Hilfsbausteine, falls, wie meistens, solche Hilfs-signale beim IC gar nicht vorgesehen sind) die Leitung /DTACK aktiv.

• Jetzt kann die CPU /AS zurücknehmen, auch wiederum in beliebig langer Zeit; anschließend nimmt die Peripherie /DTACK zurück.

Diese Form des Busses ist natürlich die allen Anforderungen am besten angepasste. Für den Hardware-Designer ist dabei zu beachten, dass Fehlzugriffe, also Zugriffe auf nicht-belegte Speicherplätze künstlich beendet werden müssen, da aufgrund des asynchronen Protokolls die CPU ggf. endlos warten würde!

Ferner müssen in den meisten Fällen die /DTACK-Antwortsignale generiert werden. Dies bedeutet, dass eine zusätzliche Logik eingebaut werden muss, die natürlich ihrerseits Verzögerungen hat und das /DTACK-Signal quasi künstlich aus einem Takt o.ä. generieren muss. Dieser Nachteil lässt die Vorteile des asynchro-nen Busses bei 'normalen' ICs wieder verschwinden, so dass auch Motorola wieder zum semi-synchronen Busprotokoll zurückgegangen ist.

4.3 Der Mikroprozessor ATmega2560

Nach den allgemeinen Behandlungen von Bussystemen wird jetzt der ATmega-2560-Mikrocontroller im Detail behandelt. Dazu sind einige Vorbemerkungen not-wendig.

Der Mikrocontroller ATmega2560 ist ein Mitglied einer ganzen Mikrocontroller-Familie. Die einzelnen Mitglieder einer solchen Familie unterscheiden sich – nicht nur bei Atmel – durch Variationen des Mikroprozessorkerns, der Größe und ggf. Zusammensetzung des Speichers für Code und Daten sowie in der Zusammen-setzung der peripheren Bauelemente.

In der Praxis bedeutet dies, dass aufgrund der Anforderungen in einem Projekt der entsprechende Mikrocontroller ausgewählt wird. Abgesehen von der (Rechen-) Performance des Kerns, die im Grunde genommen schwer einschätzbar ist (siehe hierzu auch die Vorlesung Embedded Systems Engineering, [Sie12]), muss die Speichergröße entsprechend gewählt werden – ein zu klein gewählter Speicher ist katastrophal. Besonders wichtig ist aber die Wahl der richtigen peripheren Elemen-te: Geeignete Peripherie wie USB-Controller oder Netzwerkschnittstelle entlasten den Prozessor nicht nur, sie machen manche Schnittstelle überhaupt erst möglich.

Die Konsequenz hiervon ist im Pinout zu sehen: Fast alle peripheren Elemente im Mikrocontroller benötigen einen oder mehrere Anschlüsse, so dass diese entspre-chend herausgeführt werden.


4.3.1 Das Pinout des ATmega2560 Mikrocontroller sind i.a. optimiert auf den Single-Chip-Betrieb, d.h. sie enthalten alle notwendigen Teile wie Festspeicher und RAM. Gleichzeitig damit entfällt natürlich die Notwendigkeit für externe Daten- und Adressbusse, wie die Pinbe-legung für den ATmega2560 in Bild 4.7 zeigt.

Bild 4.7 Pinout ATmega2560

Am Pinout fällt auf, dass es im Wesentlichen so genannte Portein- und -ausgänge aufweist, kenntlich durch Pxx. Diese Ports sind zu 8-bit-Gruppen zusammenge-fasst, weil die CPU 8 bit als intrinsische Datenbreite besitzt und somit einen solchen Port offenbar zu einem Zeitpunkt bedienen kann – aber keineswegs mehre-re Ports gleichzeitig!


Das zweite auffällige ist eine Doppelbelegung für viele Pins. Für die Erweiterung des Speichers im Programm- oder Datenbereich – auf den genauen Umfang der internen Ressourcen wird weiter unten eingegangen – sind die externen Busse notwendig; dies führt dazu, dass einige Pins in anderer Funktionalität genutzt werden.

Andere Schnittstellen, die im ATmega2560 integriert sind, betreffen die serielle Schnittstelle (USART, Universal Synchronous Asynchronous Receiver/Transmit-ter), verschiedene serielle Interfaces zur Kommunikation auf einem Board (SPI, Serial Peripheral Interface, TWI, Two Wire Interface), Anschlüsse für AD-Umset-zer und analoge Komparatoren sowie Anschlüsse für Timersteuerung. Auf einige dieser peripheren Elemente wird in Kapitel 6 eingegangen.

Die Umschaltung zwischen den Funktionen der Doppelbelegung erfolgt immer via Konfigurationsregister, das mit entsprechenden Konfigurationsbits geladen werden muss. Dies muss per Software erfolgen, und dieser Initialisierungsteil ist stark hardwareabhängig.

4.3.2 Der externe Bus-Modus (External Memory Interface)

Die Konfiguration des ATmega2560 (wie auch der anderen Familienmitgliedern) erfolgt durch Setzen oder Löschen von Bits in den Registern XMCRA und XMCRB (eXternal Memory Control Register A/B) an den Adressen 0x74 und 0x75. Das Setzen des Bit 7 (SRE, External SRAM/XMEM Enable) in XMCRA (auf ‘1‘) bedeutet, dass die entsprechenden Ports nunmehr als Adress- Daten- und Steuerbus arbeiten (und damit auch nicht mehr als Portbits zur Verfügung stehen).

Der Defaultwert dieses Registerbits (bei Reset) ist im Übrigen ‘0‘, so dass das Bit immer gesetzt werden muss. Letztendlich bedeutet dies, dass ein kleines Stück Software immer im internen Speicherbereich vorhanden sein muss, weil ja ansonsten der externe Speicher nicht zugänglich wird. Die übrigen 15 Bits dieser beiden Register haben dann weitere Bedeutung für die Konfiguration des Speicher-interfaces, insbesondere wird hier auch die Geschwindigkeit (in Taktzyklen) eingestellt.

Durch Setzen des SRE-Bits werden folgende Teilbussysteme aktiviert:

● AD0 .. AD7 an Port A

● A8 .. A15 an Port C

● ALE, /RD und /WR an Port G (0 .. 2)

Axx bedeutet hierbei den exklusiven Adressbus, ADxx den im zeitmultiplex gemischten Adress-/Datenbus, /RD den Lesezugriff (aktiv low), /WR den Schreib-zugriff (aktiv low) und ALE Address Latch Enable, ein Steuersignal, um den gemultiplexten Adress-/Datenbus wieder zu demultiplexen.


Bild 4.8 Interface zwischen ATmegaXXX und SRAM

Bild 4.8 zeigt das Interface zwischen ATmega2560 und einem SRAM-Baustein mithilfe eines dazwischengeschalteten Latch (ein Latch ist ein taktzustandsgesteu-ertes Flipflop, d.h. ein Baustein mit 1- oder mehreren Biteingängen, das an der korrespondierenden Ausgängen entweder den gleichen Zustand wie am Eingang zeigt (transparenter Zustand) oder den Zustand, der unmittelbar vor dem Speichern am Eingang anlag (opaker Modus)). Im Abschnitt 4.4 wird eine konkrete Schaltung für den ATmega2560 mit externem Speicher dargestellt, hier wird als Latch ein Baustein vom Typ 74HCT573 verwendet.

Bild 4.9 Zeitliches Verhalten des externen Speicherinterfaces


Das Businterface benötigt somit 3 Taktzyklen der so genannten System Clock, um einen Zugriff komplett durchzuführen. Dies ist ein Takt mehr als bei internen RAM-Zugriffen. Die Anzahl der Taktzyklen kann auf 4 oder 5 erhöht werden (1 oder 2 Waitstates), und der Start des nächsten Buszyklus kann noch um einen Takt verzögert werden, so dass de facto 6 Takte für einen Zugriff benötigt werden können.

Die Konfiguration für die Waitstates erfolgt im bereits erwähnten Register XMCRA in den Bits 6 .. 0. In 4 Bits (3 .. 2 und 1 .. 0) wird hier für zwei verschiedene Bereiche die Anzahl der Waitstates definiert, wobei die Grenze zwi-schen diesen Bereichen wiederum in den Bits 6 .. 4 gesetzt wird.

4.3.3 Speicherbelegung im ATmegaXXX Bild 4.10 zeigt im Überblick, welcher Speicher an welchen Adressen zu finden ist und wie dieser Speicher jeweils adressiert werden kann. Wie in vielen anderen Mikrocontrollern auch existieren in den Varianten ATmega640, 1280 und 2560 Flash-EEPROM-Speicher für Programm und konstante Daten, SRAM (intern, erweiterbar) für Daten sowie EEPROM für Konfigurationsdaten.

Interner Speicher wird bei Lese- und Schreibvorgängen entsprechend intern ange-steuert, so dass hier nur das Software-Interface relevant ist. Externer Speicher – hier nur SRAM – muss allerdings auch hardwaretechnisch angesteuert werden; in diesem Fall sind /RD und /WR hierfür vorgesehen.

Das Software-Interface ist schon interessant. SRAM wird immer über Load/Store-Befehle ld (load), ldd (load with displacment) und lds (load direct from SRAM) bzw. st, std, sts (store …) erreicht, intern wie extern. Die Unterscheidung intern/extern erfolgt immer über die Adresse.

Die I/O-Register, die wie bereits angedeutet das Interface zwischen Prozessor und Peripherie bilden, können im Basisbereich bis 0x5F auch über in/out, im erweiter-ten Bereich jedoch nur über die erwähnten ld/ldd/lds und st/std/sts erreicht werden.

Konstante Daten (Tabellen, Strings) können auch im Programmbereich gespeichert sein. Diese sind dann über ldm und eldm (load from program memory bzw. from extended program memory) erreichbar, während stm (store to program memory) eine Kuriosität darstellt: Im Flash-Bereich darf man aus technischen Gründen eigentlich nicht schreiben, weil mit dem Schreiben ein Löschen verbunden ist und dieses Löschen sich auf ganze Bereiche bezieht.

Der Befehl stm wurde aufgenommen, um eine Möglichkeit zu schaffen, den applikationsspezifischen Programmcode auch in das Flash zu schreiben. Zu diesem Zweck darf stm nur im so genannten Boot-Bereich (konfigurierbar 512, 1024, 2048 oder 4096 Bytes am oberen Ende des jeweiligen Speichers) als Befehl stehen – dieser Bereich wird beim Neukonfigurieren nicht überschrieben.

Die Applikationen hingegen dürfen diesen Befehl nicht nutzen.


Bild 4.10 Speichermodell im ATmega640/1280/2560

Noch eine Erklärung zum Befehl elpm: Der Programmspeicher kann bis zu 256 KByte groß sein, das entspricht einer 18-bit-Adressierung (im Datenbereich wer-den die Adressen immer Byte-weise gesetzt bzw. berechnet). Wie noch im Kapitel 5 darzustellen sein wird kann man durch ein Zeigerregister (z.B. Z) aber nur 16 bit erreichen; die übrigen Bits, bei den aktuellen Implementierung also A16 und A17, werden in einem I/O-Register namens RAMPZ (Adresse: 0x3B für Zugriff per in/out, 0x5B für ld/ldd/lds und st/std/sts, → 5.2) gespeichert, und elpm nutzt dieses Register für die zusätzlichen Bits, ldm hingegen nicht.


4.3.4 Zugriff auf das EEPROM Das („echte“) EEPROM, das Byte-weise lösch- und beschreibbar ist, wird aus-schließlich als Datenspeicher verwendet. Hier können Daten, die einen Verlust der Versorgungsspannung überleben müssen, gespeichert werden. Dies sind typischer-weise Konfigurationsdaten, die sich auch selten ändern.

Die seltene Änderung ist dabei durchaus keine Option, eher eine Notwendigkeit. Die Anzahl der Schreibzyklen ist auf etwa 100000 begrenzt (besser: garantiert), ein Wert, der für „normale“ Variablen recht schnell überschritten wird.

Aber: Der lesende wie schreibende Zugriff auf diesen Speicher ist weit entfernt von einem einzigen Mikroprozessorbefehl, wie folgendes Codebeispiel in Bild 4.11 zeigt

Zur Verwaltung des lesenden Zugriffs benötigt man die Register EECR (EEPROM Control Register, 0x1F/0x3F), EEAR (EEPROM Address Register, 0x21 und 0x22 bzw. 0x41 und 0x42) und EEDR (EEPROM Data Register, 0x20 bzw. 0x40).

Zunächst wird abgefragt, ob der Zugriff auf eine EEPROM-Zelle gerade aktiv ist; allein das ist verwunderlich, laufen doch alle Zugriffe sequenziell nach dem Von-Neumann-Prinzip ab. Die Erklärung: Das Schreiben auf eine EEPROM-Zelle be-nötigt ca. 3,3 ms. Der zu schreibende Wert wird in einer temporären SRAM-Zelle gespeichert, und das Schreiben von einem Zustandsautomaten gesteuert, so dass das Programm weiterlaufen kann. Kommt es innerhalb dieser Zeit aber zu einem zweiten Zugriff, dann muss dieser solange gebremst werden, bis der Schreibvor-gang wirklich beendet ist.

unsigned char ucEEPread( unsigned int uiAddress ) { /* Wait for completion of previous write */ while( (EECR & (1<<EEPE)) != 0 ); /* Set up address register */ EEAR = uiAddress; /* Start eeprom read by writing EERE */ EECR |= (1<<EERE); /* Return data from Data Register */ return EEDR; }

Bild 4.11 C-Code-Beispiel zum lesenden Zugriff auf eine EEPROM-Zelle

Mit anderen Worten: Das Schreiben einer EEPROM-Zelle kann den Programmlauf bis zu 3,3 ms blockieren, in Takten bei einer Taktfrequenz von 16 MHz ausge-drückt: 52800. Dies ist eine halbe Ewigkeit in Echtzeitsystemen, die es meist zu verhindern gilt. Mehr zu diesem Problem in [Sie12, Kapitel 4.2].


Wenn der Zugriff auf das EEPROM frei ist, wird die Adresse in EEAR gespei-chert, das EECR auf „Lesen eines Bytes“ gesetzt und das EEPROM via Register EEDR ausgelesen. Die verwendeten Werte EEPE und EERE (EEPROM Program| Read Enable) sind in avr/io.h definiert und stellen Bitnummern dar. Der Lesevorgang selbst benötigt 4 Takte.

Das Schreiben gestaltet sich ähnlich:

void vEEPwrite( unsigned int uiAddress, unsigned ch ar ucData ) { /* Wait for completion of previous write */ while( (EECR & (1<<EEPE)) != 0 ); /* Set up address and data register */ EEAR = uiAddress; EEDR = ucData /* Write logical one to EEMPE */ EECR |= (1<<EEMPE); /* Start eeprom write by setting EEPE */ EECR |= (1<<EEPE); }

Bild 4.12 C-Code-Beispiel zum schreibenden Zugriff auf eine EEPROM-Zelle

Auch hier wird zunächst auf die Beendigung eventueller Programmiervorgänge im EEPROM gewartet, um dann mit dem eigentlichen Schreibvorgang zu beginnen. Die Besonderheit in diesem Algorithmus ist aber, dass ein Interrupt Request – eine Unterbrechungsanfrage, → 6.4 –, der ebenfalls auf das EEPROM (lesend oder schreibend) zugreifen würde, ggf. Fehler hervorrufen könnte. Dies ist ein allgemeines Problem der nicht-reentrantfähigen Routinen, das u.a. in [Sie12, Kap. 9.3.2] behandelt wird.

Abgesehen von solchen Problemen mit der Reentrantfähigkeit sind Programme, die zeitweise der Fortlauf blockieren, im Sinn einer Echtzeitfähigkeit äußerst proble-matisch und sollen in jedem Fall verhindert werden. Wie dies erfolgen kann ist in [Sie12, Kap. 4.2.3] dargestellt.

4.4 Aufbau eines Rechnersystems auf Basis ATmega2560

4.4.1 Aufbau der Hardware Nachdem nun das Interface zwischen ATmegaXXX und Speicher bekannt ist (die folgenden Aussagen gelten für alle Derivate) und zudem unterschiedliche Speicherbausteine und deren Belegung bekannt sind, kann – zumindest theoretisch


– ein Rechnersystem aufgebaut werden. Als Beispiel wird hier ein System mit folgenden Komponenten aufgebaut:

• ATmega2560 Mikrocontroller mit Businterface für externen Speicher

• 2 statische RAM-Bausteine, 6264 (8K * 8 bit) und 62256 (32K * 8 bit) als (externer) Datenspeicher

• 1 Baustein 8255 (→ Kapitel 6) mit 24 parallelen Bitleitungen als allgemeiner Input/Output-Baustein (so genannter PIO, parallel Input/Output)

Bild 4.13 zeigt schematisch diese Konfiguration des aufzubauenden Mikrorech-ners. Dieser Mikrorechner verfügt damit über alle Komponenten eines Von-Neu-mann- bzw. Harvard-Rechners. Die folgende Aufgabe besteht nun darin, die Kom-ponenten entsprechend zu verdrahten.

Der erste Teil der Verdrahtung ist in Bild 4.14 festgehalten. Hier werden Adress- und Datenbusanschlüsse der Bausteine miteinander verbunden, wobei eine Beson-derheit am ATmega2560 berücksichtigt werden muss: Der zeitlich gemultiplexte Adress-/Datenbus.

Dieser AD-Bus muss nun zeitlich entkoppelt werden, hierzu dient das Latch 74573, das den Adressanteil im Signal durchlässt, solange das Steuersignal ALE auf low gesetzt ist (Register sind transparent), den zuletzt anliegenden Wert jedoch speichert, wenn ALE den Wert high besitzt.

Diese Entkopplung muss in Zusammenhang mit dem zeitlichen Verhalten des ATmega2560 gesehen werden, siehe auch Bild 4.9. Das Steuersignal ALE ist so gestaltet, dass bei Verwendung eines Standard-Latches die gewünschte Funktiona-lität erreicht wird. Hinter dem Latch liegt dann der „reine“ Adressbus an, während das originäre Signal als Datenbus verwendet und dementsprechend verdrahtet wird.

Bild 4.15 zeigt nun die endgültige Verdrahtung – allerdings ohne die Zuführungs-leitungen für Masse und Betriebsspannung sowie ohne Takterzeugung. Um den einzelnen Bausteinen einen Bereich im Adressraum zuzuweisen, bedarf es einer Decodierung der Adressen und Generierung der Chip-Select-Signale. Hierzu seien einige Bemerkungen gemacht:

• Das Programm ist beim ATmega2560 (und den anderen Derivaten) ausschließ-lich im internen Speicher vorhanden, so dass ein externer Speicher sinnlos wäre. Das Programm muss ferner an der Adressen 0x0000 starten, dies ist die so genannten Resetadresse, d.h., die CPU fängt bei einem Neustart (Power-On) bei der Adresse 0x0000 an.

• Für die beiden statischen RAMs, die Daten speichern werden die Speicherbe-reiche 0x8000 – 0xFFFF (32 KByte) und 0x6000 – 0x7FFF (8 KByte) gewählt. Diese Wahl ist willkürlich. Hier erfolgt die Aktivierung durch die entsprechende Adresse und ein aktives /RD oder /WR.

58 E

mbedded S

ystem

s Engineering 1

62256

A0

..

A14

/CS

/RD

/WR

D0

...

D7

6264

A0

..

A12

/CS1

CS2

/RD

/WR

D0

...

D7

PIO 8255

A0

A1

/CS

/RD

/WR

D0

...

D7

PA0

...

PA7

PB0

...

PB7

PC0

...

PC7

ATmega2560

AD0

..

AD7

A8

...

A15

ALE

/RD

/WR

Bild 4.13 B

austeine im A

Tm

ega2560-basierten Mikrorechner


Bild 4.14 Mikrorechner mit Verdrahtung des Adress- und Datenbusses


Bild 4.15 Komplette Verdrahtung


• Der I/O-Baustein wird ebenfalls im Datenspeicherbereich eingeblendet, und zwar bei 0x4000 – 0x5FFF. Der Baustein belegt zwar nur 4 Adressen, die Decodierung hat aber nur die Adresssignale A13 bis A15 zur Verfügung und kann daher nur Bereiche von einer Mindestgröße von 8 KByte unterscheiden.

Die Decodierung erfolgt durch einen programmierbaren Baustein GAL16V8. Die booleschen Gleichungen, die zur Programmierung notwendig sind, sind im Listing 4.1 aufgeführt.

CHIP DECODER_ATmega GAL16V8 NC A13 A14 A15 NC RD WR NC NC GND NC NC NC CE_RAM1 CE_RAM2 CE_8255 NC NC NC VCC /CE_RAM1 = A15 * /RD + A15 * /WR ; 32 kByte RAM 800 0h .. ; 0ffffh /CE_RAM2 = /A15 * A14 * A13 * /RD + ; 8 kByte RAM 6 000h .. /A15 * A14 * A13 * /WR ; 7fffh /CE_8255 = /A15 * A14 * /A13 * /RD + ; 8 kByte PIO 4000h .. /A15 * A14 * /A13 * /WR ; 5fffh

Listing 4.1 Decodierungslogik in GDS-Syntax

4.4.2 Konfiguration in der Software Die Nutzung der SRAMs sowie des Peripheriebausteins 8255 muss ggf. in Software konfiguriert werden. Hierzu muss in jedem Fall das Register XMCRA (eXternal Memory Control Register A, Adresse 0x74) konfiguriert werden.

Wird Bit 7 in diesem Register auf ’1‘ gesetzt, wird das externe Interface (AD-Leitungen, /RD, /WR, ALE) aktiviert. Für den gesamten Bereich kann man dann 2 Teilbereiche definieren, für die die Anzahl der Wait States getrennt voneinander definierbar sind. Für Einzelheiten sei auf [Atm_DS, Chapter 9] verwiesen.

Ein Beispiel hierzu: Wird XMCRA mit dem Wert 0xB1 initialisiert, wird der Bereich von 0x2200 bis 0xFFFF an der Stelle 0x6000 geteilt; der obere Bereich wird auf 0 Wait States (= 3 Zyklen Zugriffsdauer), der untere mit dem Baustein 8255 auf 1 Wait State (= 4 Zyklen Zugriffsdauer) gesetzt.

XMCRB (eXternal Memory Control Register B, Adresse 0x75) definiert, wie weit der externe Adressbus ausgegeben wird; hier können bis zu 8 Adressbusbits (A8 bis A15) maskiert werden, d.h., der bisherige Port C behält seine Funktion. In diesem Beispiel wird XMCRB nicht konfiguriert, weil alle Adressbits benötigt werden.

5 Einführung in die ATmega8-Assemblersyntax

Wenn man sich in die Maschinensprache eines Mikroprozessors bzw. in dessen einfachere Assemblernotation (to assemble = zusammenbauen) einarbeitet, dann gilt es, im Wesentlichen 3 Dinge zu beachten:

● Das Programmiermodell

● Die Notation und Bedeutung der Maschinen- bzw. Assemblerbefehle

● Die Adressierungsarten

Das Programmiermodell enthält die entscheidenden Informationen zu den Res-sourcen der CPU bzw. des Mikrocontrollers und umfasst im Wesentlichen das Registermodell. Zählt man auch das Speichermodell hinzu, also die Adressbereiche an denen real Speicher einer bestimmten Art existiert bzw. existieren kann, so ist das aus Sicht der CPU möglich, zugleich begibt man sich damit bereits auf das Gebiet des Mikrorechners, also einer CPU mit Speicher und Peripherie.

Literatur:

[Atm_DS] http://www.atmel.com/Images/doc2549.pdf

5.1 Das Programmiermodell der ATmega8-CPU

Obwohl es sich bei der ATmega8-CPU um eine relativ einfache, 8-Bit-Rechnerar-chitektur handelt, ist das Programmiermodell, also die Beschreibung der Hardware innerhalb der CPU, die der hardwarenahe Softwareprogrammierer 'sieht', recht umfangreich. Der Grund hierfür ist darin zu suchen, dass die ATmega8-Architektur nicht nur die reine CPU, sondern auch eine Anzahl von Peripherie-Einheiten umfasst, und diese bilden sich natürlich ebenfalls im Programmiermodell ab.

Bild 5.1 stellt die symbolisch erreichbaren Register der CPU ohne die Einbindung der Peripherie dar. Gegenüber Bild 2.4 ist diese Darstellung noch um die Einbe-ziehung der Adressregister X, Y und Z erweitert worden.

Die in Bild 5.1 gezeigten Register benötigen keinen (physikalischen) Speicherplatz im SRAM-Bereich, der Speicherplatz für Register ist in der CPU integriert. Allerdings sind die Register tatsächlich via Speicheradressen erreichbar, und zwar durch Lese- oder Schreibzugriffe auf die Adressen 0000h bis 001Fh.

Die bereits erwähnten Register X, Y und Z stellen Adressregister dar. Da Adressen in der ATmega8-CPU 16 bit groß sein müssen, musste hier von der üblichen Breite von 8 bit abgewichen werden. Der Kompromiss in der ATmega8-CPU sieht so aus, dass jeweils 2 Register aus dem 8-bit-Registersatz gekoppelt werden (low byte jeweils im Register mit der kleineren Nummer, also das so genannte little-endian-

5 Einführung in die ATmega8-Assemblersyntax 63

Modell) und symbolisch mit neuen Namen adressiert werden. Für diese „16-bit-Adressregister“ existiert aber kein eigener Register-Speicherplatz, es wird der Platz für die Register R26-R31 mehrfach genutzt.

Bild 5.1 Registermodell ATmega8

Die Register im Einzelnen:

General Purpose Register

Die Register R0 bis R31 befinden sich in der CPU und sind zusätzlich via Zugriff auf die Datenspeicheradressen 0000h bis 001fh erreichbar. Das X-Register befindet sich dabei an den Adressen 001ah (low) und 001bh (high), Y an 001ch und 001dh sowie Z an 001eh und 001fh.

Statusregister

Das Statusregister SREG ist ebenfalls über eine Daten-Adresse (003Fh) erreichbar und enthält die im Folgenden erläuterten Flags (Bild 5.2).


Bild 5.2 Statusregister

I stellt das Global Interrupt Enable Flag dar. Dieses Flag muss gesetzt sein, damit Interrupt Requests zugelassen sind und die entsprechende Interrupt Service Routine (ISR) starten kann (→ 6.5.1). Dieses Flag kann mithilfe der Befehle SEI und CLI (SEt|CLear global Interrupt enable flag) im Programmfluss beeinflusst werden. Bei jedem Start einer ISR mit dieses Flag gelöscht, bei jeder Rückkehr wieder gesetzt, um den Programmablauf einschließlich aller IRQ/ISR zu gewährleisten.

Das T-Flag (Bit Copy Storage) stellt ein gewisses Kuriosum dar. Die beiden Bitverarbeitungsbefehle BLD (Bit Load) und BST (Bit Store) benötigen eine Quelle bzw. Senke für ein Bit, und T stellt dies dar.

H wird als Half Carry Flag bezeichnet und zeigt einen Übertrag von Bit 3 auf 4 bei manchen arithmetischen Operationen an (z.B. Addition). Dies ist ausschließlich für die so genannte BCD-(Binary Coded Decimal)Arithmetik sinnvoll und stellt somit einen Spezialfall dar.

Das S-Flag (Sign Flag) zeigt das Vorzeichen einer arithmetischen Operation an und muss in Zusammenhang mit der Zahlendarstellung negativer Zahlen und dem Überlauf gesehen werden (→ 2.3.2). Das S-Flag hängt mit den weiter unten beschriebenen Flags N und V über

VNS ⊕=

zusammen.

V ist das Overflow-Flag im Zweierkomplement (→ 2.3.2). Dieses Flag zeigt an, dass bei vorzeichenbehafteten Zahlen ein Überlauf aufgetreten ist und ist somit für einige arithmetische Operationen um Addition und Subtraktion herum relevant. Ob es im Programm ausgewertet wird hängt u.a. von dem Kontext der Variablentypen ab.

N ist das Negative-Flag. Hiermit wird bei arithmetischen und logischen (!) Opera-tionen angezeigt, dass das Ergebnis negativ ist (höchstwertiges Bit ist auf 1 ge-setzt).

Das Z-Flag (Zero) zeigt bei arithmetischen und logischen Operationen an, dass das Ergebnis Null beträgt. Das Z-Flag wird also 1, wenn das Ergebnis 0 ist.

Das C-Flag (Carry) schließlich stellt das Übertrags-Flag dar, das bei vielen arithmetischen und logischen (z.B. Rotation und Shift)Operationen als Ergebnisverlängerung und für den Eingangsübertrag benötigt wird.


Stack Pointer Der Stack Pointer (zum Stack-Konzept → 5.3) ist ein 16-bit-Register, das auf einen Speicherbereich zeigt und diesen für den Stapelspeicher (→ 5.3) nutzt. Der Stackpointer muss dabei entweder die vollständige Adresse beinhalten, oder die Adresse muss entsprechend ergänzt werden.

Beim ATmega8 ist es so vorgesehen, dass der Stackpointer den gesamten Adress-raum für Daten adressieren kann, daher ist er als 16 bit Register an den Adressen 0x003D (Stackpointer low, SPL) und 0x003E (Stackpointer high, SPH) ausgeführt. Sollte ein Derivat dieser Familie weniger Adressraum im Datenbereich besitzen, ggf. sogar nur bis zu 256 Adressen, sind die Zeigerregister entsprechend ausge-führt, SPH kann sogar entfallen.

5.2 Speichermodell und Einbindung der Peripherie

Das Speichermodell der ATmega8-Familie wurde bereits in 4.4.3 erläutert; Bild 5.3 entspricht dementsprechend Bild 4.10. Im Allgemeinen wird man bei der Nut-zung von Datenspeicher anstreben, diesen ausschließlich intern zu halten. Gründe hierfür sind:

● Die Zuverlässigkeit einer Schaltung auf einem Board (PCB, Printed Circuit Board) sinkt mit der Anzahl der Bausteine, weil Lötstellen im Allgemeinen eine Schwachstelle darstellen. Daher werden „1-Chip-Systeme“ angestrebt.

● Der Zugriff auf den internen Speicher ist im Allgemeinen, auch beim Atmega8, einfach schneller, weil die externen Leitungen und Puffer fehlen und somit keine Timingverluste eintreten. Zudem lässt sich das Timing intern besser abstimmen.

Die Möglichkeit zur externen Erweiterung des Datenspeichers muss also als Option für „großen Speicherbedarf“ angesehen werden.

Der vorhandene Speicher muss in der Entwicklungsumgebung bekannt sein, d.h., der Linker – dieser bildet den Code, die Variablen und den Stack auf den vorhandenen Speicher ab – muss wissen, wo er den Stackbereich vorfinden wird, und wo die Variablen gespeichert werden können. Diese Eintragungen sind in der Regel abhängig vom Entwicklungssystem.

Eine weitaus interessantere Frage ist die Einbindung der Peripherie-Elemente wie parallele und serielle Schnittstellen im System. Gängig ist hier die Integration der Konfigurations- und Betriebsregister für die Peripherie im Datenspeicherbereich des Prozessors; diese Methode wird auch im ATmega8 genutzt, und es bedeutet, dass die Peripherie-Elemente wie Variable, allerdings mit konstanter Adresse, im Programm angesprochen werden.

Eine andere Variante, die z.B. in der 80x86-Familie (Intel) genutzt wird, besteht in der Schaffung eines eigenen I/O-Bereiches außerhalb des Datenspeichers und Nutzung eigener Maschinenbefehle zum Zugriff.


Bild 5.3 Speichermodell im ATmega640/1280/2560

Gemäß Bild 5.3 ist der Adressbereich von 0000h bis 01FFh für I/O-Register vorge-sehen. Dieser gliedert sich so, dass R0 bis R31 an den unteren 32 Adressen erreichbar sind (und hier gleich ein Tipp: Bitte nicht über die Speicheradressen, sondern mit den Symbolen R0 .. R31 nutzen), und darüber bis 005Fh die (Basis-) I/O-Register liegen.

In den ersten Versionen der ATmega8-Architektur reichte dieser Bereich vollkom-men aus. Man kann zum Zugriff spezielle Assemblerbefehle IN und OUT nehmen, die jeweils ein Byte vom I/O-Register in eines der Register R0 .. R31 (IN) bzw.


umgekehrt (OUT) kopieren. Diese Befehle können mit einer direkten Adresse angegeben werden, die im Wert von 0000h bis 003Fh angegeben wird und die I/O-Register von 0020h bis 005Fh (also mit einem konstanten Adressoffset von 20h) adressiert.

Bei aktuellen Varianten reicht die Zahl von 64 I/O-Registern nicht mehr aus, so dass der I/O-Bereich erweitert wurde. Im External I/O-Bereich von 0060h bis 01FFh können die Register aber nur noch mit der üblichen indirekten Adressierung über die Register X, Y und Z erreicht werden, also nicht mehr mit den Befehlen IN und OUT.

Tabelle 5.1 fasst nochmals einige I/O-Register in aufsteigenden Adressfolge zu-sammen.

Name Beschreibung Adresse I/O Adresse Datenspeicher

PINA Pins des Port A 00h 0020h DDRA Data Direction Register A 01h 0021h PORTA Register für Port A 02h 0022h EIFR External Interrupt Flag Register 1Ch 003Ch EIMSK External Interrupt Mask Register 1Dh 003Dh EECR EEPROM Control Register 1Fh 003Fh EEDR EEPROM Data Register 20h 0040h EEARL EEPROM Address Register Low 21h 0041h EEARH EEPROM Address Register High 22h 0042h SPCR SPI Control Register 2Ch 004Ch SPSR SPI Status Register 2Dh 004Dh SPDR SPI Data Register 2Eh 004Eh RAMPZ Extended Z-Pointer Register 3Bh 005Bh SPL Stack Pointer Low Byte 3Dh 005Dh SPH Stack Pointer High Byte 3Eh 005Eh SREG Status Register 3Fh 005Fh WDTCSR Watchdog Timer Control Register - 0060h

Tabelle 5.1 Auswahl einiger I/O-Register in der ATmega8-Familie


5.3 Das Stack-Konzept

Der Zugriff auf die im Kapitel 3 vorgestellten RAM-Bausteine war wahlfrei – da-her auch der Name Random Access. Diese Wahlfreiheit bedeutet, dass die Adres-sierungsreihenfolge beliebig gewählt werden kann.

Andererseits existieren zwei andere Zugriffskonzepte in weiter Verbreitung, die eine zeitliche Reihenfolge des Lese- und Schreibzugriffs erzwingen: FIFO und Stack.

FIFO bedeutet dabei First-In-First-Out. Dieses Prinzip kann mit einer Warte-schlange verglichen werden, bei der sich neu hinzukommende Elemente an das Ende anreihen (Schreibzugriff), während die Abarbeitung am Kopf der Schlange abläuft (Lesezugriff). Hierfür existiert eine Reihe von FIFO-RAM-Bausteinen (obwohl der Name RAM nicht mehr korrekt ist, wird dieser beibehalten), wobei als typische Anwendung die Kommunikation zwischen Prozessoren oder Tasks in Multitaskingsystemen genannt werden können. Ebenso ist eine Softwarerealisie-rung mit Hilfe zweier Datenpointern möglich (Schreib- und Lesezeiger). FIFOs haben den Vorteil, dass sie bei strenger Einhaltung des Konzepts die Daten in exakter (Schreib-)Reihenfolge wieder auslesen lassen.

Im Gegensatz hierzu wird das Stack-Prinzip, im Deutschen Stapel oder Keller-speicher genannt, gewöhnlich nicht durch spezielle Speicherbausteine oder reine Softwarelösung implementiert, sondern als Hardwareteil innerhalb einer CPU. Der Stack arbeitet dabei nach dem LIFO-Prinzip (Last-In-First-Out), das sich mit einem Tellerstapel vergleichen lässt: Lese- und Schreibzugriffe beziehen sich immer auf den obersten Teil des Stapels (Top-of-Stack), der allerdings auch der unterste Teil sein kann, je nach Wachstumsrichtung, Schreibzugriffe auf das nächste freie Element, Lesezugriffe auf das oberste besetzte Element, das damit gleichzeitig für neue Schreibzugriffe freigegeben wird.

Wie jetzt ein Stackkonzept konkret in einer CPU realisiert ist (praktisch hat jede CPU einen Stack, wobei allerdings beträchtliche Größenunterschiede zu verzeich-nen sind), hängt stark von dem Hardwaredesigner ab; so existieren Stacks, die bei Schreibzugriffen zu niedrigeren Adressen hin wachsen (Beispiel: 8086, ATmega8) ebenso wie zu höheren Adressen (8051). Das Stackkonzept wird bei drei Aktionen der CPU stark in Anspruch genommen:

• Unterprogrammsprünge: Die Rücksprungadresse landet auf dem Stack und wird beim Rücksprung wieder in den Programmzähler geladen

• Lokale Variablen: In funktionalen Sprachen wie C, Pascal werden lokale Va-riablen, die also einen beschränkten Gültigkeitsbereich besitzen, auf dem Stack angelegt und somit wieder verworfen, wenn es zu einem Rücksprung aus der Routine kommt.


• Interrupt Requests: Sowohl die Rücksprungadresse nach Behandlung der IRQs als auch (falls erforderlich) gerettete Registerinhalte und das Prozessorstatus-register werden auf dem Stack gelagert.

Beim ATmega8 existiert ein Stackpointer (SP) mit 16-Bit Breite (→ 5.1), dessen Ziel immer eine Stelle im RAM ist. Der Zeiger muss in jedem Fall auf einen Wert oberhalb 0200h zeigen, weil ansonsten in die I/O-Register geschrieben bzw. aus denen gelesen werden würde. Außerdem muss er auf einen so hohen Startwert ge-setzt werden, dass auch im Betrieb die Grenze 0200h nicht erreicht wird (der Stack „wächst“ nach unten). Der bei Reset angenommene Initialwert beim AVRme-ga2560 ist 21FFh, also genau das oberste Element des internen RAM-Datenspei-chers (→ Bild 5.3).

Bild 5.4 Stackoperationen PUSH und POP

Bild 5.4 zeigt die Funktionsweise des Stacks beim ATmega8: Bei einem Schreib-zugriff (PUSH) wird der Inhalt des Quellregisters, hier 55h in R5) in die durch SP adressierte Speicherzelle kopiert und dann der momentane SP-Inhalt um 1 dekrementiert (Post-Decrement); bei einem Lesezugriff (POP) SP um 1 inkrementiert (Pre-Increment) und dann der durch SP adressierte Speicherinhalt (hier: 55h) in das Zielregister (hier: R4) kopiert.


5.4 Die Adressierungsmodi

Bevor die Assemblernotation behandelt wird, müssen die Adressierungsmodi der ATmega8-CPU (und im Allgemeinen) näher betrachtet werden. Dies erfolgt vorab, da viele Maschinenbefehle, insbesondere die Speichertransferbefehle mit diversen (aber durchaus nicht allen) zulässig sind.

Die Modi können im Allgemeinen in Modi für Datenbefehle und solche für Kontrollflussbefehle unterschieden werden.

5.4.1 Adressierungsmodi für Datenoperationen

Unmittelbare Adressierung (immediate addressing) Es muss auf eine Weise möglich sein, konstante Werte in Register oder auch Speicher zu laden. Konstant heißt in diesem Fall, dass der Wert zur Übersetzungs-zeit (Compile Time) bekannt ist und somit der Wert der Konstanten im Programm-speicher speicherbar ist

LDI R4, 47h: R4 ← 47h (load immediate)

lädt den Wert 47h (dezimal 71) in das Register R4. Die Adressierungsart unmittelbar wird an dieser Stelle nicht extra gekennzeichnet (wie z.B. durch ein ’#‘), sondern sie ist implizit durch den Befehl (LDI, load immediate) gegeben.

Register-direkte Adressierung (register direct addressing) Es ist ein Kennzeichen von RISC-Architekturen für Prozessoren, dass die Opera-tionen möglichst immer auf Operanden wirken, die im Register stehen. Dies ist darin begründet, dass die Ausführung dann besonders schnell sein kann, weil die Operanden schon in der CPU vorliegen (selbst der interne Speicher ist langsamer als die Register.

In der Variante für die Adressierung nur eines Registers wird dementsprechend nur ein Register adressiert, was bei 32 Registern eine Minimaladressierung in 5 Bits ergibt. Ein Beispiel für eine Operation, die nur einen Operanden benötigt, ist der Inkrement-Befehl (INC): Das Ergebnis wird in das gleiche Register geschrieben.

INC R3: R3 ← (R3) + 1 (increment)

Für die meisten arithmetischen und logischen Operationen wird jedoch ein 3-Adressformat benötigt: 2 Quellen werden zu einem Ergebnis miteinander ver-knüpft. Dies in den Befehlssatz mit einer überwiegend 16 bit großen Instruktions-codierung einzufügen wäre allerdings unmöglich, da für die Adressierung dreier Register bereits 15 bit benötigt werden. Daher ist bei der ATmega8-Familie „nur“ die Register-direkte Adressierung mit 2 Registern vorhanden, so dass das zuerst angegebene Register zugleich 1. Operand als auch das Zielregister ist.

ADC R4, R5: R4 ← (R4) + (R5) + (Carry) (add with carry)


Speicher-direkte Adressierung (direct data addressing) Die Speicher-direkte Adressierung liegt quasi auf der Hand, werden Variablen doch im Speicher gehalten und über ihre Speicheradresse identifiziert. Dennoch ist gerade diese Adressierungsart zwar fast immer implementiert, aber durchaus verzichztbar.

Das Format ist einfach: Die Speicheradresse wird im Befehl als Konstante mit einer Größe von 16 Bit angegeben. Damit wird das einfache Befehlsformat von 16 Bit garantiert überschritten, der Befehl mit dieser Adressierung wird in 32 Bit codiert und dementsprechend auch langsamer abgearbeitet.

LDS R7, 1234h: R7 ← (1234h) (load direct from data space)

Das eigentliche Problem ist aber nicht die 32-bit-Codierung, sondern die Tatsache, dass auf diese Weise zwar skalare Variable (und natürlich einzelne Elemente aus Arrays) sehr gut adressiert werden können, aber keine Arrays im Allgemeinen, also z.B. mit einer variablen Indizierung, weil hier eine Adressrechnung notwendig ist.

i nt array[1024] , k, x; … if( x > 1024) x = 1024; else if( x < 0 ) x = 0; for( k = 0; k < x; k++ ) { array[k] = 0; }

Bild 5.5 Beispiel für Array-Indizierung mit variablem Ende

Das Beispiel in Bild 5.5 zeigt das Dilemma: Der Compiler weiß zur Übersetzungs-zeit nicht, bis zu welcher Grenze das Array mit 0 initialisiert wird – dies ist erst zur Laufzeit möglich, und zur Ausführung ist die Speicher-direkte Adressierung nicht geeignet.

I/O-Direkte Adressierung (I/O direct addressing) Die I/O-direkte Adressierung stellt eine Sonderform der Speicher-direkten Adres-sierung dar, indem eine auf 6 Bit verkürzte Adresse genommen wird. An dieser Stelle ist die direkte Adressierung wiederum sehr sinnvoll, denn die I/O-Register können nicht sinnvoll in einem Array verwaltet werden, sie werden immer mit konstanten Adressen adressiert.


IN R2, 3Fh: R2 ← (3Fh) (load an I/O location to register)

ist ein Beispiel hierfür: Der Inhalt von dem I/O-Register 3Fh (Statusregister) wird in R2 kopiert.

Daten-indirekte Adressierung (data-indirect) Die Register X, Y und Z, aus jeweils zwei General-Purpose-Registern (R26 .. R31) zusammengesetzt und 16 bit breit, wurden für eine indirekte Adressierung konzipiert. Diese Register enthalten also eine Adresse im Datenbereich, und beim Zugriff wird diese Adresse dann gewählt. Die Adressierung ist also indirekt, da die Adresse des Registers, das die Adresse enthält, angegeben wird.

ST X, R17: (X) ← (R17) (store indirect to memory)

zeigt ein Beispiel für diese Adressierung.

Eine Variante hiervon ist die Adressierung des Programmspeichers mithilfe der Befehle LPM und SPM (Load|Store Program Memory). Diese nutzen nur das Z-Register.

Daten-indirekte Adressierung mit Post-Inkrement oder Prä-Dekrement (data-indirect with post-increment or pre-decrement) Die indirekte Adressierung lässt sich auf mehrere Weisen erweitern; eine davon ist die Adressierung mit Veränderung der Zeiger, um z.B. auf das nächste Element eines Arrays zu zeigen. Die wirkt für viele Algorithmen sehr beschleunigend und wird u.a. in Digitalen Signalprozessoren häufig genutzt.

LD R13,–X: X ← X – 1 (load indirect from memory with pre-decrement) R13 ← (X)

und

ST Z+, R13: (Z) ← R13 (store indirect to memory with post-increment) Z ← Z + 1

sind Beispiele hierfür. Bitte beachten Sie die Reihenfolge der Operationen. Die Erzeugung solcher Adressierungen im Assemblerprogramm durch einen Compiler erweist sich im Übrigen als sehr schwierig.

Eine solche Adressierung liegt auch bei den Befehlen PUSH und POP, die Register zum/vom Stack kopieren, vor.

Daten-indirekte Adressierung mit Offset (data-indirect with displacement) Die andere Variation besteht in der Einfügung eines konstanten Offsets bei der Adressbildung. Dies ist nur mit den Registern Y und Z möglich, die effektive Adresse wird dann durch Addition des jeweiligen Registerinhalts und des Offsets (6 bit Breite, maximal 63 Adressen) gebildet.

STD Y+q, R6: ((Y)+q) ← R6 (store with displacement)

ist ein Beispiel hierfür.


5.4.2 Adressierungsmodi für Kontrollflussbefehle Bei der Adressierung für Kontrollflussbefehle wie JUMP oder CALL gibt es 3 verschiedene Adressierungsarten: Direkt (auch als absolut bezeichnet), indirekt (präzise: absolut indirekt) und relativ.

Absolute Adressierung (direct program addressing) Bei der absoluten Adressierung wird dem Program Counter – das ist das Register, das im Mikroprozessor anzeigt, wo sich das Programm genau befindet – auf den im Befehl angegebenen Wert gesetzt. Die Adressrechnung selbst erfolgt dabei im Assembler bzw. Compiler, bei der Programmentwicklung wird mit symbolischen Adressen („Label“) gearbeitet.

Die maximale Sprungweite beträgt bei der ATmega8-Familie 22 Bit. Die vollstän-dige Angabe einer Adresse bewirkt, dass solche Befehle in 32 bit codiert werden müssen.

Absolut indirekte Adressierung (indirect program addressing) Im Fall der indirekten Adressierung wird wie bei der Daten-indirekten Adressie-rung ein 16-bit-Register verwendet, in diesem Fall das Z-Register. Der Inhalt dieses Register wird in die Bits 0 bis 15 des Program Counters kopiert, die ggf. vorhandenen restlichen Bits bleiben unverändert.

Die absolut-indirekte Adressierung wird bei den Befehlen IJMP und ICALL ge-nutzt.

Relative Adressierung (relative program addressing) Anstelle der absoluten Adressierung von Sprungzielen im Programmspeicher kann eine relative, besser PC-relative Adressierung genutzt werden. Um den momen-tanen Wert des Program Counters kann damit um bis zu +2047 oder -2048 Bytes gesprungen werden, wobei die Berechnung des richtigen (relativen) Sprungwerts zumeist das Assemblerprogramm bemüht werden sollte. Befehle, die diese Adressierung nutzen, sind RJMP und RCALL.

Neben der kürzeren Codierung (16 statt 32 bit) sind Programme, die ausschließlich die relative Adressierung nutzen, relokatibel, d.h., sie können an jeder Stelle im Programmspeicher ausgeführt werden.

Für die Verzweigungsbefehle (branch instructions) existiert eine verkürzte Vari-ante der relativen Adressierung, die eine Verzweigung um –64 .. +63 erlaubt. Diese Form ist für alle Branch-Befehle implementiert.


5.5 Die Assemblernotation für die ATmega8-Familie

Die ATmega8-Familie bietet sieben Gruppen von Assemblerbefehlen, die in den folgenden Abschnitten behandelt werden sollen: Transferbefehle, Bitverarbeitungs-befehle, Logische Verknüpfungen, Arithmetische Befehle, Sprungbefehle, Unter-programmbefehle und sonstige Befehle.

Alle Befehle haben eine einheitliche Syntaxgrundstruktur:

Befehls-Mnenomic Ziel [, Quelle] wobei unäre Befehle natürlich nur das Ziel angeben.

5.5.1 Transferbefehle In der Gruppe der Transferbefehle sind folgende Befehle zusammengefasst:

• MOV Kopie eines Registerinhalts in ein anderes Register

• MOVW Kopie des Inhalts eines Registerpaars in ein anderes Registerpaar

• LDI Load Immediate (unmittelbare Adressierung) in Register

• LDS Load from Data Space (direkte Adressierung) in Register

• LD Load Indirect (indirekte Adressierung) in Register

• LDD Load Indirect with Displacement (mit Offset) in Register

• STS Store to Data Space (direkte Adressierung) from Register

• ST Store Indirect (indirekte Adressierung) from Register

• STD Store Indirect with Displacement (mit Offset) from Register

• LPM Load from Program Memory (indirekte Adressierung) in Register

• ELPM Extended Load from Program Memory (indirekte Adressierung) in Register

• SPM Store in Program Memory (indirekte Adressierung) from Register

• IN In from I/O-Location (direkte Adressierung) in Register

• OUT Out to I/O Location (direkte Adressierung) from Register

• PUSH Push Register on Stack (indirekte Adressierung)

• POP Pop Register from Stack (indirekte Adressierung)

• XCH Exchange between Memory and Register (indirekte Adressierung)

• LAS Load and Set (indirekte Adressierung) in Register

• LAC Load and Clear (indirekte Adressierung) in Register

• LAT Load and Toggle (indirekte Adressierung) in Register

• SWAP Swap Halfbytes (Nibbles) in Register


5.5.2 Bitverarbeitungsbefehle Die ATmega8-Familie bietet die Möglichkeit, Einzelbit zu adressieren und zu manipulieren. Dies ist auf einige Bereiche beschränkt, da es im Umgang mit gewöhnlichen Variablen nicht von Nutzen ist, wohl im Bereich der Flags im Statusregister (→ 5.1) und im I/O-Bereich (→ 5.2).

Die Bitmanipulationsbefehle, die zur Verfügung stehen, sind dann:

• BSET für Setzen eines Flags (die Flag-Nummer als konstanter Operand)

• BCLR für Löschen eines Flags (die Flag-Nummer als konstanter Operand)

• BST Bitstore, speicher Bit vom Register in T

• BLD Bitload, lade T-Bit in Register

• SEC Set Carry Flag

• CLC Clear Carry Flag

• SEN Set Negative Flag

• CLN Clear Negative Flag

• SEZ Set Zero Flag

• CLZ Clear Zero Flag

• SEI Set Global Interrupt Flag

• CLI Clear Global Interrupt Flag

• SES Set Sign Flag

• CLS Clear Sign Flag

• SEV Set Overflow Flag

• CLV Clear Overflow Flag

• SET Set T-Flag

• CLT Clear T-Flag

• SEH Set Half Carry Flag

• CLH Clear Half Carry Flag

• SBI Set Bit in I/O-Register

• CBI Clear Bit in I/O-Register

• CLR Clear Register

• SER Set Register (0FFh)

• SBR Set Bit in Register

• CBR Clear Bit in -Register


5.5.3 Befehle zur logischen Verknüpfung Als Befehle zur logischen Verarbeitung können

• das logische UND via AND und ANDI (AND immidiate),

• das logische ODER via OR und ORI,

• das logische EXKLUSIV-ODER via EOR (nicht EORI!),

• das Einer-Komplement via COM,

• das Zweier-Komplement via NEG (→ 2.3.3.2),

• der Rotationsbefehl mit Carry links ROL,

• der Rotationsbefehl rechts mit Carry ROR,

• der Logische Shift links LSL,

• der Logische Shift rechts LSR und

• der Arithmetische Shift rechts ASR

angewendet werden.

Der Unterschied zwischen dem logischen und dem arithmetischen Shift nach rechts liegt in der Behandlung des höchstwertigen Bits. Beim logischen Shift wird immer in die Stelle, die beim Schieben keinen Nachbarn hat, eine ’0‘ hineingeschoben. Beim arithmetischen Shift rechts macht man das nicht, sondern es wird das höchstwertige Bit, das ja zugleich das Vorzeichenbit sein kann (→ 2.3.3.2), in sich kopiert.

5.5.4 Arithmetische Verarbeitungsbefehle Die Arithmetik in den Prozessorbefehlen wurde bei der8031/51-Architektur durch Befehle zur Addition, Subtraktion, Multiplikation und Division sowie zum Inkre-ment, Dekrement und zur Justierung bei BCD-Zahlen implementiert.

Im Einzelnen gibt es die arithmetischen Befehle

• Addition ohne Berücksichtigung des Carrys ADD

• Addition mit Berücksichtigung des Carrys ADC

• Addition einer Konstanten zum Wort (16 Bit) ADIW

• Subtraktion ohne Berücksichtigung des Carrys SUB

• Subtraktion mit Berücksichtigung des Carrys SBC

• Subtraktion einer Konstanten ohne Carry SUBI

• Subtraktion einer Konstanten mit Carry SBCI

• Subtraktion einer Konstanten von einem Wort SBIW

• Inkrement eines Registers INC

• Dekrement eines Registers DEC


• Test eines Registers auf Zero oder negativ TST

• Multiplikation (unsigned) MUL

• Multiplikation (signed) MULS

• Multiplikation (signed * unsigned) MULSU

• Fractional Multiplikation (unsigned) FMUL

• Fractional Multiplikation (signed) FMULS

• Fractional Multiplikation (signed * unsigned) FMULSU

• Data Encryption DES

Zu diesen Befehlen seien hier einige Erläuterungen gegeben:

● Bei der Subtraktion wird das Carry-Bit wie bei der Addition verwendet (und nicht als Borrow Carry). Dies bedeutet, dass ein gelöschtes Carry am Eingang keinen Übertrag anzeigt.

● Die Multiplikation zweier 8-bit-Zahlen ergibt im Allgemeinen eine 16-bit-Zahl – unabhängig vom Vorzeichen. Das Ziel der Multiplikationen ist immer das Registerpaar R1:R0.

● Die Fractional Multiplication bezieht sich auf das Q1.7-Format (→ [Sie12, Kap. 9.2.4]), indem die Festkommazahl als eine mit 1 Stelle vor dem Komma und 7 dahinter interpretiert wird. Nach der Multiplikation ist das Ergebis im Format Q2.14 und wird dann auf Q1.14 „normiert“ wird. Diese Befehle sind speziell für Signalverarbeitungsalgorithmen geeignet.

● Der Data Encryption Standard Befehl (DES) benötigt den Schlüssel (64 bit) in den Registern R8 .. R15 und den Text in r= .. R7. Insgesamt sind 16 Runden entsprechend 16 DES-Befehlen zu absolvieren.

Zu den arithmetischen befehlen müssen auch die Vergleichsinstruktionen gezählt werden, die wie eine Subtraktion wirken, aber lediglich die Flags für nachfolgende Verzweigungen setzen:

• Compare (2 Register) CP

• Compare with Carry (2 Register) CPC

• Compare with Immediate (Register/Konstante) CPI

• Compare and Skip if equal (2 Register) CPSE

Der letzte Befehl überspringt die nachfolgende Instruktion, wenn das Vergleichser-gebnis Null ergibt, die beiden Operanden in den Registern also gleich sind.

5.5.5 Sprungbefehle Sprungbefehle verändern den Inhalt des Program Counters, so dass die CPU den nächsten Befehl nicht mehr an den konsekutiven Stelle im Programmcode, sondern an einer beliebigen anderen lädt und ausführt. Derartige Sprungbefehle lassen sich in zwei Kategorien unterteilen, unbedingte und bedingte Sprungbefehle.


Als unbedingte Sprungbefehle, meist auch als Jumps bezeichnet, gestattet die ATmega8-Architektur die Benutzung der Befehle

• Jump (absolut) JMP

• Jump relativ RJMP

• Jump indirekt IJMP und

• Jump indirekt erweitert EIJMP,

die sich durch Sprungweite und Adressierungsart unterscheiden.

JMP bietet ein Springen innerhalb des gesamten Adressraums des Programm-speichers an. Die Sprungadresse wird in den PC geladen. Dieser Befehl dauert 3 Takte Ausführungszeit.

RJMP besitzt die relative Adressierung (→ 5.4) und setzt den Wert des PC auf PC + K + 1 mit K als die angegebene relative Sprungweite. K kann die Werte von -2048 bis +2047 annehmen, die Addition erfolgt vorzeichenerweitert. Es werden 2 Takte Ausführungszeit benötigt.

IJMP setzt den PC auf den Wert, der in Z steht. Der PC wird also in den unteren 16 Bit geändert, der Befehl benötigt ebenfalls 2 Takte Ausführungszeit.

EIJMP erweitert die Sprungweite auf maximal 22 Bit, indem die unteren 6 Bits des im Basis-I/O-Bereich angesiedelten Registers EIND (Extended Indirect, Adres-se 03Ch/05Ch) mit in den PC kopiert werden. Auch hier beträgt die Ausführungs-zeit nur 2 Takte.

Die bedingten Sprungbefehle, häufig auch als Branch (Verzweigungen) bezeich-net, sind in der ATmega8-Architektur alle mit verkürzter relativer Adressierung, d.h. mit Sprungzielen im Bereich -64 bis +63 Words (der Programmspeicher wird mit 16 bit adressiert), ausgeführt. Folgende Instruktionen sind hier verfügbar:

Skipbefehle überspringen abhängig vom jeweiligen Testfall den nächsten Befehl oder nicht. Hierzu wird jeweils ein Bit getestet, folgende Befehle fallen in diese Kategorie:

● SBRC (Skip if Bit in Register is Cleared)

● SBRS (Skip if Bit in Register is Set)

● SBIC (Skip if Bit in I/O-Register is Cleared)

● SBIS (Skip if Bit in I/O-Register is Set)

Die zweite Gruppe stellt die “echten” Branch-Befehle dar:

● BRBS (Branch if Status Flag Set)

● BRBC (Branch if Status Flag Cleared)

● BREQ (Branch if Zero-Flag Set)

● BRNE (Branch if Zero-Flag Cleared)

● BRCS (Branch if Carry-Flag Set)

● BRCC (Branch if Carry-Flag Cleared)


● BRSH (Branch if Same or Higher)

● BRLO (Branch if Lower)

● BRMI (Branch if Minus)

● BRPL (Branch if Plus)

● BRGE (Branch if Greater or Equal, signed)

● BRLT (Branch if Less than, signed)

● BRHS (Branch if Half-Carry-Flag Set)

● BRHC (Branch if Half-Carry -Flag Cleared)

● BRTS (Branch if T-Flag Set)

● BRTC (Branch if T-Flag Cleared)

● BRVS (Branch if Overflow-Flag Set)

● BRVC (Branch if Overflow-Flag Cleared)

● BRIE (Branch if Global Interrupt Enabled)

● BRID (Branch if Global Interrupt Disabled)

5.5.6 Unterprogrammbefehle Unterprogramme werden zumeist durch CALL-Befehle angesprungen und durch Return-Befehle wieder an die der aufrufenden Programmstelle folgende Stelle verlassen. Dies findet seinen Niederschlag in der ATmega8-Architektur durch fol-gende Befehle:

• CALL (absolut) für Unterprogrammaufrufe innerhalb des gesamten Pro gramm-Adressraums

• RCALL (relativ) für Unterprogrammaufrufe innerhalb -2048 .. +2047 Pro grammstellen

• ICALL (indirekt) für Unterprogrammaufrufe innerhalb des gesamten 16-bit- Adressraums

• EICALL (indirekt erweitert) für indirekte Unterprogrammaufrufe innerhalb des gesamten Programmspeichers

• RET für die Rückkehr aus dem Unterprogramm

• RETI für die Rückkehr von Interrupt-Service-Routinen.

Unterprogramme nutzen den Stack für die Speicherung der Rückkehradresse. Dies geschieht so, dass der Program Counter Inhalt als 2 Bytes, bei einer PC-Weite > 16 Bit 3 Bytes, auf den Stack kopiert und dann der Stackpointer, zwei I/O-Register an den Adressen 3Dh/3Eh, dekrementiert wird. Beim RET-Befehl wird dieser Vorgang umgekehrt, allerdings muss der Stackpointer dann auch korrekt auf die Rücksprungadresse zeigen.


5.5.7 Sonstige Befehle Die Gruppe der sonstigen Befehle ist beim ATmega8 schon recht ansehnlich. Neben dem allgemein bekannten Befehl:

NOP (No Operation)

dessen Sinn liegt in der Veränderung der Ablaufdauer eines Programms liegt, also zum Beispiel im Schaffen von Schleifen mit einer bestimmten Laufzeit, existieren noch:

● BREAK: Dieser Befehl dient zum Debugging und stoppt die Ausführung eines Programms.

● SLEEP: Dieser Befehl versetzt den Mikrocontroller in einen so genannten Sleepmodus. Darunter versteht man, dass Programmausführung und z.T. auch die Taktversorgung abgeschaltet wird, bis ein aufweckendes Ereignis eintritt. (→ [Sie12, Kap. 5.2.3])

● WDR: Dieser Watch-Dog Reset ist ein spezieller Befehl, der einen Watchdog-Timer zurücksetzt und damit den Überwachungszyklus von Neuem startet.

6 Serielle und parallele Interfaces in Mikrorechnern

6.1 Einleitung und Unterteilung

Die so genannten peripheren Elemente, die sich gemäß dem klassischen Schema des von-Neumann-Rechners im Ein- und Ausgabebereich befinden, sind für die individuelle Gestaltung eines Computersystems von großer Wichtigkeit. Der Un-terschied im Umgang mit Speicherbausteinen einerseits und der Ein- und Ausgabe andererseits macht sich dadurch bemerkbar, dass Speicherbausteine bzw. der Speicher selbst zwar ein eigenständiger, aber in sich abgeschlossener Teil mit Zugang zum bzw. vom Mikroprozessor darstellt.

Peripheriebausteine oder Peripherieelemente hingegen schaffen Schnittstellen oder Interfaces zwischen dem Mikroprozessor einerseits und einer (fast) belie-bigen Außenwelt andererseits mit eigenständigem Verhalten, anderen Geschwin-digkeiten, neuen Signalpegeln oder auch nicht-elektrischen Größen usw.

Periphere Elemente haben daher die Aufgaben,

• zeitliche Verhaltensweisen und/oder

• Signalgrößen

zwischen Rechnersystem und Außenwelt anzupassen.

Diese Aufgabe ist sehr weit gespannt, womit bereits klargestellt ist, dass es eine große Anzahl an Peripheriebausteinen geben muss. Während in den 1970er und 1980er Jahren auf Mikroprozessor/Peripheriebaustein-Kombinationen auf dem Board gesetzt wurde, ist seitdem der Trend eher zu System-on-a-Chip zu verzeich-nen, was einfach bedeutet, dass nunmehr alle benötigten Schnittstellen möglichst auf dem Chip des Mikrocontrollers enthalten sind.

Daneben sei die Definition eines Mikrocontrollers gegeben: Ein Mikrocontroller besteht aus einem Mikroprozessor mit – auf dem Chip integriert – Speicher und/oder Peripherie.

Ohne Anspruch auf Vollständigkeit seien folgende Klassen von Peripherieelemen-ten aufgezählt:

● General-Purpose-Interfaces (GPIO, General-Purpose Input/Output): Werte wer-den nach außen hin statisch ausgegeben (Output), bis das Programm sie ändert, oder sie können im Programm eingelesen werden (Input). GPIOs besitzen keinerlei weitere Funktionalität.

● Interfaces zum Einlesen oder Ausgeben von analogen Werten. Hierzu zählen Analogue-Digital Converter (ADC) sowie Digital-Analogue Converter (DAC).


● Kommunikationsinterfaces: Meist (aber nicht ausschließlich) auf bit-serieller Basis werden Bytes, Word oder auch ganze Datenpakete in einem vordefinier-ten Protokoll ausgesendet (transmit) oder empfangen (receive). Das Interface beinhaltet also eine Schnittstelle zum Prozessor hin und eine zu einem Netz-werk oder exklusiven Kommunikationsleitung, die Kommunikation kann die ISO-Schichten 1 und 2, in Ausnahmefällen sogar mehr beinhalten.

● Interfaces zur Zeitmessung oder Taktgebung (auch Zeitgebung): Die so genann-ten Timer sind das Standard-Interface zur physikalischen Größe Zeit.

● Interfaces zur unmittelbaren Signalisierung von Zuständen der Außenprozesse. Durch dieses Interface können außenliegende Teile, die also der Umgebung zuzurechnen sind, ebenso wie innenliegende Teile dem Prozessor ein Signal übermitteln, um eine Synchronisierung mit dem Programm (im Ganzen) zu erzeugen.

● Spezialbausteine wie die Ansteuerung von Schrittmotoren, LC-Displays etc.

In diesem Kapitel werden die General-Purpose, die Kommunikations-Interfaces so-wie die Timer behandelt. Abschließend wird der Interrupt Request als Methode zur Synchronisation behandelt und hierfür natürlich der Interrupt Request Controller.

6.2 General-Purpose Interfaces

Stellvertretend für eine Vielzahl von parallelen ICs (letztlich kann auch ein 74xx373 aus der im Allgemeinen bekannten 74-Bausteinfamilie als paralleler Interfacebaustein eingesetzt werden) wird in diesem Kapitel der parallele Input/Output-Baustein (8255, PIO) sowie die im ATmegaXXX integrierten GPIO-Elemente vorgestellt. Die Wahl fiel nicht zuletzt deswegen auf diese Elemente, weil moderne Mikrocontroller viele eingebaute GPIO-Pins aufweisen, andererseits auf den 8255, da die Einsatzhäufigkeit gerade dieser ICs in Mikroprozessorsys-temen immer noch hoch ist. Im Übrigen wurde dieser Baustein bereits im Kapitel 4.4 benutzt.

6.2.1 GPIOs im ATmegaXXX Der tatsächliche Aufbau der einfachsten Zelle im Peripheriebereich, der General-Purpose Input/Output-Zelle (GPIO) ist dann doch etwas komplexer als zunächst angenommen. Bild 6.1 zeigt eine 1-bit-Zelle dieses Typs, wie sie im ATmega2560 vorkommt.

Die dabei gemachten Vereinfachungen betreffen die Synchronisation im Input-zweig – hier wird noch ein weiteres Latch genutzt, um „saubere“ Signal nach innen verfügbar zu haben –, die Pullup- bzw. Pulldown-Widerstände sowie das Verhalten im Sleep-Modus. Der Sleep-Modus ist ein besonderer Betriebsmodus von Mikro-controllern, bei dem ein Großteil der Hardware in einen sehr Energie-sparsamen Modus geschaltet wird. Näheres hierzu siehe [Sie12, Kap. 5].

6 Serielle und parallele Interfaces in Mikrorechnern 83

Pin

D Q

Q D

Q D

Interner Datenbus

WrClock_DDRx

WrClock_PINx

RdClock_PINx

RdEnable_PINx

PINx_Register

DDRx_Register

RdEnable_DDRx

Output-Zweig

Input-Zweig

Bild 6.1 Aufbau einer GPIO-Zelle (vereinfacht)

Jeder I/O-Port ist zu 8 bit Breite organisiert, wobei im Einzelfall weniger Bits herausgeführt sind, etwa, weil einige Pins in ihrer Zweitfunktion gebraucht werden oder die Anzahl der externen Anschlüsse begrenzt ist. Zu jedem Asnchluss des I/O-Ports gehört dann obige, in Bild 6.1 dargestellte Struktur.

Das Data Direction Register (DDR) definiert für jeden Anschluss, ob er als Input- oder Output genutzt wird: Eine ’1‘ bedeutet einen Output, eine ’0‘ einen Input. Bei Konfiguration als Output wird der Ausgangsverstärker eingeschaltet, und der aktuelle gespeicherte binäre Wert wird belastbar am Ausgang sichtbar.

Der Terminus belastbar muss kurz erläutert werden. Bild 6.2 zeigt einen Inverter in CMOS-Technologie. Ein MOS-Transistorpaar, je ein P- und ein N-Kanal, werden von einem Steuersignal angesteuert, dass bei ’0‘ den P-Kanal-Transistor


öffnet und den N-Kanal schließt, bei ’1‘ entsprechend umgekehrt. Somit imple-mentiert dieses Gate die logische Gleichung X = /A.

A X

T1

T2

P-Kanal

MOSFET

N-Kanal

MOSFET

R

Bild 6.2 Inverter in CMOS-Ausführung

Nun werden an X sicher ein oder mehrere weitere Systemteile angeschlossen, in Bild 6.2 durch den gestrichelten Widerstand R dargestellt. Wird also T1 leitfähig, T2 geschlossen, dann bilden T1 und R (genau genommen T2 || R) einen Span-nungsteiler, durch den ein Strom fließt und der über T1 eine Spannung abfallen lässt. Mit wachsendem Strom sinkt also die Ausgangsspannung an X, und die Belastbarkeit ist erreicht, wenn die Spannung an X soweit angefallen ist, dass der für ’1‘ gültige Spannungsbereich verlassen wurde.

A X

T1

T2

P-Kanal

MOSFET

N-Kanal

MOSFET

≥1

&

Enable

Bild 6.3 Inverter mit Tristate-Beschaltung


Bild 6.3 zeigt nun den gleichen Inverter mit zusätzlichem 3. Zustand, als High Impedance oder auch High-Z, kurz Z bezeichnet. Dieser Tristate bedeutet einfach, dass keiner der beiden Transistoren leitend ist, beide sperren, so dass der elektrische Wert an dem Ausgang X von Seiten des Inverters unbestimmt ist. Dieser Zustand wird angenommen, wenn das Enable-Signal den Wert ’0‘ annimmt.

Konsequenzen für die Software Für die Software bedeuten die Eigenschaften der GPIO-Anschlüsse, dass zunächst die Richtung im Data Direction Register definiert werden muss. Wurde hier ein Eingang definiert, so kann man von Seiten der Software zwar gerne etwas in das GPIO-Register selbst schreiben, das bleibt aber ohne Auswirkung. Der lesende Zugriff auf das GPIO-Register, der physikalisch auf ein anderes Register als der schreibende Zugriff zielt, spiegelt dann den aktuellen Zustand am Eingang wieder.

Bei einem Ausgang zeigt dieser den logischen Wert des GPIO-Registers in phy-sikalischer Form (Spannung). Jetzt wirkt das Schreiben in ein GPIO-Register unmittelbar, beim Lesen jedoch wird der physikalische Zustand erneut eingelesen, was zwar dem logischen Zustand im Ausgangsregister entsprechen sollte, aber z.B. durch einen Kurzschluss verändert sein könnte.

6.2.2 Der Parallel-Input-Output-Baustein 8255 Neben bereits integrierten GPIO-Elementen sind auch externe Bausteine mit einem ähnlichen Verhalten verfügbar. Diese Bausteine müssen dann mit dem Mikrocontroller/Mikroprozessor per Bussystem verbunden werden (siehe Kapitel 4.4) und arbeiten dann ähnlich wie die integrierten Elemente.

Der wohl bekannteste Vertreter ist die PIO-Baustein 8255 (Parallel Input/Output). Bild 6.3 zeigt die Pinkonfiguration des 8255 sowie der dazu kompatiblen 82C55 und 82C55A, Bild 6.4 die interne Blockstruktur:

Das Interface zum Prozessorsystem wird durch die Anschlüsse D0 bis D7, also dem Datenbus, A1 und A0, zwei Adressbits, so dass 4 interne Adresse ange-sprochen werden können, dem Selektierungssignal /CS, das den 8255 überhaupt aktiv zur Mikroprozessorseite hin schaltet, den Datenbusrichtungsanzeigen /RD und /WR und dem Reset-Signal geschaffen. Eine korrekte Verschaltung mit dem Mikroprozessor wird daher Daten- und Adressbusbits (nahezu) direkt am Mikro-prozessor anschließen, /RD und /WR sowie Reset ebenfalls, während /CS aus den übrigen Adressen des Mikroprozessors generiert werden muss (Adressdekodie-rung).


123456789

1011121314

282726252423222120

1918171615

PA1PA0

PA2PA3

/RD

D5D6D7

PC6

GND

PC5

VCC

/WRRESET

PC7

2930

40393837363534333231

/CS

PC4

A1A0

PC2PC1

PC3

PC0

PB2PB1PB0

PB6PB5

PB7

PB4PB3

PA6PA7

PA5PA4

D3D4

D0D1D2

Bild 6.3: Pinkonfiguration des 8255 (82C55, 82C55A)

I/O PA7 bis PA0

GruppeA

Port A(8)

I/O PC7 bis PC4

GruppeA

Port C

(4)(upper)

I/O PC3 bis PC0

GruppeB

Port C

(4)

I/O PB7 bis PB0

GruppeB

Port B

(8)

(lower)

GruppeA

Control

GruppeB

Control

Read/Write

ControlLogic

/RD

Reset

A0

A1

/WR

/CS

D0-D7

InternerDatenbus

Daten-bus

Treiber

Bild 6.4 Blockschaltbild des 8255


Die Peripherieseite des 8255 weist drei Ports, A, B und C auf, die zu 2 Gruppen zusammengefasst sind. Prinzipiell lassen sich also 24 I/O-Leitungen, die alle von-einander unabhängige (TTL-)Pegel führen können oder als Inputleitungen externe (digitale) Pegel aufnehmen können, mit dem 8255 betreiben.

Für den/die Softwaretechniker/in ist das Programmiermodell des 8255 ausschlag-gebend, da die dort aufgeführten Register durch die Software angesprochen werden können und den Baustein konfigurieren bzw. In- und Outputs am 8255 sich in diesen Register spiegeln. Die Tabelle 6.1 gibt für die Buskontrollbits A0, A1, /RD, /WR und /CS wieder, welche interne Operation sich im 8255 dahinter verbirgt.

A0 A1 /RD /WR /CS Operation 0 0 0 1 0 Input von Port A (-> Datenbus) 1 0 0 1 0 Input von Port B (-> Datenbus) 0 1 0 1 0 Input von Port C (-> Datenbus) 1 1 0 1 0 Controllword wird ausgelesen 0 0 1 0 0 Output in Port A (Datenbus -> Port A) 1 0 1 0 0 Output in Port B (Datenbus -.> Port B) 0 1 1 0 0 Output in Port C (Datenbus -> Port C) 1 1 1 0 0 Controllword wird beschrieben X X X X 1 Datenbus in Tristate X X 1 1 0 Datenbus im Tristate

Tabelle 6.1: Operationen im 8255

Die den Ports entsprechenden Register enthalten die Ausgabebits (Port konfiguriert als Output) bzw. die Eingabepegel (Port konfiguriert als Input). Die Konfiguration selbst wird im Kontrollregister an der Adresse Basisadresse + 3 eingestellt. Zu diesem Zweck haben die Bits in diesem Kontrollregister spezielle Bedeutungen, die in Bild 6.5 und anschließend erläutert sind:

Soll ein 8255 konfiguriert werden, so muss im Kontrollwort immer Bit 7 gesetzt sein. Wie man weiterhin der Bild 6.3 entnehmen kann, können die Gruppen A und B einzeln in bestimmte Modi geschaltet werden, die zunächst erklärt werden:

Mode 0 stellt den einfachsten Mode dar. Innerhalb dieses Mode werden alle Lei-tungen entweder als Input oder als Output genutzt, die Konfiguration wird dabei durch die Datenbits D4, D3, D1 und D0 bestimmt. Um also als Beispiel beide Gruppen im Mode 0, Port A und Port B als Outputs, Port C als Input zu konfi-gurieren, muss das Steuerwort

10001001b bzw. 89h

in das Register geschrieben werden, etwa in Form der ATmegaXXX-Assembler-sequenz

LDI R26, 03h LDI R27, 40h LDI R10, 89h


ST Z, R10 ,

wobei natürlich die Basisadresse 4000h nur eine Annahme (siehe auch Kapitel 4.4) ist.

D0D1D3 D2D4D5D7 D6

Port C (lower)1 = Input0 = Output

Port B1 = Input0 = Output

Mode-Selektion0 = Mode 01 = Mode 1

Gruppe B

Port C (upper)1 = Input0 = Output

Port A1 = Input0 = Output

Mode-Selektion00 = Mode 001 = Mode 1

Gruppe A

1X = Mode 2

Mode-Set-Flag1 = aktiv

Bild 6.5 Mode-Definitionsformat im Controlregister

Mode 1 weicht von diesem einfachen Schema weit ab, da nun diejenigen Leitungen des Port C, die zu der jeweiligen Gruppe (A oder B) gehören, nicht mehr als individuelle I/O-Leitungen genutzt werden, sondern als spezielle Handshakelei-tungen. Mode 1 wird durch die Bitwerte


01 (D6/D5) für die Gruppe A bzw.

1 (D2) für die Gruppe B

erreicht. Der Mode 1 bedeutet für die Gruppe A im Einzelnen:

/STB

IBF

INTR

/RD

Daten

Bild 6.6 Signale am 8255 in Mode 1 (Input)

• Ist D4 = 1 gesetzt (Input-Mode ), so wird PC4 zum /STBA-Signal (STroBe, Input), das bei 'LOW' die Eingangssignale an Port A in einem Zwischenspei-cher speichert ('Latch'). Gleichzeitig wird PC5 zum IBFA-Signal (Input Buffer Full, Output), das solange High anzeigt, bis der Zwischenspeicher für Port A wieder ausgelesen wurde. Bild 6.6 zeigt die Signalverläufe, die ideal zum Über-nehmen von Daten mit einem Handshake-Verfahren geeignet sind.

Durch den negativen Impuls an /STB werden die Daten zunächst transparent in das interne Register geschrieben, ab der steigenden Flanke bleiben diese stabil erhalten. Zugleich wird das Signal IBF auf High gesetzt. Ein Lesezugriff (/RD) löscht IBF bei Beendigung und kann zugleich das erneute Übermitteln von Daten signalisieren.

Der INTRA-Ausgang (Interrupt Request, Pin PC3, gehört eigentlich zur Gruppe B) wird auf High gesetzt, wenn /STB und IBF auf high sind und zuvor eine '1' in die Speicherstelle entsprechend dem Bit PC4 geschrieben wurde (so genanntes Interrupt-Enable-Bit). INTR kann dann als Interrupt-Quelle agieren.

Die übrig bleibenden Outputpins PC6 und PC7 können wie in Mode 0 als beliebige Input/Outputpins konfiguriert und genutzt werden (Konfigurationsbit im Controlregister: D3)


• Im Output-Mode (D4 = 0) wird der Pin PC7 zu /OBFA (Output Buffer Full, Output) und Pin PC6 zu /ACKA (Acknowledge, Input) umkonfiguriert, während nun PC5 und PC4 beliebig sind sowie INTRA auf PC3 bleibt.

OBF geht auf den Wert low, wenn die CPU ein Datenbyte in das Port A-Register geschrieben hat, und steigt wieder auf High, wenn das Signal /ACK auf Low geht. Diese Pins lassen sich vorteilhaft mit den Pins /STB und IBF eines zweiten 8255, der in Mode 1 als Input konfiguriert ist, verbinden.

/WR

/OBF

INTR

/ACK

Daten (Port)

Bild 6.7: Signale am 8255 in Mode 1 (Output)

Für Port B gilt entsprechendes, wobei frei konfigurierbare Pins nicht vorhanden sind und sich die verbleibenden Pins so verteilen:

• Im Input-Mode 1 wird PC2 zu /STBB, PC 1 zu IBFB und PC0 zu INTRB. Das Interrupt-Enable-Bit ist nun Bit PC2.

• Im Output-Mode 1 wird PC2 zu /ACKB, PC1 zu /OBFB und PC0 bleibt INTRB.

Der Mode 1 wird als Handshake-Mode zur Datenübertragung eingesetzt.

Der Mode 2 kann nur für Port A unter Verwendung von 5 Leitungen (PC3 bis PC7) des Port C eingerichtet werden. Er dient der Übertragung in bidirektionaler Weise, wird aber aufgrund seiner großen Komplexität in diesem Skript nicht weiter behandelt.

6.2.3 Allgemeine parallele Interfacebausteine Die Benutzung von Latch- oder Register-ICs als Input- oder Output-IC (die Daten-busrichtung ist dabei nicht konfigurierbar, sondern wird im Hardware-Design fest-gelegt!) bietet sich immer dann an, wenn ausschließlich I/Os, die nicht umschaltbar


oder konfigurierbar sein sollen, sondern einem von vornherein festgelegten Zweck dienen, eingesetzt werden sollen.

Bild 6.6 zeigt einen solchen Aufbau als Output-IC, der bei Selektierung durch die Decodiereinheit (hier als GAL ausgeführt) einen Low-Impuls erhält. Die Wahl des ICs (74LS574) als Register, dessen Ausgang sich also mit der positiven Flanke am Clock-Pin (Pin 11) entsprechend den Eingangsdaten einstellt, bedeutet, dass es bei jedem Schreibzugriff der CPU einen Wechsel am Ende dieses Zyklus geben kann. Voraussetzung ist dazu, dass die Eingangsbits in diesem Moment noch stabil anliegen, so dass eventuelle Laufzeitbedingungen des Registers nicht verletzt werden.

Die zugehörige Dekodierung im GAL kann beliebig ausgeführt sein; insbesondere können neben den Adressierungssignalen weitere Steuersignale wie /IOW, /WR o.ä. eingesetzt werden. Das Design einer solchen Schnittstelle nach außen obliegt in starkem Maß dem Hardwareingenieur, wobei eventuelle Timingprobleme in jedem Fall mitberücksichtigt werden sollten.

Q0

Q2Q3Q4

Q1

Q5Q6Q7

D0

D2D3D4

D1

D5D6D7

2

4

67

5

3

89

19

171615

18

141312

1/OE

8vom µP

Clock 11

GAL16V8

74LS574

A0

A2A3A4

A1

A5

...

A6

vom µP

Bild 6.8 Registerbaustein als Output-Port


6.3 Serielle I/O-Systeme: Von RS232 bis SPI

6.3.1 RS 232

6.3.1.1 Die Geschichte der RS232-Schnittstelle Serielle Schnittstellen standen am Anfang aller externen Verbindungen bei Com-putern. Eine der vordergründigen Probleme bestand in der Datenfernübertragung (DFÜ) via Telefonnetz, zu Beginn des Computerzeitalters die einzige Chance des Datenaustausches.

Von einem Netzwerk konnte man an dieser Stelle noch keineswegs sprechen. Bild 6.9 gibt einen exemplarischen Überblick über die Form der Verbindung, die man als Punkt-zu-Punkt-Verbindung mit Wählleitung (oder auch Standleitung) bezeich-net.

Die Bezeichnungen in Bild 6.9 sind auch heute noch üblich; so steht DEE für Daten End-Einrichtung (englisch: DTE, Data Terminal Equipment) und DÜE für Daten-Übertragungs-Einrichtung (englisch: DCE, Data Communication Equip-ment). Sinn dieser Verbindung war die Datenfernübertragung oder auch Datenfern-verarbeitung. Die Übertragung im Übertragungskanal geschah und geschieht zumeist in analoger Form mit modulierten Frequenzen; das DÜE-Gerät wird daher auch oft als Modem (Modulator-Demodulator) bezeichnet.

Übertragungs-kanal

DEE DEEDÜE DÜE

Datenverbindung

Datenfernverarbeitung

Bild 6.9: Frühe Form der DFÜ

Die Verbindung zwischen DEE und DÜE wurde als erste genormt, und diese Normung galt zunächst auch nur für diese (unsymmetrische) Verbindung. CCITT benannte die Empfehlungen für die Schnittstellenleitungen V.24, für die elek-trischen Pegel V.28.

Die EIA (Electronic Industries Alliance) formulierte später aus einem Teil der V.24/V.28-Empfehlungen seinen Recommended Standard RS232, dessen letzte Revision RS232E genannt wird und den heute üblichen (aber jetzt als EIA/TIA 562 bezeichneten) Standard darstellt.


Zu den V.24-Schnittstellenleitungen gehörten insgesamt 25 Leitungen, dies trotz der Bezeichnung "Serielle Schnittstelle", was sich ausschließlich auf die Form der Datenübertragung bezieht. Der Grund für die ungeheure Vielzahl an "Hilfs-leitungen" ist in der damaligen Technologie zu sehen, wo DEE und DÜE sich gegenseitig durch Hardwaresignale steuern mussten, da der Austausch von Soft-ware-Steuerinformation mangels der Verfügbarkeit von geeigneten Mikroprozes-soren zur Auswertung nicht möglich war.

Die Vielzahl der Schnittstellenleitungen lässt sich in 7 Gruppen einteilen:

• Betriebserde und Rückleiter

• Datenleitungen

• Steuerleitungen

• Meldeleitungen

• Taktleitungen

• Leitungen des Hilfskanals und

• Übergabe analoger Signale

6.3.1.2 Die RS232-Schnittstelle im Detail In der Zwischenzeit ist eine Teilausrüstung zum eigentlichen Standard geworden, so dass auf eine Darstellung der gesamten Vielfalt verzichtet werden soll. Bild 6.10 zeigt diese Teilausrüstung der V.24-Schnittstellen mit Belegung am 25poligen Submin-D-Stecker (ISO 2110) und am 9poligen Submin-D-Stecker (PC/AT-Norm):

(25:1, 9:-) Schutzerde PG

(25:2, 9:3) Sendedaten TxD

(25:3, 9:2) Empfangsdaten RxD

(25:4, 9:7) Sendeteil einschalten RTS

(25:5, 9:8) Sendebereitschaft CTS

(25:6, 9:6) Betriebsbereitschaft DSR

(25:7, 9:5) Signal-/Betriebserde SG

(25:8, 9:1) Empfangssignalpegel DCD

(25:20, 9:4) DEE betriebsbereit DTR

Bild 6.10: Teilausrüstung V.24-Schnittstelle


Die in Bild 6.10 genannten Abkürzungen haben dabei folgende Bedeutung:

Betriebserde und Rückleiter: • PG (Protective Ground, Schutzerde) Die Schutzerde wird mit dem Gehäuse und dem Schutzleiter der miteinander

gekoppelten Übertragungseinrichtungen DEE und DÜE verbunden. Im 9poli-gen System entfällt dieser Pin, nicht aber die Funktion durch die Kabelschir-mung.

• SG (Signal Ground, Betriebserde) Die Betriebserde liegt auf einem Pegel von 0 Volt und dient für alle Signale als

gemeinsamer Bezugspunkt. Sie muss von der Schutzerde getrennt sein!

Datenleitungen: • TxD (Transmit Data, Sendedaten) Über diese Leitung werden der DÜE die zu übertragenden Daten als bitserieller,

digitaler Datenstrom zugeführt. Die Zuführung ist zumeist asynchron, also ohne zusätzliche Taktleitung, das empfangende Gerät synchronisiert seinen Empfang selbständig. Diese Datenübertragung ist nur möglich, wenn sich die Steuer-leitungen RTS und DTR sowie die Meldeleitungen CTS und DSR im EIN-Zustand befinden.

• RxD (Receive Data, Empfangsdaten)

Die DEE empfängt auf gleiche Art die empfangenen Daten aus der DÜE.

Steuerleitungen: • RTS (Request To Send, Sendeteil einschalten)

Diese Steuerleitung veranlasst das Modem, das Sendeteil einzuschalten und in diesem Zustand zu verbleiben, solange RTS den Pegel EIN behält. Zum RTS-Signal zugehörig ist die Meldeleitung CTS, so dass dieses Leitungspaar mit gegenseitiger Kopplung zur direkten Rechner-Rechner-Anbindung genutzt werden kann.

• DTR (Data Terminal Ready, DEE betriebsbereit) Der Zustand EIN auf dieser Leitung signalisiert der DÜE, dass die DEE

eingeschaltet und empfangsbereit ist, falls Daten an den Rechner gesendet werden sollen.

Meldeleitungen • CTS (Clear To Send, Sendebereitschaft)

meldet die DÜE via EIN-Zustand auf dieser Leitung an die DEE. RTS/CTS bilden, wie bereits erwähnt ein Leitungspaar.

• DSR (Data Set Ready, Betriebsbereitschaft)


ist eine durchaus vergleichbare Meldeleitung, mit der aber die Verbindung zum Übertragungskanal und die Betriebsbereitschaft (ON-Line) durch den EIN-Zustand signalisiert werden soll.

• DCD (Data Channel Received Line Signal Detector, Empfangssignalpegel) zeigt den Empfangssignalpegel innerhalb gewisser Grenzen durch den EIN-

Zustand an. Werden zwei Rechner ohne Übertragungskanal miteinander gekop-pelt, dann soll DCD sofort den Zustand EIN annehmen oder mit dem RTS bzw. DTR-Signal der gegenüberliegenden Seite gekoppelt werden, um sofort den Zustand des verbundenen Kabels anzuzeigen.

Wird die V.24-Schnittstelle als synchrone Schnittstelle betrieben, gehören noch Taktsignale zur Definition. Da dies jedoch unüblich geworden ist, wird an dieser Stelle darauf verzichtet.

Es muss an dieser Stelle nochmals auf die unsymmetrische Definition der V.24-Schnittstelle hingewiesen werden. Die Leitungsbezeichnungen sind für DEE und DÜE identisch, nur bedeutet TxD für die DEE, dass wirklich Daten gesendet werden, während für die DÜE auf dieser Leitung Daten von der DEE empfangen werden. Dies ergibt gewöhnlich Probleme bei der Kopplung zwischen Computer und einem anderen Gerät gemäß RS232, da beide Geräte die "Norm" erfüllen können, ohne dass es sofort zusammenpassen muss.

6.3.1.3 Elektrische Signalpegel Die Definition der elektrischen Signalpegel beinhaltet die Spannungswerte für die logischen Werte '0' und '1' sowie Festlegungen zu den Geschwindigkeiten, An-stiegs/Abfallraten der Spannungswerte usw.

Gemäß V.28 haben die Spannungswerte auf den Datenleitungen folgende, in Bild 6.11 dargestellte Definition:

Ist die Spannung auf einem der Datenleitungen (TxD, RxD) also gegenüber der Betriebserde (SG) um 3 bis 15 Volt (Empfang) bzw. 5 bis 15 Volt (Sendebetrieb) im Betrag unterschiedlich und

• negativ, so liegt eine logische '1' auf der Leitung; dies wird auch MARK genannt und stellt den Ruhezustand dar: hingegen

• positiv, so wird eine logische '0' repräsentiert; dieser Zustand heißt auch SPACE.


U

+15 V

-15 V

+3 V

-3 V

0 V

log. '0'

SPACE

log. '1'

MARK(Ruhezustand)

Übergangsbereich

(logisch undefiniert)t

Bild 6.11 Pegeldefinition für Datenleitungen

Für Signal- und Meldeleitungen gibt es eine eigene Definition:

Ist die Spannung einer Signal- oder Meldeleitung im Betrag 3 bzw. 5 bis 15 Volt größer als die Betriebserde (SG) und

• negativ, so herrscht der AUS-Zustand,

• positiv, so herrscht den EIN-Zustand.

Bild 6.12 stellt dies grafisch dar.

U

+15 V

-15 V

+3 V

-3 V

0 V

EIN-Zustand

t

AUS-Zustand

Übergangsbereich

(undefiniert)

Bild 6.12 Pegeldefinition für Steuer- und Meldeleitungen


Mit den logischen und physikalischen Pegeln ist noch nichts über die minimale Anstiegsrate (in V/µs), Welligkeit (in % vom Vollausschlag) usw. ausgesagt worden, und in der Tat definieren V.24/V.28 sowie RS232C, RS232D und RS232E keine minimalen bzw. maximalen Werte zu diesen Größen, allerdings zur maximalen Anstiegsrate mit 30 V/µs. Abhilfe schafft an dieser Stelle erst der mit RS232 kompatible neuere (1991) Standard EIA RS562, der z.B. eine Mindest-anstiegsrate von 4 V/µs und eine maximale Welligkeit von 5% (bezogen auf den Spannungshub VHigh - VLow) zulässt.

6.3.1.4 Synchronisation und Übertragungsgeschwindig keit Synchrone Übertragungsverfahren senden einen Takt zu den jeweiligen Datenbits auf einer Extraleitung mit und bieten so jederzeit die Synchronisation zu den Bits.

Asynchrone Verfahren müssen ohne diese zusätzlichen Leitungen auskommen. Um dennoch die gesendeten Zeichen, die ja in einen Bitstrom zerlegt sind, zusammen-setzen zu können, werden bestimmte Vorvereinbarungen sowie spezielle Zeichen-rahmen notwendig.

Zu den Schnittstellenvereinbarungen zweier gekoppelter Geräte gehören

• Anzahl der Bits pro gesendetem Zeichen

• Übertragungsgeschwindigkeit (Wechselfrequenz) der Bits

• gelegentlich auch spezielle Vereinbarungen, z.B. spätestens nach 5 * logisch '0' wird einmal logisch '1' automatisch dazugegeben (nicht V.24/V.28 bzw. RS232)

Der Zeichenrahmen besteht seinerseits aus zusätzlichen Bits, die also keine Nutzin-formationen mehr enthalten. Diese Bits sind

• 1 Start-Bit, das im Wechsel zum Ruhezustand steht (logisch '0'),

• kein oder 1 Paritätsbit, dessen Wert definierbar von den Werten der Datenbits abhängt, und

• 1, 1.5 oder 2 Stopp-Bits, die den Zustand logisch '1' innehaben und sofort vom nächsten Start-Bit gefolgt sein können.

Das Paritätsbit wird, wenn es vereinbart wurde, wie folgt bestimmt:

Paritätskontrolle Datenwort Paritätsbit gerade (even) 10011000 1 (zusammen 4 * '1') 11110101 0 (zusammen 6 * '1') ungerade (odd) 10011000 0 (zusammen 3 * '1') 11110101 1 (zusammen 7 * '1')

Das Paritätsbit ergänzt den Datenstrom also so, dass eine gerade oder ungerade Anzahl von Bits, je nach Wunsch, entsteht und dient so der Fehlererkennung (nicht


der automatischen Fehlerbehebung) Zu fehlererkennenden Codes siehe [Sie12., Kapitel 14.3].

Der vollständige Bitstrom, der übertragen wird, hat also die Gestalt wie in Bild 6.13 angegeben:

Startbit Paritätsbit

Stopbit

‘1’

‘0’

D0 D3 D7(Ruhezustand)

Bild 6.13 Bitstrom im asynchronen Verfahren (1 Start-, 1 Stoppbit, gerade Parität, 8 Datenbits)

Im asynchronen Verfahren ist die maximale Geschwindigkeit der RS232-Schnitt-stelle auf 20 kBit/s, auch 20 kBaud genannt, begrenzt (RS562: 64 kBit/s). Übliche Übertragungsgeschwindigkeiten sind 110 Baud, 300 Baud, 600 Baud, 1.2 kBaud, 2.4 kBaud, 4.8 kBaud, 9.6 kBaud und 19.2 kBaud. In Computern gelegentlich auf-findbare höhere Bitraten von 38.4, 57.6 oder 115.2 kBaud werden gewissermaßen "auf eigene Gefahr" betrieben.

Bei 19200 Bit/s hat ein Bit eine Sendedauer von 52 µs. Der Wirkungsgrad einer bitseriellen Übertragung mit 1 Startbit, 1 Paritätsbit und 1 Stoppbit bei 8 Datenbits beträgt 8/11 = 72,3 % maximal, für die Übertragung von 1 MByte Nutzdaten werden rund 9,5 Minuten Zeit benötigt.

6.3.2 EIA-485 EIA steht – wie schon erwähnt – als Abkürzung für Electronic Industries Alliance. EIA-485, vormals als RS-485 bezeichnet, verwendet ein Leitungspaar, um sowohl den invertierten und einen nichtinvertierten Pegel eines 1-Bit Datensignals zu übertragen. Am Empfänger wird aus der Differenz der beiden Spannungspegel das ursprüngliche Datensignal rekonstruiert. Das hat den Vorteil, dass sich Gleichtakt-störungen nicht auf die Übertragung auswirken und somit die Störsicherheit vergrößert wird. Im Gegensatz zu EIA-232 (vormals RS-232) sind so wesentlich längere Übertragungsstrecken und höhere Taktraten möglich.

EIA-485 wird aktuell von der TIA (Telecommunications Industry Association) gepflegt und als EIA/TIA-485 bezeichnet.

Bild 6.14 zeigt die Abhängigkeit von Reichweite und Bitfolgefrequenz bei EIA-485. Ein EIA485-Transmitter kann dabei 32 Empfänger – darunter sich selbst – mit elektrischer Leistung versorgen, um den Empfang zu gewährleisten. Bei dem Vorgängerstandard EIA-422, der ebenfalls differenziell arbeitet, sind 10 Empfän-


ger möglich. Weiterhin kann der EIA-485 Standard im Multipoint-Modus, d.h. mit wechselnden Sendern betrieben werden, während EIA-422 im Point-to-Multipoint arbeitet.

6.3.2.1 Technische Einzelheiten EIA-485 ist für eine zwei- und vieradrige Übertragung, also Halb- und Vollduplex-betrieb definiert. Meist wird jedoch nur ein Halbduplexbetrieb mit einem Adern-paar gewählt, diese Variante entspricht dann auch einem Netzwerkbetrieb ähnlich zu Ethernet.

Im Gegensatz zu anderen Bussen sind bei EIA-485 nur die elektrischen Schnittstel-lenbedingungen definiert. Das Protokoll kann anwendungsspezifisch gewählt wer-den, so dass EIA-485 allein als Standard keine Übertragung gewährleistet. Ande-rerseits wurde dieser Standard als Grundlage für viele Feldbusstandards gewählt, folglich wird EIA-485 häufig eingesetzt.

Die beiden symmetrischen Leitungen der EIA-485/Schnittstelle arbeiten mit einem Differenz-Spannungspegel von mindestens +/-200 mV. Der Sender eines typischen 485-Bausteins verwendet eine Brückenschaltung, somit entspricht der Signalpegel beim Sender der Betriebsspannung des Treibers, z.B. +/- 5 V.

Wie bereits erwähnt sind mindestens 32 Teilnehmer an einem Adernpaar möglich; es existieren auch Bausteinvarianten mit 256 Teilnehmern, indem der Eingangs-widerstand der Receiver auf den 8fachen Wert gesteigert wird. Bei einer maxi-malen Übertragungsrate von 10 Mbit/s sind 12 m Übertragungsreichweite möglich, bei 100 kbit/s maximal 1200 m.

1200

12

120

m

10 100 1000 10000 kbit/s

Bild 6.14 EIA-485 Reichweite/Geschwindigkeitsdiagramm


6.3.3 I²C-Bus Der I²C-Bus, abkürzend für Inter-IC-Bus stehend, wurde in den frühen 1980er Jahren zur Kommunikation zwischen einem Mikrocontroller und Peripherie-ICs von Philips Semiconductor eingeführt. Es stellt ein typisches Bussystem auf Platinenebene dar. Technisch identisch ist das TWI (Two-Wire Interface) von Atmel.

6.3.3.1 Technische Beschreibung des I²C

Vom I²C-Bus liegen verschiedene Versionen und Geschwindigkeiten vor. Ur-sprünglich auf 100 kbit/s (als Brutto-Datenrate, Normal Mode) begrenzt wurde mit der Version 1.0 (1992) die maximale Geschwindigkeit auf 400 kbit/s (Fast Mode) erhöht. Version 2.0 (1998) erhöhte auf 3,4 Mbit/s (High Speed Mode), allerdings mit verändertem Protokoll, V 3.0 (2007) ergänzte um den Fast Mode Plus mit 1 Mbit/s bei gegenüber dem normal und fast mode identischem Protokoll.

Zugleich wurden die Adressierungsräume erweitert. Der ursprünglichen Adres-sierung von 7 bit (= 128 Adressen, von denen 112 nutzbar waren) wurde eine 10-bit-Adressierung ab dem Fast Mode hinzugefügt, so dass maximal 1136 Teilneh-mer (= 112 im 7-bit Modus plus 1024 im 10-bit Modus) angesprochen werden können.

I²C ist als Master-Slave-Bus konzipiert, d.h. zu einem Zeitpunkt hat nur der Master das Recht, die anderen Teilnehmer anzusprechen. Der Master sendet, und ein Slave reagiert darauf. Mehrere Master sind möglich (Multimaster-Mode). Die Buszutei-lung (so genannte Arbitrierung), d.h. die Übergabe der Master-Eigenschaft, ist dabei per Spezifikation geregelt.

Rp Rp

VDD

SDA

SCL

µC(Master)

ADC(Slave)

DAC(Slave)

RTC(Slave)

Bild 6.15 I²C-Bus mit einem Master (Mikrocontroller) und drei Slave-Teilnehmern (AD-Converter, DA-Converter, Real-Time Clock)

Der I²C-Bus benötigt lediglich zwei Signalleitungen: Den Takt (SCL, Serial Clock) und die Datenleitung (SDA, Serial Data). Beide sind im Ruhezustand mit den Pull-


up-Widerständen Rp auf das Potential der Versorgungsspannung VDD gezogen. Sämtliche am I²C-Bus angeschlossenen Geräte haben so genannte Open-Collector-Ausgänge, d.h., die Ausgangstransistorschaltung, die der bekannten Collector-Schaltung entspricht, weist keinen Collector-Widerstand auf (dieser ist durch Rp gegeben. Insgesamt entspricht die Schaltung einer Wired-AND-Schaltung: Zieht ein Ausgangstransistor eine Leitung auf Low, ist sie bei allen anderen Ein-/Aus-gängen ebenfalls auf Low.

Der High-Pegel soll dabei mindestens 0,7×VDD betragen, der Low-Pegel höchstens 0,3×VDD. Dieses Wired-AND-Prinzip bewirkt, dass ein nicht aktiver Ausgang (Transistor sperrt) als Eingang genutzt werden kann, indem die tatsächliche Span-nung am Transistorausgang detektiert wird.

6.3.3.2 Übertragungsprotokoll Der Bustakt wird immer vom Master ausgegeben. Für die verschiedenen Modi ist jeweils ein maximal erlaubter Bustakt vorgegeben, wobei in der Regel aber auch beliebig langsamere Taktraten verwendet werden können. Die verschiedenen Ge-schwindigkeiten wurden bereits dargestellt.

Wenn der Slave mehr Zeit benötigt, als durch den Takt des Masters vorgegeben ist, kann er zwischen der Übertragung einzelner Bytes den Clock auf low halten (clock stretching) und so den Master bremsen – allerdings nur auf Byte-Ebene, d.h. nach Übertragung eines Oktetts. Einzelbits sind nur gültig, wenn sich ihr logischer Pegel während einer Clock-High-Phase nicht ändert. Gewollte Ausnahmen davon sind das Start-, Stop- und Repeated Start-Signal. Das Start-Signal ist eine fallende Flanke auf SDA, während SCL high ist, das Stop-Signal ist eine steigende Flanke auf SDA, während SCL high ist. Repeated Start sieht genauso aus wie das Start-Signal.

SDA

SCL

S (Start)

P (Stop)

B1 B2 B8 ACK

Bild 6.16 I²C-Bus Übertragungsprotokoll

Eine Dateneinheit besteht aus 8 Datenbits = 1 Oktett (welche protokollbedingt ent-weder als Wert oder als Adresse interpretiert werden) und einem ACK-Bit. Die Übertragung der Bits erfolgt immer in der Reihenfolge Most Significant Bit First (msb).


Das Bestätigungsbit (Acknowledge) wird durch einen Low-Pegel auf der Datenlei-tung von Seiten des Slaves während der neunten Takt-High-Phase (der Takt wird immer vom Master generiert wird) und als NACK (not acknowledge) durch einen High-Pegel signalisiert. Zugleich muss der Master auf der SDA-leitung ein High setzen, um das Wired-AND zu ermöglichen, und der Master liest dann diesen Wert ein.

Der Slave muss den L-Pegel an der Datenleitung anlegen bevor der Master das CLK-Signal auf High legt, andernfalls würden weitere eventuelle Teilnehmer ein „STOP-Signal“ lesen.

6.3.3.3 Adressierung und Übertragung Eine Standard-I²C-Adresse ist das erste vom Master gesendete Byte, wobei die ersten sieben Bit als die eigentliche Adresse darstellen und das achte Bit (R/W-Bit) die Lese- oder Schreibrichtung festlegt (0 für schreiben, 1 für lesen). I²C nutzt daher einen Adressraum von 7 Bit, was bis zu 128 Knoten auf einem Bus erlaubt (16 der 128 möglichen Adressen sind allerdings für Sonderzwecke reserviert).

Jeder I²C-fähige IC hat eine vom Hersteller festgelegte Adresse, von der bisweilen die untersten drei Bits (mit Subadresse bezeichnet) über drei Steuerpins festgelegt werden können. In diesem Fall können bis zu acht gleichartige ICs an einem I²C-Bus betrieben werden. Wenn nicht, müssen mehrere gleiche ICs mit getrennten I²C-Bussen angesteuert oder abgetrennt werden können.

Wegen Adressknappheit (!) wurde später eine 10-Bit-Adressierung eingeführt. Sie ist abwärtskompatibel zum 7-Bit-Standard durch Nutzung von 4 der 16 reservierten Adressen. Beide Adressierungsarten sind gleichzeitig verwendbar, was bis zu 1136 Knoten auf einem Bus erlaubt.

Der Beginn einer Übertragung wird mit dem Start-Signal vom Master angezeigt, dann folgt die Adresse. Diese wird durch das ACK-Bit vom entsprechenden Slave bestätigt. Abhängig vom R/W-Bit werden nun Daten Oktett-weise geschrieben (Daten an Slave) oder gelesen (Daten vom Slave), wobei der Takt immer vom Master gesetzt wird.

Das ACK beim Schreiben wird vom Slave gesendet und beim Lesen vom Master. Das letzte Byte eines Lesezugriffs wird vom Master mit einem NACK quittiert, um das Ende der Übertragung anzuzeigen. Eine Übertragung wird durch das Stop-Signal beendet. Alternativ kann auch ein Repeated Start am Beginn einer erneuten Übertragung gesendet werden, ohne die vorhergehende Übertragung mit einem Stop-Signal zu beenden.

Anmerkung zum I²C-Bus: Dieses Kommunikationsmedium bietet eine hervor-ragende Möglichkeit, auf Platinenebene und –größe miteinander zu kommuni-zieren und einen Mikrocontroller mit weiteren Peripheriebausteinen zu verse-hen. Allerdings muss klar sein, dass I²C weder für große Entfernungen noch für große Übertragungssicherheit geeignet ist: Der Hauptvorteil von I²C liegt in der Effizienz dieses Standards.


Im Multi-Mastermode, in dem also mehrere (potenzielle) Master am Bus aktiv sein können, wird der Bus anhand der ersten Bytes arbitriert, und zwar anhand einer CSMA/CR-Variante (→ [Sie12, 11.5.2]) mit dominanter ‘0‘. Die Anzahl der Bytes/Oktetts, die für eine korrekte Adressierung und Befehlsübermittlung notwendig sind, muss daher für alle Kommunikationseinleitungen gleich sein, es sei denn, eine klare Unterscheidung ist bereits vorher möglich und der unter-legene Teilnehmer anhand der ersten Oktetts identifiziert.

6.3.4 Serial Peripheral Interface (SPI) Neben dem I²C-Standard stellt das Serial Peripheral Interface (SPI) einen weiteren, weit verbreiteten Standard im Bereich der Vernetzung auf einer Platine dar. Dieser Standard stammt von der Firma Motorola, wird aber von vielen Herstellern angeboten.

SPI-Bus im Detail Das Serial Peripheral Interface nutzt eine strenge Master/Slave-Kommunikation ohne Möglichkeit, den Master zu wechseln. Zur Kommunikation sind jeweils drei Leitungen notwendig, die die Teilnehmer gemeinsam nutzen:

● SCLK, Serial Clock zur Taktübermittlung (diese Leitung wird durch den Master gesetzt)

● MOSI, Master Out Slave In, zur Kommunikation in Richtung der Slaves, auch als SDO (Serial Data Out) bezeichnet.

● MISO, Master In Slave Out, zur Kommunikation in Richtung des Master, auch als SDI (Serial Data In) bezeichnet.

Zusätzlich müssen eine oder mehrere Selektierungsleitungen vorhanden sein, um den oder die Empfänger zu aktivieren. Diese Leitungen werden meist mit SS (Slave Select), CS (Chip Select), CE (Chip Enable) oder STE (Slave Transmit Enable) bezeichnet.

Die Kommunikation via SPI ist damit bidirektional (vollduplex). Bild 6.17 gibt die Verkabelung eines Masters mit drei Slaves, hier beispielhaft ein AD-Converter, ein serielles EEPROM und eine Real-Time Clock (RTC). Diese Form des Anschlusses wird meist gewählt, jeder Baustein ist separat ansprechbar, und in eingeschränktem Maße kann auch ein Multicasting erfolgen – wenn man auf die Antwort der Slaves verzichtet, da diese parallel zueinander, aber eben auf einer einzigen (Sammel-)Leitung gesendet werden.

Eine alternative Verdrahtung ist Bild 6.18 gezeigt. Hier werden die Teilnehmer in einer Kette miteinander verdrahtet, so dass die übertragenen Bits zunächst zusammengestellt werden müssen und dann solange durch die Kette getaktet werden, bis sie ihr Ziel erreicht haben. Hierfür müssen alle Mitglieder in der Kette zugleich selektiert werden.


SPIMaster

SCLKMOSIMISO

/CE3 /CE2 /CE1

SPISlave 1

(ADC)

SCLKMOSIMISO/CE

SPISlave 2

(ser. EEPROM)

SCLKMOSIMISO/CE

SPISlave 3

(Real-Time Clock)

SCLKMOSIMISO/CE

Bild 6.17 SPI in sternförmiger Verbindung

SPIMaster

SCLKMOSIMISO

/CE

SPISlave 1

(ADC)

SCLKMOSIMISO/CE

SPISlave 2

(ser. EEPROM)

SCLKMOSIMISO/CE

SPISlave 3

(Real-Time Clock)

SCLKMOSIMISO/CE

Bild 6.18 SPI in kaskadenförmiger Vernetzung

6.3.4.1 Protokollablauf Es können theoretisch beliebig viele Teilnehmer an den Bus angeschlossen werden, wobei es exakt einen Master geben muss. Dieser Master erzeugt das Clock-Signal (SCK) legt fest, mit welchem Slave er kommunizieren will. Das geschieht über die Leitung „Slave Select“ (bzw. „Chip Enable“ etc.), die bei einem gegen Masse gezogenen Potenzial den jeweiligen Slave aktiviert.


Ein aktivierter Slave legt Daten im Takt des SCK-Anschlusses an MISO, so dass zugleich ein Byte empfangen und ausgesendet wird. Welche Daten das im Einzelfall sind, hängt von dem Baustein ab. Es kann sich im Allgemeinen nicht um eine unmittelbare Reaktion auf das aktuell übertragene Byte sein, meist ist es eine Reaktion auf die vorangegangenen Übertragungen. Einzelheiten hierzu müssen den jeweiligen Datenblättern entnommen werden.

In der Praxis haben sich für SPI vier verschiedene Modi durchgesetzt. Diese wer-den durch die Parameter Clock Polarität (CPOL) und Clock Phase (CPHA) festgelegt. Bei CPOL == 0 ist der Takt im Idle-Zustand Low, bei CPOL == 1 entsprechend High. CPHA gibt nun an, bei der wievielten Flanke die Daten übernommen werden sollen. Bei CPHA == 0 werden sie bei der ersten Flanke übernommen, nachdem SS/CE auf Low gezogen wurde, bei CPHA == 1 bei der zweiten. Bild 6.19 zeigt den Verlauf für CPOL/CPHA == 0/0 (Modus 0).

Taktzyklus

1 2 4 .. 7 83

SCLK

MISO

MOSI

Bild 6.19 Zeitdiagramm SPI-Bus, Mode 0 (eine entsprechende Selektierungsleitung muss aktiv sein)

Zu beachten ist noch, dass der Slave bei CPHA == 0 seine Daten schon beim Aktivieren von SS/CE an MISO anlegt, damit der Master sie beim ersten Flan-kenwechsel übernehmen kann. Die verschiedenen Konstellationen für CPOL und CPHA werden auch als Modi bezeichnet:

Tabelle 6.2 Modi für Serial Peripheral Interface

Mode CPOL CPHA 0 0 0 1 0 1 2 1 0 3 1 1


6.4 Timer in Mikrorechnern

6.4.1 Allgemeines zu Timern Ein Timer stellt einen Taktzähler dar, der unter bestimmten Vorgaben (interne Konfiguration oder externe Anschlüsse) zählabhängige Signale nach außen geben kann. Fasst man den Timerbaustein so auf, dann dient er nicht als Interfacebau-stein, sondern als reiner Hilfsbaustein, der zeitliche Prägungen unabhängig von der Ausführungsgeschwindigkeit der CPU in das Computersystem bringt.

Dennoch gehören Timer-ICs in die Mess- und Prozesstechnik. Der Grund dafür liegt darin, dass bei allen Prozessvorgängen nicht nur die (rechnerische) Richtig-keit der Werte wichtig ist, sondern zugleich (z.T. sogar höher zu bewerten) die Rechtzeitigkeit der Werte, der Berechnungen usw.

Das Zählen von Takten kann grundsätzlich in mehreren Modi erfolgen, von denen zwei besondere Bedeutung aufgrund ihrer Allgemeingültigkeit haben:

● One-Shot-Modus

● Kontinuierlicher Modus mit Auto-Reload

Der One-Shot-Modus dient dem Zählen in einem einzigen Ablauf. Hierdurch ist es z.B. möglich, über die Zählung einer bestimmten Anzahl von Takten eine Zeit-periode zu bestimmen, z.B., um zu warten. Andere Anwendungen zählen Impulse am Takteingang, die nicht mehr von einem periodischen Taktgeber stammen, während einer Zeitperiode, die über ein Gate (Freischaltung) definiert ist.

Der kontinuierliche Modus wird meist angewendet, um eine Zeitperiode zu schaf-fen. Am Ende einer Zählung, die z.B. durch einen Underflow (ein Dekrement auf den Zählwert 0) oder Overflow gekennzeichnet sein kann, wird ein Signal zum Mikroprozessor gesendet, und die Zählung beginnt von vorne. Dies wird mit Auto-Reload bezeichnet.

Damit also ein Timer den Anforderungen gerecht werden kann, muss die Konfigu-ration in den Timer geladen werden (also der Modus), und der Startwert der Zählung muss geladen sein. Außerdem muss die Taktquelle gewählt werden.

Weitere Modi entstehen dadurch, dass Input- und Output-Vergleichseinheiten hinzugefügt werden. Bei einer Input Capture Unit steht im Vordergrund, dass der Zeitpunkt bestimmter Ereignisse gespeichert wird. Diese Einheiten werden also durch externe digitale Signale, meist durch Flanken, oder (seltener) durch analoge Vergleichseinheiten gesteuert.

Die Output Compare Unit hingegen vergleicht den Zählerstand mit einem gespei-cherten Zählerstand und unternimmt dann eine Aktion, z.B. die Auslösung einer IRQs oder die Invertierung eines Ausgangssignals. Auf diese Weise können z.B. zeitabhängige Signale in Form einer Pulsweitenmodulation (PWM, Pulse Width Modulation) generiert werden, ohne dass die CPU in Aktion tritt.


6.4.2 Timer im ATmega2560 Der ATmega2560 hat insgesamt 2 Timer mit 8-bit-Zähler (Timer 0 und 2) und 4 mit 16-bit-Zähler (Timer 1, 3, 4, 5). Für alle Timer mit Ausnahme von Timer 2 gibt es eine Prescaler-Einheit, die als Takt für die Timer den Systemtakt fCLK_I/O, fCLK_I/O/8, fCLK_I/O/64, fCLK_I/O/256 und fCLK_I/O/1024 zur Verfügung stellt. Zudem ist es möglich, den Takt auf eine externe Quelle zu konfigurieren (dann ohne Prescaler).

Unabhängig davon, dass alle den gleichen Prescaler nutzen, können die Timer selbst auf unterschiedliche Quellen konfiguriert werden. Allerdings gibt es einen so genannten Prescaler-Reset, bei dem die Ausgangstaktgenerierung wieder neu gestartet wird, und dieser wirkt auf alle Timer. Dieser Reset kann über das Register GTCCR (Global Timer/Counter Control Register, Adresse 0x23/0x43) ausgelöst werden.

Die Timer selbst sind vielfach konfigurierbar. Zur genauen Definition der Bits und der zugehörigen Register sei auf [Atm_DS] verwiesen. Hier sind aber einige summarische Anmerkungen:

Im Normal Mode laufen die Timer frei. Sie werden immer inkrementiert, begin-nend bei 0, und liefern beim Overflow (0xFF auf 0 bzw. 0xFFFF auf 0) einen Inter-rupt Request (TOVx, Timer Overflow). Innerhalb die Modes können Input Capture Registerwerte gespeichert werden – zeigt ein externes Ereignis am Input Capture Pin ICPn eine Flanke, wird der Timerwert gespeichert und ein IRQ ausgelöst, für Timer 1 kann das auch mithilfe einer analogen Vergleichseinheit (Analog Comparator Output) erfolgen. Weiterhin können mithilfe der Output Compare Unit IRQs bei bestimmten Zählerständen erzeugt werden.

Im Clear Timer on Compare Match Mode läuft der Timer ebenfalls frei, aber er wird bei einem Compare Match, dem erfolgreichen Vergleich mit einem Refe-renzwert, auf 0 zurückgesetzt. Dies bedeutet, dass spezifische Perioden erzeugt werden können.

Die Erzeugung von Wellenformen an Ausgangspins – solche werden z.B. zur Steuerung von Schrittmotoren benötigt – erfolgt im Fast PWM Mode (Pulse Width Modulation) und im Phase Correct PWM Mode und im Phase and Frequency Correct PWM Mode.

6.5 Interrupt-Requests

In Embedded Systems (eingebetteten Systemen) ist der Rechner nicht zentrales oder gar einziges Element des Systems, sondern er dient der Funktionalität eines Geräts und ist nach außen hin oft nicht direkt wahrnehmbar. Für derartige Rechner, die fast ausschließlich auf Mikrocontrollern (oder auf digitalen Signalprozessoren, DSP) beruhen, ist eine Kopplung des Rechners mit der Außenwelt unerlässlich.

Diese Kopplung kann prinzipiell auf zwei Arten erfolgen:


• Der Prozessor fragt zyklisch die Eingangssignale ab, die ihn erreichen und bestimmte Zustände signalisieren können. Dies besteht im einfachsten Fall aus dem so genannten Polling, d.h. einer ständigen Abfrage des Außenzustands. Bei den meisten Systemdesigns wird das allerdings auf eine Zeitsteuerung ab-gebildet, die mithilfe vom Timer ausgelösten Interrupt Requests implementiert wird.

• Der Prozessor wird durch spezielle Signale alarmiert, d.h., bei Auftreten von Pegeln oder Flanken an diesen Signalen versetzt den Prozessor in einen besonderen Betriebszustand.

Die Signale zur besonderen Kommunikation des Außenprozesses mit dem Prozes-sor werden Interrupt-Requests (abk.: IRQ) genannt. Sie entstammen der Umge-bung, in die der Rechner eingebettet ist, und teilen einen bestimmten Zustand asynchron zum normalen Programmablauf mit. Der gleiche Mechanismus gilt für den Timer oder eine interne Schnittstelle, die Daten sendet und empfängt und ein Ereignis signalisieren will, nur dass es sich hierbei um Mikrocontroller-interne Signale handelt.

Die Reaktion des Mikroprozessors besteht dabei in dem Verlassen des bisherigen Programmablaufs und dem Sprung in eine besondere Routine, im folgenden Interrupt-Service-Routine (ISR) genannt. Eine wichtige Architekturentscheidung ist hingegen, ob das System reaktiv arbeiten soll, d.h. auf IRQ-Signale reagiert, oder interaktiv, d.h. z.B. mithilfe der Timer die Zeitpunkte zur Wechselwirkung bestimmt. Beide Architekturen werden in [Sie12, Kapitel 3] ausführlich diskutiert.

Der Inhalt der ISR ist sehr stark von der den Mikroprozessor umgebenden Peri-pherie und natürlich dem Verursacher des IRQs abhängig. Hier wird vom System-designer erwartet, dass er/sie ein den Anforderungen entsprechendes System zusammenstellt: Viele Anforderungen erfordern Hardwareunterstützung, wenige (oder ’unwichtige‘) können in Software, ggf. sogar mit Polling bearbeitet werden. Hier beginnt u.a. das Gebiet des Hardware/Software Co-Design.

Die konkrete Reaktion des Mikroprozessorsystems auf bestimmte Ausnahmezu-stände kann im Allgemeinen nicht vom Hersteller vorherbestimmt werden, der Pro-zessor leitet nur die Reaktion ein, wenn das Signal auftritt, und der/die Program-miererIn hat zu bestimmen, was erfolgt. Allerdings können bestimmte Peripherie-ICs einen Teil der ISR, insbesondere die Feststellung des IRQ-Verursachers bei diversen Quellmöglichkeiten, erheblich vereinfachen.

Die einfachste Methode zur Quellenbestimmung der Unterbrechung ist es, nach Auflaufen eines IRQs alle möglichen Quellen abzufragen und bei Bedarf zu behandeln. Diese Methode wird im wesentlichen von einfachen, 8-Bit orientierten Systemen (z.B. 6502, 6805, 68HC11, 8051) durchgeführt. Bei komplexeren Gesamtsystemen wird die Quelle per Hardware vorbestimmt (Vektor-IRQ) und in diesem Zusammenhang Interrupt-Request-Controller eingesetzt, die automatisch die Ursache feststellen und sie an die CPU melden, die ihrerseits sofort – via einem Sprungvektor – die zuständige ISR aufruft.


6.5.1 Die Integration von IRQs im ATmega2560 Der ATmega2560-Mikrocontroller zählt zwar zu den 8-Bit-Mikrocontrollern, das Handling der Interrupt Requests ist aber gegenüber den einfachen Mikrocontrollern deutlich verbessert, denn der ATmega2560 verfügt über einen Vektor-Interrupt. Dies bedeutet folgendes:

Im Programmspeicher existiert eine Region, die ausschließlich Sprungadressen be-inhaltet. Diese beginnt an der Adresse 0x0000.

Bild 6.20a Sprungtabellen für Interrupt Requests im ATmega2560 (Teil 1)


Bild 6.20b Sprungtabellen für Interrupt Requests im ATmega2560 (Teil 2)

Jeder Eintrag in diese Liste stellt eine Anfangsadresse (2 Byte) dar, an dieser Stelle muss das entsprechende Programm beginnen. Die an der Stelle 0x0000 hinterlegte Adresse ist für den Reset zuständig, der bei Power-On, einem Low-Pegel an dem externen Anschluss /Reset und weiteren Bedingungen ausgelöst wird.

Zu den weiteren Bedingungen zählt ein Reset durch den Watchdog-Timer, der bei einem Ablauf eben diesen auslöst und somit zur Lebendüberwachung des Systems eingesetzt wird. Der Watchdog-Timer kann durch Software immer wieder auf Start zurückgesetzt werden, jedoch nie beendet werden, nachdem er einmal gestartet wurde.


Der Brown-Out-Reset wird bei Unterschreiten der Betriebsspannung unter einen Mindestpegel ausgelöst, ohne dass die Betriebsspannung komplett zusammen-bricht. Dies ist deswegen sinnvoll, weil z.B. EEPROM-Zellen nur bei ausrei-chender Spannung Korrekt programmiert werden und bei Unterspannung falsche Werte speichern können (so genannter Brown-Out-Effekt).

Der JTAG AVR Reset (Joint Test Acquisition Group) wird am Ende eines Pro-grammiervorgangs oder eines anderen Testvorgangs ausgeführt, um den Mikrocontroller komplett neu zu starten.

Alle weiteren Einträge in die Liste bedeuten Sprungwerte für eingehende Interrupt Requests. An der Größe der Tabelle wird sichtbar, dass hier eine Menge von Unter-brechungen auftreten kann, jede Quelle wird einzeln behandelt.

Der Ablauf eines IRQs gestaltet sich in folgender Reihenfolge:

1. Die Peripherie des Mikroprozessors fordert eine Interruptbehandlung durch Setzen eines speziellen Pins oder durch Setzen einer internen Anforderung an. Der Pegel dieses Pins ist µP-spezifisch, beim ATmegaXXX-System kann für externe Pins konfiguriert werden, ob eine positive oder negative Flanke diesen auslösen oder ob der IRQ Level-sensitiv (dann nur auf low-Pegel) sein soll.

2. Am Ende einer Befehlsausführung prüft die CPU, ob ein IRQ aktiv ist; die Aktivität einer potenziellen Quelle wird dabei gespeichert, so dass ein einmal ausgelöster IRQ nicht verlorengeht. Ist die Aktivität gegeben, der korrespon-dierende IRQ zugelassen und das globale I-Flag (Interrupt Enable Flag) im Statusregister gesetzt, dann wird die Bearbeitung des IRQs freigegeben und die entsprechende Service Routine gestartet.

3. Nach dem letzten ausgeführten Befehl (des normalen Programms) werden die allernotwendigsten Informationen auf dem Stack gesichert: Dies ist im Fall des ATmegaXXX die Rücksprungadresse, bei anderen Mikrocontrollern wird oft auch das Statusregister auf dem Stack gesichert.

Im ATmegaXXX wird das Interrupt Enable Flag I im Status Register (SREG, Adresse 0x3F) gelöscht. Wird dieses Register also zu Beginn der ISR auf dem Stack gerettet, ist I = 0 gesetzt, alle anderen Flags entsprechen dem Zustand bei Unterbrechung des normalen Programms.

4. In der ISR selbst müssen alle Register, die hier genutzt werden, auf dem Stack gesichert werden, um bei Rückkehr den bei Unterbrechung vorgefundenen Zustand restaurieren zu können.

Nach Beenden des eigentlichen Algorithmus in der ISR werden die Register wieder hergestellt. Damit erhält eine ISR folgende Rahmenstruktur, in Bild 6.21 dargestellte Rahmenstruktur.

5. Bei der Rückkehr in das unterbrochene Programm wird das I-Flag automatisch wieder gesetzt, so dass danach wieder Interrupt Requests zugelassen sind.


push r0 ; r0 und SREG retten in r0, $3f ; push r0 ; … ; Der eigentliche ALgorithmus pop r0 ; R0 und SREG wiederherstellen out $3f, r0 ; pop r0 ; reti ;

Bild 6.21 Rahmenstruktur für Interrupt Service Routine (ISR)

Es sei hier darauf hingewiesen, dass Unterbrechungen von ISRs im Allgemeinen nicht vorgesehen sind. Dies bedeutet nur, dass sie nicht automatisch zugelassen sind (aufgrund des gelöschten I-Flags). Innerhalb von ISRs kann man jedoch IRQs wieder zulassen, indem das I-Flag gesetzt wird.

Diese Möglichkeit sollte allerdings mit Bedacht genutzt werden. Das Verschach-teln von IRQs kann zu instabiler Software führen, indem Wechselwirkungen zwischen den Routinen bestehen. Eine solch unerwünschte Wechselwirkung ent-steht durch „Non-reentrant Functions“, deren Entstehung und Nutzung in [Sie12, Kap. 9.3.2] beschrieben ist.

6.5.2 Anwendungen von Interrupt Requests Unterbrechungen können bei entsprechendem Software Design zur Kopplung des Programmlaufs mit Ereignissen (in- und extern) sowie zur Kopplung mit Zeitvor-gängen genutzt werden.

Kopplung zu externen Ereignissen Die Kopplung zu externen Ereignissen ist unmittelbar einleuchtend: Eine externe Hardware löst einen IRQ an einem Pin aus und signalisiert so den Bedarf an Service. Der Mikrocontroller reagiert darauf und behandelt die Unterbrechung dementsprechend.

Kopplung zu internen Ereignissen Die Kopplung an interne Ereignisse – außer den Timern – muss etwas erläutert werden, und zwar am Beispiel der seriellen Schnittstelle. In einem kleinen Beispiel sei die serielle Schnittstelle so genutzt, dass mehrere Daten möglichst schnell hintereinander gesendet werden sollen. Hierzu wird ein Byte in das Transmit-Re-gister der USART (Universal Synchronous Asynchronous Receiver Transmitter), z.B. UDR0 (0xC6) für den ersten USART, geschrieben. Ist die serielle Schnittstelle frei, wird unmittelbar damit begonnen, das Byte zu senden (mit Start- und Stoppbit sowie ggf. der Parität).


Das ist soweit einfach, doch es sollen noch mehr Bytes versendet werden, und zwar möglichst nahtlos. Jetzt kann in der Software gewartet werden, wie in Bild 6.22 dargestellt wird, und bei freiem Register (dies ist bereits freigegeben, wenn der Sendevorgang beginnt) wird das nächste Byte an die serielle Schnittstelle ausge-geben.

#define UDRE0 5 #define UCSR0A (unsigned char *)0xC0 #define UDR0 (unsigned char *)0xC6; void USART_Transmit( unsigned char *pucData, int iN umOfData ) { int k; /* Wait for empty buffer */ For( k = 0; k < iNumOfData; k++ ) { while( (UCSR0A & (1 << UDRE0)) == 0 ); UDR0 = *(pucData + k); /* Sending new data */ } }

Bild 6.22 Sourcecode für blockierende Senderoutine

Der Nachteil dieses Verfahrens, auch als blockierend bezeichnet, liegt darin, dass in erheblichem Maße gewartet werden muss. Die Transmission eines Bytes per serieller Schnittstelle dauert bei 19200 Bit/s rund 0,5 ms (10 Bit werden pro Byte gesendet), und dies sind ca. 8000 Befehle beim ATmegaXXX mit 16 MHz.

Die Lösung liegt darin, dass man einen Transmissions-Handler entwirft, der den IRQ für „Sendepuffer leer“ (USARTx Data Register empty) nutzt. Die 1. Trans-mission wird dann per Software angestoßen und zugleich der Sendepuffer initia-lisiert, und bei jedem IRQ wird im Sendepuffer nachgeschaut, ob noch Zeichen zum Senden vorhanden sind oder nicht.

Ist der Sendepuffer noch gefüllt, wird das Zeichen in das Datenregister zum Senden geschrieben, ansonsten erfolgt keine weitere Reaktion, die Transmission ist beendet. Auf diese Weise werden längere Wartezeiten vermieden.

Kopplung mit zeitlichen Vorgängen Die Timer sind hervorragend dafür geeignet, zeitliche Vorgänge etwa wie periodi-sche Aktivitäten zu steuern. Hierfür wird eine Zeit im Timer eingestellt, und beim entsprechenden IRQ wird dann die Aktivität gestartet, die mit dem Ablauf der Zeit verbunden ist.

Dies führt zu den zeitgesteuerten Architekturen, die in [Sie12, Kap. 2-4] beschrie-ben sind und eine grundlegende Architektur für eingebettete Systeme darstellen.


Mithilfe diese Zeitsteuerung besteht die Möglichkeit, interaktive Systeme (= Rech-nersysteme, bei denen die Applikation die Zeitpunkte der Wechselwirkung mit dem Außenprozess bestimmt) zu konzipieren, die aber dennoch echtzeitfähig sind (oder zumindest sein können).

6.5.3 Weiterentwicklung des IRQ-Managements Das IRQ-Management im ATmegaXXX ist zwar schon recht ausführlich, kann aber noch erweitert werden. Besonderes Augenmerk gilt dabei der eingebauten Priorisierung.

Die Prioritäten im ATmegaXXX sind fest vergeben: Bei gleichzeitigem Auftreten zweier IRQs wird derjenige behandelt, dessen Adresse in der Vektorliste (Bild 6.20) kleiner ist. Ausgefeilte IRQ-Controller bietet hier eine Konfigurierbarkeit, die auch im laufenden System noch geändert werden kann.

Speziell für 80x86-Systeme wurde der IRQ-Controller 8259A konzipiert, um an-kommende Interrupts hardwaremäßig unterstützen zu können. Diese Unterstützung kann bis zu 64 IRQ-Quellen umfassen, da ein 8259A 8 IRQ-Eingänge besitzt und diese Bausteine einmal kaskadierbar sind. Als Beispiel hierzu sei auf den PC/AT verwiesen, in dem 2 ICs vom Typ 8259A kaskadiert sind.

Der IRQ-Controller ist aufgrund seiner Programmierbarkeit sehr komplex auf-gebaut; da zusätzlich noch ältere µPs unterstützt werden, sind zwei Modi vorgesehen, von denen allerdings in diesem Skript nur der für 80x86-Systeme vorgesehene behandelt werden wird. Bild 6.23 zeigt die Pinbelegung des 8259A:

Die Pins bedeuten im Einzelnen:

123456789

1011121314

2827262524232221201918171615

D2D3

D1D0

D4D5D6D7

A0

GND

CAS0

/WR/CS

CAS1

/RD /INTA

VCC

IR7IR6IR5IR4IR3IR2IR1IR0INT/SP / /ENCAS2

Bild 6.23: PIN-Belegung 8259A


/CS (I) Chip Select ist ein Eingang, an dem mit Hilfe eines aktiv low Signals aus der Dekodierung der IC angesprochen wird.

/WR (I) und /RD (I) stellen die wohlbekannten Write- und Read-Eingänge dar.

D7 - D0 (I/O) Der Datenbus ist bei diesem Baustein 8-bit breit ausgeprägt; über diese Ein-/Ausgänge werden alle Datentransfers abgewickelt.

CAS0 - CAS2 (I oder O) In einem kaskadierten System von 8259A-ICs werden diese Pins zur Kommuni-kation zwischen den verschiedenen Controllern, insbesondere vom Master zu dem/den Slave-ICs genutzt. Diese Pins sind beim Masterbaustein als Outputs, bei einer Slave-Konfigurierung als Inputs geschaltet, können aber während des Betriebs keine wechselnden Funktionen ausführen.

Datenbus

Puffer

Read/

LogikWrite

/RD

/WR

A0

/CS

Cascade

ComparatorBuffer/

CAS0

/SP / /EN

CAS1

CAS2

INServiceRegister

(ISR)

InterruptRequestRegister

(IRR)

Prioritäts-

Logik

Kontroll-Logik

INT/INTA

D0 .. 7

IR0

IR7

..

Interrupt Mask Register

(IMR)

Interner Bus

Bild 6.24 Blockschaltbild 8259A


/SP (I) / /EN (O) Dieser Pin besitzt eine duale Funktionalität, die mit verschiedenen Modi des 8259A zusammenhängen. Im so genannten 'Buffered Mode' wird die /EN-Funktion eingeschaltet, d.h., es liegt ein Ausgang vor, der Treiber via des /EN (Enable) -Ausgangs aktiv schalten kann. Im anderen Fall wird dieser Pin zum Eingang /SP (Slave Program), über den durch high Pegel ein Master, durch low Pegel ein Slave konfiguriert wird.

INT (O) übermittelt den Interrupt Request durch Einnehmen des high Pegels an die angeschlossene CPU.

IR0 bis IR7 (I) Diese Interrupt Requests stellen asynchrone Inputs dar, an denen die angeschlos-sene Peripherie die Unterbrechung signalisieren kann. Diese Pins sind Flanken-gesteuert (Low_to_high Flanke mit Halten des Pegels, bis dieser bestätigt wurde) oder Zustands-gesteuert (High Pegel bis Bestätigung) konfigurierbar.

/INTA (I) Die CPU antwortet - falls die Interruptbearbeitung nicht gesperrt ist - bei begin-nender Bearbeitung mehrfach über diesen Eingangspin (Interrupt Acknowledge), so dass bei vereinbartem Hardwareprotokoll die entsprechenden Informationen wie Interrupt-Vektornummer übermittelt werden können.

A0 (I) selektiert schließlich als Adressleitung bei Schreib- oder Lesezugriffen das entsprechende Register auf dem 8259A.

Zum Verständnis der internen Vorgänge im 8259A dient das Blockschaltbild (Bild 6.24), in dem auch einzelne Register, die softwareseitig konfiguriert werden müs-sen, eingezeichnet sind:

Die korrekte Inbetriebnahme eines 8259A beinhaltet einerseits die grundsätzliche Initialisierung des Chips, die allerdings ständig wiederholt werden kann und von einem Reset etc. unabhängig ist, sowie die kurzfristigeren Änderungen im Betrieb, z.B. die aktuelle Maskierung von Interrupts.

Die grundsätzliche Initialisierung wird durch sog. Initialization Command Words (ICWs) vorgenommen. Die Initialisierungen enthalten dabei Informationen zu

• Einzel- oder kaskadierter Betrieb

• Flanken- oder Zustandssensitven IRQs

• Vektoren-Grundadresse

• Identifikationsnummern (bei kaskadierten ICs

• 8086- oder 8080/85-Betrieb

• Modi (Buffered, Nested, automatischer EOI)


Eine Initialisierungssequenz wird immer durch einen Schreibzugriff auf die Adresse 0 mit gesetztem Datenbit D4 eingeleitet, dem sogenannten ICW1:

D7

0 (*)

D6 D5 D4

1

D3

LTIM

D2

ADI

D1

SNGL

D0

IC4

A0

0 0 (*)0 (*)

Bild 6.25 Initialisierungswort ICW1 für 8259A (nur schreibend)

In diesem ICW sind die Bits D7 bis D5 mit 0 belegt; im 8080-Mode allerdings werden hier die Adreßbits A7 bis A5 der Interrupt-Vektor-Adresse festgelegt.

LTIM legt den Triggermode fest, LTIM = 1 bedeutet Level Triggered Mode, = 0 entsprechend Edge Triggered (Flanken-getriggert). ADI = 1 legt (für 8080/85-Systeme) die Schrittweite der CALL-Aufrufe, nicht der IRQ-Vektoren, auf 4 fest, = 0 auf 8. Dies hat keinen Einfluss bei 8086.Systemen.

Das SNGL-Bit legt bei '1' fest, dass dieser 8259A der einzige IRQ-Controller an dieser Stelle ist, = 0 entsprechend, dass er sich in einem kaskadierten System befindet. Für Stand-Alone-Controller erübrigt sich die spätere Ausgabe des ICW3. IC4 = 1 stellt zum Schluss fest, dass ein 4. Wort, ICW4 benötigt wird; bei IC4 = 0 werden hingegen alle Bits, diese Initialisierung betreffend (s.u.), auf 0 gesetzt.

ICW1 startet – neben den darin bereits vorhandenen Initialisierungen - eine Sequenz von benötigten ICWs, von denen mindestens das nächste zwingend vorgeschrieben ist: ICW2

D7

T7

D6 D5 D4

T4

D3

T3

D2 D1 D0A0

1 0 (*)T6 0 (*) 0 (*)T5

Bild 6.26 Initialisierungswort ICW2 für 8259A (nur schreibend)

In ICW2, durch Schreiben an Adresse 1 des ICs einstellbar, werden die Bits 3 bis 7 des Vektors festgelegt, die dieser Controller als IRQ-Vektor später ausgeben soll. Im PC beispielsweise gibt der 1. Controller die Vektoren 8h bis 0fh entsprechend den Speicherstellen 0020h bis 003ch aus, die Initialisierung hierfür lautet also T3 = 1, T4 .. 7 = 0. Im 8080/85-Mode steht das komplette High Byte der Sprungadresse in diesem ICW2.

ICW3 wird nur erwartet, wenn es sich um ein kaskadiertes System handelt; hierbei muss auch für die Bits unterschieden werden, ob das ICW3 in den Master- oder einen der Slave-Bausteine, zu unterscheiden durch den Eingang /SP oder, gleich folgend, im ICW4, Bit 2 (M/S), geschrieben wird.


D7

S7

D6 D5 D4

S4

D3

S3

D2 D1 D0A0

1 S6 S5

Master-Device:

D7 D6 D5 D4 D3 D2 D1 D0A0

1 0

Slave-Device:

S0S2 S1

0 00 0 ID0ID2 ID1

Bild 6.27 Initialisierungswort ICW3 für 8259A (Master/Slave)

Dem Master-Device wird mit einem gesetzten Sx-Bit mitgeteilt, dass sich hinter dem korrespondierenden Eingang ein Slave-8259A befindet, bei Sx = 0 nur ein normaler IRQ-Eingang. Dem oder den Slave-Devices wird eine Identifikations-nummer, die in einem kaskadierten System natürlich eindeutig sein muss, mit Hilfe der Bits ID2 .. 0 mitgeteilt, die im späteren Betrieb mit den CAS2 .. 0-Eingängen verglichen werden, um bestimmte Aktionen ablaufen zu lassen. Die IDx-Nummer muss also mit dem Eingang IRx übereinstimmen.

ICW4 wird notwendig, falls das Bit IC4 in ICW1 gesetzt war:

D7 D6 D5 D4 D3 D2 D1 D0A0

1 0 0 SFNM0 BUF µPMM/S AEOI

Bild 6.28 Initialisierungswort ICW4 für 8259A SFNM bedeutet dabei 'Special Fully Nested Mode'; im normalen Mode werden Prioritäten an die Interrupts vergeben, höchste Priorität liegt bei IR0, niedrigste bei IR7, wobei diese Prioritäten z.B. rotieren können, um balancierte Systeme zu erhalten. Wird ein Interrupt Request zum Prozessor durchgelassen, kann dieselbe oder alle niedirger priorisierten Quellen keinen zweiten IRQ durchgeben, wohl aber die höher priorisierten.

Liegt nun ein kaskadiertes System vor, dann kann es sinnvoll sein, einen Interrupt von einem Slave, der dort eine höhere Priorität besitzt, durchzugeben, selbst wenn ein IRQ dieses Controllers schon behandelt wird. Dieser Spezialfall wird durch SFNM = 1 eingeschaltet.

BUF schaltet den gepufferten Mode ein, mit dem /SP / /EN zum Ausgang wird, um externe Treiber einschalten zu können. Dies ist für große Systeme, bei denen die Leistungsfähigkeit der 8259A-Bustreiber ggf. nicht ausreicht sinnvoll, wobei in diesem Fall die Determinierung, ob es sich um einen Master- oder Slave-Baustein handelt, durch das nachfolgende Bit, M/S geschieht. M/S = 1 bedeutet dabei Master-IC.


AEOI = 1 programmiert den automatischen End-of-Interrupt, so dass ein solches Kommando bei Beenden einer Sequenz nicht mehr durch die CPU zu programmieren ist.

µPM legt schließlich den Mikroprozessormode fest. µPM = 1 bedeutet dabei 8086-Mode, µPM = 0 entsprechend den 8080/85, so dass im PC immer ein ICW4 zu den 8259A geschickt werden muss!

Eine Beispielsequenz soll die Initialisierung des 8259A für den 8086-Mode, als Master in einem kaskadierten System mit einem Slave an der Stelle IR2 und mit der Vektorengrundadresse 8 zeigen, wobei angenommen wird, dass sich der IC bei 20h/21h adressieren lässt:

mov al, 00011101b ; ICW1 out 20h, al ; mov al, 00001000b ; ICW2, der Vektorgrundadresse en tsprechend out 21h, al ; mov al, 00000100b ; an IR2 soll ein Slave-8259A sei n out 21h, al ; ICW3 für Master-IC mov al, 00000101b ; 8086-Mode, kein AEOI, nicht-gep uffert out 21h, al ;

Im normalen Betrieb kann nun mit Hilfe der Operation Control Words (OCWs) weiter konfiguriert werden, wobei sich diese Form mehr auf Maskierungen sowie direkt ausführbare Kommandos bezieht:

OCW1 hat dabei folgende Gestalt:

D7 D6 D5 D4 D3 D2 D1 D0A0

1 M7 M6 M4M5 M1M3 M2 M0

Bild 6.29 Operation Controlwort OCW1 für 8259A

OCW1 wird als Maske für erlaubte/unterbundene IRQs an die Stelle A0 = 1 im 8259A geschrieben bzw. daraus gelesen. Ein auf '1' gesetztes Bit bedeutet dabei Maskierung, d.h. Unterdrückung des IRQs. Das dadurch adressierte Interrupt Mask Register (siehe auch Blockschaltbild) kann auf diese Weise direkt erreicht werden.

OCW2 stellt eine Art Vielzweck-Kommando dar; die Adressierung für OCW2 findet durch A0 = 0, D4 = 0 und D3 = 0 statt.

D7 D6 D5 D4 D3 D2 D1 D0A0

0 R SL EOI L1L2 L00 0


Das End-Of-Interrupt-Kommando kann auf diverse Arten gegeben werden, wichtig ist nur, dass der 8259A ein gültiges Kommando erhält, da ansonsten weitere


Aktionen im Betrieb ggf. unterbunden werden. Ist AEOI eingeschaltet, setzt sich der 8259A automatisch nach Beendigung des Handshakes mit der CPU zurück. Dieser Mode ist sinnvoll, falls die CPU selbständig für Unterbrechungsbereitschaft sorgt, und die Prioritätenvergabe keine große Rolle spielt.

In komplexeren Systemen sollte zum CPU-gesteuerten EOI übergegangen werden; dies bedeutet, dass vor Abschluss einer Interrupt-Service-Routine (ISR), die einen IRQ aus dem/den 8259A stammend bedient, ein Kommando an den betreffenden Baustein geschickt werden muss. Dieses Kommando kann ein EOI-Kommando sein, falls der 8259A selbständig entscheiden kann, welcher IRQ der höchstprio-risierteste war (Fully Nested Mode), oder es muss ein SEOI sein, falls der Special Fully Nested Mode eingeschaltet war.

Zusätzlich kann die Priorität automatisch oder durch die CPU verstellt werden, um allen Anforderungen des Gesamtsystems gerecht zu werden. Mit dem Prioritäts-kommando wird dabei z.B. der höchste Level festgesetzt, alle weiteren Prioritäten reihen sich danach ein.

OCW3 wird via A0 = 0, D4 = 0 und D3 = 1 erreicht. Dieses OCW bestimmt einen hier nicht weiter behandelten Special Mask Mode, der besonders bei komplexen Systemen mit stetiger Prioritätenänderung seine Berechtigung findet. Ferner - und dies ist an dieser Stelle wichtiger - kann ein Polling-Mode, den 8259A

D7 D6 D5 D4 D3 D2 D1 D0A0

0 0 ESMM SMM RRP RIS0 1


direkt betreffend, eingerichtet werden, bei dem die entsprechenden IRQ-Bits gesetzt sind, und es kann das nächste Register zum Auslesen festgelegt werden. Die in Bild 6.30 genannten Bits haben folgende Bedeutung:

ESMM = 1 (Enable Special Mask Mode) bedeutet, dass der Special Mask Mode eingeschaltet (SMM = 1) bzw. ausgeschaltet (SMM = 0) wird; ESMM = 0 bewirkt keine derartige Operation.

P = 1 (Poll) schaltet den Polling Mode ein, ein Mode, bei dem das ISR und das IRR direkt ausgelesen werden können, wobei als Herstellerempfehlung dann die Interrupt-Initiierung des 8259A außer Acht gelassen werden sollte. Der nächste Leseimpuls (/RD = 0, /CS = 0, A0 beliebig) ergibt dann ein Byte, bei dem D7 = 1 anzeigt, dass ein IRQ aufgetreten ist, und D2 .. 0 den höchsten Level aller aufge-tretenen IRQs angibt.

Das Auslesen von ISR und IRR kann auf folgende Weise geschehen: Ein OWC3 mit RR = 1 schaltet einen Mode ein, bei dem auf den nächsten Leseimpuls (wieder beliebige Adresse!) am 8259A das In Service Register (RIS = 1) oder das Interrupt Request Register (RIS = 0) am Datenbus ausgegeben werden. ISR bezeichnet dabei den momentan angemeldeten IRQ, IRR die zur Bearbeitung anstehenden IRQs.

Sachwortverzeichnis 121

Literatur

[Atm_DS] http://www.atmel.com/Images/doc2549.pdf

[Hab96] Marc Haberland, ”Gedächtnis ohne Ladungsträger“. Elektronik 45(26), S. 46 .. 50 (1996).

[Lee06] Tom Lee, ”Der erste kommerzielle MRAM-Baustein“. Elektronik 55(23), S. 68 .. 73 (2006).

[Sch05] Scholz, P.: Softwareentwicklung eingebetteter Systeme. Springer Verlag Berlin Heidelberg New York, 2005.

[Sie99] Christian Siemers, ”Prozessorbau“. Carl-Hanser Verlag, München und Wien, 1999.

[Sie12] Christian Siemers, „Embedded Systems Engineering Handbuch, V 0.61“.

[SS07] Christian Siemers, Axel Sikora (Hrsg.), ”Taschenbuch Digitaltechnik”. Fachbuch-verlag Leipzig im Carl Hanser Verlag, München Wien, 2. Auflage, September 2007. ISBN 978-3-446-40903-3

[unicode] http://www.unicode.org


Sachwortverzeichnis

8

8255 ........................................................ 85

8259A .................................................... 114

A

absolut indirekte Adressierung ............... 73

absolute Adressierung ............................ 73

Adressbus ................................................ 42

Adressierungsmodi ................................. 70

absolut................................................ 73

absolut indirekt .................................. 73

I/O-direkte .......................................... 71

indirekt ............................................... 72

indirekt mit Offset .............................. 72

indirekt mit Post-Inkrement ............... 72

indirekt mit Prä-Dekrement ............... 72

Register-direkt .................................... 70

relativ ................................................. 73

Speicher-direkt ................................... 71

Unmittelbare ...................................... 70

arithmetische Befehle ............................. 76

ASCII ........................................................ 12

Assembler

Beispielcode ....................................... 17

Assembler-Programm ....................... 17, 19

Assemblersprache ................................... 62

asynchroner Systembus .......................... 48

Handshake .......................................... 48

ATmega2560 ........................................... 42

Bus-Demultiplexer .............................. 52

EEPROM ............................................. 55

external memory interface................. 51

GPIO ................................................... 82

IRQ .................................................... 109

Pinbelegung ........................................ 50

Speicherinterface ............................... 57

Speichermodell .................................. 53

Sprungtabellen ................................. 109

Timer ................................................ 107

Zeitverhalten Speicherinterface ......... 52

Zugriff auf EEPROM ............................ 55

Atmega8

absolut indirekte Adressierung .......... 73

absolute Adressierung ........................ 73

I/O-direkte Adressierung .................... 71

indirekte Adressierung ....................... 72

indirekte Adressierung mit Offset ...... 72

indirekte Adressierung mit Post-

Inkrement ...................................... 72

indirekte Adressierung mit Prä-

Dekrement ..................................... 72

Register-direkte Adressierung ............ 70

relative Adressierung ......................... 73

Speicher-direkte Adressierung ........... 71

ATmega8 ................................................. 42

Adressierungsmodi ............................. 70

arithmetische Befehle ........................ 76

ATmega2560 ...................................... 42

Bitverarbeitungsbefehle ..................... 75

Carry-Flag ........................................... 64

General-Purpose Register .................. 63

I/O-Register ........................................ 66

immediate addressing ........................ 70

Interrupt Enable Flag .......................... 64

logische Befehle ................................. 76

Negative-Flag ...................................... 64

No Operation ...................................... 80

Overflow-Flag ..................................... 64

Pinbelegung ........................................ 50

Program Counter .......................... 77, 79

Programmiermodell ........................... 62

Register .............................................. 63

Registermodell ............................... 8, 62

Resetadresse ...................................... 57

Sign-Flag ............................................. 64

Speichermodell................................... 65

Sprungbefehle .................................... 77

Stack ............................................. 69, 79

Stack Funktionsweise ......................... 69

Stack Pointer ...................................... 65

Statusregister ..................................... 63

Transferbefehle .................................. 74

Unmittelbare Adressierung ................ 70

Unterprogrammbefehle ..................... 79

Zero-Flag............................................. 64


B

Befehl

arithmetisch/logische Befehle .............. 9

Kontrollflussbefehle ............................. 9

Transferbefehle .................................... 8

Befehlsbearbeitung ................................... 5

Bitverarbeitungsbefehle ......................... 75

Bussystem ........................................... 7, 42

asynchron ........................................... 48

Handshake .......................................... 48

semi-synchron .................................... 46

synchron ............................................. 44

Wartezyklus ........................................ 47

C

C

Grundaufbau ...................................... 15

Carry-Flag ................................................ 64

CAS .......................................................... 23

Code

ASCII ................................................... 12

Unicode .............................................. 12

Column Address Strobe ............. Siehe CAS

Control Unit .............................................. 4

C-Programm ............................................ 15

D

Datenbus ........................................... 42, 43

Datenfernübertragung ............................ 92

Datentypen ............................................. 11

Festkommaformat .............................. 14

Festkommazahlen .............................. 12

Gleitkommaformat ............................. 14

Integer-Zahlen .................................... 12

Komplementdarstellung ..................... 13

Vorzeichen.......................................... 13

Zweierkomplement ............................ 13

Decodierung ............................................ 61

DRAM

Blockschaltbild ................................... 24

CAS ..................................................... 23

Fehlerbehebung ................................. 28

Fehlererkennung ................................ 28

Interleaving ........................................ 26

Page Mode ......................................... 25

RAS ..................................................... 23

Refresh ......................................... 23, 26

Speicherprinzip ................................... 22

Static Column Mode ........................... 26

zeitlicher Verlauf ................................ 25

Zugriffszeit .......................................... 24

Zykluszeit ............................................ 24

Dynamic RAM.........................Siehe DRAM

E

ECC .......................................................... 28

EEPROM ............................................ 33, 55

Flash- .................................................. 35

FLOTOX-Transistor.............................. 35

EIA-232 .................................................... 98

EIA-422 .................................................... 99

EIA-485 .................................................... 98

Einerkomplement ................................... 13

Eingebettete Systeme ............................... 1

Electrically Erasable Programmable ROM ..................................... Siehe EEPROM

embedded systems ................................... 1

EPROM .................................................... 33

27256 ................................................. 35

FAMOS-Transistor .............................. 34

Erasable Programmable ROM ............ Siehe EPROM

Error Correction Code ................ Siehe ECC

F

FAMOS-Transistor ................................... 34

Programmierung ................................ 34

FeRAM..................................................... 38

Speicherzelle ...................................... 39

FIFO ......................................................... 68

Flash-EEPROM ......................................... 35

Floating Gate Tunnel Oxide TransistorSiehe FLOTOX-Transistor

Floating-Gate Avalanche MOS ........... Siehe FAMOS

FLOTOX-Transistor ............................ 35, 36

FRAM ................................... Siehe FeRAM

G

General Purpose Input/Output . Siehe GPIO


Gleitkommaformat ................................. 14

GPIO ........................................................ 82

allgemein ............................................ 91

Aufbau einer Zelle .............................. 83

Data-Direction-Register ...................... 83

High Impedance ................................. 85

PIO 8255 ............................................. 85

H

Handshake .............................................. 48

Hex-File ................................................... 18

High Impedance ...................................... 85

High-Z .......................Siehe High Impedance

I

I/O-direkte Adressierung ........................ 71

I/O-Register ............................................. 67

I²C-Bus ................................................... 100

indirekte Adressierung ............................ 72

indirekte Adressierung mit Offset ........... 72

indirekte Adressierung mit Post-Inkrement

........................................................... 72

indirekte Adressierung mit Prä-Dekrement

........................................................... 72

Inter-IC-Bus ............................ Siehe I²C-Bus

Interleaving ............................................. 26

Interrupt Enable Flag .............................. 64

Interrupt Request ........................ Siehe IRQ

Interrupt Service Routine .............. Siehe ISR

IRQ ........................................................ 107

Ablauf ............................................... 111

Anwendungen .................................. 112

IRQ-Controller 8259A ....................... 114

IRQ-Management ............................. 114

ISR .................................................... 108

Kopplung zu externen Ereignissen ... 112

Kopplung zu internen Ereignissen .... 112

Timer ................................................ 113

IRQ-Controller 8259A ............................ 114

ISR ......................................................... 108

Rahmenstruktur ............................... 112

K

Kommunikationsinterface ....................... 82

L

Linker ...................................................... 18

logische Befehle ...................................... 76

M

magnetoresistives RAM ........ Siehe MRAM

Maschinensprache .................................. 62

Mikrocontroller ....................................... 50

8-bit .............................................. 42, 46

ATmega2560 ...................................... 49

ATmega8 ............................................ 42

Definition ............................................ 81

Speicherinterface ............................... 57

SPI ....................................................... 51

Timer ................................................ 106

USART ................................................. 51

Mikrorechner .......................................... 57

Chip-Select-Leitungen ........................ 57

serielle Schnittstelle ........................... 92

Timer ................................................ 106

MRAM ..................................................... 39

Speicherzelle ...................................... 40

N

Negative-Flag .......................................... 64

Netzwerk

EIA-485 ............................................... 98

No Operation .......................................... 80

Non Volatile RAM .................................... 36

NVRAM.................................................... 36

Speicherzelle ...................................... 36

O

Overflow-Flag .......................................... 64

P

Page Mode .............................................. 25

PC ........................... Siehe Program Counter

Peripherie ............................................... 81

ADC ..................................................... 81

Aufgaben ............................................ 81

DAC ..................................................... 81


Einbindung ......................................... 19

General-Purpose Input/Output .......... 81

Klassen ............................................... 81

Kommunikationsinterface .................. 82

Signalisierung ..................................... 82

Timer .................................................. 82

Phasenpipelining ....................................... 7

PIO 8255.................................................. 85

Program Counter ................ 5, 9, 73, 77, 79

programmierbares ROM ........ Siehe PROM

Programmiermodell ................................ 62

Programmzähler ................................... 5, 9

PROM ...................................................... 33

R

RAM ........................................................ 21

DRAM ................................................. 22

FeRAM ................................................ 38

FRAM .................................................. 38

MRAM ................................................ 39

Non Volatile RAM ............................... 36

NVRAM ............................................... 36

SRAM .................................................. 28

Random Access Memory ......... Siehe RAM

RAS .......................................................... 23

Read-Only Memory .................. Siehe ROM

Refresh .............................................. 23, 26

RAS-only Refresh ................................ 26

Register-direkte Adressierung ................ 70

relative Adressierung .............................. 73

ROM ........................................................ 32

EEPROM ............................................. 33

EPROM ............................................... 33

Masken- .............................................. 33

programmierbar ................................. 33

PROM ................................................. 33

Row Address Strobe ................... Siehe RAS

RS232 ................................................ 92, 98

Signalpegel ......................................... 95

Steckernorm ....................................... 93

Synchronisation .................................. 97

S

self-contained systems ............................. 1

semi-synchroner Systembus ................... 46

Wartezyklus ........................................ 47

Serial Peripheral Interface ............ Siehe SPI

Serielle Schnittstelle ................................ 92

Sign-Flag .................................................. 64

SP ................................. Siehe Stack Pointer

Speicher

DRAM ................................................. 22

EEPROM ............................................. 33

EPROM ............................................... 33

FeRAM ................................................ 38

FRAM .................................................. 38

MRAM ................................................ 39

RAM .................................................... 21

SRAM .................................................. 28

SRAM-Speicherzelle............................ 29

Technologie ........................................ 21

Vergleich Technologien ...................... 41

Speicher-direkte Adressierung ................ 71

Speichermodell ....................................... 65

FIFO .................................................... 68

Stack ................................................... 68

Speichertechnologie ............................... 21

SPI ................................................... 51, 103

Protokollablauf ................................. 104

Sprungbefehle ......................................... 77

SRAM ...................................................... 28

62256 ................................................. 31

Blockstruktur ...................................... 30

Speicherzelle ...................................... 29

Vorteile ............................................... 32

SREG ............................ Siehe Statusregister

Stack .................................................. 68, 79

Funktionsweise ................................... 69

Stack Pointer ........................................... 65

Static Column Mode................................ 26

Statisches RAM ...................... Siehe SRAM

Statusregister .......................................... 63

Steuerbus ................................................ 42

Steuerwerk ................................................ 4

synchroner Systembus ............................ 44

Systembus

asynchron ........................................... 48

semi-synchron .................................... 46

synchron ............................................. 44

Wartezyklus ........................................ 47

T

Timer ....................................... 82, 106, 113


Input Capture ................................... 106

Output Compare .............................. 106

Transferbefehle....................................... 74

Tristate .................................................... 85

TWI ................................................ Siehe SPI

Two-Wires-Interface ..................... Siehe SPI

U

Übertrags-Flag ........................................ 64

Universalrechner ....................................... 3

Unmittelbare Adressierung ..................... 70

Unterbrechungsanforderung ....... Siehe IRQ

Unterprogrammbefehle .......................... 79

USART ................................................... 112

Blockierende Senderoutine .............. 113

V

Variable

char .................................................... 16

int ....................................................... 18

Von-Neumann-Flaschenhals ..................... 7

Von-Neumann-Modell

Adressbus ........................................... 42

Datenbus ...................................... 42, 43

Peripherie ........................................... 81

Steuerbus ........................................... 42

Verbindungswege ............................... 42

Von-Neumann-Rechner ............................ 3

arithmetisch/logische Befehle .............. 9

Befehlsbearbeitung .............................. 5

Bussystem ............................................ 7

CPU ....................................................... 3

Datentypen ......................................... 11

Flaschenhals ......................................... 7

Kontrollflussbefehle ............................. 9

Programmzähler ............................... 5, 9

Transferbefehle .................................... 8

Zentraleinheit ....................................... 3

Vorzeichen-Flag....................................... 64

W

Wait State ..................... Siehe Wartezyklus Wartezyklus ............................................ 47

Z

Zahlensystem

Dezimalsystem ................................... 10

Dualsystem ......................................... 10

Hexadezimalsystem ............................ 10

Oktalsystem ........................................ 10

polyadisch .......................................... 10

Sedezimalsystem ................................ 10

Zero-Flag ................................................. 64

Zweierkomplement ................................. 13

Documents

Embedded Systems Engineering 1 V2.00 Release 0.81 WS … · Die eingebetteten Systeme übernehmen komplexe Steuerungs-, Regelungs- und Datenverarbeitungsaufgaben für bzw. in diesen