struct sensor_desc sensor_database = { 0x30, 0x50, 0x60, 

                             0xC4, 0x21 } ; 

so that here the structure is created in memory and pre-loaded with values. 

The array case follows a similar form: 

struct sensor_desc sensor_database[4] = {{0x30,0x50,0x60, 

                            0xC4, 0x21 }, 

{ 0x32,0x56,0x56,0xC5,0x28 ; } 

} ; 

6.4.4 Placing Structures At Absolute Addresses 

It is sometimes necessary to place a structure at an absolute address. This 

might occur if, for example, the registers of a memory-mapped real time cloc 

k chip are to be grouped together as a structure. The template in this insta 

nce might be 

Contents Of RTCBYTES.C Module 

    struct RTC { unsigned char seconds ; 

             unsigned char minutes ; 

             unsigned char hours   ; 

             unsigned char days    ; 

} ; 

struct RTC xdata RTC_chip ;  // Create xdata structure 

A trick using the linker is required here so the structure creation must be 

placed in a dedicated module. This module's XDATA segement, containing the R 

TC structure, is then fixed at the required address at link time. 

Using the absolute structure could be: 

/* Structure located at base of RTC Chip */ 

MAIN.C Module 

extern xdata struct RTC_chip ; 

/* Other XDATA Objects */ 

xdata unsigned char time_secs, time_mins ; 

void main(void) { 

time_secs = RTC_chip.seconds ; 

time_mins = RTC_chip.minutes; 

} 

Linker Input File To Locate RTC_chip structure over real RTC Registers is: 

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

See section 7.6 for further examples of this placement method. 

6.4.5 Pointers To Structures 

/* Define pointer to structure */ 

Pointers can be used to access structures, just as with simple data items. H 

ere is an example: 

struct sensor_desc *sensor_database ; 

/* Use Pointer To Access Structure Elements */ 

sensor_database->gain = 0x30 ; 

sensor_database->offset = 0x50 ; 

sensor_database->temp_coeff = 0x60 ; 

sensor_database->span = 0xC4 ; 

sensor_database->amp_gain = 0x21 ; 

Note that the '*' which normally indicates a pointer has been replaced by ap 

pending '->' to the pointer name. Thus '*name' and 'name->' are equivalent. 

6.4.6 Passing Structure Pointers To Functions 

A common use for structure pointers is to allow them to be passed to functio 

ns without huge amounts of parameter passing; a typical structure might cont 

ain 20 data bytes and to pass this to a function would require 20 parameters 

 to either be pushed onto the stack or an abnormally large parameter passing 

 area. By using a pointer to the structure, only the two or three bytes that 

 constitute the pointer need be passed. This approach is recommended for C51 

 as the overhead of passing whole structures can tie the poor old 8051 CPU i 

n knots! 

This would be achieved thus: 

struct sensor_desc *sensor_database ; 

sensor_database-> gain = 0x30 ; 

sensor_database-> offset = 0x50  ; 

sensor_database-> temp_coeff = 0x60 ; 

sensor_database-> span = 0xC4 ; 

sensor_ database- >amp_gain = 0x21 ; 

test_function(*struct_pointer) ; 

test_function(struct sensor_desc *received_struct_pointer) { 

   received_struct_pointer->gain = 0x20 ; 

   received_struct_pointer->temp_coef = 0x40 ; 

   } 

Advanced Note: Using a structure pointer will cause the called function to o 

perate directly on the structure rather than on a copy made during the param 

eter passing process. 

6.4.7 Structure Pointers To Absolute Addresses 

It is sometimes necessary to place a structure at an absolute address. This 

might occur if, for example, a memory-mapped real time clock chip is to be h 

andled as a structure. An alternative approach to that given in section 6.4. 

4. is to address the clock chip via a structure pointer. 

The important difference is that in this case no memory is reserved for the 

structure - only an "image" of it appears to be at the address. 

The template in this instance might be: 

/* Define Real Time Clock Structure */ 

struct RTC {char seconds ; 

        char mins ; 

        char hours ; 

        char days ; } ; 

/* Create A Pointer To Structure */ 

struct RTC xdata *rtc_ptr ;  // 'xdata' tells C51 that this 

                     //is a memory-mapped device. 

