This miniature GPS breakout is only 1" x 1" (~ 25mm x 25mm) but houses a complete GPS/GNSS solution with both I2C and UART interfaces. There's even an antenna on top so it's plug and play!

• Support for GPS, GLONASS, GALILEO, QZSS
• -165 dBm sensitivity, up to 10 Hz updates
• Up to 210 PRN channels with 99 search channels and 33 simultaneous tracking channels
• 5V friendly design and only 30mA current draw
• Breadboard-able, with 4 mounting holes
• UART and I2C interfaces, pick whichever you like most!
• RTC battery-compatible
• PPS output on fix ±20ns jitter
• Internal patch antenna
• Low-power and standby mode with WAKE pin

The breakout is built around the MTK3333 chipset, a reliable, high-quality GPS module that can handle up to 33 simultaneous tracking channels, has an excellent high-sensitivity receiver (-165 dBm tracking!), and a built in antenna. It can do up to 10 location updates a second for high speed, high sensitivity logging or tracking. Power usage is incredibly low, only 30 mA during navigation.

Best of all, we added all the extra goodies you could ever want: a ultra-low dropout 3.3V regulator so you can power it with 3.3-5VDC in, 5V level safe inputs on UART and I2C, a footprint for optional CR1220 coin cell to keep the RTC running and allow warm starts, a green power LED and a tiny red PPS LED. The LED blinks at about 1Hz when a fix is found and is off when no fix.

Unlike our Ultimate GPS modules, this module does not have the ability to connect an external antenna, it's designed to be as small as possible for compact projects.

As with all Adafruit breakouts, we've done the work to make this GPS module super easy to use. We've put it on a breakout board with the required support circuitry and connectors to make it easy to work with, and is now a trend we've added SparkFun Qwiic compatible STEMMA QT JST SH connectors that allow you to get going without needing to solder. Just use a STEMMA QT adapter cable, plug it into your favorite micro or Blinka supported SBC and you're ready to rock!

Comes with one fully assembled and tested module, a piece of header you can solder to it for bread-boarding, and a CR1220 coin cell holder. A CR1220 coin cell is not included, but we have them in the shop if you'd like to use the GPS's RTC

This GPS module can be used with I2C or UART. Let's take a look!

GPS Module

Power Pins

I2C Data Pins

Other Pins

UART Serial Data Pins

LEDs

Optional Coin Cell

Wiring

If you have a STEMMA QT breakout cable, then you can wire like this:

If you want to solder pins to the header connectors and use a breadboard, then wire like this:

Installation

The Adafruit GPS Library includes support for the Mini GPS PA1010D module. You can install it from the Arduino IDE via the Library Manager:

Click the Manage Libraries... menu item, search for Adafruit GPS, and select the Adafruit GPS Library:

Echo Test Demo

We can test basic functionality using one of the examples from the library. This won't do any parsing. It simply dumps the raw data sentences as received from the GPS module.

Open up File -> Examples -> Adafruit GPS Library -> GPS_I2C_EchoTest and upload to your Arduino board with the GPS module connected.

Once the sketch is uploaded, open up the Serial Monitor (Tools -> Serial Monitor) at 115200 baud. You should see something like this:

If you see this, then you are successfully talking to the GPS module. Once it obtains a lock on the GPS satellites, which can takes several minutes, there will be more information in the sentences. To see that information in a more user friendly format, try running the GPS_I2C_Parsing example from the library.

Wiring

Note that the breakout has pins on two sides. Be sure to use the side with the UART pins. They are labeled TXO and RXI. We'll demonstrate using SoftwareSerial on the Metro 328. Here's the wiring:

Installation

See the Arduino I2C Usage section for details about installing the Adafruit GPS Library. The same library is used for UART.

Echo Test Demo

We can test basic functionality using one of the examples from the library. This won't do any parsing. It simply dumps the raw data sentences as received from the GPS module.

Open up File -> Examples -> Adafruit GPS Library -> GPS_SoftwareSerial_EchoTest and upload to your Arduino board with the GPS module connected.

Once the sketch is uploaded, open up the Serial Monitor (Tools -> Serial Monitor) at 115200 baud. You should see something like this:

