Pfad: Home ==> Mikrobeginner ==> 6. LED mit Interrupt     This page in English (external):

Lektion 6: Eine LED blinkt mit dem Interrupt

6.0 Übersicht

1. Einführung in die Interrupt-Programmierung
2. Hardware, Bauteile, Aufbau
3. Timer mit Overflow-Interrupt
4. Timer mit CTC-Interrupt

6.1 Einführung in die Interrupt-Programmierung

6.1.1 Interrupts

• das Setzen eines Bits in einem festgelegten Port (ein Interrupt ist eingetreten),
• dass der Prozessor die gegenwärtige Ausführungsadresse in einen Speicher ablegt,
• die Ausführung an einer bestimmten, eindeutig festgelegten Adresse im Flashspeicher fortsetzt, und
• das gesetzte Bit im Port wieder löscht (die Interrupt-Ausführung ist erfolgt).

6.1.2 Stackspeicher

Anstelle "RET" wird das angesprungene Programm mit der Instruktion "RETI" beendet, die auch gleich noch das I-Bit im Statusregister auf Eins setzt und die Interruptbearbeitung wieder einschaltet.

6.1.3 Interruptvektoren

Wo springt der Prozessor nun bei einem Interrupt hin? An die ersten Adressen im Flashspeicher. Dort befinden sich die sogenannten Interruptvektoren. Beim ATtiny13 sind das folgende:

#	Adresse	Name	Beschreibung
0	0000	RESET	Wird beim Reset, beim Anlegen der Betriebsspannung, bei Brown-Out und beim Watchdog-Reset angesprungen
1	0001	INT0	Signalflanke am Eingang INT0
2	0002	PCINT0	Signalflanke an einem Eingang
3	0003	TIM0_OVF	Timer 0 Überlauf
4	0004	EE_RDY	Schreibzyklus beim EEPROM abgeschlossen
5	0005	ANA_COMP	Polaritätswechsel am Analogvergleicher
6	0006	TIM0_COMPA	Timer 0 Vergleicher A
7	0007	TIM0_COMPB	Timer 0 Vergleicher B
8	0008	WDT	Watchdog-Ereignis
9	0009	ADC	AD-Wandlung beendet

Die ersten 10 Programmworte in jedem interruptgesteuerten Programm sehen daher so aus:

.CSEG ; Assemblieren in den Flashspeicher (Code Segment)
.ORG 0 ; Adresse auf Null (Reset- und Interruptvektoren beginnen bei Null)
	rjmp Start ; Reset Vektor, Sprung zur Initiierung
	reti ; INT0-Int, nicht aktiv
	reti ; PCINT-Int, nicht aktiv
	reti ; TIM0_OVF, nicht aktiv
	reti ; EE_RDY-Int, nicht aktiv
	reti ; ANA_COMP-Int, nicht aktiv
	reti ; TIM0_COMPA-Int, nicht aktiv
	reti ; TIM0_COMPB-Int, nicht aktiv
	reti ; WDT-Int, nicht aktiv
	reti ; ADC-Int, nicht aktiv
;
; Programmstart beim Reset
;
Start:
	; [Hier beginnt das Programm]

Das "RETI" bei allen nicht verwendeten Vektoren stellt sicher, dass bei einem versehentlich aktivierten Interrupt ein geordneter Rückweg ausgeführt wird.

Hier hat sich bei vielen Programmierern eine Unart entwickelt. Sie setzen die gewünschte Adresse eines verwendeten Vektors mit der Assembler-Direktive „.ORG Vektoradresse“. Daraus macht der Assembler in Verbindung mit dem Programmiergerät dann eine Vektortabelle, die mit lauter NOP-Instruktionen (mit unprogrammierten FFFF) durchsetzt ist. Für die hintersten Vektoren gibt es gar keine Entsprechung, da steht dann schon weiterer Programmcode oder irgendeine andere Interrupt-Service-Routine. Hat man dann einen Interrupt zugelassen, aber vergessen, den Interrupt mit einem Vektor zu versehen, dann wird statt Nichtausführung des fehlenden Vektors (dort stünde bei ordentlichem Programmieren noch ein RETI herum) nach einigen NOP's der nächste programmierte Vektor oder eben das, was auf die Vektortabelle folgt, ausgeführt. Fehlt diesem Code ein RETI, werden fürderhin einfach alle Interrupts blockiert. Das gibt lustige Folgefehler, die zu finden und zu beseitigen einen ziemlichen Aufwand verursachen kann. So kann man sich selbst lustige Beine stellen und das Leben erschweren, ohne groß nachzudenken.

