•

Published February 2, 2026 © GPL3+

RT-Spark LED Blink with STM32CubeIDE & CubeMX

Get started with embedded systems using RT-Thread RT-Spark board basics, STM32CubeIDE & CubeMX with a simple basic Blinking LED project.

BeginnerFull instructions provided3 hours68

RT-Spark LED Blink with STM32CubeIDE & CubeMX

Things used in this project

Hardware components

RT-Thread RT-Spark STM32F407ZGT6

USB Cable to Type C Wire Charger

Software apps and online services

STMicroelectronics STM32CubeIDE

STMicroelectronics STM32CubeMX

Git

GitHub

Hackster.io

Story

Introduction

This laboratory project acts as the crucial step into firmware programming in to the BCA 143 Subject. Using the STM32F407ZGT6 microcontroller with the RT-Thread RT-Spark development board. Laboratory 0 demonstrates the installation of applications such as STM32CubeIDE, STM32CubeMX, and Git, setting up and making of accounts in GitHub and Hackster.io, configuration of Input/Output (GPIO) pins, and creating an LED blink project using the RT-Spark STM32F407ZGT6 development board using STM32CubeMX and STM32CubeIDE. With the RT-Spark board, a code was programmed to toggle the onboard LED and set a toggle delay at a an interval. For this project, it has version control via GitHub and the publication of the project documentation in Hackster.io.

Hardware Description

The main component used is the RT-Thread RT-Spark Development Board, with high performance STM32F407ZGT6 microcontroller (ARM Cortex-M4).

For visual representation, the on-board LEDs are being used. Based on the board schematics and pin definition:

Blue LED: Connected to pin PF11
Red LED: Connected to pin PF12

The circuit design is dependent on the GPIO pins being configured as outputs. The microcontroller sets these pins to a logic high (1) or low state (0), current flows through LED making it light up.

Required Materials

Hardware:

RT-Thread RT-Spark Board
USB Type-C Cable
Windows PC

Software:

STM32CubeIDE
STM32CubeMX
Git

Platforms

GitHub.com
Hackster.io

Design and Implementation

The approach is divided into five phases, STM32CubeIDE & CubeMX setup, creating STM32 Blink project, building and debugging RT-Spark, creating GitHub and Hackster.io account.

Step 1: Install All Required Software

1.1 Install STM32CubeIDE on Windows

Go open a browser and search STMicroelectronics STM32CubeIDE page and click the download link for Windows only.

Choose STM32CubeIDE-Win Installer

Right-click the installer, choose Run as administrator, and accept all and default folder settings to finish the installation, if Windows asks to allow this app to make changes, click Yes.
Launch and open STM32CubeIDE, accept the default workspace folder, and click launch to start.

If you have problems on following the process you may check the link provided:

1.2 Install STM32CubeMX on Windows

Open a browser, go to ST’s STM32CubeMX page, and click the download link for Windows only.

Choose STM32CubeMx-Win Installer

Right-click the downloaded installer, choose Run as administrator, and proceed with the default setting, accept the license and install in the default folder.
Click Finish to open STM32CubeMX and accept the default workspace folder, and click launch to start to confirm the application starts.

Check this video if you want to have a guide video in installing STM32CubeMX:

Step 2: Create the STM32 Blink Project

The RT-Spark Development Board is equipped with STM32F407ZGT6 Microcontroller. Figure 1 shows the board features, the on-board LED connected to a GPIO pin.

Figure 1: RT-Thread RT-Spark Development Board on-board LEDs pinout configuration

2.1 Create a new STM32 Project

In STM32CubeMX, click File → New → STM32 Project. In MCU/MPU Filters under look for the Commercial Part Number and search for and select the STM32F407ZGT6 chip to match the RT-Spark board, then click Start Project.

Step 1

Step 2

In the Pinout tab, locate pins PF11 and PF12 (as shown in Figure 1) click and set both to GPIO_Output to control the LEDs.

FIgure 2: Pinout & Configuration Tab

Figure 3: PF11 and PF12 in Pinout & Configuration

Go to the Project Manager tab. Enter the Project Name (e.g., Last_Name_STM32_Blink_LED), choose the Project Location, and make sure the Toolchain/IDE is selected to STM32CubeIDE.
Click generate code to automatically create the project files. Once complete, click Open Project to automatically launch STM32CubeIDE with the new project ready.

Optional: If you want to see the microcontroller pinout view and it's configuration tabs (Pinout & Configuration, Clock Configuration, etc.), open the .ioc file in the generated project.

2.2 Write a simple LED Blink Program

Once STM32CubeIDE project file is created, look for the project explorer and click your project that is automatically created earlier, to make sure the project file is error free, find the hammer icon and click → Build All.

It should display like this in the terminal:

If you already expand your project, go to and expand Core → Src, find and double-click the main.c fil

Below is the typical code structure recommended in ST’s blink tutorials, simply adapt only the pin names to match the specific configuration:

main.c (Code Structure)

In the main.c file find the infinite loop inside int main(void):

The infinite loop inside main.c file

Replace the pin names with the actual names in the configuration in the board (e.g., GPIOF, GPIO_PIN_11, and GPIO_PIN_12).
Check if the #include "main.h" is found above, if not add that. But typically it's there,
The loop will toggle the LED every 500ms, a visible blink can be seen, try increasing the toggle delay , values between 1000ms and 10000ms, notice the difference of changing the delay.

Step 3: Build and Debug RT-Spark

