How to use SysTick_Handler (an HAL library function) in order to have a time base
What you're looking for is probably just a basic scheduler. Example code:

static volatile uint32_t ms_ticks = 0;
static volatile bool tick_1ms_elapsed = false;
static volatile bool tick_1000ms_elapsed = false;

//! The interrupt handler for the SysTick module
void SysTick_Handler(void)
{
    ms_ticks++;

    tick_1ms_elapsed = true;

    if (ms_ticks % 1000 == 0) {
        tick_1000ms_elapsed = true;
    }
}

void main(void) {

    // Setup SysTick Timer for 1ms interrupts
    if (SysTick_Config(sysclk_get_cpu_hz() / 1000)) {
        while (true) {  /* no error must happen here, otherwise this board is dead */ }
    }

    while(true) {

        if (tick_1ms_elapsed) {
            ... Do something every ms
            tick_1ms_elapsed = false; // Reset the flag (signal 'handled')
        }

        if (tick_1000ms_elapsed) {
            ... Do something every second
            if (state == STATE_1) {
                DoTaskOne;
                state = STATE_2;
            }
            else if (state == STATE_2) {
                DoTaskTwo;
                state = STATE_3;
            }
            tick_1000ms_elapsed = false;  // Reset the flag (signal 'handled')
        }
    }
}


What does this do?


We initialize the Systick timer to trigger an interrupt every millisecond. 
Since having long interrupt handlers is a no go, the only thing we do is to handle a flag which tells our main routing (which is handled during normal program flow and not within the interrupt routine) that 1 millisecond has passed
Additionally we increment a counter 'ms_ticks' which knows the current 'time' (time as in milliseconds since program start). We can always query that timer to know how much time has passed.


What your next tasks are going to be (at least if I understand you right):


Since you want to handle three events which happen after each other each second, you will need to create a state machine which runs inside the 1000ms tick handler.
Switch from one state to the next whenever you've completed the task for the current run, then wait until the flag arrives the next time and you will know another second has passed.