GitHub - root3315/unisat: 🛰️ Universal satellite software platform — CanSat, CubeSat 1U-12U, HAB, rocket, drone. One codebase → 14 form factors. 471 tests green, TRL-5 hardened.

Version 1.5.1 — Universal Platform (CanSat + CubeSat 1U–12U + HAB + Rocket + Drone + Rover)
Professional open-source flight software for any small-satellite class

60-second tour

git clone https://github.com/root3315/unisat.git &&cd unisat
./scripts/verify.sh # full green pipeline (Docker)
cp mission_templates/cubesat_3u.json mission_config.json
make target-cubesat_3u # → firmware/build-arm-cubesat_3u/cd ground-station && streamlit run app.py # → http://localhost:8501

Prefer CanSat? Replace cubesat_3u with cansat_standard. Going to a specific competition? Pick the preset that matches its rulebook — e.g. cansat_uzcansat.json for 🇺🇿 UzCanSat 2026. The firmware, flight-software, and ground-station all reconfigure themselves from mission_config.json.

Full step-by-step: docs/guides/USAGE_GUIDE.md · per-profile playbooks: docs/ops/ · full docs index: docs/README.md · mission templates: mission_templates/.

Overview

UniSat is a complete, modular flight-software platform that targets the full spectrum of student and research vehicles in a single codebase:

CanSat — minimal / standard / advanced (≤350 g, ≤500 g)
CubeSat — 1U, 1.5U, 2U, 3U, 6U, 12U
Suborbital rockets, high-altitude balloons, drones and rovers

The same STM32 firmware, the same Python flight controller, and the same Streamlit ground station reconfigure themselves automatically from mission_config.json. A form-factor registry enforces mass/volume/power envelopes (CDS Rev. 14 for CubeSats, ESA CanSat regulations for CanSats), and a deterministic feature-flag resolver gates every optional subsystem so the build contains only what the mission actually needs.

Обзор (Русский)

UniSat — универсальная программная платформа, которая из одного репозитория запускает:

CanSat — minimal / standard / advanced (≤350 г и ≤500 г);
CubeSat — 1U, 1.5U, 2U, 3U, 6U, 12U;
суборбитальные ракеты, стратосферные зонды, БПЛА и роверы.

Одна и та же прошивка STM32, один и тот же полётный контроллер на Python и одна и та же наземная станция на Streamlit сами подстраиваются под активную миссию через mission_config.json. Реестр форм-факторов проверяет массу/объём/энергетику (CDS Rev. 14 для CubeSat, правила ESA для CanSat), а детерминированный резолвер фич-флагов включает только те подсистемы, которые нужны конкретному аппарату.

🔒 What's new in v1.2.0 — TRL-5 hardening

Version 1.2.0 landed an eight-phase hardening sweep (75 commits on feat/trl5-hardening) that promotes UniSat from "competition- ready template" to TRL-5-capable software platform. Full details in CHANGELOG.md — summary:

Phase 1 — Real ARM target build

STM32F446RE LD script, startup.s, SystemInit/clock at 168 MHz
FreeRTOS kernel + CMSIS-RTOSv2 + HAL autodetect in CMake
make setup-all && make target produces a real .elf
Verified footprint: 31.6 KB flash (6 %) / 36.3 KB RAM (28 %)

Phase 2 — Security (T1 + T2 both closed)

T1 (injection): HMAC-SHA256 + constant-time verify
T2 (replay): 32-bit counter + 64-bit sliding-window bitmap
Persistent key store (A/B flash slots + CRC + monotonic gen)
Python CounterSender — thread-safe ground-side pair

Phase 3 — FDIR (NASA-style three-tier)

12 fault IDs + 60s escalation window + 6-level severity ladder
Advisor (fdir.c) / commander (mode_manager.c) split (ADR-005)
Persistent fault log in .noinit SRAM — survives warm reboot

Phase 4 — Tboard + mission scenario

Live TMP117 reading in beacon bytes 14-15 (was zero-padded)
End-to-end mission lifecycle test (startup → nominal → safe → recovery) + 48-hour soak harness

Phase 5 — Quality gates

make cppcheck (CI-blocking) + MISRA advisory
make coverage — 85.3 % C lines
make sanitizers — ASAN + UBSAN clean
cmake -DSTRICT=ON — -Werror -Wshadow -Wconversion clean

