SSA Architecture Session Summary

Date: April 6, 2026 Topic: Low-Cost Space Situational Awareness System Architecture Status: Planning complete, ready for implementation

---

Key Decisions Made

1. Cost Strategy: Software-Heavy, Hardware-Minimal

Core Principle: Trade compute for aperture. Use statistical methods and distributed networks instead of expensive hardware.

Traditional SSA	OpenASTRO SSA	Cost Ratio
1 professional site ($330K)	50 detection nodes ($13K)	25× cheaper
Single point of failure	Massive redundancy	Infinitely more robust
Limited coverage	Global distribution	Full sky coverage

Critical insight from SSA.md: Sony STARVIS sensors (IMX291/IMX307) cost $15-30 but achieve read noise (~1.0 e⁻) matching scientific cameras ($10,000+).

2. Three-Stage Architecture

Stage 1: Detection (Layer 1 Hardware)
├── Ultra-cheap cameras ($100-200 each)
├── Wide-field, starlight-capable
├── Find unknown objects
├── Create initial orbit estimate (Admissible Region method)
└── Output: Candidate objects with uncertainty clouds

Stage 2: Refinement (Layer 2 Hardware)
├── Entry-level telescopes ($500-1,000 each)
├── Track identified objects
├── Triangulate from multiple sites
├── Refine orbit to high precision
└── Output: Precise orbital elements

Stage 3: Characterization (No Hardware - Partnerships)
├── Light curve analysis (tumble detection)
├── Multi-filter photometry (material classification)
├── Size estimation
└── Output: Physical properties

3. Network Topology

Minimum Viable: 2 detection nodes = $260 (prototype only) Basic Triangulation: 3 detection nodes = $390 (can determine altitude) Operational: 10 detection + 3 tracking = $2,300 (continental coverage) Production: 50 detection + 5 tracking = $9,200 (global coverage)

4. Future: CubeSat Active Sensing

Passive optical has limitations: - Only sees sun-illuminated objects (twilight hours) - Cannot measure range directly - Cannot see through clouds - Limited to >10cm objects

Solution: Deploy cheap CubeSats with lidar: - 3U CubeSat: $50-100K to build - Lidar payload: Active illumination, day/night operation - Range resolution: 1-10 meters - 5-10 CubeSats = $500K-1M (still 3× cheaper than ground radar)

---

Technical Architecture

Hardware Layer

Detection Node ($100-200)

┌─────────────────────────────────────┐
│          DETECTION NODE              │
├─────────────────────────────────────┤
│ IMX307/IMX291 board      │ $15-30   │
│ 8mm f/1.2 lens           │ $20      │
│ Raspberry Pi 4 (4GB)     │ $55      │
│ SD card + cables         │ $25      │
│ 3D printed enclosure     │ $10      │
│ Power supply             │ $10      │
├─────────────────────────────────────┤
│ TOTAL                    │$135-155  │
└─────────────────────────────────────┘

Capability:
- Detection: Mag 10-11
- Field of view: ~50° (all-sky)
- Frame rate: 25-60 fps
- Astrometry: 5-30 arcsec
- Can detect: LEO debris >30cm, GEO satellites

Tracking Station ($300-800)

┌─────────────────────────────────────┐
│         TRACKING STATION            │
├─────────────────────────────────────┤
│ Used 6" Dobsonian        │ $200-400 │
│ ZWO ASI290MM (or equiv)  │ $100-300 │
│ Guide scope (30mm)        │ $50      │
│ Mini PC / NUC             │ $200     │
├─────────────────────────────────────┤
│ TOTAL                     │$550-950  │
└─────────────────────────────────────┘

OR Budget Option:
│ Modified webcam           │ $100     │
│ Used 6" telescope         │ $200     │
│ Arduino controller        │ $30      │
├─────────────────────────────────────┤
│ TOTAL                     │$330      │
└─────────────────────────────────────┘