6.1.4 Der Timerüberlauf-Interrupt

Um diesen Interrupt zu nutzen, reicht es aus, das Overflow-Interrupt-Enable-Flag TOIE0 im Timer Interrupt Mask Register TIMSK0 zu setzen, z. B. mit "ldi R16 1<<TOIE0" und "out TIMSK0 R16".

Damit der Interrupt angenommen wird, muss natürlich das I-Flag im Statusregister auf 1 gesetzt werden. Damit etwas passiert, muss natürlich noch eine Interrupt-Service-Routine her. Dazu muss in der Interruptvektortabelle in der Zeile mit dem Overflow-Int ein "rjmp ovflw_isr" hin und die Interrupt-Service-Routine ovflw_isr ist zu schreiben. Die kann z. B. zwischen die Vektortabelle und die Start-Routine. So eine typische Routine ist hier dargestellt:

ovflw_isr:
	in R15,SREG ; Statusregister in Register sichern
	dec R17 ; ein Register abwärts zählen
	brne ovflw_isr1 ; springe wenn noch nicht Null
	sbr R18,0b00000001 ; setze Bit 0 im Register R18
	ldi R17,10 ; zaehle ab 10 abwärts
ovflw_isr1:
	out SREG,R15 ; Statusregister wiederherstellen
	reti ; Rückkehr vom Interrupt, I-Flagge setzen

Typisch ist, dass zu Beginn das Statusregister gerettet werden muss. Da viele Instruktionen der Service-Routine die dortigen Flaggen beeinflussen (z. B. die Null-Flagge Z oder die Überlaufflagge C) können, muss dessen Originalzustand zu Beginn gesichert und am Ende wieder hergestellt werden. Schließlich kann die Routine jederzeit zuschlagen, auch wenn woanders mit diesen Flaggen gerade gearbeitet wird. Einhaltung dieser Grundregel "Sichern/Wiederherstellen von SREG in ISRs" ist daher reiner Selbstschutz.

6.1.5 Der Compare-Match-Interrupt

Setzt man eine oder beide Compare-Match-Flaggen OCIE0A oder OCIE0B, dann wird im Anschluss an jede Übereinstimmung mit dem Vergleichswert ein Interrupt ausgelöst. Bei einem Timer im CTC-Modus mit Compare-A tritt nach jedem Rücksetzen des Timers ein Interrupt auf, der zum Vektor TIM0_COMPA führt. Entsprechendes gilt für den Vergleicher B. Selbiges gilt für den PWM-Mode.

6.1.6 Interrupts und Schlafmodus

Im Schlafmodus Idle, den wir bereits verwendet haben, wecken alle Interrupts den Prozessor wieder auf. Damit dieser wieder schlafen gelegt werden kann, muss er in einer Schleife wieder die Instruktion "SLEEP" kriegen. Vor dem Schlafenlegen kann noch geprüft werden, ob eine Interrupt-Service-Routine noch eine Flagge hinterlassen hat, irgendetwas zu tun. Dann wird das eben jetzt erledigt, die Flagge wieder gelöscht und dann erst schlafen gelegt.

Home	Top	Einführung	Hardware	Overflow-Int	CTC-Int

6.2 Hardware, Bauteile und Aufbau

6.3 Timer mit Overflow-Interrupt

6.3.1 Aufgabenstellung

• Die LED blinkt im Sekundentakt.
• Bei jeder fünften Sekunde setzt das Blinken aus, die LED bleibt für eine Sekunde dunkel.
• Als weiteres Gimmick soll am Portpin PB1/OC0B eine weitere LED ihre Helligkeit sanft ändern.

6.3.2 Lösungsschritte

6.3.3 Programm

;
; ***************************************
; * Timer mit Overflow-Interrupt        *
; * (C)2016 by www.gsc-elektronik.net   *
; ***************************************
;
.NOLIST
.INCLUDE "tn13def.inc"
.LIST
;
; ---------- Register -------------------
; frei: R0 .. R14
.def rSreg = R15 ; SREG-Zwischenspeicher
.def rmp = R16 ; Vielzweckregister
.def rimp = R17 ; Vielzweckregister Interrupts
.def rFlag = R18 ; Flaggenregister
	.equ bPol = 0 ; Flagge Polaritaetswechsel
