STM32G431 LED Toggle Issue – LED Stays ON Until Power Cycle

[Sethnittu]

I am using an STM32G431CBT6. I wrote code to toggle an LED in stm32cubeide. When I build the project in STM32G431, the LED stays permanently ON. However, when I power the board OFF and ON again, the LED starts toggling. Why is this happening?

[bramble]

Hi @Sethnittu ,

Are you sure that you have started your application execution after downloading your build? If you are running in debug mode you'll need to start execution. 

The next thing to check would be to put a breakpoint at the point where your code writes to the GPIO that is wired to the led, and step through execution.

I think there's just a basic misunderstanding about how to use CubeIDE going on here. You can find many YouTube video tutorials that may be helpful. 

Good luck!

 

[Sethnittu]

Hi @bramble,

Thank you for your reply. Actually, when I power my controller device OFF and ON, the LED blinks, but when I build and run the code, it doesn’t work  it stays permanently high. Why?

[waclawek.jan]

Maybe it toggles to fast to see by eye. Observe using oscilloscope or logic analyzer. Single-strep code in debugger.

Post more details, include source code.

JW

[Sethnittu]

This is my code 

 

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



/* USER CODE BEGIN PV */



/* USER CODE END PV */



/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void);

static void MX_GPIO_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();

/* USER CODE BEGIN 2 */



/* USER CODE END 2 */



/* Infinite loop */

/* USER CODE BEGIN WHILE */

while (1)

{

/* USER CODE END WHILE */

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);

HAL_Delay(500);

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);

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_HSI;

RCC_OscInitStruct.HSIState = RCC_HSI_ON;

RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;

RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

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_HSI;

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_0) != HAL_OK)

{

Error_Handler();

}

}



/**

* @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_GPIOA_CLK_ENABLE();

__HAL_RCC_GPIOB_CLK_ENABLE();



/*Configure GPIO pin Output Level */

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);



/*Configure GPIO pin : PB3 */

GPIO_InitStruct.Pin = GPIO_PIN_3;

GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

GPIO_InitStruct.Pull = GPIO_NOPULL;

GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);



/* USER CODE BEGIN MX_GPIO_Init_2 */



/* USER CODE END MX_GPIO_Init_2 */

}



/* 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 */

 

---

Edited to apply source code formatting - please see How to insert source code for future reference.

[Sethnittu]

This is my debugger setting.

[waclawek.jan]

Single-step the program in debugger.

When stopped, read out and check/post GPIOB registers content. Try to toggle the LED manually by writing to GPIOB_ODR in debugger.

JW

[Sethnittu]

Thank you for your reply. I am using the HAL library, but when I build the code, the LED does not blink. However, if I power-cycle the device, the LED starts blinking.

[waclawek.jan]

You've already written that. And you've been given instructions how to proceed.

JW

[Sethnittu]

I understand what you are saying. When I use a timer delay, it works properly, but when I use HAL_Delay, the LED does not work. Please help me with the HAL library.

[bramble]

Hi @Sethnittu 

If your goal is to have a blinking LED, well you have one.

If your goal is to learn how to program an STM32 device, well you need to put some effort into investigating the problem. e.g. Did you consider single stepping (debug mode) into HAL_Delay to see why it never returns?

Roll your sleeves up, put your thinking hat on, and get stuck in to your own debugging!

 

[TDK]

Ensure USER_VECT_TAB_ADDRESS is uncommented in the system_stm32*.c file.

[Tesla DeLorean]

With recent code/build changes this might be most likely what SysTick doesn't appear to be firing.