Voorbeeld programma voor A/D conversie

Evenals in eerdere voorbeelden wordt hier de seriële poort gebruikt om gegevens vanaf de SIMPLEX naar de PC te sturen. In dit voorbeeld wordt een analoge ingang geconverteerd naar een digitale waarde, en vervolgens wordt het resultaat omgezet in twee hexadecimale ASCII tekens. Deze worden vervolgens naar de PC gestuurd.

Ook in dit voorbeeld kunt U het 'hyperterminal' programma gebruiken om de PC met de SIMPLEX te laten communiceren. Of u gebruikt het ingebouwde terminal scherm in de programmer software.

De A/D converter

De Analoog naar Digitaal converter in de micro-controller is een apart sub-systeem, dat afgezet kan worden indien het niet gebruikt wordt. De converter gebruikt dan ook geen stroom. In dit voorbeeld moet de converter natuurlijk aan staan. Hiervoor moet het ADPU bit in het OPTION register een '1' gemaakt worden. Vanaf dat moment staat de A/D converter aan.

De A/D converter kan op verschillende manieren gebruikt worden. Zo is het mogelijk slechts éénmaal één kanaal te converteren, of éénmaal een set van 4 kanalen te converteren, of continue één kanaal te converteren, of continue een set van 4 kanalen te converteren. In dit voorbeeld wordt de converter zodanig ingesteld, dat kanaal 0 t/m kanaal 3 (op PE0 t/m PE3) continue geconverteerd worden. De geconverteerde waarden zijn beschikbaar in de 4 registers ADR1, ADR2, ADR3 en ADR4.

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

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

reset		equ $		|na reset begint de micro op deze plaats

		ldab #(adpu+irqe+cr1+cr0)
		stab option	|zet de a/d converter aan

		lds #stackend	|begin daarna 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

PROGRAM		space
clistart 	equ $ 		|het beginadres van deze module

DATA 		space

* initialisatie
PROGRAM 	space

* initialiseer de seriële poort
		ldab #(scp1+scp0)
		stab baud 	|kies 9600 BAUD ( 8MHz kristal)
		ldab #(te or re)
		stab sccr2 	|en zet zender- en ontvanger aan

		bra cliend 	|einde van de initialisatie

* subroutines voor de seriële poort
PROGRAM		space

* kijk of er een karakter ontvangen is
* zoja, zet dan de zero?vlag op '0'
serincheck 	equ $
		pshb
		ldab scsr 	|lees de status vlaggen
		andb #rdrf 	|en test op het 'receiver full' bit
		pulb
		rts

* kijk of de seriele poort gereed is om een teken te versturen
* zoja, zet dan de zero?vlag op '0'
seroutcheck 	equ $
		pshb
		ldab scsr 	|lees de staus vlaggen
		andb #tc 	|en test op het 'transmitter empty' bit
		pulb
		rts

* haal een teken op uit de ontvanger, en zet het in accumulator B
getchar 	equ $
		bsr serincheck 	|wacht totdat er een teken ontvangen is
		beq getchar
		ldab scdr 	|en lees het teken uit het ontvanger?register
		rts

* verstuur een teken via de seriële poort
putchar 	equ $
		bsr seroutcheck |wacht totdat de zender gereed is
		beq putchar
		stab scdr 	|en zet dan het teken in het verzend?register
		rts

cliend 		equ $ 		|einde van de cli module

*************************************************
* Analoog -> Digitaal converter
*************************************************
PROGRAM 	space

adstart 	equ $ 		|het beginadres van deze module

DATA 		space

* initialisatie van de a/d converter
* converter wordt ingesteld op continue conversie van de kanalen PE0..PE3
* het resultaat van de conversies is beschikbaar in de registers adr1..adr4
PROGRAM 	space

		ldab #(scan or mult)
		stab adctl 	|initialiseer voor continue conversie

		bra adend 	|einde van de initialisatie

***** a/d converter interface routines
PROGRAM 	space

adend 		equ $ 		|einde van de module

*************************************************
* real-time interrupt
*************************************************
PROGRAM 	space
rtistart e	qu $ 		|het beginadres van deze module
rtirate 	equ 10 		|het aantal interrupts dat geteld wordt

DATA 		space
rticount 	rmb 1 		|deze teller wordt bij elke interrupt verhoogd

* initialisatie van de real?time interrupt
PROGRAM 	space

		ldx #regsbeg 	|IX wijst naar de I/O registers
		ldab #$7E 	|vul de entry in de interrupt?tabel in
		stab rtiint 	|met een sprong?instructie naar de routine
		ldd #rtiintentry
		std rtiint+1 	|die de interrupt afhandelt

		bset pactl+regsbeg,x,(rtr1 or rtr0)
				|zet de real-time interrupt tijd op 32.768ms
				|met 8MHz Kristal (E / 2^16)
		bset tmsk2+regsbeg,x,rtii
				|laat de interrupts door
		bra rtiend 	|einde van de initialisatie

* subroutine voor de afhandeling van de real?time interrupt
PROGRAM 	space

rtiintentry	equ $
		ldab #rtif
		stab tflg2 	|reset de interrupt-vlag
		inc rticount 	|en tel de interrupt
		rti

***** real-time interrupt interface routines
PROGRAM 	space

* test op time?out. zet de zero?vlag indien er een time?out is.
checktimeout 	equ $
		pshb
		sei 		|houd interrupts tijdelijk tegen
		ldab rticount 	|kijk hoe vaak er een interrupt was
		subb #rtirate 	|indien er minimaal 'rtirate' interrupts
		blo checkrti9 	|zijn geweest, dan is er een time?out en moet
		stab rticount 	|'rtirate' van de teller worden afgetrokken
		clrb 		|daarnaast moet de zero?vlag gezet worden
checkrti9 	cli 		|daarna kunnen de interrupts weer worden
		pulb 		|doorgelaten
		rts

rtiend 		equ $ 		|einde van de real?time interrupt module

*************************************************
* het hoofdprogramma
*************************************************
PROGRAM 	space
		bra main0

* subroutine om een byte (in B) te verzenden in twee hexadecimale cijfers
sendbyte 	equ $
		pshb
		lsrb 		|verstuur eerst de vier meest sign. bits
		lsrb
		lsrb
		lsrb
		bsr sendnibble
		pulb

* subroutine om een nibble (4 bits) in B te verzenden als een hex. cijfer
sendnibble 	equ $
		andb #$0F 	|zorg ervoor dat het echt een nibble is
		addb #'0' 	|maak er een cijfer van
		cmpb #'9' 	|en als het groter is dan een '9'
		bls sendnibble0	|maak er dan een letter A..F van
		addb #('A' - '9' - 1)
sendnibble0 	jsr putchar
		rts

main0		jsr checktimeout
		bne main1 	|kijk of de waarde al verstuurd moeten worden
		ldab adr1 	|zoja, haal dan de geconverteerde waarde op
		jsr sendbyte 	|en verstuur die naar de PC
		ldab #$0D 	|met een carriage-return
		jsr putchar
		ldab #$0A 	|en een line-feed
		jsr putchar

main1		bra main0 	|blijf dit herhalen

		end