11  GPS and Outdoor Positioning

In 60 Seconds

GPS determines position by measuring time-of-flight from at least 4 satellites, solving for 3D position plus clock offset. Signals travel at the speed of light, making timing critical – a 1 microsecond clock error equals 300 meters of position error, which is why satellites carry atomic clocks. The multipath problem (signals bouncing off buildings) is GPS’s biggest challenge in urban environments, degrading accuracy from 5-10 meters to 50+ meters.

11.1 Learning Objectives

By the end of this chapter, you will be able to:

• Explain GPS/GNSS Architecture: Describe the space, control, and user segments of satellite navigation systems and how they interact
• Calculate Positioning from Satellites: Apply Time of Flight and TDoA principles to determine position
• Diagnose Multipath Effects: Analyze how signal reflections degrade positioning accuracy in urban environments
• Justify Clock Synchronization: Explain why atomic clocks are essential and demonstrate how pseudoranges compensate for receiver clock offset

For Beginners: GPS and Outdoor Positioning

Every time you open a map application on your phone and see a blue dot showing your location, you are using GPS. The Global Positioning System is a network of satellites orbiting Earth that continuously broadcast time-stamped signals. Your phone listens to these signals, measures how long each one took to arrive, and calculates exactly where you are. In IoT, GPS enables vehicle fleet tracking, agricultural drone navigation, wildlife monitoring, and asset management across vast outdoor areas. This chapter builds from simple distance-from-timing concepts to the full GPS position-fix algorithm.

11.2 Prerequisites

• Location Awareness Fundamentals: Understanding of positioning technology landscape

11.3 Global Navigation Satellite Systems

Figure 11.1: Diagram showing GNSS systems worldwide with satellite counts and accuracy specifications.

GPS (Global Positioning System) was the first Global Navigation Satellite System (GNSS) and remains the dominant technology for outdoor localization. Developed by the US Department of Defense and declared fully operational in 1995, GPS now serves billions of civilian devices worldwide. To understand how GPS works, we first examine two foundational ranging techniques: Time of Flight and Time Difference of Arrival.

11.4 Time of Flight (ToF)

Time of Flight measures the time taken for a signal to propagate from transmitter to receiver, then converts that elapsed time into a distance.

Figure 11.2: Time of Flight Concept

Distance Calculation:

Distance = Speed of Light x Time of Flight
d = c x delta-t

where:
- c = 299,792,458 m/s (speed of light in vacuum)
- delta-t = reception time - transmission time

Critical Challenge: Both transmitter and receiver must have synchronized clocks to know the true transmission time.

Synchronization Sensitivity:

1 microsecond clock error = 300 meters position error!
1 nanosecond clock error = 0.3 meters position error

Because GPS signals travel at the speed of light, even tiny timing errors produce large distance errors. This fundamental constraint drives the entire GPS system design – from atomic clocks on satellites to the mathematical trick of solving for clock offset as an unknown.

11.5 The Multipath Problem

Figure 11.3: Multipath problem in GPS

Multipath occurs when signals reflect off buildings, terrain, or other surfaces before reaching the receiver, creating multiple paths between transmitter and receiver.

Impact:

• Fine for communications: Multiple signal copies can be combined constructively
• Degrades positioning: Reflected signals travel longer paths, making distances appear greater than reality
• Worst in urban canyons: Tall buildings create severe multipath, inflating GPS error from 5-10 meters to 50+ meters
• Indoor environments: Extreme multipath plus signal attenuation makes standard GPS essentially unusable

11.6 Time Difference of Arrival (TDoA)

Figure 11.4: Time difference of arrival

The Problem with Simple ToF:

• Mobile device and fixed transmitters are separated by large distances
• Cannot keep their clocks synchronized to nanosecond precision
• Since RF signals travel at c, a 1 us synchronization error produces 300 m of position error

TDoA Solution:

• Accept that the mobile clock is imprecise
• Solve for the clock offset as an additional unknown variable
• Any single range measurement is wrong, but every range is wrong by the same amount (the clock offset)
• These biased range measurements are called pseudoranges

Figure 11.5: Diagram showing TDoA positioning system architecture with mobile device and synchronized base stations.

Key Requirements for TDoA:

1. Base Stations Must Be Synchronized:
   • Lay cables between stations for wired time distribution
   • Use GPS timing receivers (ironically!)
   • Install atomic clocks at each station (expensive)
2. Mobile Device Clock Can Be Imprecise:
   • Clock offset becomes an additional unknown to solve
   • Need N+1 reference points for N-dimensional positioning
   • 3D position + clock offset = 4 unknowns, requiring a minimum of 4 satellites

11.7 GPS Architecture

Figure 11.6: GPS System Overview

GPS is essentially an inverted TDoA system: satellites are the synchronized transmitters and your receiver is the unsynchronized mobile device.

GPS is TDoA (Inverted):

• Satellites are the static, synchronized reference points (but they transmit rather than receive)
• Your receiver measures the arrival time of each satellite signal using its own imprecise clock
• The difference between the satellite’s transmitted timestamp and the receiver’s local clock reading gives a time-of-flight estimate
• Each estimate is biased by the receiver’s clock offset, producing a pseudorange
• With 4+ pseudoranges, the receiver solves simultaneously for 3D position and clock offset

