Assembly Language A/D buffering routine

Assembly Language A/D buffering routine.


A2D_Buffering_Utility module stacksize(12)
; Intel Corporation, July 16, 1985
; by Dave Ryan, Intel Applications Engineer
; This utility fills a memory buffer with A/D conversion results. The
; conversions are done under interrupt control, and are initiated when
; A2D_BUFF_Util is called. The results of the conversions are placed
; in one of two buffers, called BUFF0 and BUFF1.
; This utility provides options for the selection of the buffer lengths, data
; format, sample period, conversion channel and time base. The utility also
; has a donwload routine that will load either buffer into a register file
; buffer. Output formats can also be chosen for the downloaded buffer. The
; data can be formatted as signed or unsigned linear or paried arrays.
; Rather than use the STACK to pass controls, this utility gets its directions
; from 2 control words in memory. The utility expects that its control words
; are valid at the time A2D_BUFF_Util is called and remain valid throughout
; A/D interrupt executions and downloads. The control words are:
; Sample_Period ; WORD ; The time between samples in timer counts
; ; where the timer used has been specified
; Control_A2D ; BYTE ; Control information for the utility:
; BIT#
; ; 0-2 ; Channel Number
;; ; 3 ; Signed Result/Unsigned Result#
; ; 4 ; Convert/Download#
; ; 5 ; BUFF1/BUFF0# for conversions
; ; BUFF0/BUFF1# for downloads
; ; 6 ; Linear/Paired#
; ; 7 ; Converter BUSY/IDLE#

; The following is a table of equates that can be used to simplify the
; bit diddling requirements. If you are not running conversions concurrently
; with downloads, always LDB Control_A2D with the following command then
; ORB Control_A2D with the channel number you wish to convert if you are
; starting a conversion.
; Once the utility is called, care must be taken when Control_A2d is
; modified. You can cause downloads to occur while conversions are running,
; but you cannot start conversions during a download. To do this, ORB to the
; control byte with the appropriate bits set. Do NOT change the BUFF bit or
; the BUSY bit. Just set the download bit and set the data format bits to the
; correct values.
; The BUFF bit has opposite definitions for conversions and downloads. This
; allows conversions to be done into BUFF0 while downloads come from BUFF1, and
; vice versa.
; A2D UTILITY COMMANDS_____________________________________________________
;con_b0 equ 00010000b;convert to BUFF0
;con_b1 equ 00110000b; " BUFF1
;dump_b0_l_u equ 01100000b; download BUFF0 as LINEAR USIGNED data
;dump_b1_l_u equ 01000000b; " BUFF1 " " " "
;dump_b0_p_u equ 00100000b; " BUFF0 " PAIRED " "
;dump_b1_p_u equ 00000000b; " BUFF1 " " " "
;dump_b0_l_s equ 01101000b; download BUFF0 as LINEAR SIGNED data
;dump_b1_l_s equ 01001000b; " BUFF1 " " " "
;dump_b0_p_s equ 00101000b; " BUFF0 " PAIRED " "
;dump_b1_p_s equ 00001000b; " BUFF1 " " " "
; The base addresses and length of each conversion buffer and the destination
; buffer are DECLARED EXTRNal in this utility. Other options such as selection
; of the timer used as a timebase, the length of the buffer, and the effective
; number of bits in the reported result are set at assembly time through use
; of EQUates in this module.
; The following parameters need to be provided at assembly or link time.
; The buffer bases are declared EXTRNal by this utility, while the buffer
; length shift count and HSO commands are EQUated.
; BUFF0_BASE ; The starting address of BUFF0
; BUFF1_BASE ; The starting address of BUFF1
; DEST_BUFF_BASE ; The starting address of the download
; ; target buffer.
; BUFF_LENGTH ; The number of SAMPLES that each
; ; buffer must hold. must be >1 and <256
; Shift_count ; The number of times that the conversion result is
; ; to be shifted right from its natural left justified
; ; position. Setting a shift count greater than 6 will
; ; result in lost bits to the right. Rounding is NOT
; ; done.
; CLOCK ; Specify as either TIMER1 or T2CLK. This is the
; ; timebase used for conversions.
; Samples are stored as words in the buffers. The program stores
; conversions linearly in BUFF0 and BUFF1, and linearly or paired in the
; destination buffer as selected. If the download is to be paired, the first
; sample is placed in location DEST_BUFF_BASE, the second sample is placed in
; location (DEST_BUFF_BASE + BUFF_LENGTH), the third in (DEST_BUFF_BASE + 2),
; the fourth in (DEST_BUFF_BASE + 2 + BUFF_LENGTH), etc.
; When a utility call directs the initiation of a set of A2D conversions, the
; first conversion is begun at approximately one sample time plus 50 state
; times from when the utility was called. This assumes that no interrupts are
; present.
; The conversion busy bit is set approximately 50 state times after a call
; to the utility, if the convert bit was set in the A2D_Control byte. The
; busy bit is cleared after all conversion results have been stored in the
; result buffer designated (BUFF0 or BUFF1).
; Take great care in modifying the A2D_Control byte to do a download while
; conversions are taking place. You can never download a buffer that is
; being converted into. The results would be invalid.


EXTRN ad_command, ad_result_lo, ad_result_hi
EXTRN hso_command, hso_time,sp

Shift_Count EQU 1

; set up hso commands for correct timer **********************************

