Das Statusregister (SREG) - 2

Lösung: Übung 3 - Selbsttest aus AVR Assembler - Teil 1 * Statusregister SREG - 1

In diesem Kapitel wird die Instruktion SBIW sowohl mit dem AVR Simulator als auch auf dem STK200 näher untersucht mit besonderem Augenmerk auf das SREG. Hilfreich für das Verständnis sind die Erfahrungen aus den Kapiteln

• "8-Bit Arithmetik - Teil 2 * Übung 4 Aufwärtszähler mit Warteschleife - Instruktionen INC, DEC"       
  als auch
   
• "AVR Assembler - Teil 2".

Eine neue Übung

• In einem Simulationsprogramm wird von einem 16-Bit Register in einer Schleife mit der Instruktion SBIW laufend der Wert 1 abgezogen, bis 0 erreicht und das Z-Flag im SREG gesetzt ist (Abbruchbedingung).
• Eine bisher leuchtende LED wird daraufhin abgeschaltet, eine nicht leuchtende eingeschaltet.
• Die Informationen zur Instruktion SBIW aus dem Instruction Set Summary fasst die folgende Tabelle 1 zusammen.

Die Instruktion zieht von einem 16-Bit Registerwert RdH:RdL den Wert K ab.

Die Aufgaben

• In der folgenden Übung geht es um den Aufbau einer einfachen Zeit- oder Warteschleife.
• LED2 auf dem STK200-Board soll so angesteuert werden, dass sie deutlich sichtbar blinkt.
• Die Periodenzeit und die Frequenz wird über ein Simulationsprogramm Sim_Zeitschleife.asm (siehe Abb. 1) bestimmt und anschließend im Realaufbau überprüft und mit einem Oszilloskop die Frequenz gemessen werden.
• Übertrage das Programm aus Abb. 1 in den Editor des AVR Studio und speichere es ab.
• Überlege dir, was das Programm mit jedem Programmschritt veranlasst. Wie lautet die Abbruchbedingung für die Schleife LED_ein?
• Errechne die Wartezeit in der Zählschleife LED_ein, indem du die Anzahl der Takte  jeder aufgerufenen Instruktion in der Schleife bestimmst (Datenblatt), die Zahl der Durchläufe errechnest und daraus die Gesamt-Verweilzeit in der Schleife bestimmst.
• Welcher Formel-Zusammenhang besteht zwischen Frequenz f und Periodendauer T? Errechne die Periodendauer der Blinkschaltung.
• Passe das Simulationsprogramm Sim_Zeitschleife.asm an die Hardware-Bedingungen des STK200-Boards an, speichere es unter dem Namen Zeitschleife.asm ab und führe dann das lauffähige Programm aus. Bestimme mit dem Oszilloskop die Frequenz der blinkenden LED2. Vergleiche das praktische mit dem errechneten Ergebnis.

-----------------------------------------------------------------------------------------------------------------------------------

Die Materialien

• Datenblatt des ATmega8 Controllers plus AVR Instruction Set Manual
• AVR Simulator Programm oder Debugger des AVR Studio
• USB-Oszilloskop
• STK200 Board mit Programmer und Schaltnetzteil

Das Programm (siehe Abb. 2) ist vollständig auskommentiert und bedarf keiner weiteren Ergänzungen. Das Verhalten der Instruktion SBIW kann Abb. 1 entnommen werden.

Das Programm arbeitet mit dem 16-Bit Register ZH:ZL (R31:R30).

Der Zähler startet mit der Einstellung 0101 1111 0000 0000.

• Die Schleife LED_ein wird insgesamt 95 x 255 = 24225 mal durchlaufen.
• Jeder Durchlauf dauert 5 Takte. Bei einer Taktfrequenz von 1 MHz dauert jeder Takt 1 µs.
• Von den 24225 Durchläufen werden die letzten 255 Durchläufe (siehe Abbruchbedingung der Schleife) nicht ausgeführt und müssen subtrahiert werden. 24225 - 255 = 24065 Durchläufe.
• Jeder Durchlauf dauert 5 µs; das macht insgesamt 24065 * 5 µs = 120 324 µs oder 0,120324 s.
• Eine volle Periode dauert T = 2*0,120324s = 0,240648 s; dies entspricht einer Frequenz f von ca. 4,16... Hz.

• Die Zeitschleife im Block LED_ein wird verlassen, weil das Z-Flag im SREG nach 120329 Taktzyklen gesetzt worden ist (siehe Abb. 3a). Im Simulationsprogramm wurde hierzu ein Breakpoint in Programmzeile 29 gesetzt.

• Mit f = 1/T und dem errechneten Zeitwert T = 0,240648 s ergibt sich rechnerisch eine Frequenz von f = 4,16... Hz.
• Lädt man das Programm in einen ATmega8 Controller auf einem STK200 Board, dann misst man am Ausgangspin PORTB.2 eine Frequenz von f = 4,08... Hz (siehe Abb. 4). Die Abweichung von < 2% zum errechneten Wert liegt im Toleranzbereich.

