FG1000: Difference between revisions
m (→Current Status) |
|||
Line 3: | Line 3: | ||
== Current Status == | == Current Status == | ||
An initial implementation of the MFD with two pages (Navigation Map and Traffic Map) is available on git/next from the Debug Menu->FG1000. It includes a PUI-based surround, Engine Information System (early prototype), page group selection using the FMS control, and the two pages. | An initial implementation of the MFD with two pages (Navigation Map and Traffic Map) is available on git/next from the Debug Menu->FG1000. It includes a [[PUI]]-based surround, Engine Information System (early prototype), page group selection using the FMS control, and the two pages. | ||
Most of the underlying MapStructure layers are now written (though they require styling, and/or would benefit from replacement with vector data). | Most of the underlying Canvas [[MapStructure]] layers are now written (though they require styling, and/or would benefit from replacement with vector data). | ||
Next steps: | Next steps: |
Revision as of 18:06, 25 November 2017
Current Status
An initial implementation of the MFD with two pages (Navigation Map and Traffic Map) is available on git/next from the Debug Menu->FG1000. It includes a PUI-based surround, Engine Information System (early prototype), page group selection using the FMS control, and the two pages.
Most of the underlying Canvas MapStructure layers are now written (though they require styling, and/or would benefit from replacement with vector data).
Next steps:
- Writing the remaining (large) number of pages
- Styling the pages - making the iconography match Garmin exactly.
- Updating the EIS to use Emesary rather than the Driver model.
Motivation
See Canvas_News#Moving_map.2FRNAV_discussion for the main article about this subject. |
The enormous variety in current glass flight decks means we really need to think of a new way of defining glass cockpit layouts.[1]
The airspace system is in the process of changing drastically [...] this isn't just a matter of throwing up a canvas showing some GPS waypoints and a magenta line. Modern navigators are astoundingly-complex devices — probably an order of magnitude more lines of code than FlightGear itself — and even their basic flight planning algorithms and databases (e.g. fly-by waypoints vs fly-over waypoints, open vs closed approach procedures, transitions into RNAV approaches, etc.) are far beyond the scope of anything we've tried, and we'd also need an up-to-date database far more complex than the ones we have now. Once you get to the extra features, like FIS-B weather or TIS-B traffic info over ADS-B, or TAWS (terrain alerting), we're probably in way over our heads trying to emulate even the simplest general-aviation IFR GPS.
This may help folks understand what the G1000 is all about: http://static.garmincdn.com/pumac/190-00498-07_0A_Web.pdf Writing a G1000 isn't that hard. Writing a feature complete G1000 is a ton of work. [2]
Depending on how we deal with this challenge, the question is whether that means that the usefulness of FlightGear will also gradually taper off. [3]
Instead of just making one-off tweaks like the consumer sims did, we (as a team) emulated entire systems like the vacuum, pitot-static, and electrical systems, so that failures would be realistic. In the RNAV age, we need to do the same thing; it's just that it's a bigger job. FlightGear will still be great for people who want to practice the mechanical parts of flying (e.g. crosswind wheel landings in a Cub), but will slip further and further behind for people who want to use it for real IFR practice.[4]
Background
See Complex Canvas Avionics for the main article about this subject. |
Challenges
Performance
Nasal as such is fast, and compared with the cost of rendering the terrain, rendering a canvas display is fast on the GPU (you can test by rendering but not updating a canvas display), and unless you're doing something very inefficient, calculating a display but not writing it to the property tree is fast (you can test this by disabling the write commands). It's the property I/O which you need to structure well, and then canvas will run fast. And of course the complexity of your underlying simulation costs - if you run a thermal model underneath to get real temperature reading, it costs more than inventing the numbers. But that has nothing to do with canvas. [5]
it's a lot of work to code all these displays which someone has to do, but there's no reason to assume it'd be hopeless performance-wise.[6]
we need to be realistic here: The G1000 is a fairly significant piece of computer hardware that we're going to emulate. It's not going to be "free" particularly for those on older hardware that's already struggling. However, hopefully we can offload a chunk of the logic (route management, autopilot/flight director) to the core, and do things like offline generation of terrain maps to minimie the impact.[7]
Route Manager
that's exactly the kind of device James hopes the new code can support. He's read the G1000 pilot's manual, and *thinks* that nearly all the functions can be provided by the current GPS code It would be great if people could look over the current GPS features and indicate any pieces you think might be missing - additional commands, additional search features, extra data, or anything really. [8]
tile servers
Please keep in mind that most tile servers discourage bulk downloads. For the whole planet,oomlevel 8 is approx. 67k files, at zoomlevel 9 you have 265k, level 10 has a little over one million tiles. And one would probably want to go up to level 15 (roughly 1e9 files)[9]
Offline mode
would it be possible to provide an offline tool to pre-fetch a region, like TerraMaster, or terrasync.py? Call me old-fashioned or paranoid, but I don't want FG to go online and do stuff automatically, I prefer downloading what I need manually so that I know what gets onto my harddisk. Also - think of all the people with poor home internet which might have larger bandwidth only in a library elsewhere.[10]
that would certainly be possible - the code retrieving the data is pretty trivial and porting the Nasal code to python or some other script should be straightforward.[11]
we need some better data sources, especially with direct routing replacing airways in many areas, and having airspace data would help the map displays, but the current API is specifically designed to support G430, G1000 and similar class devices. Adding RNAV approaches is eminently doable, see the the RNavController base class which the GPS/FMS layer uses to allow new waypoint / route segments to define how they are flown and drive CDIs [12]
Getting the algorithms right, and keeping the data up to date every 7 weeks (we have only a tiny sliver of that data currently), is going to be much more of a challenge. I expect that it's probably an order of magnitude more complicated than our current flight dynamics (etc.), so we'd have to grow our contributor base, and find funding to pay at least Curt (and maybe a couple of others) full time to manage the project. Note that that's what has happened for other complex FOSS projects, like office suites and browsers, which generally end up working through a foundation, rather than our current relaxed circle-of-friends arrangement. The reason it's so much harder now is that the software *is* the product for GPS navigators, FMSs, etc. (unlike with older avionics, where the hardware was the main thing). That means that emulating even a simple unit like the GTN 650 or GNS 430W is almost difficult as building one, so we're trying to keep up with armies of full-time software developers at Garmin, Avidyne, etc.[13]
According to the Route Manager wiki page, we already have support for SID/STAR data provided from Navigraph, which is released on the AIRAC cycle, and costs a pretty small amount (9 EUR for a single download of FMS data, or 90 EUR per year) Given the relatively low cost, I don't think that we as an organiation want to get into trying to digitize data ourselves just to make it open-source or public domain. Particularly given the low cost of a download. We might want to digitize the STAR/SIDs for the default airport with each release so there are some approaches available for those who don't want to purchase the data.[14]
Plan
Stuart has been in contact with the author (Sébastien MARQUE) of the ZKV-1000. While he himself doesn't plan to implement a G1000, he's very happy for it to be developed in that direction. Stuart's broad plan is to make a copy of this in fgdata or fgaddon, and use it as the basis for a G1000, taking the opportunity to use Richard's MFD code and making as generic pages as possible for other glass cockpit applications.[15]
Layers
Following is the list of layers displayed by the G1000 system (see page 153 of the 190-00498-07 Rev. A), and mapping to the equivalent MapStructure Layer. Many of these would also be good to have for other avionics/GUI dialogs, including the NavDisplay framework, which is currently re-implementing this functionality separately, i.e. not yet using MapStructure.
Following is the list of layers displayed by the G1000 system, based on the Garmin G1000 Integrated Flight Deck Pilot's Guide for the Cessna Nav III Garmin Site Wayback machine, page 153, and the mapping to the equivalent MapStructure Layer.
Layer | MapStructure Layer | Status | Page | Notes |
---|---|---|---|---|
Flight Plan Route Lines | RTE | Requires styling | p.190 | |
Flight Plan Route Waypoints | WPT | Requires styling | p.190 | |
Rivers/Lakes | VFRChart | p.148 | Currently using downloaded raster from web. Perhaps generate similarly to Atlas[16], or could be vector data from scenery. Tom originally suggested to directly render an orthographic view of the scenery/terrain to the canvas, thus the atlas-based approach should also work using a custom Canvas View Camera Element, based on the Hackathon Proposal: CompositeViewer and Canvas experiments (see the ideas summarized at Canvas Tile Element). Fernando agreed already that it would be straightforward to apply custom node masks, LOD ranges and even effect schemes per Compositor instance. | |
Topography Data | VFRChart | Synthetic | p.145 | Height-map at chart-resolution. Perhaps generate similarly to Atlas? Tom originally suggested to directly render an orthographic view of the scenery/terrain to the canvas, thus the atlas-based approach should also work using a custom Canvas View Camera Element, based on the Hackathon Proposal: CompositeViewer and Canvas experiments (see the ideas summarized at Canvas Tile Element). Fernando agreed already that it would be straightforward to apply custom node masks, LOD ranges and even effect schemes per Compositor instance. |
International Borders | p.148 | Vector data from scenery? | ||
Track Vector | p.156 | Forward looking display of track. Look-ahead time selectable. | ||
Navigation Range Ring | p.159 | Straightforward extension of APS. | ||
Fuel Range Ring | 159 | Straightforward extension of APS. | ||
Terrain Data | 364 | Should be straightforward, with exception of obstacles. Profile view also required. | ||
Traffic | TFC | 394,423 | Various options, each with different iconography and data displayed. | |
Airways | VFRChart | 154 | Needs to be replaced with vector data | |
NEXRAD | 282 | Heaps of weather data with complex symbology. | ||
XM Lightning Data | WXR | Change to symbol for lightning? | 294 | Optional |
Airports | APT, RWY | Require re-style based on size | 149, 163 | |
Runway Labels | RWY | 148 | Needs to be added to RWY. Should be straightforward | |
Restricted | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[17]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[18] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [19] | |
MOA (Military) | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[20]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[21] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [22] | |
User Waypoints | ||||
Latitude/Longitude Grid | GRID | |||
NAVAIDs | APT, VOR, FIX, NDB | Requires styling | 162 | |
Class B Airspaces/TMA | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[23]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[24] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [25] | |
Class C Airspaces/TCA | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[26]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[27] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [28] | |
Class D Airspaces | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[29]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[30] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [31] | |
Other Airspaces/ADIZ | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[32]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[33] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [34] | |
TFRs | 310 | |||
Obstacles | OpenAIP | 182 | Currently using downloaded rasters. Would be better replaced with vector data, see original plans at Canvas_Maps#Vector_data. We do already have a SHP parser, that’s how the launcher loads the SHP data used in the launcher map: but loading for display is much easier than a robust ‘is point inside an arbitrary complex polygon’ tester.[35]
Using GDAL/CGAL for other features has been repeatedly discussed on the devel list, i.e. for WS 3.0 to create the meta-texture at runtime from the vector data - i.e use CGAL + GDAL to ‘paint’ the vector data into textures as they are needed. This means the resolution of the meta-texture tiles can be adaptive, which gives a trivia solution to handling roads and similar - draw them into the meta texture (or an additional one) adaptively based on distance from viewer, etc.[36] CGAL/GDAL are not so problematic to consider shipping. (They are well maintained, well supported on Windows, and have sane build systems). We would want some warning and time to handle it, but should definitely not consider this particular point to be a blocker for more advanced runtime features. [37] | |
Land/Country Text | 148 | Currently using raster data from web. Replace with POI? | ||
Cities | VFRChart | 148 | Currently using raster data from web. Perhaps generate similarly to Atlas, or could be vector data from scenery. Tom originally suggested to directly render an orthographic view of the scenery/terrain to the canvas, thus the atlas-based approach should also work using a custom Canvas View Camera Element, based on the Hackathon Proposal: CompositeViewer and Canvas experiments (see the ideas summarized at Canvas Tile Element). Fernando agreed already that it would be straightforward to apply custom node masks, LOD ranges and even effect schemes per Compositor instance. | |
Roads | VFRChart | 148 | Currently using raster data from web. Requires vector data from scenery | |
Railroads | VFRChart | 148 | Currently using raster data from web. Requires vector data from scenery | |
State/Province Boundaries | VFRChart | 148 | Currently using raster data from web. Requires vector data from scenery | |
River/Lake Names | VFRChart | 148 | Currently using raster data from web. Replace with POI? | |
Selected Altitude Intercept Arc | 161 | Simple extention to APS | ||
SafeTaxi (Optional) | RWY, TAXI | 493 | We don't currently have the data to display taxiway identifier or holding points | |
ChartView (Optional) | 503 | Rendering of PDFs. Might be possible to integrate with NaviGraph chart data? | ||
FliteChart (Optional) | 521 | Rendering of PDFs. Might be possible to integrate with NaviGraph chart data? |
Existing work
Avionics / Cockpits
Nasal / Canvas
- Canvas MFD Framework
- MapStructure
- MapStructure Layers
- Howto:Creating a Canvas GUI Widget
- Emesary
C++
- Atlas map creation
- Synthetic Vision element for rendering viewmgr views to a Canvas
- Canvas PDF element - for rendering PDF files (think EFB functionality)
Possible Work
The layers table shown above mentions a few limitations and ideas, such as:
Nasal/Canvas
- MapStructure: Allocating selectable ranges into Canvas groups
C++
- fix up projection issues, and adopt Gijs' projection handling code for the hard-coded PUI Map, to get rid of the standard Sanson-Flamsteed projection
- adding a profile view, probably in conjunction with terrain sampling
- using atlas code to generate heightmaps/topography
- adding ESRI shapefile support to the Canvas system
- adding PDF rendering support the Canvas system
Structure
Design
The broad structure of the Nasal files in Aircaft/Instruments-3d/FG1000/Nasal is as follows:
- MFD.nas - top level MFD device, loads the other Nasal files (likely to be moved elsewhere later) and pages.
- EIS.nas - Engine Information System. Currently a simple C172s is displayed, needs to be more generic and to use Emesary
- Drivers/EISDriver.nas - driver for the Engine Information System. Likely to be replaced with Emesary
- PageGroupControllers.nas - controller for the Page Group display in the bottom right of the MFD, controlled by the FMS knob, and which allows selection between different page groups and individual pages.
- [PageName]/[PageName].nas - MFD page, inheriting from the MDF_Generic.PFD_Page. Creates any required MapStructure and hierarchy of softkeys.
- [PageName]/[PageName]Controller.nas - Controller for the MFD page and the MapStructure layers.
- [PageName]/[PageName]Style.nas - Style controls for the MapStructure layers for the give Page.
- [PageName]/[PageName]Options.nas - Options for the MapStructure layers for the give Page.
Resources
Related
Commits
- GRID layer (10/2017)
- RWY, TAXI, TWR, PARKING (10/2017)
- STAMEN (10/2017)
- VFRChart (09/2017)
- OSM and OpenAIP (09/2017)