Assembler-Direktiven - Netzmafia

Mikrocomputertechnik

Mikrocomputertechnik 

Table of Contents 

Mikrocomputertechnik................................................................................................................1 

Mikrocomputertechnik..........................................................................................................................1 

Inhalt............................................................................................................................................1 

1 Einführung.........................................................................................................................1 

2 Hardware von Mikrocomputern.........................................................................................1 

3 Programmierung des Mikroprozessors 68HC11................................................................1 

4 Prozessor des Systems 68HC11.........................................................................................1 

5 Peripherie des Systems 68HC11........................................................................................2 

6 Ausblick: andere Controller...............................................................................................2 

Anhang..................................................................................................................................2 

Jack Kilby: der Vater des Mikrochips..................................................................................3 

Mikrocomputertechnik..........................................................................................................4 

Prolog.......................................................................................................................................................6 

1 Einführung...........................................................................................................................................7 

1.1 Von-Neumann-Architektur....................................................................................................8 

Vorteile der v. Neumann-Architektur:................................................................................11 

1.2 Befehlszyklus......................................................................................................................11 

Ablauf des Befehlszyklus...................................................................................................13 

1.2 Erhöhung der Leistungsfähigkeit........................................................................................14 

Vermeiden oder Mildern des v. Neumann-Flaschenhalses.................................................14 

1.4 Die Harvard-Architektur.....................................................................................................16 

RISC "Reduced Instruction Set Computer"........................................................................16 

1.5 Begriffe................................................................................................................................16 

Mikrocomputer:..................................................................................................................16 

1.6 Entwicklung.........................................................................................................................17 

Mikrocomputer als Ersatz festverdrahteter Logik..............................................................18 

Einsatzbeispiele:.................................................................................................................19 

Mikrocomputer als Universalrechner.................................................................................19 

1.7 Embedded Systems..............................................................................................................22 

Design von Embedded Systems..........................................................................................22 

Mikrocomputertechnik........................................................................................................23 

2 Hardware von Mikrocomputern......................................................................................................23 

2.1 Struktur eines Mikrocomputers...........................................................................................23 

Prinzipieller Aufbau............................................................................................................23 

Der System-Bus..................................................................................................................24 

Bus-Treiber.........................................................................................................................25 

Systembeispiel....................................................................................................................25 

2.2 Mikroprozessor....................................................................................................................26 

Versorgung und Steuerung.................................................................................................26 

Steuerungs-Signale.............................................................................................................28 

2.3 Arbeitsspeicher....................................................................................................................28 

Speicher-Bausteine.............................................................................................................29 

Zusammenschalten von Speicherbausteinen.......................................................................30 

2.4 Ein-/Ausgabe-Bausteine......................................................................................................30 

Struktur von E/A-Bausteinen..............................................................................................33 

Steuerung von E/A-Bausteinen...........................................................................................34 

Anschluß von E/A-Bausteinen............................................................................................35 

Programmgesteuerter E/A-Transfer (Polling).....................................................................36 

i



2 Hardware von Mikrocomputern 

Direktspeicherzugriff (DMA = Direct Memory Access)....................................................37 

2.5 Timer (Zeitgeber)................................................................................................................38 

2.6 Systemkonfigurationen........................................................................................................38 

Aufteilung des Adreßraums................................................................................................39 

Systembeispiel....................................................................................................................40 

Beispiele zur Systemkonfiguration.....................................................................................42 

2.7 Programmunterbrechungen.................................................................................................45 

Unterbrechungsgesteuerter E/A-Transfer...........................................................................46 


3. Programmierung des Mikroprozessors 68HC11...........................................................................47 

3.1 Überblick.............................................................................................................................47 

Programmiermodell............................................................................................................48 

Einteilung der Befehle........................................................................................................49 

3.2 Adressierungsarten..............................................................................................................50 

Konstanten-Adressierung (Immediate Addressing)............................................................50 

Absolute Adressierung........................................................................................................51 

Implizite Adressierung (Inherent Addressing)....................................................................51 

Indizierte Adressierung (Indexed Addressing)...................................................................52 

3.3 Assembler-Befehlsaufbau....................................................................................................54 

1. Quellcode........................................................................................................................55 

3.4 Pseudobefehle (Assembler-Direktiven)...............................................................................56 

Speicher-Organisation.........................................................................................................57 

Grundsätzlicher Aufbau eines 68HC11-Assemblerprogramms..........................................59 

3.5 CPU-Befehle........................................................................................................................59 

Transport-Befehle...............................................................................................................61 

Arithmetische Befehle........................................................................................................64 

Logische Befehle................................................................................................................66 

Schiebe- und Rotationsbefehle...........................................................................................68 

Test- und Statusregisterbefehle...........................................................................................69 

Bitorientierte Befehle..........................................................................................................70 

Beeinflussung des Systemzustands.....................................................................................70 

Sprungbefehle.....................................................................................................................74 

Unterprogrammsprünge (jump/branch to subroutine)........................................................76 

Programmunterbrechungsbefehle.......................................................................................76 

Reine Verzögerungsbefehle................................................................................................76 

3.6 Stapelspeicher (Stack).........................................................................................................77 

Befehle für den Stack-Zugriff.............................................................................................77 

Anwendung des Stack.........................................................................................................78 

3.7 Unterprogramme (Subroutines)...........................................................................................79 

Unterprogramm-Sprungbefehle..........................................................................................79 

Parameter-Übergabe...........................................................................................................81 

3.8 Interrupts (Programmunterbrechungen)..............................................................................82 

Interruptsystem des 68HC11:.............................................................................................84 


4. Bausteine des Systems M68HC11...................................................................................................85 

4.1 Mikroprozessor 68HC11.....................................................................................................85 

Der Prozessor......................................................................................................................86 

Die wichtigsten Anschlußpins............................................................................................87 

Reset....................................................................................................................................88 

ii



4. Bausteine des Systems M68HC11 

Der Bus...............................................................................................................................88 

Der Speicher........................................................................................................................89 

Asynchrone serielle Schnittstelle........................................................................................89 

Timer-System......................................................................................................................90 

Digitale Ein- und Ausgänge................................................................................................91 

Impulszähler........................................................................................................................91 

Analog-Digital-Wandler.....................................................................................................91 

Synchrone serielle Peripherieschnittstelle..........................................................................92 

4.2 Typische Anwendungsschaltung.........................................................................................93 

Stückliste für das Mikrocontroller-Board...........................................................................94 

4.3 Praktikumssystem PS11 mit M68HC11A0.........................................................................94 

Blockschaltung....................................................................................................................94 

Praktikumsrechner mit Experimetierboard.........................................................................95 

Der ZWERG11plus.............................................................................................................96 

Anschluß des "Zwerg 11" an den PC..................................................................................96 

Belegung des Schnittstellenkabels und des Experimentierboards......................................97 

Bootloader Firmware for MC68HC11A8 (essentials)........................................................98 


5. Peripherie des Systems M68HC11..................................................................................................99 

5.1 Peripherie-Register............................................................................................................100 

5.2 Parallele Schnittstellen......................................................................................................101 

Port A................................................................................................................................102 

Port B und STRB..............................................................................................................102 

Port C und STRA..............................................................................................................103 

Port D................................................................................................................................104 

Port E................................................................................................................................104 

Programmbeispiele...........................................................................................................107 

5.3 Serielle Schnittstellen........................................................................................................107 

SCI (serial communication interface asynchronous)........................................................110 

SPI (serial peripherial interface synchronous)..................................................................110 

Programmbeispiele...........................................................................................................114 

5.4 Zähler.................................................................................................................................116 

Der Timer..........................................................................................................................126 

5.5 Geschützte Register...........................................................................................................127 

5.6 Interrupts............................................................................................................................128 

Auslösen einer Unterbrechung..........................................................................................137 

Mikrocomputertechnik......................................................................................................138 

6 Ausblick: andere Controller...........................................................................................................138 

6.1 Atmel-Mikrocontroller......................................................................................................138 

Beispiel: Blockschaltung des ATTtiny.............................................................................142 

6.2 PIC-Microcontroller von Microchip..................................................................................143 

Beispiel: Blockschaltung und Pins des PIC16F84............................................................147 

6.3 MSP-430-Microcontroller von Texas Instruments............................................................147 

Blockschema des MSP430................................................................................................149 

6.4 8051-Microcontroller........................................................................................................149 

Blockschema des 8051......................................................................................................150 


iii



7 Anhang..............................................................................................................................................151 

7.1 Literatur und Links............................................................................................................151 

Literatur.............................................................................................................................152 

68HC11 Links...................................................................................................................153 

7.2 Tips zur Programmierung..................................................................................................154 

Grundlegende Prinzipien:.................................................................................................154 

Programm-Dokumentation...............................................................................................155 

7.3 ASCII-Tabelle...................................................................................................................155 

ASCII Tabelle (sedezimal)...............................................................................................155 

7.4 I/O-Register.......................................................................................................................160 

7.5 Interrupt-Adressen.............................................................................................................160 

7.6 Das Motorola-S-Format.....................................................................................................161 

Copyright © FH München, FB 04, Prof. Jürgen Plate......................................................161 


Programmbeispiel-Sammlung...........................................................................................................162 

Den folgenden "Programmschnipseln" fehlt noch das "Drumrum" (Definitionen von 

Variablen, Hauptprogramm, usw.). Sie dienen der Illustration verschiedener 

Programmiertechniken in Assembler.....................................................................................162 

Allgemeiner Vorspann für's Praktikum............................................................................170 

Nützliche Unterprogramme..............................................................................................175 

Komplette Programmbeispiele..........................................................................................184 


Praktikum Mikrocomputer...............................................................................................................185 

Allgemeines.............................................................................................................................185 

Installation der IDE-Software...........................................................................................185 

Einschalten und Starten.....................................................................................................186 

Programm-Namen und Ordner SAVE..............................................................................186 

Beenden und Abschalten...................................................................................................186 

Bearbeiten eines Quellprogramms....................................................................................187 

Übersetzen eines Quellprogramms (source code).............................................................188 

Simulieren eines Zielprogramms (object code)................................................................190 

Tools → Load in Target.....................................................................................................190 

Arbeiten mit der seriellen Schnittstelle.............................................................................190 

Hinweise zur Programmerstellung....................................................................................191 

Tools → Terminal..............................................................................................................192 

Belegung des Experimentier-Boards................................................................................193 

Beschaltung der Eingänge des 68HC11............................................................................195 

Anhang: Binär zu ASCII-Decodierung (hx4a).................................................................196 


Praktikum Mikrocomputer...............................................................................................................197 

Versuch 1: Parallel-Ports, Unterprogramme, Zeitverzögerungen...........................................198 

Versuch 2: Parallel-Ports, 7-Segmentanzeige, Tabellenzugriff..............................................200 

Versuch 3: Serielle Schnittstelle, ASCII-Zeichenketten.........................................................202 

Versuch 4: Zähler, bedingte Unterbrechungen........................................................................203 

Anhang: Binär zu ASCII-Decodierung (hx4a).................................................................title 

iv

Inhalt 

1 Einführung 

1. Von-Neumann-Architektur 

2. Verbesserung der Leistungsfähigkeit 

3. Befehlszyklus 

4. Harvard-Architektur 

5. Begriffe 

6. Entwicklung 

7. Embedded Systems 


1. Struktur eines Mikrocomputers 

2. Mikroprozessor 

3. Arbeitsspeicher 

4. E/A-Bausteine 

5. Timer (Zeitgeber) 

6. System-Konfiguration 


3 Programmierung des Mikroprozessors 68HC11 

1. Überblick 

2. Adressierungsarten 

3. Assembler-Befehlsaufbau 

4. Pseudobefehle (Assembler-Direktiven) 

5. CPU-Befehle 

6. Stapelspeicher (Stack) 

7. Unterprogramme (Subroutines) 

8. Interrupts (Programmunterbrechungen) 

4 Prozessor des Systems 68HC11 

1. Mikroprozessor 68HC11 

2. Typische Anwendungsschaltung 

3. Praktikumssystem PS11 mit M68HC11A0 

5 Peripherie des Systems 68HC11 

1. Peripherie-Register 

2. Parallele Schnittstellen 

3. Serielle Schnittstellen 

4. Zähler 

5. Geschützte Register 

6. Interrupts 

Mikrocomputertechnik 1

6 Ausblick: andere Controller 

1. Atmel AVR 

2. Microchip PIC 

3. Texas Instruments MSP430 

4. Intel 8051 

Anhang 

1. Literatur 

2. Tips zur Programmierung 

3. ASCII-Tabelle 

4. I/O-Register 

5. Interrupt-Adressen 

6. Das Motorola S-Format 

7. Programmbeispiel-Sammlung 

8. 68HC11 Kurz-Befehlstabelle (PDF, 80 KByte) 

9. 68HC11 A8 Reference Manual (PDF, 3,8 MByte) 

10. 68HC11 Reference Manual (PDF, 7,6 MByte) 

11. What's a Microcontroller? (Parallax Inc., 5,15 MByte) 

12. Hinweise zur Software-Sammlung 

13. Praktikumsanleitung 

14. Versuche 1 bis 4 

15. Muster-Prüfungsaufgaben 

Skript als PDF (aus HTML konvertiert) 

Download des gesamten Skripts 


Mein besonderer Dank gilt dem Kollegen Prof. Peter Schwalb, der mir viele seiner Grafiken zur 

Verfügung gestellt hat. 

Jack Kilby: der Vater des Mikrochips 

Jack Kilby baute 1958 den ersten integrierten Schaltkreis 

zusammen und legte damit die Grundlage für alle modernen 

Computerchips. Und das ist nur die bekannteste seiner 

Erfindungen. 

Der Physik-Nobelpreisträger Jack Kilby starb am 20.6.2005 im Alter von 81 Jahren nach einem 

Krebsleiden in Dallas. 

Bereits am 12. September 1958 präsentierte der Physiker den ersten Mikrochip in den Labors von 

Texas Instruments. Schon der erste Chip war nicht größer als eine Heftklammer. Mit geliehenen 

Werkzeugen hatte Kilby den ersten integrierten Schaltkreis konstruiert. 

Für Texas Instruments entwickelte Kilby Chipanwendungen für Militär, Industrie und Wirtschaft. Von 

1978 bis 1984 war der Amerikaner Professor an der Texas A&M Universität. In den letzten Jahren 

6 Ausblick: andere Controller 2

machte Kilby außerdem mit der Entwicklung verbesserter Systeme zur solaren Energiegewinnung von 

sich reden. 

Kilby besaß 60 Patente und ermöglichte unter anderem die Entwicklung des Taschenrechners und des 

Handys. "Es gibt heute praktisch kaum noch einen Bereich des Lebens, der nicht irgendwie durch die 

integrierte Halbleiterschaltung beeinflusst wird", sagte Richard Templeton, President von Texas 

Instruments. 

Im November 1993 erhielt Kilby das japanische Pendant zum Nobelpreis, den Kyoto-Preis. Ein 

Mitarbeiter von TI soll über ihn gesagt haben: "Jack hat die angeborene Fähigkeit, Probleme anders zu 

sehen, als es die meisten von uns tun. Ich denke, dass der neugierige Geist des Erfinders dahinter 

steckt." 

Nach der Verleihung des Nobelpreises im Jahr 2000 verbrachte Kilby seine letzten Jahre als Berater 

von Texas Instruments und auf Vortragsreisen um die Welt. Kilby hinterlässt zwei Töchter, einen 

Schwiegersohn und fünf Enkeltöchter. 

Im Jahr 2000 war Kilby zusammen mit dem Deutschen Herbert Kroemer und dem Russen Zhores 

Alferov der Physik-Nobelpreis verliehen worden. Kilby wurde für seine bahnbrechenden Arbeiten am 

Mikrochip ausgezeichnet. Der Inhaber von 60 Patenten war auch an der Entwicklung des 

Taschenrechners und des Thermoprinters beteiligt. 

Kilbys erster integrierter Schaltkreis 

hatte optisch keine große Ähnlichkeit mit 

heutigen Chips 

Copyright © FH München, FB 04, Prof. Jürgen Plate 

Letzte Aktualisierung: 07. Okt 2012 


In seinem alten Notizbuch befindet sich 

das Originaldesign von Kilbys Chip 


Prof. Jürgen Plate 

Jack Kilby: der Vater des Mikrochips 3

Prolog 

In dieser Vorlesung erfahren Sie, wie Computer funktionieren und dass es sich bei einem Computer 

lediglich um ein synchrones Schaltwerk oder einen Verbund mehrerer synchroner Schaltwerke 

handelt. Die Programmierung erfolgt dabei in einer maschinennahen Sprache, bei der die elementaren 

Befehle des Computers lediglich durch mnemotechnische Bezeichnungen etwas verständlicher sind, 

als der reine Binärcode. Das Programm zum Übersetzen der sogenannten Mnemonics in den 

Binärcode wird "Assembler" genannt, weshalb die Programmiersprache in der Regel auch 

"assemblersprache" heisst. 

Dass die Vorstellungen /uuml;ber Mikrocpmputer, PCs und sogenannte Heimcomputer früher nicht 

immer ganz klar waren, beweist das folgende Bild, dass ich samt Bildunterschrift im Internet fand. Es 

sollte angeblich aus der Zeitschrift "Popular Electronics" stammen: 

Sehr viel sp&aumL;ter entpuppte sich das Bild als Hoax, eine Photomontage. Es handelt sich um das 

Photo eines U-Boot-Kontrollstands (Stromversorgung, Dampf etc.) aus einer Ausstellung des 

Smithsonian's National Museum of American History, das leicht modifiziert und in ein Graustufenbild 

umgewandelt wurde: 

Prolog 4


Siehe auch: 

http://www.museumofhoaxes.com/hoax/photo_database/image/home_computer_of_the_future/ 

Auch heute sollten Sie nicht immer alles glauben, was Ihnen über die Leistung und Möglichkeiten von 

Computern erzählt wird. 

Prolog 5

1 Einführung 

Mikro-Computer sind sehr kompakte Computersysteme auf der Basis integrierter Steuer- und 

Verarbeitungsbausteine (Mikroprozessoren, Mikrocontroller) und Speicher (VLSI und 

ULSI-Bausteine) für allgemeine und spezielle DV-Anwendungen (z. B. Steuerung, Regelung): 

• Tisch-/Personal-Computer (PC), 

• Einplatinen-Computer (embedded systems), 

• Ein-Chip-Computer. 

Der folgende Überblick zeigt die Entwicklung des Computers seit Mitte des 20. Jahrhunderts. Mit 

Fortschreiten der Integration wurden die Rechner auch immer billiger und kleiner. 

Zeitraum Schaltungstechnik Verbreitung Programmierung Geschwindigkeit 

1945-1955 Relais, Röhren 

wenige 

Exemplare 

Steckbrett, 

Maschinencode 

10 3 Op./s 

1955-1965 Transistoren, Dioden Hunderte Assembler, FORTRAN 10 4 Op./s 

1965-1980 Integrierte Schaltungen Tausende 

ab 1980 

Hoch integrierte 

Schaltungen (VLSI) 

Millionen 

höhere 

Programmierspachen 

höhere 

Programmiersprachen 

10 6 Op./s 

> 10 7 Op./s 

Handelte es sich bei den ersten Systemen noch um nur in wenigen Stückzahlen gefertige Geräte mit 

hohen Anschaffungs- und Betriebskosten sowie riesigem Platzbedarf und geringer Zuverlässigkeit, so 

beanspruchen die die ab 1955 entwickelten Maschinen ihre Rolle als erste kommerziell erfolgreiche 

Systeme. 

Die Fortschritte der Fertigungstechnik erlauben eine immer weiter voranschreitende Packungsdichte 

der integrierten Schaltungen und verbilligen gleichzeitig deren Herstellung. Mit dem Personal 

Computer (PC) und den Heimcomputern (denen nur eine kurze Lebendauer beschieden war) begann 

der Einzug der Mikrocomputer und Mikrocontroller in alle Lebensbereiche. Heute enthält 

beispielsweise ein Mittelklassse-PKW eine zweistellige Anzahl vom Mikrocontrollern. 

Parallel zur Entwicklung der CPU entwickelte sich die Landschaft der zugehörigen Peripherie. Die 

erste Rechnergeneration verfügte noch über keine dedizierten Peripheriegeräte. Eingaben wurden 

direkt, durch Schalttafeln und Erstellung von Hardwareverbindungen, an der Maschine vorgenommen. 

Ausgaben erfolgten über Lampen oder andere Signalgeber. Ab den 1955er Jahren finden sich 

zunehmen externe Geräte zur Abwicklung und dauerhaften Speicherung der verarbeiteten Daten und 

Programme. Es begann mit Lochstreifen, die später durch Lochkarten abgelöst wurden. Als Ein- und 

Ausgabegerät kamen modifizierte Fernschreiber oder entsprechend angepasste elektrische 

Schreibmaschinen hinzu. Später wurden sie von Textbildschirmen abgelöst. Bei Embedded Systemen 

(Computersysteme, die in Geräten zur Steuerung dienen) gibt es meist keine Peripherie im klassischen 

Sinn, sondern dort fungieren Sensoren und Aktoren (Relais, Motoren etc.) als Ein- und Ausgabe. 

Wesentliches Element einer Rechnerarchitektur ist der Prozessor (engl. central processing unit, CPU), 

der die Hauptteile der Verarbeitung übernimmt. Der stetiger Leistungszuwachs der CPU richtete sich 

in der Vergangenheit nach dem Moore'schen Gesetz, das auf Basis empirischer Daten eine 

Verdopplung der Transistorenanzahl pro Chip (und damit der Leistungsfähigkeit) alle anderthalb Jahre 

voraussagt. 

Aktuelle Prozessoren folgen dem folgenden schematischen Aufbau, der die zentralen 

Architekturkomponenten Leitwerk, Rechenwerk (arithmetic and logic unit, ALU), Registersatz und 

typischerweise den Mikroprogrammspeicher umfaßt. 

1 Einführung 6


Diese, nach dem Erfinder als "von-Neumann-Architektur" bezeichnete, Architektur prägt den Aufbau 

von Rechenanlagen seit den 1950er Jahren und gilt im Kern bis heute (siehe unten). Einige Engpässe 

der von-Neumann-Architektur beruhen auf der Gleichbehandlung von Daten und darauf arbeitenden 

Programmen und der sequenziellen Verarbeitung. 

Moderne CPU-Architekturen (z. B. Intel Pentium, AMD Athlon und Power PC) verfügen innerhalb 

einer CPU über mehrere Rechenwerke, insbesondere solche für Fest- und Gleitkommaoperationen. 

Das Leitwerk steuert den gesamten Verarbeitungsfluss. Zur Regelung der Verarbeitung speichert das 

Leitwerk prozessorinterne Zustände (Status von Berechnungen und Fehlerindikatoren) in 

CPU-internen Speichern, den sog. Registern. 

Der Registersatz wird durch eine Reihe von Speicherzellen, die direkt in der CPU untergebracht sind 

realisiert. Diese Speicherform stellt die schnellste und gleichzeitig teuerste Form des Speichers dar. 

Register besitzen typischerweise eine feste Länge, die mit der verarbeitbaren Wortlänge der CPU 

korrespondiert. Häufig werden die zur Verfügung stehenden Register bezüglich ihrer Funktionsweise, 

d.h. ihres Einsatzgebietes unterschieden, da oftmals nicht jedes Register für jeden Maschinenbefehl 

zur Verfügung steht. Minimalanforderung an einen Registersatz ist die Bereitstellung eines 

Befehlszählers (Befehlszeigerregister, engl. Instruction Pointer Register), der die Adresse des 

nächsten abzuarbeitenden Befehls enthält. 

Darüber hinaus sind Register zur Aufnahme des Rechenergebnisses (Akkumulator) und zur Aufnahme 

von Adressen (Stackpointer, Indexregister) sowie ein Status- und Kontrollregister üblich. 

1.1 Von-Neumann-Architektur 

Im Jahre 1944 legte John von Neumann, ein ehemaliges Mitglied des ENIAC-Projektes, ein 

Architektur-Konzept für einen speicherprogrammierten Universalrechner vor. Sein erster Entwurf ist 

heute als "von-Neumann-Maschine" oder "von-Neumann-Architektur" bekannt - ein weitsichtiges und 

visionäres Konzept, das auch noch aktuellen Computern zugrunde liegt. Eine 

Von-Neumann-Maschine weist folgende wichtige Merkmale auf: 

1.1 Von-Neumann-Architektur 7

• Steuerwerk, Leitwerk (Befehlsprozessor), das den Programmablauf steuert. Die Befehle 

werden interpretiert und deren Ausführung veranlasst, gesteuert und überwacht 

(Ablaufsteuerung zur Bearbeitung der Befehle). 

• Rechenwerk (Datenprozessor), das die zu bearbeitenden Daten verknüpft und verändert. Dern 

Kern bildet die ALU (Arithmetical and Logical Unit) zur Bearbeitung der Daten. 

• Speicher, der sowohl Programmbefehle als auch Daten aufnimmt (Hauptspeicher, 

Arbeitsspeicher, Main Memory). Die Daten/Befehle liegen binär verschlüsselt, also als 

0/1-Folgen vor. Prinzipiell besteht kein Unterschied zwischen Daten und Befehlen. 

Unterteilung in Speicherplätze (Speicherzellen, Speicherworte), die über Adressen 

angesprochen werden. 

• Ein- und Ausgabewerk (E/A-Prozessoren), welche die Schnittstelle zur Außenwelt 

(Peripherie) bilden. Zusammen mit den E/A-Geräten besorgen sie die Kommunikation mit der 

realen Umwelt. 

Leitwerk und Rechenwerk bilden die zentrale Verarbeitungseinheit (CPU, Prozessor). 

Die Struktur des Rechners ist unabhängig von dem zu bearbeitenden Problem ( Universalrechner). 

Die verschiedenen Aufgaben werden durch entsprechende Programme gelöst. Programme und von 

diesen benötigte Daten werden in einem gemeinsamen Speicher abgelegt. Die Speicherplätze sind 

gleichlang und werden über Adressen einzeln angesprochen. 

Die bedeutendste Neuerung war von Neumanns Idee, Programm und Daten zuerst in den Speicher zu 

laden und dann auszuführen. Bis dahin war das Programm noch hardwaremäßig verschaltet oder 

wurde über Lochstreifen schrittweise eingelesen und sofort (streng sequentiell) bearbeitet. Nun war es 

möglich: 

• Sprünge aufgrund logischer Entscheidungen auszuführen 

• Programmcode während des Programmablaufes zu modifizieren 

Von Neumann erreichte mit seinem Konzept, dass der Rechner selbstständig logische Entscheidungen 

treffen kann. Damit ist der Übergang vom starren Programmablauf zur flexiblen Programmsteuerung 

vollzogen. 

Vorteile der v. Neumann-Architektur: 

(Dies ist der Hauptgrund für ihre Langlebigkeit) 


• Einfachheit (übersichtlich, minimaler HW-Aufwand) 

• maximale Flexibilität (bei genügend elementaren Befehlen) 

Vorteile der v. Neumann-Architektur: 8

Nachteile der v. Neumann-Architektur: 

• Im Speicher kann man Befehle und Daten nicht unterscheiden. 

• nur ein Verbindungsweg zwischen CPU und Speicher (zwischen CPU und Speicher wird 

immer nur ein Wort transportiert) 

• sequentielle Verarbeitung von Befehl und Datum 

Da Daten und Befehle im Speicher gehalten werden, wird die Verbindung und Datenübertragung 

zwischen CPU und Speicher bzw. zur Ein-/Ausgabe über den Systembus zum sogenannten 

Von-Neumann-Flaschenhals. Jeglicher Datenverkehr von und zur CPU wird über den internen Bus 

abgewickelt, dessen Transfergeschwindigkeit langsamer ist, als die Verarbeitungsgeschwindigkeit der 

CPU. Dieses Problem versucht man in modernen Prozessoren durch die Verwendung von schnellem 

Cache-Speicher, der meist in der CPU integriert ist, abzuschwächen. 

Operationsprinzip 


Die CPU kann nur elementare, (fest verdrahtete) Befehle verarbeiten ( Maschinenbefehle). Jedes 

Programm besteht also aus einer Folge elementarer Befehle. Da im Speicher nicht zwischen Daten 

und Befehlen unterschieden wird, muss das Leitwerk entscheiden, ob der Inhalt einer Speicherzelle als 

Befehl oder Datum aufzufassen ist. Es gibt somit zwei Zustände des Rechners: Befehl holen 

(Interpretieren als Befehl) und Befehl ausführen (Interpretation als Datum). Entsprechend gibt es zwei 

Phasen der Programmabarbeitung: 

• 1. Phase: Der (durch den sogenannten Befehlszähler) referierte Speicherplatzinhalt wird 

geholt und als Befehl interpretiert (Befehlsholphase, instruction fetch) 

• 2. Phase: Der Speicherplatzinhalt der durch den Befehl spezifizierten Adresse wird geholt, als 

Datum interpretiert und dem Befehl entsprechend verarbeitet (Befehlsausführungsphase, 

instruction execution) 

Dieses Zweiphasenschema erfordert eine streng sequentielle Ausführung eines Programms, d.h. es 

sind zwar Sprünge möglich, jedoch keine parallele Bearbeitung mehrerer Befehle. Ein v. 

Neumann-Rechner bearbeitet zu jedem Zeitpunkt immer nur einen Befehl, der immer eine 

Datenoperation im Rechenwerk bewirkt. 

Komponenten der von-Neumann-Rechnerarchitektur 



Die CPU besteht aus Recheneinheit (ALU) und Steuereinheit. Die ALU hat eine feste Wortbreite, z. 

B. 8, 16, 32 oder 64 Bit, ihre Aufgabe besteht in der Bearbeitung der Daten, besonders dem Ausführen 

von arithmetischen und logischen Operationen. 

Zur wichtigsten Aufgabe der Steuereinheit gehört die Koordination der zeitlichen Abläufe im 

Rechner. Dazu muss die Steuereinheit die Befehle aus dem Speicher holen, entschlüsseln und deren 

Ausführung steuern. Die Steuereinheit besteht aus Befehlsregister, Befehlsdecoder, 

Speicheradressregister und Befehlszähler (Program Counter). 

Der Speicher eines von-Neumann-Rechners besteht aus einer Vielzahl von Speicherworten, die 

wahlfrei adressiert werden können. 

Innerhalb eines von-Neumann-Rechners erfolgt der Datentransport auf internen Datenwegen, den 

Bussen: 

• Der Datenbus wird normalerweise parallel übertragen, d. h. bei einem 32-Bit-System besteht 

der Datenbus aus 32-Leitungen. Er transportiert Speicher- oder E/A-Daten von und zur CPU. 

• Der Adressbus besteht aus den Adressleitungen, deren Anzahl vom Adressbereich der CPU 

abhängt. 

• Der Steuerbus koordiniert den Zugriff auf die Komponenten und enthält u. a. Leitungen für 

die Interrupt-Steuerung, Buszugriffssteuerung, der Taktung, Reset- und Statusleitungen. 


1.2 Befehlszyklus 

Das folgende Bild zeigt den prinzipiellen Ablauf bei Bearbeiten eines Befehls. 

• Im Befehlsregister (IR, Instruction Register) befindet sich jeweils der aktuell bearbeitete 

Befehl 

• Der Befehlsdecoder entschlüsselt den Befehl und erzeugt die zur Ausführung notwendigen 

Hardware-Steuersignale 

• Im Speicheradressregister (MAR, Memory Adress Register) steht die Adresse des nächsten 

auszuführenden Befehls oder die Adresse eines Datenwortes, falls zur Ausführung eines 

Befehls ein Datenwort vom Speicher geholt bzw. in den Speicher gebracht werden muss. 

• Der Befehlszähler (PC, Program Counter) enthält die Adresse des nächsten auszuführenden 

Befehls. 

Der Befehlszyklus wird also von der CPU ständig durchlaufen: 

• die Befehle stehen im Speicher. 

• das Leitwerk "weiß" jederzeit, welcher Befehl als nächster auszuführen ist. 

• die Adresse (= Nummer der Speicherzelle) des nächsten auszuführenden Befehls steht in 

einem speziellen Register des Leitwerks, dem Befehlszähler (Program Counter, PC, BZ, 

Instruction Address Register, IAR, Instruction Pointer, IP). 

• üblicherweise stehen aufeinanderfolgende Befehle in aufeinander folgenden Speicherzellen, 

der zuerst auszuführende Befehl hat die niedrigste Adresse. 

• zu Beginn des Programms wird der BZ mit dessen Startadresse geladen. 

Ablauf des Befehlszyklus 


1.2 Befehlszyklus 11


In der Befehlsholphase erfolgt ein Speicherzugriff (1a) auf die vom Befehlszähler (BZ) angezeigte 

Adresse. Der entsprechende Befehl wird in das Befehlsregister (IR) des Leitwerks gebracht (1b). 

Anschließend wird der BZ um 1 erhöht. Er zeigt damit auf den nächsten Programmbefehl. Besteht ein 

Befehl aus mehreren Speicherworten, setzt sich diese Phase auch aus mehreren Speicherzugriffen 

zusammen (BZ wird jedes Mal erhöht), bis der Befehl vollständig im IR steht. Es erfolgt hier in der 

Befehlsholphase bereits eine Teilauswertung des Operations-Codes (s. Grafik). Das Befehlsregister 

besteht hier aus Op-Code-Register (OR, Befehlsregister) und Adress-Register (AR). 

Der Befehl im OR wird nun decodiert (Befehlsdecoder) und der Ablaufsteuerung zugeführt. Diese ist 

in der Regel als Mikroprogramm realisiert. Die Ablaufsteuerung erzeugt nun die nötigen 

Steuersignale. 

Benötigt der Befehl Operanden, so wird deren Adresse aus dem Inhalt des AR ermittelt. Häufig ist im 

Befehl nicht die tatsächliche Operandenadresse, sondern nur eine Teilinformation enthalten, die noch 

geeignet ergänzt werden muss ( Adressrechnung. 

Nun erfolgt ein Speicherzugriff (4a) auf die so festgestellten Operanden-Adresse. Der Operand wird in 

das vom Op-Code spezifizierte Register oder in das Rechenwerk (4b) oder in die ausgewählte 

Speicherzelle gebracht. 

Falls durch den Op-Code weitere Teiloperationen gefordert sind, werden diese nun ausgeführt. Dabei 

kann auch der Inhalt des BZ verändert werden (Sprungbefehle, Unterprogramm-Aufrufe). 

Ablauf des Befehlszyklus 12


Jeder Befehlszyklus besteht aus einer Anzahl von Teilschritten. Die Anzahl der Teilschritte kann für 

unterschiedliche Befehle verschieden sein, auch die Zeitdauer der einzelnen Befehle kann 

unterschiedlich sein. 

Die Befehlszyklen verschiedener Befehle können unterschiedlich lang sein. Die tatsächliche Dauer 

eines Befehlszyklus hängt von der Taktfrequenz der CPU ab. Der gesamte Ablauf in der CPU wird 

durch einen zentralen Takt gesteuert. Ein Befehlszyklus kann in eine Reihe von Maschinenzyklen 

zerlegt werden (z.B. Speicherzugriff in einem Maschinenzyklus). Ein Maschinenzyklus kann eine oder 

mehrere Taktperioden (Arbeitstakt des Prozessors) dauern. 

1.2 Erhöhung der Leistungsfähigkeit 

• Verlagerung der Prozessorfunktionen bei der Ein-/Ausgabe auf das E/A-Werk ("intelligente" 

Schnittstellen, E/A-Prozessoren, Vor-Rechner, Front-End-Rechner). 

• Weiterentwicklung des Architekturprinzips durch Steuerung der einzelnen Funktionseinheiten 

über eigene Prozessoren, wodurch eine teilweise Parallelarbeit möglich wird. 

• Bearbeiten einzelner, spezieller Befehle durch Spezialprozessoren, die abwechselnd mit der 

"normalen" CPU arbeiten (z. B. Arithmetik-Koprozessor). 

1.2 Erhöhung der Leistungsfähigkeit 13

Vermeiden oder Mildern des v. Neumann-Flaschenhalses 

• Neue Rechnerarchitekturen durchbrechen den streng sequentiellen Ablauf des v. 

Neumann-Rechners durch Parallelisierung verschiedener Abläufe im Computer. 

• Feldrechner bestehen aus mehreren parallelen Rechenwerken, mit gemeinsamen Steuerwerk. 

So kann die gleiche Operation auf vielen verschiedenen Datenwerten (Feldern) gleichzeitig 

ausgeführt werden. 

Asynchrone Trennung von Befehlshol- und -ausführungsphase 

• 

Pipeline-Rechner: Entweder mehrere hintereinandergeschaltete Rechenwerke, die verschieden 

Aufgaben erfüllen, aber gemeinsam gesteuert werden oder Aufbau eines Prozessors mit 

hintereinandergeschalteten spezialisierten Teilelementen. Die einzelnen Befehle werden in 

Teilaufgaben zerlegt, die nach einander von den Teilelementen bearbeitet werden. 

Die nächste Operation kann bereits begonnen werden, wenn die vorhergehende in die nächste 

"Station" gelangt ist. 

(schematisch dargestellt) 

Gleichzeitige Bearbeitung mehrerer Befehle 

Zur selben Zeit führt jedes Verarbeitungselement verschiedene Operationen auf 

unterschiedlichen Daten durch. 

überlappende Befehlszyklen 

• Vektorrechner: Kombination mehrerer Pipelines 

• Multiprozessorsysteme: Koppelung mehrerer Prozessoren, die auf den gleichen Speicher 

(bzw. Speicherbereich) zugreifen und weitgehend unabhängig voneinander arbeiten. Jede 

CPU kann ein eigenes Programm bearbeiten MIMD. 

• Polyprozessorsysteme: Multiprozessorsystem mit verteilter Kontrolle, bei dem die einzelnen 

CPUs autonom arbeiten, aber miteinander kommunizieren und kooperieren. 

Meist besitzt jeder Prozessor einen eigenen Speicher, z. B. Transputer. Fehlertolerante 

Mehrrechnersysteme eng/lose gekoppelt (z. B. in der Raumfahrt). 

1.4 Die Harvard-Architektur 


Die Harvard-Architektur ist im Kern älter als die von-Neumann-Architektur, denn die ersten 

Computer (etwa die Zuse 3) hatten eigentlich nur einen Datenspeicher. Der "Programmspeicher" 

Vermeiden oder Mildern des v. Neumann-Flaschenhalses 14


manifestierte sich als Lochstreifen oder -karten. Erst später wurde das Programm auf Speichermedien, 

z. B. einem Trommelspeicher abgelegt. Typisch war also die Trennung von Daten- und 

Programmspeicher. 

Die Harvard-Architektur bezeichnet heute ein Schaltungskonzept zur Realisierung besonders schneller 

CPUs und Signalprozessoren. Befehlsspeicher und Datenspeicher sind voneinander getrennt und 

werden über getrennte Busse angesteuert. Daher können Befehle und Daten gleichzeitig geladen, bzw. 

geschrieben werden. Bei einer klassischen Von-Neumann-Architektur sind hierzu mindestens zwei 

aufeinander folgende Buszyklen notwendig. Zudem sorgt die Trennung von Daten und Programm 

dafür, dass bei Softwarefehlern kein Programmcode überschrieben werden kann. Nachteilig ist 

allerdings, dass nicht benötigter Datenspeicher nicht als Programmspeicher genutzt werden kann. 

Die Harvard-Architektur wurde zunächst überwiegend in RISC-Prozessoren konsequent umgesetzt. 

"RISC" steht für "Reduced Instruction Set Computer" (Computer mit eingeschränktem Befehlssatz - 

siehe unten). RISC-Prozessoren haben einen kleinen Befehlssatz, bei dem aber fast alle Befehle 

innerhalb eines einzigen Taktzyklus ausgeführt werden können. 

Moderne Prozessoren in Harvard-Architektur sind in der Lage, parallel mehrere Rechenwerke 

gleichzeitig mit Daten zu füllen und auf diesen Daten Befehle auszuführen. Ein weiterer Vorteil der 

Trennung besteht darin, dass Datenwortbreite und Befehlswortbreite unabhängig voneinander sind. 

Damit kann, falls erforderlich, die Effizienz des Programmspeicherbedarfs verbessert werden, da sie 

nicht direkt von den Datenbusbreiten abhängig ist, sondern ausschließlich vom Befehlssatz. Besonders 

bekannte Vertreter dieser Architektur sind die Produkte der Firma Microchip Technology Inc. (PIC) 

und die Mikrocontroller der AVR-Reihe von Atmel. 

Eine bedeutende Erweiterung der Harvard-Architektur wurde von Analog Devices durch die 

Einführung der SHARC-(Super-Harvard-Architecture)-Technologie vorgenommen, bei der die 

Speichersegmente als Dual-Port-RAMs realisiert wurden, die kreuzweise zwischen den Programmund 

Daten-Bussen liegen. 

Viele moderne Prozessoren verwenden eine Mischform aus Harvard- und von-Neumann-Architektur, 

bei der innerhalb des Prozessors Daten und Programm voneinander getrennt verwaltet werden. Es 

existieren eigene Cache-Speicher und Memory Management Units mit getrennten internen Bussen. 

1.4 Die Harvard-Architektur 15

Extern wird jedoch in einem gemeinsamen Speicher zugegriffen. Beim Pipelining besteht der Vorteil 

dieser Mischform darin, dass deren einzelne Pipelinestufen in Bezug auf Speicherzugriffe getrennt 

arbeiten können. 

RISC "Reduced Instruction Set Computer" 

(Computer mit eingeschränktem Befehlssatz) 

Hat man anfangs versucht, beim Design neuer Prozessor-Chips immer mehr und immer 

leistungsfähigere Befehle zu integrieren (Complex Instruction Set Computer, CISC), so wird beim 

RISC-Prozessor der umgekehrte Weg beschritten. 

Für jeden Befehl des Prozessors gibt es eine fest verdrahtete Folge von Ablaufschritten im Chip, das 

Mikroprogramm. Je komplexer und mächtiger ein Befehl ist, desto mehr Einzelschritte muss das 

Mikroprogramm auf den Chip durchlaufen und desto mehr Taktzyklen sind notwendig, bis der 

Prozessor den nächsten Befehl verarbeiten kann. So liegt z.B. beim Prozessor 8088 die Zahl der 

Taktzyklen für einen Befehl zwischen 2 und 190. 

RISC-Prozessoren haben einen kleinen Befehlssatz, bei dem aber fast alle Befehle innerhalb eines 

einzigen Taktzyklus ausgeführt werden können. Das bedeutet auch eine Vereinfachung des Chips und 

erreicht auf diese Weise höhere Taktfrequenzen. Typische RISC-Mikrocontroller sind die 

PIC-Modelle von Microchip und etliche Atmel-Prozessoren. 

1.5 Begriffe 

Mikrocomputer: 

• Datenverarbeitungssystem mit einem Mikroprozessor als CPU 

• Extrem räumlich verkleinertes DVS (PC, Laptop, Steuerechner, etc.) 

• Leistungsfähigkeit eingeschränkt gegenüber Mini- und Groß-DVS 

• Verwendung häufig als Steuerungsrechner 

Mikroprozessor: 

• Auf einem Chip integrierte Steuer- und Verarbeitungseinheit, die als CPU im Mikrocomputer 

verwendet wird (Steuer- und Leitwerk) 

• Mikroprozessor alleine ist nicht einsatzfähig - erst der Mikrocomputer 

• Mikrocomputer = Mikroprozessor + Speicher + E/A-Bausteine [+ Peripherie] 

Mikrocontroller: 

• Mikrocomputer, die auf einem Chip integriert sind Single-Chip-Mikrocomputer 

• begrenzter Arbeitsspeicher (meist weniger als 1 MByte) 

• kein Massenspeicher (Festplatte,...) 

• längere Zykluszeiten (PC: bis GHz, MC: wenige MHz) 

• Möglichkeit der Signalverarbeitung (z. B.: integrierte serielle Schnittstelle, 

Analog-/Digital-Wandler, Zeitgeber, Impulszähler) 

1.6 Entwicklung 


RISC "Reduced Instruction Set Computer" 16


Mikroprozessor und Mikrocomputer sind Ergebnis der Entwicklungen im Bereich der 

Halbleitertechnik Mikroelekronik, ständige Erhöhung der Integrationsdichte. 

• SSI (small scale integration): einige Gatter 

• MSI (medium scale integration): Zähler, Register, ALU 

• LSI (large scale integration): Mikroprozessor, Speicher 

• VLSI (very large scale integr.): komplexere Mikroprozessor, Speicher 

• ULSI (ultra large scale integr.): Speicher hoher Kapazität 

Die zunehmende Integrationsdichte führte zu immer stärkerer Spezialisierung der Funktion und zur 

Einschränkung der Einsatzmöglichkeiten kundenspezifische LSI-Schaltkreise. Auswege: 

• standardisierte Bausteine 

• programmgesteuerte Bausteine (Mikroprozessor, Mikrocomputer) 

Der erste Mikroprozessor wurde 1970/71 von Intel als Steuerbaustein für ein Bildschirmterminal 

entwickelt. Da er für den vorgesehenen Zweck zu langsam war, wurde er als universeller 

Steuerbaustein vermarktet (4004, 8008). Durch Zufall kam dieses Produkt zur richtigen Zeit als 

Alternative zu kundenspezifischen Bausteinen auf den Markt. Folge: sensationell zunehmende 

Entwicklung des Mikrocomputer-Einsatzes. Die Entwicklung erfolgte in zwei Richtungen: 

• Ersatz festverdrahteter Logikschaltungen 

Steuerungsrechner 

Verwendung des Mikrocomputer als spezieller 

• Entwicklung kleiner und billiger Universalrechner Personal Computer 

Die ersten Mikroprozessoren von Intel, 4004 und 8008 

Mikrocomputer als Ersatz festverdrahteter Logik 

Einsatz für komplexe Steuerungsaufgaben in sich ständig ausweitenden Anwendungsgebieten. Die 

weitaus größere Zahl von Mikroprozessoren wird hier eingesetzt. Das Programm für eine bestimmte 

Aufgabe wird im ROM abgelegt. Ein kleiner RAM-Bereich speichert die Variablen, z. B.: 

1.6 Entwicklung 17

• Single-Chip-Mikrocomputer mit RAM und ROM auf dem Chip 

• Mikroprozessor + ROM + E/A-Baustein mit integr. RAM 

Einsatzbeispiele: 


• Meßtechnik: 

komfortable und leistungsfähige Meßgeräte (Bereichswahl, Berechnung, Eichkurven, graph. 

Darstellung, ...) 

• Steuerung: 

NC-Maschinen, Prozeßsteuerung, Roboter, SPS, automat.Testsysteme, KFZ-Technik 

• Nachrichtentechnik: 

Fernsprechtechnik + Vermittlungstechnik (Nebenstellenanlagen, ISDN, Mobiltelefon, ...), 

Telefax, Sender + Empfänger, Radar, Spracherkennung, ... 

• Bürotechnik: 

Kopierer (heute schon voll digital), Registrierkassen, Schreibautomaten, Anrufbeantworter, ... 

• KFZ-Elektronik: 

Motorsteuerung, ABS, Bord-Computer, Verkehrsleitsysteme, Diagnose-Computer, ... letzte 

Entwicklungen: autonomes, "sehendes" Fahrzeug 

• Haushaltelektronik: 

Waschmaschine, Nähmaschine, Heizungssteuerung, Alarmanlagen, ... 

• Unterhaltungselektronik: 

Radio- und Fernsehgeräte, HIFI-Geräte, Videorecorder, Satelliten-Empfänger, ... 

• Datenverarbeitung: 

Intelligente Peripherie (Terminals, Drucker, Plotter, Scanner, ...) 

Eines der ersten Entwicklungssysteme: KIM1 mit Prozessor 6502, 1 kByte Speicher, Hex-Tastatur 

und Siebensegmentanzeige 

Mikrocomputer als Ersatz festverdrahteter Logik 18

Mikrocomputer als Universalrechner 

Ursprünglich als Entwicklungssysteme für den o.g. Anwendungsbereich konzipiert erfolgte eine 

Weiterentwicklung zu Arbeitsplatzrechnern (PC, Homecomputer). 

• Durch Vernetzung dezentrale DV 

• Vorstoß in den Bereich der Minicomputer Die 16-, 32- und 64-Bit-Mikroprozessor zielen in 

diese Richtung. 

Kennzeichen: 

• Verwendung höherer Programmiersprachen 

• komplexe und leistungsfähige Betriebssysteme 

• Funktionsmerkmale von Großrechnern (virtuelle Speicherung, Cache) 

Technische Entwicklung: 

Anzahl Transistoren eines Intel 8080 Mikroprozessors 4 500 



Anzahl Transistoren eines Intel Pentium Mikroprozessors 3 100 000 

Anzahl Transistoren eines Intel Pentium 4 Mikroprozessors 42 000 000 

Anzahl Transistoren eines AMD KG (Athlon 64) Mikroprozessors 105 900 000 

Anzahl Transistoren eines Intel Core i7 Mikroprozessors 731 000 000 

Anzahl Transistoren eines Eight Core Xeon Nehalem-EX Mikroprozessors 2 300 000 000 

Anzahl Transistoren eines RV820 ATI/AMD Grafikprozessors 2 154 000 000 

Anzahl Transistoren eines GF100 NVIDIA Grafikprozessors 3 000 000 000 

Festplattenkosten pro Gigabyte 1990 53 000 

Festplattenkosten pro Gigabyte 1995 850 



Festplattenkosten pro Gigabyte 2010 0.1 

RAM-Kosten pro Gigabyte 1990 120 000 



RAM-Kosten pro Gigabyte 2005 190 

RAM-Kosten pro Gigabyte 2010 20 

(Alle Preisangaben in US-Dollar) 

1.7 Embedded Systems 


"Embedded Systems" ist der englische Fachbegriff für eingebettete (Computer-)Systeme, die in der 

Regel unsichtbar ihren Dienst in einer Vielzahl von Anwendungsbereichen und Geräten versehen, wie 

Mikrocomputer als Universalrechner 19

z.B. in Flugzeugen, Autos, Kühlschränken, Fernsehern, Werkzeugmaschinen, Kaffeeautomaten, 

DVD-Playern oder anderen Geräten. In der Computerbranche werden solche Systeme auch gerne 

"Appliance" genannt. ("appliance: A device or instrument designed to perform a specific 

function, especially an electrical device, such as a toaster.) 

Wenn man den Begriff aufschlüsselt ergibt sich: 


• Ein "System" ist in diesem Kontext immer eine informationsverarbeitende Maschine 

• "eingebettet" bedeutet: für einen spezifischen Zweck in einer technischen Umgebung 

entworfen, eingebaut und betrieben. 

Ein eingebettetes System verrichtet, weitgehend unsichtbar für den Benutzer, den Dienst in einer 

Vielzahl von Anwendungsbereichen und Geräten, wie z. B. in Flugzeugen oder Autos, 

Haushaltsgeräten, in der Unterhaltungselektronik, bei Mobiltelefonen oder in industriellen 

Steuerungen. Ein eingebettetes System interagiert mit seiner meist elektromechanischen Umwelt. 

Dabei ist kein menschlicher Benutzer vonnöten; er muss auch keinerlei Kenntnisse über die 

technischen Innereien des eingebetteten Systems haben, um das Gesamtsystem bedienen zu können. 

Im Fall von komplexen Gesamtsystemen handelt es sich dabei meist um eine Vernetzung einer 

Vielzahl von autonomen, eingebetteten Systemen. 

Eingebettete Systeme können in Einzelfällen auf ähnlicher Hardware wie Arbeitsplatzcomputer 

basieren (sogenannte embedded-PCs), in der Regel unterliegen sie jedoch stark einschränkenden 

Randbedingungen: Minimale Kosten, geringer Platz-, Energie-, Speicherverbrauch. Einzelne 

Komponenten wie Prozessor oder Arbeitsspeicher müssen auch wesentlich länger auf dem Markt 

verfügbar sein, um die langfristige Einsetzbarkeit und Ersatzteilbeschaffung zu gewährleisten. 

Moderne eingebettete Systeme basieren auf den verschiedensten Prozessor-Plattformen, die in 

Bezug auf die Peripheriemodule hochintegriert sind und durch moderne Stromspartechniken wenig 

Energie verbrauchen. 

"Embedded Systems" vereinigen daher durch ihre oftmals sehr hardwarenahe Konstruktion die große 

Flexibilität von Software mit der Leistungsfähigkeit der Hardware. Die Software-Entwicklung für 

diese Systeme unterscheidet sich oft grundsätzlich von jener für Desktop- oder PC-Systeme: oftmals 

werden Betriebssysteme eingesetzt, die zwar nicht über eine grafische Benutzeroberfläche verfügen, 

dafür jedoch Echtzeitanforderungen genügen. 

Bevorzugte Programmiersprachen sind daher z. B. Assembler oder C. Bekannte 

Embedded-Betriebssysteme sind z.B. QNX, VxWorks, Windows CE, DOS, LynxOS, Nucleus, 

zunehmend auch spezielle Linux-Derivate, wenn die Echtzeitbedingungen keine dominante Rolle 

spielen. Einige Beispiele für Embedded Systems sind: 

• Die Elektronik in einem Kaffeevollautomaten. Mit ihr wird beispielsweise die Kaffeemenge 

und -stärke sowie die Wassermenge reguliert. Die Kaffemaschine an sich ist kein 

datenverarbeitendes System. 

• Auch die Elektronik in einem Videorecorder ist ein eingebettetes System, auch wenn der 

Videorecorder selbst ein (eingeschränkt) datenverarbeitendes System ist. 

• Der Zündcomputer im Auto ist ebenfalls ein im Stillen wirkendes System, wobei in einem 

Fahrzeug der Oberklasse inzwischen einige Dutzend Computer werkeln. 

• Die Steuerungen von NC-Werkzeugmaschinen (NC = Numeric Control) oder anderen 

industriellen Systemen sind fast immer Embedded Systems. 

• Fast alle Peripheriegeräte in der Datenverarbeitung (Drucker, Scanner, Barcode-Leser, Router 

usw.) sind mit eigener Intelligenz zur Verarbeitung der Daten ausgerüstet. 

Kennzeichnende Merkmale von embedded Systemen sind: 

1.7 Embedded Systems 20


• sie sind fester Bestandteil eines technischen Systems 

• sie sind zweckbestimmt (im Gegensatz zum Universalrechner) 

• sie interagieren mit der Umgebung durch Sensoren und Aktoren 

• sie reagieren meist in Realzeit 

Sekundäre Merkmale von embedded Systemen sind: 

• sie werden oft für Regelungs- und Steuerungsaufgaben vorgesehen 

• sie sind häufig Massenware, Konsumgut, billig 

• sie sind vielfach schlecht bzw. nicht wartbar und nicht erweiterbar 

• sie sind manchmal auch sicherheitskritisch 

Eingebettete Systeme beanspruchen einen Marktanteil bei der Prozessor-Produktion von ca. 98%. Die 

restlichen 2% dienen dem Aufbau von interaktiven Systemen wie z. B. Laptops, Desktop-Computern 

und Servern. Nahezu die Hälfte der gesamten Microcontroller-Jahresproduktion sind immer noch 

8-Bit-Prozessoren. Bereits heute gibt es mehr eingebettete Systeme als Menschen auf der Welt. Deren 

Elektronik dient oft als Wegwerf-Artikel (z. B. RFID-Tags, Grusspostkarten). 

Man setzt deshalb für die Definition des eingebetteten Systems voraus, dass 

• die genaue Aufgabe des Systems vor der Entwicklung feststeht, 

• immer nur ein einziges Programm abläuft und 

• Hardware und Software eine funktionale Einheit bilden. 

Tatsächlich haben sich im der Industrie immer häufiger Standard-PC-Komponenten bei 

Neuentwicklungen von eingebetteten Systemen durchgesetzt -- geringe bis mittlere Stückzahlen und 

kurze Produktzyklenzeiten vorausgesetzt. Die Komponenten von der Stange ("Commodity of the 

Shelf", COTS) kosten oft nur einen Bruchteil vergleichbarer proprietärer Industrielösungen und sind 

dabei wesentlich flexibler. Diese "Embedded PCs" sind aber nicht überall sinnvoll: Oft zwingen rauhe 

Umgebungen und Platzmangel zu speziellen Eigenentwicklungen. Bei hohen Stückzahlen ist dies 

ohnehin obligatorisch. 

Anders als stationäre Systeme haben eingebettete Systeme besondere Anforderungen hinsichtlich 

Robustheit, Energieverbrauch und Speicherbedarf, Im Gegensatz zu einem Arbeitsplatzrechner wird 

ein eingebettetes System im Allgemeinen nicht "heruntergefahren", bevor man es ausschaltet. Es muss 

im Gegenteil damit zurechtkommen, dass ihm der Strom jederzeit und ohne Vorwarnung abgestellt 

werden kann. Damit ein solcher Shutdown, etwa aufgrund eines Stromausfalls, problemlos 

überstanden wird und die Software nach dem Booten in einen definierten Anfangszustand gelangt. 

Bewegliche Teile wie Lüfter oder Festplatte sind meist nicht erwünscht. Besonders sind auch meist 

die Umgebungsbedingungen wie Temperatur und Feuchtigkeit. Um auch diesen Anforderungen 

gerecht zu werden, steht eine möglichst geringe Stromaufnahme des Prozessors bzw. des Boards im 

Vordergrund. Im Vergleich zum "Stomfresser" im Desktop-Rechner kommt ein embedded Board 

meist mit weniger als 1 Watt aus. Embedded Systems laufen buchstäblich während ihrer gesamten 

Lebensdauer, also an sieben Tagen pro Woche und 24 Stunden pro Tag. Gelegentliche Abstürze mit 

der Notwendigkeit eines Neustarts sind hier absolut inakzeptabel (insofern fällt mein kürzlich 

erworbener DVB-T-Empfänger/Decoder aus dem Rahmen, bei schlechtem Empfang hängt er sich 

schon mal auf). 

Embedded Systems basieren also oft auf ähnlicher Hardware wie Arbeitsplatzcomputer, unterliegen 

jedoch meist stark einschränkenden Randbedingungen: minimale Kosten und damit geringer Platz-, 

Energie-, Speicherverbrauch. Die Fertigung in großen Stückzahlen, oft im Millionen-Bereich, ist ein 

weiterer wichtiger Punkt zur Kostenreduzierung. Hinzu kommt, dass die einzelnen Komponenten wie 

Prozessor und RAM auf Weiterentwicklungen älterer Komponenten basieren, was die Langlebigkeit 

1.7 Embedded Systems 21

steigert, Stromverbrauch und -kosten jedoch senkt. 

Für viele Anwendungen können auch ältere Komponenten eingesetzt werden, wenn zudem die 

Vereinfachung der Architektur des ursprünglichen Systems dazu beiträgt, weitere Kosten zu senken. 

Programme eines Embedded Systems müssen oft Echtzeitanforderungen genügen. In der Regel 

existieren verglichen mit Desktop-PC-Hardware nur stark reduzierte Ressourcen, zumeist ohne 

Festplatte, Betriebssystem, Tastatur oder Bildschirm. Ein ROM- oder Flash-Speicher ersetzt meist 

mechanische Speicherkomponenten wie eine Festplatte: bewegliche Teile bedeuten Verschleiß, der 

hier unerwünscht ist. Wenn überhaupt, dann gibt es meist nur ein Tastenfeld und die Ausgabe wird -soweit 

überhaupt vorgesehen -- durch ein LCD realisiert. 

Design von Embedded Systems 

Die Elektronik wird meist von einem Mikroprozessor mit entsprechender Peripherie oder einem 

Microcontroller gebildet. Vielfach handelt es sich auch um komplette PC-Boards mit stromsparenden 

Bauteilen und anderem Formfaktor. Ein solcher PC gilt bereits als groß, wenn er Postkartenformat 

besitzt. Um das Board herum ist dann die dem Aufgabengebiet entsprechende Peripherie angeordnet. 

Folgende Aspekte spielen u. a. bei Designentscheidungen von Embedded Systems eine Rolle: 

• Integration: Je mehr Funktionalität der verwendete Mikrocontroller bereits besitzt, desto 

weniger Peripheriebausteine werden benötigt, um die Anbindung an die benötigten 

Systemschnittstellen (Ein-/Ausgabe) zu ermöglichen. Je weniger Bausteine eine Platine 

benötigt, desto geringer sind der Platzbedarf der Leiterbahnen und die Signallaufzeiten 

zwischen den Bausteinen. 

• Echtzeitanforderungen: Hohe Verfügbarkeit und definierte Antwortzeit sind häufig gestellte 

Anforderungen an ein Embedded System und somit auch an dessen Betriebssystem und die 

Software. Die Verwendung spezieller Echtzeitbetriebssysteme erlaubt es, schon in der 

Entwicklungsphase die Reaktionszeiten des Gesamtsystems abzuschätzen. 

• Cross-Entwicklung: Oft ist das System, auf dem die Software entwickelt wird, nicht 

identisch mit dem Zielsystem. Es werden dann Compiler eingesetzt, die Binärcode für das 

Zielsystem erzeugen. Bei kleinen Embedded Systems (die oft nicht einmal ein Betriebssystem 

besitzen) erfolgt der Programmtransfer durch Programmieren des Flash-Speichers auf dem 

Entwicklungsrechner. Der Speicherbaustein wird dann zum Testen ins Zielsystem eingesteckt. 

Bei modernen Microcontrollern ist in der Regel die Möglichkeit gegeben, den Flash-Speicher 

on board zu programmieren -- es genügen dann ein paar Drähte zwischen Entwicklungs- und 

Zielsystem. Besitzt das Zielsystem ein eigenes Betriebssystem, kann der Datentransfer auch 

über Standardschnittstellen oder Netzwerk erfolgen. 

Zum vorhergehenden Abschnitt Zum Inhaltsverzeichnis Zum nächsten Abschnitt 






Design von Embedded Systems 22


2.1 Struktur eines Mikrocomputers 

Prinzipieller Aufbau 

Ein Mikrocomputer hat grundsätzlich die gleichen Eigenschaften, wie ein größeres DV-System, die 

von-Neumann-Struktur. Die Besonderheiten sind: 

• CPU ist in einem Chip integriert (Mikroprozessor) 

• Der Arbeitsspeicher zerfällt i.A. bei Steuerungsrechnern in Programmspeicher (ROM, PROM, 

EPROM,...) und Datenspeicher (RAM) 

• Das E/A-Werk besteht aus speziellen E/A-Bausteinen, die als IC zahlreich und passend für 

den verwendeten Mikroprozessor-Typ angeboten werden Mikroprozessor-Familie: 

♦ einfache serielle/parallele E/A-Bausteine, 

♦ DMA-, CRT-, Floppy- und Platten-Controller, 

♦ E/A-Prozessoren, 

♦ Arithmetikprozessoren, 

♦ Timer, 

♦ Speicherverwaltungsbausteine, 

♦ usw. 

• Die Verbindung der einzelnen Komponenten erfolgt durch eine Bus-Struktur. ( teilweiser 

Verzicht auf Parallelarbeit einzelner Komponenten). 

• Ein einfacher Mikrocomputer besteht aus relativ wenigen, hochintegrierten Bausteinen. 

Der System-Bus 

Bus = Anzahl von Leitungen, an die mehrere Funktionseinheiten parallel angeschlossen sind. Der 

Informationsaustausch zwischen diesen Einheiten erfolgt zeitmultiplex über den Bus. Zu jedem 

Zeitpunkt sind immer nur zwei Einheiten (Sender, Empfänger) miteinander verbunden. 

• unidirektionaler Bus: Information geht nur in einer Richtung (i.a. nur 1 Sender) 

2 Hardware von Mikrocomputern 23

• bidirektionaler Bus: Informationsaustausch in beiden Richtungen (mehrere Sender) 

In Mikroprozessor-Systemen ist (mit Ausnahme des DMA) der Mikroprozessor immer einer der 

beiden aktiven Bausteine. Die Bus-Leitungen werden in funktionelle Gruppen gegliedert: 

• Adreß-Bus (A-Bus): 

unidirektional, 8-32 Leitungen, Auswahl von Speicherzellen, Bausteinen, E/A-Registern 

• Daten-Bus (D-Bus): 

bidirektional, 8-32 Leitungen, Datentransport zw. Mikroprozessor und Speicher/Peripherie 

• Steuer-Bus (Control-Bus, S-Bus): 

Unterschiedliche Übertragungsrichtungen - aber jede Leitung für sich unidirektional, 4-20 

Leitungen, Steuerung der Zusammenarbeit der einzelnen Baugruppen 

Der Bus ist eine ökonomische Verbindung mehrerer Baugruppen. Es sind flexible Erweiterung und 

systematische Verschaltung möglich (Backplane, Bus-Platine). Der Zugang erfolgt über Steckplätze 

(Slots). Ein Bus ist aber auch relativ langsam, da keine Parallelarbeit möglich ist und das Fan-Out der 

sendenden Komponenten ist begrenzt (u.U. spezielle Pufferbausteine = Bus-Treiber, Bus-Extender 

nötig). Es gibt Systeme, bei denen ein Teil des Busses für verschiedene Funktionen mehrfach genutzt 

wird Zeitmultiplex-Betrieb (z. B. 8085: Datenbus/LSB Adressbus) 

A-Bus Adreßbus 

D-Bus Datenbus 

S-Bus Steuerbus (Control-Bus) 

RAM Random-Access-Memory (Schreib-Lese-Speicher) ROM Read-Only-Memory 

(Festwert-Speicher) SIO Serial Input Output PIA Parallel Input Output 

Bus-Treiber 

Problem bei Bus-Systemen: Es darf immer nur ein einziger Sender am Bus aktiviert sein - alle anderen 

Sender müssen abgeschaltet sein. 

Aufgaben des Bus-Treibers: 


• An-und Abschalten der angeschlossenen Funktionseinheiten am Bus 

• Durchschalten der gewünschten Übertragungsrichtung bei bidirektionalen Busanschlüssen 

Der System-Bus 24

• Erhöhung des Fan-Out (Anschlußkapazität) eines Busses Bustreiber sind heute in der Regel 

Gatter mit Tri-State-Ausgang: Der dritte Zustand (Z-State) ist ein hochohmiger Zustand = 

Trennen des Treibers vom Bus. Die Umschaltung des Z-State erfolgt mit einem 

Enable-Steuersignal. 

Die Ausgänge des Mikroprozessors und der übrigen Bausteine sind i. a. als Tri-State-Ausgänge 

ausgeführt direkter Busanschluß möglich. Für Funktionseinheiten ohne Tri-State-Ausgänge und als 

Bus-Extender gibt es spezielle Treiber-ICs. 

Unidirektionaler Treiber (Buffer, Line Driver) z. B. 74244 

Bidirektionaler Treiber (Transceiver) z. B. 74245 (8-fach) 

Systembeispiel 

Aufzugsteuerung mit Mikroprozessor 6802. Auf dem CPU-Chip sind 128 Byte RAM integriert. Somit 

wird extern nur noch E/A und ROM benötigt. 

2.2 Mikroprozessor 


Zwischenbemerkung: Die Wahl des Prozessors hängt auch von der Anwendung ab (so ist z.B. für 

einfache Steuerungen ein 8-Bit-Prozessor vollkommen ausreichend). Die Umstellung des Entwicklers 

Bus-Treiber 25

von einem auf den anderen Mikroprozessor ist i.a. nicht allzu schwierig. Im praktischen Teil wird der 

8-Bit-Mikroprozessor 6809 verwendet, der sich durch einen einfachen, überschaubaren und 

orthogonalen Befehlssatz auszeichnet. 

Versorgung und Steuerung 

Gruppierung der µP-Anschlüsse: 

Die Steuer-Signale dienen zur programmunabhängigen Beeinflussung des Mikroprozessors, z. B. 

Reset, Interrupts. Deren Quittungssignale sind teilweise auch dem S-Bus zuzuordnen. 

Die Spannungsversorgung erfolgt heute mit + 5V; früher waren of mehrere Spannungen notwendig 

(+5V, -5V, +12V). 

Der Takt wird entweder mit einem externen Taktgenerator oder intern erzeugt. Normalerweise genügt 

ein Quarz, bei einfachen Systemen sogar ein R-C-Glied. 

• nicht überlappender Zweiphasentakt (wegen der internen Ablaufsteuerung und des 

Rechenwerks) 

• Mindestfrequenz darf bei einigen Modellen nicht unterschritten werden (Register sind als 

dynamische Speicher realisiert). 

Die Taktfrequenz sagt nichts über die tatsächliche Ablaufgeschwindigkeit aus. Bei interner 

Takterzeugung ist i.a. nur noch ein externer Quarz nötig. Die Quarzfrequenz beträgt ein Vielfaches der 

Taktfrequenz (2 - 18 * Taktfrequenz). 

Steuerungs-Signale 

Dierser Abschnitt soll einen Überblick der Signale vermitteln. Nicht jeder Mikroprozessor verfügt 

über alle genannten Möglichkeiten. 

Rücksetzen (Reset) 


2.2 Mikroprozessor 26

Herstellen eines definierten Grundzustandes des Prozessors: 

• Meist durch fallende Flanke am Reset-Anschluß des Mikroprozessors 

• BZ auf definierten Anfangswert setzen (0, festen Wert oder durch Vektor definierten Wert) 

• Prozessor startet Befehlszyklus mit diesem Wert 

• Interrupts sperren (Freigabe muß durch Programm erfolgen) 

• Nicht immer: Rücksetzen der Register 

Wichtig: Einschaltverhalten der Mikroprozessor beachten! Reset darf erst erfolgen, nachdem die 

Versorgungsspannung eine bestimmte Zeit stabil anliegt (Einschwingzeit des Quarzoszillators). 

Warten (Wait, Memory Ready, MRDY, Ready) 

Dieser Anschluß dient der Anpassung an langsame Speicher oder E/A-Bausteine. Erreicht wird eine 

Verlängerung des Speicherzugriffszyklusses. 

• gezielte Verlängerung einzelner Taktphasen (z. B. 6809) 

• Einschieben leerer Zyklen (synchron) (80x86, "Wait States") 

• Warten auf Fertigmeldung (asynchron) (68000) 

Halten (Hold, Halt, Stop) 

Anhalten des Programmablaufs nach Beendigung des laufenden Befehls. 

• Bus geht in den Tri-State-Zustand 

• Mikroprozessor nach außen inaktiv (intern weiter aktiv) 

• Anwendungen: 

♦ einfache DMA-Möglichkeit 

♦ Start/Stop von außen (Test) 

♦ Einzelschrittsteuerung 

♦ Stop bei bestimmter Adresse 

• "Aufwecken" nur durch Reset oder Interrupt 

Befehlsunterbrechungen (DMA, BREQ) 


Anhalten der Ausführung des aktuellen Befehls nach Beendigung des laufenden Zyklusses - also 

mitten im Befehl. 

• Bus geht in den Tri-State-Zustand 

• Anwendung: DMA 

• Nach Beendigung der Unterbrechung wird der unterbrochene Befehl fortgesetzt 

Steuerungs-Signale 27

Befehls-Abbruch (Abort) 

Abbruch des laufenden Befehls bei virtueller Speichertechnik 

• Wegspeichern des Programmstatus 

• Seitenwechsel durchführen 

• Programmstatus wiederherstellen 

• abgebrochenen Befehl neu aufsetzen 

Programm-Unterbrechung (Interrupt) 

Unterbrechung des laufenden Programms nach Beenden des laufenden Befehls. Ausführen einer 

Interrupt-Serviceroutine (ISR). 

Arten: 

• Abspeichern des Programmstatus 

• Setzen BZ auf feste oder vektorisierte Adresse 

• Sperren weiterer Interrupts 

• Auslösung durch Flanke oder Pegel 

• Lokalisierung durch Polling oder HW-Vektor (z.B. bei 8080) 

• Abarbeiten der ISR 

• Restaurieren des Programmstatus und Fortsetzung des Programms 

• bedingter (maskierbarer) Interrupt 

• unbedingter Interrupt 

2.3 Arbeitsspeicher 

Speicher-Bausteine 

Als Speicherbausteine werden Halbleiterspeicher verwendet. Folgenden Begriffe dienen zur 

Spezifizierung eines Speichers: 

• a Adreßbreite 

• d Wortbreite 

s Speicherkapazität; s = 2a • 

• tacc Zugriffszeit 

• tcyc Zykluszeit 

Anschlüsse: 


• CS - Chip Select: Leitung(en) zur Bausteinauswahl 

• R/W - Write Enable: Festlegung der Datentransportrichtung 1 = Lesen, 0 = Schreiben 

• Adreß- und Datenleitungen 

Steuerungs-Signale 28

Organisationsformen: 

• d = 1: bitorganisierter Speicher, z.B. 64K x 1 

• d > 1: Nibble (d = 4)-, Byte (d = 8)- oder Wort (d = 8, 16, 32, 64)-organisierter Speicher 

Zusammenschalten von Speicherbausteinen 

Der Gesamtspeicher wird durch Zusammenschaltung von Speicherbausteinen gebildet (sofern nicht 

schon ein Baustein ausreicht). Er besteht aus RAM und ROM (PROM, EPROM). Die 

Zusammenschaltung kann erfolgen: 

• in Wortrichtung (d = Wortbreite des Mikroprozessors) 

• in Bitrichtung (d = 1 oder d < Wortbreite des Mikroprozessors) 

• gemischt (Wort- und Bitrichtung) 

Bei der Zusammenschaltung in Bitrichtung werden alle Bausteine parallel adressiert. 

In allen anderen Fälle gilt: 


• Zur Wortadressierung innerhalb des Bausteins dient nur ein Teil der Adresse 

• Der Rest der Adresse dient zur Bausteinanauswahl: 

♦ Uncodierte Bausteinauswahl 

♦ Decodierung auf dem Baustein (mehrere CS-Eingänge) 

♦ externe Decodierung (nur 1 CS nötig) 

♦ Kombination externe/interne Decodierung 

Beispiel 1: Zusammenschaltung in Wortrichtung, uncodierte Bausteinauswahl: 

Speicher-Bausteine 29

Beispiel 2: Zusammenschaltung in Wortrichtung, codierte Bausteinauswahl, externe Decodierung 

Ergänzende Bemerkungen 

Ist der Adreßraum des Mikroprozessors breiter als der zur Speicheradressierung eingesetzte Adreßbus, 

tritt Mehrfachadressierung auf: Adressen, die sich nur in den unbenutzten höherwertigen Bits 

unterscheiden, sprechen die gleiche Speicherzelle an. Dieser Effekt kann erwünscht sein - das 

Entwicklungssystem adressiert seinen Daten-Speicher ab $8000, der Steuerungsrechner ab Adresse 0. 

Gelegentlich muß noch ein Signal zur zeitlichen Koordination der Speicherzugriffe eingesetzt werden. 

Bei ROM-Bausteinen gibt es häufig noch einen Eingang zum Schalten der Ausgänge in den 

Tri-State-Zustand (OE=Output Enable). 

2.4 Ein-/Ausgabe-Bausteine 

Struktur von E/A-Bausteinen 


Der E/A-Baustein ist Bindeglied zwischen Prozessor und Peripherie. Seine Aufgaben sind unter 

anderem: 

Datentransport, zeitliche Anpasung, Signalumsetzung, Pegelumsetzung, Erweiterung der 

Belastbarkeit, Datenformat-Anpassung, Codeumsetzung, ...) 

Zusammenschalten von Speicherbausteinen 30


Das Einsatzgebiet der E/A-Bausteine reicht von einfacher Byte-orientierter Ein- und Ausgabe bis zur 

autonomen Verwaltung komplexer Protokolle, wie z. B. die Netzwerkanbindung. E/A-Komponenten 

werdenin der Regel so entworfen, dass sie jeweils einen möglichst großen Bereich von Anwendungen 

abdecken. Die Spezialisierung für die Anwendung geschieht durch Initialisierung des Bauteils im 

System, ein Vorgang, der in Datenblättern und im allgemeinen Sprachgebrauch "Programmierung" 

genannt wird: Nach jedem Einschalten des Systems müssen bestimmte Steuerregister in diesen 

Bausteinen von der CPU aus mit bestimmten Werten initialisiert werden. 

Bausteine für programmierten E/A-Transfer 

Zur bitparallelen Ein/Ausgabe werden von fast jedem Hersteller Bausteine angeboten und nahezu 

jeder Controller verfügt über parallele E/A. Verschiedene Bezeichnung sind in Gebrauch: 

• PIO Parallel I/0 Interface 

• PIA Peripheral Interface Adapter 

• PPI Programmable Peripheral Interface usw. 

Der Baustein besitzt hierzu Steuerregister, deren Inhalte die Datenrichtung, Bedeutung von 

Steuersignalen (Handshake) und das Interruptverhatten festlegen. 

Der Zugriff auf die Peripherie erfolgt entweder programmgesteuert (polling) oder interruptgesteuert. 

Sie werden am häufigsten verwendet. Auch Bus-Treiber können als sehr einfache E/A-Bausteine 

eingesetzt werden. So wurde z. B. die Standard-Druckerschnittstelle des IBM-PC mit zwei 

8-Bit-Latches und zwei 8-Bit-Bustreibern realisiert. Kaum komplexer sind auch Speicher-Register mit 

nachgeschalteten Leistungstreibern. Sie übernehmen auch die zeitliche Anpassung. Zum Teil sind sie 

mit Steuerlogik, Betriebsartenwahl (Ein/Aus) und Interrupt-Auslösung versehen. 

Wesentlich flexibler im Einsatz sind programmierbare E/A-Bausteine, wie man sie heute verwendet. 

Eigenschaften und Funktion sind per Software einstellbar. Programmierbare Eigenschaften können 

sein: 

• Datenrichtung 

• Übertragungsgeschwindigkeit 

• Übertragungsformat 

• Paritätsprüfung 

• Art des Interrupt-Signals von der Peripherie 

• Interrupt-Maske 

Diese Bausteine erlauben meist sowohl programmgesteuerten programmierten E/A-Transfer als auch 

interruptgesteuerten programmierten E/A-Transfer. Für den einfachen E/A-Transfer gibt es zwei 

Bausteine-Grundtypen: 

1. Parallele Schnittstelle (Parallel Interface Adapter, Parallel Input Output) Schnittstelle für 

parallelen Datenaustausch (z.B. Centronics-Druckerschnittstelle, Relais-Ausgang, 

Digital-Analog- und Analog/Digital-Wandler, digitale Eingangssignale). In der Regel sind 

mehr als ein 8 Bit breiter "Port" vorhanden (meist 2 bis 4). Steuer- oder Statusregister können 

pro Port separat vorhanden sein. 

Struktur von E/A-Bausteinen 31

2. 


SIA (Serial Interface Adapter, Serial Input Output) Dies ist eine Schnittstelle für bitseriellen 

Datenverkehr. Die Bausteine enthalten je einen Parallel-Seriell- und Seriell-Parallel-Wandler 

(Schieberegister). 

Bei seriellen Schnittstellen kann es sich um einen UART (Universal Asynchronous 

Receiver/Transmitter) handeln, wie man ihn von der guten alten seriellen Schnittstelle des PC 

her kenn, aber auch um spezielle Schnittstellen für die Kommunikation zwischen einzelnen 

ICs, beispielsweise die I 2 C- oder die SPI-Schnittstelle. Generell gilt: 

♦ CPU schreibt ein Byte (liegt "parallel" an), die serielle Schnittstelle muss es Bit für 

Bit aussenden. 

♦ Beim Empfang muss ein Bit nach dem anderen gespeichert und als komplettes Byte 

an die CPU geleitet werden. 

♦ Festzulegende Parameter: Bit-Geschwindigkeit (Baudrate), Anzahl Stoppbits, Parität, 

Steuerleitungen usw. 

Der Baustein enthält einen getrennten Sende- und Empfangsteil, sodass Vollduplexbetrieb 

möglich ist. Ein USART (Universal Synchronous/Asynchronous Receiver/Transmitter) bietet 

neben der asynchronen Betriebsweise auch synchrone Betriebsarten. Im synchronen Betrieb 

einer seriellen Übertragung werden Blöcke von Bytes (z. B. Zeichen oder beliebige 

Binärinformation) ohne Pausen übertragen. Die Synchronisation zwischen Sender und 

Empfänger, die beim asynchronen Betrieb für jedes Zeichen am Empfänger neu hergestellt 

werden muss, bleibt im synchronen Betrieb nicht nur während eines Zeichens erhalten, 

sondern während eines langen Bitstroms (Datenblock). 


Um die Syrichronisation auch dann aufrecht zu erhalten, wenn der Sender nicht schnell genug 

weitere Oktets liefern kann, wird solange automatisch ein vorgebbares 

Synchronisationszeichen übermittelt damit der serielle Bitstrom nie abreißt. Dadurch werden 

Start- und Stopbits überflüssig, was zu höheren effektiven Datenraten führt. Meist wird auch 

das Paritätsbit bei jedem Zeichen durch eine CRC-Prüfinfo (CRC = Cyclic Redundancy 

Check)am Ende einer ganzen Serie von Zeichen ersetzt, wodurch die Effektivität der 

Datenrate und der Fehlersicherung wesentlich erhöht wird. 

Daneben existieren noch viele weitere E/A-Bausteine. Sie sind i.a. wesentlich komplexer aufgebaut 

und bieten zahlreiche Programmierungsmöglichkeiten. Zum Beispiel: 

• Interrupt-Controller: Erweiterung der Interruptmöglichkeiten (Priorisierung, 

Vektorgenerierung) 

• Programmierbare Zähler (Timer, Counter) Auslösung von Interrupts in regelmäßigen 

Zeitabständen Erzeugen von Einzelimpulsen definierter Länge Erzeugung von 

Rechteckimpulsen 

• spezielle Steuerbausteine Memory Management, Floppy-Disk, Festplatte, Bildschirm, 

LC-Display, ... 

• Bausteine für DMA-Transfer 

Zusammenfassung: Aufgaben einer E/A-Schnittstelle 

Die Gesamtheit der Einrichtungen, über welche die CPU mit den peripheren Geräten kommuniziert, 

nennt man E/A-Schnittstelle. Im Allgemeinen findet ein (bidirektionaler) Datentransport zwischen 

Speicher und Peripherie statt. Neben dem reinen Datentransport ist eine Anpassung der 

Datendarstellung zwischen CPU und Peripherie erforderlich = Umsetzung der Bus- auf die 

Peripherieschnittstelle: Zeitliche Anpassung (CPU und Peripherie arbeiten i. a. nicht synchron, d. h. 

sie sind zeitlich zu entkoppeln). 

• Signalumsetzung (z. B. Pegelanpassung) 

• Datenformatanpassung (z. B. seriell/parallel-Wandlung) 

• Codewandlung 

• Fehlererkennung und -korrektur Schnittstellen können von unterschiedlicher Komplexität sein: 

• Im einfachsten Fall bestehen sie aus einer oder mehreren einfachen nicht-intelligenten 

E/A-Schnittstellen zur rein hardwaremäßigen Anpassung und Umsetzung. Die gesamte 

Steuerung des Datentransfers erfolgt durch die CPU programmierter E/A-Transfer. 

• Komplexere Schnittstellen können den Datentransfer autonom durchführen. Sie werden von 

der CPU nur angestoßen und wickeln den Datentransfer ohne weitere Hilfe der CPU ab 

Direkt- Speicher-Zugriff (DMA = Direct Memory Access) ohne Ablauf eigener 

Programme. 

• Flexiblere und leistungsfähigere Schnittstellen besitzen einen speziellen E/A-Prozessor, der 

nach einem Anstoß durch die CPU unabhängig vom (Haupt-)Prozessor mit eigenem 

Programm arbeitet und getrennten Zugriff zum Speicher besitzt. 

Steuerung von E/A-Bausteinen 

Steuersingnale von der CPU: 

• Rücksetzen (Reset, RES) 

• Freigabe, Aktivierung (Enable, E, CE) 

• Baustein-Auswahl (Chip Select, CS) 

• Register-Auswahl (Register Select, RS) 

• Datenrichtung (Read/Write, R/W) 



Steuersignale von der Peripherie: 

• Interruptleitungen (Erzeugung IRQ-Signal für CPU) 

• weitere Steuersignale (z.B. Handshakeleitungen bei SIA) 

Steuerleitungen vom E/A-Baustein zur CPU: 

• Interrupt-Anforderung (Interr. Request, IRQ) 

• Weitergabe des IRQ von der Peripherie zur CPU (Maskierungsmöglichkeit) 

• Erzeugung eines IRQ-Signals durch E/A-Baustein selbst 

Anschluß von E/A-Bausteinen 


Die Steuersignale werden mit dem Steuer-Bus verbunden. Aus dem Adreß-Bus werden die 

Cchip-Select- und Register-Select-Signale abgeleitet. Normalerweise werden die RS-Signale mit 

den niederwerigen Adreßleitungen verbunden (RS 0 mit A 0 , RS 1 mit A 1 , usw.). Über den Daten-Bus 

erfolgt der eigentliche Datenaustausch. 

Da i. a. mehrere E/A-Bausteine (mit mehreren Registern) an ein System angeschlossen werden, ist 

eine Adressierung der E/A-Bausteine nötig. Es gibt dafür zwei Methoden: 

1. Getrennte Adressierung (Isolated I/O, I/O-Mapped I/O) 

Der Rechner verfügt über spezielle E/A-Befehle und einen eigenen E/A-Adreßraum. Die 

E/A-Adresse wird oft auch Port genannt. Sie wird entweder auf separaten Adressleitungen 

zu den Schnittstellen geführt oder über den normalen Adreßbus geleitet. In diesem Fall gibt 

es (eine) zusätzliche Steuerleitung(en) zur Unterscheidung zwischen E/A- und 

Speicheradressen. Da i.a. der E/A-Adreßraum kleiner als der Speicheradreßraum ist, wird 

nur ein Teil der A-Bus-Leitungen verwendet (z. B. 8080/8085: 8 Bit, 80386: 10 Bit). 

2. Speicheradressierung (Memory Mapped I/O) 

Der E/A-Adreßraum wird in den Speicher-Adreßraum abgebildet, d.h. bestimmte Adressen 

stellen keine Speicheradressen, sondern E/A-Adressen dar geringfügige Einschränkung 

des Speicheradreßraums. Die E/A-Adressen werden von der CPU genauso behandelt und 

angesprochen, wie Speicheradressen. E/A-Operationen werden mit den normalen 

Transportbefehlen durchgeführt (z. B. Load, Store) Einsparung zusätzlichen Aufwandes 

für Adreß-/Steuerleitungen und für spezielle E/A-Befehle. 

Steuerung von E/A-Bausteinen 34

Programmgesteuerter E/A-Transfer (Polling) 

Einfache E/A-Schnittstellen für programmierten E/A-Transfer bestehen wesentlich aus: 

• E/A-Datenregister (EADR) 

• E/A-Steuer- und Statusregister (EASR) 

• Adreß- und Steuerlogik 


Sie ist normalerweise an den Systembus der CPU angeschlossen. Das EADR dient zur 

Zwischenspeicherung des zu übertragenden Datenwerts (zeitliche Anpassung). Neben den zu 

übertragenden Daten braucht die Schnittstelle Signale zur richtigen Abwicklung des Datentransfers: 

• Statussignale von der Peripherie 

z. B. Anzeige, dass das Peripheriegerät einen neuen Wert ins EADR geliefert hat oder bereit 

ist, den nächsten Wert zu übernehmen. 

• Steuersignale zur Peripherie 

z. B. Anzeige, dass der vorhergehende Datenwert gelesen wurde und die Peripherie einen 

neuen Wert ins EADR einschreiben kann. 

• Steuersignale zur Schnittstelle selbst 

z. B. Signale zum Einstellen bestimmter Betriebsmodi bei programmierbaren Schnittstellen. 

Diese Signale werden - soweit sie für längere Zeit zur Verfügung stehen müssen - im EASR 

gespeichert. Das EASR kann auch aus separaten Registern für Status- und Steuersignale bestehen. 

Normalerweise verfügt ein Computer über mehr als eine E/A-Schnittstellen Adressierung 

erforderlich. Im allgemeinen erhalten EADR und EASR eine eigene, separate Adresse. Beide sind 

am Datenbus angeschlossen. Steuersignale werden wie Datenwerte ins EASR geschrieben, 

Statussignale werden wie Datenworte aus dem EASR gelesen - die Verarbeitung muss in der CPU 

durch geeignete Befehle erfolgen (z.B. logische Verknüpfung). 

Anschluß von E/A-Bausteinen 35

Die E/A-Befehlsfolge steht innerhalb eines Programms und wird im Rahmen der normalen 

Programmausführung abgearbeitet. Die gesamte Initiative zur E/A geht vom Programm aus. Zeigt 

der Inhalt des EASR an, dass keine neuen Daten im EADR stehen, muss das Programm erneut das 

EASR abfragen Warteschleife, "Polling". Dabei können zwei "Randbereiche" Probleme 

verursachen: 

• Die Zeit, die das Programm braucht, um einen Eingabewert zu bearbeiten ist manchmal 

(oder sogar immer) länger als die Zeitspanne innerhalb der sich das Eingangssignal ändern 

kann es werden Ereignisse "übersehen". 

• Bei "langsamen" Peripheriegeräten ist der Computer während der Übertragung eines 

Datenblocks die meiste Zeit mit Abfragen bschäftigt, die in den meisten Fällen negativ 

ausfallen. 

Direktspeicherzugriff (DMA = Direct Memory Access) 

Beim DMA steuert die E/A-Schnittstelle den Transfer nach Anstoß durch die CPU selbstständig 

und ohne Zuhilfenahme der CPU Datentransport zwischen Speicher und Peripherie unter 

Umgehung der CPU. Selbst, wen die CPU in dieser Zeit nichts anderes tut, ist ein wesentlich 

schnellerer Datentransport möglich (weitgehender Wegfall der Verwaltungsarbeit). Daher ist DMA 

für den schnellen Transfer großer Datenmengen besonders geeignet. Zum Anstoßen des 

DMA-Transfers übermittelt die CPU der DMA-Schnittstelle: 

• die Anfangsadresse (im Arbeitsspeicher) des zu übertragenden Datenblocks 

• die Länge des zu übertragenden Datenblocks 

• Gegebenenfalls muss noch - wie beim programmierten Transfer - das EASR entsprechend 

geladen werden Initialisierung der Schnittstelle. 

Die DMA-Schnittstelle benötigt zwei weitere Register: 

• E/A-Adreßregister (EAAR) 

• E/A-Blocklängenzähler (EAZR) 


Programmgesteuerter E/A-Transfer (Polling) 36

Da während des DMA-Transfers anstelle der CPU die DMA-Schnittstelle die Kontrolle über den 

Systembus besitzt, muss sie zusätzlich über eine Bus-Steuerlogik verfügen (Konkurrenz zwischen 

DMA Schnittstelle und CPU um den Bus). 

Ablauf eines DMA-Transfers: 

• Initialisieren der DMA-Schnittstelle 

• Bus-Freigabe-Anforderung an die CPU (DMA-Request) 

• CPU bestätigt Bus-Freigabe (DMA-Acknowledge) (Die Bus-Freigabe der CPU geschieht 

durch Umschalten der Bustreiber-Ausgänge in den hochohmigen Zustand) 

• Nun bedient die DMA-Schnittstelle den Adreß-, Daten- und Steuerbus auf die gleiche Art 

und Weise, wie die CPU. Der Inhalt des EAAR wird an den A-Bus gelegt und die für die 

Speichersteuerung notwendigen Signale auf den Steuerbus. Das EADR wird mit dem 

Datenbus verbunden. 

Man unterscheidet verschiedene DMA-Modi: 

• Byteweise Übertragung (Byte Mode) 

Die CPU gibt auf DMA-Request hin den Bus nach Beendigung des gerade laufenden 

Maschinenzyklus frei. Nach dem Transfer eines Datenwortes erhält die CPU die Kontrolle 

über den Bus zurück und sie setzt den laufenden Befehl weiter fort (bis zum nächsten 

DMA-Request) Cycle Stealing. 

• Burst-Modus 

Auch hier wird die CPU mitten in der Bearbeitung eines Befehls kurz angehalten, jedoch 

für mehrere Zyklen Transfer eines ganzen Datenblocks. 

• Halt-Modus 

Die CPU wird nach Beendigung der gerade laufenden Instruktion angehalten - solange, bis 

der DMA-Transfer eines ganzen Blocks abgewickelt ist. 

• Transparent-Modus 

DMA-Schnittstelle und CPU arbeiten zeitmultiplex während jedes Maschinenzyklus jeweils 

in einer halben Periode. Dazu ist ein sehr schneller Speicher erforderlich keine 

Beeinträchtigung der CPU. 

2.5 Timer (Zeitgeber) 


Zur Gruppe der Port-Level-Controller gehören auch die sehr häufig eingesetzten Zähler- und 

Zeitgeber-Bausteine. Da in den meisten Systemen Impulse gezählt oder erzeugt werden bzw. die 

Dauer von Impulsen gemessen werden muss, stellt es eine große Entlastung der CPU dar, wenn 

diese Vorgänge nicht per Programm gesteuert, sondern durch zusätzliche Hardware unterstützt 

werden. 

Ein Timer besteht aus einem programmierbaren (voreinstellbaren) Rückwärts-Zähler mit eigenem, 

vom Prozessor unabhängigen, Takt. Der Takt kann über Steuerregister freigegeben bzw. gesperrt 

werden. Der aktuelle Zählerstand kann jederzeit von der CPU ausgelessen werden. Bei Zählerstand 

0 wird ein maskierbarer Interrupt erzeugt. Der Timer hat in der Regel mehrere Modi: 

Direktspeicherzugriff (DMA = Direct Memory Access) 37

• Rechteckgenerator bzw. Zähler: Beim Erreichen des Zählerstandes 0 wird ein Interrupt 

erzeugt und automatisch wieder der Startwert geladen. Somit erfolgt ein Interrupt in 

regelmäßigen Zeitabständen. 

• Monoflop, One-Shot: Nach Erreichen des Zählerstandes 0 wird ein Interrupt erzeugt und 

dann bleibt der Timer inaktiv, bis wieder ein Startwert geladen wird. Typische 

Anwendungen dieser Monoflops sind auch Programmüberwachungen (Watchdog) in 

Systemen mit einer Endlos-Programmschleife, die zyklisch durchlaufen wird: Ein Befehl 

innerhalb dieser Schleife triggert das Monoflop nach; geschieht das nicht mehr, so hat sich 

das Programm "aufgehängt" und das System würde fehlerhaft arbeiten. Das Abfallen des 

Monoflops signalisiert jedoch per Interrupt den Fehler. Gegebenenfalls kann man einen 

Neustart des Systems (Reset) auslösen. 

• Frequenz- oder Periodendauermessung: Der Interrupt erfolgt, wenn die Freqenz bzw. 

Periodendauer eines an einem externen Eingang angelegten Signals länger dauert, als die 

Timerperiode. Durch Variation des Startwertes kann die Frequenz bzw. Periodendauer 

gemessen werden. 

• Rechtecksignal mit variablem Tastverhältnis 

• Verzögerter Impuls softwaregetriggert 

• Verzögerter Impuls hardwaregetriggert 

• und andere ... 

Anwendungen: 

• Erzeugen von Interrupts in festen Zeitabständen 

• Rechteckgenerator mit programmierbarer Frequenz 

• Monoflop mit programmierbarer Zeit 

• Pulsweiten-Modulation 

• "Watch-Dog" (Reseterzeugung, wenn nicht regelmäßig per Software nachgetriggert wird 

automatisches Rücksetzen bei Störungen) 

2.6 Systemkonfigurationen 

Dieses Kapitel zeigt die Zusammenschaltung von Speicher (RAM, ROM) und E/A-Bausteinen zu 

einem Mikrocomputer-System. Die zeitliche Koordination wied hier nicht behandelt (da von 

Prozessor zu Prozessor verschieden). 

Aufteilung des Adreßraums 


Hierbei geht es um die Zuordnung verschiedener Speicher- und E/A-Bereiche zu den Adressen. 

Man unterscheidet: 

• Voll-Decodierung 

Die Adressierung jedes Bausteins wird unter Verwendung aller Adreßleitungen decodiert. 

2.5 Timer (Zeitgeber) 38

• 

Weitere Bausteine sind problemlos zuschaltbar. 

Vorteil: Adreßraum nur soweit nötig gebraucht, Erweiterung problemlos 

Nachteil: Mehr Hardware nötig 

Minimaldecodierung: 

Es wird nur eine Minimalzahl von Adreßleitungen ausgewertet. Der Speicher und die 

E/A-Schnittstellen erscheinen mehrmals unter verschiedenen Adressen. 

Vorteil: Minimaler Schaltungsaufwand 

Nachteil: Adreßraum wird vollständig verbraucht 

In der Praxis finden sich häufig Mischformen (Teildecodierung), d. h. es wird nur soweit decodiert, 

daß alle Bausteine einen eigenen Adreßraum besitzen - also eindeutig ansprechbar sind. Dabei kann 

es durchaus sein, daß ein Baustein unter mehreren Adressen ansprechbar ist Bauteileersparnis 

beim Decodieren. 

Oft erfolgt die Vergabe bestimmter Bereiche für bestimmte Gruppen von Bausteinen, z. B. ROM: 0 

- $7FFF, RAM: $8000 - $8FFF, E/A: F000 - FFFF. 

Die Vergabe ist vom Prozessor abhängig (8080: ROM bei 0, 6800: ROM bei $FFFF wegen 

Reset-Vektor). In letzteren Fall kann man durch Teildecodierung erreichen, daß das ROM sowohl 

bei 0, als auch bei $FFFF adressierbar ist. 

Systembeispiel 

Minimalsystem mit 6802: 


• Prozessor 6802 (mit 128 Byte RAM) 

• EPROM 2732 als Programmspeicher (4K x 8) 

• PIA 6821 als E/A-Baustein 

• Adreßraum: 

♦ RAM: $0000 - $007F 

♦ ROM: $F000 - $FFFF 

♦ PIO: $0080 - $0083 (memory mapped I/O) 

Aufteilung des Adreßraums 39

Beispiele zur Systemkonfiguration 

1. Volldecodierung: 

Prozessor mit eingebautem RAM 

CS vom ROM active low! 

2. Volldecodierung, erweitert 

CS von ROM und RAM active low! 

3. Minimaldecodierung 

CS vom ROM und PIO active low! 


Beispiele zur Systemkonfiguration 40

Adressierung modulo $1000! 

ROM erscheint bei $0000, $1000, $2000, ..., $D000, $E000, $F000 

4. Minimaldecodierung ROM und E/A 


Adressierung modulo $1000! 

ROM erscheint bei $0000, $1000, $2000, ..., $7000 

PIO erscheint bei $8000, $8004, $8008, ..., $FFFF 

5. Teildecodierung (Volldecodierung mit Lücken) 

µP, D− und S−Bus aus Platzgründen weggelassen! 

CS active low! 

Beispiele zur Systemkonfiguration 41


RAM erscheint bei $0000, $4000, usw. 

ROM erscheint bei $1000, $5000, usw. 

PIO 1 belegt den gesamten Bereich $2000 - $2FFF, $6000 - $6FFF, usw. 

PIO 2 belegt den gesamten Bereich $3000 - $3FFF, $7000 - $7FFF, usw. 

2.7 Programmunterbrechungen 

Programmunterbrechungen können durch Signale aus der Rechnerumgebung (z.B. vom gesteuerten 

Prozeß) ausgelöst werden, um quasi "die Aufmerksamkeit" des Rechners auf sich zu lenken. 

Insbesondere auf dringende, aber relativ selten auftretende Ereignisse können so die entsprechenden 

Programme (Interrupt Service Routinen) schnell reagieren. 

In der Regel führt die Ablaufsteuerung nach der Beendigung des gerade ausgeführten Befehls die 

Programmunterbrechung durch und setzt nach der Abarbeitung der Interrupt Service Routine (ISR) 

das unterbrochene Programm fort. 

Die Aufgaben der Interruptbehandlung im einzelnen: 

a. Aufnehmen und Überprüfen der Unterbrechungsanforderung: 

Im einfachsten Fall hat das Unterbrechungswerk nur eine einzige Eingangsleitung für die 

Unterbrechungsanforderungen. Diese führt auf ein Flip-Flop, das durch ein 

Anforderungssignal auf 1 gesetzt wird und bei Bedienung des Interrupts sofort wieder 

gelöscht werden muß um evtl. weitere Interrupt-Anforderungen aufnehmen zu können. 

Dieses FF ist notwendig, um die zu beliebigen Zeitpunkten ankommenden 

2.7 Programmunterbrechungen 42

. 


Interrupt-Anforderungen (Interrupt-Request) so lange zu speichern, bis sie vom Leitwerk 

am Ende der Befehlszyklen abgefragt werden. 

Häufig darf jedoch eine Interrupt-Anforderung nicht sofort zur Unterbrechung führen, z.B. 

während der Ausführung zeitkritischer Programmabschnitte. Eine einfache Möglichkeit 

besteht in der "Maskierung" des Signals mit Hilfe eines Masken-FF's und eines Gatters. Nur 

wenn das Masken-FF gesetzt ist, führt eine "anstehende" Unterbrechungsanforderung auch 

zu einem Interrupt. Das Masken-FF kann i.a. durch Maschinenbefehle gesetzt und gelöscht 

werden ("enable" bzw. "disable interrupt"). 

Identifizierung des Interrupt-Verursachers: 

Typische Anwendungen mit mehreren Quellen für Interrupt-Anforderungen verlangen, daß 

für jedes Signal auch ein spezifisches Unterbrechungs-Bearbeitungs-Programm (ISR = 

Interrupt Service Routine) vorhanden ist, da ja auf jedes Signal anders zu reagieren ist. 

Damit ergibt sich das Problem der Interrupt-Identifizierung als Voraussetzung für die 

Zuordnung der richtigen ISR und für das Löschen des richtigen 

Interrupt-Anforderungs-Flip-Flops. 

Die beiden wichtigsten Grundprinzipien der Interrupt-Identifizierung sind: 

♦ Polling: Der Interrupt-Verursacher kann sich nicht selbst zu erkennen geben; am 

Prozessor erscheint lediglich das Anforderungssignal und es ist die Aufgabe des 

Interrupt-Bearbeitungs-Programms, über eine Kette von Abfragen an die in Frage 

kommenden Peripherie-Bausteine, den aktuellen Interrupt-Verursacher 

herauszufinden. Mit "Abfragen" ist hier das Lesen der Statusregister der 

Peripheriebausteine gemeint, in denen die Tatsache der Interrupt-Anforderung 

jeweils in einem bestimmten gesetzten Bit (Interrupt-Request-Bit) vermerkt ist. 

♦ Interrupt-Vectoring: Der Interruptverursacher liefert (im Zuge der Bussequenzen 

bei der Interrupt-Annahme durch den Prozessor) einen "Kenn-Code" mit ab (meist 

über den Datenbus), an dem der Prozessor erkennen kann, um welchen Interrupt es 

sich handelt. Dieser sogen. "Interrupt-Vektor" wird i.a. gleich als (indirekte) 

Startadresse der zugehörigen ISR verwendet. Damit entfällt das zeitraubende 

Abfragen, die sogenannte Interrupt-Reaktionszeit wird kürzer. 

c. Vorrangsteuerung der Interruptverursacher: 

Nicht alle Interrupts sind mit der gleichen Dringlichkeit zu bearbeiten; so muß z.B. die 

Interrupt-Anforderung, die den Zusammenbruch der Netzspannung anzeigt, vorrangig 

behandelt werden gegenüber einer Interrupt-Anforderung, die lediglich zur Übernahme 

eines Datenwortes von einer Eingabeschnittstelle auffordert. 

d. Retten und Rückspeichern des Prozessorzustandes: 

Wenn eine Programmunterbrechung ausgeführt werden soll, so muß auf jeden Fall der 

Zustand des Prozessors gerettet werden. Denn das Interrupt-Service-Programm benutzt ja 

ebenfalls den Prozessor und verändert dabei dessen Zustand. Soll anschließend das 

unterbrochene Programm fortgesetzt werden, so ist es unbedingt nötig, vorher den Zustand 

wieder herzustellen, wie er bei Auftreten der Unterbrechung herrschte. Die 

Prozessorzustände, die während einer Befehlsausführung durchlaufen werden, sind nur sehr 

aufwendig zu beschreiben (z. B. mitten in einer Multiplikation). Entsprechend groß wäre 

der Aufwand zur Rettung des Prozessorzustandes, wenn man Unterbrechungen mitten im 

Befehlszyklus zuließe. Man läßt deshalb Unterbrechungen i. a. nur am Ende eines Befehls 



zu, denn dann ist der Prozessorzustand vollständig durch den Inhalt der Prozessorregister 

definiert. 

In einer typischen Interrupt-Service-Routine werden die Inhalte von Prozessor-Registern 

verändert. Aber selbst wenn keine derartigen Befehle in der ISR vorkommen, so müssen 

doch zumindest zwei Register gerettet werden: der Programmzähler und das 

Prozessor-Status-Register, denn die Inhalte dieser Register ändern sich in jedem Fall. Man 

bezeichnet diese beiden Register auch als "Zustandsvektor". Die einfachste Möglichkeit, 

den Zustandsvektor zu retten, besteht darin, ihn in bestimmte reservierte Speicherzellen zu 

schreiben, und ihn von dort nach Beendigung der ISR wieder zu lesen. Dies hat den 

offensichtlichen Nachteil, daß keine Verschachtelung (Nesting) von 

Programmunterbrechungen möglich ist, d.h. man müßte das Unterbrechen einer ISR 

verbieten, weil sonst der gerettete Zustandsvektor überschrieben würde. 

Wesentlich besser eignet sich zum Retten des Zustandsvektors ein sogenannter 

Kellerspeicher (engl. stack, oder auch LIFO = last in first out). Das Stackprinzip kann 

hardwaremäßig realisiert sein (spezielle Chips) oder in einem reservierten Bereich des 

normalen Arbeitsspeichers nachgebildet sein. Zu diesem Zweck existiert ein Zeigerregister, 

das immer den letzten Eintrag im Stack adressiert (Stackpointer zeigt immer auf den "Top 

of Stack", d.h. auf den letzten Eintrag). 

Mit jeder neuen (geschachtelten) Programmunterbrechung wächst der Kellerspeicher um 

die entsprechenden Einträge, mit jedem Rücksprung in ein vorher unterbrochenes 

Programm reduziert er sich wieder entsprechend, so daß das zuletzt unterbrochene 

Programm nach Beendigung des laufenden wieder aufgenommen wird. Der Stack wächst 

und schrumpft mit jedem Eintreten/Verlassen von ISRs, man sagt, der Stack "pulsiert". 

Häufig müssen außer den beiden o.g. Registern (PC und Prozessor-Status-Register) auch 

noch andere gerettet und rückgespeichert werden, nämlich dann, wenn sie von der ISR 

verändert werden. Auch hier bringt die Verwendung eines Stacks die gleichen Vorteile wie 

oben erwähnt. Da diese Register jedoch nicht immer gerettet werden müssen besteht hier 

die Möglichkeit, sie entweder genau wie den Zustandsvektor per Hardware (d.h. per 

Ablaufsteuerung) zu retten oder per Maschinenbefehl(e), also programmgesteuert. 

Während bei der Hardware-Lösung sämtliche Register gerettet werden müssen (sie "weiß" 

je nicht, welche es sein müssen), kann die programmierte Lösung sich auf genau die 

Register beschränken, die in der ISR verändert werden (der Programmierer weiß welche - 

hoffentlich!). Die sicherere und meist auch schnellere, jedoch auch aufwendigere Methode 

ist die Hardware-Lösung. 

Die Notwendigkeit, bei der Ausführung einer Programmunterbrechung zunächst den Zustand des 

unterbrochenen Programms zu retten, kann also eine Reihe von Transportoperationen benötigen; 

vom Moment des Eintreffens der Unterbrechnungsanforderung vergeht daher einige Zeit, die 

Interrupt-Reaktionszeit, bis der erste produktive Befehl der ISR ausgeführt wird. Diese 

Reaktionszeit setzt sich aus den folgenden Komponenten zusammen: 

• T1: Durchschaltezeit (der Anforderung bis zur Unterbrechungsanmeldung) aufgrund einer 

gesetzten Sperre (z.B. auch dann, wenn gerade eine Interrupt-Service-Routine bearbeitet 

wird). Diese Zeit kann u.U. recht lang sein! 

• T2: Wartezeit bis zur Beendigung des gerade ausgeführten Befehls (maximal die des 

längsten vorkommenden Befehls) 

• T3: Zeit zum Retten des Programm-Zustandes und Laden des Unterbrechungs-Vektors. 

Selbst wenn die Durchschaltung der Anforderung unmittelbar erfolgt (T1 = 0, weil keine 

Sperre gesetzt ist), kann die Summe von T2 und T3 für zeitkritische Echtzeitanforderungen 

doch noch zu groß sein. 



Unterbrechungsgesteuerter E/A-Transfer 

Die E/A-Befehlsfolge wird durch einen von der E/A-Schnittstelle ausgelösten Interrupt gestartet. 

Der Interrupt wird von der Schnittstelle abgesetzt, wenn ein Datenwort empfangen wurde und im 

EADR steht (bzw. wenn ein Datenwort aus dem EADR abgeholt wurde). Die CPU braucht nicht in 

einer Programmschleife zu warten, sondern kann in der Zwischenzeit ein anderes Programm 

bearbeiten, das durch den Interrupt kurzzeitig unterbrochen wird. Der interruptgesteuerte Transfer 

gestattet zudem die quasi-simultane Bedienung mehrerer langsamer Schnittstellen. Zur Realisierung 

muß eine Interrupt-Leitung von der E/A-Schnittstelle (EASR) zum Unterbrechungswerk der CPU 

vorhanden sein. 

Vorteil des programmierten Transfers: Sehr einfache Schnittstellen, die übersichtlich und leicht zu 

verwenden sind. 

Nachteil des programmierten Transfers: Für den Transfer jedes einzelnen Datenworts wird die CPU 

benötigt. Diese muss dabei relativ viel Verwaltungsaufwand leisten (Laden/lesen EASR, 

Interrupt-Behandlung) die maximale Datenrate ist sehr begrenzt. 

Durch den Interupt wird auch der Befehlszyklus erweitert. Nach Abarbeitung des Befehls wird das 

Vorhandensein eines Interrupts geprüft und ggebenenfalls in die Interrupt-Serviceroutine (ISR) 

verzweigt. Dabei werden alle Register auf dem Stack abgelegt und beim Beenden der ISR wieder 

restauriert. 

Unterbrechungsgesteuerter E/A-Transfer 45

Man unterscheidet bei der Adressangabe für die ISR zwei Möglichkeiten: 

• vektorisierter Interrupt: Es kann der ISR eine beliebige Adresse zugeordnet werden, 

welche von der CPU eingelesen wird. 

• nicht vektorisierter Interrupt: Der ISR wird eine feste Startadresse zugeordnet. 







Unterbrechungsgesteuerter E/A-Transfer 46

3. Programmierung des Mikroprozessors 

68HC11 

3.1 Überblick 

Programmiermodell 

Da man wohl kaum einen Schaltplan des CPU-Herstellers bekommt und da dieser auch viel zu 

komplex ist, wird für die Programmierung mit dem sogenannten "Programmiermodell" gearbeitet. 

Dies umfaßt: 

• Die Gesamtheit der dem Programmierer zugänglichen Register der CPU 

• Die Gesamtheit der vom Programmierer veränderbaren Register der CPU 

Der Prozessor 68HC11 ist eine Weiterentwicklung des 6800 (weitgehend befehlskompatibel, 

erweiterter Befehlssatz, zusätzliche Register). Der 68HC11 besitzt vier 8-Bit-Register und fünf 

16-Bit-Register: 

• 2 Akkumulatoren A und B (8 Bit) 

♦ Zusammenfassung von A und B zum 16-Bit-Akku D (A: MSB, B: LSB) 

16-Bit-Instruktionen 

♦ Beide Akkumulatoren werden gleich behandelt 

♦ Zwei Akkus Vorteile bei der Programmierung (z. B. bei Schleife: A zum Rechnen, 

B als Schleifenzähler) 

• Program Counter PC (Befehlszähler, 16 Bit) 64 K Adreßraum 

• Stackpointer S 

Für Unterprogrammsprünge, Prozessor-Status bei Interrupt Der Stackpointer kann auch als 

Index-Register verwendet werden 

• 2 Indexregister X und Y (16 Bit) 

3. Programmierung des Mikroprozessors 68HC11 47

♦ Für indizierte Adressierung 

♦ Beide sind gleichwertig (Abarbeitung mit X etwas schneller als mit Y) 

• Condition Code Register CC (8 Bit) Statusregister (3 Bit für Stop/Interrupt-Verarbeitung, 5 

Bit für ALU) 

♦ Jedes Bit wirkt wie ein Flip-Flop (1 = gesetzt, 0 = rückges.) 

♦ Welche Bits (= Flags) von den einzelnen Befehlen auf welche Art beeinflusst werden, 

ist in der Befehlsliste angegeben. 

♦ Ein Flag bleibt solange unverändert, bis ein Befehl ausgeführt wird, der es beeinflusst. 

♦ Jedes Bit des CC kann per Befehl gezielt gesetzt/rückgesetzt werden 

♦ Die Bedeutung der Bits: 

C: Carry-Flag 

1, wenn bei arithmetischen Operationen ein Übertrag vom höchstwertigen Bit 

auftritt (bei Subtraktion: wenn "geborgt" wird). Wird ausserdem durch 

Schiebe- und Rotationsbefehle beeinflußt. 

V: Overflow-Flag 

1, wenn ein Arithmetik-Überlauf (Zahlenbereichsüberschreitung) auftritt. 

Dies tritt nur bei konegativen Zahlen auf und ist dann der Fall, wenn bei 

Addition oder Subtraktion die beiden Operanden das gleiche Vorzeichen 

besitzen und das Vorzeichen des Ergebnisses davon verschieden ist. 

Z: Zero-Flag 

1, wenn das Ergebnis einer Operation das Ergebnis Null hat. 

N: Negativ-Flag 

1, wenn das Ergebnis einer Operation negativ ist. Das N-Bit ist gleich dem 

höchstwertigen Bit des Ergebnisses. 

H: Half-Carry-Flag 

1, wenn bei einer 8-Bit-Operation ein Übertrag von Bit 3 nach Bit 4 auftritt. 

I: Interrupt Mask 

Falls 1, werden Interrupt-Anforderungen auf der IRQ-Leitung nicht bedient 

(Freigabe des IRQ I-Bit auf 0 setzen). Bleibt solange gesperrt, solange der 

Stackpointer nicht initialisiert wurde. 

X: Non Maskable Interrupt Mask 

Falls 1, werden Interrupt-Anforderungen auf der NMI-Leitung nicht bedient. 

Eigentlich ein Paradox, denn der NMI sollte ja gerade nicht maskierbar sein. 

Der NMI wird jedoch gesperrt, wenn der Stackpointer noch nicht initialisiert 

wurde und wenn gerade die NMI-Interrupt-Serviceroutine abgearbeitet wird. 

S: Stop disable 

1, wenn der STOP-Befehl nicht ausgeführt werden soll. 

Einteilung der Befehle 


Programmiermodell 48

Der 68HC11 kennt 59 verschiedene Grundbefehle überschaubarer Befehlssatz. Anwendung der 

Befehle mit unterschiedlichen Registern und Adressierungsarten führt zu 1464 verschiedenen 

OP-Codes. Der OP-Code besteht (einschließlich Angabe über Adressierungart) aus einem, zwei oder 

drei Bytes: Der Adreßteil (falls vorhanden) besteht aus einem oder zwei Bytes; es gibt also 1-, 2-, 3-, 

4- und 5-Byte-Befehle. Das Befehlsformat kann also sein: 

Das "prebyte" erweitert den Befehlsumfang, so daß mehr als 256 Befehle möglich sind. Der Nachteil 

dabei ist, daß die Abarbeitung des Befehls länger dauert und der Befehl natürlich auch ein Byte mehr 

an Speicher braucht. 

Adressen werden in zwei aufeinanderfolgenden Speicherbytes abgelegt und zwar in der Form 

AH AL 

ea ea+1 

Mit "ea" wird die effektive Adresse = echte Adresse = Adresse des Operanden im Speicher 

bezeichnet. Je nach Adressierungsart (siehe unten) ist eine Adreßberechnung notwendig. Das Ergebnis 

der Adreßrechnung landet im Adreßregister und wird dann zur Adressierung des Speichers verwendet. 

Befehlsklassen: 

• Verarbeitungsbefehle 

♦ Transportbefehle 

♦ arithmetische Befehle 

♦ logische Befehle 

♦ Schiebe- und Rotations-Befehle 

• Steuerbefehle 

♦ Testbefehle (beeinflussen CC-Register) 

♦ Sprungbefehle 

♦ Unterbrechungsbefehle 

♦ Befehle zur Beeinflussung des Systemzustands 

Angaben über gültige Adressierungsarten, Länge, CC-Beeinflussung, Dauer (Anzahl der Taktzyklen) 

stehen in der Befehlstabelle. 

3.2 Adressierungsarten 


Einteilung der Befehle 49

Die meisten Befehle gestatten mehrere Adressierungsarten, aber nicht alle Adressierungarten lassen 

sich auf jeden Befehl anwenden. Jede zulässige Adressierungsart bei einem Befehl führt zu einen 

eigenen OP-Code. Die zulässigen Adressierungsarten und der jeweilige OP-Code lassen sich der 

Befehlsliste entnehmen. Die tatsächliche Länge und Ausführungszeit eines Befehls hängen von der 

Adressierungsart ab. Die Zahl der Bytes eines Befehls und seine Ausführungszeit lassen sich aus der 

Befehlsliste entnehmen. 

Konstanten-Adressierung (Immediate Addressing) 

Die Daten folgen unmittelbar auf den OP-Code. Je nach Befehl/Register sind es 8 Bit (1 Byte) oder 16 

Bit (2 Byte). Im Assembler wird dies durch Voranstellen von "#" kenntlich gemacht, zum Beispiel: 

LDAA #20 - Lade Akku A mit dem Wert 20 

Absolute Adressierung 


Absolut vollständige Adressierung (Extended Addressing) 

Der Adreßteil des Befehls enthält eine vollständige 16-Bit-Adresse. Es ist eine Adressierung des 

gesamten Adreßraums möglich. Zum Beispiel: 

LDAA $A174 - Lade Akku A mit dem Inhalt der Speicherzelle $A174 

Absolut unvollständige Adressierung (Zero Page / Direct Addressing) 

Der Adreßteil enthält nur den niederwertigen Teil (LSB) der Adresse. Der höherwertige Teil wird auf 

Null gesetzt. Damit lassen sich die Adressen zwischen 0 und 255 ($0 - $FF) erreichen. Der Befehl ist 

ein Byte kürzer als bei der absoluten Adressierung und deshalb auch schneller in der Ausführung. Im 

Assembler wird dies durch Voranstellen von "

Implizite Adressierung (Inherent Addressing) 

Alle Adreßangaben sind im OP-Code des Befehls enthalten, es gibt keinen Adreßteil. 

• AD-Teil im Befehl nicht nötig 

• entweder keine AD-Angabe nötig (NOP) 

• oder AD-Angabe bezieht sich auf Register (LSRA, ABX, ...) 

Indizierte Adressierung (Indexed Addressing) 

Die effektive Adresse ergibt sich hier aus dem Inhalt eines Adreßregisters (z. B. X oder Y) und einer 

dazu addierten Distanz (Offset), die auch Null sein kann. Der Offset wird grundsätzlich konegativ 

bewertet (-128 .. +127). Die Adreßrechnung erfolgt modulo 64 K (bleibt also immer im Adreßraum 

des 68HC11). Zum Beispiel: 

CLR 5,X (ergibt als Code: 6F 05) 

CLR -5,X (ergibt als Code: 6F FB) 


Anmerkungen zur Progam Counter-relativen Adressierung: 

Es wird der Stand des Program Counterszum Zeitpunkt der Befehlsausführung verwendet (Dies ist 

nicht die Adresse, an der der Befehl beginnt, denn der Program Counter enthält ja immer die Adresse 

des nächsten, auszuführenden Befehls. Der Program Counter ist gleich der Adresse des Befehls + 

Länge des Befehls). Die Program Counter-relative Adressierung wird oft bei Sprungbefehlen 

verwendet. Zweck: lageunabhängige Programme (Ablauf an jeder Position im Speicher). 

Befehlsaufbau: offset = Zieladresse - Befehlsadresse - Befehlslänge 

Befehlsausführung: Zieladresse = Befehlszählerstand + offset 

Implizite Adressierung (Inherent Addressing) 51

Alle Adressierungsarten im Überblick 

zeigt die folgende Grafik: 

3.3 Assembler-Befehlsaufbau 

Der Assembler ist ein Programm zur Übersetzung mnemotechnischer Befehlsbezeichnungen in die 

Maschinensprache. Es erfolgt 1:1-Abbildung der Befehle in die Maschinensprache, d. h. eine 

Assemblerzeile entspricht einem Befehl. 

Maschinensprache: 

• OP-Code im Maschinencode (binär bzw. sedezimale Abkürzung) 

• Adresse als Maschinenadresse (binär bzw. sedezimale Abkürzung) 

Assemblersprache: 

• Festlegung symbolischer Bezeichnungen, die vom Assembler-Programm erkannt und 

verarbeitet werden. 

• OP-Code: mnemonische Bezeichnung (Mnemonics) 

• Adresse: symbolische Bezeichnung (Name, Marke (Label)) 

Allgemeiner Aufbau eines Assemblerbefehls: 


Marke OP-Code Operand/Adresse Kommentar 

Indizierte Adressierung (Indexed Addressing) 52

Beispiel: 

START LDAA DAT1 ; Zähler initialisieren 

• Op-Code muß immer vorhanden sein 

• Operand/Adresse, falls der Befehl es verlangt 

• Marke und Kommentar sind optional 

• Trennzeichen zwischen den einzelnen Feldern: Leerzeichen 

Marken-Feld: (optional) 

Das Feld beginnt in Spalte 1 (also ganz vorne). Die Marke besteht aus Buchstaben, Ziffern 

und Sonderzeichen (".", "_", "@") und beginnt mit einem Buchstaben. Die Länge ist auf 31 

Zeichen begrenzt. Die Marke kann durch einen ":" abgeschlossen werden, dieser wird vom 

Assembler ignoriert. Es wird bei manchen Assemblern - wie beispielsweise auch in C - 

zwischen Groß- und Kleinschreibung unterschieden. Registernamen (A, B, C, D, X, Y, S) sind 

reserviert und dürfen nicht verwendet werden. Marken bezeichnen Konstante oder 

Speicheradressen. 

OP-Code-Feld: (muß vorhanden sein) 

Falls keine Marke vorhanden, muß wenigstens ein Leerzeichen davor stehen. Sinnvoller ist es 

jedoch, die Opcodes in einer Spalte untereindander zu schreiben. Die Befehle werden durch 

Mnemonics aus zwei bis vier Buchstaben dargestellt. Bei einigen Befehlen ist eine 

Registerangabe direkt an das Mnemonic anzuhängen (z. B. ADDA, ADDB, ADDD). In 

diesem Feld kann auch eine Assembler-Direktive (Pseudobefehl) stehen Anweisung für 

den Assembler, Genaueres später. 

Operanden/Adreß-Feld: (abhängig vom OP-Code) 

Dieses Feld enthält den Operanden des Befehls, meist eine Adresse oder eine Konstante. 

Aufbau hängt von der Adressierungsart ab. Falls eine Adressierungsart mehrere Operanden 

verlangt (z. B. Register + Offset) erfolgt Trennung der Operanden mit Komma. 

Bei vielen Assemblern sind arithmetische und logische Ausdrücke aus Konstanten möglich. 

Die Adreßangabe (Offset) kann erfolgen als: 

◊ Bezeichner, z. B. MAXIMUM 

◊ Dezimalzahl (ohne Kennzeichnung), z. B. 72 

◊ Sedezimalzahl (Vorsatz $), z. B. $48 

◊ Dualzahl (Vorsatz %), z. B. %01001000 

◊ ASCII-Zeichen(-folge), z. B. 'Hallo' oder "Hallo" 

◊ als Offset vom "Location Counter" (Vorsatz *), z. B. *+5 

Im Operandenfeld kann auch mit den vier Grundrechenarten (+ - * /) und Klammern 

gearbeitet werden. Beachten Sie, daß die Ausdrücke zur Assemblierungszeit ausgewertet 

werden - nicht zur Laufzeit des Programms! Es sollte sich also immer um "konstante" 

Ausdrücke handeln, z. B. 

BOTTOM EQU TOP + 10 

Kommentar-Feld: (optional) 

Das Kommentarfeld wird durch den Strichpunkt oder zwei Schrägstriche eingeleitet. Es 

enthält beliebige Zeichenfolgen und wird vom Assembler ignoriert. 

Zusätzlich sind auch reine Kommentarzeilen möglich, die mit einem "*" in Spalte 1 beginnen. 

Der Assembler hat zwei Durchläufe: 

Beispiel: 


1. Durchlauf (pass one): Syntaxprüfung und Aufbau des Adreßbuchs. 

2. Durchlauf (pass two): Vollständigkeitsprüfung und Aufbau des Zielprogramms. 

3.3 Assembler-Befehlsaufbau 53

1. Quellcode 

Die Felder für Adresse und Code sind hier noch leer, sie werden vom Assembler gefüllt. Es gibt zwei 

Pseudobefehle, die weiter unten genauer behandelt werden: ORG legt die Startadresse des erzeugten 

Codes fest und END beendet den Quellcode. 

Adresse Inhalt Marke Befehl Operand Kommentar 

ORG $8000 In den Speicher ab $8000 

MAIN BRA MARKE relativer Vorwärtssprung 

JMP MARKE absoluter Vorwärtssprung 

BRA MAIN relativer Rückwärtssprung 

MARKE JMP MAIN absoluter Rückwärtssprung 

END 

2. Erster Assemblerlauf: Adresspegel und Code eintragen 

Im ersten Durchlauf werden die Befehle übersetzt. Damit liegt die Adresse eines jeden Befehls fest 

(weil die Länge eines Befehls ja bekannt ist). Jedoch können die Sprungadressen noch nicht 

eingetragen werden, weil bei Vorwärtssprüngen diese beim Übersetzen des jeweiligen Befehls noch 

nicht bekannt sind. 



8000 20 ?? MAIN BRA MARKE relativer Vorwärtssprung 

8002 7E ?? ?? JMP MARKE absoluter Vorwärtssprung 

8005 20 ?? BRA MAIN relativer Rückwärtssprung 

8007 7E ?? ?? MARKE JMP MAIN absoluter Rückwärtssprung 

END 


3. Zweiter Assemblerlauf: Adressen absättigen 

Beim ersten Durchlauf hat der Assembler parallel zur Übersetzung noch eine Symboltabelle angelegt, 

welche die Zuordnung zwischen Marke (Name) und Adresse enthält. Nun können mit Hilfe dieser 

Tabelle im zweiten Durchlauf die Adressen eingetragen werden. 



8000 20 05 MAIN BRA MARKE relativer Vorwärtssprung 

8002 7E 80 07 JMP MARKE absoluter Vorwärtssprung 

8005 20 F9 BRA MAIN relativer Rückwärtssprung 

8007 7E 80 00 MARKE JMP MAIN absoluter Rückwärtssprung 

END 

Die Symboltabelle nimm neben den Sprungadressen auch alle Namen von Konstanten und Variablen 

auf. Im zweiten Lauf werden dann auch diese Namen durch die ermittelten Werte ersetzt. 

1. Quellcode 54

3.4 Pseudobefehle (Assembler-Direktiven) 

Pseudobefehle erzeugen keine Maschinenbefehle sondern 

• erzeugen Konstanten und Variablen (bytes, words, longwords, strings) 

• beeinflussen den Adresspegel 

• führen zu Einträgen in der Symboltabelle 

• steuern den Übersetzungsvorgang 

Der Assembler führt einen Zähler, der Auskunft über den aktuellen Adreßpegel gibt. Dieser 'Location 

Counter' dient beispielsweise zum Berechnen von Sprungadressen. Er entspricht im Prinzip dem 

'Program Counter' im realen Prozessor. Die Pseudobefehle werden im OP-Code-Feld einer 

Assemblerzeile angegeben. Unser Assembler kennt folgende Direktiven: 

ORG Origin 

Der Location Counter wird auf die im Operandenfeld angegebene Adresse 

gesetzt. Er legt damit die Adresse fest, an der der Code später im Speicher des 

Controllers abgelegt wird, z. B.: 

ORG $8000 

EQU Equate 

Definition eines Namens (Konstante, Marke). Der im Operandenfeld 

angegebene Wert wird dem im Markenfeld angegebenen Namen gleichgesetzt, 

z. B.: 

ETX EQU 3 

CR EQU $D 

LF EQU $A 

PUFL EQU $100 

DC.B Define Constant Byte 

Reservierung von Speicherplatz und Belegung mit den im Operandenfeld 

angegebenen konstanten Byte-Werten. Mehrere Operanden durch Komma 

trennen! Z. B.: 

TAB DC.B $0D,$0A,$03 

Neben einfachen Konstanten sind in (einfache oder doppelte) Hochkomma 

eingeschlossene Zeichenketten möglich. Die Hochkommas gehören dabei 

nicht zur Zeichenkette. In den Zeichenketten sind folgende Sonderzeichen 

erlaubt: 

Z. B.: 

• \a Bell ($07) 

• \f Formfeed ($0C) 

• \n Newline ($0A) 

• \r Carriage Return ($0D) 

• \t Tabulator ($09) 

• \\ \ 

TEXT DC.B "Hello World!\n\r" 


Bei manchen Assemblern wird anstelle von DC.B das Kürzel FCB (Form 

Constant Byte) verwendet (bei unserem geht beides). 

3.4 Pseudobefehle (Assembler-Direktiven) 55

DC.W Define Constant Word 


angegebenen konstanten 16-Bit-Werten. Mehrere Operanden durch Komma 

trennen, z. B.: 

ATAB DC.W $FF30,$FF45,$FFA0 

Bei manchen Assemblern (auch unserem) wird anstelle von DC.W das Kürzel 

FDB (Form Double Byte) verwendet. 

DC.L Define Constant Longword 


angegebenen konstanten 32-Bit-Werten. Mehrere Operanden durch Komma 

trennen, z. B.: 

DS.B 

DS.W 

DS.L 

XTAB DC.L $FF30FF45,$F000FFA0 

Define Storage Bytes/Words/Longwords 

Reservieren von Speicherbytes, Speicherworten (16 Bit) oder Langworten (32 

Bit) ohne Vorbelegung. Der Operand gibt die Anzahl der zu reservierenden 

Elemente (Bytes, Worte oder Langworte) an, z. B.: 

PUFFER DS.B 100 

ADRTAB DS.W 23 

Der Reservierungsvorgang hat eher informatorischen Charakter. Es findet 

seitens des Assemblers keinerlei Adress- oder Bereichsüberprüfung statt! Bei 

manchen Assembler wird stattdessen nur eine Reservierung in Bytes mit dem 

Befehl RMB (Reserve Memory Byte) vorgenommen. 

INCLUDE Einfügen einer Quelldatei an der entsprechenden Stelle. Der Dateiname wird 

entweder in < ... > (voreingestelltes Include-Verzeichnis) oder " ... " 

(beliebiger Dateipfad) eingeschlossen, z. B.: 

INCLUDE "definitionen.a" 

INCLUDE 


NOLIST Unterdrücken der Erzeugung eines Programmlistings bis zum nächsten 

LIST-Befehl. 

LIST Fortsetzen des Listings nach einem vorher platzierten NOLIST-Befehl. 

END Ende des Assemblerprogramms. Optionaler Befehl am Programmende. Wird 

aus Gründen der Kompatibilität vom Assembler akzeptiert, kann aber 

weggelassen werden. Text nach diesem Befehl wird vom Assembler ignoriert. 

Speicher-Organisation 

Mit Hilfe der ORG-Anweisung kann der Programmierer verschiedene Programmteile oder 

Datenbereiche an beliebigen Stellen im gesamten Adreßraum ablegen. Eine sinnvolle 

Speicheraufteilung hat jedoch verschiedene Randbedingungen zu berücksichtigen. 

Von der Hardwareseite her sind z.B. RAM- und ROM-Bereiche verschiedener Größe gegeben, denn 

Programme sollen häufig im ROM liegen während variable Datenbereiche natürlich nur im RAM sein 

können. Eine effiziente Nutzung der physikalisch vorhandenen Speicher verlangt auch die Definition 

von lückenlos zusammenhängenden Teilbereichen sowohl von Programmteilen (Hauptprogramm, 

Unterprogramme, Interrupt-Service-Routinen) als auch von Datenbereichen (Datenpuffer, 

Ausgabetexte, Zustandsvariablen, Stacks, Peripherie-Baustein-Register etc). 

Speicher-Organisation 56

Als Grundregel gilt: Je eine ORG-Anweisung für den Daten- und den Programmbereich genügt, denn 

dann sind beide Bereiche jeweils zusammenhängend. Es ist nicht nötig, z.B. für jedes Unterprogramm 

oder jede Interrupt-Service-Routine ein neues ORG zu setzen. Jede weitere ORG-Anweisung steigert 

nur die Gefahr von Fehlern (z.B. überlappende Bereiche) bzw. Speicherverschwendung durch 

unnötige Lücken. Bedenken Sie, dass Sie vom Assembler nicht gewarnt werden, wenn sich 

Speicherbereiche überlappen oder Sie Bereiche wählen, an denen kein realer Speicher vorhanden ist. 

Ganz auf die ORG-Anweisung zu verzichten ist zwar möglich (Programm- und Datenbereich hängen 

dann zusammen und beginnen bei Null), aber nicht zu empfehlen. Durch kommentierte 

ORG-Anweisungen zeigt man, das diese wohlüberlegt gewählt wurden; also besser ORG $0000 

angeben als einfach weglassen. 

Anmerkung: Da bei einem Mikrocontroller ja zwischen ROM- bzw. EEPROM-Speicher und RAM 

unterschieden werden muß, ist auch die Reservierung von Speicher von dieser Unterscheidung 

betroffen. Mit DC.B, DC.W oder DC.L vordefinierte Konstante liegen im ROM/EEPROM-Bereich, 

mit DS.B, DS.W oder DS.L reservierter Speicher im RAM-Bereich. 

Merkregeln für die Verwendung von EQU, DS.B/DS.W/DS.L und DC.B/DC.W/DC.L 

• EQU nur für Konstanten, die mit symbolischen Namen versehen werden sollen. Sollen solche 

Werte später doch geändert werden, so muss das Quellprogramm geändert und neu 

assembliert werden. 

• DS.B/DS.W/DS.L nur zum Bereitstellen von RAM-Speicherplatz für Daten, die vom 

Programm erst dorthin geschrieben werden, z.B. eingelesene Messwerte, etc. 

• DC.B/DC.W/DC.L zum Vorbelegen von Datenbereichen im ROM/EEPROM mit konstanten 

Werten, Umrechnungstabellen, Texten etc. 

Grundsätzlicher Aufbau eines 68HC11-Assemblerprogramms 

1. Konstantendefinitionen 

Hier werden alle Definitionen für Werte und Adressen (EQU-Anweisung) vorgenommen. Diese 

"Namensdefinitionen" belegen keinen Speicherplatz, sondern dienen nur der besseren Lesbarkeit und 

Wartbarkeit des Programms. Zum Beispiel: 

STACK EQU $7FFF Stackbereich 

PROG EQU $8000 Programmbereich 

DATA EQU $2000 Datenbereich (auch Adr. 0 möglich) 

RVECT EQU $FFFE Reset-Vektor 

SCCR1 EQU $102C 

SCCR2 EQU $102D 

CR EQU 13 Carriage-Return-Zeichen 

LF EQU 10 Linefeed-Zeichen 

ETX EQU 3 Textende 

MAXDATA EQU 100 

Wichtig sind die ersten fünf Zeilen, die bei keinem Programm fehlen dürfen. Sie legen die 

Adressbereiche für RAM und EEPROM fest und definieren die Adressen der beiden Vektoren, die 

immer gesetzt werden müssen. 

2. Variablendefinitionen 


Hier werden alle Daten definiert, die Speicherplatz belegen. Es ist ratsam, den Datenbereich durch 

eine eigene ORG-Anweisung einzuleiten, um die Daten an definierter Stelle im Speicher abzulegen. 

Bei einem Steuerungsrechner muß auf jeden Fall in Datenbereich (RAM) und Programmbereich 

Speicher-Organisation 57

(PROM) unterschieden werden. Man kann die Variablen auch nach dem Programmcode ablegen. Zum 

Beispiel: 

ORG DATA Datenbereich z.B. ab Adresse $2000 

COUNT DC.B 0 Wert mit Null vorbelegen 

PUFFER DS.B 80 80 Byte Pufferbereich reservieren 

TEXT DC.B 'Hello World' Text, abgeschlossen durch Zeilen- 

DC.B CR, LF, ETX wechsel und Nullbyte 

3. Programmbereich 

Nun folgt das eigentliche Programm. Es wird immer mit einer ORG-Anweisung an eine definierte 

Adresse gelegt. Diese Adresse ist auch Startadresse des Programms. 

Achtung: Der Assembler kümmert sich nicht um die Adreßlage des Programms, auch Überlappungen 

mit dem Datenbereich werden nicht als Fehler gemeldet aufpassen. 

Es gibt zwei Möglichkeiten der Anordnung von Haupt- und Unterprogrammen. Üblich ist es, das 

Hauptprogramm am Anfang zu postieren und dann die Unterprogramme folgen zu lassen. Wer lieber 

die UP zuerst stehen hat, muß das HP mit einer Marke versehen (z. B. "MAIN") und nach der 

ORG-Anweisung als erste Anweisung einen Sprung zum HP eintragen, z. B.: 

....... Definitionen (1. und 2.) 

ORG PROG Programmbereich, z. B. $8000 

JMP MAIN 

....... Unterprogramme 


MAIN LDS #STACK Stackpointer setzen, sonst geht nichts 

. 

. 

. 

. 

ORG RVECT 

DC.W MAIN Reset-Vektor auf Programmanfang setzen 

END 

Häufiger ist jedoch die Variante mit vorangestelltem Hauptprogramm anzutreffen. Beim folgenden 

Rumpfprogramm sind auch noch einige weitere Besonderheiten berücksichtigt: 

stak equ $7FFF ; Stackbereich ab $7FFF (RAM, abwaerts) 

prog equ $8000 ; Programmbereich ab $8000 (EEPROM) 

data equ $2000 ; Datenbereich ab $2000 (RAM) 

rvec equ $FFFE ; Reset-Vektor 

. ; ggf. weitere Vektoren 

org data ; Beginn Datenbereich 

. ; Variablen-Definitionen 

. 

org prog ; Beginn Programmbereich 

main lds #stak ; Stackpointer setzen 

. 

. ; alle Initialisierungen 

. 

loop . ; Befehle des Programms 

. 

. 

jmp loop 

Grundsätzlicher Aufbau eines 68HC11-Assemblerprogramms 58

. ; ggf. fixe Tabellen dahinter 

. 

. ; ggf. Setzen der Interrupt-Vektoren 

. ; (Reihenfolge der Adressen beachten!) 

org rvec ; Setzen des Reset-Vektors 

fdb main 

end 

Beim Programmieren einer Controller-Anwendung ist u. a. auch zu berücksichtigen, dass 

RAM-Inhalte nach dem Ausschalten und späteren Wiedereinschalten verloren gehen. Das bedeutet, 

dass feste Werte wie Ausgabestrings, Anfangswerte von Variablen usw. nicht im RAM 

(Datenspeicher), sondern im EEPROM (Programmspeicher) abgelegt werden müssen. Das hat aber 

Konsequenzen: 

• Daten im Programmspeicher können nicht geändert werden (EEPROM!) 

• Braucht man Anfangswerte für Variablen, müssen diese im Programmspeicher abgelegt und 

in der Initialisierungsphase in Variablen im RAM kopiert werden. 

Hinweis: Die im Datenbereich abgelegten konstanten Werte (mittels DC.B etc.) werden nur einmal 

beim Herunterladen des Programms ins Zielsystem im Speicher eingetragen, danach nie wieder. 

Schon das Drücken der Reset-Taste kann zu "seltsamen" Verhaltenformen des Programms führen. 

3.5 CPU-Befehle 

Bei der folgenden Beschreibung der Befehle werden einige Standardnamen verwendet: 

• Mit A, B und D werden die Akkumulatoren bezeichnet 

• Mit X, Y und S werden die Indexregister und der Stackpointer bezeichnet 

• "adr." bezeichnet den Inhalt eines beliebigen Speicherbytes oder eine Konstante 

• (A) oder (adr.) bezeichnet den Inhalt von Akku A bzw. den Inhalt der Speicheradresse "adr.". 

Transport-Befehle 

Ladebefehle: 

Load Register from Memory or Constant 


• anwendbar auf A, B (8 Bit) oder D, S, X, Y (16 Bit) 

3.5 CPU-Befehle 59

• bei 8-Bit-Register: 

LDAA adr. 

LDAB adr. 

• bei 16-Bit-Register: LDD adr 

LDS adr 

LDX adr 

LDY adr 

in (adr) steht das MSB in (adr+1) das LSB 

• Beeinflusst: N, V, Z 

• Flags 

CLR Clear Akkumulator: 0 Akkumulator-Register 

• CLRA 

CLRB 

• schneller als LDAA #0 

Speicherbefehle: 

Store Register into Memory (8 Bit/16 Bit) 

• STAA, STAB (8 Bit): (Reg) adr. 

• STD, STS, STX, STY (16 Bit): (Reg) adr., adr+1 

Clear Memory 

• CLR adr. 

Transport zwischen Registern: 

Kopie des Inhalts eines Registers in ein anderes (transfer) 

• TAB (A) B 

• TAP (A) Statusregister 

• TBA (B) A 

• TPA (Statusregister) A 

• TSX (S) X 

• TSY (S) Y 


Transport-Befehle 60

• TXS (X) S 

• TYS (Y) S 

Bit X im Statusregister kann mittels TAP nicht gesetzt werden. 

Austausch von Registerinhalten (exchange) 

• XGDX D X 

• XGDY D Y 

• Zweck: Adreßrechnung in D, Adressierung dann über X oder Y. 

Beispiel: Tausch A B 

Benötigt wird eine Hilfsvariable im Daten-Speicherbereich 

STAA HILF 

TBA 

LDAB HILF 

Beispiel: Tausch X Y 

* Beispielbelegung X Y D 

* 1 2 3 

XGDX 3 2 1 

XGDY 3 1 2 

XGDX 2 1 3 

Beispiel: Unterprogramm zum Kopieren eines Speicherbereichs (nullterminierte Zeichenkette). Die 

Adresse des Quellstrings steht im X-Register, die Adresse des Zielbereichs im Y-Register: 

strcpy ldaa 0,x ; lade ein Zeichen aus der Quelle 

staa 0,y ; ablegen im Zielbereich 

beq strc_e ; wenn Nullbyte, dann fertig 

inx ; beide Zeiger inkementieren 

iny 

bra strcpy ; und naechstes Zeichen 

strc_e rts 

Soll ein beliebiger Speicherbereich kopiert werden, müsste noch ein Blocklängenzähler 

implementiert werden. 

Arithmetische Befehle 

Dies sind Befehle, die arithmetische Operationen bewirken. Im allgemeinen steht ein Operand in 

einem Akku und das Ergebnis wieder im gleichen Akku. 

Additionsbefehle: 

Addieren (add) 


Arithmetische Befehle 61

• ADDA adr. (A) + (adr.) A 

• ADDB adr. (B) + (adr.) B 

• ADDD adr. (D) + (adr., adr+1) D (16-Bit-Addition) 

• ABA (A) + (B) A 

• ABX (X) + (B) X (Adreßrechnung), B als vorzeichenlose Zahl aufgefaßt 

• ABY (Y) + (B) Y (Adreßrechnung), B als vorzeichenlose Zahl aufgefaßt 

Addieren mit Übertrag (add with carry) 

• ADCA adr. (A) + (adr.) + C A 

• ADCB adr. (B) + (adr.) + C B 

• Anwendung: Mehrbyte-Addition 

Beispiel: Addition zweier 4-Byte-Zahlen 

1. Operand: Adresse $41 - $44 

2. Operand: Adresse $45 - $48 

Ergebnis: Adresse $49 - $4C 

LDAA $44 Niederwertiges Byte addieren 

ADDA $48 

STAA $4C 

LDAA $43 Zweites Byte addieren 

ADCA $47 

STAA $4B 

LDAA $42 Drittes Byte addieren 

ADCA $46 

STAA $4A 

LDAA $41 Höchstwertiges Byte addieren 

ADCA $45 

STAA $49 

Erhöhen (increment) 


• Sonderfall: Addition von 1 

• C-Flag wird nicht beeinflusst (Addition mod 256) 

• Für z. B. Schleifenzähler 

• INCA (A) + 1 A 

• INCB (B) + 1 B 

• INS (S) + 1 S (kein Flag beeinflußt) 

• INX (X) + 1 X (nur Z-Flag beeinflußt) 

• INY (Y) + 1 Y (nur Z-Flag beeinflußt) 


• INC adr. (adr.) + 1 adr. (Increment eines Speicherbytes) 

Subtraktionsbefehle: 

Subtraktion (subtract) = Addition des Zweierkomplements 

• SUBA adr. (A) - (adr.) A 

• SUBB adr. (B) - (adr.) B 

• SUBD: 16-Bit-Subtraktion, Operand in zwei aufeinanderfolgenden Speicherzellen 

Subtraktion mit Übertrag (subtract with carry) 

• SBCA adr. (A) - (adr.) + C A 

• SBCB adr. (B) - (adr.) + C B 

• Anwendung: Mehrbyte-Subtraktion 

Erniedrigen (decrement) 

• Sonderfall: Subtraktion von 1 

• C-Flag wird nicht beeinflusst (Subtraktion mod 256) 

• Für z. B. Schleifenzähler 

• DECA (A) - 1 A 

• DECB (B) - 1 B 

• DES (S) - 1 S (kein Flag beeinflußt) 

• DEX (X) - 1 X (nur Z-Flag beeinflußt) 

• DEY (Y) - 1 Y (nur Z-Flag beeinflußt) 

• DEC adr. (adr.) - 1 adr. (Decrement eines Speicherbytes) 

Vorzeichenwechsel (negate) 

• Sonderfall: 0 - (Akku), Bildung des Zweierkomplements 

• NEGA A komplementieren 

• NEGB B komplementieren 

• NEG adr. adr. komplementieren 

Multiplikation und Division: 

Multiplizieren (multiply) 

• MUL Vorzeichenlose Multiplikation (A) * (B) D 

• Z-Flag = 1, wenn Ergebnis = 0 ist, sonst Z = 0 

• C-Flag = Bit 7 von B 

Dividieren (divide) 

Beispiele: 

• IDIV Vorzeichenlose Division, ganzzahliger Anteil (integer divide) 

für D > X: (D) / (X) X, Rest in D 

• FDIV Vorzeichenlose Division, Quotient echter Bruch (fractional divide) 

für D < X: (D) / (X) X, Rest in D 

IDIV: FDIV: 


$8421 : $0004 = $2108 R $0001 $1000 : $2000 = $.8000 R $0000 


$0001 : $FFFF = $0000 R $0001 $0001 : $FFFF = $.0001 R $0001 

$FFFF : $0001 = $FFFF R $0000 $FFFF : $0001 = unzulässig, V=1 

Weitere arithmetische Befehle: 

DAA Decimal Adjust A 

• Dezimalkorrektur von Akku A für BCD-Arithmetik 

• Jedes Halbbyte (Nibble) entspr. 1 Dezimalziffer 

• Anwendung nach Addition im Akku 

• Korrekturaddition, wenn Pseudotetrade auftritt 

Akku enthält zwei BCD-Ziffern 

• Nach DAA enthält C-Flag den Übertrag in die nächste Stelle 

• NUR (!) nach dem Befehlen ABA, ADDA und ADCA wirksam (nicht beim INC-Befehl) 

• Bei der Subtraktion gilt Zehnerkomplement. -1 wird also nicht als $FF, sondern als $99 

dargestellt (-2 $98, -3 $97, usw.). 

Beispiel: Addition zweier 4-stelligen BCD-Zahlen 

1. Zahl: Adr. $31-$32 

2. Zahl: Adr. $33-$34 

Ergebnis: Adr. $35-$36 

LDAA $32 niederwertige 2 Ziffern 

ADDA $34 binär addieren 

DAA BCD-Justage 

STAA $36 

LDAA $31 höherwertige 2 Ziffern 

ADCA $34 binär addieren mit Carry! 

DAA BCD-Justage 

STAA $35 

Logische Befehle 

Bei logischen Befehlen erfolgt die bitweise logische Verknüpfung eines Akku-Inhalts mit einem 

Operanden (Speicherinhalt oder Konstante). Logische Befehle spielen vor allem beim Zugriff auf 

E/A-Komponenten eine Rolle, weil bei E/A-Operationen häufig einzelne Bits eines Datenworts 

gesetzt, gelöscht oder invertiert werden müssen. 

Und-Verknüpfung (and) 

Beispiele: 


• ANDA adr. (A) and (adr.) A 

• ANDB adr. (B) and (adr.) B 

• Anwendung: Löschen einzelner Bits in einem Wort 


1) Löschen der 4 höherwertigen Bits von Akku A 

ANDA #$0F 

2) Rücksetzen des 5. Bits 

ANDA #%11101111 

3) Rücksetzen des 4. Bits einer Variablen namens FLAG 

LDAA FLAG 

ANDA #%11110111 

STAA FLAG 

Oder-Verknüpfung (or) 

Beispiele: 

• ORAA adr. (A) or (adr.) A 

• ORAB adr. (B) or (adr.) B 

• Anwendung: Setzen einzelner Bits in einem Wort 

1) Setzen der 4 höherwertigen Bits von Akku A 

ORA #$F0 

2) Setzen des 5. Bits 

ORAA #%00010000 

3) Setzen des 4. Bits einer Variablen namens FLAG 

LDAA FLAG 

ORAA #%00001000 

STAA FLAG 

Exklusiv Oder (exor) 

Beispiele: 

• EORA adr. (A) exor (adr.) A 

• EORB adr. (B) exor (adr.) B 

• Anwendung: Invertieren einzelner Bits 

Maskenbit=1: Bit wird invertiert 

Maskenbit=0: Bit unverändert 

1) Invertieren der 4 höherwertigen Bits von Akku A 

EORA #%11110000 

2) Invertieren der Bits 0 und 3 einer Variablen namens FLAG 

LDAA FLAG 

EORA #%00000101 

STAA FLAG 

Bit prüfen (bit test) 


Diese Befehle haben Bedeutung in Zusammenhang mit den weiter unten behandelten 

Sprungbefehlen. Sie erlauben den Test eines Akkumulators auf Null bzw. Vorzeichen, ohne dessen 

Inhalt zu ändern. 

Logische Befehle 65

• BITA adr. (A) and (adr.) Nur Flags neu setzen, A bleibt unverändert 

• BITB adr. (B) and (adr.) Nur Flags neu setzen, B bleibt unverändert 

Invertieren (complement) 

1-Komplement Invertieren aller Bits. 

Auch auf Speicherbytes anwendbar. 

• COMA adr. not (A) A 

• COMB adr. not (B) B 

• COM adr. not (adr.) adr. 

Beispiel: Verwendung des Speicher-Bytes $41 als Software-Flip-Flop. Zu Beginn des Programms 

muß der Inhalt von $41 gelöscht werden! 

COM $41 Inhalt wird $FF 

. 

. 

COM $41 Inhalt wird wieder 0 

. 

. 

usw. 

Schiebe- und Rotationsbefehle 

Die Schiebebefehle bewirken das Verschieben eines Akku- oder Speicherinhalts um eine Stelle 

nach rechts oder links. Bei den Rotationsbefehlen erfolgt die Ringverschiebung eines Akku- oder 

Speicherinhalts unter Einbeziehung des C-Flags nach links oder rechts. Die Befehle sind auf A, B, 

D oder einen Speicherinhalt anwendbar. Die Realisierung auf Speicherinhalt erfolgt durch: Laden in 

Rechenregister, Schiebeoperation im Rechenregister, Zurückspeichern des Register-Inhalts). 

Logische Verschiebung: 

LSRx Logical Shift Right: 

von links wird 0 nachgeschoben: 0 MSB 

LSB C-Flag 


• LSRA Akku A nach rechts schieben 

Logische Befehle 66

• LSRB Akku B nach rechts schieben 

• LSRD Akku D nach rechts schieben 

• LSR adr. Speicherwort adr. nach rechts schieben 

LSLx Logical Shift Left: 

von rechts wird 0 nachgeschoben: 0 LSB 

MSB C-Flag 

• LSLA Akku A nach links schieben 

• LSLB Akku B nach links schieben 

• LSLD Akku D nach links schieben 

• LSL adr. Speicherwort adr. nach links schieben 

Arithmetische Verschiebung: 

ASRx Arithmetic Shift Right: 

Entspricht Division durch 2 

MSB MSB (Vorzeichen bleibt erhalten), LSB C-Flag 

• ASRA Akku A nach rechts schieben 

• ASRB Akku B nach rechts schieben 

• ASR adr. Speicherwort adr. nach rechts schieben 

ASLx Arithmetic Shift Left: 

von rechts wird 0 nachgeschoben: 0 LSB 

MSB C-Flag 

Identisch mit LSL! 

• ASLA Akku A nach links schieben 

• ASLB Akku B nach links schieben 

• ASLD Akku D nach links schieben 

• ASL adr. Speicherwort adr. nach links schieben 

Rotationsbefehle: 

Hin- und Herschieben des Akku- oder Speicherinhalts ohne ihn zu zerstören (anschließend Test des 

C-Flags). Vorzeichenlose duale Multiplikation und Division. 

ROLx Rotate Left 

C-Flag LSB 

MSB C-Flag 

• ROLA Akku A linksrotieren 

• ROLB Akku B linksrotieren 

• ROL adr. Speicherwort adr. linksrotieren 

RORx Rotate Right 

C-Flag MSB 

LSB C-Flag 


• RORA Akku A rechtsrotieren 

• RORB Akku B rechtsrotieren 

• ROR adr. Speicherwort adr. rechtsrotieren 

Schiebe- und Rotationsbefehle 67

Beispiele: 

1) Multiplikation von Akku A mit 10: (A) * 10 A 

ASLA (A)*2 A 

STAA $40 Erg. zwischenspeichern 

ASLA (A)*4 A 

ASLA (A)*8 A 

ADDA $40 (A)*8 + (A)*2 A 

2) Akku D nach links schieben: 

A C B 

ASLB MSB von B --> Carry +----------+__+-+__+----------+ 

ROLA Carry --> LSB von A +----------+ +-+ +----------+ 

3) Zerlegung eines Bytes in zwei Halbbytes: 

Die Halbbytes sind in getrennten Speicherzellen als niederwertiges Halbbyte 

zu speichern (höherwertiges Halbbyte ist auf 0 zu setzen). 

$70: zu zerlegendes Byte 

$71: höherwertiges Nibble 

$72: niederwetiges Nibble 

LDAA $70 Byte holen (binär: xxxxyyyy) 

ANDA #$0F niederwertiges Nibble maskieren 

STAA $72 speichern (binär: 0000yyyy) 

LDAA $70 Byte nochmal holen 

LSRA 4 x nach rechts schieben (0xxxxyyy) 

LSRA (00xxxxyy) 

LSRA (000xxxxy) 

LSRA (0000xxxx) 

STAA $71 höherwertiges Nibble speichern 

Test- und Statusregisterbefehle 

Sie dienen der Überprüfung von Datenwerten auf bestimmte Eigenschaften. Die Überprüfung 

erfolgt durch arithmetische und logische Operationen. Als Ergebnis werden bestimmte Flags des 

CC-Register beeinflusst, der Inhalt der Akkus bleibt unverändert. Die Flags können zur Steuerung 

bestimmter Sprungbefehle verwendet werden Programmfortsetzung abhängig von 

Dateneigenschaften Steuerbefehle. Beispiele bei den Sprungbefehlen. 

Test 

Die Befehle sind anwendbar auf A, B und den Speicher. Test auf Null und negativ. 

• Z-Flag = 1, wenn Akku- oder Speicherinhalt = 0 ist. 

• N-Flag = MSB von Akku- oder Speicherinhalt 

• TSTA Akku A = 0 ? 

• TSTB Akku B = 0 ? 

• TST adr. (adr.) = 0 ? 

Vergleich (compare) 


("Gedachte Subtraktion") 

Die Befehle sind anwendbar auf A, B, D, X und Y. Es wird jeweils ein Registerinhalt mit einem 

Speicherinhalt oder einer Konstanten verglichen (Ausnahme: CBA). Der Vergleich erfolgt durch 

eine Subtraktion ohne Anfallen des Ergebnisses. 

• Z-Flag = 1, wenn beide Operanden gleich sind 

• N-Flag = 1, wenn (Reg) < Operand (konegative Zahl) und kein arith. Überlauf 

• C-Flag = 1, wenn (Reg) < Operand (natürliche Zahl) 

Test- und Statusregisterbefehle 68

• V-Flag = 1, wenn arithm. Überlauf auftrat 

• CMPA #0 und TSTA sind von der Funktion her identisch 

Der Vergleich auf Null und "negativ" ermöglicht alle Vergleiche von Werten. Mathematisch 

gesehen werden die links stehenden Ungleichungen in die rechts stehenden umgesetzt: 

X 1 = X 2 X 1 - X 2 = 0 

X 1 < X 2 X 1 - X 2 < 0 

X 1 > X 2 X 1 - X 2 > 0 

Durch bedingte Sprungbefehle kann dann abhängig vom Ergebnis im Programm verzweigt werden. 

Es gibt 8-Bit- und 16-Bit-Vergleiche (je nach Wortbreite des Registers). 

• CMPA adr. (A) - (adr.) Flags 

• CMPB adr. (B) - (adr.) Flags 

• CPD adr. (D) - (adr., adr.+1) Flags 

• CPX adr. (X) - (adr., adr.+1) Flags 

• CPY adr. (Y) - (adr., adr.+1) Flags 

• CBA (A) - (B) Flags 

Bitorientierte Befehle 

Bitbefehle Statusregister 

Diese Befehle erlauben das komfortable Setzen und Rücksetzen einiger Bits des Statusregisters. 

clear carry flag X X X X X X X 0 

• CLC 

clear interrupt flag X X X 0 X X X X 

• CLI 

clear overflow flag X X X X X X 0 X 

• CLV 

set carry flag X X X X X X X 1 

• SEC 

set interrupt flag X X X 1 X X X X 

• SEI 

set overflow flag X X X X X X 1 X 

• SEV 

Bitbefehle Speicher 

Diese Befehle erlauben das Setzen oder Löschen einzelner Bits in Speicherworten. Als einzige 

Befehle haben sie zwei Operanden, die Adresse des zu ändernden Speicherbytes und eine konstante 

Maske. Da die Maske immer konstant sein muß, entfällt hier auch das "#"-Zeichen. Für jedes 1-Bit 

in der Maske wird das entsprechende Speicherbit gesetzt (BSET) oder gelöscht (BCLR). 

• 

BSET adr. mask 

Nachbildung: 

LDAA #mask 

ORAA adr. 

STAA adr. 


Bitorientierte Befehle 69

• 

BCLR adr. mask 

Nachbildung: 

LDAA #mask 

COMA 

ANDA adr. 

STAA adr. 

Beeinflussung des Systemzustands 

Dies sind Befehle, welche die Programmausführung anhalten. Sie dienen der Synchronisation des 

Programmablaufs mit externen Ereignissen. 

Warte auf Interrupt (wait for interrupt) 

• WAI 

Ablage aller Register auf dem Stack, dann warten auf Interrupt. 

Stop 

• STOP 

Reaktion hängt ab von S-Flag im Statusregister: 

• S=1: next instruction (NOP) 

• S=0: halt clocks, enter standby mode, wait for XIRQ or IRQ 

Freigabe des STOP-Befehls: 

XIRQ & X=1: next instruction 

XIRQ & X=0: service interrupt 

IRQ & I=1: no activity 

IRQ & I=0: service interrupt 

TPA Statusreg. nach Akku A 

ANDA #$7F Freigabe (S-Flag auf 0) 

TAP Akku A nach Statusreg. 

Für den Fall S=0 und X=1 wird beim Aktivieren des XIRQ-Eingangs der Prozessor nach einem 

STOP-Befehl "aufgeweckt" und er macht im Programm ganz normal weiter. 

Sprungbefehle 


Alle Sprungbefehle verändern den PC-Inhalt Programmausführung wird an anderer Stelle 

fortgesetzt. Das Statusregister wird nicht beeinflußt. Einige Befehle speichern Registerinhalte auf 

dem Stack oder holen Registerinhalte von dort wieder zurück. 

Beeinflussung des Systemzustands 70

Unbedingte Sprungbefehle (jump, branch) 

JMP adr. adr. PC 

Bei JMP erfolgt die Zielangabe mit vollständiger absoluter Adressierung (extended direct) oder 

indizierter Adressierung (mit X oder Y). Es ist ein Sprung im gesamten Adressraum möglich, denn 

der Operand ist ein 16-Bit-Wert. 

Der Sprungbefehl hat im Assemblerprogramm normalerweise eine so genannte Marke als Operand. 

Diese Marke steht am Sprungziel, wie Sie da schon eingangs des Kapitels bei der Erklärung der 

beiden Assemblerdurchläufe sehen konnten. Der Assembler entnimmt die Adresse dieser Marke aus 

der Symboltabelle und fügt sie dem JMP-Befehl als Operand hinzu. Der Programmierer kann daher 

immer mit symbolischen Adressen arbeiten. 

BRA dest. 


Hier wird keine absolute Adresse, sondern ein Offset relativ zum Program Counter angegeben (-128 

... +127). Hier berechnet der Assembler die Distanz zwischen BRA-Befehl und Sprungmarke und 

trägt als Offset eine 8-Bit-Zahl in Komplementntdarstellung ein. 

Bedingte Sprungbefehle ("Verzeigungsbefehle") 

Hier gibt es nur PC-relative Adressierung (branch conditionally). Es gibt acht Paare von zueinander 

komplementären Befehlen. Die Unterscheidung erfolgt in der jeweiligen Verzweigungsbedingung. 

Als Verzweigungsbedingung dienen (ein oder mehr) Bits des Statusregisters Verzweigung 

abhängig vom Ergebnis der vorhergehenden Operation ist die Bedingung erfüllt, erfolgt ein 

Sprung; im anderen Fall wird die Programmausführung beim nächsten Befehl fortgesetzt. Der 

Assembler übernimmt die Offset-Berechnung. 

Vergleich von Hochsprache und Assembler-Programmierung: 

Sprungbefehle 71

Die folgende Tabelle fasst alle bedingten Sprünge zusammen. Die erste Gruppe springt abhängig 

vom Wert bestimmter Flags des Condition Code Registers. Weitere Gruppen bilden die 

Sprungbefehle, die von arithmetischen Vergleichen abhängen. 

Achtung: Die Flags werden nicht nur bei arithmetischen Operationen oder Vergleichen 

(Compare-Befehl) gesetzt, sondern bei fast jedem Befehl (z. B. Ladebefehle, logische Operationen). 

Befehl Bedeutung Sprungbedingung 

BCC dest. carry clear C=0 

BCS dest. carry set C=1 

BVC dest. overflow clear V=0 

BVS dest. overflow set V=1 

BNE dest. result not equal 

zero 


einfach (simple) 

Z=0 (BZC) 

BEQ dest. result equal zero Z=1 (BZS) 

BPL dest. result plus N=0 (BNC) 

BMI dest. result minus N=1 (BNS) 

natürlich (unsigned) 

BHI dest. higher Op1 > Op2 

BLS dest. lower or same Op1 = Op2 

konegativ (signed) 

Sprungbefehle 72

BGT dest. greater than Op1 > Op2 

BLE dest. less or equal Op1 = Op2 

bitabhängig 

BRCLR adr. mask dest springe, wenn die in der Maske mit "1" markierten Bits 

alle "0" sind alle Bits des Speicherbytes adr. werden 

mit der Maske UND-verknüpft und wenn das Ergebnis 

0 ist, wird gesprungen. 

BRSET adr. mask dest springe, wenn die in der Maske mit "1" markierten Bits 

alle "1" sind alle Bits des Speicherbytes adr. werden 

mit der Maske UND-verknüpft und wenn das Ergebnis 

gleich der Maske ist, wird gesprungen. 

Der Vergleich bei natürlichen Zahlen und konegativen Zahlen kann zu unterschiedlichen 

Ergebnissen führen. Betrachten Sie dazu die beiden folgenden Befehle: 

LDAA #$F8 

CMPA #$12 

Beim "unsigned"-Vergleich ist $F8 > $12, der Sprungbefehl BHI würde also ausgeführt. Betrachtet 

man die Zahlen jedoch als ganze (konegative) Zahlen, handelt es sich um die Zahl -8 dez. , die 

natürlich kleiner als $12 (18 dez. ) ist. Der Befehl BGT würde daher nicht ausgeführt. 

Betrachten Sie folgende Beispiele für die Anwendung von Sprungbefehlen, die Berechnen der 

Summe über ein Feld von Messwerten: 

FLENG EQU 100 ;Symbolische Konstante Feldlaenge vereinbaren 

FELD RMB FLENG ; Symbolischer Name und Speicherplatz 

; fuer ein Feld von 100 Bytes reservieren 

SUMME RMB 1 ; Symbolischer Name und Speicherplatz 

; fuer 1 Byte reservieren 

; das Indexregister X dient als Pointer! 

LDX #FELD ; symbolische Adresse des Feldanfangs ' X 

LDAB #FLENG ; Zaehler für die Feldlaenge initialisieren 

CLRA ; Summe in Akku A bilden, -> erst loeschen 

LOOP ADDA 0,X ; Feldelemente indiziert adressieren 

DECB ; Zaehler um eins vermindern 

; Feld abgearbeitet (bei 0 angekommen)? 

BEQ FERTIG ; wenn ja (Zaehler = 0): fertig 

INX ; sonst: Indexregister (Zeiger!) erhoehen 

BRA LOOP ; und weitermachen in der Schleife 

FERTIG STAA SUMME ; Ergebnis abspeichern 

In der Sprache C könnte das etwa folgendermaßen aussehen, wobei feld als Array der Größe 

fleng vereinbart ist. 

feldptr = &feld[0]; 

summe = 0; 


Sprungbefehle 73

i = fleng; 

do 

{ 

summe = summe + *feldptr; 

feldptr++; 

i--; 

} while(i>0); 

Unterprogrammsprünge (jump/branch to subroutine) 

Die Unterprogrammtechnik ist ein wertvolles Hilfsmittel zur modularen Programmierung in 

Assembler. Darüber hinaus wird bei Verwendung von Unterprogrammen (UP) Speicherplatz für 

Programme gespart, wenn sie in einem Programm mehrfach verwendet (aufgerufen) werden. 

Gleiche oder sehr ähnliche Befehlssequenzen in einem Programm sollten deshalb immer zu 

Unterprogrammen zusammengefasst werden, wie eine Funktion in C. Ein weiterer Nutzen: Die 

Programme werden dadurch leichter zu lesen. Voraussetzung sind natürlich aussagekräftige Namen 

für die Unterprogramme und eine möglichst gute Kommentierung, auch im Programmkopf. 

Unterprogramme können außerdem geschachtelt, das heißt, von Unterprogrammen aufgerufen 

werden. 

UP können innerhalb der Programme, die diese verwenden, oder außerhalb derselben in 

UP-Bibliotheken definiert sein. Sie sollen möglichst universell programmiert und damit für 

wechselnde Datenwerte geeignet sein. Folglich müssen Eingabe- und Ausgabeparameter übergeben 

werden. Unterprogramme müssen auch an beliebiger Stelle des Hauptprogramms aufgerufen 

werden können (und damit auch an mehreren Stellen), sie sollten daher den Inhalt derjenigen 

Register sichern (z. B. auf dem Stack), die innerhalb des UP verändert werden. Das aufrufende 

Programm muss die Initialisierung des Stackpointers vornehmen, beim Aufruf des UP die 

Eingabeparameter an vereinbarter Stelle bereitstellen und eventuell Platz für Ausgabeparameter 

reservieren. 

Es wird allerdings ein Mechanismus notwendig, der die Rückkehr aus dem Unterprogramm zum 

Befehl nach dem Unterprogramm-Aufruf sicherstellt. Der Einsprung in ein Unterprogramm erfolgt 

deshalb mit einem speziellen Sprungbefehl, der automatisch den aktuellen Befehlszählerstand 

(Rücksprungadresse) auf den Systemstack rettet, bevor er mit der Sprungziel-Adresse überschrieben 

wird. Der Rücksprung nach Beendigung des Unterprogramms zurück ins aufrufende Programm 

besteht dann nur aus einem Zurückschreiben der beiden obersten Stack-Bytes in den Befehlszähler. 

Der "Jump to Subroutine" dient zum Sprung zu einem Unterprogramm (Function, Procedure in 

höheren Programmiersprachen). Der Unterschied zum "normalen" Sprung besteht darin, dass am 

Ende des Unterprogramms mit einem "Return from Subroutine" (RTS) an die Stelle des "Aufrufs" 

(Absprungs) zurückgekehrt werden muss. 

JSR adr. 


• absolute Adressierung 

• wie JMP adr., aber zusätzlich Ablage des PC (der die Adresse des nächsten Befehls 

enthält) auf dem Stack Möglichkeit der Rückkehr 

Beim JSR wird also vor dem Überschreiben des PC der aktuelle PC-Stand auf den Stack gerettet, 

Unterprogrammsprünge (jump/branch to subroutine) 74

d.h. der Stack wächst dabei um 2 Bytes! So kann der RTS-Befehl auf dem Stack den ursprünglichen 

PC-Stand wiederfinden (Rücksprung aus dem Unterprogramm zurück in das aufrufende 

Programm). 

BSR dest. 

• Offset wird immer PC-relativ angegeben (-128 ... +127) 

• Assembler übernimmt Offset-Berechnung 

RTS (return from subroutine) 

Der RTS-Befehl dient dazu, aus einem Unterprogramm in das "aufrufende" Programm 

zurückzukehren. Notwendige Voraussetzung ist, dass vom aufrufenden Programm per JSR- oder 

BSRBefehl in das Unterprogramm gesprungen wurde, denn nur diese Befehle retten vor dem 

Sprung den Inhalt des PC auf den Stack. 

• Rücksprung aus Unterprogramm 

• Die Rücksprungadresse wird vom Stack geholt 

• letzter Befehl eines Unterprogramms 

• PULX 

JMP 0,X 

Unterprogramme lassen sich beliebig schachteln. 

Typische Anfängerfehler: 


• Ein mit RTS logisch abgeschlossenes Unterprogramm wird mit JMP, BRA oder bedingtem 

Branch angesprungen! (Was geschieht?). 

• Ein mit JSR oder BSR angesprungenes Unterprogramm wird mit einem JMP, BRA oder 

bedingten Branch verlassen! (Was geschieht?) 

Unterprogrammsprünge (jump/branch to subroutine) 75

Programmunterbrechungsbefehle 

SWI (software interrupt) 

• Sprung in eine Interrupt-Service-Routine (ISR) 

• Startadresse ist Interruptvektor (steht in HW-mäßig festgelegter Speicherzelle) 

• vorher Ablage aller Register auf dem Stack 

• Anwendung: 

z. B. positionsunabhängiger Aufruf von BS-Routinen; Parameter in Registern oder auf dem 

U-Stack 

RTI (return from interrupt) 

• Rücksprung aus einer ISR 

• Rückladen der Register vom Stack 

• letzter Befehl der ISR 

Reine Verzögerungsbefehle 

• NOP No Operation 

• BRN Branch Never 

Anwendungen: 

• Zeitverzögerung (z. B. Laufzeitangleichung) 

• Platzhalter für spätere Programmverzeigungen (bei der Programmentwicklung) 

• Platz für Label 

• "Patchen" von Programmen (Ändern des Maschinencodes) 

3.6 Stapelspeicher (Stack) 


Zum Zwischenspeichern von Information ist ein Register(-satz) prinzipiell sehr gut geeignet. Das 

Problem ist nur seine sehr begrenzte Kapazität. Legt man temporäre Zwischenspeicher im 

Arbeitsspeicher an, so muss man Geschwindigkeitseinbußen in Kauf nehmen aber vor allem ist die 

Verwaltung derartiger "Hilfszellen" umständlich und zeitraubend. Eine Lösung dieses Problems 

bietet ein Stapelspeicher (Stack). Dies ist ein wortorganisierter Speicher mit implizitem Zugriff 

LIFO-Speicher (Last In First Out). Die Realisierung beim 68HC11 erfolgt als externer Stack 

(Software-Stack). Er ist Teil des Arbeitsspeichers, Die automatische Adressierung erfolgt über den 

Stapelzeiger (Stackpointer, S). Der Stackpointer ist ein 16-Bit-Register und zeigt immer auf die 

nächste freie Zelle. Der Stack wächst zu kleiner werdenden Adressen ("nach unten"). 

Am Programmanfang muß der Stack mit einem sinnvollen Wert besetzt werden. 

Die Vorteile des SW-Stacks mit Stackpointer-Adressierung sind unter anderem: 

• Kapazität des Stacks ist der jeweiligen Anwendung anpaßbar 

• keine Vereinbarung von Hilfszellen erforderlich 

Programmunterbrechungsbefehle 76

• keine Adreßangabe bei Verwendung des Stacks nötig 

Befehle für den Stack-Zugriff 

• Stack dient zum schnellen Ablegen von Registerinhalten 

• Befehle zum Schreiben in den Stack: PSHx ("Push") 

• Befehle zum Lesen aus dem Stack: PULx ("Pull") 

• Beim PSH-Befehl wird der SP nach dem Ablegen eines Register-Inhalts decrementiert 

• Beim PUL-Befehl wird der SP vor dem Holen eines Register-Inhalts incrementiert 

• Bei 16-Bit-Registern wird das LSB zuerst abgelegt (höhere Adr.),dann das MSB (niedrigere 

Adr.) MSB wird beim PUL zuerst geladen 

Schreiben in den Stack: 

♦ PSHA Register A Stack 

♦ PSHB Register B Stack 

♦ PSHX Register X Stack 

♦ PSHY Register Y Stack 

Lesen aus dem Stack: 

♦ PULA Stack Register A 

♦ PULB Stack Register B 

♦ PULX Stack Register X 

♦ PULY Stack Register Y 

Man kann normalerweise nur immer das "oberste" Stackelement lesen. Die Stack-"Verwaltung" 

muss sehr sorgfältig geschehen, damit jederzeit klar ist, welche Information gerade "oben" liegt 

oder - besser ausgedrückt - wo der Stackpointer gerade hinzeigt. Unsauberer Umgang mit dem 

Stack führt fast unweigerlich zu unverständlichen Programmabstürzen! 

Anwendung des Stack 


Der Stack dient dem Zwischenspeichern von Registerinhalten um: 

• Register anderweit verwenden zu können 

• Parameterübergabe bei Unterprogrammen (siehe später) 

• "Retten" von Registerinhalten beim Unterprogrammaufruf: Zu Beginn des UP werden die 

verwendeten Register auf dem Stack abgelegt und vor Rückkehr zum Hautprogramm 

wieder restauriert 

• Speicherung der Rücksprungadresse bei Unterprogrammsprüngen: Die Abspeicherung 

erfolgt automatisch auf dem Stack bei JSR und BSR. Bei RTS wird die Rücksprungadresse 

automatisch vom Stack geladen. 

• Ablage des Programmstatus bei Interrupts durch CPU auf dem Stack. Automatisches Laden 

des Programmstatus bei RTI. 

3.6 Stapelspeicher (Stack) 77

Wichtig ist der sorgfältige und überlegte Umgang mit Stack- und SP-Operationen. Damit kein 

Stack-Überlauf(-Unterlauf) auftritt: 

• gleichviele PSH- und PUL-Befehle 

• PSH- und PUL-Befehle "symmetrisch", z. B.: 

• 

PSHA 

PSHB 

. 

. 

. 

PULB 

PULA 

eventuell Dekrementieren oder Incrementieren des SP nötig 

3.7 Unterprogramme (Subroutines) 

Unterprogramme sind Programmteile (=Befehlsfolgen), die mit einem Namen versehen sind und 

unter diesem Namen aufgerufen werden. UP können in den Programmen, die diese verwenden, oder 

außerhalb derselben definiert sein UP-Bibliotheken. Sie sollen möglichst universell 

programmiert (und damit für wechselnde Datenwerte) sein Parameter müssen übergeben werden 

(Eingabe- und Ausgabeparameter). UP müssen an beliebiger Stelle des Hauptprogramms 

aufgerufen werden können (und damit auch an mehreren Stellen), sie sollten daher den Inhalt 

derjenigen Register sichern (z. B. auf dem Stack), die innerhalb des UP verändert werden. Typische 

Anwendungen der UP-Technik sind: 

• Verwendung gleicher Programmteile an mehreren Programmstellen 

• Rückgriff auf Programmbibliotheken 

• Übersichtlicher Aufbau von Programmen (modular + strukturiert) Programmerstellung 

durch mehrere Programmierer möglich 

Programme mit UP dauern etwas länger als ohne (meist überwiegen jedoch die Vorteile der UP). 

Anmerkungen zur Dokumentation: 

• Dokumentation ist wichtig für problemlose und fehlerfreie Verwendung von UP (besonders 

von fremden UP) 

• Die innere Struktur der UP muß für deren Anwendung nicht unbedingt bekannt sein 

• Folgende Informationen sind notwendig: 

♦ Zweck (Beschreibung der Aufgabe) des UP 

♦ Beschreibung der Ein- und Ausgabeparameter 

♦ Angabe der veränderten Register und Speicherplätze 

♦ Anwendungs-(Aufruf-) Beispiel 

• Dokumentation soll bereits im Programmlisting durch entsprechende Kommentare 

vorgenommen werden 

Aufgaben des aufrufenden Programms: 


• Initialisierung des/der Stackpointer (Hauptprogramm) 

• Bereitstellen der Eingabeparameter an vereinbarter Stelle 

• eventuell Platzreservierung für Ausgabeparameter 

• Aufruf des UP 

• falls erforderlich, Wegspeichern der Ausgabeparameter 

Anwendung des Stack 78

Unterprogramm-Sprungbefehle 

sind spezielle Sprungbefehle, die vor dem Sprung die Rücksprungadresse auf dem Stack sichern. 

Beim Rücksprung wird diese Adresse automatisch geladen. 

Sprung in das UP: JSR, BSR 

Unterscheidung in der Adressierungsart. Wirkung: 

• Speichern des PC auf dem Stack (da der Sprungbefehl bereits geholt und dekodiert wurde, 

zeigt der PC auf den nächsten Befehl (= Rücksprungadresse)). Zuerst Speicherung des 

PC-LSB, dann PC-MSB. 

• Laden des PC mit der Startadresse des UP 

Rücksprung aus dem UP: RTS 

Letzter Befehl des UP, Wirkung: 

• Laden der Rücksprungadresse vom Stack in den PC 

Achtung: Vor dem Rücksprung muß der Stackpointer i. a. auf die gleiche Adresse zeigen, wie nach 

dem Ansprung des UP Sorgfalt bei Stackoperationen notwendig! Beim UP-Sprung (und 

Rücksprung) wird nur der PC-Inhalt geändert, der Inhalt aller anderen Register bleibt erhalten. 

Register können zur Parameterübergabe verwendet werden 

Im UP verwendete Register müssen gegebenenfalls gesichert werden 

Vorteil der Speicherung der Rücksprungadresse auf dem Stack: 

• Aufruf weiterer UP durch ein UP möglich verschachtelte UP 

• Rückkehradresse immer am Stack-Ende 

• Schachtelungstiefe nur durch Stackgröße begrenzt 

Parameter-Übergabe 

Eingabeparameter: Werte UP 

Ausgabeparameter: Werte UP 

Möglichkeiten der Parameterübergabe: 

• Direkte Übergabe in Registern Elegante Methode, jedoch durch Registerzahl begrenzt 

• Über festen Speicherbereich inflexibel (manchmal bei BS-Aufrufen) 

• Über variablen Speicherbereich (Parameterblock) Anfangsadresse des Parameterblocks 

wird in einem Register übergeben indirekte Parameterübergabe 

• Über den Stack Ablage im aufrufenden Programm mittels PSHx. Da die Parameter vor dem 

UP-Sprung abgelegt wurden (und somit der PC-Stand der letzte Wert auf dem Stack ist), 

sind sie mit PULx nicht ohne weiteres erreichbar (außer Rücksprungadresse wird 

zwischengespeichert). Der Zugriff ist daher komplizierter. Vom HP kann vor UP-Aufruf 

Stackplatz für Ausgabeparameter freigehalten werden (Nach Rückkehr Bereinigung des 

Stack nötig). 

Beispiel: Verzögerungsroutine 


Es soll eine Verzögerung von 1 ms erreicht werden. Das Prinzip der Routine ist recht einfach: Ein 

Akkumulator wird mit einem Anfangswert besetzt und dann in einer Schleife solange 

Unterprogramm-Sprungbefehle 79

dekrementiert, bis sein Wert Null geworden ist. 

ORG PROG Programm soll bei Adresse PROG beginnen 

MAIN BSR VERZ Aufruf Unterprogramm 

STOP BRA STOP Endlosschleife, stoppt Programm 

("Wiederbeleben" des Computers mit Reset) 

* Verzögerungs-Unterprogramm 

* Verzögerungszeit: 1 ms 

* Keine Parameter 

* 

VERZ LDAA #221 Anfangswert (Konstante) laden (siehe unten) 

VZ NOP No Operation (Zeitverzoegerung) 

NOP No Operation (Zeitverzoegerung) 

DECA A runterzählen bis 0 

BNE VZ solange A != 0, weiterer Durchlauf 

RTS Verzögerung erreicht (A = 0) 

END 

Berechnung der Verzögerungszeit: Aus der Befehlstabelle kann man die Anzahl der Taktzyklen für 

jeden Befehl entnehmen. Wenn man nun noch die Taktfrequenz weiß, kann man die Ablaufzeit 

eines Programms ausrechnen. Wir müssen vier Zeiten wissen: 

tl Ausführungszeit LDAA 2 Taktzyklen 

td -"- DECA + 2 NOP 6 -"- 

tb -"- BNE 3 -"- 

tr -"- RTS 5 -"- 

Bei unserem Praktikumsrecher dauert ein Taktzyklus 0,5 Mikrosekunden. Die Gesamtzeit tg ergibt 

sich zu: 

tg = 0,5 * n * (td + tb) + tl + tr 

= 0,5 * n * (6 + 3 ) + 2 + 5 

= 0,5 * (n * 9 + 7) 

Da tg = 1 ms = 1000 Mikrosekunden sein soll, berechnet sich n zu 

n = (1000 - 3,5) / 4,5 

= 996,5 / 4,5 

= 221,44 

n = 221 

Es ergibt sich also ein kleiner Fehler; unsere Schleife ist einen knappen Taktzyklus zu langsam. 

Will man wirklich genaue Zeitintervalle, greift man auf den integrierten Timer zurück (siehe 

später). 

Im gezeigten Beispiel "Verzögerungsroutine" ist die maximale Verzögerungszeit durch die 

Wortbreite des Akku A (8 Bit 0..255) auf etwas mehr als 1 ms begrenzt. 

Für größere Verzögerungen: 


• Verlängerung von ts durch zusätzliche Befehle (NOP, BRN) 

• Verwendung eines 16-Bit-Registers (z. B. D, X, Y) 

• Schachtelung von Schleifen 

• Durch Parameter erhält man UP mit variabler Verzögerungszeit 

Beispiel: Gegeben ist folgende Verzögerungsroutine mit 16-Bit-Register: 

Parameter-Übergabe 80

* Verzögerungs-Unterprogramm 

* Verzögerungszeit: 500 ms 

* Keine Parameter 

* 

; delay dauert 3 + 5 + 4 + 5 + $f000*16 cycl 

; = 8,5 + $f000*8 us = 491528,5 us 

delay pshx ; X retten, 4 cycl 

ldx #$f000 ; Anfangswert laden, 3 cycl 

delay1 nop ; Zeit verschwenden, 5 x nop = 10 cycl 

nop 

nop 

nop 

nop 

dex ; X run 

bne delay1 ; solange X != 0 weiter, 3 cycl 

pulx ; X restor, 5 c 

rts ; und w 

3.8 Interrupts (Programmunterbrechungen) 

HAlle modernen Mikroprozessoren besitzen deshalb mehr oder weniger ausgefeilte 

Hardware-Mechanismen zur Programmunterbrechung durch solche Ereignisse. Ein 

Hardware-Ereignis erzwingt einen "Unterprogrammsprung" zu einem vorbereiteten 

Bearbeitungs-Programm, der so genannten Interrupt-Service-Routine (ISR). Die Ähn-lichkeit des 

Interrupt mit einem Unterprogrammsprung (JSR) ist tatsächlich groß. Das Auftreten des 

Interrupt-Request-Signals auf dem Bus wird vom Mikroprogramm am Ende jedes Befehlszyklus 

geprüft und führt zu einem Sprung zum Beginn der ISR. Ein JSR zu einem bestimmten 

Unterprogramm kann an beliebigen Stellen im Programm vorkommen, der Rücksprung RTS sorgt 

für die Rückkehr an die richtige Stelle im aufrufenden Programm. Ein Interrupt dagegen kann 

prinzipiell nach jedem beliebigen Befehl des Programms wirksam werden, dementsprechend muss, 

wie beim JSR, der PC-Stand gerettet werden; auch das erledigt die Ablaufsteuerung bei der 

Annahme des Interrupt Request, genau wie beim JSR. Die Interrupt-Service-Routine wird mit 

einem ähnlichen Befehl wie ein Unterprogramm verlassen (RTI statt RTS), denn auch hier muss der 

Rücksprung wieder zur Unterbrechungsstelle zurückführen. Man unterscheidet beim 68HC11 

Interrupts, die von Hardwaresignalen ausgelöst werden (XIRQ, IRQ und RESET) und den internen 

Interruptquellen (interne Peripherie-bausteine bzw. "illegal Operation"). Außerdem gibt es einem 

Befehl (SWI), der ebenfalls einen Interrupt auslöst. Ein weiteres Unterscheidungskriterium ist die 

Maskierbarkeit. Der "normale" Interrupt ist nur dann wirksam, wenn das entsprechende Maskenbit 

im CC-Register gelöscht ist (gleich 0). Die Signale RESET und XIRQ sind nicht maskierbar, sie 

werden deshalb auch als "nicht maskierbare Interrupts" (NMI) bezeichnet. Der XIRQ weist dabei 

noch eine Besonderheit auf: er ist nach einem RESET so lange gesperrt (maskiert), bis er durch 

Nullsetzen von Bit 6 im CC-Register freigegeben wird. Danach ist er nicht mehr sperrbar! 

Anwendungen: 


• Quasiparallele Ausführung mehrerer Programme (normalerweise nur Hauptprogramm und 

ISR) - Parallelarbeit von Programmen und externen Geräten (interruptgesteuerter 

3.8 Interrupts (Programmunterbrechungen) 81

E/A-Transfer) 

• Reaktion auf unvorhersehbare Ereignisse (z. B. Spannungsabfall) 

• Testen von Programmen mittels Breakpoints (SW-Interrupt) 

• Aufruf von Betriebssystemfunktionen (SW-Interrupt) 

Aufgaben der CPU bei einen Interrupt: 

1. Abspeichern von Registerinhalten (bei 68HC11 im Stack) 

2. Setzen der Interruptmaske zum Sperren weiterer Interrupts 

(Unter Berücksichtigung der Priorität) 

3. Laden der Startadresse (= Interrupt-Vektor) der ISR in den PC 

♦ Der Interruptvektor steht an einer hardwaremäßig vorgegebenen Adresse, die von 

der Art des Interrupts abhängt. 

♦ Je nach Interrupt-Art wird die entsprechende Interrupt-Vektor-Adresse auf den Bus 

gegeben. 

♦ In den so adressierten Speicherzellen steht dann die Startadresse der ISR (= 

Interrupt-Vektor), die in den PC gebracht wird Start der ISR 

4. Fortsetzung des unterbrochenen Programms nach der Interrupt-Bearbeitung: RTI-Befehl 

♦ weggespeicherte Register werden vom Stack geholt 

♦ PC erhält Adresse des nächsten Befehls des unterbrochenen Programms 

Im allgemeinen wird ein Hardware-IRQ erst am Ende eine Befehlszyklus bedient. Außer dem PC 

und dem Stackpointer werden keine Register beeinflußt. Interrupts können geschachtelt werden (3 

Ebenen). 

Interruptsystem des 68HC11: 

Signal RESET Unbedinger Abbruch und Neustart 

Signal XIRQ & (X-Bit = 0) Unbedingte Unterbrechung (non maskable interrupt) 

Signal IRQ & (I-Bit = 0) 


Bedingte Unterbrechung (interrupt request) 

(kann auch interne Ursachen haben) 

I-Bit beeinflußbar durch die Befehle SEI/CLI 

Befehl SWI Befehlsgesteuerte Unterbrechung (software interrupt) 

Befehl Illegal Opcode Nicht implementierter Befehl 

Beim Auftreten eines Interrupts wird das I-Bit auf 1 gesetzt (Sperren IRQ), bei Reset und XIRQ 

auch das X-Bit. Beim RTI wird durch das Zurückschreiben des Statusregisters diese Sperre 

automatisch wieder aufgehoben. Das X-Bit kann nicht per Programm beeinflußt werden. 

Jedem dieser Interrupts ist eine eindeutige Interrupt-Vektor-Adresse (= Adresse, unter welcher der 

Interrupt-Vektor, also die Adresse der Interrupt-Serviceroutine, zu finden ist) zugeordnet: 

Interruptsystem des 68HC11: 82


Zu jeder Interrupt-Art ist eine eigene ISR möglich. Zumindest der RESET-Vektor muß bei 

Einschalten vorhanden sein ROM im höchsten Adreßbereich nötig. 

Beispiel: Starten der Interrupt-Service-Routine für XIRQ 

Grundsätzlich gilt für Programme mit Interrupt-Serviceroutinen, daß vier Schritte für die 

Initialisierung (zu Beginn des Hauptprogramms) nötig sind: 

1. Setzen des System-Stackpointers 

Solange er nicht gesetzt ist, werden keine Interrupts entgegengenommen. 

2. Initialisierung der Hardware 

In der Regel werden Interrupts von E/A-Bausteinen ausgelöst. Diese müssen entsprechend 

programmiert werden. 

3. Setzen des Interruptvektors 

Siehe oben. 

4. Freigeben des Interrupts durch Setzen des entsprechenden I-Flags im CC-Register auf 0. 

Bei einer ISR für XIRQ entfällt dieser Punkt natürlich. 




Letzte Aktualisierung: 02. Jul 2012 





4. Bausteine des Systems M68HC11 

4.1 Mikroprozessor 68HC11 

Der Prozessor 

• ist zuständig für die sequentielle Instruktionsausführung (Instruktion entspricht einer 

Zustandsänderug im Speicher oder in einem Register). 

• Ausführung synchron durch internen Taktgenerator (dieser wird beim 68HC11 durch einen 

externen Quarz-Oszillator gesteuert). 

• Systemtakt des 68HC11: 2 MHz 

(entsprach zur Entwicklungszeit der maximalen Taktfrequenz eines externen EPROMs) 

• Systemtakt wird für externe Zwecke (an Pin E) zur Verfügung gestellt. 

• eine Instruktion benötigt beim 68HC11 mindestens 2 Takte = 1 Mikrosekunde 

• längste Operation: Division (FDIV) mindestens 41 Takte = 20,5 Mikrosekunden 

Beim 68HC11 gibt es diverse Varianten, die sich hauptsächlich im integrierten Speicher 

unterscheiden. Zusammenfassend ergeben sich folgende Eigenschaften: 

• CPU mit 8 Bit Daten und 16 Bit Adressen 

• 256 Byte RAM 

• 2 - 8 KByte ROM 

• 515 - 2048 Byte EEPROM 

• Asynchrone serielle Kommunikationsschnittstelle 

• Echtzeit-Interrupts 

• 38 digitale Ein- und Ausgänge, teils mit Handshake-Funktion 

• 2 Hardware-Interrupts 

• Impulszähler 

• 16-Bit-Timer-System mit 3 Zeitmeß-Eingängen und 4 PWM-Ausgängen 

• Analog-Digital-Wandler mit 8 gemultiplexten Eingängen 

• Synchrone serielle Schnittstelle 

Der Prozessor arbeitet mit einer Taktfrequenz von 2 MHz, die von einem 8-MHz-Quarz abgeleitet 

wird. Die Betriebsspannung beträgt 5 V, die Stromaufnahme etwa 15 mA, wobei jedoch bei 

Batteriebetrieb der Mikrocontroller in Arbeitspausen durch Software-Befehle in einen 

Stromsparzustand geschaltet werden kann. 

4. Bausteine des Systems M68HC11 85

Die wichtigsten Anschlußpins 

Name Anzahl Art Bedeutung 

Vss 

(GND) 

1 E Versorgungsspannung 0V 

VDD 1 E Versorgungsspannung 5V 

EXTAL 1 E Quarz (oder externer, CMOS-kompatiblerTaktgenerator) 

XTAL 1 A Quarz 

E 1 A Bus-Takt L: interne Aktivität H: externe Aktivität (Datenverkehr) 

RESET 1 E Rücksetzen des M68HC11 X-Bit und I-Bit = 1, (FFFE,FFFF) 

Befehlszähler 

MODA 1 E L: single chip mode (nur interne Komponenten) H: expanded mode 

(externe Komponenten möglich) 

MODB 1 E L: special variation (down load or test) H: normal variation (applications) 

XIRQ 1 E unbedingte Unterbrechung (non maskable interrupt) maskiert durch X-Bit 

im CCR 

IRQ 1 E bedingte Unterbrechung (interrupt request) maskiert durch I-Bit im CCR 

PA i 

3 

4 

1 

E 

A 

E/A 


Port A: 3 Digitaleingänge, 4 Digitalausgänge, 1 Digitalein/ausgang oder 

Pulsakku-Eingang (unterbrechungsfähig) 

PB A15-8 8 A Port B: 8 Digitalausgänge oder 8 Adressleitungen 

PCAD7-0 8 E/A Port C: 8 Digitalein/ausgänge oder 8 Adress/Datenleitungen (gemultiplext) 

STRA AS 1 E/A Steuerleitung (Eingang, unterbrechungsfähig) oder 

Adress/Datenleitungs-Steuerung 

1 A Steuerleitung (Ausgang) oder Datenrichtung (read/write) 

Der Prozessor 86

STRB 

R/W 

PD 6 E/A Port D: 6 Digitalein/ausgänge oder 1 SCI und 1 SPI 

PE 8 E Port E: 8 Digitaleingänge oder 8 Analogeingänge für A/D-Wandler 

Vrefh 1 E Referenz-Spannung für A/D-Wandler 

Vrefl 1 E Referenz-Spannung für A/D-Wandler 

Reset 


Der Reset-Eingang wird dazu benutzt, den Mikroprozessor in einen definierten Anfangszustand zu 

bringen. Da für einige der intern ablaufenden Vorgänge zwingend ein Oszillatortakt benötigt wird, 

sollte ein Reset-Signal erst nach Stabilisierung des Oszillator-Kreises gegeben werden. Sobald der 

Prozessor die Reset-Bedingung gültig erkennt, werden alle internen Schaltungsgruppen in einen 

definierten Anfangszustand versetzt: 

• Nach dem Reset-Signal lädt die CPU den Reset-Vektor aus dem der gewählten Betriebsart 

entsprechenden Adressbereich in den Programcounter. Dies ist ($FFFE, $FFFF) im 

Normalbetrieb oder ($BFFE, $BFFF) in den Betriebsarten "Special Test" und "Bootstrap". 

Der Stackpointer und die anderen Register der CPU sind nach dem Reset weiterhin 

undefiniert, nur das X- und das I-Bit im CCR-Register werden gesetzt, um undefinierte 

Interrupts zu verhindern. 

• Das INIT-Register wird beim Reset auf $01 gesetzt. Damit liegt das interne Prozessor-RAM 

im Adressbereich $0000 bis $OOFF, die Control-Register liegen auf den Adressen $1000 bis 

$103F. Der Prozessor-Reset hat keinen Einfluß auf das Mapping der ROM- und 

EEPROM-Bereiche, da die beiden Bits, die die Zugriffe auf diese Bereiche kontrollieren, 

EEPROM-Zellen des Config-Registers sind. 

• Durch das Reset-Signal wird das prozessorinterne Timer-System auf $0000 gesetzt, alle 

Prescaler-Bits werden gelöscht und sämtliche Output-Compare-Register erhalten den Wert 

$FFFF. Der Inhalt der Input-Capture-Register ist undefiniert. Damit keine undefinierten 

Signale an den E/A-Pins des Prozessors durch das Timer-Systern ausgegeben werden können, 

werden alle Output-Compare-Systeme so initialisiert, daß sie keinen Einfluß auf die logischen 

Zustände der zugeordneten E/A-Pins haben. Die Flankenerkennung der drei 

Input-Capture-Register wird durch das Reset-Signal ausgeschaltet, alle dem Timer-System 

zugeordnete Interrupt-Flags werden gelöscht und alle neun Timer-Interrupt-Quellen werden 

gesperrt. 

• Die Behandlung der E/A-Ports bei einem Reset-Signal ist von der eingestellten Betriebsart 

abhängig; in der Betriebsart "Extended" sind die 18 E/A-Pins des 68HC11 den verschiedenen 

Bussystemen zugeordnet. In der Betriebsart "Single-Chip", werden alle Interrupt-Quellen, die 

mit den E/A-Ports in Verbindung stehen, gelöscht. Dazu gehören die Bits STAF, STAI und 

HNDS im PIOC-Register. Die Betriebsart der E/A-Ports wird durch das gelöschte HNDS-Bit 

auf "Simple Strobed E/A" festgelegt. 

Port C ist nach dem Reset als Eingang definiert, sein Datenrichtungsregister demnach mit $00 

besetzt. Port B ist als Ausgang mit auf Null gesetzten Ausgangssignalen initialisiert. Der 

flankenempfindliche Eingang STRA reagiert auf die ansteigende Flanke eines Signals. 

• Nach einem Reset-Signal ist die Baud-Rate des seriellen Interfaces in jedem Fall undefiniert 

und muß durch das Anwenderprogramm festgelegt werden. Sämtliche Interrupt-Quellen der 

seriellen Schnittstelle sind deaktiviert und die Zuordnung der Empfangs- und Sendeleitungen 

zu den entsprechenden E/A-Pins ist aufgehoben, so daß diese Pins als normale E/A-Pins zur 

Verfügung stehen. Das Übertragungsformat der seriellen Schnittstelle ist auf 8 Bit eingestellt. 

Im Statusregister des seriellen Systems werden die TDRE- und TC-Bits gesetzt. 

• Das Puls-Akkumulator-System des 68HC11 ist nach einem Reset ausgeschaltet, der Eingang 

(PAI) ist als normaler E/A-Pin geschaltet. 

Die wichtigsten Anschlußpins 87

• Die interne Prozessorüberwachung (COP) verhält sich entsprechend dem NOCOP-Bit im 

Config-Register(NOCOP-Bit = 1: Überwachung aus, NOCOP-Bit = 0: Überwachung ein). In 

diesem Fall wird das Time-Out-Intervall des COP-Systems auf die kleinste verfügbare Zeit 

gesetzt. 

• Das serielle Peripherie-Interface (SPI) wird durch ein Reset-Signal ausgeschaltet. Die 

zugehörigen E/A-Leitungen stehen als normale E/A-Pins zur Verfügung. 

• Die Definition des A/D-Wandler-Systems ist undefiniert. Nur das ADPU-Bit wird gelöscht, so 

daß das A/D-System deaktiviert bleibt. 

• Sämtliche EEPROM-Steuerbits, die zur Programmierung benötigt werden, sind nach einem 

Reset gelöscht, so daß aus dem EEPROM nur gelesen werden kann. 

• Der externe Interrupt bekommt die höchste Interrupt-Priorität zugewiesen, das 

Interrupt-Signal wird auf pegelabhängig geschaltet, so daß ein Standard-Interruptsystem mit 

mehreren Quellen möglich ist. 

Als Reset-Quelle steht beim 68HC11 nicht nur der externe Reset-Eingang zur Verfügung. Es gibt drei 

weitere interne Reset-Quellen: Power-On-Reset (POR), Watchdog-Timer (COP), Taktüberwachung 

(CMR). Jeder dieser Reset-Quellen ist ein eigener Reset-Vektor zugeordnet, der auf das zugehörige 

Interrupt-Programm zeigt. 

Der Bus 

• Verbindung zwischen den Komponenten (speziell: Verbindung der CPU mit dem Speicher) 

Adreßbusbreite beim 68HC11: 16Bit = 216 • 

= 65536 verschiedenen Speicherplätze mit je 8-bit 

Datenwort (64 KByte) 

• Bus im Multiplexbetrieb = Daten und Adressen über gleiche Leitungen (Kontrolle über 

Steuerleitungen) 

• Steuerleitungen geben den Bus-Zustand an (Daten/Adressen, schreiben/lesen) 

• Zugriff auf E/A-Ports: speicherabbgebildet 

Der Speicher 


Der Speicher nimmt Instruktionen und Daten auf (wie beim klassischen von-Neuman Rechner). 

Speicherarten: 

• RAM: schreiben und lesen, sehr schnell, Speicherinhalt flüchtig (evtl. mit Batterie puffern) 

• ROM: nicht flüchtig, Inhalt nicht änderbar 

• PROM: 1x änderbar, nicht flüchtig 

• EPROM: löschen durch UV-Licht 

• EEPROM: lesen und schreiben, langsam (ms, bei RAM ns), begrenzte Lebensdauer 

Als Speicher hat der MC68HC811 ein ROM, ein EEPROM und ein RAM an Board. Programme 

können in jeden dieser Speicherbereiche geladen und in jedem Bereich ausgeführt werden. Das ROM 

kann allerdings nur während des Herstellungsprozesses programmiert werden, so daß diese Variante 

erst bei Abnahme von mehreren tausend Stück interessant wird. Ein Teil des ROM ist jedoch stets 

vorhanden, da es das Bootloader-Programm enthält. Bei kleinen Stückzahlen oder Einzelstücken ist 

das EEPROM der bevorzugte Programmspeicher. Da Programme im RAM nicht dauerhaft gespeichert 

werden, dient dieses zur temporären Speicherung von Rücksprungadressen im Stack-Bereich oder von 

Zwischenergebnissen des Programmlaufs. Die folgende Liste zeigt eine Zusammenfassung der 

Prozessorvarianten: 

Reset 88

Innerhalb der Familie gibt es nur geringe Unterschiede in Speicher (Art, Menge) und Ports (Anzahl, 

Art). Bei allen Varianten ist der Befehlssatz gleich gleiche (Assenbler-)Programme. 

Belegung des Adressraums bei verschiedenen Prozessortypen 

Asynchrone serielle Schnittstelle 

Über die asynchrone serielle Schnittstelle (SCI) wird das Programm vom PC in den Mikrocontroller 

geladen. Sie dient unter anderem auch dazu, beim Testen des Programms Statuswerte oder 

Zwischenergebnisse am Bildschirm darzustellen. Die Anschlüsse der seriellen Schnittstelle sind PD0 

= RxD (Dateneingang) und PD1 = TxD (Datenausgang). 

Timer-System 


Das Timer-System steuert solche Funktionen, die einen Bezug zur Realzeit benötigen, also 

unabhängig von Befehlsausführungszeiten sein sollen. Intern werden alle Funktionen von einem 

konstant durchlaufenden, nicht beeinflußbaren 16-Bit-Taktzähler abgeleitet: 

• Der Real-Time-Interrupt (Echtzeitunterbrechung) dient dem Zweck, in genau periodischen 

Zeitabständen einen bestimmten Vorgang auszulösen. 

• Die 3 Input-Capture-Funktionen (Zeiterfassungsfunktionen) IC1 bis IC3 dienen zur 

Zeitmessung von Eingangssignalen an den Eingängen PA0 bis PA2. 

Der Speicher 89

• Mit den 4 Output-Compare-Funktionen (Zeitvergleichsfunktionen) OC1 bis OC4 können bei 

bestimmten Timer-Zählerständen H-Pegel bzw. L-Pegel an den Anschlüssen PA3 bis PA6 

ausgegeben werden. 

• Der COP-Watchdog-Timer sorgt dafür, daß die Programmlaufüberwachung innerhalb einer 

überwachungsperiode rechtzeitig zurückgesetzt wird. Im Fehlerfall wird ein Reset (Neustart) 

des Rechners veranlaßt. 

Digitale Ein- und Ausgänge 

Je 8 Ein- bzw. Ausgänge sind in den Ports A, B, C und E zusammengefaßt. Die meisten dieser 

Anschlüsse haben mehrere Funktionen, die softwaremäßig festzulegen sind. Die jeweilige 

Pfeilrichtung im Blockschaltbild kennzeichnet den Anschluß als Eingang oder Ausgang. Der Zugriff 

erfolgt wie auf den Speicher. Eigenschaften der fünf Ports: 

• Port A: (verbunden mit 16-bit Zähler) 

3 Eingänge (sichern des aktuellen Zählerstandes in ein Register durch ein Eingangssignal) 

4 Ausgänge (Vergleichsausgänge des Zählers: sobald der Zähler den im zugehörigen Register 

gespeicherten Wert erreicht hat, wird hier eine 1-Signal erzeugt) 

1 Ein- und Ausgang (Impulszähler) 

• Port B und C: Funktion hängt von der Betriebsart der Microcontrollers ab. Der 68HC11 kennt 

vier Betriebmodi (einstellbar an den Pins MODA, MODB): 

single chip 

Mode 

expanded 

Mode 


normal Nur der interne Speicher ist verfügbar, Port B: digitale 

Ausgabeschnittstelle, Port C: digitale Eingabe- oder 

Ausgabe-Schnittstelle, STRB,STRA beliebig verwendbar (digitale Einbzw. 

Ausgänge) 

special special bootstrap mode: 

In diesem Modus lädt die Firmware über die serielle Schnittstelle (Port 

D) ein 255 Bytes großes Grundprogramm, welches anschliesend 

ausgeführt wird. 

normal Dieser Mode dient zum Anschließen externer Peripherie und externer 

Speicher. Der 68HC11 stellt sich dann wie ein normaler 

Mikroprozessor dar: 

Port B: Buserweiterung 

Port C: Buserweiterung 

STRA, STR B: Steuerleitungen 

special spezieller Testmodus 

Timer-System 90

• Port D: 

zwei Ein- /Ausgänge (serielle Schnittstelle) 

vier Ein- /Ausgänge (für synchronen Datenaustausch mit anderen 68HC11) 

• Port E: 

8-Kanal A/D-Wandler (Genauigkeit: 8-bit) 

Impulszähler 

Der Impulszähler dient je nach Software-Vorgabe zur Zählung von Pulsen oder zur Bestimmung einer 

Pulsdauer, wobei er im letzteren Fall auf das Timer-System zugreift. 

Analog-Digital-Wandler 


Die 8 Anschlüsse des Ports E können je nach Bedarf im Multiplexbetrieb auf einen 

Analog-Digital-Wandler geschaltet werden. Der Wandler arbeitet mit einer Auflösung von 8 Bit und 

beinhaltet eine Sample-and-Hold-Funktion, so daß auch zeitveränderliche Signale amplitudengetreu 

verarbeitet werden. 

Synchrone serielle Peripherieschnittstelle 

Die synchrone serielle Peripherieschnittstelle (SPI) dient zum Datenaustausch mit einem anderen 

Mikrocontroller oder speziell dafür entwickelten Peripheriebausteinen, die an PD2 bis PD5 

angeschlossen werden. 

Digitale Ein- und Ausgänge 91

Vereinfachtes Blockschaltbild des 68HC11 


4.2 Typische Anwendungsschaltung 

Wie aus dem Stromlaufplan ersichtlich ist, besteht die gesamte Schaltung des Mikrocontrollers nur aus 

drei integrierten Bausteinen. Den Mittelpunkt bildet der Mikrocontroller 68HC811 (IC1). Sämtliche 

Anschlüsse sind durch Widerstandsnetzwerke abgeschlossen. Der Takterzeugung dient ein 

8-MHz-Quarz (Q1), der mit Hilfe der beiden Keramikkondensatoren C3, C4 und dem 

Parallelwiderstand R1 auf der Grundwelle schwingt. Für das Laden der Programme und für den 

Kontakt mit der Außenwelt wurde ein serieller Pegelwandler vom Typ MAX 232 verwendet. Seine 

externe Beschaltung beschränkt sich auf vier Tantalkondensatoren (C6 bis C9) für die internen 

Spannungswandler (+12V/-12V). Mit dem Schalter SW1 kann der Mikrocontroller in den Bootmodus 

geschaltet werden. Nur in dieser Betriebsart ist es möglich, Programme zu laden und abzuspeichern. 

Der Taster TA1 löst einen Reset aus und versetzt die gesamte Schaltung in einen definierten 

Anfangszustand. 

Die Spannungsversorgung erfolgt durch IC3, einen Festspannungsregler vom Typ 7805. Die von 

einem externen Steckernetzteil zugeführte Gleichspannung von etwa 9 V wird hier auf eine konstante 

Versorgungsspannung von 5 V geregelt. 

Synchrone serielle Peripherieschnittstelle 92


Achtung: Diese Schaltung ist nicht mit der Schaltung des im Praktikum verwendeten "Zwerg 11" 

identisch. 

Stückliste für das Mikrocontroller-Board 

Bezeichnung Bauteil Wert 

IC1 Mikrocontroller MC 68HC811 E2 FN 

IC2 IC MAX 232 

IC3 Regler-IC 7805 

Q1 Quarz 8 MHz 

RN1 - RN5 Widerstandsnetzwerk 8 x 10 KOhm 

R1 Widerstand 10 MOhm 

R2 Widerstand 1 KOhm 

R3, R4 Widerstand 10 KOhm 

R5 Widerstand 4,7 KOhm 

C1, C12 Kondensator 100 nF keramik 

4.2 Typische Anwendungsschaltung 93

C3, C4 Kondensator 22 pF keramik 

C2, C5 Tantalelko 1 Mikrofarad / 35 V 

C6, C7, C8, C9 Tantalelko 10 Mikrofarad / 16 V 

C10 Elko 100 Mikrofarad / 16 V 

C11 Elko 100 Mikrofarad / 16 V 

ST1 - ST5 Steckerleiste 2 x 8-polig 

Bu1 - Bu5 Buchsenleiste 8-polig 

Fassung für IC1 IC-Fassung PLCC 52 

Fassung für IC2 IC-Fassung 16-polig 

13 Stück Lötstifte 1 mm 

4.3 Praktikumssystem PS11 mit M68HC11A0 

Blockschaltung 

(CONFIG = $0C) 


Praktikumsrechner mit Experimetierboard 

Stückliste für das Mikrocontroller-Board 94

Der ZWERG11plus 


Unter den ganz kleinen Karten ist der ZWERG11A von 

Elektronikladen Detmold ein ganz Großer. Mittlerweile 

vieltausendfach im Einsatz gab es aber immer wieder 

Applikationen, die das Speicherangebot des ZWERG11A 

überforderten. 

So wurde als Ergänzung zum "kleinen ZWERG" ein "großer ZWERG" geschaffen: der 

ZWERG11plus. Die Schwierigkeit, auf einer Platinenfläche von nur 51mm x 54mm einen "großen" 

Rechner zu entwerfen, läßt sich sicherlich nachvollziehen. Die Lösung für dieses Problem hieß: 

6-Lagen-Multilayer, mehr SMT-Bauteile und doppelseitige Bestückung. 

Zum ZWERG11plus gibt es ein Entwicklungspaket. Es besteht aus folgenden Komponenten: 

• ZWERG11plus Controllermodul 

• Benutzerhandbuch mit Diskette 

• RS232 Interface-Modul (IF-Modul) 

• Flachbandkabel für IF-Modul und Sub-D9 Anschlußkabel für PC/AT 

• Terminalprogramm zur Kommunikation zwischen PC und ZWERG11plus 

• Programmier- und Download-Utilities 

• Cross-Assembler AS11 und Hilfsprogramme 

Zur Softwareentwicklung für den ZWERG11plus können Sie, neben dem Assembler im 

Entwicklungspaket, die Integrierte Entwicklungsumgebung IDE11 einsetzen. 

Als C-Compiler stehen Produkte von Imagecraft (ICC11) und Cosmic zur Verfügung. Außerdem 

kann man das MOPS-Betriebssystem (Assembler/Basic/Pascal) mit dem ZWERG11plus verwenden. 

Praktikumsrechner mit Experimetierboard 95

Technische Daten: 


• MC68HC11A1 8Bit Mikrocontroller Motorola 

• Versorgungsspannung 5V, Stromaufnahme typ. 20-30mA 

• Reset-Controller 

• 32KByte RAM 

• 32KByte EEPROM 

• Uhrenbaustein RTC4553 mit Batterie (Option) 

• Anschluß für serielle Interfacemodule (IF-Module) 

• SPI: Interface für ser. Peripherie Bausteine (parallel I/O, AD/DA-Wandler usw.) 

• Timersystem 16 Bit mit 5x Output-Compare, 3x Input-Capture 

• 8 Bit AD-Wandler mit 8 Kanälen 

• Port Replacement Unit (PRU) MC68HC24 

• bis zu 40 digitale Ein-/Ausgänge (abzgl. genutzter Sonderfkt.) 

• Steckverbinder für alphanumerische oder grafische LCDs 

• steckerkompatibel zu ZWERG11A 

Anschluß des "Zwerg 11" an den PC 

Belegung des Schnittstellenkabels und des Experimentierboards 

Der ZWERG11plus 96

Bootloader Firmware for MC68HC11A8 (essentials) 

pddr equ $08 

baud equ $2B 

sccr2 equ $2D 

scsr equ $2E 

scdr equ $2F 

* 


Belegung des Schnittstellenkabels und des Experimentierboards 97

org $BF40 

* 

main ldx #$1000 init x for indexed access to hardware 

ldaa #$A2 

staa baud,x restart timer , set baudrate to 7812 Bd 

ldaa #$0C 

staa sccr2,x enable receiver and transmitter 

bset sccr2,x $01 send break to signal start of download to master 

wait brset pddr,x $01 wait wait for startbit from master 

bclr sccr2,x $01 clear break 

char brclr scsr,x $20 char wait for first character from master (RDRF) 

ldaa scdr,x read character 

bne goon 

jmp $B600 start program in internal EEPROM 

goon cmpa #$55 test mode ? 

beq strt yes, skip download 

cmpa #$FF baud rate ok ? 

beq bdok yes, goon 

bset baud,x $33 change to 1200 Bd 

bdok ldy #$000 init pointer 

loop brclr scsr,x $20 loop wait for RDRF 

ldaa scdr,x get character 

staa 0,y store character to RAM 

staa scdr,x echo character to master 

iny adjust pointer 

cpy #$0000 end of area ? 

bne loop no, next character 

* 

strt jmp $0000 start downloaded userprogram 

* 

org $BFFE 

dc.w main start main on RESET (MODA = MODB = 0) 

* 

end 






Bootloader Firmware for MC68HC11A8 (essentials) 98

5. Peripherie des Systems M68HC11 

5.1 Peripherie-Register 

Standardlage (default): $1000 - $103F, Verschiebung an jede 4KByte-Grenze möglich 

(INIT-Register) 

Adresse Register Funktion Adresse Register Funktion 

$1000 PORTA port A data $1020 TCTL1 

$1001 spare $1021 TCTL2 

$1002 PIOC parallel I/O control $1022 TMSK1 

$1003 PORTC port C data $1023 TFLG1 

$1004 PORTB port B data $1024 TMSK2 timer mask 2 

$1005 PORTCL port C latch $1025 TFLG2 timer flag 2 

$1006 spare $1026 PACTL pulse accu control 

$1007 DDRC port C direction $1027 PACNT pulse accu count 

$1008 PORTD port D data $1028 SPCR SPI control 

$1009 DDRD port D direction $1029 SPSR SPI status 

$100A PORTE port E data $102A spare 

$100B CFORC $102B BAUD SCI baud rate 

$100C OC1M $102C SCCR1 SCI control 1 

$100D OC1D $102D SCCR2 SCI control 2 

$100E TCNT timer count high $102E SCSR SCI status 

$100F timer count low $102F SCDR SCI data 

$1010 TIC1H $1030 ADCTL A/D control 

$1011 TIC1L $1031 spare 

$1012 TIC2H $1032 spare 

$1013 TIC2L $1033 spare 

$1014 TIC3H $1034 spare 

$1015 TIC3L $1035 spare 

$1016 TOC1H $1036 spare 

$1017 TOC1L $1037 spare 

$1018 TOC2H $1038 spare 

$1019 TOC2L $1039 OPTION 

$101A TOC3H $103A spare 

$101B TOC3L $103B PPROG 

$101C TOC4H $103C HPRIO 

$101D TOC4L $103D INIT 

$101E TOC5H $103E TEST1 

5. Peripherie des Systems M68HC11 99

$101F TOC5L $103F CONFIG 

Im Rahmen dieser Vorlesung wird nur ein ausgewählter Teil dieser Register und ihrer Funktionen 

besprochen. Im folgenden werden einzelne Ports und die zugehörigen Register zur Sprache kommen. 

5.2 Parallele Schnittstellen 

Beim Informationsaustausch des Controllers mit der "Außenwelt" müssen spezielle Eigenschaften der 

Peripheriegeräte berücksichtigt werden. Insbesondere sind die Peripherieeinheiten gegenüber der 

Prozessorgeschwindigkeit recht langsam Die Schnittstellen müssen die ein- oder ausgehenden 

Daten zwischenspeichern. Zum anderen laufen CPU und Peripherie oft zeitlich asynchron. Eine 

weitere Aufgabe von Schnittstellen ist auch die Parallel-seriell-Wandlung (siehe Abschnitt 5.3). 

Allgemein gilt für alle Schnittstellen: 

• der Datenverkehr zwischen CPU und Schnittstelle läuft meist programmgesteuert (per Polling 

oder per Interrupt) 

• die "Datenbreite" ist durch den internen Datenbus vorgegeben (8 Bit) 

• die Eigenschaften der Schnittstellen lassen sich per Programm einstellen Schnittstelle 

programmierbar Initialisierung notwendig 

• jeder Schnittstelle sind einige der oben aufgeführten Register zugeordnet. Dabei handelt es 

sich um 

♦ Register zur Einstellung der Eigenschaften 

♦ Register zur Ein- und Ausgabe 

Der 68HC11 besitzt fünf parallele Schnittstellen, die Ports A bis E, welche mit unterschiedlichen 

Hardware-Eigenschaften ausgestattet sind. Im "expanded Mode" stehen die Ports B und C nicht zur 

Verfügung, weil sie für Adreß- und Datenleitungen verwendet werden. Durch einen 

Port-Expander-Baustein lassen sie sich aber wieder ergänzen. 

Eine kurze Übersicht der Ports: 


• Port A: besitzt drei Eingänge vier Ausgänge und eine bidirektionale Leitung. Zusätzlich 

verarbeitet er die Signale des Timer-Systems und des Pulse-Akkumulators. 

Die Ports B und C werden zusammen mit den Handshakeleitungen STRA und STRB als Einheit 

betrachtet. 

• Port B: besitzt acht Ausgangsleitungen. Lesen auf Port B liefert die letzten 

hineingeschriebenen Daten. 

• Port C: hat acht bidirektionale Leitungen. Über ein Datenrichtungsregister kann für jede 

Leitung festgelegt werden, ob sie Eingang oder Ausgang sein soll. Ein zusätzliches Latch 

speichert den Eingangszustand von Port C bei jeder aktiven Signalflanke auf dem Anschluß 

STRA. 

• Port D: besitzt sechs bidirektionale Leitungen, die wie bei Port C per Datenrichtungsregister 

eingestellt werden können. Die Bits 0 und 1 von Port D werden auch von der seriellen 

Schnittstelle verwendet. 

• Port E: besitzt acht Eingangsleitungen, die alternativ als analoge Eingänge des 

A/D-Wandler-Systems verwendet werden. Beim DIL-Ghäuse stehen sogar nur vier Leitungen 

zur Verfügung. 

Den fünf Ports sind insgesamt 16 Register zugeordnet (Einstellung und E/A). Die jeweiligen Register 

werden bei der Besprechung der einzelnen Ports behandelt. 

5.1 Peripherie-Register 100

Port A 


Ein- und Ausgabeport mit fester und für ein Bit variabler Datenrichtung. 

Der Port kann auf zwei verschiedene Betriebsarten gesetzt werden: 

• Steuerbit PEAN = 0: "normale" parallele E/A (Betriebsart 1). 

• Steuerbit PEAN = 1: Impuls-Akkumulator (Betriebsart 2). Hier lassen sich entweder Impulse 

zählen (PMOD = 0) oder Impulsdauern messen (PMOD = 1). 

PAIF set by active edge on PAI, reset by writing a corresponding one to TFLG2 

PAOVF set by roll over of PACNT, reset by writing a corresponding one to TFLG2 

PAII set and reset by software, generate interrupt, if PAIF is set 

PAOVI set and reset by software, generate interrupt, if PAOVF is set 

Beim Event Counting Mode (PAMOD=0) werden am PAI Eingang (=PA7) eintreffende Impulse im 

pulse accu gezählt. 

Beim Gated Time Mode (PAMOD=1) wird die Zeit "gemessen", wie lange der PAI-Eingang im 

aktiven Zustand ist. Die Messdauer ergibt sich aus der Anzahl der gezählten Impulse, die aus dem 

Port A 101

durch 64 geteilten Systemtakt abgeleitet sind, d.h. die zeitliche Auflösung beträgt 32 ms. 

Der Port A bietet mit seinem Pin PAI (= PA7) außerdem die Möglichkeit, Programmunterbrechungen 

(Interrupts) auszulösen. 

Port B und STRB 

Ausgabeport mit fester Datenrichtung 


• Steuerbit HNDS = 0: "normale" parallele Ausgabe 

• Steuerbit HNDS = 1: full handshake mode 

Wird im Rahmen dieser Vorlesung nicht besprochen! 

Die Programmierung von Port B ist denkbar einfach. Jedes Schreiben auf die Adresse $2004 hat die 

Ausgabe des entsprechenden Bitmusters auf den Leitungen von Port B zur Folge. 

Port C und STRA 


Ein/Ausgabeport mit bitweise wählbarer Datenrichtung. Das Datenrichtungs-"Register" DDRC 

(Adresse $1007) legt fest, ob die Bits von Port C Eingangs- oder Ausgangsbits sind (0 = Eingang, 1 = 

Ausgang). Daher ist eine Initia-lisierung des Ports durch belegen von DDRC notwendig. Die folgende 

Abbildung zeigt das Impulsdiagramm einer typischen Anwendung des STRA-Signals. In der 

Abbildung sind auch die Bedingungen beschrieben, die für die einzelnen Steuer- und Statusbits in 

PIOC gelten. 


• Steuerbit HNDS = 0: "normale" parallele Ein- oder Ausgabe 

Port B und STRB 102

• Steuerbit HNDS = 1: full handshake mode 

Wird im Rahmen dieser Vorlesung nicht besprochen! 

Die Leitung STRA wird über die Bits STAI und EGA in PIOC gesteuert. STAI gibt den Interrupt für 

die Leitung STRA frei (wird weiter unten behandelt). EGA legt fest, ob STRA auf eine steigende oder 

fallende Flanke reagiert. Wird beispielsweise eine Taste an STRA angeschlossen, wird durch deren 

Betätigung das Bit STAF in PIOC gesetzt und falls STAI = 1 ist, ein Interrupt ausgelöst. Das Bit 

STAF wird durch das Lesen der Adressen PIOC und PORTCL (in dieser Reihenfolge) zurückgesetzt. 

Impulsdiagramm einer typischen Anwendung des STRA-Signals 

Port D 


Ein/Ausgabeport mit bitweise wählbarer Datenrichtung. 


• Steuerbits SPE = RE = TE = 0: "normale" parallele Ein- oder Ausgabe 

Port C und STRA 103

Port E 

• 2. Betriebsart: SPI = serial peripheral interface (synchronous) wenn SPE=1 ist oder SCI = 

serial communications interface (asynchronous) wenn RE=1 und/oder TE=1 sind. 

Wird unter 5.3 besprochen. 

Eingabeport mit fester Datenrichtung 


• "normale" parallele Eingabe, kein Schreiben ins ADCTL-Register 

• A/D-Wandlung, Schreiben ins ADCTL-Register - siehe später. 

Programmbeispiele 

Beispiel 1 

Lesen 4 Bit linksbündig von Port C 

Ausgeben 4 Bit rechtsbündig auf Port C 

Ausgeben 4 Bit rechtsbündig auf Port B mit STRB (high pulse) 

Vereinbarungen: 

pcdr equ $1003 

pcdd equ $1007 

pbdr equ $1004 

pioc equ $1002 

Initialisierung 

init ldaa #$0F 


Port D 104

Datenverkehr 

staa pcdd pc(3:0) = output 

ldaa #$01 

staa pioc STRB high active 

rts 

main ldaa pcdr 

lsra 

lsra 

lsra 

lsra 

staa pcdr 

staa pbdr 

bra main 

Beispiel 2 

Warten auf steigende Flanke am Eingang STRA 



pcdl equ $1005 

Initialisierung 

init ldaa #$02 

staa pioc STRA rising edge expected 

rts 

Daten-Abfrage 

. 

. 

. Alternative 

wait ldaa pioc 

anda #$02 bita #$02 

beq wait beq wait 

ldaa pcdl clear STAF-flag 

. 

. 

. 

Beispiel 3 

Realisieren eines 8-Bit-Zählers auf Port B 

(Port B ist zwar ein reiner Ausgabeport, aber mit dem Befehl "inc pcdr" wird Port B erst gelesen und 

somit der vorherige Ausgabewert geliefert, dann der Wert erhöht und zurückgeschrieben). 



Programm: 


init clr pbdr Port B = 0 

main inc pbdr Increment Port B 

ldx #$4000 Warteschleife 

delay dex X = X - 1 

bne delay solange X > 0 durchlaufe Schleife 

Programmbeispiele 105

Beispiel 4 


bra main 

portc equ $1003 


Programm: 

init ldaa #%11111111 

staa pcdd Port C auf Ausgabe setzen (0=in, 1=out) 

clra 

staa portc Port C = 0 

main inca 

staa portc hochzählen 

ldx #$4000 Warteschleife 

delay dex 

bne delay 

bra main 

Beispiel 5 

Lichtmuster ausgeben auf LEDs, die an Port C angeschlossen sind. 




Programm: 

init ldaa #$FF 

staa pcdd Port C auf Ausgabe setzen (0=in, 1=out) 

top ldx #TABLE X verweist nun auf die Daten in TABLE 

loop ldaa 0,X Tabellenelement lesen 

beq top ist das Element 0 --> Tabellenende 

* wieder zum Tabellenanfang 

staa portc Tabellenelement ausgeben 

bsr delay Warteschleife aufrufen 

inx naechstes Tabellenelement 

bra loop usw. 

* 

delay ldx #$4000 Warteschleife, diesmal als Unterprogramm 

dela1 dex 

bne dela1 

rts 

* 

TABLE dc.b $01, $02, $04, $08, $10, $20, $40, $80 

dc.b $40, $20, $10, $08, $04, $02, $00 

Beispiel 6 

Lesen Port E, ausgeben auf Port B 



pedr equ $100A 



Programm: 

main ldaa pedr 

staa pbdr 

bra main 

5.3 Serielle Schnittstellen 

Die SCI-Schnittstelle (serial communication interface asynchronous) ist ein Port mit langsamer, 

asynchroner serieller Datenübertragung (bis etwa 100 kbit/s). Mit einem Pegelwandler kann sie als 

RS232-Schnittstelle verwendet werden. Sie entspricht in ihrer Funktion der seriellen Schnittstelle des 

PC. 

Die SPI-Schnittstelle ist eine synchrone serielle Peripherieschnittstelle (serial peripheral interface). Sie 

dient zum Datenaustausch mit einem anderen Mikrocontroller oder mit Peripheriebausteinen. 

Beide Schnittstellen verwenden einige Pins von Port D, die dann nicht mehr als Parallelport-Pins zur 

Verfügung stehen. Für eine allgemeine Einführung in die Assemblerprogrammierung ist es nicht 

notwendig, alle Schnittstellen des 68HC11 zu besprechen. Daher wird nur die asynchrone serielle 

SCI-Schnittstelle behandelt. 

SCI (serial communication interface asynchronous) 

Port mit langsamer, asynchroner serieller Datenübertragung (bis etwa 100 kHz) 

Um die Schnittstelle mit der Außenwelt zu verbinden, werden die beiden niederwertigen Bits des 

Ports D verwendet. Für die Freigabe der Signale nach außen müssen im Register SCCR2 die Bits RE 

(Empfang) und TE (Senden) auf 1 gesetzt werden. 

Puffer und Statusbits 

Statusbits: 


5.3 Serielle Schnittstellen 107

• RDRF (receive data register full): Wird gesetzt, wenn ein Zeichen vom 

Empfangsschieberegister ins Register SCDR übertragen wird. Wird zurückgesetzt durch 

Lesen von SCSR und danach Lesen von SCDR. 

• TDRE (transmit data register empty): Wird gesetzt, wenn ein Zeichen vom Register SCDR ins 

Sendeschieberegister übertragen wird. Wird zurückgesetzt durch Lesen von SCSR und danach 

Schreiben von SCDR. 

• TC (transmission complete): Wird gesetzt, wenn ein Zeichen komplett aus dem 

Sendeschieberegister herausgeschoben wurde. Wird zurückgesetzt durch Lesen von SCSR 

und danach Schreiben von SCDR. 

Empfangs-Funktion: 

Die Steuerungslogik erkennt ein seriell ankommendes Zeichen und schiebt es im eingestellten Takt ins 

Empfangs-Schieberegister (Receive Data Register, RDR). Sobald das Zeichen vollständig im 

Schieberegister steht, wird es parallel ins Empfangsregister kopiert; gleichzeitig wird im Statusregister 

(SCSR) das Bit 5 (Receive Data Register Full, RDRF) auf 1 gesetzt. Falls im Steuerregister (SCCR2) 

der Empfangsinterrupt zugelassen wurde (Receive Interrupt Enable, RIE), wird auch noch ein 

SCI-Interrupt erzeugt. 

Das sofortige Kopieren eines Zeichens vom Schieberegister ins Empfangsregister (SCDR) ist 

notwendig, damit ein eventuell unmittelbar nachfolgendes serielles Zeichen nicht das vorherige 

überschreibt. Allerdings muß das Empfangsregister bis spätestens unmittelbar vor dem nächsten 

Kopieren vom Prozessor gelesen werden, denn sonst geht dieses Zeichen durch Überschreiben 

verloren. Die Steuerung erkennt ein solches Überschreiben und setzt dann das Bit 3 im Statusregister 

(SCSR): Overrun Error (OR). Der Zeitabstand, in dem Zeichen eintreffen können, hängt von der 

Baudrate ab, z. B. beträgt der Zeichenabstand bei 9600 Baud ca. 1 ms. 

Sende-Funktion: 

Wird ein Zeichen ins Senderegister geschrieben, so prüft die Steuerlogik, ob das 

Sende-Schieberegister frei ist, um es dann dorthin zu kopieren und den Schiebevorgang zu starten. 

Damit ist das Senderegister wieder frei und es kann erneut per Store-Befehl beschrieben werden 

(nächstes Zeichen). Die Tatsache, daß dieses Schreiben erlaubt ist, signalisiert das Bit 8 (Transmit 

Data Register Empty, TDRE) des Statusregisters (SCSR) mit einer 1. Auch hier kann ein 

SCI-Interrupt ausgelöst werden, wenn im Steuerregister der Sende-Interrupt per TIE-Bit = 1 (Transmit 

Interrupt Enable) freigegeben ist. In manchen Fällen kann auch noch das tatsächliche Ende des 

Schiebevorgängs von Interesse sein (Transmission complete). Für diesen Zweck gibt es auch noch die 

Möglichkeit, diese Tatsache sowohl am entsprechenden Statusbit (TC) zu erkennen bzw. durch einen 

Interrupt melden zu lassen. 

Serielles Rahmenformat: 

Idle: Im Ruhezustand ist die Leitung auf auf 1-Pegel. 

Beim Datenformat von 9 Bit (M = 1) ist das neunte Bit im Register SCCR1 zu finden. Beim Wert M 

= 0 werden 8 Bit empfangen/gesendet (Normalfall). 

Setzen der Datenrate 


Die Erzeugung der Datenrate erfolgt mehrstufig und ist daher etwas komplex. Es spielen dabei vier 

Teiler für die Taktfrequenz (in der Regel 8 MHz) zusammen (Register BAUD): 

SCI (serial communication interface asynchronous) 108

Der Takt gelangt erst in einen Prescaler mit vier möglichen Divisionsfaktoren (1, 3, 4, 13), dessen 

Output dann nochmals durch acht Divisoren geteilt werden kann. Bei einer Taktrate von 8 MHz lassen 

sich folgende Raten wählen (Einstellungen für das Praktikumssystem farbig hinterlegt): 

Neben den beiden schon erwähnten Bits TE und RE sind im Register SCCR2 die Steuerbits für die 

Interruptfreigabe enthalten. 

interrupt masks (set and reset by software) 


• RIE receive interrupt enable, generate IRQ, if RDRF is set 

• TIE transmit interrupt enable, generate IRQ, if TDRE is set 

• TCIE tx complete interrupt enable, generate IRQ, if TC is set 

• ILIE idle-line interrupt enable, generate IRQ, if IDLE is set 

Das SCI-Statusregister SCSR liefert Informationen über den Ablauf der Kommunikation. Die 

Fehlerflags werden zurückgesetzt durch das Lesen von SCSR und SCDR. 

SCI (serial communication interface asynchronous) 109

error flags (set by hardware, reset by reading SCSR and SCDR) 

• OR overrun error char received and previously received char not yet read 

• NF noise flag data recovery logic detected noise during reception 

• FE framing error no logic high, when stop bit is expected 

SPI (serial peripherial interface synchronous) 

Port mit schneller, synchroner serieller Datenübertragung (bis etwa 2 MHz). 

Wird im Rahmen dieser Vorlesung nicht besprochen. 

Programmbeispiele 

Beispiel 1: 

Serielles Senden und Empfangen von Zeichen mit 9600 Bd 


scdr equ $102F 

scsr equ $102E 

baud equ $102B 

sccr1 equ $102C 

sccr2 equ $102D 

Einstellungen: 


staa baud baudrate = 9600 bit/s 

ldaa #0 

staa sccr1 

ldaa #$0C 

staa sccr2 enable transmit & receive 

rts 

Datenverkehr: 

* Zeichen in Speichezelle "char" ausgeben 

chou ldaa char 

ldab scsr Sendereg. leer? 

andb #$80 

beq chou 

staa scdr transmit 

rts 


* Zeichen nach Speicherzelle "char" einlesen 

chin ldab scsr Empfangsreg. leer? 

andb #$20 

SPI (serial peripherial interface synchronous) 110

Sendeschleife: 

beq chin 

ldaa scdr receive 

staa char 

rts 

main bsr init 

loop bsr chin "Schreibmaschine" 

bsr chout 

bra loop 

Beispiel 2: 

Serielles Senden von Zeichenketten mit 9600 Bd 


scdr equ $102F 

scsr equ $102E 

baud equ $102B 

sccr1 equ $102C 

sccr2 equ $102D 

Einstellungen: 


staa baud baudrate = 9600 bit/s 

ldaa #0 

staa sccr1 

ldaa #$0C 

staa sccr2 enable transmit & receive 

rts 

Zeichen in Akku A ausgeben: 

chou ldab scsr Sendereg. leer? 

bpl chou 

staa scdr transmit 

rts 

Zeichenkette senden: Die Adresse der Zeichenkette wird in X übergeben, Ende der Zeichenkette wird 

durch ETX markiert definiert durch: ETX EQU 3. 

saus ldaa 0,x Zeichen holen 

cmpa #ETX ETX (3) ? 

beq saus_e dann fertig 

inx X inkrementieren 

bsr chou Zeichen senden 

bra saus und nächstes Zeichen 

saus_e rts 



main bsr init 

loop ldx #TEXT 

bsr saus 

bra loop 

* 

TEXT dc.b 'Hello World' Meldungstext 

dc.b $0D,$0A,ETX Zeilenvorschub, ETX 


Beispiel 3: 

Serielles Senden und Empfangen von Zeichenketten mit 9600 Bd 

Vereinbarungen: - siehe oben - 

Einstellungen: - siehe oben - 

Zeichen in Akku A ausgeben: - siehe oben - 

Zeichenkette senden: - siehe oben - 

Zeichen nach Akku A einlesen 

chin ldab scsr Empfangsreg. leer? 

andb #$20 

beq chin 

ldaa scdr receive 

rts 

Zeichenkette einlesen: Die Adresse eines Eingabepuffers wird in X übergeben. Das Eingabeende wird 

durch die Taste Carriage-Return (CR, $0D) signalisiert. 

sein bsr chin Zeichen einlesen 

cmpa #$0D Carriage Return? 

beq sein_e ja, Ende 

staa 0,x Zeichen im Puffer speichern 

inx X inkrementieren 

bra sein und nächstes 

sein_e ldaa #ETX ETX anhängen (CR wird nicht mit gesp.) 

staa 0,x 

rts 


main bsr init 

loop ldx #PUF 

bsr sein 

ldx #PUF 

bsr saus 

bra loop 

Irgendwo im Programm wird ein Puffer definiert, z. B.: 

org data 

PUF ds.b 80 80 Bytes Puffer reservieren 

Anmerkung: "sein" überprüft nicht, ob der maximale Pufferbereich überschritten wird und so 

eventuell andere Variablen überschrieben werden. Versuchen Sie, eine Begrenzung der Eingabe auf z. 

B. 80 Zeichen zu programmieren. 

Beispiel 4: Kommandoauswertung. Es wird ein Befehlsbuchstabe von der seriellen Schnittstelle 

eingelesen und verarbeitet. Es sind die Buchstaben 'a', 'b' und 'c' erlaubt - bei anderen Eingaben erfolgt 

eine Fehlermeldung. Als Pseudo-Aktion dient das Unterprogramm "doit", es gibt lediglich den 

eingegebenen Buchstaben als Grossbuchstaben aus. 

prog equ $8000 

data equ $2000 

stack equ $7FFF 



scdr equ $102f 

scsr equ $102e 

sccr1 equ $102c 

sccr2 equ $102d 

baud equ $102b 

reset equ $fffe 

cr equ 13 

lf equ 10 

org data 

buf ds.b 100 ; Eingabepuffer 


org prog 

main lds #stack ; Stackpinter setzen 

bsr sini ; Schnittstelle init. 

loop ldx #hello ; Prompt ausgeben 

bsr saus 

bsr chin ; Taste einlesen 

cmpa #'a' ; ist es 'a'? 

bne next1 ; nein, weiter 

bsr doit ; Dummy-Aktion 

bra loop ; und weiter 

next1 cmpa #'b' ; ist es 'b'? 

bne next2 ; wie oben 

bsr doit 

bra loop 

next2 cmpa #'c' ; ist es 'c'? 

bne next3 ; wie oben 

bsr doit 

bra loop 

next3 ldx #oops ; keine erlaubte Taste 

bsr saus ; Fehlermeldung ausgeben 

bra loop 

doit ; Dummy-Aktion 

psha ; Akku A retten 

ldx #k1 ; Text ausgeben 

bsr saus 

pula ; Akku wieder holen (eingeg. Zeichen) 

suba #$20 ; in Grossbuchstaben umwandeln 

bsr chou ; und ausgeben 

bsr crlf ; neue Zeile 

rts 

crlf ldaa #cr ; Carriage Return, Line Feed ausgeben 

bsr chou 

ldaa #lf 

bsr chou 

rts 

saus ldaa 0,x ; Stingausgabe, siehe oben 

beq sfin 

bsr chou 

inx 

bra saus 

sfin rts 

sini clr sccr1 ; Schnittstelle initialisieren, siehe oben 

ldaa #$0C 

staa sccr2 

ldaa #$30 

staa baud 

rts 


chou ldab scsr ; Zeichen ausgeben, siehe oben 

bpl chou 

staa scdr 

rts 

chin ldab scsr ; Zeichen einlesen, siehe oben 

andb #$20 

beq chin 

ldaa scdr 

rts 

; Zeichenkettenkonstante 

hello dc.b 'Cmd: ' ; Kommandoprompt 

dc.b 0 

oops dc.b 'Oops!' ; Fehlermeldung 

dc.b cr,lf,0 

k1 dc.b 'Eingabe war ' ; fuer Dummy-Aktion 

dc.b 0 

5.4 Zähler 

org reset ; Reset-Vektor 

fdb main 

end 


Das Timer-System steuert Funktionen, die einen Bezug zur Echtzeit benötigen, also unabhängig von 

Befehlsausführungszeiten sein sollen: 

• Der Real-Time-Interrupt (Echtzeitunterbrechung) dient dem Zweck, in genau periodischen 

Zeitabständen einen bestimmten Vorgang auszulösen. 

• Die drei Input-Capture-Funktionen (Zeiterfassungsfunktionen) IC1 bis IC3 dienen zur 

Zeitmessung von Eingangssignalen an den Eingangspins PA0 bis PA2. 

• Mit den vier Output-Compare-Funktionen (Zeitvergleichsfunktionen) OC1 bis OC4 können 

bei bestimmten Timer-Zählerständen 1-Pegel oder 0-Pegel an den Ausgangspins PA3 bis PA6 

ausgegeben werden. 

• Der COP-Watchdog-Timer sorgt dafür, dass die Programmlaufüberwachung innerhalb einer 

überwachungsperiode rechtzeitig zurückgesetzt wird. Im Fehlerfall wird ein Reset (Neustart) 

des Rechners veranlasst. 

Der 68HC11 hat eine recht komplexe Timer-Struktur, die mit Abstand die meisten Register im 

E/A-Bereich belegt. Entsprechend komplex ist seine Programmierung. 

5.4 Zähler 114

Basis des Timersystems ist ein konstant durchlaufender, nicht beeinflussbarer 16-Bit-Zähler, der im 

Register TCNT abgebildet ist. Das Timersystem leitet seinen Takt über Teiler vom Quarztakt ab 

(Abbildung 31). Die folgenden Zeitangaben beziehen sich auf eine Quarzfrequenz von 8 MHz, was 

einem CPU-Takt von 2 MHz entspricht. Der Vorteiler für den freilaufenden 16-Bit-Zähler wird durch 

die Bits PR0/PR1 im Register TMSK2 programmiert. Die folgende Tabelle zeigt, mit welchen 

Taktperioden der Zähler dann getriggert wird. 

Die beiden Vorteiler werden durch die Bits PR0/PR1 im Register TMSK2 und RTR0/RTR1 im 

Register PACTL programmiert. Nach einem RESET steht hier jeweils ein Wert von 0, so daß die 

höchste Taktrate ausgewählt ist. Diese beiden Bits können nur direkt nach einem RESET verändert 

werden, danach ist jeder weitere Zugriff gesperrt. Diese besondere Eigenschaft des Mikroprozessors 

68HC11 verhindert ungewollte Veränderungen an der Timer-Auflösung durch unzulässige Zugriffe, 

die während des Betriebs durch Störimpulse von außen ausgelöst werden könnten. 

PRn 

1 0 

division 

factor 

output 

period 

0 0 1 32.77 

ms 

0 1 4 131.07 

ms 

1 0 8 262.14 

ms 

1 1 16 524.29 

ms 


RTRn 

1 0 

division 

factor 

output 

period 

0 0 1 4.096 

ms 

0 1 2 8.192 

ms 

1 0 4 16.384 

ms 

1 1 8 32.768 

ms 

5.4 Zähler 115

TOF timer overflow 

flag 

TOI timer overflow 

interrupt enable 

RTIF real time interrupt 

flag 

RTII real time interrupt 

enable 

Der Timer 

Wird gesetzt, wenn der frei laufende 16-Bit-Zähler von FFFF auf 0 

wechselt (Zählerüberlauf). Wird zurückgesetzt durch Schreiben einer 1 

in TOF. 

Interruptfreigabe für "Timer Overflow Interrupt", 0 = Interrupt gesperrt, 

1 = Interrupt freigegeben. 

Wird gesetzt, wenn der Realtime-Interrupt-Zähler auf 0 wechselt 

(Zählerüberlauf). Wird zurückgesetzt durch Schreiben einer 1 in RTIF. 

Interruptfreigabe für "Realtime Interrupt", 0 = Interrupt gesperrt, 1 = 

Interrupt freigegeben. 

Der Timer des 68HC11 besitzt eine Länge von 16 Bit. Aus diesem Grund muß er mit einem 

16-Bit-Ladebefehl gelesen werden, da nur dann die beiden Bytes des Ergebnisses wirklich zusammen 

gehören. Würden das obere und das untere Byte getrennt voneinander gelesen, bestände kein 

eindeutiger Zusammenhang. 

Nach einem Reset der CPU ist der Zählerstand des Timers 0. Es gibt keine Möglichkeit, den 

Zählerstand des Timers auf einen bestimmten Wert zu setzen. Direkt nach dem Reset beginnt der 

Timer aufwärts zu zählen. Bei jedem Überlauf von $FFFF auf $0000 wird das Überlauf-Bit TOF 

(Timer Overflow) im Register TFLG2 gesetzt, um diesen Zustand anzuzeigen. Die Anwendersoftware 

kann so auf einfache Weise eine Kaskadierung des Timers auf beliebige Wortlänge durchführen, da 

dieses Bit auch einen Interrupt auslösen kann. 

Für die meisten Anwendungsfälle ist es sinnvoll, die längste zu messende Zeit zu bestimmen und dann 

den Vorteiler so zu definieren, daß innerhalb dieser Zeit kein Timer-Überlauf auftreten kann. Alle 

Zeitpunktberechnungen können dann mit einfacher 16-Bit-Arithmetik durchgeführt werden. Man darf 

nicht übersehen, daß das Timer-System mit 16 Bit auflöst, der Fehler bezogen auf eine Periode ist 

1/65536 entsprechend 0,0015 %. Diese Genauigkeit ist für fast alle Anwendungen ausreichend. Erhöht 

man die Taktrate des Timer-Systems und arbeitet mit höherer Auflösung, dann addieren sich 

Software-Reaktionszeiten, was häufig zu wesentlich größeren Fehlern führen. 

Bei jedem Überlauf des Timers von $FFFF auf $0000 wird das Überlauf-Bit (TOF = Timer Overflow 

Flag) im TFLG2-Register gesetzt. Das TOF-Bit muß vom Anwenderprogramm gezielt wieder 

gelöscht werden. Wird das Auslösen eines Interrupts bei jedem Timer-Oberlauf gewünscht, dann kann 

das zum TOF-Bit korrespondierende TOI-Bit (Timer Overflow Interrupt) im TFLG2-Register auf 1 

gesetzt werden. 

Der frei laufende Timer 


Der frei laufende Haupt-Timer des 68HC11 wird bei Reset auf 0 gesetzt und beginnt dann zu laufen. 

Derartige Timer findet man auch bei fast jedem anderen Controller. Der Zählerstand kann über ein 

16-Bit-Register auf den Adressen $100E und $100F ausgelesen werden. Wichtig ist hierbei, dass 

mittels einer 16-Bit-Operation gelesen wird (LDD). Würde man zwei aufeinander folgende 

8-Bit-Operationen zum Lesen nehmen (LDAA, LDAB), bekäme man einen "Versatz" von vier 

Taktzyklen, da die Ladeoperation so lange dauert. 

Der Haupt-Timer läuft nach dem Einschalten mit dem E-Takt der CPU. Der Takt kann noch durch 

einen Prescaler geteilt werden, wobei die Faktoren 1, 4, 8 oder 16 möglich sind. Der Teilfaktor wird 

über die Bits 0 und 1 des TMASK-Registers eingestellt. Das folgende Programm illustriert den 

Sachverhalt, indem der Timer ständig ausgelesen und auf den Ports B und C ausgegeben wird. 

Der Timer 116

data equ $2000 ; Datenbereich 

prog equ $8000 ; Programmbereich 

stack equ $7FFF ; Stackbereich 

tirqv equ $FFDE ; Adresse TOF-Vektor 

resetv equ $FFFE ; Adresse Reset-Vektor 

pcdd equ $1007 ; Adressen Port C 


portb equ $1004 ; Adresse Port B 

pacr equ $1026 ; Pulse Akku Control 

tflag equ $1025 ; Timer Flag 

tmask equ $1024 ; Timer Mask 

tcnt equ $100e ; Timer Counter 

org data 

org prog 

main lds #stack ; Init Stack 

ldab #$FF ; Port C auf Ausgang 

stab pcdd 

ldab #$03 ; Timer-Prescaler / 16 

stab tmask ; --> 524,3 ms 

loop ldd tcnt ; Zaehler laden HIGH in A, 

; LOW in B 

staa portb ; ausgeben 

stab pcdr 

bra loop 

org resetv ; Reset-Vektor setzen 

fdb main 

Real-Time-Interrupt 

Häufig wird in einem Mikroprozessorprogramm eine feste Zeitbasis zur Steuerung bestimmter 

Abläufe benötigt. Dafür besitzt der 68HC11 einen speziellen Real-Time-Interrupt, der von den Bits 

RTII im Register TMSK2 und RTIF im Register TFLG2 gesteuert wird. Nach Ablauf einer 

vordefinierten Zeitspanne wird das Bit RTIF im TFLG2-Register gesetzt. Zur Auslösung eines 

Interrupts muß auch hier das korrespondierende RTII-Bit im TMSK2-Register auf 1 gesetzt sein. Das 

RTIF-Bit muß zwingend vom Interrupt-Programm durch Schreiben einer 1 an diese Stelle wieder 

gelöscht werden, da sonst sofort der nächste Interrupt ausgelöst würde. Die Periodendauer des 

Real-Time-Interrupts wird über zwei Bits im PACTL-Register vorgesehen (RTRO und RTR1) 

eingestellt. 

Beispiel: Uhrentakt mittels RTI 

(Quelle: Wallrabe: Mikrocontrollerpraxis, Hanser Verlag) 

Dazu gehen wir von der kürzesten Grundperiode 4,096 ms aus, da sie die feinste Stufung erlaubt. Als 

Anfangsstand des Zählers wählen wir 244. Die so erzeugte Periode dauert somit 244 - 4,096 ms = 

999,424 ms. An der genauen Sekunde fehlen 0,576 ms, ein Fehler, der toleriert werden kann. Nach 

diesen Vorgaben ist das folgende Beispiel aufgebaut, das, vom Anfangswert 244 ausgehend, nach 

jedem RTI-Interrupt die Variable RTIZaehl herunterzählt und bei Erreichen von 0 einen Sekunden-, 

Minuten- und Stundenzähler hochzählt. 

Die Zeitwerte sollen natürlich dezimal und nicht binär (hexadezimal) ausgegeben werden. Daher wird 

nach jedem Inkrementieren eines Zählers dessen Wert mit dem Befehl DAA sofort in einen 

BCD-Wert umgewandelt und auch so abgespeichert. 

Voraussetzung ist, daß im Hauptprogramm folgende RAM-Variablen vorab definiert und initialisiert 

worden sind: 

RTIZaehl = Adresse des RTI-Zählers 

SekZaehl = Adresse des Sekunden-Zählers 


Der Timer 117

MinZaehl = Adresse des Minuten-Zählers 

StdZaehl = Adresse des Stunden-Zählers 

Sek_alt = Zwischenspeicher 


UHR DEC RTIZaehl RTI-Zähler dekrementieren. 

BNE UHR_E 

LDAA #244 Wenn RTI-Zähler = 0: 

STAA RTIZaehl Neu mit Ausgangswert laden. 

LDAA SekZaehl Nach 1 Sekunde: 

INCA Sekundenzähler hochzählen, 

DAA in BCD-Zahl wandeln. 

STAA SekZaehl 

CMPA #$60 

BNE UHR_E 

CLRB Nach 60 Sekunden: 

STAB SekZaehl Sekundenzähler auf 0 setzen, 

LDAA MinZaehl Minutenzähler hochzählen, 

INCA 

DAA 

STAA MinZaehl 

CMPA #$60 

BNE UHR_E Nach 60 Minuten: 

STAB MinZaehl Minutenzähler auf 0 setzen, 

LDAA StdZaehl Stundenzähler hochzählen, 

INCA 

DAA 

STAA StdZaehl 

CMPA #$24 

BNE UHR_E Nach 24 Stunden: 

STAB StdZaehl Stundenzähler auf 0. 

UHR_E LDAA #$40 Rücksetzen des RTI-Flags. 

STAA TFLG2 

RTI 

Diese Uhr tickt unsichtbar und lautlos im Inneren des 68HC11. Daher wird das Unterprogramm zu 

einem kompletten lauffähigen Beispielprogramm erweitert, bei dem die Zeit über die serielle 

Schnittstelle an den PC gesendet und Monitor sichtbar gemacht wird. Das Programm beginnt mit 

einem Initialisierungsteil, in dem die serielle Schnittstelle und der RTI-Interrupt vorbereitet sowie die 

Variablen auf ihre Ausgangswerte gesetzt werden. 

VECRTI equ $FFEB Real Time Interrupt 

TMSK2 equ $1024 Timer Interrupt Mask Reg.2 

SCSR equ $102e SCI Status Reg. 

SCDR equ $102f SCI Data Reg. 

BSR INIT_SCI Schnittstelle Init, siehe 5.3 

LDD #UHR 

STD VECRTI ...RTI-Serviceroutine "UHR". 

LDAA #$40 RTI-Interrupt freigeben. 

STAA TMSK2 (4,096 ms ungeaendert wie Vorgabe). 

LDAA #244 RTI-Zaehler 

STAA RTIZaehl auf Ausgangswert setzen. 

CLRB Ebenso... 

STAB SekZaehl ...Sekunden-Zaehler 

STAB Sek_alt ...Sekunden-Vergleichszaehler 

STAB MinZaehl ...Minuten-Zaehler 

STAB StdZaehl ...Stunden-Zaehler 

CLI Interrupts aktivieren 

UhrStart LDAA SekZaehl Warten, bis Sekunde einen neuen... 

CMPA Sek_alt 

BEQ UhrStart ...Wert hat. 

STAA Sek_alt Neuen Wert in Vergleichszaehler 

Der Timer 118

LDAA StdZaehl Stunden ausgeben 

JSR Hex_Tx 

LDAA #":" Trennzeichen ":" ausgeben 

JSR Byte_Tx 

LDAA MinZaehl Minuten ausgeben 

JSR Hex_Tx 

LDAA #":" 

JSR Byte_Tx 

LDAA SekZaehl Sekunden ausgeben 

JSR Hex_Tx 

LDAA #$0D Carriage Return ausgeben 

JSR Byte_Tx 

BRA UhrStart 

* Ausgabe eines Bytes hexadezimal ueber die serielle Schnittstelle 

* Das zu sendende Byte muî im Akku A vorliegen. 

Hex_Tx PSHA Zu sendendes Byte retten. 

ANDA #$F0 Hw.-Nibble abtrennen 

LSRA und 4 Stellen nach rechts schieben, 

LSRA dabei Nullen nachziehen. 

LSRA 

LSRA 

CMPA #9 0 bis 9 oder A bis F ? 

BHI Buchst1 

Ziff1 ADDA #"0" 0 bis 9. 

JSR Byte_Tx Zum Sender. 

BRA Nibble2 

Buchst1 ADDA #"A" A bis F. 

JSR Byte_Tx 

Nibble2 PULA Byte wieder holen. 

ANDA #$0F Nw.-Nibble abtrennen. 

CMPA #9 

BHI Buchst2 

Ziff2 ADDA #"0" 

JSR Byte_Tx 

RTS 

Buchst2 ADDA #"A" 

JSR Byte_Tx 

RTS 

* Ausgabe eines Bytes ueber die serielle Schnittstelle 

* Das zu sendende Byte muî im Akku A vorliegen. 

Byte_Tx LDAB SCSR Statusregister TDRE abfragen, ob leer. 

ANDB #$80 

BEQ Byte_Tx Abfrage wiederholen, wenn nicht. 

STAA SCDR Byte ausgeben. 

RTS 

Input Capture und Output Compare 


Der Zählerstand kann von drei Input-Capture-Registern zur exakten Bestimmung des Zeitpunktes 

einer extern erkannten Flanke und von fünf Output-Compare-Registern zur Erzeugung exakter 

Impulse und Kurvenformen ausgewertet werden. 

Der Timer 119


• Input Capture: Der Zählerstand des freilaufenden 16-Bit-Zählers wird als Echtzeitreferenz 

betrachtet, jede von der entsprechend programmierten Prozessorhardware erkannte Flanke 

eines extemen Signals speichert den aktuellen Stand dieses Zählers und damit den genauen 

Zeitpunkt in einem der Input-Capture-Register. Auf diese Weise ist es möglich, aus zwei 

aufeinanderfolgenden Impulsflanken eines Signals die Periodendauer als Differenz der 

Zeitpunkte zu bestimmen. Impulsbreiten können durch Verändern der aktiven Flanke nach 

Eintreten des ersten Ereignisses bestimmt werden. 

Jede einzelne Input-Capture-Funktion beinhaltet ein 16-Bit-Latch, in dem der Zeitpunkt eines 

Ereignisses festgehalten werden kann. Die notwendige Synchronisation zwischen 

asynchronem externen Ereignis und internem E-Takt wird von der Prozessor-Hardware 

unsichtbar für den Anwender vorgenommen. Der hierdurch entstehende Fehler ist klein gegen 

die Timer-Auflösung. 

Der Transfer des Timer-Inhalts in eines der Input-Capture-Register erfolgt bei der 

nichtzählenden Flanke des Timer-Signals, so daß ein sicherer Wert auf jeden Fall garantiert 

werden kann. Die Hardware zur Übertragung des Timer-Inhaltes ist für jedes 

Input-Capture-Register getrennt vorhanden, so daß es erlaubt ist, alle drei 

Input-Capture-Eingänge gleichzeitig zu triggern. Das Auslesen eines der 

Input-Capture-Register T1C1 bis T1C3 muß mit einem 16-Bit-Zugriff erfolgen, da nur so 

gewährleistet ist, daß die beiden Bytes des Ergebnisses wirklich zusammengehören. Wird der 

Inhalt eines der Input-Capture-Register nicht gelesen und tritt dann ein weiteres Ereignis ein, 

so wird der alte Wert überschrieben. Der Inhalt dieser Register repräsentiert also immer das 

letzte aufgetretene Ereignis. Je ein Bit im TMSK1- und TFLG1-Register sind als Schnittstelle 

zum Anwenderprogramm vorgesehen. 

Der Timer 120

Die Bits IC1F bis IC3F werden vom Mikroprozessor gesetzt, wenn einer der drei 

Input-Capture-Kanäle ein Ereignis registriert. Die zugehörigen Bits IC1I bis IC3I sind jeweils 

zur Freigabe eines Interrupts als Reaktion vorgesehen und müssen vom Anwenderprogramm 

definiert werden. 

Jeder der drei Kanäle kann auf verschiedene Flanken programmiert werden. Dazu sind im 

Register TCTL2 jeweils 2 Bit pro Capture-Kanal vorgesehen: 

EDGxB EDGxA Aktivierte Flanke 

0 0 Keine, Kanal ausgeschaltet 

0 1 Ansteigende Flanke 

1 0 Abfallende Flanke 

1 1 Beide Flanken 

Das folgende Programm verwendet die Input-Capture-Register, im die Periodendauer eines 

Signals zu messen. Das Signal ist am niederwertigen Kanal 0 (IC1) angeschlossen. Das erste 

Beispiel arbeitet im Polling Mode: Es wird bei der Initialisierung festgelegt, ob auf steigende 

oder fallende Flanke reagiert werden soll - in diesem Fall wurde die steigende Flanke gewählt. 

Nun wartet das Programm auf die erste Flanke und speichert den aktuellen Timerwert. Danach 

wird auf die nächste Flanke gewartet und von dem nun gelesenen Timerwert der Timerstand 

bei der ersten Flanke abgezogen. Das Ergebnis wird als Periodendauer gespeichert. 





tic1 equ $1010 ; Zaehlerstand 

tflg1 equ $1023 ; Timer Flag 

tctl2 equ $1021 ; Timer Control 

org data 

edge1 ds.b 2 ; Zaehler 

period ds.b 2 ; Clock Flag 


org prog 


ldab #$10 ; Flanke waehlen (fallend = 0, steigend = 1) 

stab tctl2 ; steigende Flanke an IC1 

loop ldab #$04 

stab tflg1 ; IC1F-Flag loeschen 

waitf1 ldab tflg1 ; auf erste Flanke warten 

andb #$04 

beq waitf1 

ldd tic1 ; akt. Zaehlerstand holen 

std edge1 ; und speichern 

ldab #$04 


waitf2 ldab tflg1 ; auf zweite Flanke warten 

andb #$04 

beq waitf2 


subd edge1 ; ersten Zaehlerstand abziehen 

std period ; Periodendauer abspeichern 

* 

* restlicher 

* Programmcode 

* 

bra loop 


fdb main 

Der Timer 121


Statt wie oben im Hauptprogramm auf die beiden Flanken zu warten, kann auch hier wieder 

eine Interrupt-Service-Routine die Aufgabe übernehmen. Das folgende Programm zur 

Periodendauermessung ersetzt das Polling durch Interruptsteuerung. Die ISR speichert beim 

ersten Auftreten einer steigenden Flanke den aktuellen Zählerstand in der Variablen edge1 

und dekrementiert edgecnt. Bei der zweiten Flanke wird nur edgecnt dekrementiert, der 

daraufhin 0 ist und dem Hauptprogramm signalisiert, dass nun die Periodendauer wie beim 

vorhergehenden Programm berechnet werden kann. 




tirqv equ $FFEE ; Adresse Interrupt-Vektor 


tic1 equ $1010 ; Zaehlerstand 

tmsk1 equ $1022 ; Timer Mask 


tctl2 equ $1021 ; Timer Control 

org data 

edgecnt ds.b 1 ; Flanken-Zaehler 

edge1 ds.b 2 ; Capture erste Flanke 

period ds.b 2 ; Clock Flag 

org prog 


ldab #$10 ; Init Timer 

stab tctl2 ; steigende Flanke an IC1F 

ldab #$04 


ldab #2 ; Flanken-Zaehler auf 2 setzen 

stab edgecnt 

ldab tmsk1 ; Interrupt freigeben 

orab #4 

stab tmsk1 

cli 

wait tst edgecnt ; warten, bis Flanken-Zahler = 0 

bne wait 


subd edge1 ; ersten Zaehlerstand abziehen 

std period ; Periodendauer abspeichern 

* 

* restlicher 

* Programmcode 

* 

bra wait 

* Interrupt-Service-Routine fuer Input Capture 

ic1_isr ldab #$04 


dec edgecnt ; Flanken-Zaehler dekrementieren 

beq skip ; falls zweite Flanke, nichts tun 

ldd tic1 ; sonst akt. Zaehlerstand holen 

std edge1 ; und speichern 

skip rti 

org tirqv ; Reset-Vektor setzen 

fdb ic1_isr 


fdb main 

Der Timer 122

• 


Durch einige Modifikationen kann dies Programmschema auch verwendet werden, um 

anstelle der Periodendauer die Breite eines Impulses zu messen. Es wird dann wie oben bei 

der (ersten) steigenden Flanke der Zählerwert gespeichert und danach der Port so 

umkonfiguriert, dass nun auf eine fallende Flanke gewartet wird: in tflg1 wird anstelle von 

$10 nun $20 geschrieben. So wird als zweites Ereignis die fallende Flanke registriert. 

Der einzige Nachteil der obigen Input Capture-Programme liegt darin, dass sich nur Zeiten 

erfassen lassen, die im 16-Bit-Bereich liegen, also nicht größer als 32,761 ms sind. Um 

längere Perioden zu messen, kann man beispielsweise das Timer-Overflow-Flag in tmask2 

berücksichtigen und bei jedem Timer-überlauf einen weiteren Zähler inkrementieren. Auf 

diese Art und Weise kann so der hardwaremäßige 16-Bit-Zähler softwareseitig auf 32 oder 

mehr Bits erweitert werden. 

Output Compare: Jedes der fünf Output-Compare-Register wird laufend mit dem 

Zählerstand des freilaufenden Zählers verglichen. Bei Übereinstimmung wird dann exakt in 

diesem Moment die programmierte Reaktion ausgelöst, zum Beispiel die Ausgabe eines 

bestimmten Signals an einem Port. Auf diese Weise ist es möglich, ein Ausgangssignal mit 

der Genauigkeit und Auflösung des Timer-Systems zu einem gewünschten Zeitpunkt zu 

erzeugen, ohne dabei Fehler durch Software-Reaktionszeiten oder auch Verzögerungen durch 

Interrupt-Antwortzeiten zu haben. 

Insgesamt sind fünf Output-Compare-Funktionen vorhanden, die jeweils ein 

16-Bit-Vergleichsregister besitzen. Der Registerinhalt wird ständig mit dem Zählerstand 

verglichen. Bei Übereinstimmung wird das vorprogrammierte Ereignis ausgelöst. Auch hier 

ist je ein Bit im TMSK1- und TFLG1-Register als Schnittstelle zum Anwenderprogramm 

vorgesehen. Das jeweiling OCxF-Bit wird gesetzt, wenn Register und Zähler übereinstimmen. 

Mit den zugehörigen OCxI-Bit kann der Interrupt gesperrt oder freigegeben werden. 

Für die Kanäle 2 bis 5 kann im TCTL1-Register festgelegt werden, was mit dem zugehörigen 

Pin beim Eintreten eines Ereignisses geschehen soll: 

OMx OLx Reaktion 

0 0 Keine 

0 1 Polarität ändern (toggle) 

1 0 auf 0 setzen 

1 1 auf 1 setzen 

Mit dem Output Compare Register 1 kann man alle OC-Pins gleichzeitig manipulieren. Der 

OC-Pn 1 hat dabei Priorität über die anderen. Der OC1-Funktion sind zwei spezielle Register 

zugeordnet, OC1M und OC1D. Die Bits 3 bis 7 dieser Register entsprechen direkt den 

Leitungen von Port A, auf denen die OC-Werte ausgegeben werden. Für jede Leitung von 

Port A, die durch die OC-Funktion beinflußt werden soll, muß das entsprechende Bit in 

OC1M auf 1 gesetzt werden. Das Bitmuster für die Ausgabe wird dann in OC1D eingetragen. 

Auf diese Weise lassen sich fünf Pins exakt zeitgleich mit einem einzigen 

Output-Compare-Register beeinflussen. 

Das folgende Programm zeigt eine typische Anwendung: es wird ein Rechtecksignal von 1 

kHz auf OC2 erzeugt, wobei ein Tastverhältnis von 40% eingestellt wird. Die verwendeten 

Werte gelten wieder für 2 MHz Taktfrequenz und einen Prescaler-Faktor von 1. Zu Beginn 

wird PA6 auf 1 gesetzt und danach der Toggle-Modus festgelegt. Für die Frequenz von 1 kHz 

muss bei 2 MHz Prozessortakt die Summe von Low- und Highzeit 2000 E-Takt-Zyklen 

betragen. Für das gewünschte Tastverhältnis muss demnach die Low-Zeit 1200 Zyklen und 

die High-Zeit 800 Zyklen lang sein. Andere Tastverhältnisse lassen sich durch Ändern dieser 

Werte leicht bestimmen. Dass beim Initialisierten dreimal hintereinander der Wert $40 

verwendet wird, ist Zufall - bei anderen Ports sind die Werte unterschiedlich. 



Der Timer 123



porta equ $1000 ; Adresse Port A 

toc2 equ $1018 ; Output Compare Register 

tctl1 equ $1020 ; OC Control Register 



* Programmkonstante 

lotime equ 1200 ; 600 Mikrosekunden 

hitime equ 800 ; 400 Mikrosekunden 

org data 


org prog 


ldaa #$40 ; OC2 auf high 

staa porta 

ldaa #$40 ; OC2F Flag loeschen 

staa tflg1 

ldaa #$40 ; toggle-Mode setzen 

staa tctl1 

; Rechteck startet mit high 

ldd tcnt ; Zaehlerstand laden 

addd #hitime ; high-delay addieren 

std toc2 ; im Vergleichsregister speichern 

high ldaa tflg1 ; Schleife bis Zeit erreicht ist 

anda #$40 

beq high 

ldaa #$40 ; OC2-Flag loeschen 

staa tflg1 

ldd toc2 ; naechster Zyklus mit low 

addd #lotime 

std toc2 

low ldaa tflg1 ; Schleife bis Zeit erreicht ist 

anda #$40 

beq low 

ldaa #$40 ; OC2-Flag loeschen 

ldd toc2 ; naechster Zyklus wieder mit high 

addd #hitime 

std toc2 

bra high 


fdb main 

Legt man anstelle des Toggle-Mode bei der Initialisierung fest, dass der PA-Ausgang nach 

dem Zeitablauf auf 0 gesetzt wird, erhält man beispielsweise einen Monoflop-Timer. 

Selbstverständlich lässt sich das obige Programm auch wieder so modifizieren, dass die ganze 

Sache interruptgesteuert abläuft. Die Interrupt-Serviceroutine wird jedesmal angesprungen, 

wenn die Zeit abgelaufen ist, und übernimmt das Eintragen der High- und Low-Zeiten. Damit 

haben Sie dann einen im Hintergrund ablaufenden Rechteckgenerator, dessen Tastverhältnis 

Sie jederzeit ändern können (indem Sie Vari-ablen anstelle der Konstanten verwenden) - also 

eine Pulsweiten-Modulation. 

Der OC1 nimmt eine Sonderstellung ein. Er kann über die Register OC1M und OC1D bis zu 

fünf OC-Pins steuern. OC1M legt fest, welche Pins von Port A beeinflusst wer-den und OC1D 

bestimmt, ob das entsprechende Bit auf 0 oder 1 gesetzt werden soll. übrigens ist der Pin PA7 

bidirektional. Soll er von OC1 gesteuert werden, muss er als Ausgang programmiert werden. 

Der Timer 124

Das folgende Programm zeigt, wie man mithilfe von OC1 und OC2 ein Rechtecksignal mit 

variablem Tastverhältnis erhält, das unabhängig vom Hauptprogramm im Hintergrund erzeugt 

wird. Im Initialisierungsteil wird festgelegt, dass OC2 bei Zeitgeberstand von 0 den Ausgang 

PA6 auf 1 setzt. OC1 wird zusätzlich so programmiert, dass beim Zeitgeberstand TV (6553) 

der Ausgang wieder auf 0 gesetzt wird. Nach Abschluß der Initialisierung laufen OC1 und 

OC2 synchron zur Zeitgeberperiode. 





porta equ $1000 ; Adresse Port A 

toc1 equ $1016 ; Output Compare Register 1 

toc2 equ $1018 ; Output Compare Register 2 

tctl1 equ $1020 ; OC Control Register 


tmsk2 equ $1024 ; Timer Mask Register 

oc1m equ $100c ; OC1M-Register 

oc1d equ $100d ; OC1D-Register 


TV equ 6553 ; Tastverhaeltnis (2^16 Zehntel) 

org data 

org prog 


ldaa #$03 ; Timer-Takt auf 8 Mikrosekunden 

staa tmsk2 ; --> 524,3 ms zwischen Ueberlaeufen 

ldaa #$C0 ; OC2 --> PA6 auf 1 setzen 

staa tctl1 

ldd #0 ; Zaehler auf Null 

std toc2 

ldaa #$40 ; OC1 --> PA6 auf 0 

staa oc1m ; Bit selektieren 

ldaa #$BF ; soll 0 werden 

staa oc1d 

ldd #TV ; Pulsdauer festlegen 

std toc1 

loop bra loop ; Hauptprogramm tut nicht 


fdb main 

Experimentieren Sie ruhig mit verschiedenen Werten für TV. Selbst im Simulator lassen sich 

Unterschiede erkennen. 

Pulse-Akkumulator 


Der Pulse-Akkumulator des 68HC1 ist ein 8-Bit-Zähler, der wahlweise als Ereigniszähler oder als 

Zeitzähler mit externer Gate-Funktion verwendet werden kann. Für beide Fälle wird der Anschluß 

Port A Bit 7 als Eingang für das externe Signal benutzt. Es sind zwei Möglichkeiten vorgesehen, einen 

Interrupt auszulösen: bei jeder aktiven Flanke dieses Eingangs oder bei Überlauf des Zählerstandes 

von $FF auf $00. 

Wird der Pulse-Akkumulator als Zeitzähler eingesetzt, dann verarbeitet er das durch 64 geteilte Signal 

des internen E-Takts. Die Auflösung beträgt damit bei einer Quarzfrequenz von 8 MHz exakt 32 

Mikrosekunden, die längste meßbare Periode somit 256 * 0,032 ms = 8,192 ms. Beim Einsatz als 

Ereigniszähler können maximal 256 Flanken gezählt werden, die zu verarbeitende Frequenz muß 

niedriger als der E-Takt des Mikroprozessors sein. Die für die Interruptauslösung des 

Der Timer 125

Pulse-Akkumulatorsystems zuständigen Konfigurations- und Flagbits sind zusammen mit anderen 

Funktionen im TMSK2- und TFLG2-Register untergebracht. Das PAOVF-Bit im TFLG2-Register 

wird immer dann gesetzt, wenn ein Überlauf des Zählers von $FF auf $00 eintritt. Durch Setzen des 

korrespondierenden Interrupt-Bits PAOVI im TMSK2-Register kann der Anwender bestimmen, ob 

durch dieses Ereignis ein Interrupt ausgelöst werden soll (0 = kein Interrupt). Der gleiche 

Mechanismus steuert mit den Bits PAIF und PAII einen möglichen Prozessor-Interrupt bei jeder 

aktiven Flanke am Eingang des Pulse-Akkumulators. 

• Damit das Pulse-Akkumulator-System überhaupt arbeiten kann, muß der externe Pin 7 von 

Port A als Eingang konfiguriert werden. Hierzu muß das Bit DDRA7 im PACTL-Register auf 

0 gesetzt werden. 

• Das Bit PAEN dieses Registers schaltet den Pulse-Akkumulator generell ein und aus, wobei 

der Zählerstand nach dem Ausschalten des Systems weiter erhalten bleibt und ausgewertet 

werden kann. 

• Das Bit PAMOD definiert die Betriebsart des Zählers: eine O macht ihn zum Ereigniszähler, 

eine 1 wählt die Zeitmessung. 

• PEDGE erlaubt die Wahl der aktiven Flanke. Eine 0 läßt den Zähler auf abfallende Flanken 

reagieren, in der Betriebsart Zeitzähler stoppt ein Low-Signal die Messung, eine 1 in PEDGE 

wählt die ansteigende Flanke und ein High-Signal als Sperre für die Betriebsart Zeitzähler. 

5.5 Geschützte Register 

(time protected control registers) 

Diese Register können nur während der ersten 64 Taktzyklen des E-Taktes nach einem RESET 

beschrieben werden. 

INIT bit 7-4: RAM3, RAM2, RAM1, RAM0 

position direct page at 4k-boundaries 

(default = 0000, RAM = $0000-$00FF) 

bit 3-0: REG3, REG2, REG1, REG0 

position Register block at 4k-boundaries 

(default = 0001, REG = $1000-$103F) 

TMSK2 bit 1-0: PR1, PR0 

prescaler of main timer 

(default = 00, ps = 1) 

OPTION bit 5: IRQE 

IRQ edge or level sensitive 

(default = 0, level sensitive) 

bit 4: DLY 

delay after coming out of STOP power saving mode 

(default = 1, wait 4000 cycles to stabilize crystal oscillator) 

bit 1-0: CR1, CR0 

COP timer rate on 2 15 base 

(default = 00, tr = 1) 


5.5 Geschützte Register 126

5.6 Interrupts 


Beim Daten-Verkehr zwischen Computer und der Außenwelt gibt es fast immer große und vor allem 

unregelmäßige Zeitabstände zwischen den Transfers. Zur Synchronisation dieser Ereignisse mit den 

Abläufen in einem Computer dienen Steuersignale der Peripherie, die zumindest als Status-Bits in 

einem Status-Register eines Peripheriebausteins erkennbar sind: im einfachsten Fall muss das 

Programm diese Status-Information regelmäßig abfragen, und zwar so häufig, dass kein Ereignis - 

auch bei maximaler Rate - "übersehen" wird. 

Dieser polling mode führt zu einer hohen Rechnerbelastung aufgrund von Abfragen, die auch fast 

immer negativ ausfallen. Alle modernen Mikroprozessoren besitzen deshalb Hardware- Mechanismen 

zur Programmunterbrechung durch solche Ereignisse. Das "Pollen" des Programms nach Ereignissen 

wird hier ersetzt durch einen von der Hardware (Ablaufsteuerung, Mikroprogramm) erzwungenen 

Unterprogrammsprung zu einem vorbereiteten Bearbeitungs-Programm, der sogenannten 

Interrupt-Service-Routine (ISR). 

Die ähnlichkeit des Interrupt mit einem Unterprogrammsprung (JSR) ist tatsächlich groß. Das 

Auftreten des Interrupt-Request-Signals auf dem Bus wird vom Mikroprogramm am Ende jedes 

Befehlszyklus geprüft und führt ggf. zu einem Sprung zum Beginn der ISR. (Genaugenommen ist das 

regelmäßige Abfragen nach externen Ereignissen nur ins Mikroprogramm der Ablaufsteuerung 

verlagert worden, jedoch mit sehr hoher Effizienz). 

Ein Interrupt kann - falls zugelassen - im Unterschied zu einem JSR prinzipiell nach jedem beliebigen 

Befehl des Programms wirksam werden, dementsprechend muss wie beim JSR der PC-Stand gerettet 

werden; auch das erledigt die Ablaufsteuerung bei der Annahme des Interrupt Request, genau wie 

beim JSR. Die Interrupt-Service-Routine wird mit einem ähnlichen Befehl wie ein Unterprogramm 

verlassen (RTI statt RTS), denn auch hier muss der Rücksprung wieder zur "Unterbrechungsstelle" 

zurückführen. 

Man unterscheidet beim 68HC11 Interrupts, die (extern!) von Hardwaresignalen ausgelöst werden 

(XIRQ, IRQ und RESET) und den internen Interruptquellen (interne Peripheriebausteine oder "illegal 

Operation"). Außerdem gibt es einem Befehl (SWI), der ebenfalls einen Interrupt auslöst. Ein weiteres 

Unterscheidungskriterium ist die Maskierbarkeit. Der normale Interrupt ist nur dann wirksam, wenn 

das entsprechende Maskenbit im CC-Register gelöscht ist (=0). Die Signale RESET und XIRQ sind 

nicht maskierbar, sie werden deshalb auch als "nicht maskierbare Interrupts" bezeichnet. 

Der XIRQ weist dabei noch eine Besonderheit auf: er ist nach einem RESET so lange gesperrt 

(maskiert), bis er durch Nullsetzen von Bit 6 im CC-Register zugelassen wird. Danach ist er nicht 

mehr sperrbar! 

Der 68HC11 verfügt über insgesamt 21 externe und interne Interruptquellen. Entsprechend komplex 

ist seine Interruptstruktur. Hier nochmals zur Erinnerung der Ablauf eines Interrupts: 

Nach einem Reset des Prozessors sind zunächst die beiden CC-Register-Flags X und I gesetzt und 

somit alle Interrupts gesperrt (= maskiert, disabled). Diese beiden Flags nennt man auch 

"Innensperren", denn mit ihnen kann im Prozessor verhindert werden, dass anstehende (pending) 

Interrupts tatsächlich den Programmablauf unterbrechen. 

5.6 Interrupts 127

Es ist wichtig, dass zunächst die Interrupts nicht zugelassen werden, denn erst wenn per Programm 

einige Vorbereitungen getroffen sind (Peripheriebausteine initialisieren, Stackpointer setzen, ) kann 

ein eintreffender Interrupt korrekt bedient werden. 

Die Interrupt-Sperren in den verschiedenen Peripherie-Bausteinen nennt man "Außensperren". Damit 

hat der Programmierer die Möglichkeit ganz gezielt Ereignisse sich entweder nur per Statusbit 

anzeigen zu lassen (polling mode) oder es sich per Interrupt melden zu lassen. 

Auslösen einer Unterbrechung 

Signal RESET Unbedinger Abbruch und Neustart 

Signal XIRQ und (X-Bit = 0) Unbedingte Unterbrechung (non maskable interrupt) 

Signal IRQ und (I-Bit = 0) 

Bedingte Unterbrechung (interrupt request) 

(kann auch interne Ursachen haben) 

Befehl SWI Befehlsgesteuerte Unterbrechung (software interrupt) 

Befehl Illegal Opcode Nicht implementierter Befehl 

Interrupt-Vektoren 


Die Interrupt Service Routine (ISR) kann an beliebiger Stelle im Speicher abgelegt werden. Beim 

Eintreffen des Interrupts muss die ISR aufgerufen werden. Die ISR-Startadresse muss daher im 

Speicher bereitgestellt werden (Aufgabe des Programmierers!). Die Adressen des 

16-Bit-Speicherworts, in dem die Adressen der ISR abgelegt werden, liegen hardwaremäßig fest. Für 

jeden der verschiedenen Interrupts gibt es ein fest zugeordnetes Speicherwort (Interrupt-Vektor): 

Auslösen einer Unterbrechung 128


Priorität Name Adresse Interrupt-Quelle 

21 SCIINT $FFD6 SCI serial system 

20 SPIINT $FFD8 SPI serial system 

19 PAIINT $FFDA Pulse Accumulator Input Edge 

18 PAOVINT $FFDC Pulse Accumulator Overflow 

17 TOINT $FFDE Timer Overflow 

16 TOC5INT $FFE0 Timer Output Compare 5 





11 TIC3INT $FFEA Timer Input Capture 3 

10 TIC2INT $FFEC Timer Input Capture 2 

9 TIC1INT $FFEE Timer Input Capture 1 

8 RTIINT $FFF0 Real Time Interrupt 

7 IRQINT $FFF2 IRQ External Interrupt 

6 XIRQINT $FFF4 XIRQ External Interrupt 

5 SWIINT $FFF6 Software Interrupt 

4 BADOPINT $FFF8 Illegal Opcode Trap Interrupt 

3 NOCOPINT $FFFA COP Failure (Reset) 

2 CMEINT $FFFC COP Clock Monitor Fail (Reset) 

1 RESETINT $FFFE RESET Interrupt 

Die nicht maskierbaren Interrupts wie RESET, CMF, COP, XIRQ, Ill. Opcode oder SWI haben eine 

feste Priorität. Bei den anderen Interrupts läßt sich die Priorität ändern. Die vier Bits PSEL0 bis 

PSEL3 im HPRIO-Register legen fest, welche Interruptquelle die höchste Priorität besitzen soll. 



PSEL3 PSEL2 PSEL1 PSEL0 Interrupt-Quelle 

0 0 0 0 Timer Overflow 

0 0 0 1 Pulse Accumulator Overflow 

0 0 1 0 Pulse Accumulator Input Edge 

0 0 1 1 SPI serial system 

0 1 0 0 SCI serial system 

0 1 0 1 Reserve 

0 1 1 0 IRQ External Interrupt 

0 1 1 1 Real Time Interrupt 

1 0 0 0 Timer Input Capture 1 



1 0 1 1 Timer Output Compare 1 





Eine besonders wichtige Rolle in jedem Mikroprozessorsystem spielen die nicht maskierbaren 

Interrupts. Sie sind speziell für das Auslösen lebenswichtiger Funktionen vorgesehen, wie zum 

Beispiel zur Erkennung eines Versorgungsspannungsausfalls. Da der Mikroprozessor 68HC11 über 

die Möglichkeit verfügt, seine interne Organisation zu modifizieren, ist für den externen nicht 

maskierbaren Interrupt XIRQ ein spezielles Bit im Condition-Code-Regisier vorgesehen, mit dem 

dieser direkt nach einem Reset-Vorgang maskiert wird. Dies ist kein Widerspruch, denn wenn das 

Anwenderprogramm die interne Organisation (Speicheraufteilung, Festlegung des Registerblocks, 

Initialisierung des Stackpointers) durchgeführt hat, kann dieses Bit nur ein einziges Mal auf 0 gesetzt 

werden. Ein erneutes Maskieren des XIRQ ist danach nicht mehr möglich, so daß man von diesem 

Zeitpunkt an von einem echten nicht maskierbaren Interrupt sprechen kann. 

Während der Organisationsphase ist es in jedem Fall zwingend notwendig, keinen Interrupt 

zuzulassen, denn ein während dieses Zeitraumes aufgerufenes Interrupt-Programm würde auf 

Resourcen zurückgreifen wollen, die unter Umständen noch nicht verfügbar sind. 

Eine zweite nicht maskierbare Interrupt-Quelle ist eine Erkennungsschaltung für illegale Befehlscodes 

(Illegal Opcode Trap). Da nicht alle möglichen Bitkombinationen mit gültigen Befehlen besetzt sind, 

besteht die Möglichkeit, daß die CPU durch einen Fehler im Programm oder durch einen Störimpuls 

von außen einen ungültigen Befehl bekommt. In einem solchen Fall wird ein spezieller Interruptvektor 

angesprungen, der auf eine Fehlerbehandlungsroutine zeigen sollte. Wird dieser Vektor nicht vom 

Anwender initialisiert, dann kann es passieren, daß er auf einen weiteren ungültigen Befehl zeigt und 

die CPU damit in eine Endlosschleife gerät. 

Eine ähnliche Funktion hat der Softwareinterrupt SWI, der häufig während der Test- und 

Emulationsphase eines Programms benutzt wird. Er stellt einen normalen gültigen Befehl der CPU 

dar. Der Software-Interrupt wird in erster Linie von Emulations-Systemen zur Manipulation des 

Zielprozessors benutzt. Man kann ihn aber auch für Sytemaufrufe verwenden, wenn im 68HC11 ein 

Mini-Betriebssystem implementiert wird. 

Alle weiteren Interrupt-Quellen des 68HC11 können durch das 1-Bit im Condition-Code-Register 

maskiert werden. Wenn dieses Bit gesetzt ist, sind alle diese Interrupt-Quellen gesperrt. Jeder 


Reset-Vorgang setzt dieses Bit. Es ist Aufgabe des Anwenderprogramms, den Interrupt nach 

sinnvoller Initialisierung des Systems gezielt freizugeben. 

Jeder Eintritt in ein Interruptprogramm setzt das I-Bit, um eine weitere Unterbrechung durch einen 

neuen Interrupt zu verhindern. Nach Beendigung des Interruptprogramms durch einen RTI-Befehl 

wird es automatisch wieder gelöscht, so daß erneute Interrupts wieder zugelassen sind. 

Zur Erweiterung der Interrupt-Struktur steht der Eingang IRQ zur Verfügung. Hier können beliebig 

viele externe Interrupt-Quellen angeschlossen werden. Zu diesem Zweck ist dieser Pin nach einem 

Reset auf Pegelabhängigkeit geschaltet ( Möglichkeit des "wired or" mehrerer Interruptquellen), um 

mit externen Peripherie-ICs kompatibel zu sein. Die Konfiguration als flankenempfindlicher Eingang 

wird seltener angewendet, da sie nur mit einer einzigen externen Interrupt-Quelle zusammenarbeiten 

kann. 

Zusammenfassung der notwendigen Voraussetzungen zum Arbeiten mit Interrupts: 

1. Der IRQ-Ausgang eines externen Peripheriebausteins muß mit einem der 

Prozessor-Interrupt-Eingänge verbunden sein: IRQ, XIRQ, RESET (Hardware-Design). 

Interne Peripheriekomponenten sind natürlich schon verbunden. 

2. Der Stackpointer muß per LDS-Befehl gesetzt worden sein, damit die Register beim Interrupt 

in den beabsichtigten Stackbereich gerettet werden. 

3. Die Interrupt-Service-Routine muß programmiert sein. 

a. gegebenenfalls muß der Interrupt-Verursacher identifiziert werden, falls mehrere per 

"wired or" zusammengeschlossen sind. 

b. das IRQ-FF beim Interrupt-Verursacher muß darin gelöscht werden 

4. Die Startadresse der ISR muß in den entsprechenden Vektorzellen stehen. Initialsierung 

beispielsweise: 

5. 

6. 


ORG $FFFE 

DC.W main 

Im Peripheriebaustein-Kontrollregister "interrupt enable" setzen (= Außensperre öffnen). 

im Prozessor (CC-Register) den entsprechenden Interrupt zulassen (= Innensperre öffnen). 

Im Praktikum geht es vor allem um die Aktionen 3, 4, 5, und 6. 

Beispiel 1: Bedingte Unterbrechung am Eingang PA7 

Am Eingang PA7 (Pulse Akku) ist ein Taster angeschlossen, mit dem eine bedingte Unterbrechung 

ausgelöst werden kann. Das Auftreten des Interrupts soll über eine Variable PFLAG signalisiert 

werden, die auch über Port C ausgegeben wird. 

Alle auszuführenden Schritte werden im Folgenden ausführlich beschrieben: 

• Setzen der Eigenschaften für PA7 im PACTL-Register: 

1. PA7 muss als Eingang konfiguriert werden. Die entsprechende Konfiguration findet 

per DDRA-Bit im Register PACTL statt: es muss auf 0 gesetzt werden. 

2. Eine Interrupt-Auslösung durch PA7 ist nur möglich, wenn sich der Port A im 

Betriebsmodus "Puls Accu Enable" befindet. Dazu muss im Register PACTL das Bit 

PAEN auf 1 gesetzt werden. 

3. Im Pulse-Accu-Betrieb muss noch unterschieden werden zwischen "Event Counting"- 


und "Gated Time"- Mode. Da jedes Ereignis einen Interrupt auslösen soll, ist der 

"Event Counting Mode" zu wählen. Dazu muss im Register PACTL das Bit PAMOD 

auf 0 gesetzt werden (PAMOD = 0 -> "Event Counting Mode"). 

4. Die steigende Impulsflanke wird durch Bit PEDGE im Register PACTL bestimmt: 

"Rising Edge" wird durch eine 1 gewählt. 

• Die ausgewählte Flanke am PA7-Pin führt somit zu einem Setzen des Statusbits PAIF im 

Register TFLG2. Somit könnte die Flanke auch an diesem gesetzten Bit durch Lesen des 

TFLG2-Registers erkannt werden ( regelmäßiges Auslesen = Polling Mode). Es soll jedoch 

per Interrupt gemeldet werden, deshalb muss noch der zugehörige Interrupt zugelassen 

werden. Erreicht wird dies durch Setzen des Bits PAII im Register TMSK2. 

• Schließlich ist noch eine Interrupt-Service Routine (ISR) nötig, die beim Auftreten des 

Interrupts die gewünschten Aktionen vornimmt (z. B. Lampe einschalten durch Ausgabe eines 

Bits an einem anderen Port). Unbedingt notwendig ist darin das Löschen des PAIF-Bits im 

Register TFLG2, denn sonst würden ständig weitere Interrupts ausgelöst! Löschen dieses Bits 

geschieht durch Schreiben einer 1 ins Bit PAIF! 

• Die Startadresse dieser ISR muss im zugehörigen Vektor abgelegt werden, damit beim 

Interrupt der Programcounter mit dieser Adresse geladen werden kann. 

• Zuletzt (als letzte Aktion der Initialisierung) muss der Interrupt ganz allgemein zugelassen 

werden. Dies erledigt der CLI-Befehl. 

Hier nun das vollständige Programm dazu: 

data equ $2000 Datenbereich 

prog equ $8000 Programmbereich 

stack equ $7FFF Stackbereich 

pirqv equ $FFDA Adresse PA-Vektor 

resetv equ $FFFE Adresse Reset-Vektor 

padr equ $1000 Adresse Port A 

pcdd equ $1007 Adressen Port C 


pacr equ $1026 Pulse Akku Control 

tflag equ $1025 Timer Flag 

tmask equ $1024 Timer Mask 

org data 

pflag ds.b 1 

org prog 

main lds #stack Init Stack 

clr pflag Init Flag 

ldab #$FF Port C auf Ausgang 

stab pcdd 

ldab #$40 Init Interrupt 

stab pacr Pulse Akku enable 

ldab #$10 

stab tmask PA7 enable 

cli Interrupt freigeben 

loop ldab pflag Ausgabeschleife 

stab pcdr 

bra loop 


pirq ldaa #$10 Interrupt Service Routine 

staa tflg 

com pflag toggle 0 - FF 0 - FF - ... 

rti 

org pirqv Interrupt-Vektor setzen 

dc.w pirq 


org resetv Reset-Vektor setzen 

dc.w main 

Beispiel 2: Bedingte Unterbrechung am Eingang STRA 

Am Eingang STRA ist ein Taster angeschlossen, mit dem eine bedingte Unterbrechung ausgelöst 

werden kann. Das Auftreten des Interrupts soll über eine Variable TFLAG signalisiert werden, die 

auch über Port C ausgegeben wird. Das Verfahren für STRA ist nahezu identisch mit dem oben 

beschriebenen. 

• Setzen der Eigenschaften für STRA-Interrupt: Das Bit STAI in PIOC muss auf 1 gesetzt 

werden. Eine Flanke am STRA-Pin führt dann zu einem Auslösen des Interrupts und Setzen 

des STAF-Bits in PIOC. 

• Weiter ist noch eine Interrupt-Service Routine (ISR) nötig, die beim Auftreten des Interrupts 

die gewünschten Aktionen vornimmt. Unbedingt notwendig ist darin das Löschen des 

STAF-Bits im Register PIOC, denn sonst würden weitere Interrupts nicht erkannt! Löschen 

dieses Bits geschieht durch Lesen von PIOC und danach Lesen von PORTCL! 

• Die Startadresse dieser ISR muss im zugehörigen Vektor abgelegt werden, damit beim 

Interrupt der Programcounter mit dieser Adresse geladen werden kann. 

• Zuletzt (als letzte Aktion der Initialisierung) muss der Interrupt ganz allgemein zugelassen 

werden. Dies erledigt der CLI-Befehl. 




irqv equ $FFF2 Adresse IRQ-Vektor 


pioc equ $1002 Adressen Port C 

portcl equ $1005 



org data 

tflag ds.b 1 


org prog 


clr tflag Init Flag 


stab pcdd 


stab pioc STRA enable 


loop ldab tflag Ausgabeschleife 

stab pcdr 

bra loop 

sirq ldaa pioc Interrupt Service Routine 

ldaa portcl 

com tflag toggle 0 - FF 0 - FF - ... 

rti 

org irqv Interrupt-Vektor setzen 

dc.w sirq 


dc.w main 


Beispiel 3: Timer-Unterbrechung 

Ein Binärzähler soll mit einer Frequenz von ca. 10 Hz betrieben werden. Seine aktuelle 

Stellung ist an Port C auszugeben. Als Taktquelle ist die bei Timerüberlauf auftretende 

Unterbrechung (Timer Overflow Interrupt) des freilaufenden 16-Bit-Zählers des 68HC11 zu 

verwenden. Da der Interrupt alle 32,77 ms auftritt, muss noch ein zusätzlicher 

Modulo-3-Zähler verwendet werden, um auf annähernd 100 ms zu kommen (genauer: 3 * 

32,77 ms = 98,31 ms). 




tirqv equ $FFDE Adresse TOF-Vektor 


padr equ $1000 Adresse Port A 

pcdd equ $1007 Adressen Port C 


pacr equ $1026 Pulse Akku Control 

tflag equ $1025 Timer Flag 

tmask equ $1024 Timer Mask 

org data 

count ds.b 1 Zaehler 

cflag ds.b 1 Clock Flag 


org prog 


clr count Init Flag 


stab pcdd 


stab tmask TOF-Interrupt enable 

ldab #$40 

stab pacr 


loop ldab cflag Ausgabeschleife 

cmpb #3 Trigger-Zeitpunkt? 

bne loop Nein 

clr cflag Gotcha! 

inc count Zaehler erhoehen 

ldab count ...und ausgeben 

stab pcdr 

bra loop 

tirq ldaa #$80 Interrupt Service Routine 

staa tflg 

inc cflag 

rti 

org tirqv Interrupt-Vektor setzen 

dc.w tirq 


dc.w main 

Bei der Einstellung der Parameter für den Timer werden ebenso wie beim PA7-Interrupt die 

Register TMASK und TFLAG verwendet. Werden beide Interrupts kombiniert, muss man 

darauf achten, die entsprechenden Bits für beide gemeinsam zu setzen. Das folgende 

Programm zeigt die Kombination aller drei Interrupts: Der Timer steuert einen Zähler, der auf 


Port B ausgegeben wird. Der STRA-Interrupt wechselt zwischen Auf- und Abwärtszähler und 

der PA7-Interrupt startet oder stoppt den Zähler. 

data equ $2000 ; data area (e-ram) 

stak equ $7FFF ; stack area (e-ram) 

prog equ $8000 ; programm area (e-eerom) 

pvec equ $FFDA ; vector pa7 

tvec equ $FFDE ; vector timer 

svec equ $FFF2 ; sirq vector 

rvec equ $FFFE ; reset vector 

pioc equ $1002 ; parallel i/o control 

pbdr equ $1004 ; port b data 

pcdl equ $1005 ; port c data latch 

tmsk equ $1024 ; timer mask 

tflg equ $1025 ; timer flag 

pacr equ $1026 ; pulse accu control 

baud equ $102B ; SCI-baudrate 

sccr1 equ $102C ; SCI-control1 

sccr2 equ $102D ; SCI-control2 

scsr equ $102E ; SCI-status 

scdr equ $102F ; SCI-data 

*************************** 

* data area * 

*************************** 

org data 

coun ds.b 1 ; counter 

cflg ds.b 1 ; clock flag 

updn ds.b 1 ; direction flag 

stop ds.b 1 ; stop flag 

*************************** 

* program area * 

*************************** 

org prog 

main lds #stak ; load stackpointer 

bsr init ; data init 

cli ; enable irq 

loop ldaa cflg ; get clock flag 

cmpa #20 ; trigger point? 

bne loop ; no, wait 

clr cflg ; yes, clear clock flag 

tst stop ; stop active? 

bne loop ; yes, wait 

bsr count ; update counter 

bra loop ; close main loop 

*************************** 

* subroutines * 

*************************** 


count ldaa coun ; load counter 

adda updn ; inc/dec counter 

staa coun ; save counter 

staa pbdr ; display counter 

rts 

init clr coun ; counter default 


clr cflg ; no clock seen 

clr stop 

ldaa #1 

staa updn ; default count up 

ldab #$40 ; enable STRA interrupt 

stab pioc 

ldab #$40 ; enable PA7 interrupt 

stab pacr ; enable pulse accu 

ldab #$90 ; $80 (Timer) + $10 (PA7) 

stab tmsk 

rts 

*************************** 

* interrupt handler * 

*************************** 

tirq ldaa #$80 

staa tflg ; clear interrupt 

inc cflg ; count interrupts 

rti 

sirq ldaa pioc 

ldaa pcdl ; clear interrupt 

neg updn ; toggle direction 

rti 

pirq ldaa #$10 


com stop ; toggle stop flag 

rti 

*************************** 

* vectors * 

*************************** 

org pvec 

fdb pirq ; PA7 interrupt 

org tvec 

fdb tirq ; DE timer overflow 

org svec 

fdb sirq ; STRA 

org rvec 

fdb main ; FE reset 

end 

Beispiel 4: XIRQ und STOP 

Der nichtmaskierbare Interrupt XIRQ muss beim Programmstart einmal freigegeben werden 

und läßt sich dann nicht mehr zurücksetzen. Das folgende Beispiel hat die kürzeste aller 

möglichen Interrupt-Serviceroutinen für den XIRQ, nämlich nur ein "rti". Natürlich kann man 

hier auch beliebigen Code unterbringen. Insofern bietet der XIRQ eigentlich nichts Neues. 

Zusammen mit dem STOP-Befehl wird es aber interessant. Zur Erinnerung: Der STOP-Befehl 

stoppt den Takt und schaltet die CPU in den Standbymodus. Ein Aufwecken ist nur per XIRQ 

oder IRQ möglich. Im folgenden Programm steht der STOP-Befehl in der Zählschleife, so 

dass bei jedem XIRQ um 1 weitergezählt wird und dann die CPU wieder schlafen geht. 

data equ $2000 ; data area 



stak equ $7FFF ; stack area 

prog equ $8000 ; program area 

xvec equ $FFF4 ; xirq vector 


portb equ $1004 ; port b data 

portc equ $1003 ; port c data 

pcdd equ $1007 ; port c data direction 

org data 


org prog 


clr coun 

tpa ; enable xirq, stop 

anda #%00111111 

tap 

loop stop ; go to sleep 

inc coun ; count up 

ldab coun 

stab portb ; display 

bra loop 

; xirq isr 

xirq rti 

org xvec 

fdb xirq 

org rvec 

fdb main 

end 

Zum vorhergehenden 

Abschnitt Zum Inhaltsverzeichnis 


Letzte Aktualisierung: 06. Mai 2012 


Zum nächsten 

Abschnitt 




6 Ausblick: andere Controller 

6.1 Atmel-Mikrocontroller 

Die Atmel AVR ist eine 8-Bit-Mikrocontroller-Familie des US-amerikanischen Herstellers Atmel. Die 

Controller dieser Familie sind wegen ihres einfachen Aufbaus und ihrer leichten Programmierbarkeit 

auch bei Hobby-Anwendern weit verbreitet. Die Typen unterteilen sich in die Gruppen 

• ATmega: "große" AVR-Controller mit bis zu 256 KB Flash-Speicher in 28- bis 100-poligen 

Gehäusen und mit integriertem Hardware-Multiplizierer. 

• ATtiny: kleinere AVR-Controller mit bis zu 16 KB Flash-Speicher in 6- bis 20-poligen 

Gehäusen. 

• AT90USB: ATmega mit integriertem USB-Controller 

• AT90CAN: ATmega mit CAN-Controller 

• Sondertypen: einige Spezialmodelle, z. B. zur Ansteuerung von Akku-Ladegeräten, Displays 

und für Steuerungen 

• AT90S: veraltete Typen, die "klassischen" AVRs 

Beispiel: Blockschaltung des ATTtiny 

6 Ausblick: andere Controller 138


Die Atmel-Prozessoren besitzen eine RISC-Architektur und zeichen sich unter anderem durch eine 

relativ große Zahl von Universalregistern aus. Normalerweise wir ein Befehl in einem Taktzyklus 

ausgeführt. Je nach Typ besitzen sie 

• 32 größtenteils gleichwertige Register, davon lassen sich drei als Pointerregister 

(Indexregister) verwenden 

• ca. 70 bis 110 Befehle, die meist nur ein bis zwei Taktzyklen dauern 

• Taktfrequenz bis 20 MHz (intern erzeugt, extern oder mit Quarz) 

• Betriebsspannung von 1,8 bis 5,5 V 

• Speicher: 1 - 256 KByte Flash-ROM als Programmspeicher, 0 - 4 KByte EEPROM, 0 - 8 

KByte RAM 

• Peripherie: A/D-Wandler, 8- und 16-Bit-Timer mit PWM, SPI, I2C (TWI), UART, 

Analog-Komparator, Watchdog, externer SRAM 

• JTAG bei den größeren ATmegas, debugWire bei den neueren AVRs 

• Konfigurationswort (Wahl der Taktquelle usw.) 

Beispiel: Pins des ATtiny 

Beispiel: Pins des ATMega8 

Um einen AVR-Prozessor zu betreiben ist eigentlich nur die Stromversorgung nötig. Der Chip wird 

mit einer stabilen Versorgungsspannung (2,7 bis 5 Volt, je nach AVR und Taktfrequenz) versorgt und 

erhält den üblichen Stützkondensator (100 nF), der möglichst nahe am AVR angebracht wird. 

Weiterhin ist ein Pull-Up-Widerstand für den Resetpin nötig (man könnte ihn weglassen, aber dadurch 

würde der Reset-Eingang sehr anfällig für Störungen. Bei den AVR Typen mit 

Analog-Digital-Wandler muss man die Pins AVCC und AGND anschließen (auch wenn die 

Analog-Schnittstelle nicht verwendet wird), da es sonst zu Fehlfunktionen der entsprechenden Ports 

kommen kann. AREF und AVCC werden an die Versorgungsspannung geklemmt, AGND an Masse. 

Im Normalfall reicht der interne Oszillator für den Betrieb des AVR aus, lediglich wenn man eine 

höhere Taktfrequenz als 8 MHz oder eine größere Genauigkeit benötigt, muss ein Quarz 

angeschlossen werden. Die maximale Quarzfrequenz hängt auch von der Höhe der 

Versorgungsspannung ab. 

Beispiel: Blockschaltung des ATTtiny 139


Die Harvard-/RISC-Architektur führt auch zu einer Speicheraufteilung, die sich vom bisher 

behandelten 68HC11 unterscheidet. Die ersten 32 Bytes des Speichers werden von den "General 

Purpose Working Registers" (GPWR) belegt. Der darauf folgende 64 Byte lange Speicherbereich 

enthält die Konfiguration der Peripherie und die "General Purpose Input Output Register" 

(GPIO-Register), was den Portadressen beim 68HC11 entspricht. Ab Adresse 0X0060 beginnt dann 

der eigentliche Arbeitsspeicher. 

Die Programmierung erfolgt in Assembler und C. Außerdem gibt es einen Basic-Dalekt (Bascom). 

Der Assembler kennt bis zu 120 Instruktionen (Rechnen, Sprünge, Bitmanipulation, Datentransfer, 

Kontroll-Funktionen). 

Die Prozessoren besitzen ein serielles Programmierinterface, wodurch die Programmierung in der 

Schaltung möglich ist (ISP, In System Programming). Verwendet werden drei Ports (z. B. PB0, PB1 

und PB2) sowie der Reset-Pin. Diese Ports und die zwei Betriebsspannungsanschlüsse wechseln beim 

Programmieren automatisch ihre Funktion und Richtung. Bei etlichen Type besteht die Wahl 

zwischen zwei Programmiermodi möglich (bei 12V am Reset-Eingang sind besondere Einstellungen 

zugänglich). 

Beim seriellen Programmieren werden die Programmbits nacheinander, gesteuert durch einen von 

außen angelegten Takt am Pin SCK, über den Pin MOSI in ein internes Schiebregister eingeschoben 

und von dort in den Flash-Speicher kopiert. Das Beobachten des Programmiervorgangs, ebenso das 

Verifizieren bzw. Lesen des Flash-Speichers erfolgt über den Datenausgang MISO. Beim 

Programmieren werden also drei Signalleitungen benötigt: der Takt SCK, die Eingabedaten MOSI und 

die Ausgabedaten MISO. Wie oben erwähnt, werden für die Programmierung drei Standard-Ports 

verwendet. Man kann also das Programmieren in der Anwender-Schaltung durchführen. Allerdings ist 

dabei zu beachten, dass die dafür drei benötigten Pins entweder 

• nur für diesen Zweck reserviert werden, 

• andernfalls die Beschaltung der Pins in Richtung Peripherie über Widerstände von mindestens 

1 Kiloohm erfolgt (Bild unten, linke Seite), oder 

• die Programmierports über eine Multiplexschaltung nur bei aktivem Reset mit dem 

Programmiersignal verbunden werden (Bild unten, rechte Seite). 

Die Atmel Controller besitzen zudem einen reservierten Speicherbereich in welchen ein eigener 

Bootloader geladen werden kann, der dann automatisch bei einem RESET des Controllers ausgeführt 

wird. Der Bootloader kann über die Konfigurationsbits des Controllers (Fusebits) eingestellt werden. 

Mit den beiden Fusebits BOOTSZ0 und BOOTSZ1 (für Bootsize) kann die Grösse des 

Bootloaderspeichers eingestellt werden und das Fusebit BOOTRST aktivoert die Bootladefunktion. 

Dementsprechend ändert sich auch der Startpunkt nach einem Reset. Um den Bootloader (und auch 

den Programmspeicher) vor ungewolltem Überschreiben zu schützen, sind vier Bootloader Lockbits 

(BLB) vorgesehen, die jeweils einen Speicherbereiche mit einem Schreib-/Leseschutz versehen. Diese 



Lockbits verhindern aber nicht das Auslesen oder Beschreiben über die ISP-Schnittstelle. Mittels 

Bootloader kann der AVR-Prozessor beispielsweise auch Programme über eine serielle Schnittstelle 

laden (fast wie beim 68HC11). 

Die Bedeutung der einzelnen Pins erschließt sich vollständig nur durch das Studium des Datenbuchs. 

An dieser Stelle soll jedoch eine kurze Zusammenfassung versucht werden. Dabei wird nur auf Pins 

mit speziellen Eigenschaften eingegangen, normale Ein- und Ausgänge werden nicht erwähnt. VCC, 

GND, AVCC und AREF dienen der Spannungsversorgung von Digital- und Analogteil des 

Controllers. Das Programmierinterface wird durch die Pins RESET, SS, MOSI, MISO und SCK 

gebildet. Diese Pins verbindet man mit dem Computer um ein Programm in den Controller zu laden. 

RXD und TXD betreffen die serielle Schnittstelle (USART). Die XTAL-Pins erlauben den Anschluss 

eines externen Quarzes oder sonstigen Taktgene-rators. Mit den OC-Pins kann ein 

pulsweitenmoduliertes Signal erzeugt werden. So kann man mit einem digitalen Pin analoge Signale 

erzeugen, indem ein Siebglied nachgeschaltet wird. Die ADC-Pins stellen die Eingänge des 

Analog-Digital-Wandlers dar. 

Beispiel ATtiny13, einer der kleinsten AVR-Prozessor 

• Zentraleinheit mit 32 Arbeitsregistern zu je 8 Bits, R0..R31, intern ca. 9 MHz Takt 

• Speicher: 512 Worte Programmspeicher (Flash), 64 Byte EEPROM, 64 Byte RAM 

• ein 8-Bit-Timer/Zähler, der Timer wird vom Taktoszillator über Vorteiler (durch 

1/8/64/256/1024) getaktet, im Zählermoduls erfolgt die Taktung durch ansteigende oder 

abfallende Signale am T0-Pin. 

• max. 6 Ein-/Ausgabe-Pins (I/O-Pins), deren Richtung als Ein- oder Ausgang programmierbar 

ist. Bei Eingängen sind Pull-Up-Widerstände zuschaltbar. Auslösung von Interrupts bei 

Eingang INT0 (PB1) programmierbar oder bei Pegelwechsel bei allen Pins wählbar, mit 

Maskierung der auslösenden Pins. Weiterhin enthält er einen zuschaltbarer Analogvergleich 

an den Pins AIN0 und AIN1 (PB0 und PB1) (Interrupt bei Wechsel). 

• Vier-Kanal AD-Wandler mit 10 Bit Auflösung. Interne Spannungsreferenz 1,1 V oder 

Betriebsspannung als Spannungsreferenz. 

Als Programmierbeispiel sollen hier die aus dem 68HC11-Praktikum bekannten Zeitschleifen dienen. 

Eine Zeitschleife mit einem 8-Bit-Register sieht in Assembler folgendermaßen aus: 

.equ c1 = 200 ; Anzahl Schleifendurchlaeufe 

ldi R16,c1 ; 1 Takt 

Loop: ; Schleifenbeginn 

nop ; 1 Takt 

nop ; 1 Takt 

dec R16 ; 1 Takt 

brne Loop ; 2 Takte wenn nicht Null, 1 Takt bei Null 

Man sieht auch, dass bei einer RISC-Architektur in der Regel jeder Befehl nur einen Takt lang dauert. 

Wenn's länger dauern soll, nimmt man eine Zeitschleife mit einem 16-Bit-Doppelregister: 

.equ c1 = 0 ; laengste Dauer 2^16 Durchlaeufe 

ldi R25,HIGH(c1) ; R25 laden, 1 Takt 

ldi R24,LOW(c1) ; 1 Takt 

Loop: ; Schleifenbeginn 

nop ; 1 Takt 

nop ; 1 Takt 

sbiw R24 ; 16-Bit-Dekrement, 2 Takte 

brne Loop ; 2 Takte wenn nicht Null, 1 Takt bei Null 

Damit sind wir beim beliebten "Hello World" für kleine Controller: Die im Sekundenrhytmus 

blinkenden LED an einem Port: 

.inc "tn13def.inc" ; Definitionen fuer einen ATtiny13 


.equ c1 = 60000 ; Bestimmt die Blinkfrequenz 

sbi DDRB,0 ; Portbit als Ausgang programmieren 

Loop: 

sbi PORTB,0 ; Portbit auf high 

rcall Delay ; UP-Aufruf 

cbi PORTB,0 ; Portbit auf low 

rcall Delay ; UP-Aufruf 

rjmp Loop 

Delay: ; Unterprogramm fuer Warteschleife 

ldi R25,HIGH(c1) ; wie oben gezeigt 

ldi R24,LOW(c1) 

Delay1: 

nop 

nop 

nop 

nop 

nop 

sbiw R24,1 

brne Delay1 

Von Atmel selbst wird eine komplette Entwicklungsplattform angeboten (Assembler, Simulator usw.), 

die man von der Atmel-Webseite herunterladen kann. Zusätzlich existiert eine komplette 

C-Entwicklungsplattform auf der Basis des GNU-Compilers (Open Source). Näheres dazu liefert der 

Link zu "tuxgraphics.org" unten. Des weiteren wird noch ein Compiler für einen Basic-Dialekt 

namens BASCOM-AVR angeboten, der aber nicht kostenlos ist. 

Für Einsteiger in den Bereich der Mikrocontroller und Elektronik ist besonders das Arduino-Projekt 

interessant, das eine günstige Entwicklungsplattform zur Verfügung stellt. Die Hardware-Seite besteht 

aus verschiedenen einfachen Controllermodulen, die über USB (Emulation einer seriellen 

Schnittstelle) mit dem PC kommunizieren. Die Softwareentwicklung erfolgt in einer integrierten 

Open-Source-Entwicklungumgebung, die bereits viele Bibliotheken für die Ansteuerung der Hardware 

mitbringt. Außerdem gibt es eine große Community, die dieses System einsetzt und unterstützt. 

Literatur 

Atmel-Webseite 

Günter Schmitt: Mikrocomputertechnik mit Controllern der Atmel-AVR-RISC-Familie, Oldenbourg 

Verlag 

Claus Kühnel: Programmieren der AVR-RISC-Mikrocontroller mit BASCOM-AVR, Skript Verlag 

Kühnel 

Weiterführende Links 


http://www.atmel.com/products/avr/ 

http://shop.avr-praxis.de/index.html 

http://tuxgraphics.org/electronics/200904/avr-c-programming.shtml 

http://imakeprojects.com/Projects/avr-tutorial/ 

/http://www.avr-projekte.de/ 

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial 

http://www.mcselec.com (Bascom und Demo) 

6.2 PIC-Microcontroller von Microchip 

Von Microchip werden inzwischen mehr als 400 unterschiedliche Flash-Controller angeboten, die im 

Baukastensystem aus einem Prozessorkern, Speicher und einigen Peripheriemodulen 

zusammengesetzt sind. Anhand des Prozessorkerns kann man fünf Familien unterscheiden: 


• Controller mit 12-Bit-Kernel (PIC10Fxxx, PIC1xF50x) - Minmalsysteme, 

• Controller mit 14-Bit-Kernel (PIC16Fxxx, PIX12Fxxx), seit vielen Jahren in Verwendung, 

haben sich zu den Arbeitspferden entwickelt, 

• Controller mit 16-Bit-Kernel (PIC18Fxxx, PIC18FxxJxx, PIC18FxxKxx), räumen mit einigen 

Mängeln der 14-Bit-Kernel auf (linear adressierbarer großer Speicher), 

• Controller mit 24-Bit-Kernel (PIC24, dsPIC30Fxxx, dsPIC33Fxxxx), haben 16 Bit 

Datenworte, einige eignen sich für digitale Signalverarbeitung, 

• Controller mit 32-Bit-Kernel (PIC32MXxxx), haben einen MIPS32-Kern und sind 

dementsprechend rechenstark, mit den urspünglichen PIC-Microcontrollern haben sie außer 

dem Namen nichts mehr gemein. 

Die Bit-Angabe hat in diesem Fall ausnahmsweise nichts mit der Datenwortbreite des jeweiligen 

Controllers zu tun, sondern mit der Breite der Befehlsworte des PIC. Ein größerer Wert deutet also auf 

einen komplexeren Controller mit leistungsfähigerem Befehlssatz hin. Alle Typen der PIC16XX- und 

PIC18XX-Familien verfügen über einen sehr kompakten RISC-Befehlssatz, unterschiedlichste 

On-Chip Peripherie, verschieden ausgeführte Programm- und Datenspeicher sowie über 

Gehäuseausführungsvarianten. Die CPU dieser Mikrocontrollerfamilien zeichnet sich aus durch eine 

strikte Trennung von Programm- und Datenspeicher und durch die Möglichkeit, gleichzeitig auf diese 

Speicher über getrennte Busse zuzugreifen, (Harvard-Architektur). Die folgende Tabelle soll einen 

knappen Überblick aller PICs vermitteln: 

12-Bit-Kernel 14-Bit-Kernel 16-Bit-Kernel 

Datenwort 8 Bit 

Befehlswort 12 Bit 

256 .. 

Programmspeichergröße 2k 

Worte 

EEPROM-Größe 0 

16 .. 

RAM-Größe 

134 

Byte 

Stack-Tiefe 2 

Interrupts keine 

4 MHz 

max. Taktfrequenz .. 20 

MHz 

verschiedene Befehle ~33 

Hardwaremultiplikation nein 

klein, billig, leistungsschwach - 

geeignet, um alte PIC-Software 

(12-Bit-PICs ohne Flash) weiter 

zu nutzen. 




1 .. 8k 

Programmspeichergröße Worte - 

segmentiert 

EEPROM-Größe 

0 .. 256 

Byte 

RAM-Größe 

64 .. 368 

Byte 

Stack-Tiefe 8 

Interrupts einfach 

max. Taktfrequenz 

4 MHz .. 20 

MHz 

verschiedene Befehle ca. 35 

Hardwaremultiplikation nein 

Eingeführte Standardtypen, für die 

viele Anwendungen zur Verfügung 

stehen. 

Beispiel: Blockschaltung und Pins des PIC16F84 



4k .. 128k 

Programmspeichergröße Byte - 

linear 

0 .. 1024 

EEPROM-Größe 

Byte 

256 .. 

RAM-Größe 

3936 

Byte 

Stack-Tiefe 31 

Interrupts priorisiert 

4 MHz .. 

max. Taktfrequenz 

40 MHz 

verschiedene Befehle ca. 75 

Hardwaremultiplikation ja 8 Bit 

Optimiert für den Einsatz von 

höheren Programmiersprachen. 

6.2 PIC-Microcontroller von Microchip 143


Ähnlich wie bei den Atmel-Prozessoren ist auch bei den PICs die Taktung recht einfach. Der 

Controller kann seinen Takt von einer externen Quelle erhalten oder mit einem internen Oszillator 

erzeugen. Letzterer kann entweder extern beschaltet werden (RC-Glied oder Quarz) oder der Takt 

wird komplett intern erzeugt. Dabei bietet nicht jeder PIC-Typ alle Möglichkeiten. 

Wie man aus der Tabelle erkennen kann, gibt es für Assembler-Programmierer zwei 

Herausforderungen: 

• Die Stacktiefe und damit die Zahl der verschactelten Unterprogrammaufrufe ist 

hardwaremäßig begrenzt. 

• Bei etlichen Typen ist der Arbeitsspeicher segmentiert, d.h. in einzelne Speichersegmente 

bzw. -seiten unterteilt, was beispielsweise die Größe von Arrays begrenzt. 

Als Beispiel für den Aufbau des Prozessors soll hier der Type 16Fxx dienen, dessen Blockschaltung 

und Pinbelegung oben abgebildet sind. Die PIC16xx-Mikrocontroller haben einen RISC-Befehlssatz 

mit nur 35 Befehlen, so dass die maschinennahe Programmierung in Assemblersyntax im Vergleich zu 

CPUs mit umfangreicheren Befehlssätzen relativ aufwendig ist. Alle Mitglieder der PIC16xx-Familie 

verfügen über Power-On Reset und Watchdog Timer. Unterschiede liegen vor allem in der 

verschiedenen Ausstattung mit On-Chip Peripheriekomponenten. 

Die Mikrocontroller der PIC16F8x-Gruppe und der PIC16C84 sind nur mit einer geringen Anzahl von 

On-Chip-Komponenten ausgestattet, die aber für viele typische Mikrocontolleranwendungen völlig 

ausreichend ist. Er verfügt über zwei Ports mit insgesamt 13 Pins, die jedoch über eine relativ große 

Beispiel: Blockschaltung und Pins des PIC16F84 144


Treiberfähigkeit verfügen, so dass LEDs problemlos direkt angeschlossen werden können. Ein 

8-Bit-Timer mit programmierbarem Vorteiler (1:1, 1:2, 1:4 bis 1:256) kann für Zeitgeber bzw. 

Zählerfunktionen eingesetzt werden. Auch bei den PIC müssen On-Chip-Funktionen über ein 

Konfigurationswort definiert werden, welches beim Programmiervorgang des Zielcontrollers auf eine 

spezielle Speicherstelle geschrieben werden muss. 

Bei der Programmierung spielt ein dem Akkumulator ähnliches Arbeitsregister W eine wichtige Rolle, 

mit dem alle arithmetischen und logischen Operationen durchgeführt werden. Dabei erfolgt die 

Verarbeitung der Daten prinzipiell in drei Schritten: 

1. Hole ein Byte aus dem RAM in das Arbeitsregister W 

2. Führe die gewünschte Operation aus 

3. Lege das Ergebnis im RAM ab 

Neben einer direkten Datenadressierung im RAM und einer besonderen Adressierung von 

Tabellenelementen im Codespeicher gibt es noch eine indirekte Adressierungsart. Dazu wird in das 

FSR (File Select Register) die Adresse der entsprechenden RAM-Speicherzelle geschrieben. Über das 

IND-Register kann nun auf die RAM-Speicherzelle schreibend oder lesend zugegriffen werden. Der 

PIC 16F84 besitzt einen 13 Bit breiten Programmzähler, der einen Programmspeicher von 8k Worten 

adressieren könnte. Der Adressbereich 0x0000-0x03FF (1 K Worte) ist physikalisch implementiert. 

Der Resetvektor liegt auf der Adresse 0; der Interruptvektor auf der Adresse 4. Der Datenspeicher 

unterteilt sich in das RAM (68 x 8 Bit, Adressbereich von 0x0C 0x4F) und im unteren 

Speicherbereich (0x00 0x0B) die I/O-Register. Diese Register werden als Special-Function-Register 

(SFR) bezeichnet. 

Das RAM wird auch als General-Purpose-Register (GPR) bezeichnet. Der Speicher ist in zwei Seiten 

(Bank 0 und Bank 1) unterteilt, die durch das Statusregister auswählbar sind. Bank 1 enthält die 

gleiche Anzahl von Speicherstellen wie Bank 0, wobei die General-Purpose-Register aus Bank 0 

gespiegelt sind, also auf beiden Seiten erreichbar sind. Einige Register sind jedoch nur über eine 

Speicherbank zu erreichen. Dazu zählen das OPTION- und das TRIS-Register, die auf Bank 1 als 

normale Register zu erreichen sind. 

Der 64 x 8 Bit große EEPROM-Bereich hat die Adressen 0x00 0x3F und ist sowohl lesbar als auch 

beschreibbar. Es bietet sich an, wenn Daten zu speichern sind, die auch nach dem Abschalten der 

Betriebsspannung erhalten bleiben müssen (z.B. Kalibrierdaten). Auf das EEPROM kann nicht direkt 

zugegriffen werden, sondern der Zugriff erfolgt über vier spezielle Register: EECON1, EECON2, 

EEADR, EEDAT. 

Speicherbelegung des PIC16F84 (nach Microchip-Unterlagen) 


Wie schon im Atmel-Abschnitt geschildert, verfügen auch die PIC-Prozessoren über die Möglichkeit 

der ISP-Programmierung. Dazu liefert Microchip eine passende Programmier-Hardware an. Derzeit 

aktuell ist der MPLAB PICkit 3 (weiterhin erhältlich ist der PICkit 2). Er ermöglicht das Debuggen 

und die Programmierung der PIC-Mikrocontroller mithilfe des MPLAB Integrated Development 

Environment (IDE). Der MPLAB PICkit 3 wird per USB-Schnittstelle am PC angeschlossen und 

verwendet zwei Portleitungen und den Reset-Anschluss zur Programmierung. 

Literatur 

Günter Schmitt: PIC-Mikrocontroller, Oldenbourg Verlag 

http://www.microchip.com/ 


http://www.microchip.com/ 

http://www.microchipdirect.com/ 

http://www.olimex.com/ 

http://www.sprut.de/electronic/pic/ 




6.3 MSP-430-Microcontroller von Texas Instruments 

Dies ist eine relativ neue 16-Bit Mikrocontrollerfamile, die speziell für Lowpower-Anwendungen 

entwickelt wurde. Es handelt sich um Controller mit: 

• 16-Bit Risc-Controllerkern 

• Einfacher Befehlssatz (nur 27 Befehle) 

• Takt: 8/16 MHz bei der MSP430F2xxx-Serie bzw. 25MHz bei der MSP430F5xxx-Serie 

• 1 KByte bis 256 KByte integrierter Flashspeicher 

• 256 Byte bis 16 KByte integriertes RAM 

• Peripherieeinheiten je nach Typ, z. B. USART, analoge Spannungskomparatoren, 

A/D-Wandler mit 10, 12 oder 16 Bit Auflösung, DA-Wandler, Timer 

• internes EEPROM 

• USB 2.0 Full Speed Interface 

• JTAG-Interface für Programmierung und Debugging 

• Betriebsspannung zwischen 1,8 und 3,6 V 

• Sehr geringe Stromaufnahme: 0.1 µA im Off-Modus, 0.8 µA im Standby und 250 µA / MIPS 

im Normalbetrieb 

Blockschema des MSP430 

Texas Instruments erweitert die Familie laufend, was auf einen großen Erfolg dieser Controllerlinie 

hindeutet. Der MSP430 besitzt eine Von-Neumann-Architektur. Die Größe des adressierbaren 

Speichers ist bei den meisten Typen auf 64 KByte limitiert. Je nach Modell können die 

Speichergrößen aber auch bis zu 256 KByte Flash und 16 KByte RAM umfassen. Bei allen 

Familienmitgliedern sind die untersten 2 KByte für interne Funktionen, z. B. einen Boot-Loader, 

reserviert. Seit 2007 wird auch eine Fami-lie mit der so genannten MSP430X-CPU angeboten. Deren 

Speichermodell kann bis zu 1 MByte Speicher adressieren (20 Bit Adressbus). Daher sind hier auch 

alle Register 20 Bit breit. 

Der Hardwaremultiplizierer erlaubt die Multiplikation von 8-Bit- und 16-Bit-Zahlen (mit/ohne 

Vorzeichen), wobei als Ergebnis eine bis zu 32 Bit große Zahl entsteht. Der jüngste Typ kann 

32-Bit-Operanden multiplizieren (64-Bit-Resultat). Er beherrscht weiterhin Multiplizieren und 

Addieren (MAC) wie ein DSP. In den untersten 16 Bytes sind spezielle Register (SFR, Special 

6.3 MSP-430-Microcontroller von Texas Instruments 147

Function Register) für die Interrupt- und "Modul"-Steuerung eingeblendet. Die Register der 

8-Bit-Peripherie belegen die folgenden Adressen ($010 bis $0FF). Die darauf folgenden 255 Bytes 

($100 bis $1FF) sind für 16-Bit-Peripherie reserviert (Speicherzugriff wortweise). Der 

Mikrocontroller verfügt über 16 Interrupt-Vektoren, welche zum Teil maskierbar sind. Beim MSP430 

sind nur die beiden höchsten Prioritäten nicht maskierbar, somit können nur diese beiden nicht in ihrer 

Funktion beeinflusst werden. 

Der Takt kann auf drei Arten erzeugt werden, die je nach Bedarf sehr geringen Stromverbrauch 

(32,768 kHz in Form eines Uhrenquarz), sehr schnelles Aufwachen nach einem Interrupt (interner 

RC-Oszillator) oder hohe Frequenz (bis zu 16 MHz) ermöglichen. Je nach Typ gibt es einem oder 

zwei Eingänge für Quarzoszillatoren sowie einen internen RC-Oszillator, dessen Frequenz in weiten 

Bereichen eingestellt werden kann. Die MSP430-Serie wurde konsequent für batteriebetriebene 

Lowpower-Anwendungen konzipiert. Typische Anwendungen sind Geräte mit Langzeitbatterie, wie 

zum Beispiel Energiezähler, Datenlogger oder auch Blutdruckmessgeräte. Die Peripherieeinheiten der 

Controller sind recht leistungsfähig und ihre Programmierung relativ einfach. Nachteilig für den 

Bastler ist lediglich die Tatsache, dass die Controller nur SMD-Bauformen (SO- oder TQFP-Gehäuse) 

erhältlich sind. 

Neben Parallel- und Seriellports sind die Mitglieder der MSP430-Familie (je nach Typ) mit 

Analogperipherie bestückt. Die Analog-Digital-Wandler haben eine Auflösung von 10, 12, 14 oder 16 

Bit, wobei je nach Typ des MSP430 als Wandlungsverfahren suk-zessive Approximation, Rampenoder 

Sigma-Delta-Verfahren eingesetzt wird. Die Digital-Analog-Wandler haben eine Auflösung von 

8 oder 12 Bit. Als Referenzspan-nung können hier wie bei den Komparatoren und A/D-Wandlern die 

internen oder externen Referenzen benutzt werden. Der Ausgangsverstärker kann automatisch 

kalib-riert werden, damit die Ausgangsspannung korrekt den digitalen Werten folgt. Der D/A-Wandler 

kann mit bis zu 550 kHz getaktet werden. 

Der MSP430 besitzt 16 Register, wobei vier von ihnen fest belegt sind. Register 0: Program-Counter, 

Register 1: Stack-Pointer, Register 2: Status-Register und Register 3: Constant-Generator. Diese vier 

Register haben spezielle Funktionen, sind aber wie alle anderen zwölf Register auch frei benutzbar. 

Der MSP430 beherrsch die komplette Palette der Adressierungsarten: Register-Adressierung, 

indizierte Adressierung, absolu-te Adressierung sowie indirekte Adressierung mit und ohne 

Autoinkrement. Der Befehlssatz beinhaltet 27 Grundbefehle und 24 "emulierte" Befehle, die aus den 

Grundbefehlen zusammengesetzt sind. Die Dauer der Befehlsabarbeitung dauert befehlsabhängig 

zwischen eins und sechs Taktzyklen. Der Prozessor ist in C und Assembler programmierbar. Für die 

Softwareentwicklung stehen verschiedene Compiler zur Ver-fügung. Auf der Website von TI gibt es 

eine auf 4 KByte begrenzte Version des IAR-C-Compilers (Kickstart-Version), der neben dem 

Compiler auch eine vollständige IDE mit Debugger usw. bietet. Seit einiger Zeit stellt TI auch eine 

vollständige Entwicklungsumgebung für den MSP430 auf Eclipse-Basis unter dem Namen 

"CCEssentials" zur Verfügung. Diese Entwicklungsumgebung enthält einen C-Compiler, der auf 16 

KByte begrenzt ist. Außerdem gibt es für die MSP430-Serie auch eine Version des GCC-Compilers 

inklusive Debugger für Linux und Windows. 

Literatur: 

Lutz Bierl: Das große MSP430 Praxisbuch, Franzis-Verlag 

Matthias Sturm: Mikrocontrollertechnik am Beispiel der MSP430-Familie, Hanser-Verlag 

Chris Nagy: Embedded Systems Design Using the TI MSP430 Series, Nownos 


Mikrocontroller-Net 

Entwicklungsboard für knapp 5 Euro 

University of Colorado 


Blockschema des MSP430 148

http://www.olimex.com/ 

6.4 8051-Microcontroller 


Bei der 8051-Familie handelt es sich um 8-Bit-Mikrocontroller der ersten Generation (Anfang der 

1980er Jahre) von Intel. Trotzdem werden Prozessoren mit 8051-Kern nach wie vor von 

verschiedenen Herstellern produziert. Eigentlich ist der 8051 für heutige Verhältnisse zu langsam und 

nicht mehr zeitgemäß. Der große Vorteil der 8051-Familie begründet sich durch die große Auswahl an 

Controllern mit sehr unterschiedlicher Hardwareausstattung. So gibt es sie mit SPI-, I2C-, CAN-, 

USB-, RS232-, Profibus-, LIN- oder Ethernetschnittstelle, mit Analog-Digital- und 

Digital-Analogwandlern, Timern, Capture-and-Compare-Einheiten usw. Softwareseitig sind alle diese 

Controller kompatibel mit dem Ur-8051, solange die spezielle Erweiterungen der neueren Typen nicht 

verwendet werden. Aufgrund der unterschiedlichen Befehlslängen von einem bis zu drei Byte sowie 

den unterschiedlichen Ausführungszeiten für einen Befehl handelt es sich eindeutig um eine 

CISC-Architektur. Das folgende Bild zeigt die Blockschaltung des Prozessors und einige 

Erweiterungen. 

Blockschema des 8051 

Aktuellere Vertreter dieser Familie sind z. B. die MicroConverter von Analog Devices, die 

AT89-Familie von Atmel, die MSC12-Familie von Texas Instruments oder die DS89C430 von Maxim 

(Dallas). Allen Modellen ist gemeinsam: 

• 8-Bit Prozessorkern mit einheitlichem Befehlssatz 

• mindestens 128 Bytes internes RAM 

• externes RAM und ROM 

• ein einheitliches Adressierungsmodell für so genannte Special Function Register (SFR) 

• Full-Duplex-UART 

• 5 Interrupt-Quellen 

• 2 Interrupt-Prioritäten 

• diverse Timer 

Ein Befehlszyklus entspricht in der ursprünglich von Intel entwickelten Struktur einem bis drei 

Maschinenzyklen. Ein Maschinenzyklus entspricht 12 Taktzyklen. Heute übliche Varianten des 8051 

kommen hingegen meist mit nur zwei Taktzyklen pro Maschinenzyklus aus. Damit ist bei gleicher 

6.4 8051-Microcontroller 149

Taktfrequenz eine deutlich höhere Befehlsabarbeitung möglich. Eine Besonderheit dieses Prozessors 

ist der Bitprozessor, der eine schnelle und einfache Bitmanipulation erlaubt. 

Später wurde sogar eine Version des 8051 mit integriertem EEPROM und BASIC-Interpreter unter 

der Typenbezeichnung 8052AH angeboten, die es erlaubte über die serielle Schnittstelle zu 

kommunizieren und Programm einzugeben und diese dann im internen EEPROM abzulegen - fast wie 

bei den frühen Heimcomputern. 

Darüber hinaus gibt es von verschiedenen Firmen erweiterte MCS-51-Mikrocontroller, z. B. die von 

Infineon in NMOS-Technik produduzierten Modelle 80515 (8192 Bytes ROM, 256 Bytes RAM, drei 

16-Bit-Timer, UART, zwei externe Interruptquellen, PWM, 8-fach-A/D-Wandler) oder 80535 

(externes ROM/EEPROM, 256 Bytes RAM, drei 16-Bit-Timer, UART, zwei externe Interruptquellen, 

PWM, 8-fach-A/D-Wandler). 

Wegen der großen Verbreitung der 8051-Familie gibt es auch eine Vielzahl von synthetisierbaren 

MCS-51-Implementierungen. Diese sind als IP-Cores in einer Hard-warebeschreibungssprache wie 

beispielsweise VHDL verfügbar. Sie eignen sich für den Einsatz in FPGAs und 

anwendungsspezifischen integrierten Schaltungen (ASICs). Typische Anwendungsbeispiele sind 

USB-Controller, wie sie in Druckern oder Schnittstellenadaptern eingesetzt werden. In diese sind zur 

Steuerung der diversen Protokolle MCS-51-Mikrocontroller integriert. 

Literatur: 

Mikrocomputer SAB 8051 Befehlsliste. Hrsg. von der Siemens AG 

Andreas Roth: Das Microcontroller Kochbuch MCS51, mitp Verlag 

J. Walter: Mikrocomputertechnik mit der 8051-Controller-Familie, Springer 2008 


Wikipedia 

8051 Projects 

Paul's 8051 Tools, Projects and Free Code 

8051 Befehlsliste 






Blockschema des 8051 150

7 Anhang 

7.1 Literatur und Links 

Literatur 

Arnulf Wallrabe: 

Mikrocontrollerpraxis 

Einstieg mit dem 68HC11 

Hanser Verlag 

Dieses Buch beschreibt den Prozessor sehr viel ausführlicher als das Werk von Rose (s. u.) und bringt 

auch viele Beispiele. Dafür kommt hier die Beschreibung der einzelnen Befehle zu kurz. Aufgrund des 

Inhaltes und des Preises ist es nach meiner Ansicht noch am besten als Begleitung zur Vorlesung 

geeignet. Auch hier liegt eine Programmdiskette bei. 

Michael Rose: 

Mikroprozessor 68HC11 

Architektur und Applikation 

Hüthig Verlag 

Das Buch beschreibt den Befehlssatz recht ausführlich, aber es gibt kaum kleinen Beispiele zu den 

Befehlen. Die umfangreicheren Beispiele im letzten Drittel des Buchs beziehen sich auf ein 

bestimmtes System. Das Buch ist relativ teuer, da neben einer Programmdiskette auch eine Platine für 

den Aufbau des Mustersystems beiliegt. 

Ludwig Orgler: 

MC68HC11 Microcontroller 

Franzis Verlag 

Sehr Hardware- und Schaltungsorientierte Anleitung. Auch hier fehlt die Beschreibung der Befehle. 

Das Buch ist eher etwas für Praktiker, die schon erste Erfahrungen mit dem Prozessor gesammelt 

haben. Auch hier liegt eine Diskette bei. 

Rainer Bermbach: 

Embedded Controller 

Hanser Verlag 

Dieses Buch macht mit dem Aufbau von Embedded Controllern auf INTEL-Basis vertraut 

(80186-Familie). Eine recht ordentliche Einführung in die Assembler-Programmierung. Auf der 

CD-ROM zum Buch gibt es eine komplette Entwicklungsumgebung, ein Tutorial und Datenblätter. 

Rainer Kelch: 

Rechnergrundlagen - Von der Binärlogik zum Schaltwerk 

Fachbuchverlag Leipzig 

Rainer Kelch: 

Rechnergrundlagen - Vom Rechenwerk zum Universalrechner 

Fachbuchverlag Leipzig 

Beide Bücher fühen von der Digitaltechnik bis hin zum fertigen Prozessor und behandeln dabei auch 

Informationtheorie, Zahlendarstellung und binäres Rechnen. In jedem Buch steckt eine CD mit 

7 Anhang 151

weiteren Infos und Lernprogrammen. 

Ausserdem gibt es noch die englischen Referenz-Handbücher von Motorola, das nur von Motorola 

selbst bezogen werden kann: 

M68HC11 Reference Manual und M68HC11 Technical Data 

Das Reference-Manual ist hier abrufbar: 

68HC11 Reference Manual (PDF, 3 MByte) und 

68HC11 Reference Manual (PS, 0,9 MByte). 

68HC11 Links 

• The MIT Handy Board 

• Motorola Microcontollers 

• HC11 FAQ 

• Axiom Manufacturing 

• Technological Arts 

• Windows-based Simulator (THRSIM11) 

• Another Windows-based Simulators 

Latest version 

• Roger's Embedded Microcontrollers Home Page 

• Course Notes: Digital Logic and Computer Systems 

• Circuit Cellar, The Computer Applications Journal 

• The Magazine of Electronics Technology 

Freeware 68HC11 C Compilers 

• Small C - Small-C ported to the 68HC11 (includes C source code). 

• ICC11 - An older version (v0.50) of the ImageCraft 68HC11 C compiler. 

• gcc11 - A version of the GNU compiler for the 68HC11, ported by Coactive Aesthetics. 

• Interactive C - Originally developed for the MIT LEGO Robot (6.270) Contest, IC provides a 

subset of C in an integrated development environment. 

Commercial 68HC11 C Compilers 


• ImageCraft - A low-cost but high-quality compiler, which includes an optimizer, 

floating-point support, assembler, linker, and librarian. Available in DOS command line 

($75), Windows IDE ($130), and Linux command line ($75) versions. The only major missing 

features are true 32-bit longs, and support for in-circuit emulators, though they offer the 

"NoICE" monitor/debugger for $30. 

• Dunfield - This reasonably-priced ($100) compiler includes an assembler, linker, librarian, 

library (with ASM source), monitor (with source), and various utilities and sample programs. 

It lacks intrinsic support for the "long" and "float" data types, doesn't support typedef's, 

enum's or bitfields, and only the first 15 characters of symbol names are significant. The 

documentation is decent, but you'll have to print it out yourself -- it's only supplied on disk. 

Dunfield also has low-cost compilers available for many other microcontrollers, including a 

freeware one for MS-DOS that produces very small and fast executables. 

• IAR Systems - It is also a high-end (starting at $1400) compiler, with good industry support. 

Documentation is fair -- good in spots, poor in others, with the most pronouced weakness 

being poor organization and indexes. ANSI compliance is excellent, as is optimization, 

especally with the most recent upgrade (v4.11). The only major omissions are lack of library 

source, and no in-line assembly (all ASM code must be in separate files). 

Literatur 152


• Cosmic - This is a professional-level compiler (starting at about $1500) with support for most 

major emulators and debuggers. Documentation was voluminous, and poorly written, but 

adequate. Library source was included; however, the source comments were in French. 

Download their Evaluation Kit and try it out. 

• Introl - They have both hobbyist ($150) and professional ($2000) HC11 compilers, offering 

full ANSI compliance, library source, an assembler, a linker, and a debugger. They also have 

similar products for the entire Motorola line (6805, 6808, 6809, 68HC12, 68HC16, and 68300 

families). Demos are available for download. 

• Avocet - Avocet is a well-respected name in embedded development tools. They have two 

families of C compilers. AVCASE is $1595 and includes Avocet C, a macro assembler, a 

monitor debugger, and a simulator. They've also taken over the 2500 AD line of products, 

which includes a C compiler ($815), assembler ($415), and simulator ($365). Demos are 

available for download. 

• HI-Tech - A high-end compiler at a mid-range price (~$850), it boasts full ANSI C 

compilance, an optimizing compiler, assembler, linker, library with full source, and a 

source-level debug monitor. 

• Archimedes - A high-end ($1395 to $2995) HC11 compiler for Windows; also versions for 

other Motorola processors (HC12, HC16, and 683XX). 30-day money-back guarantee. Demo 

can be downloaded from web site. 

• Newton Labs - Makers of a commercial version of Interactive C, with prices ranging from $35 

to $100, and versions for Windows 95/Windows NT, Macintosh, and various Unix platforms. 

The commercial version includes support for more Standard C features, as well as a better 

integrated environment, extensive peripheral libraries, and professional documentation. 

7.2 Tips zur Programmierung 

Der eigentlichen Programmierung (=Codierung) geht eine Entwurfsphase voraus: 

• Konzeption des Programms 

Vorüberlegungen zum Programm: Aufgaben, Umfang, Wirtschaftlichkeitsbetrachtungen, 

Termine, Personal 

• Grobentwurf 

Lösungswege und Konzepte entwickeln, Aufgabenumfang festlegen, Randbedingungen 

prüfen (z.B. SPeicherplatz, Geschwindigkeit) 

• Detailentwurf, Modularisierung 

Genaue Definition von Programmeigenschaften und Benutzerschnittstelle, Anforderungen 

(z.B. Rechengenauigkeit, Fehlerbehandlung, Hardwareabhängigkeit, ....). Festlegen von 

Datenstrukturen und des Aufgabenumfangs der einzelnen Module. 

• Überprüfung des Entwurfs am Schreibtisch 

Möglichst durch jemand anderen den Entwurf überprüfen lassen. 

• Dann folgt Codierung und Test der Programmmodule und anschließend: 

♦ Integration der Module zum Programm 

♦ Test des Gesamtprogramms und Korrektur 

♦ Parallel zur Programmierung: Dokumentation und Bedienungshandbuch 

Durch Testen von Programmen kann man nur 

deren Fehlerhaftigkeit feststellen 

- aber niemals deren Korektheit! 

68HC11 Links 153

Grundlegende Prinzipien: 

Es ist unmöglich, ein Programm Narrensicher 

zu machen, weil Narren zu erfindungsreich sind! 

• In kleinen überschaubaren Schritten vorgehen. Nicht zuviel zur gleichen Zeit machen. 

• Große Projekte in kleine, logisch zusammengehörende Einheiten (Module) zerlegen. Die 

Module so autonom wie möglich auslegen und separat testen. 

• Ablauf so einfach wie möglich gestalten. Das macht die Programme leichter lesbar und 

durchschaubarer. 

• Beim Entwurf (und Dokumentation) grafische Möglichkeiten (Flußdiagramme, 

Struktogramme, etc.) und Pseudocode nutzen. 

• Den ersten Entwurf so klar und einfach wie möglich halten. Optimieren können Sie später 

(falls überhaupt nötig). 

• Systematisch vorgehen. Checklisten verwenden. Beim Test Grenzfälle beachten. 

• Keine Algorithmen verwenden, die man nicht verstanden hat. 

• Berücksichtigen Sie Debugging, Test und Wartung schon beim Erstellen des Programms (z. 

B. Ausgabeanweisungen und Überwachungsprozeduren, die später auskommentiert werden). 

• Fangen Sie mit dem Kodieren erst an, wenn der Entwurf komplett steht. 

• Schreiben Sie Programme so, daß Änderungen leicht möglich sind. Vermeiden Sie 

Seiteneffekte in Unterprogrammen oder Sprünge aus Unterprogrammen in andere (weil da 

zufällig Code steht, der "passt"). 

• Behalten Sie trotz Modularisierung das Gesamtprogramm im Auge. Testen Sie die Interaktion 

zwischen Modulen gleich und nicht erst bei der Gesamtintegration. 

• Bei komplexen Daten ist das Design von Datenstrukturen genauso wichtig, wie das 

Programmdesign. 

• Versuchen Sie nicht, neu entwickelte Hardware und die Software dazu gleichzeitig zu testen. 

Programm-Dokumentation 


Die Programmdokumentation besteht nicht nur aus dem kommentierten Listing, sondern aus: 

• Beschreibung der grundsätzlichen Wirkungsweise des Programms oder des Unterprogramms 

(benutzerbezogen) 

• Ausführlicher Bedienungsanleitung 

♦ Beschreibung sämtlicher Programmfunktionen 

♦ Grenzen für Eingabewerte (Wertebereich) 

♦ Fehlermeldungen und die Benutzerreaktion auf die Fehler 

♦ Beispiel(e) für jede Programmfunktion 

♦ Besonderheiten, die beim Einsatz zu beachten sind 

• programmiererbezogene Programmbeschreibung 

♦ verwendete Algorithmen und deren Implementierung 

♦ Hinweise über Seiteneffekte einzelner Unterprogramme 

♦ Wartungs-Historie (Dok. von Änderungen/Erweiterungen) 

♦ mögliche Fehlersituationen und Reaktion des Programms darauf 

♦ alle "trickreichen" Programmsequenzen 

♦ Datenstrukturen 

• Ablaufpläne (Flußdiagramme, Struktogramme, Datenfluß) 

• kommentiertes Programmlisting 

• Programmversion und Erstellungs-/Änderungs-Datum auf Listing 

7.2 Tips zur Programmierung 154

7.3 ASCII-Tabelle 

ASCII Tabelle (sedezimal) 

| 00 nul| 01 soh| 02 stx| 03 etx| 04 eot| 05 enq| 06 ack| 07 bel| 

| 08 bs | 09 ht | 0a nl | 0b vt | 0c np | 0d cr | 0e so | 0f si | 

| 10 dle| 11 dc1| 12 dc2| 13 dc3| 14 dc4| 15 nak| 16 syn| 17 etb| 

| 18 can| 19 em | 1a sub| 1b esc| 1c fs | 1d gs | 1e rs | 1f us | 

| 20 sp | 21 ! | 22 " | 23 # | 24 $ | 25 % | 26 & | 27 ' | 

| 28 ( | 29 ) | 2a * | 2b + | 2c , | 2d - | 2e . | 2f / | 

| 30 0 | 31 1 | 32 2 | 33 3 | 34 4 | 35 5 | 36 6 | 37 7 | 

| 38 8 | 39 9 | 3a : | 3b ; | 3c < | 3d = | 3e > | 3f ? | 

| 40 @ | 41 A | 42 B | 43 C | 44 D | 45 E | 46 F | 47 G | 

| 48 H | 49 I | 4a J | 4b K | 4c L | 4d M | 4e N | 4f O | 

| 50 P | 51 Q | 52 R | 53 S | 54 T | 55 U | 56 V | 57 W | 

| 58 X | 59 Y | 5a Z | 5b [ | 5c \ | 5d ] | 5e ^ | 5f _ | 

| 60 ` | 61 a | 62 b | 63 c | 64 d | 65 e | 66 f | 67 g | 

| 68 h | 69 i | 6a j | 6b k | 6c l | 6d m | 6e n | 6f o | 

| 70 p | 71 q | 72 r | 73 s | 74 t | 75 u | 76 v | 77 w | 

| 78 x | 79 y | 7a z | 7b { | 7c | | 7d } | 7e ~ | 7f del| 

ASCII Tabelle (oktal) 

|000 nul|001 soh|002 stx|003 etx|004 eot|005 enq|006 ack|007 bel| 

|010 bs |011 ht |012 nl |013 vt |014 np |015 cr |016 so |017 si | 

|020 dle|021 dc1|022 dc2|023 dc3|024 dc4|025 nak|026 syn|027 etb| 

|030 can|031 em |032 sub|033 esc|034 fs |035 gs |036 rs |037 us | 

|040 sp |041 ! |042 " |043 # |044 $ |045 % |046 & |047 ' | 

|050 ( |051 ) |052 * |053 + |054 , |055 - |056 . |057 / | 

|060 0 |061 1 |062 2 |063 3 |064 4 |065 5 |066 6 |067 7 | 

|070 8 |071 9 |072 : |073 ; |074 < |075 = |076 > |077 ? | 

|100 @ |101 A |102 B |103 C |104 D |105 E |106 F |107 G | 

|110 H |111 I |112 J |113 K |114 L |115 M |116 N |117 O | 

|120 P |121 Q |122 R |123 S |124 T |125 U |126 V |127 W | 

|130 X |131 Y |132 Z |133 [ |134 \ |135 ] |136 ^ |137 _ | 

|140 ` |141 a |142 b |143 c |144 d |145 e |146 f |147 g | 

|150 h |151 i |152 j |153 k |154 l |155 m |156 n |157 o | 

|160 p |161 q |162 r |163 s |164 t |165 u |166 v |167 w | 

|170 x |171 y |172 z |173 { |174 | |175 } |176 ~ |177 del| 

7.4 I/O-Register 


The following quick-reference table shows all control registers and bits. The addresses are those 

resulting from a hardware reset. The registers are generally grouped according to the device they are 

associated with. Some registers are input/output registers while other perform only control functions. 

Reference appropriate text material before using these registers. 

19881019/wj van ganswijk 

1000 porta 

1001 reserved 

1002 pioc 

w 1....... staf: strobe a flag, set at active edge of stra pin/inactive 

w .1...... stai: hardware interrupt request when STAF=1 

w ..1..... cwom: port c open-drain 

w ...1.... hnds: handshake/simpel strobe mode 

w ....1... oin: output/input handshake select 

w .....1.. pls: STRB pulse/level active 

w ......1. ega: rising/falling edge select for STRA 

w .......1 invb: STRB active high/low 

1003 portc 

1004 portb 

7.3 ASCII-Tabelle 155


1005 portcl 

1006 reserved 

1007 ddrc: data direction register for port c (1=output) 

1008 portd (b0..b5) 

rw 1....... mode0 or boot: strb 

rw 1....... mode1 or test: r/w 

rw .1...... mode0 or boot: stra 

rw .1...... mode1 or test: as 

rw ..1..... pd5/ss* 

rw ...1.... pd4/sck 

rw ....1... pd3/mosi 

rw .....1.. pd2/miso 

rw ......1. pd1/txd 

rw .......1 pd0/rxd 

1009 ddrd: data direction register for port d (1=output) (b0..b5) 

100a porte: port e data register 

100b cforc: timer compare force register 

w 1....... foc1 

w .1...... foc2 

w ..1..... foc3 

w ...1.... foc4 

w ....1... foc5 

w 11111111 force compare(s) 

w .....xxx reserved 

100c oc1m: set bits to enable oc1 to control corresponding pin(s) of port a 

w 1....... oc1m7 

w .1...... oc1m6 

w ..1..... oc1m5 

w ...1.... oc1m4 

w ....1... oc1m3 



100d oc1d: if oc1mx is set, data in oc1dx is output to port a bit-x 

on successful oc1 compares 

w 1....... oc1d7 

w .1...... oc1d6 

w ..1..... oc1d5 

w ...1.... oc1d4 

w ....1... oc1d3 



100e tcnt: timer counter register 

1010 tic1: timer input capture register 



1016 toc1: timer output compare register 

1018 toc2: timer output compare register 

101a toc3: timer output compare register 

101c toc4: timer output compare register 

101e toc5: timer output compare register 

1020 tctl1: timer control register 1 

w 1....... om2 

w .1...... ol2 

w ..1..... om3 

w ...1.... ol3 

w ....1... om4 

w .....1.. ol4 

w ......1. om5 

w .......1 ol5 

for all pairs: 

w 00...... timer disconnected from output pin logic 

w 01...... ocx output line: toggle 

w 10...... ocx output line: 0 

w 11...... ocx output line: 1 

1021 tctl2: timer control register 2 

w xx...... reserved 

w ..1..... edg1b 

7.4 I/O-Register 156


w ...1.... edg1a 

w ....1... edg2b 

w .....1.. edg2a 

w ......1. edg3b 

w .......1 edg3a 

for all pairs: 

w ..00.... capture: disabled 

w ..01.... capture: on rising edge only 

w ..10.... capture: on falling edge only 

w ..11.... capture: on any edge 

1022 tmsk1: main timer interrupt mask reg 1 

w 1....... oc1l: output compare 1 interrupt enable 

w .1...... oc2l: output compare 2 interrupt enable 

w ..1..... oc3l: output compare 3 interrupt enable 

w ...1.... oc4l: output compare 4 interrupt enable 

w ....1... oc5l: output compare 5 interrupt enable 

w .....1.. ic1l: input compare 1 interrupt enable 

w ......1. ic2l: input compare 2 interrupt enable 

w .......1 ic3l: input compare 3 interrupt enable 

1023 tflg1: main timer interrupt flag reg 1 

w 1....... oc1f: clear output compare flag 1 

w .1...... oc2f: clear output compare flag 2 

w ..1..... oc3f: clear output compare flag 3 

w ...1.... oc4f: clear output compare flag 4 

w ....1... oc5f: clear output compare flag 5 

w .....1.. ic1f: clear input capture flag 1 

w ......1. ic2f: clear input capture flag 2 

w .......1 ic3f: clear input capture flag 3 

1024 tmsk2: misc timer interrupt mask reg 2 

w 1....... toi: timer overflow interrupt enable 

w .1...... rtii: interrupt enable 

w ..1..... paovi: pulse accumulator overflow interrupt enable 

w ...1.... paii: pulse accumulator input interrupt enable/disable 

w ....xx.. reserved 

w ......00 pr1,pr0: timer prescale factor 1 




1025 tflg2: misc timer interrupt flag reg 2 

w 1....... tof: clear timer overflow flag 

w .1...... rtif: clear real time (periodic) interrupt flag 

w ..1..... paovf: clear pulse accumulator overflow flag 

w ...1.... paif: clear paif pulse accumulator input edge flag 

w ....xxxx reserved 

1026 pactl: pulse accumulator control register 

w 1....... ddra7: data direction for port a bit7 is output/input 

w .1...... paen: enable/disable pulse accumulator system enable 

w ..1..... pamod: pulse acc mode: gated time accumulation/event counter 

w ...1.... pedge: pulse acc edge ctrl: rising/falling edges 

w ....xx.. reserved 

w ......00 rtr1,rtr0: interrupt rate divide by 2^13 




1027 pacnt: pulse accumulator count register 

1028 spcr: spi control register 

w 1....... spie: spi interrupt enable 

w .1...... spe: spi system enable 

w ..1..... dwom: port d: open-drain/normal 

w ...1.... mstr: master/slave mode 

w ....1... cpol: clock polarity 

w .....1.. cpha: clock phase 

w ......00 spr1,spr0: spi e-clock divided by 2 




1029 spsr: spi status register 



r 1....... spif: spi interrupt request 

r .1...... wcol: write collision status flag 

r ...1.... modf: spi mode error interrupt status flag 

r ..x.xxxx reserved 

102a spdr: spi data register 

102b baud: sci baud rate control register 

w 1....... tclr: clear baud counter chain (test only) 

w .x...... reserved 

w ..00.... scp1,scp0: serial prescaler select: divide e-clock by 1 




w ....1... rckb: sci baud rate clock test (test only) 

w .....000 scr2,scr1,scr0: prescaler output divide by 1 








102c sccr1: sci control register 1 

w 1....... r8: receive bit 8 

w .1...... t8: transmit bit 8 

w ...1.... m: ninth data bit 

w ....1... wake: wake up by address mark/idle line (msb/no low) 

w ..x..xxx reserved 

102d sccr2: sci control register 2 

w 1....... tie: transmit interrupt enable 

w .1...... tcie: transmit complete interrupt enable 

w ..1..... rie: receiver interrupt enable 

w ...1.... ilie: enable/disable idle line interrupts 

w ....1... te: transmitter enable (toggle to queue idle character) 

w .....1.. re: receiver enable on/off 

w ......1. rwu: receiver asleep/normal 

w .......1 sbk: send break 

102e scsr: sci status register 

r 1....... tdre: transmit data register empty flag 

r .1...... tc: transmit complete flag 

r ..1..... rdrf: receive data register full flag 

r ...1.... idle: idle line detected flag 

r ....1... or: over-run error flag 

r .....1.. nf: noise error flag 

r ......1. fe: framing error flag 

r .......x reserved 

102f scdr: sci data register 

1030 adctl: a/d control/status register 

r 1....... ccf: conversions complete flag (sets after fourth conversion) 

rw .x...... reserved 

w ..1..... scan: convert continuously/4 conversions and stop 

w ...1.... mult: convert four channel group/single channel 

rw ....0000 cd,cc,cb,ca: ad0 port e bit0 








rw ....10xx cd,cc,cb,ca: reserved 

rw ....1100 cd,cc,cb,ca: Vref hi 

rw ....1101 cd,cc,cb,ca: Vref low 

rw ....1110 cd,cc,cb,ca: Vref hi/2 

rw ....1111 cd,cc,cb,ca: test/reserved 

1031 adr1 

1032 adr2 

1033 adr3 



1034 adr4 

1035 reserved 

1036 reserved 

1037 reserved 

1038 reserved 

1039 option: system configuration options 

w 1....... adpu: a->d system powered up/down 

w .1...... csel: a->d and ee use an internal-r-c/system-e clock 

w ..1..... irqe: irq configured for falling edges/low level 

w ...1.... dly: enable/disable oscillator start-up delay (from stop) 

w ....1... cme: slow or stopped clocks cause reset/disabled 

w .....x.. reserved 

w ......00 cr1,cr0: e/2^15 divided by 1 




103a coprst: arm/reset cop timer circuitry, 

write $55 and $aa to reset cop watchdog timer 

103b pprog: eeprom programming register 

w 1....... odd: program odd rows in half of eeprom (test only) 

w .1...... even: program even rows in half of eeprom (test only) 

w ..x..... reserved 

w ...1.... byte: erase only one byte/row or all of eeprom 

w ....1... row: erase only one 16 byte row/all 512 bytes of eeprom 

w .....1.. erase: erase/normal read of program mode 

w ......1. eelat: eeprom busses configured for program or erase/read 

w .......1 eepgm: program or erase power switched on/off 

to program eeprom: 

- set eelat 

- write data to desired address 

- set eepgm for the required programming time 

to erase eeprom: 

- select row = 1/0 

- select byte = 1/0 

- set erase and eelat = 1 

- write to an eeprom address to be erased 

- set eepgm for the required erase time period 

103c hprio: highest priority interrupt and misc. 

w 1....... rboot: boot rom enabled/not in map (normal) 

w .00..... smod,mda: single chip mode 

w .01..... smod,mda: expanded multiplexed mode 

w .10..... smod,mda: special bootstrap 

w .11..... smod,mda: special test 

w ...1.... irv: data from internal reads visible/not 

on external bus 

reset to in test/boot mode: 1, in normal modes: 0 

r ....0000 psel3,2,1,0: timer overflow 

r ....0001 psel3,2,1,0: pulse accum. overflow 

r ....0010 psel3,2,1,0: puls accum. input edge 

r ....0011 psel3,2,1,0: spi serial xfer complete 

r ....0100 psel3,2,1,0: sci serial system 

r ....0101 psel3,2,1,0: reserved (default to irq) 

r ....0110 psel3,2,1,0: irq (ext pin or parallel i/o 

r ....0111 psel3,2,1,0: real time interrupt 

r ....1000 psel3,2,1,0: timer input capture 1 



r ....1011 psel3,2,1,0: timer output compare 1 





103d init: ram and i/o mapping register 

w xxxx.... ram3,2,1,0: ram block position (x000..x0ff) 

w ....xxxx reg3,2,1,0: register block position (x000..x03f) 

00000001 at reset 

103e test1: factory test register 


w 1....... tilop: test illegal opcode 

w .x...... reserved 

w ..1..... occr: output condition code register status to timer port 

w ...1.... cbyp: timer divider chain bypass 

w ....1... disr: disable resets from cop and clock monitor 

w .....1.. fcm: force clock monitor failure 

w ......1. fcop: force cop watchdog failure 

w .......1 tcon: test configuration 

103f config: configuration control register 

w ....1... nosec: dis/enable security mode 

(security only if mask option) 

w .....1.. nocop: dis/enable cop system 

w ......1. romon: en/disable rom at $e000..$ffff 

w .......1 eeon: en/disable eeprom at $b600..$b7ff 

note: The bits of this register are implemented with eeprom cells. 

programming and erasure follow normal eeprom procedures. 

The erased state of this location is $0f. A new value 

programmed into this register is not readable until after a 

subsequent reset sequence. 

7.5 Interrupt-Adressen 

SCIINT EQU $FFD6 ; SCI serial system 

SPIINT EQU $FFD8 ; SPI serial system 

PAIINT EQU $FFDA ; Pulse Accumulator Input Edge 

PAOVINT EQU $FFDC ; Pulse Accumulator Overflow 

TOINT EQU $FFDE ; Timer Overflow 

TOC5INT EQU $FFE0 ; Timer Output Compare 5 





TIC3INT EQU $FFEA ; Timer Input Capture 3 

TIC2INT EQU $FFEC ; Timer Input Capture 2 

TIC1INT EQU $FFEE ; Timer Input Capture 1 

RTIINT EQU $FFF0 ; Real Time Interrupt 

IRQINT EQU $FFF2 ; IRQ External Interrupt 

XIRQINT EQU $FFF4 ; XIRQ External Interrupt 

SWIINT EQU $FFF6 ; Software Interrupt 

BADOPINT EQU $FFF8 ; Illegal Opcode Trap Interrupt 

NOCOPINT EQU $FFFA ; COP Failure (Reset) 

CMEINT EQU $FFFC ; COP Clock Monitor Fail (Reset) 

RESETINT EQU $FFFE ; RESET Interrupt 

7.6 Das Motorola-S-Format 


Eine Datei im Motorola-S-Format ist eine Textdatei mit beliebig vielen Zeilen, die Sedezimalziffern in 

ASCII-Darstellung enthalten. Die Zeilen werden mit CR, LF abgeschlossen. Diese Datei enthält 

Binärcode in ASCII-Form. 

Die Datei kann (muß aber nicht) mit einer Einleitungszeile beginnen, dem Sign-On-Record. Man 

erkennt ihn am einleitenden S0 (Ziffer Null). Er enthält einen Kommentar, z. B. den Programmnamen 

(im Beispiel unten "DATA I/O"). S-Records enthalten pro Zeile eine Adresse, an der die Daten 

abgelegt werden sollen. 

Jede Datenzeile beginnt mit zwei Startzeichen "S" und einer Ziffer. Die nächsten beiden Zeichen 

geben die hexadezimale Anzahl der Datenbytes in der Zeile an, wobei auch die Adreßangabe (2 Bytes) 

und die Prüfsumme mitgezählt werden (also Zahl der "echten" Datenbytes + 3). Darauf folgen vier 

Zeichen, welche die hexadezimale Adresse des ersten Bytes des Datenrecords angeben. Nun folgen 

7.5 Interrupt-Adressen 160

die Datenbytes zweistellig hexadezimal. Leerzeichen werden überlesen. Zum Schluß folgt ein Byte 

Prüfsumme (zweistell. Hex.). Die Prüfsumme ist das Einerkomplement aus der Summe von 

Längenangabe, Adresse und Datenbytes. Der Typ des Records wird durch eine Ziffer bezeichnet: 

• 0: Startrecord (siehe oben) 

• 1,2,3: Datenrecord 

• 7,8,9: Enderecord 

Der Typ sorgt für die Unterscheidung der Adreßlänge: 

• Bei Typ 0 is die Adresse immer $0000 und 16-Bit (4 Ziffern) lang 

• Bei Typ 1 oder 9 is die Adresse 16-Bit (4 Ziffern) lang 



Die letzte Zeile der Datei beginnt mit den Startzeichen "S" und der Ziffer 9, 8 oder 7. Er bildet den 

End-Of-File-Record. Ein Enderecord enthält keine Daten, aber die Adresse in diesem Record stellt die 

Startadresse des Programms dar. 

Beispiel: 

S0 0B 0000 44 41 54 41 20 49 2F 4F F4 

S1 13 0000 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FC 

S1 13 0010 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF EC 

S1 13 0020 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF DC 

S1 13 0030 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF CC 

S1 13 0040 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF BC 

S9 03 0000 FC ¦ 

¦ ¦ ¦ ¦ ¦ 

¦ ¦ ¦ Datenbytes Prüfsumme 

¦ ¦ Adresse 

¦ Längenangabe (Datenbytes + 3) 

Record-Markierung 






7.6 Das Motorola-S-Format 161

Programmbeispiel-Sammlung 

Den folgenden "Programmschnipseln" fehlt noch das "Drumrum" 

(Definitionen von Variablen, Hauptprogramm, usw.). Sie dienen der 

Illustration verschiedener Programmiertechniken in Assembler. 

Allgemeiner Vorspann für's Praktikum 







portcl equ $1005 ; port c data latch 

portc equ $1003 ; port c data reg. 

ddrc equ $1007 ; portc data dir. reg. 









*************************** 

* data area * 

*************************** 

org data 

*************************** 


*************************** 

org prog 


*************************** 

* Nachspann: Vektoren * 

*************************** 

org reset 

fdb main 

end 

Speicherbereich Kopieren 

* Parameter: A Länge (Anzahl Bytes), X Quelle, Y Ziel 

move pshb 

mov1 ldab 0,x ; hole Quellbyte 

stab 0,y ; speichern im Zielbereich 

inx ; Adressen erhöhen 

iny 

deca ; runterzählen bis 0 

bne mov1 

pulb 

rts 

Programmbeispiel-Sammlung 162

Die größere von zwei Zahlen finden 

Vergleichen ($40) und ($41), Ergebnis in $42 

LDAA $40 ; 1. Zahl holen 

CMPA $41 ; 2. Zahl größer? 

BHS WEITER ; 1. Zahl ist größer 

LDAA $41 ; 2. Zahl laden 

WEITER STAA $42 ; Abspeichern 

16-Bit-Addition (Prüfsumme) 

Addition eines Feldes von 8-Bit-Werten. Die Anzahl der Werte steht in Speicherbyte $42, die zu 

addierenden Werte folgen ab Adresse $43. Das 16-Bit-Ergebnis wird in $40 (MSB) und $41 (LSB) 

abgelegt. 

CHECKSUM CLRA ; Summe in A und B, Register 

CLRB ; zuerst mal löschen 

LDX #$0043 ; Adresse erster Summand (Feldanfang) 

CSUM ADDB ,X ; Feldelement addieren 

ADCA #0 ; Übertrag im MSB aufaddieren 

INX ; X inkrementieren 

DEC $42 ; Elementezähler vermindern 

BNE CSUM ; Wiederholen, solange Zähler > 0 ist 

STD $40 ; Checksumme speichern 

RTS 

Quadrate von 0 - 15 über Tabelle ermitteln 

Wert in $41, Ergebnis in $42 

LDAB $41 ; Operanden holen 

LDX #TABELLE ; X-Register auf Tabellenanfang 

ABX ; X und B addieren 

LDAA 0,X ; B-ten Eintrag aus Tabelle holen 

STAA $42 ; und abspeichern 

TABELLE DC.B 0,1,4,9,16,25,36,49,64,81,100 

DC.B 121,144,169,196,225 

Addieren von 24-Bit-Zahlen 

org data 

eins dc.b 04,82,40 ; 1. Summand 

zwei dc.b 02,37,98 ; 2. Summand 

drei dc.b $00,$00,$00 ; Ergebnis 

org prog 

. 

. 

. 

ldaa eins+2 

adda zwei+2 

staa drei+2 

ldaa eins+1 

adca zwei+1 

staa drei+1 

ldaa eins+0 

adca zwei+0 

staa drei+0 

. 

. 

. 


Allgemeiner Vorspann für's Praktikum 163

Addition von 8-stelligen BCD-Zahlen 

Die 1. Zahl belegt den Speicherbereich $41 - $44 (LSB zuerst) 

Die 2. Zahl -"- $51 - $54 -"- 

Das Ergebnis wird auf die erste Zahl gespeichert 

LDAB #4 ; Zahlen sind 4 Byte lang = 8 Stellen 

LDX #$41 ; 1. Operand 

LDY #$51 ; 2. Operand 

CLRA ; Akku A (und Carry-Flag) löschen 

BCDADD LDAA 0,X ; zwei Ziffern des 1.Operanden holen 

ADCA 0,Y ; zwei Ziffern des 2.Operanden addieren 

INY 

DAA ; Dezimalkorrektur für BCD 

STAA 0,X ; Ergebnis abspeichern 

INX 

DECB 

BNE BCDADD ; solange, bis alle Stellen bearbeitet 

Zählen der negativen Elemente in einem Feld 

ANZAHL EQU 20 ; z.B. 20 Feldelemente 

FELD DS.B 20 ; Platz für 20 Werte 

COUNT DS.B 1 ; 1 Byte Zähler 

. 

. 

. 

CLRB ; Zähler für neg. Elemente löschen 

LDX #FELD ; X auf Feldanfang 

LDAA ANZAHL 

STAA COUNT ; Zähler setzen 

LOOP LDAA 0,X ; nächstes Feldelement 

BPL WEITER ; wenn positiv weiter 

INCB ; negative Elemente zählen 

WEITER INX 

DEC COUNT 

BNE LOOP ; bis alle Elemente getestet sind 

STAB COUNT ; Ergebnis in COUNT speichern 

Ein- und Ausgabe auf Ports 


Das folgende Programm liest die unteren 4 Bits von Port C ein und gibt sie auf Port B wieder aus, 

gleichzeitig blinken die oberen 4 Bits von Port C. 

. 

. 

. 

clr portb ; Portb auf 0 setzen 

ldab #%1010 ; Register B setzen 

ldaa #%11110000 ; Port C Richtungsregister setzen: 

staa ddrc ; Bits 0-3 Eingabe, 4-7 Ausgabe 

loop ldaa portc ; Port C lesen 

anda #$0F ; untere 4 Bits ausmaskieren 

staa portb ; auf Port B ausgeben 

stab portc ; Register B ausgeben 

eorb #%11110000 ; und Bits 4-7 invertieren 

bsr delay ; 0,5 s warten (siehe unten) 

jmp loop ; endlosschleife 

. 

. 

. 


Taste an PA7 einlesen 






portc equ $1005 ; port c data latch 











org data 

key ds.b 1 

org prog 

main lds #stack ; load stackpointer 

clr key 

ldaa #%01010000 ; pa7 freigabe pos. flanke 

staa pacr 

clra 

loop bsr taste 

ldaa key 

staa portb 

bra loop 

taste psha 

ldaa tflg ; taste gedrueckt? 

anda #$10 

beq tend ; nix gewesen 

ldaa #$10 

staa tflg ; Anforderung loeschen 

com key ; Ereignis melden 

tend pula 

rts 

org reset 

fdb main 

end 


16-Bit Schieberegister, Richtung per PA7-Taste umschaltbar 












pactl equ $1026 ; pulse accu control 







*************************** 

* data area * 

*************************** 

org data 

flag ds.b 1 

shift ds.b 2 

*************************** 


*************************** 

org prog 


clr flag 

ldaa #%01010000 ; pa7 Eingang, Freigabe, pos. Flanke 

staa pactl 

ldaa #$FF ; portc als Ausgabe 

staa ddrc 

clr shift ; Schieberegister mit 1 laden 

ldab #1 

stab shift+1 

loop bsr taste ; Tastenstatus abfragen 

ldaa flag ; flag = 0 - links, flag = ff - rechts 

bne rechts 

links ldd shift ; nach links schieben 

lsld 

bne raus ; falls 0, neu laden mit 1 im LSB 

ldab #1 

bra raus ; zur Ausgabe 

rechts ldd shift ; rechts schieben 

lsrd 

bne raus ; falls 0 mit 1 laden im MSB 

ldaa #$80 

raus std shift ; akt. Wert speichern 

staa portb ; und ausgeben (auf zwei 8-Bit-Ports) 

stab portc 

bsr delay 

bra loop 

rts 

taste psha ; Akku retten 

ldaa tflg ; Taste gedrueckt? 

anda #$10 

beq tend ; nix gewesen 

ldaa tflg 

oraa #$10 

staa tflg ; Anforderung loeschen 

com flag ; Ereignis melden 

tend pula ; Akku restore 

rts 

delay ldy #$ffff 

dely1 nop 

nop 

nop 

nop 

nop 



nop 

nop 

dey 

bne dely1 

rts 

*************************** 

* vectors * 

*************************** 

org rvec 

fdb main ; FFFE reset 

end 

Auf-/Abwärtszähler, Taste an STRA 

Der folgende Zähler zählt abhängig von der Variablen "tflag" aufwärts oder abwärts. Die Zählrichtung 

wird durch eine Taste am Eingang STRA umgeschaltet. 

; Vereinbarungen 




portb equ $1004 




ddrc equ $1007 


. 

. 

org data ; Datenbereich 

tflag ds.b 1 

. 

. 


org prog ; Programmbereich 

main lds #stack ; Stackpointer laden 

clr portb ; Ports/Variablen init. 

ldaa #1 ; tflag = 1 

staa tflag 

loop bsr count ; Hauptschleife, nur zwei UP-Aufrufe 

bsr taste ; Taste abfrage 

jmp loop ; auf/ab zaehlen 

; Zaehl-Unterprogramm 

; tflag wird addiert (tflag kann 1 oder -1 sein) 

count adda tflag ; zaehlen 

staa portb ; ausgeben 

bsr delay ; 0,5 s warten (siehe unten) 

rts 

; Tasten-Abfrage-UP 

; bei jedem Tastendruck wird tflag negiert (+1 -1, -1 +1) 

taste psha ; Akku A retten 

ldaa pioc ; Taste gedrueckt 

bpl njet ; nein fertig 

ldaa portcl ; dummy-read zum Ruecksetzend es Tastenbits in pioc 

neg tflag ; tflag negieren 

njet pula ; Akku A restaurieren 

rts 

. 

. 

. 


Alternativlösung mit bedingter Verzweigung 

loop bsr delay 

tst updn 

bne decr 

inc count 

ldaa count 

cmpa #$FF 

bne endf 

com updn 

bra endf 

decr dec count 

ldaa count 

tsta 

bne endf 

com updn 

endf ldaa count 

staa portb 

jmp loop 

BCD-Zähler mit Rücksetzen per STRA 


















*************************** 

* data area * 

*************************** 

org data 

flag ds.b 1 

*************************** 


*************************** 

org prog 


clra 

clr flag 

bsr init 

schl adda #1 ; BCD hochzaehlen 

daa 

anda #$0F 

bsr taste ; Taste abfragen 

psha ; a auf den stack 

lsla ; 4 x schieben 



lsla 

lsla 

lsla 

staa portc ; ausgeben 

pula ; a restore 

ldab flag ; Tastendruck bearbeiten 

stab portb ; auf Port B ausgeben 

bne weiter ; wenn nicht 0 

clra ; Zaehler loeschen 

com flag ; flag wieder setzen -> sonst "haengt" es 

weiter bsr delay 

bra schl 

init ldaa #$02 ; hands=0, raising edge 00000010 

staa pioc 

ldaa #%11110000 

staa ddrc 

rts 

delay ldy #$ffff 

dely1 nop 

nop 

nop 

nop 

nop 

nop 

nop 

dey 

bne dely1 

rts 

taste psha 

ldaa pioc ; taste gedrueckt (Bit 7)? 

bpl tend ; nix gewesen 

ldaa portcl ; dummy read --> Reset STAF 

com flag ; ereignis melden 

tend pula 

rts 

*************************** 

* vectors * 

*************************** 

org rvec 


end 

Software-Uhr 

Eine Software-Uhr wird in der Regel durch einen periodischen Interrupt (z. B. vom Timer) unterstützt. 

Bei jedem Interrupt wird ein Zähler incrementiert. Die Zählung erfolgt in Sekunden, Minuten und 

Stunden. Das im Vordergrund arbeitende Programm kann auf die Zeitinformation zugreifen. 

Die Bedienung des Timer-Interrupts wird hier nur angedeutet (da noch nicht behandelt). Der 

CLOCK-Interrupt wird im Beispiel alle 100 ms ausgelöst = 10 Tics/s. 

ZEHNTEL DS.B 1 ; 1/10 Sekunden 

SEKUNDEN DS.B 1 ; Sekunden 

MINUTEN DS.B 1 ; Minuten 

STUNDEN DS.B 1 ; Stunden 

. 

. 

. 



CLOCK 

* An dieser Stelle muß die 

* Timer-Hardware bedient werden 

INC ZEHNTEL ; 1/10 Sekunden erhöhen 

LDAA #10 

CMPA ZEHNTEL ; Sekunde erreicht? 

BNE ENDCLOCK ; nein - fertig 

CLR ZEHNTEL ; sonst 1/10 Sekunden auf 0 setzen 

INC SEKUNDEN ; und Sekunden erhöhen 

LDAA #60 

CMPA SEKUNDEN ; Minute erreicht? 


CLR SEKUNDEN ; sonst Sekunden auf 0 setzen 

INC MINUTEN ; und Minuten erhöhen 

CMPA MINUTEN ; Stunden erreicht? 


CLR MINUTEN ; sonst Minuten auf 0 setzen 

INC STUNDEN ; und Stunden erhöhen 

LDAA #24 

CMPA STUNDEN ; Tageswechsel? 


CLR STUNDEN ; sonst Stunden auf 0 setzen 

ENDCLOCK RTI ; Rücksprung 

Die Dauer der ISR beträgt im schlechtesten Fall weniger als 150 Taktzyklen. Da die ISR nur alle 100 

ms ausgelöst wird, ist die zusätzliche Belastung des Systems relativ gering (ca. 0,1%). 

Nützliche Unterprogramme 


Die folgenden Unterprogramme lassen sich in eigenen Programmen verwenden. 

Ergänzen eines ASCII-Codewortes auf gerade Parität 

EVENPAR PSHB ; Codewort zwischenspeichern 

CLRA ; Zaehler = 0 

ZHL LSRB ; naechstes Bit ins Carry holen 

ADCA #0 ; Carry zu A ddieren 

TSTB ; Restwort = 0? 

BNE ZHL ; nein, weiter 

PULB ; Codewort holen 

ASLB ; links schieben 

LSRA ; Parity-Bit ins Carry 

RORB ; Parity-Bit ins MSB vom Codewort 

RTS 

Nützliche Unterprogramme 170

Binärwert (0 - 15) zu ASCII konvertieren 

Unterprogramm zur Konvertierung eines Binärwertes (0 - 15) in die ASCII-Darstellung (z.B. für die 

Ausgabe am Terminal). Der Wert wird in Register A an das UP übergeben und das entsprechende 

ASCII-Zeichen wird vom UP wieder in A zurückgegeben. 

Der Abstand zwischen der Ziffer "9" und dem Buchstaben "A" beträgt im ASCII-Zeichensatz 7 

Zeichen, weshalb zwischen den Eingangswerten 0 - 9 und 10 - 15 unterschieden werden muss. Bei 

Werten größer 10 muss daher 7 addiert werden. 

* 

* Konvertierung Binär zu ASCII 

* Parameter in Akku A 

* 

BINASC ANDA #0F ; auf Werte zwischen 0 und 15 begrenzen 

CMPA #9 ; Wert 0 bis 9 ? 

BLS ZIF ; ja, dann direkt umwandeln 

ADDA #7 ; "A" - "9" - 1 = $41 - $39 - 1 = 7 

ZIF ADDA #$30 ; $30 = "0" (ASCII-Wert) 

RTS 

ASCII-Zeichen zu Binär konvertieren 


Unterprogramm zur Konvertierung eines ASCII-Zeichens (0 - 9, A - F) in einen Binärwert, z.B. bei 

der Eingabe von Zahlen über das Terminal. Das Zeichen wird in Akku A übergeben und der Wert 

wieder in A zurückgegeben. Das UP arbeitet invers zum obigen UP. Bei Fehleingabe (keine Ziffer) 

wird Akku A auf $FF gesetzt. 

* 

* Unterprogramm ASCII-Binär-Konvertierung (0 - 9, A - F) 

* Parameter in A 

* 

ASCBIN SUBA #$30 ; $30 = ASCII "0" 

BLO FEHL ; Erg. negativ keine Ziffer 

CMPA #9 ; kleiner oder gleich 9? 

BLS DONE ; dann fertig 

SUBA #7 ; "A" - "F" 10 - 15 

CMPA #10 ; kleiner als 10? 

BLO FEHL ; dann Fehler 

CMPA #15 ; größer 15? 

BLS DONE ; nein, fertig 

FEHL LDAA #$FF ; Fehlerflag setzen 

DONE RTS 

Binär zu ASCII-Decodierung (1, 2 oder 4 Stellen) 

Im Speicher liegen die Werte bekanntermaßen binär vor. Um einen Speicherinhalt oder eine Adresse 

auf der seriellen Schnittstelle (Terminal) oder einem LC-Display ausgeben zu können, müsen die 

Werte als ASCII-Zeichen dargestellt werden. 

Die folgenden vier miteinander verbundenen Unterprogramme erweitern das Beispiel oben und 

wandeln einen 16-Bit-Wert, einen 8-Bit-Wert (Byte) oder einen 4-Bit-Wert (Nibble) in eine 

Hexadezimalzahl in ASCII-Darstellung um (4, 2, oder 1 Stelle): 

• hx4a wandelt den Inhalt von Akku D in vier ASCII-Zeichen, die in einem 4 Byte langen 

Puffer abgelegt werden. Beim Unterprogrammaufruf muß das Indexregister Y auf die letzte 

Stelle des Puffers zeigen. 

• hx2a wandelt den Inhalt von Akku B in zwei ASCII-Zeichen, die in einem 2 Byte langen 





• hx1a wandelt den Inhalt von Akku B (Bits 0-3) in ein ASCII-Zeichen, das in einem 1 Byte 

langen Puffer abgelegt wird. Beim Unterprogrammaufruf muß das Indexregister Y auf den 

Puffers zeigen. 

Diese Unterprogramme werden beim vierten Praktikumstermin benötigt. 

hx4a psha ; Akku A auf dem Stack ablegen 

bsr hx2a ; Akku B umwandeln (Stelle 3 und 4) 

pulb ; Akku A vom Stack holen, in Akku B ablegen 

; Nun einfach in hx2a fallen und Akku B 

; umwandeln (Stelle 1 und 2) 

hx2a pshb ; Akku B aud dem Stack sichern 

bsr hx1a ; Bits 0-3 von Akku B umwandeln 

pulb ; Original-Akku B wieder holen 

lsrb ; viermal schieben (Bits 4-7 --> 0-3) 

lsrb 

lsrb ; und nun die obere Haelfte umwandeln 

lsrb ; indem einfach in hx1a gefallen wird 

; Nun wird die eigentliche Arbeit gemacht: 

hx1a andb #$0F ; die oberen 4 Bita ausmaskieren 

addb #48 ; ASCII-Wert von "0" addieren 

cmpb #57 ; groesser als "9"? 

bls hx1b ; nein, dann speichern 

addb #7 ; sonst die Distanz zwischen "9" und "a" addieren 

hx1b stab 0,y ; Im Speicher ablegen, auf den Y zeigt 

dey ; Y zeigt jetzt auf die Stelle davor 

rts ; und weg 

Überlesen von Leerzeichen am Anfang einer Zeichenkette 

Nach Ausführung zeigt X auf das erste Zeichen != ' '. Der String muß mit einem Zeichen != ' 

' abgeschlossen sein. 

LDX #STRING ; Beginn der Zeichenkette 

CHECK LDAA 0,X ; Zeichen lesen 

INX ; X erhoehen 

CHECK CMPA #$20 ; Leerzeichen? 

BEQ CHECK ; Ja, weiter testen 

DEX ; nein, Zeiger korrigieren 

. 

. 

. 

STRING DC.B ' Zeichenkette mit 4 Leerzeichen am Anfang' 

DC.B 0 Abschlußzeichen 

Beispiel: Vergleich zweier Zeichenketten (Strings) 

Die Adressen der beiden Zeichenketten werden in X und Y übergeben. Als Ergebnis wird Akku A 

verwendet - 0: Strings sind ungleich, FF: Strings sind gleich 

; Vergleich zweier Strings, Anfangsadressen in X und Y 

; Ergebnis wird in Akku A zurueckgegeben (0: ungleich, FF: gleich) 

vergl ldaa 0,X ; Zeichen aus String 1 vergleichen 

cmpa 0,Y ; mit Zeichen aus String 2 

bne ver0 ; Strings ungleich, fertig 

cmpa #0 ; Stringende 

beq ver1 ; Strings sind gleich, fertig 

inx ; naechstes Zeichen 

iny 

bra vergl 

ver1 ldaa #$ff 

rts 


ver0 clra 

rts 

Delay-Routine 

Das folgende Unterprogramm erlaubt längere Verzögerungszeiten als das in Kapitel 3 vorgestellte, da 

hier das 16-Bit-Register X verwendet wird. "delay" dauert 4 + 3 + $f422*16 + 4 + 5 + 5 Taktzyklen, 

was einer Wartezeit von 8,5 + $f422*8 µs = 499992,5 µs entspricht - also ungefähr 0,5 s. 

delay pshx ; Register x retten, 4 cycl 

ldx #$f211 ; Anfangswert laden, 3 cycl 

delay1 nop ; 5 x nop = 10 cycl 

nop 

nop 

nop 

nop 

dex ; X runterzaehlen, 3 cycl 

bne delay1 ; 3 cycl 

pulx ; Register restaurieren, 5 cycl 

rts ; 5 cycl 

Delay-Routine - Angabe der Frequenz 

Die Frequenz wird in Akku B übergeben (Werte zwischen 1 und 15). 

delay clra ; Akku D: Akku A = 0, Akku B = Wert 

andb #$0F 

beq del_end ; Division durch 0 verhindern 

ldx #$FF00 ; Wert fuer 1 Hz --> X 

xgdx ; Schalter in X, 1-Hz-Wert in D 

idiv ; D/X 

delay1 nop 

nop 

nop 

nop 

nop 

nop 

nop 

dex 

bne delay1 

del_end rts 

Demo 16-Bit-Tabellenzugriff 

Die Variablen sek und zsek werden gemeinsam aus einer Tabelle belegt. Die Auswahl des 

Tabellenelementes erfolgt über 4 Schalter an Port C. 

org data 

sek ds.b 1 

zsek ds.b 1 


org prog 

main lds #stack ; Initialisierung 

clr portb 

ldaa #%11110000 ; Bits 0-3 als Eingang 

staa ddrc 

loop ldab portc ; Schalter einlesen 

andb #$0F 

lslb ; Akku B * 2, weil 16-Bit-Zugriff 

; (jeweils 2 Byte) 

ldx #tabelle ; Tabellenzugriff: X zeigt aus Tab.-Anfang 


abx ; aktuelle Position: B + X 

ldd 0,X ; Wert laden 

std sek ; Sekunden in sek, 1/10 in zsek 

jmp loop 

* 0 1 2 3 4 5 6 7 

tabelle dc.b 0,0, 2,5, 4,0, 10,0, 15,5, 20,0, 25,3, 31,4, 

* 8 9 10 11 12 13 14 15 

dc.b 40,0, 51,2, 60,0, 65,8, 72,4, 80,1, 85,7, 95,3 

Zufallszahlen 

Bei C gibt es in der Regel eine Random-Funktion, die Pseudo-Zufallszahlen liefert. In Assembler 

muss man, sofern es keine passende Bibliothek gibt, selbst eine entsprechende Funktion 

programmieren. Im Folgenden wird eine typische Form der Implementierung verwendet, um 

8-Bit-Zufallszahlen zu generieren. Es handelt sich um die 16-Bit-Variante der klassischen Formel S' = 

S * M + A. Als Zufallswert wird das Highbyte der 16-Bit-"Seed" des Zufallsgenerators im Akku A 

zurückgegeben. Für die Konstanten werden die Werte M = 181 und A = 359 aus folgenden Gründen 

gewählt: 

• Beide Werte sind Primzahlen. 

• Die Gleichung durchläuft mit diesem Werten alls 65 536 möglichen Werte für die "Seed". 

• Es gibt keine Wiederholungen von Sequenzen mit 4 oder mehr Werten 

• Die Random-Werte sind relativ gleichverteilt 

Die Funktion benötigt wenig Speicherplatz und nur 4 Byte RAM. Mit dem Unterprogramm RndInit 

wird der Anfangswert der "Seed" auf Null gesetzt. Sie können aber auch jeden beliebigen 

Anfangswert verwenden - etwa den Eingangswert eines A/D-Wandler-Ports. 





pcdd equ $1007 ; Adressen Port C 


* Random-Constants: 

RndMult equ 181 ; Multiplikationsfaktor 

RndAdd equ 359 ; zu addierender Offset 

org data 

RndSeed ds.b 2 ; 2 Byte Random Seed 

RndTmp ds.b 2 ; temporaerer Speicher 

org prog 


ldaa #$FF 

staa pcdd ; Port C als output 

clr pcdr 

bsr RndInit ; Seed = 0 

loop bsr Random ; A = random number 

staa pcdr ; A -> Port C 

bsr Delay ; wait 

bra loop 

* Initialize the random number generator 

RndInit clr RndSeed 

clr RndSeed+1 

rts 



* Return the next 8-bit pseudo random number 

* Berechnet SEED = SEED * 181 + 359 

* return high byte of the new SEED in A 

* Return value: The A register. 

Random pshb ; save B 

* scratch = seed * RndMult 

ldaa #RndMult ; A = #181 

ldab RndSeed+1 ; B = low byte of the seed 

mul ; D = A x B 

std RndTmp ; scratch = D 

ldaa #RndMult ; A = #181 

ldab RndSeed ; B = high byte of the seed 

mul ; D = A x B 

* low byte of mult. result is added to the high byte of scratch 

addb RndTmp ; B = B + scratch_high 

stab RndTmp ; scratch = seed * 181 

ldd RndTmp ; D = scratch 

addd #RndAdd ; D = D + 359 

std RndSeed ; save new seed value 

* A holds RndSeed from addition 

pulb ; retore B 

rts 

* Delay wie ueblich ... 

Delay LDX #$FFFF 

LoopX DEX 

BNE LoopX 

RTS 


dc.w main 

Komplette Programmbeispiele 

Die folgenden Programme sind vollständig und lassen sich direkt assemblieren, simulieren und im 

Zielsystem ausführen. 

Ausgabe beliebiger Bitmuster 


Es wird ein Array mit Bitmustern angelegt ("muster"), die nacheinander auf Port B ausgegeben 

werden. Ein Nullbyte markiert das Ende des Arrays. Wenn dies erreicht ist, beginnt die Ausgabe 

wieder beim ersten Element. Das Array ist beliebig erweiterbar. 

prog equ $8000 ; Vereinbarungen 





org prog 

main lds #stack 

ldx #muster ; X verweist auf das erste Feldelement 

loop ldaa 0,x ; erstes Feldelement laden 

bne ausg ; wenn nicht 0, ausgeben 

ldx #muster ; sonst wieder zum ersten Element 

bra loop ; ohne Ausgabe 

ausg staa portb ; Bitmuster ausgeben 

jsr delay ; 0,5 s warten 

inx ; naechstes Element 

bra loop 

delay pshx ; Delay, siehe oben 

ldx #$f422 

delay1 nop 

Komplette Programmbeispiele 175

nop 

nop 

nop 

nop 

dex 

bne delay1 

pulx 

rts 

muster dc.b %11110000, %01111000, %00111100, %00011110 

dc.b %00001111, %00011110, %00111100, %01111000 

dc.b %0 

org reset ; Reset-Vektor setzen 

fdb main 

end 

Dezimal zu Siebensegment Codierung 

Der Inhalt von Akkumulator B soll in die Siebensegmentdarstellung gemäß untenstehender Abbildung 

umcodiert werden. Der erzeugte Code wird ebenfalls in Akku B zurückgegeben. Bei Werten größer 9, 

soll B mit $FF besetzt werden. 






org data 

count ds.b 1 


org prog 

main lds #stack 

clr count ; Speicher loeschen 

loop ldab count ; Schleifenbeginn, count mod 16 hochzaehlen 

incb 

andb #$0F 

stab count 

bsr umco ; Count in Akku B wird umcodiert, Ergebnis in Akku B 

stab portb ; und ausgeben 

jsr delay ; 0,5 s warten 

bra loop 

; Umcodierung binaer --> 7-Segment, eingabe und Ausgabe in Akku B 

umco ldx #umcotab ; Tabellenadresse laden 

andb #$0F ; fuer B nur Werte 0 - F zulassen 

abx ; X = X + B 

ldab 0,x ; 7-Sement-Wert holen, Adressierung durch X-Register 

rts 


delay pshx ; Delay, siehe oben 

ldx #$f422 

delay1 nop 

nop 

nop 

nop 

nop 

dex 

bne delay1 

pulx 

rts 

; Siebensegment-Tabelle (Segmentanordnung: -abcdefg) 

; Die Ziffern "0" bis "9" sind decodiert, fuer "A" bis "F" 

; wird nur ein "-" angezeigt --> noch zu ergaenzen 

umcotab dc.b %01111110, %00110000, %01101101, %01111001 

dc.b %00110011, %01011011, %01011111, %01110000 

dc.b %01111111, %01111011, %00000001, %00000001 

dc.b %00000001, %00000001, %00000001, %00000001 

org reset 

fdb main 

end 

Serielle Eingabe mit Backspace und Ignorieren von Zeichen < " " 

gets stx pufanf 

gets0 bsr recv 

cmpb #cr 

beq gets1 

cmpb #bs 

beq gets2 

cmpb #' ' ; Zeichen < ' ' ignorieren 

blo gets0 

bsr send 

stab 0,x 

inx 

bra gets0 

gets1 clrb ; Newline - Eingabeende 

stab 0,x ; Nullbeit als Abschluss 

bsr crlf ; cr + lf ausgeben 

rts 

gets2 cpx pufanf ; Backspace 

beq gets0 ; nur bis Pufferanfanng zurück 

dex 

ldab #bs ; BS , Leer, BS ausgeben 

bsr send 

ldab #' ' 

bsr send 

ldab #bs 

bsr send 

bra gets0 

; cr+lf ausgeben 

crlf ldab #cr 

bsr send 

ldab #lf 

bsr send 

rts 



Kommandoeingabe über die serielle Schnittstelle 

; Vereinbarungen 









scdr equ $102f 

scsr equ $102e 

sccr1 equ $102c 

sccr2 equ $102d 

baud equ $102b 


; ASCII-Zeichen 

cr equ 13 

lf equ 10 

org prog 

main lds #stack ; Initialisierungen 

bsr sini 

loop ldx #cmd ; Prompt ausgeben 

bsr ssend 

bsr recv ; Befehl (1 Zeichen) einlesen 

cmpa #'a' ; ist es 'a'? 


bsr doit ; Kommando 'a' verarbeiten 

bra loop 

next1 cmpa #'b' ; ist es 'b'? 


bsr doit ; Kommando 'b' verarbeiten 

bra loop 

next2 cmpa #'c' ; ist es 'c'? 


bsr doit ; Kommando 'c' verarbeiten 

bra loop 

next3 ldx #oops ; falsche Eingabe: "Oops" ausgeben 

bsr ssend 

bra loop 

; Kommandobearbeitungsroutine, hier als Dummy 

doit psha ; Kommandobearbeitung, erst Akku A retten 

ldx #k1 ; Text "Eingabe war" ausgeben 

bsr ssend 

pula ; Akku A wiederherstellen 

suba #$20 ; Kleinbuchstaben in Grossbuchstaben wandeln 

bsr send ; ausgeben 

bsr crlf ; "neue Zeile" ausgeben 

rts 

; Carriage Return und Line Feed ausgeben 

crlf ldaa #cr 

bsr send 

ldaa #lf 

bsr send 

rts 


; String ausgeben (ohne cr/lf am Ende), Stringadresse (erstes Zeichen) 


; muss in Register X uebergeben werden (siehe Kapitel 5) 

ssend ldaa 0,x 

beq sfin 

bsr send 

inx 

bra ssend 

sfin rts 

; serielle Schnittstelle initialisieren (siehe Kapitel 5) 

sini clr sccr1 

ldaa #$0C 

staa sccr2 

ldaa #$30 

staa baud 

rts 

; Zeichen seriell ausgeben (siehe Kapitel 5) 

send ldab scsr 

bpl send 

staa scdr 

rts 

; Zeichen seriell empfangen (siehe Kapitel 5) 

recv ldab scsr 

andb #$20 

beq recv 

ldaa scdr 

rts 

; String-Konstanten (Strings werden durch ein 0-Byte abgeschlossen) 

cmd dc.b 'Kommando: ' 

dc.b 0 

oops dc.b 'Oops!' 

dc.b cr,lf,0 

k1 dc.b 'Eingabe war ' 

dc.b 0 

org reset ; Reset-Vektor setzen 

fdb main 

end 

Demo für den Timer-Interrupt 

Das Programm zählt eine Variable "count" interruptgesteuert hoch. 








tvec equ $FFDE ; interrupt vector of timer 




org data 

count ds.b 1 

cflg ds.b 1 

org prog 

main lds #stack ; init variables 

clr portb 



clr count 

clr cflg 



ldab #$80 

stab tmsk 

cli ; enable interrupts 





inc count ; count up 

ldaa count 

staa portb ; display counter 

bra loop 

; interrupt service routine 

tirq ldaa #$80 



rti 

org tvec ; set interrupt vector 

fdb tirq ; DE timer overflow 

org reset ; set reset vector 

fdb main 

end 

Demo für Interrupt an STRA 














*************************** 

* data area * 

*************************** 

org data 

flag ds.b 1 ; irq flag 

*************************** 


*************************** 

org prog 




loop ldaa flag 



staa pbdr ; display 


*************************** 


*************************** 

init clr flag 


stab pioc 

rts 

*************************** 


*************************** 

sirq ldaa pioc ; stra isr 

ldaa portcl ; clear interrupt 

com flag 

rti 

*************************** 

* vectors * 

*************************** 

org svec 


org rvec 


end 

Demo für Interrupts an STRA und PA7 



















*************************** 

* data area * 

*************************** 

org data 

flag ds.b 1 ; irq flag 

*************************** 


*************************** 



org prog 




loop ldaa flag 

staa pbdr ; display 


*************************** 


*************************** 

init clr flag 


stab pioc 


stab pacr 

ldab #$10 

stab tmsk 

rts 

*************************** 


*************************** 



ldaa flag 

eora #$0F ; toggle lower nibble 

staa flag 

rti 

pirq ldaa #$10 ; pa7 isr 


ldaa flag 

eora #$F0 ; toggle upper nibble 

staa flag 

rti 

*************************** 

* vectors * 

*************************** 

org pvec 

fdb pirq ; PA7 interrupt 

org svec 


org rvec 


end 

Demo für Interrupts an STRA, PA7 und Timer 
















*************************** 

* data area * 

*************************** 

org data 


cflg ds.b 1 ; clock flag 

updn ds.b 1 ; direction flag 

stop ds.b 1 ; stop flag 

*************************** 


*************************** 

org prog 








tst stop ; stop active? 

bne loop ; yes, wait 

bsr count ; update counter 


*************************** 


*************************** 

count ldaa coun ; load counter 

adda updn ; inc/dec counter 

staa coun ; save counter 

staa pbdr ; display counter 

rts 

init clr coun ; counter default 

clr cflg ; no clock seen 

clr stop 

ldaa #1 

staa updn ; default count up 


stab pioc 



ldab #$90 ; $80 (Timer) + $10 (PA7) 

stab tmsk 

rts 

*************************** 


*************************** 



tirq ldaa #$80 ; timer isr 



rti 



neg updn ; toggle direction 

rti 

pirq ldaa #$10 ; pa7 isr 


com stop ; toggle stop flag 

rti 

*************************** 

* vectors * 

*************************** 

org pvec 

fdb pirq ; PA7 

org tvec 

fdb tirq ; timer overflow 

org svec 


org rvec 


end 



Letzte Aktualisierung: 02. Jul 2012 



Prof. Jürgen Plate, Prof. Peter Schwalb 


Praktikum Mikrocomputer 

Allgemeines 

Im Rahmen dieses Praktikums sollen einfache Programme in Maschinensprache erstellt und auf dem 

Mikrocomputer PS11 erprobt werden. Dabei werden neben dem Einüben des Befehlsvorrats eines 

typischen Mikroprozessors die Problematiken der Unterprogrammtechnik, Stackbehandlung, 

Unterbrechungsbehandlung und Behandlung von parallelen und seriellen Schnittstellen untersucht. 

Ergänzende Zusatzschaltungen werden in TTL-Technik aufgebaut. 

Der Mikrocomputer PS11 baut auf dem Mikrocontroller M68HC11 (8MHz) von Motorola auf. Er 

wird im expanded mode betrieben und ist mit einer PRU M68HC24, 32kByte RAM und 32 kByte 

EEPROM als externen Komponenten versehen. Die Programmentwicklung erfolgt auf einem PC unter 

Verwendung eines unter Windows XP laufenden Programmpakets (Integrated Development 

Environment for M68HC11). Dieses ermöglicht das Editieren, Assemblieren, Simulieren und 

Bereitstellen von Programmen für den M68HC11. Der Datentransfer zwischen PC und Zielrechner 

erfolgt über eine serielle Schnittstelle (COM-Port COM1 mit 9600 Baud). 

Die Angaben zu den einzelnen Versuchen sind als thematischer Rahmen zu sehen. Die 

Aufgabenstellung kann durch den betreuenden Dozenten jederzeit modifiziert werden. Im Verlauf des 

Versuchs ist auf eine vernünftige Dokumentation zu achten. 

Installation der IDE-Software 

Die Programme des Pakets HC11-IDE.zip benötigen keine spezielle Installation, sondern laufen unter 

Windows (ab XP) wie sie sind. Um sich das Leben zu erleichtern, können Sie das Paket jedoch in die 

übliche Windows-Umgebung einbinden: 

• Unter C:\Programme (bzw. C:\Program Files) legen Sie ein Verzeichnis namens 

"HC11-IDE" an. 

• Entpacken Sie alle Programme der ZIP-Datei in dieses Verzeichnis. Das war's eigentlich 

schon. 

• Erzeugen Sie sich eine Verknüpfung des Programms scite.exe auf dem Desktop für den 

schnellen Zugriff. Wer will, kann auch noch eine Verknüpfung in der Taskleiste anlegen. 

• Unter Windows 7 erhalten Sie beim Beenden des Simulators eine Fehlermeldung. Das 

Problem kann behoben werden, indem Sie auf die Datei wookie182upx.exe mit der rechten 

Maustaste klicken und im Menü dann "Behandeln von Kompatibilitätsproblemen" klicken - 

Windows erledigt den Rest. 

• Anstelle des Windows Hyperterminals kann auch das Programm PuTTY für die serielle 

Kommunikation auf der PC-Seite verwendet werden. Sie erhalten die aktuelle Version unter 

http://www.putty.org/. Auch dieses Programm benötigt keine spezielle Installation. 

Einschalten und Starten 

Der Arbeitsplatz ist über den Sicherungsautomaten, der PC über den Netz-Taster am PC-Gehäuse und 

das Testobjekt mittels seines Netzschalters in der Rückwand einzuschalten. Achtung: Zum 

Ausschalten dient der kleine rechteckige, rote Knopt am Sicherungsautomaten, nicht der 

Not-Aus-Taster! Nach dem Start von Windows XP sind Benutzername und Kennwort einzugeben. 

Benutzername (user): ide11 

Kennwort (password): ide11 

Praktikum Mikrocomputer 185

Das Programm HC11-IDE11 wird durch klicken auf das entsprechende Icon gestartet. Wenn Sie 

IDE11 mehr als einmal starten, verweigern alle Inkarnationen des Programms den Kontakt zum 

M68HC11. In diesem Fall sind alle laufenden Versionen zu schließen und das Programm einmal neu 

zu starten. 

Programm-Namen und Ordner SAVE 

Quellprogramme (Sourcecodes) sind immer mit der Kennung (Extension) ".a" zu versehen (z. B. 

"versuch1_1.a"), da Editor und Assembler des Systems diese Kennung erwarten. 

Die im Laufe eines Praktikums-Versuchs erstellten (name.a) oder erzeugten (name.lst) Dateien sind 

über den Ordner (Directory) Eigene Dateien verfügbar. Sie können von dort aus auf Diskette oder 

einem USB-Massenspeicher abgespeichert werden. Wenn Sie vorbereitete Programme auf Diskette 

oder USB-Massenspeicher mitbringen, dann speichern Sie diese auch immer in diesem Ordner ab. 

Beenden und Abschalten 


Wurde IDE11 versehentlich beendet, kann es über Doppelklicken des Symbols (Icon) des 

Arbeitsplatzes (Desktop) wieder gestartet werden. 

Der Praktikumsrechner PS11 ist nicht auszuschalten, sondern nur herunterzufahren: 

(START Wurde HC11-IDE11 versehentlich beendet, kann es über Doppelklicken des Symbols (Icon) 

des Arbeitsplatzes (Desktop) wieder gestartet werden. Der Praktikumsrechner PS11 ist nicht 

auszuschalten, sondern nur herunterzufahren: (START → Computer ausschalten). 

Bearbeiten eines Quellprogramms 

Einschalten und Starten 186

File → New 

Erzeugt ein leeres Editorfenster mit dem Namen "Untitled". Beim ersten Speichern wird ein SAVE AS 

ausgeführt. 

File → Open 

Eine Datei (Quellprogramm) kann aus dem Arbeitsverzeichnis ausgewählt und geöffnet werden. Für 

die Bearbeitung der Datei mittels Tasten und Maus (Markieren, Kopieren, Verschieben, etc.) gelten 

die üblichen Regeln. Weitere Funktionen werden im Menue "EDIT" angeboten. Es können auch 

mehrere Fenster geöffnet werden. Die Bearbeitungsvorgänge beziehen sich immer auf das aktive 

(oben liegende) Fenster. 

File → Save 

Speichert den Inhalt des aktiven (oben liegenden) Editorfensters als Textdatei. Ist der Dateiname noch 

nicht festgelegt, wird ein "SAVE AS"-Befehl ausgeführt und der Dateiname erfragt. 

File → Save As 


Erfragt den gewünschten Dateinamen und speichert den Inhalt des aktiven (oben liegenden) Fensters 

als Textdatei (name.a). 

Erst nachdem die Datei mit der Erweiterung .a abgespeichert wurde wird das Syntax Highlighting 

aktiviert: 

Übersetzen eines Quellprogramms (source code) 

Bearbeiten eines Quellprogramms 187

Tools → Assemble 

Der Start des Assemblers erfolgt über das Menü "Tools" im Editor. Ein neues oder verändertes 

Quellprogramm im aktiven Fenster wird abgespeichert und anschließend übersetzt. Bei fehlerfreiem 

Ablauf der Übersetzung werden ein Zielprogramm (name.s19) und ein Programmlisting (name.LST) 

erzeugt. Eine gegebenenfalls erzeugte Fehlerliste wird im Ausgabe-Fenster (unterhalb des 

Editor-Fensters) angezeigt. Durch Doppelklick auf den angezeigten Fehler (Error: xxxxx) wird im 

Quellprogamm die fehlerhafte Zeile markiert. 

Anmerkung: Lassen Sie sich nicht durch die letzte Ausgabezeile des Editors ( → Exit-Code: 0) 

täuschen, diese besagt nur, dass das Assemblerprogramm nicht abgestürzt ist. 

Simulieren eines Zielprogramms (object code) 

Tools → Simulate 


Der Start des Simulators erfolgt ebenfalls über das Menü "Tools" im Editor. Das Zielprogramm wird 

in den Simulator geladen. Hier kann das Programm in einem simulierten PS11 System erprobt werden. 

Übersetzen eines Quellprogramms (source code) 188


Der Simulator ist nicht in der Lage, alle Eigenschaften des 68HC11 exakt nachzubilden. So müssen 

Sie auf manche Interrupts und einiges andere verzichten. So ist derzeit keine umfassende Simulation 

der seriellen Schnittstelle möglich. 

Bei der Simulation des STRA-Eingangs mit dem Button [STRA = 0] ist folgendes zu beachten: 

• Mit jedem Anklicken wechselt der Zustand der (virtuellen) STRA-Eingansleitung zwischen 0 

und 1. 

• Um eine Flanke zu erzeugen, wie es der Taster auf dem Steckbrett bewirkt, muss deshalb 

zweimal auf den Button geklickt werden. 

Ähnlich verhält es sich beim Eingang PA7. Hier holen Sie sich den Port A auf die Arbeitsfläche des 

Simulators und klicken auf das höchstwertige Bit (7). Auch hier muss, um eine Flanke zu erzeugen, 

wie es der Taster auf dem Steckbrett bewirkt, zweimal auf das Bit geklickt werden. 

Je nach verwendetem PC-Modell kann es auch vorkommen, dass Zeitschleifen im Simulator schneller 

ablaufen, als dies bei einem realen Prozessor der Fall wäre. 

Beachten Sie auch, dass die Simulation des seriellen Terminals sehr einfach gehalten ist. So werden 

zum Beispiel alle Zeichen bei der Eingabe geechot, was im realen Betrieb nicht der Fall sein muss. 

Zum Starten eines Programms klicken Sie auf "Reset" und dann auf den "Start"-Button, der daraufhin 

grün wird. Im gestoppten Zustand kann das Programm im Einzelschritt-Modus durchlaufen werden. In 

diesem Fall öffnen Sie durch Klicken auf die entsprechenden Buttons die Fenster mit der 

Quellcodeanzeige ("View Code") und der Registeranzeige ("MC68HC11 CPU"). Die gerade 

Simulieren eines Zielprogramms (object code) 189

earbeitet Assemblerzeile wird dann farbig unterlegt und Sie können die aktuellen Registerinhalte 

sehen (oder auch ändern). Mit "Browse Memory" werden Sie in die Lage versetzt, Speicherinhalte 

anzusehen und zu ändern. 

Die zusätzlich zur Binäranzeige vorhandene Siebensegmentanzeige für die Ports B und C bietet eine 

undecodierte Anzeige für Port B (alle Segmente einzeln ansteuerbar) und eine decodierte zweistellige 

Anzeige für Port C. 

Tools → Load in Target 

Das Zielprogramm, das zu dem im aktiven Fenster angezeigten Quellprogramm gehört, wird in den 

Speicher des Zielrechners übertragen (aber nicht gestartet). Dazu muß der Schalter am Zielsystem auf 

"PC" stehen. Zum Programmstart drücken Sie die RESET-Taste am Zielrechner. 

Arbeiten mit der seriellen Schnittstelle 

Bei Programmen, die die serielle Schnittstelle verwenden, im mit dem Terminalprogramm auf dem PC 

(z.B. Hyperterminal oder PuTTY) zu kommunizieren ist der Schalter am Zielsystem auf "Man." 

umzustellen, bevor die RESET-Taste gedrückt wird. Das Terminalprogramm muss online sein 

(Telefonhöhrer abgehoben). 

Beim Laden des Programms ins Zielsystem muss der Schalter wieder auf "PC" gestellt werden. 

Achten Sie auch darauf, das ein gegebenenfalls geöffnetes Terminalprogramm auf "aufgelegt = 

offline" geschaltet wird, da sonst ein Konflickt beider Programme um die serielle Schnittstelle 

entsteht. Das Terminalprogramm muss jedoch nicht geschlossen werden. 

In Kurzform: 

RUN: Terminal online, Schalter auf "Man." 

LOAD: Terminal offline, Schalter auf "PC 

Hinweise zur Programmerstellung 


Jedes Programm muß folgende Anweisungen enthalten: 

stak equ $7FFF ; Stackbereich ab $7FFF (RAM, abwaerts) 

prog equ $8000 ; Programmbereich ab $8000 (EEPROM) 

data equ $2000 ; Datenbereich ab $2000 (RAM) 

rvec equ $FFFE ; Reset-Vektor 

. ; ggf. weitere Vektoren 

org data ; Beginn Datenbereich 

. ; Variablen-Definitionen 

. 

org prog ; Beginn Programmbereich 

main lds #stak ; Stackpointer setzen 

. 

. ; alle Initialisierungen 

. 

loop . ; Befehle des Programms 

. 

. 

jmp loop 

. ; ggf. fixe Tabellen dahinter 

. 

. ; ggf. Setzen der Interrupt-Vektoren 

Tools → Load in Target 190

. ; (Reihenfolge der Adressen beachten!) 

org rvec ; Setzen des Reset-Vektors 

fdb main 

end 

Der RAM-Speicher ab Adresse 0 bis Adresse 255 kann nicht genutzt werden (Bootloader bzw. 

Trace). 

Tools → Terminal 


Der Datenverkehr zwischen dem PC und dem Zielrechner über die serielle Schnittstelle wird mittels 

des Terminalprogramms Hyperterm am PC dargestellt. Damit kann der Datenverkehr über die 

SCI-Schnittstelle interaktiv erfolgen. 

Hinweise zur Programmerstellung 191


Belegung des Experimentier-Boards 

Auf dem Experimentierboard steckt eine Anzeigeplatine (die getrennt vom Board mit Strom versorgt 

werden muß). Die Platine enthält vier decodierte und eine undecodierte Siebensegmentanzeigen. Ihre 

Belegung zeigt die folgene Abbildung: 

Das Anschlußkabel zwischen M68HC11 und Experimentierboard endet auf einem Buchsenfeld, von 

dem aus die Verbindungen zur Anzeigeplatine bzw. zu den Schaltern, Tastern und LEDs gesteckt 

werden müssen. 

Belegung des Experimentier-Boards 192


Beachten Sie, daß die LED-Treiber an der Vorderkante des Boards sowie das Board mit den 

Siebensegmentanzeigen gesondert mit Spannung versorgt werden muß. Ihr Betreuer zeigt Ihnen die 

entsprechenden Verbindungen am ersten Praktikumstag. 

Beschaltung der Eingänge des 68HC11 

Die Schalter des Experimentier-Boards haben keine aktive Spannungsversorgung sondern schalten 

lediglich das Massepotential wechselweise auf zwei Anschlußbuchsen. Verbindet man einen Schalter 

mit dem Eingang eines Ports des 68HC11, dann wird - je nach Schalterstellung - der Port mit Masse 

verbunden oder der Porteingang ist offen. Aus diesem Grund muß die Leitung vom Schalter zum 

Eingangsport des 68HC11 mittels Pull-Up-Widerstand ein 1-Potential erhalten. 

Sie finden auf dem Experimentier-Board auf einer der IC-Buchsen ein Widerstandsarray (WID-SIP) 

eingesteckt, das acht Widerstände enthält, die auf einer Seite miteinander verbunden sind. Dieser 

gemeinsame Anschluß ist auf dem Gehäuse des WID-SIP durch einen Punkt gekennzeichnet. Er wird 

mit +5V verbunden. Die anderen Pins des WID-SIP werden einerseits mit einem Schalter verbunden 

und andererseits mit einem Eingansport des 68HC11. 

Beschaltung der Eingänge des 68HC11 193


Die beiden Taster sind bereits mit einer Entprell-Logik verbunden und liefern korrekte Digitalsignale 

für 0 und 1. Sie können daher direkt mit einem Eingangspin des 68HC11 verbunden werden. 

Beschaltung der Eingänge des 68HC11 194

Anhang: Binär zu ASCII-Decodierung (hx4a) 

Diese Unterprogramme werden beim vierten Praktikumstermin benötigt. Im Speicher liegen die Werte 

bekanntermaßen binär vor. Um einen Speicherinhalt oder ene Adresse auf der seriellen Schnittstelle 

(Terminal) oder einem LC-Display ausgeben zu können, müsen die Werte als ASCII-Zeichen 

dargestellt werden. 

Die folgenden vier miteinander verbundenen Unterprogramme wandeln einen 16-Bit-Wert, einen 

8-Bit-Wert oder einen 4-Bit-Wert in eine Hexadezimalzahl in ASCII-Darstellung um (4, 2, oder 1 

Stelle): 








langen Puffer abgelegt wird. Beim Unterprogrammaufruf muß das Indexregister Y auf den 







hx2a pshb ; Akku B auf dem Stack sichern 




lsrb 




hx1a andb #$0F ; die oberen 4 Bits ausmaskieren 





hx1b stab 0,y ; im Speicher ablegen, auf den Y zeigt 


rts ; und weg 

Beispielaufruf: 

Versuche 

ldd #$AFFE ; Hexzahl in Akku D laden 

ldy #PUFFER+3 ; Position auf letzte Stelle im Puffer 

; der Puffer muss im Datenbereich reserviert sein 

bsr hx4a ; do it! 

ldy #PUFFER ; y --> Pufferanfang 

bsr STOU ; z.B. seriell ausgeben 


Letzte Aktualisierung: 20. Feb 2011, 16:49:01 


Anhang: Binär zu ASCII-Decodierung (hx4a) 195




Mikrocomputertechnik 196

Praktikum Mikrocomputer 

Versuch 1: Parallel-Ports, Unterprogramme, 

Zeitverzögerungen 

Bei diesem Versuch soll unter Verwendung der Ports B und C des M68HC11 Datenverkehr mit 

externen Komponenten durchgeführt werden. Es soll grundsätzlich im polling mode gearbeitet 

werden, d.h. ohne Unterbrechungen. Geeignete Programmteile sind als Unterprogramm zu 

formulieren. Zeichnen Sie immer zuerst ein Flussdiagramm und programmieren Sie dann danach. 

Die Stellung der Schalter S7 - S4 soll andauernd über Port C [3:0] eingelesen und über Port C [7:4] 

auf die LEDs L3 - L0 ausgegeben werden. Die Initialisierung des Ports C soll als Unterprogramm 

(Name: PINI) formuliert werden. 

Zusätzlich soll ein 8-bit-Lauflicht mit einem Takt von 10 Hz programmiert werden. Seine aktuelle 

Stellung soll über Port B [7:0] ausgegeben und mittels der LEDs L15 - L8 angezeigt werden. Der 

zeitbestimmende Programmteil sowie das Weiterschalten und Anzeigen des Lauflichts sollen als 

Unterprogramme (Namen: DELAY und DISPLAY) formuliert werden. 

Nun soll sich der Takt verändern lassen. Der über die Schalter S7 - S4 des Experimentier-Boards 

eingestellte und über Port C [3:0] eingelesene Wert stellt die Lauflichtfrequenz in Hz dar, wenn er 

grösser als 0 ist. Der Wert 0 führt zu einem Anhalten der Anzeige (Lauflicht bleibt stehen und läuft 

erst weiter, wenn der Wert grösser als 0 ist). Siehe Anmerkung unten. 

Als Letztes soll noch mittels der Taste T0, die am Eingang STRA des M68HC11 anzuschließen ist, 

die Laufrichtung von Linkslauf auf Rechtslauf umgeschaltet werden können und umgekehrt (toggle). 

Anmerkung: Es gilt bekanntlich, dass die Frequenz ein Kehrwert der Zeit (Periodendauer) ist (f = 

1/t). Für eine Warteschleife, wie sie in der Vorlesung behandelt wurde, muss die Frequenz in eine 

Periodendauer umgerechnet werden (1 Hz = 1000 ms, 2 Hz = 500 ms, 3 Hz = 333 ms, 4 Hz = 250 ms 

usw.). Das Umrechnen der Frequenz in die Wartezeit kann programmtechnisch auf zweierlei Weise 

geschehen, durch (Integer-)Division oder durch eine Tabelle. Verwenden Sie in diesem Fall die 

Division (IDIV-Befehl). Schematisch stellt sich die Programmierung wie folgt dar: 

1. Entwurf einer Warteschleife für 1 Hz = 1000 ms mit einem möglichst großen Startwert I des 

Schleifenzählers. 

2. Einlesen der Schalterstellung und Expandieren des Wertes auf eine 16-Bit-Variable K. 

3. Division von J = I/K. J ist nun der aktuelle Startwert für die Zählschleife. 

Praktikum Mikrocomputer 197

Versuch 2: Parallel-Ports, 7-Segmentanzeige, 

Tabellenzugriff 

Bei diesem Versuch soll unter Verwendung der Ports B und C des M68HC11 Datenverkehr mit 

externen Komponenten durchgeführt werden. Es soll grundsätzlich im polling mode gearbeitet 

werden, d.h. ohne Unterbrechungen. Geeignete Programmteile sind als Unterprogramm zu 

formulieren. Zeichnen Sie immer zuerst ein Flußdiagramm und programmieren Sie dann danach. 

Die Stellung der Schalter S7 - S4 soll andauernd über Port C [3:0] eingelesen, über Port C [7:4] 

ausgegeben und als einstellige Sedezimalzahl angezeigt werden. Dazu ist die 7-Segment-Anzeige A3 

(mit Decoder) zu verwenden. Die Initialisierung des Ports C soll als Unterprogramm (Name: PINI) 

formuliert werden. 

Nun werden die 7-Segment-Anzeigen A1 und A2 (mit Decoder) an Port B (A1: [7:4], A2: [3:0]) 

angeschlossen. Es soll eine 'Digitaluhr' programmiert werden, die Sekunden und Zehntelsekunden 

anzeigt (Sekunden Zehner auf A1, Sekunden Einer auf A2 und Zehntelsekunden auf A3). Dazu wird, 

wie schon im ersten Versuch, einem Warteroutine DELAY benötigt, die hier eine Periodendauer von 

100 ms hat. 

Die Digitaluhr soll bei einen vorgegebenen Wert (Programmvariable) starten, bis zum Wert 00.0 

herunterzählen und dann anhalten. Mittels der Taste T0, die am Eingang STRA des M68HC11 

anzuschließen ist, kann der Zähler mit dem voreingestellten Anfangswert gestartet oder gestoppt 

werden. 

Über die Schalter S7 - S4 an Port C [3:0] soll die Startzeit des Zählers aus einer Tabelle gewählt 

werden, wobei in der Tabelle nur die Sekunden gespeichert werden, die Zehntensekunden starten 

immer mit 0. Die Tabelle besitzt somit 16 Einträge. Die in der Tabelle einzutragenden Zeiten sind frei 

wählbar. 

Hinweis:Optional kann anstelle einer Warteschleife mittels X- oder Y-Register auch der frei laufende 

Zähler für die Zeitverzögerung verwendet werden (ohne Interrupt). Dazu sind folgende 

Vereinbarungen notwendig: 

1. Bei den Konstantendefinitionen 


tflag equ $1025 ; Timer Flag Register 

tmask equ $1024 ; Timer Mask Register 

faktor equ 30 ; Multiplikationsfaktor fuer Timer 

; 3 ~ 0,1 s: 

; 32,77 * 3 = 98,31 (fast 0,1 s) 

; 30 ~ 1 s: 

; 32,77 * 30 = 983,1 ms (fast 1 s) 

2. Bei den Veriablendefinitionen 

org data 

... 

dlycnt ds.b 1 

3. Bei den Unterprogrammen (tinit wird beim Programm-Init aufgerufen) 

tinit psha ; Timer Init 

clr tmask ; Timer-Prescaler / 1 --> 32,77 ms 

ldaa #faktor ; Zeit festlegen 

staa dlycnt 

pula 

rts 

Versuch 2: Parallel-Ports, 7-Segmentanzeige, Tabellenzugriff 198


delay psha ; Delay-Routine 

delay1 ldaa tflag ; warten auf Timer-Ueberlauf 

bpl delay1 

ldaa #$80 ; TOFL-Flag zuruecksetzen 

staa tflag 

dec dlycnt ; delay-counter dekrementieren 

tst dlycnt 

bne delay1 ; warten auf dlycnt == 0 

ldaa #faktor ; dann dlycnt neu setzen 

staa dlycnt 

pula ; und fertig 

rts 

Versuch 2: Parallel-Ports, 7-Segmentanzeige, Tabellenzugriff 199


Versuch 3: Serielle Schnittstelle, ASCII-Zeichenketten 

Bei diesem Versuch soll unter Verwendung des SCI (Asynchronous Serial Communications Interface) 

des M68HC11 Datenverkehr zwischen Prozessor M68HC11 und PC als Terminal durchgeführt 

werden. Es soll grundsätzlich im polling mode gearbeitet werden, d.h. ohne Unterbrechungen. Als 

String-Terminator dient wie bei C das Nullbyte ($00). Geeignete Programmteile sind als 

Unterprogramm zu formulieren. Zeichnen Sie immer zuerst ein Flussdiagramm und programmieren 

Sie dann danach. 

Wichtig: Zum Terminalbetrieb ist nach dem Terminalbetrieb der Schalter "PC-MAN" am 

Praktikumsrechner in Stellung MAN zu bringen. Zum Laden des Programms muss er dann wieder auf 

PC gestellt werden. Entsprechend muss beim Hyperterminal zum Programm-Download "aufgelegt" 

(Telefon-Icon in der oberen Werkzeugleiste) und zum Betrieb wieder "abgehoben" werden. 

Zum Einstieg soll das ASCII-Zeichen 'R' mit einer Wiederholfrequenz von etwa 5 Hz andauernd auf 

das Terminalfenster des Hyperterminal-Programms ausgegeben werden. Die Initialisierung des SCI ist 

als Unterprogramm (Name: SINIT) zu formulieren. Das Senden des Zeiches soll durch ein 

Unterprogramm namens CHOU erfolgen, das das im Akku A übergebene Zeichen (bei freier 

Schnittstelle) sendet. 

Ein vorbereiteter Text (nullterminierter ASCII-String) ist nun mittels des neu zu schreibenden 

Unterprogramms STOU dauernd auf das Terminalfenster auszugeben. Register X enthält die Adresse 

des ersten Zeichens des Textes. Das Unterprogramm STOU gibt die ab (X) stehenden ASCII-Zeichen 

unter Verwendung des Unterprogramms CHOU aus, bis das Textendezeichen (\0) gefunden wird, das 

selbst nicht mit ausgegeben wird. Stattdessen werden die Steuerzeichen CR (Carriage Return) und LF 

(Line Feed) ausgegeben. 

Ein über die Tastatur eingegebenes Zeichen ist mittels des Unterprogramms CHIN einzulesen und 

mittels des Unterprogramms CHOU als Echo auszugeben (Endlos-Schleife). Das Unterprogramm 

CHIN übergibt das gelesene Zeichen im Akku A. 

Nun soll statt eines einzelnen Zeichens ein String über die Tastatur eingegeben, mittels des 

Unterprogramms STIN eingelesen und im Speicher abgelegt werden. STIN verwendet seinerseits 

CHIN, um ein Zeichen zu lesen. Zur Kontrolle wird der String mithilfe des Unterprogramms STOU 

wieder ausgegeben (Endlos-Schleife). Das Unterprogramm STIN soll folgende Eigenschaften 

besitzen: 

i. STIN echot die mittels CHIN eingelesenen Zeichen und legt sie im Speicher ab. Die Adresse 

des Eingabepuffers wird im Indexregister X übergeben. 

ii. Nicht darstellbare Zeichen (alle ASCII-Zeichen < " ") werden bei der Eingabe ignoriert. 

iii. Das ASCII-Zeichen CR beendet die Eingabe, es wird ohne Echo als Nullbyte abgelegt. 

iv. STIN wird durch die Ausgabe von CR und LF abgeschlossen. 

Mittels STIN soll schließlich eine Zeichenkette eingelesen und mit einem im Programm abgelegten, 

konstanten String zeichenweise verglichen werden (z. B. als Passwortabfrage). Das Ergebnis des 

Vergleichs soll über Port B [6:0] ausgegeben und mittels der 7-Segment-Anzeige A5 (ohne Decoder) 

dargestellt werden: 

i. Sind die Zeichenketten unterschiedlich, wird ein "F" ausgegeben (für "falsch"). Gleichzeitig 

wird ein Fehlerzähler inkrementiert. 

ii. Stimmen beide Zeichenketten überein, wird eine "1" ausgegeben. Der Fehlerzähler wird in 

diesem Fall zurückgesetzt. 

iii. Erfolgt dreimal hintereinander eine falsche Eingabe (Fehlerzähler == 3), wird ein "E" 

ausgegeben (für "Error"), das im Rhythmus von 2 Hz blinkt, und keine Eingabe mehr 

Versuch 3: Serielle Schnittstelle, ASCII-Zeichenketten 200

angenommen. 


Versuch 3: Serielle Schnittstelle, ASCII-Zeichenketten 201


Versuch 4: Zähler, bedingte Unterbrechungen 

Bei diesem Versuch sollen ein einfacher Zähler betrieben und verschiedene bedingte Unterbrechungen 

aktiviert und bearbeitet werden. Geeignete Programmteile sind als Unterprogramm zu formulieren. 

Zeichnen Sie immer zuerst ein Flussdiagramm und programmieren Sie dann danach. 

Ein 2-stelliger Sedezimalzähler ist mit einer Frequenz von etwa 10 Hz zu betreiben. Seine aktuelle 

Stellung soll über Port C [7:0] ausgegeben und mittels der 7-Segment-Anzeigen A1 und A2 (mit 

Decoder) dargestellt werden. Der zeitbestimmende Programmteil soll als Unterprogramm (D100) 

unter Verwendung des Registers Y formuliert werden. Orientieren Sie sich an den Programmen aus 

den Versuchen 1 und 2. 

Modifizieren Sie das Programm nun so, dass beim Starten des Programms der Text "M68HC11 

gestartet" auf das Terminalfenster ausgegeben wird. Verwenden Sie dazu die beim Versuch 3 

entwickelten Unterprogramme zur Initialisierung der SCI, sowie zur Zeichen- und Stringausgabe 

(CHOU und STOU). 

Zusätzlich sind nun bedingte Unterbrechungen zu bearbeiten. Mittels der Tasten T0 und T1, die an 

den Eingängen STRA und PA7 des M68HC11 anzuschließen sind, können bedingte Unterbrechungen 

ausgelöst werden. Als Folge darauf sollen vom Hauptprogramm aus die unten beschriebenen 

Aktionen erfolgen. 

Die Unterprogramme zur Unterbrechungsbearbeitung sind möglichst kurz zu halten. Zur 

Signalisierung von der Unterbrechungsbearbeitung zum Hauptprogramm sollen die Bits 0 und 1 einer 

Variablen DFLG (display flag) verwendet werden. Die zum Starten der Unterbrechungsbearbeitungen 

nötigen Vektoren nicht vergessen: 

org $ffda 

dc.w pirq ; pulse accu input (PA7) 

org $fff2 

dc.w sirq ; IRQ/STRA 

org $fffe 

dc.w main ; reset 

• Beim Auftreten einer Unterbrechung durch T1 an PA7 soll der jeweilige Befehlszählerstand 

des unterbrochenen Programms als 4-stellige Hexzahl auf das Terminalfenster ausgegeben 

werden ("PC=XXXX"). Verwenden Sie dazu unter anderem das Unterprogramm hx4a (siehe 

unten). 

Von der Interrupt-Serviceroutine wird nur der Wert des Befehlszählers in der 

16-Bit-Variablen PCSTAT ans Hauptprogramm übergeben. Die Tatsache, dass ein Interrupt 

auftrat, wird in einer Flag-Variablen namens PFLAG signalisiert. Die Umwandlung Binär → 

Hex sowie die Ausgabe erfolgen im Haptprogramm, das auch PFLAG wieder zurücksetzt. 

• Beim Auftreten einer Unterbrechung durch T0 an STRA soll jeweils nach dem 3. Impuls am 

Interrupteingang (also nach dreimaligem Tastendruck) der Zähler gestoppt und erst nach 

weiteren 3 Tastenbetätigungen wieder weiterlaufen. Dies soll sich periodisch wiederholen. 

Bearbeiten Sie das Zählen der Tastenbetätigungen innerhalb der Interrupt-Serviceroutine und 

signalisieren Sie die Start/Stopp-Information über eine Flag-Variable namens SFLAG. Im 

Hauptprogramm wird anhand dieser Variablen entschieden, ob der Zähler läuft oder steht. 

Die beiden Unterprogramme hx2a und hx4a können Sie von dieser Angabe per Cut-and-Paste 

übernehmen. Dabei ist zu beachten, dass hx2a und hx4a den entstehenden String nach fallenden 

Adressen hin aufbauen und dass damit die Übergabeparameter entsprechend gewählt werden müssen. 

Sehen Sie sich dazu auch den Quelltext zu den Unterprogrammen am Ende dieses Dokuments an. 

Versuch 4: Zähler, bedingte Unterbrechungen 202

Anhang: Binär zu ASCII-Decodierung (hx4a) 

Diese Unterprogramme werden beim vierten Praktikumstermin benötigt. Im Speicher liegen die Werte 

bekanntermaßen binär vor. Um einen Speicherinhalt oder eine Adresse auf der seriellen Schnittstelle 

(Terminal) oder einem LC-Display ausgeben zu können, müsen die Werte als ASCII-Zeichen 

dargestellt werden. 

Die folgenden vier miteinander verbundenen Unterprogramme wandeln einen 16-Bit-Wert, einen 

8-Bit-Wert oder einen 4-Bit-Wert in eine Hexadezimalzahl in ASCII-Darstellung um (4, 2, oder 1 

Stelle): 


Puffer abgelegt werden. Beim Unterprogrammaufruf muss das Indexregister Y auf die letzte 



Puffer abgelegt werden. Beim Unterprogrammaufruf muss das Indexregister Y auf die letzte 



langen Puffer abgelegt wird. Beim Unterprogrammaufruf muss das Indexregister Y auf den 







hx2a pshb ; Akku B auf dem Stack sichern 




lsrb 




hx1a andb #$0F ; die oberen 4 Bits ausmaskieren 





hx1b stab 0,y ; im Speicher ablegen, auf den Y zeigt 


rts ; und weg 

Beispielaufruf: 

ldd #$AFFE ; Hexzahl in Akku D laden 

ldy #PUFFER+3 ; Position auf letzte Stelle im Puffer 

; der Puffer muss im Datenbereich reserviert sein 

bsr hx4a ; do it! 

ldy #PUFFER ; y --> Pufferanfang 

bsr STOU ; z.B. seriell ausgeben 

[ Praktikumsanleitung ] [ Skript ] 


Letzte Aktualisierung: 20. Feb 2011, 16:49:01 


Anhang: Binär zu ASCII-Decodierung (hx4a) 203

Assembler-Direktiven - Netzmafia

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?