11.8 Satellite Synchronization

Figure 11.7: How satellites stay synchronized

How Satellites Stay Synchronized:

1. Atomic Clocks On Board (Caesium or Rubidium)
   • Cost: approximately $100,000 per clock (each satellite carries multiple for redundancy)
   • Accuracy: drift of roughly 1 nanosecond per day
   • All satellites share a common GPS time reference
2. Orbital Prediction:
   • Satellite positions are not fixed, but their orbits are precisely modeled
   • Ephemeris data (orbital parameters) allows receivers to predict satellite positions
   • Small perturbations from solar radiation pressure and gravitational anomalies require periodic corrections
3. Ground Control Segment:
   • Dedicated ground stations continuously monitor satellite orbits and clock drift
   • Track actual positions versus predicted trajectories
   • Upload corrections to satellites, which rebroadcast them to receivers
   • Must model relativistic effects on satellite clocks

Figure 11.8: Satellite Orbit Monitoring

Relativistic Effects:

• Special Relativity: Satellite clocks run slower due to orbital velocity (~7 us/day slower)
• General Relativity: Satellite clocks run faster due to weaker gravity at altitude (~45 us/day faster)
• Net Effect: ~38 us/day faster – must be continuously corrected

Putting Numbers to It

Let’s calculate the relativistic time dilation effects on GPS satellite clocks that must be corrected for accurate positioning:

Special Relativity (Velocity Effect): GPS satellites orbit at \(v = 3{,}874\) m/s at altitude \(h = 20{,}200\) km.

Time dilation factor: \[ \gamma = \frac{1}{\sqrt{1 - \frac{v^2}{c^2}}} \]

\[ \begin{aligned} \frac{v^2}{c^2} &= \frac{(3{,}874)^2}{(3 \times 10^8)^2} = 1.67 \times 10^{-10} \\ \gamma &\approx 1 + \frac{1}{2} \times 1.67 \times 10^{-10} = 1.0000000000835 \end{aligned} \]

Clock runs slower by: \[ \Delta t_{\text{SR}} = -\frac{1}{2} \times \frac{v^2}{c^2} \times 86{,}400\text{ s/day} = -7.2 \times 10^{-6}\text{ s/day} = -7.2\text{ \textmu s/day} \]

General Relativity (Gravitational Effect): Gravitational time dilation at satellite altitude vs. Earth surface: \[ \frac{\Delta t}{t} = \frac{GM}{c^2} \left( \frac{1}{r_{\text{surface}}} - \frac{1}{r_{\text{satellite}}} \right) \]

\[ \begin{aligned} r_{\text{surface}} &= 6{,}371\text{ km} \\ r_{\text{satellite}} &= 6{,}371 + 20{,}200 = 26{,}571\text{ km} \\ \Delta t_{\text{GR}} &= \frac{3.986 \times 10^{14}}{(3 \times 10^8)^2} \times \left( \frac{1}{6.371 \times 10^6} - \frac{1}{26.571 \times 10^6} \right) \times 86{,}400 \\ &= +45.8\text{ \textmu s/day (clock runs faster)} \end{aligned} \]

Net Relativistic Effect: \[ \Delta t_{\text{total}} = \Delta t_{\text{GR}} + \Delta t_{\text{SR}} = 45.8 - 7.2 = +38.6\text{ \textmu s/day} \]

Impact on Position Accuracy if Uncorrected: \[ \text{Position Error} = c \times \Delta t = 3 \times 10^8 \times 38.6 \times 10^{-6} = 11{,}580\text{ m/day} \]

After one day, uncorrected relativistic effects would cause 11.6 km position error! GPS receivers apply continuous frequency adjustment (\(-4.465 \times 10^{-10}\) fractional offset) to satellite clocks to compensate.

11.9 GPS Position Calculation

Figure 11.9: GPS position calculation

Position Equations:

For each satellite \(i\):

\[ \rho_i = \sqrt{(x_i - x_r)^2 + (y_i - y_r)^2 + (z_i - z_r)^2} + c \cdot \Delta t + E_i \]

Where:

• \(\rho_i\) = pseudorange to satellite \(i\) (measured)
• \((x_i, y_i, z_i)\) = satellite \(i\) position (known from ephemeris)
• \((x_r, y_r, z_r)\) = receiver position (unknown)
• \(c\) = speed of light
• \(\Delta t\) = receiver clock offset (unknown)
• \(E_i\) = error term (atmospheric delays, multipath, noise)

Four Unknowns:

1. \(x_r\) (receiver X position)
2. \(y_r\) (receiver Y position)
3. \(z_r\) (receiver Z position)
4. \(\Delta t\) (clock offset)

Need at least 4 satellites to solve for 4 unknowns. With more than 4 satellites visible (typically 6-12), the receiver uses a least-squares algorithm to find the best-fit solution, improving accuracy.

11.10 How It All Comes Together: A Complete Position Fix

