STEP 3 — SETTING UP FSMC FOR THE LCD

•

Paul Rodolf P. Castor

Published April 13, 2026 © GPL3+

Exploring GPIO on RT-Spark with LCD and Switches

Controlling RT-Spark's built-in LCD and 3 LEDs using 5 momentary switches via GPIO on STM32F407ZGT6.

IntermediateFull instructions provided3 hours27

Exploring GPIO on RT-Spark with LCD and Switches

Things used in this project

Hardware components

C&K Switches PTS 645 Series Switch

One each for Up, Down, Left, Right, Center

Jumper wires (generic)

Have extras to avoid running short

LED (generic)

Red, Green, and Blue — use separate LEDs

Breadboard (generic)

Preferably, use a large one for easier wiring

Resistor 220 ohm

For current limiting on each LED

RT-Spark (Spark-1) RT-Thread Development Board

STM32F407ZGT6-based board by RT-Thread

Resistor 10k ohm

Optional — only if not using internal pull-up

Software apps and online services

RT-Thread STM32CubeIDE (V1.19.0)

Used for coding, building, and flashing

Github: RT-Thread-Studio / SDK-BSP-STM32f407-Spark

Source for the bare-metal LCD library

Story

RT-SPARK (SPARK-1) RT-THREAD DEVELOPMENT BOARD

The RT-Spark, or what they call "Spark-1", is a development board from RT-Thread that runs on the STM32F407ZGT6 microcontroller. It comes with a lot of built-in stuff like Wi-Fi, a buzzer, SD card slot, LED matrix, and the one we care about the most for this project — the built-in LCD screen.The LCD has a 240x240 resolution and uses the ST7789 v3 driver chip. It doesn't use the usual SPI or I2C — instead it talks to the MCU through something called FSMC (Flexible Static Memory Controller) using an 8080 parallel port interface. That's what makes it a bit more complicated to set up compared to regular displays.For this project, aside from the LCD, we also added 5 momentary push buttons for user input, and 3 separate LEDs (Red, Green, Blue) that light up depending on which button you press.

STEP 1 — MAKING SURE THE LCD BACKLIGHT WORKS

Before doing anything else, I had to check if the LCD backlight was actually working. If you skip this and go straight to the code, you might spend a lot of time debugging something that's actually a hardware problem.Here's what I did:

1.1 Create a New Project in STM32CubeMX.

1.2. Searched for STM32F407ZGT6 and selected it.

1.3. Go to Project Manager. Type your desired Project Name, after that, change the Toolchain / IDE to STM32CubeIDE. Then, click GENERATE CODE.

1.4. After you clicked it, this will appear.

1.5.

STEP 2 — Look for the.ioc file. Inside the.ioc file (CubeMX), I looked for the LCD_BL pin and set it as GPIO_Output, then labeled it LCD_BL.

1 / 3

OUTPUT: If the backlight turns on, that means the hardware is fine. The LCD screen itself might still be blank at this point — that's normal, we haven't initialized it yet.

LCD Backlight Test

STEP 3 — SETTING UP FSMC FOR THE LCD

Since the LCD uses the 8080 parallel interface, I had to configure the FSMC peripheral in CubeMX so the MCU can actually communicate with it.

Opened the.ioc file again
Went to Connectivity → FSMC on the left panel
Set the configuration like this:

1 / 3 • Pinout & Configuration of FSMC 1

Note: Other green color appeared because you configured FSMC.

Step 4 — DOWNLOADING AND ADDING THE LCD LIBRARY

Writing the LCD driver from scratch would take forever, so I used a ready-made bare-metal library instead. The official RT-Thread SDK has one, but it requires RTOS which we're not using here. So I used this bare-metal version:

Download link:https://sendgb.com/M8kq5c23FwC

After downloading and extracting the zip:

Copied all.h files into my project's Core/Inc folder
Copied all.c files into Core/Src
Refreshed both folders in STM32CubeIDE by right-clicking them and clicking Refresh

1 / 3 • Refreshed Inc

Once that's done, you get access to functions like:

drv_lcd_init() — sets up the LCD
lcd_clear(COLOR) — wipes the screen
lcd_set_color(bg, fg) — sets your text and background colors
lcd_show_string(x, y, size, "text") — actually prints text on screen

STEP 5— WIRING THE SWITCHES AND LEDsSwitch Pin Assignments (GPIOG — internal pull-up):

LED Pin Assignments (GPIOA — active low):

Actual Breadboard Circuit where it connects to RT-Spark:

Breadboard X RT-Spark

FINAL OUTPUT:

Code

Main Program — GPIO User Interface (Switches, LEDs, LCD)

/* 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 */
#include "drv_lcd.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 ---------------------------------------------------------*/
SRAM_HandleTypeDef hsram1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_FSMC_Init(void);
/* USER CODE BEGIN PFP */
void MY_GPIO_Init(void);
void MY_LEDS_Init(void);
void RGBLED_Config(uint8_t red, uint8_t green, uint8_t blue);
void ToggleLEDS(void);
void print_switches(void);
/* USER CODE END PFP */

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

// --- SWITCH FUNCTIONS ---
uint8_t switch_Up()     { return HAL_GPIO_ReadPin(GPIOG, GPIO_PIN_0) == GPIO_PIN_RESET; }
uint8_t switch_Down()   { return HAL_GPIO_ReadPin(GPIOG, GPIO_PIN_1) == GPIO_PIN_RESET; }
uint8_t switch_Left()   { return HAL_GPIO_ReadPin(GPIOG, GPIO_PIN_2) == GPIO_PIN_RESET; }
uint8_t switch_Right()  { return HAL_GPIO_ReadPin(GPIOG, GPIO_PIN_5) == GPIO_PIN_RESET; }
uint8_t switch_Center() { return HAL_GPIO_ReadPin(GPIOG, GPIO_PIN_6) == GPIO_PIN_RESET; }

