Keil C51 continuous reading method of the same port

    C language is one of the most efficient, concise and hardware-friendly programming languages ​​that is universally recognized. The transplantation of C language to the single-chip microcomputer MCS-51 began in the mid-to-late 1980s. After nearly 10 years of development, C language has overcome the shortcomings of long code generation and slow running speed. In addition, C language has unparalleled advantages over assembly language in terms of development speed, software quality, structuring, maintainability, etc., and has been increasingly widely used. Keil C51 is a single-chip microcomputer C language compilation system developed by Keil, Germany. The software is fully functional and is one of the most widely used languages ​​by domestic technical developers.
    In actual work, it is found that programs written in C language that continuously read the same port often fail to execute after being compiled by Keil C51. Take the 8051 single-chip microcomputer reading 12-bit A/D MAX197 as an example, as shown in Figure 1.
 
    In Figure 1, P1.1 port is used to read the interrupt signal sent by A/D when the conversion is completed, and P1.0 selects to read the high 4 bits or low 8 bits. Now assume that the address of A/D is 8000H, and the starting working word of CH0 port is 40H. To obtain the corresponding high and low conversion data, program in C language as follows.
#include
unsigned char xdata MAX197 _at_ 0x8000;
sbit MAXINT= P1^1;
sbit MAXHBEN= P1^0;
……
void main()
{unsigned char up4, down8; //Set up two variables to receive data
……
MAX197= 0X40; //Start A/D CH0 port for conversion
while(MAXINT) //Wait for conversion to complete
{};
P1.0=0; //Read the lower 8 bits
down8=MAX197;
P1.0=1; //Read the upper 4 bits
up4=MAX197;
}
    The above program does not get the high and low bit data as expected. In fact, the data obtained in down8 and up4 are the lower 8 bits. The following is part of the C language code after compilation.
  41: //Get the lower 8 bits
  42: MAXHBEN=0;
C:0x000C C290 CLR MAXHBEN(0x90.0)
  43: down8=MAX197;
C:0x000E 908000 MOV DPTR,#MAX197(0x8000)
C:0x0011 E0 MOVX A,@DPTR
C:0x0012 F509 MOV 0x09，A
  44: //Get the upper 4 bits
  45: MAXHBEN=1
C:0x0014 D290 SETB MAXHBEN(0x90.0)
  46: up4=MAX197;
  47:
  48: 
C:0x0016 F5O8 MOV 0x08,A //0x08 is up4
  49: }
    By analyzing the above program, we can find that the C compiled program does not read the port again after P1.0 is set to high potential, but directly sends the result of the last read to the high 4-bit variable. If the high bit is read first and the low bit is read later, two high 4-bit data will be obtained. To confirm this, put 4 C language statements that read an external port repeatedly together. After compiling, it is found that only the first statement is compiled and executed. In other words, Keil C51 performs "special" processing when compiling for repeated reading of the same port address, which is very noteworthy. So how to deal with the situation where the same port really needs to be read continuously? The following two methods are introduced for reference.

The first method: add delay.
    The delay should not be too long, especially when the conversion speed is required to be high. First, write a delay function:
void delay()
{unsigned char i;
for (i=0, i<=1;i++);
}
Then put the delay program in the middle of the above two reads.
P1.0=0; //Read the lower 8 bits
down8=MAX197:
delay();
P1.0=1; //Read the upper 4 bits
up4=MAX197;
The compiled results are as follows:
 49: //Get the lower 8 bits
 50: MAXHBEN=0:
C:0x000C C29O CLR MAXHBEN(0x90.0)
 51: down8=MAX197;
C:0x000E 908000 MOV DPTR，#MAX197(0x8000)
C:0x0011 E0 MOVX A,@DPTR
C:0x0012 F509 MOV 0x09,A
 52: delay();
 53: //Get the upper 4 bits
C:0x0014 120029 LCALL delay(C:0029)
 54:MAXHBEN = 1;
C:0x0017 D290 SETB MAXHBEN(0x90.0)
 55:up4=MAX197;
 56:
 57:
C:0x0019 E0 MOVX A,@DPTR
C:0x001A F508 MOV 0x08,A
 58: }
    It can be seen that after P1.0 is set high, the port is read and written again, the program is normal and the upper 4 bits are obtained.

The second method: set another pointer.
void main()
{unsigned char up4，down8; //Set 2 variables for receiving data
unsigned char xdata *pt1;
pt1=0x8000;
……
MAX197=0X40; //Start A/D CH0 port for conversion
while(MAXINT) //Wait for conversion to complete
{};
P1.0=0; //Read the lower 8 bits
down8= MAX197:
P1.0=1; //Read the upper 4 bits
up4=*pt1:
……
The compiled result is as follows:
 42: //Get the lower 8 bits
 43: MAXHBEN=0;
C:0x0010 C290 CLR MAXHBEN(0x90.0)
 44: down8=MAX197;
C:0x0012 908000 MOV DPTR,#MAX197(0x8000)
C:0x0015 E0 M0VX A,@DPTR
C:0x0016 F509 MOV 0x09,A
 45: MAXHBEN=1:
 46: //Take the upper 4 bits
 47:
C:0x0018 D290 SETB MAXHBEN(0x90.0)
48: up4=*pt1:
49:
50:
C:0x001A 8F82 MOV DPL(0x82),R7
C:0x001C 8E83 MOV DPH (0x83),R6
C:0x001E E0 MOVX A,@DPTR
C:0x001F F508 MOV 0x08,A
The above two methods both solve the problem that Keil C51 cannot handle continuous reading and writing of a port, but if the conversion speed requirement is particularly high, it is recommended to use the second method.