Nucleo-STM32H563 RTC SSR 寄存器值中途回跳

啪发表于 2024-3-1 11:08:18

Nucleo-STM32H563 RTC SSR 寄存器值中途回跳

我在使用 Nucleo-STM32H563ZI 开发板的时候发现，RTC 的 SSR（子秒）寄存器值的变化有时候会出现回跳的现象。如下例，值在从 29 变到 28 后，没有紧跟着变为 27，而是先回跳到 31 后，再跳到 27。
00030-->00029
00029-->00028
00028-->00031
00031-->00027
00027-->00026
00026-->00025
初步观察到这种现象出现的频率很高，一秒钟内有3、4次。每次回跳值都是3（如上例：31-28=3）。
请问下是我的配置或程序有问题吗？

butterflyspring 发表于 2024-3-1 14:32:56

从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如果调试窗口看会有一定不同步现象。

如果代码去读，注意读取是有一定方式的。并且串口输出的时间也要考虑进去。

啪发表于 2024-3-1 15:11:14

butterflyspring 发表于 2024-3-1 14:32
从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如 ...

RTC的分频采用默认值，即 SSR 分频值是 255，即一秒钟会发生256次变化，一次变化大概3.9ms。

串口波特率是115200，按照程序中一次发送的内容有14个字节，发送所需时间大概1.2ms。

而程序只做了检查寄存器值一件事情，没有其他事情。这个过程中也只有 SysTick 产生的中断需要处理

MCU主频被设置成最高的250MHz。

可以确信，这个程序运行时不会漏掉任何一个变化。串口的输出内容也验证了这一点。

啪发表于 2024-3-1 15:18:42

butterflyspring 发表于 2024-3-1 14:32
从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如 ...

RTC 的 SSR 分频配置使用的是默认值 255，即是说一秒钟会发生 256 次变化，相邻变化时间间隔大概 3.9ms。

而串口波特率设置是 115200，程序中一次发送内容是 14 字节，大概需要 1.2ms。

而整个程序只做检查 SSR 值这一件事情，没有其他线程。需要处理的中断也只有 SysTick。

可以确信，程序不会错过任何一次 SSR 值变化。而串口输出也验证了这一点。

至于您说的读取要有一定的方式，这也是我想问的：读取这个寄存器是否需要什么秘诀？

我的程序是参考了 HAL 库里的 HAL_RTC_GetTime 函数实现。但没发现里面有什么窍门……

啪发表于 2024-3-1 18:14:32

butterflyspring 发表于 2024-3-1 14:32
从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如 ...

我是使用串口打印的方式查看，不是调试窗口。

SSR分频使用默认值255，即一秒钟有256次变化，相邻变化时间间隔约3.9ms

串口波特率115200，程序一次发送数据14字节，需要时间大约1.2ms

可以确信，程序不会错过任何一次正常的变化。串口输出也验证了这一点

啪发表于 2024-3-1 18:16:10

butterflyspring 发表于 2024-3-1 14:32
从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如 ...

SSR 分频使用默认值 255，即一秒钟有256次变化，变化时间间隔约3.9ms

串口波特率115200，一次发送数据14字节，需时1.2ms

程序不会错过任何一次正常的变化。串口输出也验证了这一点

啪发表于 2024-3-1 18:18:41

butterflyspring 发表于 2024-3-1 14:32
从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如 ...

SSR 分频为255，即每秒256次变化，变化间隔3.9ms。串口波特率115200，一次发送14B，需时1.2ms。程序不会错过任何一次正常的变化。串口输出验证了这一点

xmshao 发表于 2024-3-2 14:55:07

我怀疑是种误会，数据本身可能根本没问题。

现在假设你面前有个滚动盘，可以依序匀速循环滚动显示0到59，

你可以按固定时间来读显示数据，也可以不定速来读，把每次读到的

数据依次写下来，只要它的转速和你读取它的速率不同步，最后记录下

来的数据一定存在无序情况。

啪发表于 2024-3-3 09:23:57

butterflyspring 发表于 2024-3-1 14:32
从芯片原理上看，这个RTC配置好并启动，它是一直计数的，不太可能跟配置有关。

因为它的速度很快，所以如 ...

没有用调试窗口.看的是串口输出数据.
SSR 分频使用默认的255,正常情况大概3.9ms变化一次.
串口波特率115200,发送一次数据14个字节,用时大概1.2ms.
所以不存在不同步或漏读数据的问题

啪发表于 2024-3-3 09:27:07

xmshao 发表于 2024-3-2 14:55
我怀疑是种误会，数据本身可能根本没问题。

你说的情况确实在现实中经常出现.但如我在另一个回复里说明的,我已经充分考虑到运行时间的因素.
程序观察数据肯定是足够快的,不存在不同步的问题

背影101 发表于 2024-3-5 11:09:13

xmshao 发表于 2024-3-5 11:15:07

你可以这样，弄个基于子秒级的alarm中断，比方就比较1位，

即每7.8ms产生一次中断. 基于中断来读取，看看数据还乱不乱。

