当前位置：首页 > news >正文

RT-THREAD RTC组件中Alarm功能驱动完善

news 来源：原创 2025/8/5 20:46:32

使用Rt-Thread的目的为了更快的搭载工程，使用Rt-Thread丰富的组件和第三方包资源，解耦硬件，在更换芯片时可以移植应用层代码。你是要RTT的目的什么呢？

文章项目背景

以STM32L475RCT6为例

RTC使用的为LSE外部低速32 .756k Hz 的晶体振荡器。

使用RT-Thread Studio作为IDE进行项目开发，内核版本使用的为4.1.1。

参考：

RTC设备

RT-Thread-drv_rtc.c alarm 的实现

shell指令：

date：查看日期，（查询的为北京时间，不是UTC时间，北京时间比UTC时间快8h）

list_alarm：查看rtc闹钟

1.创建项目打开RTC组件

1.1配置RTC外设

打开drivers/board.h,按照注释进行对应操作，

打开RT-Thread Settings rtc driver support

board.h宏定义#define BSP_USING_ONCHIP_RTC

stm32xxxx_hal_config.h宏定义#define HAL_RTC_MODULE_ENABLED

1.2 编译报错

正常步骤来说进行上述操作后就可以了，但是编译报错

drivers/drv_rtc.c驱动报错

conflicting types for 'rt_hw_rtc_register'

出现这个错误的原因是rt_hw_rtc_register函数在两个地方被定义了，所以出现了类型定义冲突。这里只需要屏蔽其中一个定义就可以了。RTC初始化的操作是在BSP中的驱动中执行的，因此这里建议屏蔽内核中的rt_hw_rtc_register定义，只需要屏蔽rt- thread\components\drivers\include\drivers下的rtc.h文件中的函数声明就行了。

修改后编译成功，可以跑一下RTC的例程，RTC 设备使用示例

1.3 使用Alarm功能

查看 drivers/drv_rtc.c驱动，在rtt中，对RTC设备操作，最终还是通过函数指针使用static rt_err_t rt_rtc_control(rt_device_t dev, int cmd, void *args)函数进行的操作。可以发现该函数驱动并没有完善的功能。当然这部分功能在不同的BSP中驱动也会不同，所以需要手动完善。

因此，RTC的alarm功能需要完善，因此无法直接使用。

2.Alarm功能驱动开发

首先要明白Alarm的原理框架，在步骤1.2中虽然屏蔽了内核中的rtc设备注册函数，但是Alarm的功能框架仍然需要依赖内核中的rRTC组件中的Alarm功能。

查看项目中rt-thread\components\drivers\rtc目录下的alarm.c文件，在该文件中Alarm使用RTT的自动初始化机制INIT_PREV_EXPORT(rt_alarm_system_init);创建了一个线程用来监测RTC的闹钟。

通过参考官方Alarm使用示例：RTC设备

/*
** 程序清单：这是一个 RTC 设备使用例程
** 例程导出了 alarm_sample 命令到控制终端
** 命令调用格式：alarm_sample
** 程序功能：设置RTC时间，创建闹钟，模式：每秒触发，启动闹钟
**/void user_alarm_callback(rt_alarm_t alarm, time_t timestamp)
{rt_kprintf("user alarm callback function.\n");
}void alarm_sample(void)
{  rt_device_t dev = rt_device_find("rtc");struct rt_alarm_setup setup;struct rt_alarm * alarm = RT_NULL;static time_t now;struct tm p_tm;if (alarm != RT_NULL)return;/* 获取当前时间戳，并把下一秒时间设置为闹钟时间 */now = time(NULL) + 1;gmtime_r(&now,&p_tm);setup.flag = RT_ALARM_SECOND;            setup.wktime.tm_year = p_tm.tm_year;setup.wktime.tm_mon = p_tm.tm_mon;setup.wktime.tm_mday = p_tm.tm_mday;setup.wktime.tm_wday = p_tm.tm_wday;setup.wktime.tm_hour = p_tm.tm_hour;setup.wktime.tm_min = p_tm.tm_min;setup.wktime.tm_sec = p_tm.tm_sec;   alarm = rt_alarm_create(user_alarm_callback, &setup);    if(RT_NULL != alarm){rt_alarm_start(alarm);}
}
/* export msh cmd */
MSH_CMD_EXPORT(alarm_sample,alarm sample);

