PIC 16 Delay Tutorial

by Vasily Koudymov

In programming the PIC16 family of microcontrollers, it is sometimes necessary to do absolutely nothing for a certain number of cycles thereby causing a real world delay of some amount of time. This can be useful if one is programming a clock or frequency generator for example, and it is often easier to implement a delay loop rather than using a built in TMR timer.

This document will use the following PIC16 assembly instructions:

decfsz f,d:

Although f refers to a memory location, when referring to operations performed upon f it is easier to say something like [ f = (f - 1) ] to refer to the idea of “the value at the address which is called f will now be equal to the original value at address f with one subtracted from it.” I only say this as any reader who is feeling particularly anal will say that I am in error when I say, “The new value of f will be (f - 1).” Note that although I will say that, it refers to the longer idea, it just makes following the operations much easier. Let's return to the original topic.

The instruction, decfsz performs the operation (f - 1), and if d is substituted with the character 'W', the result (f - 1) will be placed in the Working Register. If d is substituted with the character 'F', it will be placed back into f such that [ f = (f - 1) ].

With regards to the cycle time of the decfsz instruction, it goes as follows “one cycle if the (f - 1) is not equal to 0 and execute the next instruction, and one cycles if (f - 1) is equal to 0 and discard the instruction immediately after.” This is irrespective of whether or not d is 'W' or 'F'.

Examples:

; W = 0x00
; file = 0x05

decfsz file,F ; 1 cycle, will execute 'decfsz file,W'

; W = 0x00
; file = 0x04

decfsz file,W ; 1 cycle, will execute 'movlw 0x01'

; W = 0x03
; file = 0x04

movlw 0x01 ; 1 cycle, move the value 0x01 to Working Register
movwf file ; 1 cycle, file = 0x01

; W = 0x01
; file = 0x01

decfsz file,F ; 2 cycle, file = (file - 1) is zero, so discard next instruction
movlw 0x20 ; discarded, we ignore

; W = 0x01
; file = 0x00

goto k:

This command goes to the address k in the program memory. Although in higher level languages, the “goto” statement is looked down upon, in assembly languages, it is necessary to complete most programs. What is great about Microchip's assembler, which we will use to compile our PIC16 code, is that it allows using relative addresses for k rather than absolute addresses. For example, 0x1234 is an absolute address which refers to the address 0x1234 in the PIC16's program memory. Please do not confuse program memory with RAM. Ram is where file registers are located and they can be modified at runtime. However, program memory is the actual programming code which you upload to the microcontroller. In all cases while the program is running, program memory is read only. In contrast, relative addresses are as follows: If the character '$' is substituted for k, then it would refer to the current address of the goto instruction (an infinite loop resulting from this code). If “$+1” is substituted for k, then it will go to the code one instruction below the goto. If k is replaced with “$-5”, it will go to the code 5 instructions above the goto. In all cases, goto takes two cycles to execute.

Examples:

clrf PORTA 	; 1 cycle - clear PORTA file register.
goto $-1 	; 2 cycles - go one instruction above and continue execution.

In the above case, it would cause an infinite loop where PORTA is constantly cleared.

goto $+2 	; 2 cycles - go two instructions below and continue execution.
movlw 0x00 	; 1 cycle - place the value 0x00 in the W register.
andlw 0x01 	; 1 cycle - AND 0x01 and the contents of W register.

In the above case, movlw 0x00 is skipped over due to the goto, and it takes 3 cycles altogether.

Lets combine the the decfsz and goto instructions to create the simplest loop:

decfsz aa, F
goto $-1

We will refer to this as a one stage delay loop, but what would this do? So long as the instruction decfsz does not produce a value of zero, it will take 1 cycle to execute, and then will execute the goto statement after it which takes 2 cycles to execute. In sum, this segment of code will take 3 instructions each time decfsz does not produce zero. When it produces zero, decfsz will discard the goto instruction and will then take 2 cycles. So in short: 3 cycles if not resulting in zero, 2 cycles if resulting in zero.

Lets plug in some values for aa:

