if (!(SCB_DEMCR & 0x01000000))

if (!(CoreDebug->DEMCR & 0x01000000))

void dwt_init(void)
{
    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    DWT->CYCCNT       = 0;                            // reset
    DWT->CTRL        |= 1;                            // enable the counter
}

static __inline uint32_t dwt_dt(uint32_t t0, uint32_t t1)
{
    return (t1 - t0); // всегда верно, даже если t1<t0
}

void dwt_delay(uint32_t us) // microseconds (max = 2^32 / (fcpu*1.0E-6) - 1)
{
    uint32_t t0 = DWT->CYCCNT;
    uint32_t dt = us * (F_CPU/1000000UL); // 1us = 72tics @ 72MHz

    while (dwt_dt(t0, DWT->CYCCNT) < dt)  {;}
}

    if( !( CoreDebug->DEMCR & CoreDebug_DEMCR_TRCENA_Msk ) || !( DWT->CTRL & DWT_CTRL_CYCCNTENA_Msk ) )
    {
        DWT->CYCCNT  = 0;
                            CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
        DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk; // enable the counter
    }

//----------------------------------------------------------------------------
u64 core_get_cycles_counter( void )
{
    TN_INTSAVE_DATA

    u64 ret = 0;        
    static u32 cch = 0, ccl_prev = 0;
    u32 ccl = DWT->CYCCNT;
    
    tn_disable_interrupt();
    if( ccl_prev > ccl )
        cch++;
    ret = ((u64)cch << 32) + ccl;
    ccl_prev = ccl;
    tn_enable_interrupt();
    
    return ret;
}

//----------------------------------------------------------------------------
u64 get_sys_mks( void )
{
    u64 ret = core_get_cycles_counter() / ( F_CPU / 1000000UL );
    return ret;
}

P.S. в векторе SysTick_Handler системного тика каждую секунду считывает core_get_cycles_counter чтобы DWT->CYCCNT не переполнился более одного раза

if (!(SCB_DEMCR & 0x01000000))

volatile uint32_t trash_in, trash_out;

for (uint32_t i=0; i<delay; i++) trash_in = trash_out;

#define __delay_us( US ) __delay_loops( (uint32_t)((double)US * F_CPU / 3000000.0))
#define __delay_ms( MS ) __delay_loops( (uint32_t)((double)MS * F_CPU / 3000.0))
#define __delay_s( S )   __delay_loops( (uint32_t)((double)S  * F_CPU / 3.0))

#pragma inline=forced
void __delay_loops(uint32_t loops){
        asm(    "Metka:    SUBS     %[R1], %[R1], %[imm] \n"
                "       BNE.N    Metka        \n"
                : [R1]"+r" (loops)
        : [imm]"i"(1));
        };

#define cli() asm volatile ( "CPSID i \n" )
#define sei() asm volatile ( "CPSIE i \n" )

#define __delay_us_cli( US ) cli(); __delay_us( US ); sei();

#define F_CPU    24000000UL

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);
TIM6->CR1 |= TIM_CR1_CEN;


// Процедура формирования линейной задержки
#pragma inline=forced
void __delay_loops(uint16_t loops)
{
    TIM6->CNT = 0x0000;
    while(loops > TIM6->CNT);
}

#define __delay_us( US ) __delay_loops( (uint16_t)(US * (uint16_t)(F_CPU / 1000000UL)) )

#pragma inline=forced
void __delay_ms(uint16_t ms){
    do{     
        __delay_us(1000);
    }
    while(ms--);
};

void DWT_Init(void)
{
DWT->CYCCNT = 0;
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}

uint32_t DWT_Get(void)
{
return DWT->CYCCNT;
}

inline uint8_t DWT_Compare(int32_t tp)
{
return (((int32_t)DWT_Get() - tp) < 0);
}

void DWT_Delay(uint32_t us) // microseconds
{
int32_t tp = DWT_Get() + us * (F_CPU/1000000);
while (DWT_Compare(tp));
}

unsigned int delay_ms(unsigned int ms)
{
    volatile unsigned int i, t = 0;
    //for(i = 0; i < (ms*400); i++) t++; // @ 8 MHz
    for(i = 0; i < (ms*5714); i++) t++;
    return t;
}

unsigned int delay_10us(unsigned int us)
{
    volatile unsigned int i, t = 0;
    //for(i = 0; i < (us*4); i++) t++; // @ 8 MHz
    for(i = 0; i < (us*57); i++) t++;
    return t;
}