QCOS NavCore™ Code Examples

Practical examples for common use cases

Basic Navigation
Integrity Monitoring
Quantum Sensor Integration
OSNMA Authentication
NIS2 Compliance
Quantum RAIM
API Client Examples
Full Application Examples

Simple Position Fix

"""
Example: Basic position fix with integrity monitoring
"""

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

# Create sensors
gnss = GNSSReceiver(
    sensor_id="GNSS-001",
    manufacturer="u-blox",
    model="ZED-F9P",
    constellations=["GPS", "Galileo", "GLONASS"],
)

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

# Create integrity monitor
monitor = IntegrityMonitor()

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

# Initialize with known position (or let GNSS acquire)
fusion.initialize(
    position=(51.5074, -0.1278, 100.0),  # London
    timestamp=datetime.now(),
)

# Main navigation loop
while True:
    # Get latest solution
    solution = fusion.get_solution()

    # Check integrity
    if solution.integrity_status == IntegrityStatus.ALERT:
        print("⚠️ INTEGRITY ALERT - Use caution!")
    elif solution.integrity_status == IntegrityStatus.WARNING:
        print("⚡ Integrity degraded")
    else:
        print("✓ Normal operation")

    # Use the position
    print(f"Position: {solution.position}")
    print(f"  Lat: {solution.position.latitude_deg:.6f}°")
    print(f"  Lon: {solution.position.longitude_deg:.6f}°")
    print(f"  Alt: {solution.position.altitude_m:.1f}m")
    print(f"  Uncertainty: {solution.position.sigma_horizontal_m:.2f}m")

    # Wait for next epoch
    time.sleep(1.0)

Multi-Constellation GNSS

"""
Example: Multi-constellation GNSS with SBAS augmentation
"""

from navcore import GNSSReceiver, FusionEngine

# Create multi-constellation receiver
receiver = GNSSReceiver(
    sensor_id="GNSS-MC-001",
    manufacturer="Septentrio",
    model="AsteRx-U",
    constellations=["GPS", "Galileo", "GLONASS", "BeiDou"],
    sbas_enabled=True,
    sbas_system="EGNOS",  # Europe
)

# Configure for RTK if base station available
receiver.configure_rtk(
    base_station_ip="192.168.1.100",
    base_station_port=2101,
    mountpoint="RTCM3",
)

# Create fusion engine
fusion = FusionEngine()
fusion.add_sensor(receiver)

# Get RTK-precision position
solution = fusion.get_solution()

if solution.rtk_fixed:
    print(f"RTK Fixed: {solution.position.sigma_horizontal_m * 100:.1f}cm accuracy")
else:
    print(f"Float solution: {solution.position.sigma_horizontal_m:.2f}m accuracy")

Integrity Monitoring

Spoof Detection

"""
Example: Real-time spoof detection
"""

from navcore import IntegrityMonitor, FaultFlags

monitor = IntegrityMonitor()

def check_for_spoofing(gnss_data, imu_data, clock_data):
    """Check current measurements for spoofing indicators."""

    # Run consistency checks
    result = monitor.check_spoofing_indicators(
        gnss_data=gnss_data,
        imu_data=imu_data,
        clock_data=clock_data,
    )

    if result.spoof_suspected:
        print("🚨 SPOOFING SUSPECTED!")
        print(f"   Confidence: {result.confidence:.1%}")
        print("   Indicators:")
        for indicator in result.indicators:
            print(f"     - {indicator}")

        # Get recommended action
        if result.confidence > 0.8:
            print("   ACTION: Switch to holdover mode immediately")
        else:
            print("   ACTION: Increase monitoring, verify with quantum sensors")

        return True

    return False

# Example: Check position jump (classic spoof indicator)
def check_position_jump(current_pos, previous_pos, dt_seconds):
    """Detect impossible position jumps."""

    result = monitor.check_position_consistency(
        current_pos=current_pos,
        previous_pos=previous_pos,
        time_delta_s=dt_seconds,
        max_velocity_ms=350.0,  # ~1260 km/h for aircraft
    )

    if not result["consistent"]:
        print(f"⚠️ Position jump detected!")
        print(f"   Distance: {result['distance_m']:.0f}m in {dt_seconds}s")
        print(f"   Implied velocity: {result['implied_velocity_ms']:.0f} m/s")
        return True

    return False