• aa = 1 which yields zero, and makes the total cycles 2
• aa = 2 which does not yield zero, making the first cycles 3, then it goes again with aa = 1, which takes 2 cycles, thus making a total of 5 cycles.
• aa = 3 which does not yield zero on the first pass, takes 3 cycles, then follows the cycle established by aa = 2, thus making a total of 8 cycles.

Or, in general [3(aa - 1)] + 2 cycles for this delay loop, because eventually there will be one value for aa which yields zero, while all of the rest do not. As such, if we had aa = 32, 31 of the values will take 3 cycles, and 1 of the values will take 2 cycles. We can simplify this function as follows:

[3(aa - 1)] + 2
3aa - 3 + 2
3aa - 1

What about when aa is initialized to zero?

when aa = 0, it will be decreased by one first, which will yield 255, which is a non-zero value. Effectively, initializing aa = 0, is like initializing aa = 256. Note that 256 is not a valid value for an 8 bit number, so in order to initialize aa = 256, one has to use aa = 0.

What are the limits of the delay loop?

Given that aa can effectively be set from aa = 1 to aa = 256(by way of initializing aa = 0), the minimum and maximum number of cycles which can be generated using this delay loop are found by plugging those values into the derived equation:

min: 3(1) - 1 = 2 cycles

max:3(256) - 1 = 767 cycles

Knowing this range will become important when we want to figure out how many variables we need in a delay loop. In order to simplify its presentation, the minimum and maximum number of cycles for a delay loop will be written as [2 ~767] which indicates that that using the loop with that specified range will only allow for at least 2 cycles and at most 767 cycles.

If we want to make a delay loop that includes more cycles, we would simply add another variable as follows:

decfsz aa,F
goto $-1
decfsz bb,F
goto $-3

Before we delve into what this specific code does, we will introduce new notation. cyc() will be used to refer to a delay loop cyc(aa) would mean that the delay loop only has one eight-bit variable in it (called aa), and we refer to it as a one stage loop, its output being a number of cycles. cyc(aa,bb) would mean that the loop involves two variables(called aa and bb) respectively, and we refer to it as a two stage loop. This pattern continues onward to however many variables you use. From this point onward, the following:

cyc(aa) = 3aa - 1 u [2~767]

Will be taken to mean a one stage delay loop with the formula (3aa - 1) which has one 8 bit variable called aa within it, and which can generate between 2 and 767 cycles inclusively. Note that the range for all inputs variables (such as aa) is actually [0~255] with 0 equating to 256.

With regards to what the above code is, it is a two stage loop. If time is taken to analyze the code, the following pattern will emerge:

[3(aa - 1) + 2] + { [(max of one stage loop) + 3](bb - 1) + 2}

The reason for this pattern is beyond the scope of description, but to actually derive it, it would be prudent to sit down with an empty sheet of paper, and go through a few iterations of a two stage loop. Now to actually plug in the values for the above derivation:

[3(aa - 1) + 2] + {[767 + 3](bb - 1) + 2}
[3aa - 3 + 2] + {770(bb - 1) + 2}
[3aa - 1] + {770bb - 770 + 2}
3aa - 1 + 770bb - 770 + 2
3aa + 770bb - 769

After plugging in the minimum values allowed for aa and bb as well as the maximum values, we obtain the range and our result is the following:

cyc(aa,bb) = 3aa + 770bb - 769 u [4~197119]

In addition, a general formula for any stage is found in the following:

[ previous stage cycle formula ] + [(max of previous formula) + 3][(new variable) - 1] + 2

Let us apply this to a three stage loop:

decfsz aa,F
goto $-1
decfsz bb,F
goto $-3
decfsz cc,F
goto $-5

Cycle formula:

[3aa + 770bb - 769] + [197119 + 3](cc - 1) + 2
[3aa + 770bb - 769] + [197122](cc - 1) + 2
[3aa + 770bb - 769] + [197122cc - 197122] + 2
3aa + 770bb + 197122cc -769 -197122 + 2
3aa + 770bb + 197122cc - 197889

After finding the range via plugging in allowable minimums and maximums, we obtain the formula:

cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197889 u [6~50463231]

Thus far, our formulas are:

cyc(aa) = 3aa - 1 u [2~767]
cyc(aa,bb) = 3aa + 770bb - 769 u [4~197119]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197889 u [6~50463231]

