nav

package
v0.14.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 5, 2026 License: GPL-3.0 Imports: 13 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	NavLogState    = "state"
	NavLogWaypoint = "waypoint"
	NavLogAltitude = "altitude"
	NavLogSpeed    = "speed"
	NavLogHeading  = "heading"
	NavLogApproach = "approach"
	NavLogCommand  = "command"
	NavLogRoute    = "route"
	NavLogHold     = "hold"
)

Available logging categories

View Source 
const (
	PTStateApproaching = iota
	PTStateTurningOutbound
	PTStateFlyingOutbound
	PTStateTurningInbound
	PTStateFlyingInbound // parallel entry only
)
View Source 
const (
	PT45StateApproaching = iota
	PT45StateTurningOutbound
	PT45StateFlyingOutbound
	PT45StateTurningAway
	PT45StateFlyingAway
	PT45StateTurningIn
	PT45StateFlyingIn
	PT45StateTurningToIntercept
)
View Source 
const MaxIAS = 290
View Source 
const MaximumRate = 100000
View Source 
const StandardTurnRate = 3

Variables

View Source 
var (
	ErrClearedForUnexpectedApproach = errors.New("Cleared for unexpected approach")
	ErrFixIsTooFarAway              = errors.New("Fix is too far away")
	ErrFixNotInRoute                = errors.New("Fix not in aircraft's route")
	ErrInvalidApproach              = errors.New("Invalid approach")
	ErrInvalidFix                   = errors.New("Invalid fix")
	ErrNotClearedForApproach        = errors.New("Aircraft has not been cleared for an approach")
	ErrNotFlyingRoute               = errors.New("Aircraft is not currently flying its assigned route")
	ErrUnableCommand                = errors.New("Unable")
	ErrUnknownApproach              = errors.New("Unknown approach")
)

Errors used by the nav package

Functions

func InitNavLog 

func InitNavLog(enabled bool, categories string, callsign string)

InitNavLog is a no-op in release builds

func LogRoute 

func LogRoute(callsign string, simTime time.Time, waypoints av.WaypointArray)

LogRoute is a no-op in release builds 

func NavLog(callsign string, simTime time.Time, category string, format string, args ...any)

NavLog is a no-op in release builds 

func NavLogEnabled(category string) bool

NavLogEnabled always returns false in release builds

func TurnAngle 

func TurnAngle(from, to float32, turn TurnMethod) float32

Types

type DeferredNavHeading 

type DeferredNavHeading struct {
	// Time is just plain old wallclock time; it should be sim time, but a
	// lot of replumbing would be required to have that available where
	// needed. The downsides are minor: 1. On quit and resume, any pending
	// assignments will generally be followed immediately, and 2. if the
	// sim rate is increased, the delay will end up being longer than
	// intended.
	Time    time.Time
	Heading *float32
	Turn    *TurnMethod
	Hold    *FlyHold
	// For direct fix, this will be the updated set of waypoints.
	Waypoints []av.Waypoint
}

DeferredNavHeading stores a heading assignment from the controller and the time at which to start executing it; this time is set to be a few seconds after the controller issues it in order to model the delay before pilots start to follow assignments.

type DepartureHeadingState added in v0.14.0 

type DepartureHeadingState int

DepartureHeadingState describes the state of a departure's heading assignment. 

const (
	// NoHeading indicates no heading is assigned or upcoming
	NoHeading DepartureHeadingState = iota
	// OnHeading indicates the aircraft is currently flying an assigned heading
	OnHeading
	// TurningToHeading indicates the aircraft is about to turn to a heading
	TurningToHeading
)

type FlightState 

type FlightState struct {
	InitialDepartureClimb     bool
	DepartureAirportLocation  math.Point2LL
	DepartureAirportElevation float32
	ArrivalAirport            av.Waypoint
	ArrivalAirportLocation    math.Point2LL
	ArrivalAirportElevation   float32

	MagneticVariation float32
	NmPerLongitude    float32

	Position     math.Point2LL
	Heading      float32
	Altitude     float32
	PrevAltitude float32
	IAS, GS      float32 // speeds...
	BankAngle    float32 // degrees
	AltitudeRate float32 // + -> climb, - -> descent
}

func (FlightState) LogValue 

func (fs FlightState) LogValue() slog.Value

func (*FlightState) Summary 

func (fs *FlightState) Summary() string

type FlyHold 

type FlyHold struct {
	Hold         av.Hold
	FixLocation  math.Point2LL
	State        HoldState
	LegStartTime time.Time
	LegStartPos  math.Point2LL
	Entry        av.HoldEntry
	Cancel       bool // when set, we end the hold after the last leg
}

func (*FlyHold) GetHeading 

func (fh *FlyHold) GetHeading(callsign string, nav *Nav, wxs wx.Sample, simTime time.Time) (float32, TurnMethod, float32)

