The time is: 33:55!

Yes, it started to occur since I disabled RTC_Init(). But now I have problem - when the RTC_Init() sets the control register (CR), I lose up to one second on each restart.

It's weird, since RTC_Init() doesn't touch the DR register.

Anyway, what I still need now is RTC that keeps time without ANY extra changes like resetting neither the seconds nor hours. Is it possible and how to enable this advanced feature? ;)

Which part of the RTC_Init() resets the fractions of seconds? I looked at the code and I can't figure it out. I see where the time format is set, along with some other bits. It seems like I could just leave the code as it is, but then the fractions of seconds keep being reset.

I read it again several times, but I'm not sure if I understood this right this time:

According to the linked article, entering the INIT mode of RTC, that MX_RTC_Init() does just resets the fraction of the seconds indirectly, by resetting the clock divider, right?

The partial solution is just not call MX_RTC_Init() when the time was already set. Right?

However, when I power cycle the device, I get random 23h error. Random means sometimes I power cycle the device and it's OK, sometimes it's not OK. It's always 23h either added or subtracted from the correct time, or zero, sometimes nothing happens with the time.

As you've said: it has nothing to do RTC_Init(), so - a set time function.

The problem with this is HAL_RTC_SetTime() is not called at all on power cycle or reset.

I only call HAL_RTC_GetTime(). I'd suspect it requires the initialized RTC_InitTypeDef struct to work properly. Am I heading in the right direction with this? Or... I reset the time manually from the device's GUI after disabling the init function, so it stored the time in wrong format. It could happen.

If so, the full working solution would be to properly initialize the structure without touching the Instance property of htrc, right?

But the HAL_RTC_Init() doesn't do anything else. It takes init struct already initialized.

It just writes RTC registers, that leads to that fraction of seconds loss.

Here's the relevant main() fragment:

 /** Initialize RTC Only
 */
 hrtc.Instance = RTC;
 hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
 hrtc.Init.AsynchPrediv = 127;
 hrtc.Init.SynchPrediv = 255;
 hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
 hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
 hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
 hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
 if (HAL_RTC_Init(&hrtc) != HAL_OK)
 {
 Error_Handler();
 }

It is executed on every start, so there's no chance the Init structure is uninitialized. All my code that uses the RTC uses HAL functions that refer to the initialized hrtc structure.

The hrtc.Init.HourFormat is always set to RTC_HOURFORMAT_24.

Thanks, I'll make my own RTC_SetTime() (-like) function, setting all registers manually. I assumed HAL function does that, but well, if it did, it would probably work properly then.

Here's my hacked MX_RTC_Init():

