Raspberry Pi GPS Tracker: Build Real-Time Fleet Monitor

Fleet management used to require expensive proprietary hardware costing lakhs of rupees. Today, a Raspberry Pi GPS tracker running real-time code can replicate most of that functionality at a fraction of the cost. Whether you’re managing a delivery fleet, tracking school buses, or monitoring field equipment across rural India, this guide shows you exactly how to build a production-ready real-time tracking system from scratch.

By the end of this tutorial, you’ll have a working GPS tracker that pushes live coordinates to a web dashboard, stores historical routes in a database, and sends alerts when a vehicle leaves a designated zone — all running on hardware that costs under ₹3,000 per unit.

Why Raspberry Pi for Fleet Tracking?

Commercial fleet management solutions like Tata Elxsi’s GPS trackers or similar enterprise tools typically lock you into monthly SIM data contracts, cloud storage fees, and proprietary apps. A Raspberry Pi-based system offers full ownership of your data, complete customisability, and negligible recurring costs beyond your SIM data plan.

The Raspberry Pi 5, in particular, brings significant advantages over older models for this use case:

• Faster serial parsing — the RP1 I/O chip on Pi 5 handles UART at much higher throughput with lower CPU overhead
• More RAM for local caching — if your vehicle enters a mobile dead zone, the Pi can buffer thousands of GPS points locally before syncing
• Python 3.11+ compatibility — async libraries like asyncio and aiomqtt run noticeably faster
• USB 3.0 ports — if you’re also recording dashcam footage alongside GPS, the higher bandwidth matters

For smaller fleets or motorcycle couriers, the Raspberry Pi Pico W (a microcontroller, not a full SBC) can also work with a cellular modem, but this guide focuses on the Pi 5 for maximum flexibility.

Hardware Components You Need

Here is the complete bill of materials for a single tracker unit. Prices are approximate retail in India as of early 2026:

The GPS module choice matters more than most beginners realise. The NEO-6M is cheap and widely available but has a slow cold-start lock time (around 30–60 seconds). The u-blox M8N with a larger patch antenna achieves lock in under 15 seconds and holds lock better in urban canyons — worth the extra ₹200 for a fleet deployment.

Wiring the GPS Module to Raspberry Pi

Most inexpensive GPS modules like the NEO-6M use a UART (serial) interface at 3.3V logic levels, which is natively compatible with the Raspberry Pi’s GPIO header. You do not need a level shifter.

Make these four connections between the GPS module and the Pi 5’s 40-pin header:

On Raspberry Pi OS, you must disable the serial console and enable the serial hardware port. Run sudo raspi-config, go to Interface Options → Serial Port, choose No for the login shell over serial, and Yes to enable the serial port hardware. After rebooting, the GPS module will appear on /dev/ttyAMA0.

Test the raw NMEA stream with:

sudo cat /dev/ttyAMA0

You should see lines starting with $GPRMC and $GPGGA scrolling at 1 Hz. If you see nothing, check your TX/RX swap — a common beginner mistake is connecting TX→TX instead of TX→RX.

Writing the Python GPS Parser

Install the pynmea2 library which handles all NMEA sentence parsing:

pip install pynmea2 aiomqtt sqlite-utils

Here is a production-ready async GPS reader that parses NMEA sentences, stores points locally in SQLite (for dead-zone buffering), and publishes via MQTT:

import asyncio
import serial
import pynmea2
import json
import sqlite3
import time
from datetime import datetime, timezone
import aiomqtt

SERIAL_PORT = '/dev/ttyAMA0'
BAUD_RATE = 9600
MQTT_BROKER = 'your-broker-ip'
MQTT_TOPIC = 'fleet/vehicle/truck-01'
DEVICE_ID = 'truck-01'
DB_PATH = '/var/lib/gps_tracker/local_buffer.db'

def init_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute('''
        CREATE TABLE IF NOT EXISTS gps_points (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT,
            lat REAL,
            lon REAL,
            speed REAL,
            heading REAL,
            synced INTEGER DEFAULT 0
        )
    ''')
    conn.commit()
    return conn

