Merge lp:~thomas-voss/location-service/add-ubx-provider into lp:location-service

[Thomas Voß]

Add ubx provider implementation.

Add ubx provider implementation.

[lp:~thomas-voss/location-service/add-ubx-provider]

276. By Thomas Voß on 2016-10-11

Adjust plug/slot naming.

277. By Thomas Voß on 2016-10-11

Add commands locationd.list and locationd.provide.

278. By Thomas Voß on 2016-10-11

Fix command name.

[Scott Sweeny (ssweeny)]

Overall the code LGTM.

Could you clarify why you removed the LGPL test and explain a bit about the new commands?

Thanks.

review: Needs Information (code)

[Thomas Voß (thomas-voss)]

top-approving and merging to enable a package build.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-08-26 13:11:26 +0000
+++ CMakeLists.txt	2016-10-11 08:54:12 +0000
@@ -132,9 +132,4 @@
 add_subdirectory(src)
 add_subdirectory(tests)
 
-# There's no nice way to format this. Thanks CMake.
-add_test(LGPL-required
-  /bin/sh -c "! grep -rl 'GNU General' ${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/include"
-)
-
 enable_coverage_report(service)

=== removed directory 'build'
=== removed directory 'build/src'
=== modified file 'snapcraft.yaml'
--- snapcraft.yaml	2016-08-30 11:04:45 +0000
+++ snapcraft.yaml	2016-10-11 08:54:12 +0000
@@ -14,24 +14,29 @@
   run:
     daemon: simple
     command: bin/locationd run --bus=system
-    slots: [control, observe]
+    slots: [service-control, service-observe]
     plugs: [network-manager]
+  list-providers:
+    command: bin/locationd list    
   status:
     command: bin/locationd status --bus=system
-    plugs: [control]
+    plugs: [client-observe]
   monitor:
     command: bin/locationd monitor --bus=system
-    plugs: [observe]
+    plugs: [client-control]
+  provide:
+    command: bin/locationd provider --bus=system
+    plugs: [client-control]
 
 slots:
-    observe:
+    service-observe:
         interface: location-observe
-    control:
+    service-control:
         interface: location-control
 plugs:
-    observe:
+    client-observe:
         interface: location-observe
-    control:
+    client-control:
         interface: location-control
 
 parts:

=== modified file 'src/location/providers/CMakeLists.txt'
--- src/location/providers/CMakeLists.txt	2016-08-14 19:36:05 +0000
+++ src/location/providers/CMakeLists.txt	2016-10-11 08:54:12 +0000
@@ -3,6 +3,7 @@
 add_subdirectory(mls)
 add_subdirectory(remote)
 add_subdirectory(gps)
+add_subdirectory(ubx)
 
 set(
   ENABLED_PROVIDER_TARGETS

=== modified file 'src/location/providers/config.cpp'
--- src/location/providers/config.cpp	2016-08-14 19:36:05 +0000
+++ src/location/providers/config.cpp	2016-10-11 08:54:12 +0000
@@ -20,6 +20,7 @@
 
 #include "dummy/provider.h"
 #include "mls/provider.h"
+#include "ubx/provider.h"
 
 #include <map>
 
@@ -46,6 +47,12 @@
     location::providers::mls::Provider::create_instance
 };
 
+static FactoryInjector ubx_injector
+{
+    "ubx::Provider",
+    location::providers::ubx::Provider::create_instance
+};
+
 #if defined(LOCATION_PROVIDERS_GPS)
 #include <location/providers/gps/provider.h>
 static FactoryInjector gps_injector

=== added directory 'src/location/providers/ubx'
=== added file 'src/location/providers/ubx/CMakeLists.txt'
--- src/location/providers/ubx/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/CMakeLists.txt	2016-10-11 08:54:12 +0000
@@ -0,0 +1,18 @@
+file(GLOB_RECURSE UBX_HEADERS*.h)
+
+add_library(
+  ubx
+
+  ${UBX_HEADERS}
+
+  _8/receiver.cpp
+  _8/serial_port_receiver.cpp
+  _8/nmea/scanner.cpp
+  _8/nmea/sentence.cpp
+
+  provider.h provider.cpp)
+
+set(
+  ENABLED_PROVIDER_TARGETS
+  ${ENABLED_PROVIDER_TARGETS} ubx
+  PARENT_SCOPE)

=== added directory 'src/location/providers/ubx/_8'
=== added file 'src/location/providers/ubx/_8/marshaller.h'
--- src/location/providers/ubx/_8/marshaller.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/marshaller.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,42 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_MARSHALLER_H_
+#define UBX_8_MARSHALLER_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+/// @brief Marshaller abstracts marshaling of arbitrary messages.
+class Marshaller
+{
+public:
+    virtual ~Marshaller() = default;
+
+    /// @brief marshal returns a message
+    /// ready to be sent over the wire to a ublox
+    /// receiver.
+    virtual Message marshal() const = 0;
+};
+}
+}
+}
+}
+
+#endif // UBX_8_MARSHALLER_H_

=== added file 'src/location/providers/ubx/_8/message.h'
--- src/location/providers/ubx/_8/message.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/message.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_SCANNER_H_
+#define UBX_8_SCANNER_H_
+
+#include <cstdint>
+
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+static constexpr const std::uint8_t sync_char_1{0xb5};
+static constexpr const std::uint8_t sync_char_2{62};
+
+enum class Class
+{
+    cfg = 0x06
+};
+
+enum class Id
+{
+};
+
+struct Message
+{
+    Class cls;
+    Id id;
+    std::uint16_t length;
+    std::vector<std::uint8_t> payload;
+    std::uint8_t ck_a;
+    std::uint8_t ck_b;
+};
+}
+}
+}
+}
+
+#endif // UBX_8_SCANNER_H_

=== added directory 'src/location/providers/ubx/_8/nmea'
=== added file 'src/location/providers/ubx/_8/nmea/cardinal_direction.h'
--- src/location/providers/ubx/_8/nmea/cardinal_direction.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/cardinal_direction.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_CARDINAL_DIRECTION_H_
+#define UBX_8_NMEA_CARDINAL_DIRECTION_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief CardinalDirection enumerates the main cardinal direction
+/// available in NMEA sentences.
+enum class CardinalDirection
+{
+    north = 'N',
+    south = 'S',
+    east = 'E',
+    west = 'W'
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_CARDINAL_DIRECTION_H_

=== added file 'src/location/providers/ubx/_8/nmea/date.h'
--- src/location/providers/ubx/_8/nmea/date.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/date.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_DATE_H_
+#define UBX_8_NMEA_DATE_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Date models a specific calendar day (Gregorian calendar).
+struct Date
+{
+    std::uint8_t day;
+    std::uint8_t month;
+    std::uint8_t year;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_DATE_H_

=== added file 'src/location/providers/ubx/_8/nmea/fusion_adapt.h'
--- src/location/providers/ubx/_8/nmea/fusion_adapt.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/fusion_adapt.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,134 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_FUSION_ADAPT_H_
+#define UBX_8_NMEA_FUSION_ADAPT_H_
+
+#define BOOST_SPIRIT_DEBUG
+#define FUSION_MAX_VECTOR_SIZE 15
+
+#include <location/providers/ubx/_8/nmea/sentence.h>
+
+#include <boost/fusion/adapted/struct.hpp>
+
+// clang-format off
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Latitude,
+    (uint32_t, degrees)
+    (double, minutes))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Longitude,
+    (uint32_t, degrees)
+    (double, minutes))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Date,
+    (std::uint8_t, day)
+    (std::uint8_t, month)
+    (std::uint8_t, year))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Utc,
+    (std::uint8_t, hours)
+    (std::uint8_t, minutes)
+    (double, seconds))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Gsa,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<location::providers::ubx::_8::nmea::Gsa::OperationMode>, operation_mode)
+    (boost::optional<location::providers::ubx::_8::nmea::Gsa::FixMode>, fix_mode)
+    (std::vector<boost::optional<std::uint8_t>>, satellite_ids)
+    (boost::optional<location::providers::ubx::Dop<location::providers::ubx::tag::Positional>>, pdop)
+    (boost::optional<location::providers::ubx::Dop<location::providers::ubx::tag::Horizontal>>, hdop)
+    (boost::optional<location::providers::ubx::Dop<location::providers::ubx::tag::Vertical>>, vdop))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Gga,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<location::providers::ubx::_8::nmea::Utc>, utc)
+    (boost::optional<location::providers::ubx::_8::nmea::Latitude>, latitude)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, latitude_direction)
+    (boost::optional<location::providers::ubx::_8::nmea::Longitude>, longitude)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, longitude_direction)
+    (boost::optional<location::providers::ubx::_8::nmea::gps::FixMode>, fix_mode)
+    (boost::optional<std::uint8_t>, satellites_in_use)
+    (boost::optional<location::providers::ubx::Dop<location::providers::ubx::tag::Horizontal>>, hdop)
+    (boost::optional<float>, altitude)
+    (boost::optional<float>, geoidal_separation)
+    (boost::optional<float>, age)
+    (boost::optional<std::uint16_t>, differential_reference_station))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Gll,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<location::providers::ubx::_8::nmea::Latitude>, latitude)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, latitude_direction)
+    (boost::optional<location::providers::ubx::_8::nmea::Longitude>, longitude)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, longitude_direction)
+    (boost::optional<location::providers::ubx::_8::nmea::Utc>, utc)
+    (boost::optional<location::providers::ubx::_8::nmea::Status>, status)
+    (boost::optional<location::providers::ubx::_8::nmea::Mode>, mode))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Gsv::Info,
+    (boost::optional<std::uint8_t>, satellite_id)
+    (boost::optional<std::uint8_t>, elevation)
+    (boost::optional<std::uint16_t>, azimuth)
+    (boost::optional<std::uint8_t>, snr))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Gsv,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<std::uint8_t>, sentence_count)
+    (boost::optional<std::uint8_t>, sentence_number)
+    (boost::optional<std::uint8_t>, satellites_count)
+    (std::vector<location::providers::ubx::_8::nmea::Gsv::Info>, satellites_info))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Rmc,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<location::providers::ubx::_8::nmea::Utc>, utc)
+    (boost::optional<location::providers::ubx::_8::nmea::Status>, status)
+    (boost::optional<location::providers::ubx::_8::nmea::Latitude>, latitude)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, latitude_direction)
+    (boost::optional<location::providers::ubx::_8::nmea::Longitude>, longitude)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, longitude_direction)
+    (boost::optional<float>, speed_over_ground)(boost::optional<float>, course_over_ground)
+    (boost::optional<location::providers::ubx::_8::nmea::Date>, date)
+    (boost::optional<float>, magnetic_variation)
+    (boost::optional<location::providers::ubx::_8::nmea::CardinalDirection>, cardinal_direction)
+    (boost::optional<location::providers::ubx::_8::nmea::Mode>, mode))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Txt,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<std::uint8_t>, total_number_of_sentences)
+    (boost::optional<std::uint8_t>, sentence_number)
+    (boost::optional<std::uint8_t>, identifier)
+    (boost::optional<std::string>, message))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::providers::ubx::_8::nmea::Vtg,
+    (location::providers::ubx::_8::nmea::Talker, talker)
+    (boost::optional<float>, cog_true)
+    (boost::optional<float>, cog_magnetic)
+    (boost::optional<float>, sog_knots)
+    (boost::optional<float>, sog_kmh)
+    (boost::optional<location::providers::ubx::_8::nmea::Mode>, mode))
+
+// clang-format on
+
+#endif // UBX_8_NMEA_FUSION_ADAPT_H_

