Modulares Experimentiersystem für den PC mit einem Atmel ...info.talentraspel.de/Handbuch.pdf ·...

Autoren: Kai Ludwig (DG4KLU), Volker Ludwig (DD0EU) Stand: 29.04.2006 / V1.07

Modulares Experimentiersystem für den PC mit einem

Atmel-AT90S2313-Mikrocontroller

Aufbauanleitung, Fehlerdiagnose, Inbetriebnahme und Programmierung

anhand von Beispielprogrammen

Modulares Experimentiersystem für den PC mit einem ATMEL-AT90S2313-Mikrocontroller

© 2004-2006 Talentraspel Elektronikversand K. Ludwig Seite 2

Inhalt 1 Einleitung......................................................................................................................................... 5

1.1 Überblick................................................................................................................................... 5 1.2 Systemstruktur .......................................................................................................................... 6 1.3 Die Wahl der Programmiersprache........................................................................................... 6

1.3.1 Basic.................................................................................................................................. 7 1.3.2 C ........................................................................................................................................ 7 1.3.3 Assembler.......................................................................................................................... 7

1.4 Upgrade auf ATtiny2313 .......................................................................................................... 8 2 Hardwarebeschreibung .................................................................................................................. 9

2.1 Basismodul................................................................................................................................ 9 2.2 LED/Taster-Modul.................................................................................................................. 10 2.3 ISP-Modul............................................................................................................................... 11

3 Aufbauanleitung............................................................................................................................ 12 3.1 Aufbau des Basismoduls......................................................................................................... 12 3.2 Aufbau des LED/Taster-Moduls............................................................................................. 13 3.3 Aufbau des ISP-Moduls .......................................................................................................... 14

4 Inbetriebnahme ............................................................................................................................. 15 4.1 Sichtkontrolle .......................................................................................................................... 15 4.2 Überprüfung der Spannungsversorgung des Basismoduls...................................................... 15 4.3 Überprüfung des LED/Taster-Moduls .................................................................................... 16 4.4 Überprüfung des ISP-Moduls ................................................................................................. 18 4.5 Bestückung der integrierten Schaltkreise................................................................................ 18 4.6 Abschließender Test................................................................................................................ 19

5 Die Programmierung des Mikrocontrollers ............................................................................... 21 5.1 Werkzeuge .............................................................................................................................. 21 5.2 Programmierung...................................................................................................................... 22

5.2.1 Datei mit Mikrocontrollerbefehlen in PonyProg laden................................................... 22 5.2.2 Daten zum Mikrocontroller übertragen........................................................................... 22

6 Experimente in der Programmiersprache C .............................................................................. 23 6.1 Werkzeuge .............................................................................................................................. 23 6.2 Programmübersetzung ............................................................................................................ 23 6.3 Aller Anfang ist schwer .......................................................................................................... 25 6.4 Versuch 1: Einschalten der Leuchtdioden (led.c) ................................................................... 26 6.5 Versuch 2: Blinkende Leuchtdioden (led_blinken.c) ............................................................. 27 6.6 Versuch 3: Leuchtdioden als Lauflicht (lauflicht.c) ............................................................... 28 6.7 Versuch 4: Leuchtdioden als Zähler (zaehler.c) ..................................................................... 29 6.8 Versuch 5: Würfelaugen (wuerfel.c)....................................................................................... 29 6.9 Versuch 6: Ampel (ampel.c) ................................................................................................... 30 6.10 Versuch 7: Der erste Interrupt (led_blinken_interrupt.c)........................................................ 30 6.11 Versuch 8: Interrupt mit Zähler (led_blinken_interrupt_zaehler.c)........................................ 32 6.12 Versuch 9: Alles zusammen (lauflicht_ampel_wuerfel.c) ...................................................... 33 6.13 Versuch 10: Taster abfragen (taster.c) .................................................................................... 33 6.14 Versuch 11: Würfel mit Taster (wuerfel_taster.c) .................................................................. 34 6.15 Versuch 12: Ampel mit Taster (ampel_taster.c) ..................................................................... 35 6.16 Versuch 13: Lauflicht mit Taster (lauflicht_taster.c).............................................................. 36 6.17 Versuch 14: Zähler mit Taster (zaehler_taster.c).................................................................... 37



7 Experimente in der Programmiersprache Assembler ............................................................... 38 7.1 Werkzeuge .............................................................................................................................. 38 7.2 Programmübersetzung ............................................................................................................ 39 7.3 Aller Anfang ist schwer .......................................................................................................... 41 7.4 Versuch 1: Einschalten der Leuchtdioden (led.asm) .............................................................. 42 7.5 Versuch 2: Blinkende Leuchtdioden (led_blinken.asm)......................................................... 44 7.6 Versuch 3: Leuchtdioden als Lauflicht (lauflicht.asm)........................................................... 46 7.7 Versuch 4: Leuchtdioden als Zähler (zaehler.asm)................................................................. 47 7.8 Versuch 5: Würfelaugen (wuerfel.asm) .................................................................................. 48 7.9 Versuch 6: Ampel (ampel.asm) .............................................................................................. 48 7.10 Versuch 7: Der erste Interrupt (led_blinken_interrupt.asm)................................................... 49 7.11 Versuch 8: Interrupt mit Zähler (led_blinken_interrupt_zaehler.asm) ................................... 50 7.12 Versuch 9: Alles zusammen (lauflicht_ampel_wuerfel.asm) ................................................. 52 7.13 Versuch 10: Taster abfragen (taster.asm) ............................................................................... 53 7.14 Versuch 11: Würfel mit Taster (wuerfel_taster.asm).............................................................. 54 7.15 Versuch 12: Ampel mit Taster (ampel_taster.asm) ................................................................ 56 7.16 Versuch 13: Lauflicht mit Taster (lauflicht_taster.asm) ......................................................... 56 7.17 Versuch 14: Zähler mit Taster (zaehler_taster.asm) ............................................................... 58

8 Experimente in der Programmiersprache Basic........................................................................ 60 8.1 Werkzeuge .............................................................................................................................. 60 8.2 Programmübersetzung ............................................................................................................ 61 8.3 Aller Anfang ist schwer .......................................................................................................... 63 8.4 Versuch 1: Einschalten der Leuchtdioden (led.bas)................................................................ 64 8.5 Versuch 2: Blinkende Leuchtdioden (led_blinken.bas).......................................................... 65 8.6 Versuch 3: Leuchtdioden als Lauflicht (lauflicht.bas)............................................................ 66 8.7 Versuch 4: Leuchtdioden als Zähler (zaehler.bas).................................................................. 67 8.8 Versuch 5: Würfelaugen (wuerfel.bas) ................................................................................... 67 8.9 Versuch 6: Ampel (ampel.bas)................................................................................................ 68 8.10 Versuch 7: Der erste Interrupt (led_blinken_interrupt.bas) .................................................... 68 8.11 Versuch 8: Interrupt mit Zähler (led_blinken_interrupt_zaehler.bas) .................................... 70 8.12 Versuch 9: Alles zusammen (lauflicht_ampel_wuerfel.bas) .................................................. 71 8.13 Versuch 10: Taster abfragen (taster.bas)................................................................................. 71 8.14 Versuch 11: Würfel mit Taster (wuerfel_taster.bas)............................................................... 72 8.15 Versuch 12: Ampel mit Taster (ampel_taster.bas).................................................................. 73 8.16 Versuch 13: Lauflicht mit Taster (lauflicht_taster.bas) .......................................................... 74 8.17 Versuch 14: Zähler mit Taster (zaehler_taster.bas) ................................................................ 75



Abbildungen Abbildung 1 - Experimentiersystem ......................................................................................................... 5 Abbildung 2 - Systemübersicht................................................................................................................. 6 Abbildung 3 - ATtiny2313 Konfigurationsbits für AT90S2313 Kompatibilität ...................................... 8 Abbildung 4 - Basismodul ........................................................................................................................ 9 Abbildung 5 - Schaltplan Basismodul ...................................................................................................... 9 Abbildung 6 - LED/Taster-Modul .......................................................................................................... 10 Abbildung 7 - Schaltplan LED/Taster-Modul ........................................................................................ 10 Abbildung 8 - ISP-Modul ....................................................................................................................... 11 Abbildung 9 - Schaltplan ISP-Modul...................................................................................................... 11 Abbildung 10 - Bestückung Basismodul ................................................................................................ 12 Abbildung 11 - Bestückung LED/Taster-Modul .................................................................................... 13 Abbildung 12 - Bestückung ISP-Modul.................................................................................................. 14 Abbildung 13 - Dialog „Neues Projekt“ bei AVR Studio 4 ................................................................... 39 Abbildung 14 - Dialog „Optionen Programmiergerät“ bei BASCOM-AVR ......................................... 61 Abbildung 15 - Schaltplan Basismodul .................................................................................................. 77 Abbildung 16 - Bestückung Basismodul ................................................................................................ 78 Abbildung 17 - Schaltplan LED/Taster-Modul ...................................................................................... 79 Abbildung 18 - Bestückung LED/Taster-Modul .................................................................................... 80 Abbildung 19 - Schaltplan ISP-Modul.................................................................................................... 81 Abbildung 20 - Bestückung ISP-Modul.................................................................................................. 82



1 Einleitung Für die Nutzung eines Mikrocontrollersystems von der Lösung einfacher Steuerungsaufgaben bis hin zur Bewältigung anspruchsvoller stationärer oder mobiler Roboteranwendungen wurde ein anschauli-ches und vielseitiges Experimentiersystem entwickelt. Die Programmierung wird anhand von Beispielprogrammen in den Programmiersprachen C, Assemb-ler und Basic erläutert. Die Programme wurden möglichst ähnlich strukturiert, um einen Vergleich zwi-schen den verschiedenen Programmiersprachen zu ermöglichen.

1.1 Überblick Das modulare Experimentiersystem arbeitet mit dem programmierbaren Mikrocontroller AT90S2313 von Atmel. Es besteht in seiner Grundversion aus dem Basismodul mit Mikrocontroller und integrierter Spannungsversorgung und den Modulen ISP-Modul1 sowie LED/Taster-Modul. Diese werden jeweils über Flachbandkabel miteinander verbunden (vgl. Abb. 1). An diese Module können - je nach Aufga-benstellung - weitere Bauteile bzw. Module wie z.B. Lautsprecher, Mikrofon, IR-Sender, IR-Empfänger, RS232-Schnittstelle, LCD-Anzeige, Tastatur, Motorsteuerungen, Sensormodule usw. an-geschlossen werden. Für die Kommunikation mit anderen Mikrocontrollermodulen oder I2C-tauglichen2 Bausteinen steht ein I2C-Interface mit bei Bedarf steckbarer Terminierung zur Verfügung.

Abbildung 1 - Experimentiersystem

1 ISP (In-System-Programming, d. h. Programmierung des Mikrocontrollers direkt in der Zielschaltung) 2 I2C (Inter-IC, ein Protokoll zur Kommunikation zwischen integrierten Schaltkreisen)



1.2 Systemstruktur Die Struktur des Systems ist aus Abb. 2 ersichtlich.

Abbildung 2 - Systemübersicht

1.3 Die Wahl der Programmiersprache Die Wahl der zu verwendenden Programmiersprache hängt immer von der geplanten Anwendung ab. Ich empfehle zum Einstieg die Programmiersprache C, wenn mehr als nur kleine Programme entwi-ckelt werden sollen. Assembler kann auf dieser Basis später noch gut dazugelernt werden. Für einen schnelleren Einstieg und bei Entwicklung einfacher Programme kann die Programmiersprache Basic empfohlen werden. Die einleitenden Versuche mit dem Experimentiersystem sind in C, Assembler und in Basic program-miert. Dadurch ist ein guter Vergleich der Programmiersprachen möglich. Die Programme wurden un-ter Verzicht auf sprachspezifische Optimierungen entwickelt, damit sie besser verglichen werden kön-nen. Optimierte Versionen für die Programmiersprachen C und Basic stehen ebenfalls zur Verfügung.



1.3.1 Basic Für Anwendungen, die nicht zeitkritisch sind, kann Basic z.B. mit BASCOM-AVR verwendet werden. Viele komplexe Dinge, wie die Verwendung von Interrupts oder die Ansteuerung von RS232, LCD bzw. I2C sowie Algorithmen für z.B. IR-Senden und Empfangen, stehen bereits zur Verfügung. Gerade für Einsteiger fällt hier die Einarbeitung leicht, da der Zugriff auf die Hardware durch vorgefertigte Befehle und Strukturen vereinfacht wird und die Syntax der Programmiersprache recht einfach ist. Bei komplexeren und zeitkritischen Anwendungen zeigt dieses Konzept aber seine Schwächen, da sich dann die vorgefertigten Bibliotheksfunktionen und der große Abstand zur Hardware des Mikrocontrol-lers bei der Programmentwicklung störend auswirken. Die für genau auf den Mikrocontroller abge-stimmte Anwendungen nötige Transparenz der Entwicklungsumgebung ist nicht mehr vorhanden.

1.3.2 C Gerade für die AVR-Mikrocontroller empfiehlt sich der Einsatz der Programmiersprache C. Der Be-fehlssatz und die Architektur dieser Mikrocontroller wurden speziell für die Programmiersprache C optimiert. Als Hochsprache stellt C Konstrukte für Datenstrukturen und Programmablaufsteuerung zur Verfügung und ermöglicht dennoch durch die direkte Einbindung von Assemblerbefehlen eine hard-warenahe Programmierung in zeitkritischen Programmabschnitten. Dadurch können auch komplexe Anwendungen strukturiert entwickelt werden. Durch die Verwendung von Bibliotheken können kom-plexere Funktionen eingebunden werden. Gängige C-Compiler optimieren den Programmcode sehr effizient. Die gerade bei der Fehlersuche nötige Transparenz der Entwicklungsumgebung bleibt erhal-ten. Der etwas höhere Aufwand im Vergleich zu Basic lohnt sich aber schnell, da man die AVR-Mikrocontroller mit C gut strukturiert programmieren kann und dabei trotzdem die volle Kontrolle über die Hardware behält. Durch den Einsatz von Bibliotheken muss nicht jede Grundfunktion selbst entwi-ckelt werden. Fertige und getestete Bibliotheken stehen zur Verfügung. Wenn komplexere Anwendun-gen entwickelt werden, zahlt sich der höhere Einarbeitungsaufwand aus, da C einen guten Kompromiss als hardwarenahe Hochsprache darstellt.

1.3.3 Assembler Bei extrem zeitkritischen Anwendungen sollte immer Assembler verwendet werden. Diese Program-miersprache ist allerdings für Einsteiger schlecht geeignet, da hier neben dem Erlernen der Sprache auch genaue Kenntnisse über die Hardware des Mikrocontrollers erforderlich sind. Da in Assembler direkt mit den elementaren Befehlen des Mikrocontrollers programmiert wird, kann hier bei sorgfälti-ger Planung des Programms ein optimales und genau definiertes Laufzeitverhalten erreicht werden. Die Entwicklung komplexerer Anwendungen ist allerdings extrem aufwändig, da keine aus Hochspra-chen bekannten Konstrukte für Datenstrukturen und Programmablaufsteuerung zur Verfügung stehen und die Programme bei zunehmender Größe schnell unübersichtlich werden.



1.4 Upgrade auf ATtiny2313 Für das vorliegende Experimentiersystem wurde bewusst der AT90S2313 ausgewählt, da er für den Einstieg noch recht einfach aufgebaut ist, aber schon eine ausreichende Anzahl von Möglichkeiten für anspruchsvolle Versuche bietet. Statt des AT90S2313, der inzwischen nicht mehr hergestellt wird, kann allerdings auch problemlos der modernere ATtiny2313 verwendet werden. Er ist pinkompatibel und wird an Stelle des AT90S2313 ohne weitere Modifikationen in die Schaltung eingesetzt. Die bestehenden Programme können weiter-hin für den AT90S2313 übersetzt werden und trotzdem in den ATtiny2313 programmiert werden. Zur Programmierung ist in diesem Fall unbedingt PonyProg ab Version 2.06f zu verwenden. Dort muss dann der Mikrocontollertyp über „Device -> AVR Micro“ auf „ATtiny2313“ gesetzt werden. Damit sich der ATtiny2313 vollständig kompatibel zum AT90S2313 verhält, sind noch die Konfigurationsbits wie in der folgenden Abbildung angegeben einzustellen.

Abbildung 3 - ATtiny2313 Konfigurationsbits für AT90S2313 Kompatibilität

Der ATtiny2313 bietet natürlich mehr Leistung und Funktionalität als der AT90S2313. Für die Pro-grammierung stehen eine Menge zusätzlicher Möglichkeiten zur Verfügung, die im Datenblatt zum ATtiny2313 detailliert beschrieben sind. Durch Austausch des 10 MHz-Quarzes gegen einen 20 MHz-Quarz kann die maximale Geschwindigkeit des ATtiny2313 genutzt werden. Es bleibt dem Anwender überlassen, ob er sich erst mit dem einfacheren AT90S2313 beschäftigt, oder gleich in die volle Komplexität des ATtiny2313 einsteigt.



2 Hardwarebeschreibung

2.1 Basismodul

Abbildung 4 - Basismodul

Das Basismodul mit Mikrocontroller und integrierter Spannungsversorgung (Schaltplan vgl. Abb. 4) besteht aus einer Platine mit zwei Spannungsversorgungsklemmen, einer Diode als Verpolungsschutz, einer Leuchtdiode mit Vorwiderstand für die Betriebsanzeige, einem Spannungskonstanter für 5 Volt mit Kühlkörper sowie stabilisierenden Kondensatoren. Der Mikrocontrolleranteil der Platine beherbergt einen Sockel für die Aufnahme eines Mikrocontrollers AT90S2313, einen Quarz 10 MHz mit zwei Kondensatoren, eine Resetlogik mit dem TL7757 Spannungsüberwachungsbaustein und einem Reset-Taster, sowie Steckvorrichtungen für die Verbindung mit einem ISP-Modul (10-polig), einem LED/Taster-Modul (2x10-polig), einem RS232-Modul (5-polig), zwei I2C-Anschlüssen (jeweils 5-polig) und einem 2-poligen Anschluss für die Weiterleitung der stabilisierten 5V-Spannung. Die Steck-verbindungen zum LED/Taster-Modul entsprechen den zwei Ports (Pin-Nr. minus 1 = Bit-Nr.) des AT90S2313 und können auch für andere Ein-/Ausgabe-Module verwendet werden.

Abbildung 5 - Schaltplan Basismodul



2.2 LED/Taster-Modul

Abbildung 6 - LED/Taster-Modul

Das LED/Taster-Modul (Schaltplan vgl. Abb. 6) das mit dem Basismodul verbunden wird, beherbergt auf seiner Platine 8 kreisförmig angeordnete Leuchtdioden mit Vorwiderständen. Weitere 7 Leuchtdio-den mit Vorwiderständen sind in einem Würfelaugenmuster angeordnet und können über einen Jumper auf farbigen Betrieb zur Darstellung von zwei Ampeln umgestellt werden. Drei Taster dienen der Ein-gabe von Signalen. Die auf dem Basismodul für I2C und RS232 benutzten Signale können per Jumper von den Leuchtdioden getrennt werden, um störendes Blinken zu vermeiden.

Abbildung 7 - Schaltplan LED/Taster-Modul



2.3 ISP-Modul

Abbildung 8 - ISP-Modul

Das ISP-Modul (Schaltplan vgl. Abb. 8) besteht aus einer Platine mit einem 25-poligen SUB-D-Stecker, einem Sockel für die Aufnahme des IS3 74HC244, einer Steckverbindung zum Basismodul sowie einem Widerstand, einem Kondensator und einer Diode. Das Modul wird über ein 25-poliges SUB-D-Druckerkabel an den PC-Druckerport angeschlossen. Zusammen mit einer Programmiersoft-ware wie z.B. PonyProg, kann der Mikrocontroller des Basismoduls direkt in der Zielschaltung pro-grammiert werden.