Jam Detection

"""
Example: RF jamming detection
"""

from navcore import IntegrityMonitor

monitor = IntegrityMonitor()

def detect_jamming(cn0_values, agc_values, baseline_cn0=45.0):
    """Detect RF jamming based on signal metrics."""

    result = monitor.check_jamming_indicators(
        cn0_values=cn0_values,
        agc_values=agc_values,
        expected_cn0=baseline_cn0,
    )

    if result.jam_detected:
        print("🔴 JAMMING DETECTED!")
        print(f"   Severity: {result.severity}")
        print(f"   Affected satellites: {len(result.affected_svs)}")
        print(f"   C/N0 drop: {result.cn0_drop_db:.1f} dB")

        if result.severity == "high":
            print("   ACTION: Engage holdover mode")
        else:
            print("   ACTION: Monitor situation")

    return result

# Example usage
cn0_samples = [45.0, 44.0, 20.0, 15.0, 10.0]  # Sudden drop
agc_samples = [50, 55, 80, 95, 100]  # AGC saturation

result = detect_jamming(cn0_samples, agc_samples)

Holdover Management

"""
Example: Automatic holdover mode management
"""

from navcore import FusionEngine, IntegrityMonitor, HoldoverManager

fusion = FusionEngine()
monitor = IntegrityMonitor()
holdover = HoldoverManager(clock_type="OCXO", holdover_budget_s=3600)

class NavigationController:
    def __init__(self):
        self.mode = "normal"
        self.holdover_start = None

    def update(self, gnss_available, gnss_data=None):
        """Update navigation mode based on GNSS availability."""

        if gnss_available and self.mode == "holdover":
            # Transition back to normal mode
            self.mode = "normal"
            holdover.reset()
            print("✓ GNSS recovered - resuming normal operation")

        elif not gnss_available and self.mode == "normal":
            # Enter holdover mode
            self.mode = "holdover"
            self.holdover_start = datetime.now()
            print("⚠️ GNSS denied - entering holdover mode")

        if self.mode == "holdover":
            # Check holdover budget
            status = holdover.get_status()

            print(f"📡 Holdover mode: {status.elapsed_s:.0f}s / {status.budget_s:.0f}s")
            print(f"   Position drift: {status.position_drift_m:.1f}m")
            print(f"   Time drift: {status.time_drift_ns:.1f}ns")

            if status.budget_exceeded:
                print("🔴 HOLDOVER BUDGET EXCEEDED - accuracy degraded")

# Usage
controller = NavigationController()

# Simulate GNSS loss
controller.update(gnss_available=True)
time.sleep(5)
controller.update(gnss_available=False)  # Lost GNSS
time.sleep(10)
controller.update(gnss_available=False)  # Still denied
controller.update(gnss_available=True)   # Recovered

Quantum Sensor Integration

Quantum Gravimeter

"""
Example: Quantum gravimeter integration for vertical reference
"""

from navcore import (
    QuantumGravimeter,
    FusionEngine,
    QECEngine,  # Short alias for QuantumErrorCorrectionEngine
)

# Create quantum gravimeter
gravimeter = QuantumGravimeter(
    sensor_id="QG-001",
    manufacturer="SoftQuantus",
    model="QGRAV-1000",
    atom_species="Rb-87",
    interrogation_time_us=100,
)

# Create QEC engine for noise suppression
qec = QECEngine()

# Create fusion engine with quantum sensor
fusion = FusionEngine()
fusion.add_sensor(gravimeter, role="quantum_truth")