=== added file 'src/location/providers/ubx/_8/nmea/generator.h'
--- src/location/providers/ubx/_8/nmea/generator.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/generator.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,254 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GENERATOR_H_
+#define UBX_8_NMEA_GENERATOR_H_
+
+#define BOOST_SPIRIT_DEBUG
+#define FUSION_MAX_VECTOR_SIZE 15
+
+#include <location/providers/ubx/_8/nmea/sentence.h>
+
+#include <location/providers/ubx/_8/nmea/fusion_adapt.h>
+
+#include <boost/spirit/include/classic.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/karma_real.hpp>
+#include <boost/spirit/include/karma_uint.hpp>
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+
+template <unsigned prec, typename T>
+struct FinitePrecisionPolicy : boost::spirit::karma::real_policies<T>
+{
+    static int floatfield(T) { return boost::spirit::karma::real_policies<T>::fmtflags::fixed; }
+    static unsigned precision(T) { return prec; }
+};
+
+template <typename Iterator>
+class Generator : public boost::spirit::karma::grammar<Iterator, Sentence()>
+{
+public:
+    Generator() : Generator::base_type{start}
+    {
+        // clang-format off
+    start %= (gga | gsa | gll | gsv | rmc | txt | vtg);
+    field_separator %= ',';
+    checksum %= boost::spirit::karma::hex;
+    talker.add
+        (Talker::gl, "GL")
+        (Talker::gn, "GN")
+        (Talker::gp, "GP");
+    status.add
+        (Status::valid, 'A')
+        (Status::not_valid, 'V');
+    mode.add
+        (Mode::autonomous, 'A')
+        (Mode::differential, 'D')
+        (Mode::estimated, 'E')
+        (Mode::manual_input, 'M')
+        (Mode::simulator_mode, 'S')
+        (Mode::data_not_valid, 'N');
+    cardinal_direction.all.add
+        (CardinalDirection::north, 'N')
+        (CardinalDirection::south, 'S')
+        (CardinalDirection::east, 'E')
+        (CardinalDirection::west, 'W');
+    cardinal_direction.ns.add
+        (CardinalDirection::north, 'N')
+        (CardinalDirection::south, 'S');
+    cardinal_direction.ew.add
+        (CardinalDirection::east, 'E')
+        (CardinalDirection::west, 'W');
+    gps.fix_mode.add
+        (gps::FixMode::invalid, '0')
+        (gps::FixMode::gps_sps, '1')
+        (gps::FixMode::differential_gps_sps, '2')
+        (gps::FixMode::gps_pps, '3')
+        (gps::FixMode::real_time_kinematic, '4')
+        (gps::FixMode::floating_point_real_time_kinematic, '5')
+        (gps::FixMode::estimated, '6')
+        (gps::FixMode::manual_input, '7')
+        (gps::FixMode::simulator, '8');
+    for_gsa.operation_mode.add
+        (Gsa::OperationMode::automatic, 'A')
+        (Gsa::OperationMode::manual, 'M');    
+    for_gsa.fix_mode.add
+        (Gsa::FixMode::fix_not_available, '1')
+        (Gsa::FixMode::fix_in_2d, '2')
+        (Gsa::FixMode::fix_in_3d, '3');
+
+    pdop %= boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>();
+    hdop %= boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>();
+    vdop %= boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>();
+
+    latitude %= boost::spirit::karma::right_align(2, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()] <<
+                boost::spirit::karma::real_generator<double, FinitePrecisionPolicy<5, double>>();
+
+    longitude %= boost::spirit::karma::right_align(3, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()] <<
+                 boost::spirit::karma::real_generator<double, FinitePrecisionPolicy<5, double>>();
+
+    date %= boost::spirit::karma::right_align(2, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()] <<
+            boost::spirit::karma::right_align(2, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()] <<
+            boost::spirit::karma::right_align(2, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()];
+
+    utc %= boost::spirit::karma::right_align(2, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()] <<
+           boost::spirit::karma::right_align(2, '0')[boost::spirit::karma::uint_generator<std::uint32_t, 10>()] <<
+           boost::spirit::karma::real_generator<double, FinitePrecisionPolicy<5, double>>();
+
+    gsa %= talker << "GSA"                                                                          << field_separator
+                  << -for_gsa.operation_mode                                                        << field_separator
+                  << -for_gsa.fix_mode                                                              << field_separator
+                  << boost::spirit::karma::repeat(12)[boost::spirit::karma::right_align(2, '0')
+                     [-boost::spirit::karma::uint_generator<std::uint32_t, 10>()]                   << field_separator]
+                  << -pdop                                                                          << field_separator
+                  << -hdop                                                                          << field_separator
+                  << -vdop;
+
+    gga %= talker << "GGA"                                                                                                  << field_separator
+                  << -utc                                                                                                   << field_separator
+                  << -(latitude)                                                                                            << field_separator
+                  << -(cardinal_direction.ns)                                                                               << field_separator
+                  << -(longitude)                                                                                           << field_separator
+                  << -(cardinal_direction.ew)                                                                               << field_separator
+                  << -gps.fix_mode                                                                                          << field_separator
+                  << boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint32_t, 10>()]  << field_separator
+                  << -hdop                                                                                                  << field_separator
+                  << -(boost::spirit::karma::real_generator<float>())                                                       << field_separator
+                  << -boost::spirit::karma::lit('M')                                                                        << field_separator
+                  << -(boost::spirit::karma::real_generator<float>())                                                       << field_separator
+                  << -boost::spirit::karma::lit('M')                                                                        << field_separator
+                  << -boost::spirit::karma::real_generator<float>()                                                         << field_separator
+                  << boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint32_t, 10>()];
+
+    gll %= talker << "GLL"                  << field_separator
+                  << -latitude              << field_separator
+                  << -cardinal_direction.ns << field_separator
+                  << -longitude             << field_separator
+                  << -cardinal_direction.ew << field_separator
+                  << -utc                   << field_separator
+                  << -status                << field_separator
+                  << -mode;
+
+    gsv_info %= field_separator <<
+                boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()] <<
+                field_separator <<
+                boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()] <<
+                field_separator <<
+                boost::spirit::karma::right_align(3, '0')[-boost::spirit::karma::uint_generator<std::uint16_t, 10>()] <<
+                field_separator <<
+                boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()];
+
+    gsv %= talker << "GSV" << field_separator
+                  << boost::spirit::karma::maxwidth(1)[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()]           << field_separator
+                  << boost::spirit::karma::maxwidth(1)[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()]           << field_separator
+                  << boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint16_t, 10>()]
+                  << +(gsv_info);
+
+    rmc %= talker << "RMC"                                                                              << field_separator
+                  << -utc                                                                               << field_separator
+                  << -status                                                                            << field_separator
+                  << -(latitude)                                                                        << field_separator
+                  << -(cardinal_direction.ns)                                                           << field_separator
+                  << -(longitude)                                                                       << field_separator
+                  << -(cardinal_direction.ew)                                                           << field_separator
+                  << -(boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>())  << field_separator
+                  << -(boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>())  << field_separator
+                  << -date                                                                              << field_separator
+                  << -(boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>())  << field_separator
+                  << -(cardinal_direction.ew)                                                           << field_separator
+                  << -mode;
+
+    txt %= talker << "TXT" << field_separator
+                  << boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()] << field_separator
+                  << boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()] << field_separator
+                  << boost::spirit::karma::right_align(2, '0')[-boost::spirit::karma::uint_generator<std::uint8_t, 10>()] << field_separator
+                  << -boost::spirit::karma::ascii::string;
+
+    vtg %= talker << "VTG"                                                                            << field_separator
+                  << -boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>()  << field_separator
+                  << 'T'                                                                              << field_separator
+                  << -boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>()  << field_separator
+                  << 'M'                                                                              << field_separator
+                  << -boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>()  << field_separator
+                  << 'N'                                                                              << field_separator
+                  << -boost::spirit::karma::real_generator<float, FinitePrecisionPolicy<5, float>>()  << field_separator
+                  << 'K'                                                                              << field_separator
+                  << -mode;
+        // clang-format on
+    }
+
+private:
+    boost::spirit::karma::rule<Iterator, Sentence()> start;
+    boost::spirit::karma::rule<Iterator> field_separator;
+    boost::spirit::karma::rule<Iterator, std::uint32_t()> checksum;
+    boost::spirit::karma::rule<Iterator, Latitude()> latitude;
+    boost::spirit::karma::rule<Iterator, Longitude()> longitude;
+    boost::spirit::karma::rule<Iterator, Date()> date;
+    boost::spirit::karma::rule<Iterator, Utc()> utc;
+    boost::spirit::karma::rule<Iterator, Dop<tag::Positional>()> pdop;
+    boost::spirit::karma::rule<Iterator, Dop<tag::Horizontal>()> hdop;
+    boost::spirit::karma::rule<Iterator, Dop<tag::Vertical>()> vdop;
+
+    boost::spirit::karma::rule<Iterator, Gsa()> gsa;
+    boost::spirit::karma::rule<Iterator, Gga()> gga;
+    boost::spirit::karma::rule<Iterator, Gll()> gll;
+    boost::spirit::karma::rule<Iterator, Gsv::Info()> gsv_info;
+    boost::spirit::karma::rule<Iterator, Gsv()> gsv;
+    boost::spirit::karma::rule<Iterator, Rmc()> rmc;
+    boost::spirit::karma::rule<Iterator, Txt()> txt;
+    boost::spirit::karma::rule<Iterator, Vtg()> vtg;
+
+    // Enumerations go here
+    boost::spirit::karma::symbols<Talker, const char*> talker;
+    boost::spirit::karma::symbols<Status, char> status;
+    boost::spirit::karma::symbols<Mode, char> mode;
+    struct
+    {
+        boost::spirit::karma::symbols<CardinalDirection, char> all;
+        boost::spirit::karma::symbols<CardinalDirection, char> ns;
+        boost::spirit::karma::symbols<CardinalDirection, char> ew;
+    } cardinal_direction;
+
+    // Positioning-system specific rules go here
+    struct
+    {
+        boost::spirit::karma::symbols<gps::FixMode, char> fix_mode;
+    } gps;
+
+    // Sentence-specific rules go here
+    struct
+    {
+        boost::spirit::karma::symbols<Gsa::OperationMode, char> operation_mode;
+        boost::spirit::karma::symbols<Gsa::FixMode, char> fix_mode;
+    } for_gsa;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GENERATOR_H_