TIMER1 equ 0AH
T2CLK equ 0CH

MASK equ (10h*CLOCK)AND(40h)

Start_A2D equ (00001111b)OR(MASK)
;start a2d based on timer 1, no interrupt

HSO_0_Low equ (00000000b)OR(MASK)
; make hso.0 low based on timer1 no interrupt

HSO_0_High equ (00100000b)OR(MASK)
; make hso.0 hi based on timer1 no interrupt

; set up storage *******************************************************

adudtemp0: DSW 1; temp register for download calls

aductemp0: DSW 1; temp registers for conversion calls
aductemp1: DSW 1
top_of_buffer: DSW 1
sample_count: DSB 1

Control_A2D: DSB 1; the byte that controls the utility execution
DForm equ 3 ; Signed/Unsigned#
Con_Dwn equ 4 ; Convert/Download#
B0_B1 equ 5 ; Buff1/Buff0# for conversions
; Buff0/Buff1# for downloads
Lin_Par equ 6 ; Linear/Paired#
Busy equ 10000000B ; Bit 8

Sample_Period: DSW 1; the word that specifies the number of clock ticks
; that elapse between each sample

PUBLIC Control_A2D, Sample_Period


src_ptr: DSW 1; some overlayable temp registers
temp set src_ptr:WORD
dest_ptr: DSW 1
loop_count: DSW 1

CSEG at 2002h





Load_HSO_Command MACRO var ; Macro to load HSO

LDB hso_command,#var
LD hso_time,aductemp0


JBS Control_A2D, Con_Dwn, Convert ; Select convert or download
LD src_ptr,#BUFF1_BASE
JBC Control_A2D, B0_B1, Set_Data_Format

LD src_ptr,#BUFF0_BASE

Set_Data_Format: ; Choose linear or paired
LD dest_ptr, #DEST_BUFF_BASE
LDB loop_count,#BUFF_LENGTH
JBS Control_A2D, Lin_Par, Linear_data_loop

PAIRED: SHRB loop_count,#1 ; The paired data routine uses 1/2
; as many loops as the unpaired
LD adudtemp0,[src_ptr]+ ; Move even word
ST adudtemp0,[dest_ptr]
ADD dest_ptr,#BUFF_LENGTH ; Length = # of words = 1/2 # of bytes

LD adudtemp0,[src_ptr]+ ; Move odd word
ST adudtemp0,[dest_ptr]+

DJNZ loop_count, Paired_Data_loop ; Loop until done

CALL Convert_Data

Linear_Data_loop: ; Move data linearly
LD adudtemp0,[src_ptr]+
ST adudtemp0,[dest_ptr]+

DJNZ loop_count, Linear_Data_loop ; Loop until done

CALL Convert_Data

Convert_Data: ; Convert the data in the destination buffer

LD loop_count,#BUFF_LENGTH

Again: LD adudtemp0,[src_ptr]
ANDB adudtemp0,#11000000b
JBC Control_A2D, DForm, Unsigned_Result

SUB adudtemp0,#7fe0H
SHRA adudtemp0,#Shift_Count
BR Replace_Sample

SHR adudtemp0, #Shift_Count

ST adudtemp0,[src_ptr]+
DJNZ loop_count,Again ; Loop until done


Convert: ;; Prepare to Start Conversions


ORB Control_A2D, #Busy ; set converter busy bit

LDB sample_count,#BUFF_LENGTH - 1
LD top_of_buffer,#BUFF0_BASE
LD aductemp1,#(BUFF0_BASE + 2*BUFF_LENGTH)

JBC Control_A2D, B0_B1, Start_Conversions
LD top_of_buffer,#BUFF1_BASE
LD aductemp1,#(BUFF1_BASE + 2*BUFF_LENGTH)


ANDB ad_command,Control_A2D,#00000111b ;load channel number

ADD aductemp0,CLOCK,Sample_Period ;start first conversion
;one sample time from

Load_HSO_Command Start_A2D ; Start A2D at Time=aductemp0

POP temp ; get a copy of the psw

Load_HSO_Command HSO_0_high ; set hso.0 high at conversion
; start time for external S/H

OR temp,#202h ; enable a2d interrupts

ADD aductemp0,Sample_Period

Load_HSO_Command Start_A2D ; start second convertion one
; sample time from the first

PUSH temp ; put psw back on stack

Load_HSO_Command HSO_0_low ;lower hso.0 for external S/H



STB ad_result_lo,[top_of_buffer]+
STB ad_result_hi,[top_of_buffer]+
ANDB ad_command,Control_A2D,#00000111b ;load channel number

DJNZ sample_count, Sample_Again
INCB sample_count

CMP top_of_buffer,aductemp1 ; Check top of buffer
BE Top_of_buffers

ADD aductemp0,Sample_Period ; Set next sample time
CMP top_of_buffer,aductemp1 ; Check top of buffer
; for later jump
Load_HSO_Command Start_A2D

JBC sample_count,0,Make_HSO_High

nop ; wait 8 states after HSO load
Load_HSO_Command HSO_0_Low
; Load for change of HSO to trigger S/H
BE Top_of_buffers

Load_HSO_Command HSO_0_High ; Load for change of HSO to trigger S/H

BE Top_of_buffers

ANDB Control_A2D,#NOT(Busy) ; Clear converter BUSY bit

Free Web Hosting

Legal Stuff © 1997 Intel Corporation