Praktikum Mikrocontroller und Eingebettete Systeme

Institut für Informatik Professur für Eingebettete Systeme Praktikum Mikrocontroller und Eingebettete Systeme Wintersemester 2009/2010 Eingebettete Systeme Prof. Dr. Uwe Brinkschulte Dipl.-Inform. Daniel Lohn Dipl.-Inform. Michael Bauer

Inhaltsverzeichnis 1 Einführung 5 2 Das Praktikumsboard 6 3 JTAG ICE mkii 9 3.1 Nutzen des JTAG-Programmers................................. 9 3.2 Anschluss des JTAG-Programmers............................... 9 4 Das Terminal Programm 12 4.1 HyperTerminal.......................................... 12 4.2 Die UART Einheit........................................ 14 5 AVR Studio 15 5.1 Anlegen eines neuen Projekts.................................. 15 5.2 Die Entwicklungsumgebung................................... 17 5.3 Kompilieren und Ausführen................................... 18 5.4 Debugging............................................. 18 6 Assemblerprogrammierung 20 6.1 Warum Assemblerprogrammierung?.............................. 20 6.2 Der AVR-Assembler....................................... 20 6.2.1 Direktive......................................... 21 6.2.2 Mnemoniks........................................ 22 6.2.3 Ein Beispielprogramm.................................. 22 7 Versuchsübersicht 24 7.1 Versuch 1............................................. 24 7.2 Versuch 2............................................. 24 7.3 Versuch 3............................................. 24 7.4 Versuch 4............................................. 24 7.5 Versuch 5............................................. 24 7.6 Versuch 6............................................. 24 8 Versuch 1 25 8.1 Inhalt............................................... 25 8.2 Aufgabe 1.1............................................ 25 8.3 Aufgabe 1.2............................................ 25 8.4 Aufgabe 1.3............................................ 26 8.5 Aufgabe 1.4............................................ 26 9 Versuch 2 27 9.1 Inhalt............................................... 27 9.2 Aufgabe 2.1............................................ 27 9.3 Aufgabe 2.2............................................ 28 9.4 Aufgabe 2.3............................................ 28 9.5 Aufgabe 2.4............................................ 29 2

10 Versuch 3 30 10.1 Inhalt............................................... 30 10.2 Das PWM Verfahren....................................... 30 10.3 Die PWM beim ATmega..................................... 30 10.4 Ausgabe 3.1............................................ 31 10.5 Aufgabe 3.2............................................ 31 10.6 Aufgabe 3.3............................................ 31 11 Versuch 4 32 11.1 Inhalt............................................... 32 11.2 Ausgabe 4.1............................................ 32 11.3 Ausgabe 4.2............................................ 32 11.4 Ausgabe 4.3............................................ 32 12 Versuch 5: Externer Speicher Teil I 33 12.1 Versuchsbeschreibung...................................... 33 12.2 Die SPI-Schnittstelle....................................... 33 12.3 Die Speicherkarte......................................... 34 12.3.1 Allgemeines........................................ 34 12.3.2 Funktionsweise...................................... 35 12.3.3 Anschluss der Speicherkarte an das Mikrocontrollerboard.............. 37 12.4 Theorieaufgaben......................................... 39 12.4.1 Aufgabe 5.1........................................ 39 12.4.2 Aufgabe 5.2........................................ 39 12.4.3 Aufgabe 5.3........................................ 39 12.4.4 Aufgahe 5.4........................................ 39 12.4.5 Aufgabe 5.5........................................ 39 12.5 Praxisaufgaben.......................................... 40 12.5.1 Aufgabe 5.6........................................ 40 12.5.2 Aufgabe 5.7........................................ 40 12.5.3 Aufgabe 5.8........................................ 40 12.5.4 Aufgabe 5.9........................................ 40 13 Versuch 6: Externer Speicher Teil II 41 13.1 Versuchsbeschreibung...................................... 41 13.2 Speichertests........................................... 41 13.2.1 Der Marching-Test.................................... 41 13.3 Theorieaufgaben......................................... 43 13.3.1 Aufgabe 6.1........................................ 43 13.4 Praxisaufgaben.......................................... 43 13.4.1 Aufgabe 6.2........................................ 43 13.4.2 Aufgabe 6.3........................................ 43 3

Abbildungsverzeichnis 1 TQFP Gehäuseformat eines Mikrocontrollers......................... 6 2 Praktikumsboard mit nummerierten Anschlüssen....................... 7 3 Praktikumsboard mit Beispielanschluss............................ 8 4 JTAG Programmer mit angeschlossenem AVR Board..................... 10 5 JTAG Anschlusspins am Praktikumsboard........................... 10 6 Status-LEDs am Programmer.................................. 11 7 Screenshot HyperTerminal.................................... 12 8 Screenshot HyperTerminal.................................... 13 9 Screenshot HyperTerminal.................................... 13 10 Projekteinstellungen im AVR Studio.............................. 15 11 Auswahl Target Device im AVR Studio............................ 16 12 Entwicklungsumgebung im AVR Studio............................ 17 13 Screenshot AVR Studio..................................... 18 14 Screenshot AVR Studio..................................... 19 15 Die Vorderseite einer Speicherkarte............................... 35 16 Die Rückseite einer Speicherkarte mit den Kontakten..................... 35 17 Der Speicherkartenadapter, bestehend aus einem Speicherkartenslot und den Anschlussleitungen............................................... 37 18 Das Mikrocontrollerboard mit dem angeschlossenen Speicherkartenadapter......... 38 4

