Build System

Complete reference for building NanoVNA-H firmware.

Prerequisites

Toolchain

Tool	Version	Purpose
`arm-none-eabi-gcc`	8.x recommended	ARM cross-compiler
`make`	3.81+	Build automation
`dfu-util`	0.9+	USB DFU flashing

Installation

Arch Linux:

sudo pacman -S arm-none-eabi-gcc arm-none-eabi-newlib dfu-util make

Ubuntu/Debian:

sudo apt install gcc-arm-none-eabi libnewlib-arm-none-eabi dfu-util make

macOS (Homebrew):

brew install --cask gcc-arm-embedded
brew install dfu-util

ChibiOS Extraction

ChibiOS is distributed as a compressed archive, not a git submodule.

cd NanoVNA-H
7z x ChibiOS.7z

This creates the ChibiOS/ directory containing the RTOS source.

Build Commands

Basic Build

# Build for NanoVNA-H (STM32F072, default)
make

# Build for NanoVNA-H4 (STM32F303)
make TARGET=F303

# Clean build artifacts
make clean

# Flash via DFU
make flash

Output Files

Target	Output	Size
F072	`build/H.bin`	~110 KB
F303	`build/H4.bin`	~130 KB

Makefile Targets

Target	Description
`all`	Build firmware (default)
`clean`	Remove build directory
`flash`	Flash via DFU
`dfu`	Reset device to DFU mode
`TAGS`	Generate etags file

Target Selection

# Default target
ifeq ($(TARGET),)
  TARGET = F072
endif

TARGET	MCU	Output
F072	STM32F072xB	H.bin
F303	STM32F303xC	H4.bin

Compiler Flags

Optimization

USE_OPT = -O2 -fno-inline-small-functions -ggdb -fomit-frame-pointer \
          -falign-functions=16 --specs=nano.specs -fstack-usage -std=c11
USE_OPT += -ffast-math -fsingle-precision-constant

Flag	Purpose
`-O2`	Optimization level 2
`-fno-inline-small-functions`	Reduce code size
`-ggdb`	Debug symbols for GDB
`-fomit-frame-pointer`	Free up a register
`-falign-functions=16`	Align functions for performance
`--specs=nano.specs`	Use newlib-nano (smaller libc)
`-fstack-usage`	Generate stack usage reports
`-std=c11`	C11 standard
`-ffast-math`	Aggressive floating-point optimization
`-fsingle-precision-constant`	Use float instead of double

Link Time Optimization

USE_LTO = yes

LTO is enabled by default, allowing cross-module optimization. This reduces code size but increases build time.

Garbage Collection

USE_LINK_GC = yes

Removes unused functions and data from the final binary.

MCU = cortex-m0
UDEFS = -DARM_MATH_CM0 -DVERSION=\"$(VERSION)\"
LDSCRIPT = NANOVNA_STM32_F072/STM32F072xB.ld

No FPU (software floating-point)
Cortex-M0 instruction set
128 KB flash, 16 KB RAM

MCU = cortex-m4
USE_FPU = hard
UDEFS = -DARM_MATH_CM4 -DVERSION=\"$(VERSION)\" -DNANOVNA_F303
LDSCRIPT = NANOVNA_STM32_F303/STM32F303xC.ld

Hard FPU (hardware floating-point)
Cortex-M4 instruction set with DSP
256 KB flash, 40 KB RAM

User Defines

# Target-specific defines
UDEFS = -DARM_MATH_CM4 -DVERSION=\"$(VERSION)\" -DNANOVNA_F303

# RTC clock source
UDEFS += -DVNA_AUTO_SELECT_RTC_SOURCE
# Or use external 32.768 kHz crystal:
# UDEFS += -DVNA_USE_LSE

# Optional features
# UDEFS += -D__VNA_Z_RENORMALIZATION__
# UDEFS += -D__VNA_FAST_LINES__

Source Files

Main Application

CSRC = usbcfg.c \
       main.c common.c si5351.c tlv320aic3204.c \
       dsp.c plot.c ui.c lcd.c \
       data_storage.c hardware.c vna_math.c

