Skip to main content

QCOS NavCore™ User Guide

Assured Position, Navigation & Timing with Quantum-Ready Architecture

Copyright © 2024-2026 SoftQuantus Innovative OÜ. All Rights Reserved.

Table of Contents​

  1. Introduction
  2. Getting Started
  3. Core Concepts
  4. API Reference
  5. Sensors
  6. Integrity Monitoring
  7. Quantum Processing
  8. OSNMA Authentication
  9. NIS2 Compliance
  10. Quantum RAIM
  11. Standards Compliance
  12. Integration Guide
  13. Best Practices
  14. Troubleshooting

Introduction​

What is NavCore?​

QCOS NavCore™ is an enterprise-grade Assured PNT (Position, Navigation, and Timing) platform that combines classical and quantum sensors to provide:

  • Resilience: Multi-source sensor fusion that works even when GNSS is jammed or spoofed
  • Integrity: Real-time spoof/jam detection with quantified confidence levels
  • Proof: Cryptographic evidence trail for every navigation decision
  • Future-Ready: Drop-in quantum sensor integration path

The Problem We Solve​

GNSS jamming and spoofing incidents are increasing exponentially worldwide:

  • Conflict Zones: Military-grade jamming affecting civilian aviation
  • Critical Infrastructure: Spoofing attacks on ports, power grids, telecom
  • Transportation: Trucking fraud, maritime incidents, railway safety

Regulators (EASA, FAA, IMO, NIS2) now require proof of PNT resilience.

Key Features​

FeatureDescription
Multi-Sensor FusionGPS, Galileo, INS, baro, quantum sensors
Spoof DetectionReal-time detection of fake GNSS signals
Jam DetectionAutomatic detection of RF interference
Holdover ModeContinue navigation when GNSS is denied
OSNMA AuthenticationGalileo cryptographic verification
Quantum RAIMQuantum sensors as "truth arbiters"
NIS2 ComplianceEU directive compliance reporting
Evidence TrailCryptographic audit for every decision

Getting Started​

Installation​

# Install from PyPI (when available)
pip install qcos-navcore

# Or install from source
git clone https://github.com/softquantus/qcos-server.git
cd qcos-server
pip install -e .

Quick Start​

from navcore import (
    FusionEngine,
    IntegrityMonitor,
    GNSSReceiver,
    IMU,
)

# Create sensors
gnss = GNSSReceiver(
    sensor_id="GNSS-001",
    manufacturer="u-blox",
    model="ZED-F9P",
)

imu = IMU(
    sensor_id="IMU-001",
    manufacturer="Honeywell",
    model="HG1120",
)

# Create integrity monitor
monitor = IntegrityMonitor()

# Create fusion engine
fusion = FusionEngine()
fusion.add_sensor(gnss)
fusion.add_sensor(imu)

# Initialize with position
fusion.initialize(
    position=(51.5074, -0.1278, 100.0),  # London
    timestamp=datetime.now(),
)

# Get navigation solution
solution = fusion.get_solution()

print(f"Position: {solution.position}")
print(f"Integrity Risk: {solution.integrity_risk}")
print(f"Fault Flags: {solution.fault_flags}")

Running the API Server​

# Start the NavCore API server
uvicorn navcore.api:app --host 0.0.0.0 --port 8000

# Or with Docker
docker run -p 8000:8000 softquantus/navcore:latest

Core Concepts​

A navigation solution contains:

Position (lat, lon, alt) ± uncertainty
Velocity (north, east, down) ± uncertainty
Attitude (roll, pitch, yaw) ± uncertainty
Time (UTC offset) ± uncertainty

Integrity Levels​

LevelDescriptionAction
NORMALFull integrity assuredContinue operation
CAUTIONDegraded integrityMonitor closely
WARNINGIntegrity at riskConsider holdover
ALERTIntegrity compromisedUse backup systems

Fault Flags​

FlagMeaning
gnss_validGNSS solution available
spoof_suspectedPossible fake signals
jam_detectedRF interference detected
holdover_activeOperating without GNSS
quantum_verifiedQuantum sensor confirms position

Protection Levels​

  • HPL (Horizontal Protection Level): Maximum horizontal position error
  • VPL (Vertical Protection Level): Maximum vertical position error
  • TPL (Time Protection Level): Maximum timing error
  • GPL (Gravity Protection Level): Quantum gravimeter accuracy

API Reference​

Base URL​

http://localhost:8000/api/v1/navcore

Endpoints Overview​