Understanding the full sequence from signal acquisition to position output ties together ToF, pseudoranges, and the 4-satellite minimum:

1. Signal Acquisition (5-30 seconds after power-on):
   • Receiver scans the GPS L1 frequency (1575.42 MHz) for satellite signals
   • Each satellite transmits a unique PRN (Pseudo-Random Noise) code
   • Receiver identifies which satellites are visible (typically 6-12 overhead)
2. Time-of-Flight Measurement (for each satellite):
   • Satellite broadcasts a timestamp: “I transmitted this at 14:32:05.123456789 GPS time”
   • Receiver notes the local arrival time: “I received this at 14:32:05.191234567 (my clock)”
   • Time difference: 0.067777778 seconds
   • Distance estimate: 0.0678 s x 300,000 km/s = ~20,340 km
   • However, the receiver clock is wrong by some unknown offset – so this is a pseudorange, not a true range
3. Pseudorange Equations (one per satellite):
   • Satellite 1: sqrt[(x1-x)^2 + (y1-y)^2 + (z1-z)^2] + c x dt = 20,340 km
   • Satellite 2: sqrt[(x2-x)^2 + (y2-y)^2 + (z2-z)^2] + c x dt = 22,145 km
   • Satellite 3: sqrt[(x3-x)^2 + (y3-y)^2 + (z3-z)^2] + c x dt = 21,789 km
   • Satellite 4: sqrt[(x4-x)^2 + (y4-y)^2 + (z4-z)^2] + c x dt = 19,456 km
   • (x, y, z) = your position (unknown), dt = your clock error (unknown)
4. Solve 4 Equations for 4 Unknowns:
   • Receiver uses iterative least-squares to find (x, y, z, dt) that best satisfies all equations
   • Result: position accurate to 5-10 meters, clock synchronized to 20-30 nanoseconds

Why This Works:

• All pseudoranges are biased by the same clock offset
• By treating the clock offset as a solvable unknown, imprecise measurements yield a precise position
• This elegant mathematical trick is why GPS receivers do not need expensive atomic clocks

11.11 GPS Error Sources

Figure 11.10: GPS error sources

Signal Strength Challenge:

• GPS signal transmitted at approximately 20 watts from each satellite
• Travels roughly 20,200 km to Earth’s surface
• Received power: approximately 10^-16 watts (extraordinarily weak)
• Various atmospheric and environmental effects introduce errors

Error Source	Typical Error	Mitigation
Ionospheric delay	+/- 5 m	Dual-frequency correction (L1 + L2/L5)
Tropospheric delay	+/- 0.5 m	Atmospheric modeling
Satellite clock	+/- 2 m	Ground station corrections
Ephemeris	+/- 2.5 m	Frequent orbital parameter updates
Multipath	+/- 1 m	Antenna design, signal averaging
Receiver noise	+/- 0.3 m	Higher-quality receiver hardware

