Merge lp:~thomas-voss/location-service/add-sirf-support into lp:location-service

[Thomas Voß]

Add support for SiRF providers.

Add support for SiRF providers.

[lp:~thomas-voss/location-service/add-sirf-support]

305. By Thomas Voß on 2017-05-05

Adjust formatting of output for locationd.monitor.

[Simon Fels (morphis)]

LGTM

review: Approve

=== modified file 'src/location/CMakeLists.txt'
--- src/location/CMakeLists.txt	2017-04-26 19:58:19 +0000
+++ src/location/CMakeLists.txt	2017-05-05 09:37:41 +0000
@@ -35,6 +35,12 @@
   COMMAND ${GDBUS_CODEGEN_EXECUTABLE} --generate-c-code "${CMAKE_CURRENT_BINARY_DIR}/connectivity/w11t_gen" "${CMAKE_CURRENT_SOURCE_DIR}/connectivity/w11t.xml")
 
 add_library(
+  nmea
+
+  nmea/scanner.cpp
+  nmea/sentence.cpp)
+
+add_library(
   ubuntu-location-service SHARED
 
   ${UBUNTU_LOCATION_SERVICE_PUBLIC_HEADERS}
@@ -88,7 +94,7 @@
   cmds/status.cpp
   cmds/test.h
   cmds/test.cpp
-
+  
   util/benchmark.h
   util/benchmark.cpp
   util/cli.h
 
=== modified file 'src/location/cmds/monitor.cpp'
--- src/location/cmds/monitor.cpp	2017-04-26 19:58:19 +0000
+++ src/location/cmds/monitor.cpp	2017-05-05 09:37:41 +0000
@@ -20,6 +20,7 @@
 #include <location/cmds/monitor.h>
 
 #include <location/criteria.h>
+#include <location/logging.h>
 #include <location/dbus/stub/service.h>
 #include <location/glib/runtime.h>
 #include <location/runtime.h>
@@ -34,17 +35,84 @@
 
 void location::cmds::Monitor::PrintingDelegate::on_new_position(const Update<Position>& pos)
 {
-    out << pos << std::endl;
+    last_position_update = pos;
+    print_row();
 }
 
 void location::cmds::Monitor::PrintingDelegate::on_new_heading(const Update<units::Degrees>& heading)
 {
-    out << heading << std::endl;
+    last_heading_update = heading;
+    print_row();
 }
 
 void location::cmds::Monitor::PrintingDelegate::on_new_velocity(const Update<units::MetersPerSecond>& velocity)
 {
-    out << velocity << std::endl;
+    last_velocity_update = velocity;
+    print_row();
+}
+
+void location::cmds::Monitor::PrintingDelegate::print_header()
+{
+    out << std::left << std::setw(15) << std::setfill(' ') << "lat.[deg]"
+        << std::left << std::setw(15) << std::setfill(' ') << "lon.[deg]"
+        << std::left << std::setw(15) << std::setfill(' ') << "hor.acc.[m]"
+        << std::left << std::setw(15) << std::setfill(' ') << "alt.[m]"
+        << std::left << std::setw(15) << std::setfill(' ') << "ver.acc.[m]"
+        << std::left << std::setw(15) << std::setfill(' ') << "heading[deg]"
+        << std::left << std::setw(15) << std::setfill(' ') << "vel.[m/s]" << std::endl;
+}
+
+void location::cmds::Monitor::PrintingDelegate::print_row()
+{
+    if (last_position_update)
+    {
+        out << std::left << std::setw(15) << std::setfill(' ') << std::fixed << std::setprecision(5) << last_position_update->value.latitude().value();
+        out << std::left << std::setw(15) << std::setfill(' ') << std::fixed << std::setprecision(5) << last_position_update->value.longitude().value();
+
+        if (last_position_update->value.accuracy().horizontal())
+            out << std::left << std::setw(15) << std::setfill(' ') << std::fixed << std::setprecision(2) << last_position_update->value.accuracy().horizontal()->value() ;
+        else
+            out << std::left << std::setw(15) << std::setfill(' ') << "n/a" ;
+
+        if (last_position_update->value.altitude())
+            out << std::left << std::setw(15) << std::setfill(' ') << std::fixed << std::setprecision(2) << last_position_update->value.altitude()->value() ;
+        else
+            out << std::left << std::setw(15) << std::setfill(' ') << "n/a" ;
+
+        if (last_position_update->value.accuracy().vertical())
+            out << std::left << std::setw(15) << std::setfill(' ') << std::fixed << std::setprecision(2) << last_position_update->value.accuracy().vertical()->value() ;
+        else
+            out << std::left << std::setw(15) << std::setfill(' ') << "n/a" ;
+    }
+    else
+    {
+        out << std::left << std::setw(15) << std::setfill(' ') << "n/a"   // latitude
+            << std::left << std::setw(15) << std::setfill(' ') << "n/a"   // longitude
+            << std::left << std::setw(15) << std::setfill(' ') << "n/a"   // horizontal accuracy
+            << std::left << std::setw(15) << std::setfill(' ') << "n/a"   // altitude
+            << std::left << std::setw(15) << std::setfill(' ') << "n/a" ; // vertical accuracy
+    }
+
+    if (last_heading_update)
+    {
+        out << std::left << std::setw(15) << std::setfill(' ') << last_heading_update->value.value() ;
+    }
+    else
+    {
+        out << std::left << std::setw(15) << std::setfill(' ') << "n/a" ;
+    }
+
+    if (last_velocity_update)
+    {
+        out << std::left << std::setw(15) << std::setfill(' ') << last_velocity_update->value.value();
+    }
+    else
+    {
+        out << std::left << std::setw(15) << std::setfill(' ') << "n/a";
+    }
+
+    out << std::endl;
+
 }
 
 location::cmds::Monitor::Monitor(const std::shared_ptr<Delegate>& delegate)
@@ -96,7 +164,7 @@
                 session->updates().heading_status = location::Service::Session::Updates::Status::enabled;
                 session->updates().velocity_status = location::Service::Session::Updates::Status::enabled;
 
-                ctxt.cout << "Enabled position/heading/velocity updates..." << std::endl;
+                LOG(INFO) << "Enabled position/heading/velocity updates..." << std::endl;
             });
         });
 
 
=== modified file 'src/location/cmds/monitor.h'
--- src/location/cmds/monitor.h	2017-03-07 10:01:34 +0000
+++ src/location/cmds/monitor.h	2017-05-05 09:37:41 +0000
@@ -61,8 +61,15 @@
         void on_new_position(const Update<Position>& pos) override;
         void on_new_heading(const Update<units::Degrees>& heading) override;
         void on_new_velocity(const Update<units::MetersPerSecond>& velocity) override;
+
     private:
+        void print_header();
+        void print_row();
+
         std::ostream& out;
+        Optional<Update<Position>> last_position_update;
+        Optional<Update<units::Degrees>> last_heading_update;
+        Optional<Update<units::MetersPerSecond>> last_velocity_update;
     };
 
     // Monitor initializes a new instance.
 
=== renamed directory 'src/location/providers/ubx/_8/nmea' => 'src/location/nmea'
=== modified file 'src/location/nmea/cardinal_direction.h'
--- src/location/providers/ubx/_8/nmea/cardinal_direction.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/cardinal_direction.h	2017-05-05 09:37:41 +0000
@@ -12,17 +12,11 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_CARDINAL_DIRECTION_H_
+#define LOCATION_NMEA_CARDINAL_DIRECTION_H_
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
 /// @brief CardinalDirection enumerates the main cardinal direction
@@ -36,8 +30,5 @@
 };
 }
 }
-}
-}
-}
 
-#endif // UBX_8_NMEA_CARDINAL_DIRECTION_H_
+#endif // LOCATION_NMEA_CARDINAL_DIRECTION_H_
 
=== modified file 'src/location/nmea/date.h'
--- src/location/providers/ubx/_8/nmea/date.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/date.h	2017-05-05 09:37:41 +0000
@@ -12,19 +12,13 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_DATE_H_
+#define LOCATION_NMEA_DATE_H_
 
 #include <cstdint>
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
 /// @brief Date models a specific calendar day (Gregorian calendar).
@@ -36,8 +30,5 @@
 };
 }
 }
-}
-}
-}
 
-#endif // UBX_8_NMEA_DATE_H_
+#endif // LOCATION_NMEA_DATE_H_
 
=== modified file 'src/location/nmea/fusion_adapt.h'
--- src/location/providers/ubx/_8/nmea/fusion_adapt.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/fusion_adapt.h	2017-05-05 09:37:41 +0000
@@ -12,123 +12,123 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_FUSION_ADAPT_H_
+#define LOCATION_NMEA_FUSION_ADAPT_H_
 
 #define BOOST_SPIRIT_DEBUG
 #define FUSION_MAX_VECTOR_SIZE 15
 
-#include <location/providers/ubx/_8/nmea/sentence.h>
+#include <location/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,
+    location::nmea::Latitude,
+    (uint32_t, degrees)
+    (double, minutes))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::nmea::Longitude,
+    (uint32_t, degrees)
+    (double, minutes))
+
+BOOST_FUSION_ADAPT_STRUCT(
+    location::nmea::Date,
     (std::uint8_t, day)
     (std::uint8_t, month)
     (std::uint8_t, year))
 
 BOOST_FUSION_ADAPT_STRUCT(
-    location::providers::ubx::_8::nmea::Utc,
+    location::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)
+    location::nmea::Gsa,
+    (location::nmea::Talker, talker)
+    (boost::optional<location::nmea::Gsa::OperationMode>, operation_mode)
+    (boost::optional<location::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::optional<float>, pdop)
+    (boost::optional<float>, hdop)
+    (boost::optional<float>, 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)
+    location::nmea::Gga,
+    (location::nmea::Talker, talker)
+    (boost::optional<location::nmea::Utc>, utc)
+    (boost::optional<location::nmea::Latitude>, latitude)
+    (boost::optional<location::nmea::CardinalDirection>, latitude_direction)
+    (boost::optional<location::nmea::Longitude>, longitude)
+    (boost::optional<location::nmea::CardinalDirection>, longitude_direction)
+    (boost::optional<location::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>, 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))
+    location::nmea::Gll,
+    (location::nmea::Talker, talker)
+    (boost::optional<location::nmea::Latitude>, latitude)
+    (boost::optional<location::nmea::CardinalDirection>, latitude_direction)
+    (boost::optional<location::nmea::Longitude>, longitude)
+    (boost::optional<location::nmea::CardinalDirection>, longitude_direction)
+    (boost::optional<location::nmea::Utc>, utc)
+    (boost::optional<location::nmea::Status>, status)
+    (boost::optional<location::nmea::Mode>, mode))
 
 BOOST_FUSION_ADAPT_STRUCT(
-    location::providers::ubx::_8::nmea::Gsv::Info,
+    location::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)
+    location::nmea::Gsv,
+    (location::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))
+    (std::vector<location::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)
+    location::nmea::Rmc,
+    (location::nmea::Talker, talker)
+    (boost::optional<location::nmea::Utc>, utc)
+    (boost::optional<location::nmea::Status>, status)
+    (boost::optional<location::nmea::Latitude>, latitude)
+    (boost::optional<location::nmea::CardinalDirection>, latitude_direction)
+    (boost::optional<location::nmea::Longitude>, longitude)
+    (boost::optional<location::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<location::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::optional<location::nmea::CardinalDirection>, cardinal_direction)
+    (boost::optional<location::nmea::Mode>, mode))
 
 BOOST_FUSION_ADAPT_STRUCT(
-    location::providers::ubx::_8::nmea::Txt,
-    (location::providers::ubx::_8::nmea::Talker, talker)
+    location::nmea::Txt,
+    (location::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)
+    location::nmea::Vtg,
+    (location::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))
+    (boost::optional<location::nmea::Mode>, mode))
 
 // clang-format on
 