EndpointMethodDescription
/statusGETCurrent PNT status
/solutionGETFull navigation solution
/integrityGETIntegrity assessment
/alertsGETActive spoof/jam alerts
/holdoverGETHoldover budget/status
/sensorsGETRegistered sensors
/quantum/statusGETQuantum processing status
/compliance/osnma/statusGETOSNMA status
/compliance/nis2/statusGETNIS2 compliance
/raim/statusGETQuantum RAIM status
/raim/protectionGETProtection levels
/standards/sosa/profilesGETSOSA slot profiles

Example: Get Navigation Solution​

curl -X GET "http://localhost:8000/api/v1/navcore/solution"

Response:

{
  "position": {
    "latitude_deg": 51.5074,
    "longitude_deg": -0.1278,
    "altitude_msl_m": 100.0,
    "sigma_horizontal_m": 0.5,
    "sigma_vertical_m": 1.0
  },
  "velocity": {
    "north_ms": 5.0,
    "east_ms": 3.0,
    "down_ms": 0.1,
    "ground_speed_ms": 5.83,
    "sigma_ms": 0.1
  },
  "integrity": {
    "status": "normal",
    "risk_level": 1e-9,
    "protection_levels": {
      "hpl_m": 10.0,
      "vpl_m": 15.0
    }
  },
  "fault_flags": {
    "gnss_valid": true,
    "spoof_suspected": false,
    "jam_detected": false,
    "holdover_active": false
  },
  "evidence_id": "EVD-20241220-123456-abc123"
}

Sensors​

Sensor Types​

Classical Sensors​

SensorPurposeAccuracy
GNSS ReceiverGlobal position1-5m (standalone)
IMUInertial navigationGrade dependent
BarometerAltitude±10m
MagnetometerHeading±2°
OdometryDistance traveled1-2%

Quantum Sensors​

SensorPurposeAccuracy
Quantum GravimeterGravity measurement1 µGal
Optical Atomic ClockTiming10⁻¹⁸
Quantum GyroscopeRotation10⁻³ °/hr
NV MagnetometerMagnetic field1 nT

Adding a Sensor​

from navcore.sensors import QuantumGravimeter

# Create quantum gravimeter
gravimeter = QuantumGravimeter(
    sensor_id="QG-001",
    manufacturer="SoftQuantus",
    model="QGRAV-1000",
)

# Add to fusion engine
fusion.add_sensor(gravimeter, role="quantum_truth")

Sensor Catalog​

from navcore.sensors import SENSOR_CATALOG

# List all supported sensors
for sensor_type, info in SENSOR_CATALOG.items():
    print(f"{sensor_type}: {info['description']}")

Integrity Monitoring​

How It Works​

The Integrity Monitor continuously checks for:

  1. Position Consistency: Is the reported position physically possible?
  2. Velocity Bounds: Are velocities within platform limits?
  3. Clock Consistency: Is timing consistent across sources?
  4. Signal Quality: Are signal characteristics normal?

Spoof Detection​

from navcore.integrity import IntegrityMonitor

monitor = IntegrityMonitor()

# Check for spoofing indicators
result = monitor.check_spoofing_indicators(
    gnss_data=gnss_measurement,
    clock_data=clock_measurement,
    imu_data=imu_measurement,
)

if result.spoof_suspected:
    print(f"ALERT: Spoofing detected!")
    print(f"Confidence: {result.confidence:.1%}")
    print(f"Indicators: {result.indicators}")

Jam Detection​

# Check for jamming
jam_result = monitor.check_jamming_indicators(
    cn0_values=signal_strengths,
    agc_values=agc_levels,
    expected_cn0=45.0,  # dB-Hz
)

if jam_result.jam_detected:
    print(f"WARNING: Jamming detected!")
    print(f"Affected satellites: {jam_result.affected_svs}")

Protection Level Computation​

# Compute protection levels
levels = monitor.compute_protection_levels(
    geometry=satellite_geometry,
    accuracy=measurement_accuracy,
    integrity_risk=1e-7,  # 10^-7
)

print(f"HPL: {levels.horizontal_m:.1f}m")
print(f"VPL: {levels.vertical_m:.1f}m")

# Check against alert limits
hal = 40.0  # Horizontal Alert Limit
val = 35.0  # Vertical Alert Limit

if levels.horizontal_m > hal or levels.vertical_m > val:
    print("ALERT: Protection levels exceed alert limits!")

Quantum Processing​

Overview​