// --- LED FUNCTION ---
void RGBLED_Config(uint8_t red, uint8_t green, uint8_t blue) {
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, !red);
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, !green);
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, !blue);
}

// --- MAP SWITCHES TO LEDS ---
void ToggleLEDS() {
    RGBLED_Config(switch_Up(), switch_Center(), switch_Down());
}

// --- LCD SWITCH DISPLAY ---
void print_switches() {
    if (switch_Up()) {
        lcd_show_string(0, 0, 32, "Button Up is Pressed    ");
    } else if (switch_Down()) {
        lcd_show_string(0, 0, 32, "Button Down is Pressed  ");
    } else if (switch_Left()) {
        lcd_show_string(0, 0, 32, "Button Left is Pressed  ");
    } else if (switch_Right()) {
        lcd_show_string(0, 0, 32, "Button Right is Pressed ");
    } else if (switch_Center()) {
        lcd_show_string(0, 0, 32, "Button Center is Pressed");
    }
}

/* 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_FSMC_Init();
  /* USER CODE BEGIN 2 */

  MY_GPIO_Init();              // Initialize switch pins
  MY_LEDS_Init();              // Initialize LED pins
  HAL_GPIO_WritePin(LCD_BL_GPIO_Port, LCD_BL_Pin, GPIO_PIN_SET); // Turn on backlight
  drv_lcd_init();              // Initialize LCD
  lcd_clear(WHITE);            // Clear screen to black
  lcd_set_color(WHITE, BLACK); // Text = white, Background = black
  lcd_show_string(0, 0, 32, "Hello World!"); // Display text

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
    print_switches();
    ToggleLEDS();
    HAL_Delay(500);
  }
  /* 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();
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LCD_BL_GPIO_Port, LCD_BL_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LCD_RST_GPIO_Port, LCD_RST_Pin, GPIO_PIN_RESET);

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

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

  /* USER CODE BEGIN MX_GPIO_Init_2 */

  /* USER CODE END MX_GPIO_Init_2 */
}

/* FSMC initialization function */
static void MX_FSMC_Init(void)
{

  /* USER CODE BEGIN FSMC_Init 0 */

  /* USER CODE END FSMC_Init 0 */

  FSMC_NORSRAM_TimingTypeDef Timing = {0};

  /* USER CODE BEGIN FSMC_Init 1 */

  /* USER CODE END FSMC_Init 1 */

  /** Perform the SRAM1 memory initialization sequence
  */
  hsram1.Instance = FSMC_NORSRAM_DEVICE;
  hsram1.Extended = FSMC_NORSRAM_EXTENDED_DEVICE;
  /* hsram1.Init */
  hsram1.Init.NSBank = FSMC_NORSRAM_BANK3;
  hsram1.Init.DataAddressMux = FSMC_DATA_ADDRESS_MUX_DISABLE;
  hsram1.Init.MemoryType = FSMC_MEMORY_TYPE_SRAM;
  hsram1.Init.MemoryDataWidth = FSMC_NORSRAM_MEM_BUS_WIDTH_8;
  hsram1.Init.BurstAccessMode = FSMC_BURST_ACCESS_MODE_DISABLE;
  hsram1.Init.WaitSignalPolarity = FSMC_WAIT_SIGNAL_POLARITY_LOW;
  hsram1.Init.WrapMode = FSMC_WRAP_MODE_DISABLE;
  hsram1.Init.WaitSignalActive = FSMC_WAIT_TIMING_BEFORE_WS;
  hsram1.Init.WriteOperation = FSMC_WRITE_OPERATION_ENABLE;
  hsram1.Init.WaitSignal = FSMC_WAIT_SIGNAL_DISABLE;
  hsram1.Init.ExtendedMode = FSMC_EXTENDED_MODE_DISABLE;
  hsram1.Init.AsynchronousWait = FSMC_ASYNCHRONOUS_WAIT_DISABLE;
  hsram1.Init.WriteBurst = FSMC_WRITE_BURST_DISABLE;
  hsram1.Init.PageSize = FSMC_PAGE_SIZE_NONE;
  /* Timing */
  Timing.AddressSetupTime = 1;
  Timing.AddressHoldTime = 15;
  Timing.DataSetupTime = 60;
  Timing.BusTurnAroundDuration = 0;
  Timing.CLKDivision = 16;
  Timing.DataLatency = 17;
  Timing.AccessMode = FSMC_ACCESS_MODE_A;
  /* ExtTiming */

  if (HAL_SRAM_Init(&hsram1, &Timing, NULL) != HAL_OK)
  {
    Error_Handler( );
  }

  /* USER CODE BEGIN FSMC_Init 2 */

  /* USER CODE END FSMC_Init 2 */
}

/* USER CODE BEGIN 4 */

// Initialize 5 switch input pins on GPIOG with pull-up
void MY_GPIO_Init(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    GPIO_InitStruct.Pin  = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2
                         | GPIO_PIN_5 | GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
}

// Initialize 3 LED output pins on GPIOA
void MY_LEDS_Init(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Set all LEDs OFF first (active low = SET means OFF)
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_SET);

    GPIO_InitStruct.Pin   = GPIO_PIN_0 | GPIO_PIN_2 | GPIO_PIN_3;
    GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStruct.Pull  = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    RGBLED_Config(0, 0, 0);
}

/* 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 */
  __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 CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Credits

GAZAWE CASIM

2 projects • 0 followers

Paul Rodolf P. Castor

17 projects • 9 followers

Exploring GPIO on RT-Spark with LCD and Switches