Merge lp:~thomas-voss/location-service/enable-ublox-protocol into lp:location-service

[Thomas Voß]

Enable parsing and handling of ublox protocol messages.

By default, we are now using the ublox binary protocol for handling
input originating from a ublox receiver/chipset. More to this, we configure
the chipset to consider GPS, Galileo, GLONASS and SBAS by default.

Enable parsing and handling of ublox protocol messages.

By default, we are now using the ublox binary protocol for handling
input originating from a ublox receiver/chipset. More to this, we configure
the chipset to consider GPS, Galileo, GLONASS and SBAS by default.

[Simon Fels (morphis)]

LGTM

review: Approve

=== modified file 'src/location/providers/ubx/CMakeLists.txt'
--- src/location/providers/ubx/CMakeLists.txt	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/CMakeLists.txt	2017-03-20 16:54:12 +0000
@@ -5,8 +5,35 @@
 
   ${UBX_HEADERS}
 
+  bits.h
+
+  _8/checksum.h
+  _8/checksum.cpp
+  _8/gnss_id.h
+  _8/gnss_id.cpp
+  _8/reader.h
+  _8/reader.cpp
+  _8/receiver.h
   _8/receiver.cpp
+  _8/scanner.h
+  _8/scanner.cpp
+  _8/serial_port_receiver.h
   _8/serial_port_receiver.cpp
+  _8/writer.h
+  _8/writer.cpp
+  _8/ack/ack.h
+  _8/ack/ack.cpp
+  _8/ack/nak.h
+  _8/ack/nak.cpp
+  _8/cfg/cfg.h
+  _8/cfg/gnss.h
+  _8/cfg/gnss.cpp
+  _8/cfg/msg.h
+  _8/cfg/msg.cpp
+  _8/nav/pvt.h
+  _8/nav/pvt.cpp
+  _8/nav/sat.h
+  _8/nav/sat.cpp
   _8/nmea/scanner.cpp
   _8/nmea/sentence.cpp
 

=== added directory 'src/location/providers/ubx/_8/ack'
=== added file 'src/location/providers/ubx/_8/ack/ack.cpp'
--- src/location/providers/ubx/_8/ack/ack.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/ack/ack.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,35 @@
+// 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/ubx/_8/ack/ack.h>
+
+#include <location/providers/ubx/_8/reader.h>
+
+#include <iostream>
+
+namespace ack = location::providers::ubx::_8::ack;
+
+void ack::Ack::read(Reader& reader)
+{
+    ackd_class_id = reader.read_unsigned_char();
+    ackd_message_id = reader.read_unsigned_char();
+}
+
+std::ostream& ack::operator<<(std::ostream& out, const ack::Ack& a)
+{
+    return out << "ack-ack:" << std::endl
+               << "  class_id: " << a.ackd_class_id << std::endl
+               << "  message_id: " << a.ackd_message_id << std::endl;
+}

=== added file 'src/location/providers/ubx/_8/ack/ack.h'
--- src/location/providers/ubx/_8/ack/ack.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/ack/ack.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,55 @@
+// 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 UBX_8_ACK_ACK_H_
+#define UBX_8_ACK_ACK_H_
+
+#include <cstdint>
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Reader;
+
+namespace ack
+{
+
+struct Ack
+{
+    static constexpr std::uint8_t class_id{0x05};
+    static constexpr std::uint8_t message_id{0x01};
+
+    void read(Reader& reader);
+
+    std::uint8_t ackd_class_id;
+    std::uint8_t ackd_message_id;
+};
+
+std::ostream& operator<<(std::ostream& out, const Ack& ack);
+
+}  // namespace ack
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_ACK_ACK_H_

=== added file 'src/location/providers/ubx/_8/ack/nak.cpp'
--- src/location/providers/ubx/_8/ack/nak.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/ack/nak.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,35 @@
+// 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/ubx/_8/ack/nak.h>
+
+#include <location/providers/ubx/_8/reader.h>
+
+#include <iostream>
+
+namespace ack = location::providers::ubx::_8::ack;
+
+void ack::Nak::read(Reader& reader)
+{
+    nakd_class_id = reader.read_unsigned_char();
+    nakd_message_id = reader.read_unsigned_char();
+}
+
+std::ostream& ack::operator<<(std::ostream& out, const ack::Nak& a)
+{
+    return out << "ack-ack:" << std::endl
+               << "  class_id: " << a.nakd_class_id << std::endl
+               << "  message_id: " << a.nakd_message_id << std::endl;
+}

=== added file 'src/location/providers/ubx/_8/ack/nak.h'
--- src/location/providers/ubx/_8/ack/nak.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/ack/nak.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,55 @@
+// 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 UBX_8_ACK_NAK_H_
+#define UBX_8_ACK_NAK_H_
+
+#include <cstdint>
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Reader;
+
+namespace ack
+{
+
+struct Nak
+{
+    static constexpr std::uint8_t class_id{0x05};
+    static constexpr std::uint8_t message_id{0x00};
+
+    void read(Reader& reader);
+
+    std::uint8_t nakd_class_id;
+    std::uint8_t nakd_message_id;
+};
+
+std::ostream& operator<<(std::ostream& out, const Nak& nak);
+
+}  // namespace ack
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_ACK_NAK_H_

