diff --git a/examples/c++/CMakeLists.txt b/examples/c++/CMakeLists.txt
index f06b724a..6a3444eb 100644
--- a/examples/c++/CMakeLists.txt
+++ b/examples/c++/CMakeLists.txt
@@ -317,3 +317,4 @@ if (OPENZWAVE_FOUND)
   add_custom_example (aeotecdsb09104-example aeotecdsb09104.cxx ozw)
   add_custom_example (tzemt400-example tzemt400.cxx ozw)
 endif()
+add_custom_example (nmea_gps_i2c_example-cxx nmea_gps_i2c.cxx nmea_gps)
diff --git a/examples/c++/nmea_gps_i2c.cxx b/examples/c++/nmea_gps_i2c.cxx
new file mode 100644
index 00000000..74e4fa21
--- /dev/null
+++ b/examples/c++/nmea_gps_i2c.cxx
@@ -0,0 +1,69 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <unistd.h>
+#include <iostream>
+#include <signal.h>
+
+#include "nmea_gps.hpp"
+
+using namespace std;
+
+bool shouldRun = true;
+
+const size_t bufferLength = 128;
+
+void sig_handler(int signo)
+{
+  if (signo == SIGINT)
+    shouldRun = false;
+}
+
+int main()
+{
+  signal(SIGINT, sig_handler);
+
+//! [Interesting]
+
+  // Instantiate a NMEA_GPS UBLOX based i2c sensor on i2c bus 0 at
+  // address 0x42
+  upm::NMEAGPS *sensor = new upm::NMEAGPS(0, 0x42);
+
+  // loop, dumping NMEA data out as fast as it comes in
+  while (shouldRun)
+    {
+      if (sensor->dataAvailable(0))
+        usleep(100);
+      else
+        cout << sensor->readStr(bufferLength);
+    }
+
+//! [Interesting]
+
+  cout << "Exiting" << endl;
+
+  delete sensor;
+
+  return 0;
+}
diff --git a/examples/c/CMakeLists.txt b/examples/c/CMakeLists.txt
index 27bcdfb4..fde707cf 100644
--- a/examples/c/CMakeLists.txt
+++ b/examples/c/CMakeLists.txt
@@ -92,3 +92,6 @@ add_example (mma7361)
 add_example (bh1750)
 add_example (urm37)
 add_example (urm37-uart)
+
+# Custom examples
+add_custom_example (nmea_gps_i2c-example-c nmea_gps_i2c.c nmea_gps)
diff --git a/examples/c/nmea_gps_i2c.c b/examples/c/nmea_gps_i2c.c
new file mode 100644
index 00000000..4049b285
--- /dev/null
+++ b/examples/c/nmea_gps_i2c.c
@@ -0,0 +1,82 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <unistd.h>
+#include <signal.h>
+
+#include "nmea_gps.h"
+
+bool shouldRun = true;
+
+const size_t bufferLength = 128;
+
+void sig_handler(int signo)
+{
+  if (signo == SIGINT)
+    shouldRun = false;
+}
+
+int main()
+{
+  signal(SIGINT, sig_handler);
+
+//! [Interesting]
+
+  // Instantiate a NMEA_GPS UBLOX based i2c sensor on i2c bus 0 at
+  // address 0x42
+  nmea_gps_context sensor = nmea_gps_init_ublox_i2c(0, 0x42);
+
+  if (!sensor)
+    {
+      printf("nmea_gps_init_ublox_i2c() failed.\n");
+      return 1;
+    }
+
+  char buffer[bufferLength];
+  int rv = 0;
+
+  // loop, dumping NMEA data out as fast as it comes in
+  while (shouldRun)
+    {
+      if (!nmea_gps_data_available(sensor, 0))
+        usleep(100);
+      else
+        {
+          if ((rv = nmea_gps_read(sensor, buffer, bufferLength)) >= 0)
+            {
+              int i;
+              for (i=0; i<rv; i++)
+                printf("%c", buffer[i]);
+            }
+        }
+    }
+
+//! [Interesting]
+
+  printf("Exiting\n");
+
+  nmea_gps_close(sensor);
+
+  return 0;
+}
diff --git a/examples/java/CMakeLists.txt b/examples/java/CMakeLists.txt
index 6531600d..6444265b 100644
--- a/examples/java/CMakeLists.txt
+++ b/examples/java/CMakeLists.txt
@@ -153,4 +153,4 @@ if (OPENZWAVE_FOUND)
   add_example_with_path(AeotecDSB09104_Example ozw ozw)
   add_example_with_path(TZEMT400_Example ozw ozw)
 endif()
