Skip to the content
2 layers51 × 40 mmFlight computer v2, the printed circuit board in 3D

Flight computer

Size
51 × 40 mm
Copper layers
2
Thickness
1.6 mm
Parts
64
Nets
112
Pads
264
Tracks, vias
565, 130
Pours
15
Routed
Yes
KiCad
KiCad 9.0 (file 20241229)
Created
16 Feb 2026
Updated
29 Jul 2026

Overview

Flight computer v2 is an open-source printed circuit board by IshraqueSarwar, from the IshraqueSarwar/CORESEN-custom-flight-computer repository on GitHub. It is a 2-layer board of 51 × 40 mm with 64 parts on 112 nets, routed with 565 tracks and 130 vias.

It is built around the AMS1117-3.3, AMS1117-5.0 and MPU-9250, with the BAT54C among its other parts. Its parts include 25 capacitors, 8 resistors, 6 connectors, 4 ICs and 4 diodes. It belongs with the STM32 boards of this library.

Main components

4

README

README.md

CoreSen-V2 — Custom STM32 Flight Computer

A from-scratch, hand-soldered flight controller built to close the gap between writing embedded firmware and actually understanding the hardware it runs on.

MCU IMU EDA Layers Assembly License

Assembled CoreSen-V2 flight computer held in hand

CoreSen-V2, fully populated. LQFP-100 STM32F407VGT6, salvaged MPU-9250, hand-soldered in one four-hour session.


Table of Contents


Why This Board Exists

I spend most of my time on the firmware side — bare-metal register work, peripheral drivers, control loops. That is a comfortable place to sit, but it is also a place where the hardware becomes a black box. You read a datasheet, you write to a register, something happens, and you never really ask why the board was built that way.

CoreSen-V2 was my way out of that. I wanted to design a board where I could point at every single component and explain what it does, why it is there, and what breaks if I remove it. Not a dev-board with a sensor bolted on — the whole thing, from the power tree up.

It took roughly two months of design across schematic capture, footprint work, and layout, and about four hours of hand-soldering to populate. The result is a compact flight controller built around the STM32F407VGT6 with a high-rate SPI IMU, four motor outputs, three UARTs, and the analogue sensing lines a real flight stack expects.

This repository is the complete design: schematics, layout, Gerbers, BOM, firmware project, and the reference material I used to get there.


At a Glance

MicrocontrollerSTM32F407VGT6 — ARM Cortex-M4F, 168 MHz, 1 MB Flash, 192 KB SRAM, LQFP-100
IMUMPU-9250, 9-DoF, on SPI1 (salvaged from a dead Navio2)
Clock source8 MHz crystal (Y1) with 10 pF load capacitors
Motor outputs4× timer-driven PWM (PA0–PA3)
Serial3× UART broken out (UART1, UART3, UART6)
RC inputPPM on PC9
Analogue sensingBattery voltage, current, RSSI (PC1 / PC3 / PC2)
Aux busI²C pads with on-board pull-ups (PB6 / PB7)
Power inputDC barrel/battery header, or USB 5 V, Schottky OR-ed
RegulationAMS1117-5.0 → AMS1117-3.3 cascade
DebugSWD (SWDIO / SWDCLK / NRST) on a 5-pin header
Board2-layer, 264 pads, 130 vias, 112 nets, 0 unrouted
EDA toolKiCad 9.0.6
Design time~2 months
AssemblyHand-soldered, ~4 hours, hot air + drag soldering

The Build Timelapse

Drag-soldering a 100-pin LQFP with 0.5 mm pitch, then placing every passive by hand, is mostly an exercise in patience and flux management. The full four-hour session is condensed below.

CoreSen-V2 assembly timelapse

Click to watch the full assembly on YouTube.

Replace YOUR_VIDEO_ID in both URLs above with your YouTube video ID (the part after watch?v=).


System Architecture

