Issues that need attention in single chip C language delay

There is no empty statement in the standard C language. However, in C language programming of microcontrollers, it is often necessary to use several empty instructions to produce a short delay effect. This is easy to achieve in assembly language, just write a few nops.

In Keil C51, call the library function directly:

#include // declares void _nop_(void);

_nop_(); // Generate a NOP instruction

Function: For very short delays, which are required to be at the us level, use the "_nop_" function, which is equivalent to the assembly NOP instruction, with a delay of several microseconds. The NOP instruction is a single-cycle instruction, and the delay time can be calculated from the crystal frequency. For a 12M crystal, the delay is 1uS. For longer delays, which are required to be greater than 10us, use the loop statement in C51 to achieve it.

When choosing a loop statement in C51, pay attention to the following issues

First, when defining loop variables in C51, try to use unsigned character variables.

Second, in the FOR loop statement, try to use variable subtraction to loop.

Third, in the do...while and while statements, the variables in the loop body are also reduced.

This is because in the C51 compiler, different instructions are used to implement different loop methods.

Here are some examples:

unsigned char i;

for(i=0;i<255;i++);

unsigned char i;

for(i=255;i>0;i--);

Among them, after the second loop statement C51 is compiled, it is completed with the DJNZ instruction, which is equivalent to the following instruction:

MOV 09H, #0FFH

LOOP: DJNZ 09H, LOOP

The instructions are quite concise and it is also easy to calculate the precise delay time.

The same is true for do...while and while loop statements.

example:

unsigned char n;

n=255;

do{n--}

while(n);

or

n=255;

while(n)

{n--};

After these two loop statements are compiled by C51, they form the method completed by DJNZ.

Therefore, it is also very convenient to calculate the exact time.

Third: For those who require a longer delay time, the nested loop method should be used. Therefore, the nested loop method is often used to achieve a delay of ms. The loop statement can also be completed using the for, do...while, while structure, and the variables in each loop body are still unsigned character variables.

unsigned char i,j

for(i=255;i>0;i--)

for(j=255;j>0;j--);

or

unsigned char i,j

i=255;

do{j=255;

do{j--}

while(j);

i--;

}

while(i);

or

unsigned char i,j

i=255;

while(i)

{j=255;

while(j)

{j--};

i--;

}

All three methods use DJNZ instructions to nest loops, which are implemented by the C51 compiler using the following instruction combination:

MOV R7, #0FFH

LOOP2: MOV R6, #0FFH

LOOP1: DJNZ R6, LOOP1

DJNZ R7, LOOP2

The combination of these instructions uses the DJNZ instruction in assembly language to delay, so its accurate time calculation is also very simple. Assuming that the initial value of the variable i is m and the initial value of the variable j is n, the total delay time is: m×(n×T+T), where T is the execution time of the DJNZ instruction (DJNZ instruction is a two-cycle instruction). Here +T is the time used by the MOV instruction. Similarly, for longer delays, multiple cycles can be used to complete it.

Just pay attention to the above issues when programming loop statements.

The following are some issues to pay attention to when designing a delay subroutine in C51:

1. When designing precise delay subroutines in C51, try not to define local variables in the delay subroutines or define as few local variables as possible in the delay subroutines. All variables in the delay subroutines are passed through parameterized functions.

2. When designing a delay subroutine, it is better to use the do...while structure as the loop body rather than the for structure.

3. When designing a delay subroutine, if you want to nest the loop body, it is better to use the inner loop first and then reduce it rather than reduce it first and then the inner loop.

unsigned char delay(unsigned char i,unsigned char j,unsigned char k)

{unsigned char b,c;

b="j";

c="k";

do{

do{

do{k--};

while(k);

k="c";

j--;};

while(j);

j=b;

i--;};

while(i);

}

This precise delay subroutine is compiled by C51 into the following instruction combination

The delay subroutine is as follows:

MOV R6,05H

MOV R4,03H

C0012: DJNZ R3, C0012

MOV R3，04H

DJNZ R5, C0012

MOV R5，06H

DJNZ R7, C0012

RET

Assuming that the initial value of parameter variable i is m, the initial value of parameter variable j is n, and the initial value of parameter variable k is l, the total delay time is: l×(n×(m×T+2T)+2T)+3T, where T is the execution time of DJNZ and MOV instructions. When m=n=l, the precise delay is 9T, the shortest; when m=n=l=256, the precise delay is 16908803T, the longest.