.def rZaehl= R19 ; Blinkzaehler
.def rPwm = R20 ; PWM-Zaehler
; frei: R20 .. R23
.def rCntL = R24 ; Zaehler, LSB
.def rCntH = R25 ; dto., MSB
;frei: R26 .. R31
;
; ---------- Ports, Portbits ------------
.equ pLedOut = PORTB ; LED-Ausgabeport
.equ bLedOut = PORTB0
.equ pLedDdr = DDRB ; LED-Richtungsport
.equ bLedDdr = DDB0
.equ pLedIn  = PINB ; LED-Eingabeport
.equ bLedIn  = PINB0
;
.equ bPwmOut = PORTB1 ; Ausgabeport PWM
.equ bPwmDdr = DDB1 ; Richtungsport PWM
;
; ---------- Timing ---------------------
.equ cClock  = 1200000 ; Takt
.equ cPolwechsel = 2 ; Taktfrequenz Led An/Aus
.equ cPresc  = 1 ; Vorteiler Timer
.equ cCount  = cClock / 256 / cPresc / cPolwechsel + 1
.equ cBlink  = 5 ; Blinkzaehler
;
; ---------- Reset- und Interrupt-Vektoren -------
.CSEG ; Programmcode
.ORG 0 ; Reset- und Vektorenadresse
	rjmp Start ; Reset Vektor, Sprung zur Initiierung
	reti ; INT0-Int, nicht aktiv
	reti ; PCINT-Int, nicht aktiv
	rjmp Tc0IsrO ; TIM0_OVF, aktiv
	reti ; EE_RDY-Int, nicht aktiv
	reti ; ANA_COMP-Int, nicht aktiv
	reti ; TIM0_COMPA-Int, nicht aktiv
	reti ; TIM0_COMPB-Int, nicht aktiv
	reti ; WDT-Int, nicht aktiv
	reti ; ADC-Int, nicht aktiv
;
; ---------- Interrupt-Service-Routinen ----------
; Timer 0 Overflow:
;   Der Timer laeuft mit einem Vorteiler von 1 und
;   ruft bei jedem Ueberlauf von 255 auf 0 diese
;   Interrupt-Service-Routine auf (256 / 1.200.000 =
;   213 µs, Frequenz = 1.200.000 / 256 = 4,6875
;   kHz).
;   In dieser wird der 16-Bit-Zaehler rCntH:rCntL,
;   der zu Beginn und beim Erreichen von Null auf
;   1.200.000 / 256 / 2 = 2.343 gesetzt wird, um
;   eins vermindert. Ist der Zaehler gleich Null,
;   wird die Flagge rPol im Flaggenregister rFlag
;   gesetzt und der Zaehler neu gestartet. Das ist
;   alle 2.343 * 256 / 1.200.000 = 0,499984 s der
;   Fall.
;   Ausserdem wird das LSB des Zaehlers daraufhin
;   ueberprueft, ob die unteren fuenf Bits Null
;   sind (ist alle 32 Timer-Interrupt-Takte =
;   213 us * 32 = 68,3 ms der Fall). Wenn das der
;   Fall ist, wird der Vergleichswert B (rPwm) um
;   Eins vermindert und die Helligkeit der LED
;   nimmt zu (kürzere Einsphase mit LED aus 
;   ist längere Nullphase der LED mit LED an).
;   War das 256 mal der Fall (= 68,3 ms * 256 =
;   17,5 s) startet der Helligkeitswert wieder mit
;   höchster Helligkeit (1 Timer-Takt lang
;   LED aus, 255 Timer-Takte lang LED an).
;
Tc0IsrO: ; Timer 0 Overflow ISR
	in rSreg,SREG ; Statusregister sichern
	sbiw rCntL,1 ; Zaehler um Eins verringern
	brne Tc0IsrO1 ; springe wenn nicht Null
	sbr rFlag,1<<bPol ; Flagge Polaritaetswechsel setzen
	ldi rCntH,HIGH(cCount) ; Zaehler neu starten
	ldi rCntL,LOW(cCount)
