

Levitas v2
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.mdLeviTAS 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.

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
firmwarefolder, runmake buildto compile code andmake reloadto download and run (ormaketo 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
firmwarefolder 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
buildsubfolder, but note that "Configure CMake" must be run first. - "Configure CMake" will create a
buildsubfolder and prepare the compilation based on configuration information in theCMakeLists.txtfile. 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 CHANGECMakeLists.txtFOR 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
picotoolcommand 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 perCMakeLists.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).
- "Compile Project" will compile (only) the software and put the compiled executables in a
- 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 inCMakeLists.txtandstdio_init_all();to be called inmain.c(which they are).
Notable Firmware files
Inside the firmware folder:
CMakeLists.txtconfigures 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.cis 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, andsrc/pio_i2c.piotogether form a library that can run I2C communication via the Pico PIOs.src/main.cuses 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.txtto make them the main project file instead ofmain.c:src/test_fdc2112_i2c.ctests 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.ctests all four connected FDC2112 chips using the PIO library, and is almost identical to code insrc/main.c.src/test_max5715_spi.ctests the MAX5715 DAC and high voltage output, and is almost identical to code insrc/main.c.src/test_mpu6050_i2c.cdisplays data the MPU6050 accelerometer on the PCB motherboard using one of the hardware built-in I2C modules.
Other files:
Makefileis used only for compiling on Linux, not for VS Code.vscodeandpico_sdk_import.cmakeare used only for VS Code with the official Pico VS Code extension, not on Linux- the
buildsubfolder 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:
- 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)
- Put into BOOTSEL mode, use picotool to upload file
- 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.
- 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:
- https://www.raspberrypi.com/products/rp2350/
- (good details on RP2350 hardware/capabilities) https://datasheets.raspberrypi.com/rp2350/rp2350-datasheet.pdf
- https://datasheets.raspberrypi.com/rp2350/hardware-design-with-rp2350.pdf
- https://datasheets.raspberrypi.com/rp2350/rp2350-product-brief.pdf
Pico and Pico 2 dev boards (which are almost identical):
- https://datasheets.raspberrypi.com/pico/pico-datasheet.pdf
- (good software getting-started guide) https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf
Programming with C/C++:
- https://github.com/raspberrypi/pico-sdk
- (code examples) https://github.com/raspberrypi/pico-examples
- https://www.raspberrypi.com/documentation/microcontrollers/c_sdk.html
- https://www.raspberrypi.com/documentation/pico-sdk/index_doxygen.html
- (good software getting-started guide) https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf
- (very thorough reference) https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-c-sdk.pdf
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:
- Device to use UART or SWD debugging. Optional. We don't have one.
- https://www.raspberrypi.com/products/debug-probe/
- https://www.raspberrypi.com/documentation/microcontrollers/debug-probe.html
More pictures

