Syncing Your Gen-2 QTFM Sensors

Why Sync? & Choosing a Method

The QTFM2 operates using magnetic-field-producing coils within the sensor head to polarize the vapor between measurements. When deploying multiple sensors simultaneously, their respective fields can interfere with each other. The QTFM2 is designed to sync the clocks of multiple sensors, ensuring all coils are inactive during the measurement window — thus eliminating cross-sensor interference and letting the array act as a gradiometer.

There are four ways to synchronize an array. All four keep the sensors’ measurement cycles phase-aligned; they differ in how the shared timebase is delivered. Methods 3 and 4 share the same underlying sensor mechanism (GPS Sync mode + 1 PPS + 11-byte UTC frame) and differ only in who supplies the host — a Magpie in Method 3, your own host in Method 4.

Method 1 — Wired Master/Slave Sync

One sensor acts as the master and distributes its clock over a UMCC cable to one or more slave sensors. This is the original Gen-2 sync method and works on every sensor.

Step-by-step (two sensors)

1. Identify the sync pins on the QTFM2 Comms board. On the Comms board (where your USB cable connects), locate the UMCC pins labeled Sync_In and Sync_Out (circled in red below).

   The Sync_Out pin outputs the sensor’s clock; Sync_In receives a clock as input. The clock is a 0–3.3 V square wave at 50% duty cycle.

   

2. Connect the sensors. Use a UMCC cable from the Sync_Out pin of the master sensor to the Sync_In pin of the slave sensor. Don’t mix these up — the master provides the clock via Sync_Out, which the slave receives via Sync_In.

   

3. Set the slave sensor. Open the QuSpin User Interface, select the COM port for the slave sensor, go to the Terminal tab, enter ! in the “Send Ascii” box and click Send Ascii. Confirm slave mode: the lower-left message reads Slave MS Mode:0, and an S appears in the top-right blue box on the Main tab.
4. Verify settings. Confirm both sensors have fully auto-started and operate normally, and that they have identical data rates and environmental settings.
5. Finalize the sync. Switch the interface to the master sensor’s COM port, go to the Terminal tab, and send the Ascii character T. Look for a #Sensors Sync Complete message in the lower-left corner. The LED indicators on all sensor ECUs should then display synchronized color patterns, confirming the sync.

Syncing more than two sensors

Use one master and designate the rest as slaves, daisy-chaining the clock:

1. Connect Sync_Out of the master to Sync_In of the first slave.
2. Connect Sync_Out of the first slave to Sync_In of the next slave.
3. Repeat until all sensors are connected.
4. Set each slave (step 3) and finalize from the master (step 5).

Method 2 — External PPS Sync New in V1_43

Each sensor disciplines its measurement cycle to a shared external 1 PPS (one-pulse-per-second) hardware signal. Fan the same PPS out to every sensor, and they all lock their cycles to the same edge — synchronized, with no clock wire between sensors and no Magpie required. There is no absolute time in this mode; the shared edge provides the alignment.

What you need