These formulas are great, so long as you copy and paste the code each time you need a delay. However, in the real world, it's more efficient and often much easier to use subroutines. A subroutine in assembly language is analogous to a function in a higher level language. Instead of typing out your code each time you need a delay, you can use subroutines. Here's how they appear in code:

; this is an excerpt from the main code section of an assembly program
call delay 		; 2 cycles, call the subroutine which we call 'delay', it's like calling a function
; the actual code for a one stage delay loop subroutine
delay:
	decfsz a,F 	; use the formula for next two lines
	goto $-1
	return 		; 2 cycle return

Or, in general:

; this is an exerpt from the main code section of an assembly program
call delay 	; 2 cycles, call the delay subroutines
; the declaration for the delay subroutine
delay:
	<code for an N-stage loop>
	return

You may notice that before, we were just using the code for an N-stage loop, however, when we turn it into a subroutine, we add on four more cycles. This applies to any number of stages. In order to adjust the stage delay loop formulas for these addition cycles, we add four to both the formula and the limits. Such that:

cyc(aa) = 3aa - 1 u [2~767]
cyc(aa,bb) = 3aa + 770bb - 769 u [4~197119]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197889 u [6~50463231]

becomes:

cyc(aa) = 3aa - 1 + 4 u [2 + 4~767 + 4]
cyc(aa,bb) = 3aa + 770bb - 769 + 4 u [4 + 4~197119 + 4]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197889 + 4 u [6 + 4~50463231 + 4]

and simplifies to:

cyc(aa) = 3aa + 3 u [6~771]
cyc(aa,bb) = 3aa + 770bb - 765 u [8~197123]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197885 u [10~50463235]

Although the formula is becoming more and more proper, there is still one last step before our formula is complete. It involves the role of initialization a loop with specific values so as to get obtain the desired number of cycles.

It is best to initialize the loop within the routine as it makes the code less clunky and it is easier to use conditional code (such as btfss, decfsz, and incfsz). The reason being that if the loop is initialized after the call statement, code like this can be used:

btfss STATUS,Z 	; check if the previous operation yielded zero
call delay 	; delay for some amount of time

while in contrast, this would not be possible if the loop was initialized outside of the subroutine:

btfss STATUS,Z 	; check if the previous operation yields zero
clrf aa 	; clear the aa variable
call delay 	; call the delay

As you see by these two examples, only in the first example is the delay conditional. The second example is not equivalent to the first as the only part which is conditional, is the clrf aa. If the previous operation does not yield zero then do not clear aa is not equivalent to call the delay routine if the previous operation does not yield zero.

As to initializing within subroutines there are two choices, static delay loops and variable delay loops

Here are examples of how static loops are to be initialized:

; one stage delay loop subroutine
delay:
	movlw D'5' 	; 1 cycle
	movwf aa 	; 1 cycle
	<code for one stage delay loop>
	return
; two stage delay loop subroutine
delay:
	movlw D'5' 	; 1 cycle
	movwf aa 	; 1 cycle
	movlw D'23' 	; 1 cycle
	movwf bb 	; 1 cycle
	<code for two stage delay loop>
	return
; three stage delay loop subroutine
delay:
	movlw D'5' 	; 1 cycle
	movwf aa 	; 1 cycle
	movlw D'23' 	; 1 cycle
	movwf bb 	; 1 cycle
	movlw D'3' 	; 1 cycle
	movwf cc 	; 1 cycle
	<code for three stage delay loop>
	return

From here, it should be noticed that for static delay loop subroutines, that if the loop involves N variables, it will require 2N cycles to initialize a variable. What this translates to is that for a one stage loop it takes 2 cycles to initialize, for a two stage loop it takes 4 cycles to initialize, and for a three stage loop it takes 6 cycles to initialize. Similarly to the adjustments required in turning simple delay loops into a subroutines, we must also add to those formulas the following additional cycles as follows:

cyc(aa) = 3aa + 3 u [6~771]
cyc(aa,bb) = 3aa + 770bb - 765 u [8~197123]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197885 u [10~50463235]

becomes:

