🟠 Synchronization is a fundamental concept that ensures that the processor, peripherals, timers, and interrupts operate in a consistent and accurate manner based on a common clock source.

🔁 How to achieve synchronization

Clocks provide the basis for timers to work, and timers, in turn, generate interrupts to perform tasks with precise timing control.

1. Clock System

  • Main synchronization source.

  • Provides a basic clock signal, which all other blocks are guided by.

  • Via dividers and PLL, generates the required frequencies for:

    • CPU
    • Buses (AHB/APB)
    • Timers, UART, SPI, etc.

  • Clock setup:

    • Always check SYSCLK, HCLK, PCLK frequencies in the datasheet.
    • Use PLL to increase the frequency if high performance is required.
    • If the clock source (e.g. RC oscillator) is unstable, timers may give inaccurate intervals, which is critical for TinyML (e.g. for audio processing) - use an external crystal or calibrate the RC oscillator.

2. Timers

  • Convert a clock signal into a time interval.
  • Count time, generate periodic signals (e.g. PWM), synchronize task launches.
  • Interconnected with the Clock System via prescalers.
  • Timer optimization:
    • Choose a timer with the required resolution (16 or 32 bits) depending on the task.
    • Use DMA to transfer data from the timer.
    • If the timer counter is too small (e.g. 16 bits), it may overflow at low frequencies - use 32-bit timers or increase the prescaler.

3. Interrupts

  • Allow the system to respond to events strictly on time (for example, triggering every 10 ms).

  • Serve as a mechanism for "interrupting" the main thread at the moment an important event is triggered.

  • Timers often initialize interrupts (for example, when a counter overflows).

  • Interrupts Settings:

    • Minimize code in ISR (interrupt handler) by pushing complex tasks to the main program via flags or queues.
    • Use cortex-m::interrupt::free for safe access to shared resources.
    • If multiple interrupts (e.g. timer and UART) fire at the same time, there may be a delay - set priorities via NVIC (Nested Vectored Interrupt Controller).

🧩 How does it all work together?

  1. The clock generates a stable clock signal (e.g. 12 MHz).
  2. This signal is sent to the timer, which counts ticks, decreasing (or increasing) the counter.
  3. When the counter reaches a threshold, the timer generates an interrupt.
  4. The interrupt calls ISR, and the code reacts - starts a task, updates data, wakes up the device, etc.
  5. The cycle repeats.

This cycle allows you to accurately start tasks, without the main code.