mermaid
flowchart TB
    subgraph PWR["Power"]
        VDC["VDC input<br/>battery"] --> U4["U4<br/>AMS1117-5.0"]
        USB5["USB 5 V<br/>via J5"] --> D5["D5 · BAT54C<br/>Schottky OR"]
        U4 --> D5
        D5 --> U3["U3<br/>AMS1117-3.3"]
        U3 --> R33["+3.3 V rail"]
        R33 --> FB["FB1 · 120R<br/>ferrite bead"]
        FB --> VDDA["+3.3 VA<br/>analogue rail"]
    end

    subgraph CORE["Compute"]
        MCU["U1 · STM32F407VGT6<br/>Cortex-M4F @ 168 MHz"]
        Y1["Y1 · 8 MHz XTAL"] --> MCU
        SW1["SW1 · Reset"] --> MCU
    end

    R33 --> MCU
    VDDA --> MCU

    subgraph SENSE["Sensing"]
        IMU["U2 · MPU-9250<br/>accel + gyro + mag"]
    end

Hardware Deep Dive

Full schematic in KiCad schematic editor

Complete schematic — MCU block, IMU block, and regulator block.

Microcontroller and Clocking

The STM32F407VGT6 was chosen for headroom rather than minimalism. A Cortex-M4F at 168 MHz with a hardware FPU means attitude estimation — quaternion maths, complementary or EKF filtering — runs in single-precision float without the usual embedded contortions of fixed-point arithmetic. The 100-pin package also gave me enough exposed I/O to break out everything a flight stack might want, instead of multiplexing peripherals against each other.

The core clock comes from Y1, an 8 MHz crystal, loaded with two 10 pF capacitors (C15, C16), feeding the internal PLL. 8 MHz was deliberate: it divides cleanly to the 168 MHz core clock and the 48 MHz clock the USB OTG FS peripheral requires, so USB and full-speed core operation can coexist without a second oscillator.

Reset and boot: SW1 pulls NRST low through a 100 nF filter cap (C12), and R1 (10 kΩ) holds BOOT0 down so the chip always boots from Flash unless deliberately overridden.

Power Tree

Power comes in from one of two sources and converges on a single 3.3 V rail:

text
VDC (battery) ──► U4 AMS1117-5.0 ──┐
                                   ├──► D5 (BAT54C dual Schottky) ──► U3 AMS1117-3.3 ──► +3.3 V ──► FB1 (120R) ──► +3.3 VA
USB 5 V (J5)  ─────────────────────┘

The BAT54C is the interesting part. It is a dual Schottky in a single package, wired as an OR-ing diode so the board can be powered from USB on the bench or from the flight battery in the air, without back-feeding the USB host and without needing a jumper. Whichever rail is higher wins.

FB1 (120 Ω ferrite bead) splits a dedicated +3.3VA analogue rail off the main digital rail, feeding VDDA and VREF+. Without this, every switching edge from 168 MHz digital activity couples straight into the ADC reference, and battery-voltage and current readings pick up noise proportional to how busy the CPU is. The bead plus C9 (10 nF) and C10 (1 µF) forms a low-pass filter that keeps the analogue domain quiet.

D3 is a power-good LED on the 3.3 V rail with a series current-limiting resistor — the cheapest possible "is this board alive" indicator, and worth every millimetre of board space during bring-up.

PWR_FLAG symbols are placed on VDC, +5 V, and USB_5V so KiCad's ERC understands where power actually originates rather than warning about undriven power nets.

The IMU Problem: SPI vs I2C

This was the single biggest sourcing constraint of the project.

A flight controller lives or dies on how fast it can read its gyroscope. Attitude loops want gyro samples at 1–8 kHz; anything slower and you are integrating stale data into your attitude estimate, which shows up as sluggish or oscillatory control. I²C at 400 kHz simply cannot sustain that for a 9-DoF sensor once you account for register addressing overhead. SPI was non-negotiable.

