Feature Request: Dual-Engine Verified RTK Module for Facet FP

I am a professional land surveyor and have been looking closely at the modular architecture of the new Facet FP series. One feature I think could be an excellent fit for this platform would be a dual-engine GNSS module designed specifically for independent RTK solution verification.

The user-replaceable GNSS engine is what makes the Facet FP particularly interesting for this concept. Rather than redesigning the entire receiver, it seems possible that a future engine module could contain two independent high-precision GNSS engines and perform the comparison internally before passing the final position through the existing Facet FP architecture to the field controller.

My preferred combination would be something similar to:

Primary engine: Septentrio mosaic-X5
Verification engine: u-blox ZED-X20P

The intent would not initially be to average or blend the two coordinates.

Instead, each engine would independently calculate its own RTK solution from the same antenna and correction stream. An onboard verification processor would compare the independent results before reporting the position as trusted.

A Verified Fix could require conditions such as:

  • Both GNSS engines independently report RTK Fixed
  • Correction age is below a user-defined maximum
  • Both engines report acceptable solution precision
  • Horizontal coordinate disagreement remains below a user-defined tolerance
  • Vertical disagreement remains below a separate tolerance
  • Agreement persists for a specified number of epochs

The system could then report three meaningful integrity states:

RTK Fixed – an RTK solution exists

Verified RTK Fixed – both independent engines are fixed and agree within tolerance

Fix Conflict – one or both engines report Fixed, but the independently calculated positions do not agree within the specified tolerance

For professional surveying, I believe the Fix Conflict condition could be extremely valuable.

In difficult canopy or multipath environments, obtaining an RTK Fixed solution is often not the biggest problem. The larger concern is determining whether a marginal Fixed solution can actually be trusted.

I have encountered field conditions where a receiver continues to report RTK Fixed beneath tree canopy, yet independent occupations of the same point can differ by substantially more than normal survey tolerance. A second independent RTK architecture could provide another layer of integrity checking before an incorrect Fixed solution reaches the field controller.

Using two different manufacturers’ engines seems preferable to using two identical engines because their tracking, satellite weighting, multipath mitigation, quality control, and ambiguity-resolution algorithms would be independently developed.

The mosaic-X5 could remain the primary positioning engine, while the second engine serves primarily as an independent verification source.

I recognize that both engines would likely share the same antenna and correction stream, so correlated errors would still be possible. This would not replace normal survey checks or independent occupations. The goal would simply be to add another meaningful integrity layer between “RTK Fixed” and “position trusted.”

The economics also seem unusually favorable for the Facet FP platform. Professional surveyors are accustomed to complete GNSS rover systems costing well into five figures. Even if a premium dual-engine module materially increased the cost of the Facet FP, it could still represent tremendous value if it provided meaningful protection against false or biased RTK fixes.

The modular FP architecture seems particularly well suited to this because the verification technology could potentially exist entirely in an interchangeable GNSS engine module while retaining the existing receiver body, tilt system, LoRa radio, batteries, communications, and field-controller interface.

I would be very interested to hear whether something like this is technically feasible within the current Facet FP engine interface, particularly regarding:

  • Power availability for two GNSS engines
  • RF splitting from the existing GNSS antenna
  • Available interface bandwidth
  • Whether the verification processor could reside on the engine module
  • Whether a Verified Fix / Fix Conflict state could be exposed through the existing firmware and NMEA output

I think this could create a very compelling premium professional-surveying option while remaining completely consistent with the upgradeable philosophy of the Facet FP platform.

@whiley9 , that is a very interesting proposal.

I have nothing more to add since you covered it so perfectly…except a +1 from me :wink:

I think this is a good, fun discussion, but I’m not convinced it makes business sense. Let’s cover the technical questions first:

Power availability for two GNSS engines

The FP has plenty of additional power and battery run time.

RF splitting from the existing GNSS antenna

Splitting the signal will degrade it slightly, but the antenna and amplifiers are already so good, I don’t foresee any issues.

Available interface bandwidth

I’m not sure what this is. Do you mean ‘does the main system processor have the available processing bandwidth’? Yes.

Whether the verification processor could reside on the engine module

This gets a bit funky, but yes maybe? It depends on how we solve it, but we could either put a verification processor in front of the two engines, or just let the two engines talk to the main processor and let the main processor do the decision making.