async def read_gps(queue):
    ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1)
    while True:
        try:
            line = ser.readline().decode('ascii', errors='replace').strip()
            if line.startswith('$GPRMC'):
                msg = pynmea2.parse(line)
                if msg.status == 'A':  # Active fix
                    point = {
                        'device_id': DEVICE_ID,
                        'timestamp': datetime.now(timezone.utc).isoformat(),
                        'lat': float(msg.latitude),
                        'lon': float(msg.longitude),
                        'speed_kmh': round(float(msg.spd_over_grnd) * 1.852, 1),
                        'heading': float(msg.true_course) if msg.true_course else 0.0
                    }
                    await queue.put(point)
        except Exception:
            pass
        await asyncio.sleep(0)

async def publish_loop(queue, db_conn):
    while True:
        point = await queue.get()
        db_conn.execute(
            'INSERT INTO gps_points (timestamp,lat,lon,speed,heading) VALUES (?,?,?,?,?)',
            (point['timestamp'], point['lat'], point['lon'],
             point['speed_kmh'], point['heading'])
        )
        db_conn.commit()
        try:
            async with aiomqtt.Client(MQTT_BROKER) as client:
                await client.publish(MQTT_TOPIC, json.dumps(point))
            db_conn.execute(
                'UPDATE gps_points SET synced=1 WHERE synced=0'
            )
            db_conn.commit()
        except Exception:
            pass  # Will retry on next point

async def main():
    db = init_db()
    queue = asyncio.Queue(maxsize=500)
    await asyncio.gather(read_gps(queue), publish_loop(queue, db))

asyncio.run(main())

Save this as /usr/local/bin/gps_tracker.py and create a systemd service to run it automatically on boot:

[Unit]
Description=GPS Fleet Tracker
After=network.target

[Service]
ExecStart=/usr/bin/python3 /usr/local/bin/gps_tracker.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

MQTT Setup and Live Map Dashboard

The architecture for a real-time dashboard has three components: the Mosquitto MQTT broker receiving coordinates from all vehicles, a lightweight Node.js or Python backend subscribing to MQTT and serving WebSocket updates, and a Leaflet.js front-end showing live positions on an OpenStreetMap tile layer.

Install Mosquitto on your central server (or the fleet server Pi):

sudo apt install mosquitto mosquitto-clients
sudo systemctl enable mosquitto

A minimal Flask-SocketIO backend that bridges MQTT to the browser:

from flask import Flask, render_template
from flask_socketio import SocketIO
import paho.mqtt.client as mqtt
import json

app = Flask(__name__)
socketio = SocketIO(app, cors_allowed_origins='*')

def on_mqtt_message(client, userdata, message):
    data = json.loads(message.payload)
    socketio.emit('vehicle_update', data)

mqtt_client = mqtt.Client()
mqtt_client.on_message = on_mqtt_message
mqtt_client.connect('localhost', 1883)
mqtt_client.subscribe('fleet/#')
mqtt_client.loop_start()

@app.route('/')
def index():
    return render_template('map.html')

if __name__ == '__main__':
    socketio.run(app, host='0.0.0.0', port=5000)

On the front-end, Leaflet.js markers update in real-time via Socket.IO events. Each vehicle gets a unique marker with a popup showing device ID, speed, and last-seen timestamp. For a production fleet, you’d add polylines to draw the last 10 minutes of each vehicle’s route.

Adding Geofencing and Alert Logic

Geofencing is the most commercially valuable feature of any fleet system. The logic is straightforward: define a polygon or circle for each allowed zone, then check each incoming GPS point against those zones. If a vehicle is outside all allowed zones, trigger an alert.

Python’s shapely library handles polygon containment checks efficiently:

from shapely.geometry import Point, Polygon
from datetime import datetime
import requests

# Define geofence zones (lat/lon pairs)
ZONES = {
    'Mumbai_Depot': Polygon([
        (19.0760, 72.8777), (19.0900, 72.8777),
        (19.0900, 72.9000), (19.0760, 72.9000)
    ]),
    'Pune_Warehouse': Polygon([
        (18.5204, 73.8567), (18.5350, 73.8567),
        (18.5350, 73.8750), (18.5204, 73.8750)
    ])
}

def check_geofence(device_id, lat, lon):
    vehicle_pos = Point(lat, lon)
    in_any_zone = any(z.contains(vehicle_pos) for z in ZONES.values())
    
    if not in_any_zone:
        send_alert(device_id, lat, lon)