-#endif // UBX_8_NMEA_FUSION_ADAPT_H_
+#endif // LOCATION_NMEA_FUSION_ADAPT_H_
 
=== modified file 'src/location/nmea/generator.h'
--- src/location/providers/ubx/_8/nmea/generator.h	2017-03-09 09:42:25 +0000
+++ src/location/nmea/generator.h	2017-05-05 09:37:41 +0000
@@ -12,15 +12,14 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GENERATOR_H_
+#define LOCATION_NMEA_GENERATOR_H_
 
-#define BOOST_SPIRIT_DEBUG
 #define FUSION_MAX_VECTOR_SIZE 15
 
-#include <location/providers/ubx/_8/nmea/sentence.h>
+#include <location/nmea/sentence.h>
 
-#include <location/providers/ubx/_8/nmea/fusion_adapt.h>
+#include <location/nmea/fusion_adapt.h>
 
 #include <boost/spirit/include/classic.hpp>
 #include <boost/spirit/include/karma.hpp>
@@ -31,12 +30,6 @@
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
 
@@ -209,9 +202,9 @@
     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, float()> pdop;
+    boost::spirit::karma::rule<Iterator, float()> hdop;
+    boost::spirit::karma::rule<Iterator, float()> vdop;
 
     boost::spirit::karma::rule<Iterator, Gsa()> gsa;
     boost::spirit::karma::rule<Iterator, Gga()> gga;
@@ -246,10 +239,8 @@
         boost::spirit::karma::symbols<Gsa::FixMode, char> fix_mode;
     } for_gsa;
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_GENERATOR_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_GENERATOR_H_
 
=== modified file 'src/location/nmea/gga.h'
--- src/location/providers/ubx/_8/nmea/gga.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/gga.h	2017-05-05 09:37:41 +0000
@@ -12,18 +12,18 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GGA_H_
+#define LOCATION_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/nmea/cardinal_direction.h>
+#include <location/nmea/latitude.h>
+#include <location/nmea/longitude.h>
+#include <location/nmea/talker.h>
+#include <location/nmea/utc.h>
 
-#include <location/providers/ubx/_8/nmea/gps/fix_mode.h>
+#include <location/nmea/gps/fix_mode.h>
 
 #include <boost/optional.hpp>
 
@@ -31,14 +31,9 @@
 
 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
@@ -54,16 +49,14 @@
     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> 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_
+
+}
+}
+
+#endif // LOCATION_NMEA_GGA_H_
 
=== modified file 'src/location/nmea/gll.h'
--- src/location/providers/ubx/_8/nmea/gll.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/gll.h	2017-05-05 09:37:41 +0000
@@ -12,29 +12,24 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GLL_H_
+#define LOCATION_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 <location/nmea/cardinal_direction.h>
+#include <location/nmea/latitude.h>
+#include <location/nmea/longitude.h>
+#include <location/nmea/mode.h>
+#include <location/nmea/status.h>
+#include <location/nmea/talker.h>
+#include <location/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
 {
@@ -49,8 +44,5 @@
 };
 }
 }
-}
-}
-}
 
-#endif // UBX_8_NMEA_GLL_H_
+#endif // LOCATION_NMEA_GLL_H_
 
=== modified file 'src/location/nmea/gps/fix_mode.h'
--- src/location/providers/ubx/_8/nmea/gps/fix_mode.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/gps/fix_mode.h	2017-05-05 09:37:41 +0000
@@ -12,21 +12,16 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GPS_FIX_MODE_H_
+#define LOCATION_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
 {
@@ -40,11 +35,9 @@
     manual_input = 7,
     simulator = 8
 };
-}
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_GPS_FIX_MODE_H_
+
+}
+}
+}
+
+#endif // LOCATION_NMEA_GPS_FIX_MODE_H_
 
=== modified file 'src/location/nmea/grammar.h'
--- src/location/providers/ubx/_8/nmea/grammar.h	2017-03-09 09:42:25 +0000
+++ src/location/nmea/grammar.h	2017-05-05 09:37:41 +0000
@@ -12,13 +12,12 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GRAMMAR_H_
+#define LOCATION_NMEA_GRAMMAR_H_
 
-#define BOOST_SPIRIT_DEBUG
 #define FUSION_MAX_VECTOR_SIZE 15
 
-#include <location/providers/ubx/_8/nmea/fusion_adapt.h>
+#include <location/nmea/fusion_adapt.h>
 
 #include <boost/spirit/include/classic.hpp>
 #include <boost/spirit/include/qi.hpp>
@@ -29,12 +28,6 @@
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
 
@@ -206,9 +199,9 @@
     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, float()> pdop;
+    boost::spirit::qi::rule<Iterator, float()> hdop;
+    boost::spirit::qi::rule<Iterator, float()> vdop;
 
     boost::spirit::qi::rule<Iterator, Gsa()> gsa;
     boost::spirit::qi::rule<Iterator, Gga()> gga;
@@ -245,8 +238,5 @@
 };
 }
 }
-}
-}
-}
 
-#endif // UBX_8_NMEA_GRAMMAR_H_
+#endif // LOCATION_NMEA_GRAMMAR_H_
 
=== modified file 'src/location/nmea/gsa.h'
--- src/location/providers/ubx/_8/nmea/gsa.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/gsa.h	2017-05-05 09:37:41 +0000
@@ -12,16 +12,16 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GSA_H_
+#define LOCATION_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/nmea/latitude.h>
+#include <location/nmea/longitude.h>
+#include <location/nmea/talker.h>
 
-#include <location/providers/ubx/_8/nmea/gps/fix_mode.h>
+#include <location/nmea/gps/fix_mode.h>
 
 #include <boost/optional.hpp>
 
@@ -30,12 +30,6 @@
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
 /// @brief GNSS DOP and Active Satellites.
@@ -71,14 +65,11 @@
     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;
+    boost::optional<float> pdop;
+    boost::optional<float> hdop;
+    boost::optional<float> vdop;
 };
 }
 }
-}
-}
-}
 
-#endif // UBX_8_NMEA_GSA_H_
+#endif // LOCATION_NMEA_GSA_H_
 
=== modified file 'src/location/nmea/gsv.h'
--- src/location/providers/ubx/_8/nmea/gsv.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/gsv.h	2017-05-05 09:37:41 +0000
@@ -12,10 +12,10 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_GSV_H_
+#define LOCATION_NMEA_GSV_H_
 
-#include <location/providers/ubx/_8/nmea/talker.h>
+#include <location/nmea/talker.h>
 
 #include <boost/optional.hpp>
 
@@ -25,14 +25,9 @@
 
 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
@@ -57,10 +52,8 @@
     boost::optional<std::uint8_t> satellites_count;
     std::vector<Info> satellites_info;
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_GSV_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_GSV_H_
 
=== modified file 'src/location/nmea/latitude.h'
--- src/location/providers/ubx/_8/nmea/latitude.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/latitude.h	2017-05-05 09:37:41 +0000
@@ -12,31 +12,24 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_LATITUDE_H_
+#define LOCATION_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_
+
+}
+}
+
+#endif // LOCATION_NMEA_LATITUDE_H_
 
=== modified file 'src/location/nmea/longitude.h'
--- src/location/providers/ubx/_8/nmea/longitude.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/longitude.h	2017-05-05 09:37:41 +0000
@@ -12,31 +12,24 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_LONGITUDE_H_
+#define LOCATION_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_
+
+}
+}
+
+#endif // LOCATION_NMEA_LONGITUDE_H_
 
=== modified file 'src/location/nmea/mode.h'
--- src/location/providers/ubx/_8/nmea/mode.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/mode.h	2017-05-05 09:37:41 +0000
@@ -12,19 +12,14 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_MODE_H_
+#define LOCATION_NMEA_MODE_H_
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
+
 /// @brief Mode enumerates all known NMEA positioning modes.
 enum class Mode
 {
@@ -35,10 +30,8 @@
     simulator_mode = 'S',
     data_not_valid = 'N'
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_MODE_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_MODE_H_
 
=== modified file 'src/location/nmea/rmc.h'
--- src/location/providers/ubx/_8/nmea/rmc.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/rmc.h	2017-05-05 09:37:41 +0000
@@ -12,17 +12,17 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_RMC_H_
+#define LOCATION_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 <location/nmea/cardinal_direction.h>
+#include <location/nmea/date.h>
+#include <location/nmea/latitude.h>
+#include <location/nmea/longitude.h>
+#include <location/nmea/mode.h>
+#include <location/nmea/status.h>
+#include <location/nmea/talker.h>
+#include <location/nmea/utc.h>
 
 #include <boost/optional.hpp>
 
@@ -32,14 +32,9 @@
 
 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.
@@ -59,10 +54,8 @@
     boost::optional<CardinalDirection> cardinal_direction;
     boost::optional<Mode> mode;
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_RMC_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_RMC_H_
 
=== modified file 'src/location/nmea/scanner.cpp'
--- src/location/providers/ubx/_8/nmea/scanner.cpp	2017-03-23 12:32:38 +0000
+++ src/location/nmea/scanner.cpp	2017-05-05 09:37:41 +0000
@@ -13,11 +13,11 @@
 // 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 <location/nmea/scanner.h>
 
 #include <stdexcept>
 
-namespace nmea = location::providers::ubx::_8::nmea;
+namespace nmea = location::nmea;
 
 nmea::Scanner::Expect nmea::Scanner::update(char c) {
   switch (state) {
 
=== modified file 'src/location/nmea/scanner.h'
--- src/location/providers/ubx/_8/nmea/scanner.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/scanner.h	2017-05-05 09:37:41 +0000
@@ -12,22 +12,17 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_SCANNER_H_
+#define LOCATION_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.
@@ -58,10 +53,8 @@
     Expect state{Expect::dollar}; ///< The state of the Scanner.
     std::stringstream ss;         ///< Buffer holding incomplete sentence data.
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_SCANNER_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_SCANNER_H_
 
=== modified file 'src/location/nmea/sentence.cpp'
--- src/location/providers/ubx/_8/nmea/sentence.cpp	2016-10-10 09:15:40 +0000
+++ src/location/nmea/sentence.cpp	2017-05-05 09:37:41 +0000
@@ -13,12 +13,12 @@
 // 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 <location/nmea/generator.h>
+#include <location/nmea/grammar.h>
 
 #include <iterator>
 
-namespace nmea = location::providers::ubx::_8::nmea;
+namespace nmea = location::nmea;
 
 namespace {
 template <typename Iterator>
 
=== modified file 'src/location/nmea/sentence.h'
--- src/location/providers/ubx/_8/nmea/sentence.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/sentence.h	2017-05-05 09:37:41 +0000
@@ -12,16 +12,16 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_SENTENCE_H_
+#define LOCATION_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 <location/nmea/gga.h>
+#include <location/nmea/gll.h>
+#include <location/nmea/gsa.h>
+#include <location/nmea/gsv.h>
+#include <location/nmea/rmc.h>
+#include <location/nmea/txt.h>
+#include <location/nmea/vtg.h>
 
 #include <boost/variant.hpp>
 
@@ -29,12 +29,6 @@
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
 
@@ -47,10 +41,8 @@
 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_
+
+}
+}
+
+#endif // LOCATION_NMEA_SENTENCE_H_
 
=== modified file 'src/location/nmea/status.h'
--- src/location/providers/ubx/_8/nmea/status.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/status.h	2017-05-05 09:37:41 +0000
@@ -12,29 +12,22 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_STATUS_H_
+#define LOCATION_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_
+
+}
+}
+
+#endif // LOCATION_NMEA_STATUS_H_
 