Whether a Verified Fix / Fix Conflict state could be exposed through the existing firmware and NMEA output

Again, very doable, but the NMEA standard doesn’t begin to cover this. We would need to create custom sentences and send these, along with one? both? of the NMEA reports from the two engines.

The challenges:

  • It may make sense to do the two GNSS receivers with one processor so that we retain the UARTs on the Flex module. Yes, workable, but oh what a beast of a module it would be! Large, possibly hot.
  • If the dual-flex module output a custom NMEA message such as “$GNTXT,Engines Disagree*4A”, no GIS app would understand it or do anything with it other than dropping it in the bin. We could certainly pass out the NMEA from one of the engines to the GIS app so that the user still got some sort of position info, but how do we let the user know there is a conflict? Custom messages necessitate a custom GIS app, which we are very heasitant to do.
  • The cost. Are customers really prepared to pay $4,000 or more for a dual engine FP?
  • Complexity add. If we are adding a decision processor to the flex module, that’s yet-another-subsystem to code and maintain. I’m mostly just complaining.
  • Configuration. We would need a way for the main processor (ESP32 on the mainboard of the FP) to configure the decision processor (likely a STM32). Hmm. Or perhaps the ‘decision’ processor is just a dumb combinator: it reads in receiver 1 GGA and changes into G1GGA and receiver 2 GGA into G2GGA, etc. Then letting the main processor parse it out. Yea, that would be simple enough. And reduces the need for code updates on the combination process.
  • Configuration of the engines. We rely on having the main processor be able to configure the GNSS receiver. If we put a combination processor in the middle, that makes configuring the GNSS receivers very difficult. Ugh, and the settings. We would need to maintain two sets of settings. Again, it’s just code, but that’s a lot.

If we’re brainstorming, why limit ourselves to two engines? Three systems are often used in life-safety environments (think train control, or space shuttles). The additional electrical and code are fairly minimal to go from two to three engines.

Professional surveyors are accustomed to complete GNSS rover systems costing well into five figures.

Can you point me at specific model numbers that I can research?

This idea does interest me! Thank you for proposing it. I’m not convinced it’s something we can pursue, but we’re listening.

Thank you for the detailed and quick response. This is exactly the kind of technical feedback I was hoping for, and it sounds like there is not necessarily a fundamental hardware limitation preventing the concept. The larger questions seem to be implementation complexity and whether there is enough professional-market demand to justify it.

On the pricing question, yes, I do think there is a professional surveying market that would be prepared to pay $4,000 or more for an FP if the additional cost provides a meaningful increase in confidence under difficult conditions.

For context, professional GNSS receivers such as the Carlson BRx7 and newer Viking are sold in roughly the five-figure-per-rover market. Current dealer pricing puts a BRx7 network rover around $13,000 and a Viking rover around $16,000, with complete base/rover systems costing considerably more.

That is the market against which I am comparing this concept, rather than primarily the hobby or GIS receiver market.

Even if a premium Facet FP ultimately cost $4,000–$5,000, a professional surveyor could still be looking at a receiver costing a fraction of the price of some traditional professional GNSS heads.

There is also precedent in the professional surveying market for going beyond the conventional idea that “RTK Fixed” by itself is sufficient indication that a position should be trusted.

Carlson has used its SureFix architecture in the BRx7 for years, where additional processing evaluates the GNSS information and RTK solution to provide another level of confidence in the result.

Their newer Viking takes that philosophy considerably further with dual GNSS RTK modules and three RTK engines in its Triple-Fix architecture, specifically aimed at increasing solution confidence and reducing false fixes.

I mention those products not because I think SparkPNT should duplicate anyone else’s architecture, but because I think they demonstrate that professional surveyors place real value on additional integrity checking beyond a single RTK Fixed indication.

That is also what led me to this idea based on my own field experience.

I currently use a SparkFun Torch. Under difficult tree canopy, I can regularly obtain an RTK Fixed solution where the receiver is indicating what appears to be a tight position, but repeated occupations or checks against known ground positions can sometimes be off by approximately ±0.20 ft.

That is the failure mode that concerns me.

The receiver is not telling me that the solution is uncertain. It is reporting Fixed and often showing tight precision indicators, while the actual ground position can still be wrong enough to matter for professional boundary or construction surveying.

By comparison, when I use the Facet with the Septentrio mosaic-X5 in similar conditions, the results are generally much better and usually remain within approximately 0.10 ft in my experience.