type FlyRacetrackPT 

type FlyRacetrackPT struct {
	ProcedureTurn      *av.ProcedureTurn
	Fix                string
	FixLocation        math.Point2LL
	Entry              av.RacetrackPTEntry
	InboundHeading     float32
	OutboundHeading    float32
	OutboundTurnRate   float32
	OutboundTurnMethod TurnMethod
	OutboundLegLength  float32
	State              int
}

func MakeFlyRacetrackPT 

func MakeFlyRacetrackPT(nav *Nav, wp []av.Waypoint) *FlyRacetrackPT

func (*FlyRacetrackPT) GetAltitude 

func (fp *FlyRacetrackPT) GetAltitude(nav *Nav) (float32, bool)

func (*FlyRacetrackPT) GetHeading 

func (fp *FlyRacetrackPT) GetHeading(nav *Nav, wxs wx.Sample) (float32, TurnMethod, float32)

type FlyStandard45PT 

type FlyStandard45PT struct {
	ProcedureTurn    *av.ProcedureTurn
	Fix              string
	FixLocation      math.Point2LL
	InboundHeading   float32 // fix->airport
	AwayHeading      float32 // outbound + 45 offset
	State            int
	SecondsRemaining int
}

func MakeFlyStandard45PT 

func MakeFlyStandard45PT(nav *Nav, wp []av.Waypoint) *FlyStandard45PT

func (*FlyStandard45PT) GetHeading 

func (fp *FlyStandard45PT) GetHeading(nav *Nav, wxs wx.Sample) (float32, TurnMethod, float32)

type HoldState 

type HoldState int
const (
	// Everyone starts here and then transitions to one of the next three groups depending on their entry method.
	HoldStateApproaching HoldState = iota

	HoldStateDirectTurningInitialOutbound

	HoldStateTurningForParallelEntry
	HoldStateFlyingParallelOutbound
	HoldStateTurningParallelInbound

	HoldStateFlyingTeardropOutbound
	HoldStateTurningForTeardropEntry

	// All holds cycle through these once after entry.
	HoldStateTurningOutbound
	HoldStateFlyingOutbound
	HoldStateTurningInbound
	HoldStateFlyingInbound
)

func (HoldState) String 

func (s HoldState) String() string

type HoldStateFunc 

type HoldStateFunc func(nav *Nav, fh *FlyHold, wxs wx.Sample, simTime time.Time) (float32, TurnMethod, HoldState)

Holds are implemented using a simple state machine where each state is handled by a function with this signature. Return values: heading to fly, which direction to turn, and which state to be in for the next step.

type InterceptState 

type InterceptState int
const (
	NotIntercepting InterceptState = iota
	InitialHeading
	TurningToJoin
	OnApproachCourse
)
type Nav struct {
	FlightState FlightState
	Perf        av.AircraftPerformance
	Altitude    NavAltitude
	Speed       NavSpeed
	Heading     NavHeading
	Approach    NavApproach
	Airwork     *NavAirwork

	FixAssignments map[string]NavFixAssignment

	// DeferredNavHeading stores a heading/direct fix assignment from the
	// controller that the pilot has not yet started to follow.  Note that
	// only a single such assignment is stored; for example, if the
	// controller issues a first heading and then a second shortly
	// afterward, before the first has been followed, it's fine for the
	// second to override it.
	DeferredNavHeading *DeferredNavHeading

	FinalAltitude float32
	Waypoints     av.WaypointArray

	Rand *rand.Rand
}

State related to navigation. Pointers are used for optional values; nil -> unset/unspecified.

func MakeArrivalNav 

func MakeArrivalNav(callsign av.ADSBCallsign, arr *av.Arrival, fp av.FlightPlan, perf av.AircraftPerformance,
	nmPerLongitude float32, magneticVariation float32, model *wx.Model, simTime time.Time, lg *log.Logger) *Nav

func MakeDepartureNav 

func MakeDepartureNav(callsign av.ADSBCallsign, fp av.FlightPlan, perf av.AircraftPerformance,
	assignedAlt, clearedAlt, speedRestriction int, wp []av.Waypoint, randomizeAltitudeRange bool,
	nmPerLongitude float32, magneticVariation float32, model *wx.Model, simTime time.Time, lg *log.Logger) *Nav

func MakeOverflightNav 

func MakeOverflightNav(callsign av.ADSBCallsign, of *av.Overflight, fp av.FlightPlan, perf av.AircraftPerformance,
	nmPerLongitude float32, magneticVariation float32, model *wx.Model, simTime time.Time, lg *log.Logger) *Nav
func (nav *Nav) AltitudeOurDiscretion() av.CommandIntent
func (nav *Nav) ApproachHeading(wxs wx.Sample) (heading float32, turn TurnMethod)

Placeholder - will be filled from source 

