Skip to the content
4 layers52 × 25 mmFlying byte v1, the printed circuit board in 3D

Here: - -n myenv specifies the environment name - python=3.10 installs a specific Python version

Size
52 × 25 mm
Copper layers
4
Thickness
1.58 mm
Parts
52
Nets
57
Pads
203
Tracks, vias
228, 155
Pours
7
Routed
Yes
KiCad
KiCad 7 (file 20221018)
Created
17 Oct 2024
Updated
30 May 2026

Overview

Flying byte v1 is an open-source printed circuit board by PanBabinicz, from the PanBabinicz/ghost-feather repository on GitHub. It is a 4-layer board of 52 × 25 mm with 52 parts on 57 nets, routed with 228 tracks and 155 vias.

It is built around the STM32WB55CEU6, DLF162500LT-5028A1 and MIC5365-3.3YD5-TR, with the USBLC6-2SC6, RNCF0402BKE220R and RNCF0402BKE5K10 among its other parts. Its parts include 19 capacitors, 9 resistors, 4 connectors, 3 ICs and 3 inductors. It belongs with the STM32 boards of this library.

Main components

12

README

README.md

Ghost Feather

GitHub tag (with filter)

[!NOTE] Please bear in mind that the workspace was primarily created for enjoyment and educational endeavors.

The MIT License (MIT)

Copyright (c) 2011-2024 The Bootstrap Authors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Compilation process

[!NOTE] The current compilation process will be changed

console
~ arm-none-eabi-gcc -g -c -mfloat-abi=hard -mfpu=fpv4-sp-d16 -mcpu=cortex-m7 -mthumb \
                          -I memory -I bootloader \
                          startup/stm32f722xx/stm32722xx_startup.c -o build/stm32f722xx_startup.o
console
~ arm-none-eabi-gcc -g -c -mfloat-abi=hard -mfpu=fpv4-sp-d16 -mcpu=cortex-m7 -mthumb \
                          -I libopencm3/include -I memory -DSTM32F7 \
                          bootloader/stm32f722xx_first_bootloader.c -o build/stm32f722xx_first_bootloader.o
console
~ arm-none-eabi-as -g vectortable/stm32f722xx/stm32f722xx_vectortable.S -o build/stm32f722xx_vectortable.o
console
~ arm-none-eabi-gcc -g -nostartfiles -nostdlib -mfloat-abi=hard -mfpu=fpv4-sp-d16 -mcpu=cortex-m7 -mthumb \
                       build/stm32f722xx_first_bootloader.o build/stm32f722xx_startup.o build/stm32f722xx_vectortable.o -o build/stm32f722xx_first_bootloader.elf \
                       -T linkerscript/stm32f722xx/stm32f722xx_bootloader.ld -L linkerscript/stm32f722xx -L libopencm3/lib -lopencm3_stm32f7

CMake generators

Unix Makefiles

console
~ cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=arm-none-eabi-toolchain.cmake
~ cd build
~ cmake --build . --config Debug

Ninja Multi-Config

console
~ cmake -G "Ninja Multi-Config" -S . -B build -DCMAKE_TOOLCHAIN_FILE=arm-none-eabi-toolchain.cmake
~ cd build
~ cmake --build . --config Debug

CMake Presets

console
~ cmake --preset list
~ cmake --preset <build-type>

Build shell script

console
~ ./build.sh <build-type>

How to program

For now, CMake generates two elf files. Each of these files needs to be uploaded to the device.

Newlib

To use newlib with libopencm3 it is necessary to recomplie the libc to be able to use hard floating point numbers which use on-chip FPU. The second option is to use soft floating point numbers but the speed will be slower.

Marco Paland printf implementation

The Marco Paland printf implementation is a lightweight, standalone alternative designed specifically to address these limitations. This implementation offers a small memory footprint, portability, and independence from the full C standard library. It is widely used in embedded projects where developers require formatted output but cannot afford the code size and dependencies of a complete libc implementation.

DFU script

Description

The script enables firmware update over USART. It allows users to upload binary firmware files to microcontroller-based devices with minimal effort. The script handles communication setup, data formatting, and transmission to ensure reliable updates.

Usage

console
~ python3 dfu_usart.py <binary> <port> <baudrate>
  • <binary>: The firmware to be uploaded.
  • <port>: The name of the serial port connected to the target device (e.g., /dev/tty.usbmodem).
  • <baudrate>: The communication speed in bits per second (e.g., 9600, 115200).

