定时器与日历时钟

原创 已于 2023-11-25 22:07:12 修改 · 1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#1024程序员节 #stm32 #单片机 #嵌入式硬件 #c语言

于 2023-11-22 19:51:04 首次发布
本文围绕STM32日历读取、设置和输出展开。先介绍RTC原理，包括其功能、特征、时钟选择、复位过程等，接着说明用CubeMX建立项目的步骤，给出相关代码，展示烧录结果，最后总结实验，了解了RTC配置和基本工作原理。

STM32日历读取，设置和输出

目录

一、RTC原理

（一）RTC介绍

一、RTC原理
（一）RTC介绍
RTC（Real-Time Clock）是一种实时时钟设备，用于记录和追踪时间。它通常包含一个时钟芯片和一个电池备份电源，以便在断电情况下保持时钟运行。

RTC的主要功能是提供准确的日期和时间信息，并能够持续跟踪时间的变化。它通常包括以下特性：

  1. 时钟计数器： RTC使用内部计数器来记录时间，通常以秒、分钟、小时、日期、月份和年份等形式进行计数。它可以精确到毫秒级别，提供高精度的时间跟踪。

  2. 时间补偿功能： RTC能够自动补偿温度和电压的变化对时钟精度的影响。它可以根据环境的变化来调整内部时钟的频率，以保持准确的时间追踪。

  3. 闹钟功能： RTC可以设置多个闹钟，以便在指定的时间触发特定的事件或响铃。这对于提醒、提醒事项和定时操作很有用。

  4. 电池备份： RTC通常具有电池备份电源，当主电源断电时，它可以保持时钟运行和时间信息的存储。这样即使在断电和重新上电后，RTC仍能继续提供准确的时间信息。

RTC广泛应用于各种系统和设备中，如计算机、嵌入式系统、通信设备、电子设备、自动化系统等。它们在需要精确时间跟踪和时间标记的应用中非常重要，如数据记录、事件触发、任务调度、日志记录等。

总之，RTC是实时时钟设备，提供准确的日期和时间信息，并能够持续跟踪时间的变化。它具有时钟计数器、时间补偿功能、闹钟功能和电池备份等特性，广泛应用于各种系统和设备中，以满足时间跟踪和时间标记的需求。

（二）RCT特征

RTC（Real-Time Clock）的特征包括以下几个方面：

  1. 准确性： RTC设计旨在提供高度准确的时间测量。它使用精密的时钟源和校准机制来确保时间的准确性，通常具有高频率计数和高分辨率的计时能力。

  2. 稳定性： RTC具有稳定的时钟信号源，能够抵抗外部环境因素对时钟频率和精度的影响。其内部电路和补偿机制可以抵消温度变化和电压波动等因素，保持时钟的稳定性。

  3. 电源备份： RTC通常包含电池备份电源，以便在主电源中断时保持时钟运行。这个特征使得RTC能够在断电或重新上电后继续提供准确的时间信息。

  4. 多功能性： RTC除了提供准确的时间跟踪外，还通常支持其他功能，如闹钟功能、定时触发、周期性事件等。这些功能使RTC在计时、调度和提醒等方面具有更广泛的应用。

  5. 低功耗： RTC的设计旨在尽可能降低功耗。它通常采用低功耗的电路和休眠模式，以延长电池寿命或节省能源。

  6. 与系统集成： RTC通常以芯片或模块的形式提供，可以方便地与系统集成。它们通常具有支持标准接口和通信协议的功能，便于与主控制器或其他设备进行通信和同步。

这些特征使得RTC成为在需要准确时间跟踪和时间标记的应用中的重要组成部分，例如计算机、嵌入式系统、通信设备、电子设备、工业自动化等领域。

（三）RTC原理框图

请添加图片描述

（四）RTC时钟选择

在选择RTC（Real-Time Clock）时钟时，以下几个方面是需要考虑的：

  1. 准确性与精度： 选择具有较高准确性和精度的RTC时钟。这对于需要精确时间跟踪和时间标记的应用非常重要。通常，RTC时钟的准确性由其内部的时钟源和校准机制决定。

  2. 稳定性： 选择具有稳定性较好的RTC时钟，可以抵抗环境因素对时钟频率和精度的影响。稳定性较好的RTC时钟具有较低的温度漂移和电压漂移，以确保长期稳定的时间测量。

  3. 功耗： 考虑RTC时钟的功耗特性。低功耗的RTC时钟可以延长电池寿命或节省系统能源，对于依赖电池供电的移动设备或电池备份系统尤其重要。

  4. 集成度与接口： 根据应用需求选择合适的RTC时钟。某些RTC时钟具有更多的集成度，集成了其他功能模块，如电池电量监测、温度传感器等。此外，选择与主控制器或系统接口兼容的RTC时钟，以方便与系统进行通信和同步。

  5. 电池备份： 如果应用需要断电时持续维持RTC时钟运行，并保留正确时间，选择具有电池备份电源的RTC时钟是必要的。

  6. 封装与尺寸： 根据应用的空间限制和安装要求，选择适合的RTC时钟封装和尺寸。

  7. 可靠性与可用性： 考虑RTC时钟的可靠性和供应情况。选择可靠的供应商和经过验证的产品，确保RTC时钟的长期可用性和技术支持。