-
+add_example_with_path(NMEAGPS_I2C_Example nmea_gps nmea_gps)
diff --git a/examples/java/NMEAGPS_I2C_Example.java b/examples/java/NMEAGPS_I2C_Example.java
new file mode 100644
index 00000000..7ceb8e3e
--- /dev/null
+++ b/examples/java/NMEAGPS_I2C_Example.java
@@ -0,0 +1,49 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import upm_nmea_gps.NMEAGPS;
+
+public class NMEAGPS_I2C_Example
+{
+    public static void main(String[] args) throws InterruptedException
+    {
+// ! [Interesting]
+        System.out.println("Initializing...");
+
+        // Instantiate a NMEA_GPS UBLOX based i2c sensor on i2c bus 0 at
+        // address 0x42
+        NMEAGPS sensor = new NMEAGPS(0, (byte)0x42);
+
+        // loop, dumping NMEA data out as fast as it comes in
+        while (true)
+            {
+                if (sensor.dataAvailable(0))
+                    System.out.print(sensor.readStr(256));
+                else
+                    Thread.sleep(100);
+            }
+
+// ! [Interesting]
+    }
+}
diff --git a/examples/javascript/nmea_gps_i2c.js b/examples/javascript/nmea_gps_i2c.js
new file mode 100644
index 00000000..bde115f7
--- /dev/null
+++ b/examples/javascript/nmea_gps_i2c.js
@@ -0,0 +1,60 @@
+/*jslint node:true, vars:true, bitwise:true, unparam:true */
+/*jshint unused:true */
+
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+var sensorObj = require('jsupm_nmea_gps');
+
+function sleepFor(millis)
+{
+    var now = new Date().getTime();
+    while(new Date().getTime() < now + millis)
+    {
+        /* do nothing */
+    }
+}
+
+// Instantiate a NMEA_GPS UBLOX based i2c sensor on i2c bus 0 at
+// address 0x42
+var sensor = new sensorObj.NMEAGPS(0, 0x42);
+
+// loop, dumping NMEA data out as fast as it comes in
+while (true)
+{
+    if (sensor.dataAvailable(0))
+        process.stdout.write(sensor.readStr(256));
+    else
+        sleepFor(10);
+}
+
+// exit on ^C
+process.on('SIGINT', function()
+{
+    sensor = null;
+    sensorObj.cleanUp();
+    sensorObj = null;
+    console.log("Exiting.");
+    process.exit(0);
+});
diff --git a/examples/python/nmea_gps_i2c.py b/examples/python/nmea_gps_i2c.py
new file mode 100644
index 00000000..355c05d3
--- /dev/null
+++ b/examples/python/nmea_gps_i2c.py
@@ -0,0 +1,52 @@
+#!/usr/bin/python
+# Author: Jon Trulson <jtrulson@ics.com>
+# Copyright (c) 2016 Intel Corporation.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import time, sys, signal, atexit
+import pyupm_nmea_gps as sensorObj
+
+# Instantiate a NMEA_GPS UBLOX based i2c sensor on i2c bus 0 at
+# address 0x42
+sensor = sensorObj.NMEAGPS(0, 0x42)
+
+## Exit handlers ##
+# This function stops python from printing a stacktrace when you hit control-C
+def SIGINTHandler(signum, frame):
+	raise SystemExit
+
+# This function lets you run code on exit
+def exitHandler():
+	print "Exiting"
+	sys.exit(0)
+
+# Register exit handlers
+atexit.register(exitHandler)
+signal.signal(signal.SIGINT, SIGINTHandler)
+
+# Every second, sample the NMEAGPS and output the measured lux value
+
+# loop, dumping NMEA data out as fast as it comes in
+while (True):
+        if (sensor.dataAvailable(0)):
+                sys.stdout.write(sensor.readStr(256))
+        else:
+                time.sleep(.1)
diff --git a/src/nmea_gps/javaupm_nmea_gps.i b/src/nmea_gps/javaupm_nmea_gps.i
index 1d2c8d5c..a80b311a 100644
--- a/src/nmea_gps/javaupm_nmea_gps.i
+++ b/src/nmea_gps/javaupm_nmea_gps.i
@@ -1,6 +1,7 @@
 %module javaupm_nmea_gps
 %include "../upm.i"
 %include "std_string.i"