SOCAT tool

Usage

console
~ socat -d -d PTY,raw,echo=0 PTY,raw,echo=0
~ stty -f /dev/ttysxxx 115200
~ screen /dev/ttysxxx 115200

Unit tests

Description

The unit tests verify the functionality, reliability, and error handling of embedded system controllers using Google Test (GTest).

They cover various scenarios, including:

  • Core functionality validation.
  • Boundary condition testing.
  • Error handling and fault tolerance.
  • Performance and efficiency checks.

Usage

console
~ cmake -G "Ninja" -S . -B build -DPROJECT_ROOT_DIR=$(pwd)/../..
~ cmake --build build
~ cd build && ctest

Conda

What is Conda?

Conda is an open-source package manager and environment manager used for installing, running, and updating software packages and their dependencies. It is widely used in data science, machine learning, and scientific computing because it simplifies managing complex software environments.

Unlike pip, which only installs Python packages, Conda can manage packages written in multiple languages (such as Python, R, and C libraries) and handles system-level dependencies as well.

Conda is distributed with platforms such as:

  • Anaconda – a large distribution that includes many preinstalled scientific packages.
  • Miniconda – a lightweight version that installs only Conda and Python.

Why Use Conda?

Conda helps solve common development problems:

  • Dependency management – automatically installs required libraries.
  • Environment isolation – different projects can use different package versions.
  • Cross-language support – works with Python, R, and other tools.
  • Reproducibility – environments can be exported and recreated.

Example: one project may require Python 3.9 while another requires Python 3.11. Conda allows both to coexist without conflicts.

Creating an Environment

A Conda environment is an isolated workspace containing its own Python version and installed packages.

Create a new environment:

bash
conda create -n myenv python=3.10

Here:

  • -n myenv specifies the environment name
  • python=3.10 installs a specific Python version

Activating an Environment

Before using an environment, it must be activated.

bash
conda activate myenv

After activation, all installed packages and Python commands will come from this environment.

To deactivate:

bash
conda deactivate

Installing Packages

Packages can be installed directly into the active environment.

bash
conda install numpy pandas matplotlib

Conda will automatically resolve and install required dependencies.

Listing Environments

To see all available environments:

bash
conda env list

or:

bash
conda info --envs

Removing an Environment

If an environment is no longer needed, it can be deleted:

bash
conda remove -n myenv --all

Exporting an Environment

To share or reproduce an environment:

bash
conda env export > environment.yml

This file can later be used to recreate the same environment.

Recreating an Environment

bash
conda env create -f environment.yml

This installs all packages and dependencies exactly as defined in the exported file.

EASTER EGG!

CBR 929 broke. We have to repair it. I will do todays job tomorrow.

Parts

52
QtyValueFootprintReferences
10100nCapacitor_SMD:C_0402_1005MetricC4, C5, C6, C7, C8, C9, C11, C12, C13, C19
5220RResistor_SMD:R_0402_1005MetricR1, R2, R3, R4, R9
54u7Capacitor_SMD:C_0603_1608MetricC1, C2, C3, C10, C14
4MountingHole_PadMountingHole:MountingHole_2.2mm_M2_PadH1, H2, H3, H4
35k1Resistor_SMD:R_0402_1005MetricR5, R6, R8
3FiducialFiducial:Fiducial_1mm_Mask2mmFM1, FM2, FM3
210pCapacitor_SMD:C_0402_1005MetricC17, C18
2LEDLED_SMD:LED_0402_1005MetricD1, D2
10Resistor_SMD:R_0402_1005MetricR7
10p3Capacitor_SMD:C_0402_1005MetricC16
10p8Capacitor_SMD:C_0402_1005MetricC15
110nInductor_SMD:L_0402_1005MetricL1
110uInductor_SMD:L_0805_2012MetricL2
12n7Inductor_SMD:L_0402_1005MetricL3
132MHzCrystal:Crystal_SMD_2016-4Pin_2.0x1.6mmX1
132kHz768Crystal:Crystal_SMD_2012-2Pin_2.0x1.2mmX2
1Conn_01x04Connector_Molex:Molex_PicoBlade_53048-0410_1x04_P1.25mm_HorizontalJ4
1Conn_ARM_SWD_TagConnect_TC2030Connector:Tag-Connect_TC2030-IDC-FP_2x03_P1.27mm_VerticalJ2
1Conn_CoaxialConnector_Coaxial:U.FL_Hirose_U.FL-R-SMT-1_VerticalJ1
1DLF162500LT-5028A1flying-byte-v1-pcb-footprints:DLF162500LT-5028A1FLT1
1LOGOicons:sabre-with-moustacheG***
1MIC5365-3.3YD5Package_TO_SOT_SMD:SOT-23-5U3
1STM32WB55CEU6Package_DFN_QFN:QFN-48-1EP_7x7mm_P0.5mm_EP5.6x5.6mmU1
1SW_PushButton_Switch_SMD:SW_SPST_CK_RS282G05A3SW1
1USBLC6-2SC6_MODPackage_TO_SOT_SMD:SOT-23-6U2
1USB_C_Receptacle_USB2.0Connector_USB:USB_C_Receptacle_GCT_USB4105-xx-A_16P_TopMnt_HorizontalJ3