static void MX_RTC_Init(void)
{
 /* USER CODE BEGIN RTC_Init 0 */
 
 // THE WORKAROUND FOR A 1 SECOND LOSS ON RESTART STARTS HERE:
 
 // The Init structure initialization code is copied from the generated part, it can't be moved since the Cube can't be made to do so.
 hrtc.Instance = RTC;
 hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
 hrtc.Init.AsynchPrediv = 127;
 hrtc.Init.SynchPrediv = 255;
 hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
 hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
 hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
 hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
 // The copied code ends here. The proper initialization ahead:
 if (hrtc.Instance->DR)
 { // The clock has been set, we skip broken initialization here to avoid resetting fraction of seconds bits.
 if (hrtc.State == HAL_RTC_STATE_RESET) hrtc.Lock = HAL_UNLOCKED;
 hrtc.State = HAL_RTC_STATE_BUSY;
 __HAL_RTC_WRITEPROTECTION_DISABLE(&hrtc);
 hrtc.Instance->CR &= ~(RTC_CR_FMT | RTC_CR_OSEL | RTC_CR_POL); // Clear RTC_CR FMT, OSEL and POL Bits.
 hrtc.Instance->CR |= (hrtc.Init.HourFormat | hrtc.Init.OutPut | hrtc.Init.OutPutPolarity); // Set RTC_CR register.
 HAL_RTC_WaitForSynchro(&hrtc);
 hrtc.State = HAL_RTC_STATE_READY;
 __HAL_RTC_WRITEPROTECTION_ENABLE(&hrtc);
 }
 else
 { // Original initialization otherwise.
 if (HAL_RTC_Init(&hrtc) != HAL_OK)
 {
 Error_Handler();
 }
 }
 return;
 
 // THE WORKAROUND FOR A 1 SECOND LOSS ON RESTART ENDS HERE.
 
 /* USER CODE END RTC_Init 0 */
 
 /* USER CODE BEGIN RTC_Init 1 */
 
 /* USER CODE END RTC_Init 1 */
 
 /** Initialize RTC Only
 */
 hrtc.Instance = RTC;
 hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
 hrtc.Init.AsynchPrediv = 127;
 hrtc.Init.SynchPrediv = 255;
 hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
 hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
 hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
 hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
 if (HAL_RTC_Init(&hrtc) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN RTC_Init 2 */
 
 /* USER CODE END RTC_Init 2 */
 
}

It solves the problem entirely. I pinpointed the exact place when the clock broke completely, and after 23:59:59 I got 24:00:00 and still the same date.

The clock behaved that way when I skipped the call to HAL_RTC_WaitForSynchro(). That was it.

However, entering the init mode in line 313 of the file you linked caused the exact problem with losing seconds on restart. When I removed that call but left the HAL_RTC_WaitForSynchro() - the clock works properly after 23:59:59 and doesn't lose seconds anymore. PROBLEM SOLVED.

/**
 * @typedef DateTypeDef
 * @struct
 * @brief A simple unpacked universal date structure.
 */
typedef struct
{
 int16_t y; ///< Year number.
 uint8_t m; ///< Month number. 1..12.
 uint8_t d; ///< Day number. 1..31.
} DateTypeDef;
 
/**
 * @typedef TimeTypeDef
 * @struct
 * @brief A precise unpacked local time structure.
 */
typedef struct
{
 uint8_t h; ///< Hour number. 0..23.
 uint8_t m; ///< Minute number. 0..59.
 uint8_t s; ///< Second number. 0..59.
 uint16_t ms; ///< Milliseconds since full second. 0..999.
 uint16_t us; ///< Microseconds since full millisecond. 0..999.
 uint16_t ns; ///< Nanoseconds since full microsecond. 0..999.
} TimeTypeDef;
 
/**
 * @typedef DateTimeTypeDef
 * @struct
 * @brief A simple 10 byte date/time structure containing full date and local time with 1ns precision.
 */
typedef struct
{
 DateTypeDef date;
 TimeTypeDef time;
} DateTimeTypeDef;
 
/**
 * @fn void DateTime2RTC(DateTimeTypeDef*, RTC_DateTypeDef*, RTC_TimeTypeDef)
 * @brief Converts the ISO date/time to RTC date and RTC time.
 * @param dateTime ISO date/time pointer.
 * @param rtcDate RTC date pointer.
 * @param rtcTime RTC time pointer.
 */
void DateTime2RTC(DateTimeTypeDef* dt, RTC_DateTypeDef* rd, RTC_TimeTypeDef* rt)
{
 rd->Year = dt->date.y - 2000;
 rd->Month = dt->date.m;
 rd->Date = dt->date.d;
 rd->WeekDay = dayOfWeek(dt->date.y, dt->date.m, dt->date.d);
 rt->TimeFormat = 0x00u; // the RTC hour format must be set to 24H!
 rt->Hours = dt->time.h;
 rt->Minutes = dt->time.m;
 rt->Seconds = dt->time.s;
 if (rt->SecondFraction != 0)
 {
 if (dt->time.ms != 0)
 rt->SubSeconds = dt->time.ms / (1000.0 / rt->SecondFraction);
 if (dt->time.us != 0)
 rt->SubSeconds += dt->time.us / (1000000.0 / rt->SecondFraction);
 if (dt->time.ns != 0)
 rt->SubSeconds += dt->time.ns / (1000000000.0 / rt->SecondFraction);
 }
}
 
/**
 * @fn HAL_StatusTypeDef RTC_SetDateTime(DateTimeTypeDef*)
 * @brief Sets the current RTC date and time from ISO time.
 * @param dateTime ISO date/time pointer.
 */
HAL_StatusTypeDef RTC_SetDateTime(DateTimeTypeDef* dt)
{
 if (!isValidDateTime(dt)) return HAL_ERROR;
 RTC_DateTypeDef rd;
 RTC_TimeTypeDef rt;
 HAL_StatusTypeDef status;
 HAL_RTC_Init(&hrtc); // Just in case.
 status = HAL_RTC_GetTime(&hrtc, &rt, RTC_FORMAT_BIN);
 if (status != HAL_OK) return status;
 status = HAL_RTC_GetDate(&hrtc, &rd, RTC_FORMAT_BIN);
 if (status != HAL_OK) return status;
 DateTime2RTC(dt, &rd, &rt);
 status = HAL_RTC_SetDate(&hrtc, &rd, RTC_FORMAT_BIN);
 if (status != HAL_OK) return status;
 HAL_RTC_SetTime(&hrtc, &rt, RTC_FORMAT_BIN);
 return status;
}

Here. Without UI, naturally.

I revisited the problem. I set all uninitialized fields, however, it didn't solve the problem.

Here's what did work:

HAL_StatusTypeDef RTC_SetDateTime(DateTimeTypeDef* dt)
{
 if (!isValidDateTime(dt)) return HAL_ERROR;
 RTC_DateTypeDef rd;
 RTC_TimeTypeDef rt;
 HAL_StatusTypeDef status;
 DateTime2RTC(dt, &rd, &rt);
 status = HAL_RTC_SetDate(&hrtc, &rd, RTC_FORMAT_BIN);
 if (status != HAL_OK) return status;
 rt.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
 rt.StoreOperation = RTC_STOREOPERATION_SET;
 status = HAL_RTC_Init(&hrtc);
 if (status != HAL_OK) return status;
 status = HAL_RTC_SetTime(&hrtc, &rt, RTC_FORMAT_BIN);
 return status;
}

So - calling full HAL_RTC_Init(). As you remember - I don't call full HAL_RTC_Init() on start, to avoid shaving fractions of seconds. But calling it just before resetting the time is a good idea, because I reset seconds anyway. I tested it several times for cases of time 23:59:59:

• just waiting a minute observing time,
• resetting the device,
• powering the device off

The valid outcome is time after 00:00:00, invalid is greater than 24:00:00.

Everything passed.