并看看相邻两次读到的时间是否固定在7.8ms样子。

另外，读取时间时遵循先TIMER后Date的规矩。

啪发表于 2024-3-5 14:23:53

xmshao 发表于 2024-3-5 11:15
你可以这样，弄个基于子秒级的alarm中断，比方就比较1位，

感谢你的关注！

使用中断方式试了一下，数据还是乱的。见下方实例数据，左侧是 SSR 值，右侧是 SysTick 计数。
00243:00000152
00241:00000159
00239:00000167
00237:00000175
00239:00000183
00233:00000191
00231:00000198
可以看出，正常情况下，大概7、8个SysTick（也就是7、8ms）变化一次。
本来应该紧跟在237后的235没有出现，而是回跳到了239，之后有恢复正常。
如果直接读取 SSR 值的话，数据应该是这样的：
00237:......
00236:......
00239:......
00235:......
00234:......

话说回来，就算使用中断方式数据会有序起来，也很难满足我的需要。
因为我需要更高精度的时钟，要把 SSR 的分频设为最大的32767，而不是默认的 255。
这样的话，使用中断方式会需要很大的中断开销：大概60微秒就要处理一次中断。这不是我所希望的。

下面是主程序代码：
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file       : main.c
* @brief       : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2024 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

DCACHE_HandleTypeDef hdcache1;

RTC_HandleTypeDef hrtc;

UART_HandleTypeDef huart3;

/* USER CODE BEGIN PV */
volatile uint32_t ssr = 0;
volatile uint32_t tr = 0;
volatile uint32_t dr = 0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ICACHE_Init(void);
static void MX_RTC_Init(void);
static void MX_USART3_UART_Init(void);
static void MX_DCACHE1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
* @briefThe application entry point.
* @retval int
*/
int main(void)
{
/* 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_ICACHE_Init();
MX_RTC_Init();
MX_USART3_UART_Init();
MX_DCACHE1_Init();
/* USER CODE BEGIN 2 */

/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
unsigned prev_ssr = 0;
unsigned this_ssr, tick;
int count;
char print_buf = { 0 };
while (1) {
this_ssr = ssr;
tr = tr;
dr = dr;

tick = HAL_GetTick();
if (this_ssr != prev_ssr) {
count = sprintf(print_buf, "%05u:%08u\n", this_ssr, tick);
HAL_UART_Transmit(&huart3, (uint8_t const*) print_buf, count, 10);
prev_ssr = this_ssr;
}
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}

/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

/** Configure the main internal regulator output voltage
*/
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);

while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}

/** Configure LSE Drive Capability
*/
HAL_PWR_EnableBkUpAccess();
__HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);

/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE|RCC_OSCILLATORTYPE_CSI;
RCC_OscInitStruct.LSEState = RCC_LSE_ON;
RCC_OscInitStruct.CSIState = RCC_CSI_ON;
RCC_OscInitStruct.CSICalibrationValue = RCC_CSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLL1_SOURCE_CSI;
RCC_OscInitStruct.PLL.PLLM = 1;
RCC_OscInitStruct.PLL.PLLN = 125;
RCC_OscInitStruct.PLL.PLLP = 2;
RCC_OscInitStruct.PLL.PLLQ = 2;
RCC_OscInitStruct.PLL.PLLR = 2;
RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1_VCIRANGE_2;
RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1_VCORANGE_WIDE;
RCC_OscInitStruct.PLL.PLLFRACN = 0;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}

/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                           |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
                           |RCC_CLOCKTYPE_PCLK3;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB3CLKDivider = RCC_HCLK_DIV1;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
{
Error_Handler();
}
}

