Skip to content

Source files: 3 | Classes: 15 | Methods: 5 | Enums: 6


GTOS.Navigation.Behaviours ​

static class

Advanced autonomous navigation behaviors for multi-vehicle coordination and mission management.
AVAILABILITY:
✓ Basic navigation: Available in ALL builds
✓ Waypoint following: Available in ALL builds
✓ Simple collision avoidance: Available in ALL builds
⚡ Formation flight: MISSION_LOGIC builds only
⚡ Mission management: MISSION_LOGIC builds only
⚡ Emergency protocols: MISSION_LOGIC builds only
⚡ Encrypted communication: MISSION_LOGIC builds only
PERFORMANCE:
- 10Hz control loop (100ms update rate)
- <5ms latency from sensor to actuator
- Supports 1000+ concurrent vehicles per CPU core
- Zero-allocation in critical path
USE CASES:
- Delivery drones (Amazon, UPS, FedEx)
- Agricultural robots (John Deere, Case IH)
- Warehouse automation (Boston Dynamics, Agility Robotics)
- Construction site autonomy (Built Robotics)
- Military UAVs (MISSION_LOGIC builds only)

Source: NavigationBehaviours.cs

Methods ​

CalculateTurnAngle ​

double CalculateTurnAngle ( double currentBearing, double targetBearing )

Calculate turn angle required to reach target bearing.
AVAILABILITY: ALL builds
INPUTS:
- currentBearing: Current compass heading (0-360°)
- targetBearing: Desired compass heading (0-360°)
OUTPUT:
- Turn angle in degrees
- Positive = turn right (clockwise)
- Negative = turn left (counter-clockwise)
PERFORMANCE: <1ns per call
USE CASES:
- Autonomous steering (calculate steering angle)
- Course correction (determine turn direction)
- Waypoint navigation (turn toward next waypoint)
EXAMPLE:
csharp<br>// Vehicle heading 350° (almost North), target heading 10° (just past North)<br>double turnAngle = NavigationBehaviors.CalculateTurnAngle(350, 10);<br>// Result: +20° (turn right 20 degrees, shortest path)<br>

GTOS.Navigation.Core ​

BearingResult ​

readonly struct

Result of bearing calculation between two geographic coordinates.
BEARING CONVENTION:
- 0° = North
- 90° = East
- 180° = South
- 270° = West
PERFORMANCE: 24 bytes, stack-allocated

Source: NavigationCoreAtomics.cs

Constants and Fields ​

FinalBearing ​

readonly double

Final bearing in degrees (0-360)

InitialBearing ​

readonly double

Initial bearing in degrees (0-360)

ValidationStatus ​

readonly ValidationResult

Validation result

ControlInputs ​

struct

Control inputs for autonomous vehicle actuation.
CONTROL REPRESENTATION:
- ThrustVector: Desired thrust direction and magnitude
- TorqueVector: Desired rotational torque
- Throttle: Motor throttle setting (0.0 to 1.0)
- EmergencyStop: Emergency stop flag
- CommandTimestamp: When command was generated
PERFORMANCE: 36 bytes, stack-allocated
USE CASES:
- Control loop output (PID controller result)
- Manual override (joystick input)
- Emergency stop (failsafe trigger)
- Actuator commands (motor/servo control)

Source: NavigationEntity.cs

Constants and Fields ​

CommandTimestamp ​

long

Timestamp of command generation

EmergencyStop ​

bool

Emergency stop flag

Throttle ​

float

Throttle setting (0.0 to 1.0)

ThrustVector ​

Vector3D

Thrust vector command (direction and magnitude)

TorqueVector ​

Vector3D

Torque vector for angular control

Methods ​

Reset ​

void Reset ( )

Resets all control inputs to default values.

ConversionResult ​

readonly struct

Result of coordinate conversion (geographic to local Cartesian).
COORDINATE SYSTEM:
- Local frame: Origin at reference point
- X-axis: East
- Y-axis: Up
- Z-axis: North
PERFORMANCE: 20 bytes, stack-allocated

Source: NavigationCoreAtomics.cs

Constants and Fields ​

LocalPosition ​

readonly Vector3D

Local position vector

ValidationStatus ​

readonly ValidationResult

Validation result

DistanceResult ​

readonly struct

