

Imu pi5 header
Open-source telemetry platform for stage rally Hardware · Data Logger · Visualization
- Size
- 65 × 37 mm
- Copper layers
- 2
- Thickness
- 1.6 mm
- Parts
- 8
- Nets
- 42
- Pads
- 66
- Tracks, vias
- 36, 0
- Pours
- 1
- Routed
- Yes
- KiCad
- KiCad 9.0 (file 20241229)
- Created
- 15 Jul 2026
- Updated
- 15 Jul 2026
Overview
Imu pi5 header is an open-source printed circuit board by sharadkj, from the sharadkj/SageStack repository on GitHub, published under the MIT licence. It is a 2-layer board of 65 × 37 mm with 8 parts on 42 nets, routed with 36 tracks and 0 vias.
Its parts include 2 resistors, 2 diodes, 1 IC, 1 connector and 1 switch. It belongs with the sensors and measurement boards of this library.
README
README.md
SageStack
Open-source telemetry platform for stage rally
Hardware · Data Logger · Visualization
Quick Start · Hardware · Data Logger · SageCompare · Contributing
What is SageStack?
SageStack is an end-to-end telemetry system purpose-built for stage rally. It combines a custom sensor board, a Raspberry Pi-based data logger, and a web application to capture, analyze, and compare driving data in real-time and after the fact.
Why SageStack?
Professional motorsport data acquisition systems cost thousands of dollars and are closed-source. They are also primarily designed for circuit racing where the lap-over-lap consistency is core to the insights they provide. SageStack provides an accessible, hackable alternative that:
- Costs under $100 in total hardware (Raspberry Pi 5 + custom hat + GPS module)
- Logs 12 channels of data at ~7.7 Hz including GPS position, speed, full IMU orientation, and 3-axis acceleration
- Outputs simple CSV files — no proprietary formats, no vendor lock-in
- Includes a visualization tool for comparing runs, analyzing cornering, and reviewing performance
- Is completely open source — from KiCAD PCB design files to every line of Python and JavaScript
📦 Repository Structure
SageStack/
├── imu_pi5_header/ # KiCAD PCB design files for the sensor hat
│ ├── imu_pi5_header.kicad_sch # Schematic
│ ├── imu_pi5_header.kicad_pcb # PCB layout
│ ├── imu_pi5_header.kicad_pro # KiCAD project file
│ ├── imu_pi5_hat/ # Gerber manufacturing files (zipped)
│ ├── imu_pi5_led_hat/ # Alternate LED hat design
│ ├── libraries/ # Custom footprints & 3D models
│ ├── DRC.rpt # Design Rule Check report
│ └── imu_pi5_hat.zip # Ready-to-order Gerber package
│
├── rally-logger/ # Python data acquisition software
│ ├── rally_logger.py # Core sensor polling & CSV writer
│ ├── watcher.py # GPIO button monitor (start/stop)
│ └── rally_log_*.csv # Sample data from real test sessions
│
├── SageCompare/ # Web-based data visualization & comparison
│ ├── index.html # Entry point
│ ├── src/ # Application source code
│ │ ├── main.js # Core application logic
│ │ └── style.css # Styles
│ ├── package.json # Dependencies (Vite, Leaflet, Chart.js)
│ └── vite.config.js # Build configuration
│
├── logo_vectorized.svg # Sage Racing brand logo
└── README.md # ← You are hereHardware — Sensor Hat
The heart of SageStack is a custom PCB hat designed to sit directly on a Raspberry Pi 5's 40-pin GPIO header. All design files are in the imu_pi5_header/ directory and can be opened with KiCAD (v8+).
What's on the board
| Component | Description |
|---|---|
| BNO055 IMU | 9-axis Inertial Measurement Unit (accelerometer, gyroscope, magnetometer) with on-chip sensor fusion. Communicates over I²C. Provides roll, pitch, yaw, and linear acceleration. |
| GPS Module (external) | Not on the PCB itself — the GPS module connects to the Pi via USB (e.g., a USB GPS dongle appearing as /dev/ttyUSB0). This keeps the hat design simple and allows flexibility in GPS hardware choice. |
| Start/Stop Button | 6mm tactile momentary push button on GPIO 17 (BCM17, pin 11). Press to start a logging session, press again to stop. Active-low with internal pull-up. |
| Status LEDs | Two 5mm through-hole LEDs: Green on GPIO 27 (pin 13) — logging active. Red on GPIO 22 (pin 15) — standby/idle. Each driven through a current-limiting resistor. |
| 40-pin Pi Header | Standard Raspberry Pi 5 GPIO header for direct board-to-board mounting. |
Design files
| File | Purpose |
|---|---|
imu_pi5_header.kicad_sch | Full schematic — component connections, power rails, I²C bus, UART GPS, GPIO button/LED |
imu_pi5_header.kicad_pcb | PCB layout — 2-layer board with component placement and routing |
imu_pi5_header.kicad_pro | KiCAD project configuration |
imu_pi5_hat.zip | Ready-to-order Gerber files — upload directly to PCB fab houses (JLCPCB, PCBWay, OSH Park, etc.) |
DRC.rpt | Design Rule Check report showing board passes validation |
libraries/ | Custom component footprints and 3D models used in the design |
imu_pi5_hat/ | Extracted Gerber/drill files for manufacturing |
imu_pi5_led_hat/ | Alternate version of the hat design with a different LED layout |
Ordering PCBs
- Download
imu_pi5_hat.zipfrom theimu_pi5_header/directory - Go to your preferred PCB manufacturer (e.g., JLCPCB, PCBWay, OSH Park)
- Upload the zip file — most fabs auto-detect Gerber layers
- Select quantity, color, and surface finish (HASL is fine for prototyping)
- Typical cost: ~$5–15 for 5 boards (excluding shipping)
Bill of Materials (BOM)
| Part | Quantity | Notes |
|---|---|---|
| Raspberry Pi 5 | 1 | Any RAM variant works |
| BNO055 breakout board | 1 | Adafruit BNO055 or equivalent I²C module |
| GPS module | 1 | UART-based (e.g., Adafruit Ultimate GPS, u-blox NEO series) |
| Custom PCB (this project) | 1 | Order from Gerber files above |
| USB GPS dongle | 1 | Any USB GPS (e.g., VK-162, u-blox 7/8 based). Appears as /dev/ttyUSB0. |
| Momentary push button | 1 | 6mm tactile through-hole. Panel mount recommended for in-car use. |
| LEDs | 2 | 5mm through-hole — 1× green, 1× red — with appropriate resistors |
| 2×20 pin header | 1 | For Pi GPIO connection (or use stacking header for access to pins) |
| Resistors | 2 | LED current limiting (220Ω–1kΩ typical), axial through-hole |
Tip: A 2×20 stacking header is recommended instead of a standard pin header. This allows you to mount additional boards or access GPIO pins above the hat.
PCB Notes: The board is a standard 2-layer Raspberry Pi HAT form factor (~65mm × 37mm) with 4 mounting holes. All components are through-hole for easy hand-soldering — no SMD skills required. The back copper layer includes a ground fill zone.
Rally Logger
The data acquisition software lives in rally-logger/ and consists of two Python scripts that run on the Raspberry Pi.
Architecture
┌─────────────┐ GPIO ┌──────────────┐
│ Button on │───────────────▶│ watcher.py │
│ sensor hat │ │ (monitors │
└─────────────┘ │ button) │
└──────┬───────┘
│ subprocess
▼
┌──────────────┐
│rally_logger.py│
┌──────────────────│ (main loop) │──────────────────┐
│ └──────────────┘ │
▼ ▼
┌───────────────┐ ┌──────────────────┐
│ BNO055 IMU │ │ GPS Module │
│ (I²C bus) │ │ (UART serial) │
│ │ │ │
│ • Roll/Pitch │ │ • Lat/Lon │
│ • Yaw │ │ • Altitude │
│ • Accel X/Y/Z │ │ • Speed (km/h) │
│ • Calib stat │ │ • Fix status │
└───────────────┘ └──────────────────┘
│ │
└──────────────────┬──────────────────────────────────┘
▼watcher.py — Button Monitor
This script runs continuously on boot and watches for button presses on the GPIO pin connected to the start/stop button on the sensor hat.
How it works:
- Uses the
gpiozerolibrary for clean GPIO access (Button and LED classes) - Configures the button on GPIO 17 with internal pull-up (active low to ground)
- Red LED on GPIO 22 turns ON at startup to indicate standby
- On first press: spawns
rally_logger.pyas a child process viasubprocess.Popen()- Red LED OFF, Green LED (GPIO 27) ON → logging in progress
- On second press: sends
terminate()signal to stop the logger- Green LED blinks rapidly during file transfer
- Auto-copies the latest CSV to
/mnt/usb_drive(if a USB drive is mounted) - Returns to Red ON, Green OFF (standby)
- Stays alive between button events using
signal.pause()— fully event-driven
GPIO pin map:
| GPIO (BCM) | Pi Header Pin | Function |
|---|---|---|
| GPIO 17 | Pin 11 | Push button input (to GND) |
| GPIO 27 | Pin 13 | Green LED — logging active |
| GPIO 22 | Pin 15 | Red LED — standby / idle |
rally_logger.py — Data Acquisition
This is the core data collection script. It initializes both sensors and polls them in a tight loop, writing each sample to a CSV file.
How it works:
- Initializes the BNO055 IMU over I²C (SDA/SCL) using the
adafruit_bno055library - Initializes the GPS module over USB serial (
/dev/ttyUSB0at 9600 baud) usingadafruit_gps - Configures the GPS for 10 Hz updates and enables RMC, VTG, and GGA NMEA sentences
- Creates a new CSV file with a Unix timestamp in the filename (e.g.,
rally_log_1772928049.csv) - Enters a polling loop with a
time.sleep(0.1)target, achieving approximately 7.7 Hz (~130ms per sample including I²C overhead):- Reads Euler angles (yaw, roll, pitch) from the BNO055
- Reads linear acceleration (X, Y, Z) from the BNO055
- Reads calibration status from the BNO055
- Reads GPS fix data (lat, lon, alt, speed) when available
- Writes all values as a single CSV row
- Calls
f.flush()on every iteration to protect against data loss on power cut
- Continues until terminated by
watcher.py(SIGTERM) or a keyboard interrupt - Gracefully closes the CSV file on exit
CSV Data Format
Each log file contains the following columns:
| Column | Unit | Description |
|---|---|---|
timestamp | Unix epoch (seconds) | High-resolution timestamp with microsecond precision |
lat | Decimal degrees | GPS latitude (WGS84). Empty until first GPS fix. |
lon | Decimal degrees | GPS longitude (WGS84). Empty until first GPS fix. |
alt | Meters | GPS altitude above mean sea level |
speed_kmh | km/h | GPS-derived ground speed |
roll | Degrees | Vehicle roll angle (left/right lean) |
pitch | Degrees | Vehicle pitch angle (nose up/down) |
yaw | Degrees | Vehicle heading (0–360°, magnetic north) |
accel_x | m/s² | Lateral acceleration (positive = right) |
accel_y | m/s² | Longitudinal acceleration (positive = forward) |
accel_z | m/s² | Vertical acceleration (~9.8 m/s² at rest) |
calib_stat | 0–3 | BNO055 system calibration quality (3 = fully calibrated) |
Example data:
timestamp,lat,lon,alt,speed_kmh,roll,pitch,yaw,accel_x,accel_y,accel_z,calib_stat
1772928049.541173,,,,0.0,0.0,0.0,0.0,-0.15,-1.48,9.38,0
1772928050.061291,29.998476,-97.55066,139.7,0.018,-0.6875,8.8125,359.9375,-0.16,-1.45,9.38,0Note: GPS fields may be empty for the first few rows while the module acquires a satellite fix. The IMU data is available immediately.
Python Dependencies
adafruit-circuitpython-bno055 # BNO055 IMU driver (I²C)
adafruit-circuitpython-gps # GPS NMEA parser
adafruit-blinka # CircuitPython compatibility layer for Raspberry Pi
# (provides board, busio modules)
pyserial # Serial communication for USB GPS
gpiozero # GPIO access for button & LEDs (used by watcher.py)Note:
boardandbusioare provided byadafruit-blinka.gpiozerocomes pre-installed on Raspberry Pi OS but may need to be installed on minimal images.
Setting Up the Logger
- Flash Raspberry Pi OS (64-bit Lite recommended) onto a microSD card
- Enable I²C and Serial in
raspi-config:bash sudo raspi-config # Interface Options → I2C → Enable # Interface Options → Serial Port → Disable login shell, Enable serial hardware - Install Python dependencies:
bash sudo apt update && sudo apt install -y python3-pip pip3 install adafruit-circuitpython-bno055 adafruit-circuitpython-gps adafruit-blinka pyserial gpiozero - Connect the hardware:
- Mount the sensor hat onto the Pi's 40-pin GPIO header
- Plug the USB GPS dongle into any USB port on the Pi
- Verify I²C connection:
sudo i2cdetect -y 1(should show the BNO055 at address0x28or0x29) - Verify GPS serial:
ls /dev/ttyUSB0(should exist when GPS is plugged in)
- Test the logger manually:
bash python3 rally_logger.py # Press Ctrl+C to stop — check for a new rally_log_*.csv file - Run the watcher on boot (recommended):
bash # Add to /etc/rc.local or create a systemd service: sudo nano /etc/systemd/system/sage-watcher.serviceini [Unit] Description=SageStack Rally Logger Watcher After=multi-user.target [Service] Type=simple ExecStart=/usr/bin/python3 /home/pi/SageStack/rally-logger/watcher.py WorkingDirectory=/home/pi/SageStack/rally-logger Restart=always User=root [Install] WantedBy=multi-user.targetbash sudo systemctl enable sage-watcher sudo systemctl start sage-watcher
In-Car Operation
- Power on the Raspberry Pi (USB-C power bank or vehicle power with a regulator)
- Wait for the red LED to turn on — system is in standby
- Press the button to start logging — red LED turns off, green LED turns on
- Drive the stage
- Press the button again to stop logging — green LED blinks during file save
- If a USB drive is mounted at
/mnt/usb_drive, the CSV is automatically copied to it - Otherwise, transfer via SCP, remove the SD card, or plug in a USB drive manually
- Open the CSV in SageCompare for analysis
SageCompare Web App
SageCompare is a browser-based data visualization and run comparison tool built with modern JavaScript. It lives in the SageCompare/ directory.
Features
SageCompare is a run comparison tool — upload two CSV files from different runs and analyze performance differences side-by-side. The app features 5 specialized analysis views accessible via tabs:
1. Dashboard
- Delta metric cards: duration, max speed, distance, peak G-sum
- Side-by-side GPS track maps with speed-colored polylines (green → amber → red)
- 8 overlaid time-series charts: speed, G-sum, longitudinal/lateral/vertical acceleration, yaw rate, pitch & roll rates
2. Threshold Braking
- Automatic braking zone detection with highlighted plateau regions
- Per-zone comparison table: peak/mean deceleration, consistency (σ), lateral wander
- Weight transfer analysis via pitch rate and vertical acceleration charts
- Directional stability analysis during braking
3. Slalom
- Zero-crossing detection and rhythm period analysis
- Lateral acceleration pattern visualization (filled area charts)
- Longitudinal pulsing coordination with yaw rate peak markers
- Pitch rate / weight transfer overlay
4. Dynamic Slalom
- Friction circle diagrams — scatter plots of lateral vs. longitudinal G with reference circle
- Efficiency metrics table with letter grades: G-sum mean/std, transition time, coasting %, diagonal ratio, quadrant balance
- G-sum over time and pitch-roll coupling charts
- Estimated slip angle visualization
5. Stage Driving
- GPS track split into sectors with per-sector timing
- Sector comparison table: distance, time, avg/max speed, peak braking, limit driving %, G-sum
- Distance-aligned speed & G-sum overlay chart
- Grouped bar charts for sector time and limit driving comparison
Additional Capabilities
- Drag-and-drop CSV import — dual upload zones (Run A / Run B) with color coding
- Auto cool-down trimming — detects and removes idle segments using rolling G-sum thresholds
- Run alignment — synchronizes runs to the first significant acceleration event
- Configurable low-pass filter — 1–10 Hz Butterworth filter slider to smooth sensor noise
- Keyboard navigation — arrow keys cycle through analysis tabs
- Dark theme with glassmorphism effects, the Sage Racing brand palette, and responsive layout
Tech Stack
| Technology | Purpose |
|---|---|
| Vite | Fast dev server and build tool |
| Leaflet | Interactive GPS track maps with CartoDB dark basemap tiles |
| Chart.js + chartjs-plugin-zoom | Time-series and scatter plot visualization with zoom/pan |
| Vanilla JavaScript (ES Modules) | No framework overhead — pure DOM manipulation |
| CSS3 | Dark theme with glassmorphism, custom properties, responsive grid |
| Google Fonts | Inter (UI) + JetBrains Mono (data display) |
Running SageCompare Locally
# Navigate to the SageCompare directory
cd SageCompare
# Install dependencies
npm install
# Start the dev server
npm run devThe app will open at http://localhost:5173 (or the next available port).
Application Architecture
SageCompare/
├── index.html # Shell: header, tab nav, upload zones, view containers
├── src/
│ ├── main.js # Entry point: upload handling, CSV parsing,
│ │ # cool-down trimming, alignment, filter control
│ ├── views/
│ │ ├── compare-dashboard.js # Dashboard: maps + 8 overlaid charts
│ │ ├── compare-braking.js # Threshold braking analysis
│ │ ├── compare-slalom.js # Slalom rhythm analysis
│ │ ├── compare-dynamic.js # Dynamic slalom / friction circles
│ │ └── compare-stage.js # Stage driving / sector analysis
│ └── styles/
│ └── index.css # Complete design system (~1000 lines)
├── package.json # Dependencies
└── vite.config.js # @core alias to shared core libraryThe app uses a shared core library (aliased as @core in Vite config) that provides reusable modules for CSV parsing, signal filtering, chart creation, and rally-specific analysis algorithms:
parser.js— CSV parsing and raw data processingfilter.js— Butterworth low-pass filter with configurable cutoffcharts.js— Chart.js wrapper utilities and color paletteanalysis.js— Braking zone detection, slalom rhythm analysis, friction circle calculation, sector splitting
Using SageCompare
- Upload data: Drag and drop two
rally_log_*.csvfiles — one into the Run A (cyan) zone and one into Run B (pink) - Click "Compare Runs": The app trims cool-down segments, aligns the runs to the first acceleration event, and applies the low-pass filter
- Explore the Dashboard: GPS tracks on maps, overlaid speed/acceleration charts, and summary metrics with delta indicators
- Dive into analysis tabs: Use the tab bar or arrow keys to switch between Threshold Braking, Slalom, Dynamic Slalom, and Stage Driving views
- Adjust the filter: Use the LP filter slider (1–10 Hz) in the header to smooth noisy sensor data
- Start a new comparison: Click "New Comparison" to reset and upload different runs
Building for Production
cd SageCompare
npm run build
# Output in dist/ — deploy to any static hosting (Netlify, Vercel, GitHub Pages, etc.)Quick Start
What You Need
| Category | Items |
|---|---|
| Hardware | Raspberry Pi 5, BNO055 IMU breakout (Adafruit 2472), USB GPS dongle, custom PCB (or breadboard prototype), 6mm button, 2× LEDs + resistors, USB-C power source |
| Software (Pi) | Raspberry Pi OS (64-bit), Python 3.9+, I²C enabled |
| Software (Desktop) | Node.js 18+, npm, a modern web browser (Chrome/Firefox/Edge) |
| Optional | KiCAD 8+ (only if modifying the PCB design) |
Step-by-Step
-
Build the hardware
- Order PCBs from the included Gerber files (or prototype on a breadboard)
- Solder components and mount onto the Raspberry Pi 5
- Connect the GPS module
-
Set up the Raspberry Pi
bash # Enable interfaces sudo raspi-config # Enable I2C and Serial # Install dependencies pip3 install adafruit-circuitpython-bno055 adafruit-circuitpython-gps adafruit-blinka pyserial gpiozero # Clone the repo git clone https://github.com/YOUR_ORG/SageStack.git cd SageStack/rally-logger # Test the logger python3 rally_logger.py -
Collect data
- Start
watcher.py(or set it up as a systemd service) - Press the button to begin logging
- Drive your stage
- Press the button to stop
- Start
-
Analyze your data
bash cd SageStack/SageCompare npm install npm run dev- Open the browser and drag in your CSV file
Project Status
SageStack is an active work in progress. Here's what's current:
| Component | Status | Notes |
|---|---|---|
| Sensor Hat PCB | ✅ Tested | v1 validated in real vehicle testing. Gerbers ready to order. |
| Rally Logger | ✅ Tested | Actively collecting data. Sample logs from real sessions included. |
| SageCompare | 🔨 In Development | Core visualization working. Comparison features being expanded. |
| Documentation | 📝 In Progress | This README. More detailed guides coming. |
Known Limitations
- GPS cold start: The GPS module can take 30–60 seconds to acquire a fix after power-on. The first few rows of data will have empty GPS fields.
- IMU calibration: The BNO055 requires calibration after each power cycle. Move the sensor in a figure-eight pattern for magnetometer calibration. The
calib_statcolumn shows calibration quality (0 = uncalibrated, 3 = fully calibrated). - Sample rate: The current ~7.7 Hz rate is sufficient for rally analysis but may be increased in future versions with optimized I²C reads or alternate IMU hardware.
- No real-time telemetry (yet): Data is currently logged to SD card and analyzed post-session. Live streaming is on the roadmap.
Roadmap
- Live telemetry dashboard (WebSocket streaming from Pi)
- Automatic run detection (start/stop on motion)
- Lap/split timing with geo-fenced sectors
- Co-driver pace note integration
- Mobile app companion
- OBD-II integration for engine/vehicle data
- Cloud data storage and sharing
- Advanced analytics (racing line optimization, braking point analysis)
Contributing
SageStack is built for the rally community, and contributions are welcome! Whether you're a hardware hacker, Python developer, web developer, or rally driver with feedback — there's a place for you.
Ways to Contribute
- Hardware: Improve the PCB design, add new sensor support, optimize the layout
- Software: Enhance the data logger, add new sensor drivers, improve reliability
- Web: Build new SageCompare features, improve the UI, add analytics
- Data: Collect and share rally log data to help improve the platform
- Documentation: Write guides, tutorials, and how-tos
- Testing: Take it to the track and report bugs, edge cases, and ideas
Getting Started as a Contributor
- Fork the repo and clone your fork
- Pick a component to work on (hardware, logger, or web app)
- Set up your dev environment following the instructions above
- Make your changes on a feature branch
- Open a Pull Request with a clear description of what you changed and why
Partners & Collaborators
We're actively looking for:
- Rally schools interested in using SageStack for student feedback
- Racing teams willing to test and provide real-world data
- Hardware sponsors to help reduce prototyping costs
- Developers passionate about motorsport technology
If you'd like to partner with us, please reach out (sharad.k.jones@gmail.com)!
License
License information to be determined. Please check back or contact the maintainers.
Acknowledgments
- Rally Ready Driving School — Co-development partner for SageCompare and real-world testing
- Adafruit — BNO055 and GPS hardware/libraries
- KiCAD — Open-source PCB design software
- Leaflet & Chart.js — Visualization libraries
- The rally community — For the passion that drives this project
Built with ❤️ for the dirt — by Sage Racing
Parts
8| Qty | Value | Footprint | References |
|---|---|---|---|
| 2 | LED | LED_THT:LED_D5.0mm | D1, D2 |
| 2 | R | Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_Horizontal | R1, R2 |
| 1 | 2472 | 2472:MODULE_2472 | U1 |
| 1 | LOGO | LOGO | G*** |
| 1 | RPi_GPIO | RPI_Hat:RPI_Hat_B+ | J1 |
| 1 | SW_Push | Button_Switch_THT:SW_PUSH_6mm | SW1 |
Similar boards
- 2 layers20.5 × 24.8 mm