综合考虑上述因素，并根据具体应用的需求，选择最合适的RTC时钟可以确保准确、稳定、可靠的时间跟踪和时间标记。

（五）RTC复位过程

RTC（Real-Time Clock）的复位过程是在特定情况下将RTC恢复到初始状态或预定的设置状态的过程。复位过程可以因RTC的具体实现和应用而有所不同，以下是一般的RTC复位过程的步骤：

  1. 检测复位条件： 首先，系统需要检测出触发RTC复位的条件。这可以是由硬件电路或软件逻辑定义的一个特定的信号或事件，例如系统上电或复位按钮被按下等。

  2. 中断RTC时钟信号： 在进行RTC复位之前，需要停止RTC时钟信号的计数。这可以通过产生一个中断信号或通过特定寄存器进行设置来实现。停止时钟信号的计数可以防止在复位过程中发生无效的时间计数。

  3. 清除计数器和寄存器： 进行RTC复位时，通常会将RTC内部的计数器和相关寄存器清零或设置为初始值。这可以通过写入特定的复位值或向特定的寄存器写入复位命令来完成。

  4. 恢复默认设置： 在RTC复位时，也可以将RTC的其他设置恢复到默认状态。这可能涉及到预定的寄存器设置、标志位的清零或复位等。这样可以确保RTC在复位后具有一致的初始配置。

  5. 复位标志位或状态： 在进行RTC复位后，可能需要复位特定的标志位或状态变量，以便后续的操作可以正确识别和处理RTC的状态。

  6. 启动RTC时钟： 在RTC复位完成后，可以重新启动RTC时钟信号的计数。这样，RTC可以开始记录和跟踪时间。

需要注意的是，RTC的复位过程可以根据具体的RTC芯片或系统设计有所不同。因此，在使用特定的RTC芯片或嵌入式系统时，请参考相应的文档和规范，了解RTC复位过程的具体细节和步骤。

（六）配置RTC寄存器

必须设置RTC_CRL寄存器中的CNF位，使RTC进入配置模式后，才能写入RTC_PRL、
RTC_CNT、RTC_ALR寄存器。

另外，对RTC任何寄存器的写操作，都必须在前一次写操作结束后进行。可以通过查询
RTC_CR寄存器中的RTOFF状态位，判断RTC寄存器是否处于更新中。仅当RTOFF状态位是’1’
时，才可以写入RTC寄存器。

（七）RTC时钟源

请添加图片描述

二、CubeMX建立项目

选择stm32型号 建立工程
请添加图片描述
sys设置
请添加图片描述
RCC设置
请添加图片描述
RTC设置
请添加图片描述

请添加图片描述

USART1

请添加图片描述
时钟设置
请添加图片描述
对文件设置
请添加图片描述
请添加图片描述

三、代码

main1.c

RTC_DateTypeDef GetData;  //获取日期结构体

RTC_TimeTypeDef GetTime;   //获取时间结构体


  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */
  

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_RTC_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
   /* Get the RTC current Time */
	    HAL_RTC_GetTime(&hrtc, &GetTime, RTC_FORMAT_BIN);
      /* Get the RTC current Date */
      HAL_RTC_GetDate(&hrtc, &GetData, RTC_FORMAT_BIN);

      /* Display date Format : yy/mm/dd */
      printf("%02d/%02d/%02d\r\n",2000 + GetData.Year, GetData.Month, GetData.Date);
      /* Display time Format : hh:mm:ss */
      printf("%02d:%02d:%02d\r\n",GetTime.Hours, GetTime.Minutes, GetTime.Seconds);

      printf("\r\n");

      HAL_Delay(1000);
      /* Display date Format : weekday */
		if(GetData.WeekDay==1){
			printf("星期一\r\n");
		}else if(GetData.WeekDay==2){
			printf("星期二\r\n");
		}else if(GetData.WeekDay==3){
			printf("星期三\r\n");
		}else if(GetData.WeekDay==4){
			printf("星期四\r\n");
		}else if(GetData.WeekDay==5){
			printf("星期五\r\n");
		}else if(GetData.WeekDay==6){
			printf("星期六\r\n");
		}else if(GetData.WeekDay==7){
			printf("星期日\r\n");
		}


 
  }
  /* USER CODE END 3 */
}