Tc0IsrO1:
	mov rimp,rCntL ; Low Byte Zaehler kopieren
	andi rimp,0b00011111 ; die unteren fuenf Bit isolieren
	brne Tc0IsrO2 ; springe wenn nicht Null
	dec rPwm ; PWM-Wert abwaerts
	out OCR0B,rPwm ; in Vergleichsregister B
Tc0IsrO2:
	out SREG,rSreg ; Statusregister wieder herstellen
	reti ; Ende ISR, I-Bit setzen
;
; ---------- Initiieren und Programmschleife -----
Start:
	; Stapel initiieren
	ldi rmp,LOW(RAMEND) ; Stapelzeiger auf SRAM-Ende
	out SPL,rmp ; Stapelzeiger setzen
	; LED-Ausgang aktivieren
	ldi rmp,(1<<bLedDdr)|(1<<bPwmDdr) ; LED-Ausgaenge an, Treiber an
	out pLedDdr,rmp ; in Port-Richtungsregister
	; Zaehler initiieren
	ldi rZaehl,cBlink ; Blinkzaehler initiieren
	ldi rCntH,HIGH(cCount) ; Zaehler auf Startwert
	ldi rCntL,LOW(cCount)
	; Vergleichsregister initiieren
	ldi rmp,0xFF ; Compare A auf 255
	out OCR0A,rmp ; in Vergleichsregister A
	clr rPwm ; Startwert PWM
	out OCR0B,rPwm ; in Vergleichsregister B
	; Zaehler 0 als starten mit Overflow-Interrupt
	ldi rmp,(1<<COM0B1)|(1<<WGM01)|(1<<WGM00) ; Fast PWM, COM0B
	out TCCR0A,rmp ; in Timer Kontrollregister A
	ldi rmp,1<<CS00 ; Vorteiler durch 1
	out TCCR0B,rmp ; in Timer Kontrollregister B
	ldi rmp,1<<TOIE0 ; Overflow-Interrupt
	out TIMSK0,rmp ; in Timer-Interrupt-Maske
	; Schlafmodus
	ldi rmp,1<<SE ; Sleep-Enable, Mode Idle
	out MCUCR,rmp ; in Universal-Kontrollregister
	; Interrupts ermoeglichen
	sei ; setze Interrupt-Flagge im Statusregister
; Programmschleife
Schleife:
	sleep ; schlafen legen
	nop ; nach Aufwachen
	sbrc rFlag,bPol ; ueberspringe naechste Instruktion wenn Flagge Null
	rcall Polaritaet ; Flagge bearbeiten: Polaritaetswechsel
	rjmp Schleife ; wieder schlafen legen
;
; --------- Polaritaet der LED wechseln ----------
Polaritaet:
	cbr rFlag,1<<bPol ; Flagge loeschen
	sbis pLedOut,bLedOut ; ueberspringe naechste Instruktion wenn Led An
	rjmp Polaritaet3 ;  Led ist an, springe zu LED aus
	; Led ist Aus
	cpi rZaehl,0 ; ist Blinkzaehler Null?
	breq Polaritaet1 ; ja, ist Null, starte Zaehler neu
	; Led Aus, Zaehler nicht Null
	dec rZaehl ; nein, vermindere Blinkzaehler
	brne Polaritaet2 ; Led einschalten
	ret ; kein Polaritaetswechsel
Polaritaet1: ; Neustart Zaehler
	ldi rZaehl,cBlink ; starte Zaehler neu
	ret ; kein Polaritaetswechsel
Polaritaet2: ; Led einschalten
	cbi pLedOut,bLedOut ; Led an
	ret
Polaritaet3: ; Led ausschalten
	sbi pLedOut,bLedOut ; Led aus
	ret
;
; Ende Quellcode
;

• IN Register,Port: liest alle acht Bits in einem Rutsch von einem Port in ein Register,
• SBR Register,Bitmaske: setzt alle Bits in einem Register, die in der Maske Eins sind, geht nur mit R16 und höher,
• CBR Register,Bitmaske: löscht alle Bits in einem Register, die in der Maske Eins sind, geht nur mit R16 und höher,
• ANDI Register,Maske: löscht alle Bits im Register, die in der Maske Null sind, geht nur mit R16 und höher,
• CPI Register,Konstante: vergleicht die Konstante (zieht sie ab, speichert aber das Ergebnis nicht) mit dem Register und setzt die Flaggen im Statusregister, geht nur mit R16 und höher,
• BREQ Label: springt zur Adresse Label, wenn die Z-Flagge gesetzt ist,
• SBRC Register,Bit: ü,berspringt die nächste Instruktion, wenn das Bit im Register Null ist, geht nur mit R16 und höher,
• SBRS Register,Bit: ü,berspringt die nächste Instruktion, wenn das Bit im Register Eins ist, geht nur mit R16 und höher,
• SBIS Port,Bit: überspringt die nächste Instruktion, wenn das Bit im Port Eins ist, geht nur mit den Ports bis 31,
• SBIC Port,Bit: überspringt die nächste Instruktion, wenn das Bit im Port Null ist, geht nur mit den Ports bis 31,