Capability:
- Detection: Mag 13-14
- Field of view: ~1° (narrow)
- Can track: LEO, MEO, GEO objects
- Astrometry: 1-2 arcsec

Software Layer

Edge Processing (Raspberry Pi)

Components: 1. Streak Detection (streak_detector.py) - Hough transform for line detection - Real-time processing at 25 fps - Filter by velocity (remove planes/birds)

1. Plate Solving (plate_solver.py)
2. Astrometry.net or astropy
3. Convert pixel → RA/Dec

4. ~5-30 arcsec precision

5. Timing Sync (timing_sync.py)

6. NTP synchronization
7. <50ms timing error

8. Essential for triangulation

9. Upload (uploader.py)

10. Batch uploads to central
11. Retry on failure
12. ~1KB per detection (vs 100MB video)

Central Server (Cloud VPS)

Components: 1. Catalog Manager (catalog.py) - Space-Track.org API integration - TLE propagation (SGP4) - Local caching

1. Track Associator (track_associator.py)
2. Link observations to known objects
3. Create new candidates for unknown objects

4. Build tracklets

5. Orbit Solver (orbit_solver.py)

6. Gauss method (long arcs)
7. Admissible Region + Particle Filter (short arcs)

8. 10,000-100,000 virtual particles

9. Triangulator (triangulator.py)

10. Multi-site position determination
11. Calculate altitude without radar

12. Uncertainty estimation

13. Scheduler (scheduler.py)

14. Find common visibility windows
15. Coordinate simultaneous observations
16. Task distribution

Characterization Module

Components: 1. Light Curve Analyzer (lightcurve.py) - Lomb-Scargle periodogram - Tumble period detection - Stability classification

1. Material Classifier (material_classifier.py)
2. B-V, V-R, R-I color indices
3. Match to material signatures
4. S-type, C-type, M-type, solar panel

---

Key Algorithms

Track-and-Stack (Replaces Large Aperture)

Problem: Faint objects below detection threshold.

Solution: Predict motion, shift frames, accumulate.

# Pseudocode
def track_and_stack(frames, predicted_velocity):
    accumulator = zeros_like(frames[0])
    for i, frame in enumerate(frames):
        # Shift frame by predicted motion
        shift = predicted_velocity * i / fps
        shifted = scipy.ndimage.shift(frame, shift)
        accumulator += shifted
    # Result: √N improvement in SNR
    return accumulator

Gain: 100 frames → 2.5 magnitude improvement

Admissible Region + Particle Filter (Replaces Perfect Astrometry)

Problem: Short observations (1 minute) don't constrain range.

Solution: Generate all physically valid orbits, then prune.

# Pseudocode
def short_arc_orbit(observations):
    # From angles and rates, define valid (range, range_rate) region
    # Constraints:
    #   - Energy < 0 (bound orbit)
    #   - Perigee > 100 km

    # Generate 10,000 particles
    particles = sample_admissible_region(n=10000)

    # Propagate forward
    for particle in particles:
        particle = propagate(particle, time=24_hours)

    # When new observation arrives:
    new_obs = wait_for_observation()

    # Prune particles inconsistent with observation
    for particle in particles:
        if angular_distance(particle, new_obs) > tolerance:
            particles.remove(particle)

    # Remaining cluster = true orbit
    return fit_orbit(particles)

Compute cost: GPU can propagate 100K particles in seconds

Hardware saved: Entire precision optics budget

Triangulation (Replaces Radar)

Problem: Single optical observation gives angle, not distance.

Solution: Use 3+ sites to find intersection.