Alarm功能主要是通过 rt_alarm_create函数创建一个Alarm闹钟，该函数返回一个rt_alarm类型的结构体来承载闹钟信息。

然后再通过rt_alarm_start来启动闹钟。

在该函数中需要注意，rt_alarm_start 函数下的 alarm_setup函数会根据闹钟标志位对

alarm->wktime 闹钟的时间信息重新赋值，alarm_setup 中重新赋值使用 get_timestamp 函数重新获取时间，rtc.c文件中的get_timestamp 本质上也是通过 rt_device_control(_rtc_device, RT_DEVICE_CTRL_RTC_GET_TIME, timestamp);来获取rtc时间，最终还是通过调用drivers/drv_rtc.c驱动中的get_rtc_timestamp函数。

在梳理整个的RTC驱动时，要注意区分UTC时间和本地时间（北京时间）的函数接口

gmtime和localtime的线程安全版本：
gmtime_r(&now, &timeinfo);//UTC时间若为00 ：00：00
localtime_r(&now, &timeinfo);//本地时间即为08 ：00：00mktime(&tm_new); 和 timegm(&tm_new);

在移植驱动的过程中，可能会因为时间原因导致闹钟配置错误。

Alarm简介

rtt的官方文档中是这样介绍Alarm功能的：

alarm 闹钟功能是基于 RTC 设备实现的，根据用户设定的闹钟时间，当时间到时触发 alarm 中断，执行闹钟事件，在硬件上 RTC 提供的 Alarm 是有限的，RT-Thread 将 Alarm 在软件层次上封装成了一个组件，原理上可以实现无限个闹钟，但每个闹钟只有最后一次设定有效

我们知道STM32 的 RTC 模块通常支持设置两个闹钟，分别为闹钟 A（Alarm A）和闹钟 B（Alarm B）。但是在rtt中通过软件确实实现了多个闹钟的功能。

（移植完驱动代码后）通过在drv_rtc.c文件中的下列代码中添加打印，来判断RTC硬件闹钟和RTT软件闹钟实现的区别。

该回调函数为硬件RTC闹钟的回调函数

void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{rt_alarm_update(0,0);rt_kprintf("HAL RTC Alarm Handle CallBack\r\n");
}

通过list_alarm指令查询闹钟

这里可以发现，RTT是通过for循环遍历_container链表来管理的软件闹钟。虽然理论上可以实现无限个闹钟，但是如果需要RTC闹钟唤醒休眠状态下的MCU，那么软件闹钟是行不通的。

如果说进行低功耗方案设计，每次休眠状态都要进入待机模式：

在该模式下，除了 RTC 和备份域（包括备份寄存器和 RTC 时钟源），芯片的其他所有电源都被切断，内部电压调节器被关闭，SRAM 和寄存器内容丢失。

因此软件RTC闹钟数据会丢失，硬件RTC闹钟数据会被保留，在进行低功耗设计时使用RTT提供的RTC Alarm组件需要注意这一点。

void rt_alarm_dump(void)
{rt_list_t *next;rt_alarm_t alarm;rt_kprintf("| hh:mm:ss | week | flag | en |\n");rt_kprintf("+----------+------+------+----+\n");for (next = _container.head.next; next != &_container.head; next = next->next){alarm = rt_list_entry(next, struct rt_alarm, list);rt_uint8_t flag_index = get_alarm_flag_index(alarm->flag);rt_kprintf("| %02d:%02d:%02d |  %2d  |  %2s  | %2d |\n",alarm->wktime.tm_hour, alarm->wktime.tm_min, alarm->wktime.tm_sec,alarm->wktime.tm_wday, _alarm_flag_tbl[flag_index].name, alarm->flag & RT_ALARM_STATE_START);}rt_kprintf("+----------+------+------+----+\n");
}MSH_CMD_EXPORT_ALIAS(rt_alarm_dump, list_alarm, list alarm info);

