An advanced simulation and visualization suite for Deep Space Network (DSN) arraying. This project models the physics of deep space communication, performing real-time digital signal processing (DSP), signal correlation, and beamforming across multiple simulated ground stations to extract clean telemetry from noisy environments.
- Accurate Physics Modeling: Utilizes Skyfield to calculate exact vectors between Earth stations and spacecraft, applying Free-Space Path Loss (FSPL), Doppler shifts, and random atmospheric attenuation.
- Waveform Generation: Simulates source transmissions using standard deep space modulation schemes (e.g., BPSK or QPSK).
- High-Performance Beamforming: A Go-based array controller calculates microsecond delays between Earth stations, utilizing Phase-Locked Loops (PLL) to phase-shift, sum signals, and maximize the Signal-to-Noise Ratio (SNR).
- Signal Demodulation: Translates the phased and summed analog waveforms back into digital telemetry bits.
- 3D Mission Dashboard: An interactive React operations center featuring a 3D Earth map with tracking antennas, dynamic signal waterfall spectrograms, and live Link Budget metrics (SNR and Bit Error Rate).
- Scalable Infrastructure: Uses Redis as a high-speed message bus between the physics engine and correlator, and TimescaleDB for storing historical metrics.
The system operates as a distributed, microservice-based architecture:
- Physics Environment (Python): The deep space and atmosphere model that streams degraded RF signals via gRPC.
- Array Controller (Go): The high-CPU, math-heavy DSP brain responsible for signal correlation, delay calculations, and demodulation.
- Mission Dashboard (React/TypeScript): The frontend UI that consumes WebSocket telemetry to visualize the array's performance in real-time.
- Infrastructure: Supported by Redis and TimescaleDB, deployable via Kubernetes or Docker Compose.
- Simulation & Physics: Python, SciPy, NumPy, Skyfield, gRPC
- DSP & Control: Go (Golang)
- Frontend UI: React, TypeScript, WebSockets, Three.js (3D map), Plotly.js (spectrograms)
- Data & Infrastructure: Redis, TimescaleDB, Docker, Kubernetes
- Docker and Docker Compose installed.
- Ensure you have
makeinstalled for build scripts and protobuf generation.
- Clone the repository:
git clone https://github.com/mtepenner/dsn-array-simulator.git cd dsn-array-simulator - Generate necessary protobufs and build the suite:
make build
- Boot up the physics engine, array controller, infrastructure, and UI via Docker Compose:
docker-compose up -d
Once the services are healthy:
- Open your browser and navigate to the Mission Dashboard (typically
http://localhost:3000). - Interact with the Array Controls to manually add or remove simulated antennas from the tracking array.
- Observe the ArrayMap3D to watch ground stations physically rotate to track the deep-space target.
- Monitor the Signal Waterfall to compare the noisy raw signals against the clean, combined beamformed signal.
- Check the Link Budget Table for real-time improvements in SNR and BER as more antennas are brought online.
Run all unit tests:
make testOr run them individually:
# Python physics engine tests (45 tests)
cd physics_environment && python -m pytest tests/ -v
# Go DSP & decoder tests (29 tests)
cd array_controller && go test ./... -vContributions are highly encouraged, especially in optimizing the DSP algorithms. Please ensure that any changes to the phase-alignment or PLL math pass the dedicated unit tests defined in .github/workflows/test-dsp-math.yml.
- Fork the Project
- Create your Feature Branch (
git checkout -b feature/NewModulation) - Commit your Changes (
git commit -m 'Add support for QAM modulation') - Push to the Branch (
git push origin feature/NewModulation) - Open a Pull Request
Distributed under the MIT License. See LICENSE for more information.