1 Einführung Im Mittelpunkt des Praktikums stehen Eingebette Systeme und deren Hardware. Um die speziellen Anfordungen Eingebetteter Systeme an ihre Hardware zu vertehen muss deren Anwendungsgebiet von dem herkömmlicher Rechensysteme abgegrenzt werden. Diese Abgrenzung liefert uns die Definition von Eingebetteten Systemen. Eine häufig verwendete Definition nach Thaller lautet: Bei Eingebetteten Systemen handelt es sich um einen durch Software kontrollierten Computer oder Mikroprozessor, der Teil eines größeren Systems ist, dessen primäre Funktion nicht rechenorientiert ist. Eine etwas anschaulicherer und ausführlichere Defintion findet sich auf Wikipedia: Der Ausdruck eingebettetes System (auch engl. embedded system) bezeichnet einen elektronischen Rechner oder auch Computer, der in einen technischen Kontext eingebunden (eingebettet) ist. Dabei hat der Rechner entweder die Aufgabe, das System, in das er eingebettet ist, zu steuern, zu regeln oder zu überwachen. Oder der Rechner ist für eine Form der Daten- bzw. Signalverarbeitung zuständig, beispielsweise Ver- /Entschlüsseln, De-/Codieren oder Filtern. Beiden Definitionen ist gemeinsam, dass sie das Feld der Eingebetteten Systeme vom Bereich der Allzweck- /Mehrzweck-Rechner abgrenzen wollen. Dieser Übergang gestaltet sich allerdings fließend: Konnten Handys zu ihrer Anfangszeit wenig mehr als Stimmen zu digitalisieren und Daten zu senden, können sie heute dank Minibetriebssystemen und Java Applets beliebige Programme ausführen. Waren Spielekonsolen anfangs nur wenig komplexer als Taschenrechner, können sie heute mit Standardbetriebsystemen ausgestatten werden und bleiben im Leistungumfang kaum hinter Desktop Rechnern zurück. Einige Eingebetteten Systeme können also durchaus dieselbe Komplexität wie Mehrzweckrechner erreichen und in manchen Fällen auch zu solchen werden. In unserem Alltag begegnen wir allerdings am häufigsten einer anderen Art von Eingebetteten Systemen. Einfache und deshalb auch billige Rechensysteme sind in Spülmaschienen, Kaffeautomaten oder digitalen Armbanduhren zu finden und damit beinahe allgegenwärtig. Bei solchen Systemen reicht häufig schon ein einzelner Mikrocontroller ohne Betriebssystem aus, um die gewünschte Funktion zu leisten. Um einen hardwarenahen Einblick in das Gebiet der Eingebetten Systeme zu bieten, steht deshalb im Praktikum ein Versuchsboard mit integriertem ATmega128 Mikrocontroller und verschiedenen Pheriperieanschlüssen zu Verfügung. Der ATmega128 enthält einen relativ einfachen 8 Bit Risc Prozessor. Dies ermöglicht es auch unerfahrenen Anwendern Programme direkt in Assembler zu verfassen und so, die wichtigsten Komponenten eines Mikrocontrollers kennenzulernen und direkt anzusteuern. Die Lernziele des Praktikums lassen sich wie folgt zusammenfassen: Detaillierte Einführung in Aufbau und Programmierung des ATmega128. Einsatz der parallelen und der seriellen Schnittstellen des Mikrocontrollers zur Kommunikation mit anderen Rechnern. Einsatz von Zählern und Zeitgebern im Zusammenspiel mit Unterbrechungsbehandlung, um beispielsweise eine Pulsweitenmodulation zu realisieren. Anbindung eines externen Speichers an das Mikrocontrollerboard und Implementierung eines einfachen Treibers inklusive Funktionstest. Am Ende des Praktikums sollen die Teilnehmer mit den grundlegenden Funktionen eines einfachen Rechnersystem vertraut sein. Dies stellt auch Inhaltlich eine Grundlage für weitere Veranstaltungen auf dem Gebiet der Technische Informatik und Rechnerarchitektur dar. 5

2 Das Praktikumsboard Ein Mikrocontroller stellt im Prinzip einem Mikrorechner auf einen Chip dar. Im Praktikum wird der Mikrocontroller ATmega128 von Atmel verwendet. Auf diesem befindet sich ein Prozessorkern, Speicher, Ein-/Ausgabeschnittstellen und weitere Komponenten wie A/D-Wandler, Zähler-/Zeitgeber und Unterbrechungssteuerung. Die Schnittstellen für alle Komponenten werden über Pins an die Aussenseite des Controllers geführt. Abbildung 1: TQFP Gehäuseformat eines Mikrocontrollers Um an die Ein-/Ausgabeschnittstellen des ATmega128 Pheriperie, wie Taster oder LEDs anzuschließen, oder um auf den Programmspeicher zugreifen zu können, muss der Mikrocontroller in eine größere Schaltung integriert werden. So lässt sich beispielsweise ein Nullmodemkabel natürlich nicht direkt an die Controllerpins für die UART-Einheit anschließen. Zu diesem Zweck gibt es eine ganze Reihe unterschiedlicher Testboards, die sich in Umfang der integrierten Pheripherie, Programmierschnittstellen und Erweiterungsmöglichkeiten unterscheiden. Als Praktikumshardware hat man sich für ein modulares Kit von Atmel entschieden. Das darin enthaltene STK500 bietet gleich mehrere Vorteile: LEDs und Taster als Ansteuerungs- und Ausgabemöglichkeiten sind bereits auf dem Board integriert. Ein Com Port als serielle Schnittstelle zur Kommunikation mit anderen Boards oder einem PC befindet sich ebenfalls auf dem STK500. Es ist ein JTAG-Anschluss zur Programmierung und Runtime Debugging des ATmega128 integriert. Der Mikrocontroller ist nicht fest mit dem Board verlötet, sondern kann durch eine Federhalterung jederzeit durch ein anderes Model ausgetauscht werden. Sämtliche Pins des Mikrocontrollers sind auf dem Board auf solide Kontaktstecker geführt und lassen sich so für beliebige Pheripheriegeräte nutzen. So kann das Board beispielsweise um die benötigte Speicherkartenhalterung erweitert werden. Da der Platz am Gehäuse des Mikrocontrollers sehr begrenzt ist, sind viele der Leitungen gemultiplext. Abhängig davon, welche Komponente des ATmega128 im Programm benötigt wird, lässt sich dies durch neue Steckverbindungen realisieren. Der modulare Aufbau des Board gestaltet zwar den Betrieb im Praktikum schwieriger, als bei einer festen Verdrahtung, erlaubt aber auch die Erweiterbarkeit um beliebige Zusatzpheriperie und die Möglichkeit 6

gemultipelexte Komponenten je nach Bedarf zu nutzen, ohne sich dauerhaft festlegen zu müssen. Die Anschlüsse für die Praktikumversuche sind dabei wie folgt: Abbildung 2: Praktikumsboard mit nummerierten Anschlüssen 1. Die Stromversorgung für das gesamte Board, einschließlich des Mikrocontrollers, der Taster, LEDs und Zusatzperipherie. 2. Der untere serielle Anschluss steht für die Versuche mit der UART-Schnittstelle zur Verfügung. Über den oberen seriellen Anschluss kann auf den Speicher des ATmega128 zugegriffen werden. Da die Programmierung über die JTAG-Schnittstelle einfacher ist und mehr Möglichkeiten bietet, siehe Abschnitt JTAG ICE mkii, wird nur der untere serielle Anschluss zu Kommunikationszwecken verwendet. 3. In dieser Federhalterung befindet sich der ATmega128. Wird der obere Rahmen nach unten gedrückt, öffnet sich die Halterung für die Pins und der Mikrocontroller kann entnommen oder gegen einen anderen ausgetauscht werden. 4. An den ATmega128 wird der JTAG Programmer über diese 10 polige Steckleiste angeschlossen. Pin 1 und 2 sind sowohl auf dem STK500, als auch am JTAG ICE Anschluss gesondert gekennzeichnet. 5. Der Anschluss für die acht Taster befindet sich links oben auf dem Board. Diese können an einen beliebigen Port des ATmega128 angeschlossen werden. Um die Taster auszulesen muss die Portrichtung auf Eingabe gestellt sein. Werden die Taster gedrückt/losgelassen, stehen Einsen/Nullen im entsprechenden Eingaberegister. Alternativ lassen sich die Taster auch an externe Interrupteingänge anschliesen. Diese müssen in den Kontrollregistern des ATmega128 freigegeben werden, um auf Tastendruck einen Interrupt auslösen zu können. 6. Damit der UART im ATmega128 auch mit dem seriellen Anschluss verbunden wird, müssen die entsprechenden Pins am Mikrocontroller mit der Schnittstelle RXD/TXD, RS232 Spare auf dem Board verbunden werden. Der ATmega128 verfügt allerdings über mehrere UARTs. Abhängig davon, welche UART-Einheit im Assemblerprogramm genutzt wird, müssen die Pins eines anderen Ports mit RXD/TXD verbunden werden. Eine Beispielschaltung, bei der Port E, und damit die UART Einheit 0, mit der seriellen Schnittstelle verbunden ist, findet sich am Ende dieses Kapitels. 7