- 2 layers14.4 × 10.5 mm

OSO SWAB B1-00 Sensor Watch Accelerometer
joeycastillo/Sensor-Watch
A board replacement for the classic Casio F-91W wristwatch
8 parts2.1k - 2 layers7.9 × 39.1 mm

Brain board STM32F407 SD wing it
rusefi/rusefi
rusefi - GPL internal combustion engine control unit
8 parts1.2k - 2 layers59.9 × 25.7 mm

Buffer
hoglet67/RGBtoHDMI
Bare-metal Raspberry Pi project that provides pixel-perfect sampling of Retro Computer RGB/YUV video and conversion to HDMI
8 parts1kGPL-3.0 - 2 layers52 × 12.6 mm

USB
shanteacontrols/OpenDeck
A platform for building interactive control and sensing devices using MIDI and OSC built with Zephyr RTOS.
8 parts960Apache-2.0 - 2 layers87.5 × 48.5 mm

7 input macropad
hackclub/OnBoard
💡 Join 1,000 teenagers and make your first PCB with a $100 grant!
8 parts915 - 2 layers36.2 × 63.1 mm

PicoMemcard pico
dangiu/PicoMemcard
Emulating PSX Memory Card (or controller) using a Raspberry Pi Pico
8 parts694GPL-3.0 - 2 layers36 × 10 mm

PCB4-PWR BTN Rev.A
OLIMEX/DIY-LAPTOP
Do It Yourself Open Source Hardware and Software Modular Hacker's Friendly Laptop
8 parts578Apache-2.0
Questions
How big is the Imu pi5 header PCB?
It measures 65 × 37 mm and has 2 copper layers, 1.6 mm thick.
What parts does the Imu pi5 header use?
8 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 Imu pi5 header KiCad files?
From the sharadkj/SageStack repository on GitHub, at the commit this page was made from: the board is imu_pi5_header/imu_pi5_header.kicad_pcb and its schematic imu_pi5_header/imu_pi5_header.kicad_sch. PCBKit opens the board in the browser, with nothing to install.
Can I use the Imu pi5 header design in my own project?
Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).