viewof errorToggle = {
  const ieee = {
    navy: "#2C3E50", teal: "#16A085", orange: "#E67E22",
    blue: "#3498DB", gray: "#7F8C8D", purple: "#9B59B6", red: "#E74C3C"
  };

  const errors = [
    { name: "Ionospheric delay", typical: 5.0, color: ieee.blue, mitigation: "Dual-frequency" },
    { name: "Tropospheric delay", typical: 0.5, color: ieee.teal, mitigation: "Modeling" },
    { name: "Satellite clock", typical: 2.0, color: ieee.orange, mitigation: "Ground corrections" },
    { name: "Ephemeris", typical: 2.5, color: ieee.purple, mitigation: "Frequent updates" },
    { name: "Multipath", typical: 1.0, color: ieee.red, mitigation: "Antenna design" },
    { name: "Receiver noise", typical: 0.3, color: ieee.gray, mitigation: "Better hardware" }
  ];

  const width = 580;
  const height = 380;
  const margin = { top: 40, right: 180, bottom: 50, left: 160 };
  const plotW = width - margin.left - margin.right;
  const plotH = height - margin.top - margin.bottom;

  const container = document.createElement("div");
  container.style.cssText = "font-family: Arial, sans-serif; max-width: 620px; margin: 0 auto;";

  const title = document.createElement("div");
  title.style.cssText = "font-weight: bold; text-align: center; margin-bottom: 8px; color: var(--bs-body-color, #2C3E50); font-size: 14px;";
  title.textContent = "GPS Error Budget: Contribution by Source";
  container.appendChild(title);

  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
  svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
  svg.setAttribute("width", "100%");
  svg.style.maxWidth = width + "px";
  svg.style.background = "var(--bs-body-bg, #ffffff)";

  const barH = plotH / errors.length - 6;
  const maxVal = 6;

  errors.forEach((e, i) => {
    const y = margin.top + i * (plotH / errors.length) + 3;
    const barW = (e.typical / maxVal) * plotW;

    const label = document.createElementNS("http://www.w3.org/2000/svg", "text");
    label.setAttribute("x", margin.left - 8);
    label.setAttribute("y", y + barH / 2 + 4);
    label.setAttribute("text-anchor", "end");
    label.setAttribute("font-size", "11");
    label.setAttribute("fill", "var(--bs-body-color, #2C3E50)");
    label.textContent = e.name;
    svg.appendChild(label);

    const rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
    rect.setAttribute("x", margin.left);
    rect.setAttribute("y", y);
    rect.setAttribute("width", barW);
    rect.setAttribute("height", barH);
    rect.setAttribute("rx", 3);
    rect.setAttribute("fill", e.color);
    rect.setAttribute("opacity", 0.85);
    svg.appendChild(rect);

    const val = document.createElementNS("http://www.w3.org/2000/svg", "text");
    val.setAttribute("x", margin.left + barW + 6);
    val.setAttribute("y", y + barH / 2 + 4);
    val.setAttribute("font-size", "11");
    val.setAttribute("font-weight", "bold");
    val.setAttribute("fill", "var(--bs-body-color, #2C3E50)");
    val.textContent = `+/- ${e.typical} m (${e.mitigation})`;
    svg.appendChild(val);
  });

  // X axis
  for (let v = 0; v <= maxVal; v += 1) {
    const x = margin.left + (v / maxVal) * plotW;
    const tick = document.createElementNS("http://www.w3.org/2000/svg", "line");
    tick.setAttribute("x1", x); tick.setAttribute("x2", x);
    tick.setAttribute("y1", margin.top - 2);
    tick.setAttribute("y2", margin.top + plotH + 4);
    tick.setAttribute("stroke", "var(--bs-body-color, #ccc)");
    tick.setAttribute("stroke-opacity", 0.2);
    svg.appendChild(tick);

    const tl = document.createElementNS("http://www.w3.org/2000/svg", "text");
    tl.setAttribute("x", x);
    tl.setAttribute("y", margin.top + plotH + 20);
    tl.setAttribute("text-anchor", "middle");
    tl.setAttribute("font-size", "10");
    tl.setAttribute("fill", "var(--bs-body-color, #666)");
    tl.textContent = v + " m";
    svg.appendChild(tl);
  }

  // RSS total
  const rss = Math.sqrt(errors.reduce((s, e) => s + e.typical * e.typical, 0));
  const note = document.createElementNS("http://www.w3.org/2000/svg", "text");
  note.setAttribute("x", width / 2);
  note.setAttribute("y", height - 6);
  note.setAttribute("text-anchor", "middle");
  note.setAttribute("font-size", "11");
  note.setAttribute("font-weight", "bold");
  note.setAttribute("fill", ieee.navy);
  note.textContent = `RSS Total (root-sum-square): +/- ${rss.toFixed(1)} m`;
  svg.appendChild(note);

  container.appendChild(svg);
  return container;
}

11.12 Interactive: Clock Error Impact Calculator

Explore how receiver clock errors translate directly into position errors through the speed of light. Adjust the clock offset to see the resulting distance bias.

viewof clockErrorCalc = {
  const ieee = {
    navy: "#2C3E50", teal: "#16A085", orange: "#E67E22",
    blue: "#3498DB", gray: "#7F8C8D", red: "#E74C3C"
  };

  const container = document.createElement("div");
  container.style.cssText = "font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 16px; border: 1px solid var(--bs-body-color, #dee2e6); border-radius: 8px; background: var(--bs-body-bg, #ffffff);";

  const title = document.createElement("div");
  title.style.cssText = `font-weight: bold; font-size: 15px; color: ${ieee.navy}; margin-bottom: 12px; text-align: center;`;
  title.textContent = "Clock Error to Position Error Converter";
  container.appendChild(title);

  const sliderRow = document.createElement("div");
  sliderRow.style.cssText = "display: flex; align-items: center; gap: 12px; margin-bottom: 8px; flex-wrap: wrap;";

  const sliderLabel = document.createElement("label");
  sliderLabel.style.cssText = "font-size: 13px; color: var(--bs-body-color, #333); min-width: 100px;";
  sliderLabel.textContent = "Clock error (ns):";
  sliderRow.appendChild(sliderLabel);

  const slider = document.createElement("input");
  slider.type = "range";
  slider.min = "1";
  slider.max = "10000";
  slider.value = "1000";
  slider.step = "1";
  slider.style.cssText = "flex: 1; min-width: 200px; accent-color: " + ieee.teal + ";";
  sliderRow.appendChild(slider);

  const valDisplay = document.createElement("span");
  valDisplay.style.cssText = `font-weight: bold; font-size: 14px; color: ${ieee.teal}; min-width: 80px; text-align: right;`;
  valDisplay.textContent = "1,000 ns";
  sliderRow.appendChild(valDisplay);
  container.appendChild(sliderRow);

  const resultBox = document.createElement("div");
  resultBox.style.cssText = "margin-top: 12px; padding: 14px; border-radius: 6px; background: var(--bs-light, #f8f9fa);";
  container.appendChild(resultBox);

  const c = 299792458; // m/s

  function update() {
    const ns = parseInt(slider.value);
    valDisplay.textContent = ns.toLocaleString() + " ns";
    const us = ns / 1000;
    const ms = ns / 1e6;
    const posError = (ns * 1e-9) * c;

    let severity = ieee.teal;
    let label = "Negligible for most applications";
    if (posError > 100) { severity = ieee.orange; label = "Significant -- affects lane-level tracking"; }
    if (posError > 1000) { severity = ieee.red; label = "Severe -- exceeds typical GPS accuracy"; }

    resultBox.innerHTML = `
      <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 13px; color: var(--bs-body-color, #333);">
        <div><strong>Clock error:</strong></div>
        <div>${ns.toLocaleString()} ns = ${us.toFixed(3)} us = ${ms.toFixed(6)} ms</div>
        <div><strong>Position error:</strong></div>
        <div style="font-size: 18px; font-weight: bold; color: ${severity};">${posError < 1 ? posError.toFixed(2) + " m" : posError < 1000 ? posError.toFixed(1) + " m" : (posError / 1000).toFixed(2) + " km"}</div>
        <div><strong>Formula:</strong></div>
        <div>d = c x dt = ${c.toLocaleString()} m/s x ${ns.toLocaleString()} ns</div>
        <div><strong>Assessment:</strong></div>
        <div style="color: ${severity}; font-weight: bold;">${label}</div>
      </div>
      <div style="margin-top: 10px; font-size: 11px; color: ${ieee.gray};">
        Reference: GPS atomic clocks drift ~1 ns/day. Consumer receiver clocks drift ~1,000 ns (1 us) without correction.
      </div>
    `;
  }

  slider.addEventListener("input", update);
  update();
  return container;
}

