Skip to the content
2 layers65 × 37 mmImu pi5 header, the printed circuit board in 3D

Imu pi5 header

sharadkj/SageStack

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

Sage Racing Logo

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

text
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 here

Hardware — 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

ComponentDescription
BNO055 IMU9-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 Button6mm 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 LEDsTwo 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 HeaderStandard Raspberry Pi 5 GPIO header for direct board-to-board mounting.

Design files

FilePurpose
imu_pi5_header.kicad_schFull schematic — component connections, power rails, I²C bus, UART GPS, GPIO button/LED
imu_pi5_header.kicad_pcbPCB layout — 2-layer board with component placement and routing
imu_pi5_header.kicad_proKiCAD project configuration
imu_pi5_hat.zipReady-to-order Gerber files — upload directly to PCB fab houses (JLCPCB, PCBWay, OSH Park, etc.)
DRC.rptDesign 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

  1. Download imu_pi5_hat.zip from the imu_pi5_header/ directory
  2. Go to your preferred PCB manufacturer (e.g., JLCPCB, PCBWay, OSH Park)
  3. Upload the zip file — most fabs auto-detect Gerber layers
  4. Select quantity, color, and surface finish (HASL is fine for prototyping)
  5. Typical cost: ~$5–15 for 5 boards (excluding shipping)

Bill of Materials (BOM)

PartQuantityNotes
Raspberry Pi 51Any RAM variant works
BNO055 breakout board1Adafruit BNO055 or equivalent I²C module
GPS module1UART-based (e.g., Adafruit Ultimate GPS, u-blox NEO series)
Custom PCB (this project)1Order from Gerber files above
USB GPS dongle1Any USB GPS (e.g., VK-162, u-blox 7/8 based). Appears as /dev/ttyUSB0.
Momentary push button16mm tactile through-hole. Panel mount recommended for in-car use.
LEDs25mm through-hole — 1× green, 1× red — with appropriate resistors
2×20 pin header1For Pi GPIO connection (or use stacking header for access to pins)
Resistors2LED 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

text
┌─────────────┐     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 gpiozero library 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.py as a child process via subprocess.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 PinFunction
GPIO 17Pin 11Push button input (to GND)
GPIO 27Pin 13Green LED — logging active
GPIO 22Pin 15Red 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:

  1. Initializes the BNO055 IMU over I²C (SDA/SCL) using the adafruit_bno055 library
  2. Initializes the GPS module over USB serial (/dev/ttyUSB0 at 9600 baud) using adafruit_gps
  3. Configures the GPS for 10 Hz updates and enables RMC, VTG, and GGA NMEA sentences
  4. Creates a new CSV file with a Unix timestamp in the filename (e.g., rally_log_1772928049.csv)
  5. 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
  6. Continues until terminated by watcher.py (SIGTERM) or a keyboard interrupt
  7. Gracefully closes the CSV file on exit

CSV Data Format

Each log file contains the following columns:

ColumnUnitDescription
timestampUnix epoch (seconds)High-resolution timestamp with microsecond precision
latDecimal degreesGPS latitude (WGS84). Empty until first GPS fix.
lonDecimal degreesGPS longitude (WGS84). Empty until first GPS fix.
altMetersGPS altitude above mean sea level
speed_kmhkm/hGPS-derived ground speed
rollDegreesVehicle roll angle (left/right lean)
pitchDegreesVehicle pitch angle (nose up/down)
yawDegreesVehicle heading (0–360°, magnetic north)
accel_xm/s²Lateral acceleration (positive = right)
accel_ym/s²Longitudinal acceleration (positive = forward)
accel_zm/s²Vertical acceleration (~9.8 m/s² at rest)
calib_stat0–3BNO055 system calibration quality (3 = fully calibrated)

Example data:

csv
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,0

Note: 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

text
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: board and busio are provided by adafruit-blinka. gpiozero comes pre-installed on Raspberry Pi OS but may need to be installed on minimal images.