7. Der Anschluss für die acht LEDs befindet sich links unten auf dem Board. Diese können an einen beliebigen Port des ATmega128 angeschlossen werden. Um die LEDs anzusteuern, muss die Portrichtung auf Ausgabe gestellt sein. Werden Einser/Nuller in das entsprechende Ausgaberegister geschrieben, so werden die LEDs aktiviert/deaktiviert. Nur die Verbindungen für den JTAG-Programmer und die Stromversorgung sind immer fest vorgegeben. Alle anderen Steckverbindungen sind variabel. Zum Beispiel können die Pins der UART-Einheiten im Assemblercode auch direkt angesteuert werden und zur Ausgabe von LED-Mustern dienen. Die Steckverbindungen hängen also von der gewünschten Pheriperie und den verwendeten Ports im Assemblercode ab. Dies ändert sich im Praktikum jedoch von Versuch zu Versuch. Besonders auf die Portrichtung (Ein- /Ausgabe) im Assemblercode und die genaue Pinbelegung beim Stecken muss besonders geachtet werden. Abbildung 3: Praktikumsboard mit Beispielanschluss Auf diesem Bild des STK500 ist die UART-Einheit 0 auf die seriellen Schnittstelle des Board geschaltet. Dazu verbindet das blau/weise, zweiadrige Kabel den Port E mit dem RXD/TXD-Anschluss (links oben). Zusätzlich sind die LEDs an Port B angeschlossen (graues Kabel links unten im Bild). Am unteren rechten Bildrand ist ein serielles Kabel angeschlossen, das den UART des ATmega128 mit dem COM PORT am PC verbindet. Mit dieser Beschaltung kann das Board schon für einfache Aufgaben benutzt werden. Zum Beispiel lassen sich so Tastaturbefehle am PC einlesen und als Eingaben im Assemblerprogramm verwenden. Der korrekte Datentransfer kann über LED Ausgaben angezeigt werden. 8

3 JTAG ICE mkii 3.1 Nutzen des JTAG-Programmers Um den ATmega128 zu programmieren, oder genauer gesagt, den erstellten Binärcode in seinen Speicher abzulegen, würde eine einfache serielle Anbindung vollkommen ausreichen. Das Ziel des Praktikums ist aber nicht nur das Erstellen und Ausführen von Assemblerprogrammen, sondern vor allem das Verständnis von Programmabläufen und dem Aufbau des Mikrocontrollers. Deshalb wird ein zusätzlicher Programmer mit integrierter JTAG-Schnittstelle verwendet. Die JTAG-Schnittstelle wurde ursprünglich verwendet, um die korrekte Funktion von Schaltungen nach der Endfertigung zu überprüfen. Dazu müssen die Integrierten Schaltungen (ICs) mit zusätzlichen JTAG- Testschaltkreisen versehen werden. Über diese Zusatzschaltkreise lässt sich die eigentliche Schaltung auslesen und integrierte Speicherzellen beschreiben. So kann nach Fertigung und Einbau der ICs in größere Systeme die Funktionalität mit Hilfe von Testprogrammen überprüft und fehlerhafte Schaltkreise ausfindig gemacht werden. Die Möglichkeiten, die sich durch das Auslesen und Beschreiben der Register und Speicherzellen ergeben, sind weit größer, als das Testen auf korrekte Funktionalität. Da der Zugriff auf die Schaltungen nicht an spezielle Testsoftware auf dem Chip oder einen eingeschränkten Testmodus beschränkt ist, kann der ursprünglich nur zur Fertigungskontrolle gedachte JTAG-Anschluss auch zum Übertragen des Codes in den Programmspeicher und sogar zum Runtime-Debugging verwendet werden. Das im Praktikum verwendete AVR Studio bietet eine virtuelle Ansicht vom angeschlossenen Mikrocontroller. Die vom Programmer über die JTAG Schnittstelle erhaltenen Daten lassen sich so übersichtlich und leicht verständlich darstellen. Auf diese Weise bietet der JTAG ICE im Zusammenspiel mit dem AVR Studio gleich mehrere Vorteile für die Praktikumsteilnehmer: Der Programmcode kann auf dem Prozessor schrittweise ausgeführt und auch angehalten werden. Registerinhalte und Speicherstellen können jederzeit während der Programmausführung gelesen und beschrieben werden. Dies erleichtert die Fehlersuche in Programmen enorm. Gerade für in Assemblerprogrammierung unerfahrene Anwender ist dies ein nicht zu unterschätzender Vorteil. Durch Benutzermodifikationen an den Kontrollregistern lassen sich alternative Sprungrichtungen und andere Programmverzweigungen zur Laufzeit testet. Programmzweige können gezielt angesteuert werden und sind nicht mehr an spezielle Ereignisse von außen gebunden. So können zum Beispiel Programmabschnitte, die auftretende Fehler abfangen sollen, getestet werden, ohne dass diese tatsächlich auftreten müssen. Da sämtliche Kontrollregister während des Programmablaufs einsehbar sind, lässt sich die Funktionsweise der Mikrocontrollerkomponenten einfacher nachvollziehen. Komponenten, wie die Zähler- /Zeitgebereinheiten, lassen sich über ihre Kontrollregister jederzeit in einen gewünschten Zustand versetzen. Folgezustände und ausgelöste Interrupt Service Routinen lassen sich so Schritt für Schritt abarbeiten und beobachten. Dies erleichtert das Verständis des Zusammenspiels zwischen Software und den Hardwareeinheiten sehr. 3.2 Anschluss des JTAG-Programmers Der JTAG-Programmer wird zwischen Entwicklungs- und Zielplattform geschaltet. Er nimmt den Programmcode vom AVR Studio entgegen, wandelt ihn in das JTAG-Format um und legt ihn, über die JTAG-Schaltkreise, im Speicher des Mikrocontrollers ab. Von der Zielplattform liest der Programmer die Register- und Speicherinhalte aus und übermittelt sie an das AVR Studio. 9

Abbildung 4: JTAG Programmer mit angeschlossenem AVR Board An den PC wird der JTAG ICE mkii über ein USB-Kabel angeschlossen. Im Gegensatz zum Anschluss über den Com Port kann der Programmer so im laufenden Betrieb angeschlossen werden, wird automatisch erkannt und benötigt keine seperaten Stromversorgung. An den ATmega128 wird der Programmer über eine 10-polige Steckleiste auf der Oberseite des STK500 angeschlossen. Pin 1 und 2 sind sowohl auf dem STK500, als auch am JTAG ICE Anschluss gesondert gekennzeichnet. Abbildung 5: JTAG Anschlusspins am Praktikumsboard Für den Betrieb des JTAG ICE mkii sind drei, auf der Oberseite befindliche LEDs wichtig. Diese liefern Informationen über den aktuellen Status des Programmers, der Verbingung und des Target Device. LED 1 leuchtet grün, wenn die Stromversorgung am Zielgerät steht. Bei der im Praktikum verwen- 10

deten Hardware zeigt diese LED also an, ob der ATmega128 am STK500 richtig angeschlossen ist und mit Spannung versorgt wird. LED 2 leuchtet rot, wenn die Stromversorgung des Programmers steht. Dies geschieht nach dem Einschaltet des Arbeits-PCs auch ohne zusätzliches Stromkabel am JTAG ICE automatisch, da die Stromversorgung über den USB Anschluss ausreicht. LED 3 leuchtet grün, wenn Daten übertragen werden, gelb bei Firmwareupgrades und während der Initialisierung und rot, wenn die Verbindung zum AVR Studio nicht steht. Die LED leuchtet nicht, wenn die Verbindung zum AVR Studio steht, aber keine Daten übertragen werden. Abbildung 6: Status-LEDs am Programmer Mehr Inforamtion über den JTAG ICE mkii erhält man im AVR Studion unter HELP/ AVR Tool User Guide/JTAG ICE mkii. 11