The Quantum Processing module provides:

  • Noise Characterization: Identify noise sources in sensor data
  • Dynamical Decoupling: Suppress quantum decoherence
  • Quantum Kalman Filter: Optimal state estimation
  • Error Correction: Enhance measurement accuracy

Noise Characterization​

from navcore.quantum_processing import (
    QECEngine,  # Alias for QuantumErrorCorrectionEngine
    NoiseType,
)

qec = QECEngine()

# Characterize sensor noise
spectrum = qec.characterize_noise(
    sensor_id="sensor-001",
    time_series=sensor_data,
    sample_rate=1000.0,
)

print(f"Noise type: {spectrum.noise_type}")
print(f"White noise floor: {spectrum.white_noise_floor:.2e}")
print(f"Flicker coefficient: {spectrum.flicker_coefficient:.2e}")

Dynamical Decoupling​

from navcore.quantum_processing import DecouplingSequence

# Select optimal sequence for noise profile
sequence = qec.select_optimal_sequence(
    sensor_id="sensor-001",
    interrogation_time_us=100.0,
)

print(f"Selected sequence: {sequence.sequence_type.value}")
print(f"N pulses: {sequence.n_pulses}")
print(f"Total time: {sequence.total_time_us:.1f} µs")

Process Measurement​

# Process quantum measurement with error correction
result = qec.process_measurement(
    raw_signal=sensor_signal,
    sequence=sequence,
    atom_number=100000,
)

print(f"Corrected value: {result.value:.9f} m/s²")
print(f"Uncertainty: {result.uncertainty:.2e} m/s²")
print(f"Improvement: {result.improvement_factor:.1f}x")

OSNMA Authentication​

What is OSNMA?​

OSNMA (Open Service Navigation Message Authentication) is Galileo's cryptographic authentication system that verifies navigation messages are genuine.

Why It Matters​

  • EU Smart Tachograph: Mandatory from 2025
  • NIS2 Compliance: Required for critical infrastructure
  • Anti-Spoofing: Cryptographic proof signals are authentic

Using OSNMA​

from navcore.osnma import OSNMAVerifier, OSNMAStatus

# Create verifier
verifier = OSNMAVerifier()

# Check status
status = verifier.get_status()
print(f"OSNMA Status: {status}")

# Verify a navigation message
result = verifier.verify_message(
    svid=1,
    subframe_data=nav_data,
    osnma_data=osnma_data,
    tow=tow,
    wn=wn,
)

if result.verified:
    print("✓ Message authenticated")
else:
    print("✗ Authentication failed")

Satellite Authentication Status​

# Get per-satellite authentication status
for svid, status in verifier.satellite_status.items():
    print(f"E{svid}: {status.value}")

API Endpoints​

# Get OSNMA status
curl -X GET "http://localhost:8000/api/v1/navcore/compliance/osnma/status"

# Get satellite authentication details
curl -X GET "http://localhost:8000/api/v1/navcore/compliance/osnma/satellites"

NIS2 Compliance​

What is NIS2?​

NIS2 (Network and Information Security Directive 2) is the EU's updated cybersecurity directive that requires critical infrastructure operators to:

  • Implement security measures (Article 21)
  • Report incidents within 24-72 hours
  • Maintain audit trails
  • Ensure supply chain security

Entity Classification​

TypeSectorsRequirements
EssentialEnergy, Transport, Health, SpaceStrictest requirements
ImportantDigital Infrastructure, ICT ServicesStandard requirements

Compliance Assessment​

from navcore.compliance import (
    NIS2ComplianceManager,
    NIS2EntityType,
    NIS2Sector,
)

# Create manager
manager = NIS2ComplianceManager(
    entity_type=NIS2EntityType.ESSENTIAL,
    sector=NIS2Sector.TRANSPORT,
)

# Assess compliance
assessment = manager.assess_compliance()

print(f"Compliance Status: {assessment.status}")
print(f"Compliance Score: {assessment.score:.1f}%")

# Identify gaps
gaps = manager.identify_gaps()
for gap in gaps:
    print(f"Gap: {gap.requirement_name}")
    print(f"  Risk: {gap.risk_level}")
    print(f"  Effort: {gap.effort_days} days")

Incident Reporting​

from navcore.compliance import NIS2Incident, IncidentCategory, IncidentSeverity

# Report incident
incident = NIS2Incident(
    id="INC-001",
    category=IncidentCategory.AVAILABILITY,
    severity=IncidentSeverity.HIGH,
    title="GNSS Service Disruption",
    description="Complete loss of GNSS signal in operational area",
    affected_systems=["NAV-001", "NAV-002"],
    detection_time=datetime.now(),
)

