VESC Firmware: Open Source Motor Controller for BLDC, DC, and FOC Applications

What VESC Firmware Controls and Who Uses It

VESC firmware is the software that runs on Vedder Electronic Speed Controller (VESC) hardware. The firmware implements three motor control paradigms: DC (direct current), BLDC (brushless DC, which uses trapezoidal commutation), and FOC (field-oriented control, which uses sinusoidal currents for smoother torque). The README links to the project website at vesc-project.com for further documentation.

The firmware's target hardware ranges across many board variants, all listed by running make. Each board has a corresponding hardware configuration file under hwconf/. The README shows that typing make alone produces a complete list of supported boards with their short names, for example 100_250 for the VESC 100/250 variant.

The repository also contains a LispBM scripting environment (lispBM/ directory) for writing custom motor control logic in a Lisp dialect without modifying the main firmware C code. This is a design choice specific to VESC firmware that has no equivalent in simpler open-source motor control projects.

Building VESC Firmware on Linux and macOS

On Ubuntu, install the build prerequisites:

sudo apt install git build-essential libgl-dev libxcb-xinerama0 wget git-gui

On macOS, the README lists stlink and openocd as useful tools:

brew install stlink
brew install openocd

After cloning the repository and changing into its directory, run these steps on all platforms:

1. git checkout origin/master 2. make arm_sdk_install (downloads the ARM GCC toolchain) 3. make (displays the supported boards list) 4. make 100_250 (builds firmware for the VESC 100/250, as an example)

For Linux users who want to flash without being root, add udev rules for the STLink v2 programmer:

wget vedder.se/Temp/49-stlinkv2.rules
sudo mv 49-stlinkv2.rules /etc/udev/rules.d/
sudo udevadm trigger

For teams using Nix with flakes enabled, the repository provides a flake.nix that builds the general-purpose firmware package:

nix build .#bldc-fw

The output is placed under result/. All boards are built by default with the Nix path.

Uploading Firmware: STLink Debugger and VESC Tool

There are two upload methods. The first is to use an STLink SWD debugger. Build and flash the bootloader first, then use the board-specific flash target:

make 100_250_flash

The second method uses the VESC tool application via USB. Build the firmware as a .bin file using the normal make command, then in the VESC tool: connect to the VESC, navigate to the Firmware tab, click Custom file, select the built .bin file from bldc/builds/100_250/100_250.bin, and press the upload firmware button.

The README includes a prominent warning about the USB method: do not disconnect power or USB during the upload, and wait 10 seconds after the progress bar shows completion before unplugging. Disconnecting prematurely risks bricking the device. If a VESC is bricked, recovery requires an SWD debugger to write a new working firmware directly.

Setting Up the Qt Creator IDE

The firmware includes a Qt Creator project at Project/Qt Creator/vesc.pro. To set up the IDE, install the aqtinstall Python package and run the Qt install script:

1. pip install aqtinstall 2. make qt_install 3. Open Qt Creator from tools/Qt/Tools/QtCreator/bin/qtcreator 4. Open the vesc.pro project file

The IDE is pre-configured to build the 100_250 firmware target. Other hardware variants are selectable from the bottom of the left panel in Qt Creator, where all supported hardware variants appear.

Configuration options beyond the board target are available in conf_general.h at the repository root. This file documents many build-time constants and feature flags. The README notes that changes there affect the compiled firmware behavior, so reviewing this file is necessary before building for production use.

LispBM Scripting and Custom Application Code

The lispBM/ directory contains a Lisp dialect interpreter that runs inside the VESC firmware. This allows writing motor control scripts that execute on the VESC hardware without requiring a firmware recompile for each change. The README does not describe the scripting API in detail; the interpreter documentation is on the vesc-project.com website.

The applications/ directory contains standard VESC application code (position control, speed control, torque control modes) that can be selected through the VESC tool. Custom applications can be added here and compiled into the firmware. This separation between application logic and firmware core is a design decision that makes the firmware more adaptable to different use cases without touching the motor control algorithms.

The firmware release tagging follows this convention in the README:

git tag -a [version] [commit] -m "VESC Firmware Version [version]"
git push --tags

Limitations: Board-Specific Builds and Nix Flash Restrictions

Each VESC hardware variant requires its own compiled binary. There is no universal firmware binary that works across all boards. Engineers working with multiple VESC variants must build and track separate firmware files for each one.

The Nix build path (nix build .#bldc-fw) builds all boards but does not support the make *_flash flash helpers. This means the Nix build covers reproducible compilation but requires the STLink or VESC tool upload path for deployment.

The firmware requires an ARM Cortex-M microcontroller on the target board. It is not portable to general-purpose microcontrollers like AVR or ESP32 without substantial porting work. The conf_general.h approach to configuration means changes require a full recompile; there is no runtime configuration file for build-time constants.

The repository carries no GitHub releases, only Git tags. Release artifacts are not hosted here; users obtain pre-built firmware from the vesc-project.com website or build from source.

Comparison with SimpleFOC

SimpleFOC is an open-source Arduino-compatible FOC library for brushless motors. It runs on general-purpose microcontrollers (ESP32, STM32, Arduino) with commonly available motor driver hardware, making it accessible for prototyping without dedicated VESC hardware.

VESC firmware targets dedicated VESC hardware boards designed for higher power applications with integrated current sensing and gate drivers. The firmware implements more motor control modes (DC, BLDC, and FOC in one firmware), the LispBM scripting environment, and a rich ecosystem of VESC tool integrations.

SimpleFOC is better suited for teams prototyping a low-power robotic system on commodity hardware. VESC firmware is better suited for production motor drive applications on VESC hardware, particularly where the higher power handling and the full feature set of the VESC ecosystem are needed. The VESC firmware codebase is substantially larger and its build process is more involved. An engineer building an electric longboard, an e-bike controller, or a high-voltage motor drive on VESC hardware will find the firmware's board-specific build targets and make qt_install IDE setup more useful than SimpleFOC's generic library approach.

Editorial conclusion

VESC firmware is the right choice for engineers building custom motor drive applications on dedicated VESC hardware. The build process is documented for Linux, macOS, and Windows, and the Qt Creator IDE setup is scripted through make qt_install. The bricking risk during USB upload is real: the README gives specific instructions to wait 10 seconds after the progress bar completes before disconnecting. Teams who need a simpler motor control solution for prototyping on general-purpose microcontrollers should look at SimpleFOC instead. For VESC hardware specifically, verify the board name via make before choosing a build target, since using the wrong target produces a binary that will not work on the connected device.

Frequently asked questions

Official sources

1. Issues
2. README
3. vedderb/bldc on GitHub