Low power mode with KW41Z

paralax — Mon, 04 May 2020 19:12:06 GMT

Hi everyone.

I'm working on a custom board with a Kinetis KW41Z on it. The board is powered up with a 3.3V rail, and I use the integrated DCDC to generate the 1.8V. At the moment, only the KW41Z, the inductors and capacitors needed by the DCDC are populated, and the 32Mhz + 32KHz crystals.

I want to achieve a sleep mode, while using FreeRTOS.

To do so, I activated tickless mode, as showed in the various sdk examples. I think this activation is successful as I enter my custom vPortSupressTicksAndSleep function.

In this function, I then setup the LPTimer0, go to sleep, and wakeup.The wakeup is programmed by a simple task that update a variable every seconds, and the timer is init like this:

//Configure Low Power timer

    lptmr_config_t lptmrConfig;

    CLOCK_EnableClock(kCLOCK_Lptmr0);

    /* Configuration LPTMR  */

/*

     * lptmrConfig.timerMode = kLPTMR_TimerModeTimeCounter;

     * lptmrConfig.pinSelect = kLPTMR_PinSelectInput_0;

     * lptmrConfig.pinPolarity = kLPTMR_PinPolarityActiveHigh;

     * lptmrConfig.enableFreeRunning = false;

     * lptmrConfig.bypassPrescaler = true;

     * lptmrConfig.prescalerClockSource = kLPTMR_PrescalerClock_1;

     * lptmrConfig.value = kLPTMR_Prescale_Glitch_0;

*/

    LPTMR_GetDefaultConfig(&lptmrConfig);

    lptmrConfig.prescalerClockSource=kLPTMR_PrescalerClock_1;

    lptmrConfig.bypassPrescaler = true;

    LPTMR_Init(LPTMR0, &lptmrConfig);

Everything seems running nicely: I can see by toggling a led in the LPTimer that the interrupt is firing every seconds as expected. I can see by toggling a led before going to sleep and after waking up that the devices behave as expected. The timing seems correct too.

However, I can't get a current consumption lower than 4mA. I tried all the low power mode, none of them seems to make any difference in sleep consumption.

My sleep function is very simple:

  GPIO_SetPinsOutput(GPIOC, 1 << 4);

  smc_power_mode_vlls_config_t vlls_config;

  vlls_config.subMode = kSMC_StopSub1;

  SMC_SetPowerModeVlls(SMC, &vlls_config);

I've tried disabling all the peripheral by hands, played with the clock configs, etc... Still 4mA minimum. Is there some sort of init needed that I missed?

Please note that I don't use the LLWU as I don't see how, with the SDK I have, to use it to configure the wake by LPTimer. And I wakeup without it anyway...

Thanks in advance.

Regards,

Matthieu

PS: here is some other code, in case it is needed:

void vOnPreSleepProcessing(portTickType expectedIdleTicks)

  (void) expectedIdleTicks;

  #if configUSE_TICKLESS_IDLE == 2

  CLOCK_DisableClock(kCLOCK_PortC);

  GPIO_SetPinsOutput(GPIOC, 1 << 4);

  smc_power_mode_vlls_config_t vlls_config;

  vlls_config.subMode = kSMC_StopSub1;

  SMC_SetPowerModeVlls(SMC, &vlls_config);

  #endif

void vOnPostSleepProcessing(portTickType expectedIdleTicks)

  (void) expectedIdleTicks;

  CLOCK_EnableClock(kCLOCK_PortC);

  GPIO_ClearPinsOutput(GPIOC, 1 << 4);

  /*dcdc_min_power_config_t dcdc;

  DCDC_GetDefaultMinPowerDefault(&dcdc);

  DCDC_SetMinPowerConfig(DCDC, &dcdc);*/

/**
 * @brief Setup the systick timer to generate the tick interrupts at the required
 * frequency.
 *
 * @author NXP, SDK2.7
 */
void vPortSetupTimerInterrupt(void)
{
/* Calculate the constants required to configure the tick interrupt. */
#if configUSE_TICKLESS_IDLE == 2
    ulTimerCountsForOneTick   = (configCPU_CLOCK_HZ / configTICK_RATE_HZ);
    ulLPTimerCountsForOneTick = (configLPTMR_CLOCK_HZ / configTICK_RATE_HZ);
    if (ulLPTimerCountsForOneTick != 0)
    {
        xMaximumPossibleSuppressedTicks = portMAX_16_BIT_NUMBER / ulLPTimerCountsForOneTick;
    }
    else
    {
        /* ulLPTimerCountsForOneTick is zero, not allowed state */
        while (1)
            ;
    }
    NVIC_EnableIRQ(LPTMR0_IRQn);
#endif /* configUSE_TICKLESS_IDLE */
    /* Configure SysTick to interrupt at the requested rate. */
    SysTick->LOAD = (configCPU_CLOCK_HZ / configTICK_RATE_HZ) - 1UL;
    SysTick->VAL  = 0UL;
    SysTick->CTRL = (SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk);
}

/**
 * @brief LPTimer0 interrupt handler
 *
 * @author NXP, SDK2.7
 */
void vPortLptmrIsr(void)
{
    ulLPTimerInterruptFired = true;
    LPTMR_ClearStatusFlags(LPTMR0, kLPTMR_TimerCompareFlag);
    LPTMR_StopTimer(LPTMR0);
    GPIO_TogglePinsOutput(GPIOC, 1 << 5);
}
/**
 * @brief Reimplementation of the vPortSuppressTicksAndSleep to enter and exit sleep
 *
 * @param xExpectedIdleTime The expected time the decice will remain in sleep
 *
 * @author  NXP, SDK2.7
 */
void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTime)
{
    uint32_t ulReloadValue, ulCompleteTickPeriods;
    TickType_t xModifiableIdleTime;
    LPTMR_Type *pxLptmrBase;
    pxLptmrBase = LPTMR0;
    if (pxLptmrBase == 0)
        return;
    /* Make sure the SysTick reload value does not overflow the counter. */
    if (xExpectedIdleTime > xMaximumPossibleSuppressedTicks)
    {
        xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
    }
    if (xExpectedIdleTime == 0)
        return;
    /* Calculate the reload value required to wait xExpectedIdleTime
    tick periods.  -1 is used because this code will execute part way
    through one of the tick periods. */
    ulReloadValue = LPTMR_GetCurrentTimerCount(pxLptmrBase) + (ulLPTimerCountsForOneTick * (xExpectedIdleTime - 1UL));
    /* Stop the LPTMR and systick momentarily.  The time the LPTMR and systick is stopped for
    is accounted for as best it can be, but using the tickless mode will
    inevitably result in some tiny drift of the time maintained by the
    kernel with respect to calendar time. */
    LPTMR_StopTimer(pxLptmrBase);
    SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
    /* Enter a critical section but don't use the taskENTER_CRITICAL()
    method as that will mask interrupts that should exit sleep mode. */
    __disable_irq();
    __DSB();
    __ISB();
    /* If a context switch is pending or a task is waiting for the scheduler
    to be unsuspended then abandon the low power entry. */
    if (eTaskConfirmSleepModeStatus() == eAbortSleep)
    {
        /* Restart from whatever is left in the count register to complete
        this tick period. */
        SysTick->LOAD = SysTick->VAL;
        /* Restart SysTick. */
        SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
        /* Reset the reload register to the value required for normal tick
        periods. */
        SysTick->LOAD = ulTimerCountsForOneTick - 1UL;
        /* Re-enable interrupts - see comments above __disable_irq()
        call above. */
        __enable_irq();
    }
    else
    {
        /* Set the new reload value. */
        LPTMR_ClearStatusFlags(LPTMR0, kLPTMR_TimerCompareFlag);
        //LPTMR_SetTimerPeriod(pxLptmrBase, ulReloadValue);
        LPTMR_SetTimerPeriod(pxLptmrBase, 100);
        /* Enable LPTMR. */
        LPTMR_StartTimer(pxLptmrBase);
        /* Sleep until something happens.  configPRE_SLEEP_PROCESSING() can
        set its parameter to 0 to indicate that its implementation contains
        its own wait for interrupt or wait for event instruction, and so wfi
        should not be executed again.  However, the original expected idle
        time variable must remain unmodified, so a copy is taken. */
        xModifiableIdleTime = xExpectedIdleTime;
        vOnPreSleepProcessing(xModifiableIdleTime);
        /*if (xModifiableIdleTime > 0)
        {
            __DSB();
            __WFI();
            __ISB();
        }*/
        vOnPostSleepProcessing(xExpectedIdleTime);
        ulLPTimerInterruptFired = false;
        /* Re-enable interrupts - see comments above __disable_irq()
        call above. */
        __enable_irq();
        __NOP();
        if (ulLPTimerInterruptFired)
        {
            /* The tick interrupt handler will already have pended the tick
            processing in the kernel.  As the pending tick will be
            processed as soon as this function exits, the tick value
            maintained by the tick is stepped forward by one less than the
            time spent waiting. */
            ulCompleteTickPeriods   = xExpectedIdleTime - 1UL;
            ulLPTimerInterruptFired = false;
        }
        else
        {
            /* Something other than the tick interrupt ended the sleep.
            Work out how long the sleep lasted rounded to complete tick
            periods (not the ulReload value which accounted for part
            ticks). */
            ulCompleteTickPeriods = LPTMR_GetCurrentTimerCount(pxLptmrBase) / ulLPTimerCountsForOneTick;
        }
        /* Stop LPTMR when CPU waked up then set SysTick->LOAD back to its standard
        value.  The critical section is used to ensure the tick interrupt
        can only execute once in the case that the reload register is near
        zero. */
        LPTMR_StopTimer(pxLptmrBase);
        portENTER_CRITICAL();
        {
            SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
            vTaskStepTick(ulCompleteTickPeriods);
            SysTick->LOAD = ulTimerCountsForOneTick - 1UL;
        }
        portEXIT_CRITICAL();
    }
}

Kinetis MicrocontrollersのトピックRe: Low power mode with KW41Z

Low power mode with KW41Z

Re: Low power mode with KW41Z

Re: Low power mode with KW41Z

Re: Low power mode with KW41Z