***WARNING 15: MULTIPLE CALL TO SEGMENT SEGMENT: ?PR?FUNC1?MAIN2

CALLER1: ?PR?TIMER0_INT?MAIN2 CALLER2: ?C_C51STARTUP

8.4.2.6 Multiple Call To Segment Solution

The solution is to:

(i) Declare func1 as REENTRANT thus:

void func1(void) reentrant { }

(ii) Use OVERLAY linker option thus:

main2.obj & to main2.abs &

OVERLAY(main ~ func1,timer0_int ~ func1)

to break connection between main and func1 and timer0_int and func1.

OVERLAY MAP OF MODULE: MAIN2.ABS (MAIN2)

?PR?MAIN?MAIN2

+—> ?PR?FUNC2?MAIN2

***WARNING 16: UNCALLED SEGMENT, IGNORED FOR OVERLAY PROCESS SEGMENT: ?PR?FUNC1?MAIN2

This means that the safe overlaying of func1 with other background functions will not occur. Removing the link only with the interrupt would solve this:

main2.obj & to main2.abs &

OVERLAY(timer0_int ~ func1)

Another route would be to disable all overlaying but this is likely to eat up large amounts of RAM very quickly and is thus a poor solution.

main2.obj & to main2.abs & NOOVERLAY

With the MULTIPLE CALL TO SEGMENT WARNING the only really “safe” solution is to declare func1 as REENTRANT, with the duplicate function a good second. The danger of using the OVERLAY command is that a less experienced programmer new to the system might not realise that the interrupt is restricted as to when it can call the function and hence system quality is degraded.

8.4.3 Overlaying Public Variables

All the preceding examples deal with the overlaying of locals and parameters at a function level. A case occurred recently in which the program was split into two distinct halves; the divide taking place very early on. To all intents and purposes the 8051 was able to run one of two completely different application programs, based on some user input during initialisation.

Each program half had a large number of public variables, some of which were known to both sides but the majority of which were local to one side only. This is almost multitasking.

This type of program structure really needs a new storage class like “GLOBAL”, with public meaning available to a certain number of modules only. GLOBAL would then be available to all modules. The new C166 supports this type of task-based variable scope. Unfortunately C51 does not, so a fix is required.

The linker’s OVERLAY command does not help, as it only controls the overlaying of local and parameter data. One possible solution uses special modules to declare the publics. Module1 declares the publics for program (task1); Module2 declares the publics for program2 (task2). Finally, Module3 declares the publics which are available to both sides.

The trick then is to use the linker to fix the data segments on Module1 and Module2 at the same physical address, whilst allowing Module3’s variables to be placed automatically by the linker.

This solution uses three special modules for declaring the publics:

/* Example of creating two sets of public data */ /*in same memory space */

extern void main1(void) ; extern void main0(void) ;

/* Main module where system splits into two parts */

void main(void) { bit flag ;

} ^^^^^^^^^^^^^^^^^^^^^^^ End of Module

/* Module that declares publics for branch 2 */

/* Publics for branch 2 */

unsigned char x2,y2 ; unsigned int z2 ; char a2[0x30] ;

/* A variable which is accessible from both branches */

extern int common ;

^^^^^^^^^^^^^^^^^^^^^^^ End of Module

void main0(void) {

unsigned char c0 ; /* Local - gets overlaid with c1 in*/ /*other branch */

x2 = 0x80 ;

y2 = x2 ;

c0 = y2 ;

z2 = x2*y2 ;

a2[2] = x2 ;

common = z2 ;

}

^^^^^^^^^^^^^^^^^^^^^^^ End of Module

/* Module that declares publics for branch 1 */

/* Publics for branch 1 */

unsigned char x1,y1 ; unsigned int z1 ; char a1[0x30] ;

/* A variable which is accessible from both branches */

extern int common ;

void main1(void) {

char c1 ;

x1 = 0x80 ;

y1 = x1 ;

c1 = y1 ;

z1 = x1*y1 ; a1[2] = x1 ;

common = z1 ;

}

^^^^^^^^^^^^^^^^^^^^^^^ End of Module

/* Module that declares variables that both */ /*branches can access */

int common ; /* A variable common to both branches */

^^^^^^^^^^^^^^^^^^^^^^^ End of Module

/* Linker Input */

l51 t.obj,t1.obj,t2.obj,com.obj to t.abs DATA(?DT?T1(20H),?DT?T2(20H))

The choice of “20H” for the location places the combined segments just above the register banks.

The main problem with this approach is that a DATA overlay warning is produced. This is not dangerous but is obviously undesirable.

9 Other C51 Extensions

9.1 Special Function Bits

A frustration for assembler programmers with the old C51 version was the need to use bit masks when testing for specific bits with chars and ints, despite there being a good set of bit-orientated assembler instructions within the 8051. In version 3, however, it is possible to force data into the bit-addressable area (starting at 0x20) where the 8051’s bit instructions can be used.

An example is testing the sign of a char by checking for bit = 1.

Here the char is declared as “bdata” thus:

bdata char test_char ;

sign_bit is defined as:

sbit sign_bit = test_char ^ 7 ;

to use this:

test_char = counter ;

if(sign_bit) { /* test_char is negative */ }

the opcodes executed are:

/* Negative */

DONE:

All of which is a lot faster than using bit masks and &'s!

The important points are that the “bdata” tells C51 and L51 that this variable is to be placed in the bit-addressable RAM area and the “sbit sign_bit = test_char ^ 7” tells C51 to assume that a bit called sign_bit will be located at position 7 in the test_char byte.

The situation with ints is somewhat more complicated. The problem is that the 8051 does not store things as you first expect. The same sign test for an int would require bit 7 to be tested. This is because the 8051 stores int’s high byte at the lower address. Thus bit 7 is the highest bit of the higher byte and 15 is the highest bit of the lower.

Bit locations in an integer

9.2 Support For 80C517/537 32-bit Maths Unit

The Infineon 80C537 and 80C517A group have a special hardware maths unit, the MDU, aimed at speeding-up numbercrunching applications.

9.2.1 The MDU - How To Use It

To allow the 8051 to cope with 16 and 32-bit (“int” and “long”) multiplication and division, the Infineon 80C517 variant has a special maths co-processor (MDU) integrated on the cpu silicon. A 32-bit normalise and shift is also included for