Phase 6 — Documentation (CDR-level)

SRS with 44 REQ + traceability CSV
8 ADRs for architectural decisions
HIL test plan + characterization templates
Threat model v2 with T1+T2 closed

Phase 7 — Python + release plumbing

make coverage-py — 85.15 % Python lines (gate ≥ 80 % MUST)
make lint-py — mypy strict clean across 21 files
make sbom — auto-generated SPDX bill of materials
make pin-docker — release-engineering digest pin

Phase 8 — Final polish

ARM build fully verified end-to-end
Zero warnings in any build profile
Total tests: 27 C + 329 Python = 356 checks
Migrated MIT → Apache 2.0 for patent-grant protection (§3)

Test + coverage progression

	Before (v1.1.0)	After (v1.2.0)
C test executables	16	27
Python tests	34	329
C line coverage	not measured	85.3 %
Python line coverage	not measured	85.15 %
ARM target `.elf`	not verified	6 % flash / 28 % RAM
ADRs	2	8
Quality gates	1	9 (all green)
License	MIT	Apache 2.0

Architecture

┌─────────────────────────────────────────────────────────────┐
│ GROUND STATION (Python/Streamlit) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐ │
│ │Dashboard │ │Telemetry │ │ Orbit │ │Command Center │ │
│ │ │ │ Charts │ │ Tracker │ │ (HMAC-AUTH) │ │
│ └──────────┘ └──────────┘ └──────────┘ └───────────────┘ │
└─────────────────────────┬───────────────────────────────────┘
│ UHF 437 MHz / S-band 2.4 GHz
│ AX.25 / CCSDS Protocol
┌─────────────────────────┴───────────────────────────────────┐
│ CUBESAT (1U-6U) │
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ FLIGHT CONTROLLER (Raspberry Pi Zero 2 W) │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌──────────────┐ │ │
│ │ │Camera │ │Orbit │ │Health │ │ Scheduler │ │ │
│ │ │Handler │ │Predict │ │Monitor │ │ (asyncio) │ │ │
│ │ └────────┘ └────────┘ └────────┘ └──────────────┘ │ │
│ └──────────────────────┬───────────────────────────────┘ │
│ │ UART │
│ ┌──────────────────────┴───────────────────────────────┐ │
│ │ OBC FIRMWARE (STM32F4 + FreeRTOS) │ │
│ │ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────────┐ │ │
│ │ │ADCS │ │EPS │ │COMM │ │GNSS │ │Telemetry │ │ │
│ │ │B-dot │ │MPPT │ │UHF │ │u-blox│ │ CCSDS │ │ │
│ │ │Sun │ │BatMgr│ │S-band│ │ │ │ │ │ │
│ │ └──────┘ └──────┘ └──────┘ └──────┘ └──────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────────────┐ ┌───────────────────────────────┐ │
│ │ SOLAR PANELS │ │ PAYLOAD (swappable) │ │
│ │ GaAs 29.5% eff. │ │ Radiation / Camera / IoT / │ │
│ │ 6 panels (3U) │ │ Magnetometer / Spectrometer │ │
│ └────────────────────┘ └───────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

Features

Subsystem	Description	Technology
OBC Firmware	Real-time task management, watchdog, safe mode	STM32F4 + FreeRTOS (C)
ADCS	B-dot detumbling, sun/nadir/target pointing	Quaternion math, PID control
EPS	MPPT solar charging, battery management	Perturb & Observe algorithm
Communication	UHF 9600 bps + S-band 256 kbps	AX.25 v2.2 full (streaming decoder, bit-stuffing, CRC-16/X.25, §3.12 addresses) + CCSDS Space Packet + HMAC-SHA256
Flight Software	Async mission control, imaging, orbit prediction	Python 3.11+ asyncio
Ground Station	10-page dashboard with real-time telemetry	Streamlit + Plotly
Simulation	Orbit, power, thermal, link budget	Python scientific stack
Configurator	Web-based mission builder with validation	Streamlit
Payloads	5 swappable payload modules	Plugin architecture

Quick Start

1. Clone the repository

git clone https://github.com/root3315/unisat.git
cd unisat

2. Install dependencies

chmod +x scripts/setup.sh
./scripts/setup.sh

3. Run the ground station

cd ground-station
pip install -r requirements.txt
streamlit run app.py

