STAR team lead & avionics — 2025–present

Cal STAR

Space Technologies and Rocketry is UC Berkeley's high-power rocketry team: eighteen complete vehicles, three liquid engines, and a 27,326 ft apogee record over ten years of launches. I'm on the avionics subteam. This page is the club, the software monorepo we build it on, and what I do inside it.

Repo
github.com/calstar/STAR — public, docs at calstar.github.io/STAR
Club
stars.berkeley.edu · public wiki
01 / The club
Complete vehicles18
Liquid engines3 (LE4 in design)
Apogee record27,326 ft — Caldera, IREC 2024
Launch history10+ years, since URSA Minor (Dec 2016)

Subteams

TeamOwns
Aerostructuresairframe, fins, recovery — everything that holds the rocket together and brings it home
Propulsionthe liquid engines, from the injector out: LE1 ELLIE, LE2 ALULA, LE3 Diablo, LE4
Avionicsthe boards, firmware, and ground software that sense, control, and record a flight or a hotfire
Payloadthe science that rides along — muon detectors, fuel cells, target-detection
Operationslaunches and hotfires: logistics, safety, procedures
Outreachschools, workshops, demos
Mediaphoto, video, socials, the public website

Sponsors include Boeing, Blue Origin, GM, Dassault Systèmes, Onshape, Ansys, JLCPCB, and the Space Sciences Laboratory. Applications open each fall at apply.starberkeley.org.

02 / Launch history newest first
EraNameKindWhatHeadline
2026–LE4engine4th liquid engine — engine, feed system, tanks, and airframe in-housein design
May 2026Gojiravehiclehigh-performance solid; first reusable aluminum high-altitude BP recovery charges20,000 ft · ~Mach 1.6
2024–2026LE3 “Diablo”engine3rd liquid engine; the custom DAQ that monitors and commands every hotfirecustom DAQ
IREC 2025Excaliburvehiclecompetition solid10,000 ft target
2025Glamourous GlennisdemonstratorLE3 solid demonstrator for a new parachute deployment systemMach 1
IREC 2024Calderavehicletwo-stage vehicle27,326 ft — UC Berkeley record
2021–2024Flight Computeravionicsin-house flight computer: 13 sensors, sensor fusion, extended Kalman filter13 sensors
IREC 2023Calvisitorvehicleair brakes + dual payload10,023 ft · 4th overall
2023ALULA (LE2)vehiclefirst liquid vehicle6,126 ft — first recovered liquid
2022Pinkbearyvehiclefirst two-stage vehicle2,377 ft · stage separation
2021–2022ELLIE (LE1)enginefirst liquid engine6 s test fire
IREC 2021BearForce 1vehiclelargest rocket to date, Mojave Desert10,000+ ft
2021MINDIvehicle2-inch minimum-diameter rocket14,000 ft projected
Nov 2019AirBearsvehicledual-deploy recovery4,509 ft · within 1 ft of prediction
2018ArktosvehicleNASA Student Launch5,323 ft
2016–2017URSA Major / MinorvehicleNASA SL competition vehicle; first high-powered rocketHuntsville, AL
03 / The monorepo calstar/STAR

Everything from the firmware on a sensor board, to the ground station that records a hotfire, to the optimizer that designed the engine lives in one repository. It is a collection of mostly-independent subprojects, each with its own README, setup script, and ./dev.sh; a top-level setup.sh dispatches so editing the P&ID never forces you to build Rust and elodin-db. CI runs per-directory: the C++ DAQ integration test, PlatformIO firmware builds plus host unit tests, pytest gates and frontend builds for each design tool, a 5 MB large-file guard, and Doxygen to GitHub Pages on every push to main.