stm32f1xx_hal_rtc.c文件(部分）

static uint32_t           RTC_ReadTimeCounter(RTC_HandleTypeDef *hrtc);
static HAL_StatusTypeDef  RTC_WriteTimeCounter(RTC_HandleTypeDef *hrtc, uint32_t TimeCounter);
static uint32_t           RTC_ReadAlarmCounter(RTC_HandleTypeDef *hrtc);
static HAL_StatusTypeDef  RTC_WriteAlarmCounter(RTC_HandleTypeDef *hrtc, uint32_t AlarmCounter);
static HAL_StatusTypeDef  RTC_EnterInitMode(RTC_HandleTypeDef *hrtc);
static HAL_StatusTypeDef  RTC_ExitInitMode(RTC_HandleTypeDef *hrtc);
static uint8_t            RTC_ByteToBcd2(uint8_t Value);
static uint8_t            RTC_Bcd2ToByte(uint8_t Value);
static uint8_t            RTC_IsLeapYear(uint16_t nYear);
static void               RTC_DateUpdate(RTC_HandleTypeDef *hrtc, uint32_t DayElapsed);
static uint8_t            RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay);
HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc)
{
  uint32_t prescaler = 0U;
  /* Check input parameters */
  if (hrtc == NULL)
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
  assert_param(IS_RTC_CALIB_OUTPUT(hrtc->Init.OutPut));
  assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv));

#if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  if (hrtc->State == HAL_RTC_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    hrtc->Lock = HAL_UNLOCKED;

    hrtc->AlarmAEventCallback          =  HAL_RTC_AlarmAEventCallback;        /* Legacy weak AlarmAEventCallback      */
    hrtc->Tamper1EventCallback         =  HAL_RTCEx_Tamper1EventCallback;     /* Legacy weak Tamper1EventCallback     */

    if (hrtc->MspInitCallback == NULL)
    {
      hrtc->MspInitCallback = HAL_RTC_MspInit;
    }
    /* Init the low level hardware */
    hrtc->MspInitCallback(hrtc);

    if (hrtc->MspDeInitCallback == NULL)
    {
      hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
    }
  }
#else
  if (hrtc->State == HAL_RTC_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    hrtc->Lock = HAL_UNLOCKED;

    /* Initialize RTC MSP */
    HAL_RTC_MspInit(hrtc);
  }
#endif /* (USE_HAL_RTC_REGISTER_CALLBACKS) */

  /* Set RTC state */
  hrtc->State = HAL_RTC_STATE_BUSY;

  /* Waiting for synchro */
  if (HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
  {
    /* Set RTC state */
    hrtc->State = HAL_RTC_STATE_ERROR;

    return HAL_ERROR;
  }

  /* Set Initialization mode */
  if (RTC_EnterInitMode(hrtc) != HAL_OK)
  {
    /* Set RTC state */
    hrtc->State = HAL_RTC_STATE_ERROR;

    return HAL_ERROR;
  }
  else
  {
    /* Clear Flags Bits */
    CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_OW | RTC_FLAG_ALRAF | RTC_FLAG_SEC));

    if (hrtc->Init.OutPut != RTC_OUTPUTSOURCE_NONE)
    {
      /* Disable the selected Tamper pin */
      CLEAR_BIT(BKP->CR, BKP_CR_TPE);
    }

    /* Set the signal which will be routed to RTC Tamper pin*/
    MODIFY_REG(BKP->RTCCR, (BKP_RTCCR_CCO | BKP_RTCCR_ASOE | BKP_RTCCR_ASOS), hrtc->Init.OutPut);

    if (hrtc->Init.AsynchPrediv != RTC_AUTO_1_SECOND)
    {
      /* RTC Prescaler provided directly by end-user*/
      prescaler = hrtc->Init.AsynchPrediv;
    }
    else
    {
      /* RTC Prescaler will be automatically calculated to get 1 second timebase */
      /* Get the RTCCLK frequency */
      prescaler = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_RTC);

      /* Check that RTC clock is enabled*/
      if (prescaler == 0U)
      {
        /* Should not happen. Frequency is not available*/
        hrtc->State = HAL_RTC_STATE_ERROR;
        return HAL_ERROR;
      }
      else
      {
        /* RTC period = RTCCLK/(RTC_PR + 1) */
        prescaler = prescaler - 1U;
      }
    }

    /* Configure the RTC_PRLH / RTC_PRLL */
    MODIFY_REG(hrtc->Instance->PRLH, RTC_PRLH_PRL, (prescaler >> 16U));
    MODIFY_REG(hrtc->Instance->PRLL, RTC_PRLL_PRL, (prescaler & RTC_PRLL_PRL));

    /* Wait for synchro */
    if (RTC_ExitInitMode(hrtc) != HAL_OK)
    {
      hrtc->State = HAL_RTC_STATE_ERROR;

      return HAL_ERROR;
    }

    /* Initialize date to 1st of January 2000 */
    hrtc->DateToUpdate.Year = 0x00U;
    hrtc->DateToUpdate.Month = RTC_MONTH_JANUARY;
    hrtc->DateToUpdate.Date = 0x01U;

    /* Set RTC state */
    hrtc->State = HAL_RTC_STATE_READY;

    return HAL_OK;
  }
}