The problem: almost every IMU breakout available to me locally in Türkiye was an I²C-only module. Bare SPI-capable IMU ICs, in single quantities, with reasonable shipping time, were not realistically obtainable.

The solution was salvage. I had a dead Navio2 board with an intact MPU-9250 on it. I hot-air rework removed the sensor, cleaned the pads, and gave it a second life on CoreSen-V2. Desoldering a QFN without cooking it is nerve-wracking, but the MPU-9250 is genuinely excellent for its footprint — 3-axis gyro, 3-axis accelerometer, and an AK8963 magnetometer in a 3×3 mm QFN-24 — and it natively supports SPI up to 20 MHz for sensor registers.

How it is wired:

MPU-9250 pinFunction in SPI modeSTM32 pin
SCL/SCLKSPI clockPA5 (SPI1_SCK)
SDA/MOSIMaster out, slave inPA7 (SPI1_MOSI)
AD0/MISOMaster in, slave outPA6 (SPI1_MISO)
nCSChip select, active lowPA4 (GPIO)
INTData-ready interruptPC4 (EXTI)

Note the pin-name trap: in I²C mode those pins are SCL, SDA, and AD0, which is why the schematic net labels still read GYRO_SCL / GYRO_SDA / GYRO_SDO. The MPU-9250 switches to SPI automatically when nCS is pulled low, and the same silicon pins take on completely different roles. Reading the pin table without reading §7 of the datasheet is a very easy way to route this backwards.

REGOUT gets its own 1 µF (C23) for the internal LDO, and the supply is decoupled with a 100 nF / 10 nF / 100 nF / 1 µF network (C17–C20) split across VDD and VDDIO.

Why the interrupt line matters: polling the IMU wastes bus bandwidth and introduces jitter between sample time and read time. Wiring INT to an EXTI pin means the control loop is driven by the sensor's own sample clock, which is exactly what you want for a deterministic attitude loop.

USB and Programming

J5 is a micro-B connector feeding the STM32's integrated USB 2.0 Full Speed transceiver directly on PA11 (D−) and PA12 (D+). The F4 series has the transceiver on-die, so no external PHY and no 22 Ω series resistors are needed — the impedance matching is internal.

Layout for USB followed ST's AN4879 (included in datasheets/): D+ and D− routed as a tightly coupled differential pair, matched length, kept short, with no vias or stubs along the pair.

A resistor divider off the USB 5 V rail provides VBUS sensing so firmware can tell whether it is bench-connected or flying.

Debug is plain SWD — SWDIO on PA13, SWDCLK on PA14, plus NRST and 3.3 V/GND on a 5-pin header. Any ST-LINK V2 clone will program it.

Decoupling Strategy

The STM32F407 has six VDD pins plus VBAT and VDDA, and ST's guidance is one 100 nF close to each supply pin plus bulk. The board follows this:

Capacitor(s)ValuePurpose
C1–C7100 nFOne per VDD pin, placed as close to the package as layout allowed
C810 µFBulk reservoir for the digital rail
C9, C1010 nF, 1 µFVDDA filtering behind FB1
C111 µFVREF+ decoupling
C12100 nFNRST filter — stops spurious resets from noise on the reset line
C13, C14see noteVCAP_1 / VCAP_2, internal core regulator stabilisation
C15, C1610 pFCrystal load capacitors
C21, C2222 µFAMS1117-5.0 input/output
C24, C2522 µFAMS1117-3.3 input/output

VCAP note: these are currently populated at 100 nF. See Known Issues — the F407 datasheet calls for 2.2 µF low-ESR here, and this is a genuine deviation I caught while documenting the board.


Peripheral and Pin Map