The mosaic-X5’s multipath mitigation and integrity features appear to work extremely well.

In fact, the X5 may already solve enough of this problem that a second engine is unnecessary in most situations.

That changes how I would frame the dual-engine idea.

I would not necessarily use two engines to produce two competing coordinates, average the results, or attempt to determine which engine is “right.”

I would let the mosaic-X5 remain the positioning engine.

The second engine could simply function as an independent gatekeeper.

The normal architecture would effectively be:

mosaic-X5 position → verification gate → existing FP output → field controller

The second GNSS engine would independently calculate its own RTK solution in parallel.

As long as both engines satisfy the agreed verification criteria, the gate remains open and the normal mosaic-X5 NMEA output passes through exactly as it does today.

The field controller never needs to know that a second engine exists.

If the engines no longer agree within the specified criteria, the gate closes.

At that point the FP could stop outputting a valid RTK position, intentionally downgrade the reported solution state, or otherwise prevent the field software from accepting what appears to be a normal Fixed solution.

That seems much simpler to me than requiring GIS or survey software to interpret a new custom verification sentence.

The field software already understands what to do when it does not have a valid Fixed position.

The second engine therefore would not need to provide another position to SurvCE, FieldGenius, SW Maps, QField, or any other application.

Its entire purpose would be to answer one question:

“Do I have sufficient independent evidence to allow the mosaic-X5 position to leave the receiver as a trusted solution?”

For example, the verification gate could require:

  • mosaic-X5 = RTK Fixed

  • verification engine = RTK Fixed

  • correction age acceptable on both

  • reported precision acceptable on both

  • horizontal position difference below a configurable threshold

  • vertical difference below a configurable threshold

  • agreement maintained for a configurable number of consecutive epochs

If all conditions are met:

Gate OPEN → mosaic-X5 output passes normally

If any critical condition fails:

Gate CLOSED → trusted Fixed output is withheld

The FP itself could still provide a red LED, distinctive audible warning, or Web UI status explaining why the gate closed, but third-party field software would not need to understand anything new.

That would seem to substantially reduce one of the concerns you raised about custom NMEA sentences and application compatibility.

From my perspective, I also do not need the system to determine which engine is correct when there is disagreement.

If the mosaic-X5 says one thing and the independent verification engine says something meaningfully different, I do not want the receiver trying to intelligently pick a winner.

I simply want it to stop and tell me:

“Independent verification failed. Do not trust this position yet.”

Then I can change the observation conditions, wait longer, disable tilt, move slightly, take another occupation, switch to conventional methods, or otherwise deal with the questionable point as a surveyor.

This also makes me think two engines may actually be preferable to three for this particular architecture.

Three engines become extremely interesting if the objective is majority voting and automatically selecting a solution.

But I am not necessarily trying to create a voting system.

I am proposing a permission system.

The mosaic-X5 creates the position.

The second independent engine decides whether sufficient agreement exists to allow that position through the gate.

For that purpose I would deliberately choose a different receiver architecture for the verification engine.

For example:

Primary positioning engine: Septentrio mosaic-X5
Verification/gatekeeper engine: u-blox ZED-X20P

The use of two manufacturers would be intentional because their tracking, multipath handling, satellite weighting, ambiguity resolution, integrity monitoring, and RTK quality algorithms have been developed independently.

If both arrive at essentially the same coordinate under difficult conditions, the mosaic-X5 output is allowed through.

If they diverge, the gate closes.

Obviously, because the engines share the same antenna and correction stream, correlated errors remain possible. This would not replace check shots, repeated occupations, conventional surveying procedures, or professional judgment.

It would simply add another independent layer between:

RTK Fixed

and

position allowed to leave the receiver as trusted data.

I also think this framing could simplify the processor architecture.

If the existing FP ESP32 has sufficient capacity and can communicate independently with both GNSS engines, I would prefer the main FP processor to own the verification logic.

That keeps the logic in the main firmware and may eliminate the need for another sophisticated decision processor on the Flex module.

The Flex module would primarily provide the two GNSS engines and whatever basic interface hardware is required to expose both receivers to the main processor.

The FP firmware could then implement the gate criteria and evolve those criteria over time.

Regarding configuration, I would expect the mosaic-X5 to retain all of its normal configuration because it remains the primary receiver.