def send_alert(device_id, lat, lon):
    # Send to Telegram bot, email, or SMS
    msg = f"ALERT: {device_id} outside permitted zones at {lat},{lon}"
    # Telegram example:
    requests.post(
        f'https://api.telegram.org/bot{BOT_TOKEN}/sendMessage',
        json={'chat_id': CHAT_ID, 'text': msg}
    )

Integrate this check into your MQTT subscription handler on the central server. Every time a vehicle publishes a position, the server checks geofence containment and fires alerts if needed. With Telegram integration, your fleet manager gets instant push notifications on their phone without needing a separate app.

Powering Your Tracker Inside a Vehicle

Power is the number-one reliability issue with vehicle-mounted Raspberry Pi builds. Vehicle 12V systems are noisy, with voltage spikes during engine starts that can corrupt SD cards or cause kernel panics. You need proper power management.

Recommended power chain:

1. Connect to a fused 12V line behind the dashboard (NOT directly to the battery positive terminal)
2. Use a quality DC-DC buck converter rated at 3A minimum for the Pi 5 (which draws up to 2.5A under load)
3. Add a small 18650-based UPS board so the Pi has 30–60 seconds to flush buffers and shut down cleanly when the engine turns off
4. Set up watchdog on the Pi so a frozen process triggers an automatic reboot

Enable the hardware watchdog on Pi 5:

# In /etc/systemd/system.conf:
RuntimeWatchdogSec=15
ShutdownWatchdogSec=2min

For the GPS antenna, if your vehicle has a metal roof, a magnetic mount external antenna (the SMA connector type sold with most u-blox M8N modules) dramatically improves fix quality compared to the tiny patch antenna soldered onto cheap NEO-6M boards. Run the coax through a door seal and mount it on the roof.

With all of this in place, each tracker unit costs roughly ₹10,000–12,000 in hardware (dominated by the Pi 5 price). For a 10-vehicle fleet that’s ₹1–1.2 lakh — compare that to commercial fleet management hardware at ₹4,000–8,000 per vehicle plus ₹500–1,500/month per vehicle in subscription fees.

Frequently Asked Questions

Can I use a Raspberry Pi Zero W for GPS tracking to save cost?

Yes, but with caveats. The Pi Zero W has only one USB port (requiring a hub for a 4G dongle + GPS), and its 512MB RAM limits concurrent processes. For a basic tracker that only sends coordinates via MQTT, it works. For anything involving local buffering, SQLite writes, and a dashboard, use a Pi 5 or at minimum a Pi 4.

What SIM card is best for fleet tracking in India?

Jio’s IoT SIM (M2M SIM) plan is the most economical for fleet deployments at scale — it requires bulk registration through a reseller but costs around ₹50–100/month per device for 1GB data. For a pilot with under 10 vehicles, a regular Jio or Airtel prepaid SIM with a ₹149 28-day data plan is perfectly adequate.

How do I handle GPS data when the vehicle is in a tunnel or basement?

The local SQLite buffer in the Python code above handles this. The GPS module will stop outputting status == 'A' (active fix) sentences, so no bad data is recorded. When the vehicle re-emerges and gets a fix, tracking resumes seamlessly. For dead reckoning in extended tunnels, you’d need an IMU (accelerometer + gyroscope) which is a significant hardware and algorithmic addition.

Is this legal to deploy in commercial vehicles in India?

For commercial vehicles, the Ministry of Road Transport and Highways mandates AIS-140 certified GPS devices for public transport. Your Raspberry Pi build does NOT qualify as AIS-140 compliant. For private company vehicles, there is no legal requirement for a specific certified device — a Pi tracker is fully legal. For school buses or public transport, you must use certified hardware.

How accurate is the GPS positioning?

The NEO-6M achieves about 2.5m CEP (Circular Error Probable) in open-sky conditions. The u-blox M8N achieves 1.5–2.0m CEP and supports multiple GNSS constellations (GPS + GLONASS + Galileo) for faster lock. For fleet management purposes, 2–3 metre accuracy is more than sufficient. Speed accuracy is typically within 0.1 m/s.

Ready to start building your fleet tracking system? Browse all Raspberry Pi boards, accessories, and sensor modules at zbotic.in/product-category/raspberry-pi/ — free shipping on orders above ₹500 across India.