=== modified file 'src/location/nmea/talker.h'
--- src/location/providers/ubx/_8/nmea/talker.h	2017-03-09 09:42:25 +0000
+++ src/location/nmea/talker.h	2017-05-05 09:37:41 +0000
@@ -12,19 +12,14 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_TALKER_H_
+#define LOCATION_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
 {
@@ -33,10 +28,8 @@
     gn, ///< Global Navigation Satellite System (GNSS)
     gp  ///< Global Positioning System (GPS)
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_TALKER_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_TALKER_H_
 
=== modified file 'src/location/nmea/txt.h'
--- src/location/providers/ubx/_8/nmea/txt.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/txt.h	2017-05-05 09:37:41 +0000
@@ -12,10 +12,10 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_TXT_H_
+#define LOCATION_NMEA_TXT_H_
 
-#include <location/providers/ubx/_8/nmea/talker.h>
+#include <location/nmea/talker.h>
 
 #include <boost/optional.hpp>
 
@@ -25,14 +25,9 @@
 
 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
@@ -46,10 +41,8 @@
     boost::optional<std::uint8_t> identifier;
     boost::optional<std::string> message;
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_TXT_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_TXT_H_
 
=== modified file 'src/location/nmea/utc.h'
--- src/location/providers/ubx/_8/nmea/utc.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/utc.h	2017-05-05 09:37:41 +0000
@@ -12,21 +12,16 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_UTC_H_
+#define LOCATION_NMEA_UTC_H_
 
 #include <cstdint>
 
 namespace location
 {
-namespace providers
-{
-namespace ubx
-{
-namespace _8
-{
 namespace nmea
 {
+
 /// @brief Time in UTC.
 struct Utc
 {
@@ -34,10 +29,8 @@
     std::uint8_t minutes;
     double seconds;
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_UTC_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_UTC_H_
 
=== modified file 'src/location/nmea/vtg.h'
--- src/location/providers/ubx/_8/nmea/vtg.h	2016-10-10 09:15:40 +0000
+++ src/location/nmea/vtg.h	2017-05-05 09:37:41 +0000
@@ -12,11 +12,11 @@
 //
 // 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_
+#ifndef LOCATION_NMEA_VTG_H_
+#define LOCATION_NMEA_VTG_H_
 
-#include <location/providers/ubx/_8/nmea/mode.h>
-#include <location/providers/ubx/_8/nmea/talker.h>
+#include <location/nmea/mode.h>
+#include <location/nmea/talker.h>
 
 #include <boost/optional.hpp>
 
@@ -24,14 +24,9 @@
 
 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).
@@ -44,10 +39,8 @@
     boost::optional<float> sog_kmh;
     boost::optional<Mode> mode;
 };
-}
-}
-}
-}
-}
-
-#endif // UBX_8_NMEA_VTG_H_
+
+}
+}
+
+#endif // LOCATION_NMEA_VTG_H_
 
=== modified file 'src/location/providers/CMakeLists.txt'
--- src/location/providers/CMakeLists.txt	2017-03-04 21:43:23 +0000
+++ src/location/providers/CMakeLists.txt	2017-05-05 09:37:41 +0000
@@ -3,6 +3,7 @@
 add_subdirectory(mls)
 # add_subdirectory(remote)
 add_subdirectory(gps)
+add_subdirectory(sirf)
 add_subdirectory(ubx)
 
 set(
 
=== modified file 'src/location/providers/config.cpp'
--- src/location/providers/config.cpp	2016-10-10 09:15:40 +0000
+++ src/location/providers/config.cpp	2017-05-05 09:37:41 +0000
@@ -20,6 +20,7 @@
 
 #include "dummy/provider.h"
 #include "mls/provider.h"
+#include "sirf/provider.h"
 #include "ubx/provider.h"
 
 #include <map>
@@ -47,6 +48,12 @@
     location::providers::mls::Provider::create_instance
 };
 
+static FactoryInjector sirf_injector
+{
+    "sirf::Provider",
+    location::providers::sirf::Provider::create_instance
+};
+
 static FactoryInjector ubx_injector
 {
     "ubx::Provider",
 
=== added directory 'src/location/providers/sirf'
=== added file 'src/location/providers/sirf/CMakeLists.txt'
--- src/location/providers/sirf/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/CMakeLists.txt	2017-05-05 09:37:41 +0000
@@ -0,0 +1,33 @@
+file(GLOB_RECURSE SIRF_HEADERS*.h)
+
+add_library(
+  sirf
+
+  ${SIRF_HEADERS}
+
+  bits.h
+
+  checksum.h
+  checksum.cpp
+  reader.h
+  reader.cpp
+  receiver.h
+  receiver.cpp
+  scanner.h
+  scanner.cpp
+  serial_port_receiver.h
+  serial_port_receiver.cpp
+  writer.h
+  writer.cpp
+
+  provider.h provider.cpp)
+
+target_link_libraries(
+  sirf
+
+  nmea)
+
+set(
+  ENABLED_PROVIDER_TARGETS
+  ${ENABLED_PROVIDER_TARGETS} sirf
+  PARENT_SCOPE)
 
=== added file 'src/location/providers/sirf/bits.h'
--- src/location/providers/sirf/bits.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/bits.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,49 @@
+// Copyright (C) 2017 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 LOCATION_PROVIDERS_SIRF_BITS_H_
+#define LOCATION_PROVIDERS_SIRF_BITS_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+namespace bits
+{
+
+template<std::size_t begin, std::size_t end, typename T, typename U>
+void set(T& bitfield, U value)
+{
+    static_assert(begin < end, "begin >= end");
+    bitfield |= ((value & ((1 << (end - begin))-1)) << begin);
+}
+
+template<std::size_t begin, std::size_t end, typename T, typename U = T>
+U get(const T& bitfield)
+{
+    static_assert(begin < end, "begin >= end");
+    return (bitfield >> begin) & ((1 << (end - begin)) - 1);
+}
+
+}  // namespace bits
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif  // LOCATION_PROVIDERS_SIRF_BITS_H_
 
=== added file 'src/location/providers/sirf/checksum.cpp'
--- src/location/providers/sirf/checksum.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/checksum.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 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/sirf/checksum.h>
+
+namespace sirf = location::providers::sirf;
+
+void sirf::Checksum::operator()(std::uint8_t byte)
+{
+    checksum += byte;
+}
+
+std::uint16_t sirf::Checksum::operator()() const
+{
+    return checksum;
+}
 
=== added file 'src/location/providers/sirf/checksum.h'
--- src/location/providers/sirf/checksum.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/checksum.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,42 @@
+// Copyright (C) 2017 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 LOCATION_PROVIDERS_SIRF_CHECKSUM_H_
+#define LOCATION_PROVIDERS_SIRF_CHECKSUM_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+class Checksum
+{
+public:
+    void operator()(std::uint8_t byte);
+    std::uint16_t operator()() const;
+
+private:
+    std::uint16_t checksum{0};
+};
+
+}  // namespace sirf
+}  // namespace providers
+}  // namepsace location
+
+#endif  // LOCATION_PROVIDERS_SIRF_CHECKSUM_H_
 
=== added file 'src/location/providers/sirf/codec.h'
--- src/location/providers/sirf/codec.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/codec.h	2017-05-05 09:37:41 +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 LOCATION_PROVIDERS_SIRF_CODEC_H_
+#define LOCATION_PROVIDERS_SIRF_CODEC_H_
+
+#include <location/providers/sirf/checksum.h>
+#include <location/providers/sirf/magic.h>
+#include <location/providers/sirf/reader.h>
+#include <location/providers/sirf/writer.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+template<typename T>
+inline T decode_message(const std::vector<std::uint8_t>& payload)
+{
+    T result;
+    Reader reader{payload.begin(), payload.end()};    
+    result.read(reader);
+
+    return result;
+}
+
+template<typename T>
+inline std::vector<std::uint8_t> encode_message(const T& message)
+{
+    auto msg_size = message.size();
+
+    std::uint16_t size =
+            sizeof(std::uint8_t) + sizeof(std::uint8_t) +
+            sizeof(std::uint16_t) +
+            msg_size +
+            sizeof(std::uint16_t) +
+            sizeof(std::uint8_t) + sizeof(std::uint8_t);
+
+    std::vector<std::uint8_t> result(size, 0);
+
+    Writer writer{result.begin(), result.end()};
+    writer.write_unsigned_char(begin::sync_char_1);
+    writer.write_unsigned_char(begin::sync_char_2);
+    writer.write_unsigned_short(msg_size);
+
+    Writer payload = writer.slice(msg_size);
+    message.write(payload);
+
+    auto checksum = std::for_each(result.begin() + 4, result.end() - 4, Checksum{});
+
+    writer.write_unsigned_short(checksum());
+    writer.write_unsigned_char(end::sync_char_1);
+    writer.write_unsigned_char(end::sync_char_2);
+
+    return result;
+}
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif  // LOCATION_PROVIDERS_SIRF_CODEC_H_
 
=== added file 'src/location/providers/sirf/dop.h'
--- src/location/providers/sirf/dop.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/dop.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,64 @@
+// 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 LOCATION_PROVIDERS_SIRF_DOP_H_
+#define LOCATION_PROVIDERS_SIRF_DOP_H_
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+namespace tag
+{
+
+struct Horizontal
+{
+};
+struct Positional
+{
+};
+struct Vertical
+{
+};
+
+}  // namespace tag
+
+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>;
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_DOP_H_
 
