TLDR: RTK fixing is the process of resolving carrier phase ambiguities to achieve centimeter-level positioning accuracy. Initial time synchronization and pre-processing deliver clean GNSS measurements to the navigation engine, and the engine combines them with other sensor measurements to maintain an accurate position. However, even with RTK corrections, pseudorange measurements remain accurate to only about 1 meter. Carrier phase measurements offer millimeter-level precision, but they’re ambiguous, meaning you don’t know which cycle of the sine wave you’re measuring. RTK fixing algorithms resolve that ambiguity by constraining the search space, how systems maintain fix during signal loss, and what differentiates production-grade implementations from research prototypes.
Standard GNSS positioning delivers meter-level accuracy. For many applications, knowing your position within a meter or two is sufficient. But robotics, autonomous vehicles, and precision agriculture require centimeter-level accuracy, which requires a different approach.
The challenge comes down to measurement types. Your GNSS receiver provides two ways to measure the distance to satellites: pseudorange and carrier phase.
This post explains how RTK fixing algorithms resolve the ambiguities for incoming carrier phase measurements, how production systems maintain centimeter accuracy when signals drop, and what separates reliable implementations from research prototypes.
Here is how we’ll tackle this topic below:
- Pseudorange vs. carrier phase
- The ambiguity problem
- Multi-sensor constraints
- Holding the fix
- Real-time implementation
- Evaluating production systems
Pseudorange: Slow, Easy to Track, Inherently Noisy
Pseudorange measurements come from tracking a signal’s unique code sequence, which is modulated on top of an underlying carrier signal (sine wave). The receiver compares the incoming code against its own internal replica, measuring how much the received signal is delayed to determine the signal travel time, which translates directly into distance. The code is slow, easy to track, and straightforward to interpret, but inherently noisy. Pseudorange measurements are affected by unpredictable sources of error like thermal noise and multipath (signals bouncing off nearby trees, buildings, and other obstacles).
Some signals’ codes repeat, usually once a millisecond or so. They do have an ambiguity, but it spans hundreds of thousands of meters. The signals have built-in features that allow receivers to resolve that ambiguity without outside help, and some codes never repeat at all. So while code ambiguity exists in theory, it isn’t a practical problem.
Even after applying RTK corrections to cancel the more observable sources of error, such as satellite clock and position prediction errors (ephemeris) and atmospheric effects like ionospheric and tropospheric delay, about 1-2 meters of uncertainty remains. Most of that comes from tracking errors. Without RTK, that uncertainty is even larger, since depending on what other information the receiver has, some or all of those observable errors will still be present. This is why standard GNSS delivers only meter-level accuracy.
Carrier Phase: Precise but Ambiguous
Carrier phase measurements offer something better: millimeter-level precision. Instead of the slow and noisy code, the receiver tracks the much faster sine and cosine components of the roughly 1.1-1.6 GHz carrier frequency itself. GNSS signals are transmitted on multiple frequencies, including L1 (1575.42 MHz), L2 (1227.60 MHz), and L5 (1176.45 MHz), with L6 used less commonly. Higher frequency means smaller wavelength. A carrier tracking loop can pinpoint the signal much more precisely than a code tracking loop, to within a small fraction of a wavelength (19-25 cm depending on frequency).
The problem is ambiguity. Your receiver can measure that you’re 0.3 cycles into some carrier cycle with millimeter precision. But it cannot determine which cycle you’re measuring. Are you at cycle 10,000,000 or cycle 10,000,001? Or maybe 10,500,000? A single cycle difference represents 19 centimeters of error, and satellites are millions of cycles away.
Unfortunately, you cannot get that answer from the code alone. Take GPS C/A (coarse/acquisition) code as an example. It’s made up of values called chips, which are what the receiver tracks to produce pseudorange measurements. In a single C/A chip, there are 1.54 million carrier cycles. Even after using the signal’s built-in information to determine which chip is which, the tracking loop can only locate the edge of that chip to within a meter or two typically. Even applying RTK corrections to eliminate most other sources of error still leaves 5-10 carrier cycles to choose from for just one signal on one satellite.
Five to ten cycles may not sound difficult. But scale that to 20-40 satellites in the sky, with 2 or 3 signals on separate frequencies for each satellite, and that small search quickly becomes a giant exponential puzzle.
This is the RTK fixing problem: determining the correct integer cycle count for each signal simultaneously, so you can use the precise carrier phase measurements instead of noisy pseudorange measurements.
Solve the puzzle correctly and you achieve centimeter-accurate position. Solve it incorrectly and your system reports high confidence while being off by several meters.
The Ambiguity Problem in Detail
Your receiver knows the carrier phase has changed by 1,247.3 cycles since it started tracking this satellite.
What your receiver doesn’t know is whether the starting point was cycle 52,631,578, cycle 52,631,579, or some other number entirely. Being wrong by just one cycle means your position estimate for that satellite is off by 19-25 cm. This is the ambiguity.
That single measurement then has to combine with all the other satellite measurements. What if some of those are wrong too? How do you determine the right answer?
Why This Matters for Positioning
If you knew there were exactly 100 million L1 wavelengths between the satellite and your antenna, you could calculate the exact range: 100,000,000 × 19 cm = 19,000 kilometers, without any ambiguity.
Resolving this correctly for enough satellites allows you to triangulate your position with minimal error. If your carrier tracking error is just 0.5 cm (3% of an L1 wavelength), that translates directly into a very accurate position.
Being wrong by one cycle means your range measurement is off by 19 centimeters. Being wrong by five cycles puts you off by nearly a meter. Combining errors across multiple satellites means your position estimate could be wrong by meters, even while the system reports high confidence.
The Search Space Challenge
The size of the search space depends on what you already know about your position when you start fixing.
Completely unconstrained, with no idea where you are, the number of possible cycle counts for a single satellite is in the millions. A satellite roughly 19,000 kilometers away represents about 100 million cycles of the 19-centimeter wavelength.
In practice, you’re not starting from nothing. The pseudorange measurements give you an initial rough position estimate. With that constraint, the unknown cycle count for each satellite shrinks dramatically, often to hundreds or thousands of possibilities rather than millions.
But even with that initial constraint, scaling up across all satellites in view creates a problem too large for brute-force search.
One satellite might have hundreds or thousands of possible cycle counts. With 8, 10, 12, or 15 satellites visible, and 2-3 frequencies per satellite, the combinatorial explosion makes testing every combination computationally impossible in real-time.
A naive approach might try to solve each satellite independently or test random combinations until one fits. Both approaches fail in practice because the search space remains too large for real-time operation.
Narrowing the Search: How RTK Fixing Actually Works
Multi-sensor integration provides the constraints needed to solve this problem.
Using Pseudorange as the First Constraint
The positioning engine combines information from multiple sources: pseudorange from GNSS, IMU measurements, wheel speed data, other sensors like cameras and LIDAR, and the engine’s own prior position estimates.
This information feeds into the RTK fixing algorithm, dramatically reducing the search space. Instead of an exponential number of possible combinations, there’s a narrow range of values most likely to be correct for each satellite. The more accurate the engine’s position estimate is when entering the fixing process, the smaller the search space becomes.
Pseudorange is accurate to about 1 meter after RTK corrections. One meter equals about 5 carrier phase cycles at 19 centimeters per wavelength.
Instead of searching all possible cycle counts unconstrained, you search a window of perhaps 10 cycles centered on what pseudorange suggests.
Other Information Sources
Pseudorange isn’t the only constraint. The navigation filter provides a position estimate indicating approximately where you are. Computer vision might contribute location information. Wheel speeds and IMU indicate how you’ve moved since the last fix.
The search space shrinks from an exponential combination of possibilities to a manageable window. While still computationally demanding, the algorithm can now converge to the correct answer within real-time constraints.
Once the algorithm resolves the ambiguities, you hold your fix.
Holding the Fix: Accumulated Range Tracking
Once the positioning engine determines the starting cycle count, it knows the precise range to that satellite and maintains that knowledge as long as the signal stays locked.
How It Works
Carrier phase tracking has two components. First, the receiver continuously measures the accumulated change in carrier phase with millimeter precision, called accumulated range tracking.
Second, there’s the unknown initial cycle count, the number the RTK fixing algorithm had to solve for.
Once you determine that initial number, you have the complete picture. The unknown offset plus the precisely-tracked changes equals the exact range.
What Changes vs What Doesn’t
The initial cycle count doesn’t change. Even as you move and satellites orbit, that integer offset remains constant. What changes is the accumulated range, the additional cycles as the distance between you and the satellite varies. The receiver measures this very precisely.
Once the algorithm resolves the ambiguity, it locks in that solution without needing to re-solve. The system now has centimeter-level range measurements updating at 10 Hz, 20 Hz, 50 Hz, or 100 Hz depending on your configuration.
With enough satellites fixed, the position solution maintains centimeter-level precision continuously.
When RTK Fix Breaks
RTK fix doesn’t persist indefinitely.
Drive under a bridge and the signal from one satellite drops for half a second, losing that satellite’s carrier phase lock. Enter a tunnel and complete signal loss occurs, losing lock on all satellites.
In an urban canyon, a building blocks three satellites, leaving seven visible. This may or may not be enough to maintain fix on the remaining satellites.
When you lose lock on a satellite’s carrier phase, the positioning engine must re-resolve the ambiguity for that satellite.
If enough other satellites maintain fix, your position degrades but doesn’t fail. You continue receiving centimeter-level updates from the satellites you haven’t lost.
If too many satellites lose lock, you drop from RTK fix to a float solution. You’re using carrier phase measurements but haven’t resolved the ambiguity yet. Position accuracy degrades to tens of centimeters or meters depending on conditions.
Cycle Slips
Even without complete signal loss, carrier phase tracking can slip. The receiver loses count of a few cycles due to interference or a momentarily weak signal.
Pre-processing detects these cycle slips. Cycle slip monitoring looks for discontinuities in the accumulated carrier phase. When detected, that satellite needs its ambiguity re-resolved.
Re-Fixing Performance Matters
Several questions determine whether your system works in production environments or only in open-sky test tracks:
How quickly can you re-acquire a fix after exiting a tunnel? Can you maintain a fix through intermittent tree cover? How many satellites do you need visible to achieve fix, and can you work with six satellites or do you need twelve?
The difference between research systems and production systems is often measured in time to re-fix and robustness under partial satellite visibility.
What helps re-fixing performance:
Multi-sensor fusion. IMU and wheel speeds maintain position estimates during GNSS outages. When satellites return, the positioning engine has tight constraints on where to search for ambiguity resolution. Point One’s positioning engine uses this multi-sensor context to re-fix faster than GNSS-only systems.
Algorithm sophistication. Advanced RTK fixing algorithms use statistical methods to identify the most likely ambiguity candidates quickly. Less sophisticated implementations may require 30-60 seconds to re-fix. Production-grade systems fix in under 5 seconds.
Satellite visibility management. Tracking more constellations (GPS + GLONASS + Galileo + BeiDou) means more satellites available. Losing three satellites in an urban canyon still leaves 12 others to work with. More satellites means faster fixes and better robustness.
RTK Fixing in the Navigation Filter Context
RTK fixing doesn’t happen in isolation.
The navigation filter provides the position estimate that constrains the RTK fixing search space. The filter combines all sensors (GNSS, IMU, wheel speeds, and others) to narrow the window of possible cycle counts.
Once ambiguities are resolved, the fixed carrier phase measurements feed back into the filter. But how does the algorithm actually resolve the ambiguities?
The algorithm at a high level: RTK fixing uses statistical methods like least-squares estimation to find the integer ambiguities that best fit all available measurements. The algorithm generates candidate solutions (possible sets of cycle counts), evaluates each candidate against the observed data, and selects the solution with the lowest residual error. Advanced implementations use techniques like LAMBDA (Least-squares AMBiguity Decorrelation Adjustment) to efficiently search the space and validate solutions. The math involves matrix operations, covariance analysis, and hypothesis testing, but the goal is straightforward: find the integer cycle counts that make all measurements consistent.
Once resolved, the filter has centimeter-level range measurements instead of meter-level. Position accuracy improves dramatically.
This creates a feedback loop where better fix leads to better position, which leads to better constraints for maintaining fix.
When one satellite loses lock, the filter uses IMU and wheel speeds to maintain position estimate. That maintained position estimate helps re-fix the lost satellite faster when it comes back into view.
Multi-sensor integration isn’t just about combining measurements. It’s about each sensor helping the others perform better.
Real-Time Implementation Challenges
RTK fixing must happen quickly: within seconds of startup and within seconds of re-acquisition after signal loss.
Why speed matters: Autonomous vehicles make navigation decisions in real-time. A delivery robot navigating a warehouse cannot wait 60 seconds for RTK fix before moving safely. An agricultural robot in a field needs centimeter accuracy immediately to avoid crop damage. Time to fix directly impacts system usability. Long initialization times mean operators wait, and long re-fix times after signal loss mean extended periods of degraded accuracy.
Different use cases have different requirements. Static surveying applications can wait minutes for ambiguity resolution. Mobile robotics, autonomous vehicles, and UAVs need fixes in under 10 seconds for practical operation. High-speed applications like racing or precision agriculture during planting season need even faster re-fix, ideally under 3 seconds.
You cannot spend a minute searching for the right ambiguity resolution while your autonomous vehicle makes navigation decisions. You need to fix quickly or fall back to lower-accuracy modes gracefully.
Computational Constraints
On embedded systems, processing power is limited. You’re sharing CPU with the rest of the navigation stack: measurement modeling, filter updates, dynamics propagation, and output generation.
The RTK fixing algorithm needs to run in real-time on your target hardware. This constrains how thorough your search can be, creating trade-offs between search comprehensiveness and time to fix.
A well-designed RTK fixing implementation balances computational efficiency with fix reliability, using smart search strategies to converge quickly without sacrificing accuracy.
Validation and Confidence
How do you verify you have the correct answer?
The positioning engine runs statistical tests to validate ambiguity resolution, evaluating whether the chosen solution is significantly better than alternative candidates.
What these tests check: Did the algorithm converge to a clear winner, or are there multiple plausible solutions with similar residual errors? Is the residual error small enough to indicate a correct fix? Are the candidate solutions well separated, meaning the correct answer stands out clearly from wrong answers?
Why this matters: High confidence in the wrong answer is worse than acknowledging uncertainty. If the algorithm reports “fixed” with high confidence but chose the wrong cycle counts, your position could be off by meters while the system believes it’s accurate to centimeters. False fixes are dangerous in safety-critical applications.
The positioning engine needs confidence metrics to decide whether the fix is reliable enough to use, whether to wait for more data, or whether to report float solution instead.
Production systems report fix quality scores, not just binary fixed/float status. Downstream autonomy software can make better decisions when it knows fix confidence, perhaps slowing down when fix quality is marginal rather than blindly trusting a low-confidence fix.
Partial Fix Scenarios
Sometimes you can fix on some satellites but not others. Perhaps you have good geometry on eight satellites and resolve their ambiguities, while three other satellites have poor geometry or higher noise that prevents confident resolution.
Can your system use the partial fix? Production systems can. They use the eight fixed satellites for improved position while continuing to work on the remaining three. This provides better accuracy than pure float solution, even without a full fix.
Graceful degradation matters. Binary fixed/float is a research artifact. Real-world systems operate across a spectrum: 12 satellites fixed (best), 8 fixed + 4 float (very good), 6 fixed + 6 float (acceptable), all float (degraded but usable), no fix (fall back to GNSS + IMU dead reckoning).
Point One’s positioning engine handles these scenarios intelligently, using whatever information is available, reporting confidence accurately, and degrading gracefully rather than failing catastrophically.
Questions Worth Asking
If you’re building or evaluating a positioning system, specifically regarding RTK fixing capabilities:
- How long from startup to RTK fixed position? Two seconds? Ten seconds? Thirty seconds? Time to first fix determines how quickly your system is useful after power-on.
- How quickly do you re-acquire after signal loss? If you drive through a tunnel, how long until you’re back to centimeter accuracy on the other side? This determines usability in urban environments.
- Can you maintain fix with partial satellite visibility? Do you need twelve satellites or can you work with six? Urban canyons and tree cover create challenging visibility conditions.
- What’s your fix success rate in downtown or ‘urban canyon’ environments? Open-sky performance is table stakes. Downtown performance matters for autonomy and robotics deployments.
- Do you report fix quality or just binary fixed or float? Confidence metrics help downstream systems make better decisions. Binary state reporting hides uncertainty.
- How quickly do you detect and recover from cycle slips? Can you recover without dropping fix entirely? Cycle slip recovery speed affects continuity in challenging RF environments.
- Do you fix across multiple constellations? GPS-only, or GPS + GLONASS + Galileo + BeiDou? More satellites provide more redundancy and faster fixes.
What’s Next
RTK fixing delivers centimeter-accurate range measurements. The navigation filter combines them with IMU, wheel speeds, and other sensors. But there’s more to the navigation stack.
How does the system handle different vehicle dynamics? Why do cars, drones, and robots need different models? What happens when your IMU drifts in temperature or your wheel diameter changes with tire pressure?
In the next post, we’ll cover dynamics modeling, sensor error learning, and how the navigation filter adapts to different platforms and deployment environments.
Getting centimeter-level measurements is only half the problem. Maintaining that accuracy as sensors drift and environments change is the other half.
This is Part 4 of our series on positioning system architecture. Part 1 covered time synchronization. Part 2 covered pre-processing and sensor strategy. Part 3 covered the navigation engine and sensor fusion.
Try our RTK Network for free
Start your free trial