4 Das Terminal Programm Um die Programme der Praktikumsversuche möglichst dynamisch zu gestalten, sind natürlich Ein- und Ausgabemöglichkeiten wichtig. Der ATmega128 verfügt zwar über mehrere Kommunikationskanäle, auf dem Praktikumsboard selbst sind aber nur Taster und LEDs angeschlossen. Um in späteren Versuchen auch entsprechend komplexe Steuerungsmöglichkeiten zu haben, wird die UART-Schnittstelle des ATmega128 genutzt. Diese bietet die Möglichkeit Pakete mit bis zu acht Datenbits zu empfangen/ verschicken und zeigt erfolgreiches senden/empfangen durch Statusflags und Interrupte an. Das STK500 Board bietet die Möglichkeit den UART Port auf eine RS323 Schnittstelle zu legen. Diese lässt sich mit einem COM Port am Praktikums PC verbinden. Durch diese Anbindung lassen sich Tastaturkommandos vom PC zur Steuerung der Assemblerprogramme auf dem ATmega128 nutzen. 4.1 HyperTerminal Das Betriebssystem Windows XP enthält bereits ein Terminalprogramm zur Kommunikation über die serielle Schnittstelle. Mit Hilfe dieses Programms lässt sich eine Verbindung zu anderen Computern, zu Telnet-Sites, zu Bulletin-Board-Systemen (BBS), zu Onlinediensten und zu Host-Computern herstellen. Eine Verknüpfung zum HyperTerminal Programm steht unter Start/Alle Programme/Zubehör /Kommunikation/Hyperterminal. Beim erstem Starten muss eine neue Verbindung eingerichtet werden. Icon und Name der Verbindung dürfen beliebig gewählt werden. Abbildung 7: Screenshot HyperTerminal Im nächsten Schritt muss bei Verbindung herstellen über: der entsprechende COM Port gewählt werden. An der Rückseite des PC Gehäuses sind die COM Ports nummeriert. Das Nullmodemkabel zwischen PC und STK500 muss also an den Port angeschlossen werden, der im Hyperterminal ausgewählt wird. 12

Abbildung 8: Screenshot HyperTerminal Als letzte Einstellung müssen die Bedingungen für den Datentransfer festgelegt werden. Auch hier sind die Einstellungen davon abhängig, mit welcher Konfiguration der ATmega128 gestartet wird. Für die Versuche im Praktikum wird eine Baudrate von 1200 Bits pro Sekunde, 8 Datenbits pro Paket, kein Test auf Parität, ein Stoppbit und Betrieb ohne Flusssteuerung empfohlen. Abbildung 9: Screenshot HyperTerminal Unter Datei/Speichern unter kann eine Verknüpfung auf den Desktop erstellt werden, um das Terminalprogramm wieder mit denselben Einstellungen starten zu können. 13

4.2 Die UART Einheit Beim ATmega128 müssen jeweils zwei Konfigurationsregister für die Baudrate und für das Datenformat eingestellt werden. In die Register ucsrxc und ucsrxb werden die Konfigurationsbits für die Flusssteuerung, die Paritätsprüfung, das Stoppbit und die Datenbits pro Paket gesetzt. Das X im Registernamen steht dabei für die jeweilige UART-Einheit 0 oder 1. Im Register icsrxa werden keine Konfigurationen vom Benutzer gespeichert, sondern der UART-Übertragungsstatus angezeigt. In die Register ubrrxh und ubrrxl wird ein 16 Bit langer Wert gespeichert. Dieser steuert die Übertragungsrate der jeweiligen UART-Einheit. In diesen Wert gehen zwei Faktoren ein: die gewünschte Baudrate und die Taktfrequenz des ATmega128. Als Baudrate wurde im Hyperterminal 1200 Baud ausgewählt. Die ATmega Frequenz lässt sich mit dem JTAG Programmer zwischen 1 bis 16 MHz einstellen. Der UBRR Wert berrechnet sich dann wie folgt: T aktfrequenz in Hz + Baudrate 8 Baudrate 16 1 Diese Werte können im Assemblercode als Konstanten mit dem Befehlen.equ zu Beginn des Programms festgelegt werden. Dies ist übersichtlicher und der Quellcode kann bei Änderungen der Übertragungsrate leicht anpasst werden..include m128def.inc.equ F CPU = 16000000 ;Systemtakt in Hz.equ BAUD = 1200 ; Baudrate.equ UBRR VAL = ((F CPU+BAUD*8)/(BAUD*16)-1) Die Details zu den USART-Einstellungen und Konfigurationsregistern sind ausführlich im ATmega128 Handbuch beschrieben. 14

5 AVR Studio Das wichtigste Softwaretool für das Praktikum ist das AVR Studio. Es übernimmt gleich mehrere Aufgaben: Entwicklungsumgebung zum Erstellen,Verwalten und Kompilieren des Programmcodes. Kommunikation mit dem JTAG Programmer zum Laden des Programmcodes in den ATmega128. Übersicht über alle Mikrocontrollerkompontenten, Register- und Speicherinhalte auch während der Programmausführung. Von besonderer Bedeutung ist dabei die Kompatibilität mit dem JTAG ICE mkii. Das Einbinden des JTAG-Programmers in die Kommunikation mit dem ATmega128 vereinfacht nicht nur das Laden des Programmcodes in den Mikrocontroller, sondern erlaubt auch Runtime Debugging. So kann das Programm, während seiner Ausführung auf dem Mikrocontroller, zu jeder Zeit im AVR Studio angehalten werden, um die Status-, Kontrollregister und Speicherbereiche auszulesen. Die Register und Speicherinhalte lassen sich dabei durch die JTAG-Schaltung nicht nur auslesen, sondern auch beschreiben. So können zur Laufzeit neue Registerwerte eingegeben, Interruptflags gesetzt und Sprungrichtungen geändert werden. Das AVR Studio ist also nicht nur die Entwicklungsumgebung, sondern wird auch zum Laden des Programmcodes in den ATmega128 und anschließendem Debuggen zur Laufzeit verwendet. 5.1 Anlegen eines neuen Projekts Nach dem Start des AVR Studio wird der Benutzer aufgefordert Projekttyp, Projektname und Speicherort anzugeben. Sollte das entspechende Startfenster nicht erscheinen, kann es unter Project/New Project jederzeit wieder geöffnet werden. Abbildung 10: Projekteinstellungen im AVR Studio 15

Für die Versuche im Praktikum wird im Feld Project type die Einstellung Atmel AVR Assembler ausgewählt. Der Projektname sollte einen eindeutigen Bezug zur jeweiligen Aufgabe haben. Unter Location muss der Pfad zum jeweiligen Praktikumsordner eingegeben werden. Sollten für spezielle Programmieraufgaben andere Einstellungen notwendig sein, wird in den jeweiligen Aufgabenstellung auf die Änderungen hingewiesen. Mit dem Button next gelangt man zum nächsten Schritt. Hier wird nach der Programmiereinheit und dem Mikrocontroller des Projekts gefragt. Abbildung 11: Auswahl Target Device im AVR Studio Im Feld Debug Platform muss JTAGICE mkii ausgewählt werden, unter Device der ATmega128 und als Port Option USB. Anschließend kann die Eingabe der Projekteinstellungen mit dem Button Finish abgeschlossen werden. 16

