Файл: The quintessential PIC microcontroller (S. Katzen, 2000).pdf

CHAPTER 6

Subroutines and Modules

Good software should be configured as a set of interacting modules rather than one large program working straight through from beginning to end. There are many advantages to modular programming, which is almost mandatory when code lengths exceed a few hundred lines or when a project is being developed by a team.

What form should should such modules take? In order to answer this question we will look at the use of program structures designed to facilitate this modular approach and the instructions associated with it.

After completing this chapter you will:

•Appreciate the need for modular programming.

•Have an understanding of the structure of the stack and its use in the call–return subroutine and interrupt mechanisms.

•Understand the term nested subroutine.

•See how parameters can be passed to a subroutine, by copy or reference, and altered or returned to the caller.

•Be able to write a subroutine having a minimal impact on its environment.

•Be able to synthesize a software stack to open and close a frame in the Data store to pass parameters and provide a temporary workspace.

Take a look at the inside of your personal computer. It will probably look something like the photograph in Fig. 6.1, with a motherboard hosting the MPU, assorted memory and other support circuitry, and a variable number of expansion sockets. Into this will be plugged a disk controller card and a video card. There may be others, such as a soundboard, modem or network card. Each of these plug-in cards has a distinct and separate logical task and they interact via the services supplied by the main board – the motherboard.

There are many advantages to this modular construction.

•Flexibility; that is it is relatively easy to upgrade or reconfigure by adding or replacing plug-in cards.

•Can reuse from previous systems.

•Can buy in standard boards or design specialist boards in-house.

•Easy to maintain.

140 The Quintessential PIC Microcontroller

100 ms delay

Subroutine return

Program call More program call Even more program

Main flow

Fig. 6.2 Subroutine calling.

The problem really is how to get back again! Somehow the MPU has to remember from where in the caller program the subroutine was entered so that it can return to the next instruction in the caller’s sequence. This can be seen in Fig. 6.2, where the jumping-o point can be from anywhere in the main program, or indeed from another subroutine – the latter process is called nesting – see Fig. 6.4.

One possibility is to place this address in a designated Address register or memory location prior to jumping o . This can then be moved back into the PC at the end of the subroutine as the return mechanism. This approach breaks down whenever one subroutine wishes to call another. Then the secondary subroutine will overwrite the return address of the first, and the main program can never be regained. To get around this problem, more than one register or memory location could be used to hold a stack of return addresses. This last-in first-out stack structure is shown in Fig. 6.3(a).

The 14-bit core PICs have a stack of eight 13-bit registers which are exclusively used to hold subroutine return addresses.3 This structure, shown in Fig. 6.3, is known as a hardware stack. This stack is outside the PIC’s normal memory map, so its contents cannot be altered by any normal process.4

Associated with this stack is a 3-bit counter which points to the next available register in the stack. This Stack Pointer (SP) cannot be explicitly altered by any instruction but it is automatically incremented each time a call instruction is executed. call is similar to a goto instruction, but before the specified instruction address is put into the Program Counter the current value of PC is pushed into the stack. This is the address of the instruction after the call instruction, as the PC has already been

3The 12-bit core devices have only two 11-bit stack registers and the 16-bit core PICs have a 16-deep stack.

4Most MPU/MCUs use an area of normal RAM together with a dedicated address register to implement their stack. This is much more flexible than a dedicated hardware stack but needs a more complex instruction set to manipulate the Stack pointer and to push and pull/pop data into and out of the stack.

6. Subroutines and Modules 141

incremented and the PIC is fetching this next instruction into the pipeline at the same time as the call instruction is being executed – see Fig. 4.4 on page 87.

(a) Before

Fig. 6.3 Using the hardware stack hold return addresses.

In Fig. 6.3(b) the situation is shown after a call to a subroutine labelled DELAY_100MS. The execution sequence of this call DELAY_100MS is:

1.Copy the 13-bit contents of the PC into the stack register pointed to by the Stack Pointer. This will be the address of the instruction following the call instruction.

2.The Stack Pointer is decremented.

3.The destination address DELAY_100MS, that is the location of the entry point instruction of the subroutine, overwrites the original state of the PC. E ectively this causes the program execution to transfer to the subroutine.

Apart from the pushing of the return address into the stack in steps 1 and 2, call acts exactly like a plain goto. Thus call requires two bus cycles for execution as the pipeline needs to be flushed to remove the next caller instruction which is already in situ. This similarity also applies to the extension of its 11-bit absolute address in the call instruction word to a 13-bit Program store address using bits 3 & 4 of the PCLATH register, as shown in Fig. 5.4 on page 114. Far calls to subroutines located between

6. Subroutines and Modules 143

path. This pattern is matched by the last-in first-out (LIFO) structure of the stack mechanism, which can handle any arbitrary nesting sequence to any depth of eight subroutines automatically. It can even handle the (painful) situation where a subroutine calls itself! Such a subroutine is known as recursive. As we shall see in the next Chapter 7, the stack mechanism is also used to handle interrupts. Thus, in a system using both subroutines and interrupts the nesting depth will be somewhat less. The technique is so useful that virtually all MPU/MCUs support subroutines in this manner.

As the stack-Stack Pointer mechanism is part of the PICs hardware and requires no initialization, from the programmer’s perspective only the following points are relevant:

•The subroutine should be invoked using the call instruction.

•The entry point to a subroutine should be labelled, and this label is then the name of that subroutine.

•The exit point from the subroutine should be either return or retlw, with the latter being used when a known constant is to be in the Working register on return – see Program 6.4.

As an example, let us code the 0.1 second (100 ms) delay subroutine of Fig. 6.2. Creating a delay in software is simply a matter of doing nothing for the appropriate duration. A common way of doing this is to count down an initial constant to zero. By choosing an appropriate constant, the delay can be tailored to the desired value. Obviously, this delay will depend on the PIC’s oscillator rate. For the examples in this chapter we will assume a clock rate of 4 MHz, giving a bus cycle of 1 µs.

Consider the single-byte count code fragment:

This continually decrements the initial setting N of the register file labelled COUNT, dropping out when it reaches zero. The total delay is contributed by both instructions as:

1.The decfsz takes one cycle to execute, except when N reaches zero, in which case two cycles are needed as the pipeline needs to be flushed

– see page 127. This gives a total execution time of [(N −1) ×1] +2.

2.As the loop exits by skipping over the goto instruction, this is only executed N − 1 times; each time taking two bus cycles. This contribution is thus (N − 1) × 2.