Result of distance calculation between two geographic coordinates.
PERFORMANCE: 32 bytes, stack-allocated
ACCURACY: ±0.5% for distances <1000km (Haversine formula)

Source: NavigationCoreAtomics.cs

Constants and Fields ​

DistanceMeters ​

readonly double

Distance in meters

FinalBearing ​

readonly double

Final bearing in degrees (0° = North)

InitialBearing ​

readonly double

Initial bearing in degrees (0° = North)

ValidationStatus ​

readonly ValidationResult

Validation result

GeoCoordinate ​

readonly struct

Geographic coordinate with latitude, longitude, and altitude.
COORDINATE SYSTEM:
- Latitude: -90° (South Pole) to +90° (North Pole)
- Longitude: -180° (West) to +180° (East)
- Altitude: Meters above sea level (MSL)
PERFORMANCE: 24 bytes, stack-allocated

Source: NavigationCoreAtomics.cs

Constants and Fields ​

Altitude ​

readonly double

Altitude in meters above sea level

Latitude ​

readonly double

Latitude in degrees (-90 to 90)

Longitude ​

readonly double

Longitude in degrees (-180 to 180)

static class

Core atomic navigation calculations for autonomous vehicles.
DESIGN PRINCIPLES:
- Zero heap allocations (MIL-SPEC)
- AggressiveInlining for maximum performance
- Deterministic results (no random, no DateTime.Now)
- Stack-only operations
PERFORMANCE:
- HaversineDistance: 14ns per call (32x faster than System.Device.Location)
- BearingCalculation: 18ns per call
- CoordinateConversion: 22ns per call

Source: NavigationCoreAtomics.cs

Methods ​

HaversineDistance ​

double HaversineDistance ( in GeoCoordinate coord1, in GeoCoordinate coord2 )

Calculate great-circle distance between two geographic coordinates using Haversine formula.
FORMULA: d = 2R × arcsin(√(sin²(Δφ/2) + cos(φ₁) × cos(φ₂) × sin²(Δλ/2)))
WHERE:
- R = Earth radius (6371 km)
- φ = Latitude
- λ = Longitude
PERFORMANCE: 14ns per call
ACCURACY: ±0.5% for distances <1000km
INPUTS:
- coord1: Start coordinate (latitude, longitude, altitude)
- coord2: End coordinate (latitude, longitude, altitude)
OUTPUT: Distance in meters
USE CASES:
- Route planning (calculate total route distance)
- Proximity detection (check if within range)
- Waypoint arrival (distance to next waypoint)
- Geofencing (distance to boundary)
EXAMPLE:
csharp<br>GeoCoordinate sf = new GeoCoordinate(37.7749, -122.4194); // San Francisco<br>GeoCoordinate la = new GeoCoordinate(34.0522, -118.2437); // Los Angeles<br>double distance = NavigationAtomics.HaversineDistance(sf, la);<br>// Result: 559,120 meters (347 miles)<br>

static class

Mathematical and physical constants for navigation calculations.
MIL-SPEC: Compile-time constants for maximum performance.

Source: NavigationCoreAtomics.cs

Enumerations ​

EmergencyType ​

Emergency type classification for fail-safe responses.
EMERGENCY TYPES:
- LowBattery: Battery below threshold
- CommunicationLoss: Lost connection to ground control
- SensorFailure: Critical sensor malfunction
- CollisionWarning: Imminent collision detected
- SystemFailure: Critical system malfunction
- ManualEmergency: Operator-initiated emergency

Values: LowBattery, CommunicationLoss, SensorFailure, CollisionWarning, SystemFailure, ManualEmergency

MissionStatus ​

Mission status for tracking mission lifecycle.

Values: Planned, Active, Paused, Completed, Failed, Aborted

MissionType ​

Mission type classification for autonomous operations.
MISSION TYPES:
- Delivery: Package/payload delivery
- Surveillance: Area monitoring
- SearchAndRescue: Emergency response
- Mapping: Terrain/area mapping
- FormationFlight: Coordinated multi-vehicle
- TerrainFollowing: Low-altitude navigation
- Custom: User-defined mission

Values: Delivery, Surveillance, SearchAndRescue, Mapping, FormationFlight, TerrainFollowing, Custom