4. Run simulation

cd simulation
pip install -r requirements.txt
python mission_analyzer.py

Подробное руководство:docs/guides/USAGE_GUIDE.md — от выбора типа миссии (CanSat / CubeSat / HAB / Rocket / Drone) до подачи на конкурс.

Что ещё можно добавить:docs/project/GAPS_AND_ROADMAP.md — честный статус, приоритизированный список открытых задач.

5. End-to-end AX.25 SITL demo (one command)

# Requires Docker Desktop running. No local gcc/cmake/pytest needed.
./scripts/verify.sh

That script builds the unisat-ci Docker image once (~30 s), then runs the full green pipeline inside it: firmware host build → ctest → pytest → end-to-end SITL beacon demo. Expected final line: ✓ UniSat green. Ready to submit.

For more granular control:

make all — build + tests
make ci — same, inside Docker
make demo — just the SITL beacon path
make test-c / make test-py — split suites
make help — list all targets

Project Status

TRL-5 hardening: all 6 phases on feat/trl5-hardening closed.

Check	Status
Firmware host build (all subsystems)	✅ clean (`unisat_core`)
Firmware target build (STM32F446RE .elf/.bin/.hex)	✅ verified: 31.6 KB flash (6%) / 36.3 KB RAM (28%) under 90% budget
C unit tests (`ctest`)	✅ 28 / 28 passing (100+ sub-tests)
Python tests (`pytest`, full suite)	✅ 420 passing — 262 flight-software + 82 ground-station + 57 simulation + 19 configurator
Python coverage (MUST gate)	✅ 85.15 % (`make coverage-py`, ≥ 80 % enforced)
Streamlit page import smoke	✅ 12/13 passing (1 skipped — streamlit not installed)
Universal platform (v1.3.1)	✅ 14 form factors: CanSat min/std/adv + CubeSat 1U/1.5U/2U/3U/6U/12U + rocket/HAB/drone/rover/custom
SBOM (SPDX)	✅ `make sbom` generates `docs/sbom/sbom-summary.md`
FreeRTOS autodetect in CMake	✅ `make setup-freertos` + `make setup-all`
AX.25 golden vectors cross-validation	✅ 28/28 byte-identical C ↔ Python
SHA-256 FIPS 180-4 oracle	✅ `"abc"` + `""` canonical digests
HMAC-SHA256 RFC 4231 vectors	✅ §4.2 + §4.3 on both C and Python
End-to-end SITL demo	✅ C encoder → TCP → Python decoder
E2E mission scenario (startup → nominal → safe)	✅ flight-software/tests/test_mission_e2e.py
Long-soak harness (48 h gated via UNISAT_SOAK_SECONDS)	✅ test_long_soak.py
Driver reality audit	✅ all 9 drivers verified real (incl. BoardTemp)
Threat T1 (command injection)	✅ HMAC dispatcher
Threat T2 (replay)	✅ 32-bit counter + 64-bit sliding window
Persistent key store (A/B + CRC + rotation)	✅ 10/10 tests
Boot-time key_store → dispatcher wiring in main.c	✅ 4/4 integration tests
Python counter-aware HMAC frame builder (CounterSender)	✅ 22/22 pytest
FDIR fault advisor + watchdog integration	✅ 9/9 tests, 12 fault IDs
FDIR mode supervisor (SAFE/DEGRADED/REBOOT wiring)	✅ 9/9 tests
Persistent fault log (.noinit, survives warm reboot)	✅ 6/6 tests
Tboard (TMP117) facade in beacon bytes 14–15	✅ 6/6 tests
cppcheck static-analysis gate	✅ clean (`make cppcheck`)
Line coverage (C)	✅ 85.3 % / functions 84.0 % (`make coverage`)
ASAN + UBSAN under ctest	✅ 28/28 clean (`make sanitizers`)
STRICT mode (-Werror -Wshadow -Wconversion)	✅ 28/28 clean (`cmake -DSTRICT=ON`)
ADRs for architectural decisions	✅ 8 ADRs under `docs/adr/`
Full SRS + traceability CSV	✅ docs/requirements/SRS.md
HIL test plan + characterization templates	✅ docs/testing + docs/characterization
Requirement traceability (AX.25 subset)	✅ auto-generated (docs/verification/ax25_trace_matrix.md)