11.13 Interactive: GPS Satellite Geometry and DOP

The arrangement of visible satellites affects positioning accuracy. When satellites are clustered together, the geometric solution is weak (high DOP – Dilution of Precision). When satellites are spread across the sky, geometry is strong (low DOP). Drag the satellite positions to explore this effect.

viewof dopExplorer = {
  const ieee = {
    navy: "#2C3E50", teal: "#16A085", orange: "#E67E22",
    blue: "#3498DB", gray: "#7F8C8D", purple: "#9B59B6", red: "#E74C3C"
  };

  const width = 400;
  const height = 400;
  const cx = width / 2;
  const cy = height / 2;
  const skyR = 170;

  const container = document.createElement("div");
  container.style.cssText = "font-family: Arial, sans-serif; max-width: 440px; margin: 0 auto;";

  const title = document.createElement("div");
  title.style.cssText = `font-weight: bold; text-align: center; margin-bottom: 6px; color: var(--bs-body-color, ${ieee.navy}); font-size: 14px;`;
  title.textContent = "Satellite Geometry and Dilution of Precision";
  container.appendChild(title);

  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
  svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
  svg.setAttribute("width", "100%");
  svg.style.maxWidth = width + "px";
  svg.style.background = "var(--bs-body-bg, #ffffff)";
  svg.style.cursor = "default";
  svg.style.userSelect = "none";

  // Sky dome
  const dome = document.createElementNS("http://www.w3.org/2000/svg", "circle");
  dome.setAttribute("cx", cx); dome.setAttribute("cy", cy); dome.setAttribute("r", skyR);
  dome.setAttribute("fill", "var(--bs-light, #f0f4f8)");
  dome.setAttribute("stroke", ieee.navy); dome.setAttribute("stroke-width", 1.5);
  svg.appendChild(dome);

  // Horizon labels
  ["N","E","S","W"].forEach((d, i) => {
    const angle = -Math.PI/2 + i * Math.PI/2;
    const lbl = document.createElementNS("http://www.w3.org/2000/svg", "text");
    lbl.setAttribute("x", cx + (skyR + 14) * Math.cos(angle));
    lbl.setAttribute("y", cy + (skyR + 14) * Math.sin(angle) + 4);
    lbl.setAttribute("text-anchor", "middle");
    lbl.setAttribute("font-size", "11");
    lbl.setAttribute("fill", "var(--bs-body-color, #666)");
    lbl.textContent = d;
    svg.appendChild(lbl);
  });

  // Receiver at center
  const rcv = document.createElementNS("http://www.w3.org/2000/svg", "circle");
  rcv.setAttribute("cx", cx); rcv.setAttribute("cy", cy); rcv.setAttribute("r", 5);
  rcv.setAttribute("fill", ieee.red);
  svg.appendChild(rcv);
  const rcvLbl = document.createElementNS("http://www.w3.org/2000/svg", "text");
  rcvLbl.setAttribute("x", cx + 8); rcvLbl.setAttribute("y", cy - 8);
  rcvLbl.setAttribute("font-size", "10"); rcvLbl.setAttribute("fill", ieee.red);
  rcvLbl.textContent = "Receiver";
  svg.appendChild(rcvLbl);

  // Satellite positions (angles in radians from center, within sky dome)
  const satColors = [ieee.blue, ieee.teal, ieee.orange, ieee.purple];
  const initAngles = [0, Math.PI/2, Math.PI, 3*Math.PI/2];
  const initR = [skyR * 0.6, skyR * 0.7, skyR * 0.5, skyR * 0.65];

  const sats = initAngles.map((a, i) => ({
    x: cx + initR[i] * Math.cos(a),
    y: cy + initR[i] * Math.sin(a),
    color: satColors[i],
    id: i + 1
  }));

  // Lines from receiver to satellites
  const lines = sats.map(s => {
    const line = document.createElementNS("http://www.w3.org/2000/svg", "line");
    line.setAttribute("x1", cx); line.setAttribute("y1", cy);
    line.setAttribute("x2", s.x); line.setAttribute("y2", s.y);
    line.setAttribute("stroke", s.color); line.setAttribute("stroke-width", 1);
    line.setAttribute("stroke-dasharray", "4,3"); line.setAttribute("opacity", 0.5);
    svg.appendChild(line);
    return line;
  });

  // Satellite circles (draggable)
  const circles = sats.map((s, i) => {
    const g = document.createElementNS("http://www.w3.org/2000/svg", "g");
    g.style.cursor = "grab";
    const circ = document.createElementNS("http://www.w3.org/2000/svg", "circle");
    circ.setAttribute("cx", s.x); circ.setAttribute("cy", s.y); circ.setAttribute("r", 14);
    circ.setAttribute("fill", s.color); circ.setAttribute("stroke", "#fff"); circ.setAttribute("stroke-width", 2);
    g.appendChild(circ);
    const lbl = document.createElementNS("http://www.w3.org/2000/svg", "text");
    lbl.setAttribute("x", s.x); lbl.setAttribute("y", s.y + 4);
    lbl.setAttribute("text-anchor", "middle"); lbl.setAttribute("font-size", "10");
    lbl.setAttribute("fill", "#fff"); lbl.setAttribute("font-weight", "bold");
    lbl.textContent = "S" + s.id;
    g.appendChild(lbl);
    svg.appendChild(g);
    return { g, circ, lbl };
  });

  // DOP indicator
  const dopText = document.createElementNS("http://www.w3.org/2000/svg", "text");
  dopText.setAttribute("x", cx); dopText.setAttribute("y", 22);
  dopText.setAttribute("text-anchor", "middle"); dopText.setAttribute("font-size", "13");
  dopText.setAttribute("font-weight", "bold");
  svg.appendChild(dopText);

  const dopDesc = document.createElementNS("http://www.w3.org/2000/svg", "text");
  dopDesc.setAttribute("x", cx); dopDesc.setAttribute("y", 37);
  dopDesc.setAttribute("text-anchor", "middle"); dopDesc.setAttribute("font-size", "11");
  svg.appendChild(dopDesc);

  function calcDOP() {
    // Simplified 2D GDOP: based on spread of satellite angles from receiver
    const angles = sats.map(s => Math.atan2(s.y - cy, s.x - cx));
    angles.sort((a, b) => a - b);
    let maxGap = 0;
    for (let i = 0; i < angles.length; i++) {
      const next = (i + 1) % angles.length;
      let gap = angles[next] - angles[i];
      if (gap < 0) gap += 2 * Math.PI;
      if (gap > maxGap) maxGap = gap;
    }
    // Also compute average distance from center (elevation proxy)
    const avgDist = sats.reduce((s, sat) => s + Math.sqrt((sat.x-cx)**2 + (sat.y-cy)**2), 0) / sats.length;
    const spreadFactor = maxGap / Math.PI; // 0 = perfect spread, 2 = all clustered
    const dop = 1 + spreadFactor * 4 + (1 - avgDist / skyR) * 2;
    return Math.max(1, Math.min(10, dop));
  }

  function updateDOP() {
    const dop = calcDOP();
    let quality, color;
    if (dop < 2) { quality = "Ideal"; color = ieee.teal; }
    else if (dop < 4) { quality = "Good"; color = ieee.blue; }
    else if (dop < 6) { quality = "Moderate"; color = ieee.orange; }
    else { quality = "Poor"; color = ieee.red; }

    dopText.textContent = `GDOP: ${dop.toFixed(1)}`;
    dopText.setAttribute("fill", color);
    dopDesc.textContent = `Quality: ${quality} -- Position uncertainty x${dop.toFixed(1)}`;
    dopDesc.setAttribute("fill", color);

    sats.forEach((s, i) => {
      lines[i].setAttribute("x2", s.x);
      lines[i].setAttribute("y2", s.y);
      circles[i].circ.setAttribute("cx", s.x);
      circles[i].circ.setAttribute("cy", s.y);
      circles[i].lbl.setAttribute("x", s.x);
      circles[i].lbl.setAttribute("y", s.y + 4);
    });
  }

  // Drag handling
  let dragIdx = -1;
  let svgPt = null;

  function getMousePos(evt) {
    const rect = svg.getBoundingClientRect();
    return {
      x: (evt.clientX - rect.left) * (width / rect.width),
      y: (evt.clientY - rect.top) * (height / rect.height)
    };
  }

  svg.addEventListener("pointerdown", (evt) => {
    const pos = getMousePos(evt);
    for (let i = 0; i < sats.length; i++) {
      const dx = pos.x - sats[i].x, dy = pos.y - sats[i].y;
      if (dx*dx + dy*dy < 20*20) {
        dragIdx = i;
        svg.style.cursor = "grabbing";
        svg.setPointerCapture(evt.pointerId);
        break;
      }
    }
  });

  svg.addEventListener("pointermove", (evt) => {
    if (dragIdx < 0) return;
    const pos = getMousePos(evt);
    const dx = pos.x - cx, dy = pos.y - cy;
    const dist = Math.sqrt(dx*dx + dy*dy);
    const clampDist = Math.min(dist, skyR - 16);
    const angle = Math.atan2(dy, dx);
    sats[dragIdx].x = cx + clampDist * Math.cos(angle);
    sats[dragIdx].y = cy + clampDist * Math.sin(angle);
    updateDOP();
  });

  svg.addEventListener("pointerup", () => {
    dragIdx = -1;
    svg.style.cursor = "default";
  });

  updateDOP();
  container.appendChild(svg);

  const hint = document.createElement("div");
  hint.style.cssText = `font-size: 11px; color: ${ieee.gray}; text-align: center; margin-top: 4px;`;
  hint.textContent = "Drag satellites to see how geometry affects position accuracy. Spread them out for lower DOP (better accuracy).";
  container.appendChild(hint);

  return container;
}