func (nav *Nav) AssignAltitude(alt float32, afterSpeed bool) av.CommandIntent
func (nav *Nav) AssignHeading(hdg float32, turn TurnMethod) av.CommandIntent
func (nav *Nav) AssignSpeed(speed float32, afterAltitude bool) av.CommandIntent
func (nav *Nav) AssignSpeedUntil(speed float32, until *av.SpeedUntil) av.CommandIntent
func (nav *Nav) AssignedHeading() (float32, bool)

AssignedHeading returns the aircraft's current heading assignment, if any, regardless of whether the pilot has yet started following it. 

func (nav *Nav) AssignedWaypoints() []av.Waypoint

AssignedWaypoints returns the route that should be flown following a controller instruction. If an instruction has been issued but the delay hasn't passed, these are different than the waypoints currently being used for navigation. 

func (nav *Nav) AtFixCleared(fix, id string) av.CommandIntent
func (nav *Nav) AtFixIntercept(fix, airport string, lg *log.Logger) av.CommandIntent
func (nav *Nav) CancelApproachClearance() av.CommandIntent
func (nav *Nav) Check(lg *log.Logger)
func (nav *Nav) ClearedApproach(airport string, id string, straightIn bool) (av.CommandIntent, bool)
func (nav *Nav) ClimbViaSID() av.CommandIntent
func (nav *Nav) ContactMessage(reportingPoints []av.ReportingPoint, star string, reportHeading bool, isDeparture bool) *av.RadioTransmission
func (nav *Nav) CrossFixAt(fix string, ar *av.AltitudeRestriction, speed int) av.CommandIntent
func (nav *Nav) DepartFixDirect(fixa string, fixb string) av.CommandIntent
func (nav *Nav) DepartFixHeading(fix string, hdg float32) av.CommandIntent
func (nav *Nav) DepartOnCourse(alt float32, exit string)
func (nav *Nav) DepartureHeading() (int, DepartureHeadingState)

DepartureHeading returns the heading a departure will fly and its state. Returns the heading and state based on: - OnHeading: aircraft has an assigned heading - TurningToHeading: first waypoint has a heading (about to turn) - NoHeading: no assigned heading and first waypoint has no heading 

func (nav *Nav) DepartureMessage(reportHeading bool) *av.RadioTransmission
func (nav *Nav) DescendViaSTAR() av.CommandIntent
func (nav *Nav) DirectFix(fix string) av.CommandIntent
func (nav *Nav) DistanceAlongRoute(fix string) (float32, error)
func (nav *Nav) DistanceToEndOfApproach() (float32, error)

distanceToEndOfApproach returns the remaining distance to the last waypoint (usually runway threshold) of the currently assigned approach. 

func (nav *Nav) DivertToAirport(airport string)
func (nav *Nav) ETA(p math.Point2LL) float32

ETA returns the estimated time in seconds until the aircraft will arrive at `p`, assuming it is flying direct. 

func (nav *Nav) EnqueueDirectFix(wps []av.Waypoint)
func (nav *Nav) EnqueueHeading(hdg float32, turn TurnMethod)

EnqueueHeading enqueues the given heading assignment to be followed a few seconds in the future. It should only be called for heading changes due to controller instructions to the pilot and never in cases where the autopilot is changing the heading assignment. 

func (nav *Nav) EnqueueOnCourse()
func (nav *Nav) ExpectApproach(airport *av.Airport, id string, runwayWaypoints map[string]av.WaypointArray,
	lahsoRunway string, lg *log.Logger) av.CommandIntent
func (nav *Nav) ExpediteClimb() av.CommandIntent
func (nav *Nav) ExpediteDescent() av.CommandIntent
func (nav *Nav) FlyPresentHeading() av.CommandIntent
func (nav *Nav) GoAround()
func (nav *Nav) HoldAtFix(callsign string, fix string, hold *av.Hold) av.CommandIntent
func (nav *Nav) InterceptApproach(airport string, lg *log.Logger) av.CommandIntent
func (nav *Nav) InterceptedButNotCleared() bool
func (nav *Nav) IsAirborne() bool
func (nav *Nav) MaintainMaximumForward() av.CommandIntent
func (nav *Nav) MaintainPresentSpeed() av.CommandIntent
func (nav *Nav) MaintainSlowestPractical() av.CommandIntent
func (nav *Nav) OnApproach(checkAltitude bool) bool
func (nav *Nav) OnExtendedCenterline(maxNmDeviation float32) bool

OnExtendedCenterline checks if the flight position is less than maxNmDeviation from the infinite line defined by the assigned approach localizer 

func (nav *Nav) RestoreSnapshot(snap NavSnapshot)

RestoreSnapshot restores nav state from a previously captured snapshot. The aircraft's physical state (FlightState) is NOT restored - only control assignments. 

