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

144 The Quintessential PIC Microcontroller

The maximum delay is when COUNT is initialized to zero which gives an e ective value for N of 256.6 In this situation the number of cycles in this code fragment is 767, plus the few cycles calling the subroutine (2˜), clearing COUNT (1˜) and returning from the subroutine (2˜), giving a total of 772˜. With a clock rate of 4 MHz, each cycle takes 1 µs (see Fig. 4.4 on page 87) giving a total ceiling 772 µs delay.

Program 6.1 A 100 ms delay subroutine.

; ************************************************************

; ************************************************************

Nequ d’130’ ; Delay parameter

Program 6.1 uses two register files to extend this count. Whenever COUNT_L has decremented to zero, COUNT_H is decremented. This inner loop takes (256 × 3) − 1 cycles in the normal way and is repeated H times, where H is the initial setting of COUNT_H. Only when this second byte reaches zero is the outer loop exited and execution returned to the caller. This second count contributes (H × 3) − 1 cycles to the total. We thus need to determine the unknown value of H to give a total of 100, 000 − 7 cycles, taking into account the call, return and the three setting up instructions.

This gives an actual delay of 100.107 ms; an error of less than 0.11%. Each incremental change in H gives an alteration of ±770 µs.

The maximum delay available with this structure is 197 ms; however, adding one or more nop instructions at the beginning of the inner loop

6If N is zero then it will decrement 00 → FF → FE → · · · 01 → 00 and exit.

6. Subroutines and Modules 145

will increase the total delay by H × 256 cycles and the same technique used in the inner loop adds H cycles for fine tuning. Example 6.3 gives an example of a very long triple count delay subroutine.

Our 100 ms delay program is an example of a double-void subroutine, in that no parameters (cf. signals in our hardware analog) are sent to it and nothing is returned – just the side e ect of a delay (and the alteration of two register files, W and some Status register flags). Most subroutines process parameters made available at entry time and provide data at return time.

As a simple example, consider the extension of Program 6.1 to give a delay of K × 100 ms, where K is a byte parameter ‘sent’ by the caller. The system view of this function is shown in Fig. 6.5 as a single input signal of range 1– 256, with no output signal – that is with a void output. This diagram also documents the location of all local variables used internally by the subroutine. This latter attribute is useful in checking for multiple usage of a file register between di erent subroutines and callers. Notice the double line vertical borders commonly used in flow diagrams to denote modules or subroutines.

Internal workspace

Fig. 6.5 System view of K × 100 ms delay subroutine.

As there is only one input byte-sized parameter, the most convenient place to place K is in the Working register. Thus to call up a 5-second delay, the caller could use the sequence:

The actual subroutine itself in Program 6.2 implements the task list:

1.DO:

(a)Delay 100ms.

(b)Decrement K.

2.WHILE (K > 0).

3.End.

The actual coding simply copies the parameter from W into File 32h before entering the following delineated coding, which is identical to Program 6.1 and gives a single 100 ms delay. On completion of the delay K

146 The Quintessential PIC Microcontroller

Program 6.2 A K × 100 ms delay subroutine.

; ************************************************************

; ************************************************************

Nequ d’130’ ; Delay parameter

is decremented in situ and the delay block repeated until K reaches zero. Thus the 100 ms block is repeated K times.

As K is tested for zero after the 100 ms delay is executed7 an initial value of K = 0 will be treated as K = 256, giving a delay range of 00.1– 25.6 s. Testing before the loop8 would give a range 0–25.5 s. Actually, the delay will be a few µs longer than the plain 100 ms delay subroutine, due to the three additional instructions outside the delineated code block.

As W is needed to set up COUNT_H it could not be used directly to hold K during the subroutine. In fact, if the caller had known that File 32h was used by the subroutine to hold K then it could have been passed directly through this register file. However, the less the caller has to know about the ‘innards’ of its subroutines the better it will be, on the basis

7Known to C programmers as a DO-WHILE loop. 8Known to C programmers as a WHILE loop.

148 The Quintessential PIC Microcontroller

These segments are typically implemented using light-emitting diodes (see Fig. 11.13 on page 298) or electrodes in a liquid-crystal cell.

(a) System view

a

f b

g

e c

d

1000000 1111011 10100100 0110000 0011001 0010010 0000010 1111000 0000000 0010000

gfedcba

(b) The 7-segment font

Fig. 6.6 The 7-segment display.

The system description of our subroutine is shown in Fig. 6.6(a). Here the input signal is a 4-bit binary code representing the ten decimal digits as 0000 – 1001b in the Working register. The output, also in W, is the corresponding 7-segment code to activate the digit as listed in Table 6.2. This code assumes that a segment is lit/opaque on a binary 0 and unlit/clear on a binary 1.

Most MPU/MCUs deal with look-up tables by storing the codes as part of the program memory and copying the Nth byte out of the table as the mapping function. In the 12and 14-bit core PICs the Havard structure makes code in the Program store inaccessible to the program – but see Fig. 15.6 on page 445 for an exception. Instead, look-up tables are implemented as a series of retlw instructions, each returning a constant byte. This structure is shown in Table 6.2. As each retlw places an 8-bit code in W, I have arbitrarily made the unused bit 7 a logic 1.

In developing a coding based on this table structure, the mechanism for element N extraction is to execute the Nth retlw instruction. This will place the instruction literal in the Working register and then do a normal return form subroutine back to the caller. In the example shown, if N is seven then the 7th retlw is executed returning with the code

11111000b for in W.

The coding shown in Program 6.4 implements this selection mechanism by simply adding N, which is in W, to the lower byte of the Program Counter – that is PCL in File 2. PC then points to the Nth retlw as desired.