VI XỬ LÝ Vxl ch03 8051 3 9 cau truc va tk chuong trinh

System & Program
Developments of 8051
“

Program Structure and Design
“
“
“
“
“

“

Introduction
Advantages and Disadvantages of Structured
Programming
The Three Structures: statements, loops, choice
Pseudo Code Syntax
Assembly Language Programming

Tools & Techniques for Program
Development
“
“
“

The Development Cycle
Integration and Verification
Command and Environments

2011/12/7

T. L. Jong, Dept. of E.E., NTHU

1


Introduction
“

Structured Programming:
“

“

“

Organizing and coding programs that reduces
complexity, improves clarity, and facilitates
debugging and modifying
All programs may be written using only three
structures: statements, loops, and choice—too
good to be true.

Introduce Structure programming to
assembly language programming
“
“
“

2011/12/7

Flowcharts
Pseudo code
Assembly language
T. L. Jong, Dept. of E.E., NTHU

2


Flowcharts
Decision block

Off-page connector

Process box

Predefined process
(subroutine)

Input/Output block

Program flow arrow

Program terminator

2011/12/7

T. L. Jong, Dept. of E.E., NTHU

3

Pseudo Code
“ Strict

adherence to structure in
combination with informal language
“ [get a character from the keyboard]
“

IF [condition is true]
THEN [do statement 1]
ELSE BEGIN
[do statement 2]
[do statement 3]
END

2011/12/7

T. L. Jong, Dept. of E.E., NTHU

4


Advantages & Disadvantages of
Structured Programming
“

Advantages:
“ Simple to trace, debug

“ Finite number of structures
“ Structures as building block
“ The set of structure is complete
“ Structures are self-documenting, easy
to read
“ Structures are easy to describe in
flowcharts, syntax diagrams, pseudo
code,..
“ Increased program productivity

2011/12/7

T. L. Jong, Dept. of E.E., NTHU

5


Advantages & Disadvantages of
Structured Programming
“ Disadvantages:
“ Only

a few high-level languages (Pascal,
C, PL/M) accept the structures directly;
others require extra translation stage
“ Structured program may execute slower
and require more memory
“ Some problems (a minority) are more
difficult to solve using only the three
structures

“ Nested structures can be difficult to
follow
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

6


The Three Structures
“ Statements
“ [count

= 0]
“ PRINT_STRING(“Select Option:”)
“ Loops

(iteration)

“ WHILE/DO
“ REPEAT/UNTIL

“ Choice
“ IF/THEN/ELSE
“ CASE

2011/12/7

T. L. Jong, Dept. of E.E., NTHU

7


The WHILE/DO Statement
WHILE [condition] DO
[statement]
(statement might not be performed at all!)
“

Enter

Condition
True?

WHILE [c == 1] DO
[statement]
No
ENTER:
STATEMENT:

Yes
EXIT:

Statement
2011/12/7

JNC
EXIT
(statement)
JMP

ENTER
(continue)

Exit

T. L. Jong, Dept. of E.E., NTHU

8


WHILE/DO: SUM Subroutine
[sum (A) = 0]
WHILE [length (R7) > 0] DO BEGIN
[sum = sum + @pointer (R0)]
[increment pointer]
[decrement length]
END
8051 code (closely structured; 13 bytes)

(loosely structured; 9 bytes)

SUM: CLR A
LOOP: CJNZ R7,#0,STAM
JMP EXIT
STAM: ADD A,@R0
INC R0
DEC R7
JMP LOOP:
EXIT: RET

SUM:

2011/12/7

CLR
INC
MORE: DJNZ
RET
SKIP: ADD
INC
SJMP

T. L. Jong, Dept. of E.E., NTHU

A
R7
R7,SKIP
A,@R0
R0
MORE
9


WHILE/DO
Pseudo code:
WHILE [ACC != CR AND R7 != 0] DO
[statement]
Enter

ACC !=

<CR>?

8051 code:
ENTER:

No

Yes
No
R7 != 0?
Yes
Statement

2011/12/7

Exit

CJNE A,#0DH,SKIP
JMP
EXIT
SKIP:
CJNE R7,#0,STAM
JMP
EXIT
STAM: (one or more statements)
.
.
JMP
ENTER
EXIT:

(continue)

T. L. Jong, Dept. of E.E., NTHU

10


The REPEAT/UNTIL Statement
REPEAT
[statement]
UNTIL
[condition]
(statement performed at least once)
“

Enter

REPEAT
UNTIL

[statement]
[c == 1]

Statement
No

Condition
True?

ENTER: (statement)

JNC
ENTER
EXIT: (continue)

Yes

Exit
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

11