Deferred (not TRL-5 blockers) — see docs/project/GAPS_AND_ROADMAP.md: Streamlit↔AX.25 live bridge, CC1125 radio config doc, MISRA backlog cleanup (~1000 Rule 8.7/10.x style deviations).

6. Build firmware manually (optional)

If you don't want to use Docker:

cd firmware
cmake -B build -S .
cmake --build build
ctest --test-dir build --output-on-failure

Cross-compile for STM32F446 (requires arm-none-eabi-gcc):

cd firmware
cmake -B build-arm -S . -DCMAKE_TOOLCHAIN_FILE=arm.cmake
cmake --build build-arm
# Output: build-arm/unisat_firmware.{elf,bin,hex}

Supported Form Factors

UniSat's form-factor registry is the single source of truth for every supported class. Every envelope in the tables below is enforced at runtime; each row also ships a mission template, a hardware BOM, a compile-time firmware profile, and a dedicated ops guide.

Form factor	Max mass	Dimensions (mm)	ADCS tiers	Typical radios	BOM	Ops guide
CanSat minimal	350 g	Ø66 × 115 cyl.	none	ISM 433/868/915, LoRa	`cansat_minimal.csv`	cansat_minimal.md
CanSat standard	500 g	Ø68 × 80 cyl.	none	ISM, LoRa	`cansat_standard.csv`	cansat_standard.md
CanSat advanced	500 g	Ø68 × 115 cyl.	passive-spin	ISM, UHF amateur	`cansat_advanced.csv`	cansat_advanced.md
CubeSat 1U	2.0 kg	100 × 100 × 113.5	passive-magnetic	VHF/UHF amateur	`cubesat_1u.csv`	cubesat_1u.md
CubeSat 1.5U	3.0 kg	100 × 100 × 170.25	magnetorquer	UHF amateur	`cubesat_1_5u.csv`	cubesat_1_5u.md
CubeSat 2U	4.0 kg	100 × 100 × 227.0	magnetorquer + sensors	UHF + optional S-band	`cubesat_2u.csv`	cubesat_2u.md
CubeSat 3U ← TRL-5 ref	6.0 kg	100 × 100 × 340.5	reaction wheels 3-axis	UHF + S-band + X-band	`cubesat_3u.csv`	cubesat_3u.md
CubeSat 6U	12.0 kg	226.3 × 100 × 366	star tracker fine-pointing	UHF + S + X + Ka	`cubesat_6u.csv`	cubesat_6u.md
CubeSat 12U	24.0 kg	226.3 × 226.3 × 366	star tracker + propulsion	UHF + S + X + Ka + optical	`cubesat_12u.csv`	cubesat_12u.md
Rocket payload	10 kg	Ø100 × 300 cyl.	none / passive-spin	ISM, UHF, S-band	—	rocket_avionics.md
HAB payload	4 kg	150 × 150 × 150	none	ISM, APRS, UHF amateur	—	hab_payload.md
Small drone (UAS)	5 kg	500 × 500 × 200	IMU attitude control	ISM 2.4 GHz	—	drone.md

Mission templates live in mission_templates/ — copy the one you want into mission_config.json and the flight controller, firmware, and ground station all follow along. Profile-selection flowchart + trade-offs in docs/ops/README.md.

Picking a profile

# 1. Choose a template (CanSat, CubeSat 1U … 12U, rocket, HAB, drone).
cp mission_templates/cubesat_3u.json mission_config.json
# 2. Build the matching firmware image.
make target-cubesat-3u # → firmware/build-arm-cubesat-3u/# 3. Launch the flight controller and ground station — they read# mission_config.json and configure themselves automatically.cd flight-software && python3 flight_controller.py
cd ground-station && streamlit run app.py

Build every profile at once with make target-all-profiles (produces nine separate build-arm-<profile>/ trees).

Feature flags

mission_config.json accepts a top-level features block whose keys are defined in flight-software/core/feature_flags.py. The resolver combines explicit overrides with platform / form-factor / ADCS-tier / radio-band gates so the final enabled set is deterministic and logged. Examples:

"features": {
"orbit_predictor": true, // CubeSat-only → disabled for CanSat"reaction_wheels": true, // requires 2U+ and an RW tier"star_tracker": false, // explicit disable always wins"descent_controller": true, // CanSat / rocket / HAB only"parachute_pyro": true,
"s_band_radio": true// requires s_band radio configured
}