11.14 Knowledge Check

Quiz: GPS Fundamentals

11.15 Worked Example: GPS Accuracy for IoT Fleet Tracking

Worked Example: Calculating GPS Position Fix Time and Accuracy for a Cold-Chain Delivery Fleet

Scenario: A pharmaceutical logistics company tracks 50 refrigerated trucks carrying vaccines across the UK. Each truck has a GPS/GNSS module (u-blox NEO-M9N) reporting position every 30 seconds to a cloud platform. The system must confirm that trucks stay on approved routes and never stop for more than 15 minutes in unauthorized locations.

Given:

• Module: u-blox NEO-M9N (multi-constellation: GPS + Galileo + GLONASS + BeiDou)
• Cold start time-to-first-fix (TTFF): 24 seconds
• Hot start TTFF: 2 seconds (ephemeris data cached)
• Reported accuracy (open sky): 1.5 m CEP (circular error probable – 50% of fixes within 1.5 m)
• Reported accuracy (urban): 2.5 m CEP
• Power consumption: 25 mA active, 7 uA backup mode

Step 1: Calculate position updates per day per truck

• Reporting interval: 30 seconds
• Driving time per day: ~8 hours = 28,800 seconds
• Fixes per truck per day: 28,800 / 30 = 960 position reports
• Fleet total: 50 trucks x 960 = 48,000 reports/day