/**
* @brief DCACHE1 Initialization Function
* @param None
* @retval None
*/
static void MX_DCACHE1_Init(void)
{

/* USER CODE BEGIN DCACHE1_Init 0 */

/* USER CODE END DCACHE1_Init 0 */

/* USER CODE BEGIN DCACHE1_Init 1 */

/* USER CODE END DCACHE1_Init 1 */
hdcache1.Instance = DCACHE1;
hdcache1.Init.ReadBurstType = DCACHE_READ_BURST_WRAP;
if (HAL_DCACHE_Init(&hdcache1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN DCACHE1_Init 2 */

/* USER CODE END DCACHE1_Init 2 */

}

/**
* @brief ICACHE Initialization Function
* @param None
* @retval None
*/
static void MX_ICACHE_Init(void)
{

/* USER CODE BEGIN ICACHE_Init 0 */

/* USER CODE END ICACHE_Init 0 */

ICACHE_RegionConfigTypeDef pRegionConfig = {0};

/* USER CODE BEGIN ICACHE_Init 1 */

/* USER CODE END ICACHE_Init 1 */

/** Configure and enable region 0 for memory remapping
*/
pRegionConfig.BaseAddress = 0x10000000;
pRegionConfig.RemapAddress = 0x60000000;
pRegionConfig.Size = ICACHE_REGIONSIZE_2MB;
pRegionConfig.TrafficRoute = ICACHE_MASTER1_PORT;
pRegionConfig.OutputBurstType = ICACHE_OUTPUT_BURST_WRAP;
if (HAL_ICACHE_EnableRemapRegion(_NULL, &pRegionConfig) != HAL_OK)
{
Error_Handler();
}

/** Enable instruction cache in 1-way (direct mapped cache)
*/
if (HAL_ICACHE_ConfigAssociativityMode(ICACHE_1WAY) != HAL_OK)
{
Error_Handler();
}
if (HAL_ICACHE_Enable() != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN ICACHE_Init 2 */

/* USER CODE END ICACHE_Init 2 */

}

/**
* @brief RTC Initialization Function
* @param None
* @retval None
*/
static void MX_RTC_Init(void)
{

/* USER CODE BEGIN RTC_Init 0 */

/* USER CODE END RTC_Init 0 */

RTC_PrivilegeStateTypeDef privilegeState = {0};
RTC_TimeTypeDef sTime = {0};
RTC_DateTypeDef sDate = {0};
RTC_AlarmTypeDef sAlarm = {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.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
hrtc.Init.OutPutPullUp = RTC_OUTPUT_PULLUP_NONE;
hrtc.Init.BinMode = RTC_BINARY_NONE;
if (HAL_RTC_Init(&hrtc) != HAL_OK)
{
Error_Handler();
}
privilegeState.rtcPrivilegeFull = RTC_PRIVILEGE_FULL_NO;
privilegeState.backupRegisterPrivZone = RTC_PRIVILEGE_BKUP_ZONE_NONE;
privilegeState.backupRegisterStartZone2 = RTC_BKP_DR0;
privilegeState.backupRegisterStartZone3 = RTC_BKP_DR0;
if (HAL_RTCEx_PrivilegeModeSet(&hrtc, &privilegeState) != HAL_OK)
{
Error_Handler();
}

/* USER CODE BEGIN Check_RTC_BKUP */

/* USER CODE END Check_RTC_BKUP */

/** Initialize RTC and set the Time and Date
*/
sTime.Hours = 12;
sTime.Minutes = 34;
sTime.Seconds = 56;
sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
sTime.StoreOperation = RTC_STOREOPERATION_RESET;
if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
sDate.WeekDay = RTC_WEEKDAY_SUNDAY;
sDate.Month = RTC_MONTH_FEBRUARY;
sDate.Date = 29;
sDate.Year = 24;

if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}

/** Enable the Alarm A
*/
sAlarm.AlarmTime.Hours = 0;
sAlarm.AlarmTime.Minutes = 0;
sAlarm.AlarmTime.Seconds = 0;
sAlarm.AlarmTime.SubSeconds = 1;
sAlarm.AlarmMask = RTC_ALARMMASK_ALL;
sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_SS14_1;
sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
sAlarm.AlarmDateWeekDay = 5;
sAlarm.Alarm = RTC_ALARM_A;
sAlarm.FlagAutoClr = ALARM_FLAG_AUTOCLR_ENABLE;
if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN RTC_Init 2 */

/* USER CODE END RTC_Init 2 */

}

/**
* @brief USART3 Initialization Function
* @param None
* @retval None
*/
static void MX_USART3_UART_Init(void)
{

/* USER CODE BEGIN USART3_Init 0 */

/* USER CODE END USART3_Init 0 */

/* USER CODE BEGIN USART3_Init 1 */

/* USER CODE END USART3_Init 1 */
huart3.Instance = USART3;
huart3.Init.BaudRate = 115200;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold(&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold(&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode(&huart3) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART3_Init 2 */

/* USER CODE END USART3_Init 2 */

}

/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();

/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(YELLOW_GPIO_Port, YELLOW_Pin, GPIO_PIN_RESET);

/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GREEN_GPIO_Port, GREEN_Pin, GPIO_PIN_RESET);

/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(RED_GPIO_Port, RED_Pin, GPIO_PIN_RESET);

/*Configure GPIO pin : Button_Pin */
GPIO_InitStruct.Pin = Button_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(Button_GPIO_Port, &GPIO_InitStruct);

/*Configure GPIO pin : YELLOW_Pin */
GPIO_InitStruct.Pin = YELLOW_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(YELLOW_GPIO_Port, &GPIO_InitStruct);

/*Configure GPIO pin : GREEN_Pin */
GPIO_InitStruct.Pin = GREEN_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GREEN_GPIO_Port, &GPIO_InitStruct);

/*Configure GPIO pin : RED_Pin */
GPIO_InitStruct.Pin = RED_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(RED_GPIO_Port, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
ssr = READ_REG(RTC->SSR);
tr = READ_REG(RTC->TR);
dr = READ_REG(RTC->DR);
}
/* USER CODE END 4 */

/**
* @briefThis function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}

#ifdefUSE_FULL_ASSERT
/**
* @briefReports the name of the source file and the source line number
*       where the assert_param error has occurred.
* @paramfile: pointer to the source file name
* @paramline: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

页: [1]

ST意法半导体中文论坛's Archiver

Nucleo-STM32H563 RTC SSR 寄存器值中途回跳