6.3.4 Das Ergebnis

6.3.5 Programmgliederung

0. Registerdefinitionen, Portfestlegungen und Konstanten zu Beginn,
1. Reset- und Interruptvektoren,
2. Interrupt-Service-Routinen,
3. Hauptprogramm-Init mit Hardwarekonfiguration und Startwerten,
4. Schleifenbearbeitung, und
5. Bearbeitungsroutinen außerhalb von Interrupt-Service-Routinen

6.3.6 Simulation der Vorgänge

• Controllertakt: 1.2 MHz
• TC0-Vorteiler: 1
• TC0 TOP-Wert: 255
• Überlauf-Interrupt nach 256 / 1,200,000: 213 µs
• 16-Bit Abwärtszähler: 2.344
• Polaritätswechsel alle 2,344 * 213 µs: 500 ms
• Polaritätswechselfrequenz = 2 * 500 ms: 1 Sekunde

• Der 16-Bit-Zähler in R25:R24 hat Null erreicht.
• Das Flaggenbit bPol in R18 ist gesetzt und wird das Ausführen der Polaritätswechselroutine nach dem SLEEP auslöen,
• Ungefähr 500 ms sind abgelaufen.

6.3.7 Vor- und Nachteile

6.4 Timer mit CTC-Interrupt

6.4.1 CTC-Auswahl

6.4.2 Programm

;
; ***************************************
; * Timer mit COMP-A-Interrupt          *
; * (C)2016 by www.gsc-elektronik.net   *
; ***************************************
;
.NOLIST
.INCLUDE "tn13def.inc"
.LIST
;
; ---------- Register -------------------
; frei: R0 .. R14
.def rSreg = R15 ; SREG-Zwischenspeicher
.def rmp = R16 ; Vielzweckregister
.def rimp = R17 ; Vielzweckregister bei Interrupts
.def rFlag = R18 ; Flaggenregister
	.equ bPol = 0 ; Flagge Polaritaetswechsel
.def rZaehl= R19 ; Blinkzaehler
.def rCtcInt = R20 ; CTC-Interrupt-Zaehler
.def rPwm = R21 ; PWM-Zaehler
; frei: R22 .. R31
;
; ---------- Ports, Portbits ------------
.equ pLedOut = PORTB ; LED-Ausgabeport
.equ bLedOut = PORTB0
.equ pLedDdr = DDRB ; LED-Richtungsport
.equ bLedDdr = DDB0
.equ pLedIn  = PINB ; LED-Eingabeport
.equ bLedIn  = PINB0
;
.equ bPwmOut = PORTB1 ; zweite LED im PwmMode
.equ bPwmDdr = DDB1
;
; ---------- Timing ---------------------
.equ cClock  = 1200000 ; Takt
.equ cPolwechsel = 2 ; Taktfrequenz Led An/Aus
.equ cPresc  = 64 ; Vorteiler Timer
.equ cCtcInt = 125 - 1 ; CTC-Int-Zaehler
.equ cCtcCnt = cClock / cPresc / cPolwechsel / (cCtcInt +1)
.equ cBlink  = 5 ; Blinkzaehler
;
; ---------- Reset- und Interrupt-Vektoren -------
.CSEG ; Programmcode
.ORG 0 ; Reset- und Vektorenadresse
	rjmp Start ; Reset Vektor, Sprung zur Initiierung
	reti ; INT0-Int, nicht aktiv
	reti ; PCINT-Int, nicht aktiv
	reti ; TIM0_OVF, nicht aktiv
	reti ; EE_RDY-Int, nicht aktiv
	reti ; ANA_COMP-Int, nicht aktiv
	rjmp Tc0IsrA ; TIM0_COMPA-Int, nicht aktiv
	reti ; TIM0_COMPB-Int, nicht aktiv
	reti ; WDT-Int, nicht aktiv
	reti ; ADC-Int, nicht aktiv