Step 2: Assess accuracy for route compliance

• UK motorway lane width: 3.65 m
• Required accuracy to distinguish lanes: < 2 m
• Open-sky highway accuracy (1.5 m CEP): Sufficient for lane-level tracking
• Urban delivery accuracy (2.5 m CEP): Can distinguish which side of road, but not individual lane
• Decision: Use geofencing with 10 m buffer zones around approved routes (well within accuracy)

Step 3: Calculate cold start impact on first morning report

• Truck starts at 6:00 AM after 12-hour overnight shutdown
• GPS ephemeris data expires after 4 hours – this is a cold start
• Cold start TTFF: 24 seconds to acquire 4+ satellites
• First valid position report: 6:00:24 AM (24-second blind spot)
• Mitigation: Keep GPS in backup mode (7 uA) overnight to maintain hot start capability
• With backup mode: First fix in 2 seconds, data current from 6:00:02 AM

Step 4: Calculate power budget for backup mode

• Backup current: 7 uA = 0.007 mA
• Overnight duration: 12 hours
• Energy for backup: 0.007 mA x 12 h = 0.084 mAh (negligible – truck battery is 60,000+ mAh)
• Trade-off: 0.084 mAh buys 22-second faster first fix – always worth it for vehicle-powered devices

Result: Fleet tracking achieves 1.5-2.5 m accuracy with 30-second reporting intervals. Hot start mode eliminates the 24-second morning blind spot for just 0.084 mAh overnight. The 10 m geofence buffer accommodates worst-case urban accuracy while reliably detecting route deviations.

Key Takeaway

GPS is an inverted TDoA system where satellites broadcast synchronized time signals and receivers calculate position from pseudoranges. Four satellites are the minimum (3 position unknowns + 1 clock offset), but more satellites improve accuracy through overdetermined solutions. The system’s fundamental insight is treating the receiver’s cheap clock offset as a solvable unknown rather than requiring expensive atomic clocks in every device. The biggest practical limitations are multipath (signal reflections in cities) and the inability to work indoors due to signal attenuation through building materials.

For Kids: Meet the Sensor Squad!

GPS is like playing Marco Polo with satellites in SPACE!

11.15.1 The Sensor Squad Adventure: Messages from Space

“How does my phone know where I am?” asked Lila the LED one day, staring at the blue dot on a map.