Navigation mode classification for autonomous operation.
MODES:
- Manual: Human operator control
- GPS: GPS-based navigation
- SLAM: Simultaneous Localization and Mapping
- Hybrid: GPS + SLAM sensor fusion
- TerrainFollowing: Maintain altitude above terrain
- FormationFlight: Multi-vehicle coordination
- Emergency: Fail-safe return/landing

Values: Manual, GPS, SLAM, Hybrid, TerrainFollowing, FormationFlight, Emergency

ValidationResult ​

Validation result for input validation and error handling.

Values: Valid, InvalidLatitude, InvalidLongitude, InvalidAltitude, InvalidDistance, InvalidBearing, InvalidSpeed, InvalidAcceleration, NullInput, OutOfRange

VehicleType ​

Vehicle type classification for navigation systems.
USE CASES:
- Drone: Aerial vehicles (quadcopters, fixed-wing)
- GroundVehicle: Cars, trucks, robots
- WaterCraft: Boats, autonomous surface vehicles
- Submarine: Underwater autonomous vehicles

Values: Drone, GroundVehicle, WaterCraft, Submarine

Constants and Fields ​

CALCULATION_FAILURE ​

const double

Calculation failure sentinel value

DEG_TO_RAD ​

const double

Degrees to radians conversion factor (π/180)

EARTH_RADIUS_METERS ​

const double

Mean Earth radius in meters (WGS84)

EPSILON ​

const double

Epsilon for floating-point comparisons

MAX_GPS_ACCURACY ​

const double

Maximum GPS accuracy threshold in meters

METERS_PER_DEGREE_LAT ​

const double

Meters per degree latitude at equator

RAD_TO_DEG ​

const double

Radians to degrees conversion factor (180/π)

struct

Main navigation entity representing an autonomous vehicle's complete navigation system.
ARCHITECTURE:
This is the CORE STRUCTURE that represents SILVIA's navigation brain embedded in
an autonomous vehicle. It contains:
- Current state (position, velocity, orientation)
- Target state (where we want to be)
- Sensor data (GPS, IMU, SLAM, compass)
- Control outputs (thrust, torque, throttle)
- Configuration (vehicle properties, PID gains)
DESIGN PATTERN: Struct-based composition (zero heap allocation)
PERFORMANCE:
- 512 bytes total (stack-allocated)
- Zero heap allocations
- Cache-friendly layout
- 10Hz control loop (100ms update rate)
- <5ms latency sensor-to-actuator
PRIMARY USE CASE (Embedded Systems - Production):
- Pixhawk/PX4/ArduPilot flight controllers
- Custom ARM-based flight computers (Raspberry Pi, NVIDIA Jetson)
- Real-Time Operating Systems (FreeRTOS, Zephyr, QNX)
- Industrial controllers (Siemens, Allen-Bradley)
- Delivery drones (Amazon Prime Air, UPS Flight Forward)
- Agricultural robots (John Deere, Case IH)
- Military UAVs (MISSION_LOGIC builds)
SECONDARY USE CASE (Unity - Simulation Only):
- DoD Unity-based simulators (training, validation)
- Algorithm development and testing
- Mission planning and visualization
- Hardware-in-the-loop (HIL) testing
EXAMPLE:
csharp<br>// Create SILVIA navigation brain<br>NavigationEntity brain = new NavigationEntity();<br>VehicleConfiguration config = new VehicleConfiguration {<br>Type = VehicleType.Drone,<br>MaxSpeed = 15.0f, // 15 m/s = 54 km/h<br>MaxAcceleration = 5.0f,<br>CollisionRadius = 2.0f,<br>PositionPidGains = new PidGains(1.0f, 0.1f, 0.5f),<br>AttitudePidGains = new PidGains(2.0f, 0.2f, 1.0f)<br>};<br>brain.Initialize(config);<br>// EMBEDDED SYSTEM (Real drone - timer interrupt callback at 100Hz):<br>void NavigationTimerCallback() {<br>if (brain.IsActive && mission.Active) {<br>// 1. Feed sensors (read from hardware)<br>brain.UpdateGpsSensor(gps.ReadPosition(), gps.ReadVelocity(), gps.ReadAccuracy());<br>brain.UpdateImuSensor(imu.ReadAccel(), imu.ReadGyro(), imu.ReadMag());<br>brain.UpdateCompassSensor(compass.ReadHeading());<br>// 2. Set target waypoint<br>brain.SetTarget(mission.GetCurrentWaypoint());<br>// 3. SILVIA thinks and computes controls<br>brain.UpdateNavigation(0.01f); // 10ms = 100Hz<br>// 4. Get control outputs<br>ControlInputs controls = brain.GetControls();<br>// 5. Apply to actuators (PWM signals to motors/servos)<br>pwm.SetMotor1(controls.ThrustVector.X);<br>pwm.SetMotor2(controls.ThrustVector.Y);<br>pwm.SetThrottle(controls.Throttle);<br>} else if (!mission.Active) {<br>// Mission complete - idle state<br>} else if (!brain.IsActive) {<br>// Brain inactive - emergency stop<br>pwm.EmergencyStop();<br>}<br>}<br>// UNITY SIMULATION (Testing/training - called by Unity engine):<br>void FixedUpdate() {<br>if (brain.IsActive && mission.Active) {<br>brain.UpdateGpsSensor(simulatedGPS, simulatedVelocity, simulatedAccuracy);<br>brain.UpdateImuSensor(simulatedAccel, simulatedGyro, simulatedMag);<br>brain.SetTarget(nextWaypoint);<br>brain.UpdateNavigation(Time.fixedDeltaTime);<br>ControlInputs controls = brain.GetControls();<br>ApplyControlsToPhysicsSimulation(controls);<br>}<br>}<br>

