Skip to the content
4 layers127 × 104.1 mmLevitas v2, the printed circuit board in 3D

PCB files for LeviTAS board

Size
127 × 104.1 mm
Copper layers
4
Thickness
1.6 mm
Parts
161
Nets
134
Pads
579
Tracks, vias
1,025, 133
Pours
2
Routed
Yes
KiCad
KiCad 10.0 (file 20260206)
Created
31 Oct 2026
Updated
6 Nov 2026

Overview

Levitas v2 is an open-source printed circuit board by biancanev, from the biancanev/levitas_pcb repository on GitHub. It is a 4-layer board of 127 × 104.1 mm with 161 parts on 134 nets, routed with 1,025 tracks and 133 vias.

Its parts include 47 capacitors, 34 resistors, 13 ICs, 12 connectors and 8 inductors.

README

readme.md

LeviTAS PCB

This is a PCB test platform originally built for the LeviTAS project.

A Raspberry Pi Pico microcontroller controls four 0-240V high voltage outputs and can simultaneously read from four FDC2112 capacitance sensors. The architecture and code should be straightforward to re-engineered to add more channels.

Full assembled PCB and enclosure

Programming / Firmware

This is how to program the microcontroller.

Introduction

This project uses the Raspberry Pi RP2350 microcontroller, which is mounted to a Raspberry Pi Pico 2 dev board that we solder onto the main project PCB. The dev board is cheap and convenient because in addition to the RP2350 itself it includes flash memory, an oscillator, and power circuitry that we'd otherwise have to include anyway. The programming is the same either way.

The RP2350 is uniquely good for our use case because we need (a) four I2C buses running in parallel to read FDC2112 capacitance sensors, for which we use the PIO modules available only on the RP2040 and RP2350, and (b) we'd like floating-point math support built into the hardware, which the RP2350 has but the RP2040 does not. An FPGA might accomplish roughly the same tasks but is much more expensive and complicated to use.

Programming the RP2350 microcontroller is officially supported in C++ or MicroPython. We use C++ to more easily write programs that satisfy tight timing constraints (e.g., making a control loop as fast as possible). See the Documentation section below for links to the official documentation.

Note we're specifically using the 2.0.0 version of the SDK (because that's what we started with and haven't bothered to update it). Updating this requires updating the pico-sdk subfolder, every mention of the SDK version in other configuration files, and the version of the picotool utility used to upload the software. To minimize compilation issues, we also specifically chose to put the SDK files inside this git repo instead of requiring them to be downloaded to an external directory and linked.

Installation and Running

Use the following steps to set up a software build environment for the Pico firmware on Linux or Windows, or follow the official getting started guide for more generic instructions.

On Linux:

  • Install gcc-arm-none-eabi compiler (arm-non-eabi-gcc on nixos)
  • Install newlib
  • Install cmake and gnumake
  • Install picotool
  • Install picotool udev rules
  • In firmware folder, run make build to compile code and make reload to download and run (or make to do both).
  • Use your favorite serial monitor to see data the Pico sends over USB.