Alarm回调函数的实现

下列函数为drv_rtc.c中RTC Alarm的事件回调函数。当RTC触发闹钟，程序便会触发该回调函数，执行rt_alarm_update

void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{rt_alarm_update(0,0);
}

alarm.c文件中的rt_alarm_update函数，rt_event_send是Rt-Thread中的线程同步机制：事件集。

事件集

在此处释放特定事件唤醒 alarmsvc 线程，最终通过该线程的alarm_update(recv)执行注册好的闹钟回调函数。

void rt_alarm_update(rt_device_t dev, rt_uint32_t event)
{rt_event_send(&_container.event, 1);
}

2.1drv_rtc.c驱动代码

附上drv_rtc.c完整代码，仅供参考

/** Copyright (c) 2006-2018, RT-Thread Development Team** SPDX-License-Identifier: Apache-2.0** Change Logs:* Date         Author        Notes* 2018-12-04   balanceTWK    first version*/#include "board.h"
#include<rtthread.h>
#include<rtdevice.h>#ifdef BSP_USING_ONCHIP_RTC#ifndef HAL_RTCEx_BKUPRead
#define HAL_RTCEx_BKUPRead(x1, x2) (~BKUP_REG_DATA)
#endif
#ifndef HAL_RTCEx_BKUPWrite
#define HAL_RTCEx_BKUPWrite(x1, x2, x3)
#endif
#ifndef RTC_BKP_DR1
#define RTC_BKP_DR1 RT_NULL
#endif//#define DRV_DEBUG
#define LOG_TAG             "drv.rtc"
#include <drv_log.h>#define BKUP_REG_DATA 0xA5A5static struct rt_device rtc;
static RTC_HandleTypeDef RTC_Handler;static time_t get_rtc_timestamp(void)
{RTC_TimeTypeDef RTC_TimeStruct = {0};RTC_DateTypeDef RTC_DateStruct = {0};struct tm tm_new;HAL_RTC_GetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN);HAL_RTC_GetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN);tm_new.tm_sec  = RTC_TimeStruct.Seconds;tm_new.tm_min  = RTC_TimeStruct.Minutes;tm_new.tm_hour = RTC_TimeStruct.Hours;tm_new.tm_mday = RTC_DateStruct.Date;tm_new.tm_mon  = RTC_DateStruct.Month - 1;tm_new.tm_year = RTC_DateStruct.Year + 100;LOG_D("get rtc time.");
//    return mktime(&tm_new);return timegm(&tm_new);
}static rt_err_t set_rtc_time_stamp(time_t time_stamp)
{RTC_TimeTypeDef RTC_TimeStruct = {0};RTC_DateTypeDef RTC_DateStruct = {0};struct tm *p_tm;p_tm = localtime(&time_stamp);if (p_tm->tm_year < 100){return -RT_ERROR;}RTC_TimeStruct.Seconds = p_tm->tm_sec ;RTC_TimeStruct.Minutes = p_tm->tm_min ;RTC_TimeStruct.Hours   = p_tm->tm_hour;RTC_DateStruct.Date    = p_tm->tm_mday;RTC_DateStruct.Month   = p_tm->tm_mon + 1 ;RTC_DateStruct.Year    = p_tm->tm_year - 100;RTC_DateStruct.WeekDay = p_tm->tm_wday + 1;if (HAL_RTC_SetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN) != HAL_OK){return -RT_ERROR;}if (HAL_RTC_SetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN) != HAL_OK){return -RT_ERROR;}LOG_D("set rtc time.");HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR1, BKUP_REG_DATA);return RT_EOK;
}static void rt_rtc_init(void)
{
#ifndef SOC_SERIES_STM32H7__HAL_RCC_PWR_CLK_ENABLE();
#endifRCC_OscInitTypeDef RCC_OscInitStruct = {0};
#ifdef BSP_RTC_USING_LSIRCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;RCC_OscInitStruct.LSEState = RCC_LSE_OFF;RCC_OscInitStruct.LSIState = RCC_LSI_ON;
#elseRCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;RCC_OscInitStruct.LSEState = RCC_LSE_ON;RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
#endifHAL_RCC_OscConfig(&RCC_OscInitStruct);
}static rt_err_t rt_rtc_config(struct rt_device *dev)
{RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};HAL_PWR_EnableBkUpAccess();PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
#ifdef BSP_RTC_USING_LSIPeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
#elsePeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
#endifHAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);/* Enable RTC Clock */__HAL_RCC_RTC_ENABLE();RTC_Handler.Instance = RTC;if (HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR1) != BKUP_REG_DATA){LOG_I("RTC hasn't been configured, please use <date> command to config.");#if defined(SOC_SERIES_STM32F1)RTC_Handler.Init.OutPut = RTC_OUTPUTSOURCE_NONE;RTC_Handler.Init.AsynchPrediv = RTC_AUTO_1_SECOND;
#elif defined(SOC_SERIES_STM32F0)/* set the frequency division */
#ifdef BSP_RTC_USING_LSIRTC_Handler.Init.AsynchPrediv = 0XA0;RTC_Handler.Init.SynchPrediv = 0xFA;
#elseRTC_Handler.Init.AsynchPrediv = 0X7F;RTC_Handler.Init.SynchPrediv = 0x0130;
#endif /* BSP_RTC_USING_LSI */RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
#elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32H7)/* set the frequency division */
#ifdef BSP_RTC_USING_LSIRTC_Handler.Init.AsynchPrediv = 0X7D;
#elseRTC_Handler.Init.AsynchPrediv = 0X7F;
#endif /* BSP_RTC_USING_LSI */RTC_Handler.Init.SynchPrediv = 0XFF;RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
#endifif (HAL_RTC_Init(&RTC_Handler) != HAL_OK){return -RT_ERROR;}}return RT_EOK;
}static rt_err_t set_rtc_alarm_stamp(struct rt_rtc_wkalarm wkalarm)
{RTC_AlarmTypeDef sAlarm = {0};//struct tm *p_tm;//p_tm = localtime(&time_stamp);if(wkalarm.enable == RT_FALSE){if (HAL_RTC_DeactivateAlarm(&RTC_Handler,RTC_ALARM_A) != HAL_OK){return -RT_ERROR;}LOG_D("stop rtc alarm.");}else {/** Enable the Alarm A*/sAlarm.AlarmTime.Hours = wkalarm.tm_hour;sAlarm.AlarmTime.Minutes = wkalarm.tm_min;sAlarm.AlarmTime.Seconds = wkalarm.tm_sec;sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;sAlarm.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY;sAlarm.Alarm = RTC_ALARM_A;if (HAL_RTC_SetAlarm_IT(&RTC_Handler, &sAlarm, RTC_FORMAT_BIN) != HAL_OK){return -RT_ERROR;}LOG_D("set rtc alarm.");}return RT_EOK;
}
/*** @brief This function handles RTC alarms A and B interrupt through EXTI line 17.*/
void RTC_Alarm_IRQHandler(void)
{/* USER CODE BEGIN RTC_Alarm_IRQn 0 *//* USER CODE END RTC_Alarm_IRQn 0 */HAL_RTC_AlarmIRQHandler(&RTC_Handler);/* USER CODE BEGIN RTC_Alarm_IRQn 1 *//* USER CODE END RTC_Alarm_IRQn 1 */
}
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{rt_alarm_update(0,0);
}
struct rt_rtc_wkalarm get_rtc_alarm_stamp(void)
{RTC_AlarmTypeDef sAlarm = {0};//struct tm tm_new = {0};struct rt_rtc_wkalarm wkalarm;if (HAL_RTC_GetAlarm(&RTC_Handler, &sAlarm,RTC_ALARM_A, RTC_FORMAT_BIN) != HAL_OK){LOG_D("get rtc alarm fail!.");}wkalarm.tm_sec  = sAlarm.AlarmTime.Seconds;wkalarm.tm_min = sAlarm.AlarmTime.Minutes;wkalarm.tm_hour = sAlarm.AlarmTime.Hours;// 打印获取到的 RTC 闹钟时间信息
//    rt_kprintf("get rtc alarm: %d %d %d\r\n", wkalarm.tm_hour, wkalarm.tm_min, wkalarm.tm_sec);return wkalarm;
}static rt_err_t rt_rtc_control(rt_device_t dev, int cmd, void *args)
{rt_err_t result = RT_EOK;RT_ASSERT(dev != RT_NULL);switch (cmd){case RT_DEVICE_CTRL_RTC_GET_TIME:*(rt_uint32_t *)args = get_rtc_timestamp();LOG_D("RTC: get rtc_time %x\n", *(rt_uint32_t *)args);break;case RT_DEVICE_CTRL_RTC_SET_TIME:if (set_rtc_time_stamp(*(rt_uint32_t *)args)){result = -RT_ERROR;}LOG_D("RTC: set rtc_time %x\n", *(rt_uint32_t *)args);break;case RT_DEVICE_CTRL_RTC_SET_ALARM:if (set_rtc_alarm_stamp(*(struct rt_rtc_wkalarm *)args)){result = -RT_ERROR;}LOG_D("RTC: set rtc_alarm %x\n", *(rt_uint32_t *)args);break;case RT_DEVICE_CTRL_RTC_GET_ALARM:*(struct rt_rtc_wkalarm *)args = get_rtc_alarm_stamp();LOG_D("RTC: get rtc_alarm %x\n", *(rt_uint32_t *)args);break;}return result;
}#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops rtc_ops =
{RT_NULL,RT_NULL,RT_NULL,RT_NULL,RT_NULL,rt_rtc_control
};
#endifstatic rt_err_t rt_hw_rtc_register(rt_device_t device, const char *name, rt_uint32_t flag)
{RT_ASSERT(device != RT_NULL);rt_rtc_init();if (rt_rtc_config(device) != RT_EOK){return -RT_ERROR;}
#ifdef RT_USING_DEVICE_OPSdevice->ops         = &rtc_ops;
#elsedevice->init        = RT_NULL;device->open        = RT_NULL;device->close       = RT_NULL;device->read        = RT_NULL;device->write       = RT_NULL;device->control     = rt_rtc_control;
#endifdevice->type        = RT_Device_Class_RTC;device->rx_indicate = RT_NULL;device->tx_complete = RT_NULL;device->user_data   = RT_NULL;/* register a character device */return rt_device_register(device, name, flag);
}int rt_hw_rtc_init(void)
{/* RTC interrupt DeInit */HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0, 0);HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);rt_err_t result;result = rt_hw_rtc_register(&rtc, "rtc", RT_DEVICE_FLAG_RDWR);if (result != RT_EOK){LOG_E("rtc register err code: %d", result);return result;}LOG_D("rtc init success");return RT_EOK;
}
INIT_DEVICE_EXPORT(rt_hw_rtc_init);#endif /* BSP_USING_ONCHIP_RTC */

