System Clock = 16 MHz
        ↓
SysTick 16000 clocks
        ↓
1 ms
        ↓
500회 반복
        ↓
500 ms delay
        ↓
LD1 Toggle

SysTick->CTRL
SysTick->LOAD
SysTick->VAL
SysTick->CALIB

Cortex-M4 Core
│
├── NVIC
├── SysTick
├── Debug
└── CPU

SysTick
→ Cortex-M 공통
TIM2, TIM3 ...
→ STM32 Peripheral

LOAD
 ↓
15999
 ↓
15998
 ↓
...
 ↓
1
 ↓
0
 ↓
COUNTFLAG = 1
 ↓
Reload

#define CTRL_ENABLE     (1UL << 0)
#define CTRL_CLKSRC     (1UL << 2)
#define CTRL_COUNTFLAG  (1UL << 16)

bit 0  ENABLE
       1 = SysTick counter enable
bit 1  TICKINT
1 = SysTick interrupt enable
이번 실습에서는 사용하지 않음
bit 2  CLKSOURCE
1 = Processor clock 사용
bit16  COUNTFLAG
Counter가 0까지 내려가면 1

COUNTFLAG Polling

16 MHz

16,000,000 clocks / second

1 ms
0.001 second

16,000,000 × 0.001
16,000 clocks

LOAD = 16000 - 1
= 15999

#define ONE_MSEC_LOAD 16000UL

SysTick->LOAD = ONE_MSEC_LOAD - 1UL;

HSI
↓
16 MHz
↓
System Clock

168 MHz

Core Clock = 16 MHz

Inc/
├── gpio.h
└── systick.h
Src/
├── gpio.c
├── systick.c
└── main.c

#ifndef SYSTICK_H__
#define SYSTICK_H__
#include <stdint.h>
/*

Delay execution for the requested number of milliseconds.


This implementation assumes:



Core Clock = 16 MHz




Example:



systick_msec_delay(500);





→ approximately 500 ms delay



*/
void systick_msec_delay(uint32_t delay);
#endif

#include "stm32f4xx.h"
#include "systick.h"
/*

============================================================
SysTick CTRL Register Bit Definitions
============================================================
*/

/*

SysTick CTRL bit0 : ENABLE


0 = Counter disabled
1 = Counter enabled
*/
#define CTRL_ENABLE     (1UL << 0)

/*

SysTick CTRL bit2 : CLKSOURCE


0 = External/reference clock
1 = Processor clock


This project uses the processor clock.
*/
#define CTRL_CLKSRC     (1UL << 2)

/*

SysTick CTRL bit16 : COUNTFLAG


Hardware sets this flag when the SysTick counter
counts down to zero.


The delay routine polls this bit to detect
the completion of each 1 ms period.
*/
#define CTRL_COUNTFLAG  (1UL << 16)

/*

============================================================
SysTick Timing Definition
============================================================
*/

/*

Current core clock:



16 MHz = 16,000,000 clocks/sec




Number of clocks in 1 ms:



16,000,000 × 0.001



= 16,000 clocks




SysTick counts:



LOAD → ... → 1 → 0




Therefore the actual value written to LOAD is:



16,000 - 1



= 15,999



*/
#define ONE_MSEC_LOAD   16000UL
/*

============================================================
Millisecond Delay
============================================================
*/

void systick_msec_delay(uint32_t delay)
{
/*
* --------------------------------------------------------
* Step 1. Set reload value
* --------------------------------------------------------
*
* ONE_MSEC_LOAD = 16000
*
* LOAD = 15999
*
* With a 16 MHz processor clock,
* this produces one 1 ms counting period.
*/
SysTick->LOAD = ONE_MSEC_LOAD - 1UL;
/*
 * --------------------------------------------------------
 * Step 2. Clear current counter value
 * --------------------------------------------------------
 *
 * Writing to VAL clears the current SysTick counter.
 *
 * This ensures that the delay starts from
 * a known counter state.
 */
SysTick-&gt;VAL = 0UL;


/*
 * --------------------------------------------------------
 * Step 3. Select SysTick clock source
 * --------------------------------------------------------
 *
 * CTRL_CLKSRC = bit2 = 1
 *
 * Use processor clock as the SysTick source.
 *
 * Note:
 * TICKINT(bit1) is NOT enabled.
 *
 * Therefore this implementation does not use
 * SysTick interrupts.
 */
SysTick-&gt;CTRL = CTRL_CLKSRC;


/*
 * --------------------------------------------------------
 * Step 4. Enable SysTick
 * --------------------------------------------------------
 *
 * Set CTRL bit0.
 *
 * SysTick now starts counting down.
 */
SysTick-&gt;CTRL |= CTRL_ENABLE;


/*
 * --------------------------------------------------------
 * Step 5. Repeat 1 ms delay
 * --------------------------------------------------------
 *
 * Example:
 *
 *     delay = 500
 *
 * The outer for-loop repeats 500 times.
 *
 * Each iteration waits for one SysTick period:
 *
 *     1 ms × 500
 *     = 500 ms
 */
for (uint32_t i = 0; i &lt; delay; i++)
{
    /*
     * Wait until COUNTFLAG becomes 1.
     *
     * While counter has NOT yet reached zero:
     *
     *     COUNTFLAG = 0
     *
     * so CPU remains in this while-loop.
     *
     * Once counter reaches zero:
     *
     *     COUNTFLAG = 1
     *
     * and the while-loop terminates.
     *
     * This is polling.
     */
    while ((SysTick-&gt;CTRL &amp; CTRL_COUNTFLAG) == 0UL)
    {
        /*
         * Busy wait.
         *
         * CPU performs no other useful work here.
         */
    }
}


/*
 * --------------------------------------------------------
 * Step 6. Stop SysTick
 * --------------------------------------------------------
 *
 * Clear CTRL register.
 *
 * ENABLE = 0
 * CLKSOURCE = 0
 * TICKINT = 0
 *
 * SysTick stops after the requested delay.
 */
SysTick-&gt;CTRL = 0UL;

}