=== added directory 'src/location/providers/ubx/_8/cfg'
=== added file 'src/location/providers/ubx/_8/cfg/gnss.cpp'
--- src/location/providers/ubx/_8/cfg/gnss.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/cfg/gnss.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,253 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/cfg/gnss.h>
+
+#include <location/providers/ubx/bits.h>
+#include <location/providers/ubx/_8/writer.h>
+
+#include <cstdint>
+#include <iostream>
+
+namespace cfg = location::providers::ubx::_8::cfg;
+
+std::size_t cfg::Gnss::size() const
+{
+    std::size_t result = 4;
+
+    if (beidou)
+        result += 8;
+    if (glonass)
+        result += 8;
+    if (gps)
+        result += 8;
+    if (galileo)
+        result += 8;
+    if (imes)
+        result += 8;
+    if (qzss)
+        result += 8;
+    if (sbas)
+        result += 8;
+
+    return result;
+}
+
+bool cfg::Gnss::write(Writer& writer) const
+{
+    writer.write_unsigned_char(version);
+    writer.write_unsigned_char(tracking_channels_hw);
+    writer.write_unsigned_char(tracking_channels_used);
+
+    std::uint8_t num_configs = 0;
+    if (beidou)     num_configs++;
+    if (glonass)    num_configs++;
+    if (gps)        num_configs++;
+    if (galileo)    num_configs++;
+    if (imes)       num_configs++;
+    if (qzss)       num_configs++;
+    if (sbas)       num_configs++;
+
+    writer.write_unsigned_char(num_configs);
+
+    if (beidou)
+    {
+        writer.write_unsigned_char(BeiDou::id);
+        writer.write_unsigned_char(beidou.get().min_tracking_channels);
+        writer.write_unsigned_char(beidou.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, beidou.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, beidou.get().b1l ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (glonass)
+    {
+        writer.write_unsigned_char(Glonass::id);
+        writer.write_unsigned_char(glonass.get().min_tracking_channels);
+        writer.write_unsigned_char(glonass.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, glonass.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, glonass.get().l1of ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (gps)
+    {
+        writer.write_unsigned_char(Gps::id);
+        writer.write_unsigned_char(gps.get().min_tracking_channels);
+        writer.write_unsigned_char(gps.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, gps.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, gps.get().l1ca ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (galileo)
+    {
+        writer.write_unsigned_char(Galileo::id);
+        writer.write_unsigned_char(galileo.get().min_tracking_channels);
+        writer.write_unsigned_char(galileo.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, galileo.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, galileo.get().e1os ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (imes)
+    {
+        writer.write_unsigned_char(Imes::id);
+        writer.write_unsigned_char(imes.get().min_tracking_channels);
+        writer.write_unsigned_char(imes.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, imes.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, imes.get().l1 ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (imes)
+    {
+        writer.write_unsigned_char(Imes::id);
+        writer.write_unsigned_char(imes.get().min_tracking_channels);
+        writer.write_unsigned_char(imes.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, imes.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, imes.get().l1 ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (qzss)
+    {
+        writer.write_unsigned_char(Qzss::id);
+        writer.write_unsigned_char(qzss.get().min_tracking_channels);
+        writer.write_unsigned_char(qzss.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, qzss.get().enable ? 1 : 0);
+        // TODO(tvoss): Consider l1saif here, too.
+        bits::set<16, 23>(flags, qzss.get().l1ca ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    if (sbas)
+    {
+        writer.write_unsigned_char(Sbas::id);
+        writer.write_unsigned_char(sbas.get().min_tracking_channels);
+        writer.write_unsigned_char(sbas.get().max_tracking_channels);
+        writer.write_unsigned_char(0);
+
+        std::uint32_t flags{0};
+        bits::set<0, 1>(flags, sbas.get().enable ? 1 : 0);
+        bits::set<16, 23>(flags, sbas.get().l1ca ? 0x01: 0x0);
+
+        writer.write_unsigned_long(flags);
+    }
+
+    return true;
+}
+
+std::ostream& cfg::operator<<(std::ostream& out, const cfg::Gnss& gnss)
+{
+    out << "cfg-gnss:" << std::endl
+        << "  version: " << std::uint32_t(gnss.version) << std::endl
+        << "  tracking_channels_hw: " << std::uint32_t(gnss.tracking_channels_hw) << std::endl
+        << "  tracking_channels_used: " << std::uint32_t(gnss.tracking_channels_used);
+
+    if (gnss.beidou)
+    {
+        out << "  beidou:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.beidou.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.beidou.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.beidou.get().max_tracking_channels << std::endl
+            << "    b1l: " << gnss.beidou.get().b1l;
+    }
+
+    if (gnss.glonass)
+    {
+        out << "  glonass:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.glonass.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.glonass.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.glonass.get().max_tracking_channels << std::endl
+            << "    l1of: " << gnss.glonass.get().l1of;
+    }
+
+    if (gnss.gps)
+    {
+        out << "  gps:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.gps.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.gps.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.gps.get().max_tracking_channels << std::endl
+            << "    l1ca: " << gnss.gps.get().l1ca;
+    }
+
+    if (gnss.galileo)
+    {
+        out << "  galileo:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.galileo.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.galileo.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.galileo.get().max_tracking_channels << std::endl
+            << "    e1os: " << gnss.galileo.get().e1os;
+    }
+
+    if (gnss.imes)
+    {
+        out << "  imes:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.imes.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.imes.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.imes.get().max_tracking_channels << std::endl
+            << "    l1: " << gnss.imes.get().l1;
+    }
+
+    if (gnss.qzss)
+    {
+        out << "  qzss:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.qzss.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.qzss.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.qzss.get().max_tracking_channels << std::endl
+            << "    l1ca: " << gnss.qzss.get().l1ca << std::endl
+            << "    l1saif: " << gnss.qzss.get().l1saif;
+    }
+
+    if (gnss.sbas)
+    {
+        out << "  sbas:" << std::endl
+            << "    enable: " << std::boolalpha << gnss.sbas.get().enable << std::endl
+            << "    min_tracking_channels: " << gnss.sbas.get().min_tracking_channels << std::endl
+            << "    max_tracking_channels: " << gnss.sbas.get().max_tracking_channels << std::endl
+            << "    l1ca: " << gnss.sbas.get().l1ca;
+    }
+
+    return out;
+}

=== added file 'src/location/providers/ubx/_8/cfg/gnss.h'
--- src/location/providers/ubx/_8/cfg/gnss.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/cfg/gnss.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,114 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_CFG_GNSS_H_
+#define UBX_8_CFG_GNSS_H_
+
+#include <location/optional.h>
+
+#include <cstdint>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Writer;
+
+namespace cfg
+{
+
+struct Gnss
+{
+    template<std::uint8_t ID>
+    struct Constellation
+    {
+        static constexpr const std::uint8_t id{ID};
+
+        bool enable;
+        std::uint8_t min_tracking_channels = 0;
+        std::uint8_t max_tracking_channels = 0;
+    };
+
+    struct BeiDou : public Constellation<3>
+    {
+        bool b1l = false;
+    };
+
+    struct Glonass : public Constellation<6>
+    {
+        bool l1of = false;
+    };
+
+    struct Gps : public Constellation<0>
+    {
+        bool l1ca = false;
+    };
+
+    struct Galileo : public Constellation<2>
+    {
+        bool e1os = false;
+    };
+
+    struct Imes : public Constellation<4>
+    {
+        bool l1 = false;
+    };
+
+    struct Qzss : public Constellation<5>
+    {
+        bool l1ca = false;
+        bool l1saif = false;
+    };
+
+    struct Sbas : public Constellation<1>
+    {
+        bool l1ca = false;
+    };
+
+    static constexpr std::uint8_t class_id{0x06};
+    static constexpr std::uint8_t message_id{0x3e};
+
+    std::size_t size() const;
+    bool write(Writer& writer) const;
+
+    std::uint8_t version = 0;
+    std::uint8_t tracking_channels_hw = 0;
+    std::uint8_t tracking_channels_used = 0xff;
+
+    Optional<BeiDou> beidou;
+    Optional<Glonass> glonass;
+    Optional<Gps> gps;
+    Optional<Galileo> galileo;
+    Optional<Imes> imes;
+    Optional<Qzss> qzss;
+    Optional<Sbas> sbas;
+};
+
+std::ostream& operator<<(std::ostream& out, const Gnss& gnss);
+
+}  // namespace cfg
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_CFG_GNSS_H_

=== added file 'src/location/providers/ubx/_8/cfg/msg.cpp'
--- src/location/providers/ubx/_8/cfg/msg.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/cfg/msg.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,49 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/cfg/msg.h>
+
+#include <location/providers/ubx/bits.h>
+#include <location/providers/ubx/_8/writer.h>
+
+#include <cstdint>
+#include <iostream>
+
+namespace cfg = location::providers::ubx::_8::cfg;
+
+std::size_t cfg::Msg::size() const
+{
+    return 8;
+}
+
+void cfg::Msg::write(Writer& writer) const
+{
+    writer.write_unsigned_char(configured_class_id);
+    writer.write_unsigned_char(configured_message_id);
+    writer.write_unsigned_char(rate[0]);
+    writer.write_unsigned_char(rate[1]);
+    writer.write_unsigned_char(rate[2]);
+    writer.write_unsigned_char(rate[3]);
+    writer.write_unsigned_char(rate[4]);
+    writer.write_unsigned_char(rate[5]);
+}
+
+std::ostream& cfg::operator<<(std::ostream& out, const cfg::Msg& msg)
+{
+    return out << "cfg-msg:" << std::endl
+        << "  configured class id: " << msg.configured_class_id << std::endl
+        << "  configured msg id: " << msg.configured_message_id << std::endl
+        << "  rates: " << "[" << msg.rate[0] << "," << msg.rate[1] << "," << msg.rate[2] << "," << msg.rate[3] << "," << msg.rate[4] << "," << msg.rate[5] << "]";
+}

=== added file 'src/location/providers/ubx/_8/cfg/msg.h'
--- src/location/providers/ubx/_8/cfg/msg.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/cfg/msg.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,65 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_CFG_MSG_H_
+#define UBX_8_CFG_MSG_H_
+
+#include <cstdint>
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Writer;
+
+namespace cfg
+{
+
+struct Msg
+{
+    static constexpr std::uint8_t class_id{0x06};
+    static constexpr std::uint8_t message_id{0x01};
+
+    enum Port
+    {
+        ddc = 0,
+        uart1 = 1,
+        usb = 3,
+        spi = 4
+    };
+
+    std::size_t size() const;
+    void write(Writer& writer) const;
+
+    std::uint8_t configured_class_id;
+    std::uint8_t configured_message_id;
+    std::uint8_t rate[6];
+};
+
+std::ostream& operator<<(std::ostream& out, const Msg& msg);
+
+}  // namespace cfg
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_CFG_MSG_H_

=== added file 'src/location/providers/ubx/_8/checksum.cpp'
--- src/location/providers/ubx/_8/checksum.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/checksum.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,34 @@
+// 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/ubx/_8/checksum.h>
+
+namespace _8 = location::providers::ubx::_8;
+
+void _8::Checksum::operator()(std::uint8_t byte)
+{
+    ck_a_ += byte;
+    ck_b_ += ck_a_;
+}
+
+std::uint8_t _8::Checksum::ck_a() const
+{
+    return ck_a_;
+}
+
+std::uint8_t _8::Checksum::ck_b() const
+{
+    return ck_b_;
+}

=== added file 'src/location/providers/ubx/_8/checksum.h'
--- src/location/providers/ubx/_8/checksum.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/checksum.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,48 @@
+// 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 UBX_8_CHECKSUM_H_
+#define UBX_8_CHECKSUM_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Checksum
+{
+public:
+    void operator()(std::uint8_t byte);
+
+    std::uint8_t ck_a() const;
+    std::uint8_t ck_b() const;
+
+private:
+    std::uint8_t ck_a_{0};
+    std::uint8_t ck_b_{0};
+};
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namepsace location
+
+#endif  // UBX_8_CHECKSUM_H_

=== renamed file 'src/location/providers/ubx/_8/marshaller.h' => 'src/location/providers/ubx/_8/codec.h'
--- src/location/providers/ubx/_8/marshaller.h	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/codec.h	2017-03-20 16:54:12 +0000
@@ -12,8 +12,19 @@
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#ifndef UBX_8_MARSHALLER_H_
-#define UBX_8_MARSHALLER_H_
+
+#ifndef UBX_8_CODEC_H_
+#define UBX_8_CODEC_H_
+
+#include <location/providers/ubx/_8/checksum.h>
+#include <location/providers/ubx/_8/magic.h>
+#include <location/providers/ubx/_8/reader.h>
+#include <location/providers/ubx/_8/writer.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <vector>
 
 namespace location
 {
@@ -23,20 +34,52 @@
 {
 namespace _8
 {
-/// @brief Marshaller abstracts marshaling of arbitrary messages.
-class Marshaller
-{
-public:
-    virtual ~Marshaller() = default;
-
-    /// @brief marshal returns a message
-    /// ready to be sent over the wire to a ublox
-    /// receiver.
-    virtual Message marshal() const = 0;
-};
-}
-}
-}
-}
-
-#endif // UBX_8_MARSHALLER_H_
+
+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::uint8_t) + sizeof(std::uint8_t) +
+            sizeof(std::uint16_t) +
+            msg_size +
+            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(sync_char_1);
+    writer.write_unsigned_char(sync_char_2);
+    writer.write_unsigned_char(T::class_id);
+    writer.write_unsigned_char(T::message_id);
+    writer.write_unsigned_short(msg_size);
+
+    Writer payload = writer.slice(msg_size);
+    message.write(payload);
+
+    auto checksum = std::for_each(result.begin() + 2, result.end() - 2, Checksum{});
+
+    writer.write_unsigned_char(checksum.ck_a());
+    writer.write_unsigned_char(checksum.ck_b());
+
+    return result;
+}
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_CODEC_H_

=== added file 'src/location/providers/ubx/_8/gnss_id.cpp'
--- src/location/providers/ubx/_8/gnss_id.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/gnss_id.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,36 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/gnss_id.h>
+
+#include <iostream>
+
+namespace _8 = location::providers::ubx::_8;
+
+std::ostream& _8::operator<<(std::ostream& out, GnssId gnss_id)
+{
+    switch (gnss_id)
+    {
+    case GnssId::gps: out << "gps"; break;
+    case GnssId::sbas: out << "sbas"; break;
+    case GnssId::galileo: out << "galileo"; break;
+    case GnssId::beidou: out << "beidou"; break;
+    case GnssId::imes: out << "imes"; break;
+    case GnssId::qzss: out << "qzss"; break;
+    case GnssId::glonass: out << "glonass"; break;
+    }
+
+    return out;
+}

=== added file 'src/location/providers/ubx/_8/gnss_id.h'
--- src/location/providers/ubx/_8/gnss_id.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/gnss_id.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,51 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_GNSS_ID_H_
+#define UBX_8_GNSS_ID_H_
+
+#include <cstdint>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+enum class GnssId : std::uint8_t
+{
+    gps = 0,
+    sbas = 1,
+    galileo = 2,
+    beidou = 3,
+    imes = 4,
+    qzss = 5,
+    glonass = 6
+
+};
+
+std::ostream& operator<<(std::ostream& out, GnssId gnss_id);
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namepsace location
+
+#endif  // UBX_8_GNSS_ID_H_

=== added file 'src/location/providers/ubx/_8/magic.h'
--- src/location/providers/ubx/_8/magic.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/magic.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,36 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_MAGIC_H_
+#define UBX_8_MAGIC_H_
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+constexpr const std::uint8_t sync_char_1{0xb5};
+constexpr const std::uint8_t sync_char_2{0x62};
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif // UBX_8_MAGIC_H_

=== modified file 'src/location/providers/ubx/_8/message.h'
--- src/location/providers/ubx/_8/message.h	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/message.h	2017-03-20 16:54:12 +0000
@@ -12,12 +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_SCANNER_H_
-#define UBX_8_SCANNER_H_
-
-#include <cstdint>
-
-#include <vector>
+
+#ifndef UBX_8_MESSAGE_H_
+#define UBX_8_MESSAGE_H_
+
+#include <location/providers/ubx/_8/ack/ack.h>
+#include <location/providers/ubx/_8/ack/nak.h>
+#include <location/providers/ubx/_8/cfg/gnss.h>
+#include <location/providers/ubx/_8/cfg/msg.h>
+#include <location/providers/ubx/_8/nav/pvt.h>
+#include <location/providers/ubx/_8/nav/sat.h>
+
+#include <boost/variant.hpp>
 
 namespace location
 {
@@ -27,30 +33,19 @@
 {
 namespace _8
 {
-static constexpr const std::uint8_t sync_char_1{0xb5};
-static constexpr const std::uint8_t sync_char_2{62};
-
-enum class Class
-{
-    cfg = 0x06
-};
-
-enum class Id
-{
-};
-
-struct Message
-{
-    Class cls;
-    Id id;
-    std::uint16_t length;
-    std::vector<std::uint8_t> payload;
-    std::uint8_t ck_a;
-    std::uint8_t ck_b;
-};
-}
-}
-}
-}
-
-#endif // UBX_8_SCANNER_H_
+
+using Message = boost::variant<
+    ack::Ack,
+    ack::Nak,
+    cfg::Gnss,
+    cfg::Msg,
+    nav::Pvt,
+    nav::Sat
+>;
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif // UBX_8_MESSAGE_H_

=== added directory 'src/location/providers/ubx/_8/nav'
=== added file 'src/location/providers/ubx/_8/nav/pvt.cpp'
--- src/location/providers/ubx/_8/nav/pvt.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nav/pvt.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,132 @@
+// 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/ubx/_8/nav/pvt.h>
+
+#include <location/providers/ubx/_8/reader.h>
+
+#include <iostream>
+
+namespace nav = location::providers::ubx::_8::nav;
+
+void nav::Pvt::read(Reader& reader)
+{
+    itow = reader.read_unsigned_long();
+    year = reader.read_unsigned_short();
+    month = reader.read_unsigned_char();
+    day = reader.read_unsigned_char();
+    hour = reader.read_unsigned_char();
+    minute = reader.read_unsigned_char();
+    second = reader.read_unsigned_char();
+    date_time_validity = static_cast<DateTimeValidity>(reader.read_unsigned_char());
+    time_accuracy = reader.read_unsigned_long();
+    nanoseconds = reader.read_signed_long();
+    fix_type = static_cast<FixType>(reader.read_unsigned_char());
+    fix_status_flags = reader.read_unsigned_char();
+    additional_flags = reader.read_unsigned_char();
+    satellite_count = reader.read_unsigned_char();
+    longitude = reader.read_signed_long() * 1e-7;
+    latitude = reader.read_signed_long() * 1e-7;
+    height.above_ellipsoid = reader.read_signed_long();
+    height.above_msl = reader.read_signed_long();
+    accuracy.horizontal = reader.read_unsigned_long();
+    accuracy.vertical = reader.read_unsigned_long();
+    velocity.north = reader.read_signed_long();
+    velocity.east = reader.read_signed_long();
+    velocity.down = reader.read_signed_long();
+    speed_over_ground = reader.read_unsigned_long();
+    heading.motion = reader.read_signed_long() * 1e-5;
+    accuracy.speed = reader.read_unsigned_long();
+    accuracy.heading = reader.read_unsigned_long() * 1e-5;
+    pdop = reader.read_unsigned_short() * 0.01;
+
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+
+    heading.vehicle = reader.read_signed_long() * 1e-5;
+
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+}
+
+std::ostream& nav::operator<<(std::ostream& out, nav::Pvt::DateTimeValidity validity)
+{
+    return out
+            << "date valid="        << std::boolalpha << (0 != (validity & Pvt::DateTimeValidity::valid_date)) << " "
+            << "time valid="        << std::boolalpha << (0 != (validity & Pvt::DateTimeValidity::valid_time)) << " "
+            << "fully resolved="    << std::boolalpha << (0 != (validity & Pvt::DateTimeValidity::fully_resolved));
+}
+
+std::ostream& nav::operator<<(std::ostream& out, nav::Pvt::FixType fix_type)
+{
+    switch (fix_type)
+    {
+    case Pvt::FixType::no_fix:
+        out << "no fix";
+        break;
+    case Pvt::FixType::dead_reckoning:
+        out << "dead reckoning";
+        break;
+    case Pvt::FixType::fix_2d:
+        out << "2D fix";
+        break;
+    case Pvt::FixType::fix_3d:
+        out << "3D fix";
+        break;
+    case Pvt::FixType::gnss_and_dead_reckoning:
+        out << "gnss & dr";
+        break;
+    case Pvt::FixType::only_time_fix:
+        out << "only time";
+        break;
+    }
+
+    return out;
+}
+
+std::ostream& nav::operator<<(std::ostream& out, const nav::Pvt& pvt)
+{
+    out << "nav-pvt:" << std::endl
+        <<   " itow: " << std::uint32_t(pvt.itow) << std::endl
+        <<   " year: " << std::uint32_t(pvt.year) << std::endl
+        <<   " month: " << std::uint32_t(pvt.month) << std::endl
+        <<   " day: " << std::uint32_t(pvt.day) << std::endl
+        <<   " hour: " << std::uint32_t(pvt.hour) << std::endl
+        <<   " minute: " << std::uint32_t(pvt.minute) << std::endl
+        <<   " seconds: " << std::uint32_t(pvt.second) << std::endl
+        <<   " dtv: " << pvt.date_time_validity << std::endl
+        <<   " time_accuracy: " << pvt.time_accuracy << std::endl
+        <<   " nanoseconds: " << pvt.nanoseconds << std::endl
+        <<   " fix_type: " << pvt.fix_type << std::endl
+        <<   " fix_status_flags: " << std::uint32_t(pvt.fix_status_flags) << std::endl
+        <<   " additional_flags: " << std::uint32_t(pvt.additional_flags) << std::endl
+        <<   " satellite_count: " << std::uint32_t(pvt.satellite_count) << std::endl
+        <<   " longitude: " << pvt.longitude << std::endl
+        <<   " latitude: " << pvt.latitude << std::endl
+        <<   " height.Ellipsoid: " << pvt.height.above_ellipsoid << std::endl
+        <<   " height.MSL: " << pvt.height.above_msl << std::endl
+        <<   " accuracy.horizontal: " << pvt.accuracy.horizontal << std::endl
+        <<   " accuracy.vertical: " << pvt.accuracy.vertical << std::endl
+        <<   " accuracy.speed: " << pvt.accuracy.speed << std::endl
+        <<   " accuracy.heading: " << pvt.accuracy.heading << std::endl;
+
+    return out;
+}

=== added file 'src/location/providers/ubx/_8/nav/pvt.h'
--- src/location/providers/ubx/_8/nav/pvt.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nav/pvt.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,114 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_NAV_PVT_H_
+#define UBX_8_NAV_PVT_H_
+
+#include <location/providers/ubx/bits.h>
+
+#include <iosfwd>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Reader;
+
+namespace nav
+{
+
+struct Pvt
+{
+    static constexpr std::uint8_t class_id{0x01};
+    static constexpr std::uint8_t message_id{0x07};
+
+    enum DateTimeValidity
+    {
+        valid_date = 1 << 0,
+        valid_time = 1 << 1,
+        fully_resolved = 1 << 2
+    };
+
+    enum FixType
+    {
+        no_fix = 0,
+        dead_reckoning = 1,
+        fix_2d = 2,
+        fix_3d = 3,
+        gnss_and_dead_reckoning = 4,
+        only_time_fix = 5
+    };
+
+    void read(Reader& reader);
+
+    std::uint32_t itow;
+    std::uint16_t year;
+    std::uint8_t month;
+    std::uint8_t day;
+    std::uint8_t hour;
+    std::uint8_t minute;
+    std::uint8_t second;
+    DateTimeValidity date_time_validity;
+    std::uint32_t time_accuracy;
+    std::int32_t nanoseconds;
+    FixType fix_type;
+    std::uint8_t fix_status_flags;
+    std::uint8_t additional_flags;
+    std::uint8_t satellite_count;
+    double longitude;
+    double latitude;
+    struct
+    {
+        std::int32_t above_ellipsoid;
+        std::int32_t above_msl;
+    } height;
+    struct
+    {
+        std::uint32_t horizontal;
+        std::uint32_t vertical;
+        std::uint32_t speed;
+        double heading;
+    } accuracy;
+    struct
+    {
+        std::int32_t north;
+        std::int32_t east;
+        std::int32_t down;
+    } velocity;
+    std::int32_t speed_over_ground;
+    struct
+    {
+        double motion;
+        double vehicle;
+    } heading;
+    std::uint16_t pdop;
+};
+
+std::ostream& operator<<(std::ostream& out, Pvt::DateTimeValidity validity);
+std::ostream& operator<<(std::ostream& out, Pvt::FixType fix_type);
+std::ostream& operator<<(std::ostream& out, const Pvt& pvt);
+
+}  // namespace nav
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_NAV_PVT_H_

=== added file 'src/location/providers/ubx/_8/nav/sat.cpp'
--- src/location/providers/ubx/_8/nav/sat.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nav/sat.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,62 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/nav/sat.h>
+
+#include <location/providers/ubx/_8/reader.h>
+
+#include <iostream>
+
+namespace nav = location::providers::ubx::_8::nav;
+
+void nav::Sat::read(Reader& reader)
+{
+    itow = reader.read_unsigned_long();
+    version = reader.read_unsigned_char();
+    info.resize(reader.read_unsigned_char());
+
+    reader.read_unsigned_char();
+    reader.read_unsigned_char();
+
+    for (std::size_t i = 0; i < info.size(); i++)
+    {
+        info[i].gnss_id = static_cast<GnssId>(reader.read_unsigned_char());
+        info[i].satellite_id = reader.read_unsigned_char();
+        info[i].carrier_to_noise = reader.read_unsigned_char();
+        info[i].elevation = reader.read_signed_char();
+        info[i].azimuth = reader.read_signed_short();
+        info[i].pseudo_range_residual = reader.read_signed_short() * 0.1;
+        info[i].flags = reader.read_signed_long();
+    }
+}
+
+std::ostream& nav::operator<<(std::ostream& out, const Sat& sat)
+{
+    out << "nav-sat:" << std::endl
+        << "  itow: " << sat.itow << std::endl
+        << "  version: " << sat.version << std::endl
+        << "  satellites: " << std::endl;
+    for (const auto& si : sat.info)
+        out << "    gnss: " << si.gnss_id << std::endl
+            << "    satellite: " << std::uint32_t(si.satellite_id) << std::endl
+            << "    cno: " << std::uint32_t(si.carrier_to_noise) << std::endl
+            << "    elevation: " << std::int32_t(si.elevation) << std::endl
+            << "    azimuth: " << std::int32_t(si.azimuth) << std::endl
+            << "    prr: " << si.pseudo_range_residual << std::endl
+            << "    flags: " << si.flags << std::endl
+            << std::endl;
+
+    return out;
+}

=== added file 'src/location/providers/ubx/_8/nav/sat.h'
--- src/location/providers/ubx/_8/nav/sat.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/nav/sat.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,71 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_NAV_SAT_H_
+#define UBX_8_NAV_SAT_H_
+
+#include <location/providers/ubx/_8/gnss_id.h>
+
+#include <cstdint>
+
+#include <iosfwd>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+class Reader;
+
+namespace nav
+{
+
+struct Sat
+{
+    static constexpr std::uint8_t class_id{0x01};
+    static constexpr std::uint8_t message_id{0x35};
+
+    struct Info
+    {
+        GnssId gnss_id;
+        std::uint8_t satellite_id;
+        std::uint8_t carrier_to_noise;
+        std::int8_t elevation;
+        std::int16_t azimuth;
+        float pseudo_range_residual;
+        std::uint32_t flags;
+    };
+
+    void read(Reader& reader);
+
+    std::uint32_t itow;
+    std::uint8_t version;
+    std::vector<Info> info;
+};
+
+std::ostream& operator<<(std::ostream& out, const Sat& sat);
+
+}  // namespace nav
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_8_NAV_SAT_H_

=== modified file 'src/location/providers/ubx/_8/nmea/scanner.cpp'
--- src/location/providers/ubx/_8/nmea/scanner.cpp	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/nmea/scanner.cpp	2017-03-20 16:54:12 +0000
@@ -12,6 +12,7 @@
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 #include <location/providers/ubx/_8/nmea/scanner.h>
 
 #include <stdexcept>

=== added file 'src/location/providers/ubx/_8/reader.cpp'
--- src/location/providers/ubx/_8/reader.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/reader.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,110 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/reader.h>
+
+#include <cstring>
+#include <stdexcept>
+
+namespace ubx = location::providers::ubx;
+
+ubx::_8::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 ubx::_8::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 ubx::_8::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 ubx::_8::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 *result;
+}
+
+std::int16_t ubx::_8::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 *result;
+}
+
+std::uint32_t ubx::_8::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 *result;
+}
+
+std::int32_t ubx::_8::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 *result;
+}
+
+float ubx::_8::Reader::read_float()
+{
+    if (current + sizeof(float) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const float*>(&(*current));
+    current += sizeof(float);
+    return *result;
+}
+
+double ubx::_8::Reader::read_double()
+{
+    if (current + sizeof(double) > end)
+        throw std::out_of_range{"Read buffer exhausted"};
+
+    auto result = reinterpret_cast<const double*>(&(*current));
+    current += sizeof(double);
+    return *result;
+}
+
+const char* ubx::_8::Reader::read_string(std::size_t size)
+{
+
+}

=== added file 'src/location/providers/ubx/_8/reader.h'
--- src/location/providers/ubx/_8/reader.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/reader.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,58 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_READER_H_
+#define UBX_8_READER_H_
+
+#include <cstdint>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+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();
+    float read_float();
+    double read_double();
+    const char* read_string(std::size_t size);
+
+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 _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif // UBX_8_READER_H_

=== modified file 'src/location/providers/ubx/_8/receiver.cpp'
--- src/location/providers/ubx/_8/receiver.cpp	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/receiver.cpp	2017-03-20 16:54:12 +0000
@@ -6,17 +6,49 @@
 
 namespace ubx = location::providers::ubx;
 
+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 ubx::_8::cfg::Gnss& gnss) const
+    {
+        return ubx::_8::encode_message(gnss);
+    }
+
+    std::vector<std::uint8_t> operator()(const ubx::_8::cfg::Msg& msg) const
+    {
+        return ubx::_8::encode_message(msg);
+    }
+};
+
+}  // namespace
+
 ubx::_8::Receiver::Receiver(const std::shared_ptr<Monitor>& monitor) : monitor{monitor} {}
 
+void ubx::_8::Receiver::send_message(const Message& message)
+{
+    send_encoded_message(boost::apply_visitor(EncodingVisitor{}, message));
+}
+
 void ubx::_8::Receiver::process_chunk(Buffer::iterator it, Buffer::iterator itE)
 {
-    monitor->on_new_chunk(it, itE);
-
     while (it != itE)
     {
-        if (nmea::Scanner::Expect::nothing_more == nmea_scanner.update(*it))
+        auto result = ubx_scanner.update(*it);
+
+        if (std::get<0>(result) == Scanner::Expect::nothing_more)
+            monitor->on_new_ubx_message(ubx_scanner.finalize());
+        if (!std::get<1>(result))
         {
-            monitor->on_new_nmea_sentence(nmea::parse_sentence(nmea_scanner.finalize()));
+            if (nmea::Scanner::Expect::nothing_more == nmea_scanner.update(*it))
+                monitor->on_new_nmea_sentence(nmea::parse_sentence(nmea_scanner.finalize()));
         }
         ++it;
     }

=== modified file 'src/location/providers/ubx/_8/receiver.h'
--- src/location/providers/ubx/_8/receiver.h	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/receiver.h	2017-03-20 16:54:12 +0000
@@ -12,9 +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_RECEIVER_H_
 #define UBX_8_RECEIVER_H_
 
+#include <location/providers/ubx/_8/codec.h>
+#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>
 
@@ -49,14 +54,18 @@
         Monitor& operator=(Monitor&&) = delete;
         /// @endcond
 
-        /// @brief on_new_chunk is invoked for every incoming chunk of raw data.
-        virtual void on_new_chunk(Buffer::iterator it, Buffer::iterator itE) = 0;
+        /// @brief on_new_ubx_message is invoked for every complete and parsed
+        /// ubx message.
+        virtual void on_new_ubx_message(const ubx::_8::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;
+        virtual void on_new_nmea_sentence(const ubx::_8::nmea::Sentence& sentence) = 0;
     };
 
+    /// @brief send_message encodes and sends 'message' to the receiver.
+    void send_message(const Message& message);
+
 protected:
     /// @brief Receiver initializes a new instance with monitor
     ///
@@ -69,13 +78,18 @@
     /// Calls out to a configured monitor instance for announcing results.
     void process_chunk(Buffer::iterator it, Buffer::iterator itE);
 
+    /// @brief send_encoded_message sends out data to the receiver.
+    virtual void send_encoded_message(const std::vector<std::uint8_t>& data) = 0;
+
 private:
     std::shared_ptr<Monitor> monitor;
-    nmea::Scanner nmea_scanner;
+    ubx::_8::nmea::Scanner nmea_scanner;
+    ubx::_8::Scanner ubx_scanner;
 };
-}
-}
-}
-}
+
+}  // namespace _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
 
 #endif // UBX_8_RECEIVER_H_