+%include "stdint.i"
 %include "typemaps.i"
 
 %include "nmea_gps.hpp"
diff --git a/src/nmea_gps/nmea_gps.c b/src/nmea_gps/nmea_gps.c
index a62943c6..03a8b2c6 100644
--- a/src/nmea_gps/nmea_gps.c
+++ b/src/nmea_gps/nmea_gps.c
@@ -29,6 +29,45 @@
 
 #include "upm_utilities.h"
 
+// For ublox6 and compatible I2C communications (see the u-blox6
+// Receiver Description Protocol Specification datasheet for details).
+
+#define UBLOX6_I2C_BYTES_AVAIL_H                0xfd
+#define UBLOX6_I2C_BYTES_AVAIL_L                0xfe
+#define UBLOX6_I2C_BYTE_STREAM                  0xff
+
+#define UBLOX6_I2C_BYTE_NONE                    0xff // read if no data avail
+
+// static helpers for i2c reading
+static uint8_t readReg(const nmea_gps_context dev, uint8_t reg)
+{
+  assert(dev != NULL);
+  assert(dev->i2c != NULL);
+
+  int rv;
+  if ((rv = mraa_i2c_read_byte_data(dev->i2c, reg)) < 0)
+    printf("%s: mraa_i2c_read_byte_data() failed.\n", __FUNCTION__);
+
+  // This will return 0xff on errors, which is invalid NMEA data anyway.
+  return (uint8_t)rv;
+}
+
+static int readRegs(const nmea_gps_context dev, uint8_t reg,
+                    uint8_t *buffer, int len)
+{
+  assert(dev != NULL);
+  assert(dev->i2c != NULL);
+
+  int rv;
+  if ((rv = mraa_i2c_read_bytes_data(dev->i2c, reg, buffer, len)) < 0)
+    {
+      printf("%s: mraa_i2c_read_bytes_data() failed.\n", __FUNCTION__);
+    }
+
+  return rv;
+}
+
+// uart init
 nmea_gps_context nmea_gps_init(unsigned int uart, unsigned int baudrate,
                                int enable_pin)
 {
@@ -42,6 +81,7 @@ nmea_gps_context nmea_gps_init(unsigned int uart, unsigned int baudrate,
   memset((void *)dev, 0, sizeof(struct _nmea_gps_context));
   
   dev->uart = NULL;
+  dev->i2c = NULL;
   dev->gpio_en = NULL;
 
   // initialize the MRAA contexts
@@ -82,6 +122,51 @@ nmea_gps_context nmea_gps_init(unsigned int uart, unsigned int baudrate,
   return dev;
 }
 
+// i2c ublox init
+nmea_gps_context nmea_gps_init_ublox_i2c(unsigned int bus, uint8_t addr)
+{
+  nmea_gps_context dev =
+    (nmea_gps_context)malloc(sizeof(struct _nmea_gps_context));
+
+  if (!dev)
+    return NULL;
+
+  // zero out context
+  memset((void *)dev, 0, sizeof(struct _nmea_gps_context));
+
+  dev->uart = NULL;
+  dev->i2c = NULL;
+  dev->gpio_en = NULL;
+
+  // initialize the MRAA contexts
+
+  if (!(dev->i2c = mraa_i2c_init(bus)))
+    {
+      printf("%s: mraa_i2c_init() failed.\n", __FUNCTION__);
+      nmea_gps_close(dev);
+      return NULL;
+    }
+
+  // This device cannot operate at more than 100Khz, so we set that
+  // here and bail if it fails.
+
+  if (mraa_i2c_frequency(dev->i2c, MRAA_I2C_STD))
+    {
+      printf("%s: mraa_i2c_frequency(MRAA_I2C_STD) failed.\n", __FUNCTION__);
+      nmea_gps_close(dev);
+      return NULL;
+    }
+
+  if (mraa_i2c_address(dev->i2c, addr))
+    {
+      printf("%s: mraa_i2c_address() failed.\n", __FUNCTION__);
+      nmea_gps_close(dev);
+      return NULL;
+    }
+
+  return dev;
+}
+
 void nmea_gps_close(nmea_gps_context dev)
 {
   assert(dev != NULL);
@@ -91,6 +176,8 @@ void nmea_gps_close(nmea_gps_context dev)
 
   if (dev->uart)
     mraa_uart_stop(dev->uart);
+  if (dev->i2c)
+    mraa_i2c_stop(dev->i2c);
   if (dev->gpio_en)
     mraa_gpio_close(dev->gpio_en);
 
@@ -116,6 +203,35 @@ int nmea_gps_read(const nmea_gps_context dev, char *buffer, size_t len)
 {
   assert(dev != NULL);
 
+  // i2c ublox
+  if (dev->i2c)
+    {
+      int rv;
+      if ((rv = readRegs(dev, UBLOX6_I2C_BYTE_STREAM, buffer, len)) < 0)
+        return rv;
+
+      // now we need to go through the bytes returned, and stop
+      // counting "real" bytes when we hit any character with the high
+      // bit set.  The documentation implies that only a 0xff will be
+      // sent when no new data is available, but it seems sometimes
+      // the return contains 0xbf and 0xc3 bytes.  So we stop counting
+      // as soon as we see any "8 bit" character (which isn't allowed
+      // by NMEA anyway).
+      int realBytes = 0;
+      int i;
+
+      for (i=0; i<rv; i++)
+        {
+          if (buffer[i] & 0x80)
+            break;
+
+          realBytes++;
+        }
+
+      return realBytes;
+    }
+
+  // uart
   return mraa_uart_read(dev->uart, buffer, len);
 }
 
@@ -123,6 +239,9 @@ int nmea_gps_write(const nmea_gps_context dev, char *buffer, size_t len)
 {
   assert(dev != NULL);
 
+  if (!dev->uart)
+    return UPM_ERROR_NO_RESOURCES;
+
   return mraa_uart_write(dev->uart, buffer, len);
 }
 
@@ -130,6 +249,24 @@ bool nmea_gps_data_available(const nmea_gps_context dev, unsigned int millis)
 {
   assert(dev != NULL);
 
+  // i2c ublox
+  if (dev->i2c)
+    {
+      // here millis is ignored
+      uint8_t h, l;
+
+      h = readReg(dev, UBLOX6_I2C_BYTES_AVAIL_H);
+      l = readReg(dev, UBLOX6_I2C_BYTES_AVAIL_L);
+
+      uint16_t total = (h << 8) | l;
+      // 0 means no data available, 0xffff means read errors
+      if (total == 0x0000 || total == 0xffff)
+        return false;
+      else
+        return true;
+    }
+
+  // uart
   if (mraa_uart_data_available(dev->uart, millis))
     return true;
   else
@@ -141,6 +278,9 @@ upm_result_t nmea_gps_set_baudrate(const nmea_gps_context dev,
 {
   assert(dev != NULL);
 
+  if (!dev->uart)
+    return UPM_ERROR_NO_RESOURCES;
+
   if (mraa_uart_set_baudrate(dev->uart, baudrate))
     {
       printf("%s: mraa_uart_set_baudrate() failed.\n", __FUNCTION__);
diff --git a/src/nmea_gps/nmea_gps.cxx b/src/nmea_gps/nmea_gps.cxx
index 372731c9..c72c3789 100644
--- a/src/nmea_gps/nmea_gps.cxx
+++ b/src/nmea_gps/nmea_gps.cxx
@@ -31,7 +31,7 @@ using namespace upm;
 using namespace std;
 
 NMEAGPS::NMEAGPS(unsigned int uart, unsigned int baudrate,
-                   int enable_pin) :
+                 int enable_pin) :
   m_nmea_gps(nmea_gps_init(uart, baudrate, enable_pin))
 {
   if (!m_nmea_gps)
@@ -39,6 +39,14 @@ NMEAGPS::NMEAGPS(unsigned int uart, unsigned int baudrate,
                              + ": nmea_gps_init() failed");
 }
 
+NMEAGPS::NMEAGPS(unsigned int bus, uint8_t addr) :
+  m_nmea_gps(nmea_gps_init_ublox_i2c(bus, addr))
+{
+  if (!m_nmea_gps)
+    throw std::runtime_error(string(__FUNCTION__)
+                             + ": nmea_gps_init() failed");
+}
+
 NMEAGPS::~NMEAGPS()
 {
   nmea_gps_close(m_nmea_gps);
diff --git a/src/nmea_gps/nmea_gps.h b/src/nmea_gps/nmea_gps.h
index 13b191e7..e8e72b69 100644
--- a/src/nmea_gps/nmea_gps.h
+++ b/src/nmea_gps/nmea_gps.h
@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include "upm.h"
 #include "mraa/uart.h"
+#include "mraa/i2c.h"
 #include "mraa/gpio.h"
 
 #ifdef __cplusplus
@@ -39,7 +40,16 @@ extern "C" {
    * This driver was tested with a number of GPS devices that emit
    * NMEA data via a serial interface of some sort (typically a UART).
    *
+   * The I2C capablity was tested with a UBLOX LEA-6H based GPS shield
+   * from DFRobot.  Currently, the I2C capability is only supported
+   * for UBLOX devices (or compatibles) that conform to the
+   * specifications outlined in the u-blox6 Receiver Description
+   * Protocol Specification, Chapter 4, DDC Port.
+   *
+   * An example using the UART.
    * @snippet nmea_gps.c Interesting
+   * An example using I2C.
+   * @snippet nmea_gps_i2c.c Interesting
    */
   
   /**
@@ -48,10 +58,11 @@ extern "C" {
   typedef struct _nmea_gps_context {
     mraa_uart_context        uart;
     mraa_gpio_context        gpio_en;
+    mraa_i2c_context         i2c;
   } *nmea_gps_context;
   
   /**
-   * NMEA_GPS Initializer
+   * NMEA_GPS Initializer for generic UART operation
    *
    * @param uart Specify which uart to use.
    * @param baudrate Specify the baudrate to use.  The device defaults
@@ -63,6 +74,16 @@ extern "C" {
   nmea_gps_context nmea_gps_init(unsigned int uart, unsigned int baudrate,
                                  int enable_pin);
 
+  /**
+   * NMEA_GPS Initializer for UBLOX I2C operation
+   *
+   * @param bus Specify which the I2C bus to use.
+   * @param addr Specify the I2C address to use.  For UBLOX devices,
+   * this typically defaults to 0x42.
+   * @return an initialized device context on success, NULL on error.
+   */
+  nmea_gps_context nmea_gps_init_ublox_i2c(unsigned int bus, uint8_t addr);
+
   /**
    * NMEA_GPS sensor close function
    */
@@ -79,7 +100,8 @@ extern "C" {
   int nmea_gps_read(const nmea_gps_context dev, char *buffer, size_t len);
 
   /**
-   * Write character data to the device.
+   * Write character data to the device.  This is only valid for a
+   * UART device.
    *
    * @param dev sensor context
    * @param buffer The character buffer containing data to write.
@@ -101,7 +123,7 @@ extern "C" {
 
   /**
    * Set the baudrate of the device.  By default, nmea_gps_init() will
-   * set the baudrate to 9600.
+   * set the baudrate to 9600.  This is only valid for UART devices.
    *
    * @param dev sensor context
    * @param baudrate The baud rate to set for the device.
@@ -111,7 +133,11 @@ extern "C" {
                                      unsigned int baudrate);
 
   /**
-   * Determine whether there is data available to be read.
+   * Determine whether there is data available to be read.  In the
+   * case of a UART, this function will wait up to "millis"
+   * milliseconds for data to become available.  In the case of an I2C
+   * device, the millis argument is ignored and the function will
+   * return immediately, indicating whether data is available.
    *
    * @param dev sensor context
    * @param millis The number of milliseconds to wait for data to
diff --git a/src/nmea_gps/nmea_gps.hpp b/src/nmea_gps/nmea_gps.hpp
index 42a9bd06..a155610c 100644
--- a/src/nmea_gps/nmea_gps.hpp
+++ b/src/nmea_gps/nmea_gps.hpp
@@ -52,14 +52,23 @@ namespace upm {
    * This driver was tested with a number of GPS devices that emit
    * NMEA data via a serial interface of some sort (typically a UART).
    *
+   * The I2C capablity was tested with a UBLOX LEA-6H based GPS shield
+   * from DFRobot.  Currently, the I2C capability is only supported
+   * for UBLOX devices (or compatibles) that conform to the
+   * specifications outlined in the u-blox6 Receiver Description
+   * Protocol Specification, Chapter 4, DDC Port.
+   *
+   * An example using the UART.
    * @snippet nmea_gps.cxx Interesting
+   * An example using I2C.
+   * @snippet nmea_gps_i2c.cxx Interesting
    */
 
   class NMEAGPS {
   public:
 
     /**
-     * NMEAGPS object constructor
+     * NMEAGPS object constructor for a UART
      *
      * @param uart Specify which uart to use.
      * @param baudrate Specify the baudrate to use.  The device defaults
@@ -68,7 +77,16 @@ namespace upm {
      * -1 to not use an enable pin.
      */
     NMEAGPS(unsigned int uart, unsigned int baudrate,
-             int enable_pin);
+            int enable_pin);
+
+    /**
+     * NMEAGPS object constructor for a UBLOX I2C interface
+     *
+     * @param bus Specify which the I2C bus to use.
+     * @param addr Specify the I2C address to use.  For UBLOX devices,
+     * this typically defaults to 0x42.
+     */
+    NMEAGPS(unsigned int bus, uint8_t addr);
 
     /**
      * NMEAGPS object destructor
@@ -84,7 +102,8 @@ namespace upm {
     std::string readStr(size_t size);
 
     /**
-     * Write character data to the device.
+     * Write character data to the device.  This is only valid for a
+     * UART device.
      *
      * @param buffer The string containing the data to write.
      * @return The number of bytes written.
@@ -102,14 +121,19 @@ namespace upm {
 
     /**
      * Set the baudrate of the device.  By default, the constructor
-     * will set the baudrate to 9600.
+     * will set the baudrate to 9600.  This is only valid for UART
+     * devices.
      *
      * @param baudrate The baud rate to set for the device.
      */
     void setBaudrate(unsigned int baudrate);
 
     /**
-     * Determine whether there is data available to be read.
+     * Determine whether there is data available to be read.  In the
+     * case of a UART, this function will wait up to "millis"
+     * milliseconds for data to become available.  In the case of an I2C
+     * device, the millis argument is ignored and the function will
+     * return immediately, indicating whether data is available.
      *
      * @param millis The number of milliseconds to wait for data to
      * become available.