The second engine could potentially use a much smaller standardized configuration because its role is narrower. It primarily needs:

  • the same correction stream

  • matching constellation/band configuration where practical

  • position output

  • solution status

  • estimated accuracy

  • correction age

  • whatever quality metrics are useful for comparison

It may not need to duplicate every user-facing setting available on the primary X5.

That could reduce some of the configuration burden you mentioned.

The reason this remains attractive to me even if the module becomes physically larger and more expensive is the economics of the professional surveying market.

Professional users routinely purchase GNSS receivers in the $10,000–$16,000-per-head range.

At perhaps $4,000–$5,000 for an FP containing a mosaic-X5, a second independent professional-grade GNSS engine, tilt compensation, LoRa, batteries, communications, and an onboard verification gate, I would still consider it an exceptional value.

And importantly, I am not suggesting the second engine because I think the mosaic-X5 is inadequate.

My experience so far suggests almost the opposite.

The X5’s multipath handling seems to remove a large percentage of the questionable fixes I encounter with less sophisticated receivers.

The second engine would be there for the remaining edge cases—the rare but potentially costly situations where even a very good primary engine reports a convincing Fixed solution that deserves additional scrutiny.

To me, that is where the modular Facet FP architecture creates an interesting opportunity:

Keep the mosaic-X5 as the trusted positioning engine, and use a completely independent second RTK architecture as a simple gatekeeper that decides whether the X5’s position is allowed to pass to the field controller.

That seems like a potentially simpler product than a true multi-engine fused positioning system while still delivering much of the integrity benefit I am looking for.

I love the idea, but I’ll play devil’s advocate for a minute.

  1. We already know to not have confidence in any GNSS solution under tree canopy or multi-path conditions.
  2. If a Mosaic X5 has decided the solution is reasonable, I’m not sure I’d trust what an X20P says.

I do love the concept, but those are my first 2 thoughts.

In the simplest form, would this be comparing ECEF of both solutions against a hard coded threshold (1-2cm as an example)? But what’s basically happening is we are giving 2 independent systems the chance to guess at the AR correctly. If they agree we gain a lot of confidence. If they disagree, we don’t really know much.

Side note: This agreement or disagreement doesn’t have to get exposed to the data collector via GNTXT, etc. It could be as simple as a beep from the FP-“Ultra” during agreement, a green light, etc ? It would function as a normal X5, but with that added local feedback when a 2’nd RTK engine is producing a similar solution.

I think those are both very valid concerns, and I agree that the second receiver probably should not have the authority to reject a Mosaic-X5 solution.

I’m thinking the simplest implementation may actually be exactly what you described: the X5 remains completely authoritative and operates exactly as it does today. The second RTK engine is only there to provide an independent confidence check.

If both engines independently reach RTK Fixed and their positions agree within some defined threshold—1–2 cm as an example—then the receiver could give the user a simple local indication:

Green LED / beep = Independent RTK agreement

If they disagree, nothing necessarily changes. The FP continues operating normally from the X5; you simply don’t get the additional confidence indication.

That eliminates the question of, “Which receiver is right?” We aren’t asking the second engine to determine that. We’re only taking advantage of the occasions where two completely independent ambiguity-resolution systems arrive at essentially the same answer.

To me, the useful information isn’t:

“X20P says the X5 is correct.”

It is:

“Two independent RTK engines, using different algorithms, independently resolved their ambiguities and arrived at essentially the same coordinate.”

I would think that substantially increases confidence in the result, even though it obviously can’t guarantee that both aren’t wrong.

ECEF seems like a very clean way to implement the comparison. Both solutions could simply be converted to ECEF XYZ and the 3D difference calculated. You could potentially have separate horizontal and vertical thresholds rather than one overall 3D threshold as well.

I also agree completely with your first point: under heavy canopy or severe multipath, we should already be suspicious of any GNSS result. I don’t see this as something that suddenly makes a bad environment “safe.” I see it more as giving the surveyor one additional piece of information that we currently don’t have.

Right now, when the X5 reports Fixed under difficult canopy, I still have to ask myself, “Is this actually right?”

With a second independent engine running silently in the background, occasionally the receiver could answer:

“I can’t guarantee it, but another completely different RTK engine independently arrived at the same place.”

That information would have value to me.