Setting Up the Logger

  1. Flash Raspberry Pi OS (64-bit Lite recommended) onto a microSD card
  2. 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
  3. 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
  4. 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 address 0x28 or 0x29)
    • Verify GPS serial: ls /dev/ttyUSB0 (should exist when GPS is plugged in)
  5. Test the logger manually:
    bash
    python3 rally_logger.py
    # Press Ctrl+C to stop — check for a new rally_log_*.csv file
  6. Run the watcher on boot (recommended):
    bash
    # Add to /etc/rc.local or create a systemd service:
    sudo nano /etc/systemd/system/sage-watcher.service
    ini
    [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.target
    bash
    sudo systemctl enable sage-watcher
    sudo systemctl start sage-watcher

In-Car Operation

  1. Power on the Raspberry Pi (USB-C power bank or vehicle power with a regulator)
  2. Wait for the red LED to turn on — system is in standby
  3. Press the button to start logging — red LED turns off, green LED turns on
  4. Drive the stage
  5. Press the button again to stop logging — green LED blinks during file save
  6. If a USB drive is mounted at /mnt/usb_drive, the CSV is automatically copied to it
  7. Otherwise, transfer via SCP, remove the SD card, or plug in a USB drive manually
  8. 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

TechnologyPurpose
ViteFast dev server and build tool
LeafletInteractive GPS track maps with CartoDB dark basemap tiles
Chart.js + chartjs-plugin-zoomTime-series and scatter plot visualization with zoom/pan
Vanilla JavaScript (ES Modules)No framework overhead — pure DOM manipulation
CSS3Dark theme with glassmorphism, custom properties, responsive grid
Google FontsInter (UI) + JetBrains Mono (data display)

Running SageCompare Locally

bash
# Navigate to the SageCompare directory
cd SageCompare

# Install dependencies
npm install

# Start the dev server
npm run dev

The app will open at http://localhost:5173 (or the next available port).

Application Architecture

text
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 library

The 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 processing
  • filter.js — Butterworth low-pass filter with configurable cutoff
  • charts.js — Chart.js wrapper utilities and color palette
  • analysis.js — Braking zone detection, slalom rhythm analysis, friction circle calculation, sector splitting

Using SageCompare

  1. Upload data: Drag and drop two rally_log_*.csv files — one into the Run A (cyan) zone and one into Run B (pink)
  2. Click "Compare Runs": The app trims cool-down segments, aligns the runs to the first acceleration event, and applies the low-pass filter
  3. Explore the Dashboard: GPS tracks on maps, overlaid speed/acceleration charts, and summary metrics with delta indicators
  4. Dive into analysis tabs: Use the tab bar or arrow keys to switch between Threshold Braking, Slalom, Dynamic Slalom, and Stage Driving views
  5. Adjust the filter: Use the LP filter slider (1–10 Hz) in the header to smooth noisy sensor data
  6. Start a new comparison: Click "New Comparison" to reset and upload different runs

Building for Production

bash
cd SageCompare
npm run build
# Output in dist/ — deploy to any static hosting (Netlify, Vercel, GitHub Pages, etc.)

Quick Start

What You Need

CategoryItems
HardwareRaspberry 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)
OptionalKiCAD 8+ (only if modifying the PCB design)

Step-by-Step

  1. 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
  2. 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
  3. 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
  4. 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:

ComponentStatusNotes
Sensor Hat PCB✅ Testedv1 validated in real vehicle testing. Gerbers ready to order.
Rally Logger✅ TestedActively collecting data. Sample logs from real sessions included.
SageCompare🔨 In DevelopmentCore visualization working. Comparison features being expanded.
Documentation📝 In ProgressThis 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_stat column 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

  1. Fork the repo and clone your fork
  2. Pick a component to work on (hardware, logger, or web app)
  3. Set up your dev environment following the instructions above
  4. Make your changes on a feature branch
  5. 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
QtyValueFootprintReferences
2LEDLED_THT:LED_D5.0mmD1, D2
2RResistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_HorizontalR1, R2
124722472:MODULE_2472U1
1LOGOLOGOG***
1RPi_GPIORPI_Hat:RPI_Hat_B+J1
1SW_PushButton_Switch_THT:SW_PUSH_6mmSW1

Similar boards

  • 2 layers20.5 × 24.8 mmPi interface, the printed circuit board in 3D

    Pi interface

    opulo-inc/lumenpnp

    The LumenPnP is an open source pick and place machine.

    8 parts3.7k
  • 2 layers59.9 × 25.7 mmBuffer, the printed circuit board in 3D

    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 mmUSB, the printed circuit board in 3D

    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 mm7 input macropad, the printed circuit board in 3D

    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 mmPicoMemcard pico, the printed circuit board in 3D

    PicoMemcard pico

    dangiu/PicoMemcard

    Emulating PSX Memory Card (or controller) using a Raspberry Pi Pico

    8 parts694GPL-3.0
  • 2 layers36 × 10 mmPCB4-PWR BTN Rev.A, the printed circuit board in 3D

    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).