def process_gravity_measurement(raw_data):
    """Process quantum gravimeter measurement with error correction."""

    # Characterize noise environment
    noise = qec.characterize_noise(
        sensor_id="QG-001",
        time_series=raw_data,
        sample_rate=100.0,
    )

    # Select optimal decoupling sequence
    sequence = qec.select_optimal_sequence(
        sensor_id="QG-001",
        interrogation_time_us=100.0,
    )

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

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

    return result

# Use gravity for altitude verification
def verify_altitude(gnss_altitude, gravity_reading):
    """Verify GNSS altitude using quantum gravimeter."""

    # Calculate expected gravity at altitude
    g0 = 9.80665  # m/s² at sea level
    R = 6371000   # Earth radius in meters
    expected_g = g0 * (R / (R + gnss_altitude)) ** 2

    # Compare with measurement
    difference = abs(gravity_reading - expected_g)

    # At 1 µGal precision, we can detect ~3m altitude change
    altitude_uncertainty = difference / (2 * g0 / R)

    if altitude_uncertainty > 10:  # More than 10m discrepancy
        print(f"⚠️ Altitude discrepancy detected: {altitude_uncertainty:.1f}m")
        return False

    print(f"✓ Altitude verified within {altitude_uncertainty:.1f}m")
    return True

Optical Atomic Clock

"""
Example: Optical atomic clock for timing assurance
"""

from navcore import OpticalAtomicClock, TimingNetwork

# Create optical atomic clock
clock = OpticalAtomicClock(
    sensor_id="OAC-001",
    manufacturer="SoftQuantus",
    model="OPTCLOCK-18",
    transition="Sr-87",  # Strontium lattice clock
    stability=1e-18,
)

# Add to timing network
timing = TimingNetwork()
timing.add_primary_reference(clock)

def verify_gnss_time(gnss_time, gnss_uncertainty_ns):
    """Verify GNSS time against optical clock."""

    # Get atomic clock time
    atomic_time = clock.get_time()

    # Compare
    offset_ns = (gnss_time - atomic_time).total_seconds() * 1e9

    # Optical clock has ~1ps uncertainty, GNSS typically 10-50ns
    if abs(offset_ns) > 3 * gnss_uncertainty_ns:
        print(f"⚠️ Time offset exceeds expected: {offset_ns:.1f}ns")
        print("   Possible time spoofing attack")
        return False

    print(f"✓ Time verified: offset {offset_ns:.1f}ns")
    return True

OSNMA Authentication

Basic OSNMA Verification

"""
Example: OSNMA authentication for Galileo signals
"""

from navcore import OSNMAVerifier, OSNMAStatus

# Create OSNMA verifier
verifier = OSNMAVerifier()

# Wait for initialization
print("Initializing OSNMA...")
while verifier.get_status() == OSNMAStatus.INITIALIZING:
    time.sleep(1)
    print("  Acquiring key chain...")

print("✓ OSNMA operational")

def process_galileo_message(svid, nav_data, osnma_data, tow, wn):
    """Process and authenticate Galileo navigation message."""

    result = verifier.verify_message(
        svid=svid,
        subframe_data=nav_data,
        osnma_data=osnma_data,
        tow=tow,
        wn=wn,
    )

    if result.verified:
        print(f"✓ E{svid}: Message authenticated")
        return True
    else:
        print(f"✗ E{svid}: Authentication FAILED")
        print(f"  Reason: {result.failure_reason}")

        # Exclude from solution
        return False

# Monitor satellite authentication status
def print_satellite_status():
    """Print authentication status for all satellites."""

    print("\nSatellite Authentication Status:")
    print("-" * 40)

    for svid, status in verifier.satellite_status.items():
        symbol = "✓" if status.value == "authenticated" else "○"
        print(f"  E{svid:02d}: {symbol} {status.value}")

    stats = verifier.get_statistics()
    print("-" * 40)
    print(f"Authenticated: {stats.authenticated}/{stats.total}")
    print(f"Authentication rate: {stats.rate:.1%}")

OSNMA with Smart Tachograph Compliance

"""
Example: EU Smart Tachograph compliance with OSNMA
"""