FunctionNet nameSTM32 pinPackage pinPeripheral
Motor 1MOTOR1PA023TIM2_CH1 / TIM5_CH1
Motor 2MOTOR2PA124TIM2_CH2 / TIM5_CH2
Motor 3MOTOR3PA225TIM2_CH3 / TIM5_CH3
Motor 4MOTOR4PA326TIM2_CH4 / TIM5_CH4
IMU chip selectGYRO_CSPA429GPIO output
IMU clockGYRO_SCLPA530SPI1_SCK
IMU MISOGYRO_SDOPA631SPI1_MISO
IMU MOSIGYRO_SDAPA732SPI1_MOSI
IMU interruptGYRO_INTPC433EXTI4
BuzzerBUZZERPA867GPIO / TIM1_CH1
Telemetry TXUART1_TXPA968USART1_TX
Telemetry RXUART1_RXPA1069USART1_RX
USB data −USB_DMPA1170OTG_FS_DM
USB data +USB_DPPA1271OTG_FS_DP
Debug dataSWDIOPA1372SWD
Debug clockSWDCLKPA1476SWD
GPS / aux TXUART3_TXPB1047USART3_TX
GPS / aux RXUART3_RXPB1148USART3_RX
Status LED 1LED1PB389GPIO (D2)
Status LED 2LED2PB490GPIO (D1)
I²C clock padSCL_PADPB692I2C1_SCL
I²C data padSDA_PADPB793I2C1_SDA
Battery voltageVBAT_PADPC116ADC1_IN11
RSSI inputRSSI_PADPC217ADC1_IN12
Current senseCURRENT_PADPC318ADC1_IN13
RX / ESC TXUART6_TXPC663USART6_TX
RX / ESC RXUART6_RXPC764USART6_RX
RC inputPPM_INPC966TIM3_CH4 input capture
ResetMCU_RSTNRST14SW1 + header
Boot selectBOOT0BOOT09410 kΩ pulldown

Motors 1–4 sit on PA0–PA3 deliberately: all four map to channels of the same 32-bit timer (TIM2 or TIM5), so all four PWM outputs share one timebase and update in the same cycle. Spreading them across different timers would introduce phase skew between motors — small, but not something you want in a control loop.

Test points are placed on the motor outputs, IMU SPI lines, buzzer, and all three analogue sense pads, which made scope probing during bring-up substantially less painful than probing package pins.


PCB Layout

KiCad PCB editor showing the CoreSen-V2 layout

Layout in the KiCad PCB editor — routing, silkscreen, and courtyards visible.

Layout Statistics

MetricValue
Copper layers2 (F.Cu / B.Cu)
Pads264
Vias130
Track segments565
Nets112
Unrouted0
Mounting holes4

Layout Priorities

Routing was ordered by how much each net cared about being routed badly:

  1. Crystal loop first. Y1 and its load caps are placed tight against the OSC_IN/OSC_OUT pins with the shortest possible loop area, and no other signals routed underneath. An oscillator that will not start is one of the more miserable bring-up failures to debug.
  2. Decoupling second. Each 100 nF sits on the same side as its VDD pin with a via to ground directly at the pad, so the current loop from cap to pin to plane stays small. Decoupling routed as a long trace is decorative, not functional.
  3. USB differential pair third. Matched, tightly coupled, short, no stubs.
  4. IMU SPI fourth. Kept short and grouped so all four lines see similar propagation delay, and routed away from the switching current paths of the regulators.
  5. Everything else. Motor outputs, UARTs, and analogue pads fanned out to board-edge headers.

IMU placement was chosen to sit away from the regulators — the AMS1117 devices are the only meaningful heat sources on the board, and thermal gradients across a MEMS gyro produce bias drift. It is also kept off the mounting-hole stress paths, since board flex mechanically couples into the sensor package and shows up as low-frequency noise in the accelerometer.

Form factor was a compromise with my own hands. I could have shrunk this board considerably by tightening component spacing, but every millimetre I removed made hand-soldering harder. Since this board was always going to be assembled by me with a soldering iron rather than by a pick-and-place machine, the design rule became: if I cannot get a fine-tip iron and tweezers in there, it is too tight.


Engineering Tradeoffs