/**
  * @brief  DeInitializes the RTC peripheral
  * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  *                the configuration information for RTC.
  * @note   This function does not reset the RTC Backup Data registers.
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
{
  /* Check input parameters */
  if (hrtc == NULL)
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));

  /* Set RTC state */
  hrtc->State = HAL_RTC_STATE_BUSY;

  /* Set Initialization mode */
  if (RTC_EnterInitMode(hrtc) != HAL_OK)
  {
    /* Set RTC state */
    hrtc->State = HAL_RTC_STATE_ERROR;

    /* Release Lock */
    __HAL_UNLOCK(hrtc);

    return HAL_ERROR;
  }
  else
  {
    CLEAR_REG(hrtc->Instance->CNTL);
    CLEAR_REG(hrtc->Instance->CNTH);
    WRITE_REG(hrtc->Instance->PRLL, 0x00008000U);
    CLEAR_REG(hrtc->Instance->PRLH);

    /* Reset All CRH/CRL bits */
    CLEAR_REG(hrtc->Instance->CRH);
    CLEAR_REG(hrtc->Instance->CRL);

    if (RTC_ExitInitMode(hrtc) != HAL_OK)
    {
      hrtc->State = HAL_RTC_STATE_ERROR;

      /* Process Unlocked */
      __HAL_UNLOCK(hrtc);

      return HAL_ERROR;
    }
  }

  /* Wait for synchro*/
  HAL_RTC_WaitForSynchro(hrtc);

  /* Clear RSF flag */
  CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);

#if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  if (hrtc->MspDeInitCallback == NULL)
  {
    hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
  }

  /* DeInit the low level hardware: CLOCK, NVIC.*/
  hrtc->MspDeInitCallback(hrtc);

#else
  /* De-Initialize RTC MSP */
  HAL_RTC_MspDeInit(hrtc);
#endif /* (USE_HAL_RTC_REGISTER_CALLBACKS) */

  hrtc->State = HAL_RTC_STATE_RESET;

  /* Release Lock */
  __HAL_UNLOCK(hrtc);

  return HAL_OK;
}