from navcore import OSNMAVerifier, NIS2ComplianceManager
from datetime import datetime

class SmartTachographCompliance:
    """Ensure EU Smart Tachograph GNSS authentication requirements."""

    def __init__(self):
        self.osnma = OSNMAVerifier()
        self.compliance = NIS2ComplianceManager(
            entity_type="essential",
            sector="transport",
        )
        self.authentication_log = []

    def record_position(self, position, gnss_data, osnma_data):
        """Record authenticated position for tachograph."""

        # Verify with OSNMA
        auth_result = self.osnma.verify_message(
            svid=gnss_data["svid"],
            subframe_data=gnss_data["nav_data"],
            osnma_data=osnma_data,
            tow=gnss_data["tow"],
            wn=gnss_data["wn"],
        )

        # Create tachograph record
        record = {
            "timestamp": datetime.now().isoformat(),
            "position": position,
            "authenticated": auth_result.verified,
            "satellites_authenticated": self.osnma.authenticated_count,
            "authentication_rate": self.osnma.authentication_rate,
            "evidence_id": auth_result.evidence_id,
        }

        self.authentication_log.append(record)

        # EU requirement: Record every 3 hours minimum
        if not auth_result.verified:
            print("⚠️ Position recorded WITHOUT authentication")
            print("   Tachograph may reject this record")
        else:
            print("✓ Authenticated position recorded")

        return record

    def export_compliance_report(self):
        """Export compliance report for regulatory inspection."""

        report = {
            "period_start": self.authentication_log[0]["timestamp"],
            "period_end": self.authentication_log[-1]["timestamp"],
            "total_records": len(self.authentication_log),
            "authenticated_records": sum(1 for r in self.authentication_log if r["authenticated"]),
            "authentication_rate": sum(1 for r in self.authentication_log if r["authenticated"]) / len(self.authentication_log),
            "osnma_status": "compliant" if self.osnma.authentication_rate > 0.8 else "non_compliant",
        }

        return report

NIS2 Compliance

Compliance Assessment

"""
Example: NIS2 compliance assessment for transport operator
"""

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

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

def run_compliance_assessment():
    """Run full NIS2 compliance assessment."""

    print("=" * 60)
    print("NIS2 Compliance Assessment Report")
    print("=" * 60)

    # Get assessment
    assessment = manager.assess_compliance()

    print(f"\nEntity Type: {assessment.entity_type}")
    print(f"Sector: {assessment.sector}")
    print(f"Overall Status: {assessment.status}")
    print(f"Compliance Score: {assessment.score:.1f}%")

    # Article 21 breakdown
    print("\nArticle 21 Requirements:")
    print("-" * 60)

    for req in ARTICLE_21_REQUIREMENTS:
        status = manager.get_requirement_status(req.id)
        symbol = "✓" if status.value == "compliant" else "○"
        print(f"  {symbol} {req.id}: {req.name}")
        print(f"      Status: {status.value}")

    # Identify gaps
    gaps = manager.identify_gaps()

    if gaps:
        print(f"\n⚠️ {len(gaps)} Compliance Gaps Identified:")
        print("-" * 60)

        for gap in gaps:
            print(f"\n  {gap.requirement_id}: {gap.requirement_name}")
            print(f"    Risk Level: {gap.risk_level}")
            print(f"    Effort: {gap.effort_days} days")
            print(f"    Remediation:")
            for step in gap.remediation_steps:
                print(f"      - {step}")
    else:
        print("\n✓ No compliance gaps identified")

    return assessment

# Run assessment
assessment = run_compliance_assessment()

Incident Reporting

"""
Example: NIS2-compliant incident reporting
"""

from navcore.compliance import (
    NIS2ComplianceManager,
    NIS2Incident,
    IncidentCategory,
    IncidentSeverity,
)
from datetime import datetime, timedelta

manager = NIS2ComplianceManager(
    entity_type="essential",
    sector="transport",
)