The REPEAT/UNTIL Statement
“

REPEAT
UNTIL

[ACC = @pointer]
[increment pointer]
[ACC == ‘Z’ or ACC == 0]

Enter

8051 code:
Get a char

Inc pointer

No
Char =
“Z”?
Yes

No

STAM: MOV
INC
JZ
CJNE
EXIT: RET

A,@R0
R0
EXIT
A,#’Z’,STAM

Char =
0?
Yes

Exit
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

12

The IF/THEN/ELSE Statement
“

IF

[condition]
THEN [statement 1]
ELSE [statement 2]
Enter

No

condition
true?

Statement 2

Yes

Statement 1

Exit

2011/12/7

T. L. Jong, Dept. of E.E., NTHU

13

The IF/THEN/ELSE Statement
[input character]
IF [input character == graphic]
THEN [echo character]
8051 code:
ELSE [echo ‘.’]
Enter

Input character

No

Graphic
char?

Echo “.”

Echo char

Exit
2011/12/7

Yes

(closely structured; 14 bytes)
ENTER:
ACALL INCH
ACALL ISGRPH
JNC
STMENT2

STMENT1:
ACALL OUTCH
JMP
EXIT
STMENT2:
MOV
A,#’.’
ACALL OUTCH
EXIT:
(continue)
(loosely structured; 10 bytes)
ACALL INCH
ACALL ISGRPH
JC
SKIP
MOV
A,#’.’
SKIP:
ACALL OUTCH
(continue)

T. L. Jong, Dept. of E.E., NTHU

14


The CASE Statement

Enter

CASE [expression] OF
0: [statement 0]
1: [statement 1]
2: [statement 2]
.
.
N: [statement 0]
[default]
END_CASE

expression No expression No expression No
0?
1?
2?
Yes
Statement 0

Yes
Statement 1

Yes
Statement 2

expression
n?

No

Yes
Statement n

default

Exit
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

15


The CASE Statement
[input a character]
CASE [character] OF
‘0’: [statement 0]
‘1’: [statement 1]
‘2’: [statement 2]
‘3’: [statement 3]
END_CASE

Enter

Input
character

char
== “0”?
Yes
Action 0

No

char
== “1”?
Yes
Action 1

No

char
== “2”?

No

Yes
Action 2

char
== “3”?

No

Yes
Action 3

Exit
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

16


The CASE Statement
8051 code:
(closely structured)
ACALL INCH
CJNE
A,#’0’,SKIP1
ACT0:
.
.
JMP
EXIT
SKIP1: CJNE
A,#’1’,SKIP2
ACT1:
.
.
JMP
EXIT
SKIP2: CJNE
A,#’2’,SKIP3
ACT2:
.
.
JMP
EXIT
SKIP3: CJNE
A,#’3’,EXIT

ACT3:
.
.
EXIT:

2011/12/7

(continue)

(loosely structured)
ACALL INCH
ANL
A,#3
;reduce to 3 bits
RL
A
MOV
DPTR,#TABLE
JMP
@A+DPTR
TABLE: AJMP
ACT0
AJMP
ACT1
AJMP
ACT2
ACT3:
.
.
JMP

EXIT
ACT0:
.
.
JMP
EXIT
ACT1:
.
.
JMP
EXIT
ACT2:
.
.
EXIT:
(continue)

T. L. Jong, Dept. of E.E., NTHU

17


The GOTO Statement
“

“

“

2011/12/7

GOTO statement can always be avoided by
using the structures. Sometimes GOTO
statement provides an easy method of
terminating a structure when errors occur.
GOTO statements usually becomes
unconditional jump in assembly
implementation. Extreme caution is needed.
Never exit a subroutine using GOTO instead
of normal return for the return address will
be left on the stack and eventually stack
overflow will occur.

T. L. Jong, Dept. of E.E., NTHU

18


Pseudo Code Syntax
Tips of using pseudo code:
“ Use descriptive language for statements
“ Avoid machine dependency in statements
“ Enclose conditions & statements in brackets: []
“ Begin all subroutines with their names followed
by a set of parameters: ()
“ End all subroutine with RETURN ()
“ Use lower text except reserved words &
subroutine names
“ Indent all statements from the structure entry
points and exit points

“ Use the commercial at sign (@) for indirect
addressing
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

19


Suggested Pseudo Code Syntax
Reserved words:
BEGIN
END
REPEAT UNTIL
WHILE
DO
IF
THEN
ELSE
CASE
OF
RETURN
Arithmetic operators:
+ addition
subtraction
* multiplication
/
division
% modulus (remainder after division)
2011/12/7

T. L. Jong, Dept. of E.E., NTHU

20