5.2 Die Entwicklungsumgebung Im Hauptfenster des AVR Studio gibt es eine Kontrollleiste am oberen Rand und fünf Unterfenster darunter. Abbildung 12: Entwicklungsumgebung im AVR Studio Fenster 1 zeigt den Projektnamen und die eingebundenen Dateien an. Hier können auch weitere Quelldateien eingefügt werden. Fenster 2 ist ein Texteditor zum Editieren des Quellcode. Fenster 3 zeigt eine Übersicht über die Funktionseinheiten des ausgewählten Mikrocontrollers. Fenster 4 liefert eine Übersicht über das Projekt. Fehler beim Kompilieren, Verbindungsstatus beim Programmieren und andere Informationen werden in diesem Feld angezeigt. Wird in Fenster 3 eine Funktionseinheit ausgewählt, zeigt Fenster 5 die dazugehörigen Kontrollund Statusregister mit dem jeweiligen Inhalt und der Adresse an. 17

5.3 Kompilieren und Ausführen Wenn der Programmcode vollständig eingegeben wurde, sind die nächsten Schritte das Kompilieren, das Kopieren in den ATmega128 Codespeicher und anschließend das Ausführen. Dafür stehen zwei verschiedene Buttons zur Verfügung: 1. ASSEMBLE: Mit diesem Button wird der Quellcode übersetzt und alle eventuell noch vorhandenen Fehler angezeigt. Nachdem die letzten Fehler beseitigt wurden, ist der nächste Schritt das Beschreiben des ATmega128. 2. ASSEMBLE AND RUN: hier wird der Quellcode kompiliert und auf den ATmega128 geladen. Abbildung 13: Screenshot AVR Studio 5.4 Debugging Auch wenn das Programm syntaktisch korrekt ist, können sich, gerade bei komplexeren Programmen, Fehler in der Programmstruktur verstecken. Um diese Fehler zu finden, müssen Sprungrichtungen, Speicherund Registerbelegungen in Abhängigkeit von den auftretenden Eingaben kontrolliert werden. Dafür bietet das AVR Studio eine ganze Reihe praktischer Funktionen. Die wichtigsten dabei sind: 1. RUN: Startet die Ausführung des Programms auf dem ATmega128. 2. PAUSE: Hält das Programm an. Alle virtuellen Mikrocontollerkomponenten im AVR Studio zeigen die tatsächlichen Belegungen im ATmega128 an. 3. RESET: Startet das Programm erneut. Interruptflags, Pointer und der Zustand von Funktionseinheiten werden zurückgesetzt. 4. STEP INTO: Erhöht den Programmcounter um Eins. Es wird der nächste Befehl ausgeführt. Mit dieser Schritt für Schritt Abarbeitung des Programms wird fremder Code verständlicher und eigener lässt sicher besser auf Fehler untersuchen. 5. RUN TO CURSOR: Führt das Programm aus, bis die Befehlszeile erreicht wird, in der sich der Cursor befindet. 18

Abbildung 14: Screenshot AVR Studio Daneben gibt es noch weitere Möglichkeiten zum Debuggen, wie das Setzten von Breakpoints und Tracepoints und mehr. Das wichtigste Feature ist jedoch, dass sich das Programm unterbrechen lässt, ohne es zu beenden. Denn sobald das Programm mit PAUSE angehalten wird, können alle Registerinhalte und Speicherbereiche ausgelesen und wenn nötig auch verändert werden. Nachdem die Veränderungen vorgenommen wurde, kann das Programm vom akutellen Befehl an, mit der neuen Speicherbelegung ausgeführt werden. Der Programmcounter und nicht veränderte Register bleiben erhalten. Alternative Sprungrichtungen und Interruptbedingungen können so von Hand erzwungen werden, ohne dass ein auslösendes Ereignis tatsächlich eintreten muss. 19

6 Assemblerprogrammierung 6.1 Warum Assemblerprogrammierung? Da ein Mikrocontroller oder ein Mikroprozessor a priori kein Wissen darüber besitzt, welche Aufgabe er erfüllen soll, muss er von einem Menschen dementsprechend programmiert werden. Allerdings ist das nicht so einfach, da der Mikrocontroller lediglich Maschinencode versteht. Bei diesem Maschinencode handelt es sich um eine Folge von Operationen, die in der Befehlssatzarchitektur (ISA 1 ) definiert sind, wobei jede Operation binär codiert ist. Allerdings ist so eine lange Folge von binären Zeichen für den Menschen nur sehr schwer zu interpretieren, so dass eine Zwischenebene eingeführt wurde, die sogenannte Assemblersprache. In der Assemblersprache werden den unterschiedlichen Maschinenbefehlen sogenannte Mnemonics zugeordnet, die für den Menschen leichter verständlich sind und einen Hinweis auf die Funktionalität der Operation geben. Das folgende Beispiel soll die bessere Lesbarkeit von Assembler gegenüber Maschinencode verdeutlichen. Es sollen zwei Zahlen, die in den Registern r2 und r1 gespeichert sind, addiert und anschließend das Ergebnis im Register r2 gespeichert werden. Assembler: add r2, r1 Maschinencode: 0000 1100 0010 0001 Durch die Einführung von Hochsprachen, wie zum Beispiel C, C++ oder Java, konnte, von der Assemblersprache ausgehend, noch weiter abstrahiert werden. Trotzdem wird in manchen Fällen noch immer die Assemblerprogrammierung verwendet, da sie gegenüber Hochsprachen einige Vorteile besitzt. In Assembler geschriebene Programme sind meist deutlich kleiner und laufen schneller, was besonders bei einer leistungsschwachen Hardware mit wenig Speicher wichtig ist. Da das Programmieren in Assembler außerdem eine genaue Kenntnis der Hardware erfordert, können hardwarespezifische Sonderfunktionen, die ein automatischer Compiler nur selten oder nie verwenden würde, zur Optimierung genutzt werden. Diesen Vorteilen stehen allerdings auch einige Nachteile entgegen. So ist es zum Beispiel fast unmöglich ein geschriebenes Programm auf eine andere Hardware zu portieren, da es für den Einsatz auf der ursprünglichen Hardware optimiert wurde und deshalb große Teile des Programms noch mal neu geschrieben werden müssten. Außerdem ist es sehr aufwändig Assemblerprogramm zu warten, wenn zum Beispiel ein Fehler behoben werden muss oder das Programm um eine neue Funktionalität erweitert werden soll, denn dazu wird viel Wissen darüber benötigt, wie das Programm arbeitet. So muss zum Beispiel bekannt sein, welche Register verwendet werden und ob die Registerinhalte später noch mal benötigt werden. Ein weiterer Punkt, der für den Einsatz von Assembler in diesem Praktikum spricht, ist, dass die Assemblerprogrammierung einen guten Einblick in die Funktionsweise der Hardware gibt. 6.2 Der AVR-Assembler Der AVR-Assembler umfasst insgesamt 133 unterschiedliche Befehle, wobei die meisten nur einen Taktzyklus zur Ausführung benötigen. Für jedes Programm wird der Quellcode, also die Assemblerbefehle und Kommentare, in einer Datei mit der Endung.asm gespeichert. Dabei unterscheidet der Assembler nicht zwischen Groß- und Kleinschreibung. Nach einer erfolgreichen Kompilierung in Maschinencode, kann dieser in den Codespeicher des Mikrocontrollers übertragen werden. Sobald der Mikrocontroller mit diesem neuen Programm initialisiert ist, wird der Code sequentiell abgearbeitet, sofern der Programmfluss nicht durch einen Sprung verändert wird. Außerdem ist zu beachten, dass ein Mikrocontroller immer in einer Endlosschleife arbeitet, d.h. nachdem das Ende des Programms erreicht wurde, beginnt das Programm wieder von neuem. In der Quelldatei darf pro Zeile maximal eine Assembleranweisung stehen. Dabei kann es sich entweder um eine Direktive oder ein Mnemonik handelt. Zusätzlich kann die Zeile noch durch einen Kommentar ergänzt 1 ISA : Instruction Set Architecture; Befehlssatzarchitektur 20