def report_security_incident(
    title: str,
    description: str,
    severity: str,
    affected_systems: list,
):
    """Report a security incident per NIS2 requirements."""

    # Create incident
    incident = NIS2Incident(
        id=f"INC-{datetime.now().strftime('%Y%m%d%H%M%S')}",
        category=IncidentCategory.AVAILABILITY,
        severity=IncidentSeverity[severity.upper()],
        title=title,
        description=description,
        affected_systems=affected_systems,
        detection_time=datetime.now(),
        report_time=datetime.now(),
    )

    # Record incident
    result = manager.record_incident(incident)

    print(f"🚨 Incident Reported: {incident.id}")
    print(f"   Severity: {severity}")
    print(f"   Category: {incident.category.value}")

    # NIS2 notification requirements
    if severity in ["HIGH", "CRITICAL"]:
        csirt_deadline = datetime.now() + timedelta(hours=24)
        print(f"\n⚠️ CSIRT Notification Required!")
        print(f"   Deadline: {csirt_deadline.isoformat()}")
        print(f"   Contact your national CSIRT immediately")

    update_deadline = datetime.now() + timedelta(hours=72)
    print(f"\n📋 72-Hour Update Required")
    print(f"   Deadline: {update_deadline.isoformat()}")

    return result

# Example: Report GNSS disruption
report_security_incident(
    title="GNSS Service Disruption - Suspected Jamming",
    description="""
    Complete loss of GNSS signals detected across all operational vehicles
    in the northern sector. C/N0 dropped to zero on all satellites.
    Suspected RF jamming attack. Vehicles operating in holdover mode.
    """,
    severity="HIGH",
    affected_systems=["NAV-001", "NAV-002", "NAV-003", "CENTRAL-DISPATCH"],
)

Quantum RAIM

Basic Quantum RAIM

"""
Example: Quantum RAIM integrity monitoring
"""

from navcore.quantum_raim import (
    QuantumRAIMEngine,
    RAIMState,
    ThreatLevel,
)

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

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

def process_navigation_epoch(gnss_data, quantum_data, imu_data):
    """Process navigation epoch with Quantum RAIM."""

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

    # Check RAIM state
    print(f"RAIM State: {result.state}")

    # Check protection levels
    print(f"Protection Levels:")
    print(f"  HPL: {result.hpl_m:.1f}m (limit: 40m) {'✓' if result.hpl_valid else '✗'}")
    print(f"  VPL: {result.vpl_m:.1f}m (limit: 35m) {'✓' if result.vpl_valid else '✗'}")

    # Check for threats
    if result.threats_detected:
        print(f"\n⚠️ THREATS DETECTED:")
        for threat in result.threats:
            print(f"  - {threat.type}: {threat.confidence:.1%} confidence")
            if threat.quantum_confirmed:
                print(f"    🔬 Confirmed by quantum sensor")

    # Position is safe to use if:
    if result.state == RAIMState.AVAILABLE and result.hpl_valid and result.vpl_valid:
        print("\n✓ Position integrity assured")
        return result.position
    else:
        print("\n⚠️ Position integrity NOT assured - use with caution")
        return None

Spoof Detection with Quantum Verification

"""
Example: Detecting carry-off spoofing attacks with quantum sensors
"""

from navcore.quantum_raim import QuantumRAIMEngine, AttackType

raim = QuantumRAIMEngine(
    integrity_risk_target=1e-7,
    horizontal_alert_limit_m=40.0,
    vertical_alert_limit_m=35.0,
)

