Delay by x microseconds in C for pic18f

Question

I need an accurate time delay function written in C that delays the pic program execution by a given number of microseconds. I did find an example on microchipc.com which uses ASM, but the code only allows for clock speeds up to 32000000. My clock speed needs to be 64000000, but since I don't understand how the code is working I can't modify it to do what I need. Can anyone offer some explanation of the code or suggest how to implement something similar?

#if PIC_CLK == 4000000
  #define DelayDivisor 4
  #define WaitFor1Us asm("nop")
  #define Jumpback asm("goto $ - 4") 
#elif PIC_CLK == 8000000
  #define DelayDivisor 2
  #define WaitFor1Us asm("nop")
  #define Jumpback asm("goto $ - 4")
#elif PIC_CLK == 16000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop")
  #define Jumpback asm("goto $ - 4")
#elif PIC_CLK == 20000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop"); asm("nop")
  #define Jumpback asm("goto $ - 6")
#elif PIC_CLK == 32000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop")
  #define Jumpback asm("goto $ - 12")
#else
#error delay.h - please define PIC_CLK correctly
#endif

#define DelayUs(x) { \
delayus_variable=(unsigned char)(x/DelayDivisor); \
asm("movlb (_delayus_variable) >> 8"); \
WaitFor1Us; } \
asm("decfsz (_delayus_variable)&0ffh,f"); \
Jumpback;

paxdiablo · Accepted Answer · 2011-01-20T14:14:43.990

It seems to me from this segment:

#elif PIC_CLK == 16000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop")
  #define Jumpback asm("goto $ - 4")
#elif PIC_CLK == 20000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop"); asm("nop")
  #define Jumpback asm("goto $ - 6")
#elif PIC_CLK == 32000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop")
  #define Jumpback asm("goto $ - 12")

that for each extra 4 million increase in PIC_CLK, you need another nop instruction.

I've not used the earlier ones since they just use a scaling function at lower clock speeds - since you can't execute half or quarter of a nop, they just reduce the loop count to half or quarter and execute a full nop that many times.

So, for 64 million (which 32 million more than the last) you would need another eight nop instructions (32 million divided by 4 million) and, since each one increase the jump size by 2 (the PIC18F having a 2-byte instruction width), you should be able to use the following:

#elif PIC_CLK == 32000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop")
  #define Jumpback asm("goto $ - 12")
#elif PIC_CLK == 64000000
  #define DelayDivisor 1
  #define WaitFor1Us asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop") \
                     asm("nop"); asm("nop"); asm("nop"); asm("nop"); \
                     asm("nop"); asm("nop"); asm("nop"); asm("nop");
  #define Jumpback asm("goto $ - 28")
#else
#error delay.h - please define PIC_CLK correctly
#endif

In summary, these are the values you need for each PIC_CLK value, on the off chance that the next generation will be even faster:

PIC_CLK    Divisor  NOP count  Jump size
---------  -------  ---------  ---------
  1000000       16          1          4
  2000000        8          1          4
  4000000        4          1          4
  8000000        2          1          4
 16000000        1          1          4
 20000000        1          2          6
 24000000        1          3          8
 28000000        1          4         10
 32000000        1          5         12
 64000000        1         13         28
 96000000        1         21         44
128000000        1         29         60

Or, if you want the formulae for values greater than or equal to 16 million:

divisor = 1
nopcount = picclk / 4000000 - 3
jumpsize = nopcount * 2 + 2

Thanks, I think this will work, but since I'm using a different compiler I'm now having to change how all the assembly is called... — Huggzorx, Jan 20 '11 at 15:18

score 1 · Answer 2 · 2011-01-20T14:18:31.657

The code simply loops over a set of nop-instructions for a set amount of time. The movlb instruction is used to load the BSR (only an 8-bit register, thus the shift). The decfsz instruction is then used to decrement the loop counter and skip the next instruction if the result is zero, to break out of the loop. If the next instruction is not skipped, the Jumpback instruction is called (a goto) which jumps back to the top of the loop. Since each instruction on an 18F is two bytes wide (double word instructions are four bytes), you have to jump 12 lines back for the 32MHz version (5 nops and a decfsz).

Now, you could follow paxdiablo's advice and make a new version with more nops, but that would take up some unnecessary space if you are only going to run @ 64MHz anyway. I would think that you could just do something like

#if PIC_CLK == 64000000
  #define WaitFor1NOP asm("nop")
  #define Jumpback asm("goto $ - 4")
#else
#error delay.h - please define PIC_CLK correctly
#endif

#define DelayUs(x) { \
delayus_variable=(unsigned char)(x*SOME_NUMBER); \
asm("movlb (_delayus_variable) >> 8"); \
WaitFor1NOP; } \
asm("decfsz (_delayus_variable)&0ffh,f"); \
Jumpback;

Here SOME_NUMBER is the number of nops you need to loop over to reach 1µs @ 64MHz, 13 according to paxdiablo's excellent math.

EDIT:

paxdiablo brought to my attention that this solution will limit the range of delay times more than his, since the largest number you can pass to the macro is 1/13th of what goes into an unsigned char. An unsigned char is 8 bits, which leaves us with 255/13 = 19. I don't know if that is too small for you. You could work around this by calling the delay macro multiple times, possibly even creating a new macro to do that for you.

That may not be a bad idea. The ifdef's themselves don't make any more code since they're not compiled in. You're right that your solution uses 24 less bytes than mine but you need to be careful since the price you pay is a reduced range of wait times. Since you're multiplying usecs by SOME_NUMBER (which will be 13 by the way), the upper limit you can pass in is restricted accordingly (to 1/13th of the extra-24-byte solution). It's a pity 13 is prime, we could have compromised a little :-) — paxdiablo, Jan 20 '11 at 13:56
I was not talking about the ifdefs, I just left them out since they won't be of much use anyway if he's only running at 64MHz. You bring up a good point with the time limitation, though. I'll edit my answer. — , Jan 20 '11 at 14:06
I'll give you a +1 for that since it may be that memory is the more limiting factor than range. I actually have no idea how tight memory is on the OPs system but I remember my days working on the 8051 and 1802A chips and it was _very_ tight, so it may still be very important. — paxdiablo, Jan 20 '11 at 14:23

Delay by x microseconds in C for pic18f

2 Answers2