werden oder mit einer Sprungmarke beginnen. Eine Sprungmarke endet immer mit einem Doppelpunkt und in einem kompletten Assemblerprojekt dürfen keine Sprungmarken denselben Namen haben, auch nicht, wenn sie in unsterschiedlichen Quelldateien des Projekts stehen. Kommentare werden immer durch ein Semikolon eingeleitet und gelten dann bis zum Ende der Zeile. Daraus ergeben sich dann die folgenden Strukturen für eine Zeile 2 : [Marke:].Direktive [Operanden] [; Kommentar] [Marke:] Mnemonik [Operanden] [; Kommentar] [Marke:] [; Kommentar] 6.2.1 Direktive Direktive werden hauptsächlich dazu genutzt, die unterschiedlichen Speicher anzusprechen oder um Makros zu definieren. Direktive beginnen immer mit einem vorangestellten Punkt. Hier ist ein kurze Auswahl der wichtigsten Direktive:.CSEG Damit wird der Codespeicher (FLASH) ausgewählt..dseg Damit wird der flüchtige Datenspeicher (RAM) ausgewählt..eseg Damit wird der nichtflüchtige Datenspeicher (EEPROM) ausgewählt..byte Dient zur Allokierung von Speichplatz für eine Variable. Beispiel: Puffer:.BYTE 24 Durch diese Zeile werden für die Variable Puffer 24 Byte im Speicher reserviert..def Mit dieser Direktive kann einem Register ein symbolischer Name zugeordnet werden. Beispiel:.DEF temp = r16 Dadurch kann das Register r16 auch über den symbolischen Namen temp angesprochen werden..equ Mit dieser Direktive kann eine Konstante definiert werden. Beispiel:.EQU wartettakte = 10.INCLUDE Diese Direktive dient zum Einbinden von weiteren Dateien. Beispiel:.INCLUDE zaehler.asm An dieser Stelle wird der Inhalt der Datei zaehler.asm eingefügt..org Wenn diese Direktive im Codesegment verwendet wird, dann wird damit der Anfangspunkt des Programms im Programmspeicher festgelegt. Wenn diese Direktive im Datensegment verwendet wird, dann gibt sie die Anfangsposition im Arbeitsspeicher an. Wobei darauf zu achten ist, dass im Codesegment wortweise und im Datensegment byteweise addressiert wird. Beispiel:.CSEG.ORG 0x100 Diese Direktive ist z.b. notwendig, um die Interrupt Service Routinen (ISR) am Programmanfang zu überspringen. 2 in Klammern stehende Teile sind optional 21

6.2.2 Mnemoniks Die Mnemoniks lassen sich grob in vier unterschiedliche Befehlsklassen einteilen: Arithmetische und Logische Befehle Zu dieser Klasse gehören die Befehle zum Addieren, Subtrahieren, Multiplizieren, bitweise UNDund ODER-Befehle, usw. Sprungbefehle Hierzu gehören bedingte oder unbedingte Sprünge und Unterprogrammaufrufe. Befehle für den Datentransfer Mit diesen Befehlen können Daten in den Speicher geschrieben oder aus diesem geladen werden. Außerdem können Konstanten oder Registerinhalte zwischen Registern verschoben werden, Einund Ausgabeschnittstellen aktiviert und auf den Stack zugegriffen werden. Befehle, die einzelne Bits von Registern verändern oder testen können 6.2.3 Ein Beispielprogramm Anhand eines einfachen Assemblerprogramms wird jetzt die Funktionsweise der unterschiedlichen Direktiven und Befehle verdeutlicht. Die in Klammern stehenden Zeilennummern gehören dabei nicht zum Programm. Sie wurden eingefügt, damit die einzelnen Zeilen besser erklärt werden können. (1).INCLUDE "m128def.inc" (2) (3).ESEG (4) (5).EQU Wartetakte = 100 ; die Anzahl der Takte, die gewartet werden soll (6) (7).DSEG (8) (9) Puffer:.BYTE 24 ; ein 24 Byte großer Puffer (10) (11).CSEG (12) (13).ORG 0x100 (14) init: (15) ; der Stackpointer wird initialisiert (16) ldi r16, high(ramend) (17) out SPH, r16 (18) ldi r16, low(ramend) (19) out SPL, r16 (20) ; Port A wird konfiguriert (21) ldi r16, 0xFF (22) out DDRA, r16 (23) out PORTA, r16 (24) main: (25) ldi r30, low(puffer) (26) ldi r31, high(puffer) (27) ldi r17, 24 (28) schleife: (29) ld r16, Z+ (30) out PORTA, r16 (31) dec r17 22

(32) cpi r17, 0 (33) brne schleife (34) call warteschleife (35) jmp main (36) (37) warteschleife: (38) push r17 (39) ldi r17, Wartetakte (40) dec r17 (41) cpi r17, 0 (42) brne warteschleife (43) pop r17 (44) ret Zuerst wird in der ersten Zeile die Datei 128def.inc eingebunden. In dieser sind alle symbolischen Namen für den ATmega128 definiert. Den jeweiligen Speicheradressen wird ein deskriptiver Registernamen zugewiesen. So kann im Quellcode direkt der Name anstelle der Speicheradresse verwendet werden. Das vereinfacht das Programmieren und hat verständlicheren Code zur Folge. In Zeile 5 wird die Konstante mit dem Namen Wartetakte und dem Wert 100 definiert. Sie ist im EEPROM (siehe Zeile 3) des Mikrocontrollers abgelegt. Danach wird durch Zeile 9 ein 24 Byte großer Bereich im Arbeitsspeicher (siehe Zeile 7) für die Variable Puffer reserviert. Ab Zeile 11 betreffen alle Befehle den Codespeicher. Durch Zeile 13 wird am Anfang des Codespeichers Platz gelassen, z.b. für die Interrupt Service Routinen. Mit Hilfe des Codes aus den Zeilen 16 bis 19 wird der Stackpointer initialisiert. Er beginnt am Ende des Arbeitsspeichers (RAMEND) und wächst dann zum Anfang des Arbeitsspeichers hin. Auf den Stack kann über die Befehle push und pop zugegriffen werden. Mit push wird ein Registerinhalt als oberstes Element auf dem Stack gespeichert und der Stackpointer inkrementiert, mit pop wird das oberste Stackelement in ein Register geladen und der Stackpointer dekrementiert. Außerdem dient der Stack als Ablage für die Rücksprungadressen bei Unterprogrammaufrufen. Beim Aufruf einer Interrupt Service Routine wird der aktuelle Programmcounter auf dem Stack abgelegt, das entsprechende Unterprogramm ausgeführt und anschließend der Programmcounter automatisch wieder vom Stack geladen. Dies ist allerdings nur möglich, wenn das Unterprogramm die Rücksprungadresse auf dem Stack nicht zerstört. Das heißt, dass das oberste Stackelement am Anfang des Unterprogramms auch das oberste Stackelement am Ende des Unterprogramms sein muss. Da der Stackpointer 16 Bit umfasst, besteht er aus zwei 8 Bit Registern. Das SPL-Register enthält den unteren Teil des Stackpointers und das SPH-Register enthält den oberen Teil. Die Zeilen 21 bis 23 dienen zur Konfiguration des Ports A. Eine genauere Beschreibung der Port-Register befindet sich im Handbuch zum ATmega 128. Das Hauptprogramm umfasst die Zeilen 25 bis 35. Nach einer vollständigen Abarbeitung, beginnt das Hauptprogramm wieder von vorne (siehe Zeile 35). Es dient zur Ausgabe des Inhalts der Variable Puffer auf Port A. Nachdem alle 24 Byte ausgegeben wurden, wird das Unterprogramm Warteschleife aufgerufen. Im Unterprogramm wird der Inhalt des Registers r17 anfangs auf dem Stack kopiert (Zeile 38) und zum Ende wird dieser alte Registerinhalt wieder vom Stack geladen (Zeile 43). Somit wird auch in Zeile 44 die korrekte Rücksprungadresse vom Stack geholt. Für die bedingten Sprünge in den Zeilen 33 und 42 werden bestimmte Bits des Statusregisters des Mikrocontrollers ausgewertet. Abhängig von diesem Ergebnis wird der Sprung genommen oder nicht. Weitere Informationen zum AVR-Assembler finden Sie im Handbuch zum ATmega 128 und im AVR Studio bei Assembler Help unter dem Menüpunkt Help. 23