On Windows:

  • Install Microsoft VS Code (This is preferable to VSCodium because the easiest way to read data from the Pico over USB is the Microsoft VS Code Serial Monitor extension, which doesn't work with VSCodium)
  • Install the official Raspberry Pi Pico Visual Studio Code extension
  • Open the firmware folder in VS Code. The Pi Pico extension should automatically detect this as a Pico project, and enable several commands under its quick access menu (click the extension icon on the Activity Bar, then under "Project" should be "Debug Project", "Compile Project", "Run Project (USB)", etc).
  • Use the following commands:
    • "Compile Project" will compile (only) the software and put the compiled executables in a build subfolder, but note that "Configure CMake" must be run first.
    • "Configure CMake" will create a build subfolder and prepare the compilation based on configuration information in the CMakeLists.txt file. This is run automatically when the folder is opened in VS Code if recognized by the Pico extension. NOTE: THIS MUST BE MANUALLY RE-RUN EVERY TIME YOU CHANGE CMakeLists.txt FOR THE CHANGES TO BE APPLIED!
    • "Run Project (USB)" will load the program onto a Rasberry Pi Pico 2 board connected over USB (specifically, by running the picotool command line utility). If the Pico is in BOOTSEL mode (achieved by holding down the BOOTSEL button before plugging in USB) it will probably work immediately. If not, uploading can still work if USB communication was enabled on the already-running Pico program (which it is for this software, as per CMakeLists.txt), though you might need to press "Run Project (USB)" twice.
    • "Debug Project" and "Flash Project (SWD)" do not work without use of the Raspberry Pi Debug Probe (which we don't have).
  • To see data the Pico is sending over USB, open the "SERIAL MONITOR" tab on the lower VS Code panel that also has "TERMINAL", "DEBUG CONSOLE", etc., set to 115200 baud and the correct COM port. Note this requires pico_enable_stdio_usb(levitas 1) to be set in CMakeLists.txt and stdio_init_all(); to be called in main.c (which they are).

Notable Firmware files

Inside the firmware folder:

  • CMakeLists.txt configures compilation, and must be manually changed to include new source code files or other settings (e.g., importing a new sublibrary for the Pico SDK)
  • src/main.c is the main source code file and holds the main LeviTAS control loop.
    • by default, this only prints capacitive sensor readings over USB; high voltage is set to zero
    • uncomment code in the main loop to enable high voltage output
  • src/pio_i2c.c, src/pio_i2c.h, and src/pio_i2c.pio together form a library that can run I2C communication via the Pico PIOs. src/main.c uses this library to run four I2C ports in parallel (to connect to four FDC2112 chips).
  • the following test code is unused but can be enabled by changing CMakeLists.txt to make them the main project file instead of main.c:
    • src/test_fdc2112_i2c.c tests only two of the four connected FDC2112 chips by using the two hardware built-in I2C modules (instead of PIO)
    • src/test_fdc2112_pio_i2c.c tests all four connected FDC2112 chips using the PIO library, and is almost identical to code in src/main.c.
    • src/test_max5715_spi.c tests the MAX5715 DAC and high voltage output, and is almost identical to code in src/main.c.
    • src/test_mpu6050_i2c.c displays data the MPU6050 accelerometer on the PCB motherboard using one of the hardware built-in I2C modules.

Other files:

  • Makefile is used only for compiling on Linux, not for VS Code
  • .vscode and pico_sdk_import.cmake are used only for VS Code with the official Pico VS Code extension, not on Linux
  • the build subfolder is automatically generated by cmake when compiling and contains compiled executables in several formats, including UF2.

Data Collection

The data-collection/collect-data.py and data-collection/graph-data.py Python programs in the data-collection subfolder of the main git repo can be used to automatically read the data the microcontroller sends over USB, then graph it. This provides much more useful data than manually looking at the printed output in a serial monitor.

Some Useful Notes

There are several ways to upload code to a RP2040 or RP2350 chip:

  1. Put into BOOTSEL mode (on Pi Pico dev board, hold down BOOTSEL buton when connecting power/USB), at which point the built-in ROM makes it act like a USB mass storage device. Upload file. (To verify file uploaded correctly, use picotool)
  2. Put into BOOTSEL mode, use picotool to upload file
  3. If USB communication enabled, can use picotool to force exit into BOOTSEL mode (use "picotool load -f" or "-F") then reboot (convenient!). There's no need to press the BOOTSEL button anymore. Note that sometimes this doesn't work on the first try, but repeating the process usually works.
  4. Use SWD debugging interface. Using the BOOTSEL mode (options 1,2) is necessary on a new chip, but afterward, as long as a program with USB communication enabled is running, option 3 is much more convenient. This is what we generally use.

Notes on the C/C++ SDK (from PDF manual):

  • Consists of a large number of CMake libraries (in pico-sdk/src/rp2_common), which must be linked in the per-project CMakeLists.txt
    • The default library used in most examples is pico_stdlib, which includes several other libraries
    • the include files are typically in pico-sdk/src/rp2_common/(CMake library name)/include/(pico, hardware, gpio, etc)/(header.h)
  • Apparently has some ability to build/debug running on the host operating system instead of the RP2040?
  • Definitions for dev boards are in pico-sdk/src-boards/include/boards/
  • The PDF manual has a bunch of examples
  • Standard stdin/stdout can use (chapter 2.7):
    • UART (easy) (enabled by default) (disable by calling pico_enable_stdio_uart in CMakeLists.txt)
    • a USB CDC ACM virtual serial port (via TinyUSB) (enable by linking pico_stdio_usb or calling pico_enable_stdio_usb in CMakeLists.txt) (this is generally my preference?)
    • serial wire debug link (semihosting)
    • Segger RTT
  • Can use bi_decl() in C code to store information in compiled binaries that picotool can access (e.g., comments, pin numbers)

Documentation

There is a large amount of good official documentation at the following links. The most useful documentation is noted.

https://www.raspberrypi.com/documentation/microcontrollers/

RP2350 microcontroller:

Pico and Pico 2 dev boards (which are almost identical):

Programming with C/C++:

Picotool:

  • An official (and open source) CLI tool to work with compiled binaries and communicate with boards when in BOOTSEL mode (using the PICOBOOT interface; see RP2040 datasheet). Used to load and verify programs.
  • https://github.com/raspberrypi/picotool

Raspberry Pi Debug Probe:

More pictures

Stacked PCBs Daughterboard

Parts

161
QtyValueFootprintReferences
20SolderJumper_2_BridgedJumper:SolderJumper-2_P1.3mm_Bridged_RoundedPad1.0x1.5mmJP1, JP2, JP3, JP4, JP5, JP10, JP11, JP12, JP13, JP14, JP15, JP16, JP17, JP18, JP20, JP22 +4
164.7kResistor_SMD:R_0603_1608MetricR1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16
12100nCapacitor_SMD:C_0603_1608MetricC2, C5, C8, C11, C14, C17, C20, C23, C39, C40, C42, C46
1210kResistor_SMD:R_1206_3216MetricR17, R18, R19, R20, R21, R22, R23, R24, R25, R26, R27, R28
12470pCapacitor_SMD:C_0805_2012MetricC25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36
114.7uCapacitor_SMD:C_0805_2012MetricC1, C4, C7, C10, C13, C16, C19, C22, C41, C43, C45
818uInductor_SMD:L_0603_1608MetricL1, L2, L3, L4, L5, L6, L7, L8
833pCapacitor_SMD:C_0603_1608MetricC3, C6, C9, C12, C15, C18, C21, C24
8FDC2112levitas_local:WSON-12-1EP_4x4mm_P0.5mm_EP2.6x3mmU2, U3, U4, U5, U6, U7, U8, U9
8TestPointTestPoint:TestPoint_Pad_D1.0mmTP2, TP4, TP6, TP8, TP10, TP12, TP14, TP16
45kResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_HorizontalR29, R34, R35, R36
4MountingHole_3.2mm_M3MountingHole:MountingHole_3.2mm_M3M3_H1, M3_H2, M3_H3, M3_H4
4PolyfuseResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_HorizontalF1, F2, F3, F4
4SolderJumper_2_OpenJumper:SolderJumper-2_P1.3mm_Open_RoundedPad1.0x1.5mmJP24, JP25, JP26, JP27
21uCapacitor_SMD:C_0805_2012MetricC37, C38
10.1uCapacitor_SMD:C_0603_1608MetricC39_2
110nCapacitor_THT:C_Disc_D7.5mm_W2.5mm_P5.00mmC44
11MResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_HorizontalR33
11N1004Diode_THT:D_DO-41_SOD81_P10.16mm_HorizontalD3
1220Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_HorizontalR32
13V3_A_TPTestPoint:TestPoint_Pad_D1.0mmTP1
15v_TPTestPoint:TestPoint_Pad_D1.0mmTP3
1DDiode_THT:D_DO-41_SOD81_P10.16mm_HorizontalD2
1GND_TPTestPoint:TestPoint_Pad_D1.0mmTP5
1HV264Package_SO:TSSOP-24_4.4x7.8mm_P0.65mmU10
1J_3V3_EXTConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ23
1J_DA_CSMConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ19
1J_DA_MOSIConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ21
1J_DB_SCLKConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ20
1J_HVConnector_PinHeader_2.54mm:PinHeader_1x24_P2.54mm_VerticalJ6
1J_HVAConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ3
1J_HVBConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ4
1J_HVCConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ5
1J_HV_OUTConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ22
1J_MPUConnector_PinSocket_2.54mm:PinSocket_1x08_P2.54mm_VerticalJ7
1Jumper_2_BridgedConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJP23
1LEDLED_THT:LED_D5.0mmD1
1Levitas3_Chip_40Pad_Wirebondlevitas_v3_footprint:Levitas3_Chip_40Pad_WirebondU1
1MAX5715Package_SO:TSSOP-14_4.4x5mm_P0.65mmU12
1Q025-5Clevitas_hv:Q025-5CU13
1RPI_LConnector_PinSocket_2.54mm:PinSocket_1x20_P2.54mm_VerticalJ1
1RPI_RConnector_PinSocket_2.54mm:PinSocket_1x20_P2.54mm_VerticalJ2
1TLV75533PDRVRTLV755:DRV0006AU11

More from biancanev/levitas_pcb

4
  • 2 layers193 × 83.8 mmLevitas, the printed circuit board in 3D

    Levitas

    biancanev/levitas_pcb

    PCB files for LeviTAS board

    68 parts
  • 2 layers50.8 × 50.8 mmAdapter pcb, the printed circuit board in 3D

    Adapter pcb

    biancanev/levitas_pcb

    PCB files for LeviTAS board

    11 parts
  • 2 layers50.8 × 50.8 mmLevitas daughter.v2, the printed circuit board in 3D

    Levitas daughter.v2

    biancanev/levitas_pcb

    PCB files for LeviTAS board

    8 parts

Similar boards

  • 4 layers70 × 70 mmAi camera, the printed circuit board in 3D

    Ai camera

    maxlab-io/tokay-lite-pcb

    Tokay AI Camera - ESP32 camera development board

    161 parts130CERN-OHL-P-2.0
  • 4 layers100 × 75 mmEPC2304, the printed circuit board in 3D

    EPC2304

    kaminaris/GigaESC

    161 parts47
  • 4 layers135.2 × 46.8 mmGd power supply board pcb, the printed circuit board in 3D

    Gd power supply board pcb

    baldengineer/Mega-IIe

    Using the Mega II from a IIgs to make a Apple IIe compatible computer: The Mega IIe!

    161 parts33MIT
  • 4 layers143 × 74 mmKitspace lpa96, the printed circuit board in 3D

    Kitspace lpa96

    PCBench/PCBench

    resolution = [0.5, 0.5] pcbfolder = '../PCBs/' pcbnames = ["1Bitsy1bitsy"] iters = 30 env = PCBRoutingEnv(resolution=resolution, pcbfolder=pcbfolder, pcbnames=pcbnames) obs, info = env.reset() for in range(iters): act =…

    161 parts21MIT
  • 4 layers73 × 88 mmFpga test kintex676-artix484, the printed circuit board in 3D

    Fpga test kintex676-artix484

    azonenberg/misc-devboards

    Miscellaneous prototype hardware that wasn't major enough to warrant a dedicated repo

    161 parts17BSD-3-Clause
  • 4 layers100 × 100 mmPi TX 35W PA, the printed circuit board in 3D

    Pi TX 35W PA

    M0LTE/pi-transceiver

    An attempt to build a complete ham radio transceiver around a Raspberry Pi

    161 parts15
  • 4 layers140 × 100 mmGpsdo, the printed circuit board in 3D

    Gpsdo

    dpiegdon/dpsgo

    David's Pretty Satisfactory Gps-disciplined Oscillator

    161 parts10
  • 4 layers154.9 × 128.4 mmDaisy hardware v1, the printed circuit board in 3D

    Daisy hardware v1

    rafkhan/lowstepper

    Dual phase manipulation low frequency oscillator by Okay Synthesizer.

    161 parts9

Questions

How big is the Levitas v2 PCB?

It measures 127 × 104.1 mm and has 4 copper layers, 1.6 mm thick.

What parts does the Levitas v2 use?

161 parts. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Levitas v2 KiCad files?

From the biancanev/levitas_pcb repository on GitHub, at the commit this page was made from: the board is pcb/levitas_v2/levitas_v2.kicad_pcb and its schematic pcb/adapter_pcb/adapter_pcb.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Levitas v2 design in my own project?

Its repository states no licence, so its author keeps all rights: ask biancanev before reusing the design.