More from PanBabinicz/ghost-feather

1
  • 4 layers106.6 × 106.7 mmGhost feather v1, the printed circuit board in 3D

    Ghost feather v1

    PanBabinicz/ghost-feather

    Here: - -n myenv specifies the environment name - python=3.10 installs a specific Python version

    97 parts

Similar boards

  • 4 layers117 × 77 mmProdDeck, the printed circuit board in 3D

    ProdDeck

    arsovskiteodor/A.ProdDeck

    Open-hardware macro pad (WIP): custom KiCad PCB with keys, encoders and a fader, plus firmware and a desktop configurator

    69 parts
  • 4 layers48 × 25 mmStm32mc, the printed circuit board in 3D

    Stm32mc

    justinfederico/STM32testPCB

    Custom STM32WB microcontroller to practice my PCB schematic and layout skills. Looking to get it printed soon! Bear in mind that this is an ameuter project, so there will probably be errors aplenty.

    51 parts
  • 4 layers55.5 × 32 mmSAFE ROOM, the printed circuit board in 3D

    SAFE ROOM

    dibreyjonatan/SAFE-ROOM

    SAFE ROOM est une dispositif électronique qui permet de connaitre en temps réel, les conditions d'une pièce. A savoir la qualité d'air, la temperature, l'humidité, et la pression.

    52 partsGPL-3.0
  • 4 layers53.5 × 28.8 mmSTM32WB PCB2, the printed circuit board in 3D

    STM32WB PCB2

    NasserTaqi/STM32WB_Bluetooth_PCB

    This project is a PCB built around an STM32WB for RF Bluetooth connection.

    52 parts
  • 4 layers58 × 38 mmBlue Pedal, the printed circuit board in 3D

    Blue Pedal

    Arre-Jay/BlueWavePCB

    Untested bluetooth and IMU board with USB input

    80 parts3
  • 2 layers60 × 78 mmSTM32WB breakout board, the printed circuit board in 3D

    STM32WB breakout board

    pho3nix06/PCB_Design_project

    Repository for PCB designed by myself

    42 parts
  • 4 layers50 × 50 mmWatch wearable, the printed circuit board in 3D

    Watch wearable

    TENNLab-UTK/NWRIST

    Code and KiCAD PCB design for the NWRIST: Neuromorphic Wearable for Real-Time Intelligent Sensing Technology paper

    79 parts
  • 4 layers30 × 30 mmWearable imu, the printed circuit board in 3D

    Wearable imu

    davispe1/wearable-imu

    Node PCB — revision 1.0. 4-layer board (F.Cu, In1.Cu, In2.Cu, B.Cu).

    72 partsMIT

Questions

How big is the Flying byte v1 PCB?

It measures 52 × 25 mm and has 4 copper layers, 1.58 mm thick.

What parts does the Flying byte v1 use?

52 parts, built around the STM32WB55CEU6, DLF162500LT-5028A1, MIC5365-3.3YD5-TR and USBLC6-2SC6. 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 Flying byte v1 KiCad files?

From the PanBabinicz/ghost-feather repository on GitHub, at the commit this page was made from: the board is hardware/flying-byte-v1/flying-byte-v1.kicad_pcb and its schematic hardware/flying-byte-v1/flying-byte-v1.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Flying byte v1 design in my own project?

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