void main(void) { 

   rtc_ptr = (void xdata *) 0x8000 ;  // Move structure 

                          // pointer to address 

                          //of real time clock at 

                          // 0x8000 in xdata 

    rtc_ptr->seconds = 0 ;  // Operate on elements 

    rtc_ptr->mins = 0x01 ; 

   } 

This general technique can be used in any situation where a pointer-addresse 

d structure needs to be placed over a specific IO device. However it is the 

user's responsibility to make sure that the address given is not likely to b 

e allocated by the linker as general variable RAM! 

To summarize, the procedure is: 

Define template 

Declare structure pointer as normal 

At run time, force pointer to required absolute address in the normal way. 

6.5 Unions 

A union is similar in concept to a structure except that rather than creatin 

g sequential locations to represent each of the items in the template, it pl 

aces each item at the same address. Thus a union of 4 bytes only occupies a 

single byte. A union may consist of a combination of longs, char and ints al 

l based at the same physical address. 

The the number of bytes of RAM used by a union is simply determined by the s 

ize of the largest element, so: 

union test { char x ; 

             int y  ; 

             char a[3] ; 

             long z ; 

} ; 

requires 4 bytes, this being the size of a long. The physical location of ea 

ch element is: 

addr _ 0   x byte  y high byte a[0]  z highest byte 

       +1           y low byte a[1]  z byte 

       +2                      a[2]  z byte 

       +3                      a[3]  z lowest byte 

Non-8051 programmers should see the section on byte ordering in the 8051 if 

they find the idea of the MSB being at the low address odd! 

In embedded C the commonest use of a union is to allow fast access to indivi 

dual bytes of longs or ints.  These might be 16 or 32 bit real time counters 

, as in this example: 

/* Declare Union */ 

union clock {long real_time_count ; // Reserve four byte 

    int real_time_words[2] ;      // Reserve four bytes as 

                        // int array 

    char real_time_bytes[4] ;     // Reserve four bytes as 

                          // char array 

      } ; 

/* Real Time Interrupt */ 

void timer0_int(void) interrupt 1 using 1 { 

    clock.real_time_count++ ;       // Increment clock 

    if(clock.real_time_words[1] == 0x8000) { // Check 

                    // lower word only for value 

    /* Do something! */ 

    } 

    if(clock.real_time_bytes[3] == 0x80) {  // Check most 

                   // significant byte only for value 

    /* Do something! */ 

    } 

    } 

6.6 Generic Pointers 

C51 offers two basic types of pointer, the spaced (memory-specific) and the 

generic. Up to version 3.00 only generic pointers were available. 

As has been mentioned, the 8051 has many physically separate memory spaces, 

each addressed by special assembler instructions. Such characteristics are n 

ot peculiar to the 8051 - for example, the 8086 has data instructions which 

operate on a 16 bit (within segment) and a 20 bit basis. 

For the sake of simplicity, and to hide the real structure of the 8051 from 

the programmer, C51 uses three byte pointers, rather than the single or two 

bytes that might be expected. The end result is that pointers can be used wi 

thout regard to the actual location of the data. 

For example: 

 xdata char buffer[10] ; 

 code char message[] = { "HELLO" } ; 

void main(void) { 

       char *s ; 

       char *d ; 

       s = message ; 

       d = buffer ; 

       while(*s != '\0') { 

          *d++ = *s++ ; 

          } 

   } 

Yields: 

    RSEG  ?XD?T1 

buffer:            DS  10 

    RSEG  ?CO?T1 

message: 

    DB  'H' ,'E' ,'L' ,'L' ,'O' ,000H 

; 

; 

; xdata char buffer[10] ; 

; code char message[] = { "HELLO" } ; 

; 