HAL_StatusTypeDef HAL_RTC_RegisterCallback(RTC_HandleTypeDef *hrtc, HAL_RTC_CallbackIDTypeDef CallbackID, pRTC_CallbackTypeDef pCallback)
{
  HAL_StatusTypeDef status = HAL_OK;

  if (pCallback == NULL)
  {
    return HAL_ERROR;
  }

  /* Process locked */
  __HAL_LOCK(hrtc);

  if (HAL_RTC_STATE_READY == hrtc->State)
  {
    switch (CallbackID)
    {
      case HAL_RTC_ALARM_A_EVENT_CB_ID :
        hrtc->AlarmAEventCallback = pCallback;
        break;

      case HAL_RTC_TAMPER1_EVENT_CB_ID :
        hrtc->Tamper1EventCallback = pCallback;
        break;

      case HAL_RTC_MSPINIT_CB_ID :
        hrtc->MspInitCallback = pCallback;
        break;

      case HAL_RTC_MSPDEINIT_CB_ID :
        hrtc->MspDeInitCallback = pCallback;
        break;

      default :
        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else if (HAL_RTC_STATE_RESET == hrtc->State)
  {
    switch (CallbackID)
    {
      case HAL_RTC_MSPINIT_CB_ID :
        hrtc->MspInitCallback = pCallback;
        break;

      case HAL_RTC_MSPDEINIT_CB_ID :
        hrtc->MspDeInitCallback = pCallback;
        break;

      default :
        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else
  {
    /* Return error status */
    status =  HAL_ERROR;
  }

  /* Release Lock */
  __HAL_UNLOCK(hrtc);

  return status;HAL_StatusTypeDef HAL_RTC_UnRegisterCallback(RTC_HandleTypeDef *hrtc, HAL_RTC_CallbackIDTypeDef CallbackID)
{
  HAL_StatusTypeDef status = HAL_OK;

  /* Process locked */
  __HAL_LOCK(hrtc);

  if (HAL_RTC_STATE_READY == hrtc->State)
  {
    switch (CallbackID)
    {
      case HAL_RTC_ALARM_A_EVENT_CB_ID :
        hrtc->AlarmAEventCallback = HAL_RTC_AlarmAEventCallback;         /* Legacy weak AlarmAEventCallback    */
        break;

      case HAL_RTC_TAMPER1_EVENT_CB_ID :
        hrtc->Tamper1EventCallback = HAL_RTCEx_Tamper1EventCallback;         /* Legacy weak Tamper1EventCallback   */
        break;

      case HAL_RTC_MSPINIT_CB_ID :
        hrtc->MspInitCallback = HAL_RTC_MspInit;
        break;

      case HAL_RTC_MSPDEINIT_CB_ID :
        hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
        break;

      default :
        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else if (HAL_RTC_STATE_RESET == hrtc->State)
  {
    switch (CallbackID)
    {
      case HAL_RTC_MSPINIT_CB_ID :
        hrtc->MspInitCallback = HAL_RTC_MspInit;
        break;

      case HAL_RTC_MSPDEINIT_CB_ID :
        hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
        break;

      default :
        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else
  {
    /* Return error status */
    status =  HAL_ERROR;
  }

  /* Release Lock */
  __HAL_UNLOCK(hrtc);

  return status;
}
  
}

HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
{
  uint32_t counter_time = 0U, counter_alarm = 0U;

  /* Check input parameters */
  if ((hrtc == NULL) || (sTime == NULL))
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_RTC_FORMAT(Format));

  /* Process Locked */
  __HAL_LOCK(hrtc);

  hrtc->State = HAL_RTC_STATE_BUSY;

  if (Format == RTC_FORMAT_BIN)
  {
    assert_param(IS_RTC_HOUR24(sTime->Hours));
    assert_param(IS_RTC_MINUTES(sTime->Minutes));
    assert_param(IS_RTC_SECONDS(sTime->Seconds));

    counter_time = (uint32_t)(((uint32_t)sTime->Hours * 3600U) + \
                              ((uint32_t)sTime->Minutes * 60U) + \
                              ((uint32_t)sTime->Seconds));
  }
  else
  {
    assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours)));
    assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes)));
    assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds)));

    counter_time = (((uint32_t)(RTC_Bcd2ToByte(sTime->Hours)) * 3600U) + \
                    ((uint32_t)(RTC_Bcd2ToByte(sTime->Minutes)) * 60U) + \
                    ((uint32_t)(RTC_Bcd2ToByte(sTime->Seconds))));
  }

  /* Write time counter in RTC registers */
  if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
  {
    /* Set RTC state */
    hrtc->State = HAL_RTC_STATE_ERROR;

    /* Process Unlocked */
    __HAL_UNLOCK(hrtc);

    return HAL_ERROR;
  }
  else
  {
    /* Clear Second and overflow flags */
    CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_SEC | RTC_FLAG_OW));

    /* Read current Alarm counter in RTC registers */
    counter_alarm = RTC_ReadAlarmCounter(hrtc);

    /* Set again alarm to match with new time if enabled */
    if (counter_alarm != RTC_ALARM_RESETVALUE)
    {
      if (counter_alarm < counter_time)
      {
        /* Add 1 day to alarm counter*/
        counter_alarm += (uint32_t)(24U * 3600U);

        /* Write new Alarm counter in RTC registers */
        if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
        {
          /* Set RTC state */
          hrtc->State = HAL_RTC_STATE_ERROR;

          /* Process Unlocked */
          __HAL_UNLOCK(hrtc);

          return HAL_ERROR;
        }
      }
    }

    hrtc->State = HAL_RTC_STATE_READY;

    __HAL_UNLOCK(hrtc);

    return HAL_OK;
  }
}