Competition Adaptation

Ready-to-submit adaptations for aerospace competitions. Detailed per-profile guides live in docs/ops/ (one file per form factor) + short form in USAGE_GUIDE.md §7.

Competition	Template	Highlights	Ops guide	Prep time
CanSat (beginner)	`cansat_minimal.json`	RP2040, ISM 433 MHz, ≤350 g	cansat_minimal.md	1 evening
🇺🇿 UzCanSat 2026 (cmspace.uz)	`cansat_uzcansat.json`	1 Hz telemetry, buzzer locator, camera 640×480 @ 30 fps — preset full compliant with cmspace.uz rulebook	UZCANSAT_COMPLIANCE.md	2–3 days
ESERO / national CanSat	`cansat_standard.json`	Parachute, IMU, Ø68 × 80 mm, ≤500 g	cansat_standard.md	2–3 days
NASA CanSat	`cansat_advanced.json`	Pyro deploy, camera, guided descent	cansat_advanced.md	1 week
CubeSat Design	`cubesat_3u.json`	3U LEO, CDR docs, HMAC auth	cubesat_3u.md	1 week
CubeSat 6U/12U research	`cubesat_6u.json` / `cubesat_12u.json`	X/Ka-band, propulsion slot	cubesat_6u.md	2–3 weeks
NASA Space Apps	Any CubeSat + NDVI	Earth observation	cubesat_6u.md	48 h
IREC / SA Cup rocket	`rocket_competition.json`	Dual-deploy, HMAC telemetry	rocket_avionics.md	2–3 days
HAB flight	`hab_standard.json`	GNSS + camera	hab_payload.md	1 day
UAV survey	`drone_survey.json`	Mission planner	drone.md	1–2 days

Also: COMPETITION_GUIDE.md (short form), docs/ops/README.md (profile-selection flowchart).

Project Structure

unisat/
├── firmware/ # STM32F446 firmware (C11 + FreeRTOS)
│ ├── stm32/Core/ # OBC, COMM, GNSS, CCSDS, telemetry,
│ │ # command_dispatcher (HMAC-auth)
│ ├── stm32/Drivers/ # 9 sensor drivers + AX25 + Crypto +
│ │ # VirtualUART (SITL TCP shim)
│ ├── stm32/ADCS/ # B-dot, quaternion, sun/target pointing
│ ├── stm32/EPS/ # MPPT, battery manager
│ └── tests/ # 28 Unity test targets
├── flight-software/ # Python async flight controller (RPi Zero 2 W)
│ ├── core/ # form_factors.py, feature_flags.py, mission_types.py
│ └── tests/ # 262 pytest incl. e2e + soak + hypothesis
├── ground-station/ # Streamlit UI + AX.25 CLI + HMAC tooling
│ ├── utils/ax25.py # AX.25 v2.2 Python mirror
│ ├── utils/hmac_auth.py# HMAC-SHA256 mirror (RFC 4231)
│ ├── utils/profile_gate.py # hides orbit/image/ADCS pages by profile
│ ├── cli/ # ax25_listen / ax25_send TCP tools
│ └── tests/ # 82 pytest incl. hypothesis + fuzz
├── simulation/ # 10 simulators (orbit, power, thermal, link) — 57 tests
├── configurator/ # Web-based mission configurator + BOM gen — 19 tests
├── hardware/
│ ├── bom/by_form_factor/ # 7 per-class BOMs with real masses
│ └── kicad/ # 4 KiCad boards (OBC, EPS, Comm, Sensor)
├── payloads/ # 5 swappable payload templates
├── mission_templates/ # 8 ready-to-use presets (CanSat min/std/adv + CubeSat 1U-12U)
├── tests/golden/ # Shared AX.25 test vectors (C + Python)
├── docs/ # 25+ md docs (USAGE_GUIDE, TECHNICAL_DOC,
│ # ADRs, threat model, tutorials, verification)
├── docker/Dockerfile.ci # Reusable CI image (cmake + pytest baked)
├── scripts/verify.sh # One-command reproducibility
├── Makefile # make all / test / demo / ci / help
├── CHANGELOG.md # Semantic-versioned history
└── README.md # This file

Documentation

Full index:docs/README.md — every doc in the repo, grouped by purpose.

Start here