And I actually like the idea of keeping it completely local to the receiver. No custom NMEA, no GNTXT requirement, no GIS or data-collector changes. Maybe just:

  • normal FP behavior = X5 solution as usual

  • green LED/beep = second engine independently agrees

  • no indication = verification unavailable or disagreement

That keeps the implementation and user experience very simple.

Worst case, the second engine doesn’t agree and the FP behaves exactly like the X5-based FP does today.

Best case, when working in the difficult environments where I’m most skeptical of a Fixed solution, I occasionally get an additional independent confirmation that I don’t currently have.

I concur 100%.

Another useful example: When I’m cutting a profile for a Highway crossing, I’ll take all the shots for the crossing, then dump the antenna and do it all over again. Or repeat it later in the day, as usually there is other work to do nearby anyway.

Having an independent agreement would be nice on the first round of points, and I might skip the repeat under most scenarios.

I fully agree with this.

Yep. I think the green light/red light simple indication is a good way to go. I’m thinking out loud here:

  • A Flex module with a combination processor has 2 UARTs connected to 2 GNSS receivers. The combo processor combines the two NMEA streams into G1GGA/G2GGA type sentence modifications. The combination processor outputs the combined stream over a 3 UART.
  • That pseudo-custom NMEA stream (G1GGA/G2GGA) is received by the ESP32 main FP processor. The ESP32 detects there is two streams and calculates if the computed locations (ECEF? LLH?) of the two receivers are within X (a configurable distance, say 25mm).
  • If the two locations are within X distance, display an icon, a big check mark or something. We can also beep tones but they can be tricky to hear in a loud construction environment.

We still have the problem of receiver configuration:

  • What if the user wants to disable all constellations but GPS on one receiver but leave the other receiver stock? We’ll need to be able to configure both receivers independently. This is solvable, just complexity.

That sounds like a very practical implementation to me.

I especially like keeping the combination processor relatively dumb and letting the main ESP32 handle the comparison logic. That seems to leave a lot of flexibility for changing thresholds or verification logic later.

ECEF also seems like the cleanest way to compare the two solutions, with a configurable agreement threshold. A large check mark or similar visual indicator would be plenty for me, I wouldn’t need the second engine to veto the X5 or change what gets sent to the data collector.

On configuration, mirroring settings to both receivers by default seems like the simplest user experience, with independent configuration available only as an advanced option if someone specifically wants it.

My one concern would be the small RF loss from splitting a single antenna between two receivers. Even if the loss is minimal, I’d want to make sure it doesn’t hurt more marginal canopy/multipath cases than the second engine helps. Those edge cases are really where I’d want the dual-engine verification most.

I still view the second engine primarily as an added confidence indicator rather than a replacement for normal field verification, but if two completely independent RTK engines both resolve Fixed and independently land within about ±10 mm of each other, that is information I would absolutely want to have.

I think the real question would be whether the added confidence from the second engine outweighs whatever small RF penalty comes from splitting the antenna, particularly in the marginal conditions where this feature would be most useful.

What about the KISS approach at first ? A dedicated USB port for the secondary receiver, so RTK Everywhere doesn’t get touched. IE: Proof of concept would be a standalone MCU that watches both NMEA streams (and it might need to push RTCM to 2’nd receiver), inverses the GGA Fixed solution, and lights up the LED when the delta H and/or delta Z is within the limit ? Something simple to see how reliable, useful, etc, this is. Just brainstorming…:smiling_face_with_sunglasses:

The split would happen after the LNA, so we shouldn’t see much impact.

But on the other side of the coin, I like to use a C/N₀ limit of 30+ anyway, so those problem signals can’t be used in the solution to start with.

Would the Dual-Engine also need Tilt compensation?

I.e. are we talking about combining a mosaic-X5, ZED-X20P and IM19 on a single Flex Module?

It is doable… But it will run warm.

In my head, the architecture could be:

Use the same BP2G1+ RF Power Splitter we used on the ZED-F9P + NEO-D9S Combo Board
mosaic-X5 UART1 (COM1) is connected to ESP32 as normal
IM19 UART1 is connected to ESP32 as normal
IM19 UART2 RX is connected to mosaic-X5 COM4 TX as normal
LoRa / External Radio TX-out is connected to both mosaic UART2 RX and X20P UART2 RX
LoRa / External Radio RX-in is connected to mosaic UART2 TX only
ZED-X20P is connected to ESP32 via I2C

