stm32G473 RCC setup for HSE

[mackelec]

As a preamble, I do this successfully on the L432.

I setup the G473 with 8MHz oscillator on PF0 . My code is setup the G473 to use HSE and run the system clock at 150Mhz.
I have a problem in that millis() and serial comms run at about 3 x longer than it ought to.

I have done similar code in stm32CubeIDE (I have included) which works as expected.
As you may notice I used MCO1 to check the freq of PLLCLK and it confirms to be 150Mhz. (150 / 16 = 9.3Mhz) checked it on the Scope.

Have I missed something?

meClock_G473.h

#include "stm32g4xx.h"


extern "C" void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {};

  /** Configure the main internal regulator output voltage
  */
  //HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_BOOST);
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  //RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  //RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI48|RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  //RCC_OscInitStruct.HSI48State = RCC_HSI48_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
  RCC_OscInitStruct.PLL.PLLN = 75; // 85
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; //4
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
  HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_PLLCLK, RCC_MCODIV_16);
  
}

Blink_473.ino

#include "meClock_G473.h"

#include <PString.h>
#include <Streaming.h>

//#define LED PB7   // ECU
#define LED PB9   // QFP48 socket PCB
#define TP1 PA4
HardwareSerial Serial1(PA10, PA9);

void setup() 
{
  pinMode(LED,OUTPUT);
  pinMode(TP1, OUTPUT);
  Serial1.begin(9600);
}

void loop() 
{
  digitalToggle(LED);
  Serial1.println("loop 2023");
  Serial1 << "RCC_CR      = " << RCC->CR << endl;
  Serial1 << "RCC_CFGR    = " << RCC->CFGR << endl;
  Serial1 << "RCC_PLLCFGR = " << RCC->PLLCFGR << endl;
//  Serial.printf("RCC_CR 0x%08X \n", RCC->CR);
//  Serial.printf("RCC_CFGR 0x%08X \n", RCC->CFGR);
//  Serial.printf("RCC_PLLCFGR 0x%08X \n", RCC->PLLCFGR);
  digitalToggle(TP1);
  delay(1000);
}

stm32CudeIDE code

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 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 */

/* 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 ---------------------------------------------------------*/
 UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

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

/* USER CODE END 0 */

/**
  * @brief  The 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_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9);
	  	  uint8_t Test[] = "Hello World !!!\r\n"; //Data to send
	  	  HAL_UART_Transmit(&huart1,Test,sizeof(Test),10);// Sending in normal mode
	  	  HAL_Delay(500);
    /* 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_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
  RCC_OscInitStruct.PLL.PLLN = 75;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
  HAL_RCC_MCOConfig(RCC_MCO1, RCC_MCO1SOURCE_PLLCLK, RCC_MCODIV_16);
}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

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

  /* USER CODE END USART1_Init 2 */

}

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

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

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : PA8 */
  GPIO_InitStruct.Pin = GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF0_MCO;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

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

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This 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 */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: 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 */

[fpistm]

Which G473? RE?...
Did you check the msp file generated by cube IDE? Some peripheral clock config are done here.

[mackelec]

the target is stm32G473CBT6.
( I have updated the titles on the code snippets above for better clarity)

I also did not mention that if I comment out "#include "meClock_G473.h" in the main ino file; that the arduino code works fine, using the default HSI clock.

I have not looked at the MSP files, will look now.

[mackelec]

I tried copying the following into meClock_G473.h from the MSP files
but it had no apparent change.

//-----  copied from MSP files

  GPIO_InitTypeDef GPIO_InitStruct = {};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {};

  __HAL_RCC_SYSCFG_CLK_ENABLE();
  __HAL_RCC_PWR_CLK_ENABLE();

   /** Initializes the peripherals clocks
  */
    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1;
    PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
    {
      Error_Handler();
    }

[mackelec]

the Arduino was a fresh install about a week ago.

[mackelec]

to help debugging I setup the serial port using bare metal below.
Note using

USART1->BRR = (150000000 / 9600);

works correctly. (proving system clock)

The error is that SystemCoreClock = 450Mhz and I don't know how it got that number.

I have now added SystemCoreClockUpdate(); to the Setup with no change to SystemCoreClock

Serial Setup

void setupUart1_BareMetal()
{
  // Enable clock for UART1
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN;

    // Set UART1 pins as alternate function
    // PA9 - Tx, PA10 - Rx
    GPIOA->MODER &= ~(GPIO_MODER_MODE9 | GPIO_MODER_MODE10);
    GPIOA->MODER |= (GPIO_MODER_MODE9_1 | GPIO_MODER_MODE10_1);
    GPIOA->AFR[1] |= (7 << 4) | (7 << 8);

    // Set baud rate to 9600
    //USART1->BRR = (SystemCoreClock / 9600);
      USART1->BRR = (150000000 / 9600);
    // Enable UART1
    USART1->CR1 |= USART_CR1_UE;

    // Enable Tx and Rx
    USART1->CR1 |= (USART_CR1_TE | USART_CR1_RE);
}

[mackelec]

