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

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

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), а детерминированный резолвер фич-флагов включает только те подсистемы, которые нужны конкретному аппарату.

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:

• 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 %)

• 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

• 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

• 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

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

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

• 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

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

┌─────────────────────────────────────────────────────────────┐
│                    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   │  │
│  └────────────────────┘  └───────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

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

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

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

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 — честный статус, приоритизированный список открытых задач.

# 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

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

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

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}

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.

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.

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

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
}

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.

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

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

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

• 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

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

• 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

• 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/.

• 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

• 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

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

• 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

• 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

• 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.md — PR workflow
• SECURITY.md — vulnerability reporting
• CHANGELOG.md — semantic-versioned history
• CLAUDE.md — guidance for AI-assisted contributions

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

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

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.

• 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