#include "gpio.h"
#include "systick.h"
int main(void)
{
/*
* Initialize LD1 GPIO.
*
* NUCLEO-F439ZI:
*
*     LD1 → PB0
*
* gpio.c configures PB0 as output.
*/
led_init();
while (1)
{
    /*
     * Wait 500 ms using the Cortex-M4 SysTick timer.
     *
     * Internally:
     *
     *     1 ms period
     *     ×
     *     500 iterations
     *     =
     *     500 ms
     */
    systick_msec_delay(500);


    /*
     * Toggle PB0.
     *
     * GPIOB->ODR bit0:
     *
     *     0 → 1
     *     1 → 0
     *
     * Therefore LD1 changes state every 500 ms.
     */
    led_toggle();
}

}

LOAD = 15999
↓
VAL = 0
↓
CLKSOURCE = Core Clock
↓
ENABLE = 1
↓
Counter Starts
↓
15999 → ... → 0
↓
COUNTFLAG = 1
↓
1 ms complete
↓
Repeat 500 times
↓
500 ms complete
↓
CTRL = 0

led_init()
↓
500 ms delay
↓
LED toggle
↓
500 ms delay
↓
LED toggle
↓
...

for (uint32_t i = 0; i < delay; i++)
{
while ((SysTick->CTRL & CTRL_COUNTFLAG) == 0UL)
{
}
}

1 ms가 끝났는가?

1 ms를 몇 번 기다릴 것인가?

systick_msec_delay(500);

1 ms 완료 확인
×
500회
500 ms

CTRL[16] = 1

COUNTFLAG = 1

while ((SysTick->CTRL & CTRL_COUNTFLAG) == 0UL)
{
}

SysTick->VAL = 0UL;

Previous Counter State
↓
VAL Write
↓
Counter Clear
↓
Known Starting State

TICKINT

while ((SysTick->CTRL & CTRL_COUNTFLAG) == 0UL)

SysTick Interrupt
X
SysTick Polling
O

while ((SysTick->CTRL & CTRL_COUNTFLAG) == 0UL)
{
}

CPU
↓
Wait
↓
Wait
↓
Wait
↓
Timer Complete

Busy Waiting

Interrupt
RTOS Tick
State Machine
Non-blocking Timer

while (count--)
{
asm("nop");
}

Software Loop Delay
Compiler Optimization
CPU Instruction
Source Code
↓
Delay 변화 가능

Hardware Counter
↓
Clock 기준으로 Count

ARM Cortex-M Core
1개
기본적인 system tick/delay 용도
24-bit down counter

STM32 Peripheral
여러 개 존재
Prescaler
Auto Reload
PWM
Input Capture
Output Compare
Interrupt
...

TIM2

text = 764 bytes
data = 0 bytes
bss  = 2560 bytes

make clean
make

Build PASS

text = 764
data = 0
bss  = 2560

SysTick->LOAD = ONE_MSEC_LOAD - 1UL;

SysTick->LOAD
15999

SysTick->VAL

15999
↓
...
↓
0

CTRL bit0
ENABLE
CTRL bit2
CLKSOURCE
CTRL bit16
COUNTFLAG

ENABLE    = 1
CLKSOURCE = 1

LD1 state change
every 500 ms

ON  500 ms
OFF 500 ms
Total period
≈ 1 second

images/ch08_build.png
images/ch08_systick_load.png
images/ch08_systick_val.png
images/ch08_systick_ctrl.png
images/ch08_led.gif

LOAD = 15999
+
VAL Down Counting
+
LD1 500 ms Toggle

16 MHz
↓
16000 clocks
↓
1 ms
↓
COUNTFLAG
↓
500 repetitions
↓
500 ms