looking at SystemCoreClockUpdate(), I now print all the variables used in this routine and I can't see how SystemCoreClock comes to equal 450Mhz. My code and output below.

new Main Loop

void loop() 
{
  uint32_t tmp, pllvco, pllr, pllsource, pllm, plln,clock1,clock2;
  digitalToggle(LED);
  
  Serial1.println("loop 2023");
  Serial1 << "RCC_CR      = " << RCC->CR << endl;
  Serial1 << "RCC_CFGR    = " << RCC->CFGR << endl;
  Serial1 << "RCC_PLLCFGR = " << RCC->PLLCFGR << endl;
  Serial1 << "SystemCore variable = " << SystemCoreClock << endl;
  Serial1 << "RCC_CFGR_SWS = " << RCC_CFGR_SWS  << endl;
  Serial1 << "RCC->CFGR & RCC_CFGR_SWS = " << (RCC->CFGR & RCC_CFGR_SWS) << endl;
  Serial1 << "HSE_VALUE = " << HSE_VALUE << endl;
  Serial1 << "pllsource = " << (RCC->PLLCFGR & RCC_PLLCFGR_PLLSRC) << endl;
  pllm = ((RCC->PLLCFGR & RCC_PLLCFGR_PLLM) >> 4) + 1U ;
  pllvco = (HSE_VALUE / pllm);
  pllr = (((RCC->PLLCFGR & RCC_PLLCFGR_PLLR) >> 25) + 1U) * 2U;
  plln = (RCC->PLLCFGR & RCC_PLLCFGR_PLLN) >> 8;
  tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
  clock1 = (((HSE_VALUE / pllm) * plln) / pllr);
  clock2 = clock1;
  clock2 >>= tmp;
  
  Serial1 << "pllvco #1 = " << pllvco << endl;
  //Serial1 << "PLLN = " << ((RCC->PLLCFGR & RCC_PLLCFGR_PLLN) >> 8) << endl;
  Serial1 << "PLLM = " << pllm << endl;
  Serial1 << "PLLN = " << plln << endl;
  Serial1 << "PLLR = " << pllr << endl;
  Serial1 << "HCLK prescale = " << tmp << endl;
  Serial1 << "Clock1 = " << clock1 << endl;
  Serial1 << "Clock2 = " << clock2 << endl;
//  Serial.printf("RCC_CR 0x%08X \n", RCC->CR);
//  Serial.printf("RCC_CFGR 0x%08X \n", RCC->CFGR);
//  Serial.printf("RCC_PLLCFGR 0x%08X \n", RCC->PLLCFGR);
  Serial1 << endl;
  digitalToggle(TP1);
  delay(1000);
}

and the results

loop 2023
RCC_CR      = 50529536
RCC_CFGR    = 1157627919
RCC_PLLCFGR = 285231891
SystemCore variable = 450000000
RCC_CFGR_SWS = 12
RCC->CFGR & RCC_CFGR_SWS = 12
HSE_VALUE = 8000000
pllsource = 3
pllvco #1 = 4000000
PLLM = 2
PLLN = 75
PLLR = 2
HCLK prescale = 0
Clock1 = 150000000
Clock2 = 150000000

[fpistm]

SystemCoreClock is updated by HAL when it configures the clock.

As stated here:

Arduino_Core_STM32/system/Drivers/CMSIS/Device/ST/STM32G4xx/Include/system_stm32g4xx.h

Lines 49 to 57 in 72524db

	/* The SystemCoreClock variable is updated in three ways:
	1) by calling CMSIS function SystemCoreClockUpdate()
	2) by calling HAL API function HAL_RCC_GetSysClockFreq()
	3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
	Note: If you use this function to configure the system clock; then there
	is no need to call the 2 first functions listed above, since SystemCoreClock
	variable is updated automatically.
	*/
	extern uint32_t SystemCoreClock; /*!< System Clock Frequency (Core Clock) */

So, in our case, it is when HAL_RCC_ClockConfig is called.
Then it is update here:

Arduino_Core_STM32/system/Drivers/STM32G4xx_HAL_Driver/Src/stm32g4xx_hal_rcc.c

Lines 936 to 937 in 72524db

	/* Update the SystemCoreClock global variable */
	SystemCoreClock = HAL_RCC_GetSysClockFreq() >> (AHBPrescTable[READ_BIT(RCC->CFGR, RCC_CFGR_HPRE) >> RCC_CFGR_HPRE_Pos] & 0x1FU);

Anyway I think I've found the issue. By default HSE_VALUE for STM32G4xx is 25MHz but in your case you used a 8MHz so you have to redefine it.

Arduino_Core_STM32/system/STM32G4xx/stm32g4xx_hal_conf_default.h

Line 117 in 72524db

#define HSE_VALUE (24000000UL) /*!< Value of the External oscillator in Hz */

You can use build_opt.h with:
-DHSE_VALUE=8000000UL

That should explain why you get 3x.

https://github.com/stm32duino/wiki/wiki/Customize-build-options-using-build_opt.h

[mackelec]

That worked! Thank you very much. I'll keep an eye out for that on the next processor.