From e89291a6af401562a7a596600b769b24cca15dc1 Mon Sep 17 00:00:00 2001
From: AdaSzi115026 <81822538+AdaSzi@users.noreply.github.com>
Date: Fri, 6 Nov 2026 00:47:33 +0100
Subject: [PATCH 1/3] Add GPS Viewer

A GNSS receiver status app: fix, satellites in view and used, signal
strength, sky plot, position, speed and time. Can record the receiver's
NMEA output to the SD card.
---
 Apps/GpsViewer/CHANGELOG.md                   |  33 +
 Apps/GpsViewer/CMakeLists.txt                 |  13 +
 Apps/GpsViewer/LICENSE                        | 674 ++++++++++++++++
 Apps/GpsViewer/README.md                      | 141 ++++
 Apps/GpsViewer/THIRD_PARTY.md                 |   6 +
 Apps/GpsViewer/docs/night.png                 | Bin 0 -> 6342 bytes
 Apps/GpsViewer/docs/position.png              | Bin 0 -> 6476 bytes
 Apps/GpsViewer/docs/signal.png                | Bin 0 -> 5037 bytes
 Apps/GpsViewer/docs/sky.png                   | Bin 0 -> 22206 bytes
 Apps/GpsViewer/docs/status.png                | Bin 0 -> 5697 bytes
 Apps/GpsViewer/main/CMakeLists.txt            |   7 +
 Apps/GpsViewer/main/Source/app/AppContext.h   |  74 ++
 Apps/GpsViewer/main/Source/app/Main.cpp       | 168 ++++
 .../GpsViewer/main/Source/app/MessageCard.cpp | 135 ++++
 .../GpsViewer/main/Source/app/PositionTab.cpp | 247 ++++++
 Apps/GpsViewer/main/Source/app/Recorder.cpp   |  89 +++
 Apps/GpsViewer/main/Source/app/Recorder.h     |  33 +
 Apps/GpsViewer/main/Source/app/SignalTab.cpp  | 337 ++++++++
 Apps/GpsViewer/main/Source/app/SkyTab.cpp     | 238 ++++++
 Apps/GpsViewer/main/Source/app/Sources.cpp    | 220 ++++++
 Apps/GpsViewer/main/Source/app/Sources.h      |  56 ++
 Apps/GpsViewer/main/Source/app/StatusTab.cpp  | 205 +++++
 Apps/GpsViewer/main/Source/app/Tabs.h         | 170 ++++
 Apps/GpsViewer/main/Source/app/Theme.cpp      |  94 +++
 Apps/GpsViewer/main/Source/app/Ui.cpp         | 738 ++++++++++++++++++
 Apps/GpsViewer/main/Source/app/Ui.h           |  21 +
 Apps/GpsViewer/main/Source/app/Widgets.cpp    | 405 ++++++++++
 Apps/GpsViewer/main/Source/app/Widgets.h      |  55 ++
 Apps/GpsViewer/main/Source/core/Format.cpp    | 163 ++++
 Apps/GpsViewer/main/Source/core/Format.h      |  37 +
 Apps/GpsViewer/main/Source/core/GnssModel.cpp | 210 +++++
 Apps/GpsViewer/main/Source/core/GnssModel.h   | 100 +++
 Apps/GpsViewer/main/Source/core/GnssTypes.cpp |  77 ++
 Apps/GpsViewer/main/Source/core/GnssTypes.h   |  57 ++
 .../GpsViewer/main/Source/core/NmeaWriter.cpp | 204 +++++
 Apps/GpsViewer/main/Source/core/NmeaWriter.h  |  15 +
 .../main/Source/core/SatelliteDb.cpp          | 254 ++++++
 Apps/GpsViewer/main/Source/core/SatelliteDb.h |  68 ++
 Apps/GpsViewer/main/Source/core/Settings.cpp  | 141 ++++
 Apps/GpsViewer/main/Source/core/Settings.h    |  22 +
 Apps/GpsViewer/main/Source/core/SunTimes.cpp  |  83 ++
 Apps/GpsViewer/main/Source/core/SunTimes.h    |  25 +
 .../main/Source/third_party/minmea/COPYING    |  13 +
 .../Source/third_party/minmea/LICENSE.MIT     |   9 +
 .../Source/third_party/minmea/LICENSE.grants  |   7 +
 .../main/Source/third_party/minmea/minmea.c   | 679 ++++++++++++++++
 .../main/Source/third_party/minmea/minmea.h   | 295 +++++++
 Apps/GpsViewer/manifest.properties            |  11 +
 48 files changed, 6629 insertions(+)
 create mode 100644 Apps/GpsViewer/CHANGELOG.md
 create mode 100644 Apps/GpsViewer/CMakeLists.txt
 create mode 100644 Apps/GpsViewer/LICENSE
 create mode 100644 Apps/GpsViewer/README.md
 create mode 100644 Apps/GpsViewer/THIRD_PARTY.md
 create mode 100644 Apps/GpsViewer/docs/night.png
 create mode 100644 Apps/GpsViewer/docs/position.png
 create mode 100644 Apps/GpsViewer/docs/signal.png
 create mode 100644 Apps/GpsViewer/docs/sky.png
 create mode 100644 Apps/GpsViewer/docs/status.png
 create mode 100644 Apps/GpsViewer/main/CMakeLists.txt
 create mode 100644 Apps/GpsViewer/main/Source/app/AppContext.h
 create mode 100644 Apps/GpsViewer/main/Source/app/Main.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/MessageCard.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/PositionTab.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Recorder.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Recorder.h
 create mode 100644 Apps/GpsViewer/main/Source/app/SignalTab.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/SkyTab.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Sources.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Sources.h
 create mode 100644 Apps/GpsViewer/main/Source/app/StatusTab.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Tabs.h
 create mode 100644 Apps/GpsViewer/main/Source/app/Theme.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Ui.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Ui.h
 create mode 100644 Apps/GpsViewer/main/Source/app/Widgets.cpp
 create mode 100644 Apps/GpsViewer/main/Source/app/Widgets.h
 create mode 100644 Apps/GpsViewer/main/Source/core/Format.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/Format.h
 create mode 100644 Apps/GpsViewer/main/Source/core/GnssModel.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/GnssModel.h
 create mode 100644 Apps/GpsViewer/main/Source/core/GnssTypes.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/GnssTypes.h
 create mode 100644 Apps/GpsViewer/main/Source/core/NmeaWriter.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/NmeaWriter.h
 create mode 100644 Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/SatelliteDb.h
 create mode 100644 Apps/GpsViewer/main/Source/core/Settings.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/Settings.h
 create mode 100644 Apps/GpsViewer/main/Source/core/SunTimes.cpp
 create mode 100644 Apps/GpsViewer/main/Source/core/SunTimes.h
 create mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/COPYING
 create mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT
 create mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants
 create mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/minmea.c
 create mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/minmea.h
 create mode 100644 Apps/GpsViewer/manifest.properties

diff --git a/Apps/GpsViewer/CHANGELOG.md b/Apps/GpsViewer/CHANGELOG.md
new file mode 100644
index 0000000..c362a3f
--- /dev/null
+++ b/Apps/GpsViewer/CHANGELOG.md
@@ -0,0 +1,33 @@
+# Changelog
+
+## 0.1.0
+
+First release: a GNSS status viewer with four tabs, a sky plot, settings and NMEA recording.
+
+**Screen**
+- Tactility toolbar with close button, title, fix state and menu button. Tabs Position, Sky, Signal, Status.
+- Flat layout with dividers, in the Tactility theme's colours. Night mode in reds on black.
+- Position: coordinates, altitude, course; speed with maximum and average; sunrise and sunset (NOAA algorithm,
+  offline); UTC and local time.
+- Sky: polar plot, north up, rings at 0, 30 and 60 degrees elevation. Shape and colour per system, filled when
+  used. Legend with used / in view per system.
+- Signal: SNR bar per satellite, grouped by system, coloured by strength, outlined when not used. Scrolls
+  sideways.
+- Status: fix type, estimated accuracy (HDOP x 5 m), HDOP / VDOP / PDOP with a quality word, satellites used and
+  in view, time to first fix, receiver model.
+- A message with "Open settings" when there is no receiver or location is off.
+
+**Data**
+- Subscribes to Tactility's location service and reads the first started GPS receiver.
+- Satellites are told apart by the NMEA talker ID when the firmware gives it. Without it, by ID ranges only.
+
+**Recording**
+- Saves the receiver's RMC, GGA, GSA and GSV sentences to `logs/gps-<date>-<time>.nmea`, written every 2 seconds.
+
+**Settings**
+- Units (metric, imperial, nautical), coordinate format (degrees, degrees and minutes, degrees minutes
+  seconds), night mode. Kept in `settings.txt`.
+
+**Input**
+- Keyboard, trackball and touch. Keys 1-4 jump to a tab, `n`, `r`, `s`, `l` and `m` act on night mode,
+  speed reset, settings, recording and the menu.
diff --git a/Apps/GpsViewer/CMakeLists.txt b/Apps/GpsViewer/CMakeLists.txt
new file mode 100644
index 0000000..3b14744
--- /dev/null
+++ b/Apps/GpsViewer/CMakeLists.txt
@@ -0,0 +1,13 @@
+# tactility-cmakelists-version: 1
+cmake_minimum_required(VERSION 3.20)
+
+if (NOT DEFINED ENV{TACTILITY_SDK_PATH})
+    message(FATAL_ERROR "TACTILITY_SDK_PATH environment variable is not set")
+endif()
+
+get_filename_component(TACTILITY_SDK_PATH "$ENV{TACTILITY_SDK_PATH}" ABSOLUTE)
+include("${TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+
+tactility_project_pre(gpsviewer)
+project(gpsviewer)
+tactility_project_post(gpsviewer)
diff --git a/Apps/GpsViewer/LICENSE b/Apps/GpsViewer/LICENSE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/Apps/GpsViewer/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Apps/GpsViewer/README.md b/Apps/GpsViewer/README.md
new file mode 100644
index 0000000..85f9ac0
--- /dev/null
+++ b/Apps/GpsViewer/README.md
@@ -0,0 +1,141 @@
+# GPS Viewer
+
+A GNSS status app for [Tactility](https://github.com/TactilityProject/Tactility) devices, like the "GPS Test"
+apps on Android. It shows the fix, the satellites in view and used, their signal strength and sky position,
+and the position, speed and time. It is not a map.
+
+Version 0.1.0, app id `tactility.gpsviewer`. Changes are listed in [CHANGELOG.md](CHANGELOG.md). Third-party
+code is listed in [THIRD_PARTY.md](THIRD_PARTY.md).
+
+## Install
+
+Needs Tactility firmware with the GPS API exported to apps. For satellite systems the NMEA talker ID must also
+be in `GpsEvent`. That change is the Tactility PR "gps: add NMEA talker ID to GpsEvent and export GPS API to
+apps", not merged yet.
+
+TODO: Tactility main after that PR, version to be filled in.
+
+Without the talker ID the app still builds and runs. It then groups satellites by NMEA ID ranges only (see
+[Known limits](#known-limits)).
+
+1. Set up a GPS receiver in Tactility's GPS settings and turn on location.
+2. Copy the `.app` file to the SD card, open it in the Files app and confirm "Install".
+3. Start "GPS Viewer" from the app list.
+
+The app subscribes to Tactility's location service, which starts the receiver, and reads the first started
+GPS receiver. It never changes GPS settings. With no receiver it says so on the screen.
+
+## Screen
+
+Tactility's toolbar with the close button, the title, the fix state (for example `3D FIX  3.5m`, prefixed with
+REC while recording, tap it for the Status tab) and the menu button. Below it four tabs: Position, Sky, Signal and Status.
+The content is laid out flat, with thin dividers, in the colours of the Tactility theme (light or dark, and the
+primary colour from Appearance). The monochrome theme drops the colours and keeps the marker shapes.
+
+Colours per system: GPS blue, GLONASS orange, Galileo cyan, BeiDou purple. Night mode draws everything in
+reds on black.
+
+- **Position:** two tiles. Left: latitude and longitude in the chosen format (the font gets smaller when they do
+  not fit), altitude and course over ground (only above 1 m/s). Right: speed, the maximum and average since
+  start or the last reset, and sunrise and sunset for today at the position, computed offline with the NOAA
+  algorithm. Below: UTC date and time from the RMC sentence, local time from Tactility's time zone, and REC
+  while recording.
+- **Sky:** polar plot, north up, rings at 0, 30 and 60 degrees elevation. The marker shape and colour show the
+  system: circle GPS, triangle GLONASS, pentagon Galileo, star BeiDou, square QZSS and SBAS, diamond NavIC and
+  unknown. A filled marker is used in the fix. The legend lists each system with used / in view counts, above
+  it the total.
+- **Signal:** one bar per satellite, height = signal strength (SNR, dB-Hz), grouped by system. Green from 35,
+  orange from 25, grey below. A filled bar is used in the fix, an outlined bar is not. Under each bar are a
+  system marker and the satellite ID. The average SNR of the used satellites is shown above. The bars scroll
+  sideways when there are more than fit.
+- **Status:** fix type, estimated accuracy, HDOP / VDOP / PDOP with a quality word, satellites used / in
+  view, time to first fix and the receiver model. Accuracy is HDOP x 5 m. NMEA has no accuracy value, so the
+  figure is labelled as an estimate. Time to first fix is counted from when the app started listening.
+
+With no receiver, or with location turned off, a message says so, with an "Open settings" button that opens
+Tactility's location settings.
+
+## Controls
+
+| To… | Keyboard | Trackball (keypad mode) | Trackball (pointer mode) | Touch |
+| --- | --- | --- | --- | --- |
+| Next / previous tab | Left / Right arrows, `.` / `,` or Space | Roll left / right | Click the tab name | Swipe left / right, or tap the tab name |
+| Scroll the Signal bars | Left / Right (at the ends, Left / Right change the tab) | Roll left / right | Click and drag the bars | Drag the bars |
+| Jump to a tab | `1`-`4` | — | Click the tab name | Tap the tab name |
+| Open the action menu | Enter | Click | Click the ⋮ button | Tap the ⋮ button in the toolbar |
+| Move in menus and settings | Up / Down or Left / Right | Roll | Click the row | Tap the row |
+| Select in menus and settings | Enter | Click | Click the row | Tap the row |
+| Close a menu or settings | Esc or Backspace | Select "< Back" | Click "< Back" | Tap "< Back" |
+| Close the app | — | Select the X button | Click the X button | Tap the X button in the toolbar |
+
+The keys `n` (night mode), `r` (reset max/average speed), `s` (settings) and `l` (start or stop recording)
+work from the keyboard. `m` opens the menu. These actions are also in the menu.
+
+Settings rows change their value on Enter or tap. The menu has: Reset max/average speed,
+Start / Stop recording, Night mode on or off, Settings, Exit and "< Back".
+
+## Settings
+
+- **Units:** Metric (km/h, m), Imperial (mph, ft) or Nautical (kn, m). Nautical uses metres for altitude and
+  accuracy.
+- **Coordinates:** Degrees, Deg. minutes or Deg. min. seconds.
+- **Night mode:** everything in red on black.
+
+Settings are kept in `settings.txt` in the app's user data folder. The file is plain text with one `key=value`
+per line.
+
+## Recording
+
+"Start recording" in the menu (or the `l` key) saves every NMEA sentence from the receiver to a file in
+`logs/` in the app's user data folder. The file is named after the GPS date and time, `gps-YYYYMMDD-HHMMSS.nmea`,
+or after the uptime, `gps-up<seconds>.nmea`, when the receiver has no time yet. The toolbar and the Position tab show
+REC while recording. The file is written every 2 seconds, so a crash or power loss loses at most the last 2
+seconds. Recording stops with "Stop recording" and when the app closes.
+
+Sentences are written back from the parsed values: RMC, GGA, GSA and GSV with their checksums. Other
+sentences and fields the app does not use are not saved. The logs are plain NMEA 0183, for use in other tools.
+
+## Screenshots
+
+![Status tab](docs/status.png)
+
+![Signal tab](docs/signal.png)
+
+![Sky tab](docs/sky.png)
+
+![Position tab](docs/position.png)
+
+![Night mode](docs/night.png)
+
+## Testing
+
+Tested on a LilyGO T-Deck with a Quectel L76K on the Grove port (GPS, GLONASS and BeiDou), outdoors and by a
+window. Recording was tested on the device: the log of a live session has the same fix and satellites when
+parsed again. The satellite database, NMEA writer, settings and formatting have host tests.
+
+## Known limits
+
+- Without the NMEA talker ID (see [Install](#install)), Galileo and BeiDou satellites are shown as GPS.
+- NMEA has no accuracy value. The accuracy shown is HDOP x 5 m, an estimate only.
+- Only tested on the LilyGO T-Deck, and with one receiver (L76K).
+- Tactility starts the receiver when the app opens and stops it when the app closes. With "Auto-detect" in the
+  GPS settings, the driver first tries other receiver types, which took about 4.4 s for the L76K. Choosing the
+  model in the GPS settings skips that.
+- Fonts are Tactility's three text sizes: there is no bold font.
+- The "Open settings" message was not tested on the device: it needs a missing receiver or location turned off.
+
+## Building
+
+Needs ESP-IDF 6.1 and the Tactility SDK matching the firmware on the device. Set `TACTILITY_SDK_PATH` to the
+SDK folder, then:
+
+```
+python <Tactility>/tt.py app build
+python <Tactility>/tt.py app install --host <device ip>
+python <Tactility>/tt.py app run --host <device ip>
+```
+
+## Licence
+
+GPL-3.0-or-later, the same as Tactility; see [LICENSE](LICENSE). Third-party code is listed in
+[THIRD_PARTY.md](THIRD_PARTY.md).
diff --git a/Apps/GpsViewer/THIRD_PARTY.md b/Apps/GpsViewer/THIRD_PARTY.md
new file mode 100644
index 0000000..a036143
--- /dev/null
+++ b/Apps/GpsViewer/THIRD_PARTY.md
@@ -0,0 +1,6 @@
+# Third-party code
+
+| Component | Where | Licence | Notes |
+|---|---|---|---|
+| minmea by Kosma Moczek | `main/Source/third_party/minmea/` (`minmea.c`, `minmea.h`) | MIT, from the licence grant in `LICENSE.grants` | The files are WTFPL (see `COPYING`), which grants the right to use MIT or LGPL-3.0-or-later instead. The MIT text is in `LICENSE.MIT`. The copy comes from Tactility's `Libraries/minmea`. |
+| NOAA solar calculator equations | `main/Source/core/SunTimes.cpp` | Public domain (US government work) | From the NOAA Global Monitoring Laboratory solar calculator. Used for sunrise and sunset. |
diff --git a/Apps/GpsViewer/docs/night.png b/Apps/GpsViewer/docs/night.png
new file mode 100644
index 0000000000000000000000000000000000000000..272253599c6428fd1bc146ec2386dcf19423be09
GIT binary patch
literal 6342
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

literal 0
HcmV?d00001

diff --git a/Apps/GpsViewer/docs/position.png b/Apps/GpsViewer/docs/position.png
new file mode 100644
index 0000000000000000000000000000000000000000..a95ac48467eb805efc6d4fa7b173a22cec851630
GIT binary patch
literal 6476
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
Mb$vvws$I<g0>fMVkN^Mx

literal 0
HcmV?d00001

diff --git a/Apps/GpsViewer/docs/signal.png b/Apps/GpsViewer/docs/signal.png
new file mode 100644
index 0000000000000000000000000000000000000000..0643c8cd4a2dda2262d42d6201281b66ef5cfc27
GIT binary patch
literal 5037
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

literal 0
HcmV?d00001

diff --git a/Apps/GpsViewer/docs/sky.png b/Apps/GpsViewer/docs/sky.png
new file mode 100644
index 0000000000000000000000000000000000000000..e062d59d2187121df85a41625a7362ed7df25e19
GIT binary patch
literal 22206
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

literal 0
HcmV?d00001

diff --git a/Apps/GpsViewer/docs/status.png b/Apps/GpsViewer/docs/status.png
new file mode 100644
index 0000000000000000000000000000000000000000..7f75f583470f7de9fa45208f7ee3b405c029190f
GIT binary patch
literal 5697
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

literal 0
HcmV?d00001

diff --git a/Apps/GpsViewer/main/CMakeLists.txt b/Apps/GpsViewer/main/CMakeLists.txt
new file mode 100644
index 0000000..7b384a3
--- /dev/null
+++ b/Apps/GpsViewer/main/CMakeLists.txt
@@ -0,0 +1,7 @@
+include("$ENV{TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+
+file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
+tactility_component_register(
+    SRCS ${SOURCE_FILES}
+    REQUIRES gps-module location-module
+)
diff --git a/Apps/GpsViewer/main/Source/app/AppContext.h b/Apps/GpsViewer/main/Source/app/AppContext.h
new file mode 100644
index 0000000..b9b4080
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/AppContext.h
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "../core/GnssModel.h"
+#include "../core/Settings.h"
+
+#include <app/instance.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+#include <atomic>
+#include <cstdint>
+
+namespace gpsviewer {
+
+constexpr const char* APP_ID = "tactility.gpsviewer";
+constexpr int PATH_LENGTH = 192;
+
+enum class SourceStatus : uint8_t {
+    NoReceiver,
+    LocationOff,
+    ReceiverStarting,
+    Receiving,
+    ReceiverLost,
+};
+
+// Bits for AppContext::requests, set by the UI and handled by the app task
+enum Request : uint32_t {
+    REQUEST_SAVE_SETTINGS = 1U << 0,
+    REQUEST_RESET_SPEED = 1U << 1,
+    REQUEST_TOGGLE_RECORDING = 1U << 3,
+    // Opens Tactility's location settings, where GPS receivers are set up and location is turned on
+    REQUEST_OPEN_LOCATION_SETTINGS = 1U << 4,
+};
+
+struct AppContext;
+
+// LVGL thread only. Defined in Ui.cpp.
+struct UiState;
+
+struct AppContext {
+    AppInstanceId appInstanceId = 0;
+    char dataDirectory[PATH_LENGTH] = "";
+
+    // Guards everything up to the end of this block, between the app task and the LVGL thread
+    SemaphoreHandle_t mutex = nullptr;
+    GnssModel model;
+    Settings settings;
+    SourceStatus status = SourceStatus::NoReceiver;
+    char receiverName[32] = "";
+    bool recording = false;
+    char recordingName[40] = "";
+    uint32_t recordedLines = 0;
+
+    std::atomic<uint32_t> requests {0};
+
+    // LVGL thread only
+    UiState* ui = nullptr;
+};
+
+uint32_t nowMs();
+
+class ContextLock {
+public:
+    explicit ContextLock(AppContext& context) : context(context) { xSemaphoreTake(context.mutex, portMAX_DELAY); }
+    ~ContextLock() { xSemaphoreGive(context.mutex); }
+    ContextLock(const ContextLock&) = delete;
+    ContextLock& operator=(const ContextLock&) = delete;
+
+private:
+    AppContext& context;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Main.cpp b/Apps/GpsViewer/main/Source/app/Main.cpp
new file mode 100644
index 0000000..2bb289e
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Main.cpp
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "AppContext.h"
+#include "Sources.h"
+#include "Ui.h"
+
+#include <app/event.h>
+#include <app/paths.h>
+#include <app/scheduler.h>
+#include <app/start.h>
+#include <lvgl_window_manager/window_manager.h>
+#include <tactility/check.h>
+
+#include <freertos/task.h>
+#include <sys/stat.h>
+
+#include <cstdio>
+#include <new>
+
+namespace gpsviewer {
+
+namespace {
+
+// The app task waits this long for a GPS event before it looks at app events and requests
+constexpr uint32_t POLL_MS = 50;
+
+void settingsPath(const AppContext& context, char* out, size_t outSize) {
+    snprintf(out, outSize, "%s/settings.txt", context.dataDirectory);
+}
+
+Settings loadSettings(const AppContext& context) {
+    char path[PATH_LENGTH + 16];
+    settingsPath(context, path, sizeof(path));
+    char text[256] = "";
+    FILE* file = fopen(path, "r");
+    if (file != nullptr) {
+        const size_t length = fread(text, 1, sizeof(text) - 1, file);
+        text[length] = '\0';
+        fclose(file);
+    }
+    return parseSettings(text);
+}
+
+void saveSettings(const AppContext& context, const Settings& settings) {
+    char text[256];
+    const size_t length = serializeSettings(settings, text, sizeof(text));
+    char path[PATH_LENGTH + 16];
+    settingsPath(context, path, sizeof(path));
+    FILE* file = fopen(path, "w");
+    if (file != nullptr) {
+        fwrite(text, 1, length, file);
+        fclose(file);
+    }
+}
+
+// On the heap, as the recorder's write buffer alone is larger than what the app task's stack can spare
+struct Sources {
+    GpsSource gps;
+    Recorder recorder;
+};
+
+void run(AppContext& context, Sources& sources) {
+    GpsSource& gps = sources.gps;
+    Recorder& recorder = sources.recorder;
+    struct TaskEventGroup eventGroup {};
+    task_event_group_construct(&eventGroup);
+    struct AppEventSubscription appEvents {};
+    check(app_event_subscribe(&appEvents, &eventGroup) == ERROR_NONE);
+
+    gps.start(context, &eventGroup);
+
+    WindowId window = window_manager_create_ext(context.appInstanceId, uiCreateWidgets, uiDestroyWidgets, &context);
+
+    bool close = false;
+    while (!close) {
+        gps.poll(context, POLL_MS, recorder);
+
+        struct AppEvent event;
+        while (app_event_poll(&appEvents, &event) == ERROR_NONE) {
+            if (event.type == APP_EVENT_CLOSE) {
+                close = true;
+            }
+        }
+
+        {
+            ContextLock lock(context);
+            context.recording = recorder.isRecording();
+            context.recordedLines = recorder.lineCount();
+            snprintf(context.recordingName, sizeof(context.recordingName), "%s", recorder.fileName());
+        }
+        const uint32_t requests = context.requests.exchange(0);
+        if ((requests & REQUEST_SAVE_SETTINGS) != 0) {
+            Settings settings;
+            {
+                ContextLock lock(context);
+                settings = context.settings;
+            }
+            saveSettings(context, settings);
+        }
+        if ((requests & REQUEST_TOGGLE_RECORDING) != 0) {
+            if (recorder.isRecording()) {
+                recorder.stop();
+            } else {
+                UtcDateTime utc;
+                {
+                    ContextLock lock(context);
+                    utc = context.model.utc();
+                }
+                recorder.start(context.dataDirectory, utc, nowMs());
+            }
+        }
+        if ((requests & REQUEST_OPEN_LOCATION_SETTINGS) != 0) {
+            struct AppStartContext start {};
+            if (app_start_context_from_id("tactility.locationsettings", &start) == ERROR_NONE) {
+                app_start_with_context(&start, nullptr);
+            }
+        }
+        if ((requests & REQUEST_RESET_SPEED) != 0) {
+            ContextLock lock(context);
+            context.model.resetSpeedStats();
+        }
+    }
+
+    window_manager_remove(window);
+    recorder.stop();
+    gps.stop();
+    check(app_event_unsubscribe(&appEvents) == ERROR_NONE);
+    task_event_group_destruct(&eventGroup);
+}
+
+} // namespace
+
+uint32_t nowMs() {
+    return static_cast<uint32_t>(pdTICKS_TO_MS(xTaskGetTickCount()));
+}
+
+} // namespace gpsviewer
+
+extern "C" int main(int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+    using namespace gpsviewer;
+
+    auto* context = new (std::nothrow) AppContext();
+    if (context == nullptr) {
+        return 0;
+    }
+    context->appInstanceId = app_scheduler_current_app_id();
+    if (app_paths_get_user_data_directory(APP_ID, context->dataDirectory, sizeof(context->dataDirectory)) == ERROR_NONE) {
+        mkdir(context->dataDirectory, 0777);
+    }
+    context->mutex = xSemaphoreCreateMutex();
+    context->ui = uiAllocate(*context);
+    if (context->mutex != nullptr && context->ui != nullptr) {
+        context->settings = loadSettings(*context);
+        context->model.reset(nowMs());
+        auto* sources = new (std::nothrow) Sources();
+        if (sources != nullptr) {
+            run(*context, *sources);
+            delete sources;
+        }
+    }
+    uiFree(context->ui);
+    if (context->mutex != nullptr) {
+        vSemaphoreDelete(context->mutex);
+    }
+    delete context;
+    return 0;
+}
diff --git a/Apps/GpsViewer/main/Source/app/MessageCard.cpp b/Apps/GpsViewer/main/Source/app/MessageCard.cpp
new file mode 100644
index 0000000..6b4dbdc
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/MessageCard.cpp
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+bool hasMessage(SourceStatus status) {
+    switch (status) {
+        case SourceStatus::NoReceiver:
+        case SourceStatus::LocationOff:
+        case SourceStatus::ReceiverStarting:
+        case SourceStatus::ReceiverLost:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool hasSettingsButton(SourceStatus status) {
+    return status == SourceStatus::NoReceiver || status == SourceStatus::LocationOff ||
+           status == SourceStatus::ReceiverStarting;
+}
+
+} // namespace
+
+void MessageCard::create(lv_obj_t* parent, const Theme& theme, lv_event_cb_t onSettings, lv_event_cb_t onKey, void* userData) {
+    card = createSection(parent);
+    lv_obj_set_width(card, LV_PCT(92));
+    lv_obj_set_height(card, LV_SIZE_CONTENT);
+    lv_obj_center(card);
+    lv_obj_set_style_pad_all(card, LV_DPX(8), LV_PART_MAIN);
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(card, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_row(card, LV_DPX(5), LV_PART_MAIN);
+
+    createIcon(card, IconKind::Alert, LV_DPX(28), theme.warning, theme.background);
+    titleLabel = createLabel(card, FONT_SIZE_LARGE, theme.text);
+    lv_obj_set_width(titleLabel, LV_PCT(100));
+    lv_obj_set_style_text_align(titleLabel, LV_TEXT_ALIGN_CENTER, LV_PART_MAIN);
+    helpLabel = createLabel(card, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_long_mode(helpLabel, LV_LABEL_LONG_WRAP);
+    lv_obj_set_width(helpLabel, LV_PCT(100));
+    lv_obj_set_style_text_align(helpLabel, LV_TEXT_ALIGN_CENTER, LV_PART_MAIN);
+
+    // The theme styles the button, except in night mode
+    button = lv_button_create(card);
+    lv_obj_t* label = lv_label_create(button);
+    lv_label_set_text(label, "Open settings");
+    if (theme.night) {
+        lv_obj_set_style_bg_color(button, theme.accent, LV_PART_MAIN);
+        lv_obj_set_style_text_color(label, theme.background, LV_PART_MAIN);
+        lv_obj_set_style_outline_color(button, theme.text, LV_STATE_FOCUS_KEY);
+    }
+    lv_obj_add_event_cb(button, onSettings, LV_EVENT_CLICKED, userData);
+    lv_obj_add_event_cb(button, onKey, LV_EVENT_KEY, userData);
+    lv_obj_add_flag(card, LV_OBJ_FLAG_HIDDEN);
+    visible = false;
+    buttonInGroup = lv_group_get_default() != nullptr;
+    // Only in the group while there is a button to use
+    if (buttonInGroup) {
+        lv_group_remove_obj(button);
+        buttonInGroup = false;
+    }
+}
+
+void MessageCard::clear() {
+    card = nullptr;
+    titleLabel = nullptr;
+    helpLabel = nullptr;
+    button = nullptr;
+    visible = false;
+    buttonInGroup = false;
+}
+
+bool MessageCard::update(SourceStatus status, const char* dataDirectory) {
+    if (card == nullptr) {
+        return false;
+    }
+    const bool show = hasMessage(status);
+    if (!show) {
+        if (buttonInGroup && button != nullptr) {
+            lv_group_remove_obj(button);
+            buttonInGroup = false;
+        }
+        setHidden(card, true);
+        visible = false;
+        return false;
+    }
+    char help[PATH_LENGTH + 40];
+    const char* title = "";
+    help[0] = '\0';
+    switch (status) {
+        case SourceStatus::NoReceiver:
+            title = "No GPS receiver";
+            snprintf(help, sizeof(help), "Set one up in Tactility's GPS settings.");
+            break;
+        case SourceStatus::LocationOff:
+            title = "Location is off";
+            snprintf(help, sizeof(help), "Turn it on in Tactility's location settings.");
+            break;
+        case SourceStatus::ReceiverStarting:
+            title = "Starting GPS receiver...";
+            snprintf(help, sizeof(help), "If this takes long, check the receiver in the GPS settings.");
+            break;
+        case SourceStatus::ReceiverLost:
+            title = "GPS receiver stopped";
+            snprintf(help, sizeof(help), "Waiting for it to come back...");
+            break;
+        default:
+            break;
+    }
+    setLabelText(titleLabel, title);
+    setLabelText(helpLabel, help);
+
+    const bool withButton = hasSettingsButton(status);
+    setHidden(button, !withButton);
+    if (button != nullptr && lv_group_get_default() != nullptr) {
+        if (withButton && !buttonInGroup) {
+            lv_group_add_obj(lv_group_get_default(), button);
+            buttonInGroup = true;
+        } else if (!withButton && buttonInGroup) {
+            lv_group_remove_obj(button);
+            buttonInGroup = false;
+        }
+    }
+    setHidden(card, false);
+    visible = true;
+    return true;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/PositionTab.cpp b/Apps/GpsViewer/main/Source/app/PositionTab.cpp
new file mode 100644
index 0000000..375371b
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/PositionTab.cpp
@@ -0,0 +1,247 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+#include "../core/SunTimes.h"
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+
+namespace gpsviewer {
+
+namespace {
+
+void localClock(long long epoch, int& hour, int& minute) {
+    time_t t = static_cast<time_t>(epoch);
+    struct tm local;
+    localtime_r(&t, &local);
+    hour = local.tm_hour;
+    minute = local.tm_min;
+}
+
+const char* compass(float degrees) {
+    static const char names[8][3] = {"N", "NE", "E", "SE", "S", "SW", "W", "NW"};
+    float d = degrees;
+    while (d < 0) {
+        d += 360.0f;
+    }
+    const int index = static_cast<int>((d + 22.5f) / 45.0f) % 8;
+    return names[index];
+}
+
+lv_obj_t* createRow(lv_obj_t* parent, int gap) {
+    lv_obj_t* row = createBox(parent);
+    lv_obj_set_size(row, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_column(row, gap, LV_PART_MAIN);
+    return row;
+}
+
+lv_obj_t* createColumn(lv_obj_t* parent) {
+    lv_obj_t* card = createSection(parent);
+    lv_obj_set_height(card, LV_PCT(100));
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(card, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_row(card, LV_DPX(2), LV_PART_MAIN);
+    return card;
+}
+
+lv_obj_t* createSpacer(lv_obj_t* parent) {
+    lv_obj_t* spacer = createBox(parent);
+    lv_obj_set_size(spacer, 1, 1);
+    lv_obj_set_flex_grow(spacer, 1);
+    return spacer;
+}
+
+} // namespace
+
+void PositionTab::create(lv_obj_t* parent, const Theme& theme) {
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_row(parent, LV_DPX(2), LV_PART_MAIN);
+
+    lv_obj_t* grid = createBox(parent);
+    lv_obj_set_width(grid, LV_PCT(100));
+    lv_obj_set_flex_grow(grid, 1);
+    lv_obj_set_flex_flow(grid, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_pad_column(grid, LV_DPX(6), LV_PART_MAIN);
+
+    // Left tile: coordinates, altitude, course
+    lv_obj_t* left = createColumn(grid);
+    lv_obj_set_width(left, LV_PCT(56));
+    setDivider(left, theme, LV_BORDER_SIDE_RIGHT);
+    createCaption(left, theme, "Coordinates");
+    latitudeLabel = createLabel(left, FONT_SIZE_LARGE, theme.text);
+    longitudeLabel = createLabel(left, FONT_SIZE_LARGE, theme.text);
+    createSpacer(left);
+    altitudeLabel = createLabel(left, FONT_SIZE_DEFAULT, theme.text);
+    courseLabel = createLabel(left, FONT_SIZE_SMALL, theme.dim);
+
+    // Right tile: speed, statistics, sunrise and sunset
+    lv_obj_t* right = createColumn(grid);
+    lv_obj_set_flex_grow(right, 1);
+    createCaption(right, theme, "Speed");
+    lv_obj_t* speedRow = createRow(right, LV_DPX(4));
+    lv_obj_set_flex_align(speedRow, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END);
+    speedLabel = createLabel(speedRow, FONT_SIZE_LARGE, theme.accent);
+    speedUnitLabel = createLabel(speedRow, FONT_SIZE_SMALL, theme.dim);
+    speedStatsLabel = createLabel(right, FONT_SIZE_SMALL, theme.dim);
+    createSpacer(right);
+    const int icon = LV_DPX(12);
+    lv_obj_t* sunRow = createRow(right, LV_DPX(3));
+    createIcon(sunRow, IconKind::Sun, icon, theme.warning, theme.background);
+    riseLabel = createLabel(sunRow, FONT_SIZE_SMALL, theme.text);
+    setRow = createRow(right, LV_DPX(3));
+    createIcon(setRow, IconKind::Moon, icon, theme.dim, theme.background);
+    setLabel = createLabel(setRow, FONT_SIZE_SMALL, theme.text);
+
+    // Bottom status bar: UTC and local time, REC
+    lv_obj_t* bar = createRow(parent, LV_DPX(6));
+    setDivider(bar, theme, LV_BORDER_SIDE_TOP);
+    lv_obj_set_style_pad_top(bar, LV_DPX(3), LV_PART_MAIN);
+    lv_obj_set_style_pad_hor(bar, LV_DPX(4), LV_PART_MAIN);
+    timeLabel = createLabel(bar, FONT_SIZE_SMALL, theme.dim);
+    lv_obj_set_flex_grow(timeLabel, 1);
+    recPill = createTag(bar, "REC", theme.warning);
+    lv_obj_add_flag(recPill, LV_OBJ_FLAG_HIDDEN);
+
+    fitWidth = -1;
+    sunYear = 0;
+    sunMonth = 0;
+    sunDay = 0;
+    sunLatitude = 1000;
+    sunLongitude = 1000;
+    riseText[0] = '\0';
+    setText[0] = '\0';
+}
+
+void PositionTab::update(const TabView& view) {
+    if (latitudeLabel == nullptr || timeLabel == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+    const Units units = view.settings.units;
+    char text[96];
+    char part[40];
+    const int columnWidth = lv_obj_get_content_width(lv_obj_get_parent(latitudeLabel));
+    // Right after a rebuild the layout may not have run yet. Pick the font again once the width is known.
+    if (columnWidth != fitWidth) {
+        fitWidth = columnWidth;
+        lv_label_set_text(latitudeLabel, "");
+        lv_label_set_text(longitudeLabel, "");
+    }
+
+    if (s.hasPosition) {
+        formatCoordinate(s.latitude, true, view.settings.coordinateFormat, part, sizeof(part));
+        setFittedText(latitudeLabel, part, columnWidth);
+        formatCoordinate(s.longitude, false, view.settings.coordinateFormat, part, sizeof(part));
+        setFittedText(longitudeLabel, part, columnWidth);
+    } else {
+        setFittedText(latitudeLabel, "Lat --", columnWidth);
+        setFittedText(longitudeLabel, "Lon --", columnWidth);
+    }
+
+    if (s.hasAltitude) {
+        formatAltitude(s.altitudeMeters, units, part, sizeof(part));
+        snprintf(text, sizeof(text), "Alt %s MSL", part);
+    } else {
+        snprintf(text, sizeof(text), "Alt --");
+    }
+    setLabelText(altitudeLabel, text);
+    if (!std::isnan(s.courseDegrees)) {
+        snprintf(text, sizeof(text), "Course %d\xC2\xB0 %s", static_cast<int>(s.courseDegrees + 0.5f) % 360,
+                 compass(s.courseDegrees));
+        setLabelText(courseLabel, text);
+        setHidden(courseLabel, false);
+    } else {
+        setHidden(courseLabel, true);
+    }
+
+    if (s.hasSpeed) {
+        formatSpeed(s.speedMps, units, part, sizeof(part));
+    } else {
+        snprintf(part, sizeof(part), "--");
+    }
+    setLabelText(speedLabel, part);
+    setLabelText(speedUnitLabel, speedUnit(units));
+    char maxText[16];
+    char avgText[16];
+    formatSpeed(s.maxSpeedMps, units, maxText, sizeof(maxText));
+    formatSpeed(s.averageSpeedMps, units, avgText, sizeof(avgText));
+    snprintf(text, sizeof(text), "Max %s | Avg %s", maxText, avgText);
+    setLabelText(speedStatsLabel, text);
+
+    setHidden(recPill, !view.recording);
+
+    if (s.utc.valid) {
+        const long long epoch = utcToEpoch(s.utc.year, s.utc.month, s.utc.day, s.utc.hour, s.utc.minute, s.utc.second);
+        int hour;
+        int minute;
+        localClock(epoch, hour, minute);
+        int length = snprintf(text, sizeof(text), "%04d-%02d-%02d %02d:%02d UTC", s.utc.year, s.utc.month, s.utc.day,
+                              s.utc.hour, s.utc.minute);
+        if ((hour != s.utc.hour || minute != s.utc.minute) && length > 0 && length < static_cast<int>(sizeof(text))) {
+            snprintf(text + length, sizeof(text) - static_cast<size_t>(length), "  %02d:%02d local", hour, minute);
+        }
+        setLabelText(timeLabel, text);
+    } else {
+        setLabelText(timeLabel, "Time --");
+    }
+
+    if (!s.hasPosition || !s.utc.valid) {
+        setLabelText(riseLabel, "Sun --");
+        setHidden(setRow, true);
+        riseText[0] = '\0';
+        sunYear = 0;
+        return;
+    }
+    const bool sameDate = s.utc.year == sunYear && s.utc.month == sunMonth && s.utc.day == sunDay;
+    const bool samePlace = std::fabs(s.latitude - sunLatitude) <= 0.01 && std::fabs(s.longitude - sunLongitude) <= 0.01;
+    if (!sameDate || !samePlace || riseText[0] == '\0') {
+        sunYear = s.utc.year;
+        sunMonth = s.utc.month;
+        sunDay = s.utc.day;
+        sunLatitude = s.latitude;
+        sunLongitude = s.longitude;
+        const SunTimes sun = computeSunTimes(sunYear, sunMonth, sunDay, sunLatitude, sunLongitude);
+        if (sun.day == SunDay::PolarDay) {
+            snprintf(riseText, sizeof(riseText), "Polar day");
+            setText[0] = '\0';
+        } else if (sun.day == SunDay::PolarNight) {
+            snprintf(riseText, sizeof(riseText), "Polar night");
+            setText[0] = '\0';
+        } else {
+            const long long base = utcToEpoch(sunYear, sunMonth, sunDay, 0, 0, 0);
+            int riseHour;
+            int riseMinute;
+            int setHour;
+            int setMinute;
+            localClock(base + static_cast<long long>(std::floor(sun.sunriseUtcMinutes * 60.0 + 0.5)), riseHour, riseMinute);
+            localClock(base + static_cast<long long>(std::floor(sun.sunsetUtcMinutes * 60.0 + 0.5)), setHour, setMinute);
+            snprintf(riseText, sizeof(riseText), "Rise %02d:%02d", riseHour, riseMinute);
+            snprintf(setText, sizeof(setText), "Set %02d:%02d", setHour, setMinute);
+        }
+    }
+    setLabelText(riseLabel, riseText);
+    setLabelText(setLabel, setText);
+    setHidden(setRow, setText[0] == '\0');
+}
+
+void PositionTab::clear() {
+    latitudeLabel = nullptr;
+    longitudeLabel = nullptr;
+    altitudeLabel = nullptr;
+    courseLabel = nullptr;
+    speedLabel = nullptr;
+    speedUnitLabel = nullptr;
+    speedStatsLabel = nullptr;
+    riseLabel = nullptr;
+    setRow = nullptr;
+    setLabel = nullptr;
+    timeLabel = nullptr;
+    recPill = nullptr;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Recorder.cpp b/Apps/GpsViewer/main/Source/app/Recorder.cpp
new file mode 100644
index 0000000..edd3240
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Recorder.cpp
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Recorder.h"
+#include "AppContext.h"
+
+#include "../core/NmeaWriter.h"
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// Fewer, larger writes keep the SD card and the shared SPI bus quiet
+constexpr uint32_t FLUSH_INTERVAL_MS = 2000;
+constexpr size_t MAX_LINE = 128;
+
+bool endsWith(const char* text, const char* suffix) {
+    const size_t textLength = strlen(text);
+    const size_t suffixLength = strlen(suffix);
+    return textLength >= suffixLength && strcmp(text + textLength - suffixLength, suffix) == 0;
+}
+
+} // namespace
+
+bool Recorder::start(const char* dataDirectory, const UtcDateTime& utc, uint32_t nowMs) {
+    stop();
+    char folder[PATH_LENGTH + 8];
+    snprintf(folder, sizeof(folder), "%s/logs", dataDirectory);
+    mkdir(folder, 0777);
+    if (utc.valid) {
+        snprintf(name, sizeof(name), "gps-%04d%02d%02d-%02d%02d%02d.nmea", utc.year, utc.month, utc.day, utc.hour, utc.minute, utc.second);
+    } else {
+        snprintf(name, sizeof(name), "gps-up%lu.nmea", static_cast<unsigned long>(nowMs / 1000));
+    }
+    char path[PATH_LENGTH + 48];
+    snprintf(path, sizeof(path), "%s/%s", folder, name);
+    file = fopen(path, "w");
+    used = 0;
+    lines = 0;
+    flushedAtMs = nowMs;
+    if (file == nullptr) {
+        name[0] = '\0';
+        return false;
+    }
+    return true;
+}
+
+void Recorder::flush() {
+    if (file != nullptr && used > 0) {
+        fwrite(buffer, 1, used, file);
+        fflush(file);
+        // FAT only commits the data and the file size on sync, so a crash or power loss keeps the log
+        fsync(fileno(file));
+    }
+    used = 0;
+}
+
+void Recorder::stop() {
+    if (file == nullptr) {
+        return;
+    }
+    flush();
+    fclose(file);
+    file = nullptr;
+}
+
+void Recorder::write(const GnssEvent& event, uint32_t nowMs) {
+    if (file == nullptr) {
+        return;
+    }
+    if (sizeof(buffer) - used < MAX_LINE) {
+        flush();
+    }
+    const size_t length = formatNmeaLine(event, buffer + used, sizeof(buffer) - used);
+    if (length > 0) {
+        used += length;
+        lines++;
+    }
+    if (nowMs - flushedAtMs >= FLUSH_INTERVAL_MS) {
+        flush();
+        flushedAtMs = nowMs;
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Recorder.h b/Apps/GpsViewer/main/Source/app/Recorder.h
new file mode 100644
index 0000000..e9b861d
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Recorder.h
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "../core/GnssModel.h"
+
+#include <cstdint>
+#include <cstdio>
+
+namespace gpsviewer {
+
+// Writes received GPS events as an NMEA log. App task only.
+class Recorder {
+public:
+    // Creates <dataDirectory>/logs/gps-<UTC date and time>.nmea, or gps-up<uptime>.nmea without a valid time
+    bool start(const char* dataDirectory, const UtcDateTime& utc, uint32_t nowMs);
+    void stop();
+    void write(const GnssEvent& event, uint32_t nowMs);
+    bool isRecording() const { return file != nullptr; }
+    uint32_t lineCount() const { return lines; }
+    const char* fileName() const { return name; }
+
+private:
+    void flush();
+
+    FILE* file = nullptr;
+    char name[40] = "";
+    char buffer[4096] = "";
+    size_t used = 0;
+    uint32_t lines = 0;
+    uint32_t flushedAtMs = 0;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/SignalTab.cpp b/Apps/GpsViewer/main/Source/app/SignalTab.cpp
new file mode 100644
index 0000000..f0aabfe
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/SignalTab.cpp
@@ -0,0 +1,337 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr int BAR_WIDTH = 14;
+constexpr int BAR_SPACING = 4;
+constexpr int BAR_PITCH = BAR_WIDTH + BAR_SPACING;
+// Extra space between two constellation groups
+constexpr int GROUP_GAP = 8;
+// Left strip with the scale labels
+constexpr int GUTTER = 20;
+constexpr int PAGE_BARS = 4;
+constexpr int MAX_SNR = 50;
+
+int systemRank(GnssSystem system) {
+    return system == GnssSystem::Unknown ? 99 : static_cast<int>(system);
+}
+
+bool before(const Satellite& a, const Satellite& b) {
+    if (a.system != b.system) {
+        return systemRank(a.system) < systemRank(b.system);
+    }
+    return a.id < b.id;
+}
+
+bool sameDrawn(const Satellite& a, const Satellite& b) {
+    return a.system == b.system && a.id == b.id && a.snr == b.snr && a.used == b.used;
+}
+
+} // namespace
+
+void SignalTab::create(lv_obj_t* parent, const Theme& themeIn) {
+    theme = &themeIn;
+    lv_obj_t* card = createSection(parent);
+    lv_obj_set_size(card, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_style_pad_all(card, LV_DPX(4), LV_PART_MAIN);
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(card, LV_DPX(2), LV_PART_MAIN);
+
+    summaryLabel = createLabel(card, FONT_SIZE_SMALL, themeIn.text);
+    lv_obj_set_width(summaryLabel, LV_PCT(100));
+
+    bars = createBox(card);
+    lv_obj_set_width(bars, LV_PCT(100));
+    lv_obj_set_flex_grow(bars, 1);
+    // The bars are dragged, so the tab swipe must not fire on top of that
+    lv_obj_remove_flag(bars, LV_OBJ_FLAG_GESTURE_BUBBLE);
+    lv_obj_add_flag(bars, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_add_event_cb(bars, onDraw, LV_EVENT_DRAW_MAIN, this);
+    lv_obj_add_event_cb(bars, onPress, LV_EVENT_PRESSED, this);
+    lv_obj_add_event_cb(bars, onPress, LV_EVENT_PRESSING, this);
+    lv_obj_add_event_cb(bars, onPress, LV_EVENT_RELEASED, this);
+    dragging = false;
+    count = 0;
+    totalWidth = 0;
+}
+
+int SignalTab::contentWidth() const {
+    return lv_obj_get_width(bars) - GUTTER;
+}
+
+int SignalTab::maxScroll() const {
+    const int overflow = totalWidth - contentWidth();
+    return overflow > 0 ? overflow : 0;
+}
+
+void SignalTab::update(const TabView& view) {
+    if (summaryLabel == nullptr || bars == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+
+    Satellite sorted[SatelliteDb::MAX_SATELLITES];
+    int n = s.satelliteCount;
+    if (n > SatelliteDb::MAX_SATELLITES) {
+        n = SatelliteDb::MAX_SATELLITES;
+    }
+    if (n < 0) {
+        n = 0;
+    }
+    for (int i = 0; i < n; i++) {
+        const Satellite value = s.satellites[i];
+        int j = i;
+        while (j > 0 && before(value, sorted[j - 1])) {
+            sorted[j] = sorted[j - 1];
+            j--;
+        }
+        sorted[j] = value;
+    }
+
+    bool changed = n != count;
+    for (int i = 0; !changed && i < n; i++) {
+        changed = !sameDrawn(sorted[i], satellites[i]);
+    }
+    if (changed) {
+        count = n;
+        int x = 0;
+        for (int i = 0; i < n; i++) {
+            satellites[i] = sorted[i];
+            if (i > 0) {
+                x += BAR_PITCH + (satellites[i].system != satellites[i - 1].system ? GROUP_GAP : 0);
+            }
+            offsets[i] = static_cast<int16_t>(x);
+        }
+        totalWidth = n > 0 ? x + BAR_WIDTH : 0;
+        const int limit = maxScroll();
+        if (scrollPx > limit) {
+            scrollPx = limit;
+        }
+        lv_obj_invalidate(bars);
+    }
+
+    int sum = 0;
+    int used = 0;
+    for (int i = 0; i < n; i++) {
+        if (sorted[i].used && sorted[i].snr > 0) {
+            sum += sorted[i].snr;
+            used++;
+        }
+    }
+    char text[96];
+    if (used > 0) {
+        snprintf(text, sizeof(text), "Avg SNR (used) %d dB-Hz   %d used / %d in view", (sum + used / 2) / used,
+                 s.satellitesUsed, s.satellitesInView);
+    } else {
+        snprintf(text, sizeof(text), "Avg SNR (used) --   %d used / %d in view", s.satellitesUsed, s.satellitesInView);
+    }
+    setLabelText(summaryLabel, text);
+}
+
+void SignalTab::clear() {
+    summaryLabel = nullptr;
+    bars = nullptr;
+    theme = nullptr;
+    dragging = false;
+}
+
+bool SignalTab::scroll(int direction) {
+    if (bars == nullptr) {
+        return false;
+    }
+    const int limit = maxScroll();
+    if (direction > 0 && scrollPx < limit) {
+        scrollPx += PAGE_BARS * BAR_PITCH;
+        if (scrollPx > limit) {
+            scrollPx = limit;
+        }
+        lv_obj_invalidate(bars);
+        return true;
+    }
+    if (direction < 0 && scrollPx > 0) {
+        scrollPx -= PAGE_BARS * BAR_PITCH;
+        if (scrollPx < 0) {
+            scrollPx = 0;
+        }
+        lv_obj_invalidate(bars);
+        return true;
+    }
+    return false;
+}
+
+void SignalTab::onPress(lv_event_t* event) {
+    auto* self = static_cast<SignalTab*>(lv_event_get_user_data(event));
+    if (self->bars == nullptr) {
+        return;
+    }
+    const lv_event_code_t code = lv_event_get_code(event);
+    if (code == LV_EVENT_RELEASED) {
+        self->dragging = false;
+        return;
+    }
+    lv_indev_t* indev = lv_indev_active();
+    if (indev == nullptr) {
+        return;
+    }
+    lv_point_t p;
+    lv_indev_get_point(indev, &p);
+    if (code == LV_EVENT_PRESSED) {
+        self->dragging = true;
+        self->dragStartX = p.x;
+        self->dragStartScroll = self->scrollPx;
+        return;
+    }
+    if (!self->dragging) {
+        return;
+    }
+    int next = self->dragStartScroll - (p.x - self->dragStartX);
+    const int limit = self->maxScroll();
+    if (next < 0) {
+        next = 0;
+    }
+    if (next > limit) {
+        next = limit;
+    }
+    if (next != self->scrollPx) {
+        self->scrollPx = next;
+        lv_obj_invalidate(self->bars);
+    }
+}
+
+void SignalTab::onDraw(lv_event_t* event) {
+    auto* self = static_cast<SignalTab*>(lv_event_get_user_data(event));
+    if (self->bars == nullptr || self->theme == nullptr) {
+        return;
+    }
+    const Theme& theme = *self->theme;
+    lv_layer_t* layer = lv_event_get_layer(event);
+    lv_area_t area;
+    lv_obj_get_coords(self->bars, &area);
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    const int lineHeight = lv_font_get_line_height(font);
+
+    if (self->count == 0) {
+        lv_area_t box = area;
+        box.y1 = area.y1 + ((area.y2 - area.y1 + 1) - lineHeight) / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, "No satellites in view", font, theme.dim, box, LV_TEXT_ALIGN_CENTER);
+        return;
+    }
+
+    const int limit = self->maxScroll();
+    if (self->scrollPx > limit) {
+        self->scrollPx = limit;
+    }
+    const int left = area.x1 + GUTTER;
+    const int origin = left - self->scrollPx;
+
+    const int markerRow = 9;
+    const int chartBottom = area.y2 - lineHeight - markerRow;
+    const int chartTop = area.y1 + lineHeight + 3;
+    const int chartHeight = chartBottom - chartTop;
+    if (chartHeight < 10) {
+        return;
+    }
+
+    // Scale lines at the colour thresholds, drawn first so the bars cover them
+    const int levels[2] = {25, 35};
+    for (int i = 0; i < 2; i++) {
+        const int y = chartBottom - levels[i] * chartHeight / MAX_SNR;
+        drawLine(layer, left, y, area.x2, y, theme.grid);
+    }
+    drawLine(layer, left, chartBottom, area.x2, chartBottom, theme.dim);
+
+    int groupStart = 0;
+    for (int i = 0; i < self->count; i++) {
+        const Satellite& sat = self->satellites[i];
+        const bool lastOfGroup = i == self->count - 1 || self->satellites[i + 1].system != sat.system;
+        const int x = origin + self->offsets[i];
+        if (x + BAR_WIDTH >= left && x <= area.x2) {
+            const int snr = sat.snr > MAX_SNR ? MAX_SNR : (sat.snr < 0 ? 0 : sat.snr);
+            const lv_color_t color = snrColor(snr, theme);
+            if (snr == 0) {
+                drawLine(layer, x, chartBottom - 1, x + BAR_WIDTH - 1, chartBottom - 1, theme.dim);
+            } else {
+                int height = snr * chartHeight / MAX_SNR;
+                if (height < 3) {
+                    height = 3;
+                }
+                lv_area_t bar;
+                bar.x1 = x;
+                bar.x2 = x + BAR_WIDTH - 1;
+                bar.y1 = chartBottom - height;
+                bar.y2 = chartBottom - 1;
+                lv_draw_rect_dsc_t rect;
+                lv_draw_rect_dsc_init(&rect);
+                rect.radius = 2;
+                if (sat.used) {
+                    rect.bg_opa = LV_OPA_COVER;
+                    rect.bg_color = color;
+                    rect.border_width = 0;
+                } else {
+                    rect.bg_opa = LV_OPA_TRANSP;
+                    rect.border_opa = LV_OPA_COVER;
+                    rect.border_color = color;
+                    rect.border_width = 1;
+                    rect.border_side = LV_BORDER_SIDE_FULL;
+                }
+                lv_draw_rect(layer, &rect, &bar);
+            }
+
+            const float centre = static_cast<float>(x) + static_cast<float>(BAR_WIDTH - 1) / 2.0f;
+            drawMarker(layer, sat.system, centre, static_cast<float>(chartBottom + markerRow / 2 + 1), 2.5f, true,
+                       systemColor(sat.system, theme));
+            lv_area_t idBox;
+            idBox.x1 = x - BAR_SPACING / 2 - 3;
+            idBox.x2 = x + BAR_WIDTH + BAR_SPACING / 2 + 2;
+            idBox.y1 = area.y2 - lineHeight + 1;
+            idBox.y2 = area.y2;
+            char id[8];
+            snprintf(id, sizeof(id), "%d", static_cast<int>(sat.id));
+            drawText(layer, id, font, theme.text, idBox, LV_TEXT_ALIGN_CENTER);
+        }
+
+        if (lastOfGroup) {
+            // Group label at the start of the group, kept in view while the group is scrolled
+            const int groupLeft = origin + self->offsets[groupStart];
+            const int groupRight = x + BAR_WIDTH;
+            const int labelWidth = 3 * lineHeight / 2 + 4;
+            int labelX = groupLeft < left ? left : groupLeft;
+            if (labelX + labelWidth > groupRight) {
+                labelX = groupRight - labelWidth;
+            }
+            if (groupRight > left && groupLeft < area.x2) {
+                lv_area_t box;
+                box.x1 = labelX;
+                box.x2 = labelX + labelWidth;
+                box.y1 = area.y1;
+                box.y2 = area.y1 + lineHeight;
+                drawText(layer, systemShortName(sat.system), font, systemColor(sat.system, theme), box,
+                         LV_TEXT_ALIGN_LEFT);
+            }
+            groupStart = i + 1;
+        }
+    }
+
+    // Scale strip on top of the scrolled content
+    drawFilledRect(layer, area.x1, area.y1, left - 3, area.y2, theme.background);
+    for (int i = 0; i < 2; i++) {
+        const int y = chartBottom - levels[i] * chartHeight / MAX_SNR;
+        lv_area_t box;
+        box.x1 = area.x1;
+        box.x2 = left - 4;
+        box.y1 = y - lineHeight / 2;
+        box.y2 = box.y1 + lineHeight;
+        char label[8];
+        snprintf(label, sizeof(label), "%d", levels[i]);
+        drawText(layer, label, font, theme.dim, box, LV_TEXT_ALIGN_LEFT);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/SkyTab.cpp b/Apps/GpsViewer/main/Source/app/SkyTab.cpp
new file mode 100644
index 0000000..489298c
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/SkyTab.cpp
@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cmath>
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr float PI_F = 3.14159265f;
+constexpr float MARKER_RADIUS = 5.0f;
+// Smallest width of the legend sidebar
+constexpr int MIN_LEGEND_WIDTH = 96;
+
+bool sameSky(const Satellite& a, const Satellite& b) {
+    return a.system == b.system && a.elevation == b.elevation && a.azimuth == b.azimuth && a.used == b.used;
+}
+
+} // namespace
+
+void SkyTab::create(lv_obj_t* parent, const Theme& themeIn) {
+    theme = &themeIn;
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_column(parent, LV_DPX(4), LV_PART_MAIN);
+
+    // The radar is as large as the height allows, but leaves room for the legend
+    int side = lv_obj_get_content_height(parent);
+    const int maxSide = lv_obj_get_content_width(parent) - LV_DPX(4) - LV_DPX(MIN_LEGEND_WIDTH);
+    if (side > maxSide) {
+        side = maxSide;
+    }
+    plot = createBox(parent);
+    lv_obj_set_size(plot, side, side);
+    lv_obj_add_event_cb(plot, onDrawRadar, LV_EVENT_DRAW_MAIN, this);
+
+    lv_obj_t* sidebar = createSection(parent);
+    setDivider(sidebar, themeIn, LV_BORDER_SIDE_LEFT);
+    lv_obj_set_height(sidebar, LV_PCT(100));
+    lv_obj_set_flex_grow(sidebar, 1);
+    lv_obj_set_style_pad_all(sidebar, LV_DPX(4), LV_PART_MAIN);
+    lv_obj_set_flex_flow(sidebar, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(sidebar, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_left(sidebar, LV_DPX(8), LV_PART_MAIN);
+    lv_obj_set_style_pad_row(sidebar, LV_DPX(4), LV_PART_MAIN);
+
+    createCaption(sidebar, themeIn, "Used / in view");
+    totalLabel = createLabel(sidebar, FONT_SIZE_LARGE, themeIn.text);
+    legend = createBox(sidebar);
+    lv_obj_set_width(legend, LV_PCT(100));
+    lv_obj_set_flex_grow(legend, 1);
+    lv_obj_add_event_cb(legend, onDrawLegend, LV_EVENT_DRAW_MAIN, this);
+    count = 0;
+    for (int i = 0; i < GNSS_SYSTEM_COUNT; i++) {
+        inView[i] = 0;
+        used[i] = 0;
+    }
+}
+
+void SkyTab::update(const TabView& view) {
+    if (plot == nullptr || legend == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+    int n = s.satelliteCount;
+    if (n > SatelliteDb::MAX_SATELLITES) {
+        n = SatelliteDb::MAX_SATELLITES;
+    }
+    if (n < 0) {
+        n = 0;
+    }
+    bool changed = n != count;
+    for (int i = 0; !changed && i < n; i++) {
+        changed = !sameSky(s.satellites[i], satellites[i]);
+    }
+    if (changed) {
+        count = n;
+        for (int i = 0; i < n; i++) {
+            satellites[i] = s.satellites[i];
+        }
+        lv_obj_invalidate(plot);
+    }
+
+    int newInView[GNSS_SYSTEM_COUNT] = {};
+    int newUsed[GNSS_SYSTEM_COUNT] = {};
+    for (int i = 0; i < n; i++) {
+        const int system = static_cast<int>(s.satellites[i].system);
+        if (system < 0 || system >= GNSS_SYSTEM_COUNT) {
+            continue;
+        }
+        newInView[system]++;
+        if (s.satellites[i].used) {
+            newUsed[system]++;
+        }
+    }
+    bool legendChanged = false;
+    for (int i = 0; i < GNSS_SYSTEM_COUNT; i++) {
+        if (newInView[i] != inView[i] || newUsed[i] != used[i]) {
+            legendChanged = true;
+            inView[i] = newInView[i];
+            used[i] = newUsed[i];
+        }
+    }
+    if (legendChanged) {
+        lv_obj_invalidate(legend);
+    }
+
+    char text[32];
+    snprintf(text, sizeof(text), "%d / %d", s.satellitesUsed, s.satellitesInView);
+    setLabelText(totalLabel, text);
+}
+
+void SkyTab::clear() {
+    plot = nullptr;
+    totalLabel = nullptr;
+    legend = nullptr;
+    theme = nullptr;
+}
+
+void SkyTab::onDrawRadar(lv_event_t* event) {
+    auto* self = static_cast<SkyTab*>(lv_event_get_user_data(event));
+    if (self->plot == nullptr || self->theme == nullptr) {
+        return;
+    }
+    const Theme& theme = *self->theme;
+    lv_layer_t* layer = lv_event_get_layer(event);
+    lv_area_t area;
+    lv_obj_get_coords(self->plot, &area);
+    const int side = area.x2 - area.x1 + 1;
+    const int cx = area.x1 + side / 2;
+    const int cy = area.y1 + side / 2;
+    const int r = side / 2 - 1;
+    if (r < 20) {
+        return;
+    }
+
+    // Rings for 0 (outer), 30 and 60 degrees elevation
+    for (int elevation = 0; elevation < 90; elevation += 30) {
+        const int rr = r * (90 - elevation) / 90;
+        drawCircle(layer, cx, cy, rr, elevation == 0 ? theme.dim : theme.grid, false, 1);
+    }
+    drawLine(layer, cx, cy - r, cx, cy + r, theme.grid);
+    drawLine(layer, cx - r, cy, cx + r, cy, theme.grid);
+
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    const int lineHeight = lv_font_get_line_height(font);
+    const int half = lineHeight / 2 + 1;
+    const struct {
+        char text[2];
+        int x;
+        int y;
+    } marks[4] = {
+        {"N", cx, cy - r + lineHeight / 2 + 2},
+        {"E", cx + r - half - 2, cy},
+        {"S", cx, cy + r - lineHeight / 2 - 2},
+        {"W", cx - r + half + 2, cy},
+    };
+    for (int i = 0; i < 4; i++) {
+        lv_area_t box;
+        box.x1 = marks[i].x - half;
+        box.x2 = marks[i].x + half;
+        box.y1 = marks[i].y - lineHeight / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, marks[i].text, font, theme.dim, box, LV_TEXT_ALIGN_CENTER);
+    }
+
+    // Unused first so the used ones end up on top
+    for (int pass = 0; pass < 2; pass++) {
+        for (int i = 0; i < self->count; i++) {
+            const Satellite& sat = self->satellites[i];
+            if (sat.elevation < 0 || sat.azimuth < 0 || sat.used != (pass == 1)) {
+                continue;
+            }
+            const float distance = static_cast<float>(r) * static_cast<float>(90 - sat.elevation) / 90.0f;
+            const float azimuth = static_cast<float>(sat.azimuth) * PI_F / 180.0f;
+            const float x = static_cast<float>(cx) + distance * std::sin(azimuth);
+            const float y = static_cast<float>(cy) - distance * std::cos(azimuth);
+            drawMarker(layer, sat.system, x, y, MARKER_RADIUS, sat.used, systemColor(sat.system, theme));
+        }
+    }
+}
+
+void SkyTab::onDrawLegend(lv_event_t* event) {
+    auto* self = static_cast<SkyTab*>(lv_event_get_user_data(event));
+    if (self->legend == nullptr || self->theme == nullptr) {
+        return;
+    }
+    const Theme& theme = *self->theme;
+    lv_layer_t* layer = lv_event_get_layer(event);
+    lv_area_t area;
+    lv_obj_get_coords(self->legend, &area);
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    const int lineHeight = lv_font_get_line_height(font);
+
+    int rows = 0;
+    for (int i = 0; i < GNSS_SYSTEM_COUNT; i++) {
+        if (self->inView[i] > 0) {
+            rows++;
+        }
+    }
+    if (rows == 0) {
+        lv_area_t box = area;
+        box.y1 = area.y1 + ((area.y2 - area.y1 + 1) - lineHeight) / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, "No satellites", font, theme.dim, box, LV_TEXT_ALIGN_CENTER);
+        return;
+    }
+    int pitch = lineHeight + 3;
+    const int available = area.y2 - area.y1 + 1;
+    if (pitch * rows > available) {
+        pitch = available / rows;
+    }
+    int y = area.y1 + (available - pitch * rows) / 2;
+    for (int k = 0; k < GNSS_SYSTEM_COUNT; k++) {
+        const int index = (k + 1) % GNSS_SYSTEM_COUNT;
+        if (self->inView[index] == 0) {
+            continue;
+        }
+        const auto system = static_cast<GnssSystem>(index);
+        const lv_color_t color = systemColor(system, theme);
+        const float markerX = static_cast<float>(area.x1) + MARKER_RADIUS + 2.0f;
+        const float markerY = static_cast<float>(y) + static_cast<float>(pitch) / 2.0f;
+        drawMarker(layer, system, markerX, markerY, MARKER_RADIUS, self->used[index] > 0, color);
+        char text[24];
+        snprintf(text, sizeof(text), "%s %d/%d", systemName(system), self->used[index], self->inView[index]);
+        lv_area_t box;
+        box.x1 = area.x1 + static_cast<int>(MARKER_RADIUS * 2.0f) + 8;
+        box.x2 = area.x2;
+        box.y1 = y + (pitch - lineHeight) / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, text, font, theme.text, box, LV_TEXT_ALIGN_LEFT);
+        y += pitch;
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Sources.cpp b/Apps/GpsViewer/main/Source/app/Sources.cpp
new file mode 100644
index 0000000..7ddbaaf
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Sources.cpp
@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Sources.h"
+
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// The location service starts the receiver when the app subscribes, so the first checks come quickly
+constexpr uint32_t CONNECT_INTERVAL_MS = 250;
+constexpr int QUEUE_LENGTH = 48;
+constexpr uint32_t READER_IDLE_MS = 100;
+constexpr uint32_t READER_STACK_SIZE = 3072;
+// Above the GPS driver's thread (THREAD_PRIORITY_HIGH, 5) so no event is overwritten before it's copied
+constexpr UBaseType_t READER_PRIORITY = 6;
+
+// Firmware headers without GpsEvent::talker select the second overload: talker unknown,
+// and satellites are then told apart by their ID ranges only
+template <typename Event>
+auto copyTalker(const Event& event, char* out, int) -> decltype(event.talker, void()) {
+    memcpy(out, event.talker, 2);
+    out[2] = '\0';
+}
+
+template <typename Event>
+void copyTalker(const Event&, char* out, long) {
+    out[0] = '\0';
+}
+
+bool toGnssEvent(const GpsEvent& in, GnssEvent& out) {
+    memset(&out, 0, sizeof(out));
+    copyTalker(in, out.talker, 0);
+    switch (in.type) {
+        case GPS_EVENT_MESSAGE_RMC:
+            out.type = GnssEventType::Rmc;
+            out.data.rmc = in.data.rmc;
+            return true;
+        case GPS_EVENT_MESSAGE_GGA:
+            out.type = GnssEventType::Gga;
+            out.data.gga = in.data.gga;
+            return true;
+        case GPS_EVENT_MESSAGE_GSV:
+            out.type = GnssEventType::Gsv;
+            out.data.gsv = in.data.gsv;
+            return true;
+        case GPS_EVENT_MESSAGE_GSA:
+            out.type = GnssEventType::Gsa;
+            out.data.gsa = in.data.gsa;
+            return true;
+        default:
+            return false;
+    }
+}
+
+void setStatus(AppContext& context, SourceStatus status) {
+    ContextLock lock(context);
+    context.status = status;
+}
+
+} // namespace
+
+// The driver frees its state when the device stops, after it sent GPS_EVENT_UNSUBSCRIBED and
+// dropped all subscriptions. So the API is only called on a started device, and never after that event.
+void GpsSource::tryConnect(uint32_t now) {
+    if (static_cast<int32_t>(now - nextAttemptMs) < 0) {
+        return;
+    }
+    nextAttemptMs = now + CONNECT_INTERVAL_MS;
+
+    if (!location_is_enabled()) {
+        setStatus(*context, SourceStatus::LocationOff);
+        return;
+    }
+    Device* found = nullptr;
+    if (device_get_first_active_by_type(&GPS_TYPE, &found) != ERROR_NONE) {
+        Device* configured = nullptr;
+        const bool exists = device_get_first_by_type(&GPS_TYPE, &configured) == ERROR_NONE;
+        if (exists) {
+            device_put(configured);
+        }
+        setStatus(*context, lost ? SourceStatus::ReceiverLost : exists ? SourceStatus::ReceiverStarting : SourceStatus::NoReceiver);
+        return;
+    }
+    if (gps_get_state(found) != GPS_STATE_ON) {
+        device_put(found);
+        setStatus(*context, lost ? SourceStatus::ReceiverLost : SourceStatus::ReceiverStarting);
+        return;
+    }
+    subscription = {};
+    if (gps_event_subscribe(found, &subscription) != ERROR_NONE) {
+        device_put(found);
+        return;
+    }
+    device = found;
+    subscribed = true;
+    lost = false;
+
+    char name[32] = "";
+    gps_get_model_name(device, name, sizeof(name));
+    ContextLock lock(*context);
+    memcpy(context->receiverName, name, sizeof(context->receiverName));
+    context->receiverName[sizeof(context->receiverName) - 1] = '\0';
+    context->status = SourceStatus::Receiving;
+    context->model.reset(now);
+}
+
+void GpsSource::disconnect() {
+    if (subscribed) {
+        if (device_is_ready(device)) {
+            gps_event_unsubscribe(device, &subscription);
+        }
+        subscribed = false;
+        device_put(device);
+        device = nullptr;
+    }
+    lost = false;
+    nextAttemptMs = 0;
+}
+
+void GpsSource::readerLoop() {
+    while (!stopRequested.load()) {
+        if (!subscribed) {
+            tryConnect(nowMs());
+            if (!subscribed) {
+                vTaskDelay(pdMS_TO_TICKS(READER_IDLE_MS));
+                continue;
+            }
+        }
+        if (gps_event_await(device, &subscription, pdMS_TO_TICKS(READER_IDLE_MS)) != ERROR_NONE) {
+            continue;
+        }
+        const GpsEvent event = subscription.event;
+        if (event.type == GPS_EVENT_UNSUBSCRIBED) {
+            subscribed = false;
+            lost = true;
+            device_put(device);
+            device = nullptr;
+            setStatus(*context, SourceStatus::ReceiverLost);
+            continue;
+        }
+        GnssEvent gnss;
+        if (toGnssEvent(event, gnss)) {
+            // A full queue drops the event, the next epoch repeats the data
+            xQueueSend(queue, &gnss, 0);
+        }
+    }
+    disconnect();
+}
+
+void GpsSource::readerMain(void* argument) {
+    auto* source = static_cast<GpsSource*>(argument);
+    source->readerLoop();
+    source->readerDone.store(true);
+    vTaskDelete(nullptr);
+}
+
+// Only the location service starts GPS receivers. Its subscription also keeps the receiver running
+// while this app reads the raw sentences.
+void GpsSource::start(AppContext& appContext, TaskEventGroup* eventGroup) {
+    context = &appContext;
+    if (!locationSubscribed) {
+        location = {};
+        locationSubscribed = location_subscribe(&location, eventGroup, "GPS Viewer") == ERROR_NONE;
+    }
+    if (queue == nullptr) {
+        queue = xQueueCreate(QUEUE_LENGTH, sizeof(GnssEvent));
+    }
+    if (queue == nullptr || !readerDone.load()) {
+        return;
+    }
+    stopRequested.store(false);
+    readerDone.store(false);
+    nextAttemptMs = 0;
+    if (xTaskCreatePinnedToCore(readerMain, "gpsviewer_rx", READER_STACK_SIZE, this, READER_PRIORITY, &reader, tskNO_AFFINITY) != pdPASS) {
+        readerDone.store(true);
+        reader = nullptr;
+    }
+}
+
+void GpsSource::poll(AppContext& appContext, uint32_t timeoutMs, Recorder& recorder) {
+    if (queue == nullptr) {
+        vTaskDelay(pdMS_TO_TICKS(timeoutMs));
+        return;
+    }
+    GnssEvent event;
+    if (xQueueReceive(queue, &event, pdMS_TO_TICKS(timeoutMs)) != pdTRUE) {
+        return;
+    }
+    const uint32_t now = nowMs();
+    int handled = 0;
+    do {
+        {
+            ContextLock lock(appContext);
+            appContext.model.onEvent(event, now);
+        }
+        recorder.write(event, now);
+        handled++;
+    } while (handled < QUEUE_LENGTH && xQueueReceive(queue, &event, 0) == pdTRUE);
+}
+
+
+void GpsSource::stop() {
+    stopRequested.store(true);
+    // The reader wakes at least every READER_IDLE_MS
+    for (int i = 0; i < 100 && !readerDone.load(); i++) {
+        vTaskDelay(pdMS_TO_TICKS(20));
+    }
+    reader = nullptr;
+    if (locationSubscribed) {
+        location_unsubscribe(&location);
+        locationSubscribed = false;
+    }
+    if (queue != nullptr && readerDone.load()) {
+        vQueueDelete(queue);
+        queue = nullptr;
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Sources.h b/Apps/GpsViewer/main/Source/app/Sources.h
new file mode 100644
index 0000000..8a94a0d
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Sources.h
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "AppContext.h"
+#include "Recorder.h"
+
+#include <gps/gps.h>
+#include <location/location.h>
+#include <tactility/device.h>
+
+#include <freertos/queue.h>
+#include <freertos/task.h>
+
+#include <atomic>
+
+namespace gpsviewer {
+
+// Live data from the first started GPS_TYPE device.
+// A GPS subscription holds only the latest event, and the driver's thread runs at a high priority.
+// So a reader task with a higher priority copies every event into a queue right away, otherwise
+// the parts of a GSV set get overwritten before they are read. The app task drains the queue.
+class GpsSource {
+public:
+    // Subscribes to the location service, which starts the receiver and shows the location icon,
+    // and starts the reader task. App task only.
+    void start(AppContext& context, TaskEventGroup* eventGroup);
+    // Feeds queued events into the model and the recorder, waiting at most timeoutMs for the first. App task only.
+    void poll(AppContext& context, uint32_t timeoutMs, Recorder& recorder);
+    // Stops the reader task, which drops the GPS subscription, then the location subscription. App task only.
+    void stop();
+
+private:
+    static void readerMain(void* argument);
+    void readerLoop();
+    // Reader task only
+    void tryConnect(uint32_t now);
+    void disconnect();
+
+    AppContext* context = nullptr;
+    QueueHandle_t queue = nullptr;
+    TaskHandle_t reader = nullptr;
+    std::atomic<bool> stopRequested {false};
+    std::atomic<bool> readerDone {true};
+    LocationSubscription location {};
+    bool locationSubscribed = false;
+
+
+    // Reader task only
+    Device* device = nullptr;
+    GpsSubscription subscription {};
+    bool subscribed = false;
+    uint32_t nextAttemptMs = 0;
+    bool lost = false;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/StatusTab.cpp b/Apps/GpsViewer/main/Source/app/StatusTab.cpp
new file mode 100644
index 0000000..2555d62
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/StatusTab.cpp
@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cmath>
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr int DOT_SIZE = 14;
+
+const char* dopQualityWord(float value) {
+    if (std::isnan(value)) {
+        return "";
+    }
+    if (value < 1.0f) {
+        return "Ideal";
+    }
+    if (value < 2.0f) {
+        return "Excellent";
+    }
+    if (value < 5.0f) {
+        return "Good";
+    }
+    if (value < 10.0f) {
+        return "Moderate";
+    }
+    if (value < 20.0f) {
+        return "Fair";
+    }
+    return "Poor";
+}
+
+lv_obj_t* createRow(lv_obj_t* parent) {
+    lv_obj_t* row = createBox(parent);
+    lv_obj_set_size(row, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_column(row, LV_DPX(4), LV_PART_MAIN);
+    return row;
+}
+
+lv_obj_t* createSpacer(lv_obj_t* parent) {
+    lv_obj_t* spacer = createBox(parent);
+    lv_obj_set_size(spacer, 1, 1);
+    lv_obj_set_flex_grow(spacer, 1);
+    return spacer;
+}
+
+// Full-width block, with a divider below unless it is the last one
+lv_obj_t* createBlock(lv_obj_t* parent, const Theme& theme, bool divider) {
+    lv_obj_t* block = createSection(parent);
+    lv_obj_set_size(block, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_ver(block, LV_DPX(5), LV_PART_MAIN);
+    if (divider) {
+        setDivider(block, theme, LV_BORDER_SIDE_BOTTOM);
+    }
+    return block;
+}
+
+} // namespace
+
+void StatusTab::create(lv_obj_t* parent, const Theme& theme) {
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_row(parent, 0, LV_PART_MAIN);
+
+    // Fix card: status indicator on the left, accuracy on the right
+    lv_obj_t* fixCard = createBlock(parent, theme, true);
+    lv_obj_set_flex_flow(fixCard, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(fixCard, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_column(fixCard, LV_DPX(6), LV_PART_MAIN);
+    fixDot = createBox(fixCard);
+    lv_obj_set_size(fixDot, DOT_SIZE, DOT_SIZE);
+    lv_obj_set_style_radius(fixDot, LV_RADIUS_CIRCLE, LV_PART_MAIN);
+    lv_obj_set_style_border_color(fixDot, theme.dim, LV_PART_MAIN);
+    lv_obj_set_style_border_width(fixDot, 2, LV_PART_MAIN);
+    fixLabel = createLabel(fixCard, FONT_SIZE_LARGE, theme.dim);
+    createSpacer(fixCard);
+    lv_obj_t* accuracy = createBox(fixCard);
+    lv_obj_set_size(accuracy, LV_SIZE_CONTENT, LV_SIZE_CONTENT);
+    // One line: "est." next to the value, so the tab fits the T-Deck's content height
+    lv_obj_set_flex_flow(accuracy, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(accuracy, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END);
+    lv_obj_set_style_pad_column(accuracy, LV_DPX(3), LV_PART_MAIN);
+    lv_obj_t* estimate = createLabel(accuracy, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(estimate, "est.");
+    accuracyLabel = createLabel(accuracy, FONT_SIZE_LARGE, theme.accent);
+
+    // DOP card: three columns
+    lv_obj_t* dopCard = createBlock(parent, theme, true);
+    lv_obj_set_flex_flow(dopCard, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(dopCard, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    const char captions[3][5] = {"HDOP", "VDOP", "PDOP"};
+    for (int i = 0; i < 3; i++) {
+        lv_obj_t* column = createBox(dopCard);
+        lv_obj_set_size(column, LV_PCT(32), LV_SIZE_CONTENT);
+        lv_obj_set_flex_flow(column, LV_FLEX_FLOW_COLUMN);
+        createCaption(column, theme, captions[i]);
+        lv_obj_t* row = createRow(column);
+        lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END);
+        dopValue[i] = createLabel(row, FONT_SIZE_DEFAULT, theme.text);
+        dopQuality[i] = createLabel(row, FONT_SIZE_SMALL, theme.dim);
+    }
+
+    // Satellites, time to first fix, receiver
+    lv_obj_t* infoCard = createBlock(parent, theme, false);
+    lv_obj_set_flex_flow(infoCard, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(infoCard, LV_DPX(2), LV_PART_MAIN);
+    lv_obj_t* satellitesRow = createRow(infoCard);
+    lv_obj_t* satellitesCaption = createLabel(satellitesRow, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(satellitesCaption, "Satellites used / in view");
+    createSpacer(satellitesRow);
+    satellitesLabel = createLabel(satellitesRow, FONT_SIZE_DEFAULT, theme.text);
+    lv_obj_t* ttffRow = createRow(infoCard);
+    lv_obj_t* ttffCaption = createLabel(ttffRow, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(ttffCaption, "Time to first fix");
+    createSpacer(ttffRow);
+    ttffLabel = createLabel(ttffRow, FONT_SIZE_DEFAULT, theme.text);
+    ttffNote = createLabel(ttffRow, FONT_SIZE_SMALL, theme.dim);
+    receiverLabel = createLabel(infoCard, FONT_SIZE_SMALL, theme.dim);
+    lv_obj_set_width(receiverLabel, LV_PCT(100));
+    lastFix = -1;
+}
+
+void StatusTab::update(const TabView& view) {
+    if (fixDot == nullptr || fixLabel == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+    const Theme& theme = view.theme;
+    const int fix = static_cast<int>(s.fix);
+    if (fix != lastFix) {
+        lastFix = fix;
+        const lv_color_t color = fixColor(s.fix, theme);
+        // Filled dot with a fix, hollow ring without
+        lv_obj_set_style_bg_color(fixDot, color, LV_PART_MAIN);
+        lv_obj_set_style_bg_opa(fixDot, s.fix == FixType::None ? LV_OPA_TRANSP : LV_OPA_COVER, LV_PART_MAIN);
+        lv_obj_set_style_border_color(fixDot, color, LV_PART_MAIN);
+        lv_obj_set_style_text_color(fixLabel, color, LV_PART_MAIN);
+    }
+    setLabelText(fixLabel, fixText(s.fix));
+
+    char text[96];
+    if (std::isnan(s.hdop)) {
+        setLabelText(accuracyLabel, "--");
+    } else {
+        char accuracy[24];
+        formatAccuracy(estimatedAccuracyMeters(s.hdop), view.settings.units, accuracy, sizeof(accuracy));
+        snprintf(text, sizeof(text), "\xC2\xB1%s", accuracy);
+        setLabelText(accuracyLabel, text);
+    }
+
+    const float dops[3] = {s.hdop, s.vdop, s.pdop};
+    for (int i = 0; i < 3; i++) {
+        if (std::isnan(dops[i])) {
+            setLabelText(dopValue[i], "--");
+        } else {
+            snprintf(text, sizeof(text), "%.1f", static_cast<double>(dops[i]));
+            setLabelText(dopValue[i], text);
+        }
+        setLabelText(dopQuality[i], dopQualityWord(dops[i]));
+    }
+
+    snprintf(text, sizeof(text), "%d / %d", s.satellitesUsed, s.satellitesInView);
+    setLabelText(satellitesLabel, text);
+
+    char duration[24];
+    if (s.hasTtff) {
+        formatDuration(s.ttffMs / 1000, duration, sizeof(duration));
+        setLabelText(ttffLabel, duration);
+        setLabelText(ttffNote, "since app start");
+    } else {
+        formatDuration(s.listeningMs / 1000, duration, sizeof(duration));
+        snprintf(text, sizeof(text), "searching %s", duration);
+        setLabelText(ttffLabel, text);
+        setLabelText(ttffNote, "since app start");
+    }
+
+    if (view.receiverName[0] == '\0') {
+        snprintf(text, sizeof(text), "Receiver: unknown");
+    } else {
+        snprintf(text, sizeof(text), "Receiver: %s", view.receiverName);
+    }
+    setLabelText(receiverLabel, text);
+}
+
+void StatusTab::clear() {
+    fixDot = nullptr;
+    fixLabel = nullptr;
+    accuracyLabel = nullptr;
+    for (int i = 0; i < 3; i++) {
+        dopValue[i] = nullptr;
+        dopQuality[i] = nullptr;
+    }
+    satellitesLabel = nullptr;
+    ttffLabel = nullptr;
+    ttffNote = nullptr;
+    receiverLabel = nullptr;
+    lastFix = -1;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Tabs.h b/Apps/GpsViewer/main/Source/app/Tabs.h
new file mode 100644
index 0000000..edbd384
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Tabs.h
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "AppContext.h"
+
+#include <lvgl.h>
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+struct Theme {
+    bool night;
+    // Monochrome theme: no colours, shapes and fills only
+    bool mono;
+    // Screen background behind the app. Only painted in night mode, otherwise the window's own.
+    lv_color_t background;
+    bool paintBackground;
+    // Divider lines
+    lv_color_t border;
+    lv_color_t accent;
+    lv_color_t success;
+    lv_color_t warning;
+    lv_color_t text;
+    // Secondary labels and units
+    lv_color_t dim;
+    // Radar rings, chart lines
+    lv_color_t grid;
+};
+
+Theme makeTheme(bool night);
+// Day: >= 35 dB-Hz success, 25..34 warning, below that the dim colour. Night: three reds.
+lv_color_t snrColor(int snr, const Theme& theme);
+lv_color_t systemColor(GnssSystem system, const Theme& theme);
+// Sets the label text only when it differs, so unchanged labels cause no redraw
+void setLabelText(lv_obj_t* label, const char* text);
+
+// What every tab gets on each refresh. LVGL thread only.
+struct TabView {
+    const GnssSnapshot& snapshot;
+    const Settings& settings;
+    SourceStatus status;
+    bool recording;
+    const char* receiverName;
+    const Theme& theme;
+};
+
+// Each tab builds its widgets in create() inside `parent` (the content area, about 312x150 on a
+// T-Deck, sizes from lv_obj_get_content_width/height), and update() only changes what differs.
+// clear() forgets the widget pointers after LVGL deleted them.
+
+class StatusTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+
+private:
+    lv_obj_t* fixDot = nullptr;
+    lv_obj_t* fixLabel = nullptr;
+    lv_obj_t* accuracyLabel = nullptr;
+    lv_obj_t* dopValue[3] {};
+    lv_obj_t* dopQuality[3] {};
+    lv_obj_t* satellitesLabel = nullptr;
+    lv_obj_t* ttffLabel = nullptr;
+    lv_obj_t* ttffNote = nullptr;
+    lv_obj_t* receiverLabel = nullptr;
+    int lastFix = -1;
+};
+
+class SignalTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+    // Scrolls the bars by a few satellites. Returns false when already at that end.
+    bool scroll(int direction);
+
+private:
+    static void onDraw(lv_event_t* event);
+    static void onPress(lv_event_t* event);
+    int contentWidth() const;
+    int maxScroll() const;
+
+    lv_obj_t* summaryLabel = nullptr;
+    lv_obj_t* bars = nullptr;
+    const Theme* theme = nullptr;
+    int count = 0;
+    Satellite satellites[SatelliteDb::MAX_SATELLITES] {};
+    // X of each bar relative to the first one, group gaps included
+    int16_t offsets[SatelliteDb::MAX_SATELLITES] {};
+    int totalWidth = 0;
+    int scrollPx = 0;
+    int dragStartX = 0;
+    int dragStartScroll = 0;
+    bool dragging = false;
+};
+
+class SkyTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+
+private:
+    static void onDrawRadar(lv_event_t* event);
+    static void onDrawLegend(lv_event_t* event);
+
+    lv_obj_t* plot = nullptr;
+    lv_obj_t* totalLabel = nullptr;
+    lv_obj_t* legend = nullptr;
+    const Theme* theme = nullptr;
+    int count = 0;
+    Satellite satellites[SatelliteDb::MAX_SATELLITES] {};
+    int inView[GNSS_SYSTEM_COUNT] {};
+    int used[GNSS_SYSTEM_COUNT] {};
+};
+
+class PositionTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+
+private:
+    lv_obj_t* latitudeLabel = nullptr;
+    lv_obj_t* longitudeLabel = nullptr;
+    lv_obj_t* altitudeLabel = nullptr;
+    lv_obj_t* courseLabel = nullptr;
+    lv_obj_t* speedLabel = nullptr;
+    lv_obj_t* speedUnitLabel = nullptr;
+    lv_obj_t* speedStatsLabel = nullptr;
+    lv_obj_t* riseLabel = nullptr;
+    lv_obj_t* setRow = nullptr;
+    lv_obj_t* setLabel = nullptr;
+    lv_obj_t* timeLabel = nullptr;
+    lv_obj_t* recPill = nullptr;
+    // Column width the coordinate fonts were picked for
+    int fitWidth = -1;
+    int sunYear = 0;
+    int sunMonth = 0;
+    int sunDay = 0;
+    double sunLatitude = 1000;
+    double sunLongitude = 1000;
+    char riseText[24] = "";
+    char setText[24] = "";
+};
+
+// Centred card for the states without data: alert icon, title, help line and an optional
+// OPEN SETTINGS button. It lives in the content area next to the tab panels.
+class MessageCard {
+public:
+    // onSettings is called on click, onKey gets the keys of the focused button
+    void create(lv_obj_t* parent, const Theme& theme, lv_event_cb_t onSettings, lv_event_cb_t onKey, void* userData);
+    void clear();
+    // Shows the card for a status without data and returns true, or hides it and returns false
+    bool update(SourceStatus status, const char* dataDirectory);
+    lv_obj_t* focusTarget() const { return button; }
+    bool shown() const { return visible; }
+
+private:
+    lv_obj_t* card = nullptr;
+    lv_obj_t* titleLabel = nullptr;
+    lv_obj_t* helpLabel = nullptr;
+    lv_obj_t* button = nullptr;
+    bool visible = false;
+    bool buttonInGroup = false;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Theme.cpp b/Apps/GpsViewer/main/Source/app/Theme.cpp
new file mode 100644
index 0000000..2302b35
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Theme.cpp
@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+
+#include <lvgl/theme.h>
+
+#include <cstring>
+
+namespace gpsviewer {
+
+Theme makeTheme(bool night) {
+    Theme theme {};
+    theme.night = night;
+    if (night) {
+        // Tactical red: one hue only, brightness carries the hierarchy
+        theme.background = lv_color_hex(0x000000);
+        theme.paintBackground = true;
+        theme.border = lv_color_hex(0x380C0C);
+        theme.accent = lv_color_hex(0xFF2A2A);
+        theme.success = lv_color_hex(0xFF2A2A);
+        theme.warning = lv_color_hex(0xB81F1F);
+        theme.text = lv_color_hex(0xFF2A2A);
+        theme.dim = lv_color_hex(0x7A1E1E);
+        theme.grid = lv_color_hex(0x4A1212);
+        return theme;
+    }
+    // The theme's own tones (Material 3 neutrals of the Tactility theme), for what the app draws itself
+    LvglThemeSettings settings;
+    lvgl_theme_get_settings(&settings);
+    const bool dark = settings.is_dark;
+    const bool mono = lvgl_theme_is_mono();
+    theme.background = dark ? lv_color_hex(0x21222B) : lv_color_hex(0xF3F3F3);
+    if (settings.surface_override) {
+        theme.background = settings.color_surface;
+    }
+    theme.paintBackground = false;
+    theme.text = dark ? lv_color_hex(0xE2E2E2) : lv_color_hex(0x1C1C1C);
+    theme.dim = dark ? lv_color_hex(0x919191) : lv_color_hex(0x5E5E5E);
+    theme.border = dark ? lv_color_hex(0x3A3B44) : lv_color_hex(0xD6D6D6);
+    theme.grid = dark ? lv_color_hex(0x4A4B55) : lv_color_hex(0xC6C6C6);
+    theme.accent = mono ? theme.text : settings.color_primary;
+    theme.success = mono ? theme.text : lv_palette_main(LV_PALETTE_GREEN);
+    theme.warning = mono ? theme.dim : lv_palette_main(LV_PALETTE_AMBER);
+    theme.mono = mono;
+    return theme;
+}
+
+lv_color_t snrColor(int snr, const Theme& theme) {
+    if (snr >= 35) {
+        return theme.success;
+    }
+    if (snr >= 25) {
+        return theme.warning;
+    }
+    return theme.dim;
+}
+
+lv_color_t systemColor(GnssSystem system, const Theme& theme) {
+    if (theme.mono) {
+        return theme.text;
+    }
+    if (theme.night) {
+        switch (system) {
+            case GnssSystem::Gps:
+            case GnssSystem::Glonass:
+            case GnssSystem::Galileo:
+            case GnssSystem::Beidou:
+            case GnssSystem::Qzss:
+                return theme.text;
+            default:
+                return theme.warning;
+        }
+    }
+    switch (system) {
+        case GnssSystem::Gps: return lv_color_hex(0x3B82F6);
+        case GnssSystem::Glonass: return lv_color_hex(0xF59E0B);
+        case GnssSystem::Galileo: return lv_color_hex(0x06B6D4);
+        case GnssSystem::Beidou: return lv_color_hex(0xA855F7);
+        case GnssSystem::Qzss: return lv_color_hex(0xEC4899);
+        case GnssSystem::Sbas: return lv_color_hex(0xA3E635);
+        case GnssSystem::Navic: return lv_color_hex(0xFB7185);
+        default: return lv_color_hex(0x8E9BAE);
+    }
+}
+
+void setLabelText(lv_obj_t* label, const char* text) {
+    if (label == nullptr) {
+        return;
+    }
+    if (strcmp(lv_label_get_text(label), text) != 0) {
+        lv_label_set_text(label, text);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Ui.cpp b/Apps/GpsViewer/main/Source/app/Ui.cpp
new file mode 100644
index 0000000..51f8be1
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Ui.cpp
@@ -0,0 +1,738 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Ui.h"
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <app/event.h>
+#include <lvgl/fonts.h>
+#include <lvgl/icons/shared.h>
+#include <lvgl/widgets/toolbar.h>
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <new>
+
+namespace gpsviewer {
+
+namespace {
+
+// lv_color_to_u32() is not exported to apps
+uint32_t colorKey(lv_color_t color) {
+    return (static_cast<uint32_t>(color.red) << 16) | (static_cast<uint32_t>(color.green) << 8) | color.blue;
+}
+
+constexpr int TAB_COUNT = 4;
+constexpr uint32_t REFRESH_MS = 333;
+
+// Tab order. The indices are also the keys 1 to 4.
+enum TabIndex : int {
+    TAB_POSITION = 0,
+    TAB_SKY = 1,
+    TAB_SIGNAL = 2,
+    TAB_STATUS = 3,
+};
+
+// Character arrays, not string pointers: the app loader leaves pointers in data tables unrelocated
+constexpr char TAB_NAMES[TAB_COUNT][9] = {"Position", "Sky", "Signal", "Status"};
+
+enum class Overlay : uint8_t {
+    None,
+    Menu,
+    Settings,
+};
+
+enum class MenuItem : uint8_t {
+    ResetSpeed,
+    Recording,
+    NightMode,
+    OpenSettings,
+    Exit,
+    Back,
+};
+
+enum class SettingItem : uint8_t {
+    Units,
+    Coordinates,
+    Night,
+    Back,
+};
+
+} // namespace
+
+struct UiState {
+    AppContext* context = nullptr;
+    Theme theme {};
+    lv_obj_t* root = nullptr;
+    lv_obj_t* header = nullptr;
+    lv_obj_t* headerBadge = nullptr;
+    uint32_t badgeColor = 0;
+    lv_obj_t* tabButtons[TAB_COUNT] {};
+    lv_obj_t* tabIndicators[TAB_COUNT] {};
+    lv_obj_t* content = nullptr;
+    lv_obj_t* panels[TAB_COUNT] {};
+    MessageCard messageCard;
+    lv_obj_t* overlay = nullptr;
+    lv_timer_t* timer = nullptr;
+    Overlay overlayType = Overlay::None;
+    int activeTab = 0;
+    bool rebuildPending = false;
+    SourceStatus status = SourceStatus::NoReceiver;
+    char receiverName[32] = "";
+    bool recording = false;
+    uint32_t recordedLines = 0;
+    Settings settings {};
+    StatusTab statusTab;
+    SignalTab signalTab;
+    SkyTab skyTab;
+    PositionTab positionTab;
+    GnssSnapshot snapshot {};
+};
+
+namespace {
+
+void build(UiState& ui);
+void refresh(UiState& ui);
+void setNightMode(UiState& ui, bool enable);
+
+// Fix state in the toolbar: "3D FIX  3.5m", prefixed with REC
+void updateHeader(UiState& ui) {
+    if (ui.headerBadge == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = ui.snapshot;
+    const bool receiving = ui.status == SourceStatus::Receiving;
+    const FixType fix = receiving ? s.fix : FixType::None;
+    char text[40];
+    size_t length = 0;
+    text[0] = '\0';
+    if (ui.recording) {
+        length = static_cast<size_t>(snprintf(text, sizeof(text), "REC  "));
+    }
+    length += static_cast<size_t>(snprintf(text + length, sizeof(text) - length, "%s", fixText(fix)));
+    if (fix != FixType::None && !std::isnan(s.hdop) && length < sizeof(text)) {
+        char accuracy[24];
+        formatAccuracy(estimatedAccuracyMeters(s.hdop), ui.settings.units, accuracy, sizeof(accuracy));
+        // "3.5 m" -> "3.5m"
+        size_t out = 0;
+        for (size_t i = 0; accuracy[i] != '\0'; i++) {
+            if (accuracy[i] != ' ') {
+                accuracy[out++] = accuracy[i];
+            }
+        }
+        accuracy[out] = '\0';
+        snprintf(text + length, sizeof(text) - length, "  %s", accuracy);
+    }
+    lv_color_t color = fixColor(fix, ui.theme);
+    if (ui.recording) {
+        color = ui.theme.warning;
+    }
+    setLabelText(ui.headerBadge, text);
+    const uint32_t colorValue = colorKey(color);
+    if (colorValue != ui.badgeColor) {
+        ui.badgeColor = colorValue;
+        lv_obj_set_style_text_color(ui.headerBadge, color, LV_PART_MAIN);
+    }
+}
+
+void styleTabButtons(UiState& ui) {
+    for (int i = 0; i < TAB_COUNT; i++) {
+        lv_obj_t* button = ui.tabButtons[i];
+        if (button == nullptr) {
+            continue;
+        }
+        const bool active = i == ui.activeTab;
+        setHidden(ui.tabIndicators[i], !active);
+        lv_obj_t* label = lv_obj_get_child(button, 0);
+        lv_obj_set_style_text_color(label, active ? ui.theme.accent : ui.theme.dim, LV_PART_MAIN);
+    }
+}
+
+void setTab(UiState& ui, int tab) {
+    ui.activeTab = (tab + TAB_COUNT) % TAB_COUNT;
+    styleTabButtons(ui);
+    refresh(ui);
+}
+
+void requestBits(UiState& ui, uint32_t bits) {
+    ui.context->requests.fetch_or(bits);
+}
+
+void applySettings(UiState& ui, const Settings& settings) {
+    {
+        ContextLock lock(*ui.context);
+        ui.context->settings = settings;
+    }
+    ui.settings = settings;
+    requestBits(ui, REQUEST_SAVE_SETTINGS);
+}
+
+// Stores the palette choice. The widget tree is rebuilt with the other palette on the next timer
+// tick (or when the overlay is closed), as there are no shared styles to restyle in place.
+void setNightMode(UiState& ui, bool enable) {
+    Settings settings = ui.settings;
+    if (settings.nightMode == enable) {
+        return;
+    }
+    settings.nightMode = enable;
+    applySettings(ui, settings);
+    ui.rebuildPending = true;
+}
+
+void toggleNight(UiState& ui) {
+    setNightMode(ui, !ui.settings.nightMode);
+}
+
+// Keys go to the content area, or to OPEN SETTINGS while a message card with that button is shown
+void focusMain(UiState& ui) {
+    lv_group_t* group = lv_group_get_default();
+    if (group == nullptr) {
+        return;
+    }
+    lv_obj_t* target = ui.content;
+    if (ui.messageCard.shown() && ui.messageCard.focusTarget() != nullptr &&
+        !lv_obj_has_flag(ui.messageCard.focusTarget(), LV_OBJ_FLAG_HIDDEN)) {
+        target = ui.messageCard.focusTarget();
+    }
+    if (target != nullptr) {
+        lv_group_focus_obj(target);
+    }
+}
+
+void closeOverlay(UiState& ui) {
+    if (ui.overlay != nullptr) {
+        lv_obj_delete_async(ui.overlay);
+        ui.overlay = nullptr;
+    }
+    ui.overlayType = Overlay::None;
+    focusMain(ui);
+}
+
+// Overlay lists get Left/Up and Right/Down as focus moves, and Esc/Backspace to close
+void onOverlayItemKey(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_obj_t* item = lv_event_get_current_target_obj(event);
+    const uint32_t key = lv_event_get_key(event);
+    lv_obj_t* list = lv_obj_get_parent(item);
+    const int count = static_cast<int>(lv_obj_get_child_count(list));
+    const int index = static_cast<int>(lv_obj_get_index(item));
+    if (key == LV_KEY_LEFT || key == LV_KEY_UP) {
+        lv_group_focus_obj(lv_obj_get_child(list, (index + count - 1) % count));
+    } else if (key == LV_KEY_RIGHT || key == LV_KEY_DOWN) {
+        lv_group_focus_obj(lv_obj_get_child(list, (index + 1) % count));
+    } else if (key == LV_KEY_ESC || key == LV_KEY_BACKSPACE) {
+        closeOverlay(*ui);
+    }
+}
+
+void onOverlayBackdrop(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    if (lv_event_get_target_obj(event) == ui->overlay) {
+        closeOverlay(*ui);
+    }
+}
+
+lv_obj_t* createOverlay(UiState& ui, Overlay type, const char* title) {
+    closeOverlay(ui);
+    ui.overlayType = type;
+    ui.overlay = lv_obj_create(ui.root);
+    lv_obj_add_flag(ui.overlay, LV_OBJ_FLAG_FLOATING);
+    lv_obj_set_size(ui.overlay, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_style_bg_color(ui.overlay, lv_color_black(), LV_PART_MAIN);
+    lv_obj_set_style_bg_opa(ui.overlay, LV_OPA_60, LV_PART_MAIN);
+    lv_obj_set_style_border_width(ui.overlay, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(ui.overlay, 0, LV_PART_MAIN);
+    lv_obj_add_event_cb(ui.overlay, onOverlayBackdrop, LV_EVENT_CLICKED, &ui);
+
+    lv_obj_t* list = lv_list_create(ui.overlay);
+    lv_obj_set_size(list, LV_PCT(80), LV_PCT(95));
+    lv_obj_center(list);
+    lv_list_add_text(list, title);
+    return list;
+}
+
+lv_obj_t* addOverlayItem(UiState& ui, lv_obj_t* list, const char* text, lv_event_cb_t onClick, uint32_t id) {
+    lv_obj_t* button = lv_list_add_button(list, nullptr, text);
+    lv_obj_set_user_data(button, reinterpret_cast<void*>(static_cast<uintptr_t>(id)));
+    lv_obj_add_event_cb(button, onClick, LV_EVENT_CLICKED, &ui);
+    lv_obj_add_event_cb(button, onOverlayItemKey, LV_EVENT_KEY, &ui);
+    if (lv_group_get_default() != nullptr) {
+        lv_group_add_obj(lv_group_get_default(), button);
+    }
+    return button;
+}
+
+uint32_t itemId(lv_event_t* event) {
+    return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(lv_obj_get_user_data(lv_event_get_current_target_obj(event))));
+}
+
+void openSettings(UiState& ui);
+
+void onMenuItem(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    const auto item = static_cast<MenuItem>(itemId(event));
+    switch (item) {
+        case MenuItem::ResetSpeed:
+            requestBits(*ui, REQUEST_RESET_SPEED);
+            closeOverlay(*ui);
+            break;
+        case MenuItem::Recording:
+            requestBits(*ui, REQUEST_TOGGLE_RECORDING);
+            closeOverlay(*ui);
+            break;
+        case MenuItem::NightMode:
+            closeOverlay(*ui);
+            toggleNight(*ui);
+            break;
+        case MenuItem::OpenSettings:
+            openSettings(*ui);
+            break;
+        case MenuItem::Exit:
+            closeOverlay(*ui);
+            app_event_emit_close(ui->context->appInstanceId);
+            break;
+        case MenuItem::Back:
+            closeOverlay(*ui);
+            break;
+    }
+}
+
+void openMenu(UiState& ui) {
+    lv_obj_t* list = createOverlay(ui, Overlay::Menu, "GPS Viewer");
+    lv_obj_t* first = addOverlayItem(ui, list, "Reset max/average speed", onMenuItem, static_cast<uint32_t>(MenuItem::ResetSpeed));
+    char recordText[48];
+    if (ui.recording) {
+        snprintf(recordText, sizeof(recordText), "Stop recording (%lu lines)", static_cast<unsigned long>(ui.recordedLines));
+    } else {
+        snprintf(recordText, sizeof(recordText), "Start recording");
+    }
+    addOverlayItem(ui, list, recordText, onMenuItem, static_cast<uint32_t>(MenuItem::Recording));
+    addOverlayItem(ui, list, ui.settings.nightMode ? "Night mode: off" : "Night mode: on", onMenuItem, static_cast<uint32_t>(MenuItem::NightMode));
+    addOverlayItem(ui, list, "Settings", onMenuItem, static_cast<uint32_t>(MenuItem::OpenSettings));
+    addOverlayItem(ui, list, "Exit", onMenuItem, static_cast<uint32_t>(MenuItem::Exit));
+    addOverlayItem(ui, list, "< Back", onMenuItem, static_cast<uint32_t>(MenuItem::Back));
+    if (first != nullptr) {
+        lv_group_focus_obj(first);
+    }
+}
+
+void settingText(const Settings& settings, SettingItem item, char* out, size_t outSize) {
+    static const char units[3][9] = {"Metric", "Imperial", "Nautical"};
+    static const char coordinates[3][18] = {"Degrees", "Deg. minutes", "Deg. min. seconds"};
+    switch (item) {
+        case SettingItem::Units:
+            snprintf(out, outSize, "Units: %s", units[static_cast<int>(settings.units)]);
+            break;
+        case SettingItem::Coordinates:
+            snprintf(out, outSize, "Coordinates: %s", coordinates[static_cast<int>(settings.coordinateFormat)]);
+            break;
+        case SettingItem::Night:
+            snprintf(out, outSize, "Night mode: %s", settings.nightMode ? "on" : "off");
+            break;
+        case SettingItem::Back:
+            snprintf(out, outSize, "< Back");
+            break;
+    }
+}
+
+void onSettingItem(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    const auto item = static_cast<SettingItem>(itemId(event));
+    Settings settings = ui->settings;
+    switch (item) {
+        case SettingItem::Units:
+            settings.units = static_cast<Units>((static_cast<int>(settings.units) + 1) % 3);
+            break;
+        case SettingItem::Coordinates:
+            settings.coordinateFormat = static_cast<CoordinateFormat>((static_cast<int>(settings.coordinateFormat) + 1) % 3);
+            break;
+        case SettingItem::Night:
+            settings.nightMode = !settings.nightMode;
+            break;
+        case SettingItem::Back:
+            closeOverlay(*ui);
+            return;
+    }
+    applySettings(*ui, settings);
+    if (item == SettingItem::Night) {
+        ui->rebuildPending = true;
+    }
+    char text[48];
+    settingText(settings, item, text, sizeof(text));
+    lv_obj_t* label = lv_obj_get_child(lv_event_get_current_target_obj(event), 0);
+    if (label != nullptr) {
+        lv_label_set_text(label, text);
+    }
+}
+
+void openSettings(UiState& ui) {
+    lv_obj_t* list = createOverlay(ui, Overlay::Settings, "Settings");
+    lv_obj_t* first = nullptr;
+    for (int i = 0; i <= static_cast<int>(SettingItem::Back); i++) {
+        char text[48];
+        settingText(ui.settings, static_cast<SettingItem>(i), text, sizeof(text));
+        lv_obj_t* item = addOverlayItem(ui, list, text, onSettingItem, i);
+        if (first == nullptr) {
+            first = item;
+        }
+    }
+    lv_group_focus_obj(first);
+}
+
+void onMenuButton(lv_event_t* event) {
+    openMenu(*static_cast<UiState*>(lv_event_get_user_data(event)));
+}
+
+void onTabButton(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_obj_t* button = lv_event_get_current_target_obj(event);
+    for (int i = 0; i < TAB_COUNT; i++) {
+        if (ui->tabButtons[i] == button) {
+            setTab(*ui, i);
+        }
+    }
+}
+
+void moveTab(UiState& ui, int direction) {
+    if (ui.activeTab == TAB_SIGNAL && ui.signalTab.scroll(direction)) {
+        return;
+    }
+    setTab(ui, ui.activeTab + direction);
+}
+
+// Keys reach the content area while it has the focus. Letter keys are shortcuts only, every
+// action is also in the Enter menu.
+void onContentKey(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    const uint32_t key = lv_event_get_key(event);
+    switch (key) {
+        case LV_KEY_LEFT:
+        case ',':
+            moveTab(*ui, -1);
+            break;
+        case LV_KEY_RIGHT:
+        case '.':
+        case ' ':
+            moveTab(*ui, 1);
+            break;
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+            setTab(*ui, static_cast<int>(key - '1'));
+            break;
+        case 'n':
+        case 'N':
+            toggleNight(*ui);
+            break;
+        case 'r':
+        case 'R':
+            requestBits(*ui, REQUEST_RESET_SPEED);
+            break;
+        case 's':
+        case 'S':
+            openSettings(*ui);
+            break;
+        case 'm':
+        case 'M':
+            openMenu(*ui);
+            break;
+        case 'l':
+        case 'L':
+            requestBits(*ui, REQUEST_TOGGLE_RECORDING);
+            break;
+        default:
+            break;
+    }
+}
+
+// Enter from a keyboard, trackball or encoder opens the menu. Taps on the content don't.
+void onContentClicked(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_indev_t* indev = lv_indev_active();
+    if (indev == nullptr || lv_indev_get_type(indev) == LV_INDEV_TYPE_POINTER) {
+        return;
+    }
+    openMenu(*ui);
+}
+
+void onContentGesture(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_indev_t* indev = lv_indev_active();
+    if (indev == nullptr || ui->overlayType != Overlay::None) {
+        return;
+    }
+    // Widgets with event bubbling pass their own gestures up too. One that turned off gesture bubbling,
+    // like the dragged Signal bars, handles the swipe itself.
+    lv_obj_t* target = lv_event_get_target_obj(event);
+    if (target != ui->content && !lv_obj_is_gesture_bubble(target)) {
+        return;
+    }
+    const lv_dir_t direction = lv_indev_get_gesture_dir(indev);
+    if (direction == LV_DIR_LEFT) {
+        setTab(*ui, ui->activeTab + 1);
+    } else if (direction == LV_DIR_RIGHT) {
+        setTab(*ui, ui->activeTab - 1);
+    }
+}
+
+
+void onTimer(lv_timer_t* timer) {
+    auto* ui = static_cast<UiState*>(lv_timer_get_user_data(timer));
+    if (ui->rebuildPending && ui->overlayType == Overlay::None) {
+        ui->rebuildPending = false;
+        build(*ui);
+        return;
+    }
+    refresh(*ui);
+}
+
+lv_obj_t* createPanel(lv_obj_t* parent) {
+    lv_obj_t* panel = lv_obj_create(parent);
+    lv_obj_set_size(panel, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_style_bg_opa(panel, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_set_style_border_width(panel, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(panel, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(panel, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(panel, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_remove_flag(panel, LV_OBJ_FLAG_CLICK_FOCUSABLE);
+    lv_obj_add_flag(panel, LV_OBJ_FLAG_EVENT_BUBBLE);
+    return panel;
+}
+
+void clearTabs(UiState& ui) {
+    ui.statusTab.clear();
+    ui.signalTab.clear();
+    ui.skyTab.clear();
+    ui.positionTab.clear();
+}
+
+void forgetWidgets(UiState& ui) {
+    if (ui.timer != nullptr) {
+        lv_timer_delete(ui.timer);
+        ui.timer = nullptr;
+    }
+    clearTabs(ui);
+    ui.messageCard.clear();
+    ui.header = nullptr;
+    ui.headerBadge = nullptr;
+    ui.badgeColor = 0;
+    ui.content = nullptr;
+    ui.overlay = nullptr;
+    ui.overlayType = Overlay::None;
+    for (int i = 0; i < TAB_COUNT; i++) {
+        ui.tabButtons[i] = nullptr;
+        ui.tabIndicators[i] = nullptr;
+        ui.panels[i] = nullptr;
+    }
+}
+
+void onCloseButton(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    app_event_emit_close(ui->context->appInstanceId);
+}
+
+void onOpenLocationSettings(lv_event_t* event) {
+    requestBits(*static_cast<UiState*>(lv_event_get_user_data(event)), REQUEST_OPEN_LOCATION_SETTINGS);
+}
+
+void onBadgeButton(lv_event_t* event) {
+    setTab(*static_cast<UiState*>(lv_event_get_user_data(event)), TAB_STATUS);
+}
+
+// Night mode paints the toolbar like the rest of the app
+void paintNight(lv_obj_t* object, const Theme& theme) {
+    lv_obj_set_style_text_color(object, theme.text, LV_PART_MAIN);
+    const uint32_t count = lv_obj_get_child_count(object);
+    for (uint32_t i = 0; i < count; i++) {
+        paintNight(lv_obj_get_child(object, static_cast<int32_t>(i)), theme);
+    }
+}
+
+void createHeader(UiState& ui) {
+    ui.header = lvgl_toolbar_create(ui.root, "GPS Viewer");
+    lvgl_toolbar_set_nav_action(ui.header, LV_SYMBOL_CLOSE, onCloseButton, &ui);
+    // Fix state, filled in by updateHeader(). Opens the Status tab.
+    lv_obj_t* badge = lvgl_toolbar_add_text_button_action(ui.header, "", onBadgeButton, &ui);
+    // Action buttons are square, this one holds text
+    lv_obj_set_width(badge, LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_hor(badge, LV_DPX(4), LV_PART_MAIN);
+    ui.headerBadge = lv_obj_get_child(badge, 0);
+    if (ui.headerBadge != nullptr) {
+        lv_obj_set_style_text_font(ui.headerBadge, lvgl_get_text_font(FONT_SIZE_SMALL), LV_PART_MAIN);
+    }
+    lv_obj_t* menu = lvgl_toolbar_add_text_button_action(ui.header, LVGL_ICON_SHARED_MORE_VERT, onMenuButton, &ui);
+    lv_obj_set_style_text_font(menu, lvgl_get_shared_icon_default_font(), LV_PART_MAIN);
+    if (ui.theme.night) {
+        lv_obj_set_style_bg_color(ui.header, ui.theme.background, LV_PART_MAIN);
+        paintNight(ui.header, ui.theme);
+    }
+    ui.badgeColor = 0;
+}
+
+// Text tabs with a 2 px line under the active one
+void createTabStrip(UiState& ui) {
+    const Theme& theme = ui.theme;
+    lv_obj_t* strip = createBox(ui.root);
+    lv_obj_set_size(strip, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_flex_flow(strip, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_border_color(strip, theme.border, LV_PART_MAIN);
+    lv_obj_set_style_border_width(strip, 1, LV_PART_MAIN);
+    lv_obj_set_style_border_side(strip, LV_BORDER_SIDE_BOTTOM, LV_PART_MAIN);
+    for (int i = 0; i < TAB_COUNT; i++) {
+        lv_obj_t* button = createBox(strip);
+        lv_obj_set_size(button, LV_PCT(25), LV_DPX(24));
+        lv_obj_add_flag(button, LV_OBJ_FLAG_CLICKABLE);
+        lv_obj_remove_flag(button, LV_OBJ_FLAG_EVENT_BUBBLE);
+        lv_obj_remove_flag(button, LV_OBJ_FLAG_GESTURE_BUBBLE);
+        lv_obj_t* label = createLabel(button, FONT_SIZE_SMALL, theme.dim);
+        lv_label_set_text(label, TAB_NAMES[i]);
+        lv_obj_center(label);
+        lv_obj_t* indicator = createBox(button);
+        lv_obj_set_size(indicator, LV_PCT(70), 2);
+        lv_obj_align(indicator, LV_ALIGN_BOTTOM_MID, 0, 0);
+        lv_obj_set_style_bg_color(indicator, theme.accent, LV_PART_MAIN);
+        lv_obj_set_style_bg_opa(indicator, LV_OPA_COVER, LV_PART_MAIN);
+        lv_obj_add_flag(indicator, LV_OBJ_FLAG_FLOATING);
+        lv_obj_add_event_cb(button, onTabButton, LV_EVENT_CLICKED, &ui);
+        ui.tabButtons[i] = button;
+        ui.tabIndicators[i] = indicator;
+    }
+}
+
+void build(UiState& ui) {
+    forgetWidgets(ui);
+    lv_obj_clean(ui.root);
+    {
+        ContextLock lock(*ui.context);
+        ui.settings = ui.context->settings;
+    }
+    ui.theme = makeTheme(ui.settings.nightMode);
+    lv_obj_t* root = ui.root;
+
+    if (ui.theme.paintBackground) {
+        lv_obj_set_style_bg_color(root, ui.theme.background, LV_PART_MAIN);
+        lv_obj_set_style_bg_opa(root, LV_OPA_COVER, LV_PART_MAIN);
+    }
+    lv_obj_set_flex_flow(root, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(root, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(root, LV_OBJ_FLAG_SCROLLABLE);
+
+    createHeader(ui);
+    createTabStrip(ui);
+
+    ui.content = lv_obj_create(root);
+    lv_obj_set_width(ui.content, LV_PCT(100));
+    lv_obj_set_flex_grow(ui.content, 1);
+    lv_obj_set_style_bg_opa(ui.content, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_set_style_border_width(ui.content, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(ui.content, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(ui.content, LV_DPX(4), LV_PART_MAIN);
+    lv_obj_set_style_outline_width(ui.content, 0, LV_STATE_FOCUS_KEY);
+    lv_obj_set_style_outline_width(ui.content, 0, LV_STATE_FOCUSED);
+    lv_obj_remove_flag(ui.content, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_add_event_cb(ui.content, onContentKey, LV_EVENT_KEY, &ui);
+    lv_obj_add_event_cb(ui.content, onContentClicked, LV_EVENT_CLICKED, &ui);
+    lv_obj_add_event_cb(ui.content, onContentGesture, LV_EVENT_GESTURE, &ui);
+    lv_obj_update_layout(root);
+
+    for (int i = 0; i < TAB_COUNT; i++) {
+        ui.panels[i] = createPanel(ui.content);
+    }
+    // The tabs size their widgets from the panel size
+    lv_obj_update_layout(ui.content);
+    ui.positionTab.create(ui.panels[TAB_POSITION], ui.theme);
+    ui.skyTab.create(ui.panels[TAB_SKY], ui.theme);
+    ui.signalTab.create(ui.panels[TAB_SIGNAL], ui.theme);
+    ui.statusTab.create(ui.panels[TAB_STATUS], ui.theme);
+    ui.messageCard.create(ui.content, ui.theme, onOpenLocationSettings, onContentKey, &ui);
+
+    lv_group_t* group = lv_group_get_default();
+    if (group != nullptr) {
+        lv_group_add_obj(group, ui.content);
+        lv_group_focus_obj(ui.content);
+    }
+
+    styleTabButtons(ui);
+    ui.timer = lv_timer_create(onTimer, REFRESH_MS, &ui);
+    refresh(ui);
+}
+
+void refresh(UiState& ui) {
+    if (ui.content == nullptr) {
+        return;
+    }
+    SourceStatus status;
+    bool recording;
+    {
+        ContextLock lock(*ui.context);
+        ui.context->model.snapshot(ui.snapshot, nowMs());
+        status = ui.context->status;
+        memcpy(ui.receiverName, ui.context->receiverName, sizeof(ui.receiverName));
+        ui.settings = ui.context->settings;
+        recording = ui.context->recording;
+        ui.recordedLines = ui.context->recordedLines;
+    }
+    ui.status = status;
+    ui.recording = recording;
+    updateHeader(ui);
+
+    const bool wasShown = ui.messageCard.shown();
+    const bool hadButton = wasShown && ui.messageCard.focusTarget() != nullptr &&
+                           !lv_obj_has_flag(ui.messageCard.focusTarget(), LV_OBJ_FLAG_HIDDEN);
+    const bool showMessage = ui.messageCard.update(ui.status, ui.context->dataDirectory);
+    const bool hasButton = showMessage && !lv_obj_has_flag(ui.messageCard.focusTarget(), LV_OBJ_FLAG_HIDDEN);
+    if ((wasShown != showMessage || hadButton != hasButton) && ui.overlayType == Overlay::None) {
+        focusMain(ui);
+    }
+    for (int i = 0; i < TAB_COUNT; i++) {
+        setHidden(ui.panels[i], i != ui.activeTab || showMessage);
+    }
+    if (showMessage) {
+        return;
+    }
+
+    const TabView view {ui.snapshot, ui.settings, ui.status, ui.recording, ui.receiverName, ui.theme};
+    switch (ui.activeTab) {
+        case TAB_POSITION: ui.positionTab.update(view); break;
+        case TAB_SKY: ui.skyTab.update(view); break;
+        case TAB_SIGNAL: ui.signalTab.update(view); break;
+        default: ui.statusTab.update(view); break;
+    }
+}
+
+} // namespace
+
+UiState* uiAllocate(AppContext& context) {
+    auto* ui = new (std::nothrow) UiState();
+    if (ui != nullptr) {
+        ui->context = &context;
+    }
+    return ui;
+}
+
+void uiFree(UiState* ui) {
+    delete ui;
+}
+
+void uiCreateWidgets(lv_obj_t* root, void* userData) {
+    auto* context = static_cast<AppContext*>(userData);
+    UiState& ui = *context->ui;
+    ui.root = root;
+    build(ui);
+}
+
+void setNightMode(AppContext& context, bool enable) {
+    if (context.ui != nullptr) {
+        setNightMode(*context.ui, enable);
+    }
+}
+
+void uiDestroyWidgets(void* userData) {
+    auto* context = static_cast<AppContext*>(userData);
+    UiState& ui = *context->ui;
+    forgetWidgets(ui);
+    ui.root = nullptr;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Ui.h b/Apps/GpsViewer/main/Source/app/Ui.h
new file mode 100644
index 0000000..9ff4521
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Ui.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "AppContext.h"
+
+#include <lvgl.h>
+
+namespace gpsviewer {
+
+UiState* uiAllocate(AppContext& context);
+void uiFree(UiState* ui);
+
+// window_manager_create_ext() callbacks, user_data is the AppContext
+void uiCreateWidgets(lv_obj_t* root, void* userData);
+void uiDestroyWidgets(void* userData);
+
+// Switches between the normal dark and the tactical red palette. Stores the choice and rebuilds the
+// widget tree. LVGL thread only.
+void setNightMode(AppContext& context, bool enable);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Widgets.cpp b/Apps/GpsViewer/main/Source/app/Widgets.cpp
new file mode 100644
index 0000000..0c80bef
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Widgets.cpp
@@ -0,0 +1,405 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Widgets.h"
+
+#include <cmath>
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr int MAX_POINTS = 10;
+constexpr float PI_F = 3.14159265f;
+
+// lv_obj_get_style_*_color are not exported to apps, so the icon keeps its colours in the user data
+uintptr_t packColor(lv_color_t color) {
+    return (static_cast<uintptr_t>(color.red) << 16) | (static_cast<uintptr_t>(color.green) << 8) | color.blue;
+}
+
+lv_color_t unpackColor(uintptr_t packed) {
+    lv_color_t color;
+    color.red = static_cast<uint8_t>(packed >> 16);
+    color.green = static_cast<uint8_t>(packed >> 8);
+    color.blue = static_cast<uint8_t>(packed);
+    return color;
+}
+
+// Width of one line of UTF-8 text, as lv_text_get_size() is not exported to apps
+int textWidth(const char* text, const lv_font_t* font) {
+    int width = 0;
+    const auto* bytes = reinterpret_cast<const unsigned char*>(text);
+    while (*bytes != 0) {
+        uint32_t letter = *bytes++;
+        int extra = 0;
+        if (letter >= 0xF0) {
+            letter &= 0x07;
+            extra = 3;
+        } else if (letter >= 0xE0) {
+            letter &= 0x0F;
+            extra = 2;
+        } else if (letter >= 0xC0) {
+            letter &= 0x1F;
+            extra = 1;
+        }
+        for (; extra > 0 && (*bytes & 0xC0) == 0x80; extra--) {
+            letter = (letter << 6) | (*bytes++ & 0x3F);
+        }
+        width += lv_font_get_glyph_width(font, letter, *bytes);
+    }
+    return width;
+}
+
+int roundInt(float value) {
+    return static_cast<int>(std::floor(value + 0.5f));
+}
+
+void drawIcon(lv_event_t* event) {
+    lv_obj_t* object = lv_event_get_current_target_obj(event);
+    lv_layer_t* layer = lv_event_get_layer(event);
+    const auto packed = reinterpret_cast<uintptr_t>(lv_obj_get_user_data(object));
+    const auto kind = static_cast<IconKind>(packed >> 24);
+    const lv_color_t color = unpackColor(packed & 0xFFFFFFU);
+    lv_area_t area;
+    lv_obj_get_coords(object, &area);
+    const int size = area.x2 - area.x1 + 1;
+    const float cx = static_cast<float>(area.x1) + static_cast<float>(size - 1) / 2.0f;
+    const float cy = static_cast<float>(area.y1) + static_cast<float>(size - 1) / 2.0f;
+    const float half = static_cast<float>(size) / 2.0f;
+    switch (kind) {
+        case IconKind::Sun: {
+            drawCircle(layer, roundInt(cx), roundInt(cy), roundInt(half * 0.4f + 0.5f), color, true);
+            for (int i = 0; i < 8; i++) {
+                const float angle = static_cast<float>(i) * PI_F / 4.0f;
+                const float c = std::cos(angle);
+                const float s = std::sin(angle);
+                drawLine(layer, roundInt(cx + c * half * 0.65f), roundInt(cy + s * half * 0.65f),
+                         roundInt(cx + c * (half - 0.5f)), roundInt(cy + s * (half - 0.5f)), color);
+            }
+            break;
+        }
+        case IconKind::Moon: {
+            const lv_color_t surface = unpackColor(reinterpret_cast<uintptr_t>(lv_event_get_user_data(event)));
+            drawCircle(layer, roundInt(cx), roundInt(cy), roundInt(half * 0.85f), color, true);
+            drawCircle(layer, roundInt(cx + half * 0.5f), roundInt(cy - half * 0.3f), roundInt(half * 0.7f), surface, true);
+            break;
+        }
+        case IconKind::Alert: {
+            const float xs[3] = {cx, cx + half - 0.5f, cx - half + 0.5f};
+            const float ys[3] = {cy - half + 1.0f, cy + half - 1.5f, cy + half - 1.5f};
+            for (int i = 0; i < 3; i++) {
+                const int j = (i + 1) % 3;
+                drawLine(layer, roundInt(xs[i]), roundInt(ys[i]), roundInt(xs[j]), roundInt(ys[j]), color, 2);
+            }
+            // Exclamation mark: bar and dot
+            const int x = roundInt(cx);
+            const int top = roundInt(cy - half * 0.35f);
+            const int bottom = roundInt(cy + half * 0.2f);
+            drawFilledRect(layer, x - 1, top, x, bottom, color);
+            drawFilledRect(layer, x - 1, bottom + 3, x, bottom + 4, color);
+            break;
+        }
+    }
+}
+
+} // namespace
+
+lv_obj_t* createBox(lv_obj_t* parent) {
+    lv_obj_t* box = lv_obj_create(parent);
+    lv_obj_set_style_bg_opa(box, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_set_style_border_width(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_outline_width(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_shadow_width(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_row(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_column(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(box, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_CLICK_FOCUSABLE);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_SCROLL_CHAIN);
+    lv_obj_add_flag(box, LV_OBJ_FLAG_EVENT_BUBBLE);
+    lv_obj_add_flag(box, LV_OBJ_FLAG_GESTURE_BUBBLE);
+    if (lv_group_get_default() != nullptr) {
+        lv_group_remove_obj(box);
+    }
+    return box;
+}
+
+lv_obj_t* createSection(lv_obj_t* parent) {
+    lv_obj_t* section = createBox(parent);
+    lv_obj_set_style_pad_all(section, LV_DPX(4), LV_PART_MAIN);
+    return section;
+}
+
+void setDivider(lv_obj_t* object, const Theme& theme, lv_border_side_t side) {
+    lv_obj_set_style_border_color(object, theme.border, LV_PART_MAIN);
+    lv_obj_set_style_border_width(object, 1, LV_PART_MAIN);
+    lv_obj_set_style_border_side(object, side, LV_PART_MAIN);
+}
+
+lv_obj_t* createLabel(lv_obj_t* parent, LvglFontSize size, lv_color_t color) {
+    lv_obj_t* label = lv_label_create(parent);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_CLIP);
+    lv_obj_set_style_text_font(label, lvgl_get_text_font(size), LV_PART_MAIN);
+    lv_obj_set_style_text_color(label, color, LV_PART_MAIN);
+    lv_label_set_text(label, "");
+    return label;
+}
+
+lv_obj_t* createCaption(lv_obj_t* parent, const Theme& theme, const char* text) {
+    lv_obj_t* label = createLabel(parent, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(label, text);
+    return label;
+}
+
+lv_obj_t* createTag(lv_obj_t* parent, const char* text, lv_color_t color) {
+    lv_obj_t* tag = createLabel(parent, FONT_SIZE_SMALL, color);
+    lv_label_set_text(tag, text);
+    return tag;
+}
+
+void setHidden(lv_obj_t* object, bool hidden) {
+    if (object == nullptr) {
+        return;
+    }
+    if (hidden == lv_obj_has_flag(object, LV_OBJ_FLAG_HIDDEN)) {
+        return;
+    }
+    if (hidden) {
+        lv_obj_add_flag(object, LV_OBJ_FLAG_HIDDEN);
+    } else {
+        lv_obj_remove_flag(object, LV_OBJ_FLAG_HIDDEN);
+    }
+}
+
+void setFittedText(lv_obj_t* label, const char* text, int maxWidth) {
+    if (label == nullptr || strcmp(lv_label_get_text(label), text) == 0) {
+        return;
+    }
+    const LvglFontSize sizes[3] = {FONT_SIZE_LARGE, FONT_SIZE_DEFAULT, FONT_SIZE_SMALL};
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    for (int i = 0; i < 3; i++) {
+        font = lvgl_get_text_font(sizes[i]);
+        if (textWidth(text, font) <= maxWidth) {
+            break;
+        }
+    }
+    lv_obj_set_style_text_font(label, font, LV_PART_MAIN);
+    lv_label_set_text(label, text);
+}
+
+lv_obj_t* createIcon(lv_obj_t* parent, IconKind kind, int size, lv_color_t color, lv_color_t surface) {
+    lv_obj_t* icon = createBox(parent);
+    lv_obj_set_size(icon, size, size);
+    const uintptr_t packed = (static_cast<uintptr_t>(kind) << 24) | packColor(color);
+    lv_obj_set_user_data(icon, reinterpret_cast<void*>(packed));
+    lv_obj_add_event_cb(icon, drawIcon, LV_EVENT_DRAW_MAIN, reinterpret_cast<void*>(packColor(surface)));
+    return icon;
+}
+
+void drawText(lv_layer_t* layer, const char* text, const lv_font_t* font, lv_color_t color, const lv_area_t& area,
+              lv_text_align_t align) {
+    lv_draw_label_dsc_t dsc;
+    lv_draw_label_dsc_init(&dsc);
+    dsc.font = font;
+    dsc.color = color;
+    dsc.text = text;
+    dsc.text_local = 1;
+    dsc.align = align;
+    lv_draw_label(layer, &dsc, &area);
+}
+
+void drawLine(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int width) {
+    lv_draw_line_dsc_t dsc;
+    lv_draw_line_dsc_init(&dsc);
+    dsc.color = color;
+    dsc.width = width;
+    dsc.p1.x = x1;
+    dsc.p1.y = y1;
+    dsc.p2.x = x2;
+    dsc.p2.y = y2;
+    lv_draw_line(layer, &dsc);
+}
+
+void drawCircle(lv_layer_t* layer, int cx, int cy, int radius, lv_color_t color, bool filled, int borderWidth) {
+    lv_area_t box;
+    box.x1 = cx - radius;
+    box.y1 = cy - radius;
+    box.x2 = cx + radius;
+    box.y2 = cy + radius;
+    lv_draw_rect_dsc_t rect;
+    lv_draw_rect_dsc_init(&rect);
+    rect.radius = LV_RADIUS_CIRCLE;
+    if (filled) {
+        rect.bg_opa = LV_OPA_COVER;
+        rect.bg_color = color;
+        rect.border_width = 0;
+    } else {
+        rect.bg_opa = LV_OPA_TRANSP;
+        rect.border_opa = LV_OPA_COVER;
+        rect.border_color = color;
+        rect.border_width = borderWidth;
+        rect.border_side = LV_BORDER_SIDE_FULL;
+    }
+    lv_draw_rect(layer, &rect, &box);
+}
+
+void drawFilledRect(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int radius) {
+    lv_area_t box;
+    box.x1 = x1;
+    box.y1 = y1;
+    box.x2 = x2;
+    box.y2 = y2;
+    lv_draw_rect_dsc_t rect;
+    lv_draw_rect_dsc_init(&rect);
+    rect.radius = radius;
+    rect.bg_opa = LV_OPA_COVER;
+    rect.bg_color = color;
+    rect.border_width = 0;
+    lv_draw_rect(layer, &rect, &box);
+}
+
+// Even-odd scanline fill, works for convex and concave outlines
+void fillPolygon(lv_layer_t* layer, const float* px, const float* py, int n, lv_color_t color) {
+    float top = py[0];
+    float bottom = py[0];
+    for (int i = 1; i < n; i++) {
+        if (py[i] < top) {
+            top = py[i];
+        }
+        if (py[i] > bottom) {
+            bottom = py[i];
+        }
+    }
+    lv_draw_fill_dsc_t fill;
+    lv_draw_fill_dsc_init(&fill);
+    fill.color = color;
+    fill.radius = 0;
+    const int yStart = static_cast<int>(std::floor(top));
+    const int yEnd = static_cast<int>(std::ceil(bottom));
+    for (int y = yStart; y <= yEnd; y++) {
+        const float yc = static_cast<float>(y) + 0.5f;
+        float xs[MAX_POINTS];
+        int m = 0;
+        for (int i = 0; i < n; i++) {
+            const int j = (i + 1) % n;
+            const float lo = py[i] < py[j] ? py[i] : py[j];
+            const float hi = py[i] < py[j] ? py[j] : py[i];
+            if (hi > lo && yc >= lo && yc < hi && m < MAX_POINTS) {
+                xs[m++] = px[i] + (yc - py[i]) * (px[j] - px[i]) / (py[j] - py[i]);
+            }
+        }
+        for (int i = 1; i < m; i++) {
+            const float value = xs[i];
+            int j = i;
+            while (j > 0 && xs[j - 1] > value) {
+                xs[j] = xs[j - 1];
+                j--;
+            }
+            xs[j] = value;
+        }
+        for (int i = 0; i + 1 < m; i += 2) {
+            lv_area_t span;
+            span.x1 = roundInt(xs[i]);
+            span.x2 = roundInt(xs[i + 1]) - 1;
+            if (span.x2 < span.x1) {
+                span.x2 = span.x1;
+            }
+            span.y1 = y;
+            span.y2 = y;
+            lv_draw_fill(layer, &fill, &span);
+        }
+    }
+}
+
+void drawMarker(lv_layer_t* layer, GnssSystem system, float cx, float cy, float radius, bool filled, lv_color_t color) {
+    const float r = radius;
+    float xs[MAX_POINTS];
+    float ys[MAX_POINTS];
+    int n = 0;
+    switch (system) {
+        case GnssSystem::Gps:
+            drawCircle(layer, roundInt(cx), roundInt(cy), roundInt(r), color, filled, 2);
+            return;
+        case GnssSystem::Glonass:
+            xs[n] = cx;
+            ys[n++] = cy - r * 1.15f;
+            xs[n] = cx + r * 1.1f;
+            ys[n++] = cy + r * 0.85f;
+            xs[n] = cx - r * 1.1f;
+            ys[n++] = cy + r * 0.85f;
+            break;
+        case GnssSystem::Galileo:
+            for (int i = 0; i < 5; i++) {
+                const float angle = (-90.0f + 72.0f * static_cast<float>(i)) * PI_F / 180.0f;
+                xs[n] = cx + r * 1.05f * std::cos(angle);
+                ys[n++] = cy + r * 1.05f * std::sin(angle);
+            }
+            break;
+        case GnssSystem::Beidou:
+            for (int i = 0; i < 10; i++) {
+                const float angle = (-90.0f + 36.0f * static_cast<float>(i)) * PI_F / 180.0f;
+                const float radiusI = (i % 2 == 0) ? r * 1.2f : r * 0.5f;
+                xs[n] = cx + radiusI * std::cos(angle);
+                ys[n++] = cy + radiusI * std::sin(angle);
+            }
+            break;
+        case GnssSystem::Qzss:
+        case GnssSystem::Sbas: {
+            const float h = r * 0.85f;
+            xs[n] = cx - h;
+            ys[n++] = cy - h;
+            xs[n] = cx + h;
+            ys[n++] = cy - h;
+            xs[n] = cx + h;
+            ys[n++] = cy + h;
+            xs[n] = cx - h;
+            ys[n++] = cy + h;
+            break;
+        }
+        default:
+            xs[n] = cx;
+            ys[n++] = cy - r * 1.2f;
+            xs[n] = cx + r * 1.2f;
+            ys[n++] = cy;
+            xs[n] = cx;
+            ys[n++] = cy + r * 1.2f;
+            xs[n] = cx - r * 1.2f;
+            ys[n++] = cy;
+            break;
+    }
+    if (filled) {
+        fillPolygon(layer, xs, ys, n, color);
+        return;
+    }
+    for (int i = 0; i < n; i++) {
+        const int j = (i + 1) % n;
+        drawLine(layer, roundInt(xs[i]), roundInt(ys[i]), roundInt(xs[j]), roundInt(ys[j]), color);
+    }
+}
+
+lv_color_t fixColor(FixType fix, const Theme& theme) {
+    if (fix == FixType::Fix3d) {
+        return theme.success;
+    }
+    return fix == FixType::Fix2d ? theme.warning : theme.dim;
+}
+
+const char* fixText(FixType fix) {
+    return fix == FixType::Fix3d ? "3D FIX" : (fix == FixType::Fix2d ? "2D FIX" : "NO FIX");
+}
+
+const char* systemShortName(GnssSystem system) {
+    switch (system) {
+        case GnssSystem::Gps: return "GPS";
+        case GnssSystem::Glonass: return "GLO";
+        case GnssSystem::Galileo: return "GAL";
+        case GnssSystem::Beidou: return "BDS";
+        case GnssSystem::Qzss: return "QZS";
+        case GnssSystem::Sbas: return "SBS";
+        case GnssSystem::Navic: return "NIC";
+        default: return "UNK";
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Widgets.h b/Apps/GpsViewer/main/Source/app/Widgets.h
new file mode 100644
index 0000000..7b19a85
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Widgets.h
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Tabs.h"
+
+#include <lvgl.h>
+#include <lvgl/fonts.h>
+
+namespace gpsviewer {
+
+// Widgets: all use local styles only, the platform has no shared style descriptors
+
+// Transparent container without border, padding, scrolling or input
+lv_obj_t* createBox(lv_obj_t* parent);
+// Flat group of widgets with a little padding, no background or border
+lv_obj_t* createSection(lv_obj_t* parent);
+// 1 px line in the divider colour on the given sides of the object
+void setDivider(lv_obj_t* object, const Theme& theme, lv_border_side_t side);
+lv_obj_t* createLabel(lv_obj_t* parent, LvglFontSize size, lv_color_t color);
+// Small dim label above a value
+lv_obj_t* createCaption(lv_obj_t* parent, const Theme& theme, const char* text);
+// Small coloured label for a state, e.g. REC
+lv_obj_t* createTag(lv_obj_t* parent, const char* text, lv_color_t color);
+void setHidden(lv_obj_t* object, bool hidden);
+// Sets the text in the largest of the LARGE, DEFAULT and SMALL fonts that fits maxWidth, only
+// when the text differs
+void setFittedText(lv_obj_t* label, const char* text, int maxWidth);
+
+enum class IconKind : uint8_t {
+    Sun,
+    Moon,
+    Alert,
+};
+// Square icon drawn with the draw calls. Its text colour is the icon colour, its background
+// colour (not painted) is the colour of the surface behind it, used to cut out the moon.
+lv_obj_t* createIcon(lv_obj_t* parent, IconKind kind, int size, lv_color_t color, lv_color_t surface);
+
+// Drawing, for LV_EVENT_DRAW_MAIN handlers
+void drawText(lv_layer_t* layer, const char* text, const lv_font_t* font, lv_color_t color, const lv_area_t& area,
+              lv_text_align_t align);
+void drawLine(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int width = 1);
+void drawCircle(lv_layer_t* layer, int cx, int cy, int radius, lv_color_t color, bool filled, int borderWidth = 1);
+void drawFilledRect(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int radius = 0);
+void fillPolygon(lv_layer_t* layer, const float* xs, const float* ys, int count, lv_color_t color);
+// Marker shapes: circle GPS, triangle GLONASS, pentagon Galileo, star BeiDou, square QZSS and SBAS,
+// diamond NavIC and unknown. The shape is about 2 * radius wide.
+void drawMarker(lv_layer_t* layer, GnssSystem system, float cx, float cy, float radius, bool filled, lv_color_t color);
+
+lv_color_t fixColor(FixType fix, const Theme& theme);
+// "3D FIX", "2D FIX" or "NO FIX"
+const char* fixText(FixType fix);
+// Short constellation name for tight spaces: "GPS", "GLO", "GAL", "BDS", "QZS", "SBS", "NIC", "UNK"
+const char* systemShortName(GnssSystem system);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Format.cpp b/Apps/GpsViewer/main/Source/core/Format.cpp
new file mode 100644
index 0000000..5a3dfeb
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Format.cpp
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "Format.h"
+
+#include <cmath>
+#include <cstdio>
+#include <limits>
+
+namespace gpsviewer {
+
+namespace {
+
+// llround() is not exported to Tactility apps
+long long lroundExported(double value) {
+    return static_cast<long long>(std::round(value));
+}
+
+float quietNaN() {
+    return std::numeric_limits<float>::quiet_NaN();
+}
+
+void writeDash(char* out, size_t outSize) {
+    std::snprintf(out, outSize, "--");
+}
+
+double speedFactor(Units units) {
+    switch (units) {
+        case Units::Imperial:
+            return 2.236936;
+        case Units::Nautical:
+            return 1.943844;
+        case Units::Metric:
+            break;
+    }
+    return 3.6;
+}
+
+double lengthFactor(Units units) {
+    return units == Units::Imperial ? 3.28084 : 1.0;
+}
+
+// One decimal below the limit, whole numbers from it on. The check uses the rounded value.
+void writeAdaptive(double value, double limit, const char* suffix, char* out, size_t outSize) {
+    if (std::round(value * 10.0) < limit * 10.0) {
+        std::snprintf(out, outSize, "%.1f%s", value, suffix);
+    } else {
+        std::snprintf(out, outSize, "%lld%s", static_cast<long long>(std::round(value)), suffix);
+    }
+}
+
+} // namespace
+
+float estimatedAccuracyMeters(float hdop) {
+    if (std::isnan(hdop) || hdop <= 0.0f) {
+        return quietNaN();
+    }
+    return hdop * 5.0f;
+}
+
+void formatCoordinate(double degrees, bool isLatitude, CoordinateFormat format, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(degrees)) {
+        writeDash(out, outSize);
+        return;
+    }
+
+    const bool negative = degrees < 0.0;
+    const char hemisphere = isLatitude ? (negative ? 'S' : 'N') : (negative ? 'W' : 'E');
+    const double absolute = std::fabs(degrees);
+
+    switch (format) {
+        case CoordinateFormat::Degrees:
+            std::snprintf(out, outSize, "%.5f\xC2\xB0 %c", absolute, hemisphere);
+            return;
+        case CoordinateFormat::DegreesMinutes: {
+            // Thousandths of a minute, rounded before splitting so carries propagate
+            const long long units = lroundExported(absolute * 60000.0);
+            const long long deg = units / 60000;
+            const long long rest = units % 60000;
+            std::snprintf(out, outSize, "%lld\xC2\xB0 %lld.%03lld' %c",
+                          deg, rest / 1000, rest % 1000, hemisphere);
+            return;
+        }
+        case CoordinateFormat::DegreesMinutesSeconds: {
+            // Tenths of a second, rounded before splitting so carries propagate
+            const long long tenths = lroundExported(absolute * 36000.0);
+            const long long deg = tenths / 36000;
+            const long long rest = tenths % 36000;
+            const long long minutes = rest / 600;
+            const long long rest2 = rest % 600;
+            std::snprintf(out, outSize, "%lld\xC2\xB0 %lld' %lld.%lld\" %c",
+                          deg, minutes, rest2 / 10, rest2 % 10, hemisphere);
+            return;
+        }
+    }
+}
+
+void formatSpeed(float metersPerSecond, Units units, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(metersPerSecond)) {
+        writeDash(out, outSize);
+        return;
+    }
+    writeAdaptive(static_cast<double>(metersPerSecond) * speedFactor(units), 100.0, "", out, outSize);
+}
+
+const char* speedUnit(Units units) {
+    switch (units) {
+        case Units::Imperial:
+            return "mph";
+        case Units::Nautical:
+            return "kn";
+        case Units::Metric:
+            break;
+    }
+    return "km/h";
+}
+
+void formatAltitude(float meters, Units units, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(meters)) {
+        writeDash(out, outSize);
+        return;
+    }
+    const double value = static_cast<double>(meters) * lengthFactor(units);
+    const char* suffix = units == Units::Imperial ? " ft" : " m";
+    std::snprintf(out, outSize, "%lld%s", static_cast<long long>(std::round(value)), suffix);
+}
+
+void formatAccuracy(float meters, Units units, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(meters)) {
+        writeDash(out, outSize);
+        return;
+    }
+    const double value = static_cast<double>(meters) * lengthFactor(units);
+    const char* suffix = units == Units::Imperial ? " ft" : " m";
+    writeAdaptive(value, 10.0, suffix, out, outSize);
+}
+
+void formatDuration(unsigned seconds, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    const unsigned hours = seconds / 3600U;
+    const unsigned minutes = (seconds / 60U) % 60U;
+    const unsigned secs = seconds % 60U;
+    if (hours > 0) {
+        std::snprintf(out, outSize, "%u:%02u:%02u", hours, minutes, secs);
+    } else {
+        std::snprintf(out, outSize, "%u:%02u", minutes, secs);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Format.h b/Apps/GpsViewer/main/Source/core/Format.h
new file mode 100644
index 0000000..0036d55
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Format.h
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include <cstddef>
+
+namespace gpsviewer {
+
+enum class Units {
+    Metric,
+    Imperial,
+    Nautical,
+};
+
+enum class CoordinateFormat {
+    Degrees,
+    DegreesMinutes,
+    DegreesMinutesSeconds,
+};
+
+// Estimated horizontal accuracy in meters: HDOP times 5 m. NMEA gives no real accuracy.
+float estimatedAccuracyMeters(float hdop);
+
+// Writes e.g. "47.49801° N", "47° 29.881' N" or "47° 29' 52.8\" N" (° is UTF-8)
+void formatCoordinate(double degrees, bool isLatitude, CoordinateFormat format, char* out, size_t outSize);
+
+// Speed number without unit, e.g. "12.3", and the unit "km/h", "mph" or "kn"
+void formatSpeed(float metersPerSecond, Units units, char* out, size_t outSize);
+const char* speedUnit(Units units);
+
+// Altitude and accuracy: "123 m" or "404 ft". Nautical uses meters.
+void formatAltitude(float meters, Units units, char* out, size_t outSize);
+void formatAccuracy(float meters, Units units, char* out, size_t outSize);
+
+// "1:05" for 65 s, "1:02:03" from one hour up
+void formatDuration(unsigned seconds, char* out, size_t outSize);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssModel.cpp b/Apps/GpsViewer/main/Source/core/GnssModel.cpp
new file mode 100644
index 0000000..8ecb2ad
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssModel.cpp
@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "GnssModel.h"
+
+#include <cmath>
+
+namespace gpsviewer {
+
+namespace {
+
+// A fix source that went quiet for this long no longer counts
+constexpr uint32_t FIX_TIMEOUT_MS = 5000;
+
+bool olderThan(uint32_t nowMs, uint32_t thenMs, uint32_t ageMs) {
+    return static_cast<uint32_t>(nowMs - thenMs) > ageMs;
+}
+
+float toFloatOrNan(const minmea_float& value) {
+    return value.scale == 0 ? NAN : minmea_tofloat(&value);
+}
+
+// minmea_tocoord() returns a float, which loses about half a meter
+double toCoordinate(const minmea_float& value) {
+    if (value.scale == 0) {
+        return NAN;
+    }
+    const double raw = static_cast<double>(value.value) / value.scale;
+    const int degrees = static_cast<int>(raw / 100);
+    return degrees + (raw - degrees * 100) / 60.0;
+}
+
+} // namespace
+
+void GnssModel::reset(uint32_t nowMs) {
+    satellites.clear();
+    startMs = nowMs;
+    gsaFix = FixType::None;
+    gsaAtMs = 0;
+    ggaFix = false;
+    ggaSatellites = 0;
+    ggaAtMs = 0;
+    rmcValid = false;
+    pdop = NAN;
+    hdop = NAN;
+    vdop = NAN;
+    hasTtff = false;
+    ttffMs = 0;
+    hasPosition = false;
+    hasAltitude = false;
+    hasSpeed = false;
+    maxSpeedMps = 0;
+    speedSum = 0;
+    speedSamples = 0;
+    utcTime = {};
+}
+
+void GnssModel::onEvent(const GnssEvent& event, uint32_t nowMs) {
+    switch (event.type) {
+        case GnssEventType::Rmc:
+            onRmc(event.data.rmc, nowMs);
+            break;
+        case GnssEventType::Gga:
+            onGga(event.data.gga, nowMs);
+            break;
+        case GnssEventType::Gsv:
+            satellites.onGsv(event.talker, event.data.gsv, nowMs);
+            break;
+        case GnssEventType::Gsa:
+            satellites.onGsa(event.talker, event.data.gsa, nowMs);
+            onGsa(event.data.gsa, nowMs);
+            break;
+    }
+    updateFixState(nowMs);
+}
+
+void GnssModel::onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs) {
+    (void)nowMs;
+    rmcValid = rmc.valid;
+    if (rmc.date.year > 0 && rmc.time.hours >= 0) {
+        utcTime.valid = true;
+        utcTime.year = rmc.date.year < 100 ? 2000 + rmc.date.year : rmc.date.year;
+        utcTime.month = rmc.date.month;
+        utcTime.day = rmc.date.day;
+        utcTime.hour = rmc.time.hours;
+        utcTime.minute = rmc.time.minutes;
+        utcTime.second = rmc.time.seconds;
+    }
+    if (!rmc.valid) {
+        hasSpeed = false;
+        return;
+    }
+    const double lat = toCoordinate(rmc.latitude);
+    const double lon = toCoordinate(rmc.longitude);
+    if (!std::isnan(lat) && !std::isnan(lon)) {
+        hasPosition = true;
+        latitude = lat;
+        longitude = lon;
+    }
+    const float knots = toFloatOrNan(rmc.speed);
+    if (std::isnan(knots)) {
+        hasSpeed = false;
+        return;
+    }
+    hasSpeed = true;
+    speedMps = knots * METERS_PER_SECOND_PER_KNOT;
+    courseDegrees = toFloatOrNan(rmc.course);
+    if (speedMps > maxSpeedMps) {
+        maxSpeedMps = speedMps;
+    }
+    speedSum += speedMps;
+    speedSamples++;
+}
+
+void GnssModel::onGga(const minmea_sentence_gga& gga, uint32_t nowMs) {
+    ggaFix = gga.fix_quality > 0;
+    ggaSatellites = gga.satellites_tracked;
+    ggaAtMs = nowMs;
+    if (!ggaFix) {
+        return;
+    }
+    const float ggaHdop = toFloatOrNan(gga.hdop);
+    if (!std::isnan(ggaHdop) && olderThan(nowMs, gsaAtMs, FIX_TIMEOUT_MS)) {
+        hdop = ggaHdop;
+    }
+    const double lat = toCoordinate(gga.latitude);
+    const double lon = toCoordinate(gga.longitude);
+    if (!std::isnan(lat) && !std::isnan(lon)) {
+        hasPosition = true;
+        latitude = lat;
+        longitude = lon;
+    }
+    const float altitude = toFloatOrNan(gga.altitude);
+    hasAltitude = !std::isnan(altitude) && (gga.altitude_units == 'M' || gga.altitude_units == '\0');
+    if (hasAltitude) {
+        altitudeMeters = altitude;
+    }
+}
+
+void GnssModel::onGsa(const minmea_sentence_gsa& gsa, uint32_t nowMs) {
+    gsaAtMs = nowMs;
+    gsaFix = gsa.fix_type == MINMEA_GPGSA_FIX_3D ? FixType::Fix3d
+        : gsa.fix_type == MINMEA_GPGSA_FIX_2D ? FixType::Fix2d
+        : FixType::None;
+    pdop = toFloatOrNan(gsa.pdop);
+    hdop = toFloatOrNan(gsa.hdop);
+    vdop = toFloatOrNan(gsa.vdop);
+}
+
+void GnssModel::updateFixState(uint32_t nowMs) {
+    if (hasTtff) {
+        return;
+    }
+    const bool gsaSaysFix = gsaFix != FixType::None && !olderThan(nowMs, gsaAtMs, FIX_TIMEOUT_MS);
+    const bool ggaSaysFix = ggaFix && !olderThan(nowMs, ggaAtMs, FIX_TIMEOUT_MS);
+    if ((gsaSaysFix || ggaSaysFix) && rmcValid) {
+        hasTtff = true;
+        ttffMs = nowMs - startMs;
+    }
+}
+
+void GnssModel::resetSpeedStats() {
+    maxSpeedMps = hasSpeed ? speedMps : 0;
+    speedSum = 0;
+    speedSamples = 0;
+}
+
+void GnssModel::snapshot(GnssSnapshot& out, uint32_t nowMs) {
+    satellites.expire(nowMs);
+
+    const bool gsaFresh = !olderThan(nowMs, gsaAtMs, FIX_TIMEOUT_MS) && gsaAtMs != 0;
+    const bool ggaFresh = !olderThan(nowMs, ggaAtMs, FIX_TIMEOUT_MS) && ggaAtMs != 0;
+    FixType fix = FixType::None;
+    if (gsaFresh) {
+        fix = gsaFix;
+    } else if (ggaFresh && ggaFix) {
+        fix = FixType::Fix3d;
+    }
+    if (ggaFresh && !ggaFix) {
+        fix = FixType::None;
+    }
+
+    out.fix = fix;
+    out.satellitesInView = satellites.count();
+    out.satellitesUsed = satellites.usedCount();
+    if (out.satellitesUsed == 0 && ggaFresh && ggaFix) {
+        out.satellitesUsed = ggaSatellites;
+    }
+    out.pdop = gsaFresh ? pdop : NAN;
+    out.hdop = (gsaFresh || ggaFresh) ? hdop : NAN;
+    out.vdop = gsaFresh ? vdop : NAN;
+    out.hasTtff = hasTtff;
+    out.ttffMs = ttffMs;
+    out.listeningMs = nowMs - startMs;
+    out.hasPosition = hasPosition;
+    out.latitude = latitude;
+    out.longitude = longitude;
+    out.hasAltitude = hasAltitude && fix == FixType::Fix3d;
+    out.altitudeMeters = altitudeMeters;
+    out.hasSpeed = hasSpeed && fix != FixType::None;
+    out.speedMps = speedMps;
+    out.maxSpeedMps = maxSpeedMps;
+    out.averageSpeedMps = speedSamples == 0 ? 0.0f : static_cast<float>(speedSum / speedSamples);
+    out.courseDegrees = (out.hasSpeed && speedMps >= COURSE_MIN_SPEED_MPS) ? courseDegrees : NAN;
+    out.utc = utcTime;
+    out.satelliteCount = satellites.count();
+    for (int i = 0; i < out.satelliteCount; i++) {
+        out.satellites[i] = satellites.at(i);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssModel.h b/Apps/GpsViewer/main/Source/core/GnssModel.h
new file mode 100644
index 0000000..e3505a5
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssModel.h
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "GnssTypes.h"
+#include "SatelliteDb.h"
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+enum class FixType : uint8_t {
+    None,
+    Fix2d,
+    Fix3d,
+};
+
+struct UtcDateTime {
+    bool valid;
+    int year;
+    int month;
+    int day;
+    int hour;
+    int minute;
+    int second;
+};
+
+// Everything the screens show, copied out of GnssModel in one go
+struct GnssSnapshot {
+    FixType fix;
+    int satellitesUsed;
+    int satellitesInView;
+    // NAN when unknown
+    float pdop;
+    float hdop;
+    float vdop;
+    bool hasTtff;
+    uint32_t ttffMs;
+    uint32_t listeningMs;
+    bool hasPosition;
+    double latitude;
+    double longitude;
+    bool hasAltitude;
+    float altitudeMeters;
+    bool hasSpeed;
+    float speedMps;
+    float maxSpeedMps;
+    float averageSpeedMps;
+    // NAN while slower than COURSE_MIN_SPEED_MPS
+    float courseDegrees;
+    UtcDateTime utc;
+    int satelliteCount;
+    Satellite satellites[SatelliteDb::MAX_SATELLITES];
+};
+
+constexpr float COURSE_MIN_SPEED_MPS = 1.0f;
+constexpr float METERS_PER_SECOND_PER_KNOT = 0.514444f;
+
+class GnssModel {
+public:
+    void reset(uint32_t nowMs);
+    void onEvent(const GnssEvent& event, uint32_t nowMs);
+    void resetSpeedStats();
+    void snapshot(GnssSnapshot& out, uint32_t nowMs);
+    int satellitesInView() const { return satellites.count(); }
+    const UtcDateTime& utc() const { return utcTime; }
+
+private:
+    void onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs);
+    void onGga(const minmea_sentence_gga& gga, uint32_t nowMs);
+    void onGsa(const minmea_sentence_gsa& gsa, uint32_t nowMs);
+    void updateFixState(uint32_t nowMs);
+
+    SatelliteDb satellites;
+    uint32_t startMs = 0;
+    FixType gsaFix = FixType::None;
+    uint32_t gsaAtMs = 0;
+    bool ggaFix = false;
+    int ggaSatellites = 0;
+    uint32_t ggaAtMs = 0;
+    bool rmcValid = false;
+    float pdop = 0;
+    float hdop = 0;
+    float vdop = 0;
+    bool hasTtff = false;
+    uint32_t ttffMs = 0;
+    bool hasPosition = false;
+    double latitude = 0;
+    double longitude = 0;
+    bool hasAltitude = false;
+    float altitudeMeters = 0;
+    bool hasSpeed = false;
+    float speedMps = 0;
+    float courseDegrees = 0;
+    float maxSpeedMps = 0;
+    double speedSum = 0;
+    uint32_t speedSamples = 0;
+    UtcDateTime utcTime {};
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssTypes.cpp b/Apps/GpsViewer/main/Source/core/GnssTypes.cpp
new file mode 100644
index 0000000..547483f
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssTypes.cpp
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "GnssTypes.h"
+
+namespace gpsviewer {
+
+GnssSystem systemFromTalker(const char* talker) {
+    if (talker == nullptr || talker[0] == '\0') {
+        return GnssSystem::Unknown;
+    }
+    // No tables of string pointers: the app loader leaves pointers in data tables unrelocated
+    const char first = talker[0];
+    const char second = talker[1];
+    if (first == 'G') {
+        switch (second) {
+            case 'P': return GnssSystem::Gps;
+            case 'L': return GnssSystem::Glonass;
+            case 'A': return GnssSystem::Galileo;
+            case 'B': return GnssSystem::Beidou;
+            case 'Q': return GnssSystem::Qzss;
+            case 'I': return GnssSystem::Navic;
+            default: return GnssSystem::Unknown;
+        }
+    }
+    if (first == 'B' && second == 'D') return GnssSystem::Beidou;
+    if (first == 'Q' && second == 'Z') return GnssSystem::Qzss;
+    return GnssSystem::Unknown;
+}
+
+GnssSystem systemFromId(int id) {
+    if (id >= 1 && id <= 32) return GnssSystem::Gps;
+    if ((id >= 33 && id <= 64) || (id >= 120 && id <= 158)) return GnssSystem::Sbas;
+    if (id >= 65 && id <= 96) return GnssSystem::Glonass;
+    if (id >= 193 && id <= 202) return GnssSystem::Qzss;
+    return GnssSystem::Unknown;
+}
+
+GnssSystem systemOfSatellite(const char* talker, int id) {
+    const GnssSystem fromTalker = systemFromTalker(talker);
+    if (fromTalker == GnssSystem::Unknown) {
+        return systemFromId(id);
+    }
+    if (fromTalker == GnssSystem::Gps) {
+        const GnssSystem fromId = systemFromId(id);
+        if (fromId == GnssSystem::Sbas || fromId == GnssSystem::Qzss) {
+            return fromId;
+        }
+    }
+    return fromTalker;
+}
+
+char systemLetter(GnssSystem system) {
+    switch (system) {
+        case GnssSystem::Gps: return 'G';
+        case GnssSystem::Glonass: return 'R';
+        case GnssSystem::Galileo: return 'E';
+        case GnssSystem::Beidou: return 'C';
+        case GnssSystem::Qzss: return 'J';
+        case GnssSystem::Sbas: return 'S';
+        case GnssSystem::Navic: return 'I';
+        default: return '?';
+    }
+}
+
+const char* systemName(GnssSystem system) {
+    switch (system) {
+        case GnssSystem::Gps: return "GPS";
+        case GnssSystem::Glonass: return "GLONASS";
+        case GnssSystem::Galileo: return "Galileo";
+        case GnssSystem::Beidou: return "BeiDou";
+        case GnssSystem::Qzss: return "QZSS";
+        case GnssSystem::Sbas: return "SBAS";
+        case GnssSystem::Navic: return "NavIC";
+        default: return "Unknown";
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssTypes.h b/Apps/GpsViewer/main/Source/core/GnssTypes.h
new file mode 100644
index 0000000..13c7d05
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssTypes.h
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include <minmea.h>
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+enum class GnssSystem : uint8_t {
+    Unknown,
+    Gps,
+    Glonass,
+    Galileo,
+    Beidou,
+    Qzss,
+    Sbas,
+    Navic,
+};
+
+constexpr int GNSS_SYSTEM_COUNT = 8;
+
+enum class GnssEventType : uint8_t {
+    Rmc,
+    Gga,
+    Gsv,
+    Gsa,
+};
+
+// The data of one parsed NMEA sentence, filled from a GpsEvent
+struct GnssEvent {
+    GnssEventType type;
+    char talker[3];
+    union {
+        minmea_sentence_rmc rmc;
+        minmea_sentence_gga gga;
+        minmea_sentence_gsv gsv;
+        minmea_sentence_gsa gsa;
+    } data;
+};
+
+// "GP" Gps, "GL" Glonass, "GA" Galileo, "GB" and "BD" Beidou, "GQ" and "QZ" Qzss, "GI" Navic.
+// "GN", empty and anything else give Unknown: the satellite ID decides then.
+GnssSystem systemFromTalker(const char* talker);
+
+// NMEA ID ranges: 1..32 GPS, 33..64 and 120..158 SBAS, 65..96 GLONASS, 193..202 QZSS. Others give Unknown.
+GnssSystem systemFromId(int id);
+
+// System of a satellite listed under a talker. A GP talker also carries SBAS and QZSS IDs.
+GnssSystem systemOfSatellite(const char* talker, int id);
+
+// G GPS, R GLONASS, E Galileo, C BeiDou, J QZSS, S SBAS, I NavIC, ? unknown
+char systemLetter(GnssSystem system);
+
+const char* systemName(GnssSystem system);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/NmeaWriter.cpp b/Apps/GpsViewer/main/Source/core/NmeaWriter.cpp
new file mode 100644
index 0000000..d5ac7c2
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/NmeaWriter.cpp
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "NmeaWriter.h"
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+struct Out {
+    char* buf;
+    size_t cap;
+    size_t len;
+    bool ok;
+};
+
+void put(Out& o, const char* fmt, ...) {
+    if (!o.ok) {
+        return;
+    }
+    va_list ap;
+    va_start(ap, fmt);
+    int n = vsnprintf(o.buf + o.len, o.cap - o.len, fmt, ap);
+    va_end(ap);
+    if (n < 0 || static_cast<size_t>(n) >= o.cap - o.len) {
+        o.ok = false;
+        return;
+    }
+    o.len += static_cast<size_t>(n);
+}
+
+// Writes value/scale with log10(scale) decimals, nothing for scale 0 (empty field).
+// withSign false writes the absolute value because the hemisphere letter carries the sign.
+void putFloat(Out& o, const minmea_float& f, int intDigits, bool withSign) {
+    if (f.scale <= 0) {
+        return;
+    }
+    int64_t v = f.value;
+    const bool negative = v < 0;
+    if (negative) {
+        v = -v;
+    }
+    int decimals = 0;
+    int64_t div = 1;
+    for (int64_t s = f.scale; s > 1; s /= 10) {
+        decimals++;
+        div *= 10;
+    }
+    if (negative && withSign) {
+        put(o, "-");
+    }
+    const long long ip = static_cast<long long>(v / div);
+    if (decimals > 0) {
+        put(o, "%0*lld.%0*lld", intDigits, ip, decimals, static_cast<long long>(v % div));
+    } else {
+        put(o, "%0*lld", intDigits, ip);
+    }
+}
+
+void putCoord(Out& o, const minmea_float& f, int intDigits, char positive, char negative) {
+    put(o, ",");
+    putFloat(o, f, intDigits, false);
+    put(o, ",");
+    if (f.scale > 0) {
+        put(o, "%c", f.value < 0 ? negative : positive);
+    }
+}
+
+void putTime(Out& o, const minmea_time& t) {
+    put(o, ",");
+    if (t.hours < 0) {
+        return;
+    }
+    put(o, "%02d%02d%02d", t.hours, t.minutes, t.seconds);
+    int us = t.microseconds < 0 ? 0 : t.microseconds;
+    int digits = 6;
+    while (digits > 2 && us % 10 == 0) {
+        us /= 10;
+        digits--;
+    }
+    put(o, ".%0*d", digits, us);
+}
+
+void putDate(Out& o, const minmea_date& d) {
+    put(o, ",");
+    if (d.day < 0) {
+        return;
+    }
+    put(o, "%02d%02d%02d", d.day, d.month, d.year);
+}
+
+void putChar(Out& o, char c) {
+    put(o, ",");
+    if (c != 0) {
+        put(o, "%c", c);
+    }
+}
+
+void putFloatField(Out& o, const minmea_float& f) {
+    put(o, ",");
+    putFloat(o, f, 1, true);
+}
+
+void putRmc(Out& o, const minmea_sentence_rmc& r) {
+    putTime(o, r.time);
+    put(o, r.valid ? ",A" : ",V");
+    putCoord(o, r.latitude, 4, 'N', 'S');
+    putCoord(o, r.longitude, 5, 'E', 'W');
+    putFloatField(o, r.speed);
+    putFloatField(o, r.course);
+    putDate(o, r.date);
+    putCoord(o, r.variation, 1, 'E', 'W');
+}
+
+void putGga(Out& o, const minmea_sentence_gga& g) {
+    putTime(o, g.time);
+    putCoord(o, g.latitude, 4, 'N', 'S');
+    putCoord(o, g.longitude, 5, 'E', 'W');
+    put(o, ",%d,%02d", g.fix_quality, g.satellites_tracked);
+    putFloatField(o, g.hdop);
+    putFloatField(o, g.altitude);
+    putChar(o, g.altitude_units);
+    putFloatField(o, g.height);
+    putChar(o, g.height_units);
+    putFloatField(o, g.dgps_age);
+    put(o, ",");
+}
+
+void putGsa(Out& o, const minmea_sentence_gsa& a) {
+    putChar(o, a.mode);
+    put(o, ",%d", a.fix_type);
+    for (int i = 0; i < 12; i++) {
+        put(o, ",");
+        if (a.sats[i] != 0) {
+            put(o, "%02d", a.sats[i]);
+        }
+    }
+    putFloatField(o, a.pdop);
+    putFloatField(o, a.hdop);
+    putFloatField(o, a.vdop);
+}
+
+void putGsv(Out& o, const minmea_sentence_gsv& v) {
+    put(o, ",%d,%d,%d", v.total_msgs, v.msg_nr, v.total_sats);
+    int last = -1;
+    for (int i = 0; i < 4; i++) {
+        const minmea_sat_info& s = v.sats[i];
+        if (s.nr != 0 || s.elevation != 0 || s.azimuth != 0 || s.snr != 0) {
+            last = i;
+        }
+    }
+    for (int i = 0; i <= last; i++) {
+        const minmea_sat_info& s = v.sats[i];
+        put(o, ",");
+        if (s.nr != 0) {
+            put(o, "%02d", s.nr);
+        }
+        put(o, ",%02d,%03d,%02d", s.elevation, s.azimuth, s.snr);
+    }
+}
+
+} // namespace
+
+size_t formatNmeaLine(const GnssEvent& event, char* out, size_t outSize) {
+    if (out == nullptr || outSize == 0) {
+        return 0;
+    }
+    Out o = {out, outSize, 0, true};
+    const bool hasTalker = event.talker[0] != '\0' && event.talker[1] != '\0';
+    const char t0 = hasTalker ? event.talker[0] : 'G';
+    const char t1 = hasTalker ? event.talker[1] : 'N';
+    const char* name = "RMC";
+    switch (event.type) {
+        case GnssEventType::Rmc: name = "RMC"; break;
+        case GnssEventType::Gga: name = "GGA"; break;
+        case GnssEventType::Gsv: name = "GSV"; break;
+        case GnssEventType::Gsa: name = "GSA"; break;
+    }
+    put(o, "$%c%c%s", t0, t1, name);
+    switch (event.type) {
+        case GnssEventType::Rmc: putRmc(o, event.data.rmc); break;
+        case GnssEventType::Gga: putGga(o, event.data.gga); break;
+        case GnssEventType::Gsv: putGsv(o, event.data.gsv); break;
+        case GnssEventType::Gsa: putGsa(o, event.data.gsa); break;
+    }
+    if (!o.ok) {
+        out[0] = '\0';
+        return 0;
+    }
+    unsigned checksum = 0;
+    for (size_t i = 1; i < o.len; i++) {
+        checksum ^= static_cast<unsigned char>(out[i]);
+    }
+    put(o, "*%02X\r\n", checksum);
+    if (!o.ok) {
+        out[0] = '\0';
+        return 0;
+    }
+    return o.len;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/NmeaWriter.h b/Apps/GpsViewer/main/Source/core/NmeaWriter.h
new file mode 100644
index 0000000..c77470a
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/NmeaWriter.h
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "GnssTypes.h"
+
+#include <cstddef>
+
+namespace gpsviewer {
+
+// Formats an event back into one NMEA 0183 line, "$<talker><type>,...*XX\r\n", so that
+// parseNmeaLine() gives the same event again. An empty talker is written as "GN".
+// Returns the length written without the NUL, or 0 when it doesn't fit in out.
+size_t formatNmeaLine(const GnssEvent& event, char* out, size_t outSize);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp b/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
new file mode 100644
index 0000000..bac87d3
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "SatelliteDb.h"
+
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// A second GSV set of the same talker within this time belongs to the same epoch.
+// Receivers send one set per signal band (L1, L5), so the sets are merged.
+constexpr uint32_t SAME_EPOCH_MS = 500;
+// Combined (GN) GSA sentences closer together than this belong to one epoch
+constexpr uint32_t GSA_EPOCH_MS = 300;
+
+bool olderThan(uint32_t nowMs, uint32_t thenMs, uint32_t ageMs) {
+    return static_cast<uint32_t>(nowMs - thenMs) > ageMs;
+}
+
+uint32_t systemBit(GnssSystem system) {
+    return 1U << static_cast<uint32_t>(system);
+}
+
+// Maps an ID from a GSA sentence to its satellite system, once the sentence's system is known
+GnssSystem usedIdSystem(GnssSystem gsaSystem, int id) {
+    if (gsaSystem == GnssSystem::Gps) {
+        return systemOfSatellite("GP", id);
+    }
+    if (gsaSystem == GnssSystem::Unknown) {
+        return systemFromId(id);
+    }
+    return gsaSystem;
+}
+
+} // namespace
+
+void SatelliteDb::clear() {
+    satelliteCount = 0;
+    groupCount = 0;
+    combinedGsaAtMs = 0;
+    combinedGsaSystems = 0;
+}
+
+int SatelliteDb::groupIndex(const char* talker) {
+    for (int i = 0; i < groupCount; i++) {
+        if (strncmp(groups[i].talker, talker, 2) == 0) {
+            return i;
+        }
+    }
+    if (groupCount == MAX_GROUPS) {
+        return -1;
+    }
+    PendingSet& set = groups[groupCount];
+    set = {};
+    strncpy(set.talker, talker, 2);
+    set.talker[2] = '\0';
+    return groupCount++;
+}
+
+int SatelliteDb::find(GnssSystem system, int id) const {
+    for (int i = 0; i < satelliteCount; i++) {
+        if (satellites[i].system == system && satellites[i].id == id) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+void SatelliteDb::onGsv(const char* talker, const minmea_sentence_gsv& gsv, uint32_t nowMs) {
+    const int group = groupIndex(talker);
+    if (group < 0) {
+        return;
+    }
+    PendingSet& set = groups[group];
+    if (gsv.msg_nr == 1) {
+        set.count = 0;
+        set.totalMessages = gsv.total_msgs;
+        set.nextMessage = 1;
+    }
+    if (gsv.msg_nr != set.nextMessage || gsv.total_msgs != set.totalMessages || gsv.total_msgs < 1) {
+        set.nextMessage = 0;
+        return;
+    }
+    // NMEA 4.10 adds a signal ID after the satellites, which minmea reads as the next satellite's
+    // number in a last message with fewer than four satellites. Entries beyond total_sats are dropped.
+    for (int i = 0; i < 4; i++) {
+        const minmea_sat_info& info = gsv.sats[i];
+        const int position = (gsv.msg_nr - 1) * 4 + i;
+        if (info.nr <= 0 || set.count == MAX_SATELLITES || (gsv.total_sats > 0 && position >= gsv.total_sats)) {
+            continue;
+        }
+        Satellite& satellite = set.satellites[set.count++];
+        satellite = {};
+        satellite.system = systemOfSatellite(talker, info.nr);
+        satellite.group = static_cast<uint8_t>(group);
+        satellite.id = static_cast<int16_t>(info.nr);
+        // minmea gives 0 for empty fields, and receivers leave both empty for satellites without a position
+        const bool hasPosition = info.elevation != 0 || info.azimuth != 0;
+        satellite.elevation = static_cast<int16_t>(hasPosition ? info.elevation : -1);
+        satellite.azimuth = static_cast<int16_t>(hasPosition ? info.azimuth : -1);
+        satellite.snr = static_cast<int16_t>(info.snr > 0 ? info.snr : 0);
+        satellite.lastSeenMs = nowMs;
+    }
+    if (gsv.msg_nr == gsv.total_msgs) {
+        commit(group, nowMs);
+        set.nextMessage = 0;
+    } else {
+        set.nextMessage++;
+    }
+}
+
+void SatelliteDb::commit(int group, uint32_t nowMs) {
+    PendingSet& set = groups[group];
+    const bool merge = set.committed && !olderThan(nowMs, set.committedAtMs, SAME_EPOCH_MS);
+
+    if (!merge) {
+        int kept = 0;
+        for (int i = 0; i < satelliteCount; i++) {
+            if (satellites[i].group != group) {
+                satellites[kept++] = satellites[i];
+                continue;
+            }
+            // Keep the used flag of satellites that are in the new set
+            for (int j = 0; j < set.count; j++) {
+                Satellite& fresh = set.satellites[j];
+                if (fresh.system == satellites[i].system && fresh.id == satellites[i].id) {
+                    fresh.used = satellites[i].used;
+                    fresh.usedAtMs = satellites[i].usedAtMs;
+                }
+            }
+        }
+        satelliteCount = kept;
+    }
+
+    for (int j = 0; j < set.count; j++) {
+        const Satellite& fresh = set.satellites[j];
+        const int index = find(fresh.system, fresh.id);
+        if (index < 0) {
+            if (satelliteCount < MAX_SATELLITES) {
+                satellites[satelliteCount++] = fresh;
+            }
+            continue;
+        }
+        Satellite& existing = satellites[index];
+        if (!merge || fresh.snr > existing.snr) {
+            existing.snr = fresh.snr;
+        }
+        if (fresh.elevation >= 0) {
+            existing.elevation = fresh.elevation;
+            existing.azimuth = fresh.azimuth;
+        }
+        existing.lastSeenMs = nowMs;
+    }
+
+    set.committed = true;
+    set.committedAtMs = nowMs;
+}
+
+// Combined GSA sentences don't say their system in minmea's fields. Receivers send one per system
+// per epoch, so each system is picked once per epoch: the one whose satellites in view contain
+// most of the used IDs. Ties go to the first system in enum order. Without a match the ID ranges decide.
+GnssSystem SatelliteDb::guessGsaSystem(const int* ids, int idCount) const {
+    GnssSystem best = GnssSystem::Unknown;
+    int bestScore = 0;
+    for (int s = 1; s < GNSS_SYSTEM_COUNT; s++) {
+        const auto system = static_cast<GnssSystem>(s);
+        if (system == GnssSystem::Sbas || (combinedGsaSystems & systemBit(system)) != 0) {
+            continue;
+        }
+        int score = 0;
+        for (int i = 0; i < idCount; i++) {
+            if (find(usedIdSystem(system, ids[i]), ids[i]) >= 0) {
+                score++;
+            }
+        }
+        if (score > bestScore) {
+            best = system;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+
+void SatelliteDb::markUsed(GnssSystem gsaSystem, const int* ids, int idCount, uint32_t nowMs) {
+    if (gsaSystem != GnssSystem::Unknown) {
+        for (int i = 0; i < satelliteCount; i++) {
+            if (satellites[i].system == gsaSystem) {
+                satellites[i].used = false;
+            }
+        }
+    }
+    for (int i = 0; i < idCount; i++) {
+        const int index = find(usedIdSystem(gsaSystem, ids[i]), ids[i]);
+        if (index >= 0) {
+            satellites[index].used = true;
+            satellites[index].usedAtMs = nowMs;
+        }
+    }
+}
+
+// Used IDs belong to the talker's system when the talker names one. A GP talker can also list
+// SBAS (33..64, 120..158) and QZSS (193..202) IDs. Combined talkers are resolved by guessGsaSystem().
+void SatelliteDb::onGsa(const char* talker, const minmea_sentence_gsa& gsa, uint32_t nowMs) {
+    int ids[12];
+    int idCount = 0;
+    for (int id : gsa.sats) {
+        if (id > 0) {
+            ids[idCount++] = id;
+        }
+    }
+
+    GnssSystem system = systemFromTalker(talker);
+    if (system == GnssSystem::Unknown) {
+        if (idCount == 0) {
+            return;
+        }
+        if (combinedGsaAtMs == 0 || olderThan(nowMs, combinedGsaAtMs, GSA_EPOCH_MS)) {
+            combinedGsaSystems = 0;
+        }
+        combinedGsaAtMs = nowMs;
+        system = guessGsaSystem(ids, idCount);
+        if (system != GnssSystem::Unknown) {
+            combinedGsaSystems |= systemBit(system);
+        }
+    }
+    markUsed(system, ids, idCount, nowMs);
+}
+
+void SatelliteDb::expire(uint32_t nowMs) {
+    int kept = 0;
+    for (int i = 0; i < satelliteCount; i++) {
+        Satellite& satellite = satellites[i];
+        if (olderThan(nowMs, satellite.lastSeenMs, EXPIRY_MS)) {
+            continue;
+        }
+        if (satellite.used && olderThan(nowMs, satellite.usedAtMs, USED_EXPIRY_MS)) {
+            satellite.used = false;
+        }
+        satellites[kept++] = satellite;
+    }
+    satelliteCount = kept;
+}
+
+int SatelliteDb::usedCount() const {
+    int used = 0;
+    for (int i = 0; i < satelliteCount; i++) {
+        if (satellites[i].used) {
+            used++;
+        }
+    }
+    return used;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SatelliteDb.h b/Apps/GpsViewer/main/Source/core/SatelliteDb.h
new file mode 100644
index 0000000..a7a037c
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SatelliteDb.h
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "GnssTypes.h"
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+struct Satellite {
+    GnssSystem system;
+    // Index of the GSV talker group that reported it, see SatelliteDb
+    uint8_t group;
+    int16_t id;
+    // Degrees, -1 when the receiver gave no position
+    int16_t elevation;
+    int16_t azimuth;
+    // dB-Hz, 0 when not tracked
+    int16_t snr;
+    bool used;
+    uint32_t lastSeenMs;
+    uint32_t usedAtMs;
+};
+
+// Satellites in view, assembled from GSV sets and marked used from GSA sentences
+class SatelliteDb {
+public:
+    static constexpr int MAX_SATELLITES = 72;
+    static constexpr int MAX_GROUPS = 8;
+    static constexpr uint32_t EXPIRY_MS = 10000;
+    static constexpr uint32_t USED_EXPIRY_MS = 3000;
+
+    void clear();
+    void onGsv(const char* talker, const minmea_sentence_gsv& gsv, uint32_t nowMs);
+    void onGsa(const char* talker, const minmea_sentence_gsa& gsa, uint32_t nowMs);
+    // Drops satellites not seen for EXPIRY_MS and used flags older than USED_EXPIRY_MS
+    void expire(uint32_t nowMs);
+
+    int count() const { return satelliteCount; }
+    const Satellite& at(int index) const { return satellites[index]; }
+    int usedCount() const;
+
+private:
+    struct PendingSet {
+        char talker[3];
+        int totalMessages;
+        int nextMessage;
+        int count;
+        Satellite satellites[MAX_SATELLITES];
+        uint32_t committedAtMs;
+        bool committed;
+    };
+
+    int groupIndex(const char* talker);
+    void commit(int group, uint32_t nowMs);
+    int find(GnssSystem system, int id) const;
+    void markUsed(GnssSystem system, const int* ids, int idCount, uint32_t nowMs);
+    GnssSystem guessGsaSystem(const int* ids, int idCount) const;
+
+    Satellite satellites[MAX_SATELLITES] {};
+    int satelliteCount = 0;
+    PendingSet groups[MAX_GROUPS] {};
+    int groupCount = 0;
+    uint32_t combinedGsaAtMs = 0;
+    uint32_t combinedGsaSystems = 0;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Settings.cpp b/Apps/GpsViewer/main/Source/core/Settings.cpp
new file mode 100644
index 0000000..d7157de
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Settings.cpp
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "Settings.h"
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+bool isBlank(char c) {
+    return c == ' ' || c == '\t' || c == '\r';
+}
+
+// True when the range [begin, end) equals the NUL-terminated word
+bool sameText(const char* begin, const char* end, const char* word) {
+    const char* p = begin;
+    while (p < end && *word != '\0') {
+        if (*p != *word) {
+            return false;
+        }
+        ++p;
+        ++word;
+    }
+    return p == end && *word == '\0';
+}
+
+void applyLine(const char* begin, const char* end, Settings& settings) {
+    while (begin < end && isBlank(*begin)) {
+        ++begin;
+    }
+    while (end > begin && isBlank(end[-1])) {
+        --end;
+    }
+    if (begin == end || *begin == '#') {
+        return;
+    }
+
+    const char* eq = begin;
+    while (eq < end && *eq != '=') {
+        ++eq;
+    }
+    if (eq == end) {
+        return;
+    }
+
+    const char* keyEnd = eq;
+    while (keyEnd > begin && isBlank(keyEnd[-1])) {
+        --keyEnd;
+    }
+    const char* value = eq + 1;
+    while (value < end && isBlank(*value)) {
+        ++value;
+    }
+
+    if (sameText(begin, keyEnd, "units")) {
+        if (sameText(value, end, "metric")) {
+            settings.units = Units::Metric;
+        } else if (sameText(value, end, "imperial")) {
+            settings.units = Units::Imperial;
+        } else if (sameText(value, end, "nautical")) {
+            settings.units = Units::Nautical;
+        }
+    } else if (sameText(begin, keyEnd, "coordinates")) {
+        if (sameText(value, end, "dd")) {
+            settings.coordinateFormat = CoordinateFormat::Degrees;
+        } else if (sameText(value, end, "dm")) {
+            settings.coordinateFormat = CoordinateFormat::DegreesMinutes;
+        } else if (sameText(value, end, "dms")) {
+            settings.coordinateFormat = CoordinateFormat::DegreesMinutesSeconds;
+        }
+    } else if (sameText(begin, keyEnd, "night")) {
+        if (sameText(value, end, "0")) {
+            settings.nightMode = false;
+        } else if (sameText(value, end, "1")) {
+            settings.nightMode = true;
+        }
+    }
+}
+
+const char* unitsName(Units units) {
+    switch (units) {
+        case Units::Imperial:
+            return "imperial";
+        case Units::Nautical:
+            return "nautical";
+        case Units::Metric:
+            break;
+    }
+    return "metric";
+}
+
+const char* coordinatesName(CoordinateFormat format) {
+    switch (format) {
+        case CoordinateFormat::DegreesMinutes:
+            return "dm";
+        case CoordinateFormat::DegreesMinutesSeconds:
+            return "dms";
+        case CoordinateFormat::Degrees:
+            break;
+    }
+    return "dd";
+}
+
+} // namespace
+
+Settings parseSettings(const char* text) {
+    Settings settings;
+    if (!text) {
+        return settings;
+    }
+    const char* line = text;
+    while (*line != '\0') {
+        const char* end = line;
+        while (*end != '\0' && *end != '\n') {
+            ++end;
+        }
+        applyLine(line, end, settings);
+        line = (*end == '\n') ? end + 1 : end;
+    }
+    return settings;
+}
+
+size_t serializeSettings(const Settings& settings, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return 0;
+    }
+    const int written = std::snprintf(out, outSize,
+                                      "units=%s\ncoordinates=%s\nnight=%d\n",
+                                      unitsName(settings.units),
+                                      coordinatesName(settings.coordinateFormat),
+                                      settings.nightMode ? 1 : 0);
+    // A text that does not fit is not written at all, so a partial file never parses to odd values
+    if (written < 0 || static_cast<size_t>(written) >= outSize) {
+        out[0] = '\0';
+        return 0;
+    }
+    return static_cast<size_t>(written);
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Settings.h b/Apps/GpsViewer/main/Source/core/Settings.h
new file mode 100644
index 0000000..d9fbab1
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Settings.h
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Format.h"
+
+#include <cstddef>
+
+namespace gpsviewer {
+
+struct Settings {
+    Units units = Units::Metric;
+    CoordinateFormat coordinateFormat = CoordinateFormat::Degrees;
+    bool nightMode = false;
+};
+
+// Text format, one "key=value" per line: units=metric|imperial|nautical, coordinates=dd|dm|dms,
+// night=0|1. Unknown keys and bad values are ignored and keep the defaults.
+Settings parseSettings(const char* text);
+// Returns the number of characters written, without the NUL
+size_t serializeSettings(const Settings& settings, char* out, size_t outSize);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SunTimes.cpp b/Apps/GpsViewer/main/Source/core/SunTimes.cpp
new file mode 100644
index 0000000..555b742
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SunTimes.cpp
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "SunTimes.h"
+
+#include <cmath>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr double PI_VALUE = 3.14159265358979323846;
+constexpr double DEG = PI_VALUE / 180.0;
+
+struct SolarValues {
+    double declination; // radians
+    double equationOfTime; // minutes
+};
+
+SolarValues solarAt(double julianDay) {
+    double t = (julianDay - 2451545.0) / 36525.0;
+    double l0 = std::fmod(280.46646 + t * (36000.76983 + t * 0.0003032), 360.0);
+    double m = (357.52911 + t * (35999.05029 - 0.0001537 * t)) * DEG;
+    double e = 0.016708634 - t * (0.000042037 + 0.0000001267 * t);
+    double center = std::sin(m) * (1.914602 - t * (0.004817 + 0.000014 * t))
+        + std::sin(2 * m) * (0.019993 - 0.000101 * t)
+        + std::sin(3 * m) * 0.000289;
+    double trueLong = l0 + center;
+    double omega = (125.04 - 1934.136 * t) * DEG;
+    double apparent = (trueLong - 0.00569 - 0.00478 * std::sin(omega)) * DEG;
+    double seconds = 21.448 - t * (46.815 + t * (0.00059 - t * 0.001813));
+    double meanObliq = 23.0 + (26.0 + seconds / 60.0) / 60.0;
+    double obliq = (meanObliq + 0.00256 * std::cos(omega)) * DEG;
+    double decl = std::asin(std::sin(obliq) * std::sin(apparent));
+    double y = std::tan(obliq / 2.0);
+    y *= y;
+    double l0r = l0 * DEG;
+    double eot = y * std::sin(2 * l0r) - 2 * e * std::sin(m)
+        + 4 * e * y * std::sin(m) * std::cos(2 * l0r)
+        - 0.5 * y * y * std::sin(4 * l0r) - 1.25 * e * e * std::sin(2 * m);
+    return { decl, 4.0 * eot / DEG };
+}
+
+} // namespace
+
+long long utcToEpoch(int year, int month, int day, int hour, int minute, int second) {
+    long long y = year;
+    y -= month <= 2 ? 1 : 0;
+    long long era = (y >= 0 ? y : y - 399) / 400;
+    long long yoe = y - era * 400;
+    long long mp = (month + 9) % 12;
+    long long doy = (153 * mp + 2) / 5 + day - 1;
+    long long doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    long long days = era * 146097 + doe - 719468;
+    return days * 86400 + hour * 3600LL + minute * 60LL + second;
+}
+
+SunTimes computeSunTimes(int year, int month, int day, double latitude, double longitude) {
+    double jdMidnight = (double)utcToEpoch(year, month, day, 0, 0, 0) / 86400.0 + 2440587.5;
+    // Solar noon first guess, then evaluate again at the refined noon
+    SolarValues first = solarAt(jdMidnight + 0.5 - longitude / 360.0);
+    double noon = 720.0 - 4.0 * longitude - first.equationOfTime;
+    SolarValues s = solarAt(jdMidnight + noon / 1440.0);
+
+    double lat = latitude * DEG;
+    double cosHa = std::cos(90.833 * DEG) / (std::cos(lat) * std::cos(s.declination))
+        - std::tan(lat) * std::tan(s.declination);
+
+    SunTimes out { SunDay::Normal, 0.0, 0.0 };
+    if (cosHa > 1.0) {
+        out.day = SunDay::PolarNight;
+        return out;
+    }
+    if (cosHa < -1.0) {
+        out.day = SunDay::PolarDay;
+        return out;
+    }
+    double ha = std::acos(cosHa) / DEG;
+    // Not wrapped into 0..1440, so values may be negative or above 1440
+    out.sunriseUtcMinutes = 720.0 - 4.0 * (longitude + ha) - s.equationOfTime;
+    out.sunsetUtcMinutes = 720.0 - 4.0 * (longitude - ha) - s.equationOfTime;
+    return out;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SunTimes.h b/Apps/GpsViewer/main/Source/core/SunTimes.h
new file mode 100644
index 0000000..25f3917
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SunTimes.h
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+namespace gpsviewer {
+
+enum class SunDay {
+    Normal,
+    PolarDay,
+    PolarNight,
+};
+
+struct SunTimes {
+    SunDay day;
+    // Minutes after 00:00 UTC of the given date, can be below 0 or above 1440
+    double sunriseUtcMinutes;
+    double sunsetUtcMinutes;
+};
+
+// NOAA solar calculator algorithm, with the sun 0.833° below the horizon at rise and set
+SunTimes computeSunTimes(int year, int month, int day, double latitude, double longitude);
+
+// Seconds since 1970-01-01 00:00 UTC
+long long utcToEpoch(int year, int month, int day, int hour, int minute, int second);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/COPYING b/Apps/GpsViewer/main/Source/third_party/minmea/COPYING
new file mode 100644
index 0000000..c6c7def
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/third_party/minmea/COPYING
@@ -0,0 +1,13 @@
+        DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT b/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT
new file mode 100644
index 0000000..920d8dd
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2023 Kosma Moczek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants b/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants
new file mode 100644
index 0000000..0f784ce
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants
@@ -0,0 +1,7 @@
+At your option, if WTFPL is unacceptable for your legal department, I hereby
+explicitly grant you the right to use any the following licenses for minmea:
+
+1. MIT License
+2. LGPL-3.0 License or later
+
+See accompanying license files for full license text.
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/minmea.c b/Apps/GpsViewer/main/Source/third_party/minmea/minmea.c
new file mode 100644
index 0000000..fafbc67
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/third_party/minmea/minmea.c
@@ -0,0 +1,679 @@
+/*
+ * Copyright © 2014 Kosma Moczek <kosma@cloudyourcar.com>
+ * This program is free software. It comes without any warranty, to the extent
+ * permitted by applicable law. You can redistribute it and/or modify it under
+ * the terms of the Do What The Fuck You Want To Public License, Version 2, as
+ * published by Sam Hocevar. See the COPYING file for more details.
+ */
+
+#include "minmea.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define boolstr(s) ((s) ? "true" : "false")
+
+static int hex2int(char c)
+{
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+    return -1;
+}
+
+uint8_t minmea_checksum(const char *sentence)
+{
+    // Support senteces with or without the starting dollar sign.
+    if (*sentence == '$')
+        sentence++;
+
+    uint8_t checksum = 0x00;
+
+    // The optional checksum is an XOR of all bytes between "$" and "*".
+    while (*sentence && *sentence != '*')
+        checksum ^= *sentence++;
+
+    return checksum;
+}
+
+bool minmea_check(const char *sentence, bool strict)
+{
+    uint8_t checksum = 0x00;
+
+    // A valid sentence starts with "$".
+    if (*sentence++ != '$')
+        return false;
+
+    // The optional checksum is an XOR of all bytes between "$" and "*".
+    while (*sentence && *sentence != '*' && isprint((unsigned char) *sentence))
+        checksum ^= *sentence++;
+
+    // If checksum is present...
+    if (*sentence == '*') {
+        // Extract checksum.
+        sentence++;
+        int upper = hex2int(*sentence++);
+        if (upper == -1)
+            return false;
+        int lower = hex2int(*sentence++);
+        if (lower == -1)
+            return false;
+        int expected = upper << 4 | lower;
+
+        // Check for checksum mismatch.
+        if (checksum != expected)
+            return false;
+    } else if (strict) {
+        // Discard non-checksummed frames in strict mode.
+        return false;
+    }
+
+    // The only stuff allowed at this point is a newline.
+    while (*sentence == '\r' || *sentence == '\n') {
+        sentence++;
+    }
+    
+    if (*sentence) {
+        return false;
+    }
+
+    return true;
+}
+
+bool minmea_scan(const char *sentence, const char *format, ...)
+{
+    bool result = false;
+    bool optional = false;
+
+    if (sentence == NULL)
+        return false;
+
+    va_list ap;
+    va_start(ap, format);
+
+    const char *field = sentence;
+#define next_field() \
+    do { \
+        /* Progress to the next field. */ \
+        while (minmea_isfield(*sentence)) \
+            sentence++; \
+        /* Make sure there is a field there. */ \
+        if (*sentence == ',') { \
+            sentence++; \
+            field = sentence; \
+        } else { \
+            field = NULL; \
+        } \
+    } while (0)
+
+    while (*format) {
+        char type = *format++;
+
+        if (type == ';') {
+            // All further fields are optional.
+            optional = true;
+            continue;
+        }
+
+        if (!field && !optional) {
+            // Field requested but we ran out if input. Bail out.
+            goto parse_error;
+        }
+
+        switch (type) {
+            case 'c': { // Single character field (char).
+                char value = '\0';
+
+                if (field && minmea_isfield(*field))
+                    value = *field;
+
+                *va_arg(ap, char *) = value;
+            } break;
+
+            case 'd': { // Single character direction field (int).
+                int value = 0;
+
+                if (field && minmea_isfield(*field)) {
+                    switch (*field) {
+                        case 'N':
+                        case 'E':
+                            value = 1;
+                            break;
+                        case 'S':
+                        case 'W':
+                            value = -1;
+                            break;
+                        default:
+                            goto parse_error;
+                    }
+                }
+
+                *va_arg(ap, int *) = value;
+            } break;
+
+            case 'f': { // Fractional value with scale (struct minmea_float).
+                int sign = 0;
+                int_least32_t value = -1;
+                int_least32_t scale = 0;
+
+                if (field) {
+                    while (minmea_isfield(*field)) {
+                        if (*field == '+' && !sign && value == -1) {
+                            sign = 1;
+                        } else if (*field == '-' && !sign && value == -1) {
+                            sign = -1;
+                        } else if (isdigit((unsigned char) *field)) {
+                            int digit = *field - '0';
+                            if (value == -1)
+                                value = 0;
+                            if (value > (INT_LEAST32_MAX-digit) / 10) {
+                                /* we ran out of bits, what do we do? */
+                                if (scale) {
+                                    /* truncate extra precision */
+                                    break;
+                                } else {
+                                    /* integer overflow. bail out. */
+                                    goto parse_error;
+                                }
+                            }
+                            value = (10 * value) + digit;
+                            if (scale)
+                                scale *= 10;
+                        } else if (*field == '.' && scale == 0) {
+                            scale = 1;
+                        } else if (*field == ' ') {
+                            /* Allow spaces at the start of the field. Not NMEA
+                             * conformant, but some modules do this. */
+                            if (sign != 0 || value != -1 || scale != 0)
+                                goto parse_error;
+                        } else {
+                            goto parse_error;
+                        }
+                        field++;
+                    }
+                }
+
+                if ((sign || scale) && value == -1)
+                    goto parse_error;
+
+                if (value == -1) {
+                    /* No digits were scanned. */
+                    value = 0;
+                    scale = 0;
+                } else if (scale == 0) {
+                    /* No decimal point. */
+                    scale = 1;
+                }
+                if (sign)
+                    value *= sign;
+
+                *va_arg(ap, struct minmea_float *) = (struct minmea_float) {value, scale};
+            } break;
+
+            case 'i': { // Integer value, default 0 (int).
+                int value = 0;
+
+                if (field) {
+                    char *endptr;
+                    value = strtol(field, &endptr, 10);
+                    if (minmea_isfield(*endptr))
+                        goto parse_error;
+                }
+
+                *va_arg(ap, int *) = value;
+            } break;
+
+            case 's': { // String value (char *).
+                char *buf = va_arg(ap, char *);
+
+                if (field) {
+                    while (minmea_isfield(*field))
+                        *buf++ = *field++;
+                }
+
+                *buf = '\0';
+            } break;
+
+            case 't': { // NMEA talker+sentence identifier (char *).
+                // This field is always mandatory.
+                if (!field)
+                    goto parse_error;
+
+                if (field[0] != '$')
+                    goto parse_error;
+                for (int f=0; f<5; f++)
+                    if (!minmea_isfield(field[1+f]))
+                        goto parse_error;
+
+                char *buf = va_arg(ap, char *);
+                memcpy(buf, field+1, 5);
+                buf[5] = '\0';
+            } break;
+
+            case 'D': { // Date (int, int, int), -1 if empty.
+                struct minmea_date *date = va_arg(ap, struct minmea_date *);
+
+                int d = -1, m = -1, y = -1;
+
+                if (field && minmea_isfield(*field)) {
+                    // Always six digits.
+                    for (int f=0; f<6; f++)
+                        if (!isdigit((unsigned char) field[f]))
+                            goto parse_error;
+
+                    char dArr[] = {field[0], field[1], '\0'};
+                    char mArr[] = {field[2], field[3], '\0'};
+                    char yArr[] = {field[4], field[5], '\0'};
+                    d = strtol(dArr, NULL, 10);
+                    m = strtol(mArr, NULL, 10);
+                    y = strtol(yArr, NULL, 10);
+                }
+
+                date->day = d;
+                date->month = m;
+                date->year = y;
+            } break;
+
+            case 'T': { // Time (int, int, int, int), -1 if empty.
+                struct minmea_time *time_ = va_arg(ap, struct minmea_time *);
+
+                int h = -1, i = -1, s = -1, u = -1;
+
+                if (field && minmea_isfield(*field)) {
+                    // Minimum required: integer time.
+                    for (int f=0; f<6; f++)
+                        if (!isdigit((unsigned char) field[f]))
+                            goto parse_error;
+
+                    char hArr[] = {field[0], field[1], '\0'};
+                    char iArr[] = {field[2], field[3], '\0'};
+                    char sArr[] = {field[4], field[5], '\0'};
+                    h = strtol(hArr, NULL, 10);
+                    i = strtol(iArr, NULL, 10);
+                    s = strtol(sArr, NULL, 10);
+                    field += 6;
+
+                    // Extra: fractional time. Saved as microseconds.
+                    if (*field++ == '.') {
+                        uint32_t value = 0;
+                        uint32_t scale = 1000000LU;
+                        while (isdigit((unsigned char) *field) && scale > 1) {
+                            value = (value * 10) + (*field++ - '0');
+                            scale /= 10;
+                        }
+                        u = value * scale;
+                    } else {
+                        u = 0;
+                    }
+                }
+
+                time_->hours = h;
+                time_->minutes = i;
+                time_->seconds = s;
+                time_->microseconds = u;
+            } break;
+
+            case '_': { // Ignore the field.
+            } break;
+
+            default: { // Unknown.
+                goto parse_error;
+            }
+        }
+
+        next_field();
+    }
+
+    result = true;
+
+parse_error:
+    va_end(ap);
+    return result;
+}
+
+bool minmea_talker_id(char talker[3], const char *sentence)
+{
+    char type[6];
+    if (!minmea_scan(sentence, "t", type))
+        return false;
+
+    talker[0] = type[0];
+    talker[1] = type[1];
+    talker[2] = '\0';
+
+    return true;
+}
+
+enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict)
+{
+    if (!minmea_check(sentence, strict))
+        return MINMEA_INVALID;
+
+    char type[6];
+    if (!minmea_scan(sentence, "t", type))
+        return MINMEA_INVALID;
+
+    if (!strcmp(type+2, "GBS"))
+        return MINMEA_SENTENCE_GBS;
+    if (!strcmp(type+2, "GGA"))
+        return MINMEA_SENTENCE_GGA;
+    if (!strcmp(type+2, "GLL"))
+        return MINMEA_SENTENCE_GLL;
+    if (!strcmp(type+2, "GSA"))
+        return MINMEA_SENTENCE_GSA;
+    if (!strcmp(type+2, "GST"))
+        return MINMEA_SENTENCE_GST;
+    if (!strcmp(type+2, "GSV"))
+        return MINMEA_SENTENCE_GSV;
+    if (!strcmp(type+2, "RMC"))
+        return MINMEA_SENTENCE_RMC;
+    if (!strcmp(type+2, "VTG"))
+        return MINMEA_SENTENCE_VTG;
+    if (!strcmp(type+2, "ZDA"))
+        return MINMEA_SENTENCE_ZDA;
+
+    return MINMEA_UNKNOWN;
+}
+
+bool minmea_parse_gbs(struct minmea_sentence_gbs *frame, const char *sentence)
+{
+    // $GNGBS,170556.00,3.0,2.9,8.3,,,,*5C
+    char type[6];
+    if (!minmea_scan(sentence, "tTfffifff",
+            type,
+            &frame->time,
+            &frame->err_latitude,
+            &frame->err_longitude,
+            &frame->err_altitude,
+            &frame->svid,
+            &frame->prob,
+            &frame->bias,
+            &frame->stddev
+            ))
+        return false;
+    if (strcmp(type+2, "GBS"))
+        return false;
+
+    return true;
+}
+
+bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence)
+{
+    // $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
+    char type[6];
+    char validity;
+    int latitude_direction;
+    int longitude_direction;
+    int variation_direction;
+    if (!minmea_scan(sentence, "tTcfdfdffDfd",
+            type,
+            &frame->time,
+            &validity,
+            &frame->latitude, &latitude_direction,
+            &frame->longitude, &longitude_direction,
+            &frame->speed,
+            &frame->course,
+            &frame->date,
+            &frame->variation, &variation_direction))
+        return false;
+    if (strcmp(type+2, "RMC"))
+        return false;
+
+    frame->valid = (validity == 'A');
+    frame->latitude.value *= latitude_direction;
+    frame->longitude.value *= longitude_direction;
+    frame->variation.value *= variation_direction;
+
+    return true;
+}
+
+bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence)
+{
+    // $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47
+    char type[6];
+    int latitude_direction;
+    int longitude_direction;
+
+    if (!minmea_scan(sentence, "tTfdfdiiffcfcf_",
+            type,
+            &frame->time,
+            &frame->latitude, &latitude_direction,
+            &frame->longitude, &longitude_direction,
+            &frame->fix_quality,
+            &frame->satellites_tracked,
+            &frame->hdop,
+            &frame->altitude, &frame->altitude_units,
+            &frame->height, &frame->height_units,
+            &frame->dgps_age))
+        return false;
+    if (strcmp(type+2, "GGA"))
+        return false;
+
+    frame->latitude.value *= latitude_direction;
+    frame->longitude.value *= longitude_direction;
+
+    return true;
+}
+
+bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence)
+{
+    // $GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39
+    char type[6];
+
+    if (!minmea_scan(sentence, "tciiiiiiiiiiiiifff",
+            type,
+            &frame->mode,
+            &frame->fix_type,
+            &frame->sats[0],
+            &frame->sats[1],
+            &frame->sats[2],
+            &frame->sats[3],
+            &frame->sats[4],
+            &frame->sats[5],
+            &frame->sats[6],
+            &frame->sats[7],
+            &frame->sats[8],
+            &frame->sats[9],
+            &frame->sats[10],
+            &frame->sats[11],
+            &frame->pdop,
+            &frame->hdop,
+            &frame->vdop))
+        return false;
+    if (strcmp(type+2, "GSA"))
+        return false;
+
+    return true;
+}
+
+bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence)
+{
+    // $GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41$;
+    char type[6];
+    int latitude_direction;
+    int longitude_direction;
+
+    if (!minmea_scan(sentence, "tfdfdTc;c",
+            type,
+            &frame->latitude, &latitude_direction,
+            &frame->longitude, &longitude_direction,
+            &frame->time,
+            &frame->status,
+            &frame->mode))
+        return false;
+    if (strcmp(type+2, "GLL"))
+        return false;
+
+    frame->latitude.value *= latitude_direction;
+    frame->longitude.value *= longitude_direction;
+
+    return true;
+}
+
+bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence)
+{
+    // $GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58
+    char type[6];
+
+    if (!minmea_scan(sentence, "tTfffffff",
+            type,
+            &frame->time,
+            &frame->rms_deviation,
+            &frame->semi_major_deviation,
+            &frame->semi_minor_deviation,
+            &frame->semi_major_orientation,
+            &frame->latitude_error_deviation,
+            &frame->longitude_error_deviation,
+            &frame->altitude_error_deviation))
+        return false;
+    if (strcmp(type+2, "GST"))
+        return false;
+
+    return true;
+}
+
+bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence)
+{
+    // $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74
+    // $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D
+    // $GPGSV,4,2,11,08,51,203,30,09,45,215,28*75
+    // $GPGSV,4,4,13,39,31,170,27*40
+    // $GPGSV,4,4,13*7B
+    char type[6];
+
+    if (!minmea_scan(sentence, "tiii;iiiiiiiiiiiiiiii",
+            type,
+            &frame->total_msgs,
+            &frame->msg_nr,
+            &frame->total_sats,
+            &frame->sats[0].nr,
+            &frame->sats[0].elevation,
+            &frame->sats[0].azimuth,
+            &frame->sats[0].snr,
+            &frame->sats[1].nr,
+            &frame->sats[1].elevation,
+            &frame->sats[1].azimuth,
+            &frame->sats[1].snr,
+            &frame->sats[2].nr,
+            &frame->sats[2].elevation,
+            &frame->sats[2].azimuth,
+            &frame->sats[2].snr,
+            &frame->sats[3].nr,
+            &frame->sats[3].elevation,
+            &frame->sats[3].azimuth,
+            &frame->sats[3].snr
+            )) {
+        return false;
+    }
+    if (strcmp(type+2, "GSV"))
+        return false;
+
+    return true;
+}
+
+bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence)
+{
+    // $GPVTG,054.7,T,034.4,M,005.5,N,010.2,K*48
+    // $GPVTG,156.1,T,140.9,M,0.0,N,0.0,K*41
+    // $GPVTG,096.5,T,083.5,M,0.0,N,0.0,K,D*22
+    // $GPVTG,188.36,T,,M,0.820,N,1.519,K,A*3F
+    char type[6];
+    char c_true, c_magnetic, c_knots, c_kph, c_faa_mode;
+
+    if (!minmea_scan(sentence, "t;fcfcfcfcc",
+            type,
+            &frame->true_track_degrees,
+            &c_true,
+            &frame->magnetic_track_degrees,
+            &c_magnetic,
+            &frame->speed_knots,
+            &c_knots,
+            &frame->speed_kph,
+            &c_kph,
+            &c_faa_mode))
+        return false;
+    if (strcmp(type+2, "VTG"))
+        return false;
+    // values are only valid with the accompanying characters
+    if (c_true != 'T')
+        frame->true_track_degrees.scale = 0;
+    if (c_magnetic != 'M')
+        frame->magnetic_track_degrees.scale = 0;
+    if (c_knots != 'N')
+        frame->speed_knots.scale = 0;
+    if (c_kph != 'K')
+        frame->speed_kph.scale = 0;
+    frame->faa_mode = (enum minmea_faa_mode)c_faa_mode;
+
+    return true;
+}
+
+bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence)
+{
+  // $GPZDA,201530.00,04,07,2002,00,00*60
+  char type[6];
+
+  if(!minmea_scan(sentence, "tTiiiii",
+          type,
+          &frame->time,
+          &frame->date.day,
+          &frame->date.month,
+          &frame->date.year,
+          &frame->hour_offset,
+          &frame->minute_offset))
+      return false;
+  if (strcmp(type+2, "ZDA"))
+      return false;
+
+  // check offsets
+  if (abs(frame->hour_offset) > 13 ||
+      frame->minute_offset > 59 ||
+      frame->minute_offset < 0)
+      return false;
+
+  return true;
+}
+
+int minmea_getdatetime(struct tm *tm, const struct minmea_date *date, const struct minmea_time *time_)
+{
+    if (date->year == -1 || time_->hours == -1)
+        return -1;
+
+    memset(tm, 0, sizeof(*tm));
+    if (date->year < 80) {
+        tm->tm_year = 2000 + date->year - 1900; // 2000-2079
+    } else if (date->year >= 1900) {
+        tm->tm_year = date->year - 1900;        // 4 digit year, use directly
+    } else {
+        tm->tm_year = date->year;               // 1980-1999
+    }
+    tm->tm_mon = date->month - 1;
+    tm->tm_mday = date->day;
+    tm->tm_hour = time_->hours;
+    tm->tm_min = time_->minutes;
+    tm->tm_sec = time_->seconds;
+
+    return 0;
+}
+
+int minmea_gettime(struct timespec *ts, const struct minmea_date *date, const struct minmea_time *time_)
+{
+    struct tm tm;
+    if (minmea_getdatetime(&tm, date, time_))
+        return -1;
+
+    time_t timestamp = mktime(&tm); /* See README.md if your system lacks timegm(). */
+    if (timestamp != (time_t)-1) {
+        ts->tv_sec = timestamp;
+        ts->tv_nsec = time_->microseconds * 1000;
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+/* vim: set ts=4 sw=4 et: */
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/minmea.h b/Apps/GpsViewer/main/Source/third_party/minmea/minmea.h
new file mode 100644
index 0000000..494b218
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/third_party/minmea/minmea.h
@@ -0,0 +1,295 @@
+/*
+ * Copyright © 2014 Kosma Moczek <kosma@cloudyourcar.com>
+ * This program is free software. It comes without any warranty, to the extent
+ * permitted by applicable law. You can redistribute it and/or modify it under
+ * the terms of the Do What The Fuck You Want To Public License, Version 2, as
+ * published by Sam Hocevar. See the COPYING file for more details.
+ */
+
+#ifndef MINMEA_H
+#define MINMEA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <ctype.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <time.h>
+#include <math.h>
+#ifdef MINMEA_INCLUDE_COMPAT
+#include <minmea_compat.h>
+#endif
+
+#ifndef MINMEA_MAX_SENTENCE_LENGTH
+#define MINMEA_MAX_SENTENCE_LENGTH 80
+#endif
+
+enum minmea_sentence_id {
+    MINMEA_INVALID = -1,
+    MINMEA_UNKNOWN = 0,
+    MINMEA_SENTENCE_GBS,
+    MINMEA_SENTENCE_GGA,
+    MINMEA_SENTENCE_GLL,
+    MINMEA_SENTENCE_GSA,
+    MINMEA_SENTENCE_GST,
+    MINMEA_SENTENCE_GSV,
+    MINMEA_SENTENCE_RMC,
+    MINMEA_SENTENCE_VTG,
+    MINMEA_SENTENCE_ZDA,
+};
+
+struct minmea_float {
+    int_least32_t value;
+    int_least32_t scale;
+};
+
+struct minmea_date {
+    int day;
+    int month;
+    int year;
+};
+
+struct minmea_time {
+    int hours;
+    int minutes;
+    int seconds;
+    int microseconds;
+};
+
+struct minmea_sentence_gbs {
+    struct minmea_time time;
+    struct minmea_float err_latitude;
+    struct minmea_float err_longitude;
+    struct minmea_float err_altitude;
+    int svid;
+    struct minmea_float prob;
+    struct minmea_float bias;
+    struct minmea_float stddev;
+};
+
+struct minmea_sentence_rmc {
+    struct minmea_time time;
+    bool valid;
+    struct minmea_float latitude;
+    struct minmea_float longitude;
+    struct minmea_float speed;
+    struct minmea_float course;
+    struct minmea_date date;
+    struct minmea_float variation;
+};
+
+struct minmea_sentence_gga {
+    struct minmea_time time;
+    struct minmea_float latitude;
+    struct minmea_float longitude;
+    int fix_quality;
+    int satellites_tracked;
+    struct minmea_float hdop;
+    struct minmea_float altitude; char altitude_units;
+    struct minmea_float height; char height_units;
+    struct minmea_float dgps_age;
+};
+
+enum minmea_gll_status {
+    MINMEA_GLL_STATUS_DATA_VALID = 'A',
+    MINMEA_GLL_STATUS_DATA_NOT_VALID = 'V',
+};
+
+// FAA mode added to some fields in NMEA 2.3.
+enum minmea_faa_mode {
+    MINMEA_FAA_MODE_AUTONOMOUS = 'A',
+    MINMEA_FAA_MODE_DIFFERENTIAL = 'D',
+    MINMEA_FAA_MODE_ESTIMATED = 'E',
+    MINMEA_FAA_MODE_MANUAL = 'M',
+    MINMEA_FAA_MODE_SIMULATED = 'S',
+    MINMEA_FAA_MODE_NOT_VALID = 'N',
+    MINMEA_FAA_MODE_PRECISE = 'P',
+};
+
+struct minmea_sentence_gll {
+    struct minmea_float latitude;
+    struct minmea_float longitude;
+    struct minmea_time time;
+    char status;
+    char mode;
+};
+
+struct minmea_sentence_gst {
+    struct minmea_time time;
+    struct minmea_float rms_deviation;
+    struct minmea_float semi_major_deviation;
+    struct minmea_float semi_minor_deviation;
+    struct minmea_float semi_major_orientation;
+    struct minmea_float latitude_error_deviation;
+    struct minmea_float longitude_error_deviation;
+    struct minmea_float altitude_error_deviation;
+};
+
+enum minmea_gsa_mode {
+    MINMEA_GPGSA_MODE_AUTO = 'A',
+    MINMEA_GPGSA_MODE_FORCED = 'M',
+};
+
+enum minmea_gsa_fix_type {
+    MINMEA_GPGSA_FIX_NONE = 1,
+    MINMEA_GPGSA_FIX_2D = 2,
+    MINMEA_GPGSA_FIX_3D = 3,
+};
+
+struct minmea_sentence_gsa {
+    char mode;
+    int fix_type;
+    int sats[12];
+    struct minmea_float pdop;
+    struct minmea_float hdop;
+    struct minmea_float vdop;
+};
+
+struct minmea_sat_info {
+    int nr;
+    int elevation;
+    int azimuth;
+    int snr;
+};
+
+struct minmea_sentence_gsv {
+    int total_msgs;
+    int msg_nr;
+    int total_sats;
+    struct minmea_sat_info sats[4];
+};
+
+struct minmea_sentence_vtg {
+    struct minmea_float true_track_degrees;
+    struct minmea_float magnetic_track_degrees;
+    struct minmea_float speed_knots;
+    struct minmea_float speed_kph;
+    enum minmea_faa_mode faa_mode;
+};
+
+struct minmea_sentence_zda {
+    struct minmea_time time;
+    struct minmea_date date;
+    int hour_offset;
+    int minute_offset;
+};
+
+/**
+ * Calculate raw sentence checksum. Does not check sentence integrity.
+ */
+uint8_t minmea_checksum(const char *sentence);
+
+/**
+ * Check sentence validity and checksum. Returns true for valid sentences.
+ */
+bool minmea_check(const char *sentence, bool strict);
+
+/**
+ * Determine talker identifier.
+ */
+bool minmea_talker_id(char talker[3], const char *sentence);
+
+/**
+ * Determine sentence identifier.
+ */
+enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict);
+
+/**
+ * Scanf-like processor for NMEA sentences. Supports the following formats:
+ * c - single character (char *)
+ * d - direction, returned as 1/-1, default 0 (int *)
+ * f - fractional, returned as value + scale (struct minmea_float *)
+ * i - decimal, default zero (int *)
+ * s - string (char *)
+ * t - talker identifier and type (char *)
+ * D - date (struct minmea_date *)
+ * T - time stamp (struct minmea_time *)
+ * _ - ignore this field
+ * ; - following fields are optional
+ * Returns true on success. See library source code for details.
+ */
+bool minmea_scan(const char *sentence, const char *format, ...);
+
+/*
+ * Parse a specific type of sentence. Return true on success.
+ */
+bool minmea_parse_gbs(struct minmea_sentence_gbs *frame, const char *sentence);
+bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence);
+bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence);
+bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence);
+bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence);
+bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence);
+bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence);
+bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence);
+bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence);
+
+/**
+ * Convert GPS UTC date/time representation to a UNIX calendar time.
+ */
+int minmea_getdatetime(struct tm *tm, const struct minmea_date *date, const struct minmea_time *time_);
+
+/**
+ * Convert GPS UTC date/time representation to a UNIX timestamp.
+ */
+int minmea_gettime(struct timespec *ts, const struct minmea_date *date, const struct minmea_time *time_);
+
+/**
+ * Rescale a fixed-point value to a different scale. Rounds towards zero.
+ */
+static inline int_least32_t minmea_rescale(const struct minmea_float *f, int_least32_t new_scale)
+{
+    if (f->scale == 0)
+        return 0;
+    if (f->scale == new_scale)
+        return f->value;
+    if (f->scale > new_scale)
+        return (f->value + ((f->value > 0) - (f->value < 0)) * f->scale/new_scale/2) / (f->scale/new_scale);
+    else
+        return f->value * (new_scale/f->scale);
+}
+
+/**
+ * Convert a fixed-point value to a floating-point value.
+ * Returns NaN for "unknown" values.
+ */
+static inline float minmea_tofloat(const struct minmea_float *f)
+{
+    if (f->scale == 0)
+        return NAN;
+    return (float) f->value / (float) f->scale;
+}
+
+/**
+ * Convert a raw coordinate to a floating point DD.DDD... value.
+ * Returns NaN for "unknown" values.
+ */
+static inline float minmea_tocoord(const struct minmea_float *f)
+{
+    if (f->scale == 0)
+        return NAN;
+    if (f->scale  > (INT_LEAST32_MAX / 100))
+        return NAN;
+    if (f->scale < (INT_LEAST32_MIN / 100))
+        return NAN;
+    int_least32_t degrees = f->value / (f->scale * 100);
+    int_least32_t minutes = f->value % (f->scale * 100);
+    return (float) degrees + (float) minutes / (60 * f->scale);
+}
+
+/**
+ * Check whether a character belongs to the set of characters allowed in a
+ * sentence data field.
+ */
+static inline bool minmea_isfield(char c) {
+    return isprint((unsigned char) c) && c != ',' && c != '*';
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MINMEA_H */
+
+/* vim: set ts=4 sw=4 et: */
diff --git a/Apps/GpsViewer/manifest.properties b/Apps/GpsViewer/manifest.properties
new file mode 100644
index 0000000..d2787d6
--- /dev/null
+++ b/Apps/GpsViewer/manifest.properties
@@ -0,0 +1,11 @@
+manifest.version=0.3
+target.sdk=0.8.0-dev
+target.platforms=esp32,esp32s3,esp32c6,esp32p4
+id=tactility.gpsviewer
+version.name=0.1.0
+version.code=1
+app.0.id=tactility.gpsviewer
+app.0.name=GPS Viewer
+app.0.binary=gpsviewer
+name=GPS Viewer
+description=GNSS receiver status: fix, satellites, signal, sky plot, position and time

From 8333f7209efcb63337fac39c4795a6a012a939dc Mon Sep 17 00:00:00 2001
From: AdaSzi115026 <81822538+AdaSzi@users.noreply.github.com>
Date: Sat, 7 Nov 2026 19:16:18 +0100
Subject: [PATCH 2/3] GPS Viewer: controls updates and other updates

---
 Apps/GpsViewer/README.md                      |  20 +-
 Apps/GpsViewer/THIRD_PARTY.md                 |   1 -
 Apps/GpsViewer/docs/night.png                 | Bin 6342 -> 0 bytes
 Apps/GpsViewer/docs/position.png              | Bin 6476 -> 0 bytes
 Apps/GpsViewer/docs/signal.png                | Bin 5037 -> 0 bytes
 Apps/GpsViewer/docs/sky.png                   | Bin 22206 -> 0 bytes
 Apps/GpsViewer/docs/status.png                | Bin 5697 -> 0 bytes
 Apps/GpsViewer/main/Source/app/AppContext.h   |   2 -
 Apps/GpsViewer/main/Source/app/Main.cpp       |  23 +-
 Apps/GpsViewer/main/Source/app/Sources.cpp    |   6 +-
 Apps/GpsViewer/main/Source/app/Sources.h      |   4 +-
 Apps/GpsViewer/main/Source/app/Ui.cpp         |  75 +-
 .../main/Source/third_party/minmea/COPYING    |  13 -
 .../Source/third_party/minmea/LICENSE.MIT     |   9 -
 .../Source/third_party/minmea/LICENSE.grants  |   7 -
 .../main/Source/third_party/minmea/minmea.c   | 679 ------------------
 .../main/Source/third_party/minmea/minmea.h   | 295 --------
 Apps/GpsViewer/manifest.properties            |   2 +-
 18 files changed, 89 insertions(+), 1047 deletions(-)
 delete mode 100644 Apps/GpsViewer/docs/night.png
 delete mode 100644 Apps/GpsViewer/docs/position.png
 delete mode 100644 Apps/GpsViewer/docs/signal.png
 delete mode 100644 Apps/GpsViewer/docs/sky.png
 delete mode 100644 Apps/GpsViewer/docs/status.png
 delete mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/COPYING
 delete mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT
 delete mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants
 delete mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/minmea.c
 delete mode 100644 Apps/GpsViewer/main/Source/third_party/minmea/minmea.h

diff --git a/Apps/GpsViewer/README.md b/Apps/GpsViewer/README.md
index 85f9ac0..05df3ee 100644
--- a/Apps/GpsViewer/README.md
+++ b/Apps/GpsViewer/README.md
@@ -60,14 +60,17 @@ Tactility's location settings.
 | To… | Keyboard | Trackball (keypad mode) | Trackball (pointer mode) | Touch |
 | --- | --- | --- | --- | --- |
 | Next / previous tab | Left / Right arrows, `.` / `,` or Space | Roll left / right | Click the tab name | Swipe left / right, or tap the tab name |
-| Scroll the Signal bars | Left / Right (at the ends, Left / Right change the tab) | Roll left / right | Click and drag the bars | Drag the bars |
+| Scroll the Signal bars | Enter on the Signal tab, then Left / Right. Enter or Esc to switch tabs again | Click on the Signal tab, then roll left / right. Click to switch tabs again | Click and drag the bars | Drag the bars |
 | Jump to a tab | `1`-`4` | — | Click the tab name | Tap the tab name |
-| Open the action menu | Enter | Click | Click the ⋮ button | Tap the ⋮ button in the toolbar |
+| Select a tab from the tab row | Move the focus to the tab row, Left / Right, Enter. The Signal tab then scrolls its bars | Roll up to the tab row, roll left / right, click. The Signal tab then scrolls its bars | Click the tab name | Tap the tab name |
+| Open the action menu | Enter (`m` on the Signal tab) | Click (the ⋮ button on the Signal tab) | Click the ⋮ button | Tap the ⋮ button in the toolbar |
 | Move in menus and settings | Up / Down or Left / Right | Roll | Click the row | Tap the row |
 | Select in menus and settings | Enter | Click | Click the row | Tap the row |
 | Close a menu or settings | Esc or Backspace | Select "< Back" | Click "< Back" | Tap "< Back" |
 | Close the app | — | Select the X button | Click the X button | Tap the X button in the toolbar |
 
+An encoder steps through the toolbar buttons, the tabs and the content, and its button selects.
+
 The keys `n` (night mode), `r` (reset max/average speed), `s` (settings) and `l` (start or stop recording)
 work from the keyboard. `m` opens the menu. These actions are also in the menu.
 
@@ -95,18 +98,6 @@ seconds. Recording stops with "Stop recording" and when the app closes.
 Sentences are written back from the parsed values: RMC, GGA, GSA and GSV with their checksums. Other
 sentences and fields the app does not use are not saved. The logs are plain NMEA 0183, for use in other tools.
 
-## Screenshots
-
-![Status tab](docs/status.png)
-
-![Signal tab](docs/signal.png)
-
-![Sky tab](docs/sky.png)
-
-![Position tab](docs/position.png)
-
-![Night mode](docs/night.png)
-
 ## Testing
 
 Tested on a LilyGO T-Deck with a Quectel L76K on the Grove port (GPS, GLONASS and BeiDou), outdoors and by a
@@ -122,7 +113,6 @@ parsed again. The satellite database, NMEA writer, settings and formatting have
   GPS settings, the driver first tries other receiver types, which took about 4.4 s for the L76K. Choosing the
   model in the GPS settings skips that.
 - Fonts are Tactility's three text sizes: there is no bold font.
-- The "Open settings" message was not tested on the device: it needs a missing receiver or location turned off.
 
 ## Building
 
diff --git a/Apps/GpsViewer/THIRD_PARTY.md b/Apps/GpsViewer/THIRD_PARTY.md
index a036143..a92fd50 100644
--- a/Apps/GpsViewer/THIRD_PARTY.md
+++ b/Apps/GpsViewer/THIRD_PARTY.md
@@ -2,5 +2,4 @@
 
 | Component | Where | Licence | Notes |
 |---|---|---|---|
-| minmea by Kosma Moczek | `main/Source/third_party/minmea/` (`minmea.c`, `minmea.h`) | MIT, from the licence grant in `LICENSE.grants` | The files are WTFPL (see `COPYING`), which grants the right to use MIT or LGPL-3.0-or-later instead. The MIT text is in `LICENSE.MIT`. The copy comes from Tactility's `Libraries/minmea`. |
 | NOAA solar calculator equations | `main/Source/core/SunTimes.cpp` | Public domain (US government work) | From the NOAA Global Monitoring Laboratory solar calculator. Used for sunrise and sunset. |
diff --git a/Apps/GpsViewer/docs/night.png b/Apps/GpsViewer/docs/night.png
deleted file mode 100644
index 272253599c6428fd1bc146ec2386dcf19423be09..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6342
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

diff --git a/Apps/GpsViewer/docs/position.png b/Apps/GpsViewer/docs/position.png
deleted file mode 100644
index a95ac48467eb805efc6d4fa7b173a22cec851630..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6476
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
Mb$vvws$I<g0>fMVkN^Mx

diff --git a/Apps/GpsViewer/docs/signal.png b/Apps/GpsViewer/docs/signal.png
deleted file mode 100644
index 0643c8cd4a2dda2262d42d6201281b66ef5cfc27..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5037
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

diff --git a/Apps/GpsViewer/docs/sky.png b/Apps/GpsViewer/docs/sky.png
deleted file mode 100644
index e062d59d2187121df85a41625a7362ed7df25e19..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 22206
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

diff --git a/Apps/GpsViewer/docs/status.png b/Apps/GpsViewer/docs/status.png
deleted file mode 100644
index 7f75f583470f7de9fa45208f7ee3b405c029190f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5697
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

diff --git a/Apps/GpsViewer/main/Source/app/AppContext.h b/Apps/GpsViewer/main/Source/app/AppContext.h
index b9b4080..f0ce97c 100644
--- a/Apps/GpsViewer/main/Source/app/AppContext.h
+++ b/Apps/GpsViewer/main/Source/app/AppContext.h
@@ -58,8 +58,6 @@ struct AppContext {
     UiState* ui = nullptr;
 };
 
-uint32_t nowMs();
-
 class ContextLock {
 public:
     explicit ContextLock(AppContext& context) : context(context) { xSemaphoreTake(context.mutex, portMAX_DELAY); }
diff --git a/Apps/GpsViewer/main/Source/app/Main.cpp b/Apps/GpsViewer/main/Source/app/Main.cpp
index 2bb289e..e1204d1 100644
--- a/Apps/GpsViewer/main/Source/app/Main.cpp
+++ b/Apps/GpsViewer/main/Source/app/Main.cpp
@@ -8,13 +8,14 @@
 #include <app/scheduler.h>
 #include <app/start.h>
 #include <lvgl_window_manager/window_manager.h>
+#include <tactility/Memory.hpp>
 #include <tactility/check.h>
+#include <tactility/time.h>
 
 #include <freertos/task.h>
 #include <sys/stat.h>
 
 #include <cstdio>
-#include <new>
 
 namespace gpsviewer {
 
@@ -105,13 +106,14 @@ void run(AppContext& context, Sources& sources) {
                     ContextLock lock(context);
                     utc = context.model.utc();
                 }
-                recorder.start(context.dataDirectory, utc, nowMs());
+                recorder.start(context.dataDirectory, utc, get_millis());
             }
         }
         if ((requests & REQUEST_OPEN_LOCATION_SETTINGS) != 0) {
             struct AppStartContext start {};
             if (app_start_context_from_id("tactility.locationsettings", &start) == ERROR_NONE) {
-                app_start_with_context(&start, nullptr);
+                AppInstanceId instanceId;
+                app_start_with_context(&start, &instanceId);
             }
         }
         if ((requests & REQUEST_RESET_SPEED) != 0) {
@@ -129,10 +131,6 @@ void run(AppContext& context, Sources& sources) {
 
 } // namespace
 
-uint32_t nowMs() {
-    return static_cast<uint32_t>(pdTICKS_TO_MS(xTaskGetTickCount()));
-}
-
 } // namespace gpsviewer
 
 extern "C" int main(int argc, char* argv[]) {
@@ -140,7 +138,8 @@ extern "C" int main(int argc, char* argv[]) {
     (void)argv;
     using namespace gpsviewer;
 
-    auto* context = new (std::nothrow) AppContext();
+    // The app state is large, so it goes to external memory when there is some
+    auto* context = tt::newObject<AppContext>();
     if (context == nullptr) {
         return 0;
     }
@@ -152,17 +151,17 @@ extern "C" int main(int argc, char* argv[]) {
     context->ui = uiAllocate(*context);
     if (context->mutex != nullptr && context->ui != nullptr) {
         context->settings = loadSettings(*context);
-        context->model.reset(nowMs());
-        auto* sources = new (std::nothrow) Sources();
+        context->model.reset(get_millis());
+        auto* sources = tt::newObject<Sources>();
         if (sources != nullptr) {
             run(*context, *sources);
-            delete sources;
+            tt::deleteObject(sources);
         }
     }
     uiFree(context->ui);
     if (context->mutex != nullptr) {
         vSemaphoreDelete(context->mutex);
     }
-    delete context;
+    tt::deleteObject(context);
     return 0;
 }
diff --git a/Apps/GpsViewer/main/Source/app/Sources.cpp b/Apps/GpsViewer/main/Source/app/Sources.cpp
index 7ddbaaf..ba4a864 100644
--- a/Apps/GpsViewer/main/Source/app/Sources.cpp
+++ b/Apps/GpsViewer/main/Source/app/Sources.cpp
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 #include "Sources.h"
 
+#include <tactility/time.h>
+
 #include <cstring>
 
 namespace gpsviewer {
@@ -121,7 +123,7 @@ void GpsSource::disconnect() {
 void GpsSource::readerLoop() {
     while (!stopRequested.load()) {
         if (!subscribed) {
-            tryConnect(nowMs());
+            tryConnect(get_millis());
             if (!subscribed) {
                 vTaskDelay(pdMS_TO_TICKS(READER_IDLE_MS));
                 continue;
@@ -187,7 +189,7 @@ void GpsSource::poll(AppContext& appContext, uint32_t timeoutMs, Recorder& recor
     if (xQueueReceive(queue, &event, pdMS_TO_TICKS(timeoutMs)) != pdTRUE) {
         return;
     }
-    const uint32_t now = nowMs();
+    const uint32_t now = get_millis();
     int handled = 0;
     do {
         {
diff --git a/Apps/GpsViewer/main/Source/app/Sources.h b/Apps/GpsViewer/main/Source/app/Sources.h
index 8a94a0d..47e2974 100644
--- a/Apps/GpsViewer/main/Source/app/Sources.h
+++ b/Apps/GpsViewer/main/Source/app/Sources.h
@@ -16,9 +16,7 @@
 namespace gpsviewer {
 
 // Live data from the first started GPS_TYPE device.
-// A GPS subscription holds only the latest event, and the driver's thread runs at a high priority.
-// So a reader task with a higher priority copies every event into a queue right away, otherwise
-// the parts of a GSV set get overwritten before they are read. The app task drains the queue.
+// A reader task waits for the GPS events and copies them into a queue, which the app task drains.
 class GpsSource {
 public:
     // Subscribes to the location service, which starts the receiver and shows the location icon,
diff --git a/Apps/GpsViewer/main/Source/app/Ui.cpp b/Apps/GpsViewer/main/Source/app/Ui.cpp
index 51f8be1..c831684 100644
--- a/Apps/GpsViewer/main/Source/app/Ui.cpp
+++ b/Apps/GpsViewer/main/Source/app/Ui.cpp
@@ -5,13 +5,15 @@
 
 #include <app/event.h>
 #include <lvgl/fonts.h>
+#include <lvgl/grid_navigation.h>
 #include <lvgl/icons/shared.h>
 #include <lvgl/widgets/toolbar.h>
+#include <tactility/Memory.hpp>
+#include <tactility/time.h>
 
 #include <cmath>
 #include <cstdio>
 #include <cstring>
-#include <new>
 
 namespace gpsviewer {
 
@@ -76,6 +78,8 @@ struct UiState {
     lv_timer_t* timer = nullptr;
     Overlay overlayType = Overlay::None;
     int activeTab = 0;
+    // Left and Right scroll the Signal bars instead of switching tabs
+    bool signalScrolling = false;
     bool rebuildPending = false;
     SourceStatus status = SourceStatus::NoReceiver;
     char receiverName[32] = "";
@@ -148,8 +152,25 @@ void styleTabButtons(UiState& ui) {
     }
 }
 
+// The content area gets an outline while the keys scroll the Signal bars
+void setSignalScrolling(UiState& ui, bool scrolling) {
+    ui.signalScrolling = scrolling;
+    if (ui.content == nullptr) {
+        return;
+    }
+    const int32_t width = scrolling ? 2 : 0;
+    for (const lv_style_selector_t state : { LV_STATE_DEFAULT, LV_STATE_FOCUSED, LV_STATE_FOCUS_KEY }) {
+        lv_obj_set_style_outline_color(ui.content, ui.theme.accent, state);
+        lv_obj_set_style_outline_width(ui.content, width, state);
+        lv_obj_set_style_outline_pad(ui.content, -2, state);
+    }
+}
+
 void setTab(UiState& ui, int tab) {
     ui.activeTab = (tab + TAB_COUNT) % TAB_COUNT;
+    if (ui.activeTab != TAB_SIGNAL && ui.signalScrolling) {
+        setSignalScrolling(ui, false);
+    }
     styleTabButtons(ui);
     refresh(ui);
 }
@@ -383,18 +404,29 @@ void onMenuButton(lv_event_t* event) {
     openMenu(*static_cast<UiState*>(lv_event_get_user_data(event)));
 }
 
+bool isKeyInput() {
+    lv_indev_t* indev = lv_indev_active();
+    return indev != nullptr && lv_indev_get_type(indev) != LV_INDEV_TYPE_POINTER;
+}
+
+// Selecting the Signal tab with keys moves the keys to its bars, as Left and Right on the tab row only move the focus
 void onTabButton(lv_event_t* event) {
     auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
     lv_obj_t* button = lv_event_get_current_target_obj(event);
     for (int i = 0; i < TAB_COUNT; i++) {
         if (ui->tabButtons[i] == button) {
             setTab(*ui, i);
+            if (i == TAB_SIGNAL && isKeyInput() && !ui->messageCard.shown()) {
+                lv_group_focus_obj(ui->content);
+                setSignalScrolling(*ui, true);
+            }
         }
     }
 }
 
 void moveTab(UiState& ui, int direction) {
-    if (ui.activeTab == TAB_SIGNAL && ui.signalTab.scroll(direction)) {
+    if (ui.signalScrolling) {
+        ui.signalTab.scroll(direction);
         return;
     }
     setTab(ui, ui.activeTab + direction);
@@ -406,6 +438,12 @@ void onContentKey(lv_event_t* event) {
     auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
     const uint32_t key = lv_event_get_key(event);
     switch (key) {
+        case LV_KEY_ESC:
+        case LV_KEY_BACKSPACE:
+            if (ui->signalScrolling) {
+                setSignalScrolling(*ui, false);
+            }
+            break;
         case LV_KEY_LEFT:
         case ',':
             moveTab(*ui, -1);
@@ -447,15 +485,26 @@ void onContentKey(lv_event_t* event) {
 }
 
 // Enter from a keyboard, trackball or encoder opens the menu. Taps on the content don't.
+// Enter opens the action menu, and on the Signal tab it switches between scrolling the bars and switching tabs
 void onContentClicked(lv_event_t* event) {
     auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
-    lv_indev_t* indev = lv_indev_active();
-    if (indev == nullptr || lv_indev_get_type(indev) == LV_INDEV_TYPE_POINTER) {
+    if (!isKeyInput()) {
+        return;
+    }
+    if (ui->activeTab == TAB_SIGNAL && !ui->messageCard.shown()) {
+        setSignalScrolling(*ui, !ui->signalScrolling);
         return;
     }
     openMenu(*ui);
 }
 
+void onContentDefocused(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    if (ui->signalScrolling) {
+        setSignalScrolling(*ui, false);
+    }
+}
+
 void onContentGesture(lv_event_t* event) {
     auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
     lv_indev_t* indev = lv_indev_active();
@@ -518,6 +567,7 @@ void forgetWidgets(UiState& ui) {
     ui.headerBadge = nullptr;
     ui.badgeColor = 0;
     ui.content = nullptr;
+    ui.signalScrolling = false;
     ui.overlay = nullptr;
     ui.overlayType = Overlay::None;
     for (int i = 0; i < TAB_COUNT; i++) {
@@ -570,7 +620,8 @@ void createHeader(UiState& ui) {
     ui.badgeColor = 0;
 }
 
-// Text tabs with a 2 px line under the active one
+// Text tabs with a 2 px line under the active one. The strip is a grid navigation row, so the arrow keys and
+// encoders reach the tabs, and Enter selects the focused one.
 void createTabStrip(UiState& ui) {
     const Theme& theme = ui.theme;
     lv_obj_t* strip = createBox(ui.root);
@@ -583,6 +634,10 @@ void createTabStrip(UiState& ui) {
         lv_obj_t* button = createBox(strip);
         lv_obj_set_size(button, LV_PCT(25), LV_DPX(24));
         lv_obj_add_flag(button, LV_OBJ_FLAG_CLICKABLE);
+        lv_obj_add_flag(button, LV_OBJ_FLAG_CLICK_FOCUSABLE);
+        lv_obj_set_style_outline_color(button, theme.accent, LV_STATE_FOCUS_KEY);
+        lv_obj_set_style_outline_width(button, 2, LV_STATE_FOCUS_KEY);
+        lv_obj_set_style_outline_pad(button, -2, LV_STATE_FOCUS_KEY);
         lv_obj_remove_flag(button, LV_OBJ_FLAG_EVENT_BUBBLE);
         lv_obj_remove_flag(button, LV_OBJ_FLAG_GESTURE_BUBBLE);
         lv_obj_t* label = createLabel(button, FONT_SIZE_SMALL, theme.dim);
@@ -598,6 +653,7 @@ void createTabStrip(UiState& ui) {
         ui.tabButtons[i] = button;
         ui.tabIndicators[i] = indicator;
     }
+    lvgl_grid_navigation_add(strip);
 }
 
 void build(UiState& ui) {
@@ -633,6 +689,7 @@ void build(UiState& ui) {
     lv_obj_remove_flag(ui.content, LV_OBJ_FLAG_SCROLLABLE);
     lv_obj_add_event_cb(ui.content, onContentKey, LV_EVENT_KEY, &ui);
     lv_obj_add_event_cb(ui.content, onContentClicked, LV_EVENT_CLICKED, &ui);
+    lv_obj_add_event_cb(ui.content, onContentDefocused, LV_EVENT_DEFOCUSED, &ui);
     lv_obj_add_event_cb(ui.content, onContentGesture, LV_EVENT_GESTURE, &ui);
     lv_obj_update_layout(root);
 
@@ -666,7 +723,7 @@ void refresh(UiState& ui) {
     bool recording;
     {
         ContextLock lock(*ui.context);
-        ui.context->model.snapshot(ui.snapshot, nowMs());
+        ui.context->model.snapshot(ui.snapshot, get_millis());
         status = ui.context->status;
         memcpy(ui.receiverName, ui.context->receiverName, sizeof(ui.receiverName));
         ui.settings = ui.context->settings;
@@ -704,7 +761,7 @@ void refresh(UiState& ui) {
 } // namespace
 
 UiState* uiAllocate(AppContext& context) {
-    auto* ui = new (std::nothrow) UiState();
+    auto* ui = tt::newObject<UiState>();
     if (ui != nullptr) {
         ui->context = &context;
     }
@@ -712,7 +769,9 @@ UiState* uiAllocate(AppContext& context) {
 }
 
 void uiFree(UiState* ui) {
-    delete ui;
+    if (ui != nullptr) {
+        tt::deleteObject(ui);
+    }
 }
 
 void uiCreateWidgets(lv_obj_t* root, void* userData) {
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/COPYING b/Apps/GpsViewer/main/Source/third_party/minmea/COPYING
deleted file mode 100644
index c6c7def..0000000
--- a/Apps/GpsViewer/main/Source/third_party/minmea/COPYING
+++ /dev/null
@@ -1,13 +0,0 @@
-        DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                    Version 2, December 2004
-
- Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
-
- Everyone is permitted to copy and distribute verbatim or modified
- copies of this license document, and changing it is allowed as long
- as the name is changed.
-
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. You just DO WHAT THE FUCK YOU WANT TO.
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT b/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT
deleted file mode 100644
index 920d8dd..0000000
--- a/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.MIT
+++ /dev/null
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Kosma Moczek
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants b/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants
deleted file mode 100644
index 0f784ce..0000000
--- a/Apps/GpsViewer/main/Source/third_party/minmea/LICENSE.grants
+++ /dev/null
@@ -1,7 +0,0 @@
-At your option, if WTFPL is unacceptable for your legal department, I hereby
-explicitly grant you the right to use any the following licenses for minmea:
-
-1. MIT License
-2. LGPL-3.0 License or later
-
-See accompanying license files for full license text.
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/minmea.c b/Apps/GpsViewer/main/Source/third_party/minmea/minmea.c
deleted file mode 100644
index fafbc67..0000000
--- a/Apps/GpsViewer/main/Source/third_party/minmea/minmea.c
+++ /dev/null
@@ -1,679 +0,0 @@
-/*
- * Copyright © 2014 Kosma Moczek <kosma@cloudyourcar.com>
- * This program is free software. It comes without any warranty, to the extent
- * permitted by applicable law. You can redistribute it and/or modify it under
- * the terms of the Do What The Fuck You Want To Public License, Version 2, as
- * published by Sam Hocevar. See the COPYING file for more details.
- */
-
-#include "minmea.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-
-#define boolstr(s) ((s) ? "true" : "false")
-
-static int hex2int(char c)
-{
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    if (c >= 'A' && c <= 'F')
-        return c - 'A' + 10;
-    if (c >= 'a' && c <= 'f')
-        return c - 'a' + 10;
-    return -1;
-}
-
-uint8_t minmea_checksum(const char *sentence)
-{
-    // Support senteces with or without the starting dollar sign.
-    if (*sentence == '$')
-        sentence++;
-
-    uint8_t checksum = 0x00;
-
-    // The optional checksum is an XOR of all bytes between "$" and "*".
-    while (*sentence && *sentence != '*')
-        checksum ^= *sentence++;
-
-    return checksum;
-}
-
-bool minmea_check(const char *sentence, bool strict)
-{
-    uint8_t checksum = 0x00;
-
-    // A valid sentence starts with "$".
-    if (*sentence++ != '$')
-        return false;
-
-    // The optional checksum is an XOR of all bytes between "$" and "*".
-    while (*sentence && *sentence != '*' && isprint((unsigned char) *sentence))
-        checksum ^= *sentence++;
-
-    // If checksum is present...
-    if (*sentence == '*') {
-        // Extract checksum.
-        sentence++;
-        int upper = hex2int(*sentence++);
-        if (upper == -1)
-            return false;
-        int lower = hex2int(*sentence++);
-        if (lower == -1)
-            return false;
-        int expected = upper << 4 | lower;
-
-        // Check for checksum mismatch.
-        if (checksum != expected)
-            return false;
-    } else if (strict) {
-        // Discard non-checksummed frames in strict mode.
-        return false;
-    }
-
-    // The only stuff allowed at this point is a newline.
-    while (*sentence == '\r' || *sentence == '\n') {
-        sentence++;
-    }
-    
-    if (*sentence) {
-        return false;
-    }
-
-    return true;
-}
-
-bool minmea_scan(const char *sentence, const char *format, ...)
-{
-    bool result = false;
-    bool optional = false;
-
-    if (sentence == NULL)
-        return false;
-
-    va_list ap;
-    va_start(ap, format);
-
-    const char *field = sentence;
-#define next_field() \
-    do { \
-        /* Progress to the next field. */ \
-        while (minmea_isfield(*sentence)) \
-            sentence++; \
-        /* Make sure there is a field there. */ \
-        if (*sentence == ',') { \
-            sentence++; \
-            field = sentence; \
-        } else { \
-            field = NULL; \
-        } \
-    } while (0)
-
-    while (*format) {
-        char type = *format++;
-
-        if (type == ';') {
-            // All further fields are optional.
-            optional = true;
-            continue;
-        }
-
-        if (!field && !optional) {
-            // Field requested but we ran out if input. Bail out.
-            goto parse_error;
-        }
-
-        switch (type) {
-            case 'c': { // Single character field (char).
-                char value = '\0';
-
-                if (field && minmea_isfield(*field))
-                    value = *field;
-
-                *va_arg(ap, char *) = value;
-            } break;
-
-            case 'd': { // Single character direction field (int).
-                int value = 0;
-
-                if (field && minmea_isfield(*field)) {
-                    switch (*field) {
-                        case 'N':
-                        case 'E':
-                            value = 1;
-                            break;
-                        case 'S':
-                        case 'W':
-                            value = -1;
-                            break;
-                        default:
-                            goto parse_error;
-                    }
-                }
-
-                *va_arg(ap, int *) = value;
-            } break;
-
-            case 'f': { // Fractional value with scale (struct minmea_float).
-                int sign = 0;
-                int_least32_t value = -1;
-                int_least32_t scale = 0;
-
-                if (field) {
-                    while (minmea_isfield(*field)) {
-                        if (*field == '+' && !sign && value == -1) {
-                            sign = 1;
-                        } else if (*field == '-' && !sign && value == -1) {
-                            sign = -1;
-                        } else if (isdigit((unsigned char) *field)) {
-                            int digit = *field - '0';
-                            if (value == -1)
-                                value = 0;
-                            if (value > (INT_LEAST32_MAX-digit) / 10) {
-                                /* we ran out of bits, what do we do? */
-                                if (scale) {
-                                    /* truncate extra precision */
-                                    break;
-                                } else {
-                                    /* integer overflow. bail out. */
-                                    goto parse_error;
-                                }
-                            }
-                            value = (10 * value) + digit;
-                            if (scale)
-                                scale *= 10;
-                        } else if (*field == '.' && scale == 0) {
-                            scale = 1;
-                        } else if (*field == ' ') {
-                            /* Allow spaces at the start of the field. Not NMEA
-                             * conformant, but some modules do this. */
-                            if (sign != 0 || value != -1 || scale != 0)
-                                goto parse_error;
-                        } else {
-                            goto parse_error;
-                        }
-                        field++;
-                    }
-                }
-
-                if ((sign || scale) && value == -1)
-                    goto parse_error;
-
-                if (value == -1) {
-                    /* No digits were scanned. */
-                    value = 0;
-                    scale = 0;
-                } else if (scale == 0) {
-                    /* No decimal point. */
-                    scale = 1;
-                }
-                if (sign)
-                    value *= sign;
-
-                *va_arg(ap, struct minmea_float *) = (struct minmea_float) {value, scale};
-            } break;
-
-            case 'i': { // Integer value, default 0 (int).
-                int value = 0;
-
-                if (field) {
-                    char *endptr;
-                    value = strtol(field, &endptr, 10);
-                    if (minmea_isfield(*endptr))
-                        goto parse_error;
-                }
-
-                *va_arg(ap, int *) = value;
-            } break;
-
-            case 's': { // String value (char *).
-                char *buf = va_arg(ap, char *);
-
-                if (field) {
-                    while (minmea_isfield(*field))
-                        *buf++ = *field++;
-                }
-
-                *buf = '\0';
-            } break;
-
-            case 't': { // NMEA talker+sentence identifier (char *).
-                // This field is always mandatory.
-                if (!field)
-                    goto parse_error;
-
-                if (field[0] != '$')
-                    goto parse_error;
-                for (int f=0; f<5; f++)
-                    if (!minmea_isfield(field[1+f]))
-                        goto parse_error;
-
-                char *buf = va_arg(ap, char *);
-                memcpy(buf, field+1, 5);
-                buf[5] = '\0';
-            } break;
-
-            case 'D': { // Date (int, int, int), -1 if empty.
-                struct minmea_date *date = va_arg(ap, struct minmea_date *);
-
-                int d = -1, m = -1, y = -1;
-
-                if (field && minmea_isfield(*field)) {
-                    // Always six digits.
-                    for (int f=0; f<6; f++)
-                        if (!isdigit((unsigned char) field[f]))
-                            goto parse_error;
-
-                    char dArr[] = {field[0], field[1], '\0'};
-                    char mArr[] = {field[2], field[3], '\0'};
-                    char yArr[] = {field[4], field[5], '\0'};
-                    d = strtol(dArr, NULL, 10);
-                    m = strtol(mArr, NULL, 10);
-                    y = strtol(yArr, NULL, 10);
-                }
-
-                date->day = d;
-                date->month = m;
-                date->year = y;
-            } break;
-
-            case 'T': { // Time (int, int, int, int), -1 if empty.
-                struct minmea_time *time_ = va_arg(ap, struct minmea_time *);
-
-                int h = -1, i = -1, s = -1, u = -1;
-
-                if (field && minmea_isfield(*field)) {
-                    // Minimum required: integer time.
-                    for (int f=0; f<6; f++)
-                        if (!isdigit((unsigned char) field[f]))
-                            goto parse_error;
-
-                    char hArr[] = {field[0], field[1], '\0'};
-                    char iArr[] = {field[2], field[3], '\0'};
-                    char sArr[] = {field[4], field[5], '\0'};
-                    h = strtol(hArr, NULL, 10);
-                    i = strtol(iArr, NULL, 10);
-                    s = strtol(sArr, NULL, 10);
-                    field += 6;
-
-                    // Extra: fractional time. Saved as microseconds.
-                    if (*field++ == '.') {
-                        uint32_t value = 0;
-                        uint32_t scale = 1000000LU;
-                        while (isdigit((unsigned char) *field) && scale > 1) {
-                            value = (value * 10) + (*field++ - '0');
-                            scale /= 10;
-                        }
-                        u = value * scale;
-                    } else {
-                        u = 0;
-                    }
-                }
-
-                time_->hours = h;
-                time_->minutes = i;
-                time_->seconds = s;
-                time_->microseconds = u;
-            } break;
-
-            case '_': { // Ignore the field.
-            } break;
-
-            default: { // Unknown.
-                goto parse_error;
-            }
-        }
-
-        next_field();
-    }
-
-    result = true;
-
-parse_error:
-    va_end(ap);
-    return result;
-}
-
-bool minmea_talker_id(char talker[3], const char *sentence)
-{
-    char type[6];
-    if (!minmea_scan(sentence, "t", type))
-        return false;
-
-    talker[0] = type[0];
-    talker[1] = type[1];
-    talker[2] = '\0';
-
-    return true;
-}
-
-enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict)
-{
-    if (!minmea_check(sentence, strict))
-        return MINMEA_INVALID;
-
-    char type[6];
-    if (!minmea_scan(sentence, "t", type))
-        return MINMEA_INVALID;
-
-    if (!strcmp(type+2, "GBS"))
-        return MINMEA_SENTENCE_GBS;
-    if (!strcmp(type+2, "GGA"))
-        return MINMEA_SENTENCE_GGA;
-    if (!strcmp(type+2, "GLL"))
-        return MINMEA_SENTENCE_GLL;
-    if (!strcmp(type+2, "GSA"))
-        return MINMEA_SENTENCE_GSA;
-    if (!strcmp(type+2, "GST"))
-        return MINMEA_SENTENCE_GST;
-    if (!strcmp(type+2, "GSV"))
-        return MINMEA_SENTENCE_GSV;
-    if (!strcmp(type+2, "RMC"))
-        return MINMEA_SENTENCE_RMC;
-    if (!strcmp(type+2, "VTG"))
-        return MINMEA_SENTENCE_VTG;
-    if (!strcmp(type+2, "ZDA"))
-        return MINMEA_SENTENCE_ZDA;
-
-    return MINMEA_UNKNOWN;
-}
-
-bool minmea_parse_gbs(struct minmea_sentence_gbs *frame, const char *sentence)
-{
-    // $GNGBS,170556.00,3.0,2.9,8.3,,,,*5C
-    char type[6];
-    if (!minmea_scan(sentence, "tTfffifff",
-            type,
-            &frame->time,
-            &frame->err_latitude,
-            &frame->err_longitude,
-            &frame->err_altitude,
-            &frame->svid,
-            &frame->prob,
-            &frame->bias,
-            &frame->stddev
-            ))
-        return false;
-    if (strcmp(type+2, "GBS"))
-        return false;
-
-    return true;
-}
-
-bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence)
-{
-    // $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
-    char type[6];
-    char validity;
-    int latitude_direction;
-    int longitude_direction;
-    int variation_direction;
-    if (!minmea_scan(sentence, "tTcfdfdffDfd",
-            type,
-            &frame->time,
-            &validity,
-            &frame->latitude, &latitude_direction,
-            &frame->longitude, &longitude_direction,
-            &frame->speed,
-            &frame->course,
-            &frame->date,
-            &frame->variation, &variation_direction))
-        return false;
-    if (strcmp(type+2, "RMC"))
-        return false;
-
-    frame->valid = (validity == 'A');
-    frame->latitude.value *= latitude_direction;
-    frame->longitude.value *= longitude_direction;
-    frame->variation.value *= variation_direction;
-
-    return true;
-}
-
-bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence)
-{
-    // $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47
-    char type[6];
-    int latitude_direction;
-    int longitude_direction;
-
-    if (!minmea_scan(sentence, "tTfdfdiiffcfcf_",
-            type,
-            &frame->time,
-            &frame->latitude, &latitude_direction,
-            &frame->longitude, &longitude_direction,
-            &frame->fix_quality,
-            &frame->satellites_tracked,
-            &frame->hdop,
-            &frame->altitude, &frame->altitude_units,
-            &frame->height, &frame->height_units,
-            &frame->dgps_age))
-        return false;
-    if (strcmp(type+2, "GGA"))
-        return false;
-
-    frame->latitude.value *= latitude_direction;
-    frame->longitude.value *= longitude_direction;
-
-    return true;
-}
-
-bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence)
-{
-    // $GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39
-    char type[6];
-
-    if (!minmea_scan(sentence, "tciiiiiiiiiiiiifff",
-            type,
-            &frame->mode,
-            &frame->fix_type,
-            &frame->sats[0],
-            &frame->sats[1],
-            &frame->sats[2],
-            &frame->sats[3],
-            &frame->sats[4],
-            &frame->sats[5],
-            &frame->sats[6],
-            &frame->sats[7],
-            &frame->sats[8],
-            &frame->sats[9],
-            &frame->sats[10],
-            &frame->sats[11],
-            &frame->pdop,
-            &frame->hdop,
-            &frame->vdop))
-        return false;
-    if (strcmp(type+2, "GSA"))
-        return false;
-
-    return true;
-}
-
-bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence)
-{
-    // $GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41$;
-    char type[6];
-    int latitude_direction;
-    int longitude_direction;
-
-    if (!minmea_scan(sentence, "tfdfdTc;c",
-            type,
-            &frame->latitude, &latitude_direction,
-            &frame->longitude, &longitude_direction,
-            &frame->time,
-            &frame->status,
-            &frame->mode))
-        return false;
-    if (strcmp(type+2, "GLL"))
-        return false;
-
-    frame->latitude.value *= latitude_direction;
-    frame->longitude.value *= longitude_direction;
-
-    return true;
-}
-
-bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence)
-{
-    // $GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58
-    char type[6];
-
-    if (!minmea_scan(sentence, "tTfffffff",
-            type,
-            &frame->time,
-            &frame->rms_deviation,
-            &frame->semi_major_deviation,
-            &frame->semi_minor_deviation,
-            &frame->semi_major_orientation,
-            &frame->latitude_error_deviation,
-            &frame->longitude_error_deviation,
-            &frame->altitude_error_deviation))
-        return false;
-    if (strcmp(type+2, "GST"))
-        return false;
-
-    return true;
-}
-
-bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence)
-{
-    // $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74
-    // $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D
-    // $GPGSV,4,2,11,08,51,203,30,09,45,215,28*75
-    // $GPGSV,4,4,13,39,31,170,27*40
-    // $GPGSV,4,4,13*7B
-    char type[6];
-
-    if (!minmea_scan(sentence, "tiii;iiiiiiiiiiiiiiii",
-            type,
-            &frame->total_msgs,
-            &frame->msg_nr,
-            &frame->total_sats,
-            &frame->sats[0].nr,
-            &frame->sats[0].elevation,
-            &frame->sats[0].azimuth,
-            &frame->sats[0].snr,
-            &frame->sats[1].nr,
-            &frame->sats[1].elevation,
-            &frame->sats[1].azimuth,
-            &frame->sats[1].snr,
-            &frame->sats[2].nr,
-            &frame->sats[2].elevation,
-            &frame->sats[2].azimuth,
-            &frame->sats[2].snr,
-            &frame->sats[3].nr,
-            &frame->sats[3].elevation,
-            &frame->sats[3].azimuth,
-            &frame->sats[3].snr
-            )) {
-        return false;
-    }
-    if (strcmp(type+2, "GSV"))
-        return false;
-
-    return true;
-}
-
-bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence)
-{
-    // $GPVTG,054.7,T,034.4,M,005.5,N,010.2,K*48
-    // $GPVTG,156.1,T,140.9,M,0.0,N,0.0,K*41
-    // $GPVTG,096.5,T,083.5,M,0.0,N,0.0,K,D*22
-    // $GPVTG,188.36,T,,M,0.820,N,1.519,K,A*3F
-    char type[6];
-    char c_true, c_magnetic, c_knots, c_kph, c_faa_mode;
-
-    if (!minmea_scan(sentence, "t;fcfcfcfcc",
-            type,
-            &frame->true_track_degrees,
-            &c_true,
-            &frame->magnetic_track_degrees,
-            &c_magnetic,
-            &frame->speed_knots,
-            &c_knots,
-            &frame->speed_kph,
-            &c_kph,
-            &c_faa_mode))
-        return false;
-    if (strcmp(type+2, "VTG"))
-        return false;
-    // values are only valid with the accompanying characters
-    if (c_true != 'T')
-        frame->true_track_degrees.scale = 0;
-    if (c_magnetic != 'M')
-        frame->magnetic_track_degrees.scale = 0;
-    if (c_knots != 'N')
-        frame->speed_knots.scale = 0;
-    if (c_kph != 'K')
-        frame->speed_kph.scale = 0;
-    frame->faa_mode = (enum minmea_faa_mode)c_faa_mode;
-
-    return true;
-}
-
-bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence)
-{
-  // $GPZDA,201530.00,04,07,2002,00,00*60
-  char type[6];
-
-  if(!minmea_scan(sentence, "tTiiiii",
-          type,
-          &frame->time,
-          &frame->date.day,
-          &frame->date.month,
-          &frame->date.year,
-          &frame->hour_offset,
-          &frame->minute_offset))
-      return false;
-  if (strcmp(type+2, "ZDA"))
-      return false;
-
-  // check offsets
-  if (abs(frame->hour_offset) > 13 ||
-      frame->minute_offset > 59 ||
-      frame->minute_offset < 0)
-      return false;
-
-  return true;
-}
-
-int minmea_getdatetime(struct tm *tm, const struct minmea_date *date, const struct minmea_time *time_)
-{
-    if (date->year == -1 || time_->hours == -1)
-        return -1;
-
-    memset(tm, 0, sizeof(*tm));
-    if (date->year < 80) {
-        tm->tm_year = 2000 + date->year - 1900; // 2000-2079
-    } else if (date->year >= 1900) {
-        tm->tm_year = date->year - 1900;        // 4 digit year, use directly
-    } else {
-        tm->tm_year = date->year;               // 1980-1999
-    }
-    tm->tm_mon = date->month - 1;
-    tm->tm_mday = date->day;
-    tm->tm_hour = time_->hours;
-    tm->tm_min = time_->minutes;
-    tm->tm_sec = time_->seconds;
-
-    return 0;
-}
-
-int minmea_gettime(struct timespec *ts, const struct minmea_date *date, const struct minmea_time *time_)
-{
-    struct tm tm;
-    if (minmea_getdatetime(&tm, date, time_))
-        return -1;
-
-    time_t timestamp = mktime(&tm); /* See README.md if your system lacks timegm(). */
-    if (timestamp != (time_t)-1) {
-        ts->tv_sec = timestamp;
-        ts->tv_nsec = time_->microseconds * 1000;
-        return 0;
-    } else {
-        return -1;
-    }
-}
-
-/* vim: set ts=4 sw=4 et: */
diff --git a/Apps/GpsViewer/main/Source/third_party/minmea/minmea.h b/Apps/GpsViewer/main/Source/third_party/minmea/minmea.h
deleted file mode 100644
index 494b218..0000000
--- a/Apps/GpsViewer/main/Source/third_party/minmea/minmea.h
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * Copyright © 2014 Kosma Moczek <kosma@cloudyourcar.com>
- * This program is free software. It comes without any warranty, to the extent
- * permitted by applicable law. You can redistribute it and/or modify it under
- * the terms of the Do What The Fuck You Want To Public License, Version 2, as
- * published by Sam Hocevar. See the COPYING file for more details.
- */
-
-#ifndef MINMEA_H
-#define MINMEA_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <ctype.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <time.h>
-#include <math.h>
-#ifdef MINMEA_INCLUDE_COMPAT
-#include <minmea_compat.h>
-#endif
-
-#ifndef MINMEA_MAX_SENTENCE_LENGTH
-#define MINMEA_MAX_SENTENCE_LENGTH 80
-#endif
-
-enum minmea_sentence_id {
-    MINMEA_INVALID = -1,
-    MINMEA_UNKNOWN = 0,
-    MINMEA_SENTENCE_GBS,
-    MINMEA_SENTENCE_GGA,
-    MINMEA_SENTENCE_GLL,
-    MINMEA_SENTENCE_GSA,
-    MINMEA_SENTENCE_GST,
-    MINMEA_SENTENCE_GSV,
-    MINMEA_SENTENCE_RMC,
-    MINMEA_SENTENCE_VTG,
-    MINMEA_SENTENCE_ZDA,
-};
-
-struct minmea_float {
-    int_least32_t value;
-    int_least32_t scale;
-};
-
-struct minmea_date {
-    int day;
-    int month;
-    int year;
-};
-
-struct minmea_time {
-    int hours;
-    int minutes;
-    int seconds;
-    int microseconds;
-};
-
-struct minmea_sentence_gbs {
-    struct minmea_time time;
-    struct minmea_float err_latitude;
-    struct minmea_float err_longitude;
-    struct minmea_float err_altitude;
-    int svid;
-    struct minmea_float prob;
-    struct minmea_float bias;
-    struct minmea_float stddev;
-};
-
-struct minmea_sentence_rmc {
-    struct minmea_time time;
-    bool valid;
-    struct minmea_float latitude;
-    struct minmea_float longitude;
-    struct minmea_float speed;
-    struct minmea_float course;
-    struct minmea_date date;
-    struct minmea_float variation;
-};
-
-struct minmea_sentence_gga {
-    struct minmea_time time;
-    struct minmea_float latitude;
-    struct minmea_float longitude;
-    int fix_quality;
-    int satellites_tracked;
-    struct minmea_float hdop;
-    struct minmea_float altitude; char altitude_units;
-    struct minmea_float height; char height_units;
-    struct minmea_float dgps_age;
-};
-
-enum minmea_gll_status {
-    MINMEA_GLL_STATUS_DATA_VALID = 'A',
-    MINMEA_GLL_STATUS_DATA_NOT_VALID = 'V',
-};
-
-// FAA mode added to some fields in NMEA 2.3.
-enum minmea_faa_mode {
-    MINMEA_FAA_MODE_AUTONOMOUS = 'A',
-    MINMEA_FAA_MODE_DIFFERENTIAL = 'D',
-    MINMEA_FAA_MODE_ESTIMATED = 'E',
-    MINMEA_FAA_MODE_MANUAL = 'M',
-    MINMEA_FAA_MODE_SIMULATED = 'S',
-    MINMEA_FAA_MODE_NOT_VALID = 'N',
-    MINMEA_FAA_MODE_PRECISE = 'P',
-};
-
-struct minmea_sentence_gll {
-    struct minmea_float latitude;
-    struct minmea_float longitude;
-    struct minmea_time time;
-    char status;
-    char mode;
-};
-
-struct minmea_sentence_gst {
-    struct minmea_time time;
-    struct minmea_float rms_deviation;
-    struct minmea_float semi_major_deviation;
-    struct minmea_float semi_minor_deviation;
-    struct minmea_float semi_major_orientation;
-    struct minmea_float latitude_error_deviation;
-    struct minmea_float longitude_error_deviation;
-    struct minmea_float altitude_error_deviation;
-};
-
-enum minmea_gsa_mode {
-    MINMEA_GPGSA_MODE_AUTO = 'A',
-    MINMEA_GPGSA_MODE_FORCED = 'M',
-};
-
-enum minmea_gsa_fix_type {
-    MINMEA_GPGSA_FIX_NONE = 1,
-    MINMEA_GPGSA_FIX_2D = 2,
-    MINMEA_GPGSA_FIX_3D = 3,
-};
-
-struct minmea_sentence_gsa {
-    char mode;
-    int fix_type;
-    int sats[12];
-    struct minmea_float pdop;
-    struct minmea_float hdop;
-    struct minmea_float vdop;
-};
-
-struct minmea_sat_info {
-    int nr;
-    int elevation;
-    int azimuth;
-    int snr;
-};
-
-struct minmea_sentence_gsv {
-    int total_msgs;
-    int msg_nr;
-    int total_sats;
-    struct minmea_sat_info sats[4];
-};
-
-struct minmea_sentence_vtg {
-    struct minmea_float true_track_degrees;
-    struct minmea_float magnetic_track_degrees;
-    struct minmea_float speed_knots;
-    struct minmea_float speed_kph;
-    enum minmea_faa_mode faa_mode;
-};
-
-struct minmea_sentence_zda {
-    struct minmea_time time;
-    struct minmea_date date;
-    int hour_offset;
-    int minute_offset;
-};
-
-/**
- * Calculate raw sentence checksum. Does not check sentence integrity.
- */
-uint8_t minmea_checksum(const char *sentence);
-
-/**
- * Check sentence validity and checksum. Returns true for valid sentences.
- */
-bool minmea_check(const char *sentence, bool strict);
-
-/**
- * Determine talker identifier.
- */
-bool minmea_talker_id(char talker[3], const char *sentence);
-
-/**
- * Determine sentence identifier.
- */
-enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict);
-
-/**
- * Scanf-like processor for NMEA sentences. Supports the following formats:
- * c - single character (char *)
- * d - direction, returned as 1/-1, default 0 (int *)
- * f - fractional, returned as value + scale (struct minmea_float *)
- * i - decimal, default zero (int *)
- * s - string (char *)
- * t - talker identifier and type (char *)
- * D - date (struct minmea_date *)
- * T - time stamp (struct minmea_time *)
- * _ - ignore this field
- * ; - following fields are optional
- * Returns true on success. See library source code for details.
- */
-bool minmea_scan(const char *sentence, const char *format, ...);
-
-/*
- * Parse a specific type of sentence. Return true on success.
- */
-bool minmea_parse_gbs(struct minmea_sentence_gbs *frame, const char *sentence);
-bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence);
-bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence);
-bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence);
-bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence);
-bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence);
-bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence);
-bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence);
-bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence);
-
-/**
- * Convert GPS UTC date/time representation to a UNIX calendar time.
- */
-int minmea_getdatetime(struct tm *tm, const struct minmea_date *date, const struct minmea_time *time_);
-
-/**
- * Convert GPS UTC date/time representation to a UNIX timestamp.
- */
-int minmea_gettime(struct timespec *ts, const struct minmea_date *date, const struct minmea_time *time_);
-
-/**
- * Rescale a fixed-point value to a different scale. Rounds towards zero.
- */
-static inline int_least32_t minmea_rescale(const struct minmea_float *f, int_least32_t new_scale)
-{
-    if (f->scale == 0)
-        return 0;
-    if (f->scale == new_scale)
-        return f->value;
-    if (f->scale > new_scale)
-        return (f->value + ((f->value > 0) - (f->value < 0)) * f->scale/new_scale/2) / (f->scale/new_scale);
-    else
-        return f->value * (new_scale/f->scale);
-}
-
-/**
- * Convert a fixed-point value to a floating-point value.
- * Returns NaN for "unknown" values.
- */
-static inline float minmea_tofloat(const struct minmea_float *f)
-{
-    if (f->scale == 0)
-        return NAN;
-    return (float) f->value / (float) f->scale;
-}
-
-/**
- * Convert a raw coordinate to a floating point DD.DDD... value.
- * Returns NaN for "unknown" values.
- */
-static inline float minmea_tocoord(const struct minmea_float *f)
-{
-    if (f->scale == 0)
-        return NAN;
-    if (f->scale  > (INT_LEAST32_MAX / 100))
-        return NAN;
-    if (f->scale < (INT_LEAST32_MIN / 100))
-        return NAN;
-    int_least32_t degrees = f->value / (f->scale * 100);
-    int_least32_t minutes = f->value % (f->scale * 100);
-    return (float) degrees + (float) minutes / (60 * f->scale);
-}
-
-/**
- * Check whether a character belongs to the set of characters allowed in a
- * sentence data field.
- */
-static inline bool minmea_isfield(char c) {
-    return isprint((unsigned char) c) && c != ',' && c != '*';
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* MINMEA_H */
-
-/* vim: set ts=4 sw=4 et: */
diff --git a/Apps/GpsViewer/manifest.properties b/Apps/GpsViewer/manifest.properties
index d2787d6..6669bf8 100644
--- a/Apps/GpsViewer/manifest.properties
+++ b/Apps/GpsViewer/manifest.properties
@@ -1,6 +1,6 @@
 manifest.version=0.3
 target.sdk=0.8.0-dev
-target.platforms=esp32,esp32s3,esp32c6,esp32p4
+target.platforms=all
 id=tactility.gpsviewer
 version.name=0.1.0
 version.code=1

From 8101bffd79b671a65c452cbfc5fbe1faf74dc4a5 Mon Sep 17 00:00:00 2001
From: AdaSzi115026 <81822538+AdaSzi@users.noreply.github.com>
Date: Sat, 7 Nov 2026 19:53:11 +0100
Subject: [PATCH 3/3] GPS Viewer: fix review findings

- Build for the ESP32 platforms only again, the PC build fails
- Timestamp GPS events in the reader and drop events from an earlier receiver connection
- Start the first connection attempt from the clock instead of 0
- Keep GGA and GSA HDOP apart, latch TTFF with the shown fix, expire speed with RMC and altitude with GGA
- Clear used flags per GSA source, also for an empty combined GSA without a fix
- Count GSV merge windows from the first set of an epoch
- Give the menu and settings overlays their own focus group and the night palette, skip the title when wrapping
- Count recording start/stop presses so two quick presses cancel out
- Restore the window background after night mode, and use white on black for night mode on 1-bit displays
- Put the speed statistics on two lines when they don't fit
- Keep no settings and refuse recording without a user data folder, and say so in the menu
---
 Apps/GpsViewer/README.md                      |  11 +-
 Apps/GpsViewer/main/Source/app/AppContext.h   |   5 +-
 Apps/GpsViewer/main/Source/app/Main.cpp       |  13 ++-
 .../GpsViewer/main/Source/app/MessageCard.cpp |   8 +-
 .../GpsViewer/main/Source/app/PositionTab.cpp |   5 +
 Apps/GpsViewer/main/Source/app/Recorder.cpp   |   3 +
 Apps/GpsViewer/main/Source/app/Sources.cpp    |  38 ++++---
 Apps/GpsViewer/main/Source/app/Sources.h      |   1 +
 Apps/GpsViewer/main/Source/app/Theme.cpp      |  16 ++-
 Apps/GpsViewer/main/Source/app/Ui.cpp         | 100 +++++++++++++++---
 Apps/GpsViewer/main/Source/app/Widgets.cpp    |   4 +
 Apps/GpsViewer/main/Source/app/Widgets.h      |   2 +
 Apps/GpsViewer/main/Source/core/GnssModel.cpp |  67 +++++++-----
 Apps/GpsViewer/main/Source/core/GnssModel.h   |   7 +-
 .../main/Source/core/SatelliteDb.cpp          |  28 ++++-
 Apps/GpsViewer/main/Source/core/SatelliteDb.h |   6 +-
 Apps/GpsViewer/manifest.properties            |   2 +-
 17 files changed, 246 insertions(+), 70 deletions(-)

diff --git a/Apps/GpsViewer/README.md b/Apps/GpsViewer/README.md
index 05df3ee..17a862f 100644
--- a/Apps/GpsViewer/README.md
+++ b/Apps/GpsViewer/README.md
@@ -89,14 +89,15 @@ per line.
 
 ## Recording
 
-"Start recording" in the menu (or the `l` key) saves every NMEA sentence from the receiver to a file in
+"Start recording" in the menu (or the `l` key) saves the RMC, GGA, GSA and GSV sentences from the receiver to a file in
 `logs/` in the app's user data folder. The file is named after the GPS date and time, `gps-YYYYMMDD-HHMMSS.nmea`,
 or after the uptime, `gps-up<seconds>.nmea`, when the receiver has no time yet. The toolbar and the Position tab show
-REC while recording. The file is written every 2 seconds, so a crash or power loss loses at most the last 2
-seconds. Recording stops with "Stop recording" and when the app closes.
+REC while recording. The app writes the file to storage every 2 seconds, so a crash or power loss usually loses
+only the last seconds. Recording stops with "Stop recording" and when the app closes. Without a user data folder
+the app can't record or keep its settings, and the menu says so.
 
-Sentences are written back from the parsed values: RMC, GGA, GSA and GSV with their checksums. Other
-sentences and fields the app does not use are not saved. The logs are plain NMEA 0183, for use in other tools.
+Sentences are written back from the parsed values, with their checksums. Other sentences (VTG, GLL, ...) and
+fields the app does not use are not saved, so a log is not a full capture of the receiver output. The logs are plain NMEA 0183, for use in other tools.
 
 ## Testing
 
diff --git a/Apps/GpsViewer/main/Source/app/AppContext.h b/Apps/GpsViewer/main/Source/app/AppContext.h
index f0ce97c..cf7ac77 100644
--- a/Apps/GpsViewer/main/Source/app/AppContext.h
+++ b/Apps/GpsViewer/main/Source/app/AppContext.h
@@ -28,7 +28,6 @@ enum class SourceStatus : uint8_t {
 enum Request : uint32_t {
     REQUEST_SAVE_SETTINGS = 1U << 0,
     REQUEST_RESET_SPEED = 1U << 1,
-    REQUEST_TOGGLE_RECORDING = 1U << 3,
     // Opens Tactility's location settings, where GPS receivers are set up and location is turned on
     REQUEST_OPEN_LOCATION_SETTINGS = 1U << 4,
 };
@@ -47,12 +46,16 @@ struct AppContext {
     GnssModel model;
     Settings settings;
     SourceStatus status = SourceStatus::NoReceiver;
+    // Counts receiver connections. Events from an earlier connection are dropped.
+    uint32_t session = 0;
     char receiverName[32] = "";
     bool recording = false;
     char recordingName[40] = "";
     uint32_t recordedLines = 0;
 
     std::atomic<uint32_t> requests {0};
+    // Start/stop presses not handled yet. Each one toggles recording, so two quick presses cancel out.
+    std::atomic<uint32_t> recordingToggles {0};
 
     // LVGL thread only
     UiState* ui = nullptr;
diff --git a/Apps/GpsViewer/main/Source/app/Main.cpp b/Apps/GpsViewer/main/Source/app/Main.cpp
index e1204d1..d95073f 100644
--- a/Apps/GpsViewer/main/Source/app/Main.cpp
+++ b/Apps/GpsViewer/main/Source/app/Main.cpp
@@ -28,7 +28,11 @@ void settingsPath(const AppContext& context, char* out, size_t outSize) {
     snprintf(out, outSize, "%s/settings.txt", context.dataDirectory);
 }
 
+// Without a data folder the settings stay at their defaults and aren't saved
 Settings loadSettings(const AppContext& context) {
+    if (context.dataDirectory[0] == '\0') {
+        return parseSettings("");
+    }
     char path[PATH_LENGTH + 16];
     settingsPath(context, path, sizeof(path));
     char text[256] = "";
@@ -42,6 +46,9 @@ Settings loadSettings(const AppContext& context) {
 }
 
 void saveSettings(const AppContext& context, const Settings& settings) {
+    if (context.dataDirectory[0] == '\0') {
+        return;
+    }
     char text[256];
     const size_t length = serializeSettings(settings, text, sizeof(text));
     char path[PATH_LENGTH + 16];
@@ -97,7 +104,7 @@ void run(AppContext& context, Sources& sources) {
             }
             saveSettings(context, settings);
         }
-        if ((requests & REQUEST_TOGGLE_RECORDING) != 0) {
+        if ((context.recordingToggles.exchange(0) % 2) != 0) {
             if (recorder.isRecording()) {
                 recorder.stop();
             } else {
@@ -144,8 +151,12 @@ extern "C" int main(int argc, char* argv[]) {
         return 0;
     }
     context->appInstanceId = app_scheduler_current_app_id();
+    // Without a data folder the app still shows the receiver, but keeps no settings and can't record.
+    // The menu says so in place of "Start recording".
     if (app_paths_get_user_data_directory(APP_ID, context->dataDirectory, sizeof(context->dataDirectory)) == ERROR_NONE) {
         mkdir(context->dataDirectory, 0777);
+    } else {
+        context->dataDirectory[0] = '\0';
     }
     context->mutex = xSemaphoreCreateMutex();
     context->ui = uiAllocate(*context);
diff --git a/Apps/GpsViewer/main/Source/app/MessageCard.cpp b/Apps/GpsViewer/main/Source/app/MessageCard.cpp
index 6b4dbdc..67b57ba 100644
--- a/Apps/GpsViewer/main/Source/app/MessageCard.cpp
+++ b/Apps/GpsViewer/main/Source/app/MessageCard.cpp
@@ -2,6 +2,8 @@
 #include "Tabs.h"
 #include "Widgets.h"
 
+#include <lvgl/devices/keyboard.h>
+
 #include <cstdio>
 
 namespace gpsviewer {
@@ -118,9 +120,11 @@ bool MessageCard::update(SourceStatus status, const char* dataDirectory) {
 
     const bool withButton = hasSettingsButton(status);
     setHidden(button, !withButton);
-    if (button != nullptr && lv_group_get_default() != nullptr) {
+    // The app's group, also while a menu overlay has its own group
+    lv_group_t* group = lvgl_keyboard_get_app_group();
+    if (button != nullptr && group != nullptr) {
         if (withButton && !buttonInGroup) {
-            lv_group_add_obj(lv_group_get_default(), button);
+            lv_group_add_obj(group, button);
             buttonInGroup = true;
         } else if (!withButton && buttonInGroup) {
             lv_group_remove_obj(button);
diff --git a/Apps/GpsViewer/main/Source/app/PositionTab.cpp b/Apps/GpsViewer/main/Source/app/PositionTab.cpp
index 375371b..e861657 100644
--- a/Apps/GpsViewer/main/Source/app/PositionTab.cpp
+++ b/Apps/GpsViewer/main/Source/app/PositionTab.cpp
@@ -170,7 +170,12 @@ void PositionTab::update(const TabView& view) {
     char avgText[16];
     formatSpeed(s.maxSpeedMps, units, maxText, sizeof(maxText));
     formatSpeed(s.averageSpeedMps, units, avgText, sizeof(avgText));
+    // On one line when it fits the column, otherwise on two, so large fonts keep both values
     snprintf(text, sizeof(text), "Max %s | Avg %s", maxText, avgText);
+    const int statsWidth = lv_obj_get_content_width(lv_obj_get_parent(speedStatsLabel));
+    if (measureTextWidth(text, lvgl_get_text_font(FONT_SIZE_SMALL)) > statsWidth) {
+        snprintf(text, sizeof(text), "Max %s\nAvg %s", maxText, avgText);
+    }
     setLabelText(speedStatsLabel, text);
 
     setHidden(recPill, !view.recording);
diff --git a/Apps/GpsViewer/main/Source/app/Recorder.cpp b/Apps/GpsViewer/main/Source/app/Recorder.cpp
index edd3240..78f0720 100644
--- a/Apps/GpsViewer/main/Source/app/Recorder.cpp
+++ b/Apps/GpsViewer/main/Source/app/Recorder.cpp
@@ -28,6 +28,9 @@ bool endsWith(const char* text, const char* suffix) {
 
 bool Recorder::start(const char* dataDirectory, const UtcDateTime& utc, uint32_t nowMs) {
     stop();
+    if (dataDirectory[0] == '\0') {
+        return false;
+    }
     char folder[PATH_LENGTH + 8];
     snprintf(folder, sizeof(folder), "%s/logs", dataDirectory);
     mkdir(folder, 0777);
diff --git a/Apps/GpsViewer/main/Source/app/Sources.cpp b/Apps/GpsViewer/main/Source/app/Sources.cpp
index ba4a864..cda192f 100644
--- a/Apps/GpsViewer/main/Source/app/Sources.cpp
+++ b/Apps/GpsViewer/main/Source/app/Sources.cpp
@@ -55,6 +55,13 @@ bool toGnssEvent(const GpsEvent& in, GnssEvent& out) {
     }
 }
 
+// What the reader queues: the event, when it arrived and from which connection
+struct QueuedEvent {
+    GnssEvent event;
+    uint32_t atMs;
+    uint32_t session;
+};
+
 void setStatus(AppContext& context, SourceStatus status) {
     ContextLock lock(context);
     context.status = status;
@@ -117,7 +124,6 @@ void GpsSource::disconnect() {
         device = nullptr;
     }
     lost = false;
-    nextAttemptMs = 0;
 }
 
 void GpsSource::readerLoop() {
@@ -141,10 +147,12 @@ void GpsSource::readerLoop() {
             setStatus(*context, SourceStatus::ReceiverLost);
             continue;
         }
-        GnssEvent gnss;
-        if (toGnssEvent(event, gnss)) {
+        QueuedEvent queued;
+        if (toGnssEvent(event, queued.event)) {
+            queued.atMs = get_millis();
+            queued.session = session;
             // A full queue drops the event, the next epoch repeats the data
-            xQueueSend(queue, &gnss, 0);
+            xQueueSend(queue, &queued, 0);
         }
     }
     disconnect();
@@ -166,14 +174,15 @@ void GpsSource::start(AppContext& appContext, TaskEventGroup* eventGroup) {
         locationSubscribed = location_subscribe(&location, eventGroup, "GPS Viewer") == ERROR_NONE;
     }
     if (queue == nullptr) {
-        queue = xQueueCreate(QUEUE_LENGTH, sizeof(GnssEvent));
+        queue = xQueueCreate(QUEUE_LENGTH, sizeof(QueuedEvent));
     }
     if (queue == nullptr || !readerDone.load()) {
         return;
     }
     stopRequested.store(false);
     readerDone.store(false);
-    nextAttemptMs = 0;
+    // The first attempt is due now. A deadline of 0 would wait for the clock to wrap after 24.9 days of uptime.
+    nextAttemptMs = get_millis();
     if (xTaskCreatePinnedToCore(readerMain, "gpsviewer_rx", READER_STACK_SIZE, this, READER_PRIORITY, &reader, tskNO_AFFINITY) != pdPASS) {
         readerDone.store(true);
         reader = nullptr;
@@ -185,20 +194,25 @@ void GpsSource::poll(AppContext& appContext, uint32_t timeoutMs, Recorder& recor
         vTaskDelay(pdMS_TO_TICKS(timeoutMs));
         return;
     }
-    GnssEvent event;
-    if (xQueueReceive(queue, &event, pdMS_TO_TICKS(timeoutMs)) != pdTRUE) {
+    QueuedEvent queued;
+    if (xQueueReceive(queue, &queued, pdMS_TO_TICKS(timeoutMs)) != pdTRUE) {
         return;
     }
-    const uint32_t now = get_millis();
     int handled = 0;
     do {
+        bool current;
         {
             ContextLock lock(appContext);
-            appContext.model.onEvent(event, now);
+            current = queued.session == appContext.session;
+            if (current) {
+                appContext.model.onEvent(queued.event, queued.atMs);
+            }
+        }
+        if (current) {
+            recorder.write(queued.event, queued.atMs);
         }
-        recorder.write(event, now);
         handled++;
-    } while (handled < QUEUE_LENGTH && xQueueReceive(queue, &event, 0) == pdTRUE);
+    } while (handled < QUEUE_LENGTH && xQueueReceive(queue, &queued, 0) == pdTRUE);
 }
 
 
diff --git a/Apps/GpsViewer/main/Source/app/Sources.h b/Apps/GpsViewer/main/Source/app/Sources.h
index 47e2974..198f6df 100644
--- a/Apps/GpsViewer/main/Source/app/Sources.h
+++ b/Apps/GpsViewer/main/Source/app/Sources.h
@@ -47,6 +47,7 @@ class GpsSource {
     Device* device = nullptr;
     GpsSubscription subscription {};
     bool subscribed = false;
+    uint32_t session = 0;
     uint32_t nextAttemptMs = 0;
     bool lost = false;
 };
diff --git a/Apps/GpsViewer/main/Source/app/Theme.cpp b/Apps/GpsViewer/main/Source/app/Theme.cpp
index 2302b35..2353c6d 100644
--- a/Apps/GpsViewer/main/Source/app/Theme.cpp
+++ b/Apps/GpsViewer/main/Source/app/Theme.cpp
@@ -10,6 +10,21 @@ namespace gpsviewer {
 Theme makeTheme(bool night) {
     Theme theme {};
     theme.night = night;
+    const bool mono = lvgl_theme_is_mono();
+    if (night && mono) {
+        // A 1-bit display has no dark reds: white on black, shapes carry the hierarchy
+        theme.background = lv_color_black();
+        theme.paintBackground = true;
+        theme.border = lv_color_white();
+        theme.accent = lv_color_white();
+        theme.success = lv_color_white();
+        theme.warning = lv_color_white();
+        theme.text = lv_color_white();
+        theme.dim = lv_color_white();
+        theme.grid = lv_color_white();
+        theme.mono = true;
+        return theme;
+    }
     if (night) {
         // Tactical red: one hue only, brightness carries the hierarchy
         theme.background = lv_color_hex(0x000000);
@@ -27,7 +42,6 @@ Theme makeTheme(bool night) {
     LvglThemeSettings settings;
     lvgl_theme_get_settings(&settings);
     const bool dark = settings.is_dark;
-    const bool mono = lvgl_theme_is_mono();
     theme.background = dark ? lv_color_hex(0x21222B) : lv_color_hex(0xF3F3F3);
     if (settings.surface_override) {
         theme.background = settings.color_surface;
diff --git a/Apps/GpsViewer/main/Source/app/Ui.cpp b/Apps/GpsViewer/main/Source/app/Ui.cpp
index c831684..10a6b79 100644
--- a/Apps/GpsViewer/main/Source/app/Ui.cpp
+++ b/Apps/GpsViewer/main/Source/app/Ui.cpp
@@ -5,6 +5,7 @@
 
 #include <app/event.h>
 #include <lvgl/fonts.h>
+#include <lvgl/devices/keyboard.h>
 #include <lvgl/grid_navigation.h>
 #include <lvgl/icons/shared.h>
 #include <lvgl/widgets/toolbar.h>
@@ -26,6 +27,8 @@ uint32_t colorKey(lv_color_t color) {
 
 constexpr int TAB_COUNT = 4;
 constexpr uint32_t REFRESH_MS = 333;
+constexpr lv_state_t NIGHT_STATE = LV_STATE_USER_4;
+constexpr lv_style_selector_t NIGHT_SELECTOR = static_cast<lv_style_selector_t>(LV_PART_MAIN) | static_cast<lv_style_selector_t>(NIGHT_STATE);
 
 // Tab order. The indices are also the keys 1 to 4.
 enum TabIndex : int {
@@ -75,6 +78,8 @@ struct UiState {
     lv_obj_t* panels[TAB_COUNT] {};
     MessageCard messageCard;
     lv_obj_t* overlay = nullptr;
+    // The keys go to this group while an overlay is open, so the focus can't leave it
+    lv_group_t* overlayGroup = nullptr;
     lv_timer_t* timer = nullptr;
     Overlay overlayType = Overlay::None;
     int activeTab = 0;
@@ -179,6 +184,10 @@ void requestBits(UiState& ui, uint32_t bits) {
     ui.context->requests.fetch_or(bits);
 }
 
+void toggleRecording(UiState& ui) {
+    ui.context->recordingToggles.fetch_add(1);
+}
+
 void applySettings(UiState& ui, const Settings& settings) {
     {
         ContextLock lock(*ui.context);
@@ -220,7 +229,17 @@ void focusMain(UiState& ui) {
     }
 }
 
+// Hands the keys back to the app's group and drops the overlay's
+void releaseOverlayGroup(UiState& ui) {
+    if (ui.overlayGroup != nullptr) {
+        lvgl_keyboard_set_active_group(nullptr);
+        lv_group_delete(ui.overlayGroup);
+        ui.overlayGroup = nullptr;
+    }
+}
+
 void closeOverlay(UiState& ui) {
+    releaseOverlayGroup(ui);
     if (ui.overlay != nullptr) {
         lv_obj_delete_async(ui.overlay);
         ui.overlay = nullptr;
@@ -229,18 +248,32 @@ void closeOverlay(UiState& ui) {
     focusMain(ui);
 }
 
+// The next button in the list from index, wrapping around, past the title
+lv_obj_t* nextOverlayButton(lv_obj_t* list, int index, int step) {
+    const int count = static_cast<int>(lv_obj_get_child_count(list));
+    for (int i = 1; i < count; i++) {
+        lv_obj_t* child = lv_obj_get_child(list, ((index + step * i) % count + count) % count);
+        // The buttons are clickable, the title is not
+        if (lv_obj_has_flag(child, LV_OBJ_FLAG_CLICKABLE)) {
+            return child;
+        }
+    }
+    return nullptr;
+}
+
 // Overlay lists get Left/Up and Right/Down as focus moves, and Esc/Backspace to close
 void onOverlayItemKey(lv_event_t* event) {
     auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
     lv_obj_t* item = lv_event_get_current_target_obj(event);
     const uint32_t key = lv_event_get_key(event);
     lv_obj_t* list = lv_obj_get_parent(item);
-    const int count = static_cast<int>(lv_obj_get_child_count(list));
     const int index = static_cast<int>(lv_obj_get_index(item));
-    if (key == LV_KEY_LEFT || key == LV_KEY_UP) {
-        lv_group_focus_obj(lv_obj_get_child(list, (index + count - 1) % count));
-    } else if (key == LV_KEY_RIGHT || key == LV_KEY_DOWN) {
-        lv_group_focus_obj(lv_obj_get_child(list, (index + 1) % count));
+    if (key == LV_KEY_LEFT || key == LV_KEY_UP || key == LV_KEY_RIGHT || key == LV_KEY_DOWN) {
+        const int step = (key == LV_KEY_LEFT || key == LV_KEY_UP) ? -1 : 1;
+        lv_obj_t* next = nextOverlayButton(list, index, step);
+        if (next != nullptr) {
+            lv_group_focus_obj(next);
+        }
     } else if (key == LV_KEY_ESC || key == LV_KEY_BACKSPACE) {
         closeOverlay(*ui);
     }
@@ -265,20 +298,47 @@ lv_obj_t* createOverlay(UiState& ui, Overlay type, const char* title) {
     lv_obj_set_style_radius(ui.overlay, 0, LV_PART_MAIN);
     lv_obj_add_event_cb(ui.overlay, onOverlayBackdrop, LV_EVENT_CLICKED, &ui);
 
+    ui.overlayGroup = lv_group_create();
+    if (ui.overlayGroup != nullptr) {
+        lvgl_keyboard_set_active_group(ui.overlayGroup);
+    }
+
     lv_obj_t* list = lv_list_create(ui.overlay);
     lv_obj_set_size(list, LV_PCT(80), LV_PCT(95));
     lv_obj_center(list);
-    lv_list_add_text(list, title);
+    lv_obj_t* titleLabel = lv_list_add_text(list, title);
+    if (ui.theme.night) {
+        const Theme& theme = ui.theme;
+        lv_obj_set_style_bg_color(list, theme.background, LV_PART_MAIN);
+        lv_obj_set_style_border_color(list, theme.border, LV_PART_MAIN);
+        lv_obj_set_style_bg_color(titleLabel, theme.background, LV_PART_MAIN);
+        lv_obj_set_style_text_color(titleLabel, theme.dim, LV_PART_MAIN);
+    }
     return list;
 }
 
+// Night mode: dark buttons with red text, and a dark red fill on the focused one
+void paintOverlayButton(lv_obj_t* button, const Theme& theme) {
+    lv_obj_set_style_bg_color(button, theme.background, LV_PART_MAIN);
+    lv_obj_set_style_text_color(button, theme.text, LV_PART_MAIN);
+    lv_obj_set_style_border_color(button, theme.border, LV_PART_MAIN);
+    for (const lv_style_selector_t state : { LV_STATE_FOCUSED, LV_STATE_FOCUS_KEY, LV_STATE_PRESSED }) {
+        lv_obj_set_style_bg_color(button, theme.mono ? theme.text : theme.border, state);
+        lv_obj_set_style_bg_opa(button, LV_OPA_COVER, state);
+        lv_obj_set_style_text_color(button, theme.mono ? theme.background : theme.accent, state);
+    }
+}
+
 lv_obj_t* addOverlayItem(UiState& ui, lv_obj_t* list, const char* text, lv_event_cb_t onClick, uint32_t id) {
     lv_obj_t* button = lv_list_add_button(list, nullptr, text);
     lv_obj_set_user_data(button, reinterpret_cast<void*>(static_cast<uintptr_t>(id)));
     lv_obj_add_event_cb(button, onClick, LV_EVENT_CLICKED, &ui);
     lv_obj_add_event_cb(button, onOverlayItemKey, LV_EVENT_KEY, &ui);
-    if (lv_group_get_default() != nullptr) {
-        lv_group_add_obj(lv_group_get_default(), button);
+    if (ui.theme.night) {
+        paintOverlayButton(button, ui.theme);
+    }
+    if (ui.overlayGroup != nullptr) {
+        lv_group_add_obj(ui.overlayGroup, button);
     }
     return button;
 }
@@ -298,7 +358,7 @@ void onMenuItem(lv_event_t* event) {
             closeOverlay(*ui);
             break;
         case MenuItem::Recording:
-            requestBits(*ui, REQUEST_TOGGLE_RECORDING);
+            toggleRecording(*ui);
             closeOverlay(*ui);
             break;
         case MenuItem::NightMode:
@@ -322,12 +382,18 @@ void openMenu(UiState& ui) {
     lv_obj_t* list = createOverlay(ui, Overlay::Menu, "GPS Viewer");
     lv_obj_t* first = addOverlayItem(ui, list, "Reset max/average speed", onMenuItem, static_cast<uint32_t>(MenuItem::ResetSpeed));
     char recordText[48];
+    const bool canRecord = ui.context->dataDirectory[0] != '\0';
     if (ui.recording) {
         snprintf(recordText, sizeof(recordText), "Stop recording (%lu lines)", static_cast<unsigned long>(ui.recordedLines));
-    } else {
+    } else if (canRecord) {
         snprintf(recordText, sizeof(recordText), "Start recording");
+    } else {
+        snprintf(recordText, sizeof(recordText), "No storage: can't record or save settings");
+    }
+    lv_obj_t* recordItem = addOverlayItem(ui, list, recordText, onMenuItem, static_cast<uint32_t>(MenuItem::Recording));
+    if (!ui.recording && !canRecord) {
+        lv_obj_add_state(recordItem, LV_STATE_DISABLED);
     }
-    addOverlayItem(ui, list, recordText, onMenuItem, static_cast<uint32_t>(MenuItem::Recording));
     addOverlayItem(ui, list, ui.settings.nightMode ? "Night mode: off" : "Night mode: on", onMenuItem, static_cast<uint32_t>(MenuItem::NightMode));
     addOverlayItem(ui, list, "Settings", onMenuItem, static_cast<uint32_t>(MenuItem::OpenSettings));
     addOverlayItem(ui, list, "Exit", onMenuItem, static_cast<uint32_t>(MenuItem::Exit));
@@ -477,7 +543,7 @@ void onContentKey(lv_event_t* event) {
             break;
         case 'l':
         case 'L':
-            requestBits(*ui, REQUEST_TOGGLE_RECORDING);
+            toggleRecording(*ui);
             break;
         default:
             break;
@@ -557,6 +623,7 @@ void clearTabs(UiState& ui) {
 }
 
 void forgetWidgets(UiState& ui) {
+    releaseOverlayGroup(ui);
     if (ui.timer != nullptr) {
         lv_timer_delete(ui.timer);
         ui.timer = nullptr;
@@ -666,9 +733,14 @@ void build(UiState& ui) {
     ui.theme = makeTheme(ui.settings.nightMode);
     lv_obj_t* root = ui.root;
 
+    // The night background is a style of a user state of the window's widget. Leaving night mode clears
+    // the state, and the window's own background is back (lv_obj_remove_local_style_prop() is not exported).
     if (ui.theme.paintBackground) {
-        lv_obj_set_style_bg_color(root, ui.theme.background, LV_PART_MAIN);
-        lv_obj_set_style_bg_opa(root, LV_OPA_COVER, LV_PART_MAIN);
+        lv_obj_set_style_bg_color(root, ui.theme.background, NIGHT_SELECTOR);
+        lv_obj_set_style_bg_opa(root, LV_OPA_COVER, NIGHT_SELECTOR);
+        lv_obj_add_state(root, NIGHT_STATE);
+    } else {
+        lv_obj_remove_state(root, NIGHT_STATE);
     }
     lv_obj_set_flex_flow(root, LV_FLEX_FLOW_COLUMN);
     lv_obj_set_style_pad_row(root, 0, LV_PART_MAIN);
diff --git a/Apps/GpsViewer/main/Source/app/Widgets.cpp b/Apps/GpsViewer/main/Source/app/Widgets.cpp
index 0c80bef..149c8bd 100644
--- a/Apps/GpsViewer/main/Source/app/Widgets.cpp
+++ b/Apps/GpsViewer/main/Source/app/Widgets.cpp
@@ -103,6 +103,10 @@ void drawIcon(lv_event_t* event) {
 
 } // namespace
 
+int measureTextWidth(const char* text, const lv_font_t* font) {
+    return textWidth(text, font);
+}
+
 lv_obj_t* createBox(lv_obj_t* parent) {
     lv_obj_t* box = lv_obj_create(parent);
     lv_obj_set_style_bg_opa(box, LV_OPA_TRANSP, LV_PART_MAIN);
diff --git a/Apps/GpsViewer/main/Source/app/Widgets.h b/Apps/GpsViewer/main/Source/app/Widgets.h
index 7b19a85..fbec711 100644
--- a/Apps/GpsViewer/main/Source/app/Widgets.h
+++ b/Apps/GpsViewer/main/Source/app/Widgets.h
@@ -25,6 +25,8 @@ void setHidden(lv_obj_t* object, bool hidden);
 // Sets the text in the largest of the LARGE, DEFAULT and SMALL fonts that fits maxWidth, only
 // when the text differs
 void setFittedText(lv_obj_t* label, const char* text, int maxWidth);
+// Width of one line of text in the font
+int measureTextWidth(const char* text, const lv_font_t* font);
 
 enum class IconKind : uint8_t {
     Sun,
diff --git a/Apps/GpsViewer/main/Source/core/GnssModel.cpp b/Apps/GpsViewer/main/Source/core/GnssModel.cpp
index 8ecb2ad..57419b9 100644
--- a/Apps/GpsViewer/main/Source/core/GnssModel.cpp
+++ b/Apps/GpsViewer/main/Source/core/GnssModel.cpp
@@ -14,6 +14,16 @@ bool olderThan(uint32_t nowMs, uint32_t thenMs, uint32_t ageMs) {
     return static_cast<uint32_t>(nowMs - thenMs) > ageMs;
 }
 
+// A time of 0 means the sentence never came
+bool fresh(uint32_t nowMs, uint32_t atMs) {
+    return atMs != 0 && !olderThan(nowMs, atMs, FIX_TIMEOUT_MS);
+}
+
+// Event times are 0 only in the first millisecond of uptime, which then counts as never
+uint32_t stamp(uint32_t nowMs) {
+    return nowMs == 0 ? 1 : nowMs;
+}
+
 float toFloatOrNan(const minmea_float& value) {
     return value.scale == 0 ? NAN : minmea_tofloat(&value);
 }
@@ -39,8 +49,10 @@ void GnssModel::reset(uint32_t nowMs) {
     ggaSatellites = 0;
     ggaAtMs = 0;
     rmcValid = false;
+    rmcAtMs = 0;
     pdop = NAN;
-    hdop = NAN;
+    gsaHdop = NAN;
+    ggaHdop = NAN;
     vdop = NAN;
     hasTtff = false;
     ttffMs = 0;
@@ -73,8 +85,8 @@ void GnssModel::onEvent(const GnssEvent& event, uint32_t nowMs) {
 }
 
 void GnssModel::onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs) {
-    (void)nowMs;
     rmcValid = rmc.valid;
+    rmcAtMs = stamp(nowMs);
     if (rmc.date.year > 0 && rmc.time.hours >= 0) {
         utcTime.valid = true;
         utcTime.year = rmc.date.year < 100 ? 2000 + rmc.date.year : rmc.date.year;
@@ -113,14 +125,12 @@ void GnssModel::onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs) {
 void GnssModel::onGga(const minmea_sentence_gga& gga, uint32_t nowMs) {
     ggaFix = gga.fix_quality > 0;
     ggaSatellites = gga.satellites_tracked;
-    ggaAtMs = nowMs;
+    ggaAtMs = stamp(nowMs);
+    ggaHdop = ggaFix ? toFloatOrNan(gga.hdop) : NAN;
     if (!ggaFix) {
+        hasAltitude = false;
         return;
     }
-    const float ggaHdop = toFloatOrNan(gga.hdop);
-    if (!std::isnan(ggaHdop) && olderThan(nowMs, gsaAtMs, FIX_TIMEOUT_MS)) {
-        hdop = ggaHdop;
-    }
     const double lat = toCoordinate(gga.latitude);
     const double lon = toCoordinate(gga.longitude);
     if (!std::isnan(lat) && !std::isnan(lon)) {
@@ -136,22 +146,33 @@ void GnssModel::onGga(const minmea_sentence_gga& gga, uint32_t nowMs) {
 }
 
 void GnssModel::onGsa(const minmea_sentence_gsa& gsa, uint32_t nowMs) {
-    gsaAtMs = nowMs;
+    gsaAtMs = stamp(nowMs);
     gsaFix = gsa.fix_type == MINMEA_GPGSA_FIX_3D ? FixType::Fix3d
         : gsa.fix_type == MINMEA_GPGSA_FIX_2D ? FixType::Fix2d
         : FixType::None;
     pdop = toFloatOrNan(gsa.pdop);
-    hdop = toFloatOrNan(gsa.hdop);
+    gsaHdop = toFloatOrNan(gsa.hdop);
     vdop = toFloatOrNan(gsa.vdop);
 }
 
+FixType GnssModel::currentFix(uint32_t nowMs) const {
+    const bool gsaFresh = fresh(nowMs, gsaAtMs);
+    const bool ggaFresh = fresh(nowMs, ggaAtMs);
+    if (ggaFresh && !ggaFix) {
+        return FixType::None;
+    }
+    if (gsaFresh) {
+        return gsaFix;
+    }
+    return ggaFresh ? FixType::Fix3d : FixType::None;
+}
+
+// TTFF uses the same fix as the screens, plus a valid RMC for the position
 void GnssModel::updateFixState(uint32_t nowMs) {
     if (hasTtff) {
         return;
     }
-    const bool gsaSaysFix = gsaFix != FixType::None && !olderThan(nowMs, gsaAtMs, FIX_TIMEOUT_MS);
-    const bool ggaSaysFix = ggaFix && !olderThan(nowMs, ggaAtMs, FIX_TIMEOUT_MS);
-    if ((gsaSaysFix || ggaSaysFix) && rmcValid) {
+    if (currentFix(nowMs) != FixType::None && rmcValid && fresh(nowMs, rmcAtMs)) {
         hasTtff = true;
         ttffMs = nowMs - startMs;
     }
@@ -166,17 +187,10 @@ void GnssModel::resetSpeedStats() {
 void GnssModel::snapshot(GnssSnapshot& out, uint32_t nowMs) {
     satellites.expire(nowMs);
 
-    const bool gsaFresh = !olderThan(nowMs, gsaAtMs, FIX_TIMEOUT_MS) && gsaAtMs != 0;
-    const bool ggaFresh = !olderThan(nowMs, ggaAtMs, FIX_TIMEOUT_MS) && ggaAtMs != 0;
-    FixType fix = FixType::None;
-    if (gsaFresh) {
-        fix = gsaFix;
-    } else if (ggaFresh && ggaFix) {
-        fix = FixType::Fix3d;
-    }
-    if (ggaFresh && !ggaFix) {
-        fix = FixType::None;
-    }
+    const bool gsaFresh = fresh(nowMs, gsaAtMs);
+    const bool ggaFresh = fresh(nowMs, ggaAtMs);
+    const bool rmcFresh = fresh(nowMs, rmcAtMs);
+    const FixType fix = currentFix(nowMs);
 
     out.fix = fix;
     out.satellitesInView = satellites.count();
@@ -185,7 +199,8 @@ void GnssModel::snapshot(GnssSnapshot& out, uint32_t nowMs) {
         out.satellitesUsed = ggaSatellites;
     }
     out.pdop = gsaFresh ? pdop : NAN;
-    out.hdop = (gsaFresh || ggaFresh) ? hdop : NAN;
+    // GSA gives all three DOP values of one solution, GGA's HDOP stands in without GSA
+    out.hdop = gsaFresh ? gsaHdop : ggaFresh ? ggaHdop : NAN;
     out.vdop = gsaFresh ? vdop : NAN;
     out.hasTtff = hasTtff;
     out.ttffMs = ttffMs;
@@ -193,9 +208,9 @@ void GnssModel::snapshot(GnssSnapshot& out, uint32_t nowMs) {
     out.hasPosition = hasPosition;
     out.latitude = latitude;
     out.longitude = longitude;
-    out.hasAltitude = hasAltitude && fix == FixType::Fix3d;
+    out.hasAltitude = hasAltitude && ggaFresh && fix == FixType::Fix3d;
     out.altitudeMeters = altitudeMeters;
-    out.hasSpeed = hasSpeed && fix != FixType::None;
+    out.hasSpeed = hasSpeed && rmcFresh && fix != FixType::None;
     out.speedMps = speedMps;
     out.maxSpeedMps = maxSpeedMps;
     out.averageSpeedMps = speedSamples == 0 ? 0.0f : static_cast<float>(speedSum / speedSamples);
diff --git a/Apps/GpsViewer/main/Source/core/GnssModel.h b/Apps/GpsViewer/main/Source/core/GnssModel.h
index e3505a5..34780a4 100644
--- a/Apps/GpsViewer/main/Source/core/GnssModel.h
+++ b/Apps/GpsViewer/main/Source/core/GnssModel.h
@@ -68,6 +68,8 @@ class GnssModel {
     void onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs);
     void onGga(const minmea_sentence_gga& gga, uint32_t nowMs);
     void onGsa(const minmea_sentence_gsa& gsa, uint32_t nowMs);
+    // The fix shown at nowMs: a fresh GSA decides, a fresh GGA without a fix overrides it
+    FixType currentFix(uint32_t nowMs) const;
     void updateFixState(uint32_t nowMs);
 
     SatelliteDb satellites;
@@ -78,14 +80,17 @@ class GnssModel {
     int ggaSatellites = 0;
     uint32_t ggaAtMs = 0;
     bool rmcValid = false;
+    uint32_t rmcAtMs = 0;
     float pdop = 0;
-    float hdop = 0;
+    float gsaHdop = 0;
+    float ggaHdop = 0;
     float vdop = 0;
     bool hasTtff = false;
     uint32_t ttffMs = 0;
     bool hasPosition = false;
     double latitude = 0;
     double longitude = 0;
+    // Altitude comes from GGA, speed and course from RMC. Each expires with its sentence.
     bool hasAltitude = false;
     float altitudeMeters = 0;
     bool hasSpeed = false;
diff --git a/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp b/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
index bac87d3..59d1f07 100644
--- a/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
+++ b/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
@@ -7,8 +7,9 @@ namespace gpsviewer {
 
 namespace {
 
-// A second GSV set of the same talker within this time belongs to the same epoch.
-// Receivers send one set per signal band (L1, L5), so the sets are merged.
+// GSV sets of the same talker within this time of the epoch's first set belong to that epoch.
+// Receivers send one set per signal band (L1, L5) right after each other, so the sets are merged.
+// The window is counted from the first set, so a receiver sending faster than this still starts new epochs.
 constexpr uint32_t SAME_EPOCH_MS = 500;
 // Combined (GN) GSA sentences closer together than this belong to one epoch
 constexpr uint32_t GSA_EPOCH_MS = 300;
@@ -111,7 +112,7 @@ void SatelliteDb::onGsv(const char* talker, const minmea_sentence_gsv& gsv, uint
 
 void SatelliteDb::commit(int group, uint32_t nowMs) {
     PendingSet& set = groups[group];
-    const bool merge = set.committed && !olderThan(nowMs, set.committedAtMs, SAME_EPOCH_MS);
+    const bool merge = set.committed && !olderThan(nowMs, set.epochStartMs, SAME_EPOCH_MS);
 
     if (!merge) {
         int kept = 0;
@@ -125,6 +126,7 @@ void SatelliteDb::commit(int group, uint32_t nowMs) {
                 Satellite& fresh = set.satellites[j];
                 if (fresh.system == satellites[i].system && fresh.id == satellites[i].id) {
                     fresh.used = satellites[i].used;
+                    fresh.usedBy = satellites[i].usedBy;
                     fresh.usedAtMs = satellites[i].usedAtMs;
                 }
             }
@@ -152,8 +154,10 @@ void SatelliteDb::commit(int group, uint32_t nowMs) {
         existing.lastSeenMs = nowMs;
     }
 
+    if (!merge) {
+        set.epochStartMs = nowMs;
+    }
     set.committed = true;
-    set.committedAtMs = nowMs;
 }
 
 // Combined GSA sentences don't say their system in minmea's fields. Receivers send one per system
@@ -181,10 +185,12 @@ GnssSystem SatelliteDb::guessGsaSystem(const int* ids, int idCount) const {
     return best;
 }
 
+// A GSA sentence replaces the used flags it set last time, so a GP sentence also clears the
+// SBAS and QZSS satellites it listed before, and leaves those of a QZ or GN sentence alone
 void SatelliteDb::markUsed(GnssSystem gsaSystem, const int* ids, int idCount, uint32_t nowMs) {
     if (gsaSystem != GnssSystem::Unknown) {
         for (int i = 0; i < satelliteCount; i++) {
-            if (satellites[i].system == gsaSystem) {
+            if (satellites[i].used && satellites[i].usedBy == gsaSystem) {
                 satellites[i].used = false;
             }
         }
@@ -193,11 +199,18 @@ void SatelliteDb::markUsed(GnssSystem gsaSystem, const int* ids, int idCount, ui
         const int index = find(usedIdSystem(gsaSystem, ids[i]), ids[i]);
         if (index >= 0) {
             satellites[index].used = true;
+            satellites[index].usedBy = gsaSystem;
             satellites[index].usedAtMs = nowMs;
         }
     }
 }
 
+void SatelliteDb::clearUsed() {
+    for (int i = 0; i < satelliteCount; i++) {
+        satellites[i].used = false;
+    }
+}
+
 // Used IDs belong to the talker's system when the talker names one. A GP talker can also list
 // SBAS (33..64, 120..158) and QZSS (193..202) IDs. Combined talkers are resolved by guessGsaSystem().
 void SatelliteDb::onGsa(const char* talker, const minmea_sentence_gsa& gsa, uint32_t nowMs) {
@@ -212,6 +225,11 @@ void SatelliteDb::onGsa(const char* talker, const minmea_sentence_gsa& gsa, uint
     GnssSystem system = systemFromTalker(talker);
     if (system == GnssSystem::Unknown) {
         if (idCount == 0) {
+            // An empty combined sentence without a fix: no satellite is used. With a fix it's
+            // only a system without used satellites, and its system can't be told.
+            if (gsa.fix_type != MINMEA_GPGSA_FIX_2D && gsa.fix_type != MINMEA_GPGSA_FIX_3D) {
+                clearUsed();
+            }
             return;
         }
         if (combinedGsaAtMs == 0 || olderThan(nowMs, combinedGsaAtMs, GSA_EPOCH_MS)) {
diff --git a/Apps/GpsViewer/main/Source/core/SatelliteDb.h b/Apps/GpsViewer/main/Source/core/SatelliteDb.h
index a7a037c..4bf1867 100644
--- a/Apps/GpsViewer/main/Source/core/SatelliteDb.h
+++ b/Apps/GpsViewer/main/Source/core/SatelliteDb.h
@@ -18,6 +18,8 @@ struct Satellite {
     // dB-Hz, 0 when not tracked
     int16_t snr;
     bool used;
+    // The GSA sentence that marked it used: its talker's system, or the system picked for a combined talker
+    GnssSystem usedBy;
     uint32_t lastSeenMs;
     uint32_t usedAtMs;
 };
@@ -47,7 +49,8 @@ class SatelliteDb {
         int nextMessage;
         int count;
         Satellite satellites[MAX_SATELLITES];
-        uint32_t committedAtMs;
+        // First commit of the current epoch. Later sets within SAME_EPOCH_MS of it are merged into it.
+        uint32_t epochStartMs;
         bool committed;
     };
 
@@ -55,6 +58,7 @@ class SatelliteDb {
     void commit(int group, uint32_t nowMs);
     int find(GnssSystem system, int id) const;
     void markUsed(GnssSystem system, const int* ids, int idCount, uint32_t nowMs);
+    void clearUsed();
     GnssSystem guessGsaSystem(const int* ids, int idCount) const;
 
     Satellite satellites[MAX_SATELLITES] {};
diff --git a/Apps/GpsViewer/manifest.properties b/Apps/GpsViewer/manifest.properties
index 6669bf8..d2787d6 100644
--- a/Apps/GpsViewer/manifest.properties
+++ b/Apps/GpsViewer/manifest.properties
@@ -1,6 +1,6 @@
 manifest.version=0.3
 target.sdk=0.8.0-dev
-target.platforms=all
+target.platforms=esp32,esp32s3,esp32c6,esp32p4
 id=tactility.gpsviewer
 version.name=0.1.0
 version.code=1