=== added file 'src/location/providers/sirf/geodetic_navigation_data.h'
--- src/location/providers/sirf/geodetic_navigation_data.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/geodetic_navigation_data.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,213 @@
+// Copyright (C) 2017 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 LOCATION_PROVIDERS_SIRF_GEODETIC_NAVIGATION_DATA_H_
+#define LOCATION_PROVIDERS_SIRF_GEODETIC_NAVIGATION_DATA_H_
+
+#include <location/providers/sirf/reader.h>
+
+#include <cstdint>
+#include <iostream>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+struct GeodeticNavigationData
+{
+    enum NavValid
+    {
+        valid_navigation = 0,
+        solution_not_overdetermined = 1 << 0,
+        invalid_dr_sensor_data = 1 << 3,
+        invalid_dr_calibration = 1 << 4,
+        unavailable_dr_gps_calibration = 1 << 5,
+        invalid_dr_position_fix = 1 << 6,
+        invalid_heading = 1 << 7,
+        no_tracker_data_available = 1 << 15
+    };
+
+    enum NavType
+    {
+        no_navigation_fix = 0,
+        one_sv_kf_solution = 1,
+        two_sv_kf_solution = 2,
+        three_sv_kf_solution = 3,
+        four_sv_kf_solution = 4,
+        two_dim_least_squares_solution = 5,
+        three_dim_least_squares_solution = 6,
+        dr_solution = 7,
+        trickle_power_in_use = 1 << 3,
+        altitude_hold_off = 0,
+        altitude_hold_kf = 1,
+        altitude_hold_user_input = 2,
+        altitude_hold_user_input_always = 3,
+        dop_limits_exceeded = 1 << 6,
+        dgps_corrections_applied = 1 << 7,
+        dr_solution_type_sensor = 1,
+        dr_solution_type_velocity = 0,
+        navigation_solution_overdetermined = 1 << 9,
+        velocity_dr_timeout_exceeded = 1 << 10,
+        fix_edited_by_mi_functions = 1 << 11,
+        invalid_velocity = 1 << 12,
+        altitude_hold_disabled = 1 << 13,
+
+    };
+
+    static constexpr std::uint8_t id{0x29};
+
+    std::size_t size() const
+    {
+        return 91;
+    }
+
+    void read(Reader& reader)
+    {
+        nav_valid = reader.read_unsigned_short();
+        nav_type = reader.read_unsigned_short();
+        extended_week_number = reader.read_unsigned_short();
+        time_of_week = reader.read_unsigned_long();
+        utc.year = reader.read_unsigned_short();
+        utc.month = reader.read_unsigned_char();
+        utc.day = reader.read_unsigned_char();
+        utc.hour = reader.read_unsigned_char();
+        utc.minute = reader.read_unsigned_char();
+        utc.seconds = reader.read_unsigned_short();
+        satellite_id_list = reader.read_unsigned_long();
+        latitude = reader.read_signed_long() * 1e-7;
+        longitude = reader.read_signed_long() * 1e-7;
+        altitude.above_ellipsoid = reader.read_signed_long() * 1e-2;
+        altitude.above_mean_sea_level = reader.read_signed_long() * 1e-2;
+        map_datum = reader.read_signed_char();
+        over_ground.speed = reader.read_unsigned_short() * 1e-2;
+        over_ground.course = reader.read_unsigned_short() * 1e-2;
+        magnetic_variation = reader.read_signed_short();
+        climb_rate = reader.read_signed_short() * 1e-2;
+        heading_rate = reader.read_signed_short() * 1e-2;
+        error.horizontal_position = reader.read_unsigned_long() * 1e-2;
+        error.vertical_position = reader.read_unsigned_long() * 1e-2;
+        error.time = reader.read_unsigned_long() * 1e-2;
+        error.horizontal_velocity = reader.read_unsigned_short() * 1e-2;
+        clock.bias = reader.read_signed_long() * 1e-2;
+        clock.bias_error = reader.read_unsigned_long() * 1e-2;
+        clock.drift = reader.read_signed_long() * 1e-2;
+        clock.drift_error = reader.read_unsigned_long() * 1e-2;
+        distance_traveled = reader.read_unsigned_long();
+        distance_traveled_error = reader.read_unsigned_short();
+        error.heading = reader.read_unsigned_short() * 1e-2;
+        svs_in_fix = reader.read_unsigned_char();
+        hdop = reader.read_unsigned_char() / 5.f;
+        mode_info = reader.read_unsigned_char();
+    }
+
+    std::uint16_t nav_valid;
+    std::uint16_t nav_type;
+    std::uint16_t extended_week_number;
+    std::uint32_t time_of_week;
+    struct
+    {
+        std::uint16_t year;
+        std::uint8_t month;
+        std::uint8_t day;
+        std::uint8_t hour;
+        std::uint8_t minute;
+        std::uint16_t seconds;
+    } utc;
+    std::uint32_t satellite_id_list;
+    float latitude;
+    float longitude;
+    struct
+    {
+        float above_ellipsoid;
+        float above_mean_sea_level;
+    } altitude;
+    std::int8_t map_datum;
+    struct
+    {
+        std::uint16_t speed;
+        std::uint16_t course;
+    } over_ground;
+    std::int16_t magnetic_variation;
+    float climb_rate;
+    float heading_rate;
+    struct
+    {
+        float horizontal_position;
+        float vertical_position;
+        float time;
+        float horizontal_velocity;
+        float heading;
+    } error;
+    struct
+    {
+        float bias;
+        float bias_error;
+        float drift;
+        float drift_error;
+    } clock;
+    std::uint32_t distance_traveled;
+    std::uint32_t distance_traveled_error;
+    std::uint8_t svs_in_fix;
+    std::uint8_t hdop;
+    std::uint8_t mode_info;
+};
+
+inline std::ostream& operator<<(std::ostream& out, const GeodeticNavigationData& gnd)
+{
+    return out << "GeodeticNavigationData:" << std::endl
+               << "  nav-valid: " << gnd.nav_valid << std::endl
+               << "  nav-type: " << gnd.nav_type << std::endl
+               << "  extended-week-number: " << gnd.extended_week_number << std::endl
+               << "  time-of-week: " << gnd.time_of_week << std::endl
+               << "  utc.year: " << gnd.utc.year << std::endl
+               << "  utc.month: " << std::uint32_t(gnd.utc.month) << std::endl
+               << "  utc.day: " << std::uint32_t(gnd.utc.day) << std::endl
+               << "  utc.hour: " << std::uint32_t(gnd.utc.hour) << std::endl
+               << "  utc.minute: " << std::uint32_t(gnd.utc.minute) << std::endl
+               << "  utc.seconds: " << gnd.utc.seconds << std::endl
+               << "  satellite-id-list: " << gnd.satellite_id_list << std::endl
+               << "  latitude: " << gnd.latitude << std::endl
+               << "  longitude: " << gnd.longitude << std::endl
+               << "  altitude.above-ellipsoid: " << gnd.altitude.above_ellipsoid << std::endl
+               << "  altitude.above-msl: " << gnd.altitude.above_mean_sea_level << std::endl
+               << "  map-datum: " << std::int32_t(gnd.map_datum) << std::endl
+               << "  over-ground.speed: " << gnd.over_ground.speed << std::endl
+               << "  over-ground.course: " << gnd.over_ground.course << std::endl
+               << "  climb-rate: " << gnd.climb_rate << std::endl
+               << "  heading-rate: " << gnd.heading_rate << std::endl
+               << "  error.horizontal-position: " << gnd.error.horizontal_position << std::endl
+               << "  error.vertical-position: " << gnd.error.vertical_position << std::endl
+               << "  error.time: " << gnd.error.time << std::endl
+               << "  error.horizontal-velocity: " << gnd.error.horizontal_velocity << std::endl
+               << "  error.heading: " << gnd.error.heading << std::endl
+               << "  clock.bias: " << gnd.clock.bias << std::endl
+               << "  clock.bias-error: " << gnd.clock.bias_error << std::endl
+               << "  clock.drift: " << gnd.clock.drift << std::endl
+               << "  clock.drift-error: " << gnd.clock.drift_error << std::endl
+               << "  distance-traveled: " << gnd.distance_traveled << std::endl
+               << "  distance-traveled-error: " << gnd.distance_traveled_error << std::endl
+               << "  svs-in-fix: " << std::uint32_t(gnd.svs_in_fix) << std::endl
+               << "  hdop: " << std::uint32_t(gnd.hdop) << std::endl
+               << "  mode-info: " << std::uint32_t(gnd.mode_info);
+}
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif  // LOCATION_PROVIDERS_SIRF_GEODETIC_NAVIGATION_DATA_H_
 
=== added file 'src/location/providers/sirf/initialize_data_source.h'
--- src/location/providers/sirf/initialize_data_source.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/initialize_data_source.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,93 @@
+// Copyright (C) 2017 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 LOCATION_PROVIDERS_SIRF_INITIALIZE_DATA_SOURCE_H_
+#define LOCATION_PROVIDERS_SIRF_INITIALIZE_DATA_SOURCE_H_
+
+#include <location/providers/sirf/writer.h>
+
+#include <cstdint>
+#include <iostream>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+struct InitializeDataSource
+{
+    enum ResetConfiguration
+    {
+        data_valid = 1 << 0,
+        clear_ephemeris_data = 1 << 1,
+        clear_all_history = 1 << 2,
+        factory_reset = 1 << 3,
+        enable_nav_lib_data = 1 << 4,
+        enable_debug_data = 1 << 5,
+        rtc_is_not_precise = 1 << 6,
+        reset = 1 << 7
+    };
+
+    static constexpr std::uint8_t id{128};
+    static constexpr std::uint8_t max_number_channels{12};
+
+    std::size_t size() const
+    {
+        return 25;
+    }
+
+    void write(Writer& writer) const
+    {
+        writer.write_unsigned_char(id);
+        writer.write_signed_long(ecef_x);
+        writer.write_signed_long(ecef_y);
+        writer.write_signed_long(ecef_z);
+        writer.write_signed_long(clock_drift);
+        writer.write_unsigned_long(ecef_x);
+        writer.write_unsigned_short(week_number);
+        writer.write_unsigned_char(channels);
+        writer.write_unsigned_char(reset_configuration);
+    }
+
+    std::int32_t ecef_x;
+    std::int32_t ecef_y;
+    std::int32_t ecef_z;
+    std::int32_t clock_drift;
+    std::uint32_t time_of_week;
+    std::uint16_t week_number;
+    std::uint8_t channels;
+    std::uint8_t reset_configuration;
+};
+
+inline std::ostream& operator<<(std::ostream& out, const InitializeDataSource& ids)
+{
+    return out << "InitializeDataSource:" << std::endl
+               << "  ecef-x: " << ids.ecef_x << std::endl
+               << "  ecef-y: " << ids.ecef_y << std::endl
+               << "  ecef-z: " << ids.ecef_z << std::endl
+               << "  clock-drift: " << ids.clock_drift << std::endl
+               << "  time-of-week: " << ids.time_of_week << std::endl
+               << "  week_number: " << ids.week_number << std::endl
+               << "  channels: " << std::uint32_t(ids.channels) << std::endl
+               << "  reset-config: " << std::uint32_t(ids.reset_configuration) << std::endl;
+}
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif  // LOCATION_PROVIDERS_SIRF_INITIALIZE_DATA_SOURCE_H_
 