cyc(aa) = 3aa + 3 + 2 u [6 + 2~771 + 2]
cyc(aa,bb) = 3aa + 770bb - 765 + 4 u [8 + 4~197123 + 4]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197885 + 6 u [10 + 6~50463235 + 6]

and simplifies to:

cyc(aa) = 3aa + 5 u [8~773]
cyc(aa,bb) = 3aa + 770bb - 761 u [12~197127]
cyc(aa,bb,cc) = 3aa + 770bb + 197122cc - 197879 u [16~50463241]

Static delay loops are great for when you only need a constant number of delay cycles, but what about when it varies? We can use variable delay loops, and the code is as follows:

; one stage delay loop subroutine
delay:
	movf aak,W 	; 1 cycle
	movwf aa 	; 1 cycle
	<code for one stage delay loop>
	return
; two stage delay loop subroutine
delay:
	movf aak,W 	; 1 cycle
	movwf aa 	; 1 cycle
	movf bbk,W 	; 1 cycle
	movwf bb 	; 1 cycle
	<code for two stage delay loop>
	return
; three stage delay loop subroutine
delay:
	movf aak,W 	; 1 cycle
	movwf aa 	; 1 cycle
	movf bbk,W 	; 1 cycle
	movwf bb 	; 1 cycle
	movf cck,W 	; 1 cycle
	movwf cc 	; 1 cycle
	<code for three stage delay loop>
	return

Where aak, bbk, and cck, and the values you need to initialize only once. Afterward, whenever you call the delay subroutine, it initializes the loop with aa = aak, bb = bbk, cc = cck, or mnemonically aa(variable) = aa(constant). Should you desire to change the number of cycles to delay for, all that is needed to be changed are the constant values.

With regards to the number of cycles that variable delay loops take, it is exactly the same as static delay loops, thereby making the formulas (with the exception of the constant values playing a role):

cyc(aak) = 3aak + 5 u [8~773]
cyc(aak,bbk) = 3aak + 770bbk - 761 u [12~197127]
cyc(aak,bbk,cck) = 3aak + 770bbk + 197122cck - 197879 u [16~50463241]

Please be certain that you initialize variable delay loops before their initial calling.

Now we can discuss the topic of solving for the the constants given that a certain number of cycles is required:

We need 600 cycles:

cyc(aak) = 3aak + 5 = 600
3aak = 600 - 5
3aak = 595
aak = 595/3 = 198.3333

as aak can only be a whole integer, we assign 198 to it. We absolutely do not round up or down, we always truncate. What we do with the fractional part 0.3333 is multiply it by 3 to convert back to who many cycles are needed in addition to what the loop can supply, essentially, we are finding the remainder:

198.3333 - 198 = [value after division - value assigned to constant aak] = 0.3333
0.3333 x 3 = 0.9999

We round at the very last step to the nearest integer, thereby this remainder will tell us how short of our desired number of cycles we are if we use the value 198 for aak so as to obtain a cycle count of 600. Therefore, as 0.9999 rounded to the nearest integer is 1, we are short 1 cycle which indicates that the delay loop only generates 595 cycles. In practice, after the final division, before multiplying by three a 0.3333 excess indicates one cycle short, while a 0.6666 indicates that it is two cycles short. To remedy this deficiency, we recommend the following:

; this can be placed in the main code
call delay 		; 595 cycle
	nop 		; 1 cycle
; or we can add the null operation to the subroutine
delay:
	movf aak,W 	; 1 cycle
	movwf aa 	; 1 cycle
	<code for one stage delay loop>
	nop 		; 1 cycle
	return

Note that for the second solution, embedding a one cycle null operation within the delay loop will add one more cycle to this subroutine making the formula change from:

cyc(aak) = 3aak + 5 u [8~773]

to this:

cyc(aak) = 3aak + 5 + 1 u [8 + 1~773 + 1]

which simplifies to:

cyc(aak) = 3aak + 6 u [9~774]

Therefore, in case you decide to embed the nop instruction within your delay loop subroutine, make certain to modify the formula as well.

Before we continue, I will now explain the procedure for finding the remainder on a calculator:

We want to take 50002 and divide it by 35. We require both the quotient and the remainder and begin by dividing this expression in our calculators:

50002/35 = 1428.628571

This makes the quotient 1428, an now to find the remainder:

