Generating a delay on the order of microseconds (timer vs HAL_Delay())

Question

So I am using an nRF24 radio module and I probably need a 10us delay after enabling chip select. But the thing is I can't use HAL_Delay() since the least it provides is 1ms delay (SCK/1000 is hardcoded in the HAL function).

I was suggested to not use SysTick timer for too small of a delay anyways and rather go for hardware timers. I read up on Timers and to me, it looks more like they're mainly used for tasks where you need to do a function at a specific interval i.e blinking LED every 4 seconds or something by changing the prescaler and counter period and I did try it out as well -- and it's nonblocking as opposed to a delay. So every time a counter hits the specific counter period, it generates an event/IRQ

Am I interpreting it incorrectly? Is there a way around it?

I'm using STM32F401RE.

Answer 1

You can start a timer and read the count until it is large enough. Or you can poll the overflow flag when it rolls over. No need for interrupts. You can also sit in a while or for loop for enough counts to reach 10us.

Answer 2

For a delay of at least some amount, You could set a flag in the main loop and enable a timer interrupt that resets the flag. The main loop polls the flag in sequence while running other tasks and skips the function that executes the second half while it is set. You may need another flag to indicate that the second half is armed to run. (Or just poll the timer counter directly like what justme said. Much simpler if nothing else needs to happen right when the delay is over).

An interrupt of exactly some amount requires running things in the interrupt which is bad practice if not absolutely necessary.

Answer 3

Timers are great at making accurate time intervals. But if you just need a one time delay of some period longer than 10us, when the chip is enabled and don't want to hassle with configuring a timer, then a simple for loop with a NOP might be the most expeditious path. Add a pragma to it so that it doesn't change with optimization levels and you are good to go.

Answer 4

I was suggested to not use SysTick timer for too small of a delay anyways and rather go for hardware timers.

Yes, this is the sensible approach. 10us is a pretty "hard" real-time constraint.

I read up on Timers and to me, it looks more like they're mainly used for tasks where you need to do a function at a specific interval

Not necessarily. They are supposed to be general enough to be used in a lots of different ways. Periodic interrupts, one-time interrupts, PWM generation, input capture, output generation etc etc.

and it's nonblocking as opposed to a delay

Indeed, this is often a big advantage over fishy busy-delays.

Is there a way around it?

Set up the pre-scaler, enable the timer interrupt, start the timer, from the ISR that triggers 10us later simply disable the timer interrupt, then set a application-specific flag. Preferably wrap this whole functionality including the ISR inside some manner of HAL.

You could have something like this in the caller code:

tim_init(10);
...

tim_enable(timer_n);

while(!tim_done(timer_n))
{
  /* optionally do other stuff here while you wait */
}

Answer 5

Or you might use the 74LS121 one-shot delay IC.

Answer 6

Here is the code on how ST implements a delay in one of their example projects (also as another user has suggested here):

for (volatile uint8_t i=0; i!=0xFF; i++);

Change the value of 0xFF to the max count representing the max time delay you would like based on the system clock of your device. Assuming that you use STM32CubeMX to generate your project template, this system clock is the same SYSCLK (MHz) clock under 'Clock Configuration'.

Example: if you use a max count of 8000 on a system clock of 8MHz, the delay would be 1ms.