=== added file 'src/location/providers/ubx/_8/scanner.cpp'
--- src/location/providers/ubx/_8/scanner.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/scanner.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,166 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/scanner.h>
+
+#include <location/providers/ubx/_8/codec.h>
+#include <location/providers/ubx/_8/magic.h>
+#include <location/providers/ubx/_8/message.h>
+
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <stdexcept>
+#include <tuple>
+#include <vector>
+
+namespace _8 = location::providers::ubx::_8;
+
+namespace
+{
+
+template<std::uint8_t class_id, std::uint8_t message_id>
+std::tuple<std::uint8_t, std::uint8_t> make_tuple()
+{
+    return std::make_tuple(class_id, message_id);
+}
+
+}  // namespace
+
+_8::Scanner::Scanner()
+    : next{Expect::sync_char_1},
+      class_id{0},
+      message_id{0},
+      expected_size{0},
+      payload_iterator{payload.end()}
+{
+    factories[make_tuple<ack::Ack::class_id, ack::Ack::message_id>()] =
+            [](const std::vector<std::uint8_t>& payload) { return decode_message<ack::Ack>(payload); };
+    factories[make_tuple<ack::Nak::class_id, ack::Nak::message_id>()] =
+            [](const std::vector<std::uint8_t>& payload) { return decode_message<ack::Nak>(payload); };
+    factories[make_tuple<cfg::Gnss::class_id, cfg::Gnss::message_id>()] =
+            [](const std::vector<std::uint8_t>&) { return cfg::Gnss{}; };
+    factories[make_tuple<cfg::Msg::class_id, cfg::Msg::message_id>()] =
+            [](const std::vector<std::uint8_t>&) { return cfg::Msg{}; };
+    factories[make_tuple<nav::Pvt::class_id, nav::Pvt::message_id>()] =
+            [](const std::vector<std::uint8_t>& payload) { return decode_message<nav::Pvt>(payload); };
+    factories[make_tuple<nav::Sat::class_id, nav::Sat::message_id>()] =
+            [](const std::vector<std::uint8_t>& payload) { return decode_message<nav::Sat>(payload); };
+}
+
+std::tuple<_8::Scanner::Expect, bool> _8::Scanner::update(std::uint8_t c)
+{
+    bool consumed = false;
+
+    // TODO(tvoss): This lacks a lot of validiation and verification.
+    // UBX allows us to partially parse while we scan and carry out online
+    // checksum calculation. Ideally, we would have a common class State that
+    // captures behavior and transition logic.
+    switch (next)
+    {
+    case Expect::sync_char_1:
+        if (c == sync_char_1)
+        {
+            next = Expect::sync_char_2;
+            consumed = true;
+        }
+        break;
+    case Expect::sync_char_2:
+        if (c == sync_char_2)
+        {
+            next = Expect::class_;
+            consumed = true;
+        }
+        break;
+    case Expect::class_:
+        checksum(c);
+        class_id = c;
+        next = Expect::id;
+        consumed = true;
+        break;
+    case Expect::id:
+        checksum(c);
+        message_id = c;
+        next = Expect::length_1;
+        consumed = true;
+        break;
+    case Expect::length_1:
+        checksum(c);
+        expected_size = c;
+        next = Expect::length_2;
+        consumed = true;
+        break;
+    case Expect::length_2:
+        checksum(c);
+        expected_size |= (c << 8);
+        payload.resize(expected_size);
+        payload_iterator = payload.begin();
+        next = Expect::payload;
+        consumed = true;
+        break;
+    case Expect::payload:
+        checksum(c);
+        *payload_iterator = c;
+        ++payload_iterator;
+        next = payload_iterator == payload.end()
+                ? Expect::ck_a
+                : next;
+        consumed = true;
+        break;
+    case Expect::ck_a:
+        ck_a = c;
+        next = Expect::ck_b;
+        consumed = true;
+        break;
+    case Expect::ck_b:
+        ck_b = c;
+        next = Expect::nothing_more;
+        consumed = true;
+        break;
+    default:
+        consumed = false;
+        break;
+    }
+
+    return std::make_tuple(next, consumed);
+}
+
+_8::Message _8::Scanner::finalize()
+{
+    if (next != Expect::nothing_more)
+        throw std::logic_error{"Not ready for extraction."};
+
+    if (ck_a != checksum.ck_a() || ck_b != checksum.ck_b())
+        throw std::runtime_error{"Verification failed."};
+
+    auto it = factories.find(std::make_tuple(class_id, message_id));
+
+    if (it == factories.end())
+        throw std::runtime_error{"Could not decode message."};
+
+    auto result = it->second(payload);
+
+    checksum = Checksum{};
+    next = Expect::sync_char_1;
+    class_id = 0;
+    message_id = 0;
+    expected_size = 0;
+    payload.clear();
+    payload_iterator = payload.end();
+    ck_a = ck_b = 0;
+
+    return result;
+}

