Four basic program structures

Below we introduce four basic program structures

1) Sequential structure

* A structure in which program modules or instructions are executed sequentially.

2) Branch structure

* The structure of jumping to different program segments (branches) according to conditions.

* Branches should not be transfers between modules, and the process should return to the main line after executing the branch.

* Be careful not to enter the entrance of another branch from the exit of one branch

3) Loop structure

* Repeat a certain program according to the loop control conditions for continuous repetitive operations.

* The loop includes the loop body and loop control; the loop structure also includes loop initialization and post-processing. There are two types of loop control: count loop and conditional loop.

* Loops can be nested, but they should not cross, and you should not jump into a loop from outside the loop body.

Reprinting must retain the address: http://www.51hei.com/mcu/286.html

4) Subroutine structure

* In the main program, the call subroutine instruction is executed, and the CPU switches to execute the subroutine. In the subroutine, the return instruction returns to the main program and continues to execute the next instruction of the call instruction.

* When calling, the return address is pushed onto the stack first, and the subroutine is transferred to the address provided by the call instruction. When returning, the return address is popped from the stack and sent to the PC, returning to the main program.

* Function modules used in multiple places in the program can adopt subroutine structure to save program space.

* Seven elements for writing and using subroutines:

* Functional description.

* Subroutine name and entry address.

* Entry conditions.

* Export status.

* Occupies resources.

* Calls in subroutines.

* Four points to note when writing and using subroutines:

* Site protection and site recovery to avoid conflicts with the main program.

* Stack operations should be performed in pairs, with PUSH first to protect the return address.

* Multiple calls should take the stack capacity into consideration, and direct or indirect reflexive calls should not be made.

* Prevent entering a subroutine without a call, and prohibit jumping out of a subroutine without a return instruction.