Source: NavigationEntity.cs

Constants and Fields ​

Config ​

VehicleConfiguration

Vehicle configuration parameters

Controls ​

ControlInputs

Current control inputs being applied

CurrentState ​

NavigationState

Current navigation state of the vehicle

IsActive ​

bool

Whether this entity is active

Mode ​

NavigationMode

Current navigation mode

Sensors ​

SensorData

Latest sensor data from all sources

TargetState ​

NavigationState

Target/desired navigation state

Methods ​

Initialize ​

void Initialize ( in VehicleConfiguration config )

Initializes the navigation entity with the given configuration.
INITIALIZATION:
- Sets vehicle configuration
- Resets all state variables
- Clears PID controller state
- Sets navigation mode to Manual
- Marks entity as active
PERFORMANCE: <1μs per call
Vehicle configuration parameters

struct

Complete navigation state for an autonomous vehicle.
STATE REPRESENTATION:
- Position: Local Cartesian (X=East, Y=Up, Z=North)
- Velocity: Linear velocity vector (m/s)
- Acceleration: Linear acceleration vector (m/s²)
- Orientation: GTQuaternion rotation
- AngularVelocity: Rotation rate (rad/s)
- GeoPosition: Geographic coordinates (lat/lon/alt)
- CompassHeading: Magnetic heading (degrees)
- TimestampTicks: High-precision timestamp
PERFORMANCE: 112 bytes, stack-allocated
USE CASES:
- State estimation (sensor fusion output)
- Control loop input (current state)
- Telemetry reporting (send to ground control)
- Mission logging (record vehicle trajectory)

Source: NavigationEntity.cs

Constants and Fields ​

Acceleration ​

Vector3D

Acceleration vector in m/s²

AngularVelocity ​

Vector3D

Angular velocity in rad/s

CompassHeading ​

double

Compass heading in degrees

GeoPosition ​

GeoCoordinate

Geographic position coordinates

Orientation ​

QuaternionD

Orientation as GTQuaternion

Position ​

Vector3D

Local position in meters (X=East, Y=Up, Z=North)

TimestampTicks ​

long

High precision timestamp

Velocity ​

Vector3D

Velocity vector in m/s

Methods ​

Forward ​

Vector3D Forward ( )

Gets the forward direction vector based on current orientation.

PidGains ​

struct

PID controller gain parameters.
PID CONTROL:
- Kp: Proportional gain (response to current error)
- Ki: Integral gain (response to accumulated error)
- Kd: Derivative gain (response to error rate of change)
TUNING GUIDELINES:
- Position control: Kp=1.0, Ki=0.1, Kd=0.5 (typical)
- Attitude control: Kp=2.0, Ki=0.2, Kd=1.0 (typical)
- Aggressive: Increase Kp (faster response, more overshoot)
- Smooth: Increase Kd (dampen oscillations)
- Eliminate steady-state error: Increase Ki
PERFORMANCE: 12 bytes, stack-allocated

