PM电源管理低功耗华大_小华单片机HC32

移植PM到HC32L196

发布于 2024-03-16 11:15:07 浏览：401 订阅该版

[tocm]

我准备移植HC32L196的PM2.0驱动
LPUart作为consol，使用LPTimer1作为PM的低功耗定时器
LPUart和LPTimer都使用RCL时钟源
# 问题：
我创建一个lptimer，超时时间2s，在回调函数里翻转LED，设备开机后5s后进入深度睡眠
从功耗上看，5s后确认进入深度睡眠了，但是5s内闪烁频率还没问题，5s后**闪烁周期不是2s**，而是一个**无规律的闪烁**，
正常应该是2s灭，2s亮，但是现象是可能亮了200ms，灭了3s，又亮5s，又灭500ms，完全没有规律。
但是如果我不进入深度睡眠，在正常模式和轻度睡眠模式下，定时器都可以正常2s超时中断，非常准
感觉是drv_lptim.c驱动问题，导致pm.c中，计算timeout_tick或者delta_tick出的问题，因为hc32l196的lptimer是超时后，把arr的值写到cnt，然后向上计数超时，类似51单片机的定时器，但是水平有限，不知道怎么改，拜托大神???

# 代码：
主要是两个文件，drv_lptim.c和drv_pm.c
drv_lptime.c内容：
```c
#include <board.h>
#include <hc32l196_lptim.h>
#include <drv_lptim.h>

#define LPTIMER_HANDLER M0P_LPTIMER1
#define SysctrlPeripheralLpTim SysctrlPeripheralLpTim1

void LpTim1_IRQHandler(void)
{
    if (TRUE == Lptim_GetItStatus(LPTIMER_HANDLER))
    {
        Lptim_ClrItStatus(LPTIMER_HANDLER); // 清除LPTIMER0的中断标志位
    }
}

/**
 * This function get current count value of LPTIM
 *
 * @return the count vlaue
 */
rt_uint32_t lptim_get_current_tick(void)
{
    return LPTIMER_HANDLER->CNT - LPTIMER_HANDLER->ARR;
}

/**
 * This function get the max value that LPTIM can count
 *
 * @return the max count
 */
rt_uint32_t lptim_get_tick_max(void)
{
    return (0xFFFF);
}

/**
 * This function start LPTIM with reload value
 *
 * @param reload The value that LPTIM count down from
 *
 * @return RT_EOK
 */
rt_err_t lptim_start(rt_uint32_t reload)
{
    Lptim_Cmd(LPTIMER_HANDLER, FALSE); // 关闭LPTIMER0
    LPTIMER_HANDLER->ARR = 0xffff - reload + 1;
    Lptim_Cmd(LPTIMER_HANDLER, TRUE);    // 使能LPTIMER0
    return (RT_EOK);
}

/**
 * This function stop LPTIM
 */
void lptim_stop(void)
{
    Lptim_Cmd(LPTIMER_HANDLER, FALSE);  // 关闭LPTIMER0
}

/**
 * This function get the count clock of LPTIM
 *
 * @return the count clock frequency in Hz
 */
rt_uint32_t lptim_get_countfreq(void)
{
    return 38400 / 32;
}

/**
 * This function initialize the lptim
 */
int hw_lptim_init(void)
{
    stc_lptim_cfg_t stcLptCfg;
    DDL_ZERO_STRUCT(stcLptCfg);

//Sysctrl_ClkSourceEnable(SysctrlClkXTL, TRUE);
    Sysctrl_SetRCLTrim(SysctrlRclFreq38400);
    Sysctrl_ClkSourceEnable(SysctrlClkRCL, TRUE);
    ///< 使能LPTIM0 外设时钟
    Sysctrl_SetPeripheralGate(SysctrlPeripheralLpTim, TRUE);

stcLptCfg.enPrs = LptimPrsDiv32;
    stcLptCfg.enGate = LptimGateLow;
    stcLptCfg.enGatep = LptimGatePLow;
    stcLptCfg.enTcksel = LptimRcl;
    stcLptCfg.enTogen = LptimTogEnLow;
    stcLptCfg.enCt = LptimTimerFun;
    stcLptCfg.enMd = LptimMode2;
    stcLptCfg.u16Arr = 65535;
    Lptim_Init(LPTIMER_HANDLER, &stcLptCfg);

Lptim_ClrItStatus(LPTIMER_HANDLER);  // 清除中断标志位
    Lptim_ConfIt(LPTIMER_HANDLER, TRUE); // 允许LPTIMER中断
    EnableNvic(LPTIM_0_1_IRQn, IrqLevel0, TRUE);

return 0;
}

INIT_DEVICE_EXPORT(hw_lptim_init);

```
drv_pm.c内容

```c
/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-05-06     Zero-Free    first version
 */

#include <board.h>
#include <drv_lptim.h>
//#include <pm.h>
#include <hc32l196_lpm.h>

static void uart_console_reconfig(void)
{
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;

rt_device_control(rt_console_get_device(), RT_DEVICE_CTRL_CONFIG, &config);
    rt_device_close(rt_console_get_device());
    rt_device_open(rt_console_get_device(), RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_STREAM);
}

/**
 * This function will put STM32L4xx into sleep mode.
 *
 * @param pm pointer to power manage structure
 */
static void sleep(struct rt_pm *pm, uint8_t mode)
{
    switch (mode)
    {
    case PM_SLEEP_MODE_NONE:
        break;

case PM_SLEEP_MODE_IDLE:
        Lpm_GotoSleep(FALSE);
        break;

case PM_SLEEP_MODE_LIGHT:
        Lpm_GotoSleep(FALSE);
        break;

case PM_SLEEP_MODE_DEEP:
        Lpm_GotoDeepSleep(FALSE);
        break;

case PM_SLEEP_MODE_STANDBY:
        Lpm_GotoDeepSleep(FALSE);
        break;

case PM_SLEEP_MODE_SHUTDOWN:
        Lpm_GotoDeepSleep(FALSE);
        break;

default:
        RT_ASSERT(0);
        break;
    }
}

static uint8_t run_speed[PM_RUN_MODE_MAX][2] =
{
    {24, 0},
    {16, 1},
    {8, 2},
    {4,  3},
};

static void run(struct rt_pm *pm, uint8_t mode)
{
    static uint8_t last_mode;
    static char *run_str[] = PM_RUN_MODE_NAMES;

if (mode == last_mode)
        return;
    last_mode = mode;

/* 2. 根据RUN模式切换时钟频率(HSI) */
    switch (mode)
    {
    case PM_RUN_MODE_HIGH_SPEED:
        rt_hw_board_clock_init(SysctrlRchFreq24MHz);
        break;
    case PM_RUN_MODE_NORMAL_SPEED:
        rt_hw_board_clock_init(SysctrlRchFreq16MHz);
        break;
    case PM_RUN_MODE_MEDIUM_SPEED:
        rt_hw_board_clock_init(SysctrlRchFreq8MHz);
        break;
    case PM_RUN_MODE_LOW_SPEED:
        rt_hw_board_clock_init(SysctrlRchFreq4MHz);
        break;
    default:
        break;
    }
    /* 4. 更新外设时钟 */
    uart_console_reconfig();
    /* Re-Configure the Systick time */
    SysTick_Configuration();

rt_kprintf("switch to %s mode, frequency = %d MHz\n", run_str[mode], run_speed[mode][0]);
}

/**
 * This function caculate the PM tick from OS tick
 *
 * @param tick OS tick
 *
 * @return the PM tick
 */
static rt_tick_t pm_tick_from_os_tick(rt_tick_t tick)
{
    rt_uint32_t freq = lptim_get_countfreq();

return (freq * tick / RT_TICK_PER_SECOND);
}

/**
 * This function caculate the OS tick from PM tick
 *
 * @param tick PM tick
 *
 * @return the OS tick
 */
static rt_tick_t os_tick_from_pm_tick(rt_uint32_t tick)
{
    static rt_uint32_t os_tick_remain = 0;
    rt_uint32_t ret, freq;

freq = lptim_get_countfreq();
    ret = (tick * RT_TICK_PER_SECOND + os_tick_remain) / freq;

os_tick_remain += (tick * RT_TICK_PER_SECOND);
    os_tick_remain %= freq;

return ret;
}

/**
 * This function start the timer of pm
 *
 * @param pm Pointer to power manage structure
 * @param timeout How many OS Ticks that MCU can sleep
 */
static void pm_timer_start(struct rt_pm *pm, rt_uint32_t timeout)
{
    RT_ASSERT(pm != RT_NULL);
    RT_ASSERT(timeout > 0);

if (timeout != RT_TICK_MAX)
    {
        /* Convert OS Tick to pmtimer timeout value */
        timeout = pm_tick_from_os_tick(timeout);
        if (timeout > lptim_get_tick_max())
        {
            timeout = lptim_get_tick_max();
        }

/* Enter PM_TIMER_MODE */
        lptim_start(timeout);
    }
}

/**
 * This function stop the timer of pm
 *
 * @param pm Pointer to power manage structure
 */
static void pm_timer_stop(struct rt_pm *pm)
{
    RT_ASSERT(pm != RT_NULL);

/* Reset pmtimer status */
    lptim_stop();
}

/**
 * This function calculate how many OS Ticks that MCU have suspended
 *
 * @param pm Pointer to power manage structure
 *
 * @return OS Ticks
 */
static rt_tick_t pm_timer_get_tick(struct rt_pm *pm)
{
    rt_uint32_t timer_tick;

RT_ASSERT(pm != RT_NULL);

timer_tick = lptim_get_current_tick();

return os_tick_from_pm_tick(timer_tick);
}

/**
 * This function initialize the power manager
 */
int drv_pm_hw_init(void)
{
    static const struct rt_pm_ops _ops =
    {
        sleep,
        run,
        pm_timer_start,
        pm_timer_stop,
        pm_timer_get_tick
    };

rt_uint8_t timer_mask = 0;

/* initialize timer mask */
    timer_mask = 1UL << PM_SLEEP_MODE_DEEP;

/* initialize system pm module */
    rt_system_pm_init(&_ops, timer_mask, RT_NULL);

return 0;
}

INIT_BOARD_EXPORT(drv_pm_hw_init);

```
timer_app.c

```c
/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-08-07     Tanek        first implementation
 * 2019-05-06     Zero-Free    adapt to the new power management interface
 */

#include <board.h>
#include <rtthread.h>
#include <rtdevice.h>

#define LED_PIN                 GET_PIN(C, 8)

#ifndef RT_USING_TIMER_SOFT
    #error "Please enable soft timer feature!"
#endif

#define TIMER_APP_DEFAULT_TICK  (RT_TICK_PER_SECOND * 2)

#ifdef RT_USING_PM

static void _timeout_entry(void *parameter)
{
    static rt_uint8_t state = 0;
    rt_kprintf("current tick: %ld\n", rt_tick_get());
    if(state == 0)
    {
        rt_pin_write(LED_PIN, PIN_LOW);
        state  = 1;
    }else
    {
        rt_pin_write(LED_PIN, PIN_HIGH);
        state = 0;
    }
}
static struct rt_lptimer lptimer; 
static int timer_app_init(void)
{
    rt_lptimer_init(&lptimer,
    "timer_app",
                             _timeout_entry,
                             RT_NULL,
                             TIMER_APP_DEFAULT_TICK,
                             RT_TIMER_FLAG_PERIODIC);
    //if (timer1 != RT_NULL)
    {
        rt_lptimer_start(&lptimer);

/* keep in timer mode */
        //rt_pm_request(PM_SLEEP_MODE_DEEP);

return 0;
    }

}
INIT_APP_EXPORT(timer_app_init);

#endif /* RT_USING_PM */

```

1 个回答

johnzhy 2024-03-16

这家伙很懒，什么也没写！

johnzhy

johnzhy 2024-03-16

这家伙很懒，什么也没写！

johnzhy

johnzhy 2024-03-18

这家伙很懒，什么也没写！

自己解决了，优化了一下lptimer的驱动。不过留了个小问题，就是使用的外部低速时钟32768，32分频，但是2s的定时器时间只有1.7s左右，就这样吧。

drv_lptim.c

```c
#include <board.h>
#include <hc32l196_lptim.h>
#include <drv_lptim.h>

#define LPTIMER_HANDLER M0P_LPTIMER1
#define SysctrlPeripheralLpTim SysctrlPeripheralLpTim1
static volatile rt_uint16_t lpt_start = 0;
void LpTim1_IRQHandler(void)
{
    if (TRUE == Lptim_GetItStatus(LPTIMER_HANDLER))
    {
        Lptim_ClrItStatus(LPTIMER_HANDLER); 
    }
}

/**
 * This function get current count value of LPTIM
 *
 * @return the count vlaue
 */
rt_uint32_t lptim_get_current_tick(void)
{
    rt_uint16_t temp_cnt, res;
    temp_cnt = LPTIMER_HANDLER->CNT;
    if(temp_cnt >= lpt_start)
        res = temp_cnt - lpt_start;
    else 
        res = (rt_uint32_t)temp_cnt + 0xffff - lpt_start;
    return res;
}

/**
 * This function get the max value that LPTIM can count
 *
 * @return the max count
 */
rt_uint32_t lptim_get_tick_max(void)
{
    return (0xFFFF);
}

/**
 * This function start LPTIM with reload value
 *
 * @param reload The value that LPTIM count down from
 *
 * @return RT_EOK
 */
rt_err_t lptim_start(rt_uint32_t reload)
{
    Lptim_Cmd(LPTIMER_HANDLER, FALSE); 
    Lptim_ClrItStatus(LPTIMER_HANDLER);
    lpt_start = 0xffff - reload;
    while(LPTIMER_HANDLER->CR_f.WT_FLAG == 0);
    rt_enter_critical();
    LPTIMER_HANDLER->ARR = lpt_start;
    Lptim_Cmd(LPTIMER_HANDLER, TRUE); 
    while(LPTIMER_HANDLER->CR_f.WT_FLAG == 0);
    rt_exit_critical();
    
    return (RT_EOK);
}

/**
 * This function stop LPTIM
 */
void lptim_stop(void)
{
    Lptim_Cmd(LPTIMER_HANDLER, FALSE); 
}

/**
 * This function get the count clock of LPTIM
 *
 * @return the count clock frequency in Hz
 */
rt_uint32_t lptim_get_countfreq(void)
{
    return 32768 / 32;
}

/**
 * This function initialize the lptim
 */
int hw_lptim_init(void)
{
    stc_lptim_cfg_t stcLptCfg;
    DDL_ZERO_STRUCT(stcLptCfg);

Sysctrl_ClkSourceEnable(SysctrlClkXTL, TRUE);
    // Sysctrl_SetRCLTrim(SysctrlRclFreq38400);
    // Sysctrl_ClkSourceEnable(SysctrlClkRCL, TRUE);

Sysctrl_SetPeripheralGate(SysctrlPeripheralLpTim, TRUE);

stcLptCfg.enPrs = LptimPrsDiv32;
    stcLptCfg.enGate = LptimGateLow;
    stcLptCfg.enGatep = LptimGatePLow;
    stcLptCfg.enTcksel = LptimRcl;
    stcLptCfg.enTogen = LptimTogEnLow;
    stcLptCfg.enCt = LptimTimerFun;
    stcLptCfg.enMd = LptimMode1;
    stcLptCfg.u16Arr = 0;
    Lptim_Init(LPTIMER_HANDLER, &stcLptCfg);

Lptim_ClrItStatus(LPTIMER_HANDLER);  
    Lptim_ConfIt(LPTIMER_HANDLER, TRUE); 
    EnableNvic(LPTIM_0_1_IRQn, IrqLevel0, TRUE);

return 0;
}

INIT_DEVICE_EXPORT(hw_lptim_init);

```

xiaorui

xiaorui 2024-03-18

小睿手办 https://item.taobao.com/item.htm?id=674889867009

请登录后再发布评论，点击登录

撰写答案

关注者

0

被浏览

401

关于作者

johnzhy

这家伙很懒，什么也没写！

提问

回答

被采纳

相关问题

1

STM32F103的低功耗

2

最近用rtthread系统下AD采样并低功耗，中断响应不及时

3

rt-thread低功耗休眠应用问题请教

4

关于RTT对低功耗的支持

5

RT-Thread怎么休眠实现低功耗。

6

RT-Thread V3.0支持的低功耗，OS会自行进入吗？

7

关于RTThread3.0低功耗休眠模式

8

RTT3.0的bsp包中哪些MCU自带低功耗定时器？

9

关于低功耗上次说针对L4出个BSP的，怎么迟迟不见呀

10

低功耗问题。

本月文章贡献

程序员阿伟

程序员阿伟

9 篇文章 2 次点赞

hhart

3 篇文章 4 次点赞

大龄码农

1 篇文章 5 次点赞

RTT_逍遥

1 篇文章 2 次点赞

ThinkCode

1 篇文章 1 次点赞

回到
顶部

发布
问题

手机
浏览

扫码手机浏览

回到
底部