Connect the RT-Spark board to your windows pc using USB Cable to Type C, the cable should be connected to the debug label in the board and install all drivers needed.
In the STM32CubeIDE, click build ( hammer icon) to build the project.
Once the build proceeds without errors click the green bug icon to Debug or the green play icon to Run.

When debug configuration dialog appears, accept the default ST-Link configuration and click OK to proceed.
STM32CubeIDE will program the board, after it finishes, check if the code's running, and click Resume if debug mode is selected.

You can see the RT-Spark board LED is blinking at specified toggle delay time set.

Step 4: Upload your project to GitHub

(If you already have an account skip this step in creating an GitHub account).

4.1 Create GitHub account

Open a browser and go to github.com

Use your institute email, remember your username and password you used in creating the account, follow other instructions to complete your creation of your account.
Choose the free plan for now, and skip surveys.

You can also check the Youtube Link provided:

You have now your GitHub account logged in to the website.

4.2 Create your new GitHub repository

Now go the the dashboard, and click new to create a new repository.

Enter a Repository Name

Set to Public
Do not add a README, .gitignore, or license, then click create repository.

4.3 Install Git for windows

Go to https://git-scm.com/install/windows

Download the Git for Windows Setup
In the downloads folder find the installer file and install Git, and click finish.
Once installed you are ready to use from Git Bash or Command Prompt

If you have problems in installing you may follow the Youtube link provided:

4.4 Upload your STM32CubeIDE project using Git

Go to File Explorer and locate your STM32 Project folder containing all the files required for this project and proceed to the folder.

Project File Folder

In your address bar type cmd.

Address Bar

After typing cmd, click enter

In the Command prompt, enter the following commands one by one, by pressing Enter one after the other.

git init
git add .
git commit -m "Initial commit: STM32F407ZGT6 Blink LED"

Link your local project to the GitHub Repository, and replace it with your own URL.

Type and enter these commands one after the other:

git remote add origin https://github.com/yourname/rt-spark-blink-led.git
git branch -M main
git push -u origin main

If you are asked for authentication, enter the credentials to you GitHub account to complete the process, a separate window may open for you to authorize.

Refresh your GitHub repository page, and check if all files are successfully and uploaded visible online.

Step 5: Create a Hackster.io account

You may use your GitHub account to create an account to make it easier.

5.1 Create a Hackter.io project

Presenting your project to the fellow innovators or developers is good for you to display what you made and easily document and share your hardware projects online.

In your dashboard find create project

After creating project, create a short title, elevator pitch, and add a cover image for your project and click continue.

Now finish your project by completing the checklist, basics, team, things, story, and attachments.

Save your project and you are done with your project and it is shared online.

Documentation

The infinite loop used used in the program, setting the toggle delay to specific interval.

/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
HAL_GPIO_TogglePin(GPIOF, GPIO_PIN_11);
HAL_GPIO_TogglePin(GPIOF, GPIO_PIN_12);
HAL_Delay(500);
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */

Result and Testing

The project is built using the STM32CubeIDE and CubeMX integration. The RT-Spark is connected to the PC via USB Type C cable to supply power to the board enabling the ST-Link debugging configuration.

Result:

Following this, the toolchain used is correctly installed including the drivers and the GPIO configuration is accurate.. Your blinking led project will work.

Conclusion

For Lab 0, learning is the first step of the embedded journey. Installing STM32CubeIDE, STM32CubeMX, and Git, moving to configuring these new apps, and then creating a simple LED blink project using the RT-Thread RT-Spark development board with ST's applications was a great milestone to achieve because it was not easy as a beginner.

This include creating a GitHub account and Hackster.io profile, and lastly, creating a repository and a project to showcase, which was not an easy task. Creating the title, elevator pitch, and the story was the difficult part for me, but facing these challenges made me think critically and plan for greater heights. I am loving these kinds of things and hoping to learn more in this subject.

Code

Main Code (main.c)

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2026 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_TogglePin(GPIOF, GPIO_PIN_11);
	  HAL_GPIO_TogglePin(GPIOF, GPIO_PIN_12);
	  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_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(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_GPIOF_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOF, GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_RESET);

  /*Configure GPIO pins : PF11 PF12 */
  GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOF, &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 */

Credits

Yestin Paraguya

1 project • 0 followers

Paul Rodolf P. Castor

17 projects • 9 followers

RT-Spark LED Blink with STM32CubeIDE & CubeMX

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Hardware Description

Platforms

Design and Implementation

Step 1: Install All Required Software

Step 2: Create the STM32 Blink Project

Step 3: Build and Debug RT-Spark

Step 4: Upload your project to GitHub

Step 5: Create a Hackster.io account

Documentation

Result and Testing

Conclusion

Schematics

RT-Spark Architecture

Code

Main Code (main.c)

rt-spark-blink-led

Credits

Yestin Paraguya

Paul Rodolf P. Castor

Comments

Embed the widget on your own site

RT-Spark LED Blink with STM32CubeIDE & CubeMX

RT-Spark LED Blink with STM32CubeIDE & CubeMX

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Hardware Description

Platforms

Design and Implementation

Step 1: Install All Required Software

Step 2: Create the STM32 Blink Project

Step 3: Build and Debug RT-Spark

Step 4: Upload your project to GitHub

Step 5: Create a Hackster.io account

Documentation

Result and Testing

Conclusion

Schematics

RT-Spark Architecture

Code

Main Code (main.c)

rt-spark-blink-led

Credits

Yestin Paraguya

Paul Rodolf P. Castor

Comments

Related channels and tags