The most useful thing this project taught me had nothing to do with routing or register maps. It was that hardware design is a negotiation between three things that are almost never simultaneously satisfiable: what you want, what you can afford, and what you can actually get hold of.

I wantedConstraintWhat I didWhat it cost me
SPI IMU at 8 kHzOnly I²C modules available locallySalvaged an MPU-9250 from a dead Navio2 via hot-air reworkHours of rework risk; non-reproducible BOM
4-layer board with solid ground plane2-layer is dramatically cheaper in single quantitiesBuilt 2-layer with careful return-path managementCompromised return paths; noisier analogue domain
Switching regulator for the 5 V railLinear regs were what I had, and simpler to routeAMS1117-5.0 linearSignificant heat dissipation from a high-voltage input
Machine assemblyNo access, and costHand-soldered LQFP-100 + 0603/0402 passivesFour hours and a lot of flux
Compact footprintMust remain hand-solderableRelaxed component spacingBoard is larger than it strictly needs to be

Several components I would have reached for first simply were not obtainable in Türkiye in single quantities without a multi-week lead time. Working around that pushed me into solutions I would never have found if the parts had just been sitting on a shelf — the Navio2 salvage in particular. Constraint turned out to be a better teacher than budget would have been.


Known Issues and V3 Roadmap

I would rather document the problems honestly than pretend the board is perfect. These are the issues I have identified, in rough order of severity.

#IssueImpactPlanned fix
1VCAP_1/VCAP_2 populated at 100 nF. The STM32F407 datasheet specifies 2.2 µF low-ESR capacitors on these pins for internal core-regulator stability.Potential core regulator instability, especially at 168 MHz under load. May manifest as intermittent resets or erratic behaviour rather than a clean failure.Swap to 2.2 µF X5R/X7R with ESR < 2 Ω. Same footprint, drop-in on the existing board.
22-layer stack-up. No solid ground plane means return currents take whatever path the pour allows.Degraded EMI performance, worse ADC noise floor, higher risk of USB signal integrity issues.Move to 4-layer: signal / GND / power / signal. Cost delta is small at prototype quantities now.
3Linear regulation from battery voltage. A 3S LiPo at 12.6 V through an AMS1117-5.0 at 200 mA dissipates over 1.5 W in a SOT-223.Thermal problem; also wasteful of flight battery capacity.Replace U4 with a synchronous buck (e.g. TPS5430 or MP2315 class).
4No USB ESD protection. D+/D− go straight to the MCU. AN4879 recommends a TVS array.A single static discharge on the connector can kill the USB peripheral or the MCU.Add a USBLC6-2SC6 across the pair at the connector.
5No reverse-polarity protection on the DC input.Wiring the battery backwards destroys the board.Add a P-channel MOSFET ideal-diode on VDC.
6Single IMU, no redundancy.Any sensor failure is a total loss of attitude estimation.Add a barometer (BMP280/DPS310) and, ideally, a second IMU on a separate SPI bus.
7No SD card or flight logging.Cannot post-analyse a flight.SDIO is available on the F407 — add a microSD socket.
8Salvaged IMU makes the BOM non-reproducible.Nobody else can build this exactly.Move to a currently-manufactured SPI IMU (ICM-42688-P or BMI270) for V3.

Firmware Status

ComponentStatus
CubeMX project + clock tree config✅ Done
SWD connectivity, blink✅ Done
SPI1 driver, MPU-9250 WHO_AM_I readback🚧 In progress
Gyro/accel register configuration + DMA reads🚧 In progress
AK8963 magnetometer via auxiliary bus📋 Planned
Sensor fusion (complementary → EKF)📋 Planned
PWM output driver (OneShot125 / DShot)📋 Planned
PPM input capture📋 Planned
ADC battery/current/RSSI monitoring📋 Planned
USB CDC configuration interface📋 Planned
Full stabilisation loop📋 Planned

Bring-Up Procedure