获取RTC时间的shell指令，如果有需要可以放在drv_rtc.c文件中使用

void getrtc(void)
{RTC_TimeTypeDef RTC_TimeStruct = {0};RTC_DateTypeDef RTC_DateStruct = {0};struct tm tm_new;HAL_RTC_GetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN);HAL_RTC_GetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN);tm_new.tm_sec  = RTC_TimeStruct.Seconds;tm_new.tm_min  = RTC_TimeStruct.Minutes;tm_new.tm_hour = RTC_TimeStruct.Hours;tm_new.tm_mday = RTC_DateStruct.Date;tm_new.tm_mon  = RTC_DateStruct.Month - 1;tm_new.tm_year = RTC_DateStruct.Year + 100;rt_kprintf("GET RTC time: %04d-%02d-%02d %02d:%02d:%02d\n",tm_new.tm_year,  // tm_year是从1900年开始计算的tm_new.tm_mon,      // tm_mon是从0开始的，所以要加1tm_new.tm_mday,tm_new.tm_hour,tm_new.tm_min,tm_new.tm_sec);
}MSH_CMD_EXPORT(getrtc,alarm sample);

2.2Alarm测试代码

以下为Alarm测试代码，可以放在main.c中使用

/** Copyright (c) 2006-2025, RT-Thread Development Team** SPDX-License-Identifier: Apache-2.0** Change Logs:* Date           Author       Notes* 2025-05-08     RT-Thread    first version*/#include <rtthread.h>
#include <rtdevice.h>
#include <stdlib.h>
#include <time.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>#include "board.h"int main(void)
{
//    int count = 1;
//
//    while (count++)
//    {
//        LOG_D("Hello RT-Thread!");
//        rt_thread_mdelay(1000);
//    }return RT_EOK;
}/*
** 程序清单：这是一个 RTC 设备使用例程
** 例程导出了 alarm_sample 命令到控制终端
** 命令调用格式：alarm_sample
** 程序功能：设置RTC时间，创建闹钟，模式：每秒触发，启动闹钟
**/void user_alarm_callback(rt_alarm_t alarm, time_t timestamp)
{rt_kprintf("user alarm callback function.\n");
}void alarm_sample(void)
{
//  设置RTC时间，set_time(00, 00, 00);//北京时间，alarm为UTC时间
//  配置Alarm闹钟time_t now;struct tm timeinfo;rt_device_t rtc_dev = rt_device_find("rtc");if (rtc_dev == RT_NULL){rt_kprintf("Find RTC device failed!\n");return;}rt_device_open(rtc_dev, RT_DEVICE_OFLAG_RDWR);rt_err_t result = rt_device_control(rtc_dev, RT_DEVICE_CTRL_RTC_GET_TIME, &now);if (result != RT_EOK){rt_kprintf("Get RTC time failed! Error code: %d\n", result);rt_device_close(rtc_dev);return;}
//  RTC闹钟设置为本地时间可以触发，但是alarm线程会将时间改为UTC时间，所以建议使用UTC时间设置闹钟，这样可以将时间统一。gmtime_r(&now, &timeinfo);//UTC时间0时
//    localtime_r(&now, &timeinfo);//本地北京时间8时rt_kprintf("timeinfo time: %04d-%02d-%02d %02d:%02d:%02d\n",timeinfo.tm_year + 1900,  // tm_year是从1900年开始计算的timeinfo.tm_mon + 1,      // tm_mon是从0开始的，所以要加1timeinfo.tm_mday,timeinfo.tm_hour,timeinfo.tm_min,timeinfo.tm_sec);struct rt_alarm_setup setup;struct rt_alarm * alarm = RT_NULL;setup.flag = RT_ALARM_SECOND;setup.wktime.tm_year = timeinfo.tm_year;setup.wktime.tm_mon = timeinfo.tm_mon;setup.wktime.tm_mday = timeinfo.tm_mday;setup.wktime.tm_wday = timeinfo.tm_wday;setup.wktime.tm_hour = timeinfo.tm_hour;setup.wktime.tm_min = timeinfo.tm_min;setup.wktime.tm_sec = timeinfo.tm_sec;alarm = rt_alarm_create(user_alarm_callback, &setup);if(RT_NULL != alarm){rt_alarm_start(alarm);}rt_kprintf("net time: %02d:%02d:%02d\n",alarm->wktime.tm_hour,alarm->wktime.tm_min,alarm->wktime.tm_sec);}
/* export msh cmd */
MSH_CMD_EXPORT(alarm_sample,alarm sample);

附：

项目工程：

https://gitee.com/Z-cjie/rtts-rtc-alarm-component.git