Übung 2 - LED Lichtmuster erzeugen

In Übung 2 geht es auch wieder um eine Zeitschleife aber auch darum, wie man Daten ins SRAM schreibt und wieder ausliest und wie man Eingangsdaten eines Tasters liest und damit Entscheidungen trifft.

Im ersten Entwicklungsschritt wird das Lichtmuster erzeugt. Dazu werden die Daten der vier verschiedenen 8-Bit LED-Muster im SRAM abgelegt und zu gegebener Zeit von dort abgerufen und auf der LED-Bargrafanzeige dargestellt. Die Leuchtdauer jedes LED-Musters sollte ca. 0,1 - 0,3 ms betragen. Pro Sekunde werden dann ca. vier verschiedene Muster übertragen. Wie das aussehen könnte, zeigt das folgende Video.

Die Aufgaben

• Schreibe ein Simulationsprogramm für einen ATmega8, das auf einer LED-Bargrafanzeige ein dauerhaftes Lichtmuster erzeugt, das folgende Phasen durchläuft:
  Phase 1: 0111 1110
  Phase 2: 1011 1101
  Phase 3: 1101 1011
  Phase 4: 1110 0111.
  Dabei bedeutet eine 0, die LED leuchtet und eine 1, die LED leuchtet nicht (Anpassung an das STK200 Board; dort sind die LEDs low active geschaltet).
• Die Bargrafanzeige wird über PORTB angesteuert, die Taster über PORTD.
• Abgebrochen bzw. beendet wird das Lichtmuster, sobald Taster T1 gedrückt ist.
• Wenn das Simulationsprogramm läuft, übertrage es auf ein STK200 mit einem ATmega8 und überprüfe praktisch seine Funktionstüchtigkeit.

-----------------------------------------------------------------------------------------------------------------------------------

Die Materialien

• Datenblatt des ATmega8 Controllers plus AVR Instruction Set Manual
• AVR Simulator Programm oder Debugger des AVR Studio
• STK200 Board mit Programmer und Schaltnetzteil

Vorüberlegung zur Phase 1 - Lauflicht mit vier verschiedenen Lichtmustern erstellen

1. Die vier verschiedenen 8-Bit Lichtmuster werden im SRAM abgelegt. Dazu muss vorher der Stapelzeiger gesichert werden und PortB auf Ausgang eingestellt sein.
2. Anschließend werden nacheinander die vier Lichtmuster aus dem SRAM abgerufen und auf der LED-Bargrafanzeige dargestellt.
3. Jedes Muster wird ca. 0,1 - 0,3 s lang zu sehen sein, bevor das nächste Muster aufgerufen wird. Dazu wird ein Unterprogramm aufgerufen, das die Ausführung des nächsten Befehls um ca. 0,2 s verzögert.

Programmvorschlag zur Phase 1

Wenn das Programm fehlerfrei läuft, sollte das Lauflicht sich - ähnlich wie im Kurzvideo - verhalten.

Wie arbeitet das Programm?

Alle Programmzeilen des Programms wurden auskommentiert (siehe Abb. 5a - 5c). Der Programmablauf lässt sich wie folgt strukturieren:

1. Initialisierung (Stack anlegen/retten, Ports setzen, Lichtmuster festlegen, Daten ins SRAM schreiben)
2. Hauptprogramm - Endlosschleife (Die Lichtmuster werden nacheinander aufgerufen. Nach jedem Lichtmusteraufruf geht das Programm in eine Zeitschleife).
3. Unterprogramme (Zeitschleife)

Vorüberlegung zur Phase 2 - Taster T1 hält das Lauflicht an

1. Im Initialisierungsteil wird PORTD als Eingang für die Taster definiert.
2. Im Hauptprogramm wird der Sprungbefehl in das Unterprogramm schlafen nach jedem Lichtmusteraufruf gesetzt. Vorher wird Eingang PIND gelesen und mit einem Vorgabewert verglichen. Bei Gleichheit ist T1 gedrückt und das Programm verzweigt zum Unterprogrammm schlafen.

Im Block Unterprogramme wird das Unterprogramm schlafen eingefügt.

Damit ist die Aufgabe, wie oben beschrieben, erfüllt.

Die Aufgaben

• Wandel das Programm aus Übung 2 so ab, dass ein sogenanntes Knight-Rider-Lauflicht entsteht (siehe Kurzvideo).

• Die Tasterfunktionen aus Übung 2 werden so verändert, dass T1 und T2 zwei unterschiedliche Geschwindigkeiten des Lauflichts erzeugen, die frei gewählt aber deutlich unterscheidbar sein müssen.