Mikrocontroller.net - Benutzerbeiträge [de]

AVR-Tutorial: 7-Segment-Anzeige

2009-02-24T13:37:24Z

85.183.44.11: /* Schaltung */

Die Ausgabe von Zahlenwerten auf ein Text-LCD ist sicherlich das Nonplusultra, aber manchmal liegen die Dinge sehr viel einfacher. Um beispielsweise eine Temperatur anzuzeigen ist ein LCD etwas Overkill. In solchen Fällen kann die Ausgabe auf ein paar 7-Segmentanzeigen gemacht werden. Ausserdem haben 7-Segmentanzeigen einen ganz besonderen Charme :-)

==Eine einzelne 7-Segment Anzeige==

===Codetabelle===

Die Umkodierung von einzelnen Ziffern in ein bestimmtes Ausgabemuster bezeichnet man als Codetabelle. Die auszugebende Ziffer wird als Offset zum Anfang dieser Tabelle aufgefasst und aus der Tabelle erhält man ein Byte (Code), welches direkt auf den Port ausgegeben werden kann und das entsprechende Bitmuster enthält, sodass die für diese Ziffer notwendigen LED ein- bzw. ausgeschaltet sind.

Beispiel: Um die Ziffer '''3''' anzuzeigen, müssen auf der Anzeige die Segmente '''a''', '''b''', '''c''', '''d''' und '''g''' aufleuchten. Alle anderen Segmente sollen dunkel sein.

[[Bild:Tut_7_Seg_02a.gif | framed | left | Darstellung der Ziffer "3"]]
 

Aus dem Anschlußschema ergibt sich, dass die dazu notwendige Ausgabe am Port binär '''10110000''' lauten muss. Untersucht man dies für alle Ziffern, so ergibt sich folgende Tabelle:
<avrasm>
.db 0b11000000 ; 0: a, b, c, d, e, f
.db 0b11111001 ; 1: b, c
.db 0b10100100 ; 2: a, b, d, e, g
.db 0b10110000 ; 3: a, b, c, d, g
.db 0b10011001 ; 4: b, c, f, g
.db 0b10010010 ; 5: a, c, d, f, g
.db 0b10000010 ; 6: a, c, d, e, f, g
.db 0b11111000 ; 7: a, b, c
.db 0b10000000 ; 8: a, b, c, d, e, f, g
.db 0b10010000 ; 9: a, b, c, d, f, g
</avrasm>

===Programm===

Das Testprogramm stellt nacheinander die Ziffern 0 bis 9 auf der 7-Segmentanzeige dar. Die jeweils auszugebende Zahl steht im Register '''count''' und wird innerhalb der Schleife um jeweils 1 erhöht. Hat das Register den Wert 10 erreicht, so wird es wieder auf 0 zurückgesetzt. Nach der Erhöhung folgt eine Warteschleife, welche dafür sorgt, dass bis zur nächsten Ausgabe eine gewisse Zeit vergeht. Normalerweise macht man keine derartigen langen Warteschleifen, aber hier geht es ja nicht ums Warten sondern um die Ansteuerung einer 7-Segmentanzeige. Einen Timer dafür zu benutzen wäre zunächst zuviel Aufwand.