Abbildung 9 - Schaltplan ISP-Modul

3 IS (Integrierter Schaltkreis)



3 Aufbauanleitung Die Bauteile müssen plan auf der Platine aufliegen, um Leiterbahnschäden durch späteren Druck auf die Bauteile zu vermeiden. Daher sollte der Aufbau in der Reihenfolge der Bauteilehöhe erfolgen. Die jeweiligen Bauteile sollten nach dem Bestücken direkt verlötet werden.

3.1 Aufbau des Basismoduls Der Aufbau des Basismoduls geschieht mithilfe des Bestückungsplans in Abb. 9.

Abbildung 10 - Bestückung Basismodul

• Widerstand 330 Ohm mit den Farben orange, orange, braun und gold • Widerstand 100 kOhm mit den Farben braun, schwarz, gelb und gold • Diode 1N4001

Sie ist polrichtig einzulöten, ihr silberner Ring auf schwarzem Gehäuse kennzeichnet die Ka-thode und entspricht dem Querbalken zur „Pfeilspitze“ im Schaltbild.

• 10 MHz Quarz • Zwei Kondensatoren 22 pF • 20-poliger Sockel mit einer Kerbe als Markierungszeichen.

Der AT90S2313-Mikrocontroller wird später mit seiner Markierung darauf ausgerichtet. Der Sockel fällt beim Wenden der Platine zum Einlöten nicht heraus, wenn zwei äußere, weit über Kreuz auseinanderliegende Anschlüsse leicht nach außen gebogen werden.

• Leuchtdiode Das kurze Bein kennzeichnet die Kathode. Sie zeigt in Richtung der beiden später zu montie-renden Port-Wannenstecker

• Dreibeiniger Spannungsüberwachungsbaustein TL7757 • Drei Kondensatoren 100 nF • Reset-Taster • Drei 5-polige und eine 2-polige Stiftleiste. Die Stifte zeigen zum nahegelegenen Platinenrand.



• Drei 10-polige Wannensteckverbinder Die Aussparung am ISP-Wannenstecker zeigt zum IS, die Aussparungen der beiden Port-Wannenstecker zeigen zum Platinenrand. Die Pins zügig einlöten, weil sich sonst die Stifte we-gen zu großer Hitze im aufgeweichten Kunststoff verziehen.

• 2-polige Anreih-Schraubklemme Die Öffnungen für das Kabel zeigen nach außen.

• Kondensator 470 µF Der Minuspol zeigt zum Platinenrand.

• Spannungskonstanter 7805 mit Kühlkörper In einem ersten Schritt den Spannungskonstanter ohne Kühlkörper polrichtig (Metallseite zur Platinenbohrung) in die Platine stecken. Dann wird das Bauteil zur Platinenbohrung hin so um-gebogen, dass das Montageloch des 7805 mit der Platinenbohrung zur Deckung kommt und das Bauteil plan auf der Platine aufliegt. Im zweiten Schritt wird der so vorgebogene 7805 wieder aus der Platine gezogen, auf den Kühlkörper gelegt und mit diesem zusammen erneut in die Pla-tine gesteckt. Danach wird die Schraube M3x5 von der Bestückungsseite her durch den 7805, den Kühlkörper und die Platine gesteckt und festgeschraubt.

• Zweiadriges Kabelstück Das beigelegte 2-adrige Kabelstück wird an beiden Seiten abisoliert und an einem Ende ver-zinnt. Die farbig markierte verzinnte Ader (+5V) wird mit dem mittleren Pin der Hohlstecker-kupplung verlötet, die andere Ader (Masse) kommt an den seitlichen Pin. Das Kabel wird nun in die Anreih-Schraubklemme eingesteckt (farbige Ader zum Platinenrand) und festgeschraubt.

Wichtig: Der Mikrocontroller wird noch nicht eingesetzt.

3.2 Aufbau des LED/Taster-Moduls Der Aufbau des LED/Taster-Moduls geschieht mithilfe des Bestückungsplans in Abb. 10.

Abbildung 11 - Bestückung LED/Taster-Modul



• 18 Widerstände 150 Ohm mit den Farben braun, grün, braun und gold • Widerstand 10 Ohm mit den Farben braun, schwarz, schwarz, gold • Drei Taster • 8 LEDs mit je zwei Anschlüssen unter Beachtung der Polung.

Die abgeflachten Seiten an den Gehäusen kennzeichnen die Kathoden. Sie zeigen alle in Rich-tung der Taster.

• 7 Duo-LEDs mit je drei Anschlüssen unter Beachtung der Polung. Die abgeflachten Seiten an den Gehäusen kennzeichnen die Kathoden für die Farbe grün. Sie zeigen alle in Richtung der Taster.

• Fünf 3-polige Stiftleisten für die Jumper. Die kurzen Anschlüsse gehören in die Platine. Nach dem Einlöten werden die Jumper aufgesteckt, damit diese nicht verloren gehen.

• Zwei 10-polige Wannensteckverbinder Die Aussparungen zeigen in Richtung Platinenmitte.

3.3 Aufbau des ISP-Moduls Der Aufbau des ISP-Moduls geschieht mithilfe des Bestückungsplans in Abb. 11.

Abbildung 12 - Bestückung ISP-Modul

• Diode 1N4148

Sie ist gepolt einzulöten, ihr z.B. schwarzer Ring auf durchsichtigem Gehäuse kennzeichnet die Kathode und entspricht dem Querbalken zur „Pfeilspitze“ im Schaltbild.

• 100 kOhm Widerstand mit den Farben braun, schwarz, gelb, gold • 20-poliger Sockel mit einer Kerbe als Markierungszeichen. Das IS 74HC244 wird später mit

seiner Markierung darauf ausgerichtet. Der Sockel fällt beim Wenden der Platine zum Einlöten nicht heraus, wenn zwei äußere, weit über Kreuz auseinanderliegende Anschlüsse leicht nach außen gebogen werden.

• 100 nF Kondensator • 10-poliger Wannenstecker

Die Aussparung zeigt zum IS.



• 25-poliger SUB-D-Stecker Zuerst, nach Überprüfung auf gute Einrastung aller Stifte, die Doppelstifte in den beiden 3-mm-Bohrungen mit der Platine so verlöten, dass die Bohrungen mit Lötzinn ausgefüllt sind. Die Lötstellen danach jeweils etwas abkühlen lassen und danach die 25 Stifte verlöten.

4 Inbetriebnahme

4.1 Sichtkontrolle Vor der Inbetriebnahme der einzelnen Platinen sollte die Bestückungsseite nach liegengebliebenen Drähten und die Lötseite nach Lötrückständen oder Zinnbrücken abgesucht werden.

4.2 Überprüfung der Spannungsversorgung des Basismoduls Wichtig: Bei starker Erhitzung des Kühlkörpers SOFORT abschalten, da dann ein Kurzschluss vorliegt. Das Basismodul polrichtig mit einem Netzteil 9 V Gleichspannung, 0,8 A verbinden. Wenn die LED auf dem Basismodul leuchtet und der Kühlkörper sich nicht erwärmt, dann arbeitet die Spannungsver-sorgung, und es ist auch kein Kurzschluss vorhanden. Fehlerdiagnose: 1. Die LED auf dem Spannungsversorgungsteil des Basismoduls bleibt dunkel.

Mögliche Fehlerquellen:

• Das Netzteil ist defekt: Die Spannung am Netzteil nachmessen. • Die Diode ist verpolt: Die Diode umpolen. • Die Diode ist defekt, sodass an ihrer Kathode keine Spannung anliegt, obwohl an der

Anode Spannung anliegt: Die Diode austauschen. • Der Spannungsregler ist defekt, sodass an seinem Ausgang keine Spannung anliegt, ob-

wohl an seinem Eingang eine Spannung anliegt: Den Spannungsregler austauschen. • Die Leuchtdiode ist verpolt: Die Leuchtdiode umpolen. • Die Leuchtdiode ist defekt und leuchtet trotz anliegender Spannung nicht: Die Leucht-

diode austauschen. • Wenn beim Nachmessen des Spannungsverlaufs die Spannung zwischen zwei miteinan-

der verbundenen Messpunkten verloren geht, dann liegt entweder eine kalte Lötstelle oder eine Leiterbahnunterbrechung vor: Kalte Lötstellen nachlöten, unterbrochene Lei-terbahnen an der Unterbrechungsstelle z.B. mit Lötzinn überbrücken.



2. Starke Erhitzung des Kühlkörpers

Mögliche Fehlerquelle:

• Es liegt ein Kurzschluss vor: Kurzschluss mit dem Ohmmeter suchen (Auf Lötrückstän-de oder Zinnbrücken achten).

Wichtig: Der Mikrocontrolleranteil wird erst nach dem Test des LED/Taster-Moduls geprüft. Der Mikrocontroller wird noch nicht eingesetzt!

4.3 Überprüfung des LED/Taster-Moduls Nach dem Abschalten der Spannungsversorgung das LED/Taster-Modul mit dem Basismodul (ohne eingesetzten Mikrocontroller!) verbinden. Nach dem Einschalten der Spannungsversorgung muss die Kontroll-LED weiter leuchten. Wichtig: Bei starker Erhitzung des Kühlkörpers SOFORT abschalten, da dann ein Kurzschluss vorliegt. Fehlerdiagnose: 1. Die LED auf dem Spannungsversorgungsmodul geht aus, der Konstanter 7805 wird heiß.


• Kurzschluss auf dem LED/Taster-Modul: Kurzschluss mit dem Ohmmeter suchen (Auf Lötrückstände oder Zinnbrücken achten).

Nun können die 15 LEDs (ohne eingesetzten Mikrocontroller!) einzeln überprüft werden. Dazu werden die vier Jumper in Richtung Wannenstecker gesetzt. Ebenso wird der alleinstehende Jum-per in Richtung Wannenstecker gesetzt. Wichtig: Auf keinen Fall die falsche Seite der LED-Vorwiderstände mit Masse verbinden, da sonst die LEDs zerstört werden. Jetzt klemmt man ein Ende eines Prüfkabels an Masse (z.B. Kühlkörper des Spannungskonstanters), das andere Ende des Prüfkabels hält man nacheinander an die zu den Wannensteckern zeigenden Beine der 150 Ohm LED-Vorwiderstände. Alle 15 LEDs müssen nun nacheinander rot aufleuchten. Wenn der allein stehende Jumper umgesetzt wird, leuchten bei erneutem Test die LEDs D3 und D5 gelb, die LEDs D1 und D2 leuchten grün.



Fehlerdiagnose: 1. Keine LED leuchtet.


• Die gemeinsame Zuleitung zu den LEDs ist unterbrochen: Diese vom Wannenstecker beginnend mit Hilfe eines Voltmeters auf fehlende Spannung hin untersuchen. Eine be-stehende Unterbrechung z.B. mit Lötzinn überbrücken.

• Das Zuleitungskabel vom Basismodul ist defekt: Wenn auch an Pin 10 des Wannenste-ckers keine + 5V anliegen, diese aber am Wannenstecker des Basismoduls anliegen, dann ist das zugehörige Verbindungskabel defekt und muss ausgetauscht werden.

• Die Zuleitung zum Wannenstecker auf dem Basismodul ist unterbrochen: Wenn am Wannenstecker des Basismoduls keine +5V anliegen, dann ist die Zuleitung zum Pin 10 des Wannensteckers auf dem Basismodul unterbrochen. Diese auf dem Basismodul vom Wannenstecker beginnend mit Hilfe eines Voltmeters auf fehlende Spannung hin unter-suchen. Eine bestehende Unterbrechung z.B. mit Lötzinn überbrücken.

2. Einzelne LEDs leuchten nicht oder in der falschen Farbe.


• Die LED ist verpolt eingesetzt: Sichtvergleich mit LED, die in der richtigen Farbe auf-leuchtet bzw. den Sitz der Abflachung am LED-Körper überprüfen. Verpolte LED um-drehen.

• Fehler am Vorwiderstand: Leuchtet eine LED immer noch nicht, ist der dazugehörende Vorwiderstand zu prüfen und gegebenenfalls nachzulöten.

• Unterbrochene Leiterbahn: Wenn die LED nach Überprüfung der dazugehörenden Lei-terbahn auf Unterbrechungen immer noch nicht leuchtet, dann ist sie defekt und muss ausgetauscht werden.

Zum Test der Taster werden diese gedrückt. Es leuchtet jeweils eine LED auf.

1. Linker Taster: LED8 leuchtet rot. 2. Mittlerer Taster: LED1 leuchtet rot. 3. Rechter Taster: LED2 leuchtet rot.

Fehlerdiagnose: 1. Unabhängig vom gedrückten Taster leuchten keine LEDs.


• Die gemeinsame Masseleitung ist unterbrochen: Zugehörige Leiterbahn mit dem Ohm-meter überprüfen. Eine bestehende Unterbrechung z.B. mit Lötzinn überbrücken.



2. Bei Betätigung einzelner Taster leuchtet die zugehörige LED nicht.


• Die jeweilige Leitung zur LED ist unterbrochen: Leiterbahnen mit dem Ohmmeter überprüfen. Eine bestehende Unterbrechung z.B. mit Lötzinn überbrücken.

• Der Taster ist defekt: Den Taster austauschen.

4.4 Überprüfung des ISP-Moduls Nach dem Abschalten der Spannungsversorgung das ISP-Modul mithilfe des 10-poligen Flachbandka-bels mit dem Basismodul verbinden. Das LED/Taster-Modul kann angeschlossen bleiben. Nach dem Einschalten der Spannungsversorgung muss die Kontroll-LED wieder leuchten. Wichtig: Bei starker Erhitzung SOFORT abschalten, da dann ein Kurzschluss vorliegt

4.5 Bestückung der integrierten Schaltkreise Nun bei abgeschalteter Spannungsversorgung das IS 74HC244 polrichtig auf dem ISP-Modul einset-zen. Dies muss bei leichtem Widerstand möglich sein. (Vor dem Einfügen eines unbenutzten4 IS in einen Sockel sollten die beiden Anschlussreihen des IS auf einer geraden Unterlage durch leichtes Bie-gen parallel ausgerichtet werden). Die Spannungsversorgung nun wieder einschalten. Die Kontroll-LED des Basismoduls muss wieder wie gewohnt leuchten. Der Kühlkörper und das IS 74HC244 dürfen nicht heiß werden, sonst liegt ein Kurzschluss vor. Danach die Spannungsversorgung wieder abschalten und das Flachbandkabel zwischen Programmier- und Basismodul entfernen. Den Mikrocontroller At-mel AT90S2313 polrichtig auf dem Basismodul einsetzen. Die Spannungsversorgung wieder einschal-ten. Auch hier muss die Kontroll-LED des Basismoduls wieder wie gewohnt leuchten. Der Mikrocont-roller Atmel AT90S2313 und der Kühlkörper dürfen nicht heiß werden, sonst liegt ein Kurzschluss vor. Wurde der Mikrocontroller mit dem vorprogrammierten Diagnoseprogramm eingesetzt, so beginnen die LEDs bereits zu blinken. Fehlerdiagnose: 1. Kurzschluss


• Ein IS wurde verpolt eingesetzt: IS polrichtig einsetzen, gegebenenfalls ersetzen. • Kurzschluss durch Lötbrücke oder Lötzinnreste: Leiterbahnen mit dem Ohmmeter über-

prüfen. Eine bestehende Unterbrechung z.B. mit Lötzinn überbrücken.

4 erkennbar an den leicht nach außen gewinkelten Anschlüssen



4.6 Abschließender Test Wenn die Kontroll-LED auf dem Basismodul sowie die 15 LEDs auf dem LED/Taster-Modul zufrie-denstellend arbeiten und die integrierten Schaltkreise erfolgreich bestückt wurden, dann kann in einem abschließenden Test die Gesamtfunktion des Experimentiersystems überprüft werden. Der mitgelieferte Mikrocontroller ist bereits mit einem Diagnoseprogramm vorprogrammiert und kann daher direkt für den Test verwendet werden. Nach dem Einschalten blinken alle 15 LEDs. Bei Betätigung des linken Tasters leuchten nur LED8 und LED15, bei Betätigung des mittleren Tasters leuchten nur LED1 sowie LED12, und bei Betätigung des rechten Tasters leuchten nur LED2 und LED14. Fehlerdiagnose: 1. Eine oder mehrere LEDs bleiben dunkel.


• Die Leitung vom Vorwiderstand der betreffenden LED bis zum Pin des Mikrocontrol-lers ist unterbrochen oder hat einen Kurzschluss: Leiterbahnen mit dem Ohmmeter überprüfen und gegebenenfalls den Kurzschluss beseitigen. Eine bestehende Unterbre-chung z.B. mit Lötzinn überbrücken.

2. Alle LEDs bleiben dunkel.


• An Pin 20 des 74HC244 oder an Pin 20 des AT90S2313 liegen keine +5 Volt an: Die in-frage kommenden Leiterbahnen mit einem Ohmmeter auf Unterbrechung überprüfen.

• An Pin 10 des 74HC244 und Pin 10 des AT90S2313 liegt keine Masse: Die infrage kommenden Leiterbahnen mit einem Ohmmeter auf Unterbrechung überprüfen.

• Unterbrechung der Resetleitung (Pin 3,5,7 des 74HC244 und Pin 1 des AT90S2313): Die infrage kommenden Leiterbahnen mit einem Ohmmeter auf Unterbrechung überprü-fen.

• Unterbrechung zwischen Pin 4 und 5 des AT90S2313 und den jeweiligen Anschlüssen des Quarzes: Die infrage kommenden Leiterbahnen mit einem Ohmmeter auf Unterbre-chung überprüfen.

• Kurzschlüsse zwischen benachbarten Anschlüssen des AT90S2313: Die infrage kom-menden Anschlüsse mit einem Ohmmeter auf Kurzschluss überprüfen. Bei Kurzschluss diesen entfernen.

• Quarz schwingt nicht: An Pin des AT90S2313 mit einem Oszilloskop nachmessen, ob 10 MHz vorhanden sind. Ist kein Oszilloskop verfügbar, dann zumindest überprüfen, ob die Verbindung von Masse an Pin 10 des AT90S2313 mit den Kondensatoren am Quarz vorhanden ist und ob die anderen Enden der Kondensatoren jeweils mit dem Quarz ver-bunden sind. Im Zweifel die Kondensatoren und den Quarz nachlöten und dabei sicher-stellen, dass die Anschlüsse tatsächlich mit den Leiterbahnen verbunden sind.



• Der Mikrocontroller ist defekt: Mikrocontroller ersetzen und programmieren (vgl. Kapi-tel 5).

• Der Mikrocontroller ist nicht korrekt programmiert: Mikrocontroller erneut program-mieren (vgl. Kapitel 5).

3. Reset funktioniert nicht.


• Der Resettaster schaltet im gedrückten Zustand den Pin 1 des AT90S2313 nicht von +5 Volt auf 0 Volt: Die infrage kommenden Leiterbahnen mit einem Ohmmeter auf Unter-brechung überprüfen.

4. Mikrocontroller lässt sich nicht programmieren (Bei Programmierung wie in Kapitel 5).


• Unterbrechung zwischen Pin 11 des 74HC244 und Pin 18 des AT90S2313, Unterbre-chung zwischen Pin 12 und 14 des 74HC244 und Pin 19 des AT90S2313 oder Unterbre-chung zwischen Pin 18 des 74HC244 und Pin 17 des AT90S2313: Die in Frage kom-menden Anschlüsse mit einem Ohmmeter auf Kurzschluss überprüfen.

• Der Mikrocontroller ist defekt: Mikrocontroller ersetzen und programmieren (vgl. Kapi-tel 5).