DirectoryWhat it isStack
daq-server/Ground DAQ server / flight software. Receives sensor data over the network, logs it, drives the state machine and actuators, serves the live web GUI used during hotfires.C++ · TypeScript/Node · Next.js · Elodin DB
firmware/Board firmware for every avionics board (PT, TC, RTD, LC, Encoder, Actuator). Reads sensors, talks to the DAQ server over Ethernet, runs on-board abort logic. Subtree of calstar/DiabloAvionics.PlatformIO · ESP32-S3 · C++
lib/DAQv2-Comms/The wire protocol shared by firmware and DAQ server — packet definitions, enums, (de)serialization. Single source of truth for what goes over the wire.C++ (Arduino library)
lib/stardesign/Design core shared by the design tools: per-user storage, cross-user sharing, version history (microversions + immutable releases, local volume or versioned S3).Python
lib/stardesign-ui/Client half of the same — Change dialog, checkout chip, read-only context, design API client.TypeScript · React
lib/feedtwin/Feed-system physics core: real-gas properties, component library, steady network solver, transient response from COPV to injector face. A library, not a service (ADR-0001).Python · CoolProp · fluids
EngineDesign/Engine design and optimization pipeline for liquid bipropellant engines. Chamber pressure is never an input — it is solved from tank pressures. Multi-layer optimizer, Numba-compiled physics kernel (~120× per candidate), stability analysis, RocketPy validation.Python · FastAPI · React
pid-designer/Interactive P&ID editor for the propulsion feed system. React Flow canvas, git-style versioning, every parameter stored as {value, unit, source, reference} so a run report can say which inputs were measured and which were guessed.FastAPI · React + React Flow
feed-twin/Feed-system simulator — COPV through regulator, tanks, lines, valves to the injector. Built on lib/feedtwin; the same schematic will show simulated physics, replayed test data, or a live DAQ stream.Python · FastAPI · React
star-openrocket/Onshape assembly viewer + centre-of-mass, stability, ascent dynamics, and recovery calculator. Loads from a build cache so the viewer costs zero Onshape API calls.FastAPI · React + three.js
starproject/Internal task tracker replacing OpenProject. Served at project.starberkeley.org.Next.js · PostgreSQL · Prisma
landing/ · auth/ · deploy/Gated internal-tools portal, the Google-login auth service, and the Caddy + docker compose stack that serves everything at *.starberkeley.org behind one @berkeley.edu login.React · Python · Caddy · Docker
website/The public site — Home, launch-history timeline, Leads, Sponsors, Join. Deployed to OCF.React 19 · Vite · Tailwind

How they fit together

        design tools                          test / flight pipeline
  +------------------------+     +------------------------------------------+
  | EngineDesign/          |     | firmware/  (ESP32 boards: PT/TC/RTD/...) |
  |   optimizes geometry   |     |      |  sensor data / heartbeat          |
  |   & pressure curves    |     |      v  (lib/DAQv2-Comms wire protocol)  |
  |                        |     | daq-server/                              |
  | pid-designer/          |     |   DAQ bridge -> Elodin DB -> backend     |
  |   lays out the P&ID    |     |   -> web GUI + state machine + control   |
  | feed-twin/             |     |                                          |
  | star-openrocket/       |     |                                          |
  +------------------------+     +------------------------------------------+
         all four build on lib/stardesign (server) + lib/stardesign-ui (client)
         and mount one shared userdata volume: browse a teammate's design,
         take a copy, or share one and edit it together.

The design tools deploy together at *.starberkeley.org behind a single Google login restricted to @berkeley.edu. Caddy asks the auth service about every request before forwarding it, so the apps carry no auth code of their own, and local development, which never runs Caddy, never sees a login screen. The DAQ server is the deliberate exception: it runs natively under systemd on the test stand, because the C++ bridge, elodin-db, and the board links need the hardware.

04 / The hotfire pipeline boards → UDP → DAQ → GUI

Each avionics board is an ESP32-S3 running a small state machine: boot, self-test the ADC and sensors, wait for the server to send its configuration, then stream sensor data and exchange heartbeats. If it loses the server's heartbeat it aborts on its own. Packets are packed binary over UDP, defined once in lib/DAQv2-Comms, so firmware and server can never disagree about the wire format. On the ground the DAQ server is eleven coordinated processes:

ServiceDoes
daq_bridgeC++ UDP receiver → Elodin time-series DB publisher
sequencerhotfire state machine + actuator commands over UDP
calibrationraw sensor → calibrated sensor, Elodin → Elodin
controllerRobustDDP controller, Elodin → PWM over UDP
heartbeatSERVER_HEARTBEAT to every board; lose it and the board aborts on its own
config_broadcastSENSOR_CONFIG / ACTUATOR_CONFIG pushed to boards at startup
data_loggerCSV logger from Elodin
otaEthernet over-the-air firmware flash
backend + frontendNode/TypeScript WS+HTTP backend, React/Vite GUI on :3000

./dev.sh --sim runs the whole pipeline against simulated boards, so the full-stack integration test needs no test stand. The predecessor of this stack, the Diablo static-fire ground control firmware, is still public at calstar/Diablo-FSW and calstar/DiabloAvionics.

05 / What I do team lead & avionics
  • Avionics for high-power rockets (~30,000 ft apogee): custom PCBs in Altium Designer, soldered and tested under strict mass and volume limits.
  • ESP32-S3 board firmware for the PT, TC, RTD, LC, and ATCOMM boards.
  • The packed-binary UDP wire protocol (lib/DAQv2-Comms) both ends of the pipeline speak.
  • The C++/TypeScript ground DAQ pipeline that runs liquid-engine hotfires across 13 networked boards.
  • Tuned the actuator/valve board’s hotfire state machine: heartbeat timeout, abort, and connection-loss transitions.
  • The mobile experience for STARProject, the team’s internal task tracker.

Board-level design credit is shared across the avionics leads; PCB sources live in the club's Altium 365 workspace rather than the public repo. My software contributions are in calstar/STAR. Tools I actually use: Altium Designer · KiCad 8 · Fusion 360 · ESP-IDF · PlatformIO · Saleae Logic 2. The rest of what I build is at /projects.