89c52外扩6116RAM，用C语言怎么在片外定义两个数组？然后再调用这两个数组！
External Data Memory
External data memory is read/write. Since external data memory is indirectly accessed through a data pointer register (which must be loaded with an address), it is slower than access to internal data memory.
Several 8051 devices provide on-chip XRAM space that is accessed with the same instructions as the traditional external data space. This XRAM space is typically enabled via dedicated chip configuration SFR registers and overlaps the external memory space.
There may be up to 64K Bytes of external data memory; though, this address space does not necessarily have to be used as memory. Your hardware design may map peripheral devices into the memory space. If this is the case, your program would access external data memory to program and control the peripheral. This technique is referred to as memory-mapped I/O.
The C51 Compiler offers two memory types that access external data: xdata and pdata.
The xdata memory specifier refers to any location in the 64K Byte address space of external data memory. The large memory model locates variables in this memory space.
The pdata memory type specifier refers to exactly one (1) page (256 bytes) of external data memory. The compact memory model locates variables in this memory space.
Note
External data memory may be accessed indirectly using the MOVX instruction. It may not be accessed directly.
_________________________________________________________
Generic Pointers
Generic pointers are declared like standard C pointers. For example:
char *s; /* string ptr */
int *numptr; /* int ptr */
long *state; /* Texas */
Generic pointers are always stored using three bytes. The first byte is the memory type, the second is the high-order byte of the offset, and the third is the low-order byte of the offset. Generic pointers may be used to access any variable regardless of its location in 8051 memory space. Many of the Cx51 Compiler library routines use these pointer types for this reason. By using these generic pointers, a function can access data regardless of the memory in which it is stored.
The following code and assembly listing shows the values assigned to generic pointers for variables in different memory areas. Note that the first value is the memory space followed by the high-order byte and low-order byte of the address.
stmt level source
1 char *c_ptr; /* char ptr */
2 int *i_ptr; /* int ptr */
3 long *l_ptr; /* long ptr */
4
5 void main (void)
6 {
7 1 char data dj; /* data vars */
8 1 int data dk;
9 1 long data dl;
10 1
11 1 char xdata xj; /* xdata vars */
12 1 int xdata xk;
13 1 long xdata xl;
14 1
15 1 char code cj = 9; /* code vars */
16 1 int code ck = 357;
17 1 long code cl = 123456789;
18 1
19 1
20 1 c_ptr = &dj; /* data ptrs */
21 1 i_ptr = &dk;
22 1 l_ptr = &dl;
23 1
24 1 c_ptr = &xj; /* xdata ptrs */
25 1 i_ptr = &xk;
26 1 l_ptr = &xl;
27 1
28 1 c_ptr = &cj; /* code ptrs */
29 1 i_ptr = &ck;
30 1 l_ptr = &cl;
31 1 }
ASSEMBLY LISTING OF GENERATED OBJECT CODE
; FUNCTION main (BEGIN)
; SOURCE LINE # 5
; SOURCE LINE # 6
; SOURCE LINE # 20
0000 750000 R MOV c_ptr,#00H
0003 750000 R MOV c_ptr+01H,#HIGH dj
0006 750000 R MOV c_ptr+02H,#LOW dj
; SOURCE LINE # 21
0009 750000 R MOV i_ptr,#00H
000C 750000 R MOV i_ptr+01H,#HIGH dk
000F 750000 R MOV i_ptr+02H,#LOW dk
; SOURCE LINE # 22
0012 750000 R MOV l_ptr,#00H
0015 750000 R MOV l_ptr+01H,#HIGH dl
0018 750000 R MOV l_ptr+02H,#LOW dl
; SOURCE LINE # 24
001B 750001 R MOV c_ptr,#01H
001E 750000 R MOV c_ptr+01H,#HIGH xj
0021 750000 R MOV c_ptr+02H,#LOW xj
; SOURCE LINE # 25
0024 750001 R MOV i_ptr,#01H
0027 750000 R MOV i_ptr+01H,#HIGH xk
002A 750000 R MOV i_ptr+02H,#LOW xk
; SOURCE LINE # 26
002D 750001 R MOV l_ptr,#01H
0030 750000 R MOV l_ptr+01H,#HIGH xl
0033 750000 R MOV l_ptr+02H,#LOW xl
; SOURCE LINE # 28
0036 7500FF R MOV c_ptr,#0FFH
0039 750000 R MOV c_ptr+01H,#HIGH cj
003C 750000 R MOV c_ptr+02H,#LOW cj
; SOURCE LINE # 29
003F 7500FF R MOV i_ptr,#0FFH
0042 750000 R MOV i_ptr+01H,#HIGH ck
0045 750000 R MOV i_ptr+02H,#LOW ck
; SOURCE LINE # 30
0048 7500FF R MOV l_ptr,#0FFH
004B 750000 R MOV l_ptr+01H,#HIGH cl
004E 750000 R MOV l_ptr+02H,#LOW cl
; SOURCE LINE # 31
0051 22 RET
; FUNCTION main (END)
In the above example listing, the generic pointers c_ptr, i_ptr, and l_ptr are all stored in the internal data memory of the 8051. However, you may specify the memory area in which a generic pointer is stored by using a memory type specifier. For example:
char * xdata strptr; /* generic ptr stored in xdata */
int * data numptr; /* generic ptr stored in data */
long * idata varptr; /* generic ptr stored in idata */
These examples are pointers to variables that may be stored in any memory area. The pointers, however, are stored in xdata, data, and idata respectively.
Note
The code generated for a generic pointer executes more slowly than the equivalent code generated for a memory-specific pointer because the memory area is not known until run-time. The compiler cannot optimize memory accesses and must generate generic code that can access any memory area. If execution speed is a priority, you should use memory-specific pointers instead of generic pointers wherever possible.
_________________________________________________________
Memory-Specific Pointers
Memory-specific pointers always include a memory type specification in the pointer declaration and always refer to a specific memory area. For example:
char data *str; /* ptr to string in data */
int xdata *numtab; /* ptr to int(s) in xdata */
long code *powtab; /* ptr to long(s) in code */
Because the memory type is specified at compile-time, the memory type byte required by generic pointers is not needed by memory-specific pointers. Memory-specific pointers can be stored using only one byte (idata, data, bdata, and pdata pointers) or two bytes (code and xdata pointers).
Like generic pointers, you may specify the memory area in which a memory-specific pointer is stored. To do so, prefix the pointer declaration with a memory type specifier. For example:
char data * xdata str; /* ptr in xdata to data char */
int xdata * data numtab; /* ptr in data to xdata int */
long code * idata powtab; /* ptr in idata to code long */
Memory-specific pointers may be used to access variables in the declared 8051 memory area only. Memory-specific pointers provide the most efficient method of accessing data objects, but at the cost of reduced flexibility.
The following code and assembly listing shows how pointer values are assigned to memory-specific pointers. Note that the code generated for these pointers is much less involved than the code generated in the generic pointers example listing.
stmt level source
1 char data *c_ptr; /* memory-specific char ptr */
2 int xdata *i_ptr; /* memory-specific int ptr */
3 long code *l_ptr; /* memory-specific long ptr */
4
5 long code powers_of_ten [] =
6 {
7 1L,
8 10L,
9 100L,
10 1000L,
11 10000L,
12 100000L,
13 1000000L,
14 10000000L,
15 100000000L
16 };
17
18 void main (void)
19 {
20 1 char data strbuf [10];
21 1 int xdata ringbuf [1000];
22 1
23 1 c_ptr = &strbuf [0];
24 1 i_ptr = &ringbuf [0];
25 1 l_ptr = &powers_of_ten [0];
26 1 }
ASSEMBLY LISTING OF GENERATED OBJECT CODE
; FUNCTION main (BEGIN)
; SOURCE LINE # 18
; SOURCE LINE # 19
; SOURCE LINE # 23
0000 750000 R MOV c_ptr,#LOW strbuf
; SOURCE LINE # 24
0003 750000 R MOV i_ptr,#HIGH ringbuf
0006 750000 R MOV i_ptr+01H,#LOW ringbuf
; SOURCE LINE # 25
0009 750000 R MOV l_ptr,#HIGH powers_of_ten
000C 750000 R MOV l_ptr+01H,#LOW powers_of_ten
; SOURCE LINE # 26
000F 22 RET
; FUNCTION main (END)
Note
The code generated for a memory-specific pointer executes more quickly than the equivalent code generated for a generic pointer. This is because the memory area is known at compile-time rather than at run-time. The compiler can use this information to optimize memory accesses. If execution speed is a priority, you should use memory-specific pointers instead of generic pointers wherever possible.
_________________________________________________________
Pointer Conversions
......
_________________________________________________________
Abstract Pointers
|