;
; ---------- Interrupt-Service-Routinen ----------
Tc0IsrA: ; Timer 0 Compare A Interrupt
	in rSreg,SREG ; Statusregister sichern
	dec rPwm ; PWM-Zaehler erniedrigen
	brne Tc0IsrA1 ; springen wenn nicht Null
	ldi rPwm,cCtcInt ; Neustart PWM-Zaehler
Tc0IsrA1:
	out OCR0B,rPwm ; PWM aktualisieren
	dec rCtcInt ; Zaehler um Eins verringern
	brne Tc0IsrA2 ; springe wenn nicht Null
	sbr rFlag,1<<bPol ; Flagge Polaritaetswechsel setzen
	ldi rCtcInt,cCtcCnt ; Zaehler neu starten
Tc0IsrA2:
	out SREG,rSreg ; Statusregister wieder herstellen
	reti ; Ende ISR, I-Bit setzen
;
; ---------- Initiieren und Programmschleife -----
Start:
	; Stapel initiieren
	ldi rmp,LOW(RAMEND) ; Stapelzeiger auf SRAM-Ende
	out SPL,rmp ; Stapelzeiger setzen
	; LED-Ausgang aktivieren
	ldi rmp,(1<<bPwmDdr)|(1<<bLedDdr) ; LED-Ausgaenge, Treiber an
	out pLedDdr,rmp ; in Richtungsregister
	; Zaehler initiieren
	ldi rZaehl,cBlink ; Blinkzaehler initiieren
	ldi rCtcInt,cCtcCnt ; Zaehlerstartwert
	ldi rPwm,cCtcInt ; PWM initiieren
	; Compare A-Wert fuer CTC setzen
	ldi rmp,cCtcInt ; CTC-Teiler durch 125
	out OCR0A,rmp ; in Vergleicher A
	; Zaehler 0 normal starten mit Overflow-Interrupt
	ldi rmp,(1<<COM0B1)|(1<<WGM01)|(1<<WGM00) ; PWM am Port OC0B, Fast PWM
	out TCCR0A,rmp ; in Timer Kontrollregister A
	ldi rmp,(1<<WGM02)|(1<<CS01)|(1<<CS00) ; Fast PWM, Vorteiler durch 64
	out TCCR0B,rmp ; in Timer Kontrollregister B
	ldi rmp,1<<OCIE0A ; Compare A-Interrupt
	out TIMSK0,rmp ; in Timer-Interrupt-Maske
	; Schlafmodus
	ldi rmp,1<<SE ; Sleep-Enable, Mode Idle
	out MCUCR,rmp ; in Universal-Kontrollregister
	; Interrupts ermoeglichen
	sei ; setze Interrupt-Flagge im Statusregister
; Programmschleife
Schleife:
	sleep ; schlafen legen
	nop ; nach Aufwachen
	sbrc rFlag,bPol ; ueberspringe naechste Instruktion wenn Flagge Null
	rcall Polaritaet ; Flagge bearbeiten: Polaritaetswechsel
	rjmp Schleife ; wieder schlafen legen
;
; --------- Polaritaet der LED wechseln ----------
Polaritaet:
	cbr rFlag,1<<bPol ; Flagge loeschen
	sbis pLedOut,bLedOut ; ueberspringe naechste Instruktion wenn Led An
	rjmp Polaritaet3 ;  Led ist an, springe zu LED aus
	; Led ist Aus
	cpi rZaehl,0 ; ist Blinkzaehler Null?
	breq Polaritaet1 ; ja, ist Null, starte Zaehler neu
	; Led Aus, Zaehler nicht Null
	dec rZaehl ; nein, vermindere Blinkzaehler
	brne Polaritaet2 ; Led einschalten
	ret ; kein Polaritaetswechsel
Polaritaet1: ; Neustart Zaehler
	ldi rZaehl,cBlink ; starte Zaehler neu
	ret ; kein Polaritaetswechsel
Polaritaet2: ; Led einschalten
	cbi pLedOut,bLedOut ; Led an
	ret
Polaritaet3: ; Led ausschalten
	sbi pLedOut,bLedOut ; Led aus
	ret
;
; Ende Quellcode
;

6.4.3 Simulation