Incoming LoRa corrections would feed both mosaic and X20P simultaneously

Outgoing LoRa corrections would be sourced by mosaic only

IM19 is fed with mosaic NMEA only

We would need to review / test the extra I2C bus traffic. I2C would be carrying NMEA / PVT messages from the X20P, and WiFi/BT RTCM corrections to the X20P.

The X5 is so very clever, it may be possible to: daisy-chain the WiFi/BT RTCM corrections from mosaic COM1 to COM3 (currently unused); use mosaic COM3 to feed corrections to the X20P UART1. This would avoid I2C having to carry corrections to the X20P.

We would need to review / test the BP2G1+ bandwidth. Strictly, L5 is below what the BP2G1+ supports. Mini-Circuits have newer parts which cover all the bands. We’d just need to pick one that provides DC pass-through. The mosaic-X5 would provide power to the active antenna, X20P would not.

Would we need to include a USB Hub on the Flex Module, so that both mosaic and X20P USB are accessible? How much use would this be? Remember that X20P can’t be updated over USB. How would we do firmware upgrades of the X20P? If X20P UART1 is connected to mosaic COM3, would that provide a path? You would need to put the mosaic into COM1-COM3 daisy-chain pass-through, upgrade, then shut down the daisy-chain. It might work? Needs more thought and testing. Ah! X20P upgrade via I2C is supported. Yes, that’s the solution. We have already demonstrated this.

If we decide not to support Tilt and remove the IM19, then the X20P could have its own UART connection to ESP32.

Interesting…

Best wishes,
Paul

ECEF will be a lot easier for the comparison, and provide greater precision. Both devices have a binary protocol for sending ECEF [ PVTCartesian & UBX_NAV_POSECEF ]

In a perfect world, I’d think each device sends their specific binary packet over a dedicated port, to avoid the traffic collisions with the standard NMEA going to the data collector.

Then a ESP just watches both ports/outputs, checks the timestamps, performs the simple cartesian math, and lights an LED.

Since each user configures their Corrections and NMEA out (messages and rates) differently, this feels like a safe direction. Just stay out of the RTK Everywhere FW pipeline completely, for this proposed product…?

Naturally, I’m probably missing something important - but is this direction even possible?

[EDIT] - This post is referring to the scope for testing, not final deployment :slight_smile:

Point taken about ECEF. My “PVT” above was just meant to indicate non-NMEA Position Velocity Time messages. Not necessarily PVTCartesian / PVTGeodetic / UBX_NAV_PVT etc..

Not really… We only have three ESP32 UARTs to play with. One is dedicated to communication with the GNSS UART1. One is dedicated to communication with the IM19 UART1 (if present). One is dedicated to the USB Console.

It is fortunate that the X20P also supports I2C. That’s our “back door” for the verification positioning. But I2C is shared with the OLED, battery fuel gauge, etc.. If we significantly increase the traffic on I2C, we’re asking for trouble.

I’m trying to think of solutions that fit within the UARTs we have available, and don’t cause problems elsewhere.

So the big snag is how to get the RTCM (or any correction service) into the standalone/secondary X20P ?

Thanks for taking the time to explain all of this Paul !

No problem!

Yes, exactly. You can push the RTCM over I2C, we’ve done that previously, but it does choke up the I2C bus. You can also enable messages like NAV_PVT, NAV_HPPOSLLH, NAV_HPPOSECEF on I2C. But, again, it’s extra bus traffic. If there’s a solution that let’s us access the X20P UART1 through the X5, we should test that first.

I might be changing my mind a little bit…

Pretend I had this proposed Facet FP(X5 + X20P) and I’m working in a typical environment. As soon as I’m stable over a point and DONT get the green light for agreement - I’m going to want to know why. My “standalone” theory might cause some major frustration. I will want some feedback from RTK Everywhere/OLED screen on what’s happening. The ∆ H & ∆V at a minimum :thinking:

Instead of combining multiple GNSS engines together on a single (GNSS Flex module), maybe a new multi-engine mainboard for the FP-platform with 2 or 3 slots for the GNSS Flex modules would be better. That way, the individual GNSS engines (GNSS Flex modules) could be upgraded (without needing to create new GNSS Flex modules).

i.e. make the FP-platform’s mainboard (single vs multi engine)

You have seen how crowded the FP PCB is, right? :wink: