Chain two timers

[Pilous Droip]

hi friends,

I try chain of 2 timers on STM32L053. From 2 16 bit timers I would like to create one 32bit timer.

My init is here.

void CLOCK__TIM21_Init(uint16_t Prescaler) {
 
 //initialize tim21 as master
 //enable clock to tim21
 LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM21);
 
 //stop the timer to configure it
 LL_TIM_DisableCounter(TIM21); //clear cen. 0=disable the timer, 1=enable the timer
 LL_TIM_SetClockDivision(TIM21, LL_TIM_CLOCKDIVISION_DIV1); //clear CKD0..1. 0b00->1x clock; 0b01->2:1 clock, 0b10->4:1 clk; 0b11->reserved
 LL_TIM_SetCounterMode(TIM21, LL_TIM_COUNTERMODE_UP); //clear DIR bit. 0=upcounter, 1=downcounter
 LL_TIM_SetOnePulseMode(TIM21, LL_TIM_ONEPULSEMODE_REPETITIVE); //clear opm bit. 0=periodic timer, 1=one-shot timer
 
 //or to simply zero the register
 LL_TIM_SetTriggerOutput(TIM21, LL_TIM_TRGO_UPDATE); //MMS = 0b010->tim2 as prescaler
 //source from internal clock -> disable slave mode
 LL_TIM_SetSlaveMode(TIM21, LL_TIM_SLAVEMODE_DISABLED); //clear sms->master mode and use internal clock
 
 //clear the status register bits for capture / compare flags
 LL_TIM_ClearFlag_UPDATE(TIM21);
 LL_TIM_ClearFlag_CC4(TIM21);
 LL_TIM_ClearFlag_CC3(TIM21);
 LL_TIM_ClearFlag_CC2(TIM21);
 LL_TIM_ClearFlag_CC1(TIM21);
 //disable the interrupt by clearing the enable bits
 LL_TIM_DisableIT_CC1(TIM21);
 LL_TIM_DisableIT_CC2(TIM21);
 LL_TIM_DisableIT_CC3(TIM21);
 LL_TIM_DisableIT_CC4(TIM21);
 LL_TIM_DisableIT_UPDATE(TIM21);
 
 //set the prescaler
 LL_TIM_SetPrescaler(TIM21, Prescaler - 1); //set the prescaler to Prescaler
 //user can specify a prescaler here. otherwise use 0xffff
 LL_TIM_SetAutoReload(TIM21, 0xffff); //auto reload register / period = 0; - need to change for downcounters
 
 LL_TIM_SetCounter(TIM21, 0); //reset the counter
 
 //enable the timer.
 // go
 LL_TIM_EnableCounter(TIM21);
}
 
void CLOCK__TIM22_Init(void) {
 
 //initialize tim22 as slave
 LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM22);
 
 LL_TIM_DisableCounter(TIM22); //clear cen. 0=disable the timer, 1=enable the timer
 LL_TIM_SetClockDivision(TIM22, LL_TIM_CLOCKDIVISION_DIV1); //clear CKD0..1. 0b00->1x clock; 0b01->2:1 clock, 0b10->4:1 clk; 0b11->reserved
 LL_TIM_SetCounterMode(TIM22, LL_TIM_COUNTERMODE_UP); //clear DIR bit. 0=upcounter, 1=downcounter
 LL_TIM_SetOnePulseMode(TIM22, LL_TIM_ONEPULSEMODE_REPETITIVE); //clear opm bit. 0=periodic timer, 1=one-shot timer
 
 //source from internal clock -> disable slave mode
 LL_TIM_SetSlaveMode(TIM22, LL_TIM_SLAVEMODE_DISABLED); //clear sms->master mode and use internal clock
 
 //clear the status register bits for capture / compare flags
 LL_TIM_ClearFlag_UPDATE(TIM22);
 LL_TIM_ClearFlag_CC4(TIM22);
 LL_TIM_ClearFlag_CC3(TIM22);
 LL_TIM_ClearFlag_CC2(TIM22);
 LL_TIM_ClearFlag_CC1(TIM22);
 //disable the interrupt by clearing the enable bits
 LL_TIM_DisableIT_CC1(TIM22);
 LL_TIM_DisableIT_CC2(TIM22);
 LL_TIM_DisableIT_CC3(TIM22);
 LL_TIM_DisableIT_CC4(TIM22);
 LL_TIM_DisableIT_UPDATE(TIM22);
 
 //set the prescaler
 LL_TIM_SetPrescaler(TIM22, 0); //set the prescaler to 1:1 - master timer acts as prescaler
 LL_TIM_SetAutoReload(TIM22, 0xffff); //auto reload register / period = 0; - need to change for downcounters
 LL_TIM_SetCounter(TIM22, 0); //reset the counter
 
 //enable the timer.
 LL_TIM_EnableCounter(TIM22); //enable the timer
 
 //source from trgo -> enable slave mode and trigger on trgo
 LL_TIM_SetTriggerInput(TIM22, LL_TIM_TS_ITR0);
 LL_TIM_SetClockSource(TIM22, LL_TIM_CLOCKSOURCE_EXT_MODE1);
}

And My init function is:

 CLOCK__TIM21_Init(32000);
 CLOCK__TIM22_Init();

And I want to use it, for read uptime my board.

uint32_t Timer_time(void) {
 uint16_t msw, lsw; //timer's high/low words
 do {
 msw = LL_TIM_GetCounter(TIM22);
 lsw = LL_TIM_GetCounter(TIM21);
 } while (msw != LL_TIM_GetCounter(TIM22)); //see if overflow has taken place
 return (msw << 16) | lsw; //return 32-bit time
}
 

For uptime I call this function:

void SerialConsole_timeUP(void) {
 print("Time : %u sec", (uint32_t )Timer_Time() / 1000u);
}

And my problem is:

1. Start time is set about: 1384 sec
2. increment is only in range: cca 1384 to 1441

For settings I use this document: https://www.st.com/resource/en/application_note/dm00042534-stm32-crossseries-timer-overview-stmicroelectronics.pdf

Does anybody see any problems?

[waclawek.jan]

> //source from internal clock -> disable slave mode

> LL_TIM_SetSlaveMode(TIM21, LL_TIM_SLAVEMODE_DISABLED); //clear sms->master mode and use internal clock

>

> //source from internal clock -> disable slave mode

> LL_TIM_SetSlaveMode(TIM22, LL_TIM_SLAVEMODE_DISABLED); //clear sms->master mode and use internal clock

OK so how are they chained?

JW

[Pilous Droip]

In CLOCK__TIM22_Init I have the last two lines. Where I enable slave timer. Or not? :grinning_face:

 //source from trgo -> enable slave mode and trigger on trgo
 LL_TIM_SetTriggerInput(TIM22, LL_TIM_TS_ITR0);
 LL_TIM_SetClockSource(TIM22, LL_TIM_CLOCKSOURCE_EXT_MODE1);

[waclawek.jan]

I don't use Cube/LL so don't understand the code. At the end of the day, the mcu works out of the registers, so read them out and check/post.

[EDIT] Also, what exactly do you mean by "increment" in your initial post?

JW

[Pilous Droip]

On page 588 in Reference manual is specific table: https://www.st.com/resource/en/reference_manual/dm00095744-ultra-low-power-stm32l0x3-advanced-arm-based-32-bit-mcus-stmicroelectronics.pdf#page=588 where is shown, how is connected slave and master TIM21 and TIM22. And it was my mistake.

Here is init functions for TIM21 and TIM22 in master/mode.

/*------------------------------------------------------------------------------
 -- CLOCK__TIM21_Init
 --
 -- Spojeni Master timeru 21 a slave timeru 22 do jednoho 32bitoveho
 --
 -- Init master timer 21
 ------------------------------------------------------------------------------*/
void CLOCK__TIM21_Init(uint16_t Prescaler) {
 
 LL_TIM_InitTypeDef TIM_InitStruct = { 0 };
 
 /* Peripheral clock enable */
 LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM21);
 
 TIM_InitStruct.Prescaler = Prescaler - LL_TIM_IC_FILTER_FDIV1_N2;
 TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
 TIM_InitStruct.Autoreload = 65535;
 TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
 LL_TIM_Init(TIM21, &TIM_InitStruct);
 LL_TIM_DisableARRPreload(TIM21);
 LL_TIM_SetClockSource(TIM21, LL_TIM_CLOCKSOURCE_INTERNAL);
 LL_TIM_SetTriggerOutput(TIM21, LL_TIM_TRGO_UPDATE);
 LL_TIM_DisableMasterSlaveMode(TIM21);
 
 LL_TIM_EnableCounter(TIM21);
}
 
/*------------------------------------------------------------------------------
 -- CLOCK__TIM22_Init
 --
 -- Spojeni Master timeru 21 a slave timeru 22 do jednoho 32bitoveho
 --
 -- Init slave timer 22
 ------------------------------------------------------------------------------*/
void CLOCK__TIM22_Init(void) {
 
 LL_TIM_InitTypeDef TIM_InitStruct = { 0 };
 
 /* Peripheral clock enable */
 LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM22);
 
 TIM_InitStruct.Prescaler = 0;
 TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
 TIM_InitStruct.Autoreload = 65535;
 TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
 LL_TIM_Init(TIM22, &TIM_InitStruct);
 LL_TIM_DisableARRPreload(TIM22);
 LL_TIM_SetTriggerInput(TIM22, LL_TIM_TS_ITR0);
 LL_TIM_SetClockSource(TIM22, LL_TIM_CLOCKSOURCE_EXT_MODE1);
 LL_TIM_DisableIT_TRIG(TIM22);
 LL_TIM_DisableDMAReq_TRIG(TIM22);
 LL_TIM_SetTriggerOutput(TIM22, LL_TIM_TRGO_RESET);
 LL_TIM_DisableMasterSlaveMode(TIM22);
 
 LL_TIM_EnableCounter(TIM22);
}

Here is function for reading:

uint32_t GetTickTimer(void) {
 uint16_t msw, lsw; //timer's high/low words
 do {
 msw = LL_TIM_GetCounter(TIM22);
 lsw = LL_TIM_GetCounter(TIM21);
 } while (msw != LL_TIM_GetCounter(TIM22)); //see if overflow has taken place
 return (msw << 16) | lsw; //return 32-bit time
}

Test delay function:

void WaitMsec(uint32_t msec) {
 uint32_t new;
 
 uint16_t msw, lsw; //timer's high/low words
 do {
 msw = LL_TIM_GetCounter(TIM22);
 lsw = LL_TIM_GetCounter(TIM21);
 } while (msw != LL_TIM_GetCounter(TIM22)); //see if overflow has taken place
 
 new = ((msw << 16) | lsw) + msec;
 
 while (((LL_TIM_GetCounter(TIM22) << 16) | LL_TIM_GetCounter(TIM21)) < new) {
 __NOP();
 };
}

[Piranha]

Why don't you use the popular and very handy approach - global 32-bit software tick counter, which is incremented in a SysTick interrupt?

[Pilous Droip]

Because I wouldn't learn anything. :grinning_face: