使用alarm模块的时候，设置时间之后没有更新新的alarm时间

发布于 2023-11-03 11:15:06 浏览：529 订阅该版

你好，我使用的是rt-thread studio 2.2.6，在STM32F407VG芯片上使用RT-THREAD的标准版本4.1.1。
在使用提供的alarm模块时，设置了一个每分钟触发的alarm。当我在msh命令行中，使用date命令设置时间之后，这个每分钟触发的alarm有可能出现没有更新的情况，通过实验是可以复现这个bug的。复现的方法是使用date命令设置时间是，秒的设置不是0秒，比如设置成12秒，就会出现每分钟触发的alarm不更新。
可以看如下截图

![1.png](https://oss-club.rt-thread.org/uploads/20231103/fb1472005cd70231a4fe9d5bb46f1526.png)

而使用date设置时间时，只有秒为0的时候，每分钟触发的alarm才能正确的更新

![2.png](https://oss-club.rt-thread.org/uploads/20231103/521d111315674e8b46675364a831eb90.png)

我创建的alarm的代码如下：

```c
rt_alarm_t alarm_10min,alarm_timing,alarm_zerotime;

void create_10_min_alarm()
{
    struct rt_alarm_setup alarm_setup;
    alarm_setup.flag = RT_ALARM_MINUTE;
    alarm_setup.wktime.tm_sec = 0;
    alarm_10min = rt_alarm_create(alarm_10min_handle,&alarm_setup);
}

void create_alarm_app()
{
    rt_err_t err1,err2,err3;
    create_10_min_alarm();
    create_timing_alarm();
    create_zerotime_alarm();
    err1 = rt_alarm_start(alarm_10min);
    err2 = rt_alarm_start(alarm_timing);
    err3 = rt_alarm_start(alarm_zerotime);
    if((err1 != RT_EOK) || (err2 != RT_EOK)|| (err3 != RT_EOK)){
        LOG_E("ALARM start failed,%d-%d-%d",err1,err2,err3);
    }else{
        LOG_D("start Alarm");
    }
}
```
希望程序员们能够提供如何修改的方法。

3 个回答

crystal266 2023-11-03

嵌入式

李宇鹏 2023-11-03

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

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

追加回复

见微知著 2024-01-17

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

li1151894668 2025-03-19

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

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

追加回复

li1151894668 2025-03-19

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

使用日时间戳判断周期性分钟及小时闹钟是否过时来更新设定时间，溢出计算放到switch之后减少冗余代码。
```c
static rt_int32_t get_delta(rt_int32_t a, rt_int32_t b, rt_int32_t limit)
{
    if (!a)
    {
        a = limit;
    }

if (!b)
    {
        b = limit;
    }

if (a > b)
    {
        return a - b;
    }

return b - a;
}

static void alarm_wakeup(struct rt_alarm *alarm, struct tm *now)
{
    rt_uint32_t sec_alarm, sec_now;
    rt_bool_t wakeup = RT_FALSE;
    time_t timestamp;

sec_alarm = alarm_mkdaysec(&alarm->wktime);
    sec_now = alarm_mkdaysec(now);

if (alarm->flag & RT_ALARM_STATE_START)
    {
        switch (alarm->flag & 0xFF00)
        {
            case RT_ALARM_ONESHOT:
            {
                sec_alarm = timegm(&alarm->wktime);
                sec_now = timegm(now);
                if (((sec_now - sec_alarm) <= RT_ALARM_DELAY) && (sec_now >= sec_alarm))
                {
                    /* stop alarm */
                    alarm->flag &= ~RT_ALARM_STATE_START;
                    alarm_set(alarm);
                    wakeup = RT_TRUE;
                }
            }
            break;
            case RT_ALARM_SECOND:
            {
                alarm->wktime.tm_hour = now->tm_hour;
                alarm->wktime.tm_min = now->tm_min;
                alarm->wktime.tm_sec = now->tm_sec + 1;
                wakeup = RT_TRUE;
            }
            break;
                        case RT_ALARM_MINUTE:
            {
                if (60 - 1 < get_delta(sec_alarm, sec_now, 24*60*60))
                {
                    alarm->wktime.tm_hour = now->tm_hour;
                    alarm->wktime.tm_min = now->tm_min;
                }
                if (sec_alarm <= sec_now)
                {
                    alarm->wktime.tm_min = now->tm_min + 1;
                }
                if (alarm->wktime.tm_sec == now->tm_sec)
                {
                    wakeup = RT_TRUE;
                }
            }
            break;
            case RT_ALARM_HOUR:
            {
                if (60*60 - 1 < get_delta(sec_alarm, sec_now, 24*60*60))
                {
                    alarm->wktime.tm_hour = now->tm_hour;
                }
                if (sec_alarm <= sec_now)
                {
                    alarm->wktime.tm_hour = now->tm_hour + 1;
                }
                if ((alarm->wktime.tm_min == now->tm_min) &&
                    (alarm->wktime.tm_sec == now->tm_sec))
                {
                    wakeup = RT_TRUE;
                }
            }
            break;
            case RT_ALARM_DAILY:
            {
                if (((sec_now - sec_alarm) <= RT_ALARM_DELAY) && (sec_now >= sec_alarm))
                    wakeup = RT_TRUE;
            }
            break;
            case RT_ALARM_WEEKLY:
            {
                /* alarm at wday */
                if (alarm->wktime.tm_wday == now->tm_wday)
                {
                    sec_alarm += alarm->wktime.tm_wday * 24 * 3600;
                    sec_now += now->tm_wday * 24 * 3600;

if (sec_now == sec_alarm)
                        wakeup = RT_TRUE;
                }
            }
            break;
            case RT_ALARM_MONTHLY:
            {
                /* monthly someday generate alarm signals */
                if (alarm->wktime.tm_mday == now->tm_mday)
                {
                    if ((sec_now - sec_alarm) <= RT_ALARM_DELAY)
                        wakeup = RT_TRUE;
                }
            }
            break;
            case RT_ALARM_YAERLY:
            {
                if ((alarm->wktime.tm_mday == now->tm_mday) && \
                        (alarm->wktime.tm_mon == now->tm_mon))
                {
                    if ((sec_now - sec_alarm) <= RT_ALARM_DELAY)
                        wakeup = RT_TRUE;
                }
            }
            break;
        }

if (alarm->wktime.tm_sec > 59)
        {
            alarm->wktime.tm_sec = 0;
            alarm->wktime.tm_min = alarm->wktime.tm_min + 1;
        }

if (alarm->wktime.tm_min > 59)
        {
            alarm->wktime.tm_min = 0;
            alarm->wktime.tm_hour = alarm->wktime.tm_hour + 1;
        }

if (alarm->wktime.tm_hour > 23)
        {
            alarm->wktime.tm_hour = 0;
        }

if ((wakeup == RT_TRUE) && (alarm->callback != RT_NULL))
        {
            timestamp = (time_t)0;
            get_timestamp(×tamp);
            alarm->callback(alarm, timestamp);
        }
    }
}
```