=== modified file 'src/location/providers/ubx/_8/scanner.h'
--- src/location/providers/ubx/_8/scanner.h	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/scanner.h	2017-03-20 16:54:12 +0000
@@ -12,9 +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_SCANNER_H_
 #define UBX_8_SCANNER_H_
 
+#include <location/providers/ubx/_8/checksum.h>
+#include <location/providers/ubx/_8/message.h>
+
+#include <cstdint>
+#include <map>
+#include <tuple>
+#include <vector>
+
 namespace location
 {
 namespace providers
@@ -23,33 +32,10 @@
 {
 namespace _8
 {
-class Checksum
-{
-public:
-    struct VerificationFailed : public std::runtime_error
-    {
-        ValidationFailed() : std::runtime_error{"Checksum verification failed."} {}
-    };
-
-    void update(std::uint8_t c)
-    {
-        ck_a += c;
-        ck_b += ck_a;
-    }
-
-    void verify_or_throw(std::uint8_t a, std::uint8_t b)
-    {
-        if (a != ck_a || b != ck_b)
-            throw VerificationFailed{};
-    }
-
-private:
-    std::uint8_t ck_a{0};
-    std::uint8_t ck_b{0};
-};
+
 class Scanner
 {
-public:
+public:    
     ///  @brief Expect enumerates the different states of the scanner/parser.
     enum class Expect
     {
@@ -63,80 +49,28 @@
         ck_a,
         ck_b,
         nothing_more
-    };
-
-    /// @brief finalize returns the complete message
-    /// or throws in case of issues.
-    Message finalize()
-    {
-        if (not message)
-            throw std::runtime_error{"Too early"};
-        if (next != Expect::nothing_more)
-            throw std::runtime_error{"Too early"};
-
-        auto result = *message;
-
-        next = Expect::sync_char_1;
-        message.reset();
-
-        return result;
-    }
-
-    Expect update(std::uint8_t c)
-    {
-        // TODO(tvoss): This lacks a lot of validiation and verification.
-        // UBX allows us to partially parse while we scan and carry out online
-        // checksum calculation. Ideally, we would have a common class State that
-        // captures behavior and transition logic.
-
-        switch (next)
-        {
-        case Expect::sync_char_1:
-            if (c == sync_char_1)
-                next = Expect::sync_char_1;
-            break;
-        case Expect::sync_char_2:
-            if (c == sync_char_2)
-                next = Expect::class_;
-            break;
-        case Expect::class_:
-            message->cls = static_cast<Class>(c);
-            next = Expect::id;
-            break;
-        case Expect::id_:
-            message->id = static_cast<Id>(c);
-            next = Expect::length_1;
-            break;
-        case Expect::length_1:
-            message->length = c;
-            next = Expect::length_2;
-            break;
-        case Excpet::length_2:
-            message->length |= c << 8;
-            next = Expect::payload;
-        case Expect::payload:
-            message->payload.push_back(c);
-            checksum.update(c);
-            next = message->payload.size() == message->length() ? Expect::ck_a : next;
-            break;
-        case Expect::ck_a:
-            message->ck_a = c;
-            next = Expect::ck_b;
-            break;
-        case Expect::ck_b:
-            message->ck_b |= c << 8;
-            checksum.verify_or_throw(message->ck_a, message->ck_b);
-            next = Expect::nothing_more;
-            break;
-        }
-
-        return next;
-    }
+    };    
+
+    Scanner();
+
+    std::tuple<Expect, bool> update(std::uint8_t c);
+
+    Message finalize();
 
 private:
-    Expect next{Expect::sync_char_1};
+    Expect next;
     Checksum checksum;
-    boost::optional<Message> message;
+    std::uint8_t class_id;
+    std::uint8_t message_id;
+    std::uint16_t expected_size;
+    std::vector<uint8_t> payload;
+    std::vector<uint8_t>::iterator payload_iterator;
+    std::uint8_t ck_a;
+    std::uint8_t ck_b;
+    std::map<
+        std::tuple<std::uint8_t, std::uint8_t>,
+        std::function<Message(const std::vector<std::uint8_t>&)>
+    > factories;
 };
 }
 }