If you see this, then you are successfully talking to the GPS module. Once it obtains a lock on the GPS satellites, which can takes several minutes, there will be more information in the sentences. To see that information in a more user friendly format, try running the GPS_SoftwareSerial_Parsing example from the library.

Hardware UART

The above example demonstrated UART usage via SoftwareSerial. If you have a board with an available hardware UART, you can use that also. Simply connect to the TX/RX pins for the hardware UART for your particular board and then see the examples in the Adafruit GPS Library with HardwareSerial in the name.

It's easy to use the Adafruit Mini GPS PA1010D breakout with Python or CircuitPython and the Adafruit CircuitPython GPS module. This library allows you to write Python code that reads the date, time, location and more from the breakout.

You can use this sensor with any CircuitPython microcontroller board or with a computer that has GPIO and Python thanks to Adafruit_Blinka, our CircuitPython-for-Python compatibility library.

CircuitPython Microcontroller Wiring

The Adafruit Mini GPS PA1010D can be wired up in multiple ways. We recommend I2C as it is the simplest. There are two ways you can connect the GPS to a microcontroller using I2C.

I2C Interface

Here is an example of the module connected to a Feather M0 Express for I2C using the STEMMA connector and a STEMMA cable:

Here is an example of the module connected to a Feather M0 Express for I2C using jumper wires:

UART Interface

Here is an example of the module connected to a Feather M0 Express using UART:

Python Computer Wiring

Since there's dozens of Linux computers/boards you can use we will show wiring for Raspberry Pi. For other platforms, please visit the guide for CircuitPython on Linux to see whether your platform is supported. 

I2C Interface

Here's the Raspberry Pi wired with I2C using the STEMMA connector and a STEMMA cable:

Here's the Raspberry Pi wired with I2C using jumper wires:

UART Interface

For UART, you have two options: An external USB-to-serial converter or the built-in UART on the Pi's TX/RX pins.

USB-to-Serial Cable Interface

Here's an example of wiring up the USB-to-TTL serial converter, and the FTDI serial TTL-232 USB cable (also available in USB-C):

Hardware UART Interface

Here's an example using the Pi's built-in UART:

If you want to use the built-in UART, you'll need to disable the serial console and enable the serial port hardware in raspi-config. See the UART/Serial section of the CircuitPython on Raspberry Pi guide for detailed instructions on how to do this.

CircuitPython Installation of GPS Library

Next you'll need to install the Adafruit CircuitPython GPS library on your CircuitPython board.

First make sure you are running the latest version of Adafruit CircuitPython for your board.

Next you'll need to install the necessary libraries to use the hardware. Carefully follow the steps to find and install these libraries from Adafruit's CircuitPython library bundle.  For example, the Welcome to CircuitPython guide has a great page on how to install the library bundle.

To install the libraries, you'll need to copy the following files from the bundle to the lib folder on your CIRCUITPY drive:

• adafruit_gps.mpy
• adafruit_bus_device

Before continuing make sure your board's lib folder has the adafruit_gps.mpy and adafruit_bus_device files and folders copied over.

Python Installation of GPS Library

You'll need to install the Adafruit_Blinka library that provides the CircuitPython support in Python. This may also require enabling I2C and UART on your platform and verifying you are running Python 3. Since each platform is a little different, and Linux changes often, please visit the CircuitPython on Linux guide to get your computer ready!

Once that's done, from your command line run the following command:

• pip3 install adafruit-circuitpython-gps

If your default Python is version 3 you may need to run 'pip' instead. Just make sure you aren't trying to use CircuitPython on Python 2.x, it isn't supported!

To demonstrate the usage of the GPS module in CircuitPython using I2C, let's look at a complete program example, the gps_echotest.py file from the module's examples.

To use this example with I2C, you need to change four separate lines of code found towards the beginning of the initialisation section of the example.

First, comment out the following lines by adding a # to the beginning of each line:

uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)

gps = adafruit_gps.GPS(uart, debug=False)

1
2
3

uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)

gps = adafruit_gps.GPS(uart, debug=False)

Then, uncomment the following lines by removing the # from the beginning of each line:

#i2c = busio.I2C(board.SCL, board.SDA)

#gps = adafruit_gps.GPS_GtopI2C(i2c, debug=False) # Use I2C interface

1
2
3

