Delay functionalities in microcontroller programing are essential for managing timing. In the context of STM32 microcontrollers, this document explains the implementation of four diverse delay methods, focusing on their mechanics and specific use cases.

1. Simple Loop-Based Delay

This simplest delay technique uses iterative loops to achieve time delays. While efficient and accessible, accuracy is often compromised due to compiler optimizations. Suitable applications include general scenarios where high precision is not critical.

Example implementation:

void delay_microseconds(uint32_t microseconds) {
    volatile uint32_t count;

    for (count = 0; count < microseconds; count++) {
        volatile uint16_t temp = 12;
        while (temp > 0) {
            temp--;
        }
    }
}

void delay_milliseconds(uint16_t milliseconds) {
    for (uint32_t i = 0; i < milliseconds; i++) {
        delay_microseconds(1000);
    }
}

2. Timer-Based Delay via Interrupts

Utilizing timer peripherals of STM32 microcontrollers allows precise delay functions via interrupt mechanisms. While effective, this method engages the system's interrupt infrastructure, making it unsuitable for scenarios where interrupt reliability is paramount.

Initialization Example:

void init_systick(uint32_t frequency) {
    SysTick_Config(SystemCoreClock / frequency);
}

void SysTick_Handler(void) {
    TimingDelay_Decrement();
}

void TimingDelay_Decrement(void) {
    if (TimingDelay > 0) {
        TimingDelay--;
    }
}

void delay(uint32_t duration) {
    TimingDelay = duration;
    while (TimingDelay > 0);
}

3. Timer Query-Based Delay

This approach uses internal timers as decremanting counters without enabling their respective interrupts. It provides precision while avoiding interrupt interaction.

Implementation Example:

void delay_timer(uint32_t microseconds) {
    uint32_t start_ticks = SysTick->VAL;
    uint32_t ticking = SysTick->LOAD / (1000000 / microseconds);

    while ((SysTick->VAL - start_ticks) < ticking);
}

4. Assembly Instruction-Based Delay

Direct assembly instructions can execute precise delays with out relying heavily on peripheral resources. This is optimal for resource-constricted setups and ensures accurate timing since no compiler optimizations apply.

Assembly Example:

void delay_assembly(unsigned long cycles) {
    __asm("subs r0, #1
 bne delay_assembly
 bx lr");
}

void delay_microseconds(unsigned long microseconds) {
    delay_assembly(microseconds * (SystemCoreClock / 1000000));
}