Documented here both as a record and because it is the checklist I wish I had written before powering the board for the first time. Do not skip to step 5.

  1. Visual inspection, unpowered. Inspect every fine-pitch joint under magnification. Look for bridges on the LQFP and tombstoned passives.
  2. Continuity and short check. Measure 3.3 V to GND, 5 V to GND, and VDC to GND. Any resistance below a few hundred ohms means stop and find the short before applying power.
  3. Regulator check, no MCU load. Apply input power through a current-limited bench supply set to ~100 mA. Confirm 5 V and 3.3 V rails are within tolerance and D3 lights.
  4. Current draw sanity check. Idle draw should be tens of milliamps. Anything dramatically higher indicates a problem.
  5. SWD handshake. Connect the ST-LINK and confirm the debugger can read the device ID. If this fails, check NRST, BOOT0, and the 3.3 V rail at the package.
  6. Blink test. Flash a minimal program toggling D1/D2 from the internal HSI. This proves core, Flash, and GPIO.
  7. Crystal verification. Switch to HSE + PLL. Confirm the expected core frequency by toggling a pin at a known rate and measuring with a scope, or via MCO output.
  8. IMU handshake. Read the MPU-9250 WHO_AM_I register (0x75) over SPI. It should return 0x71. This is the single most informative test on the board — it proves the SPI bus, chip select, the salvaged sensor, and the power rail all at once.
  9. Interrupt line. Configure the IMU data-ready interrupt and confirm EXTI fires at the expected rate.
  10. ADC calibration. Feed known voltages into the VBAT and current pads and record the scaling factors.
  11. Motor outputs — propellers removed. Verify PWM timing on a scope before anything is ever connected to an ESC.

Repository Structure

text
fc_ee-26/
│
├── images/                          # Photographs and renders of the board
│   ├── flight_computer_final.jpeg   # Assembled board
│   ├── pcb.jpg                      # KiCad PCB editor view
│   ├── schematic.jpg                # Full schematic sheet (printed)
│   └── schematic_color.jpg          # Schematic in the KiCad editor
│
├── schematics/
│   ├── fc-ee/                       # V1 design (archived, KiCad project)
│   │   ├── fc-ee.kicad_sch
│   │   ├── fc-ee.kicad_pcb
│   │   └── fc-ee.csv                # V1 BOM
│   │
│   └── version2/                    # V2 — the current design
│       ├── flight_computer_v2/
│       │   ├── flight_computer_v2.kicad_pro    # ← open this in KiCad 9
│       │   ├── flight_computer_v2.kicad_sch
│       │   ├── flight_computer_v2.kicad_pcb
│       │   ├── bom/ibom.html                   # Interactive BOM for assembly
│       │   ├── MPU_9250.zip                    # IMU footprint + symbol library
│       │   └── QFN24_3X3X1_IVS.step            # IMU 3D model
│       │
│       ├── analysis/

A note on datasheets/: these PDFs are copyrighted by ST and InvenSense. If you plan to make this repository public, consider replacing them with links to the manufacturers' pages rather than redistributing the files.


Building the Firmware

Requirements

  • STM32CubeIDE (or CubeMX + arm-none-eabi-gcc + Make)
  • ST-LINK V2 or V3 programmer
  • STM32CubeF4 HAL package

Steps

bash
git clone https://github.com/ISHRAQUE_SARWAR/coresen-v2.git
cd coresen-v2/program
  1. Open program.ioc in STM32CubeMX or STM32CubeIDE.
  2. Verify the clock tree: HSE 8 MHz → PLL → 168 MHz SYSCLK, with the USB clock at 48 MHz.
  3. Generate code and build.
  4. Connect the ST-LINK to the SWD header (SWDIO, SWDCLK, NRST, 3V3, GND).
  5. Flash and run.

Opening the hardware

Install KiCad 9.0 or newer, then open:

text
schematics/version2/flight_computer_v2/flight_computer_v2.kicad_pro

The MPU-9250 symbol and footprint are in MPU_9250.zip — extract and add it as a project library if the symbol shows as unresolved.