7 Versuchsübersicht 7.1 Versuch 1 Ziel des ersten Versuch ist es, die Arbeitsumgebung, speziell das AVR Studio und das STK500, kennenzulernen. Dazu soll ein vorgegebenes Assemblerprogramm eingebunden, korrigiert und anschließend ausgeführt werden. Der Versuch ist erfolgreich abgeschlossen, wenn das Assemblerprogramm die vorgegebene Peripherie des Praktikumsboard in gewünschter Weise steuert. 7.2 Versuch 2 Im zweiten Versuch sollen die wichtigsten Einheiten eines Microcontrollers kennengelernt werden. Neben der Funktionsweise von Zähler/Zeitgebern steht die Entwicklung von Interrupt Service Routinen (kurz ISR) und deren Einbinden in das Hauptprogramm im Vordergund. Als Ergebnis sollen Programme zur zyklischen Ausgabesteuerung und zum Entprellen der Taster entstehen. 7.3 Versuch 3 Im dritten Versuch steht weiterhin das Zusammenspiel aus Zählern/Zeitgebern, Interrupt Service Routinen und Ein-/Ausgaben im Vordergrund. Aufbauend auf den zweiten Versuch werden aufwendigere Programme und komplexere Modi der Funktionseinheiten in den Aufgaben behandelt. Spannunsgesteuerte Helligkeitsausgabe der LEDs und PWM-Modus nehmen dabei eine zentrale Rolle ein. 7.4 Versuch 4 Im vierten Versuch steht eine weitere Schnittstelle des ATmega128 im Vordergund, der USART. Ziel des Versuchs ist es, die Assemblerprogramme um eine interaktive Eingabe zu erweitern. Zu diesem Zweck werden von einem PC, über ein Terminalprogramm (HyperTerminal), Tastaturkommandos über den COM Port an die serielle Schnittstelle des ATMega übermittelt. Die im Umgang mit der USART-Schnittstelle gemachten Erfahrungen sind Grundlage für alle folgenden Versuche. 7.5 Versuch 5 Bei diesem Versuch wird ein externer Speicher, in diesem Fall eine Speicherkarte, an dem Mikrocontrollerboard angeschlossen. Ziel des Versuches ist es, einen einfachen Treiber zu schreiben, der über die SPI- Schnittstelle einen Datentransfer zwischen der Speicherkarte und dem Mikrocontrollerboard ermöglicht. 7.6 Versuch 6 Der sechste Versuch ist eine Fortsetzung des fünften Versuchs. Im ersten Teil des Versuchs soll die Datenübertragung des Treibers auf Fehler getestet werden. Der zweite Teil des Versuchs beschäftigt sich mit der Emulation der SPI-Schnittstelle durch Software. 24

8 Versuch 1 8.1 Inhalt Ziel des ersten Versuch ist es die Arbeitsumgebung, speziell das AVR Studio und das STK500, kennenzulernen. Dazu soll ein vorgegebenes Assemblerprogramm eingebunden, korrigiert und anschließend ausgeführt werden. Anschließend sind kleinere Erweiterungen am Quellcode selbständig vorzunehmen. Der Versuch ist erfolgreich abgeschlossen, wenn das Assemblerprogramm die vorgegebene Peripherie des Praktikumsboard in gewünschter Weise steuert. 8.2 Aufgabe 1.1 Als erstes muss das AVR Studio gestartet werden, um ein neues Projekt anzulegen. Alle wichtigen Informationen dafür finden Sie im Kapitel Praktikumsumgebung. Besonders ist darauf zu achten, dass als Projekttyp die Einstellung Assemblerprojekt ausgewählt werden muss. Anschließend soll das folgende Programm eingegeben und kompiliert werden..include m128def.inc.dseg.cseg.org 0x00 init: ldi r16, 0xf out PORTD, r16 out DDRB, r16 out PORTB, r16 main: in r16, PIND out PORTB, r16 jmp main 8.3 Aufgabe 1.2 Beim Kompilieren taucht eine Fehlermeldung auf. Was bedeutet diese Fehlermeldung? Antwort: Welche Schritte werden während der Initialisierung (Abschnitt init) durchgeführt? Antwort: Ändern Sie das Programm so ab, dass es fehlerfrei kompiliert werden kann. 25

8.4 Aufgabe 1.3 Nachdem das Programm lauffähig ist, muss die Periperie an die richtigen Ports angeschlossen werden. An Port D sollen die Taster angeschlossen werden, an Port B die LEDs. Nehmen Sie die benötigten Anschlüsse vor und lassen Sie es dann vom Tutor überprüfen. Hinweis: Erklärungen der Portanschlüsse und Beispielschaltungen stehen im Kapitel Praktikumsboard. Welche Funktion hat der main Abschnitt? Antwort: Die Taster werden durch das Programm zyklisch abgefragt und lösen selbst keinen Interrupt aus. Wie nennt man das verwendete Verfahren? Antwort: Verbinden Sie den JTAG-ICE mit dem Rechner und dem STK500. Programmieren Sie anschließend den ATmega128 und führen Sie das Programm vor. 8.5 Aufgabe 1.4 Ändern Sie jetzt noch Ihr Programm ab, so dass alle LEDs während der Initialisierung angeschaltet werden und durch das Drücken des jeweiligen Tasters ihren Zustand (an/aus) wechseln. 26