1428.628571 - 1428 = 0.628571

We take this and multiply it by the number we divided by:

0.628571 x 35 = 22

Therefore, the final answer is:

1428 remainder 22

or in the shorthand we will use (where ex is excess) throughout this document:

1428 ex 22

With this knowledge in mind, we can now solve for a three stage delay loop for 600 cycles:

cyc(aak,bbk,cck) = 3aak + 770bbk + 197122cck - 197879 u [16~50463241]

The procedure should be fairly intuitive if followed. Its rules are nearly the same as above, but remember to bring the constant (integer at the very end) to the other side, and to start with the largest coefficient in division:

cyc(aak,bbk,cck) = 3aak + 770bbk + 197122cck - 197879 = 600
3aak + 770bbk + 197122cck = 600 + 197879
3aak + 770bbk + 197122cck = 198479

solve for cck by taking the new constant, and dividing it by the coefficient in front of cck:

198479/197122 = 1 ex 1357 [as a result, cck = 1]

we find bbk by taking the remainder and dividing it by the coefficient in front of bbk:

1357/770 = 1 ex 587 [as a result, bbk = 1]

and finally, we find cck by taking this remainder and dividing it by the coefficient in front of aak:

587/3 = 195 ex 2 [as a result, aak = 195]

Because of the last remainder being two, we now know that this formula is two cycles short of 600. Lets verify:

cyc(aak,bbk,cck) = 3aak + 770bbk + 197122cck - 197879
cyc(195,1,1) = 3(195) + 770(1) + 197122(1) - 197879
cyc(195,1,1) = 585 + 770 + 197122 - 197879
cyc(195,1,1) = 585 + 770 - 757
cyc(195,1,1) = 585 + 13
cyc(195,1,1) = 598

We must also discuss the topic of picking stages. Clearly with the three formulas we have derived before, any of them will work for a 600 cycle loop, however, in practice it is better to use the loop with fewest variables where possible as it conserves memory. Consider that a one stage loop requires two bytes of ram for aa and aak, a two stage loop requires four bytes of ram for aa, aak, bb, and bbk. As you can see by the pattern a three stage loop will require six bytes of ram, and in general an N-stage loop will require 2N bytes of ram. In addition, to initialize the constants aak, bbk, and cck, it takes two cycles per each variable, so for a six stage loop, this means 6 cycles. This may be wasteful if your application barely fits into the microcontroller.

Another concern when using delay loops is offset errors. You may be tempted to use a 5000 delay loop if you need your instruction to execute every 5000 cycles, however this would create an offset error since your instruction would take at least 1 cycle, thereby making your instruction would now execute every 5001 cycles.

In order to avoid this, pad your time critical routine or set of instructions so that it always takes the same amount of cycles to process, and set the delay loop to be equal to whatever your desired value is with the number of cycles your instructions or routine takes.

Sometimes, it is important to use delay loops to create real time delays. What this means is that sometimes it is necessarily to calculate how many seconds a delay loop will take. To do this, we include the following:

The PIC16 architecture is odd in that when you use a crystal oscillator oscillating at 4.000 Mhz, the number of instructions per second with simple instructions (such as nop, movlw, bcf, etc.) is actually 1.000 MIPS (million instructions per second). Therefore, the number of MIPS can be found by taking the frequency in megahertz, and dividing it by 4, and the number of instructions per second(IPS) can be found by multiplying this answer by 1,000,000. Thus:

[ips] = [xtal frequency in Mhz] * 1,000,000 / 4

[ips] = [xtal frequency in Mhz] * 250,000

Now that we know how many instructions per second it executes, we can figure out how many seconds a number of instructions will take by dividing the number of cycles by the number of instructions per second.

Thereby:

[seconds] = [cycles] / [ips]

or:

[seconds] = [cycles] / ([xtal frequency in Mhz] * 250,000)

and since frequency is the inverse of time(period):

[frequency in Hz] = 1 / [seconds]

[frequency in Hz] = 1 / [[cycles] / ([xtal frequency in Mhz] * 250,000)]

[frequency in Hz] = [xtal frequency in Mhz] * 250,000 / [cycles]

Last Revision: 2007-05-14