=== modified file 'src/location/providers/ubx/_8/serial_port_receiver.cpp'
--- src/location/providers/ubx/_8/serial_port_receiver.cpp	2017-03-04 21:52:34 +0000
+++ src/location/providers/ubx/_8/serial_port_receiver.cpp	2017-03-20 16:54:12 +0000
@@ -19,14 +19,21 @@
 {
 }
 
+void ubx::_8::SerialPortReceiver::send_encoded_message(const std::vector<std::uint8_t>& data)
+{
+    ios.dispatch([this, data]()
+    {
+        boost::asio::write(sp, boost::asio::buffer(data), boost::asio::transfer_all());
+    });
+}
+
 void ubx::_8::SerialPortReceiver::start()
 {
-    auto flush_rc = ::tcflush(sp.lowest_layer().native_handle(), TCIOFLUSH);
     start_read();
-    if (flush_rc) throw std::system_error(errno, std::system_category());
 }
 
-void ubx::_8::SerialPortReceiver::stop() {
+void ubx::_8::SerialPortReceiver::stop()
+{
     sp.cancel();
 }
 

=== modified file 'src/location/providers/ubx/_8/serial_port_receiver.h'
--- src/location/providers/ubx/_8/serial_port_receiver.h	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/_8/serial_port_receiver.h	2017-03-20 16:54:12 +0000
@@ -44,6 +44,9 @@
     void start();
     void stop();
 
+protected:
+    void send_encoded_message(const std::vector<std::uint8_t>& data) override;
+
 private:
     /// @brief Receiver initializes a new instance opening the serial port
     /// located at path.

=== added file 'src/location/providers/ubx/_8/writer.cpp'
--- src/location/providers/ubx/_8/writer.cpp	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/writer.cpp	2017-03-20 16:54:12 +0000
@@ -0,0 +1,119 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <location/providers/ubx/_8/writer.h>
+
+#include <cstring>
+#include <stdexcept>
+
+namespace ubx = location::providers::ubx;
+
+ubx::_8::Writer::Writer(std::vector<std::uint8_t>::iterator begin,
+                        std::vector<std::uint8_t>::iterator end)
+    : begin{begin}, current{begin}, end{end} {}
+
+void ubx::_8::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 ubx::_8::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 ubx::_8::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)) = value;
+    current += sizeof(value);
+}
+
+void ubx::_8::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)) = value;
+    current += sizeof(value);
+}
+
+void ubx::_8::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)) = value;
+    current += sizeof(value);
+}
+
+void ubx::_8::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)) = value;
+    current += sizeof(value);
+}
+
+void ubx::_8::Writer::write_float(float value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<float*>(&(*current)) = value;
+    current += sizeof(value);
+}
+
+void ubx::_8::Writer::write_double(double value)
+{
+    if (current + sizeof(value) > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    *reinterpret_cast<double*>(&(*current)) = value;
+    current += sizeof(value);
+}
+
+void ubx::_8::Writer::write_string(const char* s, std::size_t size)
+{
+    if (current + size > end)
+        throw std::out_of_range{"Write buffer exhausted"};
+
+    memcpy(&(*current), s, size);
+    current += size;
+}
+
+ubx::_8::Writer ubx::_8::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/ubx/_8/writer.h'
--- src/location/providers/ubx/_8/writer.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/_8/writer.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,60 @@
+// Copyright (C) 2016 Thomas Voss <[e-mail]>
+//
+// This library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef UBX_8_WRITER_H_
+#define UBX_8_WRITER_H_
+
+#include <cstdint>
+#include <vector>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace _8
+{
+
+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);
+    void write_float(float value);
+    void write_double(double value);
+    void write_string(const char* s, std::size_t size);
+
+    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 _8
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif // UBX_8_WRITER_H_

=== added file 'src/location/providers/ubx/bits.h'
--- src/location/providers/ubx/bits.h	1970-01-01 00:00:00 +0000
+++ src/location/providers/ubx/bits.h	2017-03-20 16:54:12 +0000
@@ -0,0 +1,41 @@
+// 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 UBX_BITS_H_
+#define UBX_BITS_H_
+
+#include <cstdint>
+
+namespace location
+{
+namespace providers
+{
+namespace ubx
+{
+namespace bits
+{
+
+template<std::size_t begin, std::size_t end, typename T, typename U>
+void set(T& bitfield, U value)
+{
+    bitfield |= (value << begin);
+}
+
+}  // namespace bits
+}  // namespace ubx
+}  // namespace providers
+}  // namespace location
+
+#endif  // UBX_BITS_H_

=== modified file 'src/location/providers/ubx/provider.cpp'
--- src/location/providers/ubx/provider.cpp	2017-03-09 10:07:56 +0000
+++ src/location/providers/ubx/provider.cpp	2017-03-20 16:54:12 +0000
@@ -22,9 +22,16 @@
 #include <location/runtime.h>
 #include <location/glib/runtime.h>
 
+#include <location/providers/ubx/_8/cfg/gnss.h>
+#include <location/providers/ubx/_8/cfg/msg.h>
+#include <location/providers/ubx/_8/nav/pvt.h>
+#include <location/providers/ubx/_8/nav/sat.h>
+
 #include <core/posix/this_process.h>
 
 #include <fstream>
+#include <iostream>
+#include <iterator>
 #include <thread>
 
 namespace env = core::posix::this_process::env;
@@ -39,17 +46,19 @@
 {
 }
 
-void ubx::Provider::Monitor::on_new_chunk(_8::Receiver::Buffer::iterator, _8::Receiver::Buffer::iterator)
+void ubx::Provider::Monitor::on_new_ubx_message(const _8::Message& message)
 {
-    // We drop the chunk on purpose.
+    VLOG(1) << message;
+    if (provider->protocol == Provider::Protocol::ubx)
+        boost::apply_visitor(*this, message);
 }
 
+
 void ubx::Provider::Monitor::on_new_nmea_sentence(const _8::nmea::Sentence& sentence)
 {
-    // TODO(tvoss): This is a little verbose and we should remove it
-    // for production scenarios.
-    LOG(INFO) << sentence;
-    boost::apply_visitor(*this, sentence);
+    VLOG(1) << sentence;
+    if (provider->protocol == Provider::Protocol::nmea)
+        boost::apply_visitor(*this, sentence);
 }
 
 void ubx::Provider::Monitor::operator()(const _8::nmea::Gga& gga) const
@@ -80,6 +89,35 @@
     }
 }
 