Parts
161| Qty | Value | Footprint | References |
|---|---|---|---|
| 20 | SolderJumper_2_Bridged | Jumper:SolderJumper-2_P1.3mm_Bridged_RoundedPad1.0x1.5mm | JP1, JP2, JP3, JP4, JP5, JP10, JP11, JP12, JP13, JP14, JP15, JP16, JP17, JP18, JP20, JP22 +4 |
| 16 | 4.7k | Resistor_SMD:R_0603_1608Metric | R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16 |
| 12 | 100n | Capacitor_SMD:C_0603_1608Metric | C2, C5, C8, C11, C14, C17, C20, C23, C39, C40, C42, C46 |
| 12 | 10k | Resistor_SMD:R_1206_3216Metric | R17, R18, R19, R20, R21, R22, R23, R24, R25, R26, R27, R28 |
| 12 | 470p | Capacitor_SMD:C_0805_2012Metric | C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35, C36 |
| 11 | 4.7u | Capacitor_SMD:C_0805_2012Metric | C1, C4, C7, C10, C13, C16, C19, C22, C41, C43, C45 |
| 8 | 18u | Inductor_SMD:L_0603_1608Metric | L1, L2, L3, L4, L5, L6, L7, L8 |
| 8 | 33p | Capacitor_SMD:C_0603_1608Metric | C3, C6, C9, C12, C15, C18, C21, C24 |
| 8 | FDC2112 | levitas_local:WSON-12-1EP_4x4mm_P0.5mm_EP2.6x3mm | U2, U3, U4, U5, U6, U7, U8, U9 |
| 8 | TestPoint | TestPoint:TestPoint_Pad_D1.0mm | TP2, TP4, TP6, TP8, TP10, TP12, TP14, TP16 |
| 4 | 5k | Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_Horizontal | R29, R34, R35, R36 |
| 4 | MountingHole_3.2mm_M3 | MountingHole:MountingHole_3.2mm_M3 | M3_H1, M3_H2, M3_H3, M3_H4 |
| 4 | Polyfuse | Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_Horizontal | F1, F2, F3, F4 |
| 4 | SolderJumper_2_Open | Jumper:SolderJumper-2_P1.3mm_Open_RoundedPad1.0x1.5mm | JP24, JP25, JP26, JP27 |
| 2 | 1u | Capacitor_SMD:C_0805_2012Metric | C37, C38 |
| 1 | 0.1u | Capacitor_SMD:C_0603_1608Metric | C39_2 |
| 1 | 10n | Capacitor_THT:C_Disc_D7.5mm_W2.5mm_P5.00mm | C44 |
| 1 | 1M | Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_Horizontal | R33 |
| 1 | 1N1004 | Diode_THT:D_DO-41_SOD81_P10.16mm_Horizontal | D3 |
| 1 | 220 | Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_Horizontal | R32 |
| 1 | 3V3_A_TP | TestPoint:TestPoint_Pad_D1.0mm | TP1 |
| 1 | 5v_TP | TestPoint:TestPoint_Pad_D1.0mm | TP3 |
| 1 | D | Diode_THT:D_DO-41_SOD81_P10.16mm_Horizontal | D2 |
| 1 | GND_TP | TestPoint:TestPoint_Pad_D1.0mm | TP5 |
| 1 | HV264 | Package_SO:TSSOP-24_4.4x7.8mm_P0.65mm | U10 |
| 1 | J_3V3_EXT | Connector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_Vertical | J23 |
| 1 | J_DA_CSM | Connector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_Vertical | J19 |
| 1 | J_DA_MOSI | Connector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_Vertical | J21 |
| 1 | J_DB_SCLK | Connector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_Vertical | J20 |
| 1 | J_HV | Connector_PinHeader_2.54mm:PinHeader_1x24_P2.54mm_Vertical | J6 |
| 1 | J_HVA | Connector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_Vertical | J3 |
| 1 | J_HVB | Connector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_Vertical | J4 |
| 1 | J_HVC | Connector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_Vertical | J5 |
| 1 | J_HV_OUT | Connector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_Vertical | J22 |
| 1 | J_MPU | Connector_PinSocket_2.54mm:PinSocket_1x08_P2.54mm_Vertical | J7 |
| 1 | Jumper_2_Bridged | Connector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_Vertical | JP23 |
| 1 | LED | LED_THT:LED_D5.0mm | D1 |
| 1 | Levitas3_Chip_40Pad_Wirebond | levitas_v3_footprint:Levitas3_Chip_40Pad_Wirebond | U1 |
| 1 | MAX5715 | Package_SO:TSSOP-14_4.4x5mm_P0.65mm | U12 |
| 1 | Q025-5C | levitas_hv:Q025-5C | U13 |
| 1 | RPI_L | Connector_PinSocket_2.54mm:PinSocket_1x20_P2.54mm_Vertical | J1 |
| 1 | RPI_R | Connector_PinSocket_2.54mm:PinSocket_1x20_P2.54mm_Vertical | J2 |
| 1 | TLV75533PDRVR | TLV755:DRV0006A | U11 |
More from biancanev/levitas_pcb
4- 2 layers50.8 × 50.8 mm

- 2 layers193 × 83.8 mm

- 2 layers50.8 × 50.8 mm

- 2 layers50.8 × 50.8 mm

Similar boards
- 4 layers70 × 70 mm

Ai camera
maxlab-io/tokay-lite-pcb
Tokay AI Camera - ESP32 camera development board
161 parts130CERN-OHL-P-2.0 - 4 layers100 × 75 mm

- 4 layers135.2 × 46.8 mm

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 mm

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 mm

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 mm

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 mm

- 4 layers154.9 × 128.4 mm

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.