Sammy the Sensor knew the answer. “There are 24 special satellites orbiting Earth, way up in space – about 20,000 kilometers high! Each one is basically shouting ‘I AM HERE and the time is 3:00:00.000000!’”

“But how does that help?” asked Lila.

“Imagine you’re blindfolded in a big park,” said Max the Microcontroller. “Three friends stand in different spots and each one shouts ‘I’m 50 meters from you!’ or ‘I’m 30 meters from you!’ With three distances, there’s only ONE spot where you could be standing!”

“That’s TRILATERATION!” cheered Bella the Battery. “GPS works the same way, but instead of friends shouting, it’s satellites sending time signals. Your phone calculates how far each satellite signal traveled by how long it took to arrive.”

“But here’s the tricky part,” said Sammy. “Radio signals travel at the SPEED OF LIGHT – 300,000 kilometers per second! That is SO fast that if your phone’s clock is off by just ONE MILLIONTH of a second, it is wrong by 300 meters!”

“That’s why we need a FOURTH satellite!” explained Max. “Three satellites tell us where we are, and the fourth one helps us figure out exactly what time it is. The satellites have super-expensive atomic clocks that cost $100,000 each, but our phones can figure out the right time by using math!”

“So GPS is really about TIME, not just PLACE!” realized Lila.

“Exactly! And the satellites are so far away that their signals are incredibly weak when they reach us. That is why GPS does not work inside buildings – the signals cannot get through walls and ceilings!”

11.15.2 Key Words for Kids

Word	What It Means
Satellite	A special machine orbiting Earth in space that sends time signals to GPS receivers
Speed of Light	The fastest speed in the universe – 300,000 km per second! GPS signals travel this fast
Atomic Clock	A super-accurate clock on satellites that loses less than 1 second in a MILLION years
Pseudorange	A distance measurement that is slightly wrong because your phone’s clock is not perfect

Concept Relationships

GPS and Outdoor Positioning connects to:

• Time Synchronization - GPS provides global time reference (stratum 0)
• RF Propagation - Understanding ionospheric and tropospheric signal delays
• Sensor Fusion - GPS outdoors + Wi-Fi/BLE indoors for seamless positioning
• Location Awareness Fundamentals - WGS84 datum and geographic coordinate conversion
• Kalman Filtering - Smoothing GPS position estimates over time

See Also

GPS Technology Deep Dives:

• IS-GPS-200 - GPS Interface Specification (official signal structure document)
• Navstar GPS User Equipment Introduction - DoD GPS primer
• u-blox GPS Compendium - Practical GPS module integration guide

Enhancement Technologies:

• DGPS and RTK - Differential corrections for sub-meter accuracy
• SBAS Systems - WAAS (US), EGNOS (EU), MSAS (Japan) augmentation
• PPP (Precise Point Positioning) - Cloud-based corrections

Alternative GNSS:

• GLONASS (Russia) - 24 satellites, global coverage
• Galileo (EU) - 30 satellites, higher accuracy than GPS
• BeiDou (China) - Regional and global constellation
• Multi-GNSS receivers - Use all constellations for better accuracy and availability

Match: Key Concepts

Order: Process Steps

11.16 Navigation

Previous	Up	Next
Location Fundamentals	Accessibility	GPS Accuracy

Common Pitfalls

1. Assuming cold start time is negligible for IoT applications

A GPS receiver with no cached satellite data (cold start) requires 30-60 seconds to acquire a first fix. IoT applications where location is needed immediately after power-on (asset tracking, emergency response) must use assisted GPS (AGPS) to pre-load almanac data via cellular, or maintain periodic fixes to keep the receiver warm. Designing without accounting for cold start time causes user experience failures when the device is first powered on in a new location.

2. Using GPS for power-sensitive battery IoT devices without duty cycling

A continuously active GPS module draws 20-50 mA – enough to drain a 2000 mAh battery in 40-100 hours. For asset tracking IoT devices requiring weeks or months of battery life, duty-cycle the GPS receiver: fix position every 5-30 minutes, then immediately power off. Some applications can tolerate dead reckoning (estimating position from last known fix + velocity) between GPS updates to extend battery life while maintaining location continuity.

3. Trusting GPS altitude values for IoT elevation applications

GPS horizontal accuracy (3-10 meters) is significantly better than vertical accuracy (10-30 meters) because satellite geometry is inherently better in the horizontal plane. IoT applications that need elevation for flood monitoring, building floor detection, or drone altitude control cannot rely on GPS vertical accuracy. Use barometric pressure sensors (accurate to 1-2 meters indoors) for elevation, with GPS providing horizontal position only.

Label the Diagram

11.17 What’s Next

If you want to…	Read this
Understand GPS accuracy enhancement including DGPS and RTK	GPS Accuracy and Enhancement
Implement indoor positioning when GPS is unavailable	Indoor Positioning Systems
Understand all location technologies in a unified overview	Location Awareness Overview
Design location privacy controls for GPS-equipped IoT devices	Location Privacy and Consent
Integrate GPS location into IoT interface map displays	Interface and Interaction Design

💻 Code Challenge

Order the Steps

Match the Concepts