/**
  * @brief  Gets RTC current time.
  * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  *                the configuration information for RTC.
  * @param  sTime: Pointer to Time structure
  * @param  Format: Specifies the format of the entered parameters.
  *          This parameter can be one of the following values:
  *            @arg RTC_FORMAT_BIN: Binary data format
  *            @arg RTC_FORMAT_BCD: BCD data format
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
{
  uint32_t counter_time = 0U, counter_alarm = 0U, days_elapsed = 0U, hours = 0U;

  /* Check input parameters */
  if ((hrtc == NULL) || (sTime == NULL))
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_RTC_FORMAT(Format));

  /* Check if counter overflow occurred */
  if (__HAL_RTC_OVERFLOW_GET_FLAG(hrtc, RTC_FLAG_OW))
  {
    return HAL_ERROR;
  }

  /* Read the time counter*/
  counter_time = RTC_ReadTimeCounter(hrtc);

  /* Fill the structure fields with the read parameters */
  hours = counter_time / 3600U;
  sTime->Minutes  = (uint8_t)((counter_time % 3600U) / 60U);
  sTime->Seconds  = (uint8_t)((counter_time % 3600U) % 60U);

  if (hours >= 24U)
  {
    /* Get number of days elapsed from last calculation */
    days_elapsed = (hours / 24U);

    /* Set Hours in RTC_TimeTypeDef structure*/
    sTime->Hours = (hours % 24U);

    /* Read Alarm counter in RTC registers */
    counter_alarm = RTC_ReadAlarmCounter(hrtc);

    /* Calculate remaining time to reach alarm (only if set and not yet expired)*/
    if ((counter_alarm != RTC_ALARM_RESETVALUE) && (counter_alarm > counter_time))
    {
      counter_alarm -= counter_time;
    }
    else
    {
      /* In case of counter_alarm < counter_time */
      /* Alarm expiration already occurred but alarm not deactivated */
      counter_alarm = RTC_ALARM_RESETVALUE;
    }

    /* Set updated time in decreasing counter by number of days elapsed */
    counter_time -= (days_elapsed * 24U * 3600U);

    /* Write time counter in RTC registers */
    if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
    {
      return HAL_ERROR;
    }

    /* Set updated alarm to be set */
    if (counter_alarm != RTC_ALARM_RESETVALUE)
    {
      counter_alarm += counter_time;

      /* Write time counter in RTC registers */
      if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
      {
        return HAL_ERROR;
      }
    }
    else
    {
      /* Alarm already occurred. Set it to reset values to avoid unexpected expiration */
      if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
      {
        return HAL_ERROR;
      }
    }

    /* Update date */
    RTC_DateUpdate(hrtc, days_elapsed);
  }
  else
  {
    sTime->Hours = hours;
  }

  /* Check the input parameters format */
  if (Format != RTC_FORMAT_BIN)
  {
    /* Convert the time structure parameters to BCD format */
    sTime->Hours    = (uint8_t)RTC_ByteToBcd2(sTime->Hours);
    sTime->Minutes  = (uint8_t)RTC_ByteToBcd2(sTime->Minutes);
    sTime->Seconds  = (uint8_t)RTC_ByteToBcd2(sTime->Seconds);
  }

  return HAL_OK;
}