#i2c = busio.I2C(board.SCL, board.SDA)

#gps = adafruit_gps.GPS_GtopI2C(i2c, debug=False) # Use I2C interface

Once these changes are made, you are ready to continue.

CircuitPython Microcontroller Usage

With a CircuitPython microcontroller, save the gps_echotest.py file as code.py on your CIRCUITPY drive. Then connect to the serial console to see the output.

Linux, Computer or Raspberry Pi Usage

From the command line, run the following command:

python3 gps_echotest.py

1

python3 gps_echotest.py

Echotest Example

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

# Simple GPS module demonstration.
# Will print NMEA sentences received from the GPS, great for testing connection
# Uses the GPS to send some commands, then reads directly from the GPS
import time

import board
import busio

import adafruit_gps

# Create a serial connection for the GPS connection using default speed and
# a slightly higher timeout (GPS modules typically update once a second).
# These are the defaults you should use for the GPS FeatherWing.
# For other boards set RX = GPS module TX, and TX = GPS module RX pins.
uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)

# for a computer, use the pyserial library for uart access
# import serial
# uart = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=10)

# If using I2C, we'll create an I2C interface to talk to using default pins
# i2c = board.I2C()  # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C()  # For using the built-in STEMMA QT connector on a microcontroller

# Create a GPS module instance.
gps = adafruit_gps.GPS(uart)  # Use UART/pyserial
# gps = adafruit_gps.GPS_GtopI2C(i2c)  # Use I2C interface

# Initialize the GPS module by changing what data it sends and at what rate.
# These are NMEA extensions for PMTK_314_SET_NMEA_OUTPUT and
# PMTK_220_SET_NMEA_UPDATERATE but you can send anything from here to adjust
# the GPS module behavior:
#   https://cdn-shop.adafruit.com/datasheets/PMTK_A11.pdf

# Turn on the basic GGA and RMC info (what you typically want)
gps.send_command(b"PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0")
# Turn on just minimum info (RMC only, location):
# gps.send_command(b'PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Turn off everything:
# gps.send_command(b'PMTK314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Tuen on everything (not all of it is parsed!)
# gps.send_command(b'PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0')

# Set update rate to once a second (1hz) which is what you typically want.
gps.send_command(b"PMTK220,1000")
# Or decrease to once every two seconds by doubling the millisecond value.
# Be sure to also increase your UART timeout above!
# gps.send_command(b'PMTK220,2000')
# You can also speed up the rate, but don't go too fast or else you can lose
# data during parsing.  This would be twice a second (2hz, 500ms delay):
# gps.send_command(b'PMTK220,500')

# Main loop runs forever printing data as it comes in
timestamp = time.monotonic()
while True:
    data = gps.read(32)  # read up to 32 bytes
    # print(data)  # this is a bytearray type

    if data is not None:
        # convert bytearray to string
        data_string = "".join([chr(b) for b in data])
        print(data_string, end="")

    if time.monotonic() - timestamp > 5:
        # every 5 seconds...
        gps.send_command(b"PMTK605")  # request firmware version
        timestamp = time.monotonic()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

# Simple GPS module demonstration.
# Will print NMEA sentences received from the GPS, great for testing connection
# Uses the GPS to send some commands, then reads directly from the GPS
import time

import board
import busio

import adafruit_gps

# Create a serial connection for the GPS connection using default speed and
# a slightly higher timeout (GPS modules typically update once a second).
# These are the defaults you should use for the GPS FeatherWing.
# For other boards set RX = GPS module TX, and TX = GPS module RX pins.
uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)

# for a computer, use the pyserial library for uart access
# import serial
# uart = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=10)

# If using I2C, we'll create an I2C interface to talk to using default pins
# i2c = board.I2C()  # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C()  # For using the built-in STEMMA QT connector on a microcontroller

# Create a GPS module instance.
gps = adafruit_gps.GPS(uart)  # Use UART/pyserial
# gps = adafruit_gps.GPS_GtopI2C(i2c)  # Use I2C interface

# Initialize the GPS module by changing what data it sends and at what rate.
# These are NMEA extensions for PMTK_314_SET_NMEA_OUTPUT and
# PMTK_220_SET_NMEA_UPDATERATE but you can send anything from here to adjust
# the GPS module behavior:
#   https://cdn-shop.adafruit.com/datasheets/PMTK_A11.pdf