class CarryOffDetector:
    """Detect slow-drift carry-off spoofing attacks."""

    def __init__(self, raim_engine):
        self.raim = raim_engine
        self.position_history = []
        self.gravity_history = []

    def check_for_carry_off(self, gnss_position, gravity_reading):
        """Check for carry-off attack using quantum gravimeter."""

        # Store history
        self.position_history.append(gnss_position)
        self.gravity_history.append(gravity_reading)

        # Need history for drift detection
        if len(self.position_history) < 10:
            return None

        # Calculate implied altitude change from GNSS
        gnss_altitude_change = (
            self.position_history[-1]["altitude"] -
            self.position_history[0]["altitude"]
        )

        # Calculate implied altitude change from gravity
        g0 = 9.80665
        R = 6371000

        gravity_delta = self.gravity_history[-1] - self.gravity_history[0]
        gravity_implied_altitude_change = -gravity_delta * R**2 / (2 * g0)

        # Compare
        discrepancy = abs(gnss_altitude_change - gravity_implied_altitude_change)

        if discrepancy > 50:  # 50m threshold
            print(f"🚨 CARRY-OFF ATTACK DETECTED!")
            print(f"   GNSS claims altitude change: {gnss_altitude_change:.1f}m")
            print(f"   Gravity indicates altitude change: {gravity_implied_altitude_change:.1f}m")
            print(f"   Discrepancy: {discrepancy:.1f}m")
            print(f"\n   Quantum sensor proves GNSS is being spoofed!")

            return {
                "attack_type": AttackType.SPOOFING_CARRY_OFF,
                "confidence": min(discrepancy / 100, 0.99),
                "gnss_altitude_change": gnss_altitude_change,
                "true_altitude_change": gravity_implied_altitude_change,
            }

        return None

API Client Examples

Python Requests

"""
Example: NavCore API client using Python requests
"""

import requests
from datetime import datetime

class NavCoreClient:
    """Simple NavCore API client."""

    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def get_status(self) -> dict:
        """Get system status."""
        response = requests.get(
            f"{self.base_url}/api/v1/navcore/status",
            headers=self.headers,
        )
        response.raise_for_status()
        return response.json()

    def get_solution(self) -> dict:
        """Get navigation solution."""
        response = requests.get(
            f"{self.base_url}/api/v1/navcore/solution",
            headers=self.headers,
        )
        response.raise_for_status()
        return response.json()

    def get_protection_levels(self) -> dict:
        """Get RAIM protection levels."""
        response = requests.get(
            f"{self.base_url}/api/v1/navcore/raim/protection",
            headers=self.headers,
        )
        response.raise_for_status()
        return response.json()

    def report_incident(self, incident: dict) -> dict:
        """Report NIS2 incident."""
        response = requests.post(
            f"{self.base_url}/api/v1/navcore/compliance/nis2/incident",
            headers=self.headers,
            json=incident,
        )
        response.raise_for_status()
        return response.json()

# Usage
client = NavCoreClient("http://localhost:8000", "your-api-key")

# Get current solution
solution = client.get_solution()
print(f"Position: {solution['position']['latitude_deg']}, {solution['position']['longitude_deg']}")

# Check protection levels
levels = client.get_protection_levels()
if levels["hpl_valid"] and levels["vpl_valid"]:
    print("✓ Integrity assured")

cURL Examples

#!/bin/bash
# NavCore API cURL examples

API_URL="http://localhost:8000"
API_KEY="your-api-key"

# Get status
curl -s -H "Authorization: Bearer $API_KEY" \
  "$API_URL/api/v1/navcore/status" | jq

# Get navigation solution
curl -s -H "Authorization: Bearer $API_KEY" \
  "$API_URL/api/v1/navcore/solution" | jq

# Get OSNMA status
curl -s -H "Authorization: Bearer $API_KEY" \
  "$API_URL/api/v1/navcore/compliance/osnma/status" | jq

# Get RAIM protection levels
curl -s -H "Authorization: Bearer $API_KEY" \
  "$API_URL/api/v1/navcore/raim/protection" | jq

# Report incident
curl -s -X POST \
  -H "Authorization: Bearer $API_KEY" \
  -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"
  }' \
  "$API_URL/api/v1/navcore/compliance/nis2/incident" | jq

Full Application Examples

Maritime PNT System

"""
Example: Complete maritime PNT system with NavCore
"""

from navcore import (
    FusionEngine,
    IntegrityMonitor,
    OSNMAVerifier,
    QuantumRAIMEngine,
    GNSSReceiver,
    IMU,
    Barometer,
)