Die eigentliche Ausgabe und damit der in diesem Artikel interessante Teil findet jedoch direkt nach dem Label loop statt. Die bereits bekannte Codetabelle wird mittels '''.db''' Direktive ('''d'''efine '''b'''yte) in den [[Speicher#Flash-ROM | Flash-Speicher]] gelegt. Der Zugriff darauf erfolgt über den Z-Pointer und dem Befehl '''lpm'''. Zusätzlich wird vor dem Zugriff noch der Wert des Registers '''count''' und damit der aktuelle Zählerwert zum Z-Pointer addiert.

Beachtet werden muss nur, dass der Zählerwert verdoppelt werden muss. Dies hat folgenden Grund: Wird die Tabelle so wie hier gezeigt mittels einzelnen '''.db''' Anweisungen aufgebaut, so fügt der Assembler sog. '''Padding Bytes''' zwischen die einzelnen Bytes ein, damit jede '''.db''' Anweisung auf einer geraden Speicheradresse liegt. Dies ist eine direkte Folge der Tatsache, dass der Flash-Speicher '''wortweise''' (16 Bit) und nicht '''byteweise''' (8 Bit) organisiert ist. Da aber von einem .db in der Tabelle zum nächsten .db eine Differenz von 2 Bytes vorliegt, muss dies in der Berechnung berücksichtigt werden. Im zweiten Beispiel auf dieser Seite wird dies anders gemacht. Dort wird gezeigt wie man durch eine andere Schreibweise der Tabelle das Erzeugen der Padding Bytes durch den Assembler verhindern kann.

Aus dem gleichen Grund wird auch der Z-Pointer mit dem 2-fachen der Startadresse der Tabelle geladen. Die Startadresse wird vom Assembler in wortweiser Adressierung eingesetzt, '''lpm''' möchte die Zugriffsadresse als Byteadresse angegeben haben.

Interessant ist auch, dass in der Berechnung ein Register benötigt wird, welches den Wert 0 enthält. Dies deshalb, da es im AVR keinen Befehl gibt der eine Konstante mit gleichzeitiger Berücksichtigung des Carry-Bits addieren kann. Daher muss diese Konstante zunächst in ein Register geladen werden und erst dann kann die Addition mithilfe dieses Registers vorgenommen werden. Das Interessante daran ist nun, dass dieser Umstand in sehr vielen Programmen vorkommt und es sich bei der Konstanten in der überwiegenden Mehrzahl der Fälle um die Konstante 0 handelt. Viele Programmierer reservieren daher von vorne herein ein Register für diesen Zweck und nennen es das Zero-Register. Sinnvollerweise legt man dieses Register in den Breich r0..r15, da diese Register etwas zweitklassig sind (ldi, cpi etc. funktionieren nicht damit).

<avrasm>
.include "m8def.inc"

.def zero = r1
.def count = r16
.def temp1 = r17

.org 0x0000
rjmp main ; Reset Handler
;
main:
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
ldi temp1, $FF ; die Anzeige hängt am Port D
out DDRD, temp1 ; alle Pins auf Ausgang
;
ldi count, 0 ; und den Zähler initialisieren
mov zero, count
;
loop:
ldi ZL, LOW(Codes*2) ; die Startadresse der Tabelle in den
ldi ZH, HIGH(Codes*2) ; Z-Pointer laden

mov temp1, count ; die wortweise Adressierung der Tabelle
add temp1, count ; berücksichtigen

add ZL, temp1 ; und ausgehend vom Tabellenanfang
adc ZH, zero ; die Adresse des Code Bytes berechnen

lpm ; dieses Code Byte in das Register r0 laden

out PORTD, r0 ; und an die Anzeige ausgeben
;
inc count ; den Zähler erhöhen, wobei der Zähler
cpi count, 10 ; immer nur von 0 bis 9 zählen soll
brne wait
ldi count, 0
;
wait: ldi r17, 10 ; und etwas warten, damit die Ziffer auf
wait0: ldi r18, 0 ; der Anzeige auch lesbar ist, bevor die
wait1: ldi r19, 0 ; nächste Ziffer gezeigt wird
wait2: dec r19
brne wait2
dec r18
brne wait1
dec r17
brne wait0
;
rjmp loop ; auf zur nächsten Ausgabe
;
Codes: ; Die Codetabelle für die Ziffern 0 bis 9
; sie regelt, welche Segmente für eine bestimmte
; Ziffer eingeschaltet werden müssen
;
.db 0b11000000 ; 0: a, b, c, d, e, f
.db 0b11111001 ; 1: b, c
.db 0b10100100 ; 2: a, b, d, e, g
.db 0b10110000 ; 3: a, b, c, d, g
.db 0b10011001 ; 4: b, c, f, g
.db 0b10010010 ; 5: a, c, d, f, g
.db 0b10000010 ; 6: a, c, d, e, f, g
.db 0b11111000 ; 7: a, b, c
.db 0b10000000 ; 8: a, b, c, d, e, f, g
.db 0b10010000 ; 9: a, b, c, d, f, g

</avrasm>

==Mehrere 7-Segment Anzeigen (Multiplexen)==

Mit dem bisherigen Vorwissen könnte man sich jetzt daran machen, auch einmal drei oder vier Anzeigen mit dem Mega8 anzusteuern. Leider gibt es da ein Problem, denn für eine Anzeige sind acht Portpins notwendig - vier Anzeigen würden demnach 32 Portpins benötigen. Die hat der Mega8 aber nicht. Dafür gibt es aber mehrere Auswege. Schieberegister sind bereits in einem anderen [[AVR-Tutorial:_Schieberegister|Tutorial]] beschrieben. Damit könnte man sich ganz leicht die benötigten 32 Ausgangsleitungen mit nur 3 Portpins erzeugen. Das Prinzip der Ansteuerung unterscheidet sich in nichts von der Ansteurung einer einzelnen 7-Segment Anzeige, lediglich die Art und Weise, wie die 'Ausgangspins' zu ihren Werten kommen ist anders und durch die Verwendung von Schieberegistern vorgegeben. An dieser Stelle soll aber eine andere Variante der Ansteuerung gezeigt werden. Im Folgenden werden wir uns daher das [[Multiplexen]] einmal näher ansehen.

Multiplexen bedeutet, dass nicht alle vier Anzeigen gleichzeitig eingeschaltet sind, sondern immer nur Eine für eine kurze Zeit. Geschieht der Wechsel zwischen den Anzeigen schneller als wir Menschen das wahrnehmen können, so erscheinen uns alle vier Anzeigen gleichzeitig in Betrieb zu sein obwohl immer nur Eine für eine kurze Zeit aufleuchtet. Dabei handelt es sich praktisch um eine [[LED-Matrix]]. Die vier Anzeigen können sich dadurch die einzelnen Segmentleitungen teilen und alles was benötigt wird sind 4 zusätzliche Steuerleitungen für die 4 Anzeigen, mit denen jeweils eine Anzeige eingeschaltet wird. Dieses Ein/Ausschalten wird mit einem pnp-Transistor in der Versorgungsspannung jeder Anzeige realisiert, die vom Mega8 am '''PortC''' angesteuert werden.

Ein Aspekt dieser Ansteuerungsart ist die Multiplexfrequenz. Sie muss hoch genug sein, um ein Flimmern der Anzeige zu vermeiden. Das menschliche Auge ist träge, im Kino reichen 24 Bilder pro Sekunde, beim Fernseher sind es 50. Um auf der sicheren Seite zu sein, dass auch Standbilder ruhig wirken, sollen jedes Segment mit mindestens 100 Hz angesteuert werden, es also mindestens alle 10ms angeschaltet ist. In Ausnahmefällen können aber selbst 100 Hz noch flimmern, z.B. wenn die Anzeige schnell bewegt wird oder wenn es zu Interferenzerscheinungen mit künstlichen Lichtquellen kommt, die mit Wechselstrom betrieben werden.

Bei genauerer Betrachtung fällt auch auf, dass die vier Anzeigen nicht mehr ganz so hell leuchten wie die eine einzelne Anzeige ohne Multiplexen. Bei wenigen Anzeigen ist dies praktisch kaum sichtbar, erst bei mehreren Anzeigen wird es deutlich. Um dem entgegen zu wirken lässt man pro Segment einfach mehr Strom fließen, bei LEDs dürfen dann 20mA überschritten werden. Als Faustregel gilt, dass der n-fache Strom für die (1/n)-fache Zeit fließen darf. Details finden sich im Datenblatt unter dem Punkt '''Peak-Current''' (Spitzenstrom) und '''Duty-Cycle''' ([[PWM | Tastverhältnis]]).

Allerdings gibt es noch ein anderes Problem wenn insgesamt zu viele Anzeigen gemultiplext werden. Die Pulsströme durch die LEDs werden einfach zu hoch. Die meisten LEDs kann man bis 8:1 multiplexen, manchmal auch bis 16:1. Hier fliesst aber schon ein Pulsstrom von 320mA (16 x 20mA), was nicht mehr ganz ungefährlich ist. '''Strom lässt sich durch Multiplexen nicht sparen''', denn die verbrauchte Leistung ändert sich beim n-fachen Strom für 1/n der Zeit nicht. Kritisch wird es aber, wenn das Multiplexen deaktiviert wird (Ausfall der Ansteuerung durch Hardware- oder Softwarefehler) und der n-fache Strom dauerhaft durch eine Segment-LED fließt. Bei 320mA werden die meisten LEDs innerhalb von Sekunden zerstört. Hier muss sichergestellt werden, dass sowohl Programm (Breakpoint im Debugger) als auch Schaltung (Reset, Power-On, [http://www.mikrocontroller.net/topic/107941]) diesen Fall verhindern. Prinzipiell sollte man immer den Pulsstrom und die Multiplexfrequenz einmal überschlagen, bevor der Lötkolben angeworfen wird.

===Schaltung===

[[Bild:Tut_7_Seg_03.gif | framed | left | Ansteuerung von vier 7-Segmentanzeigen per Multiplex]]
 

Sollten die Anzeigen zu schwach leuchten so können, wie bereits beschrieben, die Ströme durch die Anzeigen erhöht werden. Dazu werden die 330 Ohm Widerstände kleiner gemacht. Da hier 4 Anzeigen gemultiplext werden, würden sich Widerstände in der Größenordnung von 100 Ohm anbieten. Auch kann dann der Basiswiderstand der Transistoren verkleinert werden.

===Programm===

Das folgende Programm zeigt eine Möglichkeit zum Multiplexen. Dazu wird ein Timer benutzt, der in regelmässigen Zeitabständen einen Overflow [[Interrupt]] auslöst. Innerhalb der Overflow Interrupt Routine wird
* die momentan erleuchtete Anzeige abgeschaltet
* das Muster für die nächste Anzeige am Port D ausgegeben
* die nächste Anzeige durch eine entsprechende Ausgabe am Port C eingeschaltet

Da Interruptfunktionen kurz sein sollten, holt die Interrupt Routine das auszugebende Muster für jede Stelle direkt aus dem SRAM, wo sie die Ausgabefunktion hinterlassen hat. Dies hat 2 Vorteile:
* Zum einen braucht die Interrupt Routine die Umrechnung einer Ziffer in das entsprechende Bitmuster nicht selbst machen
* Zum anderen ist die Anzeigefunktion dadurch unabhängig von dem was angezeigt wird. Die Interrupt Routine gibt das Bitmuster so aus, wie sie es aus dem SRAM liest. Werden die SRAM Zellen mit geeigneten Bitmustern gefüllt, können so auch einige Buchstaben oder Balkengrafik oder auch kleine Balken-Animationen abgespielt werden. Insbesondere letzteres sieht man manchmal bei Consumer-Geräten kurz nach dem Einschalten des Gerätes um eine Art Defektkontrolle zu ermöglichen oder einfach nur als optischer Aufputz.

Die Funktion out_number ist in einer ähnlichen Form auch schon an anderer Stelle vorgekommen: Sie verwendet die Technik der fortgesetzten Subtraktionen um eine Zahl in einzelne Ziffern zu zerlegen. Sobald jede Stelle feststeht, wird über die Codetabelle das Bitmuster aufgesucht, welches für die Interrupt Funktion an der entsprechenden Stelle im SRAM abgelegt wird.

'''Achtung''': Anders als bei der weiter oben gezeigten Variante wurde die Codetabelle ohne Padding Bytes angelegt. Dadurch ist es auch nicht notwendig derartige Padding Bytes in der Programmierung zu berücksichtigen.

Der Rest ist wieder die übliche Portinitialisierung, Timerinitialisierung und eine einfache Anwendung, indem ein 16 Bit Zähler laufend erhöht und über die Funktion out_number ausgegeben wird. Wie schon im ersten Beispiel, wurde auch hier kein Aufwand getrieben: Zähler um 1 erhöhen und mit Warteschleifen eine gewisse Verzögerungszeit einhalten. In einer realen Applikation wird man das natürlich nicht so machen, sondern ebenfalls einen Timer für diesen Teilaspekt der Aufgabenstellung einsetzen.

Weiterhin ist auch noch interessant. Die Overflow Interrupt Funktion ist wieder so ausgelegt, dass sie völlig transparent zum restlichen Programm ablaufen kann. Dies bedeutet, dass alle verwendeten Register beim Aufruf der Interrupt Funktion gesichert und beim Verlassen wiederhergestellt werden. Dadurch ist man auf der absolut sicheren Seite, hat aber den Nachteil etwas Rechenzeit für manchmal unnötige Sicherungs- und Aufräumarbeiten zu 'verschwenden'. Stehen genug freie Register zur Verfügung, dann wird man natürlich diesen Aufwand nicht treiben, sondern ein paar Register ausschließlich für die Zwecke der Behandlung der 7-Segment Anzeige abstellen und sich damit den Aufwand der Registersicherung sparen (mit Ausnahme von '''SREG''' natürlich!).

<avrasm>
.include "m8def.inc"

.def temp = r16
.def temp1 = r17
.def temp2 = r18

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp multiplex

;
;********************************************************************
; Die Multiplexfunktion
;
; Aufgabe dieser Funktion ist es, bei jedem Durchlauf eine andere Stelle
; der 7-Segmentanzeige zu aktivieren und das dort vorgesehene Muster
; auszugeben
; Die Funktion wird regelmässig in einem Timer Interrupt aufgerufen
;
multiplex:
push temp ; Alle verwendeten Register sichern
push temp1
in temp, SREG
push temp
push ZL
push ZH

ldi temp1, 0 ; Die 7 Segment ausschalten
out PORTC, temp1

; Das Muster für die nächste Stelle ausgeben
; Dazu zunächst mal berechnen, welches Segment als
; nächstest ausgegeben werden muss
ldi ZL, LOW( Segment0 )
ldi ZH, HIGH( Segment0 )
lds temp, NextSegment
add ZL, temp
adc ZH, temp1

ld temp, Z ; das entsprechende Muster holen und ausgeben
out PORTD, temp

lds temp1, NextDigit ; Und die betreffende Stelle einschalten
out PORTC, temp1

lds temp, NextSegment
inc temp
lsl temp1 ; beim nächsten Interrupt kommt reihum die
cpi temp1, $10 ; nächste Stelle dran.
brne multi1
ldi temp, 0
ldi temp1, $01

multi1:
sts NextSegment, temp
sts NextDigit, temp1

pop ZH ; die gesicherten Register wiederherstellen
pop ZL
pop temp
out SREG, temp
pop temp1
pop temp
reti
;
;************************************************************************
; 16 Bit-Zahl aus dem Registerpaar temp (=low), temp1 (=high) ausgeben
; die Zahl muss kleiner als 10000 sein, da die Zehntausenderstelle
; nicht berücksichtigt wird.
; Werden mehr als 4 7-Segmentanzeigen eingesetzt, dann muss dies
; natürlich auch hier berücksichtigt werden
;
out_number:
push temp
push temp1

ldi temp2, -1 ; Die Tausenderstelle bestimmen
_out_tausend:
inc temp2
subi temp, low(1000) ; -1000
sbci temp1, high(1000)
brcc _out_tausend

ldi ZL, low(2*Codes) ; fuer diese Ziffer das Codemuster fuer
ldi ZH, high(2*Codes) ; die Anzeige in der Codetabelle nachschlagen
add ZL, temp2

lpm
sts Segment3, r0 ; und dieses Muster im SRAM ablegen
; die OvI Routine sorgt dann duer die Anzeige
ldi temp2, 10

_out_hundert: ; die Hunderterstelle bestimmen
dec temp2
subi temp, low(-100) ; +100
sbci temp1, high(-100)
brcs _out_hundert

ldi ZL, low(2*Codes) ; wieder in der Codetabelle das entsprechende
ldi ZH, high(2*Codes) ; Muster nachschlagen
add ZL, temp2

lpm
sts Segment2, r0 ; und im SRAM hinterlassen

ldi temp2, -1
_out_zehn: ; die Zehnerstelle bestimmen
inc temp2
subi temp, low(10) ; -10
sbci temp1, high(10)
brcc _out_zehn

ldi ZL, low(2*Codes) ; wie gehabt: Die Ziffer in der Codetabelle
ldi ZH, high(2*Codes) ; aufsuchen
add ZL, temp2

lpm
sts Segment1, r0 ; und entsprechend im SRAM ablegen

_out_einer: ; bleiben noch die Einer
subi temp, low(-10) ; +10
sbci temp1, high(-10)

ldi ZL, low(2*Codes) ; ... Codetabelle
ldi ZH, high(2*Codes)
add ZL, temp

lpm
sts Segment0, r0 ; und ans SRAm ausgeben

pop temp1
pop temp

ret
;
;**************************************************************************
;
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp
; die Segmenttreiber initialisieren
ldi temp, $FF
out DDRD, temp
; die Treiber für die einzelnen Stellen
ldi temp, $0F
out DDRC, temp
; initialisieren der Steuerung für die
; Interrupt Routine
ldi temp, 1
sts NextDigit, temp

ldi temp, 0
sts NextSegment, temp

ldi temp, ( 1 << CS01 ) | ( 1 << CS00 )
out TCCR0, temp

ldi temp, 1 << TOIE0
out TIMSK, temp

sei

ldi temp, 0
ldi temp1, 0

loop:
inc temp
brne _loop
inc temp1
_loop:
rcall out_number

cpi temp, low( 4000 )
brne wait
cpi temp1, high( 4000 )
brne wait

ldi temp, 0
ldi temp1, 0

wait: ldi r21, 1
wait0: ldi r22, 0
wait1: ldi r23, 0
wait2: dec r23
brne wait2
dec r22
brne wait1
dec r21
brne wait0

rjmp loop

Codes:
.db 0b11000000, 0b11111001 ; 0: a, b, c, d, e, f
; 1: b, c
.db 0b10100100, 0b10110000 ; 2: a, b, d, e, g
; 3: a, b, c, d, g
.db 0b10011001, 0b10010010 ; 4: b, c, f, g
; 5: a, c, d, f, g
.db 0b10000010, 0b11111000 ; 6: a, c, d, e, f, g
; 7: a, b, c
.db 0b10000000, 0b10010000 ; 8: a, b, c, d, e, f, g
; 9: a, b, c, d, f, g

.DSEG
NextDigit: .byte 1 ; Bitmuster für die Aktivierung des nächsten Segments
NextSegment: .byte 1 ; Nummer des nächsten aktiven Segments
Segment0: .byte 1 ; Ausgabemuster für Segment 0
Segment1: .byte 1 ; Ausgabemuster für Segment 1
Segment2: .byte 1 ; Ausgabemuster für Segment 2
Segment3: .byte 1 ; Ausgabemuster für Segment 3
</avrasm>

{{Navigation_zurückhoch|
zurücktext=SRAM|
zurücklink=AVR-Tutorial: SRAM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: 7-Segment-Anzeige

2009-02-24T13:37:13Z

85.183.44.11: /* Typen von 7-Segment Anzeigen */

Die Ausgabe von Zahlenwerten auf ein Text-LCD ist sicherlich das Nonplusultra, aber manchmal liegen die Dinge sehr viel einfacher. Um beispielsweise eine Temperatur anzuzeigen ist ein LCD etwas Overkill. In solchen Fällen kann die Ausgabe auf ein paar 7-Segmentanzeigen gemacht werden. Ausserdem haben 7-Segmentanzeigen einen ganz besonderen Charme :-)

==Eine einzelne 7-Segment Anzeige==

===Schaltung===

Eine einzelne 7-Segmentanzeige wird nach dem folgenden Schema am '''Port D''' des Mega8 angeschlossen. Port D wurde deshalb gewählt, da er am Mega8 als einziger Port aus den vollen 8 Bit besteht. Die 7-Segmentanzeige hat eine gemeinsame Anode.

[[Bild:Tut_7_Seg_01.gif | framed | left | Ansteuerung einer einzelnen 7-Segmentanzeige]]
 

Welcher Pin an der Anzeige welchem Segment (a-g) bzw. dem Dezimalpunkt entspricht wird am besten dem Datenblatt zur Anzeige entnommen. Im Folgenden wird von dieser Segmentbelegung ausgegangen:

[[Bild:Tut_7_Seg_02.gif | framed | left | Pinbelegung der 7-Segmentanzeige]]
 

Wird eine andere Belegung genutzt dann ist das prinzipiell möglich, jedoch müsste das in der Programmierung berücksichtigt werden.

Da eine 7-Segmentanzeige konzeptionell sieben einzelnen LEDs entspricht, ergibt sich im Prinzip keine Änderung in der Ansteuerung einer derartigen Anzeige im Vergleich zur LED Ansteuerung wie sie im [[AVR-Tutorial: IO-Grundlagen]] gezeigt wird. Genau wie bei den einzelnen LEDs wird eine davon eingeschaltet, indem der zugehörige Port Pin auf 0 gesetzt wird. Aber anders als bei einzelnen LED möchte man mit einer derartigen Anzeige eine Ziffernanzeige erhalten. Dazu ist es lediglich notwendig, für eine bestimmte Ziffer die richtigen LEDs einzuschalten.

===Codetabelle===

Die Umkodierung von einzelnen Ziffern in ein bestimmtes Ausgabemuster bezeichnet man als Codetabelle. Die auszugebende Ziffer wird als Offset zum Anfang dieser Tabelle aufgefasst und aus der Tabelle erhält man ein Byte (Code), welches direkt auf den Port ausgegeben werden kann und das entsprechende Bitmuster enthält, sodass die für diese Ziffer notwendigen LED ein- bzw. ausgeschaltet sind.

Beispiel: Um die Ziffer '''3''' anzuzeigen, müssen auf der Anzeige die Segmente '''a''', '''b''', '''c''', '''d''' und '''g''' aufleuchten. Alle anderen Segmente sollen dunkel sein.

[[Bild:Tut_7_Seg_02a.gif | framed | left | Darstellung der Ziffer "3"]]
 

Aus dem Anschlußschema ergibt sich, dass die dazu notwendige Ausgabe am Port binär '''10110000''' lauten muss. Untersucht man dies für alle Ziffern, so ergibt sich folgende Tabelle:
<avrasm>
.db 0b11000000 ; 0: a, b, c, d, e, f
.db 0b11111001 ; 1: b, c
.db 0b10100100 ; 2: a, b, d, e, g
.db 0b10110000 ; 3: a, b, c, d, g
.db 0b10011001 ; 4: b, c, f, g
.db 0b10010010 ; 5: a, c, d, f, g
.db 0b10000010 ; 6: a, c, d, e, f, g
.db 0b11111000 ; 7: a, b, c
.db 0b10000000 ; 8: a, b, c, d, e, f, g
.db 0b10010000 ; 9: a, b, c, d, f, g
</avrasm>

===Programm===

Das Testprogramm stellt nacheinander die Ziffern 0 bis 9 auf der 7-Segmentanzeige dar. Die jeweils auszugebende Zahl steht im Register '''count''' und wird innerhalb der Schleife um jeweils 1 erhöht. Hat das Register den Wert 10 erreicht, so wird es wieder auf 0 zurückgesetzt. Nach der Erhöhung folgt eine Warteschleife, welche dafür sorgt, dass bis zur nächsten Ausgabe eine gewisse Zeit vergeht. Normalerweise macht man keine derartigen langen Warteschleifen, aber hier geht es ja nicht ums Warten sondern um die Ansteuerung einer 7-Segmentanzeige. Einen Timer dafür zu benutzen wäre zunächst zuviel Aufwand.

Die eigentliche Ausgabe und damit der in diesem Artikel interessante Teil findet jedoch direkt nach dem Label loop statt. Die bereits bekannte Codetabelle wird mittels '''.db''' Direktive ('''d'''efine '''b'''yte) in den [[Speicher#Flash-ROM | Flash-Speicher]] gelegt. Der Zugriff darauf erfolgt über den Z-Pointer und dem Befehl '''lpm'''. Zusätzlich wird vor dem Zugriff noch der Wert des Registers '''count''' und damit der aktuelle Zählerwert zum Z-Pointer addiert.

Beachtet werden muss nur, dass der Zählerwert verdoppelt werden muss. Dies hat folgenden Grund: Wird die Tabelle so wie hier gezeigt mittels einzelnen '''.db''' Anweisungen aufgebaut, so fügt der Assembler sog. '''Padding Bytes''' zwischen die einzelnen Bytes ein, damit jede '''.db''' Anweisung auf einer geraden Speicheradresse liegt. Dies ist eine direkte Folge der Tatsache, dass der Flash-Speicher '''wortweise''' (16 Bit) und nicht '''byteweise''' (8 Bit) organisiert ist. Da aber von einem .db in der Tabelle zum nächsten .db eine Differenz von 2 Bytes vorliegt, muss dies in der Berechnung berücksichtigt werden. Im zweiten Beispiel auf dieser Seite wird dies anders gemacht. Dort wird gezeigt wie man durch eine andere Schreibweise der Tabelle das Erzeugen der Padding Bytes durch den Assembler verhindern kann.

Aus dem gleichen Grund wird auch der Z-Pointer mit dem 2-fachen der Startadresse der Tabelle geladen. Die Startadresse wird vom Assembler in wortweiser Adressierung eingesetzt, '''lpm''' möchte die Zugriffsadresse als Byteadresse angegeben haben.

Interessant ist auch, dass in der Berechnung ein Register benötigt wird, welches den Wert 0 enthält. Dies deshalb, da es im AVR keinen Befehl gibt der eine Konstante mit gleichzeitiger Berücksichtigung des Carry-Bits addieren kann. Daher muss diese Konstante zunächst in ein Register geladen werden und erst dann kann die Addition mithilfe dieses Registers vorgenommen werden. Das Interessante daran ist nun, dass dieser Umstand in sehr vielen Programmen vorkommt und es sich bei der Konstanten in der überwiegenden Mehrzahl der Fälle um die Konstante 0 handelt. Viele Programmierer reservieren daher von vorne herein ein Register für diesen Zweck und nennen es das Zero-Register. Sinnvollerweise legt man dieses Register in den Breich r0..r15, da diese Register etwas zweitklassig sind (ldi, cpi etc. funktionieren nicht damit).

<avrasm>
.include "m8def.inc"

.def zero = r1
.def count = r16
.def temp1 = r17

.org 0x0000
rjmp main ; Reset Handler
;
main:
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1
;
ldi temp1, $FF ; die Anzeige hängt am Port D
out DDRD, temp1 ; alle Pins auf Ausgang
;
ldi count, 0 ; und den Zähler initialisieren
mov zero, count
;
loop:
ldi ZL, LOW(Codes*2) ; die Startadresse der Tabelle in den
ldi ZH, HIGH(Codes*2) ; Z-Pointer laden

mov temp1, count ; die wortweise Adressierung der Tabelle
add temp1, count ; berücksichtigen

add ZL, temp1 ; und ausgehend vom Tabellenanfang
adc ZH, zero ; die Adresse des Code Bytes berechnen

lpm ; dieses Code Byte in das Register r0 laden

out PORTD, r0 ; und an die Anzeige ausgeben
;
inc count ; den Zähler erhöhen, wobei der Zähler
cpi count, 10 ; immer nur von 0 bis 9 zählen soll
brne wait
ldi count, 0
;
wait: ldi r17, 10 ; und etwas warten, damit die Ziffer auf
wait0: ldi r18, 0 ; der Anzeige auch lesbar ist, bevor die
wait1: ldi r19, 0 ; nächste Ziffer gezeigt wird
wait2: dec r19
brne wait2
dec r18
brne wait1
dec r17
brne wait0
;
rjmp loop ; auf zur nächsten Ausgabe
;
Codes: ; Die Codetabelle für die Ziffern 0 bis 9
; sie regelt, welche Segmente für eine bestimmte
; Ziffer eingeschaltet werden müssen
;
.db 0b11000000 ; 0: a, b, c, d, e, f
.db 0b11111001 ; 1: b, c
.db 0b10100100 ; 2: a, b, d, e, g
.db 0b10110000 ; 3: a, b, c, d, g
.db 0b10011001 ; 4: b, c, f, g
.db 0b10010010 ; 5: a, c, d, f, g
.db 0b10000010 ; 6: a, c, d, e, f, g
.db 0b11111000 ; 7: a, b, c
.db 0b10000000 ; 8: a, b, c, d, e, f, g
.db 0b10010000 ; 9: a, b, c, d, f, g

</avrasm>

==Mehrere 7-Segment Anzeigen (Multiplexen)==

Mit dem bisherigen Vorwissen könnte man sich jetzt daran machen, auch einmal drei oder vier Anzeigen mit dem Mega8 anzusteuern. Leider gibt es da ein Problem, denn für eine Anzeige sind acht Portpins notwendig - vier Anzeigen würden demnach 32 Portpins benötigen. Die hat der Mega8 aber nicht. Dafür gibt es aber mehrere Auswege. Schieberegister sind bereits in einem anderen [[AVR-Tutorial:_Schieberegister|Tutorial]] beschrieben. Damit könnte man sich ganz leicht die benötigten 32 Ausgangsleitungen mit nur 3 Portpins erzeugen. Das Prinzip der Ansteuerung unterscheidet sich in nichts von der Ansteurung einer einzelnen 7-Segment Anzeige, lediglich die Art und Weise, wie die 'Ausgangspins' zu ihren Werten kommen ist anders und durch die Verwendung von Schieberegistern vorgegeben. An dieser Stelle soll aber eine andere Variante der Ansteuerung gezeigt werden. Im Folgenden werden wir uns daher das [[Multiplexen]] einmal näher ansehen.

Multiplexen bedeutet, dass nicht alle vier Anzeigen gleichzeitig eingeschaltet sind, sondern immer nur Eine für eine kurze Zeit. Geschieht der Wechsel zwischen den Anzeigen schneller als wir Menschen das wahrnehmen können, so erscheinen uns alle vier Anzeigen gleichzeitig in Betrieb zu sein obwohl immer nur Eine für eine kurze Zeit aufleuchtet. Dabei handelt es sich praktisch um eine [[LED-Matrix]]. Die vier Anzeigen können sich dadurch die einzelnen Segmentleitungen teilen und alles was benötigt wird sind 4 zusätzliche Steuerleitungen für die 4 Anzeigen, mit denen jeweils eine Anzeige eingeschaltet wird. Dieses Ein/Ausschalten wird mit einem pnp-Transistor in der Versorgungsspannung jeder Anzeige realisiert, die vom Mega8 am '''PortC''' angesteuert werden.

Ein Aspekt dieser Ansteuerungsart ist die Multiplexfrequenz. Sie muss hoch genug sein, um ein Flimmern der Anzeige zu vermeiden. Das menschliche Auge ist träge, im Kino reichen 24 Bilder pro Sekunde, beim Fernseher sind es 50. Um auf der sicheren Seite zu sein, dass auch Standbilder ruhig wirken, sollen jedes Segment mit mindestens 100 Hz angesteuert werden, es also mindestens alle 10ms angeschaltet ist. In Ausnahmefällen können aber selbst 100 Hz noch flimmern, z.B. wenn die Anzeige schnell bewegt wird oder wenn es zu Interferenzerscheinungen mit künstlichen Lichtquellen kommt, die mit Wechselstrom betrieben werden.

Bei genauerer Betrachtung fällt auch auf, dass die vier Anzeigen nicht mehr ganz so hell leuchten wie die eine einzelne Anzeige ohne Multiplexen. Bei wenigen Anzeigen ist dies praktisch kaum sichtbar, erst bei mehreren Anzeigen wird es deutlich. Um dem entgegen zu wirken lässt man pro Segment einfach mehr Strom fließen, bei LEDs dürfen dann 20mA überschritten werden. Als Faustregel gilt, dass der n-fache Strom für die (1/n)-fache Zeit fließen darf. Details finden sich im Datenblatt unter dem Punkt '''Peak-Current''' (Spitzenstrom) und '''Duty-Cycle''' ([[PWM | Tastverhältnis]]).

Allerdings gibt es noch ein anderes Problem wenn insgesamt zu viele Anzeigen gemultiplext werden. Die Pulsströme durch die LEDs werden einfach zu hoch. Die meisten LEDs kann man bis 8:1 multiplexen, manchmal auch bis 16:1. Hier fliesst aber schon ein Pulsstrom von 320mA (16 x 20mA), was nicht mehr ganz ungefährlich ist. '''Strom lässt sich durch Multiplexen nicht sparen''', denn die verbrauchte Leistung ändert sich beim n-fachen Strom für 1/n der Zeit nicht. Kritisch wird es aber, wenn das Multiplexen deaktiviert wird (Ausfall der Ansteuerung durch Hardware- oder Softwarefehler) und der n-fache Strom dauerhaft durch eine Segment-LED fließt. Bei 320mA werden die meisten LEDs innerhalb von Sekunden zerstört. Hier muss sichergestellt werden, dass sowohl Programm (Breakpoint im Debugger) als auch Schaltung (Reset, Power-On, [http://www.mikrocontroller.net/topic/107941]) diesen Fall verhindern. Prinzipiell sollte man immer den Pulsstrom und die Multiplexfrequenz einmal überschlagen, bevor der Lötkolben angeworfen wird.

===Schaltung===

[[Bild:Tut_7_Seg_03.gif | framed | left | Ansteuerung von vier 7-Segmentanzeigen per Multiplex]]
 

Sollten die Anzeigen zu schwach leuchten so können, wie bereits beschrieben, die Ströme durch die Anzeigen erhöht werden. Dazu werden die 330 Ohm Widerstände kleiner gemacht. Da hier 4 Anzeigen gemultiplext werden, würden sich Widerstände in der Größenordnung von 100 Ohm anbieten. Auch kann dann der Basiswiderstand der Transistoren verkleinert werden.

===Programm===

Das folgende Programm zeigt eine Möglichkeit zum Multiplexen. Dazu wird ein Timer benutzt, der in regelmässigen Zeitabständen einen Overflow [[Interrupt]] auslöst. Innerhalb der Overflow Interrupt Routine wird
* die momentan erleuchtete Anzeige abgeschaltet
* das Muster für die nächste Anzeige am Port D ausgegeben
* die nächste Anzeige durch eine entsprechende Ausgabe am Port C eingeschaltet

Da Interruptfunktionen kurz sein sollten, holt die Interrupt Routine das auszugebende Muster für jede Stelle direkt aus dem SRAM, wo sie die Ausgabefunktion hinterlassen hat. Dies hat 2 Vorteile:
* Zum einen braucht die Interrupt Routine die Umrechnung einer Ziffer in das entsprechende Bitmuster nicht selbst machen
* Zum anderen ist die Anzeigefunktion dadurch unabhängig von dem was angezeigt wird. Die Interrupt Routine gibt das Bitmuster so aus, wie sie es aus dem SRAM liest. Werden die SRAM Zellen mit geeigneten Bitmustern gefüllt, können so auch einige Buchstaben oder Balkengrafik oder auch kleine Balken-Animationen abgespielt werden. Insbesondere letzteres sieht man manchmal bei Consumer-Geräten kurz nach dem Einschalten des Gerätes um eine Art Defektkontrolle zu ermöglichen oder einfach nur als optischer Aufputz.

Die Funktion out_number ist in einer ähnlichen Form auch schon an anderer Stelle vorgekommen: Sie verwendet die Technik der fortgesetzten Subtraktionen um eine Zahl in einzelne Ziffern zu zerlegen. Sobald jede Stelle feststeht, wird über die Codetabelle das Bitmuster aufgesucht, welches für die Interrupt Funktion an der entsprechenden Stelle im SRAM abgelegt wird.

'''Achtung''': Anders als bei der weiter oben gezeigten Variante wurde die Codetabelle ohne Padding Bytes angelegt. Dadurch ist es auch nicht notwendig derartige Padding Bytes in der Programmierung zu berücksichtigen.

Der Rest ist wieder die übliche Portinitialisierung, Timerinitialisierung und eine einfache Anwendung, indem ein 16 Bit Zähler laufend erhöht und über die Funktion out_number ausgegeben wird. Wie schon im ersten Beispiel, wurde auch hier kein Aufwand getrieben: Zähler um 1 erhöhen und mit Warteschleifen eine gewisse Verzögerungszeit einhalten. In einer realen Applikation wird man das natürlich nicht so machen, sondern ebenfalls einen Timer für diesen Teilaspekt der Aufgabenstellung einsetzen.

Weiterhin ist auch noch interessant. Die Overflow Interrupt Funktion ist wieder so ausgelegt, dass sie völlig transparent zum restlichen Programm ablaufen kann. Dies bedeutet, dass alle verwendeten Register beim Aufruf der Interrupt Funktion gesichert und beim Verlassen wiederhergestellt werden. Dadurch ist man auf der absolut sicheren Seite, hat aber den Nachteil etwas Rechenzeit für manchmal unnötige Sicherungs- und Aufräumarbeiten zu 'verschwenden'. Stehen genug freie Register zur Verfügung, dann wird man natürlich diesen Aufwand nicht treiben, sondern ein paar Register ausschließlich für die Zwecke der Behandlung der 7-Segment Anzeige abstellen und sich damit den Aufwand der Registersicherung sparen (mit Ausnahme von '''SREG''' natürlich!).

<avrasm>
.include "m8def.inc"

.def temp = r16
.def temp1 = r17
.def temp2 = r18

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp multiplex

;
;********************************************************************
; Die Multiplexfunktion
;
; Aufgabe dieser Funktion ist es, bei jedem Durchlauf eine andere Stelle
; der 7-Segmentanzeige zu aktivieren und das dort vorgesehene Muster
; auszugeben
; Die Funktion wird regelmässig in einem Timer Interrupt aufgerufen
;
multiplex:
push temp ; Alle verwendeten Register sichern
push temp1
in temp, SREG
push temp
push ZL
push ZH

ldi temp1, 0 ; Die 7 Segment ausschalten
out PORTC, temp1

; Das Muster für die nächste Stelle ausgeben
; Dazu zunächst mal berechnen, welches Segment als
; nächstest ausgegeben werden muss
ldi ZL, LOW( Segment0 )
ldi ZH, HIGH( Segment0 )
lds temp, NextSegment
add ZL, temp
adc ZH, temp1

ld temp, Z ; das entsprechende Muster holen und ausgeben
out PORTD, temp

lds temp1, NextDigit ; Und die betreffende Stelle einschalten
out PORTC, temp1

lds temp, NextSegment
inc temp
lsl temp1 ; beim nächsten Interrupt kommt reihum die
cpi temp1, $10 ; nächste Stelle dran.
brne multi1
ldi temp, 0
ldi temp1, $01

multi1:
sts NextSegment, temp
sts NextDigit, temp1

pop ZH ; die gesicherten Register wiederherstellen
pop ZL
pop temp
out SREG, temp
pop temp1
pop temp
reti
;
;************************************************************************
; 16 Bit-Zahl aus dem Registerpaar temp (=low), temp1 (=high) ausgeben
; die Zahl muss kleiner als 10000 sein, da die Zehntausenderstelle
; nicht berücksichtigt wird.
; Werden mehr als 4 7-Segmentanzeigen eingesetzt, dann muss dies
; natürlich auch hier berücksichtigt werden
;
out_number:
push temp
push temp1

ldi temp2, -1 ; Die Tausenderstelle bestimmen
_out_tausend:
inc temp2
subi temp, low(1000) ; -1000
sbci temp1, high(1000)
brcc _out_tausend

ldi ZL, low(2*Codes) ; fuer diese Ziffer das Codemuster fuer
ldi ZH, high(2*Codes) ; die Anzeige in der Codetabelle nachschlagen
add ZL, temp2

lpm
sts Segment3, r0 ; und dieses Muster im SRAM ablegen
; die OvI Routine sorgt dann duer die Anzeige
ldi temp2, 10

_out_hundert: ; die Hunderterstelle bestimmen
dec temp2
subi temp, low(-100) ; +100
sbci temp1, high(-100)
brcs _out_hundert

ldi ZL, low(2*Codes) ; wieder in der Codetabelle das entsprechende
ldi ZH, high(2*Codes) ; Muster nachschlagen
add ZL, temp2

lpm
sts Segment2, r0 ; und im SRAM hinterlassen

ldi temp2, -1
_out_zehn: ; die Zehnerstelle bestimmen
inc temp2
subi temp, low(10) ; -10
sbci temp1, high(10)
brcc _out_zehn

ldi ZL, low(2*Codes) ; wie gehabt: Die Ziffer in der Codetabelle
ldi ZH, high(2*Codes) ; aufsuchen
add ZL, temp2

lpm
sts Segment1, r0 ; und entsprechend im SRAM ablegen

_out_einer: ; bleiben noch die Einer
subi temp, low(-10) ; +10
sbci temp1, high(-10)

ldi ZL, low(2*Codes) ; ... Codetabelle
ldi ZH, high(2*Codes)
add ZL, temp

lpm
sts Segment0, r0 ; und ans SRAm ausgeben

pop temp1
pop temp

ret
;
;**************************************************************************
;
main:
ldi temp, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp
; die Segmenttreiber initialisieren
ldi temp, $FF
out DDRD, temp
; die Treiber für die einzelnen Stellen
ldi temp, $0F
out DDRC, temp
; initialisieren der Steuerung für die
; Interrupt Routine
ldi temp, 1
sts NextDigit, temp

ldi temp, 0
sts NextSegment, temp

ldi temp, ( 1 << CS01 ) | ( 1 << CS00 )
out TCCR0, temp

ldi temp, 1 << TOIE0
out TIMSK, temp

sei

ldi temp, 0
ldi temp1, 0

loop:
inc temp
brne _loop
inc temp1
_loop:
rcall out_number

cpi temp, low( 4000 )
brne wait
cpi temp1, high( 4000 )
brne wait

ldi temp, 0
ldi temp1, 0

wait: ldi r21, 1
wait0: ldi r22, 0
wait1: ldi r23, 0
wait2: dec r23
brne wait2
dec r22
brne wait1
dec r21
brne wait0

rjmp loop

Codes:
.db 0b11000000, 0b11111001 ; 0: a, b, c, d, e, f
; 1: b, c
.db 0b10100100, 0b10110000 ; 2: a, b, d, e, g
; 3: a, b, c, d, g
.db 0b10011001, 0b10010010 ; 4: b, c, f, g
; 5: a, c, d, f, g
.db 0b10000010, 0b11111000 ; 6: a, c, d, e, f, g
; 7: a, b, c
.db 0b10000000, 0b10010000 ; 8: a, b, c, d, e, f, g
; 9: a, b, c, d, f, g

.DSEG
NextDigit: .byte 1 ; Bitmuster für die Aktivierung des nächsten Segments
NextSegment: .byte 1 ; Nummer des nächsten aktiven Segments
Segment0: .byte 1 ; Ausgabemuster für Segment 0
Segment1: .byte 1 ; Ausgabemuster für Segment 1
Segment2: .byte 1 ; Ausgabemuster für Segment 2
Segment3: .byte 1 ; Ausgabemuster für Segment 3
</avrasm>

{{Navigation_zurückhoch|
zurücktext=SRAM|
zurücklink=AVR-Tutorial: SRAM|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Vergleiche

2009-02-24T13:36:27Z

85.183.44.11: /* Schleifenkonstrukte */

AVR-Tutorial: Vergleiche

2009-02-24T13:36:10Z

85.183.44.11: /* Flags */

Vergleiche und Entscheidungen sind in jeder Programmiersprache ein zentrales Mittel um den Programmfluss abhängig von Bedingungen zu kontrollieren. In einem [[AVR]] spielen dazu 3 Komponenten zusammen:
* Vergleichsbefehle
* die Flags im Statusregister
* bedingte Sprungbefehle

Der Zusammenhang ist dabei folgender: Die Vergleichsbefehle führen einen Vergleich durch, zum Beispiel zwischen zwei Registern oder zwischen einem Register und einer Konstante. Das Ergebnis des Vergleiches wird in den Flags abgelegt. Die bedingten Sprungbefehle werten die Flags aus und führen bei einem positiven Ergebnis den Sprung aus. Besonders der erste Satzteil ist wichtig! Den bedingten Sprungbefehlen ist es nämlich völlig egal, ob die Flags über Vergleichsbefehle oder über sonstige Befehle gesetzt wurden. Die Sprungbefehle werten einfach nur die Flags aus, wie auch immer diese zu ihrem Zustand kommen.

==Vergleiche==
Um einen Vergleich durchzuführen, wird intern eine Subtraktion der beiden Operanden durchgeführt. Das eigentliche Ergebnis der Subtraktion wird allerdings verworfen, es bleibt nur die neue Belegung der Flags übrig, die in weiterer Folge ausgewertet werden kann

===CP - Compare===
Vergleicht den Inhalt zweier Register miteinander. Prozessorintern wird dabei eine Subtraktion der beiden Register durchgeführt. Das eigentliche Subtraktionsergebnis wird allerdings verworfen, das Subtraktionsergebnis beeinflusst lediglich die Flags.

===CPC - Compare with Carry===
Vergleicht den Inhalt zweier Register, wobei das Carry Flag in den Vergleich mit einbezogen wird. Dieser Befehl wird für Arithmetik mit grossen Variablen (16/32 Bit) benötigt. Siehe [[AVR-Tutorial: Arithmetik]].

==Bedingte Sprünge==

Die bedingten Sprünge werten immer bestimmte Flags im Statusregister '''SREG''' aus. Es spielt dabei keine Rolle, ob dies nach einem Vergleichsbefehl oder einem sonstigen Befehl gemacht wird. Entscheidend ist einzig und alleine der Zustand des abgefragten Flags. Die Namen der Sprungbefehle wurden allerdings so gewählt, daß sich im Befehlsnamen die Beziehung der Operanden direkt nach einem Compare Befehl wiederspiegelt. Zu beachten ist auch, daß die Flags nicht nur durch Vergleichsbefehle verändert werden, sondern auch durch arithmetische Operationen, Schiebebefehle und logische [[Bitmanipulation | Verknüpfungen]]. Da dieses Information wichtig ist, ist auch in der bei Atmel erhältlichen [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Übersicht über alle Assemblerbefehle] bei jedem Befehl angegeben, ob und wie er Flags beeinflusst. Ebenso ist dort eine kompakte Übersicht aller bedingten Sprünge zu finden. Beachten muss man jedoch, dass die bedingten Sprünge maximal 64 Worte weit springen können.

=== Bedingte Sprünge für vorzeichenlose Zahlen ===

====BRSH - Branch if Same or Higher ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand größer oder gleich dem zweiten Operanden ist.

====BRLO - Branch if Lower ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand kleiner dem zweiten Operanden ist.

=== Bedingte Sprünge für vorzeichenbehaftete Zahlen ===

====BRGE - Branch if Greater or Equal ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand größer oder gleich dem ersten Operanden ist.

====BRLT - Branch if Less Than ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand kleiner als der erste Operand ist.

====BRMI - Branch if Minus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' gesetzt ist, das Ergbnis der letzen Operation also negativ war.

====BRPL - Branch if Plus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' nicht gesetzt ist, das Ergbnis der letzen Operation also positiv war (einschiesslich Null).

=== Sonstige bedingte Sprünge ===

====BREQ - Branch if Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' gesetzt ist. Ist nach einem Vergleich das Zero Flag gesetzt, lieferte die interne Subtraktion also 0, so waren beide Operanden gleich.

====BRNE - Branch if Not Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' nicht gesetzt ist. Ist nach einem Vergleich das Zero Flag nicht gesetzt, lieferte die interne Subtraktion also nicht 0, so waren beide Operanden verschieden.

====BRCC - Branch if Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Dieser Befehl wird oft für Arithmetik mit grossen Variablen (16/32 Bit) bzw. im Zusammenhang mit Schiebeoperatioen verwendet.

====BRCS - Branch if Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Die Verwendung ist sehr ähnlich zu BRCC.

=== Selten verwendete bedingte Sprünge ===

====BRHC - Branch if Half Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' nicht gesetzt ist.

====BRHS - Branch if Half Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' gesetzt ist.

====BRID - Branch if Global Interrupt is Disabled (Cleared)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' nicht gesetzt ist.

====BRIS - Branch if Global Interrupt is Enabled (Set)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' gesetzt ist.

====BRTC - Branch if T Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''(T)''' nicht gesetzt ist.

====BRTS - Branch if T Flag is Set====
Der Sprung wird durchgeführt, wenn das '''(T)''' gesetzt ist.

====BRVC - Branch if Overflow Cleared====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' nicht gesetzt ist.

====BRVS - Branch if Overflow Set====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' gesetzt ist.

==Beispiele==

===Schleifenkonstrukte===

Ein immer wiederkehrendes Muster in der Programmierung ist eine '''Schleife'''. Die einfachste Form einer Schleife ist die '''Zählschleife'''. Dabei wird ein Register von einem Startwert ausgehend eine gewisse Anzahl erhöht, bis ein Endwert erreicht wird.

<avrasm>
ldi r17, 10 ; der Startwert sei in diesem Beispiel 10
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

inc r17 ; erhöhe das Zaehlregister
cpi r17, 134 ; mit dem Endwert vergleichen
brne loop ; und wenn der Endwert noch nicht erricht ist
; wird bei der Marke loop ein weiterer Schleifendurchlauf ausgeführt
</avrasm>

Sehr oft ist es auch möglich das Konstrukt umzudrehen. Anstatt von einem Startwert aus zu inkrementieren genügt es die Anzahl der gewünschten Schleifendurchläufe in ein Register zu laden und dieses Register zu dekrementieren. Dabei kann man von der Eigenschaft der Dekrementieranweisung gebrauch machen, das '''Zero Flag (Z)''' zu beeinflussen. Ist das Ergebnis des Dekrements 0, so wird das '''Zero Flag (Z)''' gesetzt, welches wiederum in der nachfolgenden '''BRNE''' Anweisung für einen bedingen Sprung benutzt werden kann. Das vereinfacht die Schleife und spart eine Anweisung sowie einen Takt Ausführungzeit.

<avrasm>
ldi r17, 124 ; Die Anzahl der Wiederholungen in ein Register laden
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

dec r17 ; Schleifenzähler um 1 verringern, dabei wird das Zero Flag beeinflusst
brne loop ; wenn r17 noch nicht 0 geworden ist -> Schleife wiederholen
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Interrupts|
zurücklink=AVR-Tutorial: Interrupts|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Mehrfachverzweigungen|
vorlink=AVR-Tutorial: Mehrfachverzweigung}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Vergleiche

2009-02-24T13:35:54Z

85.183.44.11: /* Entscheidungen */

Vergleiche und Entscheidungen sind in jeder Programmiersprache ein zentrales Mittel um den Programmfluss abhängig von Bedingungen zu kontrollieren. In einem [[AVR]] spielen dazu 3 Komponenten zusammen:
* Vergleichsbefehle
* die Flags im Statusregister
* bedingte Sprungbefehle

Der Zusammenhang ist dabei folgender: Die Vergleichsbefehle führen einen Vergleich durch, zum Beispiel zwischen zwei Registern oder zwischen einem Register und einer Konstante. Das Ergebnis des Vergleiches wird in den Flags abgelegt. Die bedingten Sprungbefehle werten die Flags aus und führen bei einem positiven Ergebnis den Sprung aus. Besonders der erste Satzteil ist wichtig! Den bedingten Sprungbefehlen ist es nämlich völlig egal, ob die Flags über Vergleichsbefehle oder über sonstige Befehle gesetzt wurden. Die Sprungbefehle werten einfach nur die Flags aus, wie auch immer diese zu ihrem Zustand kommen.

==Flags==

Die Flags residieren im Statusregister '''SREG'''. Ihre Aufgabe ist es, das Auftreten bestimmter Ereignisse, die während Berechnungen eintreten können festzuhalten.

+---+---+---+---+---+---+---+---+
| I | T | H | S | V | N | Z | C |
+---+---+---+---+---+---+---+---+

===Carry (C)===
Das Carry Flag zeigt an, ob ein Überlauf oder Unterlauf bei einer 8-Bit Berechnung statt gefunden hat (Addition, Subtraktion). Ebenso ist es ein Zwischenspeicher bei Schiebe- und Rotationsoperationen.

===Zero (Z)===
Das Zero Flag hält fest, ob das Ergebnis der letzten 8-Bit Berechnung 0 war oder nicht.

===Negative (N)===
Spiegelt den Zustand des höchstwertigen Bits der letzten 8-Bit Berechnung wieder. In 2-Komplement Arithmetik bedeutet ein gesetztes 7. Bit eine negative Zahl, daher der Name.

===Overflow (V)===
Dieses Bit wird gesetzt, wenn bei einer Berechnung mit 2-Komplement Arithmetik ein Überlauf (Unterlauf) stattgefunden hat. Dies entspricht einem Überlauf von Bit 6 ins Bit 7

===Signed (S)===
Das Signed Bit ist eine Verknüpfung aus dem N und dem V Flag. Es wird hauptsächlich für 'Signed' Tests benötigt. Daher auch der Name.

===Half Carry (H)===
Das Half Carry Flag hat die gleiche Aufgabe wie das Carry Flag, nur beschäftigt es sich mit einem Überlauf von Bit 3 nach Bit 4. Das Haupteinsatzgebiet ist der Bereich der BCD Arithmetik.

=== Transfer (T)===
Das T-Flag wird von keiner Berechnung gesetzt, sondern steht zur ausschliesslichen Verwendung des Programmierers zur Verfügung. Damit können Bits von einer Stelle schnell an eine andere kopiert oder getestet werden.

===Interrupt (I)===
Das Interrupt Flag hat ebenfalls nichts mit Vergleichen zu tun, sondern steuert ob Interrupts systemweit zugelassen sind (siehe [[AVR-Tutorial: Interrupts]]).

==Vergleiche==
Um einen Vergleich durchzuführen, wird intern eine Subtraktion der beiden Operanden durchgeführt. Das eigentliche Ergebnis der Subtraktion wird allerdings verworfen, es bleibt nur die neue Belegung der Flags übrig, die in weiterer Folge ausgewertet werden kann

===CP - Compare===
Vergleicht den Inhalt zweier Register miteinander. Prozessorintern wird dabei eine Subtraktion der beiden Register durchgeführt. Das eigentliche Subtraktionsergebnis wird allerdings verworfen, das Subtraktionsergebnis beeinflusst lediglich die Flags.

===CPC - Compare with Carry===
Vergleicht den Inhalt zweier Register, wobei das Carry Flag in den Vergleich mit einbezogen wird. Dieser Befehl wird für Arithmetik mit grossen Variablen (16/32 Bit) benötigt. Siehe [[AVR-Tutorial: Arithmetik]].

==Bedingte Sprünge==

Die bedingten Sprünge werten immer bestimmte Flags im Statusregister '''SREG''' aus. Es spielt dabei keine Rolle, ob dies nach einem Vergleichsbefehl oder einem sonstigen Befehl gemacht wird. Entscheidend ist einzig und alleine der Zustand des abgefragten Flags. Die Namen der Sprungbefehle wurden allerdings so gewählt, daß sich im Befehlsnamen die Beziehung der Operanden direkt nach einem Compare Befehl wiederspiegelt. Zu beachten ist auch, daß die Flags nicht nur durch Vergleichsbefehle verändert werden, sondern auch durch arithmetische Operationen, Schiebebefehle und logische [[Bitmanipulation | Verknüpfungen]]. Da dieses Information wichtig ist, ist auch in der bei Atmel erhältlichen [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Übersicht über alle Assemblerbefehle] bei jedem Befehl angegeben, ob und wie er Flags beeinflusst. Ebenso ist dort eine kompakte Übersicht aller bedingten Sprünge zu finden. Beachten muss man jedoch, dass die bedingten Sprünge maximal 64 Worte weit springen können.

=== Bedingte Sprünge für vorzeichenlose Zahlen ===

====BRSH - Branch if Same or Higher ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand größer oder gleich dem zweiten Operanden ist.

====BRLO - Branch if Lower ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand kleiner dem zweiten Operanden ist.

=== Bedingte Sprünge für vorzeichenbehaftete Zahlen ===

====BRGE - Branch if Greater or Equal ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand größer oder gleich dem ersten Operanden ist.

====BRLT - Branch if Less Than ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand kleiner als der erste Operand ist.

====BRMI - Branch if Minus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' gesetzt ist, das Ergbnis der letzen Operation also negativ war.

====BRPL - Branch if Plus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' nicht gesetzt ist, das Ergbnis der letzen Operation also positiv war (einschiesslich Null).

=== Sonstige bedingte Sprünge ===

====BREQ - Branch if Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' gesetzt ist. Ist nach einem Vergleich das Zero Flag gesetzt, lieferte die interne Subtraktion also 0, so waren beide Operanden gleich.

====BRNE - Branch if Not Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' nicht gesetzt ist. Ist nach einem Vergleich das Zero Flag nicht gesetzt, lieferte die interne Subtraktion also nicht 0, so waren beide Operanden verschieden.

====BRCC - Branch if Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Dieser Befehl wird oft für Arithmetik mit grossen Variablen (16/32 Bit) bzw. im Zusammenhang mit Schiebeoperatioen verwendet.

====BRCS - Branch if Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Die Verwendung ist sehr ähnlich zu BRCC.

=== Selten verwendete bedingte Sprünge ===

====BRHC - Branch if Half Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' nicht gesetzt ist.

====BRHS - Branch if Half Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' gesetzt ist.

====BRID - Branch if Global Interrupt is Disabled (Cleared)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' nicht gesetzt ist.

====BRIS - Branch if Global Interrupt is Enabled (Set)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' gesetzt ist.

====BRTC - Branch if T Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''(T)''' nicht gesetzt ist.

====BRTS - Branch if T Flag is Set====
Der Sprung wird durchgeführt, wenn das '''(T)''' gesetzt ist.

====BRVC - Branch if Overflow Cleared====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' nicht gesetzt ist.

====BRVS - Branch if Overflow Set====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' gesetzt ist.

==Beispiele==

===Schleifenkonstrukte===

Ein immer wiederkehrendes Muster in der Programmierung ist eine '''Schleife'''. Die einfachste Form einer Schleife ist die '''Zählschleife'''. Dabei wird ein Register von einem Startwert ausgehend eine gewisse Anzahl erhöht, bis ein Endwert erreicht wird.

<avrasm>
ldi r17, 10 ; der Startwert sei in diesem Beispiel 10
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

inc r17 ; erhöhe das Zaehlregister
cpi r17, 134 ; mit dem Endwert vergleichen
brne loop ; und wenn der Endwert noch nicht erricht ist
; wird bei der Marke loop ein weiterer Schleifendurchlauf ausgeführt
</avrasm>

Sehr oft ist es auch möglich das Konstrukt umzudrehen. Anstatt von einem Startwert aus zu inkrementieren genügt es die Anzahl der gewünschten Schleifendurchläufe in ein Register zu laden und dieses Register zu dekrementieren. Dabei kann man von der Eigenschaft der Dekrementieranweisung gebrauch machen, das '''Zero Flag (Z)''' zu beeinflussen. Ist das Ergebnis des Dekrements 0, so wird das '''Zero Flag (Z)''' gesetzt, welches wiederum in der nachfolgenden '''BRNE''' Anweisung für einen bedingen Sprung benutzt werden kann. Das vereinfacht die Schleife und spart eine Anweisung sowie einen Takt Ausführungzeit.

<avrasm>
ldi r17, 124 ; Die Anzahl der Wiederholungen in ein Register laden
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

dec r17 ; Schleifenzähler um 1 verringern, dabei wird das Zero Flag beeinflusst
brne loop ; wenn r17 noch nicht 0 geworden ist -> Schleife wiederholen
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Interrupts|
zurücklink=AVR-Tutorial: Interrupts|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Mehrfachverzweigungen|
vorlink=AVR-Tutorial: Mehrfachverzweigung}}

[[Category:AVR]][[Category:AVR-Tutorial]]

AVR-Tutorial: Vergleiche

2009-02-24T13:35:36Z

85.183.44.11: /* CPI - Compare Immediate */

Vergleiche und Entscheidungen sind in jeder Programmiersprache ein zentrales Mittel um den Programmfluss abhängig von Bedingungen zu kontrollieren. In einem [[AVR]] spielen dazu 3 Komponenten zusammen:
* Vergleichsbefehle
* die Flags im Statusregister
* bedingte Sprungbefehle

Der Zusammenhang ist dabei folgender: Die Vergleichsbefehle führen einen Vergleich durch, zum Beispiel zwischen zwei Registern oder zwischen einem Register und einer Konstante. Das Ergebnis des Vergleiches wird in den Flags abgelegt. Die bedingten Sprungbefehle werten die Flags aus und führen bei einem positiven Ergebnis den Sprung aus. Besonders der erste Satzteil ist wichtig! Den bedingten Sprungbefehlen ist es nämlich völlig egal, ob die Flags über Vergleichsbefehle oder über sonstige Befehle gesetzt wurden. Die Sprungbefehle werten einfach nur die Flags aus, wie auch immer diese zu ihrem Zustand kommen.

==Flags==

Die Flags residieren im Statusregister '''SREG'''. Ihre Aufgabe ist es, das Auftreten bestimmter Ereignisse, die während Berechnungen eintreten können festzuhalten.

+---+---+---+---+---+---+---+---+
| I | T | H | S | V | N | Z | C |
+---+---+---+---+---+---+---+---+

===Carry (C)===
Das Carry Flag zeigt an, ob ein Überlauf oder Unterlauf bei einer 8-Bit Berechnung statt gefunden hat (Addition, Subtraktion). Ebenso ist es ein Zwischenspeicher bei Schiebe- und Rotationsoperationen.

===Zero (Z)===
Das Zero Flag hält fest, ob das Ergebnis der letzten 8-Bit Berechnung 0 war oder nicht.

===Negative (N)===
Spiegelt den Zustand des höchstwertigen Bits der letzten 8-Bit Berechnung wieder. In 2-Komplement Arithmetik bedeutet ein gesetztes 7. Bit eine negative Zahl, daher der Name.

===Overflow (V)===
Dieses Bit wird gesetzt, wenn bei einer Berechnung mit 2-Komplement Arithmetik ein Überlauf (Unterlauf) stattgefunden hat. Dies entspricht einem Überlauf von Bit 6 ins Bit 7

===Signed (S)===
Das Signed Bit ist eine Verknüpfung aus dem N und dem V Flag. Es wird hauptsächlich für 'Signed' Tests benötigt. Daher auch der Name.

===Half Carry (H)===
Das Half Carry Flag hat die gleiche Aufgabe wie das Carry Flag, nur beschäftigt es sich mit einem Überlauf von Bit 3 nach Bit 4. Das Haupteinsatzgebiet ist der Bereich der BCD Arithmetik.

=== Transfer (T)===
Das T-Flag wird von keiner Berechnung gesetzt, sondern steht zur ausschliesslichen Verwendung des Programmierers zur Verfügung. Damit können Bits von einer Stelle schnell an eine andere kopiert oder getestet werden.

===Interrupt (I)===
Das Interrupt Flag hat ebenfalls nichts mit Vergleichen zu tun, sondern steuert ob Interrupts systemweit zugelassen sind (siehe [[AVR-Tutorial: Interrupts]]).

==Vergleiche==
Um einen Vergleich durchzuführen, wird intern eine Subtraktion der beiden Operanden durchgeführt. Das eigentliche Ergebnis der Subtraktion wird allerdings verworfen, es bleibt nur die neue Belegung der Flags übrig, die in weiterer Folge ausgewertet werden kann

===CP - Compare===
Vergleicht den Inhalt zweier Register miteinander. Prozessorintern wird dabei eine Subtraktion der beiden Register durchgeführt. Das eigentliche Subtraktionsergebnis wird allerdings verworfen, das Subtraktionsergebnis beeinflusst lediglich die Flags.

===CPC - Compare with Carry===
Vergleicht den Inhalt zweier Register, wobei das Carry Flag in den Vergleich mit einbezogen wird. Dieser Befehl wird für Arithmetik mit grossen Variablen (16/32 Bit) benötigt. Siehe [[AVR-Tutorial: Arithmetik]].

==Bedingte Sprünge==

Die bedingten Sprünge werten immer bestimmte Flags im Statusregister '''SREG''' aus. Es spielt dabei keine Rolle, ob dies nach einem Vergleichsbefehl oder einem sonstigen Befehl gemacht wird. Entscheidend ist einzig und alleine der Zustand des abgefragten Flags. Die Namen der Sprungbefehle wurden allerdings so gewählt, daß sich im Befehlsnamen die Beziehung der Operanden direkt nach einem Compare Befehl wiederspiegelt. Zu beachten ist auch, daß die Flags nicht nur durch Vergleichsbefehle verändert werden, sondern auch durch arithmetische Operationen, Schiebebefehle und logische [[Bitmanipulation | Verknüpfungen]]. Da dieses Information wichtig ist, ist auch in der bei Atmel erhältlichen [http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf Übersicht über alle Assemblerbefehle] bei jedem Befehl angegeben, ob und wie er Flags beeinflusst. Ebenso ist dort eine kompakte Übersicht aller bedingten Sprünge zu finden. Beachten muss man jedoch, dass die bedingten Sprünge maximal 64 Worte weit springen können.

=== Bedingte Sprünge für vorzeichenlose Zahlen ===

====BRSH - Branch if Same or Higher ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand größer oder gleich dem zweiten Operanden ist.

====BRLO - Branch if Lower ====

Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann statt, wenn der erste Operand kleiner dem zweiten Operanden ist.

=== Bedingte Sprünge für vorzeichenbehaftete Zahlen ===

====BRGE - Branch if Greater or Equal ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' nicht gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand größer oder gleich dem ersten Operanden ist.

====BRLT - Branch if Less Than ====
Der Sprung wird durchgeführt, wenn das '''Signed Flag (S)''' gesetzt ist. Wird dieser Branch direkt nach einer '''CP''', '''CPI''', '''SUB''' oder '''SUBI''' Operation eingesetzt, so findet der Sprung dann und nur dann statt, wenn der zweite Operand kleiner als der erste Operand ist.

====BRMI - Branch if Minus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' gesetzt ist, das Ergbnis der letzen Operation also negativ war.

====BRPL - Branch if Plus====
Der Sprung wird durchgeführt, wenn das '''Negativ Flag (N)''' nicht gesetzt ist, das Ergbnis der letzen Operation also positiv war (einschiesslich Null).

=== Sonstige bedingte Sprünge ===

====BREQ - Branch if Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' gesetzt ist. Ist nach einem Vergleich das Zero Flag gesetzt, lieferte die interne Subtraktion also 0, so waren beide Operanden gleich.

====BRNE - Branch if Not Equal====
Der Sprung wird durchgeführt, wenn das '''Zero Flag (Z)''' nicht gesetzt ist. Ist nach einem Vergleich das Zero Flag nicht gesetzt, lieferte die interne Subtraktion also nicht 0, so waren beide Operanden verschieden.

====BRCC - Branch if Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' nicht gesetzt ist. Dieser Befehl wird oft für Arithmetik mit grossen Variablen (16/32 Bit) bzw. im Zusammenhang mit Schiebeoperatioen verwendet.

====BRCS - Branch if Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Carry Flag (C)''' gesetzt ist. Die Verwendung ist sehr ähnlich zu BRCC.

=== Selten verwendete bedingte Sprünge ===

====BRHC - Branch if Half Carry Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' nicht gesetzt ist.

====BRHS - Branch if Half Carry Flag is Set====
Der Sprung wird durchgeführt, wenn das '''Half Carry Flag (H)''' gesetzt ist.

====BRID - Branch if Global Interrupt is Disabled (Cleared)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' nicht gesetzt ist.

====BRIS - Branch if Global Interrupt is Enabled (Set)====
Der Sprung wird durchgeführt, wenn das '''Interrupt Flag (I)''' gesetzt ist.

====BRTC - Branch if T Flag is Cleared====
Der Sprung wird durchgeführt, wenn das '''(T)''' nicht gesetzt ist.

====BRTS - Branch if T Flag is Set====
Der Sprung wird durchgeführt, wenn das '''(T)''' gesetzt ist.

====BRVC - Branch if Overflow Cleared====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' nicht gesetzt ist.

====BRVS - Branch if Overflow Set====
Der Sprung wird durchgeführt, wenn das '''Overflow Flag (V)''' gesetzt ist.

==Beispiele==

=== Entscheidungen ===

In jedem Programm kommt früher oder später das Problem, die Ausführung von Codeteilen von irgendwelchen Zahlenwerten, die sich in anderen Registern befinden abhängig zu machen. Sieht beispielweise die Aufgabe vor, daß Register r18 auf 0 gesetzt werden soll, wenn im Register r17 der Zahlenwert 25 enthalten ist, dann lautet der Code

<avrasm>
cpi r17, 25 ; vergleiche r17 mit der Konstante 25
brne nicht_gleich ; wenn nicht gleich, dann mach bei nicht_gleich weiter
ldi r18, 0 ; hier stehen nun Anweisungen für den Fall
; dass R17 gleich 25 ist
rjmp weiter ; meist will man den anderen Zweig nicht durchlaufen, darum der Sprung
nicht_gleich:
ldi r18,123 ; hier stehen nun Anweisungen für den Fall
; dass R17 ungleich 25 ist
weiter: ; hier geht das Programm weiter
</avrasm>

In ähnlicher Weise können die anderen bedingten Sprungbefehle eingesetzt werden, um die üblicherweise vorkommenden Vergleiche auf Gleichheit, Ungleichheit, Größer, Kleiner zu realisieren.

===Schleifenkonstrukte===

Ein immer wiederkehrendes Muster in der Programmierung ist eine '''Schleife'''. Die einfachste Form einer Schleife ist die '''Zählschleife'''. Dabei wird ein Register von einem Startwert ausgehend eine gewisse Anzahl erhöht, bis ein Endwert erreicht wird.

<avrasm>
ldi r17, 10 ; der Startwert sei in diesem Beispiel 10
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

inc r17 ; erhöhe das Zaehlregister
cpi r17, 134 ; mit dem Endwert vergleichen
brne loop ; und wenn der Endwert noch nicht erricht ist
; wird bei der Marke loop ein weiterer Schleifendurchlauf ausgeführt
</avrasm>

Sehr oft ist es auch möglich das Konstrukt umzudrehen. Anstatt von einem Startwert aus zu inkrementieren genügt es die Anzahl der gewünschten Schleifendurchläufe in ein Register zu laden und dieses Register zu dekrementieren. Dabei kann man von der Eigenschaft der Dekrementieranweisung gebrauch machen, das '''Zero Flag (Z)''' zu beeinflussen. Ist das Ergebnis des Dekrements 0, so wird das '''Zero Flag (Z)''' gesetzt, welches wiederum in der nachfolgenden '''BRNE''' Anweisung für einen bedingen Sprung benutzt werden kann. Das vereinfacht die Schleife und spart eine Anweisung sowie einen Takt Ausführungzeit.

<avrasm>
ldi r17, 124 ; Die Anzahl der Wiederholungen in ein Register laden
loop:
; an dieser Stelle stehen die Befehle, welche innerhalb der Schleife
; mehrfach ausgeführt werden sollen

dec r17 ; Schleifenzähler um 1 verringern, dabei wird das Zero Flag beeinflusst
brne loop ; wenn r17 noch nicht 0 geworden ist -> Schleife wiederholen
</avrasm>

{{Navigation_zurückhochvor|
zurücktext=Interrupts|
zurücklink=AVR-Tutorial: Interrupts|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Mehrfachverzweigungen|
vorlink=AVR-Tutorial: Mehrfachverzweigung}}

[[Category:AVR]][[Category:AVR-Tutorial]]