An example might be:

7.3 Run Time xdata Pointers

The situation often occurs that you need to point at addresses in the xdata space which are only known at run-time. Here the xdata pointer is setup in the executable code.

The best way to achieve this is to declare an “uncommitted” pointer at compile time and to then equate it to an address when running:

xdata_ptr=(char xdata*) 0x8000 ; /*Point at 0x8000 in */ /*xdata */

}

An alternative is to declare a pointer to the xdata space and simply equate it to a variable.

Here is an example:

char xdata *ptr ; /* This is a spaced pointer!!! */

main(){

start_address = 0x8000 ; /*Variable containing address*/ /*to be pointed to */

A variation of this is to declare a pointer to zero and use a variable as an offset thus:

char xdata *ptr ;

main() {

unsigned int i ; unsigned char x ;

ptr = (char*) 0x0000 ;

for(i = 0 ; i < 0x40 ; i++) {

x = ptr[i] ;

}

}

This results in rather more code, as an addition to the pointer must be performed within each loop.

7.4 The “volatile” Storage Class

A common situation with external devices is that values present in their registers change without the cpu taking any action. A good example is a real-time clock chip - the time changes continuously without the cpu writing anything.

Consider the following:

unsigned int xdata *milliseconds = 0x8000 ; // Pointer to // RTC chip

time = *milliseconds ; -> (1) // Get RTC register value

x = array[time] ;

time = *milliseconds ; -> (2) // Second register access // optimised out!

y = array[time] ;

Here the value retrieved from the array is related to the value of *milliseconds, a register in an external RTC.

If this is compiled it will not work. Why? Well the compiler’s optimiser shoots itself in the foot by assuming that, because no WRITE occurred between (1) and (2), *millisec cannot have changed. Hence all the code generated to make the second access to the register is optimised out and so y == x!

The solution is declare *milliseconds as “volatile” thus:

unsigned int volatile xdata *milliseconds = 0x8000 ;

Now the optimiser will not try to remove subsequent accesses to the register.

7.5 Placing Variables At Specific Locations - The Linker Method

A final method of establishing external variables at fixed addresses, especially arrays, is by using the linker rather than the compiler. For example, to produce a 10 character array in external memory, starting at 8000H, the following steps are necessary:

/*** Module 1 ***/

/* This module contains only data declarations! */

xdata unsigned char array[30] ;

/* End Module 1 */

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

/*** Module 2 ***/

/* This module contains the executable statements */

extern xdata unsigned char array[10] ;

main()

{

unsigned char i ;

i = array[i] ;

}

Now by linking with the invocation:

L51 module1.obj, module2.obj XDATA (?XD?module1 (8000H))

the linker will make the XDATA segment in Module 1 (indicated by ?XD?module1) start at 8000H, regardless of other xdata declarations elsewhere. Thus the array starts at 8000H and is 10 bytes (+ null terminator) long.

This approach lacks the flexibility of the above methods but has the advantage of making the linker reserve space in the XDATA space.

Similar control can be exercised over the address of segments in other memory spaces. C51 uses the following convention for segment names:

Thus the parameter receiving area of a LARGE model function ‘test()’ in module MOD1.C would be:

?XD?TEST?MOD1,

The code is:

?PR?TEST?MOD1

And so on.

A knowledge of this is useful for assembler interfacing to C51 programs. See section 14.

7.6 Excluding External Data Ranges From Specific Areas

This very much follows on from the previous section. Occasionally a memory-mapped device, such as real time clock chip, is used as both a source of time values and RAM. Typically the first 8 bytes in the RTC’s address range are the time counts, seconds, minutes etc. whilst the remaining 248 bytes are RAM.

Left to its own devices, the L51 linker will automatically place any xdata variables starting at zero. If the RTC has been mapped at this address a problem occurs, as the RTC time registers are overwritten. In addition, it would be convenient to allow the registers to be individually named.

One approach is to define a special module containing just a structure which describes the RTC registers. In the main program the RTC registers are accessed as elements in the structure. The trick is that, when linking, the XDATA segment belonging to the special module is forced to a specific address, here zero. This results in the RTC structure being at zero, with any other XDATA variables following on. The basic method could also be used to stop L51 locating any variables in a specific area.

Example Of Excluding Specific Areas From L51

Linker Input File To Locate RTC_chip structure over real RTC

Registers is:

l51 main.obj,rtcbytes.obj XDATA(?XD?RTCBYTES(0h))

7.7 -missing ORDER and AT now in C51

Perhaps the most curious omission from C51 was the inability to fix the address of a data object at an absolute address from the source file. Whilst there have always been methods of achieving the same effect, users have long requested an extension to allow the address of an object to be included in the original declaration. In C51 v4.xx, the new_AT_control now exists.

7.8 Using The _at_and _ORDER_ Controls

Here, the order of the variables must not change as it must match the physical location of the real time clock’s registers. The #pragma ORDER tells C51 to place the data objects at ascending addresses, with the first item at the lowest address. The linker must then be used to fix the address of the whole block in memory.

Source File MAIN.C

#pragma ORDER

unsigned char xdata RTC_secs ; unsigned char xdata RTC_mins ; unsigned char xdata RTC_hours ;

main() { RTC_mins = 1 ; }

Linker Input File MAIN.LIN

main.obj & to main & XDATA(?XD?MAIN(0fa00h))

The alternative _at_ control forces C51 to put data objects at an address given in the source file:

/** Fix Real Time Clock Registers Over Memory-Mapped Device **/ /** Fix each item individually **/

unsigned char xdata RTC_secs _at_ 0xfa00 ; unsigned char xdata RTC_mins _at_ 0xfa01 ; unsigned char xdata RTC_hours _at_ 0xfa02 ;

main() { RTC_mins = 1 ;

}

... which hopefully is self-explanatory!