=== added file 'src/location/providers/ubx/_8/nmea/gga.h'
--- src/location/providers/ubx/_8/nmea/gga.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/gga.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,69 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GGA_H_
+#define UBX_8_NMEA_GGA_H_
+
+#include <location/providers/ubx/dop.h>
+
+#include <location/providers/ubx/_8/nmea/cardinal_direction.h>
+#include <location/providers/ubx/_8/nmea/latitude.h>
+#include <location/providers/ubx/_8/nmea/longitude.h>
+#include <location/providers/ubx/_8/nmea/talker.h>
+#include <location/providers/ubx/_8/nmea/utc.h>
+
+#include <location/providers/ubx/_8/nmea/gps/fix_mode.h>
+
+#include <boost/optional.hpp>
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Global positioning system fix data.
+///
+/// Time and position, together with GPS fixing related data (number of
+/// satellites in use, and
+/// the resulting HDOP, age of differential data if in use, etc.).
+struct Gga
+{
+    Talker talker;
+    boost::optional<Utc> utc;
+    boost::optional<Latitude> latitude;
+    boost::optional<CardinalDirection> latitude_direction;
+    boost::optional<Longitude> longitude;
+    boost::optional<CardinalDirection> longitude_direction;
+    boost::optional<gps::FixMode> fix_mode;
+    boost::optional<std::uint8_t> satellites_in_use;
+    boost::optional<Dop<tag::Horizontal>> hdop;
+    boost::optional<float> altitude;
+    boost::optional<float> geoidal_separation;
+    boost::optional<float> age; // [s]
+    boost::optional<std::uint16_t> differential_reference_station;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GGA_H_

=== added file 'src/location/providers/ubx/_8/nmea/gll.h'
--- src/location/providers/ubx/_8/nmea/gll.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/gll.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GLL_H_
+#define UBX_8_NMEA_GLL_H_
+
+#include <location/providers/ubx/_8/nmea/cardinal_direction.h>
+#include <location/providers/ubx/_8/nmea/latitude.h>
+#include <location/providers/ubx/_8/nmea/longitude.h>
+#include <location/providers/ubx/_8/nmea/mode.h>
+#include <location/providers/ubx/_8/nmea/status.h>
+#include <location/providers/ubx/_8/nmea/talker.h>
+#include <location/providers/ubx/_8/nmea/utc.h>
+
+#include <boost/optional.hpp>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Latitude and longitude, with time of position fix and status
+struct Gll
+{
+    Talker talker;
+    boost::optional<Latitude> latitude;
+    boost::optional<CardinalDirection> latitude_direction;
+    boost::optional<Longitude> longitude;
+    boost::optional<CardinalDirection> longitude_direction;
+    boost::optional<Utc> utc;
+    boost::optional<Status> status;
+    boost::optional<Mode> mode;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GLL_H_

=== added directory 'src/location/providers/ubx/_8/nmea/gps'
=== added file 'src/location/providers/ubx/_8/nmea/gps/fix_mode.h'
--- src/location/providers/ubx/_8/nmea/gps/fix_mode.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/gps/fix_mode.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,50 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GPS_FIX_MODE_H_
+#define UBX_8_NMEA_GPS_FIX_MODE_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+namespace gps
+{
+/// @brief FixMode enumerates all known, gps-specific fix modes.
+enum class FixMode
+{
+    invalid = 0,
+    gps_sps = 1,
+    differential_gps_sps = 2,
+    gps_pps = 3,
+    real_time_kinematic = 4,
+    floating_point_real_time_kinematic = 5,
+    estimated = 6,
+    manual_input = 7,
+    simulator = 8
+};
+}
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GPS_FIX_MODE_H_

=== added file 'src/location/providers/ubx/_8/nmea/grammar.h'
--- src/location/providers/ubx/_8/nmea/grammar.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/grammar.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,251 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GRAMMAR_H_
+#define UBX_8_NMEA_GRAMMAR_H_
+
+#define BOOST_SPIRIT_DEBUG
+#define FUSION_MAX_VECTOR_SIZE 15
+
+#include <location/providers/ubx/_8/nmea/fusion_adapt.h>
+
+#include <boost/spirit/include/classic.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/qi_real.hpp>
+#include <boost/spirit/include/qi_uint.hpp>
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+
+template <std::size_t integral, typename T>
+struct FixedPrecisionRealPolicy : boost::spirit::qi::ureal_policies<T>
+{
+    //  Thousands separated numbers
+    template <typename Iterator, typename Attribute>
+    static bool parse_n(Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        return boost::spirit::qi::extract_uint<T, 10, integral, integral>::call(first, last, attr);
+    }
+};
+
+template <typename Iterator>
+class Grammar : public boost::spirit::qi::grammar<Iterator, Sentence()>
+{
+public:
+    Grammar() : Grammar::base_type{start}
+    {
+        // clang-format off
+    start %= (gga | gsa | gll | gsv | rmc | txt | vtg);
+    field_separator %= ',';
+    checksum %= boost::spirit::qi::hex;
+    talker.add
+        ("GL", Talker::gl)
+        ("GN", Talker::gn)
+        ("GP", Talker::gp);
+    status.add
+        ("A", Status::valid)
+        ("V", Status::not_valid);
+    mode.add
+        ("A", Mode::autonomous)
+        ("D", Mode::differential)
+        ("E", Mode::estimated)
+        ("M", Mode::manual_input)
+        ("S", Mode::simulator_mode)
+        ("N", Mode::data_not_valid);
+    cardinal_direction.all.add
+        ("N", CardinalDirection::north)
+        ("S", CardinalDirection::south)
+        ("E", CardinalDirection::east)
+        ("W", CardinalDirection::west);
+    cardinal_direction.ns.add
+        ("N", CardinalDirection::north)
+        ("S", CardinalDirection::south);
+    cardinal_direction.ew.add
+        ("E", CardinalDirection::east)
+        ("W", CardinalDirection::west);
+    gps.fix_mode.add
+        ("0", gps::FixMode::invalid)
+        ("1", gps::FixMode::gps_sps)
+        ("2", gps::FixMode::differential_gps_sps)
+        ("3", gps::FixMode::gps_pps)
+        ("4", gps::FixMode::real_time_kinematic)
+        ("5", gps::FixMode::floating_point_real_time_kinematic)
+        ("6", gps::FixMode::estimated)("7", gps::FixMode::manual_input)
+        ("8", gps::FixMode::simulator);
+    for_gsa.operation_mode.add
+        ("A", Gsa::OperationMode::automatic)
+        ("M", Gsa::OperationMode::manual);
+    for_gsa.fix_mode.add
+        ("1", Gsa::FixMode::fix_not_available)
+        ("2", Gsa::FixMode::fix_in_2d)
+        ("3", Gsa::FixMode::fix_in_3d);
+
+    pdop %= boost::spirit::qi::real_parser<float>();
+    hdop %= boost::spirit::qi::real_parser<float>();
+    vdop %= boost::spirit::qi::real_parser<float>();
+
+    latitude %= boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>() >>                                                                             
+                boost::spirit::qi::real_parser<double, FixedPrecisionRealPolicy<2, double>>();
+
+    longitude %= boost::spirit::qi::uint_parser<std::uint32_t, 10, 3, 3>() >>
+                 boost::spirit::qi::real_parser<double, FixedPrecisionRealPolicy<2, double>>();
+
+    date %= boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>() >>
+            boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>() >>
+            boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>();
+
+    utc %= boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>() >>
+           boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>() >>
+           boost::spirit::qi::real_parser<double, FixedPrecisionRealPolicy<2, double>>();
+
+    gsa %= talker >> "GSA" >> field_separator >> -for_gsa.operation_mode >>
+           field_separator >> -for_gsa.fix_mode >> field_separator >>
+           boost::spirit::qi::repeat(
+               12)[-boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>() >>
+                   field_separator] >>
+           -pdop >> field_separator >> -hdop >> field_separator >> -vdop;
+
+    gga %= talker >> "GGA"                                                                                        >> field_separator
+                  >> -utc                                                                                         >> field_separator
+                  >> -latitude                                                                                    >> field_separator
+                  >> -(cardinal_direction.ns)                                                                     >> field_separator
+                  >> -longitude                                                                                   >> field_separator
+                  >> -(cardinal_direction.ew)                                                                     >> field_separator
+                  >> -gps.fix_mode                                                                                >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>()                                   >> field_separator
+                  >> -hdop                                                                                        >> field_separator
+                  >> -(boost::spirit::qi::real_parser<float, boost::spirit::qi::strict_ureal_policies<float>>())  >> field_separator
+                  >> -boost::spirit::qi::lit('M')                                                                 >> field_separator
+                  >> -(boost::spirit::qi::real_parser<float, boost::spirit::qi::strict_ureal_policies<float>>())  >> field_separator
+                  >> -boost::spirit::qi::lit('M')                                                                 >> field_separator
+                  >> -boost::spirit::qi::real_parser<float, boost::spirit::qi::strict_ureal_policies<float>>()    >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint32_t, 10, 2, 2>();
+
+    gll %= talker >> "GLL"                      >> field_separator
+                  >> -latitude                  >> field_separator
+                  >> -cardinal_direction.ns     >> field_separator
+                  >> -longitude                 >> field_separator
+                  >> -cardinal_direction.ew     >> field_separator
+                  >> -utc                       >> field_separator
+                  >> -status                    >> field_separator
+                  >> -mode;
+
+    gsv_info %= field_separator >>
+                -boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>() >>
+                field_separator >>
+                -boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>() >>
+                field_separator >>
+                -boost::spirit::qi::uint_parser<std::uint16_t, 10, 3, 3>() >>
+                field_separator >>
+                -boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>();
+
+    gsv %= talker >> "GSV"                                                      >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint8_t, 10, 1, 1>()  >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint8_t, 10, 1, 1>()  >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint16_t, 10, 2, 2>()
+                  >> +(gsv_info);
+
+    rmc %= talker >> "RMC"                                                                                        >> field_separator
+                  >> -utc                                                                                         >> field_separator
+                  >> -status                                                                                      >> field_separator
+                  >> -(latitude)                                                                                  >> field_separator
+                  >> -(cardinal_direction.ns)                                                                     >> field_separator
+                  >> -(longitude) >> field_separator >> -(cardinal_direction.ew)                                  >> field_separator
+                  >> -(boost::spirit::qi::real_parser<float, boost::spirit::qi::strict_ureal_policies<float>>())  >> field_separator
+                  >> -(boost::spirit::qi::real_parser<float, boost::spirit::qi::strict_ureal_policies<float>>())  >> field_separator
+                  >> -date                                                                                        >> field_separator
+                  >> -(boost::spirit::qi::real_parser<float, boost::spirit::qi::strict_ureal_policies<float>>())  >> field_separator
+                  >> -(cardinal_direction.ew)                                                                     >> field_separator
+                  >> -mode;
+
+    txt %= talker >> "TXT"                                                      >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>()  >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>()  >> field_separator
+                  >> -boost::spirit::qi::uint_parser<std::uint8_t, 10, 2, 2>()  >> field_separator
+                  >> -boost::spirit::qi::as_string[*boost::spirit::qi::ascii::char_];
+
+    vtg %= talker >> "VTG"                                    >> field_separator
+                  >> -boost::spirit::qi::real_parser<float>() >> field_separator
+                  >> -boost::spirit::qi::lit('T')             >> field_separator
+                  >> -boost::spirit::qi::real_parser<float>() >> field_separator
+                  >> -boost::spirit::qi::lit('M')             >> field_separator
+                  >> -boost::spirit::qi::real_parser<float>() >> field_separator
+                  >> -boost::spirit::qi::lit('N')             >> field_separator
+                  >> -boost::spirit::qi::real_parser<float>() >> field_separator
+                  >> -boost::spirit::qi::lit('K')             >> field_separator
+                  >> mode;
+        // clang-format on
+    }
+
+    boost::spirit::qi::rule<Iterator, Sentence()> start;
+    boost::spirit::qi::rule<Iterator> field_separator;
+    boost::spirit::qi::rule<Iterator, std::uint32_t()> checksum;
+    boost::spirit::qi::rule<Iterator, Latitude()> latitude;
+    boost::spirit::qi::rule<Iterator, Longitude()> longitude;
+    boost::spirit::qi::rule<Iterator, Date()> date;
+    boost::spirit::qi::rule<Iterator, Utc()> utc;
+    boost::spirit::qi::rule<Iterator, Dop<tag::Positional>()> pdop;
+    boost::spirit::qi::rule<Iterator, Dop<tag::Horizontal>()> hdop;
+    boost::spirit::qi::rule<Iterator, Dop<tag::Vertical>()> vdop;
+
+    boost::spirit::qi::rule<Iterator, Gsa()> gsa;
+    boost::spirit::qi::rule<Iterator, Gga()> gga;
+    boost::spirit::qi::rule<Iterator, Gll()> gll;
+    boost::spirit::qi::rule<Iterator, Gsv::Info()> gsv_info;
+    boost::spirit::qi::rule<Iterator, Gsv()> gsv;
+    boost::spirit::qi::rule<Iterator, Rmc()> rmc;
+    boost::spirit::qi::rule<Iterator, Txt()> txt;
+    boost::spirit::qi::rule<Iterator, Vtg()> vtg;
+
+    // Enumerations go here
+    boost::spirit::qi::symbols<char, Talker> talker;
+    boost::spirit::qi::symbols<char, Status> status;
+    boost::spirit::qi::symbols<char, Mode> mode;
+    struct
+    {
+        boost::spirit::qi::symbols<char, CardinalDirection> all;
+        boost::spirit::qi::symbols<char, CardinalDirection> ns;
+        boost::spirit::qi::symbols<char, CardinalDirection> ew;
+    } cardinal_direction;
+
+    // Positioning-system specific rules go here
+    struct
+    {
+        boost::spirit::qi::symbols<char, gps::FixMode> fix_mode;
+    } gps;
+
+    // Sentence-specific rules go here
+    struct
+    {
+        boost::spirit::qi::symbols<char, Gsa::OperationMode> operation_mode;
+        boost::spirit::qi::symbols<char, Gsa::FixMode> fix_mode;
+    } for_gsa;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GRAMMAR_H_

=== added file 'src/location/providers/ubx/_8/nmea/gsa.h'
--- src/location/providers/ubx/_8/nmea/gsa.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/gsa.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,84 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GSA_H_
+#define UBX_8_NMEA_GSA_H_
+
+#include <location/providers/ubx/dop.h>
+
+#include <location/providers/ubx/_8/nmea/latitude.h>
+#include <location/providers/ubx/_8/nmea/longitude.h>
+#include <location/providers/ubx/_8/nmea/talker.h>
+
+#include <location/providers/ubx/_8/nmea/gps/fix_mode.h>
+
+#include <boost/optional.hpp>
+
+#include <cstdint>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief GNSS DOP and Active Satellites.
+///
+/// The GNSS receiver operating mode, satellites used for navigation, and DOP
+/// values.
+///   - If less than 12 SVs are used for navigation, the remaining fields are
+///   left empty. If more
+///     than 12 SVs are used for navigation, only the IDs of the first 12 are
+///     output.
+///   - The SV numbers (fields 'sv') are in the range of 1 to 32 for GPS
+///   satellites, and 33 to 64
+///     for SBAS satellites (33 = SBAS PRN 120, 34 = SBAS PRN 121, and so on)
+///
+/// In a multi-GNSS system this message will be output multiple times, once for
+/// each GNSS.
+struct Gsa
+{
+    enum class OperationMode
+    {
+        manual = 'M',   ///< Manual, forced to operate in 2D or 3D mode.
+        automatic = 'A' ///< Automatic, allowed to switch between 2D and 3D.
+    };
+
+    enum FixMode
+    {
+        fix_not_available = 1, ///< Fix not available
+        fix_in_2d = 2,         ///< 2d fix
+        fix_in_3d = 3,         ///< 3d fix
+    };
+
+    Talker talker;
+    boost::optional<OperationMode> operation_mode;
+    boost::optional<FixMode> fix_mode;
+    std::vector<boost::optional<std::uint8_t>> satellite_ids;
+    boost::optional<Dop<tag::Positional>> pdop;
+    boost::optional<Dop<tag::Horizontal>> hdop;
+    boost::optional<Dop<tag::Vertical>> vdop;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GSA_H_

=== added file 'src/location/providers/ubx/_8/nmea/gsv.h'
--- src/location/providers/ubx/_8/nmea/gsv.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/gsv.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,66 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_GSV_H_
+#define UBX_8_NMEA_GSV_H_
+
+#include <location/providers/ubx/_8/nmea/talker.h>
+
+#include <boost/optional.hpp>
+
+#include <cstdint>
+
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief GNSS Satellites in View.
+///
+/// The number of satellites in view, together with each SV ID, elevation
+/// azimuth, and signal
+/// strength (C/No) value. Only four satellite details are transmitted in one
+/// message.
+/// In a multi-GNSS system sets of GSV messages will be output multiple times,
+/// one
+/// set for each GNSS.
+struct Gsv
+{
+    struct Info
+    {
+        boost::optional<std::uint8_t> satellite_id;
+        boost::optional<std::uint8_t> elevation;
+        boost::optional<std::uint16_t> azimuth;
+        boost::optional<std::uint8_t> snr;
+    };
+    Talker talker;
+    boost::optional<std::uint8_t> sentence_count;
+    boost::optional<std::uint8_t> sentence_number;
+    boost::optional<std::uint8_t> satellites_count;
+    std::vector<Info> satellites_info;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_GSV_H_

=== added file 'src/location/providers/ubx/_8/nmea/latitude.h'
--- src/location/providers/ubx/_8/nmea/latitude.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/latitude.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,42 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_LATITUDE_H_
+#define UBX_8_NMEA_LATITUDE_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Latitude as defined in wgs84.
+struct Latitude
+{
+    std::uint32_t degrees;
+    double minutes;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_LATITUDE_H_

=== added file 'src/location/providers/ubx/_8/nmea/longitude.h'
--- src/location/providers/ubx/_8/nmea/longitude.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/longitude.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,42 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_LONGITUDE_H_
+#define UBX_8_NMEA_LONGITUDE_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Longitude as defined in wgs84.
+struct Longitude
+{
+    std::uint32_t degrees;
+    double minutes;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_LONGITUDE_H_

=== added file 'src/location/providers/ubx/_8/nmea/mode.h'
--- src/location/providers/ubx/_8/nmea/mode.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/mode.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,44 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_MODE_H_
+#define UBX_8_NMEA_MODE_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Mode enumerates all known NMEA positioning modes.
+enum class Mode
+{
+    autonomous = 'A',
+    differential = 'D',
+    estimated = 'E',
+    manual_input = 'M',
+    simulator_mode = 'S',
+    data_not_valid = 'N'
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_MODE_H_

=== added file 'src/location/providers/ubx/_8/nmea/rmc.h'
--- src/location/providers/ubx/_8/nmea/rmc.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/rmc.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,68 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_RMC_H_
+#define UBX_8_NMEA_RMC_H_
+
+#include <location/providers/ubx/_8/nmea/cardinal_direction.h>
+#include <location/providers/ubx/_8/nmea/date.h>
+#include <location/providers/ubx/_8/nmea/latitude.h>
+#include <location/providers/ubx/_8/nmea/longitude.h>
+#include <location/providers/ubx/_8/nmea/mode.h>
+#include <location/providers/ubx/_8/nmea/status.h>
+#include <location/providers/ubx/_8/nmea/talker.h>
+#include <location/providers/ubx/_8/nmea/utc.h>
+
+#include <boost/optional.hpp>
+
+#include <cstdint>
+
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Recommended Minimum data.
+///
+/// The recommended minimum sentence defined by NMEA for GNSS system data.
+struct Rmc
+{
+    Talker talker;
+    boost::optional<Utc> utc;
+    boost::optional<Status> status;
+    boost::optional<Latitude> latitude;
+    boost::optional<CardinalDirection> latitude_direction;
+    boost::optional<Longitude> longitude;
+    boost::optional<CardinalDirection> longitude_direction;
+    boost::optional<float> speed_over_ground;  // [knots]
+    boost::optional<float> course_over_ground; // [°]
+    boost::optional<Date> date;
+    boost::optional<float> magnetic_variation; // [°]
+    boost::optional<CardinalDirection> cardinal_direction;
+    boost::optional<Mode> mode;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_RMC_H_

=== added file 'src/location/providers/ubx/_8/nmea/scanner.cpp'
--- src/location/providers/ubx/_8/nmea/scanner.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/scanner.cpp	2016-10-11 08:54:12 +0000
@@ -0,0 +1,65 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#include <location/providers/ubx/_8/nmea/scanner.h>
+
+#include <stdexcept>
+
+namespace nmea = location::providers::ubx::_8::nmea;
+
+nmea::Scanner::Expect nmea::Scanner::update(char c) {
+  switch (state) {
+    case Expect::dollar:
+      if (c == '$') {
+        ss << c;
+        state = Expect::more_data;
+      }
+      break;
+    case Expect::more_data:
+      switch (c) {
+        case '\r':
+          state = Expect::line_feed;
+          break;
+        default:
+          break;
+      }
+      ss << c;
+      break;
+    case Expect::line_feed:
+      switch (c) {
+        case '\n':
+          state = Expect::nothing_more;
+          break;
+        default:
+          break;
+      }
+      ss << c;
+      break;
+    default:
+      break;
+  }
+
+  return state;
+}
+
+std::string nmea::Scanner::finalize() {
+  if (state != Expect::nothing_more) throw std::runtime_error{"Incomplete"};
+
+  auto result = ss.str();
+  ss.str("");
+  ss.clear();
+  state = Expect::dollar;
+
+  return result;
+}

=== added file 'src/location/providers/ubx/_8/nmea/scanner.h'
--- src/location/providers/ubx/_8/nmea/scanner.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/scanner.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,67 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_SCANNER_H_
+#define UBX_8_NMEA_SCANNER_H_
+
+#include <sstream>
+#include <string>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Scanner inspects incoming characters and tries to identify beginning
+/// and end of
+/// NMEA messages.
+class Scanner
+{
+public:
+    /// @brief Expect models the state of the scanner, describing what it expects
+    /// next
+    /// to advance its state.
+    enum class Expect
+    {
+        dollar,
+        more_data,
+        line_feed,
+        nothing_more
+    };
+
+    /// @brief update updates the state of the Scanner with c.
+    Expect update(char c);
+
+    /// @brief finalize tries to extract a complete NMEA sentence.
+    ///
+    /// Throws a std::runtime_error if the Scanner is not in state
+    /// Expect::nothing_more.
+    std::string finalize();
+
+private:
+    Expect state{Expect::dollar}; ///< The state of the Scanner.
+    std::stringstream ss;         ///< Buffer holding incomplete sentence data.
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_SCANNER_H_

=== added file 'src/location/providers/ubx/_8/nmea/sentence.cpp'
--- src/location/providers/ubx/_8/nmea/sentence.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/sentence.cpp	2016-10-11 08:54:12 +0000
@@ -0,0 +1,81 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/nmea/generator.h>
+#include <location/providers/ubx/_8/nmea/grammar.h>
+
+#include <iterator>
+
+namespace nmea = location::providers::ubx::_8::nmea;
+
+namespace {
+template <typename Iterator>
+std::uint8_t checksum(Iterator it, Iterator itE) {
+  std::uint8_t result = 0;
+  for (; it != itE; ++it) result ^= *it;
+
+  return result;
+}
+}
+
+nmea::Sentence nmea::parse_sentence(const std::string& message) {
+  using boost::phoenix::ref;
+  using boost::spirit::qi::hex;
+  using boost::spirit::qi::lit;
+  using boost::spirit::qi::ascii::char_;
+  using boost::spirit::qi::_1;
+  using boost::spirit::qi::as_string;
+
+  std::string s;
+  std::uint32_t cs;
+
+  auto set_s = [&s](const std::string& in) { s = in; };
+
+  auto set_cs = [&cs](std::uint32_t in) { cs = in; };
+
+  if (not boost::spirit::qi::parse(message.begin(), message.end(),
+                                   (lit('$') >> as_string[*(~char_('*'))][set_s] >> lit('*') >> hex[set_cs] >> "\r\n")))
+    throw std::runtime_error("Failed to unmarshal NMEA message: " + message);
+
+  nmea::Sentence sentence;
+  if (not boost::spirit::qi::parse(s.begin(), s.end(), nmea::Grammar<std::string::iterator>(), sentence))
+    throw std::runtime_error("Failed to parse NMEA sentence: " + s);
+
+  if (checksum(s.begin(), s.end()) != cs) throw std::runtime_error("Failed to verify NMEA message integrity.");
+
+  return sentence;
+}
+
+std::string nmea::generate_sentence(const Sentence& sentence) {
+  using boost::spirit::karma::hex;
+  using boost::spirit::karma::lit;
+  using boost::spirit::karma::upper;
+
+  std::string s;
+  std::back_insert_iterator<std::string> its(s);
+  boost::spirit::karma::generate(its, Generator<std::back_insert_iterator<std::string>>(), sentence);
+
+  std::string result;
+  std::back_insert_iterator<std::string> itr(result);
+  if (not boost::spirit::karma::generate(itr, lit('$') << s << lit('*') << upper[hex] << "\r\n",
+                                         checksum(s.begin(), s.end())))
+    throw std::logic_error("Failed to marshal NMEA message");
+
+  return result;
+}
+
+std::ostream& nmea::operator<<(std::ostream& out, const Sentence& sentence) {
+  return out << generate_sentence(sentence);
+}

=== added file 'src/location/providers/ubx/_8/nmea/sentence.h'
--- src/location/providers/ubx/_8/nmea/sentence.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/sentence.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_SENTENCE_H_
+#define UBX_8_NMEA_SENTENCE_H_
+
+#include <location/providers/ubx/_8/nmea/gga.h>
+#include <location/providers/ubx/_8/nmea/gll.h>
+#include <location/providers/ubx/_8/nmea/gsa.h>
+#include <location/providers/ubx/_8/nmea/gsv.h>
+#include <location/providers/ubx/_8/nmea/rmc.h>
+#include <location/providers/ubx/_8/nmea/txt.h>
+#include <location/providers/ubx/_8/nmea/vtg.h>
+
+#include <boost/variant.hpp>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+
+/// @brief Sentence bundles together all known NMEA sentences.
+using Sentence = boost::variant<Gga, Gsa, Gll, Gsv, Rmc, Txt, Vtg>;
+
+/// @brief parse_sentence parses an NMEA sentence from s.
+Sentence parse_sentence(const std::string& s);
+/// @brief generate_sentence creates a string representation from sentence.
+std::string generate_sentence(const Sentence& sentence);
+/// @brief operator<< inserts sentence into out.
+std::ostream& operator<<(std::ostream& out, const Sentence& sentence);
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_SENTENCE_H_

=== added file 'src/location/providers/ubx/_8/nmea/status.h'
--- src/location/providers/ubx/_8/nmea/status.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/status.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,40 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_STATUS_H_
+#define UBX_8_NMEA_STATUS_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Status enumerates all status codes known to NMEA messages.
+enum class Status
+{
+    valid = 'A',    ///< The referenced data is valid.
+    not_valid = 'V' ///< The reference data is missing and thus not valid.
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_STATUS_H_

=== added file 'src/location/providers/ubx/_8/nmea/talker.h'
--- src/location/providers/ubx/_8/nmea/talker.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/talker.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,41 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_TALKER_H_
+#define UBX_8_NMEA_TALKER_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Talker enumerates well-known participants on an NMEA bus.
+enum class Talker
+{
+    gl, ///< GLONASS receiver
+    gn, ///< Global Navigation Satellite System (GNSS)
+    gp  ///< Global Positioning System (GPS)
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_TALKER_H_

=== added file 'src/location/providers/ubx/_8/nmea/txt.h'
--- src/location/providers/ubx/_8/nmea/txt.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/txt.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,55 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_TXT_H_
+#define UBX_8_NMEA_TXT_H_
+
+#include <location/providers/ubx/_8/nmea/talker.h>
+
+#include <boost/optional.hpp>
+
+#include <cstdint>
+
+#include <string>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Text Transmission.
+///
+/// This message outputs various information on the receiver, such as power-up
+/// screen,
+/// software version etc.
+struct Txt
+{
+    Talker talker;
+    boost::optional<std::uint8_t> total_number_of_sentences;
+    boost::optional<std::uint8_t> sentence_number;
+    boost::optional<std::uint8_t> identifier;
+    boost::optional<std::string> message;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_TXT_H_

=== added file 'src/location/providers/ubx/_8/nmea/utc.h'
--- src/location/providers/ubx/_8/nmea/utc.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/utc.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_UTC_H_
+#define UBX_8_NMEA_UTC_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Time in UTC.
+struct Utc
+{
+    std::uint8_t hours;
+    std::uint8_t minutes;
+    double seconds;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_UTC_H_

=== added file 'src/location/providers/ubx/_8/nmea/vtg.h'
--- src/location/providers/ubx/_8/nmea/vtg.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nmea/vtg.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,53 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_NMEA_VTG_H_
+#define UBX_8_NMEA_VTG_H_
+
+#include <location/providers/ubx/_8/nmea/mode.h>
+#include <location/providers/ubx/_8/nmea/talker.h>
+
+#include <boost/optional.hpp>
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+namespace nmea
+{
+/// @brief Course over ground and Ground speed.
+///
+/// Velocity is given as Course over Ground (COG) and Speed over Ground (SOG).
+struct Vtg
+{
+    Talker talker;
+    boost::optional<float> cog_true;
+    boost::optional<float> cog_magnetic;
+    boost::optional<float> sog_knots;
+    boost::optional<float> sog_kmh;
+    boost::optional<Mode> mode;
+};
+}
+}
+}
+}
+}
+
+#endif // UBX_8_NMEA_VTG_H_

=== added file 'src/location/providers/ubx/_8/receiver.cpp'
--- src/location/providers/ubx/_8/receiver.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/receiver.cpp	2016-10-11 08:54:12 +0000
@@ -0,0 +1,23 @@
+#include <location/providers/ubx/_8/receiver.h>
+
+#include <location/providers/ubx/_8/nmea/sentence.h>
+
+#include <iostream>
+
+namespace ubx = location::providers::ubx;
+
+ubx::_8::Receiver::Receiver(const std::shared_ptr<Monitor>& monitor) : monitor{monitor} {}
+
+void ubx::_8::Receiver::process_chunk(Buffer::iterator it, Buffer::iterator itE)
+{
+    monitor->on_new_chunk(it, itE);
+
+    while (it != itE)
+    {
+        if (nmea::Scanner::Expect::nothing_more == nmea_scanner.update(*it))
+        {
+            monitor->on_new_nmea_sentence(nmea::parse_sentence(nmea_scanner.finalize()));
+        }
+        ++it;
+    }
+}

=== added file 'src/location/providers/ubx/_8/receiver.h'
--- src/location/providers/ubx/_8/receiver.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/receiver.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,81 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_RECEIVER_H_
+#define UBX_8_RECEIVER_H_
+
+#include <location/providers/ubx/_8/nmea/scanner.h>
+#include <location/providers/ubx/_8/nmea/sentence.h>
+
+#include <memory>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+/// @brief Receiver connects to a ublox 8 GNSS receiver.
+class Receiver
+{
+public:
+    using Buffer = std::array<char, 1024>;
+
+    /// @brief Monitor provides calling code with means for monitoring
+    /// receiver operation.
+    class Monitor
+    {
+    public:
+        /// @cond
+        Monitor() = default;
+        Monitor(const Monitor&) = delete;
+        Monitor(Monitor&&) = delete;
+        virtual ~Monitor() = default;
+        Monitor& operator=(const Monitor&) = delete;
+        Monitor& operator=(Monitor&&) = delete;
+        /// @endcond
+
+        /// @brief on_new_chunk is invoked for every incoming chunk of raw data.
+        virtual void on_new_chunk(Buffer::iterator it, Buffer::iterator itE) = 0;
+
+        /// @brief on_new_nmea_sentence is invoked for every complete and parsed
+        /// nmea sentence.
+        virtual void on_new_nmea_sentence(const nmea::Sentence& sentence) = 0;
+    };
+
+protected:
+    /// @brief Receiver initializes a new instance with monitor
+    ///
+    /// Throws in case of issues.
+    Receiver(const std::shared_ptr<Monitor>& monitor);
+
+    /// @brief process_chunk iterates over the given range, updating scanners and
+    /// parsers.
+    ///
+    /// Calls out to a configured monitor instance for announcing results.
+    void process_chunk(Buffer::iterator it, Buffer::iterator itE);
+
+private:
+    std::shared_ptr<Monitor> monitor;
+    nmea::Scanner nmea_scanner;
+};
+}
+}
+}
+}
+
+#endif // UBX_8_RECEIVER_H_

=== added file 'src/location/providers/ubx/_8/replaying_receiver.cpp'
--- src/location/providers/ubx/_8/replaying_receiver.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/replaying_receiver.cpp	2016-10-11 08:54:12 +0000
@@ -0,0 +1,32 @@
+#include <location/providers/ubx/_8/replaying_receiver.h>
+
+#include <iostream>
+#include <memory>
+
+namespace ubx = location::providers::ubx;
+
+std::shared_ptr<ubx::_8::ReplayingReceiver> ubx::_8::ReplayingReceiver::create(
+    const boost::filesystem::path& trace, const std::shared_ptr<Monitor>& monitor)
+{
+    return std::shared_ptr<ReplayingReceiver>{new ReplayingReceiver{trace, monitor}};
+}
+
+void ubx::_8::ReplayingReceiver::run()
+{
+    while (in)
+    {
+        auto size = in.readsome(&buffer.front(), buffer.size());
+        if (size > 0)
+            process_chunk(buffer.begin(), buffer.begin() + size);
+        else
+            break;
+    }
+}
+
+ubx::_8::ReplayingReceiver::ReplayingReceiver(const boost::filesystem::path& trace,
+                                              const std::shared_ptr<Monitor>& monitor)
+    : Receiver{monitor}, in{trace.string().c_str()}
+{
+    if (not in)
+        throw std::runtime_error{"Failed to open " + trace.string() + " for reading."};
+}

=== added file 'src/location/providers/ubx/_8/replaying_receiver.h'
=== added file 'src/location/providers/ubx/_8/scanner.h'
--- src/location/providers/ubx/_8/scanner.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/scanner.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,146 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_SCANNER_H_
+#define UBX_8_SCANNER_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+class Checksum
+{
+public:
+    struct VerificationFailed : public std::runtime_error
+    {
+        ValidationFailed() : std::runtime_error{"Checksum verification failed."} {}
+    };
+
+    void update(std::uint8_t c)
+    {
+        ck_a += c;
+        ck_b += ck_a;
+    }
+
+    void verify_or_throw(std::uint8_t a, std::uint8_t b)
+    {
+        if (a != ck_a || b != ck_b)
+            throw VerificationFailed{};
+    }
+
+private:
+    std::uint8_t ck_a{0};
+    std::uint8_t ck_b{0};
+};
+class Scanner
+{
+public:
+    ///  @brief Expect enumerates the different states of the scanner/parser.
+    enum class Expect
+    {
+        sync_char_1,
+        sync_char_2,
+        class_,
+        id,
+        length_1,
+        length_2,
+        payload,
+        ck_a,
+        ck_b,
+        nothing_more
+    };
+
+    /// @brief finalize returns the complete message
+    /// or throws in case of issues.
+    Message finalize()
+    {
+        if (not message)
+            throw std::runtime_error{"Too early"};
+        if (next != Expect::nothing_more)
+            throw std::runtime_error{"Too early"};
+
+        auto result = *message;
+
+        next = Expect::sync_char_1;
+        message.reset();
+
+        return result;
+    }
+
+    Expect update(std::uint8_t c)
+    {
+        // TODO(tvoss): This lacks a lot of validiation and verification.
+        // UBX allows us to partially parse while we scan and carry out online
+        // checksum calculation. Ideally, we would have a common class State that
+        // captures behavior and transition logic.
+
+        switch (next)
+        {
+        case Expect::sync_char_1:
+            if (c == sync_char_1)
+                next = Expect::sync_char_1;
+            break;
+        case Expect::sync_char_2:
+            if (c == sync_char_2)
+                next = Expect::class_;
+            break;
+        case Expect::class_:
+            message->cls = static_cast<Class>(c);
+            next = Expect::id;
+            break;
+        case Expect::id_:
+            message->id = static_cast<Id>(c);
+            next = Expect::length_1;
+            break;
+        case Expect::length_1:
+            message->length = c;
+            next = Expect::length_2;
+            break;
+        case Excpet::length_2:
+            message->length |= c << 8;
+            next = Expect::payload;
+        case Expect::payload:
+            message->payload.push_back(c);
+            checksum.update(c);
+            next = message->payload.size() == message->length() ? Expect::ck_a : next;
+            break;
+        case Expect::ck_a:
+            message->ck_a = c;
+            next = Expect::ck_b;
+            break;
+        case Expect::ck_b:
+            message->ck_b |= c << 8;
+            checksum.verify_or_throw(message->ck_a, message->ck_b);
+            next = Expect::nothing_more;
+            break;
+        }
+
+        return next;
+    }
+
+private:
+    Expect next{Expect::sync_char_1};
+    Checksum checksum;
+    boost::optional<Message> message;
+};
+}
+}
+}
+}
+
+#endif // UBX_8_SCANNER_H_

=== added file 'src/location/providers/ubx/_8/serial_port_receiver.cpp'
--- src/location/providers/ubx/_8/serial_port_receiver.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/serial_port_receiver.cpp	2016-10-11 08:54:12 +0000
@@ -0,0 +1,44 @@
+#include <location/providers/ubx/_8/serial_port_receiver.h>
+
+#include <iostream>
+#include <system_error>
+
+namespace ubx = location::providers::ubx;
+
+std::shared_ptr<ubx::_8::SerialPortReceiver> ubx::_8::SerialPortReceiver::create(
+    boost::asio::io_service& ios, const boost::filesystem::path& dev, const std::shared_ptr<Monitor>& monitor)
+{
+    return std::shared_ptr<SerialPortReceiver>{new SerialPortReceiver{ios, dev, monitor}};
+}
+
+ubx::_8::SerialPortReceiver::SerialPortReceiver(boost::asio::io_service& ios, const boost::filesystem::path& dev,
+                                                const std::shared_ptr<Monitor>& monitor)
+    : Receiver{monitor}, ios{ios}, sp{ios, dev.string().c_str()}
+{
+    sp.set_option(boost::asio::serial_port::baud_rate(9600));
+}
+
+void ubx::_8::SerialPortReceiver::start()
+{
+    if (-1 == ::tcflush(sp.lowest_layer().native_handle(), TCIOFLUSH))
+        throw std::system_error(errno, std::system_category());
+
+    start_read();
+}
+
+void ubx::_8::SerialPortReceiver::stop() { sp.cancel(); }
+
+void ubx::_8::SerialPortReceiver::start_read()
+{
+    auto thiz = shared_from_this();
+    boost::asio::async_read(sp, boost::asio::buffer(&buffer.front(), buffer.size()),
+                            [thiz, this](const boost::system::error_code& ec, std::size_t transferred) {
+                                if (ec == boost::asio::error::operation_aborted)
+                                    return;
+
+                                if (not ec)
+                                    process_chunk(buffer.begin(), buffer.begin() + transferred);
+
+                                start_read();
+                            });
+}

=== added file 'src/location/providers/ubx/_8/serial_port_receiver.h'
--- src/location/providers/ubx/_8/serial_port_receiver.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/serial_port_receiver.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_8_SERIAL_PORT_RECEIVER_H_
+#define UBX_8_SERIAL_PORT_RECEIVER_H_
+
+#include <location/providers/ubx/_8/receiver.h>
+
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+
+#include <array>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+/// @brief SerialPortReceiver connects to a ublox 8 GNSS receiver over a serial
+/// port.
+class SerialPortReceiver : public Receiver, public std::enable_shared_from_this<SerialPortReceiver>
+{
+public:
+    /// @brief create returns a new Receiver instance connected to the
+    /// serial port reachable under dev.
+    static std::shared_ptr<SerialPortReceiver> create(boost::asio::io_service& ios, const boost::filesystem::path& dev,
+                                                      const std::shared_ptr<Receiver::Monitor>& monitor);
+
+    void start();
+    void stop();
+
+private:
+    /// @brief Receiver initializes a new instance opening the serial port
+    /// located at path.
+    ///
+    /// Throws in case of issues.
+    SerialPortReceiver(boost::asio::io_service& ios, const boost::filesystem::path& dev,
+                       const std::shared_ptr<Receiver::Monitor>& monitor);
+
+    /// @brief finalize returns a finalized reader instance reading from
+    /// the serial port.
+    std::shared_ptr<SerialPortReceiver> finalize();
+
+    /// @brief start_read starts an async read operation from the configured
+    /// serial port.
+    void start_read();
+
+    Receiver::Buffer buffer;
+    boost::asio::io_service& ios;
+    boost::asio::serial_port sp;
+};
+}
+}
+}
+}
+
+#endif // UBX_8_SERIAL_PORT_RECEIVER_H_