class MaritimePNTSystem:
    """Maritime PNT system with IMO A.915(22) compliance."""

    def __init__(self):
        # Sensors
        self.gnss = GNSSReceiver(
            sensor_id="GNSS-001",
            manufacturer="Furuno",
            model="GP-170",
            constellations=["GPS", "Galileo", "GLONASS"],
        )
        self.imu = IMU(
            sensor_id="IMU-001",
            manufacturer="Kongsberg",
            model="MRU-5+",
        )
        self.baro = Barometer(sensor_id="BARO-001")

        # Core components
        self.fusion = FusionEngine()
        self.integrity = IntegrityMonitor()
        self.osnma = OSNMAVerifier()
        self.raim = QuantumRAIMEngine(
            integrity_risk_target=1e-5,  # Maritime standard
            horizontal_alert_limit_m=25.0,
            vertical_alert_limit_m=30.0,
        )

        # Add sensors
        self.fusion.add_sensor(self.gnss)
        self.fusion.add_sensor(self.imu)
        self.fusion.add_sensor(self.baro)

    def get_navigation_data(self) -> dict:
        """Get navigation data for ECDIS/VDR."""

        solution = self.fusion.get_solution()

        # IMO A.915(22) requires:
        # - Position accuracy
        # - Integrity information
        # - System status

        return {
            "position": {
                "latitude": solution.position.latitude_deg,
                "longitude": solution.position.longitude_deg,
                "accuracy_m": solution.position.sigma_horizontal_m,
            },
            "course_over_ground": solution.velocity.ground_track_deg,
            "speed_over_ground": solution.velocity.ground_speed_ms * 1.944,  # knots
            "heading": solution.attitude.heading_deg,
            "integrity": {
                "status": solution.integrity_status.value,
                "raim_available": self.raim.get_status()["integrity_available"],
            },
            "time_utc": solution.time.utc.isoformat(),
        }

    def check_safety_critical(self) -> bool:
        """Check if navigation is safe for critical operations."""

        raim_status = self.raim.get_status()
        levels = self.raim.get_protection_levels()

        # For port approach, require:
        # - RAIM available
        # - HPL < 10m
        # - No active threats

        safe = (
            raim_status["integrity_available"] and
            levels["hpl_m"] < 10.0 and
            not raim_status["fault_detected"]
        )

        if not safe:
            print("⚠️ Navigation not suitable for safety-critical operations")

        return safe

# Usage
pnt = MaritimePNTSystem()

while True:
    nav_data = pnt.get_navigation_data()

    if pnt.check_safety_critical():
        # Safe for port approach
        pass
    else:
        # Reduce speed, increase watch
        pass

    time.sleep(1.0)

These examples are for QCOS NavCore™. For licensing information, contact sales@softquantus.com

Table of Contents​

Basic Navigation​

Simple Position Fix​

Multi-Constellation GNSS​

Integrity Monitoring​

Spoof Detection​

Jam Detection​

Holdover Management​

Quantum Sensor Integration​

Quantum Gravimeter​

Optical Atomic Clock​

OSNMA Authentication​

Basic OSNMA Verification​

OSNMA with Smart Tachograph Compliance​

NIS2 Compliance​

Compliance Assessment​

Incident Reporting​

Quantum RAIM​

Basic Quantum RAIM​

Spoof Detection with Quantum Verification​

API Client Examples​

Python Requests​

cURL Examples​

Full Application Examples​

Maritime PNT System​

Table of Contents

Basic Navigation

Simple Position Fix

Multi-Constellation GNSS

Integrity Monitoring

Spoof Detection

Jam Detection

Holdover Management

Quantum Sensor Integration

Quantum Gravimeter

Optical Atomic Clock

OSNMA Authentication

Basic OSNMA Verification

OSNMA with Smart Tachograph Compliance

NIS2 Compliance

Compliance Assessment

Incident Reporting

Quantum RAIM

Basic Quantum RAIM

Spoof Detection with Quantum Verification

API Client Examples

Python Requests

cURL Examples

Full Application Examples

Maritime PNT System