+void ubx::Provider::Monitor::operator()(const _8::nav::Pvt& pvt) const
+{
+    if (pvt.fix_type == _8::nav::Pvt::FixType::no_fix)
+        return;
+
+    Position position
+    {
+        pvt.latitude * units::degrees,
+        pvt.longitude * units::degrees
+    };
+    position.accuracy().horizontal(pvt.accuracy.horizontal * 1e-3 * units::meters);
+
+    if (pvt.fix_type == _8::nav::Pvt::FixType::fix_3d)
+    {
+        position.altitude(pvt.height.above_msl * 1e-3 * units::meters);
+        position.accuracy().vertical(pvt.accuracy.vertical * 1e-3 * units::meters);
+    }
+
+    units::Degrees heading = pvt.heading.vehicle * units::degrees;
+    units::MetersPerSecond speed = pvt.speed_over_ground * 1e-3 * units::meters_per_second;
+
+    glib::Runtime::instance()->dispatch([this, position, heading, speed]()
+    {
+        provider->updates.position(location::Update<location::Position>{position});
+        provider->updates.heading(location::Update<units::Degrees>{heading});
+        provider->updates.velocity(location::Update<units::MetersPerSecond>{speed});
+    });
+}
+
 void ubx::Provider::Monitor::operator()(const _8::nmea::Gsa&) const
 {
     // Empty on purpose
@@ -122,20 +160,65 @@
 
 location::Provider::Ptr ubx::Provider::create_instance(const location::ProviderFactory::Configuration& config)
 {
-    std::string device_path;
+    std::string device_path = "/dev/ttyACM0";
     std::ifstream in(env::get("SNAP_DATA") + "/ubx/provider/path");
-
     in >> device_path;
 
-    return location::Provider::Ptr{new ubx::Provider{config.get<std::string>("device", device_path.empty() ? "/dev/ttyACM0" : device_path)}};
+    return location::Provider::Ptr{new ubx::Provider{
+            Protocol::ubx, config.get<std::string>("device", device_path)}};
 }
 
-ubx::Provider::Provider(const boost::filesystem::path& device)
-    : runtime{location::Runtime::create(1)},
+ubx::Provider::Provider(Protocol protocol, const boost::filesystem::path& device)
+    : protocol{protocol},
+      runtime{location::Runtime::create(1)},
       monitor{std::make_shared<Monitor>(this)},
       receiver{_8::SerialPortReceiver::create(runtime->service(), device, monitor)}
 {   
     runtime->start();
+
+    _8::cfg::Gnss::Gps gps;
+    gps.l1ca = true;
+    gps.enable = true;
+    gps.min_tracking_channels = 4;
+    gps.max_tracking_channels = 8;
+
+    _8::cfg::Gnss::Galileo galileo;
+    galileo.e1os = true;
+    galileo.enable = true;
+    galileo.min_tracking_channels = 4;
+    galileo.max_tracking_channels = 8;
+
+    _8::cfg::Gnss::Glonass glonass;
+    glonass.l1of = true;
+    glonass.enable = true;
+    glonass.min_tracking_channels = 4;
+    glonass.max_tracking_channels = 8;
+
+    _8::cfg::Gnss::Sbas sbas;
+    sbas.l1ca = true;
+    sbas.enable = true;
+    sbas.min_tracking_channels = 4;
+    sbas.max_tracking_channels = 8;
+
+    _8::cfg::Gnss gnss;
+    gnss.gps = gps;
+    gnss.galileo = galileo;
+    gnss.glonass = glonass;
+    gnss.sbas = sbas;
+
+    receiver->send_message(gnss);
+
+    if (protocol == Protocol::ubx)
+    {
+        _8::cfg::Msg cfg_msg{ubx::_8::nav::Pvt::class_id, ubx::_8::nav::Pvt::message_id, { 0 }};
+        cfg_msg.rate[_8::cfg::Msg::Port::usb] = 1;
+        cfg_msg.rate[_8::cfg::Msg::Port::uart1] = 1;
+        receiver->send_message(cfg_msg);
+
+        cfg_msg.configured_class_id = _8::nav::Sat::class_id;
+        cfg_msg.configured_message_id = _8::nav::Sat::message_id;
+        receiver->send_message(cfg_msg);
+    }
 }
 
 ubx::Provider::~Provider() noexcept

=== modified file 'src/location/providers/ubx/provider.h'
--- src/location/providers/ubx/provider.h	2016-10-10 09:15:40 +0000
+++ src/location/providers/ubx/provider.h	2017-03-20 16:54:12 +0000
@@ -53,8 +53,14 @@
     // for the list of known options.
     static Provider::Ptr create_instance(const ProviderFactory::Configuration&);
 
+    enum class Protocol
+    {
+        ubx,  // Rely on ubx.
+        nmea  // Rely on nmea.
+    };
+
     // Creates a new provider instance talking via device to the ubx chipset.
-    Provider(const boost::filesystem::path& device);
+    Provider(Protocol protocol, const boost::filesystem::path& device);
     // Cleans up all resources and stops the updates.
     ~Provider() noexcept;
 
@@ -79,9 +85,14 @@
         explicit Monitor(Provider* provider);
 
         // From Receiver::Monitor
-        void on_new_chunk(_8::Receiver::Buffer::iterator it, _8::Receiver::Buffer::iterator itE) override;
+        void on_new_ubx_message(const _8::Message& message) override;
         void on_new_nmea_sentence(const _8::nmea::Sentence& sentence) override;
 
+        template<typename T>
+        void operator()(const T&) const {}
+
+        void operator()(const _8::nav::Pvt& pvt) const;
+
         void operator()(const _8::nmea::Gga& gga) const;
         void operator()(const _8::nmea::Gsa& gsa) const;
         void operator()(const _8::nmea::Gll& gll) const;
@@ -93,6 +104,7 @@
         Provider* provider;
     };
 
+    Protocol protocol;
     std::shared_ptr<location::Runtime> runtime;
     std::shared_ptr<Monitor> monitor;
     std::shared_ptr<_8::SerialPortReceiver> receiver;