# Turn on the basic GGA and RMC info (what you typically want)
gps.send_command(b"PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0")
# Turn on just minimum info (RMC only, location):
# gps.send_command(b'PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Turn off everything:
# gps.send_command(b'PMTK314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Tuen on everything (not all of it is parsed!)
# gps.send_command(b'PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0')

# Set update rate to once a second (1hz) which is what you typically want.
gps.send_command(b"PMTK220,1000")
# Or decrease to once every two seconds by doubling the millisecond value.
# Be sure to also increase your UART timeout above!
# gps.send_command(b'PMTK220,2000')
# You can also speed up the rate, but don't go too fast or else you can lose
# data during parsing.  This would be twice a second (2hz, 500ms delay):
# gps.send_command(b'PMTK220,500')

# Main loop runs forever printing data as it comes in
timestamp = time.monotonic()
while True:
    data = gps.read(32)  # read up to 32 bytes
    # print(data)  # this is a bytearray type

    if data is not None:
        # convert bytearray to string
        data_string = "".join([chr(b) for b in data])
        print(data_string, end="")

    if time.monotonic() - timestamp > 5:
        # every 5 seconds...
        gps.send_command(b"PMTK605")  # request firmware version
        timestamp = time.monotonic()

Connect to the serial console. You should see something like the following output.

This is the raw GPS "NMEA sentence" output from the module. There are a few different kinds of NMEA sentences, the most common ones people use are the $GPRMC (Global Positioning RecommendedMinimum Coordinates or something like that) and the $GPGGA sentences. These two provide the time, date, latitude, longitude, altitude, estimated land speed, and fix type. Fix type indicates whether the GPS has locked onto the satellite data and received enough data to determine the location (2D fix) or location+altitude (3D fix).

For more details about NMEA sentences and what data they contain, check out this site

If you look at the data in the above window, you can see that there are a lot of commas, with no data in between them. That's because this module is on my desk, indoors, and does not have a 'fix'. To get a fix, we need to put the module outside.

Note: Due to the antenna being built in, the PA1010D Mini GPS module may need a more unobstructed view of the sky than other GPS modules with eternal antennae. If you are having trouble getting a fix, try moving the module to a more ideal location.

For an explanation of the rest of the setup in this example, see the GPS Example Code Explained section of the CircuitPython & Python UART Usage page.

Following setup is the main loop.

while True:
    data = gps.read(32)  # read up to 32 bytes
    # print(data)  # this is a bytearray type

    if data is not None:
        # convert bytearray to string
        data_string = ''.join([chr(b) for b in data])
        print(data_string, end="")

    if time.monotonic() - timestamp > 5:
        # every 5 seconds...
        gps.send_command(b'PMTK605')  # request firmware version
        timestamp = time.monotonic()

1
2
3
4
5
6
7
8
9
10
11
12
13

while True:
    data = gps.read(32)  # read up to 32 bytes
    # print(data)  # this is a bytearray type

    if data is not None:
        # convert bytearray to string
        data_string = ''.join([chr(b) for b in data])
        print(data_string, end="")

    if time.monotonic() - timestamp > 5:
        # every 5 seconds...
        gps.send_command(b'PMTK605')  # request firmware version
        timestamp = time.monotonic()

First we read up to 32 bytes directly from the GPS and save it to data as a bytearray.

Next, we check to see that data has been read by verifying that it is not equal to None - this avoids the code failing when no data is returned. Then we convert the bytearray into a string and print it out.

Lastly, every 5 seconds, we request the firmware version.

Once you've used the Echotest to verify that your Mini GPS module is connected and working, you can switch to the Simpletest example to get a more readable version of the data. To use the gps_simpletest.py example with I2C, you must make the same changes shown above that you made to the Echotest example. Comment out the UART setup lines and uncomment the I2C setup lines. Once the changes are made, you can follow along with the code explanation found in the CircuitPython & Python UART Usage: Example Parsing Code section.

Files:

• PA1010D Datasheet
• EagleCAD PCB files on GitHub
• 3D models on GitHub
• Fritzing object in the Adafruit Fritzing Library

Schematic

Fab Print

3D Model