Appearance
Source files: 3 | Classes: 15 | Methods: 5 | Enums: 6
GTOS.Navigation.Behaviours
NavigationBehaviors
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)
NavigationAtomics
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>
NavigationConstants
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
NavigationMode
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/π)
NavigationEntity
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
NavigationState
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