=== added file 'src/location/providers/ubx/dop.h'
--- src/location/providers/ubx/dop.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/dop.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,60 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser 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 Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#ifndef UBX_DOP_H_
+#define UBX_DOP_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace tag
+{
+struct Horizontal
+{
+};
+struct Positional
+{
+};
+struct Vertical
+{
+};
+}
+template <typename T>
+struct DillusionOfPrecision
+{
+    explicit DillusionOfPrecision(float value = -1) : value{value} {}
+
+    DillusionOfPrecision(const DillusionOfPrecision<T>& rhs) : value{rhs.value} {}
+
+    DillusionOfPrecision& operator=(const DillusionOfPrecision<T>& rhs)
+    {
+        value = rhs.value;
+        return *this;
+    }
+
+    operator float() const { return value; }
+
+    float value;
+};
+
+template <typename T>
+using Dop = DillusionOfPrecision<T>;
+}
+}
+}
+
+#endif // UBX_DOP_H_

=== added file 'src/location/providers/ubx/provider.cpp'
--- src/location/providers/ubx/provider.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/provider.cpp	2016-10-11 08:54:12 +0000
@@ -0,0 +1,160 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include "provider.h"
+
+#include <location/logging.h>
+#include <location/runtime.h>
+
+#include <thread>
+
+namespace ubx = location::providers::ubx;
+
+std::string ubx::Provider::class_name()
+{
+    return "ubx::Provider";
+}
+
+ubx::Provider::Monitor::Monitor(Provider* provider) : provider{provider}
+{
+}
+
+void ubx::Provider::Monitor::on_new_chunk(_8::Receiver::Buffer::iterator, _8::Receiver::Buffer::iterator)
+{
+    // We are dropping raw chunks on purpose here.
+}
+
+void ubx::Provider::Monitor::on_new_nmea_sentence(const _8::nmea::Sentence& sentence)
+{
+    boost::apply_visitor(*this, sentence);
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gga&) const
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gsa&) const
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gll&) const
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Gsv&) const
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Rmc& rmc) const
+{
+    if (rmc.latitude && rmc.longitude)
+    {
+        auto lat = rmc.latitude.get();
+        auto lon = rmc.longitude.get();
+
+        auto pos = location::Position{
+            (lat.degrees + lat.minutes) * units::degrees,
+            (lon.degrees + lon.minutes) * units::degrees};
+
+        provider->updates.position(location::Update<location::Position>{pos});
+    }
+
+    if (rmc.course_over_ground)
+        provider->updates.heading(location::Update<units::Degrees>{rmc.course_over_ground.get() * units::degrees});
+
+    if (rmc.speed_over_ground)
+        provider->updates.velocity(location::Update<units::MetersPerSecond>{rmc.speed_over_ground.get() * units::meters_per_second});
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Txt&) const
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const _8::nmea::Vtg&) const
+{
+    // Empty on purpose
+}
+
+location::Provider::Ptr ubx::Provider::create_instance(const location::ProviderFactory::Configuration& config)
+{
+    return location::Provider::Ptr{new ubx::Provider{config.get<std::string>("device", "/dev/ttyUSB1")}};
+}
+
+ubx::Provider::Provider(const boost::filesystem::path& device)
+    : runtime{location::Runtime::create(1)},
+      monitor{std::make_shared<Monitor>(this)},
+      receiver{_8::SerialPortReceiver::create(runtime->service(), device, monitor)}
+{
+}
+
+ubx::Provider::~Provider() noexcept
+{
+    deactivate();
+}
+
+void ubx::Provider::on_new_event(const Event&)
+{
+}
+
+location::Provider::Requirements ubx::Provider::requirements() const
+{
+    return Requirements::none;
+}
+
+bool ubx::Provider::satisfies(const location::Criteria&)
+{
+    return true;
+}
+
+void ubx::Provider::enable()
+{
+    receiver->start();
+}
+
+void ubx::Provider::disable()
+{
+    receiver->stop();
+}
+
+void ubx::Provider::activate()
+{
+}
+
+void ubx::Provider::deactivate()
+{
+}
+
+const core::Signal<location::Update<location::Position>>& ubx::Provider::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::units::Degrees>>& ubx::Provider::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::units::MetersPerSecond>>& ubx::Provider::velocity_updates() const
+{
+    return updates.velocity;
+}