5 Die Programmierung des Mikrocontrollers Bei der Entwicklung eines Programms wird ein Quelltext in einer Programmiersprache wie z.B. C, Assembler oder Basic erstellt. Dieser wird dann in vom Mikrocontroller ausführbare Befehle übersetzt. Bei der Programmiersprache Assembler heißt dieser Vorgang „assemblieren“, bei den Programmier-sprachen C und Basic heißt dieser Vorgang „kompilieren“. Die aus dem Quelltext durch assemblieren oder kompilieren erzeugten ausführbaren Befehle werden in einer Datei mit der Dateinamenerweiterung „.hex“5 abgelegt. Diese Datei kann dann mit einer Pro-grammiersoftware wie z.B. PonyProg, in den Mikrocontroller übertragen werden. Für die Versuche mit dem Experimentiersystem können die Quelltexte für die verschiedenen Pro-grammiersprachen als komprimierte Dateien bei www.talentraspel.de in der Rubrik „Experimentiersys-tem -> Dokumentation und Downloads“ heruntergeladen werden. Die Dateien sind auch auf der mitge-lieferten CD enthalten. Die Inhalte der komprimierten Dateien lassen sich aus folgender Tabelle ent-nehmen: Datei Unterverzeichnis Inhalt avr2313_c_v101.zip avr2313_c Quelltexte der C-Programme avr2313_c\vorkompiliert Dateien mit Mikrocontrollerbefehlen avr2313_assembler_v100.zip avr2313_assembler Quelltexte der Assembler-Programme avr2313_assembler\vorkompiliert Dateien mit Mikrocontrollerbefehlen avr2313_bascom_v100.zip avr2313_bascom Quelltexte der Basic-Programme avr2313_bascom\vorkompiliert Dateien mit Mikrocontrollerbefehlen Im jeweiligen Unterverzeichnis „..\vorkompiliert“ sind bereits die übersetzten Dateien mit den vom Mikrocontroller ausführbaren Befehlen enthalten. Diese können direkt mit PonyProg in den Mikrocon-troller übertragen werden ohne vorher die Quelltexte übersetzen zu müssen. Die Übersetzung der Quelltexte wird bei den verschiedenen Sprachversionen jeweils beim ersten Expe-riment beschrieben.

5.1 Werkzeuge Für die Programmierung des Mikrocontrollers ist zunächst das Programm PonyProg nötig. Dieses kann bei www.talentraspel.de in der Rubrik „Experimentiersystem -> Dokumentation und Downloads“ her-untergeladen werden. Hier werden auch Hinweise zur Bedienung von PonyProg in einer deutschspra-chigen Anleitung gegeben. Bei der Installation von PonyProg können die von der Installationsroutine vorgeschlagenen Vorgaben unverändert übernommen werden. Nach der Installation muss PonyProg, wie in der deutschsprachigen Anleitung beschrieben, eingerichtet werden.

5 Die Dateinamenerweiterung „.hex“ kennzeichnet ein standardisiertes Dateiformat. Dateien in diesem Format werden zur Übertragung von übersetzten Programmen in einen Mikrocontroller verwendet.



5.2 Programmierung Die Programmierung des Mikrocontrollers besteht im Wesentlichen aus zwei Schritten. Zunächst wird die zu übertragende Datei mit Mikrocontrollerbefehlen in PonyProg geladen, danach werden die Daten zum Mikrocontroller übertragen. Hierzu müssen neben einem Windows-PC folgende Bestandteile vorhanden sein:

• Das Programm PonyProg • Das Experimentiersystem • Ein geeignetes Netzgerät • Ein 25-poliges SUB-D-Druckerkabel (Stecker/Buchse) zum Anschluss des ISP-Moduls an den

PC Die Komponenten müssen folgendermaßen verbunden werden:

• Das LED/Taster-Modul mit dem Basismodul verbinden • Das ISP-Modul mit dem Basismodul verbinden • Das ISP-Modul mit dem SUB-D-Druckerkabel an den PC anschließen • Die Spannungsversorgung mit dem Basismodul verbinden

Danach kann mit der Übertragung von Dateien mit Mikrocontrollerbefehlen zum Mikrocontroller be-gonnen werden.

5.2.1 Datei mit Mikrocontrollerbefehlen in PonyProg laden Im PonyProg-Menü "File" den Punkt "Open Device File..." wählen, im Dialog die Datei mit Mikro-controllerbefehlen (Dateityp „.hex“) auswählen und mit [OK] in PonyProg laden.

5.2.2 Daten zum Mikrocontroller übertragen Im PonyProg-Menü "Command" den Punkt "Program" wählen. PonyProg überträgt die Daten aus der Datei mit Mikrocontrollerbefehlen in den Mikrocontroller und verifiziert im Anschluss, ob der Pro-grammiervorgang fehlerfrei durchgeführt wurde. Dazu wird der Inhalt des Mikrocontroller-Flash-Speichers gelesen und mit dem Inhalt der geladenen Datei verglichen. Das alte Programm im Mikrocontroller wird vor der Programmierung gelöscht.



6 Experimente in der Programmiersprache C Je nach Vorwissen des Benutzers des Experimentiersystems kann dieser seinen Einstieg frei wählen, also z.B. mit einer Roboter-Programmierung beginnen (erfordert zusätzliche Hardware) oder zunächst den Einstieg mit einfachen Experimenten finden. Die hier beschriebene Programmierung erfolgt in der Programmiersprache C. Die dazu benötigte Ent-wicklungsumgebung ist das kostenlos erhältliche WinAVR. Zur Übertragung der Programmdateien in den Mikrocontroller wird das ebenfalls kostenlos erhältliche PonyProg verwendet (vgl. Kapitel 5). Al-ternativ können natürlich auch andere (kommerzielle) Programme verwendet werden. Zum Einstieg in die Programmiersprache C sollte das allgemeine AVR GCC Tutorial (vgl. Kapitel 6.1) dienen. Parallel dazu können dann die im Folgenden angegebenen Experimente direkt mit dem Expe-rimentiersystem durchgeführt werden. Die Bedienung der Entwicklungsumgebung WinAVR von der Programmeingabe bis hin zur Kompilie-rung der Programme wird im WinAVR Tutorial (vgl. Kapitel 6.1) beschrieben. Die im Folgenden an-gegebenen Programme können auf dieser Basis mit WinAVR kompiliert werden.

6.1 Werkzeuge Zur Übersetzung der C-Programme wird das Programm WinAVR benötigt. Bei der Installation von WinAVR können die von der Installationsroutine vorgeschlagenen Vorgaben unverändert übernommen werden. Das Programm kann bei www.talentraspel.de in der Rubrik „Experimentiersystem -> Doku-mentation und Downloads“ heruntergeladen werden. Dort gibt es auch ein WinAVR Tutorial, das den Umgang mit WinAVR erläutert. Zusätzlich gibt es noch ein AVR GCC Tutorial, das den Umgang mit der Programmiersprache C speziell für Atmel-Mikrocontroller erklärt. Weitere Details zum Mikrocontroller AT90S2313 können aus der Beschrei-bung des Befehlssatzes und den zugehörigen Datenblättern entnommen werden. Die Quelltexte für die C-Programme können als komprimierte Dateien bei www.talentraspel.de in der Rubrik „Experimentiersystem -> Dokumentation und Downloads“ heruntergeladen werden. Die Datei „avr2313_c_v101.zip“ sollte direkt auf die Hauptverzeichnisebene des Laufwerks C „C:\“ entpackt werden. Dadurch liegen die Daten dann im Unterverzeichnis „C:\avr2313_c“. Zum Editieren von C-Programmen wird der Editor „Programmers Notepad“ verwendet. Er kann über „Start -> Programme -> WinAVR -> Programmers Notepad“ aufgerufen werden.

6.2 Programmübersetzung Um mit WinAVR ein C-Programm zu kompilieren, benötigt man den Quelltext in einer Datei mit der Dateinamenerweiterung „.c“ und ein dazugehöriges Makefile. Beide Dateien müssen in einem Ver-zeichnis liegen. Wenn die Datei mit den Quelltexten, wie in Kapitel 6.1 beschrieben, entpackt wurde, dann liegen die C-Programme alle im Unterverzeichnis „C:\avr2313_c“



Die Datei mit dem Quelltext enthält das eigentliche Programm. Damit es von WinAVR einwandfrei übersetzt werden kann, wird noch ein Makefile benötigt. Dieses steuert die Reihenfolge der Bearbei-tungsschritte bei der Programmübersetzung. Das Makefile kann als Kopie des in „C:\WinAVR\sample“ liegenden Beispielmakefiles „makefile“ erstellt werden. Um für jedes Programm ein eigenes Makefile zu erhalten, verwendet man den Pro-grammnamen und die Dateinamenerweiterung „.mak“ für die Benennung des Makefiles. Für das Pro-gramm „led.c“ nennt man das Makefile z.B. „led.mak“ An einem so durch Kopie erzeugten neuen Makefile sind für einfache C-Programme ein paar Anpas-sungen vorzunehmen:

• In der Zeile „MCU =“ ist der Typ des verwendeten Mikrocontrollers einzutragen. In diesem Fall also „MCU = at90s2313“.

• In der Zeile „TARGET =“ ist der Name des C-Programms ohne die Dateinamenerweiterung „.c“ einzutragen. Für das Programm „led.c“ also „TARGET = led“.

• In der Zeile „SRC =“ ist der Name des C-Programms mit Dateinamenerweiterung „.c“ einzu-tragen. Für das Programm „led.c“ also „SRC = led.c“.

• In der Zeile „CPPSRC =“ ist der Name des C++-Programms „main.cpp“ immer zu entfernen. • In der Zeile „F_CPU =“ ist die Taktfrequenz des verwendeten Systems einzutragen. Hier also

immer „F_CPU = 10000000“. Für die Beispielprogramme sind bereits alle Makefiles vorhanden. Um nun ein Programm zu übersetzen, werden folgende Schritte ausgeführt:

• Eingabeaufforderung (DOS-Box) öffnen über „Start -> Programme -> Zubehör -> Eingabeaufforderung“.

• Nun „cd \av2313_c“ eingeben und dann die Eingabetaste drücken. • Danach „make –f led.mak“ eingeben. Dies startet den Übersetzungsvorgang für das Programm

„led.c“. • Nach der Übersetzung die Textausgabe in der Eingabeaufforderung auf Fehlermeldungen über-

prüfen. Eine erfolgreiche Programmübersetzung endet mit der Zeile „-------- end --------“. Nach erfolgreicher Übersetzung erscheint im Verzeichnis „C:\avr2313_c“ eine neue Datei „led.hex“. Diese Datei enthält die ausführbaren Befehle für den Mikrocontroller und kann, wie in Kapitel 5 be-schrieben, mit PonyProg zum Mikrocontroller übertragen werden. Nach jeder Programmänderung muss der Übersetzungsvorgang - wie oben beschrieben - wiederholt werden, damit eine neue Datei mit Mikrocontrollerbefehlen erstellt wird.



6.3 Aller Anfang ist schwer Für die Versuchsdurchführung sollten die Taster des LED/Taster-Moduls zum Benutzer zeigen. Die Seite mit den Tastern wird im Folgenden als "unten" bezeichnet. Zur Durchführung der folgenden Versuche sollten die vier benachbarten Jumper nach links ge-setzt werden. Der allein stehende Jumper sollte zunächst auch nach links gesetzt werden. Nur bei den Ampelversuchen wird dieser nach rechts gesetzt (vgl. Kapitel 6.9). Um die folgenden C-Programme besser lesen zu können, sollte man einige einfache Bestandteile ken-nen:

• Beginn eines Kommentarblocks /*

• Ende eines Kommentarblocks

*/

• Einzeiliger Kommentar // Dies ist ein Kommentar

• Einbindung einer Bibliothek

#include <inttypes.h>