Fonts

CSRC += fonts/numfont16x22.c \
        fonts/Font5x7.c \
        fonts/Font6x10.c \
        fonts/Font7x11b.c \
        fonts/Font11x14.c

FatFS (SD Card)

CSRC += FatFs/ff.c \
        FatFs/ffunicode.c

ChibiOS

CSRC = $(STARTUPSRC) \
       $(KERNSRC) \
       $(PORTSRC) \
       $(OSALSRC) \
       $(HALSRC) \
       $(PLATFORMSRC) \
       $(BOARDSRC) \
       $(STREAMSSRC)

ChibiOS Integration

Include Files

# F072
include $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_stm32f0xx.mk
include $(CHIBIOS)/os/hal/ports/STM32/STM32F0xx/platform.mk
include NANOVNA_STM32_F072/board.mk
include $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/port_v6m.mk

# F303
include $(CHIBIOS)/os/common/startup/ARMCMx/compilers/GCC/mk/startup_stm32f3xx.mk
include $(CHIBIOS)/os/hal/ports/STM32/STM32F3xx/platform.mk
include NANOVNA_STM32_F303/board.mk
include $(CHIBIOS)/os/common/ports/ARMCMx/compilers/GCC/mk/port_v7m.mk

Stack Configuration

# Main thread stack
USE_PROCESS_STACKSIZE = 0x200    # 512 bytes

# Exception/interrupt stack
USE_EXCEPTIONS_STACKSIZE = 0x100  # 256 bytes

Version String

VERSION = "$(shell git describe --tags)"

The version is embedded in the firmware and displayed by the version and info commands.

Example: 1.2.44

Flashing

DFU Mode Entry

Hardware: Hold BOOT0 jumper while powering on
Menu: CONFIG > EXPERT SETTINGS > DFU
Shell: reset dfu command

Flash Command

make flash
# Equivalent to:
dfu-util -d 0483:df11 -a 0 -s 0x08000000:leave -D build/H.bin

Option	Meaning
`-d 0483:df11`	ST DFU device ID
`-a 0`	Alt setting 0 (internal flash)
`-s 0x08000000:leave`	Start address, exit DFU after
`-D build/H.bin`	Download this file

Debug Configuration

OpenOCD

openocd -f NanoVNA_DAP.cfg

The NanoVNA_DAP.cfg file configures OpenOCD for CMSIS-DAP debugging.

GDB Connection

arm-none-eabi-gdb build/H.elf
(gdb) target remote localhost:3333
(gdb) monitor reset halt
(gdb) load

Build Output

After building, examine the output:

# Check binary size
arm-none-eabi-size build/H.elf

# Example output:
   text    data     bss     dec     hex filename
 108544    1024    8192  117760   1cc00 build/H.elf

Section	Content
`text`	Code and constants (flash)
`data`	Initialized variables (flash + RAM)
`bss`	Uninitialized variables (RAM)

Troubleshooting

Linker Error: Flash Overflow

region `flash0' overflowed by XXXXX bytes

Solutions:

Disable unused features in nanovna.h
Reduce optimization: change -O2 to -Os
Remove debug commands

Compiler Version Issues

HardFault exception on startup

Solution: Use GCC 8.x specifically. Install from ARM’s website if your distribution has a different version.

DFU Not Detected

dfu-util: No DFU capable USB device available

Solutions:

Verify device is in DFU mode (BOOT0 held)
Check USB connection
Linux: add udev rule for DFU device
Check lsusb for 0483:df11

Build From Clean

make clean
rm -rf build
make TARGET=F072  # or F303

Docker Build

For reproducible builds with correct toolchain version:

FROM ubuntu:20.04
RUN apt-get update && apt-get install -y \
    gcc-arm-none-eabi \
    libnewlib-arm-none-eabi \
    make \
    p7zip-full
WORKDIR /build
COPY . .
RUN 7z x ChibiOS.7z && make

docker build -t nanovna-build .
docker run --rm -v $(pwd)/build:/build/build nanovna-build