docs/guides/USAGE_GUIDE.md — step-by-step from clone to competition submission
docs/guides/OPERATIONS_GUIDE.md — 12-section playbook: profile pick → flight day → post-flight
docs/guides/TROUBLESHOOTING.md — common build / run / integration issues
docs/ops/README.md — profile-selection flowchart + index of all 11 per-profile ops guides
docs/reference/TECHNICAL_DOCUMENTATION.md — full technical deep-dive (~1200 lines)
docs/project/GAPS_AND_ROADMAP.md — honest status, open work, out-of-scope

Per-profile operations guides (`docs/ops/`)

One file per form factor covering setup → build → bench test → flight → post-flight:

CanSat — cansat_minimal · cansat_standard · cansat_advanced
CubeSat — cubesat_1u · cubesat_1_5u · cubesat_2u · cubesat_3u · cubesat_6u · cubesat_12u
Other platforms — rocket_avionics · hab_payload · drone

Design & architecture (`docs/design/`)

architecture.md — layered architecture + form-factor registry overview
universal_platform.md — one code base / 14 form factors
mission_design.md — mission concept of operations
communication_protocol.md — AX.25 + CCSDS wire format
assembly_guide.md — physical assembly

Quantitative budgets (`docs/budgets/`, 3U reference)

mass_budget.md — 3U component mass with margins
power_budget.md — solar / storage / consumption
link_budget.md — UHF + S-band link margins
orbit_analysis.md — ground track, eclipse, J2
thermal_analysis.md — orbital thermal environment

Per-profile envelopes (mass / volume / power) are in flight-software/core/form_factors.py; per-class BOMs are under hardware/bom/by_form_factor/.

Reference (`docs/reference/`)

API_REFERENCE.md — programmatic API surface
TECHNICAL_DOCUMENTATION.md — technical deep-dive
STYLE_GUIDE.md — Google-derived code + prose conventions
REQUIREMENTS_TRACEABILITY.md — REQ → source → test mapping

Architecture decisions (`docs/adr/` — 8 ADRs)

ADR-001 — No CSP
ADR-002 — Style Adapter
ADR-003 — A/B Key Store
ADR-004 — Replay Counter Zero-Sentinel
ADR-005 — FDIR Advisory Split
ADR-006 — .noinit Persistent Log
ADR-007 — HAL Shim Strategy
ADR-008 — Command Dispatcher Wire Format

Hardware (`docs/hardware/`)

CC1125_configuration.md — UHF radio register map
radiation_budget.md — TID / SEE design budget per orbital class

Verification, testing, reliability

docs/requirements/SRS.md — Software Requirements Specification
docs/requirements/traceability.csv — REQ → source → test CSV
docs/verification/ax25_trace_matrix.md — auto-generated trace matrix
docs/verification/driver_audit.md — every driver proven real (not mock)
docs/testing/testing_plan.md — overall V&V strategy
docs/testing/hil_test_plan.md — HIL bench procedure + 10 tests
docs/reliability/fdir.md — 12 fault IDs + recovery ladder
docs/quality/static_analysis.md — cppcheck + coverage + sanitizers
docs/characterization/README.md — WCET / stack / power measured baselines
docs/security/ax25_threat_model.md — T1 + T2 both mitigated

Project state & regulatory (`docs/project/`)

GAPS_AND_ROADMAP.md — what works, what's next, what's out of scope
REGULATORY.md — licensing, export control, radio regulation
POSTER_TEMPLATE.md — competition poster starter

Tutorials, operations, SBOM, diagrams

docs/tutorials/ax25_walkthrough.md — byte-by-byte beacon decode
docs/operations/commissioning_runbook.md — post-deploy activation
docs/sbom/sbom-summary.md — SPDX bill of materials (auto-generated via make sbom)
docs/diagrams/ — SVG block diagrams

Contributing & security

CONTRIBUTING.md — PR workflow
SECURITY.md — vulnerability reporting
CHANGELOG.md — semantic-versioned history
CLAUDE.md — guidance for AI-assisted contributions

Testing

One command:

./scripts/verify.sh # Docker-based, no local toolchain needed

Via Makefile:

make all # build + test (C + Python)
make test-c # ctest only (28 targets, 100+ sub-tests)
make test-py # pytest only (420 tests across all 4 Python packages)
make demo # end-to-end SITL AX.25 beacon demo
make help# list all targets