# Pseudocode
def triangulate(observations):
    # observations = [(site_lat, site_lon, site_elev), (ra, dec, time), ...]

    # Convert sites to ECI at each time
    sites_eci = [eci_from_ecef(site, obs.time) for site, obs in observations]

    # Line of sight vectors
    los_vectors = [ra_dec_to_unit_vector(obs.ra, obs.dec) for obs in observations]

    # Find point minimizing distance to all lines
    # (geometric intersection)
    position = geometric_intersection(sites_eci, los_vectors)

    # Altitude = distance from Earth center - Earth radius
    altitude = norm(position) - 6371  # km

    return position, altitude

Requirement: Timing synchronization (GPS or NTP)

---

Data Flow

┌─────────────────────────────────────────────────────────────┐
│                    COMPLETE DATA FLOW                       │
└─────────────────────────────────────────────────────────────┘

1. EDGE NODE (RPi)
   │
   ├── Video stream (25 fps)
   ├── Detect streaks (Hough)
   ├── Plate solve (RA/Dec)
   ├── Timestamp (NTP)
   └── Upload JSON (~1KB)
       │
       ▼

2. CENTRAL SERVER
   │
   ├── Store in PostgreSQL
   ├── Associate with catalog
   │   ├── Known object? → Update orbit
   │   └── Unknown? → Create candidate
   │
   ├── For new candidates:
   │   ├── Short arc? → Admissible Region + particles
   │   └── Wait for more observations
   │
   ├── For known objects:
   │   ├── Triangulate (if multi-site)
   │   └── Refine orbit (Gauss method)
   │
   └── Schedule precision observations (if needed)
       │
       ▼

3. TRACKING STATIONS (for refinement)
   │
   ├── Receive task schedule
   ├── Track object
   ├── Measure precise position
   └── Return high-precision observations
       │
       ▼

4. CHARACTERIZATION
   │
   ├── Light curve analysis
   │   ├── Periodogram for tumble period
   │   └── Stability classification
   │
   ├── Multi-filter photometry
   │   ├── B-V, V-R, R-I colors
   │   └── Material classification
   │
   └── Size estimation
       └── From magnitude + distance + albedo
       │
       ▼

5. OUTPUT
   ├── Orbit elements (a, e, i, Ω, ω, ν)
   ├── Altitude and velocity
   ├── Tumble status (stable/unstable)
   ├── Materialtype
   └── Size estimate

---

Performance Targets

Metric	Professional	OpenASTRO Target	Notes
Cost per site	$150,000+	$130	1000× cheaper
Detection limit	Mag 15-18	Mag 10-11	Stack to improve
Astrometric precision	0.5 arcsec	5-30 arcsec	N-sites averaging
Timing precision	μs (GPS)	ms (NTP)	Acceptable for LEO
Coverage	Single point	Global	Distributed advantage
Weather resilience	50% uptime	99%+	Multi-site redundancy
Orbit precision	km	10-50 km	Improves with time
Altitude determination	Radar (m)	Optical (km)	Lower precision, acceptable
Characterization	Yes	Partial	Via partnerships

---

Implementation Roadmap

Phase 1: Foundation (Weeks 1-4)

Tasks:
├── Hardware
│   ├── Order IMX307 kits (3-5 units)
│   ├── Order RPi 4 boards
│   └── Prepare enclosures
│
├── Software Edge
│   ├── Implement streak_detector.py
│   ├── Implement plate_solver.py
│   ├── Implement timing_sync.py
│   └── Implement uploader.py
│
├── Software Central
│   ├── Set up PostgreSQL
│   ├── Implement catalog.py
│   ├── Implement track_associator.py
│   └── Implement basic API
│
└── Testing
    ├── Unit tests for all modules
    ├── ISS detection test
    └── Validation against known TLEs

Phase 2: Network (Weeks 5-12)

Tasks:
├── Deployment
│   ├── Deploy 3 detection nodes
│   ├── Configure central server
│   └── Test simultaneous observations
│
├── Coordination
│   ├── Implement scheduler.py
│   ├── Implement visibility calculator
│   └── Test multi-site timing
│
├── Orbit Determination
│   ├── Implement triangulator.py
│   ├── Implement orbit_solver.py (Gauss method)
│   └── Implement orbit_solver.py (Admissible Region)
│
└── Testing
    ├── Test triangulation with ISS
    ├── Verify altitude accuracy (<100 km error)
    └── Test unknown object detection

