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

6. Subroutines and Modules 151

(b)IF Carry bit is one THEN and Multiplicand to subproduct.

(c)Shift Multiplicand right once.

(d)Repeat WHILE product not zero.

4.End with 16-bit Product.

Program 6.5 declares the variables that are passed to and from the subroutine at the of the main program. Keeping all these global declarations in one part of the program and using a di erent file register for each overall global variable reduces the possibility of interaction but at the expense of rather extravagant use of scarce Data memory resources. Temporary local storage is declared within each subroutine as its need will be ‘thrown away’ after the subroutine is terminated. However, interaction can still occur in local storage where nested subroutine structures are used.

The coding follows the task list closely. The decision whether to add the left-shifted multiplicand to the subproduct is dependent on the state of the Carry flag when the multiplier is shifted right. This implements the conditional addition

product = product + (multiplicand<<n) × bit n

Rather than implementing this shift and conditional add process eights times, the summation loop is terminated whenever the multiplier residue is zero. This means that the execution time of the subroutine is variable, depending on the bit pattern of the multiplier. The worst-case scenario is when the multiplier is 255 (11111111b). This takes 142 cycles including the two cycle call.

In order to use this subroutine, the caller copies the multiplicand into File 20h and multiplier into File 21h. On return, the 16-bit product can be read at File 2E:Fh. As an example, consider that the bytes located at File 42h and File 46h are to be multiplied.

Most MPU/MCUs have software stacks which in addition to saving subroutine return addresses allow the programmer to push and pull data to and from memory to pass information between caller and subroutine. As the stack is a dynamic storage entity, growing where necessary to accommodate these passed and temporary variables and shrinking again when the subroutine terminates, this clearly is an e cient method of memory allocation. Furthermore, each call outwards in a nested structure opens a new stack frame for this dynamic storage as an extension to the

152 The Quintessential PIC Microcontroller

Program 6.5 The byte multiplication subroutine.

;The MULT subroutine

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

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

;Local declarations

MULTIPLICAND_H equ 30h

; Task 1: Zero double-byte product MUL clrf PRODUCT_L

clrf PRODUCT_H

; Task 2: Extend multiplicand to 16 bits clrf MULTIPLICAND_H

;Task 3: DO

;Task 3A: Shift multiplier right once

6. Subroutines and Modules 155

(b)Copy the Multiplicand from memory (we assume it is at File 46h as in our last example) into W and then indirectly into the frame using INDF as the target. Decrementing the FSR completes the push action.

(c)In a similar manner, the Multiplicand is pushed into the stack.

(d)Call the subroutine.

Coding of the subroutine MUL_S is given in Program 6.6. This implements items 2–4 of Fig. 6.8. Firstly, MULTIPLICAND_H, the temporary storage of the multiplicand overflow, is zeroed and then zero is pushed into the next two locations to create the initial value for the product. In item 4 the Pseudo Stack Pointer is reset to point to the next free byte below the frame. In this way, should the subroutine wish to call another, then there will be a new frame available for that next-level storage with the new TOF beginning just below the old frame. These two instructions may be omitted in this case as there are no further nested call outs, although Task 3C will have to be altered. This is done in Example 6.6.

The core of the subroutine, that is Task 3, is similar to Program 6.5 but the FSR has to be moved up and down the frame to access the appropriate level. The only non-obvious use of the FSR is at Task 3C. As there are two ways into this routine, depending on whether the shifted multiplicand is added to the product or not, the state of the FSR is unknown. It can however be reset from the PSP which is pointing to just below the frame at this point. By adding five to this PSR value, the FSR will always point to MULTIPLICAND.

Finally the subroutine ‘cleans up’ the stack by updating the Pseudo Stack Pointer to its previous value. In this case this is done by adding five, but in general by adding the frame depth n.

Program 6.6 requires 45 instructions as compared to 20 in Program 6.5. Its worst-case execution time of 274 cycles also compares unfavorably

156 The Quintessential PIC Microcontroller

with 142 cycles. Thus in all respects except reusability and robustness this stack-based model is clearly inferior. It may be more economical in

Program 6.6 Implementing a byte multiply using a stack model. (continued next page).

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

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

;Tasks 1 & 2: Extend multiplicand and zero double-byte product

;Task 3: DO

;Task 3A: Shift multiplier right once

; Task 3B: IF Carry == 1 THEN add multiplicand to product btfss STATUS,C ; IF C == 1 THEN do addition

goto MUL_CONT ; ELSE skip this task