=== added file 'src/location/providers/sirf/magic.h'
--- src/location/providers/sirf/magic.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/magic.h	2017-05-05 09:37:41 +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 LOCATION_PROVIDERS_SIRF_MAGIC_H_
+#define LOCATION_PROVIDERS_SIRF_MAGIC_H_
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+namespace begin
+{
+
+constexpr const std::uint8_t sync_char_1{0xa0};
+constexpr const std::uint8_t sync_char_2{0xa2};
+
+}  // namespace begin
+namespace end
+{
+
+constexpr const std::uint8_t sync_char_1{0xb0};
+constexpr const std::uint8_t sync_char_2{0xb3};
+
+}  // namespace end
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_MAGIC_H_
 
=== added file 'src/location/providers/sirf/message.h'
--- src/location/providers/sirf/message.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/message.h	2017-05-05 09:37:41 +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 LOCATION_PROVIDERS_SIRF_MESSAGE_H_
+#define LOCATION_PROVIDERS_SIRF_MESSAGE_H_
+
+#include <location/providers/sirf/geodetic_navigation_data.h>
+#include <location/providers/sirf/initialize_data_source.h>
+#include <location/providers/sirf/set_protocol.h>
+
+#include <boost/variant.hpp>
+
+#include <iostream>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+struct Null {};
+
+using Message = boost::variant<
+    Null,
+    InitializeDataSource,
+    GeodeticNavigationData,
+    SetProtocol
+>;
+
+inline std::ostream& operator<<(std::ostream& out, const Null&)
+{
+    return out << "Uninterpreted sirf message";
+}
+
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_MESSAGE_H_
 