result = manager.record_incident(incident)
print(f"Incident recorded: {result.incident_id}")
print(f"CSIRT notification required within: 24 hours")

API Endpoints​

# Get NIS2 compliance status
curl -X GET "http://localhost:8000/api/v1/navcore/compliance/nis2/status"

# Get compliance gaps
curl -X GET "http://localhost:8000/api/v1/navcore/compliance/nis2/gaps"

# Report incident
curl -X POST "http://localhost:8000/api/v1/navcore/compliance/nis2/incident" \
  -H "Content-Type: application/json" \
  -d '{
    "category": "AVAILABILITY",
    "severity": "HIGH",
    "title": "GNSS Disruption",
    "description": "Complete signal loss",
    "affected_systems": ["NAV-001"],
    "detection_time": "2024-12-20T10:00:00Z"
  }'

Quantum RAIM​

What is Quantum RAIM?​

Quantum RAIM (Receiver Autonomous Integrity Monitoring) uses quantum sensors as "truth arbiters" to detect sophisticated spoofing attacks that would fool classical RAIM.

How It Works​

  1. Classical RAIM: Uses GNSS satellite redundancy to detect faults
  2. Quantum Enhancement: Compares GNSS against quantum sensors
  3. Truth Arbitration: Quantum sensors are immune to RF spoofing
  4. Fault Isolation: Identify and exclude faulty sources

Using Quantum RAIM​

from navcore.quantum_raim import QuantumRAIMEngine

# Create RAIM engine
raim = QuantumRAIMEngine(
    integrity_risk_target=1e-7,  # 10^-7
    horizontal_alert_limit_m=40.0,
    vertical_alert_limit_m=35.0,
)

# Add quantum sensors
raim.add_sensor("quantum_gravimeter", gravimeter)
raim.add_sensor("quantum_clock", atomic_clock)

# Process epoch
result = raim.process_epoch(
    gnss_measurements=gnss_data,
    quantum_measurements=quantum_data,
    classical_measurements=imu_data,
)

# Check result
if result.threats_detected:
    print("⚠️ Threat detected!")
    for threat in result.threats:
        print(f"  {threat.type}: {threat.confidence:.1%}")

print(f"Protection Levels:")
print(f"  HPL: {result.hpl_m:.1f}m (limit: 40m)")
print(f"  VPL: {result.vpl_m:.1f}m (limit: 35m)")

Attack Detection​

Attack TypeDetection Method
JammingC/N0 drop, AGC saturation
Simple SpoofingPosition jump, velocity inconsistency
Carry-Off AttackSlow drift detected by quantum sensors
MeaconingTiming discrepancy vs atomic clock

API Endpoints​

# Get RAIM status
curl -X GET "http://localhost:8000/api/v1/navcore/raim/status"

# Get protection levels
curl -X GET "http://localhost:8000/api/v1/navcore/raim/protection"

# Get active threats
curl -X GET "http://localhost:8000/api/v1/navcore/raim/threats"

# Get detection statistics
curl -X GET "http://localhost:8000/api/v1/navcore/raim/statistics?hours=24"

Standards Compliance​

SOSA (Sensor Open Systems Architecture)​

For integration into military ground vehicles:

from navcore.standards import SOSAConformanceChecker, SOSA_SLOT_PROFILES

checker = SOSAConformanceChecker()

# Validate module conformance
result = checker.validate_module(
    module_id="NAVCORE-VPX",
    target_profile="SOSA_3U_PAYLOAD",
    form_factor="3U",
    power_watts=25,
    thermal_watts=20,
    interfaces=["PCIe", "Ethernet", "1PPS"],
)

print(f"Conformant: {result.conformant}")
print(f"Level: {result.level}")

VICTORY (Vehicle Integration for C4ISR/EW)​

For US Army vehicle integration:

from navcore.standards import VICTORYPNTService

service = VICTORYPNTService(service_id="navcore-pnt")

# Publish PNT data
service.publish_pnt(
    position={"lat": 51.5074, "lon": -0.1278, "alt": 100},
    velocity={"north": 5.0, "east": 3.0, "down": 0.1},
    heading=45.0,
    integrity="assured",
)

FACE (Future Airborne Capability Environment)​

For avionics portability:

from navcore.standards import FACEPortableComponent

component = FACEPortableComponent(component_id="navcore-face")