/**
  * @brief  Sets RTC current date.
  * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  *                the configuration information for RTC.
  * @param  sDate: Pointer to date structure
  * @param  Format: specifies the format of the entered parameters.
  *          This parameter can be one of the following values:
  *            @arg RTC_FORMAT_BIN: Binary data format
  *            @arg RTC_FORMAT_BCD: BCD data format
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
{
  uint32_t counter_time = 0U, counter_alarm = 0U, hours = 0U;

  /* Check input parameters */
  if ((hrtc == NULL) || (sDate == NULL))
  {
    return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_RTC_FORMAT(Format));

  /* Process Locked */
  __HAL_LOCK(hrtc);

  hrtc->State = HAL_RTC_STATE_BUSY;

  if (Format == RTC_FORMAT_BIN)
  {
    assert_param(IS_RTC_YEAR(sDate->Year));
    assert_param(IS_RTC_MONTH(sDate->Month));
    assert_param(IS_RTC_DATE(sDate->Date));

    /* Change the current date */
    hrtc->DateToUpdate.Year  = sDate->Year;
    hrtc->DateToUpdate.Month = sDate->Month;
    hrtc->DateToUpdate.Date  = sDate->Date;
  }
  else
  {
    assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
    assert_param(IS_RTC_MONTH(RTC_Bcd2ToByte(sDate->Month)));
    assert_param(IS_RTC_DATE(RTC_Bcd2ToByte(sDate->Date)));

    /* Change the current date */
    hrtc->DateToUpdate.Year  = RTC_Bcd2ToByte(sDate->Year);
    hrtc->DateToUpdate.Month = RTC_Bcd2ToByte(sDate->Month);
    hrtc->DateToUpdate.Date  = RTC_Bcd2ToByte(sDate->Date);
  }

  /* WeekDay set by user can be ignored because automatically calculated */
  hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(hrtc->DateToUpdate.Year, hrtc->DateToUpdate.Month, hrtc->DateToUpdate.Date);
  sDate->WeekDay = hrtc->DateToUpdate.WeekDay;

  /* Reset time to be aligned on the same day */
  /* Read the time counter*/
  counter_time = RTC_ReadTimeCounter(hrtc);

  /* Fill the structure fields with the read parameters */
  hours = counter_time / 3600U;
  if (hours > 24U)
  {
    /* Set updated time in decreasing counter by number of days elapsed */
    counter_time -= ((hours / 24U) * 24U * 3600U);
    /* Write time counter in RTC registers */
    if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
    {
      /* Set RTC state */
      hrtc->State = HAL_RTC_STATE_ERROR;

      /* Process Unlocked */
      __HAL_UNLOCK(hrtc);

      return HAL_ERROR;
    }

    /* Read current Alarm counter in RTC registers */
    counter_alarm = RTC_ReadAlarmCounter(hrtc);

    /* Set again alarm to match with new time if enabled */
    if (counter_alarm != RTC_ALARM_RESETVALUE)
    {
      if (counter_alarm < counter_time)
      {
        /* Add 1 day to alarm counter*/
        counter_alarm += (uint32_t)(24U * 3600U);

        /* Write new Alarm counter in RTC registers */
        if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
        {
          /* Set RTC state */
          hrtc->State = HAL_RTC_STATE_ERROR;

          /* Process Unlocked */
          __HAL_UNLOCK(hrtc);

          return HAL_ERROR;
        }
      }
    }


  }

  hrtc->State = HAL_RTC_STATE_READY ;

  /* Process Unlocked */
  __HAL_UNLOCK(hrtc);

  return HAL_OK;
}

四、烧录结果

请添加图片描述

五、总结

此次实验我了解了RTC的配置和基本工作原理，32位计数器，每1秒加1来显示当下的时间日期没有年月日及时间寄存器，需要软件配合，才能实现日历、时钟功能

remaker7
关注
实时时钟（STM32学习之RTC）
Dkkkkk20的博客
08-22 816
STM32学习之RTC
RTC实时时钟
m0_59802543的博客
10-02 730
RTC实时时钟。
嵌入式(3)——RTC实时时钟
最新发布
s386199的博客
09-22 632
RTC实时时钟是一种独立定时器，可为系统提供时钟和日历功能。其核心特性包括：32位可编程计数器、断电后通过备用电源VBAT保持计时、可编程预分频系数及三种时钟源选择。RTC模块位于后备区域，系统复位时数据不会丢失。在软件实现上，需注意控制寄存器访问权限，并通过特定操作使能后备区域访问。代码示例展示了如何设置RTC时间、日期以及通过串口传输实时数据，同时提到需要软件校准日期的问题，最后通过备份寄存器验证实现数据持久化。
什么是RCT实时时钟？(STM32中RTC时钟源)
ZAD000000的博客
11-16 5986
RTC（Real Time Clock，实时时钟）是指安装在电子设备或实现其功能的IC（集成电路）上的时钟，一般会是集成电路，因此也称为时钟芯片。他的实质是一个掉电后还继续运行的定时器。
RTC时钟
m0_52864526的博客
09-15 1447
STM32的RTC外设，实质是一个掉电后还能继续运行的定时器，通过配置，可以让它准确地每秒钟中断一次。当主电源VDD有效时，由VDD给RTC外设供电。当VDD掉电后，由VBAT给RTC外设供电。
第8周-定时器与日历时钟
syw0113的博客
11-07 352
第八周作业
STM32CubeMX定时器与日历时钟
m0_73576827的博客
11-07 387
STM32CubeMX定时器与日历时钟
stm32-OLED屏+RTC实现简易实时时钟（下篇）
2301_76891917的博客
08-29 2732
实时时钟是一个独立的定时器。RTC模块拥有一组连续计数的计数器，在相应软件配置下，可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。RTC模块和时钟配置系统(RCC_BDCR寄存器)处于后备区域，即在系统复位或从待机模式唤醒后，RTC的设置和时间维持不变。但是在系统复位后，会自动禁止访问后备寄存器和 RTC，以防止对后备区域(BKP)的意外写操作。所以在要设置时间之前， 先要取消备份区域（BKP）写保护。
#stm32RTC时钟
Pretender_1205的博客
07-26 855
【代码】#stm32RTC时钟。
RTC实时时钟(LCD显示)
Kk_01110001B的博客
12-09 8707
  目录 RTC简介 RTC时钟框图 RTC工作原理图 RTC相关寄存器（详细配置过程参考STM32参考手册） 部分代码分析 附录    RTC简介 实时时钟(RTC)是一个独立的定时器。RTC模块拥有一组连续计数的计数器，在相应软件配置下，可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。 RTC模块和时钟配置系统(RCC_BDCR寄存器)处...