=== added file 'src/location/providers/sirf/provider.cpp'
--- src/location/providers/sirf/provider.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/provider.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,353 @@
+/*
+ * 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 <location/providers/sirf/provider.h>
+
+#include <location/logging.h>
+#include <location/runtime.h>
+#include <location/events/reference_position_updated.h>
+#include <location/glib/runtime.h>
+
+#include <core/net/http/client.h>
+#include <core/posix/this_process.h>
+
+#include <boost/lexical_cast.hpp>
+
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <thread>
+
+namespace env = core::posix::this_process::env;
+namespace sirf = location::providers::sirf;
+
+namespace
+{
+
+struct SettingsHelper
+{
+    template<typename T>
+    static T get_value(std::string key, T&& default_value)
+    {
+        static const std::string snap_path = env::get("SNAP_DATA");
+
+        boost::filesystem::path path{snap_path};
+        std::replace(key.begin(), key.end(), '.', '/');
+        path /= key;
+
+        LOG(INFO) << "Reading setting from " << path.string();
+
+        std::ifstream in{path.string().c_str()};
+        T value{default_value}; in >> value;
+
+        return value;
+    }
+};
+
+}
+
+std::string sirf::Provider::class_name()
+{
+    return "sirf::Provider";
+}
+
+void sirf::Provider::Monitor::on_new_sirf_message(const Message& message)
+{
+    VLOG(1) << message;
+    if (auto sp = provider.lock())
+        if (sp->configuration.protocol == Provider::Protocol::sirf)
+            boost::apply_visitor(*this, message);
+}
+
+
+void sirf::Provider::Monitor::on_new_nmea_sentence(const nmea::Sentence& sentence)
+{
+    VLOG(1) << sentence;
+    if (auto sp = provider.lock())
+        if (sp->configuration.protocol == Provider::Protocol::nmea)
+            boost::apply_visitor(*this, sentence);
+}
+
+void sirf::Provider::Monitor::operator()(const sirf::GeodeticNavigationData& gnd)
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<sirf::Provider::Monitor> wp{thiz};
+
+    glib::Runtime::instance()->dispatch([gnd, wp]()
+    {
+        if (auto sp = wp.lock())
+        {
+            if (auto spp = sp->provider.lock())
+            {
+                if (gnd.nav_valid == GeodeticNavigationData::valid_navigation)
+                {
+                    Position position
+                    {
+                        gnd.latitude * units::degrees,
+                        gnd.longitude * units::degrees
+                    };
+                    position.accuracy().horizontal(gnd.error.horizontal_position * units::meters);
+
+                    position.altitude(gnd.altitude.above_mean_sea_level * units::meters);
+                    position.accuracy().vertical(gnd.error.vertical_position * units::meters);
+
+                    spp->updates.position(location::Update<location::Position>{position});
+                    if (!(gnd.nav_type & GeodeticNavigationData::invalid_heading))
+                        spp->updates.heading(location::Update<units::Degrees>{gnd.over_ground.course * units::degrees});
+                    if (!(gnd.nav_type & GeodeticNavigationData::invalid_velocity))
+                        spp->updates.velocity(location::Update<units::MetersPerSecond>{gnd.over_ground.speed * units::meters_per_second});
+                }
+            }
+        }
+    });
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Gga& gga)
+{   
+    if (gga.latitude && gga.longitude)
+    {
+        auto lat = gga.latitude.get();
+        auto lon = gga.longitude.get();
+
+        Position position
+        {
+            (lat.degrees + lat.minutes / 60.f) * units::degrees,
+            (lon.degrees + lon.minutes / 60.f) * units::degrees
+        };
+
+        if (gga.altitude)
+            position.altitude(units::Meters::from_value(*gga.altitude));
+
+        // TODO(tvoss): Maximum accuracy should be reported by the receiver
+        // implementation rather than hardcoding 3 [m] here.
+        if (gga.hdop)
+            position.accuracy().horizontal(gga.hdop.get() * 3. * units::meters);
+
+        auto thiz = shared_from_this();
+        std::weak_ptr<sirf::Provider::Monitor> wp{thiz};
+
+        glib::Runtime::instance()->dispatch([position, wp]()
+        {
+            if (auto sp = wp.lock())
+                if (auto spp = sp->provider.lock())
+                    spp->updates.position(location::Update<location::Position>{position});
+        });
+    }
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Gsa&)
+{
+    // Empty on purpose
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Gll&)
+{
+    // Empty on purpose
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Gsv&)
+{
+    // Empty on purpose
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Rmc&)
+{
+    // Empty on purpose
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Txt&)
+{
+    // Empty on purpose
+}
+
+void sirf::Provider::Monitor::operator()(const nmea::Vtg& vtg)
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<sirf::Provider::Monitor> wp{thiz};
+
+    glib::Runtime::instance()->dispatch([vtg, wp]()
+    {
+        if (auto sp = wp.lock())
+        {
+            if (vtg.cog_true)
+                if (auto spp = sp->provider.lock())
+                    spp->updates.heading(
+                                Update<units::Degrees>(
+                                    vtg.cog_true.get() * units::degrees));
+            if (vtg.sog_kmh)
+                if (auto spp = sp->provider.lock())
+                    spp->updates.velocity(
+                                Update<units::MetersPerSecond>(
+                                    vtg.sog_kmh.get() * 1000./3600. * units::meters_per_second));
+        }
+    });
+}
+
+location::Provider::Ptr sirf::Provider::create_instance(const location::ProviderFactory::Configuration& config)
+{
+    Configuration configuration
+    {
+        SettingsHelper::get_value<Protocol>(
+            "sirf.provider.protocol",
+            Protocol::sirf),
+        config.get<std::string>(
+            "device", SettingsHelper::get_value<std::string>(
+                    "sirf.provider.path",
+                    "/dev/ttyUSB1"
+            )
+        )
+    };
+
+    return sirf::Provider::create(configuration);
+}
+
+// Create a new instance with configuration.
+std::shared_ptr<sirf::Provider> sirf::Provider::create(const Configuration& configuration)
+{
+    auto sp = std::shared_ptr<Provider>{new Provider{configuration}};
+    return sp->finalize_construction();
+}
+
+
+sirf::Provider::Provider(const Configuration& configuration)
+    : configuration{configuration},
+      runtime{location::Runtime::create(1)},
+      monitor{std::make_shared<Monitor>()},
+      receiver{SerialPortReceiver::create(runtime->service(), configuration.device, monitor)}
+{
+    runtime->start();
+    configure_protocol();
+}
+
+sirf::Provider::~Provider() noexcept
+{
+    deactivate();
+    runtime->stop();
+}
+
+void sirf::Provider::reset()
+{
+    InitializeDataSource ids;
+    ids.channels = InitializeDataSource::max_number_channels;
+    ids.reset_configuration = InitializeDataSource::clear_ephemeris_data | InitializeDataSource::clear_all_history;
+    receiver->send_message(Message{ids});
+}
+
+void sirf::Provider::on_new_event(const Event&)
+{
+    // TODO(tvoss): Use incoming reference position updates
+    // to query assistance data.
+}
+
+location::Provider::Requirements sirf::Provider::requirements() const
+{
+    return Requirements::none;
+}
+
+bool sirf::Provider::satisfies(const location::Criteria&)
+{
+    return true;
+}
+
+void sirf::Provider::enable()
+{
+}
+
+void sirf::Provider::disable()
+{
+}
+
+void sirf::Provider::activate()
+{
+    receiver->start();
+}
+
+void sirf::Provider::deactivate()
+{
+    receiver->stop();
+}
+
+const core::Signal<location::Update<location::Position>>& sirf::Provider::position_updates() const
+{
+    return updates.position;
+}
+
+const core::Signal<location::Update<location::units::Degrees>>& sirf::Provider::heading_updates() const
+{
+    return updates.heading;
+}
+
+const core::Signal<location::Update<location::units::MetersPerSecond>>& sirf::Provider::velocity_updates() const
+{
+    return updates.velocity;
+}
+
+std::shared_ptr<sirf::Provider> sirf::Provider::finalize_construction()
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<sirf::Provider> wp{thiz};
+
+    monitor->provider = wp;
+    return thiz;
+}
+
+void sirf::Provider::configure_protocol()
+{
+    switch(configuration.protocol)
+    {
+    case Protocol::sirf:
+    {
+        static const std::string set_serial_port{"$PSRF100,0,4800,8,1,0*0F\r\n"};
+        receiver->send_encoded_message(std::vector<std::uint8_t>{set_serial_port.begin(), set_serial_port.end()});
+        break;
+    }
+    case Protocol::nmea:
+        receiver->send_message(Message{SetProtocol{SetProtocol::nmea}});
+        break;
+    default:
+        break;
+    }
+}
+
+std::istream& sirf::operator>>(std::istream& in, Provider::Protocol& protocol)
+{
+    std::string value;
+    in >> value;
+
+    if (value == "sirf")
+        protocol = Provider::Protocol::sirf;
+    if (value == "nmea")
+        protocol = Provider::Protocol::nmea;
+
+    return in;
+}
+
+std::ostream& sirf::operator<<(std::ostream& out, Provider::Protocol protocol)
+{
+    switch (protocol)
+    {
+    case Provider::Protocol::sirf:
+        out << "sirf";
+        break;
+    case Provider::Protocol::nmea:
+        out << "nmea";
+        break;
+    }
+
+    return out;
+}
 
=== added file 'src/location/providers/sirf/provider.h'
--- src/location/providers/sirf/provider.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/provider.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,143 @@
+/*
+ * 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_SIRF_PROVIDER_H_
+#define LOCATION_PROVIDERS_SIRF_PROVIDER_H_
+
+#include <location/provider.h>
+#include <location/provider_factory.h>
+#include <location/runtime.h>
+#include <location/nmea/sentence.h>
+#include <location/providers/sirf/serial_port_receiver.h>
+
+#include <boost/filesystem.hpp>
+
+#include <iosfwd>
+#include <thread>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+// sirf::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 std::enable_shared_from_this<Provider>
+{
+public:
+    enum class Protocol
+    {
+        sirf, // Rely on sirf.
+        nmea  // Rely on nmea.
+    };
+
+    // Configuration bundles all construction time parameters.
+    struct Configuration
+    {
+        Protocol protocol;                                  // The protocol used for communicating with the receiver.
+        boost::filesystem::path device;                     // Serial device used for communicating with the receiver.
+    };
+
+    // 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&);
+
+    // Create a new instance with configuration.
+    static std::shared_ptr<Provider> create(const Configuration& configuration);
+
+    // Cleans up all resources and stops the updates.
+    ~Provider() noexcept;
+
+    // Resets the chipset and drops all cached data.
+    // The next positioning request will be a cold start.
+    void reset();
+
+    // 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 std::enable_shared_from_this<sirf::Provider::Monitor>, public sirf::Receiver::Monitor, public boost::static_visitor<>
+    {
+        // From Receiver::Monitor
+        void on_new_sirf_message(const Message& message) override;
+        void on_new_nmea_sentence(const nmea::Sentence& sentence) override;
+
+        template<typename T>
+        void operator()(const T&) const {}
+
+        void operator()(const GeodeticNavigationData& gnd);
+
+        void operator()(const nmea::Gga& gga);
+        void operator()(const nmea::Gsa& gsa);
+        void operator()(const nmea::Gll& gll);
+        void operator()(const nmea::Gsv& gsv);
+        void operator()(const nmea::Rmc& rmc);
+        void operator()(const nmea::Txt& txt);
+        void operator()(const nmea::Vtg& vtg);
+
+        std::weak_ptr<Provider> provider;
+    };
+
+    // Creates a new provider instance talking via device to the ubx chipset.
+    Provider(const Configuration& configuration);
+
+    std::shared_ptr<Provider> finalize_construction();
+    void configure_protocol();
+
+    Configuration configuration;
+    std::shared_ptr<location::Runtime> runtime;
+    std::shared_ptr<Monitor> monitor;
+    std::shared_ptr<SerialPortReceiver> receiver;
+    struct
+    {
+        core::Signal<Update<Position>> position;
+        core::Signal<Update<units::Degrees>> heading;
+        core::Signal<Update<units::MetersPerSecond>> velocity;
+    } updates;
+};
+
+std::istream& operator>>(std::istream&, Provider::Protocol&);
+std::ostream& operator<<(std::ostream&, Provider::Protocol);
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_PROVIDER_H_
 
=== added file 'src/location/providers/sirf/reader.cpp'
--- src/location/providers/sirf/reader.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/reader.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,87 @@
+// 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/sirf/reader.h>
+
+#include <arpa/inet.h>
+
+#include <cstring>
+#include <stdexcept>
+
+namespace sirf = location::providers::sirf;
+
+sirf::Reader::Reader(std::vector<std::uint8_t>::const_iterator begin,
+                        std::vector<std::uint8_t>::const_iterator end)
+    : begin{begin}, current{begin}, end{end} {}
+
+std::uint8_t sirf::Reader::read_unsigned_char()
+{
+    if (current + sizeof(std::uint8_t) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = *current;
+    ++current;
+    return result;
+}
+
+std::int8_t sirf::Reader::read_signed_char()
+{
+    if (current + sizeof(std::int8_t) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const std::int8_t*>(&(*current));
+    current += sizeof(std::int8_t);
+    return *result;
+}
+
+std::uint16_t sirf::Reader::read_unsigned_short()
+{
+    if (current + sizeof(std::uint16_t) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const std::uint16_t*>(&(*current));
+    current += sizeof(std::uint16_t);
+    return ::htons(*result);
+}
+
+std::int16_t sirf::Reader::read_signed_short()
+{
+    if (current + sizeof(std::int16_t) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const std::int16_t*>(&(*current));
+    current += sizeof(std::int16_t);
+    return ::htons(*result);
+}
+
+std::uint32_t sirf::Reader::read_unsigned_long()
+{
+    if (current + sizeof(std::uint32_t) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const std::uint32_t*>(&(*current));
+    current += sizeof(std::uint32_t);
+    return ::htonl(*result);
+}
+
+std::int32_t sirf::Reader::read_signed_long()
+{
+    if (current + sizeof(std::int32_t) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const std::int32_t*>(&(*current));
+    current += sizeof(std::int32_t);
+    return ::htonl(*result);
+}
 
=== added file 'src/location/providers/sirf/reader.h'
--- src/location/providers/sirf/reader.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/reader.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,52 @@
+// 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 LOCATION_PROVIDERS_SIRF_READER_H_
+#define LOCATION_PROVIDERS_SIRF_READER_H_
+
+#include <cstdint>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+class Reader
+{
+public:
+    explicit Reader(std::vector<std::uint8_t>::const_iterator begin,
+                    std::vector<std::uint8_t>::const_iterator end);
+
+    std::uint8_t read_unsigned_char();
+    std::int8_t read_signed_char();
+    std::uint16_t read_unsigned_short();
+    std::int16_t read_signed_short();
+    std::uint32_t read_unsigned_long();
+    std::int32_t read_signed_long();
+
+private:
+    std::vector<std::uint8_t>::const_iterator begin;
+    std::vector<std::uint8_t>::const_iterator current;
+    std::vector<std::uint8_t>::const_iterator end;
+};
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_READER_H_
 
=== added file 'src/location/providers/sirf/receiver.cpp'
--- src/location/providers/sirf/receiver.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/receiver.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,80 @@
+#include <location/providers/sirf/receiver.h>
+
+#include <location/nmea/sentence.h>
+#include <location/providers/sirf/message.h>
+
+#include <iostream>
+
+namespace sirf = location::providers::sirf;
+
+namespace
+{
+
+struct EncodingVisitor : public boost::static_visitor<std::vector<std::uint8_t>>
+{
+    template<typename T>
+    std::vector<std::uint8_t> operator()(const T&) const
+    {
+        throw std::logic_error{"Encoding not supported"};
+    }
+
+    std::vector<std::uint8_t> operator()(const sirf::InitializeDataSource& ids) const
+    {
+        return sirf::encode_message(ids);
+    }
+
+    std::vector<std::uint8_t> operator()(const sirf::SetProtocol& sp) const
+    {
+        return sirf::encode_message(sp);
+    }
+};
+
+}  // namespace
+
+sirf::Receiver::Receiver(const std::shared_ptr<Monitor>& monitor) : monitor{monitor} {}
+
+void sirf::Receiver::send_message(const Message& message)
+{
+    send_encoded_message(boost::apply_visitor(EncodingVisitor{}, message));
+}
+
+void sirf::Receiver::process_chunk(Buffer::iterator it, Buffer::iterator itE)
+{
+    while (it != itE)
+    {
+        auto result = sirf_scanner.update(*it);
+
+        if (std::get<0>(result) == Scanner::Expect::nothing_more)
+        {
+            try
+            {
+                monitor->on_new_sirf_message(sirf_scanner.finalize());
+            }
+            catch (...)
+            {
+                // Dropping the exception as there is hardly any reasonable measure
+                // we can take. Both scanners are designed to recover from issues, and we
+                // we just trap the exception here to guarantee that we keep on consuming the
+                // entire buffer.
+            }
+        }
+        else if (!std::get<1>(result))
+        {
+            if (nmea::Scanner::Expect::nothing_more == nmea_scanner.update(*it))
+            {
+                try
+                {
+                    monitor->on_new_nmea_sentence(nmea::parse_sentence(nmea_scanner.finalize()));
+                }
+                catch (...)
+                {
+                    // Dropping the exception as there is hardly any reasonable measure
+                    // we can take. Both scanners are designed to recover from issues, and we
+                    // we just trap the exception here to guarantee that we keep on consuming the
+                    // entire buffer.
+                }
+            }
+        }
+        ++it;
+    }
+}
 
=== added file 'src/location/providers/sirf/receiver.h'
--- src/location/providers/sirf/receiver.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/receiver.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,92 @@
+// 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 LOCATION_PROVIDERS_SIRF_RECEIVER_H_
+#define LOCATION_PROVIDERS_SIRF_RECEIVER_H_
+
+#include <location/providers/sirf/codec.h>
+#include <location/providers/sirf/message.h>
+#include <location/providers/sirf/scanner.h>
+
+#include <location/nmea/scanner.h>
+#include <location/nmea/sentence.h>
+
+#include <memory>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+/// @brief Receiver connects to a ublox 8 GNSS receiver.
+class Receiver
+{
+public:
+    using Buffer = std::array<std::uint8_t, 4096>;
+
+    /// @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_ubx_message is invoked for every complete and parsed
+        /// ubx message.
+        virtual void on_new_sirf_message(const sirf::Message& message) = 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;
+    };
+
+    /// @brief send_message encodes and sends 'message' to the receiver.
+    void send_message(const Message& message);
+
+    /// @brief send_encoded_message sends out data to the receiver.
+    virtual void send_encoded_message(const std::vector<std::uint8_t> &data) = 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;
+    sirf::Scanner sirf_scanner;
+};
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_RECEIVER_H_
 
=== added file 'src/location/providers/sirf/scanner.cpp'
--- src/location/providers/sirf/scanner.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/scanner.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,161 @@
+// 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/sirf/scanner.h>
+
+#include <location/providers/sirf/codec.h>
+#include <location/providers/sirf/magic.h>
+#include <location/providers/sirf/message.h>
+
+#include <cstdint>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <tuple>
+#include <vector>
+
+namespace sirf = location::providers::sirf;
+
+sirf::Scanner::Scanner()
+    : next{Expect::sync_char_begin_1},
+      expected_size{0},
+      message_id{0},
+      payload_iterator{payload.end()},
+      checksum_1{0},
+      checksum_2{0}
+{
+}
+
+std::tuple<sirf::Scanner::Expect, bool> sirf::Scanner::update(std::uint8_t c)
+{
+    bool consumed = false;
+
+    switch (next)
+    {
+    case Expect::sync_char_begin_1:
+        if (c == begin::sync_char_1)
+        {
+            reset();
+            next = Expect::sync_char_begin_2;
+            consumed = true;
+        }
+        break;
+    case Expect::sync_char_begin_2:
+        if (c == begin::sync_char_2)
+        {
+            next = Expect::length_1;
+            consumed = true;
+        }
+        break;
+    case Expect::length_1:
+        expected_size |= (c << 8);
+        next = Expect::length_2;
+        consumed = true;
+        break;
+    case Expect::length_2:
+        expected_size |= c;
+        if (expected_size > 0)
+            expected_size -= 1;
+        payload.resize(expected_size);
+        payload_iterator = payload.begin();
+        next = Expect::message_id;
+        consumed = true;
+        break;
+    case Expect::message_id:
+        checksum(c);
+        message_id = c;
+        next = expected_size > 0 ? Expect::payload : Expect::checksum_1;
+        consumed = true;
+        break;
+    case Expect::payload:
+        checksum(c);
+        *payload_iterator = c;
+        ++payload_iterator;
+        next = payload_iterator == payload.end()
+                ? Expect::checksum_1
+                : next;
+        consumed = true;
+        break;
+    case Expect::checksum_1:
+        checksum_1 = c;
+        next = Expect::checksum_2;
+        consumed = true;
+        break;
+    case Expect::checksum_2:
+        checksum_2 = c;
+        next = Expect::sync_char_end_1;
+        consumed = true;
+        break;
+    case Expect::sync_char_end_1:
+        if (c == end::sync_char_1)
+        {
+            next = Expect::sync_char_end_2;
+            consumed = true;
+        }
+        break;
+    case Expect::sync_char_end_2:
+        if (c == end::sync_char_2)
+        {
+            next = Expect::nothing_more;
+            consumed = true;
+        }
+        break;
+    default:
+        consumed = false;
+        break;
+    }
+
+    return std::make_tuple(next, consumed);
+}
+
+sirf::Message sirf::Scanner::finalize()
+{
+    if (next != Expect::nothing_more)
+        throw std::logic_error{"Not ready for extraction."};
+
+    struct Scope
+    {
+        Scope(Scanner& scanner) : scanner{scanner} {}
+        ~Scope() { scanner.reset(); }
+
+        Scanner& scanner;
+    } scope{*this};
+
+    if (checksum() != ((checksum_1 << 8) | checksum_2))
+        throw std::runtime_error("Failed to verify sirf protocol message integrity.");
+
+    switch (message_id)
+    {
+    case GeodeticNavigationData::id:
+        return decode_message<GeodeticNavigationData>(payload);
+    default:
+        break;
+    }
+
+    return Message{Null{}};
+}
+
+void sirf::Scanner::reset()
+{
+    checksum = Checksum{};
+    next = Expect::sync_char_begin_1;
+    expected_size = 0;
+    message_id = 0;
+    payload.clear();
+    payload_iterator = payload.end();
+    checksum_1 = checksum_2 = 0;
+}
 
=== added file 'src/location/providers/sirf/scanner.h'
--- src/location/providers/sirf/scanner.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/scanner.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,76 @@
+// 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 LOCATION_PROVIDERS_SIRF_SCANNER_H_
+#define LOCATION_PROVIDERS_SIRF_SCANNER_H_
+
+#include <location/providers/sirf/checksum.h>
+#include <location/providers/sirf/message.h>
+
+#include <cstdint>
+#include <tuple>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+class Scanner
+{
+public:    
+    ///  @brief Expect enumerates the different states of the scanner/parser.
+    enum class Expect
+    {
+        sync_char_begin_1,
+        sync_char_begin_2,        
+        length_1,
+        length_2,
+        message_id,
+        payload,
+        checksum_1,
+        checksum_2,
+        sync_char_end_1,
+        sync_char_end_2,
+        nothing_more
+    };    
+
+    Scanner();
+
+    std::tuple<Expect, bool> update(std::uint8_t c);
+
+    Message finalize();
+
+private:
+
+    void reset();
+
+    Expect next;
+    Checksum checksum;    
+    std::uint16_t expected_size;
+    std::uint8_t message_id;
+    std::vector<uint8_t> payload;
+    std::vector<uint8_t>::iterator payload_iterator;
+    std::uint8_t checksum_1;
+    std::uint8_t checksum_2;
+};
+
+}
+}
+}
+
+#endif // LOCATION_PROVIDERS_SIRF_SCANNER_H_
 
=== added file 'src/location/providers/sirf/serial_port_receiver.cpp'
--- src/location/providers/sirf/serial_port_receiver.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/serial_port_receiver.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,80 @@
+#include <location/providers/sirf/serial_port_receiver.h>
+
+#include <location/logging.h>
+
+#include <iostream>
+#include <system_error>
+
+namespace sirf = location::providers::sirf;
+
+std::shared_ptr<sirf::SerialPortReceiver> sirf::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}};
+}
+
+sirf::SerialPortReceiver::SerialPortReceiver(boost::asio::io_service& ios, const boost::filesystem::path& dev,
+                                                const std::shared_ptr<Monitor>& monitor)
+    : Receiver{monitor}, ios{ios}, serial_port{ios, dev.string().c_str()}
+{
+    serial_port.set_option(boost::asio::serial_port::baud_rate(4800));
+    serial_port.set_option(boost::asio::serial_port::stop_bits(boost::asio::serial_port::stop_bits::one));
+    serial_port.set_option(boost::asio::serial_port::parity(boost::asio::serial_port::parity::none));
+    serial_port.set_option(boost::asio::serial_port::flow_control(boost::asio::serial_port::flow_control::none));
+}
+
+void sirf::SerialPortReceiver::send_encoded_message(const std::vector<std::uint8_t>& data)
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<SerialPortReceiver> wp{thiz};
+
+    ios.dispatch([this, wp, data]()
+    {
+        if (auto sp = wp.lock())
+            boost::asio::write(serial_port, boost::asio::buffer(data), boost::asio::transfer_all());
+    });
+}
+
+void sirf::SerialPortReceiver::start()
+{
+    ::tcflush(serial_port.lowest_layer().native_handle(), TCIFLUSH);
+    start_read();
+}
+
+void sirf::SerialPortReceiver::stop()
+{
+    serial_port.cancel();
+}
+
+void sirf::SerialPortReceiver::start_read()
+{
+    auto thiz = shared_from_this();
+    std::weak_ptr<SerialPortReceiver> wp{thiz};
+
+    boost::asio::async_read(serial_port, boost::asio::buffer(&buffer.front(), buffer.size()),
+                            [this, wp](const boost::system::error_code& ec, std::size_t transferred) {
+                                if (ec == boost::asio::error::operation_aborted)
+                                    return;
+
+                                if (auto sp = wp.lock())
+                                {
+                                    if (not ec)
+                                    {
+                                        try
+                                        {
+                                            process_chunk(buffer.begin(), buffer.begin() + transferred);
+                                        }
+                                        catch(const std::exception& e)
+                                        {
+                                            LOG(WARNING) << "Error processing data chunk: " << e.what();
+                                        }
+                                        catch(...)
+                                        {
+                                            LOG(WARNING) << "Error processing data chunk.";
+                                        }
+
+                                        start_read();
+                                    }
+                                }
+                            });
+}
 
=== added file 'src/location/providers/sirf/serial_port_receiver.h'
--- src/location/providers/sirf/serial_port_receiver.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/serial_port_receiver.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,79 @@
+// 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 LOCATION_PROVIDERS_SIRF_SERIAL_PORT_RECEIVER_H_
+#define LOCATION_PROVIDERS_SIRF_SERIAL_PORT_RECEIVER_H_
+
+#include <location/providers/sirf/receiver.h>
+
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+
+#include <array>
+#include <atomic>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+/// @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();
+
+    void send_encoded_message(const std::vector<std::uint8_t>& data) override;
+
+private:
+    enum class State
+    {
+        running,
+        stopped
+    };
+
+    /// @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 serial_port;
+};
+
+}
+}
+}
+
+#endif // LOCATION_PROVIDERS_SIRF_SERIAL_PORT_RECEIVER_H_
 
=== added file 'src/location/providers/sirf/set_protocol.h'
--- src/location/providers/sirf/set_protocol.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/set_protocol.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,73 @@
+// Copyright (C) 2017 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 LOCATION_PROVIDERS_SIRF_SET_PROTOCOL_H_
+#define LOCATION_PROVIDERS_SIRF_SET_PROTOCOL_H_
+
+#include <location/providers/sirf/writer.h>
+
+#include <cstdint>
+#include <iostream>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+// Switches the protocol to another protocol. For most software,
+// the default protocol is SiRF binary.
+struct SetProtocol
+{
+    enum
+    {
+        null = 0,
+        sirf_binary = 1,
+        nmea = 2,
+        ascii = 3,
+        rtcm = 4,
+        user1 = 5,
+        sirf_loc = 6,
+        statistic = 7
+    };
+
+    static constexpr std::uint8_t id{0x87};
+
+    std::size_t size() const
+    {
+        return sizeof(std::uint8_t) + sizeof(std::uint8_t);
+    }
+
+    void write(Writer& writer) const
+    {
+        writer.write_unsigned_char(id);
+        writer.write_unsigned_char(protocol);
+    }
+
+    std::uint8_t protocol;
+};
+
+inline std::ostream& operator<<(std::ostream& out, const SetProtocol& sp)
+{
+    return out << "SetProtocol:" << std::endl
+               << "  protocol: " << sp.protocol;
+}
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif  // LOCATION_PROVIDERS_SIRF_SET_PROTOCOL_H_
 
=== added file 'src/location/providers/sirf/writer.cpp'
--- src/location/providers/sirf/writer.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/writer.cpp	2017-05-05 09:37:41 +0000
@@ -0,0 +1,94 @@
+// 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/sirf/writer.h>
+
+#include <arpa/inet.h>
+
+#include <cstring>
+#include <stdexcept>
+
+namespace sirf = location::providers::sirf;
+
+sirf::Writer::Writer(std::vector<std::uint8_t>::iterator begin,
+                        std::vector<std::uint8_t>::iterator end)
+    : begin{begin}, current{begin}, end{end} {}
+
+void sirf::Writer::write_unsigned_char(std::uint8_t value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<std::uint8_t*>(&(*current)) = value;
+    current += sizeof(value);
+
+}
+
+void sirf::Writer::write_signed_char(std::int8_t value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<std::int8_t*>(&(*current)) = value;
+    current += sizeof(value);
+
+}
+
+void sirf::Writer::write_unsigned_short(std::uint16_t value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<std::uint16_t*>(&(*current)) = ::ntohs(value);
+    current += sizeof(value);
+}
+
+void sirf::Writer::write_signed_short(std::int16_t value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<std::int16_t*>(&(*current)) = ::ntohs(value);
+    current += sizeof(value);
+}
+
+void sirf::Writer::write_unsigned_long(std::uint32_t value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<std::uint32_t*>(&(*current)) = ::ntohl(value);
+    current += sizeof(value);
+}
+
+void sirf::Writer::write_signed_long(std::int32_t value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<std::int32_t*>(&(*current)) = ::ntohl(value);
+    current += sizeof(value);
+}
+
+sirf::Writer sirf::Writer::slice(std::size_t size)
+{
+    if (current + size > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    Writer result{current, current + size};
+    current += size;
+
+    return result;
+}
 
=== added file 'src/location/providers/sirf/writer.h'
--- src/location/providers/sirf/writer.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/sirf/writer.h	2017-05-05 09:37:41 +0000
@@ -0,0 +1,54 @@
+// 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 LOCATION_PROVIDERS_SIRF_WRITER_H_
+#define LOCATION_PROVIDERS_SIRF_WRITER_H_
+
+#include <cstdint>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace sirf
+{
+
+class Writer
+{
+public:
+    explicit Writer(std::vector<std::uint8_t>::iterator begin,
+                    std::vector<std::uint8_t>::iterator end);
+
+    void write_unsigned_char(std::uint8_t value);
+    void write_signed_char(std::int8_t value);
+    void write_unsigned_short(std::uint16_t value);
+    void write_signed_short(std::int16_t value);
+    void write_unsigned_long(std::uint32_t value);
+    void write_signed_long(std::int32_t value);
+
+    Writer slice(std::size_t size);
+
+private:
+    std::vector<std::uint8_t>::iterator begin;
+    std::vector<std::uint8_t>::iterator current;
+    std::vector<std::uint8_t>::iterator end;
+};
+
+}  // namespace sirf
+}  // namespace providers
+}  // namespace location
+
+#endif // LOCATION_PROVIDERS_SIRF_WRITER_H_
 
=== modified file 'src/location/providers/ubx/CMakeLists.txt'
--- src/location/providers/ubx/CMakeLists.txt	2017-03-23 12:32:38 +0000
+++ src/location/providers/ubx/CMakeLists.txt	2017-05-05 09:37:41 +0000
@@ -37,11 +37,14 @@
   _8/nav/pvt.cpp
   _8/nav/sat.h
   _8/nav/sat.cpp
-  _8/nmea/scanner.cpp
-  _8/nmea/sentence.cpp
 
   provider.h provider.cpp)
 
+target_link_libraries(
+  ubx
+
+  nmea)
+
 set(
   ENABLED_PROVIDER_TARGETS
   ${ENABLED_PROVIDER_TARGETS} ubx
 
=== modified file 'src/location/providers/ubx/_8/receiver.cpp'
--- src/location/providers/ubx/_8/receiver.cpp	2017-03-23 15:47:38 +0000
+++ src/location/providers/ubx/_8/receiver.cpp	2017-05-05 09:37:41 +0000
@@ -1,6 +1,6 @@
 #include <location/providers/ubx/_8/receiver.h>
 
-#include <location/providers/ubx/_8/nmea/sentence.h>
+#include <location/nmea/sentence.h>
 
 #include <iostream>
 
 
=== modified file 'src/location/providers/ubx/_8/receiver.h'
--- src/location/providers/ubx/_8/receiver.h	2017-03-24 21:13:53 +0000
+++ src/location/providers/ubx/_8/receiver.h	2017-05-05 09:37:41 +0000
@@ -20,8 +20,8 @@
 #include <location/providers/ubx/_8/message.h>
 #include <location/providers/ubx/_8/scanner.h>
 
-#include <location/providers/ubx/_8/nmea/scanner.h>
-#include <location/providers/ubx/_8/nmea/sentence.h>
+#include <location/nmea/scanner.h>
+#include <location/nmea/sentence.h>
 
 #include <memory>
 
@@ -60,7 +60,7 @@
 
         /// @brief on_new_nmea_sentence is invoked for every complete and parsed
         /// nmea sentence.
-        virtual void on_new_nmea_sentence(const ubx::_8::nmea::Sentence& sentence) = 0;
+        virtual void on_new_nmea_sentence(const nmea::Sentence& sentence) = 0;
     };
 
     /// @brief send_message encodes and sends 'message' to the receiver.
@@ -83,7 +83,7 @@
 
 private:
     std::shared_ptr<Monitor> monitor;
-    ubx::_8::nmea::Scanner nmea_scanner;
+    nmea::Scanner nmea_scanner;
     ubx::_8::Scanner ubx_scanner;
 };
 
 
=== modified file 'src/location/providers/ubx/_8/scanner.cpp'
--- src/location/providers/ubx/_8/scanner.cpp	2017-03-23 12:32:38 +0000
+++ src/location/providers/ubx/_8/scanner.cpp	2017-05-05 09:37:41 +0000
@@ -105,7 +105,7 @@
         expected_size |= (c << 8);
         payload.resize(expected_size);
         payload_iterator = payload.begin();
-        next = Expect::payload;
+        next = expected_size > 0 ? Expect::payload : Expect::ck_a;
         consumed = true;
         break;
     case Expect::payload:
 
=== modified file 'src/location/providers/ubx/provider.cpp'
--- src/location/providers/ubx/provider.cpp	2017-04-21 07:16:45 +0000
+++ src/location/providers/ubx/provider.cpp	2017-05-05 09:37:41 +0000
@@ -80,7 +80,7 @@
 }
 
 
-void ubx::Provider::Monitor::on_new_nmea_sentence(const _8::nmea::Sentence& sentence)
+void ubx::Provider::Monitor::on_new_nmea_sentence(const nmea::Sentence& sentence)
 {
     VLOG(1) << sentence;
     if (auto sp = provider.lock())
@@ -88,7 +88,7 @@
             boost::apply_visitor(*this, sentence);
 }
 
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gga& gga)
+void ubx::Provider::Monitor::operator()(const nmea::Gga& gga)
 {   
     if (gga.latitude && gga.longitude)
     {
@@ -159,32 +159,32 @@
     });
 }
 
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gsa&)
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gll&)
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Gsv&)
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Rmc&)
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Txt&)
-{
-    // Empty on purpose
-}
-
-void ubx::Provider::Monitor::operator()(const _8::nmea::Vtg& vtg)
+void ubx::Provider::Monitor::operator()(const nmea::Gsa&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const nmea::Gll&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const nmea::Gsv&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const nmea::Rmc&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const nmea::Txt&)
+{
+    // Empty on purpose
+}
+
+void ubx::Provider::Monitor::operator()(const nmea::Vtg& vtg)
 {
     auto thiz = shared_from_this();
     std::weak_ptr<ubx::Provider::Monitor> wp{thiz};
 
=== modified file 'src/location/providers/ubx/provider.h'
--- src/location/providers/ubx/provider.h	2017-04-21 07:16:45 +0000
+++ src/location/providers/ubx/provider.h	2017-05-05 09:37:41 +0000
@@ -21,7 +21,7 @@
 #include <location/provider.h>
 #include <location/provider_factory.h>
 #include <location/runtime.h>
-
+#include <location/nmea/sentence.h>
 #include <location/providers/ubx/_8/assist_now_online_client.h>
 #include <location/providers/ubx/_8/serial_port_receiver.h>
 
@@ -104,20 +104,20 @@
     {
         // From Receiver::Monitor
         void on_new_ubx_message(const _8::Message& message) override;
-        void on_new_nmea_sentence(const _8::nmea::Sentence& sentence) override;
+        void on_new_nmea_sentence(const nmea::Sentence& sentence) override;
 
         template<typename T>
         void operator()(const T&) const {}
 
         void operator()(const _8::nav::Pvt& pvt);
 
-        void operator()(const _8::nmea::Gga& gga);
-        void operator()(const _8::nmea::Gsa& gsa);
-        void operator()(const _8::nmea::Gll& gll);
-        void operator()(const _8::nmea::Gsv& gsv);
-        void operator()(const _8::nmea::Rmc& rmc);
-        void operator()(const _8::nmea::Txt& txt);
-        void operator()(const _8::nmea::Vtg& vtg);
+        void operator()(const nmea::Gga& gga);
+        void operator()(const nmea::Gsa& gsa);
+        void operator()(const nmea::Gll& gll);
+        void operator()(const nmea::Gsv& gsv);
+        void operator()(const nmea::Rmc& rmc);
+        void operator()(const nmea::Txt& txt);
+        void operator()(const nmea::Vtg& vtg);
 
         std::weak_ptr<Provider> provider;
     };
 
=== modified file 'src/location/runtime_tests.cpp'
--- src/location/runtime_tests.cpp	2017-04-03 07:32:40 +0000
+++ src/location/runtime_tests.cpp	2017-05-05 09:37:41 +0000
@@ -22,6 +22,7 @@
 #include <location/clock.h>
 #include <location/glib/runtime.h>
 #include <location/providers/gps/hardware_abstraction_layer.h>
+#include <location/providers/sirf/provider.h>
 #include <location/providers/ubx/provider.h>
 #include <location/util/benchmark.h>
 #include <location/util/cli.h>
@@ -251,12 +252,98 @@
     return 0;
 }
 
+int sirf(std::ostream& cout, std::ostream&)
+{
+    location::util::Benchmark benchmark{boost::lexical_cast<unsigned int>(env::get("SIRF_PROVIDER_TEST_TRIALS", "15")), "ttff in [µs]"};
+
+    auto test_device = env::get_or_throw("SIRF_PROVIDER_TEST_DEVICE");
+
+    location::providers::sirf::Provider::Configuration configuration
+    {
+        location::providers::sirf::Provider::Protocol::sirf, test_device
+    };
+
+    auto provider = location::providers::sirf::Provider::create(configuration);
+
+    struct State
+    {
+        State() : worker{[this]() { runtime.run(); }}, fix_received(false)
+        {
+        }
+
+        ~State()
+        {
+            runtime.stop();
+            if (worker.joinable())
+                worker.join();
+        }
+
+        bool wait_for_fix_for(const std::chrono::seconds& seconds)
+        {
+            std::unique_lock<std::mutex> ul(guard);
+            return wait_condition.wait_for(
+                        ul,
+                        seconds,
+                        [this]() {return fix_received == true;});
+        }
+
+        void on_position_updated(const location::Position&)
+        {
+            fix_received = true;
+            wait_condition.notify_all();
+        }
+
+        void reset()
+        {
+            fix_received = false;
+        }
+
+        location::glib::Runtime runtime{location::glib::Runtime::WithOwnMainLoop{}};
+        std::thread worker;
+        std::mutex guard;
+        std::condition_variable wait_condition;
+        bool fix_received;
+    } state;
+
+    provider->position_updates().connect([&state](const location::Update<location::Position>& update)
+    {
+        state.on_position_updated(update.value);
+    });
+
+    {
+        cli::ProgressBar pb(cout, "sirf runtime test: ", 30);
+
+        benchmark.run(
+            [&](std::size_t)
+            {
+                provider->reset(); state.reset();
+            },
+            [&](std::size_t trial)
+            {
+                pb.update(trial / static_cast<double>(benchmark.trials()));
+
+                provider->activate();
+                // We expect a maximum cold start time of 15 minutes. The theoretical
+                // limit is 12.5 minutes, and we add up some grace period to make the
+                // test more robust (see http://en.wikipedia.org/wiki/Time_to_first_fix).
+                expect<true, std::runtime_error>(state.wait_for_fix_for(std::chrono::seconds{15 * 60}), "Wait for fix timed out.");
+                provider->deactivate();
+            });
+    }
+
+    cout << benchmark << std::endl;
+
+    return 0;
+}
+
 }  // namespace
 
 int location::execute_runtime_tests(const std::string& test_suite, std::ostream& cout, std::ostream& cerr)
 {
     if (test_suite == "android-gps")
         return snr_and_ttff(cout, cerr);
+    else if (test_suite == "sirf")
+        return sirf(cout, cerr);
     else if (test_suite == "ubx")
         return ubx(cout, cerr);
     return 0;