• Programmrumpf int main (void) { // Hier kommt das Programm rein }

• Beginn einer Zahl in hexadezimaler Notation: 0x

Beginn einer Zahl in binärer Notation: 0b In den Programmen werden einige speziellere Operatoren verwendet:

• Operator " Wert um 1 erhöhen" ++

• Operator " Wert um 1 verringern"

--

• Operator "Wert negieren"

~

• Operator "Wert nach links schieben"

<<

• Operator "Wert nach rechts schieben"

>>



6.4 Versuch 1: Einschalten der Leuchtdioden (led.c) Das Programm "led.c" zeigt die Grundstruktur eines C-Programms und führt die elementaren Befehle zur Initialisierung der Ports aus. Die Ports werden dabei durch Beschreiben der Datenrichtungsregister6 DDRB und DDRD mit dem hexadezimalen Wert FF auf Ausgang geschaltet. Die Ausgänge werden durch Beschreiben der Portregister7 PORTB und PORTD mit dem hexadezimalen Wert 00 auf 0 (ent-spricht 0 Volt) gesetzt. Danach verbleibt das Programm in einer Endlosschleife. /****************************************************************************************************** Program: led Funktion: Initialisiert die Ports, schaltet die Ports auf Ausgang und setzt die Ausgänge auf 0, damit die gegen 5V geschalteten Leuchtdioden leuchten. Autor: Kai Ludwig / Version: 1.00 Copyright 2004 by DG4KLU ******************************************************************************************************/ #include <inttypes.h> // Allgemeine Bibliotheken #include <avr/io.h> #include <avr/interrupt.h> #include <avr/signal.h> int main (void) { DDRB=0xFF; // Port B auf Ausgang PORTB=0x00; // Alle Ausgänge auf 0 DDRD=0xFF; // Port D auf Ausgang PORTD=0x00; // Alle Ausgänge auf 0 for (;;) {} // Endlosschleife }

Die LEDs sind gemeinsam an ihren Anoden mit + 5 Volt verbunden. Das Setzen aller Ausgänge von Port B und von Port D auf den Wert 0 führt dazu, dass die 15 LEDs an ihren Kathoden auf 0 Volt ge-legt werden, sodass sie leuchten. Die Hardwareanordnung wurde so gewählt, da der Mikrocontroller seine Ausgänge mit 20 mA gegen Masse schalten kann, jedoch nur mit 3 mA gegen + 5 Volt. Zahlen können entweder in dezimaler8, hexadezimaler9 oder binärer10 Notation angegeben werden. Zur Umwandlung zwischen den einzelnen Darstellungen empfiehlt sich die Verwendung des Windows-Taschenrechners.

6 Für jeden Anschluss wird im Datenrichtungsregister (DDR = data direction register) festgelegt, ob er als Eingang oder als Ausgang arbeitet. Wird das zum Anschluss gehörende Bit auf 1 gesetzt, so arbeitet der Anschluss als Ausgang. Sonst arbei-tet er als Eingang. 7 Bei als Ausgang arbeitenden Anschlüssen entscheidet der Wert des zugehörigen Bits im Portregister, ob am Ausgang 0 Volt (Bit ist auf 0 gesetzt) oder 5 Volt (Bit ist auf 1 gesetzt) anliegen. Bei als Eingang arbeitenden Anschlüssen entscheidet der Wert des zugehörigen Bits im Portregister, ob ein interner Pull-Up-Widerstand zugeschaltet (Bit ist auf 1 gesetzt) wird oder nicht (Bit ist auf 0 gesetzt). Ein zugeschalteter Pull-Up-Widerstand sorgt dafür, dass ein nicht angeschlossener Eingang auf dem definierten Pegel 5 Volt gehalten wird. 8 zur Basis 10 mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8 und 9 9 zur Basis 16 mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E und F (Hexadezimalzahlen beginnen in C mit „0x“) 10 zur Basis 2 mit den Ziffern 0 und 1 (Binärzahlen beginnen in C mit „0b“)



Im diesem Programm werden alle Ausgänge auf 0 gesetzt. Also: PORT B = binär 00000000 = dezimal 0 = hexadezimal 00 PORT D = binär 00000000 = dezimal 0 = hexadezimal 00 Variation: Aus den Schaltplänen des Basis-Moduls und des LED/Taster-Moduls geht hervor, dass LED1 mit Aus-gang 0 von Port B verbunden ist. Um nun LED1 einzeln leuchten zu lassen, muss der Ausgang 0 auf 0 und alle anderen Ausgänge auf 1 gesetzt werden. Also: PORT B = binär 11111110 = dezimal 254 = hexadezimal FE PORT D = binär 11111111 = dezimal 255 = hexadezimal FF

6.5 Versuch 2: Blinkende Leuchtdioden (led_blinken.c) Das Programm "led_blinken.c" führt die gleiche Initialisierung aus, die bereits im Programm "led.c" erläutert wurde. In der Endlosschleife werden die Leuchtdioden aber regelmäßig ein- und ausgeschal-tet. Die Blinkfrequenz wird über eine Warteschleife gesteuert, die als Funktion implementiert ist. Warteschleife: void warte(uint16_t t) { // Funktion "Warteschleife" uint16_t i, j; for (i=0;i<t;i++) { // Verschachtelte Schleife mit Befehl nop="Tue nichts", damit for (j=1;j<200;j++) { // die Schleife nicht wegoptimiert wird. asm volatile ("nop"); } } }

Variation: Verringert man in der inneren Schleife den Wert 200 z.B. auf den Wert 10, so erhöht sich die Blinkfre-quenz deutlich bei der Programmausführung, da die Schleifendurchlaufzeit nun kürzer ist. Durch An-passung dieses Wertes lässt sich also das Zeitverhalten der Schleife justieren.



Die folgenden Befehle innerhalb der Endlosschleife schalten die LEDs immer wieder an und aus: for (;;) { // Endlosschleife PORTB=0x00; // Alle Ausgänge auf 0 (LEDs an) PORTD=0x00; warte(4000); // Warten PORTB=0xFF; // Alle Ausgänge auf 1 (LEDs aus) PORTD=0xFF; warte(4000); // Warten }

Variation: Durch gleiches Verändern beider Werte "warte(4000)" kann die Blinkfrequenz symmetrisch blinkend verändert werden. Durch ungleiches Verändern beider Werte "warte(4000)" kann die Symmetrie der Blinkfrequenz verändert werden.

6.6 Versuch 3: Leuchtdioden als Lauflicht (lauflicht.c) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt ein Lauflicht auf den Leuchtdioden aus. lauflicht=1; // Lauflicht auf Anfang setzen for (;;) { // Endlosschleife PORTB=~lauflicht; // Untere 8 Bit auf PORT B ausgegeben (invertiert) lauflicht=lauflicht<<1; // Lauflicht um 1 Bit nach links weiterschieben if (lauflicht==0) // Wenn Lauflicht durchgelaufen ist, lauflicht=1; // dann wieder am Anfang beginnen warte(2000); // Warten }

Die 8-Bit-Variable "lauflicht" wird zunächst mit der Binärzahl "00000001" (dezimal 1) initialisiert. Durch "<<1" wird das Bitmuster um ein Bit nach links geschoben ("00000010"). Wenn nach dem ach-ten Mal die 1 nach links herausgeschoben wurde, ist danach die Variable "lauflicht" wieder gleich Null. Dann wird die Variable erneut auf 1 gesetzt, und das Lauflicht beginnt von neuem. Variation: Wenn die 8-Bit-Variable "lauflicht" zunächst mit der Binärzahl "10000000" (dezimal 128) initialisiert wird und zum Verschieben des Wertes statt "<<1" nun ">>1" verwendet wird, dann läuft das Lauflicht anders herum.



6.7 Versuch 4: Leuchtdioden als Zähler (zaehler.c) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und zählt einen 16-Bit-Zähler bis dezimal 32767 (binär "0111111111111111"). Die unteren 8 Bit werden auf Port B, die oberen 8 Bit auf Port D ausgegeben. zaehler=0; for (;;) { // Endlosschleife PORTB=~zaehler; // Untere 8 Bit auf PORT B ausgegeben (invertiert) PORTD=~(zaehler>>8); // Obere 8 Bit auf PORT D ausgegeben (invertiert) zaehler++; // Zähler um 1 erhöhen if (zaehler==32768) // und bei 32768 wieder auf Null setzen zaehler=0; warte(1000); // Warten }

Mit ">>8" wird der Wert um 8 Bit nach rechts geschoben. Dadurch werden die oberen 8 Bit des 16-Bit-Wertes an die Position der unteren 8 Bit geschoben und können dann auf den 8-Bit-Port D ausgegeben werden. Bei der Ausgabe des 16-Bit-Wertes auf den 8-Bit-Port B werden die oberen 8 Bit einfach igno-riert.

6.8 Versuch 5: Würfelaugen (wuerfel.c) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt nacheinander Werte auf die Ausgänge, sodass die Leuchtdioden in Würfelaugenmustern aufleuchten. Die zu den Mustern gehörenden Werte ergeben sich dabei gemäß folgender Tabelle11: Muster Bit 7

(unbe-nutzt)

Bit 6 (LED oben links)

Bit 5 (LED oben rechts)

Bit 4 (LED mitte links)

Bit 3 (LED mitte)

Bit 2 (LED mitte rechts)

Bit 1 (LED unten links)

Bit 0 (LED unten rechts)

Hexadezimal-zahl

1 0 0 0 0 1 0 0 0 08 2 0 1 0 0 0 0 0 1 41 3 0 0 1 0 1 0 1 0 2A 4 0 1 1 0 0 0 1 1 63 5 0 1 1 0 1 0 1 1 6B 6 0 1 1 1 0 1 1 1 77

11 Wenn man die in einer Tabellenzeile enthaltenen Einträge der Bits 7 bis 0 aneinander schreibt, so erhält man eine 8-stellige Binärzahl. In Zeile 1 ergibt sich somit binär „00001000“, dies entspricht hexadezimal 08.



6.9 Versuch 6: Ampel (ampel.c) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt nacheinander Werte auf die Ausgänge, sodass Ampelphasen auf den Leuchtdioden ausgegeben werden. Wichtig: Damit die Leuchtdioden auch in den Farben Gelb und Grün aufleuchten, muss der einzeln stehende Jumper auf dem LED/Taster-Modul nach rechts gesetzt werden. Die zu den Mustern gehörenden Werte ergeben sich dabei gemäß folgender Tabelle: Phase (linke Ampel, rechte Ampel)

Bit 7 (unbe-nutzt)




Bit 3 (LED mitte)




Hexadezimal-zahl

ROT_ROTGELB 0 1 1 0 0 1 0 0 64 ROT_GRUEN 0 1 0 0 0 0 0 1 41 ROT_GELB 0 1 0 0 0 1 0 0 44 ROTGELB_ROT 0 1 1 1 0 0 0 0 70 GRUEN_ROT 0 0 1 0 0 0 1 0 22 GELB_ROT 0 0 1 1 0 0 0 0 30 ROT_ROT 0 1 1 0 0 0 0 0 60

6.10 Versuch 7: Der erste Interrupt (led_blinken_interrupt.c) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und setzt diese auf 0. Die Ausgän-ge werden in einer durch Timer 0 ausgelösten Interruptroutine12 abwechselnd auf 0 oder 1 gesetzt, in-dem sie jeweils invertiert werden. Die Taktfrequenz wird zunächst durch einen einstellbaren Vorteilungsfaktor geteilt, bevor sie an den Timer 0 gelangt. Trotz maximaler Vorteilung blinken die LEDs immer noch recht schnell, da die von der Taktfrequenz abhängige Interruptroutine mit 10.000.000 Hz geteilt durch (1024*256) = ca. 38 Hz aufgerufen wird. Da für eine vollständige Blinkphase zwei Aufrufe benötigt werden, ergibt sich eine Blinkfrequenz von ca. 19 Hz. Die Vorteilung von 1024 wird im Register TCCR0 eingestellt. Die weitere Teilung von 256 ergibt sich aus dem in Timer 0 geladenen Startwert 0, der 256 mal erhöht wird, bis er erneut auf 0 springt und da-mit den Interrupt wieder auslöst. Die Beschreibung des Timers und die Werte für die Vorteilung kön-nen aus dem Datenblatt zum AT90S2313 entnommen werden.

12 Interruptroutine = Programmteil, der im Rahmen einer Unterbrechung des Hauptprogramms aufgerufen wird



Interruptroutine: SIGNAL(SIG_OVERFLOW0) { TCNT0 = 0x00; // Timer-0-Startwert setzen (Teilung 256) PORTB=~PORTB; // Ausgänge invertieren PORTD=~PORTD; }

Im Hauptprogramm wird der Timer-0 Interrupt initialisiert, dann werden die Interrupts aktiviert und danach bleibt das Programm in einer Endlosschleife. Alle weiteren Aktivitäten geschehen in der Inter-ruptroutine. int main (void) { DDRB=0xFF; // Port B auf Ausgang PORTB=0x00; // Alle Ausgänge auf 0 DDRD=0xFF; // Port D auf Ausgang PORTD=0x00; // Alle Ausgänge auf 0 TCCR0 = (5<<CS00); // Timer-0-Vorteiler auf 1024 TCNT0 = 0x00; // Timer-0-Startwert setzen (Teilung 256) sbi(TIMSK,TOIE0); // Timer-0-Interrupt einschalten sei(); // Interrupts aktivieren for (;;) {} // Endlosschleife }

Variation: Durch Verändern des Startwertes für Timer 0 an beiden Stellen im Programm kann die Blinkfrequenz gesteigert werden. Durch Verändern des Vorteilers in TCCR0 ist eine weitere Steigerung der Blinkfre-quenz möglich. Allerdings wird das Blinken dann ohne Messgerät nicht mehr wahrnehmbar sein. Verändert man den Vorteilerwert von 1024 auf 256 („TCCR0 = (4<<CS00);“), so erhöht sich die Blinkfre-quenz von ca. 19 Hz um den Faktor 4 auf ca. 77 Hz. Das menschliche Auge kann diese Blinkfrequenz nicht mehr wahrnehmen. Bewegt man bei dieser Blinkfrequenz jedoch die Platine mit den LEDs schnell hin und her, so sieht man die durch die Bewegung verursachten Leuchtspuren der getakteten LEDs mit Unterbrechungen. Die Leuchtspur der ungetakteten grünen LED auf der Basisplatine zeigt keine Unterbrechungen.



6.11 Versuch 8: Interrupt mit Zähler (led_blinken_interrupt_zaehler.c) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und setzt diese auf 0. In der durch Timer 0 ausgelösten Interruptroutine wird eine Zählvariable heruntergezählt. Im Hauptprogramm wird nach dem Umschalten der Ausgänge gewartet, bis die Zählvariable nach dem Setzen auf einen Start-wert wieder bei Null ankommt. Interruptroutine: #define TIMER0_STARTWERT 0x80 // Startwert für Timer-0 (Teilung 128) volatile uint16_t zaehler; // Zähler für Zeitsteuerung SIGNAL(SIG_OVERFLOW0) { TCNT0 = TIMER0_STARTWERT; // Timer-0-Startwert setzen if (zaehler>0) // Zähler herunterzählen zaehler--; }

Hier wird durch "#define" dem Text "TIMER0_STARTWERT" der Text "0x80" zugeordnet. Da im weiteren Programm immer auf "TIMER0_STARTWERT" Bezug genommen wird, kann der eigentli-che Wert dadurch an zentraler Stelle definiert und verändert werden. Das Schlüsselwort "volatile" ist in Verbindung mit Variablen, die in Interruptroutinen verwendet wer-den, nötig. Die Interruptroutine wird mit 10.000.000 Hz geteilt durch (8*128) = ca. 9,8 kHz aufgerufen. Der Wert 8 entspricht der eingestellten Vorteilung. Der Wert 128 ergibt sich aus dem in Timer 0 geladenen Start-wert (hexadezimal 80 = dezimal 128), der noch 128 mal erhöht wird, bis er erneut auf 0 springt und damit den Interrupt wieder auslöst. Im Hauptprogramm wird der Timer-0-Interrupt initialisiert, dann werden die Interrupts aktiviert und danach bleibt das Programm in einer Endlosschleife. In der Endlosschleife werden jeweils die Leucht-dioden ein- oder ausgeschaltet. Danach wird ein Zähler auf den Wert 4000 gesetzt und gewartet, bis dieser in der mit 9,8 kHz aufgerufenen Interruptroutine wieder auf 0 heruntergezählt wurde. Daraus ergibt sich eine Blinkfrequenz von ca. 1 Hz (pro Blinkphase 2 mal warten). TCCR0 = (2<<CS00); // Timer-0-Vorteiler auf 8 TCNT0 = TIMER0_STARTWERT; // Timer-0-Startwert setzen sbi(TIMSK,TOIE0); // Timer-0-Interrupt einschalten sei(); // Interrupts aktivieren for (;;) { // Endlosschleife PORTB=0x00; // Alle Ausgänge auf 0 (LEDs an) PORTD=0x00; zaehler=4000; // Zählvariable auf Startwert setzen while (zaehler>0) {} // Warten, bis Zählvariable wieder bei Null ankommt PORTB=0xFF; // Alle Ausgänge auf 1 (LEDs aus) PORTD=0xFF; zaehler=4000; // Zählvariable auf Startwert setzen while (zaehler>0) {} // Warten, bis Zählvariable wieder bei Null ankommt }



Variation: Durch gleiches Verändern beider Werte "zaehler=4000" kann die Blinkfrequenz symmetrisch blinkend verändert werden. Durch ungleiches Verändern beider Werte "zaehler=4000" kann die Symmetrie der Blinkfrequenz verändert werden.

6.12 Versuch 9: Alles zusammen (lauflicht_ampel_wuerfel.c) Das Programm vereint die Funktionen der Programme "lauflicht.c", "ampel.c" und "wuerfel.c". Nach der Initialisierung der Ports wird auf Port B ein Lauflicht ausgegeben. Dieses wird in der Interruptrou-tine gesteuert und läuft somit im Hintergrund. Die Geschwindigkeit des Lauflichts wird durch die in der Interruptroutine heruntergezählte Zählvariable bestimmt. Im Hauptprogramm werden nacheinander Ampelphasen und Würfelaugenmuster ausgegeben, dabei wird die Zeitsteuerung des Ablaufs über eine Warteschleife erreicht. Die Würfelaugenmuster werden durch eine Schleife mehrfach ausgegeben. Der Quelltext des Programms ist kommentiert, Details können dort eingesehen werden.

6.13 Versuch 10: Taster abfragen (taster.c) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Die Aus-gänge an Port B werden auf 1 gesetzt und die Pull-Up-Widerstände werden zu den Eingängen an Port D dazugeschaltet. Der Zustand der drei Taster wird abgefragt und jeweils mit einer LED angezeigt. int main (void) { DDRB=0xFF; // Port B auf Ausgang PORTB=0xFF; // Alle Ausgänge auf 1 DDRD=0x00; // Port D auf Eingang PORTD=0xFF; // Mit dazugeschalteten Pull-Up-Widerständen for (;;) { // Endlosschleife if (bit_is_clear(PIND,6)) // Taster 1 abfragen (gedrückt = Bit geht auf 0) cbi(PORTB,7); // Zugehörige LED an else sbi(PORTB,7); // Zugehörige LED aus if (bit_is_clear(PIND,3)) // Taster 2 abfragen (gedrückt = Bit geht auf 0) cbi(PORTB,0); // Zugehörige LED an else sbi(PORTB,0); // Zugehörige LED aus if (bit_is_clear(PIND,5)) // Taster 3 abfragen (gedrückt = Bit geht auf 0) cbi(PORTB,1); // Zugehörige LED an else sbi(PORTB,1); // Zugehörige LED aus } }

In der Endlosschleife wird geprüft, ob der Eingang durch den jeweiligen Taster auf 0 geschaltet wurde. In diesem Fall wird die zugehörige Leuchtdiode eingeschaltet. Beim Drücken eines Tasters leuchten zwei LEDs. Die obere LED leuchtet bedingt durch die Hardware, die untere LED leuchtet gesteuert durch die Software.



Die Zuordnung von Tastern, Eingängen und Ausgabeleuchtdioden ergibt sich aus folgender Tabelle: Taster Eingang an Port D Ausgang an Port B

für Leuchtdiode 1 6 7 2 3 0 3 5 1

6.14 Versuch 11: Würfel mit Taster (wuerfel_taster.c) Das Programm initialisiert die Ports und schaltet diese auf Ausgang. Der Ausgang, an dem Taster 2 angeschlossen ist, wird durch kurzes Umschalten auf Eingang auch als Eingang abgefragt. Wenn der Taster gedrückt wird, läuft der Würfel mit Maximalgeschwindigkeit und rollt nach dem Los-lassen des Tasters langsam aus. Der zufällige Zeitpunkt des Loslassens bestimmt indirekt den Würfel-wert, auf die Verwendung einer Zufallsfunktion wurde verzichtet. Abfrage des Tasters: uint8_t taster(void) { // Tasterabfrage durch kurzes Umschalten auf Eingang uint8_t status, ret_val; status=PORTD&0x08; // Alten Status merken cbi(DDRD,3); // Bit auf Eingang schalten sbi(PORTD,3); if (bit_is_clear(PIND,3)) // Taster abfragen ret_val=1; else ret_val=0; PORTD=(PORTD&0xF7)|status; // Alten Status wieder herstellen sbi(DDRD,3); // Bit wieder auf Ausgang schalten return ret_val; }

Im Hauptprogramm wird regelmäßig der Taster abgefragt. Das kurze Umschalten des Ausgangs auf Eingang ist allerdings nicht wahrnehmbar. phase=1; zeit=5000; for (;;) { // Endlosschleife if (taster()) { // Auf Taster warten wuerfel_schritt(); zeit=1000; PORTB=0x00; } else if (zeit<5000) { // Ausrollen wuerfel_schritt(); warte(zeit); zeit=zeit+250; if (zeit>=5000) PORTB=0xFF; } }



Solange der Taster als gedrückt erkannt wird, werden die Würfelmuster schnell weitergeschaltet. Es sieht dann so aus, als ob alle Augen gleichzeitig leuchten. Nach dem Loslassen des Tasters beginnt der Würfel auszurollen. Dabei wird die Zeit für die Warteschleife stufenweise erhöht, damit der Eindruck eines immer langsamer werdenden Ausrollvorgangs entsteht. Ist der Würfel langsam genug, so bleibt er stehen. Während des gesamten Würfelvorgangs werden die Leuchtdioden an Port B eingeschaltet. Sobald der Würfel stehen bleibt, werden diese wieder ausgeschaltet. Variation: Durch Verändern des Wertes 5000 an allen Stellen im Programm kann die Dauer des Ausrollvorgangs beeinflusst werden. Durch Verändern des Wertes 250 in der Zeile „zeit=zeit+250;“ kann die Geschwin-digkeit des Ausrollvorgangs beeinflusst werden.

6.15 Versuch 12: Ampel mit Taster (ampel_taster.c) Das Programm initialisiert die Ports und schaltet diese auf Ausgang. Der Ausgang, an dem Taster 2 angeschlossen ist, wird durch kurzes Umschalten auf Eingang auch als Eingang abgefragt. Wenn der Taster gedrückt wird, beginnt nach kurzem Warten eine Ampelphase. Nach Ablauf der Am-pelphase wartet das Programm auf den nächsten Tasterdruck. Zur Abfrage des Tasters wird dieselbe Funktion "taster" benutzt, die auch schon im Programm "wuer-fel_taster.c" zum Einsatz kam. Der Ablauf der Ampelphasen wird wie im Programm "ampel.c" durch eine Warteschleife gesteuert.



6.16 Versuch 13: Lauflicht mit Taster (lauflicht_taster.c) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Wenn der linke Taster gedrückt wird, bewegt sich das Lauflicht einen Schritt im Uhrzeigersinn. Wenn der rechte Taster gedrückt wird, bewegt sich das Lauflicht einen Schritt gegen den Uhrzeigersinn. Wenn der mitt-lere Taster gedrückt wird, dann stellt sich das Lauflicht auf die Ausgangsposition zurück. Um die Taster zu entprellen, wird jeweils nach Drücken und Loslassen kurz gewartet. Dadurch werden die beim Prellen entstehenden zusätzlichen Impulse nicht ausgewertet. Ohne Entprellen würde das Lauflicht "springen". lauflicht=1; for (;;) { // Endlosschleife if ((PIND&0x68)!=0x68) { // Warte auf beliebigen Taster warte(10); // Entprellen if ((PIND&0x68)==0x28) { // Wenn Taster 1 gedrückt wurde lauflicht=lauflicht>>1; // Lauflicht um 1 Bit nach rechts weiterschieben if (lauflicht==0) // Wenn Lauflicht durchgelaufen ist, dann wieder am Anfang beginnen lauflicht=128; } else if ((PIND&0x68)==0x48) { // Wenn Taster 3 gedrückt wurde lauflicht=lauflicht<<1; // Lauflicht um 1 Bit nach links weiterschieben if (lauflicht==0) // Wenn Lauflicht durchgelaufen ist, dann wieder am Anfang beginnen lauflicht=1; } else if ((PIND&0x68)==0x60) { // Wenn Taster 3 gedrückt wurde lauflicht=1; // Lauflicht zurücksetzen } while ((PIND&0x68)!=0x68) {} // Warte bis kein Taster gedrückt ist warte(10); // Entprellen } PORTB=~lauflicht; // Untere 8 Bit auf PORT B ausgegeben }

Zur Abfrage der Taster wird mit hexadezimal 68 UND-verknüpft. Dadurch werden die zugehörigen Bits ausmaskiert. Wenn der ausmaskierte Wert nicht gleich hexadezimal 68 ist, so wurde mindestens ein Taster gedrückt. Beim Wert hexadezimal 28 wurde das Bit 6 für Taster 1 auf 0 geschaltet. Beim Wert hexadezimal 60 wurde das Bit 3 für Taster 2 auf 0 geschaltet. Beim Wert hexadezimal 48 wurde das Bit 5 für Taster 3 auf 0 geschaltet. Durch Vergleich kann also der jeweils gedrückte Taster be-stimmt werden. Wenn mehrere Taster gleichzeitig gedrückt werden, so reagiert das Programm nicht.



6.17 Versuch 14: Zähler mit Taster (zaehler_taster.c) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Wenn der linke Taster gedrückt wird, wird der Zähler um 1 verringert. Wenn der rechte Taster gedrückt wird, wird der Zähler um 1 erhöht. Wenn der mittlere Taster gedrückt wird, dann stellt sich der Zähler auf 0 zurück. Um die Taster zu entprellen, wird jeweils nach Drücken und Loslassen kurz gewartet. Dadurch werden die beim Prellen entstehenden zusätzlichen Impulse nicht ausgewertet. Ohne Entprellen würde der Zäh-ler "springen". zaehler=0; for (;;) { // Endlosschleife if ((PIND&0x68)!=0x68) { // Warte auf beliebigen Taster warte(10); // Entprellen if ((PIND&0x68)==0x28) { // Wenn Taster 1 gedrückt wurde zaehler--; // Zähler um 1 verringern if (zaehler==65535) // Wenn Zähler-Unterlauf, dann wieder am Anfang beginnen zaehler=32767; } else if ((PIND&0x68)==0x48) { // Wenn Taster 3 gedrückt wurde zaehler++; // Zähler um 1 erhöhen if (zaehler==32768) // Wenn Zähler-Überlauf, dann wieder am Anfang beginnen zaehler=0; } else if ((PIND&0x68)==0x60) { // Wenn Taster 3 gedrückt wurde zaehler=0; // Zähler zurücksetzen } while ((PIND&0x68)!=0x68) {} // Warte bis kein Taster gedrückt ist warte(10); // Entprellen } PORTB=~zaehler; // Untere 8 Bit auf PORT B ausgegeben (invertiert) PORTD=~(zaehler>>8); // Obere 8 Bit auf PORT D ausgegeben (invertiert) }




7 Experimente in der Programmiersprache Assembler Je nach Vorwissen des Benutzers des Experimentiersystems kann dieser seinen Einstieg frei wählen, also z.B. mit einer Roboter-Programmierung beginnen (erfordert zusätzliche Hardware) oder zunächst den Einstieg mit einfachen Experimenten finden. Die hier beschriebene Programmierung erfolgt in der Programmiersprache Assembler. Die dazu benö-tigte Entwicklungsumgebung ist das kostenlos erhältliche AVR Studio von ATMEL. Zur Übertragung der Programmdateien in den Mikrocontroller wird das ebenfalls kostenlos erhältliche PonyProg ver-wendet (vgl. Kapitel 5). Alternativ können natürlich auch andere (kommerzielle) Programme verwen-det werden. Zum Einstieg in die Programmiersprache Assembler sollte das allgemeine AVR Assembler Tutorial (vgl. Kapitel 7.1) dienen. Parallel dazu können dann die im Folgenden angegebenen Experimente direkt mit dem Experimentiersystem durchgeführt werden. Die Bedienung der Entwicklungsumgebung AVR Studio von der Programmeingabe bis hin zur As-semblierung der Programme wird im AVR Studio Tutorial (vgl. Kapitel 7.1) beschrieben. Die im Fol-genden angegebenen Programme können auf dieser Basis mit AVR Studio assembliert werden.

7.1 Werkzeuge Zur Übersetzung der Assembler-Programme wird das Programm AVR Studio benötigt. Bei der Instal-lation von AVR Studio können die von der Installationsroutine vorgeschlagenen Vorgaben unverändert übernommen werden. Das Programm kann bei www.talentraspel.de in der Rubrik „Experimentiersys-tem -> Dokumentation und Downloads“ heruntergeladen werden. Dort gibt es auch ein AVR Studio Tutorial, das den Umgang mit AVR Studio erläutert. Zusätzlich gibt es noch ein AVR Assembler Tutorial, das den Umgang mit der Programmiersprache Assembler spe-ziell für Atmel-Mikrocontroller erklärt. Weitere Details zum Mikrocontroller AT90S2313 können aus der Beschreibung des Befehlssatzes und den zugehörigen Datenblättern entnommen werden. Die Quelltexte für die Assembler-Programme können als komprimierte Dateien bei www.talentraspel.de in der Rubrik „Experimentiersystem -> Dokumentation und Downloads“ herun-tergeladen werden. Die Datei „avr2313_assembler_v100.zip“ sollte direkt auf die Hauptverzeichnis-ebene des Laufwerks C „C:\“ entpackt werden. Dadurch liegen die Daten dann im Unterverzeichnis „C:\avr2313_assembler“. Zum Editieren von Assembler-Programmen wird der in AVR Studio integrierte Editor verwendet. Er steht nach dem Start von AVR Studio zur Verfügung, sobald eine Datei bzw. ein Projekt geöffnet oder erstellt wurde.



7.2 Programmübersetzung Um mit AVR Studio ein Assembler-Programm zu assemblieren, benötigt man den Quelltext in einer Datei mit der Dateinamenerweiterung „.asm“. Zusätzlich gibt es noch eine Projektdatei mit der Datei-namenerweiterung „.aps“ in der AVR Studio weitere Daten verwaltet. Wenn die Datei mit den Quell-texten, wie in Kapitel 7.1 beschrieben, entpackt wurde, dann liegen die Assembler-Programme und die Projektdateien alle im Unterverzeichnis „C:\avr2313_assembler“. Die Datei mit dem Quelltext enthält das eigentliche Programm. Damit es von AVR Studio einwandfrei übersetzt werden kann, wird noch eine Projektdatei benötigt. In dieser werden einige für AVR Studio wichtige interne Daten gespeichert. Eine neue Projektdatei mit leerer Quelltextdatei kann nach dem Start von AVR Studio mit „Project -> New Project“ angelegt werden. Es erscheint ein Dialog, in dem einige Daten abgefragt werden. Um z.B. eine neue Projektdatei „test.aps“ mit der Quelltextdatei „test.asm“ im Unterverzeichnis „C:\av2313_assembler“ anzulegen, ist der Dialog folgendermaßen auszufüllen:

Abbildung 13 - Dialog „Neues Projekt“ bei AVR Studio 4

Mit [Finish] kann der Dialog bestätigt werden. AVR Studio öffnet dann die neu angelegte Projektdatei „test.aps“ und zeigt die leere Quelltextdatei „test.asm“ im integrierten Editor an. Für die Beispielprogramme sind bereits alle Projektdateien vorhanden.



Um nun ein Programm zu übersetzen, werden folgende Schritte ausgeführt:

• AVR Studio öffnen über „Start -> Programme -> Atmel AVR Tools -> AVR Studio 4“.

• Projekt öffnen über „Project -> Open Project“. In der Auswahlbox in das Verzeichnis „C:\av2313_assembler“ navi-gieren und dort z.B. die Projektdatei „led.aps“ auswählen. Mit [Öffnen] wird die Projektdatei geöffnet. AVR Studio zeigt nach dem Öffnen die Quelltextdatei „led.asm“ im integrierten Edi-tor an.

• Danach kann mit „Build -> Build“ der Übersetzungsvorgang für das Programm „led.asm“ ge-startet werden.

• In der unteren Hälfte des AVR Studio Fensters befindet sich ein Ausgabebereich. Hier wird auf dem Reiter „Build“ das Ergebnis der Programmübersetzung angezeigt. Eine erfolgreiche Pro-grammübersetzung endet mit der Zeile „Assembly complete, 0 errors. 0 warnings“.

Nach erfolgreicher Übersetzung erscheint im Verzeichnis „C:\avr2313_assembler“ eine neue Datei „led.hex“. Diese Datei enthält die ausführbaren Befehle für den Mikrocontroller und kann, wie in Kapi-tel 5 beschrieben, mit PonyProg zum Mikrocontroller übertragen werden. Nach jeder Programmänderung muss der Übersetzungsvorgang - wie oben beschrieben - wiederholt werden, damit eine neue Datei mit Mikrocontrollerbefehlen erstellt wird.



7.3 Aller Anfang ist schwer Für die Versuchsdurchführung sollten die Taster des LED/Taster-Moduls zum Benutzer zeigen. Die Seite mit den Tastern wird im Folgenden als "unten" bezeichnet. Zur Durchführung der Versuche sollten die vier benachbarten Jumper nach links gesetzt wer-den. Der allein stehende Jumper sollte zunächst auch nach links gesetzt werden. Nur bei den Ampelversuchen wird dieser nach rechts gesetzt (vgl. Kapitel 7.9). Um die Assembler-Programme besser lesen zu können, sollte man einige einfache Bestandteile kennen:

• Beginn eines Kommentars am Zeilenanfang oder an beliebiger Stelle in einer Zeile ;

• Einbindung einer Bibliothek

.include “2313def.inc“

• Die Angabe „.cseg“ (code segment) legt den Start des Programmsegments fest. Die Angabe

„.org“ (origin) legt die Adresse der darauf folgenden Befehle fest. Am Beginn eines Programms wird so die Interruptvektortabelle13 definiert, in der auf Programmadresse 0 auch der nach dem Reset auszuführende Sprungbefehl zum Label14 „Reset:“ eingetragen ist. ; Interrupt Vector Table .cseg .org 0x00 ; Reset-Address rjmp Reset .org 0x01 ; External Interrupt0 Vector Address reti .org 0x02 ; External Interrupt1 Vector Address reti .org 0x03 ; Input Capture1 Interrupt Vector Address reti .org 0x04 ; Output Compare1 Interrupt Vector Address reti .org 0x05 ; Overflow1 Interrupt Vector Address reti .org 0x06 ; Overflow0 Interrupt Vector Address reti .org 0x07 ; UART Receive Complete Interrupt Vector Address reti .org 0x08 ; UART Data Register Empty Interrupt Vector Address reti .org 0x09 ; UART Transmit Complete Interrupt Vector Address reti .org 0x0a ; Analog Comparator Interrupt Vector Address reti

• In der Interruptvektortabelle verwendete Befehle

rjmp Reset ; Sprung auf das Label “Reset:” reti ; Rücksprung nach Interrupt (return from interrupt)

13 Bei AVR Mikrocontrollern führt ein Reset zu einem Sprung auf die Programmadresse 0. Dort muss dann ein Sprungbe-fehl zum eigentlichen Programmanfang stehen. Durch diesen Sprungbefehl wird die ab der Progammadresse 1 stehende Tabelle (Interruptverktortabelle) mit den für die Interruptroutinen benötigten Sprung- oder Returnbefehlen übersprungen. Für jede Interruptart des Mikrocontrollers steht hier ein Sprungbefehl zur zugehörigen Interruptroutine oder der Befehl „reti“, wenn die Interruptart nicht verwendet wird. 14 Ein Label bezeichnet ein Sprungziel im Programm. Sprungziele enden mit einem Doppelpunkt und werden beim Sprung-befehl ohne Doppelpunkt angegeben.



7.4 Versuch 1: Einschalten der Leuchtdioden (led.asm) Das Programm "led.asm" zeigt die Grundstruktur eines Assembler-Programms und führt die elementa-ren Befehle zur Initialisierung des Stackpointers und der Ports aus. Die Ports werden dabei durch Be-schreiben der Datenrichtungsregister15 DDRB und DDRD mit dem hexadezimalen Wert FF auf Aus-gang geschaltet. Die Ausgänge werden durch Beschreiben der Portregister16 PORTB und PORTD mit dem hexadezimalen Wert 00 auf 0 (entspricht 0 Volt) gesetzt. Danach verbleibt das Programm in einer Endlosschleife. Durch die Angabe „.def“ wird dem Text "temp" der Text "r16" zugeordnet. Dadurch wird im weiteren Programm, immer wenn auf "temp" Bezug genommen wird, der an zentraler Stelle definierte Wert verwendet. Die Verwendung von Registern wird auf diese Weise lesbarer und kann zentral gepflegt werden. Im Programm "led.asm" wird das Register „r16“ unter der Bezeichnung „temp“ als Universal-register verwendet. .def temp = r16 ; Universalregister

Nach dem Programmstart springt der Mikrocontroller über den in der Interruptvektortabelle an der Re-set-Adresse stehenden Sprungbefehl auf das Label “Reset:”, das den eigentlichen Programmanfang bezeichnet. Als erstes wird dann der Stackpointer initialisiert. Der Mikrocontroller benötigt die Infor-mation, wo er seine Daten bei push/pop-Befehlen17, bei Interrupts und bei dem Aufruf von Unterrouti-nen ablegen kann. Danach folgt die Initialisierung der Ports und dann verbleibt das Programm in einer Endlosschleife. Reset: ldi temp,LOW(RAMEND) ; Stackpointer initialisieren out SPL,temp ldi temp,0xFF ; PORTB auf Ausgabe setzen out DDRB,temp ldi temp,0x00 ; Alle Ausgänge auf 0 setzen out PORTB,temp ldi temp,0xFF ; PORTD auf Ausgabe setzen out DDRD,temp ldi temp,0x00 ; Alle Ausgänge auf 0 setzen out PORTD,temp loop: ; Endlosschleife rjmp loop ; Sprung auf das Label “loop:”

Im Hauptteil des Progamms „led.asm“ verwendete Befehle ldi ; Lade ein Register mit einem Wert (load immediate) out ; Ausgabe auf ein I/O-Register (out = output) rjmp loop ; Sprung auf das Label “loop:” der Endlosschleife

15 Für jeden Anschluss wird im Datenrichtungsregister (DDR = data direction register) festgelegt, ob er als Eingang oder als Ausgang arbeitet. Wird das zum Anschluss gehörende Bit auf 1 gesetzt, so arbeitet der Anschluss als Ausgang. Sonst arbeitet er als Eingang. 16 Bei als Ausgang arbeitenden Anschlüssen entscheidet der Wert des zugehörigen Bits im Portregister, ob am Ausgang 0 Volt (Bit ist auf 0 gesetzt) oder 5 Volt (Bit ist auf 1 gesetzt) anliegen. Bei als Eingang arbeitenden Anschlüssen entscheidet der Wert des zugehörigen Bits im Portregister, ob ein interner Pull-Up-Widerstand zugeschaltet (Bit ist auf 1 gesetzt) wird oder nicht (Bit ist auf 0 gesetzt). Ein zugeschalteter Pull-Up-Widerstand sorgt dafür, dass ein nicht angeschlossener Eingang auf dem definierten Pegel 5 Volt gehalten wird. 17 Mit dem Befehl „push“ wird ein Wert auf dem Stack abgelegt. Mit dem Befehl „pop“ wird ein Wert vom Stack gelesen.



Für eine genaue Erklärung der Befehle sollten die bei www.talentraspel.de in der Rubrik „Experimen-tiersystem -> Dokumentation und Downloads“ abrufbare Beschreibung des Befehlssatzes und die zu-gehörigen Datenblätter herangezogen werden. Die LEDs sind gemeinsam an ihren Anoden mit + 5 Volt verbunden. Das Setzen aller Ausgänge von Port B und von Port D auf den Wert 0 führt dazu, dass die 15 LEDs an ihren Kathoden auf 0 Volt ge-legt werden, sodass sie leuchten. Die Hardwareanordnung wurde so gewählt, da der Mikrocontroller seine Ausgänge mit 20 mA gegen Masse schalten kann, jedoch nur mit 3 mA gegen + 5 Volt. Zahlen können entweder in dezimaler18, hexadezimaler19 oder binärer20 Notation angegeben werden. Zur Umwandlung zwischen den einzelnen Darstellungen empfiehlt sich die Verwendung des Win-dows-Taschenrechners. Im diesem Programm werden alle Ausgänge auf 0 gesetzt. Also: PORT B = binär 00000000 = dezimal 0 = hexadezimal 00 PORT D = binär 00000000 = dezimal 0 = hexadezimal 00 Variation: Aus den Schaltplänen des Basis-Moduls und des LED/Taster-Moduls geht hervor, dass LED1 mit Aus-gang 0 von Port B verbunden ist. Um nun LED1 einzeln leuchten zu lassen, muss der Ausgang 0 auf 0 und alle anderen Ausgänge auf 1 gesetzt werden. Also: PORT B = binär 11111110 = dezimal 254 = hexadezimal FE PORT D = binär 11111111 = dezimal 255 = hexadezimal FF

18 zur Basis 10 mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8 und 9 19 zur Basis 16 mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E und F (Hexadezimalzahlen beginnen in Assembler mit „0x“) 20 zur Basis 2 mit den Ziffern 0 und 1 (Binärzahlen beginnen in Assembler mit „0b“)



7.5 Versuch 2: Blinkende Leuchtdioden (led_blinken.asm) Das Programm "led_blinken.asm" führt die gleiche Initialisierung aus, die bereits im Programm "led.asm" erläutert wurde. In der Endlosschleife werden die Leuchtdioden aber regelmäßig ein- und ausgeschaltet. Die Blinkfrequenz wird über eine Warteschleife gesteuert, die als Funktion implemen-tiert ist. In der Registerdefinition werden drei Register für die Durchführung einer Programmschleife definiert. .def i = r17 ; Schleifenregister .def j = r18 .def k = r19

Durch das Label „Wait:“ wird der Einsprungpunkt der Warteschleife definiert. Der Befehl „ret“ (re-turn) am Ende der Warteschleife verlässt die Unterroutine wieder. In den Registern „i“ (r17) und „j“ (r18) werden der Warteschleife beim Aufruf der obere und der untere Teil eines 16-Bit-Wertes überge-ben. Dadurch wird die Anzahl der äußeren Schleifendurchläufe und somit die Wartezeit bestimmt. Die innere Programmschleife mit den beiden Befehlen „nop“ (no operation) definiert über eine konstante Anzahl Schleifendurchläufe eine bestimmte Wartezeit. In der inneren Programmschleife über das Label „loop_k:“ wird zuerst der vorher auf dezimal 200 vor-eingestellte Wert von Register „k“ (r19) bei jedem Programmdurchlauf mit dem Befehl „dec k“ (dec-rement) um 1 verringert. Danach wird der Wert von „k“ mit dem Befehl „cpi k,0xFF“ (compare imme-diate) mit dem hexadezimalen Wert FF (dezimal 256) verglichen. Ist er nicht gleich (brne = branch not equal), so wird wieder zum Label „loop_k:“ gesprungen. Ist er gleich FF, dann wird die innere Schleife verlassen. In den beiden äußeren Schleifen über die Register „i“ und „j“ werden die Register in ähnlicher Weise verringert und verglichen. Das Register „i“ enthält den oberen, das Register „j“ den unteren Teil eines 16-Bit-Wertes, der die Gesamtzahl der Durchläufe der inneren Schleife bestimmt. Wait: ; Warteschleife ldi k,200 loop_k: nop nop dec k cpi k,0xFF brne loop_k dec j cpi j,0xFF brne Wait dec i cpi i,0xFF brne Wait ret

Durch die drei ineinander verschachtelten Schleifen wird eine Wartefunktion implementiert, deren Dauer vom übergebenen Wert abhängt.



Variation: Verringert man in der inneren Schleife den Wert 200 z.B. auf den Wert 10, so erhöht sich die Blinkfre-quenz deutlich bei der Programmausführung, da die Schleifendurchlaufzeit nun kürzer ist. Durch An-passung dieses Wertes lässt sich also das Zeitverhalten der Schleife justieren. Im Hauptprogramm werden nach der Initialisierung ab dem Label „loop:“ abwechselnd die Ausgänge auf den hexadezimalen Wert 00 und den hexadezimalen Wert FF gesetzt. Dazwischen wird jeweils die Warteschleife aufgerufen. Dabei werden in den Registern „i“ und „j“ der obere (HIGH) und untere (LOW) Teil der 16-Bit-Zahl21 4000 übergeben. Die Warteschleife führt somit 4000 Durchläufe durch. Am Ende des Programms wird wieder zum Label „loop:“ gesprungen, dadurch wiederholt sich der Ab-lauf. loop: ; Endlosschleife ldi temp,0x00 ; Alle Ausgänge auf 0 setzen (LEDs an) out PORTB,temp out PORTD,temp ldi i,HIGH(4000) ; Warten ldi j,LOW(4000) rcall Wait ldi temp,0xFF ; Alle Ausgänge auf 1 setzen (LEDs aus) out PORTB,temp out PORTD,temp ldi i,HIGH(4000) ; Warten ldi j,LOW(4000) rcall Wait rjmp loop

Variation: Durch gleiches Verändern der beim Ein- und Ausschalten der LEDs verwendeten Werte für die 16-Bit-Zahl kann die Blinkfrequenz symmetrisch blinkend verändert werden. Durch ungleiches Verändern der Werte kann die Symmetrie der Blinkfrequenz verändert werden. Die Angaben bei aufeinanderfolgendem „HIGH“ und „LOW“ beziehen sich jeweils auf denselben Wert, dieser muss also an beiden Stellen identisch sein.

21 dezimal 4000 = hexadezimal 0FA0. Durch HIGH(4000) wird 0F, durch LOW(4000) A0 zurückgegeben. Damit kann die 16-bit-Zahl auf zwei Register aufgeteilt werden.



7.6 Versuch 3: Leuchtdioden als Lauflicht (lauflicht.asm) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt ein Lauflicht auf den Leuchtdioden aus. In der Registerdefinition wird ein Register für das Lauflicht definiert. .def lauflicht = r20 ; Lauflicht

Das Register „lauflicht“ wird zunächst mit der Binärzahl "00000001" (hexadezimal 01) initialisiert. Durch den Befehl „lsl“ (logical shift left) wird das Bitmuster um ein Bit nach links geschoben ("00000010"). Wenn nach dem achten Mal die 1 nach links herausgeschoben wurde, ist danach das Register „lauflicht“ wieder gleich Null. Dann wird das Register „lauflicht“ erneut auf hexadezimal 01 gesetzt, und das Lauflicht beginnt von neuem. ldi lauflicht,0x01 ; Lauflicht auf Anfang setzen loop: ; Endlosschleife mov temp, lauflicht ; Untere 8 Bit auf PORT B ausgegeben (invertiert) com temp out PORTB,temp lsl lauflicht ; Lauflicht um 1 Bit nach links weiterschieben cpi lauflicht,0x00 ; Wenn Lauflicht durchgelaufen ist, dann wieder am Anfang beginnen brne loop_wait ldi lauflicht,0x01 ; Lauflicht auf Anfang setzen loop_wait: ldi i,HIGH(2000) ; Warten ldi j,LOW(2000) rcall Wait rjmp loop

Variation: Wenn das Register „lauflicht“ zunächst mit der Binärzahl "10000000" (hexadezimal 80) initialisiert wird und zum Verschieben des Wertes statt des Befehls „lsl“ nun der Befehl „lsr“ (logical shift right) verwendet wird, dann läuft das Lauflicht anders herum.



7.7 Versuch 4: Leuchtdioden als Zähler (zaehler.asm) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und zählt einen 16-Bit-Zähler bis dezimal 32767 (binär "0111111111111111"). Die unteren 8 Bit werden auf Port B, die oberen 8 Bit auf Port D ausgegeben. In der Registerdefinition werden zwei Register definiert, die gemeinsam als 16-Bit-Zähler verwendet werden. .def cnt_low = r20 ; Zähler .def cnt_high = r21

Für das Heraufzählen des 16-Bit-Zählers wird zunächst das Register „cnt_low“ erhöht. Sobald dieses Register überläuft, wird auch das Register „cnt_high“ erhöht. Durch Vergleich von Register „cnt_low“ mit dem hexadezimalen Wert 00 und von Register „cnt_high“ mit dem hexadezimalen Wert 80 wird geprüft, ob der 16-Bit-Zähler auf dem hexadezimalen Wert 8000 (dezimal 32768) angekommen ist. Ist dies der Fall, so wird der Zähler wieder auf 0 zurückgesetzt. ldi cnt_low,0x00 ; Zähler = 0 ldi cnt_high,0x00 loop: ; Endlosschleife mov temp,cnt_low ; Untere 8 Bit auf PORT B ausgegeben (invertiert) com temp out PORTB,temp mov temp,cnt_high ; Obere 8 Bit auf PORT D ausgegeben (invertiert) com temp out PORTD,temp inc cnt_low ; Zähler = Zähler + 1 brne loop_check inc cnt_high loop_check: ; Zähler gleich 32768 ? cpi cnt_low,0x00 brne loop_wait cpi cnt_high,0x80 brne loop_wait ldi cnt_low,0x00 ; Zähler = 0 ldi cnt_high,0x00 loop_wait: ldi i,HIGH(1000) ; Warten ldi j,LOW(1000) rcall Wait rjmp loop



7.8 Versuch 5: Würfelaugen (wuerfel.asm) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt nacheinander Werte auf die Ausgänge, sodass die Leuchtdioden in Würfelaugenmustern aufleuchten. Die zu den Mustern gehörenden Werte ergeben sich dabei gemäß folgender Tabelle22: Muster Bit 7

(unbe-nutzt)




Bit 3 (LED mitte)




Hexadezimal-zahl

1 0 0 0 0 1 0 0 0 08 2 0 1 0 0 0 0 0 1 41 3 0 0 1 0 1 0 1 0 2A 4 0 1 1 0 0 0 1 1 63 5 0 1 1 0 1 0 1 1 6B 6 0 1 1 1 0 1 1 1 77

7.9 Versuch 6: Ampel (ampel.asm) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt nacheinander Werte auf die Ausgänge, sodass Ampelphasen auf den Leuchtdioden ausgegeben werden. Wichtig: Damit die Leuchtdioden auch in den Farben Gelb und Grün aufleuchten, muss der einzeln stehende Jumper auf dem LED/Taster-Modul nach rechts gesetzt werden. Die zu den Mustern gehörenden Werte ergeben sich dabei gemäß folgender Tabelle: Phase (linke Ampel, rechte Ampel)

Bit 7 (unbe-nutzt)




Bit 3 (LED mitte)




Hexadezimal-zahl





7.10 Versuch 7: Der erste Interrupt (led_blinken_interrupt.asm) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und setzt diese auf 0. Die Ausgän-ge werden in einer durch Timer 0 ausgelösten Interruptroutine23 abwechselnd auf 0 oder 1 gesetzt, in-dem sie jeweils invertiert werden. Die Taktfrequenz wird zunächst durch einen einstellbaren Vorteilungsfaktor geteilt, bevor sie an den Timer 0 gelangt. Trotz maximaler Vorteilung blinken die LEDs immer noch recht schnell, da die von der Taktfrequenz abhängige Interruptroutine mit 10.000.000 Hz geteilt durch (1024*256) = ca. 38 Hz aufgerufen wird. Da für eine vollständige Blinkphase zwei Aufrufe benötigt werden, ergibt sich eine Blinkfrequenz von ca. 19 Hz. Die Vorteilung von 1024 wird im Register TCCR0 eingestellt. Die weitere Teilung von 256 ergibt sich aus dem in Timer 0 geladenen Startwert 0, der 256 mal erhöht wird, bis er erneut auf 0 springt und da-mit den Interrupt wieder auslöst. Die Beschreibung des Timers und die Werte für die Vorteilung kön-nen aus dem Datenblatt zum AT90S2313 entnommen werden. Wenn durch Überlauf von Timer 0 ein Interrupt ausgelöst wird, dann wird auf die Programmadresse 6 gesprungen. Durch den dort in der Interruptvektortabelle stehenden Befehl „rjmp OVF0_Call“ wird dann die Interruptroutine aufgerufen. Durch den am Ende der Interruptroutine stehenden Befehl „reti“ (return from interrupt) wird wieder an die Stelle zurückgesprungen, an der das Hauptprogramm durch den Interrupt unterbrochen wurde. .org 0x06 ; Overflow0 Interrupt Vector Address rjmp OVF0_Call

In der Registerdefinition wird ein Register definiert, in dem die Interruptroutine das Statusregister zwi-schenspeichert. .def store = r17 ; Puffer für SREG

Interruptroutine: OVF0_Call: ; Interruptroutine cli ; Interrupts deaktivieren in store,SREG ; Statusregister retten ldi temp,0x00 ; Timer-0 Startwert setzen out TCNT0,temp in temp,PORTB ; Ausgänge invertieren com temp out PORTB,temp in temp,PORTD com temp out PORTD,temp out SREG,store ; Statusregister wiederherstellen sei ; Interrupts aktivieren reti




Im Hauptprogramm wird der Timer-0 Interrupt initialisiert, dann werden die Interrupts aktiviert und danach bleibt das Programm in einer Endlosschleife. Alle weiteren Aktivitäten geschehen in der Inter-ruptroutine. ldi temp,0x05 ; Timer-0 Vorteiler auf 1024 out TCCR0,temp ldi temp,0x00 ; Timer-0 Startwert setzen out TCNT0,temp ldi temp,0x02 ; Timer-0 Interrupt einschalten out TIMSK,temp sei ; Interrupts aktivieren loop: ; Endlosschleife rjmp loop

Variation: Durch Verändern des Startwertes für Timer 0 an beiden Stellen im Programm kann die Blinkfrequenz gesteigert werden. Durch Verändern des Vorteilers in TCCR0 ist eine weitere Steigerung der Blinkfre-quenz möglich. Allerdings wird das Blinken dann ohne Messgerät nicht mehr wahrnehmbar sein. Verändert man den Vorteilerwert von 1024 auf 256 („ldi temp,0x04“), so erhöht sich die Blinkfrequenz von ca. 19 Hz um den Faktor 4 auf ca. 77 Hz. Das menschliche Auge kann diese Blinkfrequenz nicht mehr wahrnehmen. Bewegt man bei dieser Blinkfrequenz jedoch die Platine mit den LEDs schnell hin und her, so sieht man die durch die Bewegung verursachten Leuchtspuren der getakteten LEDs mit Unterbrechungen. Die Leuchtspur der ungetakteten grünen LED auf der Basisplatine zeigt keine Un-terbrechungen.

7.11 Versuch 8: Interrupt mit Zähler (led_blinken_interrupt_zaehler.asm)

Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und setzt diese auf 0. In der durch Timer 0 ausgelösten Interruptroutine wird ein 16-Bit-Zähler heruntergezählt. Im Hauptprogramm wird nach dem Umschalten der Ausgänge gewartet, bis der Zähler nach dem Setzen auf einen Startwert wie-der bei Null ankommt. In der Registerdefinition wird ein Register definiert, in dem die Interruptroutine das Statusregister zwi-schenspeichert. Zusätzlich werden zwei Register definiert, die gemeinsam als 16-Bit-Zähler verwendet werden. .def store = r17 ; Puffer für SREG .def cnt_high = r18 ; Zähler .def cnt_low = r19



Interruptroutine: OVF0_Call: ; Interruptroutine cli ; Interrupts deaktivieren in store,SREG ; Statusregister retten ldi temp,0x80 ; Timer-0 Startwert setzen out TCNT0,temp mov temp,cnt_high ; Zähler gleich 0 ? or temp,cnt_low breq OVF0_Exit dec cnt_low ; Zähler = Zähler - 1 cpi cnt_low,0xFF brne OVF0_Exit dec cnt_high OVF0_Exit: out SREG,store ; Statusregister wiederherstellen sei ; Interrupts aktivieren reti

Die Interruptroutine wird mit 10.000.000 Hz geteilt durch (8*128) = ca. 9,8 kHz aufgerufen. Der Wert 8 entspricht der eingestellten Vorteilung. Der Wert 128 ergibt sich aus dem in Timer 0 geladenen Start-wert (hexadezimal 80 = dezimal 128), der noch 128 mal erhöht wird, bis er erneut auf 0 springt und damit den Interrupt wieder auslöst. Im Hauptprogramm wird der Timer-0-Interrupt initialisiert, dann werden die Interrupts aktiviert und danach bleibt das Programm in einer Endlosschleife. In der Endlosschleife werden jeweils die Leucht-dioden ein- oder ausgeschaltet. Danach werden die beiden Register des 16-Bit-Zählers auf den oberen (HIGH) und unteren (LOW) Teil der 16-Bit-Zahl 4000 gesetzt und gewartet, bis dieser in der mit 9,8 kHz aufgerufenen Interruptroutine wieder auf 0 heruntergezählt wurde. Daraus ergibt sich eine Blink-frequenz von ca. 1 Hz (pro Blinkphase 2 mal warten). ldi temp,0x02 ; Timer-0 Vorteiler auf 8 out TCCR0,temp ldi temp,0x80 ; Timer-0 Startwert setzen out TCNT0,temp ldi temp,0x02 ; Timer-0 Interrupt einschalten out TIMSK,temp sei ; Interrupts aktivieren



loop: ; Endlosschleife ldi temp,0x00 ; Alle Ausgänge auf 0 setzen (LEDs an) out PORTB,temp out PORTD,temp ldi cnt_high,HIGH(4000) ; Zähler setzen ldi cnt_low,LOW(4000) wait_1: ; Warten mov temp,cnt_high ; Zähler gleich 0 ? or temp,cnt_low brne wait_1 ldi temp,0xFF ; Alle Ausgänge auf 1 setzen (LEDs aus) out PORTB,temp out PORTD,temp ldi cnt_high,HIGH(4000) ; Zähler setzen ldi cnt_low,LOW(4000) wait_2: ; Warten mov temp,cnt_high ; Zähler gleich 0 ? or temp,cnt_low brne wait_2 rjmp loop

Variation: Durch gleiches Verändern der beim Ein- und Ausschalten der LEDs verwendeten Werte für die 16-Bit-Zahl kann die Blinkfrequenz symmetrisch blinkend verändert werden. Durch ungleiches Verändern der Werte kann die Symmetrie der Blinkfrequenz verändert werden. Die Angaben bei aufeinanderfolgendem „HIGH“ und „LOW“ beziehen sich jeweils auf denselben Wert, dieser muss also an beiden Stellen identisch sein.

7.12 Versuch 9: Alles zusammen (lauflicht_ampel_wuerfel.asm) Das Programm vereint die Funktionen der Programme "lauflicht.asm", "ampel.asm" und "wuer-fel.asm". Nach der Initialisierung der Ports wird auf Port B ein Lauflicht ausgegeben. Dieses wird in der Interruptroutine gesteuert und läuft somit im Hintergrund. Die Geschwindigkeit des Lauflichts wird durch den in der Interruptroutine heruntergezählten 16-Bit-Zähler bestimmt. Im Hauptprogramm wer-den nacheinander Ampelphasen und Würfelaugenmuster ausgegeben, dabei wird die Zeitsteuerung des Ablaufs über eine Warteschleife erreicht. Die Würfelaugenmuster werden durch eine Schleife mehrfach ausgegeben. Der Quelltext des Programms ist kommentiert, Details können dort eingesehen werden.



7.13 Versuch 10: Taster abfragen (taster.asm) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Die Aus-gänge an Port B werden auf 1 gesetzt und die Pull-Up-Widerstände werden zu den Eingängen an Port D dazugeschaltet. Der Zustand der drei Taster wird abgefragt und jeweils mit einer LED angezeigt. ldi temp,0xFF ; PORTB auf Ausgabe setzen out DDRB,temp ldi temp,0xFF ; Alle Ausgänge auf 1 setzen out PORTB,temp ldi temp,0x00 ; Port D auf Eingang setzen out DDRD,temp ldi temp,0xFF ; Mit eingeschalteten Pull-Up-Widerständen out PORTD,temp loop: ; Endlosschleife sbic PIND,6 ; Taster 1 abfragen (gedrückt = Bit geht auf 0) rjmp t1a cbi PORTB,7 ; Zugehörige LED an rjmp t2 t1a: sbi PORTB,7 ; Zugehörige LED aus t2: sbic PIND,3 ; Taster 2 abfragen (gedrückt = Bit geht auf 0) rjmp t2a cbi PORTB,0 ; Zugehörige LED an rjmp t3 t2a: sbi PORTB,0 ; Zugehörige LED aus t3: sbic PIND,5 ; Taster 3 abfragen (gedrückt = Bit geht auf 0) rjmp t3a cbi PORTB,1 ; Zugehörige LED an rjmp loop t3a: sbi PORTB,1 ; Zugehörige LED aus rjmp loop

In der Endlosschleife wird geprüft, ob der Eingang durch den jeweiligen Taster auf 0 geschaltet wurde. In diesem Fall wird durch den Befehl „sbic“ (Skip if Bit in I/O Register is Cleared) der direkt folgende Sprungbefehl ausgelassen24. Dadurch wird abhängig vom Zustand des Tasters der Befehl „cbi“ (Clear Bit in I/O Register) oder der Befehl „sbi“ (Set Bit in I/O Register) erreicht und somit die zugehörige Leuchtdiode ein- oder ausgeschaltet. Beim Drücken eines Tasters leuchten zwei LEDs. Die obere LED leuchtet bedingt durch die Hardware, die untere LED leuchtet gesteuert durch die Software. Die Zuordnung von Tastern, Eingängen und Ausgabeleuchtdioden ergibt sich aus folgender Tabelle: Taster Eingang an Port D Ausgang an Port B


24 to skip = auslassen



7.14 Versuch 11: Würfel mit Taster (wuerfel_taster.asm) Das Programm initialisiert die Ports und schaltet diese auf Ausgang. Der Ausgang, an dem Taster 2 angeschlossen ist, wird durch kurzes Umschalten auf Eingang auch als Eingang abgefragt. Wenn der Taster gedrückt wird, läuft der Würfel mit Maximalgeschwindigkeit und rollt nach dem Los-lassen des Tasters langsam aus. Der zufällige Zeitpunkt des Loslassens bestimmt indirekt den Würfel-wert, auf die Verwendung einer Zufallsfunktion wurde verzichtet. Abfrage des Tasters: Taster: in status,PORTD ; Alten Status merken andi status,0x08 cbi DDRD,3 ; Bit auf Eingang schalten sbi PORTD,3 sbic PIND,3 ; Taster abfragen rjmp t1 ldi return,0x01 rjmp t2 t1: ldi return,0x00 t2: in temp,PORTD ; Alten Status wieder herstellen andi temp,0xF7 or temp,status out PORTD,temp sbi DDRD,3 ; Bit wieder auf Ausgang schalten ret

Im Hauptprogramm wird regelmäßig der Taster abgefragt. Das kurze Umschalten des Ausgangs auf Eingang ist allerdings nicht wahrnehmbar. ldi phase,0x01 ldi z1,HIGH(5000) ldi z2,LOW(5000) loop: ; Endlosschleife rcall taster ; Auf Taster warten cpi return,1 brne label1 rcall Schritt ; Würfel schnell weiterschalten ldi z1,HIGH(1000) ldi z2,LOW(1000) ldi temp,0x00 out PORTB,temp rjmp loop label1: cpi z1,HIGH(5000) ; Ausrollen brlo label2 brne loop cpi z2,LOW(5000) brlo label2 rjmp loop label2: rcall Schritt ; Würfel weiterschalten mov i,z1 ; Warten mov j,z2 rcall Wait



ldi temp,250 ; Zeitbasis = Zeitbasis + 250 add z2,temp ldi temp,0 adc z1,temp cpi z1,HIGH(5000) brlo loop brne label3 cpi z2,LOW(5000) brlo loop label3: ldi temp,0xFF out PORTB,temp rjmp loop

Solange der Taster als gedrückt erkannt wird, werden die Würfelmuster schnell weitergeschaltet. Es sieht dann so aus, als ob alle Augen gleichzeitig leuchten. Nach dem Loslassen des Tasters beginnt der Würfel auszurollen. Dabei wird die Zeit für die Warteschleife stufenweise erhöht, damit der Eindruck eines immer langsamer werdenden Ausrollvorgangs entsteht. Ist der Würfel langsam genug, so bleibt er stehen. Während des gesamten Würfelvorgangs werden die Leuchtdioden an Port B eingeschaltet. Sobald der Würfel stehen bleibt, werden diese wieder ausgeschaltet. Variation: Durch Verändern des Wertes 5000 an allen Stellen im Programm kann die Dauer des Ausrollvorgangs beeinflusst werden. Durch Verändern des Wertes 250 in der Zeile „ldi temp,250“ kann die Geschwin-digkeit des Ausrollvorgangs beeinflusst werden. Die Angaben bei aufeinanderfolgendem „HIGH“ und „LOW“ beziehen sich jeweils auf denselben Wert, dieser muss also an beiden Stellen identisch sein.



7.15 Versuch 12: Ampel mit Taster (ampel_taster.asm) Das Programm initialisiert die Ports und schaltet diese auf Ausgang. Der Ausgang, an dem Taster 2 angeschlossen ist, wird durch kurzes Umschalten auf Eingang auch als Eingang abgefragt. Wenn der Taster gedrückt wird, beginnt nach kurzem Warten eine Ampelphase. Nach Ablauf der Am-pelphase wartet das Programm auf den nächsten Tasterdruck. Zur Abfrage des Tasters wird dieselbe Funktion "taster" benutzt, die auch schon im Programm "wuer-fel_taster.asm" zum Einsatz kam. Der Ablauf der Ampelphasen wird wie im Programm "ampel.asm" durch eine Warteschleife gesteuert.

7.16 Versuch 13: Lauflicht mit Taster (lauflicht_taster.asm) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Wenn der linke Taster gedrückt wird, bewegt sich das Lauflicht einen Schritt im Uhrzeigersinn. Wenn der rechte Taster gedrückt wird, bewegt sich das Lauflicht einen Schritt gegen den Uhrzeigersinn. Wenn der mitt-lere Taster gedrückt wird, dann stellt sich das Lauflicht auf die Ausgangsposition zurück. Um die Taster zu entprellen, wird jeweils nach Drücken und Loslassen kurz gewartet. Dadurch werden die beim Prellen entstehenden zusätzlichen Impulse nicht ausgewertet. Ohne Entprellen würde das Lauflicht "springen". ldi lauflicht,0x01 ; Lauflicht = 1 loop: ; Endlosschleife in temp,PIND ; Warte auf beliebigen Taster andi temp,0x68 cpi temp,0x68 breq output ldi i,0x00 ; Entprellen ldi j,0x0A rcall Wait in temp,PIND ; Wenn Taster 1 gedrueckt wurde andi temp,0x68 cpi temp,0x28 brne label1 lsr lauflicht ; Lauflicht um 1 Bit nach rechts weiterschieben cpi lauflicht,0x00 ; Wenn Lauflicht durchgelaufen ist, dann wieder am Anfang beginnen brne label1 ldi lauflicht,0x80 ; Lauflicht = 128



label1: in temp,PIND ; Wenn Taster 3 gedrueckt wurde andi temp,0x68 cpi temp,0x48 brne label2 lsl lauflicht ; Lauflicht um 1 Bit nach links weiterschieben cpi lauflicht,0x00 ; Wenn Lauflicht durchgelaufen ist, dann wieder am Anfang beginnen brne label2 ldi lauflicht,0x01 ; Lauflicht = 1 label2: in temp,PIND ; Wenn Taster 2 gedrueckt wurde andi temp,0x68 cpi temp,0x60 brne label3 ldi lauflicht,0x01 ; Lauflicht zurücksetzen label3: in temp,PIND ; Warte bis kein Taster gedrueckt ist andi temp,0x68 cpi temp,0x68 brne label3 ldi i,0x00 ; Entprellen ldi j,0x0A rcall Wait output: mov temp,lauflicht ; Untere 8 Bit auf PORT B ausgegeben (invertiert) com temp out PORTB,temp rjmp loop




7.17 Versuch 14: Zähler mit Taster (zaehler_taster.asm) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Wenn der linke Taster gedrückt wird, wird der Zähler um 1 verringert. Wenn der rechte Taster gedrückt wird, wird der Zähler um 1 erhöht. Wenn der mittlere Taster gedrückt wird, dann stellt sich der Zähler auf 0 zurück. Um die Taster zu entprellen, wird jeweils nach Drücken und Loslassen kurz gewartet. Dadurch werden die beim Prellen entstehenden zusätzlichen Impulse nicht ausgewertet. Ohne Entprellen würde der Zäh-ler "springen". ldi cnt_low,0x00 ; Zähler = 0 ldi cnt_high,0x00 loop: ; Endlosschleife in temp,PIND ; Warte auf beliebigen Taster andi temp,0x68 cpi temp,0x68 breq output ldi i,0x00 ; Entprellen ldi j,0x0A rcall Wait in temp,PIND ; Wenn Taster 1 gedrueckt wurde andi temp,0x68 cpi temp,0x28 brne label1 dec cnt_low ; Zähler = Zähler - 1 cpi cnt_low,0xFF brne label1_check dec cnt_high label1_check: ; Zähler gleich 65535 ? cpi cnt_low,0xFF brne label1 cpi cnt_high,0xFF brne label1 ldi cnt_low,0xFF ; Zähler = 32767 ldi cnt_high,0x7F label1: in temp,PIND ; Wenn Taster 3 gedrueckt wurde andi temp,0x68 cpi temp,0x48 brne label2 inc cnt_low ; Zähler = Zähler + 1 brne label2_check inc cnt_high label2_check: ; Zähler gleich 32768 ? cpi cnt_low,0x00 brne label2 cpi cnt_high,0x80 brne label2 ldi cnt_low,0x00 ; Zähler = 0 ldi cnt_high,0x00



label2: in temp,PIND ; Wenn Taster 2 gedrueckt wurde andi temp,0x68 cpi temp,0x60 brne label3 ldi cnt_low,0x00 ; Zähler zurücksetzen ldi cnt_high,0x00 label3: in temp,PIND ; Warte bis kein Taster gedrueckt ist andi temp,0x68 cpi temp,0x68 brne label3 ldi i,0x00 ; Entprellen ldi j,0x0A rcall Wait output: mov temp,cnt_low ; Untere 8 Bit auf PORT B ausgegeben (invertiert) com temp out PORTB,temp mov temp,cnt_high ; Obere 8 Bit auf PORT D ausgegeben (invertiert) com temp out PORTD,temp rjmp loop




8 Experimente in der Programmiersprache Basic Je nach Vorwissen des Benutzers des Experimentiersystems kann dieser seinen Einstieg frei wählen, also z.B. mit einer Roboter-Programmierung beginnen (erfordert zusätzliche Hardware) oder zunächst den Einstieg mit einfachen Experimenten finden. Die hier beschriebene Programmierung erfolgt in der Programmiersprache Basic. Die dazu benötigte Entwicklungsumgebung ist die kostenlos erhältliche Demoversion des BASCOM-AVR Basic Compi-lers von MCS Elec-tronics (www.mcselec.com). Statt BASCOM-AVR können natürlich auch andere (kommerzielle) Programme verwendet werden. Die Übertragung der Programmdateien in den Mikrocontroller kann mit der in BASCOM-AVR inte-grierten Programmiersoftware erfolgen. Es kann auch das in Kapitel 5 beschriebene PonyProg verwen-det werden, die Verwendung der integrierten Programmiersoftware ist allerdings komfortabler. Zum Einstieg in die Programmiersprache Basic sollten die allgemeinen Tutorials (vgl. Kapitel 8.1) die-nen, die auch die Bedienung der Entwicklungsumgebung BASCOM-AVR von der Programmeingabe bis hin zur Kompilierung der Programme beschreiben. Parallel dazu können dann die im Folgenden angegebenen Experimente direkt mit dem Experimentiersystem durchgeführt werden. Die dazugehö-renden Programme können mit BASCOM-AVR kompiliert werden.

8.1 Werkzeuge Zur Übersetzung der Basic-Programme wird das Programm BASCOM-AVR benötigt. Bei der Installa-tion von BASCOM-AVR können die von der Installationsroutine vorgeschlagenen Vorgaben unverän-dert übernommen werden. Das Programm kann als Demoversion bei www.talentraspel.de in der Rubrik „Experimentiersystem -> Dokumentation und Downloads“ oder auch beim Hersteller MCS Electronics (www.mcselec.com) heruntergeladen werden. Die Demoversion ist auf eine Programmgröße von 2048 Byte beschränkt, der AT90S2313 kann damit vollständig programmiert werden. In der Rubrik „Experimentiersystem -> Dokumentation und Downloads“ gibt es auch Hinweise zur Installation von BASCOM-AVR und einige Dokumente zum Thema „AVR-Mikrocontroller und BASCOM“. Weitere Details zum Mikrocontroller AT90S2313 können aus der Beschreibung des Be-fehlssatzes und den zugehörigen Datenblättern entnommen werden. Die Quelltexte für die Basic-Programme können als komprimierte Dateien bei www.talentraspel.de in der Rubrik „Experimentiersystem -> Dokumentation und Downloads“ heruntergeladen werden. Die Datei „avr2313_bascom_v100.zip“ sollte direkt auf die Hauptverzeichnisebene des Laufwerks C „C:\“ entpackt werden. Dadurch liegen die Daten dann im Unterverzeichnis „C:\avr2313_bascom“. Zum Editieren von Basic-Programmen wird der in BASCOM-AVR integrierte Editor verwendet. Er steht nach dem Start von BASCOM-AVR zur Verfügung, sobald ein Basic-Programm geöffnet oder erstellt wurde.



8.2 Programmübersetzung Um mit BASCOM-AVR ein Basic-Programm zu kompilieren, benötigt man den Quelltext in einer Da-tei mit der Dateinamenerweiterung „.bas“. Wenn die Datei mit den Quelltexten, wie in Kapitel 8.1 be-schrieben, entpackt wurde, dann liegen die Basic-Programme alle im Unterverzeichnis „C:\avr2313_bascom“. Um nun ein Programm zu übersetzen, werden folgende Schritte ausgeführt:

• BASCOM-AVR öffnen über „Start -> Programme -> BASCOM-AVR -> BASCOM-AVR“.

• Basic-Programm öffnen über „File -> Open“. In der Auswahlbox in das Verzeichnis „C:\av2313_bascom“ navigieren und dort z.B. das Basic-Programm „led.bas“ auswählen. Mit [Öffnen] wird die Programmdatei ge-öffnet. BASCOM-AVR zeigt nach dem Öffnen die Quelltextdatei „led.bas“ im integrierten Edi-tor an.

• Danach kann mit „Program -> Compile“ der Übersetzungsvorgang für das Programm „led.bas“ gestartet werden.

• In der Statuszeile des BASCOM-AVR Fensters erscheint bei erfolgreicher Übersetzung der Text „No errors found“.

Nach erfolgreicher Übersetzung erscheint im Verzeichnis „C:\avr2313_bascom“ eine neue Datei „led.hex“. Diese Datei enthält die ausführbaren Befehle für den Mikrocontroller und kann, wie in Kapi-tel 5 beschrieben, mit PonyProg zum Mikrocontroller übertragen werden. In BASCOM-AVR ist eine Programmiersoftware integriert, die mit dem ISP-Modul zusammenarbeitet. Das ISP-Modul wird wie in Kapitel 5 mit einem Kabel an den Druckerport des Computers angeschlos-sen (LPT1). Die Programmiersoftware von BASCOM-AVR muss vor der ersten Verwendung passend eingestellt werden. Dazu wird der Konfigurationsdialog über „Options -> Programmer“ aufgerufen und der Reiter „Programmer“ folgendermaßen ausgefüllt:

Abbildung 14 - Dialog „Optionen Programmiergerät“ bei BASCOM-AVR



Mit [Ok] kann der Dialog bestätigt werden. Um das übersetzte Programm damit in den Mikrocontroller zu übertragen, sind folgende Schritte aus-zuführen:

• Die integrierte Programmiersoftware mit „Program -> Send to chip“ aufrufen. • Den Programmiervorgang mit „Chip -> Autoprogram“ starten. • In der Statuszeile des BASCOM-AVR Fensters erscheint bei erfolgreicher Programmierung der

Text „Verified OK“. Nach jeder Programmänderung muss der Übersetzungsvorgang - wie oben beschrieben - wiederholt werden, damit eine neue Datei mit Mikrocontrollerbefehlen erstellt wird.



8.3 Aller Anfang ist schwer Für die Versuchsdurchführung sollten die Taster des LED/Taster-Moduls zum Benutzer zeigen. Die Seite mit den Tastern wird im Folgenden als "unten" bezeichnet. Zur Durchführung der folgenden Versuche sollten die vier benachbarten Jumper nach links ge-setzt werden. Der allein stehende Jumper sollte zunächst auch nach links gesetzt werden. Nur bei den Ampelversuchen wird dieser nach rechts gesetzt (vgl. Kapitel 8.9). Um die folgenden Basic-Programme besser lesen zu können, sollte man einige einfache Bestandteile kennen:

• Einzeiliger Kommentar Rem Dies ist ein Kommentar

• Einbindung einer Definitionsdatei für den verwendeten Prozessor

$regfile = "2313def.dat"

• Einstellung der Takfrequenz (für den Simulator) $crystal = 10000000

• Beginn der Vorwärtsdeklaration für Prozeduren und Funktionen

Declare

• Beginn und Ende der Deklaration einer Prozedur

Sub p(… eventuelle Parameter …) End Sub

• Beginn und Ende der Deklaration einer Funktion mit dem Rückgabetyp Integer

Function f(… eventuelle Parameter …) as Integer End Function

• Beginn einer Zahl in hexadezimaler Notation: &H

Beginn einer Zahl in binärer Notation: &B



8.4 Versuch 1: Einschalten der Leuchtdioden (led.bas) Das Programm "led.bas" zeigt die Grundstruktur eines Basic-Programms und führt die elementaren Befehle zur Initialisierung der Ports aus. Die Ports werden dabei durch den Befehl „Config“ und den Parameter „Output“ auf Ausgang geschaltet. Dabei werden intern die Datenrichtungsregister25 DDRB und DDRD mit dem hexadezimalen Wert FF auf Ausgang geschaltet. Die Ausgänge werden durch Be-schreiben der Portregister26 PORTB und PORTD mit dem hexadezimalen Wert 00 auf 0 (entspricht 0 Volt) gesetzt. Danach verbleibt das Programm in einer Endlosschleife. Rem ************************************************************************************************ Rem Rem Program: led Rem Rem Funktion: Rem Initialisiert die Ports, schaltet die Ports auf Ausgang und setzt die Ausgänge auf 0, Rem damit die gegen 5V geschalteten Leuchtdioden leuchten. Rem Rem Autor: Kai Ludwig / Version: 1.00 Rem Rem Copyright 2004 by DG4KLU Rem Rem ************************************************************************************************ $regfile = "2313def.dat" ' Definitionen für AT90S2313 $crystal = 10000000 ' Die Taktfrequenz ist 10 MHz Config Portb = Output ' Port B auf Ausgang Config Portd = Output ' Port D auf Ausgang Portb = &H00 ' Alle Ausgänge auf 0 Portd = &H00 Do ' Endlosschleife Loop

Die LEDs sind gemeinsam an ihren Anoden mit + 5 Volt verbunden. Das Setzen aller Ausgänge von Port B und von Port D auf den Wert 0 führt dazu, dass die 15 LEDs an ihren Kathoden auf 0 Volt ge-legt werden, sodass sie leuchten. Die Hardwareanordnung wurde so gewählt, da der Mikrocontroller seine Ausgänge mit 20 mA gegen Masse schalten kann, jedoch nur mit 3 mA gegen + 5 Volt. Zahlen können entweder in dezimaler27, hexadezimaler28 oder binärer29 Notation angegeben werden. Zur Umwandlung zwischen den einzelnen Darstellungen empfiehlt sich die Verwendung des Win-dows-Taschenrechners.

25 Für jeden Anschluss wird im Datenrichtungsregister (DDR = data direction register) festgelegt, ob er als Eingang oder als Ausgang arbeitet. Wird das zum Anschluss gehörende Bit auf 1 gesetzt, so arbeitet der Anschluss als Ausgang. Sonst arbeitet er als Eingang. 26 Bei als Ausgang arbeitenden Anschlüssen entscheidet der Wert des zugehörigen Bits im Portregister, ob am Ausgang 0 Volt (Bit ist auf 0 gesetzt) oder 5 Volt (Bit ist auf 1 gesetzt) anliegen. Bei als Eingang arbeitenden Anschlüssen entscheidet der Wert des zugehörigen Bits im Portregister, ob ein interner Pull-Up-Widerstand zugeschaltet (Bit ist auf 1 gesetzt) wird oder nicht (Bit ist auf 0 gesetzt). Ein zugeschalteter Pull-Up-Widerstand sorgt dafür, dass ein nicht angeschlossener Eingang auf dem definierten Pegel 5 Volt gehalten wird. 27 zur Basis 10 mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8 und 9 28 zur Basis 16 mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E und F (Hexadezimalzahlen beginnen in Basic mit „&H“) 29 zur Basis 2 mit den Ziffern 0 und 1 (Binärzahlen beginnen in Basic mit „&B“)



Im diesem Programm werden alle Ausgänge auf 0 gesetzt. Also: PORT B = binär 00000000 = dezimal 0 = hexadezimal 00 PORT D = binär 00000000 = dezimal 0 = hexadezimal 00 Variation: Aus den Schaltplänen des Basis-Moduls und des LED/Taster-Moduls geht hervor, dass LED1 mit Aus-gang 0 von Port B verbunden ist. Um nun LED1 einzeln leuchten zu lassen, muss der Ausgang 0 auf 0 und alle anderen Ausgänge auf 1 gesetzt werden. Also: PORT B = binär 11111110 = dezimal 254 = hexadezimal FE PORT D = binär 11111111 = dezimal 255 = hexadezimal FF

8.5 Versuch 2: Blinkende Leuchtdioden (led_blinken.bas) Das Programm "led_blinken.bas" führt die gleiche Initialisierung aus, die bereits im Programm "led.bas" erläutert wurde. In der Endlosschleife werden die Leuchtdioden aber regelmäßig ein- und ausgeschaltet. Die Blinkfrequenz wird über eine Warteschleife gesteuert, die als Funktion implemen-tiert ist. Mit „Declare“ wird der Funktionskopf am Programmanfang definiert. Dadurch kann die Funktion be-reits im Programm verwendet werden, obwohl der eigentliche Funktionstext erst am Programmende steht. Declare Sub Warte(byval T As Word) ' Vorwärtsdeklarationen

Warteschleife: Sub Warte(byval T As Word) ' Warteschleife Dim I As Word Dim J As Word For I = 0 To T ' Verschachtelte Schleife mit Befehl nop="Tue nichts" For J = 0 To 200 nop Next J Next I End Sub

Variation: Verringert man in der inneren Schleife den Wert 200 z.B. auf den Wert 10, so erhöht sich die Blinkfre-quenz deutlich bei der Programmausführung, da die Schleifendurchlaufzeit nun kürzer ist. Durch An-passung dieses Wertes lässt sich also das Zeitverhalten der Schleife justieren.



Die folgenden Befehle innerhalb der Endlosschleife schalten die LEDs immer wieder an und aus: Do ' Endlosschleife Portb = &H00 ' Alle Ausgänge auf 0 Portd = &H00 Call Warte(1000) ' Warten Portb = &HFF ' Alle Ausgänge auf 1 Portd = &HFF Call Warte(1000) ' Warten Loop

Variation: Durch gleiches Verändern beider Werte "Call Warte(1000)" kann die Blinkfrequenz symmetrisch blin-kend verändert werden. Durch ungleiches Verändern beider Werte "Call Warte(1000)" kann die Sym-metrie der Blinkfrequenz verändert werden.

8.6 Versuch 3: Leuchtdioden als Lauflicht (lauflicht.bas) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt ein Lauflicht auf den Leuchtdioden aus. Lauflicht = 1 ' Lauflicht auf Anfang setzen Do ' Endlosschleife Portb = &HFF - Lauflicht ' Lauflicht auf Port B ausgeben (invertiert) Shift Lauflicht , Left , 1 ' Lauflicht um 1 Bit nach links weiterschieben If Lauflicht = 0 Then Lauflicht = 1 ' Wenn Lauflicht durchgelaufen ist, ' dann wieder am Anfang beginnen Call Warte(1000) ' Warten Loop

Die 8-Bit-Variable "lauflicht" wird zunächst mit der Binärzahl "00000001" (dezimal 1) initialisiert. Durch "Shift Lauflicht , Left , 1" wird das Bitmuster um ein Bit nach links geschoben ("00000010"). Wenn nach dem achten Mal die 1 nach links herausgeschoben wurde, ist danach die Variable "lauf-licht" wieder gleich Null. Dann wird die Variable erneut auf 1 gesetzt, und das Lauflicht beginnt von neuem. Variation: Wenn die 8-Bit-Variable "lauflicht" zunächst mit der Binärzahl "10000000" (dezimal 128) initialisiert wird und zum Verschieben des Wertes statt "Left" nun "Right" verwendet wird, dann läuft das Lauflicht anders herum.



8.7 Versuch 4: Leuchtdioden als Zähler (zaehler.bas) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und zählt einen 16-Bit-Zähler bis dezimal 32767 (binär "0111111111111111"). Die unteren 8 Bit werden auf Port B, die oberen 8 Bit auf Port D ausgegeben. Zaehler = 0 ' Zähler auf Null setzen Do ' Endlosschleife Portb = &HFF - Low(zaehler) ' Untere 8 Bit auf Port B ausgeben (invertiert) Portd = &HFF - High(zaehler) ' Obere 8 Bit auf Port D ausgeben (invertiert) Zaehler = Zaehler + 1 ' Zähler um 1 erhöhen If Zaehler = 32768 Then Zaehler = 0 ' Zähler bei 32768 wieder auf Null setzen Call Warte(1000) ' Warten Loop

Mit "Low" werden die unteren 8 Bit der 16-Bit-Variable „zaehler“ ermittelt. Diese werden auf Port B ausgegeben. Mit "High" werden die oberen 8 Bit der 16-Bit-Variable „zaehler“ ermittelt. Diese werden auf Port D ausgegeben.

8.8 Versuch 5: Würfelaugen (wuerfel.bas) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt nacheinander Werte auf die Ausgänge, sodass die Leuchtdioden in Würfelaugenmustern aufleuchten. Die zu den Mustern gehörenden Werte ergeben sich dabei gemäß folgender Tabelle30: Muster Bit 7

(unbe-nutzt)




Bit 3 (LED mitte)




Hexadezimal-zahl

1 0 0 0 0 1 0 0 0 08 2 0 1 0 0 0 0 0 1 41 3 0 0 1 0 1 0 1 0 2A 4 0 1 1 0 0 0 1 1 63 5 0 1 1 0 1 0 1 1 6B 6 0 1 1 1 0 1 1 1 77




8.9 Versuch 6: Ampel (ampel.bas) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und gibt nacheinander Werte auf die Ausgänge, sodass Ampelphasen auf den Leuchtdioden ausgegeben werden. Wichtig: Damit die Leuchtdioden auch in den Farben Gelb und Grün aufleuchten, muss der einzeln stehende Jumper auf dem LED/Taster-Modul nach rechts gesetzt werden. Die zu den Mustern gehörenden Werte ergeben sich dabei gemäß folgender Tabelle: Phase (linke Ampel, rechte Ampel)

Bit 7 (unbe-nutzt)




Bit 3 (LED mitte)




Hexadezimal-zahl


8.10 Versuch 7: Der erste Interrupt (led_blinken_interrupt.bas) Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und setzt diese auf 0. Die Ausgän-ge werden in einer durch Timer 0 ausgelösten Interruptroutine31 abwechselnd auf 0 oder 1 gesetzt, in-dem sie jeweils invertiert werden. Die Taktfrequenz wird zunächst durch einen einstellbaren Vorteilungsfaktor geteilt, bevor sie an den Timer 0 gelangt. Trotz maximaler Vorteilung blinken die LEDs immer noch recht schnell, da die von der Taktfrequenz abhängige Interruptroutine mit 10.000.000 Hz geteilt durch (1024*256) = ca. 38 Hz aufgerufen wird. Da für eine vollständige Blinkphase zwei Aufrufe benötigt werden, ergibt sich eine Blinkfrequenz von ca. 19 Hz. Die Vorteilung von 1024 wird im Register TCCR0 eingestellt. Die weitere Teilung von 256 ergibt sich aus dem in Timer 0 geladenen Startwert 0, der 256 mal erhöht wird, bis er erneut auf 0 springt und da-mit den Interrupt wieder auslöst. Die Beschreibung des Timers und die Werte für die Vorteilung kön-nen aus dem Datenblatt zum AT90S2313 entnommen werden. Durch „On Timer0 T0“ wird die Interruptroutine zugeordnet. Immer wenn Timer 0 den Interrupt auslöst, wird zum Label „T0:“ gesprungen. Dort steht dann die Interruptroutine. Durch den Befehl „Return“ am Ende der Interruptroutine wird wieder an die Stelle zurückgesprungen, an der das Hauptprogramm durch den Interrupt unterbrochen wurde.




Interruptroutine: T0: ' Timer-0 Interruptroutine Timer0 = &H00 ' Timer-0 Startwert setzen Portb = &HFF - Portb ' Ausgänge invertieren Portd = &HFF - Portd Return

Im Hauptprogramm wird der Timer-0 Interrupt initialisiert, dann werden die Interrupts aktiviert und danach bleibt das Programm in einer Endlosschleife. Alle weiteren Aktivitäten geschehen in der Inter-ruptroutine. Config Portb = Output ' Port B auf Ausgang Config Portd = Output ' Port D auf Ausgang Portb = &H00 ' Alle Ausgänge auf 0 Portd = &H00 On Timer0 T0 ' Timer-0 Interruptroutine festlegen Config Timer0 = Timer , Prescale = 1024 ' Timer-0 Vorteiler auf 1024 Timer0 = &H00 ' Timer-0 Startwert setzen Enable Timer0 ' Timer-0 Interrupt einschalten Enable Interrupts ' Interrupts aktivieren Do ' Endlosschleife Loop

Variation: Durch Verändern des Startwertes für Timer 0 an beiden Stellen im Programm kann die Blinkfrequenz gesteigert werden. Durch Verändern des Vorteilers in TCCR0 ist eine weitere Steigerung der Blinkfre-quenz möglich. Allerdings wird das Blinken dann ohne Messgerät nicht mehr wahrnehmbar sein. Verändert man den Vorteilerwert von 1024 auf 256 („Prescale = 256“), so erhöht sich die Blinkfrequenz von ca. 19 Hz um den Faktor 4 auf ca. 77 Hz. Das menschliche Auge kann diese Blinkfrequenz nicht mehr wahrnehmen. Bewegt man bei dieser Blinkfrequenz jedoch die Platine mit den LEDs schnell hin und her, so sieht man die durch die Bewegung verursachten Leuchtspuren der getakteten LEDs mit Unterbrechungen. Die Leuchtspur der ungetakteten grünen LED auf der Basisplatine zeigt keine Un-terbrechungen.



8.11 Versuch 8: Interrupt mit Zähler (led_blinken_interrupt_zaehler.bas)

Das Programm initialisiert die Ports, schaltet die Ports auf Ausgang und setzt diese auf 0. In der durch Timer 0 ausgelösten Interruptroutine wird eine Zählvariable heruntergezählt. Im Hauptprogramm wird nach dem Umschalten der Ausgänge gewartet, bis die Zählvariable nach dem Setzen auf einen Start-wert wieder bei Null ankommt. Interruptroutine: T0: ' Timer-0 Interruptroutine Timer0 = &H80 ' Timer-0 Startwert setzen If Zaehler > 0 Then Zaehler = Zaehler - 1 ' Zähler herunterzählen Return

Die Interruptroutine wird mit 10.000.000 Hz geteilt durch (8*128) = ca. 9,8 kHz aufgerufen. Der Wert 8 entspricht der eingestellten Vorteilung. Der Wert 128 ergibt sich aus dem in Timer 0 geladenen Start-wert (hexadezimal 80 = dezimal 128), der noch 128 mal erhöht wird, bis er erneut auf 0 springt und damit den Interrupt wieder auslöst. Im Hauptprogramm wird der Timer-0-Interrupt initialisiert, dann werden die Interrupts aktiviert und danach bleibt das Programm in einer Endlosschleife. In der Endlosschleife werden jeweils die Leucht-dioden ein- oder ausgeschaltet. Danach wird ein Zähler auf den Wert 4000 gesetzt und gewartet, bis dieser in der mit 9,8 kHz aufgerufenen Interruptroutine wieder auf 0 heruntergezählt wurde. Daraus ergibt sich eine Blinkfrequenz von ca. 1 Hz (pro Blinkphase 2 mal warten). On Timer0 T0 ' Timer-0 Interruptroutine festlegen Config Timer0 = Timer , Prescale = 8 ' Timer-0 Vorteiler auf 8 Timer0 = &H80 ' Timer-0 Startwert setzen Enable Timer0 ' Timer-0 Interrupt einschalten Enable Interrupts ' Interrupts aktivieren Do ' Endlosschleife Portb = &H00 ' Alle Ausgänge auf 0 (LEDs an) Portd = &H00 Zaehler = 4000 ' Zählvariable auf Startwert setzen While Zaehler > 0 ' Warten, bis Zählvariable wieder bei Null ankommt Wend Portb = &HFF ' Alle Ausgänge auf 1 (LEDs aus) Portd = &HFF Zaehler = 4000 ' Zählvariable auf Startwert setzen While Zaehler > 0 ' Warten, bis Zählvariable wieder bei Null ankommt Wend Loop

Variation: Durch gleiches Verändern beider Werte "Zaehler = 4000" kann die Blinkfrequenz symmetrisch blin-kend verändert werden. Durch ungleiches Verändern beider Werte "Zaehler = 4000" kann die Symmet-rie der Blinkfrequenz verändert werden.



8.12 Versuch 9: Alles zusammen (lauflicht_ampel_wuerfel.bas) Das Programm vereint die Funktionen der Programme "lauflicht.bas", "ampel.bas" und "wuerfel.bas". Nach der Initialisierung der Ports wird auf Port B ein Lauflicht ausgegeben. Dieses wird in der Inter-ruptroutine gesteuert und läuft somit im Hintergrund. Die Geschwindigkeit des Lauflichts wird durch die in der Interruptroutine heruntergezählte Zählvariable bestimmt. Im Hauptprogramm werden nach-einander Ampelphasen und Würfelaugenmuster ausgegeben, dabei wird die Zeitsteuerung des Ablaufs über eine Warteschleife erreicht. Die Würfelaugenmuster werden durch eine Schleife mehrfach ausge-geben. Der Quelltext des Programms ist kommentiert, Details können dort eingesehen werden.

8.13 Versuch 10: Taster abfragen (taster.bas) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Die Aus-gänge an Port B werden auf 1 gesetzt und die Pull-Up-Widerstände werden zu den Eingängen an Port D dazugeschaltet. Der Zustand der drei Taster wird abgefragt und jeweils mit einer LED angezeigt. Config Portb = Output ' Port B auf Ausgang Config Portd = Input ' Port D auf Eingang Portb = &HFF ' Alle Ausgänge auf 1 Portd = &HFF ' Pull-Up-Widerstände einschalten Do ' Endlosschleife If Pind.6 = 0 Then ' Taster 1 abfragen (gedrueckt = Bit geht auf 0) Portb.7 = 0 ' Zugehörige LED an Else Portb.7 = 1 ' Zugehörige LED aus End If If Pind.3 = 0 Then ' Taster 2 abfragen (gedrueckt = Bit geht auf 0) Portb.0 = 0 ' Zugehörige LED an Else Portb.0 = 1 ' Zugehörige LED aus End If If Pind.5 = 0 Then ' Taster 3 abfragen (gedrueckt = Bit geht auf 0) Portb.1 = 0 ' Zugehörige LED an Else Portb.1 = 1 ' Zugehörige LED aus End If Loop

In der Endlosschleife wird geprüft, ob der Eingang durch den jeweiligen Taster auf 0 geschaltet wurde. In diesem Fall wird die zugehörige Leuchtdiode eingeschaltet. Beim Drücken eines Tasters leuchten zwei LEDs. Die obere LED leuchtet bedingt durch die Hardware, die untere LED leuchtet gesteuert durch die Software.



Die Zuordnung von Tastern, Eingängen und Ausgabeleuchtdioden ergibt sich aus folgender Tabelle: Taster Eingang an Port D Ausgang an Port B


8.14 Versuch 11: Würfel mit Taster (wuerfel_taster.bas) Das Programm initialisiert die Ports und schaltet diese auf Ausgang. Der Ausgang, an dem Taster 2 angeschlossen ist, wird durch kurzes Umschalten auf Eingang auch als Eingang abgefragt. Wenn der Taster gedrückt wird, läuft der Würfel mit Maximalgeschwindigkeit und rollt nach dem Los-lassen des Tasters langsam aus. Der zufällige Zeitpunkt des Loslassens bestimmt indirekt den Würfel-wert, auf die Verwendung einer Zufallsfunktion wurde verzichtet. Abfrage des Tasters: Function Taster() As Byte ' Tasterabfrage durch kurzes Umschalten auf Eingang Dim Status As Byte Dim Ret_val As Byte Status = Portd And &H08 ' Alten Status merken Ddrd.3 = 0 ' Bit auf Eingang schalten Portd.3 = 1 If Pind.3 = 0 Then ' Taster abfragen Ret_val = 1 Else Ret_val = 0 End If Temp = Portd And &HF7 ' Alten Status wieder herstellen Portd = Temp Or Status Ddrd.3 = 1 ' Bit wieder auf Ausgang schalten Taster = Ret_val End Function

Im Hauptprogramm wird regelmäßig der Taster abgefragt. Das kurze Umschalten des Ausgangs auf Eingang ist allerdings nicht wahrnehmbar. Phase = 1 Zeit = 1250 Do ' Endlosschleife If Taster() = 1 Then ' Auf Taster warten Call Wuerfel_schritt Zeit = 250 Portb = &H00 Elseif Zeit < 1250 Then ' Ausrollen Call Wuerfel_schritt Call Warte(zeit) Zeit = Zeit + 63 If Zeit >= 1250 Then Portb = &HFF End If Loop



Solange der Taster als gedrückt erkannt wird, werden die Würfelmuster schnell weitergeschaltet. Es sieht dann so aus, als ob alle Augen gleichzeitig leuchten. Nach dem Loslassen des Tasters beginnt der Würfel auszurollen. Dabei wird die Zeit für die Warteschleife stufenweise erhöht, damit der Eindruck eines immer langsamer werdenden Ausrollvorgangs entsteht. Ist der Würfel langsam genug, so bleibt er stehen. Während des gesamten Würfelvorgangs werden die Leuchtdioden an Port B eingeschaltet. Sobald der Würfel stehen bleibt, werden diese wieder ausgeschaltet. Variation: Durch Verändern des Wertes 1250 an allen Stellen im Programm kann die Dauer des Ausrollvorgangs beeinflusst werden. Durch Verändern des Wertes 63 in der Zeile „Zeit = Zeit + 63“ kann die Ge-schwindigkeit des Ausrollvorgangs beeinflusst werden.

8.15 Versuch 12: Ampel mit Taster (ampel_taster.bas) Das Programm initialisiert die Ports und schaltet diese auf Ausgang. Der Ausgang, an dem Taster 2 angeschlossen ist, wird durch kurzes Umschalten auf Eingang auch als Eingang abgefragt. Wenn der Taster gedrückt wird, beginnt nach kurzem Warten eine Ampelphase. Nach Ablauf der Am-pelphase wartet das Programm auf den nächsten Tasterdruck. Zur Abfrage des Tasters wird dieselbe Funktion "taster" benutzt, die auch schon im Programm "wuer-fel_taster.bas" zum Einsatz kam. Der Ablauf der Ampelphasen wird wie im Programm "ampel.bas" durch eine Warteschleife gesteuert.



8.16 Versuch 13: Lauflicht mit Taster (lauflicht_taster.bas) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Wenn der linke Taster gedrückt wird, bewegt sich das Lauflicht einen Schritt im Uhrzeigersinn. Wenn der rechte Taster gedrückt wird, bewegt sich das Lauflicht einen Schritt gegen den Uhrzeigersinn. Wenn der mitt-lere Taster gedrückt wird, dann stellt sich das Lauflicht auf die Ausgangsposition zurück. Um die Taster zu entprellen, wird jeweils nach Drücken und Loslassen kurz gewartet. Dadurch werden die beim Prellen entstehenden zusätzlichen Impulse nicht ausgewertet. Ohne Entprellen würde das Lauflicht "springen". Lauflicht = 1 ' Lauflicht auf Anfang setzen Do ' Endlosschleife Temp = Pind And &H68 If Temp <> &H68 Then ' Warte auf beliebigen Taster Call Warte(5) ' Entprellen Temp = Pind And &H68 If Temp = &H28 Then ' Wenn Taster 1 gedrueckt wurde, Shift Lauflicht , Right , 1 ' Lauflicht um 1 Bit nach rechts weiterschieben If Lauflicht = 0 Then Lauflicht = 128 ' Wenn Lauflicht durchgelaufen ist, ' dann wieder am Anfang beginnen End If Temp = Pind And &H68 If Temp = &H48 Then ' Wenn Taster 2 gedrueckt wurde, Shift Lauflicht , Left , 1 ' Lauflicht um 1 Bit nach links weiterschieben If Lauflicht = 0 Then Lauflicht = 1 ' Wenn Lauflicht durchgelaufen ist, ' dann wieder am Anfang beginnen End If Temp = Pind And &H68 If Temp = &H60 Then ' Wenn Taster 3 gedrueckt wurde, Lauflicht = 1 ' Lauflicht zurücksetzen End If Temp = Pind And &H68 While Temp <> &H68 ' Warte, bis kein Taster gedrueckt ist Temp = Pind And &H68 Wend Call Warte(5) ' Entprellen End If Portb = &HFF - Lauflicht ' Lauflicht auf Port B ausgeben (invertiert) Loop




8.17 Versuch 14: Zähler mit Taster (zaehler_taster.bas) Das Programm initialisiert die Ports, schaltet Port B auf Ausgang und Port D auf Eingang. Wenn der linke Taster gedrückt wird, wird der Zähler um 1 verringert. Wenn der rechte Taster gedrückt wird, wird der Zähler um 1 erhöht. Wenn der mittlere Taster gedrückt wird, dann stellt sich der Zähler auf 0 zurück. Um die Taster zu entprellen, wird jeweils nach Drücken und Loslassen kurz gewartet. Dadurch werden die beim Prellen entstehenden zusätzlichen Impulse nicht ausgewertet. Ohne Entprellen würde der Zäh-ler "springen". Zaehler = 0 ' Zähler auf Anfang setzen Do ' Endlosschleife Temp = Pind And &H68 If Temp <> &H68 Then ' Warte auf beliebigen Taster Call Warte(5) ' Entprellen Temp = Pind And &H68 If Temp = &H28 Then ' Wenn Taster 1 gedrueckt wurde, Zaehler = Zaehler - 1 ' Zähler um 1 verringern und If Zaehler = 65535 Then Zaehler = 32767 ' bei Zähler-Unterlauf wieder am Anfang beginnen End If Temp = Pind And &H68 If Temp = &H48 Then ' Wenn Taster 2 gedrueckt wurde, Zaehler = Zaehler + 1 ' Zähler um 1 erhöhen und If Zaehler = 32768 Then Zaehler = 0 ' bei Zähler-Überlauf wieder am Anfang beginnen End If Temp = Pind And &H68 If Temp = &H60 Then ' Wenn Taster 3 gedrueckt wurde, Zaehler = 0 ' Zähler zurücksetzen End If Temp = Pind And &H68 While Temp <> &H68 ' Warte, bis kein Taster gedrueckt ist Temp = Pind And &H68 Wend Call Warte(5) ' Entprellen End If Portb = &HFF - Low(zaehler) ' Untere 8 Bit auf Port B ausgeben (invertiert) Portd = &HFF - High(zaehler) ' Obere 8 Bit auf Port D ausgeben (invertiert) Loop




Abbildung 16 - Bestückung Basismodul



Abbildung 17 - Schaltplan LED/Taster-Modul



Abbildung 18 - Bestückung LED/Taster-Modul



Abbildung 19 - Schaltplan ISP-Modul



Abbildung 20 - Bestückung ISP-Modul

Modulares Experimentiersystem für den PC mit einem Atmel ...info.talentraspel.de/Handbuch.pdf ·...

Documents

Transcript of Modulares Experimentiersystem für den PC mit einem Atmel ...info.talentraspel.de/Handbuch.pdf ·...