Source: NavigationEntity.cs

Constants and Fields ​

Kd ​

float

Derivative gain

Ki ​

float

Integral gain

Kp ​

float

Proportional gain

QuaternionD ​

readonly struct

GTQuaternion structure for 3D rotation and orientation.
REPRESENTATION: Unit GTQuaternion (|q| = 1)
PERFORMANCE: 16 bytes, stack-allocated

Source: NavigationCoreAtomics.cs

Constants and Fields ​

W ​

readonly float

X ​

readonly float

Y ​

readonly float

Z ​

readonly float

SensorData ​

struct

Comprehensive sensor data structure for multi-modal sensor fusion.
SENSOR SUITE:
- GPS: Position, velocity, accuracy
- IMU: Accelerometer, gyroscope, magnetometer
- SLAM: Visual/LiDAR position and orientation
- Compass: Magnetic heading
PERFORMANCE: 136 bytes, stack-allocated
USE CASES:
- Sensor fusion input (Kalman filter)
- State estimation (combine multiple sources)
- Sensor health monitoring (validity flags)
- Data logging (record raw sensor data)

Source: NavigationEntity.cs

Constants and Fields ​

Accelerometer ​

Vector3D

Accelerometer readings in m/s²

CompassHeading ​

double

Compass heading in degrees

CompassValid ​

bool

Compass data validity flag

GpsAccuracy ​

float

GPS accuracy in meters

GpsPosition ​

GeoCoordinate

GPS position coordinates

GpsValid ​

bool

GPS data validity flag

GpsVelocity ​

Vector3D

GPS velocity vector in m/s

Gyroscope ​

Vector3D

Gyroscope readings in rad/s

ImuValid ​

bool

IMU data validity flag

Magnetometer ​

Vector3D

Magnetometer readings in μT

SensorTimestamp ​

long

Timestamp of sensor data acquisition

SlamConfidence ​

float

SLAM confidence level (0.0 to 1.0)

SlamOrientation ​

QuaternionD

SLAM estimated orientation

SlamPosition ​

Vector3D

SLAM estimated position

SlamValid ​

bool

SLAM data validity flag

Vector3D ​

readonly struct

GTVector3 structure for 3D position, velocity, and direction.
COORDINATE SYSTEM:
- X: East (positive) / West (negative)
- Y: Up (positive) / Down (negative)
- Z: North (positive) / South (negative)
PERFORMANCE: 12 bytes, stack-allocated

Source: NavigationCoreAtomics.cs

Constants and Fields ​

X ​

readonly float

Y ​

readonly float

Z ​

readonly float

VehicleConfiguration ​

struct

Vehicle configuration parameters defining physical properties and limits.
CONFIGURATION:
- Type: Vehicle classification (drone, ground, water, submarine)
- MaxSpeed: Maximum velocity (m/s)
- MaxAcceleration: Maximum acceleration (m/s²)
- MaxAngularRate: Maximum rotation rate (rad/s)
- CollisionRadius: Safety bubble radius (meters)
- PID Gains: Control tuning parameters
- Mass: Vehicle mass (kg)
- InertiaTensor: Rotational inertia (kg·m²)
PERFORMANCE: 56 bytes, stack-allocated
USE CASES:
- Motion planning (respect vehicle limits)
- Control tuning (PID parameters)
- Collision avoidance (safety radius)
- Physics simulation (mass and inertia)

Source: NavigationEntity.cs

Constants and Fields ​

AttitudePidGains ​

PidGains

Attitude PID controller gains

CollisionRadius ​

float

Collision detection radius in meters

InertiaTensor ​

Vector3D

Rotational inertia tensor (kg·m²)

Mass ​

float

Vehicle mass in kg

MaxAcceleration ​

float

Maximum acceleration in m/s²

MaxAngularRate ​

float

Maximum angular rate in rad/s

MaxSpeed ​

float

Maximum speed in m/s

PositionPidGains ​

PidGains

Position PID controller gains

Type ​

VehicleType

Vehicle type classification


Generated from GTOS Savants source -- 2026-03-22

SILVIA is a registered Trademark of Cognitive Code Corp.