Using Data Pointers to Read/Write to SRAM

Introduction

This application note describes how to write two words of data to SRAM, using data pointers DP[0] and BP[OFFS]. The data is then read back into the MAXQ's accumulators from SRAM using the same data pointers, and a logical "AND" is performed on the two registers.

Getting Started

To begin, you need basic knowledge about the MAXQ architecture, register map, and instruction set, which can be obtained from the MAXQ Family User's Guide or from any MAXQ-based microcontroller data sheet. A good example is the MAXQ2000 data sheet. You also need to reference "Accessing Data Memory" which is in the MAXQ Family User's Guide. Basic familiarity with assembly language in general, and with MAXQ assembler in particular, is assumed.

Data Pointer Overview

There are three data pointers available on a MAXQ-based microcontroller: DP[0], DP[1], and BP[OFFS]. Each of these data pointers can be configured to either word- or byte-access modes by setting the corresponding bit in the Data Point Control (DPC) register.

The three pointers share a single read/write port on the data memory, and thus the user must knowingly activate the desired pointer before accessing memory. This can be done explicitly using the data select bits (SDPS2:0; DPC.1:0), or implicitly by writing to the DP[n], BP, or OFFS register as shown below. Any indirect memory access using a data pointer will also set the SDPS bits, thus activating the pointer as the active source pointer.

move DPC,   #2      ;(explicit) selection of BP as the active pointer
move DP[1], DP[1]       ;(implicit) selection of DP[1]; set SDPS1: 0=01b
move OFFS,  src     ;(implicit) selection of BP; set SDPS1=1
move @DP[0],src     ;(implicit) selection of DP[0]; set SDPS1:0=00b

Increment/Decrement Data Pointer

Data pointers can be updated using pre- and post-increment/decrement operator with a register or a virtual NUL destination. Data pointer increment/decrement operation can be done as follows:

move NUL, @DP[0]++      ;increment DP[0]
move NUL, @DP[1]--      ;decrement DP[1]
move NUL, @BP[OFFS++]   ;increment Frame Pointer Base + Offset + 1

move @++DP[0], A[1]     ;increment address and store A[1] at new address
;Note: Only the pre-increment/decrement can be ;used
                ;when writing to memory
move A[1], @DP[1]--     ;Reads value from DP[1] and store in A[1] then
                ;decrement
;Note: Only the post-increment/decrement can be
;used
                ;when reading from memory

Code Example

1. Move 2 words to SRAM using DP[0]. 5555h is moved to the first word of SRAM, referenced by int_Var1; AAAAh is moved to the second word of SRAM, referenced by int_Var2. Var_1 and Var_2 are read back from SRAM into accumulator A[0] and A[1].



int_Var1 EQU 0h     ;address of int_Var1 to the first byte of SRAM
int_Var2 EQU 1h     ;address of int_Var2 to the second byte of SRAM

main:
move DPC,    #4h        ;Set DP[0] to word mode
                    ;Must be set active before using

move DP[0],  #int_Var1  ;Load address of int_Var1 into DP[0]
                    ;also activated DP[0]
move @DP[0], #5555h     ;write 5555h to SRAM at address of int_Var1

move DP[0],  #int_Var2  ;Load address into of int_Var1 into DP[0]
move @DP[0], #0AAAAh        ;Writes AAAAh to SRAM at address of int_Var2

move DP[0],  #int_Var1  ;Load address of int_Var1 into DP[0]
move A[0],  @DP[0]      ;Reads from address of int_Var1

move DP[0], #int_Var2   ;Load address of int_Var2 into DP[0]
move A[1],  @DP[0]      ;Reads from address of int_Var2

move  AP,   #0          ;select accumulator 0
and  A[1]           ;AND the A[1] and A[0] and store in A[0]
end



2. Move 2 bytes to SRAM using DP[1]. 55h is moved to the first byte of SRAM, referenced by int_Var1; AAh is moved to the second byte of SRAM, referenced by int_Var2. Var_1 and Var_2 are read back from SRAM into accumulator A[0] and A[1].



int_Var1 EQU 0h     ;address of int_Var1 to the first word of SRAM
int_Var2 EQU 1h     ;address of int_Var2 to the second word of SRAM

main:
move DPC,    #0h        ;Set DP[1] to byte mode
                    ;Must be set active before using

move DP[1],  #int_Var1  ;Load address of int_Var1 into DP[1]
                    ;also activated DP[1]
move @DP[1], #55h       ;write 55h to SRAM at address of int_Var1

move DP[1],  #int_Var2  ;Load address into of int_Var1 into DP[1]
move @DP[1], #0AAh      ;Writes AAh to SRAM at address of int_Var2

move DP[1],  #int_Var1  ;Load address of int_Var1 into DP[1]
move A[0],   @DP[1]     ;Reads from address of int_Var1

move DP[1],  #int_Var2  ;Load address of int_Var2 into DP[1]
move A[1],   @DP[1]     ;Reads from address of int_Var2

move  AP,    #0         ;select accumulator 0
and  A[1]           ;AND the A[1] and A[0] and store in A[0]
end



3. Move 2 words to SRAM using BP[Offs]. 5555h is moved to the first word of SRAM, referenced by int_Var1; AAAAh is moved to the second word of SRAM, referenced by int_Var2. Var_1 and Var_2 are read back from SRAM into accumulator A[0] and A[1].



int_Var1 EQU 0h     ;address of int_Var1 to the first word of SRAM
int_Var2 EQU 1h     ;address of int_Var2 to the second word of SRAM

main:
move DPC, #10h          ;Set BP[OFFS] to word mode
move BP,  #0h           ;Sets BP to 0 and activates BP[OFFS]

move OFFS, #int_Var1        ;Load address of int_Var1 into OFFS
move @BP[OFFS], #5555h  ;write to 5555h to SRAM at address of int_Var1

move OFFS, #int_Var2        ;Load address into of int_Var1 into OFFS
move @BP[OFFS], #0AAAAh     ;Writes AAAAh to SRAM at address of int_Var2

move OFFS, #int_Var1        ;Load address of int_Var1 into OFFS
move A[0], @BP[OFFS]        ;Reads from address of int_Var1

move OFFS, #int_Var2        ;Load address of int_Var2 into OFFS
move A[1], @BP[OFFS]        ;Reads from address of int_Var2

move AP,   #0           ;select accumulator 0
and  A[1]           ;AND the A[1] and A[0] and store in A[0]
end

Invalid Data Pointer Instruction

The following are incorrect uses of data pointers:

move DP[0], DP[0]
move A[1], @DP[0]
move A[2], @DP[1]

move DP[0], DP[0]
move A[1], @DP[0]
move DP[1], DP[1]
move A[2], @DP[1]

move BP[OFFS], #0h

move BP, #0h
move OFFS, #0h

move @DP[0]++, A[0]

move @++DP[0], A[0]

move A[0], @++DP[0]

move A[0], @DP[0]--

move @++DP[0], @DP[0]++

move A[1], @DP[0]++
move @++DP[0], A[1]

move @DP[0]++, A[1]

move @DP[0], A[1]
move NUL, @DP[0]++

move A[0], @--DP[0]

move NUL, @DP[0]--
move A[0], @DP[0]