Phase 3: Refinement (Weeks 13-20)

Tasks:
├── Hardware
│   ├── Add 3 tracking stations
│   └── Integrate with scheduler
│
├── Software
│   ├── Implement precision tracking
│   ├── Implement orbit refinement
│   └── Implement accuracy metrics
│
└── Testing
    ├── Verify orbit precision
    ├── Compare with Space-Track
    └── Validate catalog updates

Phase 4: Characterization (Weeks 21-28)

Tasks:
├── Software
│   ├── Implement lightcurve.py
│   ├── Implement material_classifier.py
│   └── Integrate with pipeline
│
├── Testing
│   ├── Test tumble detection
│   ├── Validate material classification
│   └── Compare with professional data
│
└── Partnerships
    ├── Contact amateur networks
    ├── Establish data sharing
    └── Collaborate oncharacterization

Phase 5: Scale (Months 7+)

Tasks:
├── Expand network
│   ├── Add detection nodes
│   ├── Add tracking stations
│   └── Geographic distribution
│
├── Operations
│   ├── Automate catalog updates
│   ├── Implement collision alerts
│   └── Build web interface
│
└── Future
    ├── CubeSat design
    └── Active sensing payload

---

Files Created This Session

1. SSA Low Cost Architecture.md
2. Core philosophy: software-heavy, hardware-minimal
3. Hardware tiers and costs
4. Software substitutions for expensive hardware

5. Network topology

6. SSA Implementation Roadmap.md

7. Phase-by-phase implementation plan
8. Hardware bills of materials
9. Success metrics
10. Testing checklist

11. Risk register

12. SSA Bulk Coding Handoff.md

13. Complete code specifications
14. File structure
15. Function signatures
16. Implementation requirements
17. Testing requirements

18. Deployment configuration

19. SSA Session Summary.md (this document)

20. Key decisions
21. Technical architecture
22. Algorithms
23. Data flow
24. Implementation roadmap

---

References

From Science Docs: - SSA.md - Primary technical reference - Security cameras SSA.md - Hardware specifications - Global Meteor Network - Operational reference - Project Luciole - Fly's eye architecture

---

Glossary

Term	Definition
SSA	Space Situational Awareness
LEO	Low Earth Orbit (160-2000 km)
MEO	Medium Earth Orbit (2000-35786 km)
GEO	Geostationary Earth Orbit (35786 km)
TLE	Two-Line Element (orbit format)
SGP4	Simplified General Perturbations (orbit propagator)
IMX307	Sony STARVIS sensor model
NTP	Network Time Protocol
RA/Dec	Right Ascension/Declination (celestial coordinates)
Admissible Region	Valid (range, range-rate) space for short-arc orbits
Tracklet	Short series of observations
Plate solving	Astrometric calibration (pixel→sky)

---

Next Actions

1. Review all created documents
2. Begin implementation starting with /edge/streak_detector.py
3. Order hardware for first detection nodes
4. Set up central server (VPS + PostgreSQL)
5. Test with ISS observations

---

Open Questions

1. Deployment locations: Where will first 3 detection nodes be located?
2. Git repository: Need to set up GitHub repo and create issues
3. VPS provider: Which cloud provider for central server?
4. Partnerships: Which amateur networks to contact for Stage 3?
5. Funding: Budget for Phase 1 hardware ($2,000)?

---

Contact & Handoff

This documentation is ready for handoff to implementation team.

Implementation priority: 1. Edge detection (streak_detector.py) 2. Catalog integration (catalog.py) 3. Central API (api.py) 4. Testing infrastructure

Documentation complete: April 6, 2026 Ready for implementation: Yes