• Sensors with FPGA bitstream v5.05+ and firmware V1_43+ (boot banner shows #FPGA 5.05 features).
• A common 1 PPS source — a 0–3.3 V pulse, once per second — fanned out to each sensor’s external sync (PPS) input. This is the same input used by the legacy Master/Slave clock.

One-time setup (per sensor — both settings persist across reboot)

1. Select External PPS Sync mode: send command 112 (p). The sensor confirms #External_PPS_Sync MS Mode:2. Saved to EEPROM.
2. Enable periodic re-arm + auto-engage: send command 230. Saved to EEPROM. This does two things: it keeps the sensor re-aligned to the PPS edge over long runs, and it tells the sensor to bring itself into sync automatically after cell-lock whenever a valid PPS is present.

After this one-time setup, every time the sensor powers on it autostarts, locks its cell, detects the PPS, and engages sync on its own — no commands needed at power-up. It prints #PPS sync auto-engaged … when it does.

Verify the sensor is locked to the PPS

Send command 234 to toggle the approx. 1 Hz PPS status debug line:

#PPS dbg: M_S=2 alive=1 consec=12 edges=1234 dt=4ms offset=27 locked=1 ra=0 resume_n=0

The line is reprinted once per wall-clock second so you can watch it converge. Send 234 a second time to turn the stream off (the sensor confirms with #PPS status debug: OFF).

What each field means

Realigning the array

“Realign” resets each sensor’s millisecond timestamp, restarts its averaging window, and (in vector mode) makes the Bx/By/Bz samples coincide. Because all sensors share the same PPS, triggering a realign on a common edge lines them all up at the same instant. Two one-shot options:

Method 3 — Wireless GPS Sync Magpie only

A QuSpin Magpie data logger with an onboard GPS receiver forwards GPS-derived absolute UTC time to each sensor over its UART. The sensor disciplines its measurement cycle to that time — so an array stays synchronized with no clock wire between sensors, and every sample is tagged with absolute UTC. This method requires a Magpie (firmware V5.10 or later).

Hardware prerequisites

• A QuSpin Magpie (firmware V5.10+) connected to the QTFM sensor (the existing connection also carries the sync line — no new wiring required).
• The Magpie’s GPS antenna has a clear sky view; at least 4 satellites for a valid time fix.
• Sensor FPGA bitstream v5.05+ and firmware V1_43+ (boot banner shows #FPGA 5.05 features).

Turnkey setup — two Magpie commands, no sensor commands

# On the Magpie (one time — persists across reboots):
[GPS on]             → power on the Magpie's GPS receiver
[gps_sync_auto on]   → start the turnkey auto-arm sequence

# Monitor progress at any time:
[gps_sync status]

Send these to the Magpie over its Wi-Fi terminal, Bluetooth terminal, or USB console.

Magpie sync commands

Manual alternative (configure the sensor yourself)

If you prefer to drive the sensor: send [gps_sync on] (manual) on the Magpie, then once the sensor has finished autostart send it: 113 (GPS Sync mode) → 206 (enable sync) → 209 (arm edge) → 230 (periodic re-arm, recommended for long runs).

Verification

• Watch the sensor LED. Once synced and the data is good, the ECU LED is solid white (red = the current measurement is flagged bad). For a multi-sensor visual check you can switch to a per-second rainbow with sensor command 235 — all properly synced sensors then step through the same color at the same instant. (The rainbow is troubleshooting-only; it adds a small 1 Hz magnetic signature and reverts to white on reboot.)
• [gps_sync status] shows AUTO (turnkey) with Auto-arm state: ARMED and Sensor cell locked: YES when complete.

UTC time frame (technical reference)

For reference, the Magpie forwards absolute UTC time as an 11-byte binary frame over the sensor’s UART once per second:

To exit GPS Sync

Send [gps_sync off] to the Magpie (stops UTC forwarding; the sensor’s periodic re-arm self-suppresses within approx. 3 s). Optionally, on the sensor send space (Master) or ! (Slave) to return to a legacy mode — the mode is saved to EEPROM.

Method 4 — Sensor-Only GPS Sync New in V1_44

Same underlying sensor sync mode as Method 3, but driven by your own host instead of a Magpie. The sensor’s main UART now accepts the same 11-byte UTC frame on a non-Magpie line, so you can integrate the QTFM into a custom carrier (drone, robot, fixed installation) without a Magpie in the loop. You provide the 1 PPS edge and a host that can read your GPS receiver’s NMEA time and pack it into the frame.

What you need

• A 1 PPS source wired to the sensor’s PPS sync input — the same input used for External PPS Sync (Method 2). Typically a GPS receiver’s 1 PPS output (0–3.3 V edge).
• A UTC time source that your host can read — typically the NMEA stream from the same GPS receiver. The host’s job is to turn the NMEA time into absolute Unix-epoch milliseconds and pack it into the 11-byte frame.
• A serial connection from your host to the sensor’s main UART (the same UART used for normal commands and data) at the sensor’s configured baud rate. 921600 is recommended for the lowest serial latency.
• Sensor FPGA v5.05+ and firmware V1_44+. Boot banner shows #FPGA 5.05 features and the firmware version line shows V1_44 or later.

Workflow

1. One-time sensor configuration. Send to the sensor:
   • 113 — select GPS Sync mode (FPGA addr 30 = 3). Saved to EEPROM.
   • 206 — enable the GPS sync subsystem. Response: #GPS Sync: ENABLED.
   • 230 — enable periodic auto-engage so subsequent reboots come back synced automatically. Saved to EEPROM.
2. Wire up the 1 PPS from your GPS receiver to the sensor’s PPS sync input. The sensor will start counting PPS edges as soon as they appear; verify with sensor command 234 (the #PPS dbg: stream — edges field should advance once per second).
3. On your host, once per UTC second, send an 11-byte frame to the sensor’s main UART:

   Byte	Field	Value
   0	Sync byte 1	0xAA
   1	Sync byte 2	0x55
   2–9	UTC milliseconds	64-bit unsigned, big-endian. Absolute Unix-epoch milliseconds.
   10	CRC-8	CRC-8 over bytes 2–9 (poly 0x07, init 0x00, no reflection).

   Send the frame within roughly 100 ms of the PPS edge it corresponds to — before or after, doesn’t matter. The sensor pairs the frame’s UTC value with the most recent PPS edge it saw, so loose timing is fine.

4. Verify the sync. See the verification section below.

CRC-8 reference implementation

For a quick host-side check — standard CRC-8 with polynomial 0x07, init 0x00, no input/output reflection. Run it over the 8 UTC payload bytes (positions 2 through 9 of the frame):

uint8_t crc8(const uint8_t *data, int len) {
    uint8_t crc = 0;
    for (int i = 0; i < len; i++) {
        crc ^= data[i];
        for (int b = 0; b < 8; b++) {
            crc = (crc & 0x80) ? (uint8_t)((crc << 1) ^ 0x07)
                                : (uint8_t)(crc << 1);
        }
    }
    return crc;
}

Verification

Enable the PPS debug stream with sensor command 234 — it prints once per second:

#PPS dbg: alive=1 edges=1234 dt=1000ms offset=27 locked=1 mode=0 resume_n=0

What to look for as you bring the system up:

• alive=1 and edges advancing — your PPS is reaching the sensor. If not, check the wiring and signal level (0–3.3 V edge).
• Send 206 if you haven’t already, then look at the response line UTC frames received so far: good=N  bad=N. good should climb once per second, bad should stay at 0. If bad is climbing, the frame format or CRC is wrong; if both stay at 0, the host isn’t sending bytes (or wrong baud).
• locked=1 — the sensor’s cycle is now sub-microsecond aligned to your PPS edge. May take a few seconds after cell-lock completes.

Things to keep in mind

• The UART frame alone does not provide phase lock. It provides absolute time stamping. The actual phase alignment of the sensor’s measurement cycle comes from the 1 PPS edge on the sync input pin. Without a real PPS edge, the sensor will still receive UTC frames but the cycle won’t align.
• The same UART carries normal commands and data. Hardware UART is full-duplex, so the sensor’s measurement output stream (sensor → host) and your UTC frames (host → sensor) don’t collide. Avoid sending other commands within approx. 100 ms of when you’ll be sending a UTC frame to keep things tidy.
• Stray 0xAA bytes are safe. A malformed or partial frame counts as a bad frame after a 10 ms timeout and is discarded; normal command processing resumes immediately.
• No Magpie required, no Magpie commands. Everything happens between your host, the sensor’s main UART, and the PPS input.

To exit Sensor-Only GPS Sync

Send space (Master) or ! (Slave) to the sensor — the mode is saved to EEPROM and the sensor returns to that mode on the next reboot. Stopping the host’s UTC frame stream alone does not exit the mode — the sensor stays in GPS Sync mode but reports the lack of frames as falling counters in the debug stream.

Appendix — Running Multiple QuSpin UI Instances

To monitor several sensors on one PC at the same time, run a separate copy of the QuSpin User Interface for each.

1. Open the folder containing the installed QuSpin UI (by default C:\Program Files (x86)\QuSpin\QTFM2_UI).
2. Copy the QTFM2_UI application and paste it back into the same folder (right-click → Copy, then right-click → Paste).
3. Make as many copies as you have sensors. Double-click each copy to launch an independent UI, then connect each to its own sensor’s COM port.