Twee output-compares op dezelfde uitgang

Een andere opzet waarbij de duty-cycle binnen ruimere grenzen gekozen kan worden, is gegeven in het volgende voorbeeld. Hier worden zowel output-compare 1 als output-compare 2 gebruikt om PA6 aan te passen. Output-compare 1 wordt gebruikt om de periodetijd van het uitgangs signaal te bepalen. Iedere keer als output-compare 1 afloopt, wordt de uitgang een '1' gemaakt. In de interrupt routine voor output-compare 1 wordt output-compare 2 geactiveerd en ingesteld om na bepaalde tijd de uitgang weer een '0' te maken. Output-compare 2 kan dit volledig zelfstandig, zonder dat hiervoor een interrupt routine moet worden aangeroepen. Hierdoor is het mogelijk de duty-cycle van het signaal bijna 100% te maken. Bij een periodetijd van 2000 counts kan output-compare 2 bijvoorbeeld worden geladen met 1999, wat een duty-cycle van 1999 / 2000 = 99.95% mogelijk maakt.

Het programma genereert een duty-cycle gemoduleerd signaal op uitgang PA6. Wanneer U dit signaal wilt meten, denk er dan aan dat het een ongebufferd signaal is.

*************************************************
* definiëren van de geheugen map
*************************************************
		incl "map512.asm"

*************************************************
* start van het programma
*************************************************
PROGRAM		space		|kies het programma-gebied

reset		equ $		|na reset begint de micro op deze plaats
		lds #stackend	|begin met de stackpointer te laden

		ldx #databeg	|en zet dan het volledige datagebied op 00
clearram	clr 0,x
		inx
		cpx #dataend
		bls clearram

		ldx #regsbeg	|laat IX op de bank met I/O registers wijzen

*************************************************
* output compare interrupts
*************************************************
PROGRAM		space
oc1start	equ $		|het beginadres van deze module
oc1time		equ 2000	|het aantal klokperioden per interrupt
				|een klokperiode duurt 0.5 micro-seconden
oc2time		equ 500		|het actieve deel van het signaal

* initialisatie van de output-compare interrupt
* output compare 1 zorgt voor de tijdbasis
* output compare 2 zorgt voor de realisatie van de duty-cycle
* op PA6 onstaat zodoende een duty-cycle signaal
PROGRAM		space

		ldx #regsbeg	|IX wijst naar de I/O registers
* output compare 1 maakt het signaal een '1'
		bset oc1m+regsbeg,x,oc1m6
				|laat output compare op PA6 werken
		bset oc1d+regsbeg,x,oc1d6
				|begin met de output een '1' te maken
* output compare 2 maakt het signaal een '0'
		bset tctl1+regsbeg,x,om2

		ldd tcnt	|haal de systeemtijd
		addd #oc1time	|en zet deze 'oc1time' verder voor de eerste
		std toc1	|interrupt, clear dan een eventuele interrupt
		ldab #oc1f
		stab tflg1	|en enable de interrupts van output-compare 1
		bset tmsk1+regsbeg,x,oc1i
		bra oc1end	|einde van de initialisatie

* subroutine voor de afhandeling van de output-compare interrupt
PROGRAM		space

oc1intentry	equ $
		ldab #(oc1f or oc2f)
		stab tflg1	|reset de interrupt-vlaggen
		ldd toc1	|haal de tijd op het moment van de interrupt
		pshb		|en bewaar deze tijd op de stack
		psha
		addd #oc1time	|tel hierbij de periodetijd van het signaal op
		std toc1	|zodat aan het eind van de periode weer een
				|interrupt komt
		pula		|haal het begintijdstip van deze periode terug
		pulb		|en tel er de tijd dat het signaal een '1'
		addd #oc2time	|moet zijn bij op. zet het resultaat in toc2
		std toc2	|zodat oc2 het signaal op tijd weer '0' maakt
		rti

oc1end		equ $		|einde van de output?compare interrupt module

*************************************************
* het hoofdprogramma
*************************************************
PROGRAM		space

		cli		|laat de interrupts door

main0		bra main0	|en wacht oneindig

		end

Ofschoon dit programma het wel mogelijk maakt de duty-cycle tot nagenoeg 100% in te stellen, is een duty-cycle van 0% niet haalbaar. Wanneer het voor de toepassing nodig is dat een duty-cycle van bijna 0% wel haalbaar is, kan de functie van de output-compares verwisseld worden. U laat output-compare 1 dan het signaal een '0' maken, en output-compare 2 maakt dan na verloop van tijd het signaal een '1'. U kunt dan een duty-cycle van nagenoeg 0% realiseren, terwijl een duty-cycle van 100% in dit geval weer slecht haalbaar is.
U kunt natuurlijk een bijzonder slim programma schrijven, dat afhankelijk van de verlangde duty-cycle, de éne of de andere methode kiest.