RTC--时钟芯片
2301_79109608的博客
12-06 3238
原因是CPU的定时器时钟功能只在“通电时”运行，断电时停止。当然，如果时钟不能连续跟踪时间，则必须手动设置时间。如今，通过接收标准电波（传输各国标准时间的电波）来自动调整时间的手表越来越多，但它是一种不应该在室内携带的电子设备。RTC有一个与CPU单独分离的电源，如纽扣电池（备用电池），即使主机电源关闭，它也保持滴答作响，随时可以实时显示时间。然后，当计算机再次打开时，计算机内置的定时器时钟从RTC读取当前时间，并在此基础上供电的同时，时间在其自身机制下显示。
STM32F103学习笔记（六） RTC实时时钟（应用篇）
全社区最菜的博客
02-21 6428
本节我们将利用RTC实现一个时钟显示的功能，通过读取时间戳来获取当前时间（主供电断开依然可以由备用电池供电，故主供电断开依然可以记时），本程序可以通过动态传参的方法来配置当前的初始时间。
RTC时钟原理
2302_82091511的博客
06-21 1025
系统时间按TR_CLK周期累加并与存储在RTC_ALR寄存器中的可编程时间相比，当匹配时候如果设置了闹钟中断允许位，可以产生闹钟中断。2个分离的时钟:用于APB1接口的PCLK1和RTC时钟(RTC时钟的频率必须小于PCLK1时钟频率的四分之一以上)。设置寄存器PWR_CR的DBP位，使能对RTC和后备寄存器的访问。RTC预分频装载寄存器 (RTC_PRLH， RTC_PRLL)RTC预分频余数寄存器 (RTC_DIVH， RTC_DIVL)RTC闹钟寄存器 (RTC_ALRH ，RTC_ALRL)
stm32专题三十二：RTC实时时钟
weixin_42519181的博客
12-18 1625
在高或低寄存器(RTC_CNTH或RTC_CNTL)上的写操作，能够直接装载到相应的可编程计数器，并且重新装载RTC预分频器。RTC_PRL写入一个计数器目标值，计几个数溢出一次，就是几分频，因为从0开始计数，所以分频系数等于RTC_PRL+1。在c语言中，gmtime函数返回的时间日期未经时区转换，而是UTC时间（格林尼治时间），localtime（取得当地目前UTC时间和日期） ，此函数返回的时间日期已经转换成当地时区。但是在STM32中，不知道位于哪个时区，所以返回的都是格林尼治时间（0时区）。
STM32——RTC实时时钟
2403_89181725的博客
04-09 1365
备份寄存器是42个16位的寄存器，可用来存储84个字节的用户应用程序数据。他们处在备份域里，当VDD电源被切断，他们仍然由VBAT维持供电。当系统在待机模式下被唤醒，或系统复位或电源复位时，他们也不会被复位。此外，BKP控制寄存器用来管理侵入检测和RTC校准功能。复位后，对备份寄存器和RTC的访问被禁止，并且备份域被保护以防止可能存在的意外的写操作。执行以下操作可以使能对备份寄存器和RTC的访问。
RTC实时时钟知识
2302_82091511的博客
06-21 1957
另外,对RTC任何寄存器的写操作,都必须在前一次写操作结束后进行。可以通过查询RTC_CR寄存器中的RTOFF状态位,判断RTC寄存器是否处于更新中。仅当RTOFF状态位是’1’时,才可以写入RTC寄存器。必须设置RTC_CRL寄存器中的CNF位,使RTC进入配置模式后,才能写入RTC_PRL、RTC_CNT、RTC_ALR寄存器。仅当CNF标志位被清除时,写操作才能进行,这个过程至少需要3个RTCCLK周期。
8253定时器实现屏幕日历时钟的设计与应用
资源摘要信息:"用8253定时器实现屏幕上的日历时钟" 知识点一：8253定时器 8253定时器是Intel公司生产的一款可编程间隔定时器（Programmable Interval Timer，简称PIT），广泛应用于计算机系统中，用于产生精确的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值