Manufacturing It Yourself

Everything needed is already exported.

  1. Upload schematics/version2/output/manufacturing.zip directly to JLCPCB, PCBWay, or your fab of choice.
  2. Recommended settings: 1.6 mm FR4, 1 oz copper, HASL or ENIG. ENIG is worth the small upcharge for the 0.5 mm pitch LQFP footprint.
  3. Order a stencil if you intend to reflow rather than hand-solder — it makes the LQFP-100 and the QFN-24 far more forgiving.
  4. Open bom/ibom.html in a browser during assembly. It highlights each component's position on the board as you work through the list, which is the single biggest time-saver in hand assembly.

Assembly order that worked for me:

  1. STM32 LQFP-100 first, by drag soldering with plenty of flux, while the board is otherwise empty and easy to manipulate.
  2. Check for bridges under magnification and clean thoroughly. Fix problems now, not later.
  3. MPU-9250 QFN with hot air and paste.
  4. Regulators and larger passives.
  5. Small passives, grouped by value to avoid mixing up unmarked capacitors.
  6. Connectors, crystal, switch, and LEDs last.

What I Learned

Datasheets are not reference material, they are the design. Almost every value on this board — the crystal load capacitors, the ferrite bead, the decoupling network, the VCAP requirement I got wrong — comes directly from an application note or a datasheet section. Building hardware taught me to read them as specifications rather than as documentation to search when something breaks.

Layout is a physical argument, not a drawing. Before this project I understood "keep decoupling caps close" as a rule to follow. Now I understand it as a statement about current loop area and inductance, which means I can reason about when it matters and how much. The same applies to differential pairs, return paths, and analogue/digital rail separation.

Constraints generate solutions. Every part I could not buy forced a decision I would not otherwise have made. The salvaged MPU-9250 is the clearest example — an inconvenience that turned into the most interesting part of the build.

Design for the assembly process you actually have. The single most consequential layout decision was to space components for a human with tweezers rather than for a pick-and-place machine. A denser board that I could not have assembled would have been worthless.

Write the bring-up plan before you power the board. The temptation to plug it in and see what happens is enormous. A methodical sequence — shorts, then rails, then debugger, then blink, then peripherals — turns "it does not work" into "it fails at step 6", which is a solvable problem.


Acknowledgements

  • ST Microelectronics — for the STM32F4 reference manuals and AN4879, which shaped the USB layout.
  • InvenSense/TDK — MPU-9250 register map and product specification.
  • The Navio2 board that died so this one could have a gyroscope.
  • The KiCad project, which is remarkable for a free tool.

License

  • Hardware (schematics, layout, Gerbers): CERN-OHL-S v2
  • Firmware: MIT
  • Documentation: CC BY 4.0

Third-party datasheets in datasheets/ remain the property of their respective manufacturers and are included for reference only.


Designed, routed, and hand-assembled by Ishraque Sarwar Siam Mechatronics Engineering · Yıldız Technical University · Istanbul, Türkiye

If you found this useful, a ⭐ is appreciated. Questions and design critique are very welcome — open an issue.

Parts