9 Versuch 2 9.1 Inhalt Im zweiten Versuch sollen die wichtigsten Einheiten eines Microcontrollers kennengelern werden. Neben der Funktionsweise von Zähler/Zeitgebern steht die Entwicklung von Interruptserviceroutinen (kurz ISR) und deren Einbinden in das Hauptprogramm im Vordergund. Als Ergebnis sollen Programme zur zyklischen Ausgabesteuerung und zum Entprellen der Taster entstehen. Hinweis: Sobald ein Interrupt auftritt und das Programm zur entsprechenden ISR springt, wird der aktuelle Programmcounter im Stacksegment gespeichert. Im Initialisierungsabschnitt des Quellcodes muss deshalb bei allen Versuchen, in denen die Befehle push und pop oder Interrupte genutzt werden, unbedingt der Stack initialisiert werden, siehe Kapitel Assemblerprogrammierung. 9.2 Aufgabe 2.1 Informieren Sie sich im ATmega128 Handbuch über die Funktionsweise und die verschiedenen Modi der Zähler/Zeitgebereinheiten und beantworten Sie folgende Fragen schriftlich: Beim ATmega128 stehen vier Zähler-/Zeitgebereinheiten zur Verfügung. Zwei davon als 8 Bit Einheiten, zwei weitere als 16 Bit Einheiten. Was ist mit der Bezeichnung 8 bzw 16 Bit gemeint? Antwort: Für die Initialisierung und Konfiguration der Zähler-/Zeitgebereinheiten sind fünf Register besonders wichtig: OCRx, TCNTx, TCCRx, TIFR und TIMSKp. Wofür stehen diese Abkürzungen und was sind die Aufgaben der Register? OCRx: TCNTx: TCCRx: TIFR: TIMSK: 27

Beim Einsatz der Zähler/Zeitgebereinheiten lassen sich drei wichtige Modi unterscheiden. Erklären Sie kurz die Eigenschaften (Anzahl und Zeitpunkt der Interrupte, Zyklendauer, etc.): Normaler Modus: CTC Modus: fast PWM Modus: Im normalen Modus der Zähler/Zeitgebereinheiten gibt es mehre Faktoren welche die Frequenz/Periode beeinflussen. Nennen Sie drei Möglichkeiten die Periode des Timer Overflow Interrupt zu beeinflussen. Erstens: Zweitens: Drittens: 9.3 Aufgabe 2.2 Schreiben Sie ein Programm für Zähler/Zeitgebereinheit 0, das einmal pro Sekunde das LED-Ausgabemuster ändert. Das main Programm soll dabei nur aus einer Schleife von Nop Befehlen bestehen. Alle anderen Programmabläufe sollen durch Interrupte ausgelöst werden und in den ISRs abgehandelt werden. 9.4 Aufgabe 2.3 Bei dem Praktikumsboard kommt es vor, dass ein einmaliges Drücken des Tasters mehrfache erkannt wird. Ein sinnvolles Programm, auch für andere Anwendungen, wäre also die Interruptroutinen der Taster so zu ändern, dass sie nach einer Aktivierung für eine oder mehrere Sekunden gesperrt sind. Die einfachste Lösung ist ein wechselseitiges Sperren/Freigeben der Interruptservice Routinen von Taster und Zähler: Beim Auslösen des Tasters wird die dazugehörige Aktion ausgeführt. Danach sperrt sich die Taster- ISR selbst, setzt den Zählerstand zurück und gibt die Zähler-ISR frei. Aufgabe der Zähler-ISR ist es, die Taster-ISRs nach einer Sekunde wieder Freizugeben und sich danach selbst zu sperren. Erstellen sie ein Programm, bei dem mit vier Tastern Interrupte auslöst werden können. Ein nicht symmetrisches LED-Ausgabemuster soll mit Taster 1 um eine Stelle nach rechts geschiftet werden, mit Taster 2 um zwei Stellen nach rechts, mit Taster 3 um eine Stelle nach links und mit Taster 4 um zwei Stellen nach links. Die zugehörigen Interrupte sollen, wie oben beschrieben, auf ein Intervall von zwei Sekunden 28

begrenzt werden. Hinweis: Bei der Verwendung einer 8 Bit Zählereinheit und einer Sperrzeit von zwei Sekunde müssen Sie die Zählerbreite mit einem Hilfsregister erweitern. 9.5 Aufgabe 2.4 Ändern Sie das Programm aus Aufgabe 2.3 so ab, dass alle vier Taster einzeln, mit ingesamt einem 8 Bit Zähler und 5 Hilfsregistern, gesperrt werden. Die Genauigkeit darf dabei um 5 ms abweichen. Das main Programm soll nur aus einer Schleife von Nop Befehlen bestehen. Alle anderen Programmabläufe sollen weiterhin über Interrupte ausgelöst werden und in den ISRs abgehandelt werden. 29

10 Versuch 3 10.1 Inhalt Im dritten Versuch sollen weitere Zählermodi untersucht werden und das Zusammenspiel aus Zählern/Zeitgebern, ISRs und Ein-/Ausgaben besser kennengelernt werden. 10.2 Das PWM Verfahren In dieser Aufgabe sollen die LEDs auf dem Praktikumsboard unterschiedlich helle Muster ausgeben. Die Helligkeit einer LED hängt dabei von der angelegten Spannung ab. Bei der Helligkeitsregelung im Praktikum gibt es aber ein Problem. Der Ausgabepegel an den Ports kann nur zwei Werte annehmen: 0 Volt bei einer Eins im Ausgaberegister und 5 Volt bei einer Null. Eine Helligkeitsdimmung ist aber über Puls Weiten Modulation trotzdem möglich. Das Prinzip ist einfach: Innerhalb einer festen Periode der Dauer T liegt für eine bestimmte Zeit E die Eins am Ausgang. Beim Erreichen des fest eingestellten Vergleichswert E schaltet die Ausgabe um und es liegt für den Rest der Periode (T-E) die Null am Portausgang. Durch das Verhältnis von E zu T liegt dabei innerhalb eines Zyklus im Mittel ein Wert zwischen 5 und 0 Volt an. Ist die Zyklusdauer klein genug, im ms Bereich, nimmt das Menschliche Auge kein Flimmern war, sondern lediglich eine abgestufte Helligkeit. Bei einer Periodendauer von 128 Takten; wie lange muss eine Eins ausgegeben werden, um eine mittlere Ausgangsspannung von ca. 3 Volt zu erreichen? Anzahl der Takte: Wie viele Takte braucht man bei einer Zählerbreite von 16 Bit? Anzahl der Takte: Was fällt bei dem Vergleich mit dem vorherigem Ergebnis auf? Abweichung: Wie heißt der Fehler der zu dieser Abweichung führt 10.3 Die PWM beim ATmega Die Funktion des PWM-Modus lässt sich natürlich auch in Software realisieren. Dazu müssen bei dem Zähler der Überlauf- und Vergleichsinterrupt abgefangen werden, um die Ausgabe zu steuern. Die Frequenz des PWM-Verfahrens entspricht dabei genau der Zählerfrequenz. Der Wert im Vergleichsregister bestimmt den Abstand zwischen den beiden ISRs innerhalb eines Zyklus. Die Pulsweitenmodulation im Hardwaremodus hat den Vorteil, dass die Pegelausgabe ohne Aufruf einer ISR geschieht. Es kann als nicht zu Verzögerungen durch andere ISR kommen. Die Softwareemulation des PWM-Verfahrens bietet aber einen entscheidenden Vorteil: Der Zähler gibt den Pegel im Hardwaremodus nur an einem einzelnen, nicht veränderbaren Pin aus. Welche Aktionen bei der Software-PWM ausgeführt werden, ist natürlich frei wählbar. Natürlich lässt sich die Softwareemulation auch komplett ohne Zähler-/Zeitgebereinheit programmieren, indem man die benötigten Unterprogramme im Hauptprogramm aufruft und nicht in den ISRs. 30