Quality gates:

# C firmware
make cppcheck # static-analysis gate (zero issues)
make cppcheck-strict # + MISRA-C:2012 advisory report
make coverage # lcov html report (85.3 % lines)
make sanitizers # ASAN + UBSAN under ctest# Python
make coverage-py # pytest + coverage (≥ 50 % MUST gate, 80 % SHOULD)
make lint-py # mypy type check on flight-software# supply-chain
make sbom # SPDX bill-of-materials under docs/sbom/

STM32 target (Phase 1):

make setup-all # fetch STM32Cube HAL + FreeRTOS kernel (one-time)
make target # cross-compile .elf / .bin / .hex
make size # per-section flash / RAM usage
make flash # st-flash to Nucleo-F446RE

Manual:

cd firmware && cmake -B build -S .&& cmake --build build
ctest --test-dir build --output-on-failure
cd ../ground-station && python -m pytest tests/test_ax25.py -v

Contributing

See CONTRIBUTING.md for guidelines on how to contribute to UniSat.

License

This project is licensed under the Apache License, Version 2.0 — see LICENSE and NOTICE for the full terms and the third-party attribution summary.

License history: the project was initially published under MIT (2026-02-15 — 2026-04-18) and migrated to Apache-2.0 on 2026-04-18 for its patent-grant clause (§3) and the defensive-termination language (retaliation against a patent suit terminates the aggressor's patent licence). Copies obtained during the MIT window stay MIT-licensed; new releases from 2026-04-18 onward are Apache-2.0 only.

Acknowledgments

CCSDS (Consultative Committee for Space Data Systems) for protocol standards
FreeRTOS for the real-time operating system
SGP4 algorithm authors for orbit prediction
CubeSat Design Specification (CalPoly) for mechanical standards

Name		Name	Last commit message	Last commit date
Latest commit History 189 Commits
configurator		configurator
docker		docker
docs		docs
firmware		firmware
flight-software		flight-software
ground-station		ground-station
hardware		hardware
mission_templates		mission_templates
notebooks		notebooks
payloads		payloads
scripts		scripts
simulation		simulation
tests/golden		tests/golden
tools		tools
.cppcheck-suppressions		.cppcheck-suppressions
.gitattributes		.gitattributes
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CLAUDE.md		CLAUDE.md
COMPETITION_GUIDE.md		COMPETITION_GUIDE.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
Makefile		Makefile
NOTICE		NOTICE
README.md		README.md
SECURITY.md		SECURITY.md
docker-compose.yml		docker-compose.yml
mission_config.json		mission_config.json

Folders and files

Latest commit

History

Repository files navigation

60-second tour

Overview

Обзор (Русский)

🔒 What's new in v1.2.0 — TRL-5 hardening

Phase 1 — Real ARM target build

Phase 2 — Security (T1 + T2 both closed)

Phase 3 — FDIR (NASA-style three-tier)

Phase 4 — Tboard + mission scenario

Phase 5 — Quality gates

Phase 6 — Documentation (CDR-level)

Phase 7 — Python + release plumbing

Phase 8 — Final polish

Test + coverage progression

Architecture

Features

Quick Start

1. Clone the repository

2. Install dependencies

3. Run the ground station

4. Run simulation

5. End-to-end AX.25 SITL demo (one command)

Project Status

6. Build firmware manually (optional)

Supported Form Factors

Picking a profile

Feature flags

Competition Adaptation

Project Structure

Documentation

Start here

Per-profile operations guides (docs/ops/)

Design & architecture (docs/design/)

Quantitative budgets (docs/budgets/, 3U reference)

Reference (docs/reference/)

Architecture decisions (docs/adr/ — 8 ADRs)

Hardware (docs/hardware/)

Verification, testing, reliability

Project state & regulatory (docs/project/)

Tutorials, operations, SBOM, diagrams

Contributing & security

Testing

Contributing

License

Acknowledgments

About

Topics

Resources

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Per-profile operations guides (`docs/ops/`)

Design & architecture (`docs/design/`)

Quantitative budgets (`docs/budgets/`, 3U reference)

Reference (`docs/reference/`)

Architecture decisions (`docs/adr/` — 8 ADRs)

Hardware (`docs/hardware/`)

Project state & regulatory (`docs/project/`)