=== added file 'src/location/providers/ubx/provider.h'
--- src/location/providers/ubx/provider.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/provider.h	2016-10-11 08:54:12 +0000
@@ -0,0 +1,110 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef LOCATION_PROVIDERS_UBX_PROVIDER_H_
+#define LOCATION_PROVIDERS_UBX_PROVIDER_H_
+
+#include <location/provider.h>
+#include <location/provider_factory.h>
+#include <location/runtime.h>
+
+#include <location/providers/ubx/_8/serial_port_receiver.h>
+
+#include <boost/filesystem.hpp>
+
+#include <thread>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+// ubx::Provider integrates GNSS receivers relying on
+// ublox chipsets with locationd.
+//
+// In this version, only receivers connected to a serial port
+// are supported. More to this, this version only reads NMEA sentences
+// and does not support the proprietary ublox protocol.
+//
+// Configuration parameters:
+//   - device[=/dev/ttyUSB1] serial device connecting to the receiver.
+class Provider : public location::Provider
+{
+public:
+    // For integration with the Provider factory.
+    static std::string class_name();
+    // Instantiates a new provider instance, populating the configuration object
+    // from the provided property bundle. Please see dummy::Configuration::Keys
+    // for the list of known options.
+    static Provider::Ptr create_instance(const ProviderFactory::Configuration&);
+
+    // Creates a new provider instance talking via device to the ubx chipset.
+    Provider(const boost::filesystem::path& device);
+    // Cleans up all resources and stops the updates.
+    ~Provider() noexcept;
+
+    // From Provider
+    void on_new_event(const Event& event) override;
+
+    void enable() override;
+    void disable() override;
+    void activate() override;
+    void deactivate() override;
+
+    Requirements requirements() const override;
+    bool satisfies(const Criteria& criteria) override;
+    const core::Signal<Update<Position>>& position_updates() const override;
+    const core::Signal<Update<units::Degrees>>& heading_updates() const override;
+    const core::Signal<Update<units::MetersPerSecond>>& velocity_updates() const override;
+
+private:
+    // Relays incoming sentences to a provider instance.
+    struct Monitor : public _8::Receiver::Monitor, public boost::static_visitor<>
+    {
+        explicit Monitor(Provider* provider);
+
+        // From Receiver::Monitor
+        void on_new_chunk(_8::Receiver::Buffer::iterator it, _8::Receiver::Buffer::iterator itE) override;
+        void on_new_nmea_sentence(const _8::nmea::Sentence& sentence) override;
+
+        void operator()(const _8::nmea::Gga& gga) const;
+        void operator()(const _8::nmea::Gsa& gsa) const;
+        void operator()(const _8::nmea::Gll& gll) const;
+        void operator()(const _8::nmea::Gsv& gsv) const;
+        void operator()(const _8::nmea::Rmc& rmc) const;
+        void operator()(const _8::nmea::Txt& txt) const;
+        void operator()(const _8::nmea::Vtg& vtg) const;
+
+        Provider* provider;
+    };
+
+    std::shared_ptr<location::Runtime> runtime;
+    std::shared_ptr<Monitor> monitor;
+    std::shared_ptr<_8::SerialPortReceiver> receiver;
+    struct
+    {
+        core::Signal<Update<Position>> position;
+        core::Signal<Update<units::Degrees>> heading;
+        core::Signal<Update<units::MetersPerSecond>> velocity;
+    } updates;
+};
+}
+}
+}
+
+#endif // LOCATION_PROVIDERS_UBX_PROVIDER_H_