TovaIDE-STM - STM32 Development Environment User Guide

Overview

TovaIDE-STM is an integrated development environment for STM32 microcontroller development on Visual Studio Code. It integrates CubeMX, build system, flash programming, debugging, and hardware configuration tools for efficient embedded development.

If you're unfamiliar with STM32, all I can say is "good luck."

This was created to be easy to use for those familiar with CubeIDE.

Key Features

• STM32CubeMX Integration - Code generation from IOC files
• Build System - Makefile-based automatic builds
• Flash Programming - Program writing via ST-LINK
• Debug Features - GDB integrated debugger, register view, Live Expressions
• Pin Visualizer - Visual confirmation of IOC configuration
• Code Size Analysis - Memory usage visualization via MAP file analysis
• SWV/ITM Trace - Real-time log output
• Environment Settings - Configure tools and paths

Installation

1. Quick Installation

• Download the VS Code extension from the releases page (https://github.com/rintaro-s/TovaIDE-STM/releases) and install it in VS Code

2. Use the stable version

• git clone https://github.com/rintaro-s/TovaIDE-STM.git
• cd TovaIDE-STM
• npm install
• Open the codebase in VS Code and run the `VS Code - Build` task
• ./scripts/code.bat

Initial Setup

1. Install Required Tools

Install the following tools before starting:

• STM32CubeMX - Download from STMicroelectronics official website
• STM32CubeCLT - Command-line tools (includes GCC, GDB, ST-LINK)
• arm-none-eabi-gcc - ARM embedded GCC compiler (required for building)
• GNU Make - For Windows, use MinGW/MSYS or the version included with CubeCLT

2. Configure Environment Settings

From the command palette (Ctrl+Shift+P), run:

Open environment settings with:

STM32: Open STM32 Environment Settings

Configure paths to CubeMX, GCC, GDB, and ST-LINK tools.

3. Environment Check

STM32: Run Environment Check

This verifies installation status and configuration, highlighting any missing tools.

4. Detect CubeCLT Metadata

After installing CubeCLT, auto-detect it with:

STM32: Detect CubeCLT Metadata

Alternatively, click CubeMX Catalog Sync from the Dashboard.

Creating a Project

Method 1: Create New Project

1. From the command palette, run STM32: New Project
2. Select Board or MCU(e.g., STM32F401RE)
3. Enter project name
4. Select destination folder
5. CubeMX will launch automatically and create the IOC file

Method 2: Import CubeIDE Project

1. From the command palette, run STM32: Import CubeIDE Project
2. Select an existing CubeIDE project folder
3. Choose "Open Folder" or "Add to Workspace"

Method 3: Create from Board Config Studio (recommended)

1. Open "TovaIDE-STM Dashboard" in the sidebar
2. Click "Open Board Config Studio"
3. Select a board and configure pin assignments
4. Create project

Basic Development Flow

1. Hardware Configuration (IOC File Editing)

1. Click the .ioc file in your project, then click "Launch CubeMX"

2. The IOC editor opens (or CubeMX if configured)

3. Configure pin assignments, clock settings, and peripherals
4. Code generation runs automatically after saving

2. Code Generation

Code generation runs automatically when saving the IOC file. To manually regenerate:

STM32: Regenerate Code from IOC

Note: Code within USER CODE sections is automatically protected and restored.

3. Write User Code

Write your code in the generated source files (e.g., Core/Src/main.c) within the USER CODE sections:

4. Build

Build using one of these methods:

• Command palette: STM32: Build (Debug)
• Sidebar "Build Quick Actions" - click "Build (Debug)"
• Keyboard shortcut (if configured)

Build output appears in the output panel. If errors occur, use STM32: Jump to First Build Error to navigate to the error location.

4a. If Build Fails - Use CubeMX Makefile Generation

If the build fails and you need to regenerate the Makefile:

1. Run STM32: Open STM32 Environment Settings and verify tool paths
2. Open the IOC file in CubeMX: STM32: Open CubeMX
3. In CubeMX, go to Project Manager > Project
4. Ensure "Makefile" is selected as the toolchain

5. Click Generate
6. Return to VS Code and retry the build

5. Flash Programming

1. Connect ST-LINK to PC and board
2. From command palette, run STM32: Flash
3. Or use STM32: Build and Flash to build and program in one step

6. Debugging

1. Set breakpoints by clicking on line numbers in the editor
2. Press F5 or run STM32: Start Debug
3. Use the debug toolbar for step execution, variable inspection, etc.
4. Stop debugging: STM32: Stop Debug or Shift+F5

Useful Features

Pin Visualizer

Visually confirm pin assignments configured in the IOC file:

STM32: Open Pin Visualizer

Pin functions are displayed on the MCU package diagram.

Code Size Analysis

Analyze memory usage in detail after building:

STM32: Show Code Size Analysis

Sizes are displayed in table format by section and symbol.

Fault Analyzer

Analyze register values when a HardFault occurs:

1. Run STM32: Show Fault Analyzer
2. Enter CFSR register value (e.g., 0x00008200)
3. Enter HFSR register value (e.g., 0x40000000)
4. Fault cause is displayed with detailed explanation

Live Expressions (Real-time Variable Monitoring During Debug)

1. Open the "Live Expressions" view in the sidebar
2. Click the "+" button to add an expression (e.g., *((uint32_t*)0x40021000))
3. Values update automatically during debugging

SVD Register View

View peripheral registers in a hierarchy during debugging:

1. Open the "SVD Registers" view in the sidebar
2. Expand peripheral names to view register values
3. Click refresh to get the latest values

SWV/ITM Trace

Display printf output in real-time via SWO:

1. Configure stm32.debug.swv.startCommands in settings
2. After starting debug, run STM32: SWV Start
3. Logs appear in the "STM32 SWV/ITM" output panel
4. Stop with: STM32: SWV Stop

Command Reference

Command	Description
STM32: New Project	Create a new STM32 project
STM32: Import CubeIDE Project	Import an existing CubeIDE project
STM32: Build (Debug)	Execute a Debug build
STM32: Flash	Program the device via ST-LINK
STM32: Build and Flash	Build and program in one step
STM32: Start Debug	Start a debug session
STM32: Stop Debug	Stop the debug session
STM32: Regenerate Code from IOC	Regenerate code from IOC file
STM32: Open IOC Editor	Open the IOC editor
STM32: Open Pin Visualizer	Open the pin visualizer
STM32: Show Code Size Analysis	Display code size analysis
STM32: Show Fault Analyzer	Open the HardFault analyzer tool
STM32: Run Environment Check	Verify development environment configuration
STM32: Detect CubeCLT Metadata	Auto-detect CubeCLT installation
STM32: Open STM32 Environment Settings	Configure tool paths and settings
STM32: Jump to First Build Error	Navigate to the first build error
STM32: Open CubeMX	Launch CubeMX for the current project
STM32: SWV Start	Start SWV/ITM trace
STM32: SWV Stop	Stop SWV/ITM trace
STM32: SWV Show Log	Display SWV log

Configuration

Key Settings (settings.json)

{
  "stm32.cubemx.executable": "C:/ST/STM32CubeMX/STM32CubeMX.exe",
  "stm32.cubeclt.gccPath": "C:/ST/STM32CubeCLT/GNU-tools-for-STM32/bin/arm-none-eabi-gcc.exe",
  "stm32.cubeclt.gdbPath": "C:/ST/STM32CubeCLT/GNU-tools-for-STM32/bin/arm-none-eabi-gdb.exe",
  "stm32.cubeclt.stlinkPath": "C:/ST/STM32CubeCLT/STLink-gdb-server/bin/ST-LINK_gdbserver.exe",
  "stm32.build.makeExecutable": "make",
  "stm32.debug.svdPath": "${workspaceFolder}/STM32F401.svd",
  "stm32.debug.liveExpressions": [
    "*((uint32_t*)0x40021000)",
    "SystemCoreClock"
  ],
  "stm32.debug.swv.startCommands": [
    "monitor SWV port 0 on",
    "monitor SWV start"
  ],
  "stm32.debug.swv.stopCommands": [
    "monitor SWV stop"
  ]
}

Troubleshooting

Build Fails

• Run environment check: STM32: Run Environment Check
• Verify Makefile exists in the project
• Verify GCC path is correctly configured
• Check error messages in the output panel
• If Makefile is missing, launch CubeMX: STM32: Open CubeMX, go to Project > Generate Code, ensure "Makefile" toolchain is selected, and click Generate
• Verify arm-none-eabi-gcc is installed and in the configured path

Flash Programming Fails

• Verify ST-LINK driver is installed
• Verify ST-LINK is properly connected (check Device Manager)
• Ensure no other tool is using ST-LINK
• Verify board power is on
• Check ST-LINK firmware is up to date

Debug Session Won't Start

• Verify GDB path is correctly configured
• Verify ST-LINK GDB Server path is correct
• Verify launch.json is properly generated
• Check firewall is not blocking GDB server
• Verify arm-none-eabi-gdb is installed

USER CODE Disappears After Code Generation

• Ensure code is written only within USER CODE sections
• Verify comment format is correct: /* USER CODE BEGIN n */ and /* USER CODE END n */
• Develop a habit of backing up files manually

Frequently Asked Questions

Q: What is the difference between CubeMX and CubeCLT?

A: CubeMX is a GUI-based configuration tool (IOC file editing, code generation). CubeCLT is a command-line tool suite (GCC, GDB, ST-LINK). Both are required.

Q: How do I build Release instead of Debug?

A: Currently only Debug builds are supported. For Release builds, edit the Makefile directly.

Q: How do I switch between multiple STM32 boards?

A: Add multiple project folders to your workspace and switch between them as needed.

Q: What if arm-none-eabi-gcc is not found?

A: Ensure it is installed as part of CubeCLT or separately. Configure the correct path in STM32 Environment Settings.

Q: Can I use this offline?

A: Yes. Build, flash programming, and debugging all work offline. No internet connection is required.