64
QtyValueFootprintReferences
13100nCapacitor_SMD:C_0805_2012Metric_Pad1.18x1.45mm_HandSolderC1, C2, C3, C4, C5, C6, C7, C12, C13, C14, C17, C19, C23
10TestPointTestPoint:TestPoint_Pad_D2.0mmTP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10
510kResistor_SMD:R_0805_2012Metric_Pad1.20x1.40mm_HandSolderR1, R2, R3, R4, R5
422uCapacitor_SMD:C_1206_3216Metric_Pad1.33x1.80mm_HandSolderC21, C22, C24, C25
4MountingHoleMountingHole:MountingHole_2.2mm_M2H1, H2, H3, H4
31kResistor_SMD:R_0805_2012Metric_Pad1.20x1.40mm_HandSolderR8, R10, R11
31uCapacitor_SMD:C_0805_2012Metric_Pad1.18x1.45mm_HandSolderC10, C11, C20
3Conn_01x04_PinConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ1, J2, J3
210nCapacitor_SMD:C_0805_2012Metric_Pad1.18x1.45mm_HandSolderC9, C18
210pCapacitor_SMD:C_0805_2012Metric_Pad1.18x1.45mm_HandSolderC15, C16
2LED_SmallLED_SMD:LED_0805_2012Metric_Pad1.15x1.40mm_HandSolderD1, D2
110uCapacitor_SMD:C_0805_2012Metric_Pad1.18x1.45mm_HandSolderC8
1120RInductor_SMD:L_0805_2012Metric_Pad1.05x1.20mm_HandSolderFB1
18MHzCrystal:Crystal_SMD_5032-2Pin_5.0x3.2mm_HandSolderingY1
1AMS1117-3.3Package_TO_SOT_SMD:SOT-223-3_TabPin2U3
1AMS1117-5.0Package_TO_SOT_SMD:SOT-223-3_TabPin2U4
1BAT54CPackage_TO_SOT_SMD:SOT-23D5
1Conn_01x03_PinConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ4
1Conn_01x05_PinConnector_PinHeader_2.54mm:PinHeader_1x05_P2.54mm_VerticalJ6
1LEDLED_SMD:LED_0805_2012Metric_Pad1.15x1.40mm_HandSolderD3
1MPU-9250Sensor_Motion:InvenSense_QFN-24_3x3mm_P0.4mmU2
1STM32F407VGTxPackage_QFP:LQFP-100_14x14mm_P0.5mmU1
1SW_PushButton_Switch_SMD:SW_SPST_EVQPE1SW1
1USB_B_MicroConnector_USB:USB_Micro-B_Amphenol_10118194-0001LF_HorizontalJ5

More from IshraqueSarwar/CORESEN-custom-flight-computer

1
  • 2 layersFc ee, the printed circuit board in 3D

    Fc ee

    IshraqueSarwar/CORESEN-custom-flight-computer

    Flight computer

    54 parts

Similar boards

  • 4 layers99.1 × 68.6 mmSTM32XP, the printed circuit board in 3D

    STM32XP

    MechatronixLab/STM32XP

    Development board based on the STM32F411RET6

    176 parts14
  • 2 layers96 × 62.6 mmCardspansion dev, the printed circuit board in 3D

    Cardspansion dev

    XyrusB2010/Cardspansion

    A modular microcontroller system, featuring a customizable MCU

    65 partsMIT
  • 4 layers70 × 80 mmPower Board, the printed circuit board in 3D

    Power Board

    kbob/LED-Cube

    Blinky in 3D!

    91 parts51
  • 2 layers85.6 × 54 mmNrf card, the printed circuit board in 3D

    Nrf card

    dossalab/random-pcbs

    Random PCBs I have at my disposal

    64 parts
  • 2 layers54 × 68 mmOpenSTM32F4 LQFP64, the printed circuit board in 3D

    OpenSTM32F4 LQFP64

    phonght32/openSTM32F4_LQFP64

    openSTM32 board using STM32F4 LQFP64 package. This board designed to perform base control for SLAM and Navigation.There are also many availabe connectors that meet many other application requirements.

    77 parts7MIT

Questions

How big is the Flight computer v2 PCB?

It measures 51 × 40 mm and has 2 copper layers, 1.6 mm thick.

What parts does the Flight computer v2 use?

64 parts, built around the AMS1117-3.3, AMS1117-5.0, MPU-9250 and BAT54C. 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 Flight computer v2 KiCad files?

From the IshraqueSarwar/CORESEN-custom-flight-computer repository on GitHub, at the commit this page was made from: the board is schematics/version2/flight_computer_v2/flight_computer_v2.kicad_pcb and its schematic schematics/fc-ee/fc-ee.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Flight computer v2 design in my own project?

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