;    void main(void) { 

    RSEG  ?PR?main?T1 

    USING    0 

main: 

            ; SOURCE LINE # 6 

; 

;       char *s ; 

;       char *d ; 

; 

;       s = message ; 

            ; SOURCE LINE # 11 

    MOV      s?02,#05H 

    MOV      s?02+01H,#HIGH message 

    MOV      s?02+02H,#LOW message 

;       d = buffer ; 

            ; SOURCE LINE # 12 

    MOV      d?02,#02H 

    MOV      d?02+01H,#HIGH buffer 

    MOV      d?02+02H,#LOW buffer 

?C0001: 

; 

;       while(*s != '\0') { 

            ; SOURCE LINE # 14 

    MOV      R3,s?02 

    MOV      R2,s?02+01H 

    MOV      R1,s?02+02H 

    LCALL    ?C_CLDPTR 

    JZ       ?C0003 

;          *d++ = *s++ ; 

            ; SOURCE LINE # 15 

    INC      s?02+02H 

    MOV      A,s?02+02H 

    JNZ      ?C0004 

    INC      s?02+01H 

?C0004: 

    DEC      A 

    MOV      R1,A 

    LCALL    ?C_CLDPTR 

    MOV      R7,A 

    MOV      R3,d?02 

    INC      d?02+02H 

    MOV      A,d?02+02H 

    MOV      R2,d?02+01H 

    JNZ      ?C0005 

    INC      d?02+01H 

?C0005: 

    DEC      A 

    MOV      R1,A 

    MOV      A,R7 

    LCALL    ?C_CSTPTR 

;          } 

            ; SOURCE LINE # 16 

    SJMP     ?C0001 

;       } 

            ; SOURCE LINE # 17 

?C0003: 

    RET 

; END OF main 

    END 

As can be seen, the pointers '*s' and '*d' are composed of three bytes, not 

two as might be expected. In making *s point at the message in the code spac 

e an '05' is loaded into s ahead of the actual address to be pointed at. In 

the case of *d '02' is loaded. These additional bytes are how C51 knows whic 

h assembler addressing mode to use. The library function C_CLDPTR checks the 

 value of the first byte and loads the data, using the addressing instructio 

ns appropriate to the memory space being used. 

This means that every access via a generic pointer requires this library fun 

ction to be called. The memory space codes used by C51 are: 

CODE  - 05 

XDATA - 02 

PDATA - 03 

DATA  - 05 

IDATA - 01 

6.7 Spaced Pointers In C51 

Considerable run time savings are possible by using spaced pointers. By rest 

ricting a pointer to only being able to point into one of the 8051's memory 

spaces, the need for the memory space "code" byte is eliminated, along with 

the library routines needed to interpret it. 

A spaced pointer is created thus: 

char xdata *ext_ptr ; 

to produce an uncommitted pointer into the XDATA space or 

char code *const_ptr ; 

which gives a pointer solely into the CODE space. Note that in both cases th 

e pointers themselves are located in the memory space given by the current m 

emory model. Thus a pointer to xdata which is to be itself located in PDATA 

would be declared thus: 

pdata char xdata *ext_ptr ; 

   |         | 

location     | 

of pointer   | 

        Memory space pointed into 

        by pointer 

In this example strings are always copied from the CODE area into an XDATA b 

uffer. By customising the library function "strcpy()" to use a CODE source p 

ointer and a XDATA destination pointer, the runtime for the string copy was 

reduced by 50%. The new strcpy has been named strcpy_x_c(). 

The function prototype is: 

extern char xdata *strcpy(char xdata*,char code *) ; Here is the code produc 

ed by the spaced pointer strcpy(): 

; char xdata *strcpy_x_c(char xdata *s1, char code *s2)  { 

_strcpy_x_c: 

    MOV      s2?10,R4 

    MOV      s2?10+01H,R5 

;__ Variable 's1?10' assigned to Register 'R6/R7' __ 

;   unsigned char i = 0; 

;__ Variable 'i?11' assigned to Register 'R1' __ 

    CLR      A 

    MOV      R1,A 

?C0004: 

; 

;   while ((s1[i++] = *s2++) != 0); 

    INC      s2?10+01H 

    MOV      A,s2?10+01H 

    MOV      R4,s2?10 

    JNZ      ?C0008 

    INC      s2?10 

?C0008: 

    DEC      A 

    MOV      DPL,A 

    MOV      DPH,R4 

    CLR      A 

    MOVC     A,@A+DPTR 

    MOV      R5,A 

    MOV      R4,AR1 

    INC      R1 

    MOV      A,R7 

    ADD      A,R4 

    MOV      DPL,A 

    CLR      A 

    ADDC     A,R6 

    MOV      DPH,A 

    MOV      A,R5 

    MOVX     @DPTR,A 

    JNZ      ?C0004 

?C0005: 

;   return (s1); 

; } 

?C0006: 

    END 

Notice that no library functions are used to determine which memory spaces a 

re intended. The function prototype tells C51 only to look in code fot the s 

tring and xdata for the RAM buffer. 

---------------------------------------------------------------------------- 

---- 

  



-- 

Ours is essentially a tragic age, so we refuse to take it tragically.