How to access external RAM in C51

XBYTE defines the external address so that it can communicate with the device connected to your IO port.
In general programs that read and write external RAM, you often see sentences like this:

    XBYTE[address]=data    write data
    data=XBYTE[address]    read data 1
    The external bus consists of 3 groups of buses, data address control, we often call it the external bus, since there are 3 groups of different signals, how do they coordinate work? Generally speaking, the CPU has special external data

The access instruction is like the 51's ＭＯＶＸ instruction you mentioned here (it will be compiled into this instruction in C language). When executing this instruction, the three groups of lines work in coordination.
mov dptr,#1000h
mov a,#55h
movx @dptr,a
The above three call statements can be expressed in C language as follows
#define   W_DATA   XBYTE[0x1000]
W_DATA=0X55;
When using the external bus, the data address and control signal are directly output high and low levels according to the specified timing, so you don't have to worry about it. Of course, you must meet the timing work. How to understand #define XBYTE ((unsigned char

volatile xdata * ))
8051 unique memory type
code     program memory read with MOVC @A+DPTR
data     internal data memory that can be directly accessed
idata     internal data memory accessed with Mov @Rn
bdata     bit addressable internal memory
xdata     external data memory accessed with MOVX @DPTR
pdata     external data memory accessed with MOVX @Rn
Special data type
bit     general bit variable
sbit     absolute addressing bit variable
Syntax
sbit     my_flag     =     location;     (location range from 0x00 ~ 0x7F)
Example
sbit     EA =     0xAF;
or bit variable declared with bdata
char     bdata         my_flags;
sbit     flag0 =       my_flags ^ 0;
(Note that static cannot be added before sbit)
sfr     Special Function Register
Syntax
sfr     my_sfr     =     location;     (location range from 0x80 ~ 0xFF)
Example
sfr     P0     =     0x80;
Specify the absolute address of the variable
In a single module, you can use the following syntax to declare
[memory_space]     type     variable_name     _at_     location
Example
pdata         char     my_pdata     _at_     0x80;
If the variable must be used by multiple modules (Global Variable),
it is more convenient to define it in the header file as an abstract pointer.
#define     variable_name     *((data_type *)         location)
Example
#define     my_pdata     *((char pdata *)     0x80)
(Note the order of char and pdata)
ABSACC.H provides the following convenient macro definitions.
#define CBYTE ((unsigned char volatile code *) 0)
#define DBYTE ((unsigned char volatile data *) 0)
#define PBYTE ((unsigned char volatile pdata *) 0)
#define XBYTE ((unsigned char volatile xdata *) 0)
#define CWORD ((unsigned int volatile code *) 0)
#define DWORD ((unsigned int volatile data *) 0)
#define PWORD ((unsigned int volatile pdata *) 0)
#define XWORD ((unsigned int volatile xdata *) 0)
Hidden initialization program
The first program module executed by 80C51 after power reset (Power On Reset) is not the user's main program
main(), but a program module called startup.a51 hidden in the KEIL-C51 standard link library.
The main task of startup.a51 is to clear the memory blocks including idata, xdata, and pdata to 0, and
initialize the recursive pointer. Then startup.a51 is still executed by a
program module called init.a51 hidden in the KEIL-C51 standard link library. The main task of init.a51 is to initialize
variables with non-zero initial values.
After completing the above initialization program, the control of 80C51 will be handed over to main() to start executing the user's program.
#define XBYTE ((unsigned char volatile xdata *) 0)
defines     XBYTE as a pointer to the unsigned char data type in the xdata address space, and the pointer value is 0
In this way, you can directly use XBYTE[0xnnnn] or *(XBYTE+0xnnnn) to access external RAM.

Among them, the initial address is 0x0000;

Baidu Knows:

#define XBYTE((char*)0x20000L)
XBYTE[0x8000]=0x41;
What does this procedure mean?

#define XBYTE ((char*)0x20000L) defines XBYTE as a character pointer (or array) variable pointing to address 0x20000L

XBYTE[0x8000]=0x41; Assign a value of 0x41 to the variable 0x8000 of the array XBYTE. That is, assign a value of 0x41 to the memory unit at address 0x28000L.

This means that you are using a 51 chip with an external data bus. The external memory is most likely RAM, and the capacity of RAM is at least 0x8000 (32k) bytes. The capacity of RAM may be 64k bytes?

If you still have questions, please send a message to contact

Supplement 1:
L stands for long, which means 0x20000L is a long integer. Generally speaking, in 8-bit microcontrollers such as 51, integers are represented by 16 bits of binary and long integers are represented by 32 bits of binary.

There is also this use:

Write a header file like this

Type storage space definition alias keyword _at_ register address

The keyword _at_ is an absolute definition of the address