func (nav *Nav) ResumeOwnNavigation() av.CommandIntent
func (nav *Nav) SayAltitude() av.CommandIntent
func (nav *Nav) SayHeading() av.CommandIntent
func (nav *Nav) SaySpeed() av.CommandIntent
func (nav *Nav) Summary(fp av.FlightPlan, model *wx.Model, simTime time.Time, lg *log.Logger) string

Full human-readable summary of nav state for use when paused and mouse hover on the scope 

func (nav *Nav) TAS() float32
func (nav *Nav) TakeSnapshot() NavSnapshot

TakeSnapshot captures the current controller-modifiable nav state for later rollback. 

func (nav *Nav) TargetAltitude() (float32, float32)
func (nav *Nav) TargetHeading(callsign string, wxs wx.Sample, simTime time.Time) (heading float32, turn TurnMethod, rate float32)
func (nav *Nav) TargetSpeed(targetAltitude float32, fp *av.FlightPlan, wxs wx.Sample, bravo *av.AirspaceGrid) (float32, float32)
func (nav *Nav) Update(callsign string, model *wx.Model, fp *av.FlightPlan, simTime time.Time, bravo *av.AirspaceGrid) *av.Waypoint

returns passed waypoint if any 

func (nav *Nav) UpdateWithWeather(callsign string, wxs wx.Sample, fp *av.FlightPlan, simTime time.Time, bravo *av.AirspaceGrid) *av.Waypoint

UpdateWithWeather is a helper for simulations that use pre-fetched weather 

type NavAirwork struct {
	Radius   float32
	Center   math.Point2LL
	AltRange [2]float32

	RemainingSteps  int
	NextMoveCounter int
	Heading         float32
	TurnRate        float32
	TurnDirection   TurnMethod
	IAS             float32
	Altitude        float32
	Dive            bool
	ToCenter        bool
}

func StartAirwork 

func StartAirwork(wp av.Waypoint, nav Nav) *NavAirwork
func (aw *NavAirwork) Start360(nav Nav)
func (aw *NavAirwork) TargetAltitude() (float32, float32)
func (aw *NavAirwork) TargetHeading() (heading float32, turn TurnMethod, rate float32)
func (aw *NavAirwork) TargetSpeed() (float32, float32, bool)
func (aw *NavAirwork) Update(nav *Nav) bool
type NavAltitude struct {
	Assigned           *float32 // controller assigned
	Cleared            *float32 // from initial clearance
	AfterSpeed         *float32
	AfterSpeedSpeed    *float32
	Expedite           bool
	ExpediteAfterSpeed bool

	// Carried after passing a waypoint if we were unable to meet the
	// restriction at the way point; we keep trying until we get there (or
	// are given another instruction..)
	Restriction *av.AltitudeRestriction
}
type NavApproach struct {
	Assigned          *av.Approach
	AssignedId        string
	ATPAVolume        *av.ATPAVolume
	Cleared           bool
	InterceptState    InterceptState
	PassedApproachFix bool // have we passed a fix on the approach yet?
	PassedFAF         bool
	NoPT              bool
	AtFixClearedRoute []av.Waypoint
	AtFixInterceptFix string // fix where aircraft should intercept the localizer
}
type NavFixAssignment struct {
	Arrive struct {
		Altitude *av.AltitudeRestriction
		Speed    *float32
	}
	Depart struct {
		Fix     *av.Waypoint
		Heading *float32
	}
	Hold *av.Hold
}
type NavHeading struct {
	Assigned     *float32
	Turn         *TurnMethod
	Arc          *av.DMEArc
	JoiningArc   bool
	RacetrackPT  *FlyRacetrackPT
	Standard45PT *FlyStandard45PT
	Hold         *FlyHold
}
type NavSnapshot struct {
	Altitude           NavAltitude
	Speed              NavSpeed
	Heading            NavHeading
	Approach           NavApproach
	Waypoints          av.WaypointArray
	DeferredNavHeading *DeferredNavHeading
	FixAssignments     map[string]NavFixAssignment
}

NavSnapshot captures all controller-modifiable state in Nav for rollback purposes. It does NOT include FlightState (aircraft physical position/heading/altitude) - only control assignments that can be rolled back. 

type NavSpeed struct {
	Assigned                 *float32
	AfterAltitude            *float32
	AfterAltitudeAltitude    *float32
	MaintainSlowestPractical bool
	MaintainMaximumForward   bool
	// Carried after passing a waypoint
	Restriction *float32
}

type TurnMethod 

type TurnMethod int
const (
	TurnClosest TurnMethod = iota // default
	TurnLeft
	TurnRight
)

func (TurnMethod) String 

func (t TurnMethod) String() string

type WaypointCrossingConstraint 

type WaypointCrossingConstraint struct {
	Altitude float32
	Fix      string  // where we're trying to readh Altitude
	ETA      float32 // seconds
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.