# Register TSS interfaces
component.register_tss_interface("GPS_POSVEL")
component.register_tss_interface("TIMING_UTC")

White Rabbit Time Distribution​

For sub-nanosecond synchronization:

from navcore.standards import WhiteRabbitNetwork

network = WhiteRabbitNetwork(network_id="timing-net")

# Add nodes
network.add_grandmaster("GM-001", clock_class="Class-6")
network.add_boundary_clock("BC-001", upstream="GM-001")

# Get network accuracy
accuracy = network.get_accuracy()
print(f"Network accuracy: {accuracy:.1f} ns")

Integration Guide​

FastAPI Integration​

from fastapi import FastAPI
from navcore import (
    api_router,
    quantum_api_router,
    compliance_api_router,
    standards_api_router,
    raim_api_router,
)

app = FastAPI(title="My PNT Service")

# Include NavCore routers
app.include_router(api_router)
app.include_router(quantum_api_router)
app.include_router(compliance_api_router)
app.include_router(standards_api_router)
app.include_router(raim_api_router)

Docker Deployment​

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Kubernetes Deployment​

apiVersion: apps/v1
kind: Deployment
metadata:
  name: navcore
spec:
  replicas: 3
  selector:
    matchLabels:
      app: navcore
  template:
    metadata:
      labels:
        app: navcore
    spec:
      containers:
      - name: navcore
        image: softquantus/navcore:latest
        ports:
        - containerPort: 8000
        resources:
          limits:
            memory: "512Mi"
            cpu: "500m"

Best Practices​

1. Always Check Integrity​

solution = fusion.get_solution()

if solution.integrity_status == IntegrityStatus.ALERT:
    # Do not use this position!
    use_backup_navigation()
else:
    use_position(solution.position)

2. Enable OSNMA Where Possible​

# Always use OSNMA-authenticated satellites when available
verifier = OSNMAVerifier()
verifier.set_policy(require_authentication=True)

3. Monitor Protection Levels​

levels = raim.get_protection_levels()

if not levels["hpl_valid"] or not levels["vpl_valid"]:
    alert_operator("Protection levels exceeded!")

4. Maintain Audit Trail​

# Every navigation decision should be logged
evidence = fusion.get_evidence_bundle()
audit_logger.log(evidence)

5. Test Regularly​

from navcore.benchmark import FireDrillProtocol

# Run quarterly fire drills
drill = FireDrillProtocol()
drill.execute_scenario("urban_canyon_spoofing")

Troubleshooting​

Common Issues​

"No GNSS Fix"​

Symptom: Solution shows no GNSS data
Check:
  1. Antenna connected and sky-visible
  2. Receiver powered and configured
  3. Check C/N0 levels in /sensors endpoint

"OSNMA Initializing"​

Symptom: OSNMA stuck in initializing state
Check:
  1. At least 4 Galileo satellites in view
  2. Wait up to 2 minutes for key chain acquisition
  3. Check internet connectivity for hot start

"High Protection Levels"​

Symptom: HPL/VPL exceeding alert limits
Check:
  1. Satellite geometry (PDOP)
  2. Number of satellites used
  3. Multipath environment
  4. Consider adding quantum sensors

"Spoof Detection Alert"​

Symptom: System reporting spoofing
Action:
  1. Verify with quantum sensors if available
  2. Check for legitimate causes (simulator, testing)
  3. Engage holdover mode
  4. Report incident per NIS2

Getting Help​

Appendix​

A. Glossary​

TermDefinition
GNSSGlobal Navigation Satellite System
PNTPosition, Navigation, and Timing
RAIMReceiver Autonomous Integrity Monitoring
OSNMAOpen Service Navigation Message Authentication
HPL/VPLHorizontal/Vertical Protection Level
HAL/VALHorizontal/Vertical Alert Limit
NIS2Network and Information Security Directive 2
SOSASensor Open Systems Architecture
FACEFuture Airborne Capability Environment
VICTORYVehicle Integration for C4ISR/EW Interoperability

B. References​

  1. EASA GNSS Interference Mitigation Guidelines
  2. Galileo OSNMA SIS ICD v1.0
  3. EU NIS2 Directive 2022/2555
  4. IEEE P1952 PNT Resilience Standard (draft)
  5. DHS PNT Security Best Practices

C. Version History​

VersionDateChanges
1.0.02024-12-20Initial release

This documentation is for QCOS NavCore™. For licensing information, contact sales@softquantus.com