diff --git a/examples/Callbacks/CallbackExample7_ESF_MEAS/CallbackExample7_ESF_MEAS.ino b/examples/Callbacks/CallbackExample7_ESF_MEAS/CallbackExample7_ESF_MEAS.ino new file mode 100644 index 0000000..10217d2 --- /dev/null +++ b/examples/Callbacks/CallbackExample7_ESF_MEAS/CallbackExample7_ESF_MEAS.ino @@ -0,0 +1,212 @@ +/* + u-blox Example: ESF MEAS (Wheel Ticks) + By: Paul Clark + SparkFun Electronics + Date: December 19th, 2023 + License: MIT. See license file for more information + + This example configures the External Sensor Fusion MEAS sensor messages on the ZED-F9R and + shows how to access the ESF data using callbacks. + + Feel like supporting open source hardware? + Buy a board from SparkFun! + ZED-F9R: https://www.sparkfun.com/products/22660 + + Hardware Connections: + Plug a Qwiic cable into the GPS and a Redboard Qwiic + If you don't have a platform with a Qwiic connection use the + SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425) + + Open the serial monitor at >>> 230400 <<< baud to see the output + +*/ + +#include //Needed for I2C to GPS + +#include //http://librarymanager/All#SparkFun_u-blox_GNSS_v3 +SFE_UBLOX_GNSS myGNSS; + +// Callback: printESFMEASdata will be called when new ESF MEAS data arrives +// See u-blox_structs.h for the full definition of UBX_ESF_MEAS_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setAutoESFMEAScallback +// / _____ This _must_ be UBX_ESF_MEAS_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void printESFMEASdata(UBX_ESF_MEAS_data_t *ubxDataStruct) +{ + // New ESF MEAS data has arrived: + + // Print the timeTag + Serial.print(F("Time: ")); + Serial.println(ubxDataStruct->timeTag); + + // ubxDataStruct->flags.bits.numMeas indicates how many sensor groups the UBX_ESF_MEAS_data_t contains. + for (uint8_t i = 0; i < ubxDataStruct->flags.bits.numMeas; i++) + { + // Print the sensor data type + // From the M8 interface description: + // 0: None + // 1-4: Reserved + // 5: z-axis gyroscope angular rate deg/s * 2^-12 signed + // 6: front-left wheel ticks: Bits 0-22: unsigned tick value. Bit 23: direction indicator (0=forward, 1=backward) + // 7: front-right wheel ticks: Bits 0-22: unsigned tick value. Bit 23: direction indicator (0=forward, 1=backward) + // 8: rear-left wheel ticks: Bits 0-22: unsigned tick value. Bit 23: direction indicator (0=forward, 1=backward) + // 9: rear-right wheel ticks: Bits 0-22: unsigned tick value. Bit 23: direction indicator (0=forward, 1=backward) + // 10: speed ticks: Bits 0-22: unsigned tick value. Bit 23: direction indicator (0=forward, 1=backward) + // 11: speed m/s * 1e-3 signed + // 12: gyroscope temperature deg Celsius * 1e-2 signed + // 13: y-axis gyroscope angular rate deg/s * 2^-12 signed + // 14: x-axis gyroscope angular rate deg/s * 2^-12 signed + // 16: x-axis accelerometer specific force m/s^2 * 2^-10 signed + // 17: y-axis accelerometer specific force m/s^2 * 2^-10 signed + // 18: z-axis accelerometer specific force m/s^2 * 2^-10 signed + switch (ubxDataStruct->data[i].data.bits.dataType) + { + case 5: + Serial.print(F("Z Gyro: ")); + break; + case 6: + Serial.print(F("Front Left: ")); + break; + case 7: + Serial.print(F("Front Right: ")); + break; + case 8: + Serial.print(F("Rear Left: ")); + break; + case 9: + Serial.print(F("Rear Right: ")); + break; + case 10: + Serial.print(F("Speed Ticks: ")); + break; + case 11: + Serial.print(F("Speed: ")); + break; + case 12: + Serial.print(F("Temp: ")); + break; + case 13: + Serial.print(F("Y Gyro: ")); + break; + case 14: + Serial.print(F("X Gyro: ")); + break; + case 16: + Serial.print(F("X Accel: ")); + break; + case 17: + Serial.print(F("Y Accel: ")); + break; + case 18: + Serial.print(F("Z Accel: ")); + break; + default: + break; + } + + // Tick data + if ((ubxDataStruct->data[i].data.bits.dataType >= 6) && (ubxDataStruct->data[i].data.bits.dataType <= 10)) + { + if ((ubxDataStruct->data[i].data.bits.dataField & (1 << 23)) > 0) + Serial.print(F("-")); // Backward + else + Serial.print(F("+")); // Forward + Serial.println(ubxDataStruct->data[i].data.bits.dataField & 0x007FFFFF); + } + // Speed + else if (ubxDataStruct->data[i].data.bits.dataType == 11) + { + union + { + int32_t signed32; + uint32_t unsigned32; + } signedUnsigned; // Avoid any ambiguity casting uint32_t to int32_t + // The dataField is 24-bit signed, stored in the 24 LSBs of a uint32_t + signedUnsigned.unsigned32 = ubxDataStruct->data[i].data.bits.dataField << 8; // Shift left by 8 bits to correctly align the data + float speed = signedUnsigned.signed32; // Extract the signed data. Convert to float + speed /= 256.0; // Divide by 256 to undo the shift + speed *= 0.001; // Convert from m/s * 1e-3 to m/s + Serial.println(speed, 3); + } + // Gyro data + else if ((ubxDataStruct->data[i].data.bits.dataType == 5) || (ubxDataStruct->data[i].data.bits.dataType == 13) || (ubxDataStruct->data[i].data.bits.dataType == 14)) + { + union + { + int32_t signed32; + uint32_t unsigned32; + } signedUnsigned; // Avoid any ambiguity casting uint32_t to int32_t + // The dataField is 24-bit signed, stored in the 24 LSBs of a uint32_t + signedUnsigned.unsigned32 = ubxDataStruct->data[i].data.bits.dataField << 8; // Shift left by 8 bits to correctly align the data + float rate = signedUnsigned.signed32; // Extract the signed data. Convert to float + rate /= 256.0; // Divide by 256 to undo the shift + rate *= 0.000244140625; // Convert from deg/s * 2^-12 to deg/s + Serial.println(rate); + } + // Accelerometer data + else if ((ubxDataStruct->data[i].data.bits.dataType == 16) || (ubxDataStruct->data[i].data.bits.dataType == 17) || (ubxDataStruct->data[i].data.bits.dataType == 18)) + { + union + { + int32_t signed32; + uint32_t unsigned32; + } signedUnsigned; // Avoid any ambiguity casting uint32_t to int32_t + // The dataField is 24-bit signed, stored in the 24 LSBs of a uint32_t + signedUnsigned.unsigned32 = ubxDataStruct->data[i].data.bits.dataField << 8; // Shift left by 8 bits to correctly align the data + float force = signedUnsigned.signed32; // Extract the signed data. Convert to float + force /= 256.0; // Divide by 256 to undo the shift + force *= 0.0009765625; // Convert from m/s^2 * 2^-10 to m/s^2 + Serial.println(force); + } + // Gyro Temperature + else if (ubxDataStruct->data[i].data.bits.dataType == 12) + { + union + { + int32_t signed32; + uint32_t unsigned32; + } signedUnsigned; // Avoid any ambiguity casting uint32_t to int32_t + // The dataField is 24-bit signed, stored in the 24 LSBs of a uint32_t + signedUnsigned.unsigned32 = ubxDataStruct->data[i].data.bits.dataField << 8; // Shift left by 8 bits to correctly align the data + float temperature = signedUnsigned.signed32; // Extract the signed data. Convert to float + temperature /= 256.0; // Divide by 256 to undo the shift + temperature *= 0.01; // Convert from C * 1e-2 to C + Serial.println(temperature); + } + } +} + +void setup() +{ + Serial.begin(230400); // <-- Use a fast baud rate to avoid the Serial prints slowing the code + + while (!Serial) + ; // Wait for user to open terminal + Serial.println(F("SparkFun u-blox Example")); + + Wire.begin(); + Wire.setClock(400000); // <-- Use 400kHz I2C + + // myGNSS.enableDebugging(); // Uncomment this line to enable debug messages on Serial + + if (myGNSS.begin() == false) // Connect to the u-blox module using Wire port + { + Serial.println(F("u-blox GNSS not detected at default I2C address. Please check wiring. Freezing.")); + while (1) + ; + } + + myGNSS.setI2COutput(COM_TYPE_UBX); // Set the I2C port to output UBX only (turn off NMEA noise) + myGNSS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT); // Save (only) the communications port settings to flash and BBR + + if (myGNSS.setAutoESFMEAScallbackPtr(&printESFMEASdata) == true) // Enable automatic ESF MEAS messages with callback to printESFMEASdata + Serial.println(F("setAutoESFMEAScallback successful")); +} + +void loop() +{ + myGNSS.checkUblox(); // Check for the arrival of new data and process it. + myGNSS.checkCallbacks(); // Check if any callbacks are waiting to be processed. +} \ No newline at end of file diff --git a/examples/NEO-D9S_and_NEO-D9C/Example10_LBand_PMP_over_Serial/Example10_LBand_PMP_over_Serial.ino b/examples/NEO-D9S_and_NEO-D9C/Example10_LBand_PMP_over_Serial/Example10_LBand_PMP_over_Serial.ino new file mode 100644 index 0000000..eb6995d --- /dev/null +++ b/examples/NEO-D9S_and_NEO-D9C/Example10_LBand_PMP_over_Serial/Example10_LBand_PMP_over_Serial.ino @@ -0,0 +1,126 @@ +/* + Use the NEO-D9S L-Band receiver to provide corrections as PMP over Serial + By: SparkFun Electronics / Paul Clark + Based on original code by: u-blox AG / Michael Ammann + v3 updates: Decembe 22nd, 2022 + License: MIT. See license file for more information. + + This example shows how to obtain PMP correction data from a NEO-D9S L-Band receiver and push it over Serial (UART). + + Feel like supporting open source hardware? + Buy a board from SparkFun! + ZED-F9P RTK2: https://www.sparkfun.com/products/16481 + NEO-D9S: https://www.sparkfun.com/products/19390 + Combo Board: https://www.sparkfun.com/products/20167 + + Hardware Connections: + Use a Qwiic cable to connect the NEO-D9S to your board + If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425) + Open the serial monitor at 115200 baud to see the output +*/ + +#include //Required for uart_set_rx_full_threshold() on cores //http://librarymanager/All#SparkFun_u-blox_GNSS_v3 +SFE_UBLOX_GNSS myLBand; // NEO-D9S + +const uint32_t myLBandFreq = 1556290000; // Uncomment this line to use the US SPARTN 1.8 service +//const uint32_t myLBandFreq = 1545260000; // Uncomment this line to use the EU SPARTN 1.8 service + +#define OK(ok) (ok ? F(" -> OK") : F(" -> ERROR!")) // Convert uint8_t into OK/ERROR + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: pushRXMPMP will be called when new PMP data arrives +// See u-blox_structs.h for the full definition of UBX_RXM_PMP_message_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setRXMPMPmessageCallbackPtr +// / _____ This _must_ be UBX_RXM_PMP_message_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void pushRXMPMP(UBX_RXM_PMP_message_data_t *pmpData) +{ + //Extract the raw message payload length + uint16_t payloadLen = ((uint16_t)pmpData->lengthMSB << 8) | (uint16_t)pmpData->lengthLSB; + + uint16_t numBytesUserData = pmpData->payload[2] | ((uint16_t)pmpData->payload[3] << 8); + uint16_t fecBits = pmpData->payload[20] | ((uint16_t)pmpData->payload[21] << 8); + float ebno = (float)pmpData->payload[22] / 8; + + Serial.print(F("New RXM-PMP data received. userData: ")); + Serial.print(numBytesUserData); + Serial.print(F(" Bytes. fecBits: ")); + Serial.print(fecBits); + Serial.print(F(". ebno (dB): ")); + Serial.print(ebno); + Serial.println(F(".")); + + Serial.println(F("Pushing PMP to Serial...")); + + serialGNSS.write(&pmpData->payload[24], (size_t)numBytesUserData); // Push only the raw PMP userData + (void)payloadLen; + + //serialGNSS.write(&pmpData->sync1, (size_t)payloadLen + 6); // Push the sync chars, class, ID, length and payload + //serialGNSS.write(&pmpData->checksumA, (size_t)2); // Push the checksum bytes +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void setup() +{ + delay(1000); + + Serial.begin(115200); + Serial.println(F("NEO-D9S SPARTN Corrections")); + + serialGNSS.begin(38400); // UART2 on pins 16/17. + + Wire.begin(); //Start I2C + + //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + // Begin and configure the NEO-D9S L-Band receiver + + //myLBand.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + while (myLBand.begin(Wire, 0x43) == false) //Connect to the u-blox NEO-D9S using Wire port. The D9S default I2C address is 0x43 (not 0x42) + { + Serial.println(F("u-blox NEO-D9S not detected at default I2C address. Please check wiring.")); + delay(2000); + } + Serial.println(F("u-blox NEO-D9S connected")); + + myLBand.newCfgValset(); // Create a new Configuration Interface message - this defaults to VAL_LAYER_RAM_BBR (change in RAM and BBR) + myLBand.addCfgValset(UBLOX_CFG_PMP_CENTER_FREQUENCY, myLBandFreq); // Default 1539812500 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_SEARCH_WINDOW, 2200); // Default 2200 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_SERVICE_ID, 0); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_SERVICE_ID, 21845); // Default 50821 + myLBand.addCfgValset(UBLOX_CFG_PMP_DATA_RATE, 2400); // Default 2400 bps + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_DESCRAMBLER, 1); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_DESCRAMBLER_INIT, 26969); // Default 23560 + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_PRESCRAMBLING, 0); // Default 0 + myLBand.addCfgValset(UBLOX_CFG_PMP_UNIQUE_WORD, 16238547128276412563ull); + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C, 1); // Ensure UBX-RXM-PMP is enabled on the I2C port + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1, 1); // Output UBX-RXM-PMP on UART1 + myLBand.addCfgValset(UBLOX_CFG_UART2OUTPROT_UBX, 1); // Enable UBX output on UART2 + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2, 1); // Output UBX-RXM-PMP on UART2 + myLBand.addCfgValset(UBLOX_CFG_UART1_BAUDRATE, 38400); // match baudrate with ZED default + myLBand.addCfgValset(UBLOX_CFG_UART2_BAUDRATE, 38400); // match baudrate with ZED default + bool ok = myLBand.sendCfgValset(); // Apply the settings + + Serial.print(F("L-Band: configuration ")); + Serial.println(OK(ok)); + + myLBand.softwareResetGNSSOnly(); // Do a restart + + myLBand.setRXMPMPmessageCallbackPtr(&pushRXMPMP); // Call pushRXMPMP when new PMP data arrives. Push it to the GNSS + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void loop() +{ + myLBand.checkUblox(); // Check for the arrival of new PMP data and process it. + myLBand.checkCallbacks(); // Check if any LBand callbacks are waiting to be processed. +} diff --git a/examples/NEO-D9S_and_NEO-D9C/Example7_LBand_Corrections_over_Serial/Example7_LBand_Corrections_over_Serial.ino b/examples/NEO-D9S_and_NEO-D9C/Example7_LBand_Corrections_over_Serial/Example7_LBand_Corrections_over_Serial.ino new file mode 100644 index 0000000..1f0724f --- /dev/null +++ b/examples/NEO-D9S_and_NEO-D9C/Example7_LBand_Corrections_over_Serial/Example7_LBand_Corrections_over_Serial.ino @@ -0,0 +1,286 @@ +/* + Use the NEO-D9S L-Band receiver to provide corrections to a ZED-F9x via UBX-RXM-PMP messages + By: SparkFun Electronics / Paul Clark + Based on original code by: u-blox AG / Michael Ammann + v3 updates: Decembe 22nd, 2022 + License: MIT. See license file for more information. + + This example shows how to obtain SPARTN correction data from a NEO-D9S L-Band receiver and push it over ESP32 Serial (UART) to a ZED-F9x. + + This is a proof of concept to show how the UBX-RXM-PMP corrections control the accuracy. + + You will need a Thingstream PointPerfect account to be able to access the SPARTN Credentials (L-Band or L-Band + IP Dynamic Keys). + Copy and paste the Current Key and Next Key into secrets.h. + + Feel like supporting open source hardware? + Buy a board from SparkFun! + ZED-F9P RTK2: https://www.sparkfun.com/products/16481 + NEO-D9S: https://www.sparkfun.com/products/19390 + Combo Board: https://www.sparkfun.com/products/20167 + + Hardware Connections: + Use Qwiic cables to connect the NEO-D9S and ZED-F9x GNSS to your board + If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425) + Open the serial monitor at 115200 baud to see the output +*/ + +#include "secrets.h" // <- Copy and paste the Current Key and Next Key into secrets.h + +#include //Required for uart_set_rx_full_threshold() on cores //http://librarymanager/All#SparkFun_u-blox_GNSS_v3 +SFE_UBLOX_GNSS myGNSS; // ZED-F9x +SFE_UBLOX_GNSS myLBand; // NEO-D9S + +const uint32_t myLBandFreq = 1556290000; // Uncomment this line to use the US SPARTN 1.8 service +//const uint32_t myLBandFreq = 1545260000; // Uncomment this line to use the EU SPARTN 1.8 service + +#define OK(ok) (ok ? F(" -> OK") : F(" -> ERROR!")) // Convert uint8_t into OK/ERROR + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: pushRXMPMP will be called when new PMP data arrives +// See u-blox_structs.h for the full definition of UBX_RXM_PMP_message_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setRXMPMPmessageCallbackPtr +// / _____ This _must_ be UBX_RXM_PMP_message_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void pushRXMPMP(UBX_RXM_PMP_message_data_t *pmpData) +{ + //Extract the raw message payload length + uint16_t payloadLen = ((uint16_t)pmpData->lengthMSB << 8) | (uint16_t)pmpData->lengthLSB; + Serial.print(F("New RXM-PMP data received. Message payload length is ")); + Serial.print(payloadLen); + + Serial.println(F(" Bytes. Pushing it to the GNSS...")); + + //Push the PMP data to the GNSS + //The payload length could be variable, so we need to push the header and payload, then checksum + serialGNSS.write(&pmpData->sync1, (size_t)payloadLen + 6); // Push the sync chars, class, ID, length and payload + serialGNSS.write(&pmpData->checksumA, (size_t)2); // Push the checksum bytes + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: printPVTdata will be called when new NAV PVT data arrives +// See u-blox_structs.h for the full definition of UBX_NAV_PVT_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setAutoPVTcallbackPtr +// / _____ This _must_ be UBX_NAV_PVT_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct) +{ + double latitude = ubxDataStruct->lat; // Print the latitude + Serial.print(F("Lat: ")); + Serial.print(latitude / 10000000.0, 7); + + double longitude = ubxDataStruct->lon; // Print the longitude + Serial.print(F(" Long: ")); + Serial.print(longitude / 10000000.0, 7); + + double altitude = ubxDataStruct->hMSL; // Print the height above mean sea level + Serial.print(F(" Height: ")); + Serial.print(altitude / 1000.0, 3); + + uint8_t fixType = ubxDataStruct->fixType; // Print the fix type + Serial.print(F(" Fix: ")); + Serial.print(fixType); + if (fixType == 0) + Serial.print(F(" (None)")); + else if (fixType == 1) + Serial.print(F(" (Dead Reckoning)")); + else if (fixType == 2) + Serial.print(F(" (2D)")); + else if (fixType == 3) + Serial.print(F(" (3D)")); + else if (fixType == 3) + Serial.print(F(" (GNSS + Dead Reckoning)")); + else if (fixType == 5) + Serial.print(F(" (Time Only)")); + else + Serial.print(F(" (UNKNOWN)")); + + uint8_t carrSoln = ubxDataStruct->flags.bits.carrSoln; // Print the carrier solution + Serial.print(F(" Carrier Solution: ")); + Serial.print(carrSoln); + if (carrSoln == 0) + Serial.print(F(" (None)")); + else if (carrSoln == 1) + Serial.print(F(" (Floating)")); + else if (carrSoln == 2) + Serial.print(F(" (Fixed)")); + else + Serial.print(F(" (UNKNOWN)")); + + uint32_t hAcc = ubxDataStruct->hAcc; // Print the horizontal accuracy estimate + Serial.print(F(" Horizontal Accuracy Estimate: ")); + Serial.print(hAcc); + Serial.print(F(" (mm)")); + + Serial.println(); +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: printRXMCOR will be called when new RXM COR data arrives +// See u-blox_structs.h for the full definition of UBX_RXM_COR_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setRXMCORcallbackPtr +// / _____ This _must_ be UBX_RXM_COR_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void printRXMCOR(UBX_RXM_COR_data_t *ubxDataStruct) +{ + Serial.print(F("UBX-RXM-COR: ebno: ")); + Serial.print((double)ubxDataStruct->ebno / 8, 3); //Convert ebno to dB + + Serial.print(F(" protocol: ")); + if (ubxDataStruct->statusInfo.bits.protocol == 1) + Serial.print(F("RTCM3")); + else if (ubxDataStruct->statusInfo.bits.protocol == 2) + Serial.print(F("SPARTN")); + else if (ubxDataStruct->statusInfo.bits.protocol == 29) + Serial.print(F("PMP (SPARTN)")); + else if (ubxDataStruct->statusInfo.bits.protocol == 30) + Serial.print(F("QZSSL6")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" errStatus: ")); + if (ubxDataStruct->statusInfo.bits.errStatus == 1) + Serial.print(F("Error-free")); + else if (ubxDataStruct->statusInfo.bits.errStatus == 2) + Serial.print(F("Erroneous")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" msgUsed: ")); + if (ubxDataStruct->statusInfo.bits.msgUsed == 1) + Serial.print(F("Not used")); + else if (ubxDataStruct->statusInfo.bits.msgUsed == 2) + Serial.print(F("Used")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" msgEncrypted: ")); + if (ubxDataStruct->statusInfo.bits.msgEncrypted == 1) + Serial.print(F("Not encrypted")); + else if (ubxDataStruct->statusInfo.bits.msgEncrypted == 2) + Serial.print(F("Encrypted")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" msgDecrypted: ")); + if (ubxDataStruct->statusInfo.bits.msgDecrypted == 1) + Serial.print(F("Not decrypted")); + else if (ubxDataStruct->statusInfo.bits.msgDecrypted == 2) + Serial.print(F("Successfully decrypted")); + else + Serial.print(F("Unknown")); + + Serial.println(); +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void setup() +{ + Serial.begin(115200); + Serial.println(F("NEO-D9S SPARTN Corrections")); + + serialGNSS.setRxBufferSize(1024); + serialGNSS.setTimeout(1); // Requires serial traffic on the UART pins for detection + serialGNSS.begin(38400); // UART2 on pins 16/17 for SPP. The ZED-F9P will be configured to use the same rate. + + Wire.begin(); //Start I2C + + //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + // Begin and configure the ZED-F9x + + //myGNSS.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + while (myGNSS.begin() == false) //Connect to the u-blox module using Wire port + { + Serial.println(F("u-blox GNSS module not detected at default I2C address. Please check wiring.")); + delay(2000); + } + Serial.println(F("u-blox GNSS module connected")); + + uint8_t ok = myGNSS.setI2COutput(COM_TYPE_UBX); //Turn off NMEA noise + if (ok) ok = myGNSS.setI2CInput(COM_TYPE_UBX | COM_TYPE_NMEA | COM_TYPE_SPARTN); //Be sure SPARTN input is enabled + if (ok) ok = myGNSS.setUART2Input(COM_TYPE_UBX | COM_TYPE_NMEA | COM_TYPE_SPARTN); //Be sure SPARTN input is enabled + if (ok) ok = myGNSS.setDGNSSConfiguration(SFE_UBLOX_DGNSS_MODE_FIXED); // Set the differential mode - ambiguities are fixed whenever possible + if (ok) ok = myGNSS.setNavigationFrequency(1); //Set output in Hz. + if (ok) ok = myGNSS.setVal8(UBLOX_CFG_SPARTN_USE_SOURCE, 1); // use LBAND PMP message + if (ok) ok = myGNSS.setVal8(UBLOX_CFG_MSGOUT_UBX_RXM_COR_I2C, 1); // Enable UBX-RXM-COR messages on I2C + + //Configure the SPARTN IP Dynamic Keys + //"When the receiver boots, the host should send 'current' and 'next' keys in one message." - Use setDynamicSPARTNKeys for this. + //"Every time the 'current' key is expired, 'next' takes its place." + //"Therefore the host should then retrieve the new 'next' key and send only that." - Use setDynamicSPARTNKey for this. + // The key can be provided in binary (uint8_t) format or in ASCII Hex (char) format, but in both cases keyLengthBytes _must_ represent the binary key length in bytes. + if (ok) ok = myGNSS.setDynamicSPARTNKeys(currentKeyLengthBytes, currentKeyGPSWeek, currentKeyGPSToW, currentDynamicKey, + nextKeyLengthBytes, nextKeyGPSWeek, nextKeyGPSToW, nextDynamicKey); + + //if (ok) ok = myGNSS.saveConfiguration(VAL_CFG_SUBSEC_IOPORT | VAL_CFG_SUBSEC_MSGCONF); //Optional: Save the ioPort and message settings to NVM and BBR + + Serial.print(F("GNSS: configuration ")); + Serial.println(OK(ok)); + + myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata so we can watch the carrier solution go to fixed + + myGNSS.setRXMCORcallbackPtr(&printRXMCOR); // Print the contents of UBX-RXM-COR messages so we can check if the PMP data is being decrypted successfully + + //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + // Begin and configure the NEO-D9S L-Band receiver + + //myLBand.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + while (myLBand.begin(Wire, 0x43) == false) //Connect to the u-blox NEO-D9S using Wire port. The D9S default I2C address is 0x43 (not 0x42) + { + Serial.println(F("u-blox NEO-D9S not detected at default I2C address. Please check wiring.")); + delay(2000); + } + Serial.println(F("u-blox NEO-D9S connected")); + + myLBand.newCfgValset(); // Create a new Configuration Interface message - this defaults to VAL_LAYER_RAM_BBR (change in RAM and BBR) + myLBand.addCfgValset(UBLOX_CFG_PMP_CENTER_FREQUENCY, myLBandFreq); // Default 1539812500 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_SEARCH_WINDOW, 2200); // Default 2200 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_SERVICE_ID, 0); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_SERVICE_ID, 21845); // Default 50821 + myLBand.addCfgValset(UBLOX_CFG_PMP_DATA_RATE, 2400); // Default 2400 bps + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_DESCRAMBLER, 1); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_DESCRAMBLER_INIT, 26969); // Default 23560 + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_PRESCRAMBLING, 0); // Default 0 + myLBand.addCfgValset(UBLOX_CFG_PMP_UNIQUE_WORD, 16238547128276412563ull); + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C, 1); // Ensure UBX-RXM-PMP is enabled on the I2C port + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1, 1); // Output UBX-RXM-PMP on UART1 + myLBand.addCfgValset(UBLOX_CFG_UART2OUTPROT_UBX, 1); // Enable UBX output on UART2 + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2, 1); // Output UBX-RXM-PMP on UART2 + myLBand.addCfgValset(UBLOX_CFG_UART1_BAUDRATE, 38400); // match baudrate with ZED default + myLBand.addCfgValset(UBLOX_CFG_UART2_BAUDRATE, 38400); // match baudrate with ZED default + ok = myLBand.sendCfgValset(); // Apply the settings + + Serial.print(F("L-Band: configuration ")); + Serial.println(OK(ok)); + + myLBand.softwareResetGNSSOnly(); // Do a restart + + myLBand.setRXMPMPmessageCallbackPtr(&pushRXMPMP); // Call pushRXMPMP when new PMP data arrives. Push it to the GNSS + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void loop() +{ + myGNSS.checkUblox(); // Check for the arrival of new GNSS data and process it. + myGNSS.checkCallbacks(); // Check if any GNSS callbacks are waiting to be processed. + + myLBand.checkUblox(); // Check for the arrival of new PMP data and process it. + myLBand.checkCallbacks(); // Check if any LBand callbacks are waiting to be processed. +} diff --git a/examples/NEO-D9S_and_NEO-D9C/Example7_LBand_Corrections_over_Serial/secrets.h b/examples/NEO-D9S_and_NEO-D9C/Example7_LBand_Corrections_over_Serial/secrets.h new file mode 100644 index 0000000..06eeee4 --- /dev/null +++ b/examples/NEO-D9S_and_NEO-D9C/Example7_LBand_Corrections_over_Serial/secrets.h @@ -0,0 +1,27 @@ +// You can set the information below after signing up with the u-blox Thingstream portal +// and adding a new New PointPerfect Thing (L-Band or L-Band + IP) +// https://portal.thingstream.io/app/location-services/things +// In the new PointPerfect Thing, you go to the credentials tab and copy and paste the IP Dynamic Keys here. +// +// The keys are valid from a particular GPS Week Number and Time of Week. +// Looking at the credentials tab, the current key expires 23:59 Feb 11th 2022. +// This means the next key is valid _from_ Midnight Feb 12th 2022. +// That is GPS Week 2196. The GPS Time of Week in seconds is 518400. +// Working backwards, the current key became valid exactly 4 weeks earlier (Midnight Jan 15th 2022). +// +// See: https://www.labsat.co.uk/index.php/en/gps-time-calculator +// +// The keys are given as: 32 hexadecimal digits = 128 bits = 16 Bytes +// +// The next example shows how to retrieve the keys using ESP32 WiFi and MQTT. +// You can cut and paste the keys and GPS week/time-of-week from that example into here. + +const uint8_t currentKeyLengthBytes = 16; +const char currentDynamicKey[] = ""; +const uint16_t currentKeyGPSWeek = 2254; // Update this when you add new keys +const uint32_t currentKeyGPSToW = 0; + +const uint8_t nextKeyLengthBytes = 16; +const char nextDynamicKey[] = ""; +const uint16_t nextKeyGPSWeek = 2258; // Update this when you add new keys +const uint32_t nextKeyGPSToW = 0; diff --git a/examples/NEO-D9S_and_NEO-D9C/Example8_LBand_SPARTN_Parsing/Example8_LBand_SPARTN_Parsing.ino b/examples/NEO-D9S_and_NEO-D9C/Example8_LBand_SPARTN_Parsing/Example8_LBand_SPARTN_Parsing.ino new file mode 100644 index 0000000..f648391 --- /dev/null +++ b/examples/NEO-D9S_and_NEO-D9C/Example8_LBand_SPARTN_Parsing/Example8_LBand_SPARTN_Parsing.ino @@ -0,0 +1,316 @@ +/* + Use the NEO-D9S L-Band receiver to provide corrections to a ZED-F9x as SPARTN data + By: SparkFun Electronics / Paul Clark + Based on original code by: u-blox AG / Michael Ammann + v3 updates: Decembe 22nd, 2022 + License: MIT. See license file for more information. + + This example shows how to obtain SPARTN correction data from a NEO-D9S L-Band receiver and push it over ESP32 Serial (UART) to a ZED-F9x. + This example parses (extracts) SPARTN packets from the L-Band data stream and validates them before pushing. + + This is a proof of concept to show how the UBX-RXM-PMP corrections control the accuracy. + + You will need a Thingstream PointPerfect account to be able to access the SPARTN Credentials (L-Band or L-Band + IP Dynamic Keys). + Copy and paste the Current Key and Next Key into secrets.h. + + Feel like supporting open source hardware? + Buy a board from SparkFun! + ZED-F9P RTK2: https://www.sparkfun.com/products/16481 + NEO-D9S: https://www.sparkfun.com/products/19390 + Combo Board: https://www.sparkfun.com/products/20167 + + Hardware Connections: + Use Qwiic cables to connect the NEO-D9S and ZED-F9x GNSS to your board + If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425) + Open the serial monitor at 115200 baud to see the output +*/ + +#include "secrets.h" // <- Copy and paste the Current Key and Next Key into secrets.h + +#include //Required for uart_set_rx_full_threshold() on cores //http://librarymanager/All#SparkFun_u-blox_GNSS_v3 +SFE_UBLOX_GNSS myGNSS; // ZED-F9x +SFE_UBLOX_GNSS myLBand; // NEO-D9S + +const uint32_t myLBandFreq = 1556290000; // Uncomment this line to use the US SPARTN 1.8 service +//const uint32_t myLBandFreq = 1545260000; // Uncomment this line to use the EU SPARTN 1.8 service + +#define OK(ok) (ok ? F(" -> OK") : F(" -> ERROR!")) // Convert uint8_t into OK/ERROR + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: pushRXMPMP will be called when new PMP data arrives +// See u-blox_structs.h for the full definition of UBX_RXM_PMP_message_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setRXMPMPmessageCallbackPtr +// / _____ This _must_ be UBX_RXM_PMP_message_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void pushRXMPMP(UBX_RXM_PMP_message_data_t *pmpData) +{ + //Extract the raw message payload length + uint16_t payloadLen = ((uint16_t)pmpData->lengthMSB << 8) | (uint16_t)pmpData->lengthLSB; + + uint16_t numBytesUserData = pmpData->payload[2] | ((uint16_t)pmpData->payload[3] << 8); + uint16_t fecBits = pmpData->payload[20] | ((uint16_t)pmpData->payload[21] << 8); + float ebno = (float)pmpData->payload[22] / 8; + + Serial.print(F("New RXM-PMP data received. userData: ")); + Serial.print(numBytesUserData); + Serial.print(F(" Bytes. fecBits: ")); + Serial.print(fecBits); + Serial.print(F(". ebno (dB): ")); + Serial.print(ebno); + Serial.println(F(".")); + + //Parse the SPARTN data stream contained in the userData + for (uint16_t i = 0; i < numBytesUserData; i++) + { + bool valid = false; + uint16_t len; + uint8_t *spartn = myLBand.parseSPARTN(pmpData->payload[24 + i], valid, len); + + if (valid) + { + Serial.print(F("Valid SPARTN data parsed. Pushing ")); + Serial.print(len); + Serial.println(F(" bytes to the ZED-F9P...")); + + //myGNSS.pushRawData(spartn, len); // Push the SPARTN data to the module using I2C + + serialGNSS.write(spartn, len); // Push the SPARTN data to the module using Serial + } + } + + //myGNSS.pushRawData(&pmpData->sync1, (size_t)payloadLen + 6); // Push the sync chars, class, ID, length and payload + //myGNSS.pushRawData(&pmpData->checksumA, (size_t)2); // Push the checksum bytes + + //serialGNSS.write(&pmpData->sync1, (size_t)payloadLen + 6); // Push the sync chars, class, ID, length and payload + //serialGNSS.write(&pmpData->checksumA, (size_t)2); // Push the checksum bytes + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: printPVTdata will be called when new NAV PVT data arrives +// See u-blox_structs.h for the full definition of UBX_NAV_PVT_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setAutoPVTcallbackPtr +// / _____ This _must_ be UBX_NAV_PVT_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct) +{ + double latitude = ubxDataStruct->lat; // Print the latitude + Serial.print(F("Lat: ")); + Serial.print(latitude / 10000000.0, 7); + + double longitude = ubxDataStruct->lon; // Print the longitude + Serial.print(F(" Long: ")); + Serial.print(longitude / 10000000.0, 7); + + double altitude = ubxDataStruct->hMSL; // Print the height above mean sea level + Serial.print(F(" Height: ")); + Serial.print(altitude / 1000.0, 3); + + uint8_t fixType = ubxDataStruct->fixType; // Print the fix type + Serial.print(F(" Fix: ")); + Serial.print(fixType); + if (fixType == 0) + Serial.print(F(" (None)")); + else if (fixType == 1) + Serial.print(F(" (Dead Reckoning)")); + else if (fixType == 2) + Serial.print(F(" (2D)")); + else if (fixType == 3) + Serial.print(F(" (3D)")); + else if (fixType == 3) + Serial.print(F(" (GNSS + Dead Reckoning)")); + else if (fixType == 5) + Serial.print(F(" (Time Only)")); + else + Serial.print(F(" (UNKNOWN)")); + + uint8_t carrSoln = ubxDataStruct->flags.bits.carrSoln; // Print the carrier solution + Serial.print(F(" Carrier Solution: ")); + Serial.print(carrSoln); + if (carrSoln == 0) + Serial.print(F(" (None)")); + else if (carrSoln == 1) + Serial.print(F(" (Floating)")); + else if (carrSoln == 2) + Serial.print(F(" (Fixed)")); + else + Serial.print(F(" (UNKNOWN)")); + + uint32_t hAcc = ubxDataStruct->hAcc; // Print the horizontal accuracy estimate + Serial.print(F(" Horizontal Accuracy Estimate: ")); + Serial.print(hAcc); + Serial.print(F(" (mm)")); + + Serial.println(); +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: printRXMCOR will be called when new RXM COR data arrives +// See u-blox_structs.h for the full definition of UBX_RXM_COR_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setRXMCORcallbackPtr +// / _____ This _must_ be UBX_RXM_COR_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void printRXMCOR(UBX_RXM_COR_data_t *ubxDataStruct) +{ + Serial.print(F("UBX-RXM-COR: ebno: ")); + Serial.print((double)ubxDataStruct->ebno / 8, 3); //Convert ebno to dB + + Serial.print(F(" protocol: ")); + if (ubxDataStruct->statusInfo.bits.protocol == 1) + Serial.print(F("RTCM3")); + else if (ubxDataStruct->statusInfo.bits.protocol == 2) + Serial.print(F("SPARTN")); + else if (ubxDataStruct->statusInfo.bits.protocol == 29) + Serial.print(F("PMP (SPARTN)")); + else if (ubxDataStruct->statusInfo.bits.protocol == 30) + Serial.print(F("QZSSL6")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" errStatus: ")); + if (ubxDataStruct->statusInfo.bits.errStatus == 1) + Serial.print(F("Error-free")); + else if (ubxDataStruct->statusInfo.bits.errStatus == 2) + Serial.print(F("Erroneous")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" msgUsed: ")); + if (ubxDataStruct->statusInfo.bits.msgUsed == 1) + Serial.print(F("Not used")); + else if (ubxDataStruct->statusInfo.bits.msgUsed == 2) + Serial.print(F("Used")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" msgEncrypted: ")); + if (ubxDataStruct->statusInfo.bits.msgEncrypted == 1) + Serial.print(F("Not encrypted")); + else if (ubxDataStruct->statusInfo.bits.msgEncrypted == 2) + Serial.print(F("Encrypted")); + else + Serial.print(F("Unknown")); + + Serial.print(F(" msgDecrypted: ")); + if (ubxDataStruct->statusInfo.bits.msgDecrypted == 1) + Serial.print(F("Not decrypted")); + else if (ubxDataStruct->statusInfo.bits.msgDecrypted == 2) + Serial.print(F("Successfully decrypted")); + else + Serial.print(F("Unknown")); + + Serial.println(); +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void setup() +{ + Serial.begin(115200); + Serial.println(F("NEO-D9S SPARTN Corrections")); + + serialGNSS.begin(38400); // UART2 on pins 16/17 for SPP. The ZED-F9P will be configured to use the same rate. + + Wire.begin(); //Start I2C + + //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + // Begin and configure the ZED-F9x + + //myGNSS.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + while (myGNSS.begin() == false) //Connect to the u-blox module using Wire port + { + Serial.println(F("u-blox GNSS module not detected at default I2C address. Please check wiring.")); + delay(2000); + } + Serial.println(F("u-blox GNSS module connected")); + + uint8_t ok = myGNSS.setI2COutput(COM_TYPE_UBX); //Turn off NMEA noise + if (ok) ok = myGNSS.setI2CInput(COM_TYPE_UBX); + if (ok) ok = myGNSS.setUART1Output(0); + if (ok) ok = myGNSS.setUART1Input(0); + if (ok) ok = myGNSS.setUART2Output(0); + if (ok) ok = myGNSS.setUART2Input(COM_TYPE_SPARTN); //Be sure SPARTN input is enabled + if (ok) ok = myGNSS.setDGNSSConfiguration(SFE_UBLOX_DGNSS_MODE_FIXED); // Set the differential mode - ambiguities are fixed whenever possible + if (ok) ok = myGNSS.setNavigationFrequency(1); //Set output in Hz. + if (ok) ok = myGNSS.setVal8(UBLOX_CFG_SPARTN_USE_SOURCE, 0); // Use "IP" source, not L-Band. We are injecting raw SPARTN, not PMP + if (ok) ok = myGNSS.setVal8(UBLOX_CFG_MSGOUT_UBX_RXM_COR_I2C, 1); // Enable UBX-RXM-COR messages on I2C + + //Configure the SPARTN IP Dynamic Keys + //"When the receiver boots, the host should send 'current' and 'next' keys in one message." - Use setDynamicSPARTNKeys for this. + //"Every time the 'current' key is expired, 'next' takes its place." + //"Therefore the host should then retrieve the new 'next' key and send only that." - Use setDynamicSPARTNKey for this. + // The key can be provided in binary (uint8_t) format or in ASCII Hex (char) format, but in both cases keyLengthBytes _must_ represent the binary key length in bytes. + if (ok) ok = myGNSS.setDynamicSPARTNKeys(currentKeyLengthBytes, currentKeyGPSWeek, currentKeyGPSToW, currentDynamicKey, + nextKeyLengthBytes, nextKeyGPSWeek, nextKeyGPSToW, nextDynamicKey); + + //if (ok) ok = myGNSS.saveConfiguration(VAL_CFG_SUBSEC_IOPORT | VAL_CFG_SUBSEC_MSGCONF); //Optional: Save the ioPort and message settings to NVM and BBR + + Serial.print(F("GNSS: configuration ")); + Serial.println(OK(ok)); + + myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata so we can watch the carrier solution go to fixed + + myGNSS.setRXMCORcallbackPtr(&printRXMCOR); // Print the contents of UBX-RXM-COR messages so we can check if the PMP data is being decrypted successfully + + //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + // Begin and configure the NEO-D9S L-Band receiver + + //myLBand.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + while (myLBand.begin(Wire, 0x43) == false) //Connect to the u-blox NEO-D9S using Wire port. The D9S default I2C address is 0x43 (not 0x42) + { + Serial.println(F("u-blox NEO-D9S not detected at default I2C address. Please check wiring.")); + delay(2000); + } + Serial.println(F("u-blox NEO-D9S connected")); + + myLBand.newCfgValset(); // Create a new Configuration Interface message - this defaults to VAL_LAYER_RAM_BBR (change in RAM and BBR) + myLBand.addCfgValset(UBLOX_CFG_PMP_CENTER_FREQUENCY, myLBandFreq); // Default 1539812500 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_SEARCH_WINDOW, 2200); // Default 2200 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_SERVICE_ID, 0); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_SERVICE_ID, 21845); // Default 50821 + myLBand.addCfgValset(UBLOX_CFG_PMP_DATA_RATE, 2400); // Default 2400 bps + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_DESCRAMBLER, 1); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_DESCRAMBLER_INIT, 26969); // Default 23560 + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_PRESCRAMBLING, 0); // Default 0 + myLBand.addCfgValset(UBLOX_CFG_PMP_UNIQUE_WORD, 16238547128276412563ull); + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C, 1); // Ensure UBX-RXM-PMP is enabled on the I2C port + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1, 1); // Output UBX-RXM-PMP on UART1 + myLBand.addCfgValset(UBLOX_CFG_UART2OUTPROT_UBX, 1); // Enable UBX output on UART2 + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2, 1); // Output UBX-RXM-PMP on UART2 + myLBand.addCfgValset(UBLOX_CFG_UART1_BAUDRATE, 38400); // match baudrate with ZED default + myLBand.addCfgValset(UBLOX_CFG_UART2_BAUDRATE, 38400); // match baudrate with ZED default + ok = myLBand.sendCfgValset(); // Apply the settings + + Serial.print(F("L-Band: configuration ")); + Serial.println(OK(ok)); + + myLBand.softwareResetGNSSOnly(); // Do a restart + + myLBand.setRXMPMPmessageCallbackPtr(&pushRXMPMP); // Call pushRXMPMP when new PMP data arrives. Push it to the GNSS + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void loop() +{ + myGNSS.checkUblox(); // Check for the arrival of new GNSS data and process it. + myGNSS.checkCallbacks(); // Check if any GNSS callbacks are waiting to be processed. + + myLBand.checkUblox(); // Check for the arrival of new PMP data and process it. + myLBand.checkCallbacks(); // Check if any LBand callbacks are waiting to be processed. +} diff --git a/examples/NEO-D9S_and_NEO-D9C/Example8_LBand_SPARTN_Parsing/secrets.h b/examples/NEO-D9S_and_NEO-D9C/Example8_LBand_SPARTN_Parsing/secrets.h new file mode 100644 index 0000000..06eeee4 --- /dev/null +++ b/examples/NEO-D9S_and_NEO-D9C/Example8_LBand_SPARTN_Parsing/secrets.h @@ -0,0 +1,27 @@ +// You can set the information below after signing up with the u-blox Thingstream portal +// and adding a new New PointPerfect Thing (L-Band or L-Band + IP) +// https://portal.thingstream.io/app/location-services/things +// In the new PointPerfect Thing, you go to the credentials tab and copy and paste the IP Dynamic Keys here. +// +// The keys are valid from a particular GPS Week Number and Time of Week. +// Looking at the credentials tab, the current key expires 23:59 Feb 11th 2022. +// This means the next key is valid _from_ Midnight Feb 12th 2022. +// That is GPS Week 2196. The GPS Time of Week in seconds is 518400. +// Working backwards, the current key became valid exactly 4 weeks earlier (Midnight Jan 15th 2022). +// +// See: https://www.labsat.co.uk/index.php/en/gps-time-calculator +// +// The keys are given as: 32 hexadecimal digits = 128 bits = 16 Bytes +// +// The next example shows how to retrieve the keys using ESP32 WiFi and MQTT. +// You can cut and paste the keys and GPS week/time-of-week from that example into here. + +const uint8_t currentKeyLengthBytes = 16; +const char currentDynamicKey[] = ""; +const uint16_t currentKeyGPSWeek = 2254; // Update this when you add new keys +const uint32_t currentKeyGPSToW = 0; + +const uint8_t nextKeyLengthBytes = 16; +const char nextDynamicKey[] = ""; +const uint16_t nextKeyGPSWeek = 2258; // Update this when you add new keys +const uint32_t nextKeyGPSToW = 0; diff --git a/examples/NEO-D9S_and_NEO-D9C/Example9_LBand_SPARTN_over_Serial/Example9_LBand_SPARTN_over_Serial.ino b/examples/NEO-D9S_and_NEO-D9C/Example9_LBand_SPARTN_over_Serial/Example9_LBand_SPARTN_over_Serial.ino new file mode 100644 index 0000000..5230204 --- /dev/null +++ b/examples/NEO-D9S_and_NEO-D9C/Example9_LBand_SPARTN_over_Serial/Example9_LBand_SPARTN_over_Serial.ino @@ -0,0 +1,141 @@ +/* + Use the NEO-D9S L-Band receiver to provide corrections as SPARTN data over Serial + By: SparkFun Electronics / Paul Clark + Based on original code by: u-blox AG / Michael Ammann + v3 updates: Decembe 22nd, 2022 + License: MIT. See license file for more information. + + This example shows how to obtain SPARTN correction data from a NEO-D9S L-Band receiver and push it over Serial (UART). + This example parses (extracts) SPARTN packets from the L-Band data stream and validates them before pushing. + + Feel like supporting open source hardware? + Buy a board from SparkFun! + ZED-F9P RTK2: https://www.sparkfun.com/products/16481 + NEO-D9S: https://www.sparkfun.com/products/19390 + Combo Board: https://www.sparkfun.com/products/20167 + + Hardware Connections: + Use a Qwiic cable to connect the NEO-D9S to your board + If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425) + Open the serial monitor at 115200 baud to see the output +*/ + +#include //Required for uart_set_rx_full_threshold() on cores //http://librarymanager/All#SparkFun_u-blox_GNSS_v3 +SFE_UBLOX_GNSS myLBand; // NEO-D9S + +const uint32_t myLBandFreq = 1556290000; // Uncomment this line to use the US SPARTN 1.8 service +//const uint32_t myLBandFreq = 1545260000; // Uncomment this line to use the EU SPARTN 1.8 service + +#define OK(ok) (ok ? F(" -> OK") : F(" -> ERROR!")) // Convert uint8_t into OK/ERROR + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// Callback: pushRXMPMP will be called when new PMP data arrives +// See u-blox_structs.h for the full definition of UBX_RXM_PMP_message_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setRXMPMPmessageCallbackPtr +// / _____ This _must_ be UBX_RXM_PMP_message_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void pushRXMPMP(UBX_RXM_PMP_message_data_t *pmpData) +{ + //Extract the raw message payload length + uint16_t payloadLen = ((uint16_t)pmpData->lengthMSB << 8) | (uint16_t)pmpData->lengthLSB; + + uint16_t numBytesUserData = pmpData->payload[2] | ((uint16_t)pmpData->payload[3] << 8); + uint16_t fecBits = pmpData->payload[20] | ((uint16_t)pmpData->payload[21] << 8); + float ebno = (float)pmpData->payload[22] / 8; + + Serial.print(F("New RXM-PMP data received. userData: ")); + Serial.print(numBytesUserData); + Serial.print(F(" Bytes. fecBits: ")); + Serial.print(fecBits); + Serial.print(F(". ebno (dB): ")); + Serial.print(ebno); + Serial.println(F(".")); + + //Parse the SPARTN data stream contained in the userData + for (uint16_t i = 0; i < numBytesUserData; i++) + { + bool valid = false; + uint16_t len; + uint8_t *spartn = myLBand.parseSPARTN(pmpData->payload[24 + i], valid, len); + + if (valid) + { + Serial.print(F("Valid SPARTN data parsed. Pushing ")); + Serial.print(len); + Serial.println(F(" bytes to Serial...")); + + serialGNSS.write(spartn, len); // Push the SPARTN data to the module using Serial + } + } + + (void)payloadLen; + //serialGNSS.write(&pmpData->sync1, (size_t)payloadLen + 6); // Push the sync chars, class, ID, length and payload + //serialGNSS.write(&pmpData->checksumA, (size_t)2); // Push the checksum bytes + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void setup() +{ + delay(1000); + + Serial.begin(115200); + Serial.println(F("NEO-D9S SPARTN Corrections")); + + serialGNSS.begin(38400); // UART2 on pins 16/17. + + Wire.begin(); //Start I2C + + //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + // Begin and configure the NEO-D9S L-Band receiver + + //myLBand.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + while (myLBand.begin(Wire, 0x43) == false) //Connect to the u-blox NEO-D9S using Wire port. The D9S default I2C address is 0x43 (not 0x42) + { + Serial.println(F("u-blox NEO-D9S not detected at default I2C address. Please check wiring.")); + delay(2000); + } + Serial.println(F("u-blox NEO-D9S connected")); + + myLBand.newCfgValset(); // Create a new Configuration Interface message - this defaults to VAL_LAYER_RAM_BBR (change in RAM and BBR) + myLBand.addCfgValset(UBLOX_CFG_PMP_CENTER_FREQUENCY, myLBandFreq); // Default 1539812500 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_SEARCH_WINDOW, 2200); // Default 2200 Hz + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_SERVICE_ID, 0); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_SERVICE_ID, 21845); // Default 50821 + myLBand.addCfgValset(UBLOX_CFG_PMP_DATA_RATE, 2400); // Default 2400 bps + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_DESCRAMBLER, 1); // Default 1 + myLBand.addCfgValset(UBLOX_CFG_PMP_DESCRAMBLER_INIT, 26969); // Default 23560 + myLBand.addCfgValset(UBLOX_CFG_PMP_USE_PRESCRAMBLING, 0); // Default 0 + myLBand.addCfgValset(UBLOX_CFG_PMP_UNIQUE_WORD, 16238547128276412563ull); + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C, 1); // Ensure UBX-RXM-PMP is enabled on the I2C port + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1, 1); // Output UBX-RXM-PMP on UART1 + myLBand.addCfgValset(UBLOX_CFG_UART2OUTPROT_UBX, 1); // Enable UBX output on UART2 + myLBand.addCfgValset(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2, 1); // Output UBX-RXM-PMP on UART2 + myLBand.addCfgValset(UBLOX_CFG_UART1_BAUDRATE, 38400); // match baudrate with ZED default + myLBand.addCfgValset(UBLOX_CFG_UART2_BAUDRATE, 38400); // match baudrate with ZED default + bool ok = myLBand.sendCfgValset(); // Apply the settings + + Serial.print(F("L-Band: configuration ")); + Serial.println(OK(ok)); + + myLBand.softwareResetGNSSOnly(); // Do a restart + + myLBand.setRXMPMPmessageCallbackPtr(&pushRXMPMP); // Call pushRXMPMP when new PMP data arrives. Push it to the GNSS + +} + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +void loop() +{ + myLBand.checkUblox(); // Check for the arrival of new PMP data and process it. + myLBand.checkCallbacks(); // Check if any LBand callbacks are waiting to be processed. +} diff --git a/examples/NEO-F10N/Example1_RAWX/Example1_RAWX.ino b/examples/NEO-F10N/Example1_RAWX/Example1_RAWX.ino new file mode 100644 index 0000000..030ccc1 --- /dev/null +++ b/examples/NEO-F10N/Example1_RAWX/Example1_RAWX.ino @@ -0,0 +1,263 @@ +/* + Configuring the NEO-F10N GNSS to send RXM RAWX reports over I2C and display them using a callback + By: Paul Clark + SparkFun Electronics + Date: November 24th, 2023 + License: MIT. See license file for more information. + + This example shows how to configure the u-blox NEO-F10N GNSS to send RXM RAWX reports automatically + and access the data via a callback. It also demonstrates how to mark the L5 signals as healthy. + + Feel like supporting open source hardware? + Buy a board from SparkFun! + NEO-F10N: https://www.sparkfun.com/products/24114 + + Hardware Connections: + Plug a Qwiic cable into the GPS and a BlackBoard + If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425) + Open the serial monitor at 115200 baud to see the output +*/ + +#include //Needed for I2C to GPS + +#include //http://librarymanager/All#SparkFun_u-blox_GNSS_v3 +SFE_UBLOX_GNSS myGNSS; + +// Callback: newRAWX will be called when new RXM RAWX data arrives +// See u-blox_structs.h for the full definition of UBX_RXMRAWX_data_t +// _____ You can use any name you like for the callback. Use the same name when you call setAutoRXMRAWXcallback +// / _____ This _must_ be UBX_RXM_RAWX_data_t +// | / _____ You can use any name you like for the struct +// | | / +// | | | +void newRAWX(UBX_RXM_RAWX_data_t *ubxDataStruct) +{ + Serial.println(); + + Serial.print(F("New RAWX data received. It contains ")); + Serial.print(ubxDataStruct->header.numMeas); // Print numMeas (Number of measurements / blocks) + Serial.println(F(" data blocks:")); + + for (uint8_t block = 0; block < ubxDataStruct->header.numMeas; block++) // For each block + { + char SV[14 + 4 + 4 + 256 + 1]; // Allocate space for sigId plus svId plus cno plus bars plus NULL + switch (ubxDataStruct->blocks[block].gnssId) + { + case 0: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "GPS L1 C/A "); + break; + case 3: + sprintf(SV, "GPS L2 CL "); + break; + case 4: + sprintf(SV, "GPS L2 CM "); + break; + case 6: + sprintf(SV, "GPS L5 I "); + break; + case 7: + sprintf(SV, "GPS L5 Q "); + break; + default: + sprintf(SV, "GPS Unknown "); + break; + } + } + break; + case 1: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "SBAS L1 C/A "); + break; + default: + sprintf(SV, "SBAS Unknown "); + break; + } + } + break; + case 2: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "Galileo E1 C "); + break; + case 1: + sprintf(SV, "Galileo E1 B "); + break; + case 3: + sprintf(SV, "Galileo E5 aI "); + break; + case 4: + sprintf(SV, "Galileo E5 aQ "); + break; + case 5: + sprintf(SV, "Galileo E5 bI "); + break; + case 6: + sprintf(SV, "Galileo E5 bQ "); + break; + default: + sprintf(SV, "GAL Unknown "); + break; + } + } + break; + case 3: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "BeiDou B1I D1 "); + break; + case 1: + sprintf(SV, "BeiDou B1I D2 "); + break; + case 2: + sprintf(SV, "BeiDou B2I D1 "); + break; + case 3: + sprintf(SV, "BeiDou B2I D2 "); + break; + case 5: + sprintf(SV, "BeiDou B1 Cp "); + break; + case 6: + sprintf(SV, "BeiDou B2 Cd "); + break; + case 7: + sprintf(SV, "BeiDou B2 ap "); + break; + case 8: + sprintf(SV, "BeiDou B2 ad "); + break; + default: + sprintf(SV, "BDS Unknown "); + break; + } + } + break; + case 5: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "QZSS L1 C/A "); + break; + case 1: + sprintf(SV, "QZSS L1S "); + break; + case 4: + sprintf(SV, "QZSS L2 CM "); + break; + case 5: + sprintf(SV, "QZSS L2 CL "); + break; + case 8: + sprintf(SV, "QZSS L5 I "); + break; + case 9: + sprintf(SV, "QZSS L5 Q "); + break; + default: + sprintf(SV, "QZSS Unknown "); + break; + } + } + break; + case 6: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "GLONASS L1 OF "); + break; + case 2: + sprintf(SV, "GLONASS L2 OF "); + break; + default: + sprintf(SV, "GLO Unknown "); + break; + } + } + break; + case 7: + { + switch (ubxDataStruct->blocks[block].sigId) + { + case 0: + sprintf(SV, "NavIC L5 A "); + break; + default: + sprintf(SV, "NavIC Unknown "); + break; + } + } + break; + default: + sprintf(SV, "Unknown "); + break; + } + + if (ubxDataStruct->blocks[block].svId < 10) sprintf(&SV[14], "%d ", ubxDataStruct->blocks[block].svId); // Align the svId + else if (ubxDataStruct->blocks[block].svId < 100) sprintf(&SV[14], "%d ", ubxDataStruct->blocks[block].svId); // Align the svId + else sprintf(&SV[14], "%d ", ubxDataStruct->blocks[block].svId); // Align the svId + + if (ubxDataStruct->blocks[block].cno < 10) sprintf(&SV[18], " %d ", ubxDataStruct->blocks[block].cno); // Align the svId + else if (ubxDataStruct->blocks[block].cno < 100) sprintf(&SV[18], " %d ", ubxDataStruct->blocks[block].cno); // Align the svId + else sprintf(&SV[18], "%d ", ubxDataStruct->blocks[block].cno); // Align the svId + + // Print cno as a bar chart + uint8_t cno; + for (cno = 0; cno <= ubxDataStruct->blocks[block].cno; cno++) + SV[22 + cno] = '='; + SV[22 + cno] = 0; // NULL + + Serial.println(SV); + } +} + +void setup() +{ + delay(1000); + + Serial.begin(115200); + while (!Serial); //Wait for user to open terminal + Serial.println("SparkFun u-blox Example"); + + Wire.begin(); + + //myGNSS.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial + + if (myGNSS.begin() == false) //Connect to the u-blox module using Wire port + { + Serial.println(F("u-blox GNSS not detected at default I2C address. Please check wiring. Freezing.")); + while (1); + } + + myGNSS.setGPSL5HealthOverride(true); // Mark L5 signals as healthy - store in RAM and BBR + + myGNSS.setLNAMode(SFE_UBLOX_LNA_MODE_NORMAL); // Set the LNA gain to normal (full). Other options: LOWGAIN, BYPASS + + myGNSS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise) + myGNSS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT); //Save (only) the communications port settings to flash and BBR + + myGNSS.setMeasurementRate(5000); //Produce one solution every five seconds (RAWX produces a _lot_ of data!) + + myGNSS.setAutoRXMRAWXcallbackPtr(&newRAWX); // Enable automatic RXM RAWX messages with callback to newRAWX +} + +void loop() +{ + myGNSS.checkUblox(); // Check for the arrival of new data and process it. + myGNSS.checkCallbacks(); // Check if any callbacks are waiting to be processed. + + Serial.print("."); + delay(50); +} diff --git a/keys/NEO-D9S_InterfaceDescription_UBX-19048765_keys_sorted.txt b/keys/u-blox-D9-PMP-1.04_InterfaceDescription_UBX-21040023_keys_sorted.txt similarity index 85% rename from keys/NEO-D9S_InterfaceDescription_UBX-19048765_keys_sorted.txt rename to keys/u-blox-D9-PMP-1.04_InterfaceDescription_UBX-21040023_keys_sorted.txt index 3196fea..f42c2e4 100644 --- a/keys/NEO-D9S_InterfaceDescription_UBX-19048765_keys_sorted.txt +++ b/keys/u-blox-D9-PMP-1.04_InterfaceDescription_UBX-21040023_keys_sorted.txt @@ -3,6 +3,7 @@ 0x10510002 0x10510003 0x10520005 +0x10520006 0x10530005 0x10530006 0x10640002 @@ -23,6 +24,10 @@ 0x107a0001 0x10a20001 0x10a20002 +0x10a30018 +0x10a30019 +0x10a30029 +0x10a3002c 0x10a3002e 0x10a3002f 0x10a30030 @@ -31,6 +36,7 @@ 0x10a30033 0x10a30034 0x10a30035 +0x10a30047 0x10b10014 0x10b10016 0x10b10019 @@ -86,6 +92,11 @@ 0x209101bb 0x209101bc 0x209101bd +0x20910209 +0x2091020a +0x2091020b +0x2091020c +0x2091020d 0x20910231 0x20910232 0x20910233 @@ -101,6 +112,16 @@ 0x2091031f 0x20910320 0x20910321 +0x20910322 +0x20910323 +0x20910324 +0x20910325 +0x20910326 +0x20910331 +0x20910332 +0x20910333 +0x20910334 +0x20910335 0x20920001 0x20920002 0x20920003 @@ -113,6 +134,7 @@ 0x2092000a 0x20a20003 0x20a20005 +0x20a30025 0x20a30036 0x20a30037 0x20a30038 @@ -130,6 +152,10 @@ 0x30b10017 0x40520001 0x40530001 +0x40a30028 +0x40a3002a +0x40a3002b +0x40a4000d 0x40b10011 0x40d0000f 0x5065000d diff --git a/keys/u-blox-F10-SPG-6.00_InterfaceDescription_UBX-23002975_keys_sorted.txt b/keys/u-blox-F10-SPG-6.00_InterfaceDescription_UBX-23002975_keys_sorted.txt new file mode 100644 index 0000000..cd0d0f8 --- /dev/null +++ b/keys/u-blox-F10-SPG-6.00_InterfaceDescription_UBX-23002975_keys_sorted.txt @@ -0,0 +1,371 @@ +0x10050007 +0x10050008 +0x10050009 +0x1005000a +0x1005000b +0x10110013 +0x10110025 +0x10110061 +0x101100d7 +0x10220001 +0x10220002 +0x10220003 +0x10220004 +0x10230001 +0x10310001 +0x10310004 +0x10310005 +0x10310007 +0x10310009 +0x1031000d +0x1031000f +0x10310012 +0x10310014 +0x10310017 +0x1031001d +0x1031001f +0x10310020 +0x10310021 +0x10310022 +0x10310024 +0x10310026 +0x10310028 +0x10340014 +0x10360002 +0x10360003 +0x10360004 +0x10360005 +0x10360007 +0x10370005 +0x10370006 +0x10370007 +0x1041000d +0x10410013 +0x10510002 +0x10510003 +0x10520005 +0x10640002 +0x10640003 +0x10640005 +0x10640006 +0x10710001 +0x10710002 +0x10720001 +0x10720002 +0x10730001 +0x10730002 +0x10740001 +0x10740002 +0x10790001 +0x10790002 +0x107a0001 +0x107a0002 +0x10930003 +0x10930004 +0x10930005 +0x10930006 +0x10930011 +0x10930012 +0x10930013 +0x10930015 +0x10930017 +0x10930018 +0x10930021 +0x10930022 +0x10930023 +0x10930024 +0x10930025 +0x10930026 +0x10a20001 +0x10a20002 +0x10a3002e +0x10a3002f +0x10a30030 +0x10a30031 +0x10a30032 +0x10a30033 +0x10a30034 +0x10a30035 +0x10c70001 +0x10c70002 +0x10f60009 +0x2005000c +0x20050023 +0x20050030 +0x20050035 +0x20110011 +0x2011001c +0x20110021 +0x201100a1 +0x201100a2 +0x201100a3 +0x201100a4 +0x201100aa +0x201100ab +0x201100c4 +0x201100d6 +0x20210003 +0x20220005 +0x20220021 +0x20220022 +0x20220031 +0x20220032 +0x20250038 +0x20410001 +0x20410002 +0x20410010 +0x20510001 +0x20520002 +0x20520003 +0x20520004 +0x20640001 +0x20910006 +0x20910007 +0x2091000a +0x20910010 +0x20910011 +0x20910014 +0x20910015 +0x20910016 +0x20910019 +0x2091001a +0x2091001b +0x2091001e +0x20910024 +0x20910025 +0x20910028 +0x20910029 +0x2091002a +0x2091002d +0x20910038 +0x20910039 +0x2091003c +0x2091003d +0x2091003e +0x20910041 +0x20910042 +0x20910043 +0x20910046 +0x20910047 +0x20910048 +0x2091004b +0x20910051 +0x20910052 +0x20910055 +0x20910056 +0x20910057 +0x2091005a +0x2091005b +0x2091005c +0x2091005f +0x20910060 +0x20910061 +0x20910064 +0x20910065 +0x20910066 +0x20910069 +0x2091006a +0x2091006b +0x2091006e +0x20910079 +0x2091007a +0x2091007d +0x2091007e +0x2091007f +0x20910082 +0x20910083 +0x20910084 +0x20910087 +0x20910092 +0x20910093 +0x20910096 +0x209100a6 +0x209100a7 +0x209100aa +0x209100ab +0x209100ac +0x209100af +0x209100b0 +0x209100b1 +0x209100b4 +0x209100b5 +0x209100b6 +0x209100b9 +0x209100ba +0x209100bb +0x209100be +0x209100bf +0x209100c0 +0x209100c3 +0x209100c4 +0x209100c5 +0x209100c8 +0x209100c9 +0x209100ca +0x209100cd +0x209100ce +0x209100cf +0x209100d2 +0x209100d3 +0x209100d4 +0x209100d7 +0x209100d8 +0x209100d9 +0x209100dc +0x209100dd +0x209100de +0x209100e1 +0x209100e7 +0x209100e8 +0x209100eb +0x209100ec +0x209100ed +0x209100f0 +0x209100f1 +0x209100f2 +0x209100f5 +0x209100f6 +0x209100f7 +0x209100fa +0x2091015f +0x20910160 +0x20910163 +0x20910178 +0x20910179 +0x2091017c +0x2091017d +0x2091017e +0x20910181 +0x20910187 +0x20910188 +0x2091018b +0x20910196 +0x20910197 +0x2091019a +0x209101a5 +0x209101a6 +0x209101a9 +0x209101b4 +0x209101b5 +0x209101b8 +0x209101b9 +0x209101ba +0x209101bd +0x20910204 +0x20910205 +0x20910208 +0x20910231 +0x20910232 +0x20910235 +0x2091025e +0x2091025f +0x20910262 +0x20910336 +0x20910337 +0x2091033a +0x20910345 +0x20910346 +0x20910349 +0x2091034f +0x20910350 +0x20910353 +0x20910354 +0x20910355 +0x20910358 +0x20910359 +0x2091035a +0x2091035d +0x20910386 +0x20910387 +0x2091038a +0x2091038b +0x2091038c +0x2091038f +0x20910400 +0x20910401 +0x20910404 +0x20910415 +0x20910416 +0x20910419 +0x20910634 +0x20910635 +0x20910638 +0x20910689 +0x2091068a +0x2091068d +0x2091069d +0x2091069e +0x209106a1 +0x209106a2 +0x209106a3 +0x209106a6 +0x20920001 +0x20920002 +0x20920005 +0x20920006 +0x20920007 +0x2092000a +0x20930001 +0x20930002 +0x20930007 +0x20930031 +0x20930032 +0x20a20003 +0x20a20005 +0x20a30036 +0x20a30037 +0x20a30038 +0x20a30054 +0x20a30055 +0x20a30056 +0x20a30057 +0x20c70003 +0x30050001 +0x30110017 +0x301100b1 +0x301100b2 +0x301100b3 +0x301100b4 +0x301100b5 +0x30210001 +0x30210002 +0x30230002 +0x3025003b +0x30360008 +0x30370008 +0x30930033 +0x30a20004 +0x30a3003c +0x30f6000a +0x30f6000b +0x40050002 +0x40050003 +0x40050004 +0x40050005 +0x40050006 +0x40050024 +0x40050025 +0x40110064 +0x40110065 +0x40110066 +0x40110067 +0x40110068 +0x40110069 +0x4011006a +0x401100c1 +0x401100c2 +0x40520001 +0x5005002a +0x5005002b +0x50110062 +0x50110063 +0x50180013 +0x50180014 +0x50180016 +0x50180017 +0x50180018 +0x50360006 +0x50c70004 +0x50c70005 +0x50c70006 +0x50c70007 diff --git a/keys/u-blox-F9-HPG-1.30_InterfaceDescription_UBX-21046737_keys_sorted.txt b/keys/u-blox-F9-HPG-1.32_InterfaceDescription_UBX-22008968_keys_sorted.txt similarity index 100% rename from keys/u-blox-F9-HPG-1.30_InterfaceDescription_UBX-21046737_keys_sorted.txt rename to keys/u-blox-F9-HPG-1.32_InterfaceDescription_UBX-22008968_keys_sorted.txt diff --git a/keys/u-blox-F9-HPG-L1L5-1.40_InterfaceDescription_UBX-23006991_keys_sorted.txt b/keys/u-blox-F9-HPG-L1L5-1.40_InterfaceDescription_UBX-23006991_keys_sorted.txt new file mode 100644 index 0000000..07669ad --- /dev/null +++ b/keys/u-blox-F9-HPG-L1L5-1.40_InterfaceDescription_UBX-23006991_keys_sorted.txt @@ -0,0 +1,845 @@ +0x10050007 +0x10050008 +0x10050009 +0x1005000a +0x1005000b +0x10110013 +0x10110025 +0x10110061 +0x101100d7 +0x10170001 +0x10170002 +0x10220001 +0x10220002 +0x10220003 +0x10220004 +0x10240012 +0x10240020 +0x10240030 +0x10240040 +0x10240050 +0x10310001 +0x10310004 +0x10310005 +0x10310007 +0x10310009 +0x1031000d +0x10310012 +0x10310014 +0x10310017 +0x10310018 +0x1031001d +0x1031001f +0x10310020 +0x10310021 +0x10310022 +0x10310024 +0x10310025 +0x10310026 +0x10310028 +0x10340014 +0x10360002 +0x10360003 +0x10360004 +0x10360005 +0x10360007 +0x10370005 +0x10370006 +0x10370007 +0x10510002 +0x10510003 +0x10520005 +0x10530005 +0x10640002 +0x10640003 +0x10640005 +0x10640006 +0x10650001 +0x10650002 +0x10710001 +0x10710002 +0x10710004 +0x10710005 +0x10720001 +0x10720002 +0x10720004 +0x10730001 +0x10730002 +0x10730004 +0x10730005 +0x10740001 +0x10740002 +0x10740004 +0x10750001 +0x10750002 +0x10750004 +0x10750005 +0x10760001 +0x10760002 +0x10760004 +0x10770001 +0x10770002 +0x10770004 +0x10770005 +0x10780001 +0x10780002 +0x10780004 +0x10790001 +0x10790002 +0x10790004 +0x10790005 +0x107a0001 +0x107a0002 +0x107a0004 +0x10930003 +0x10930004 +0x10930005 +0x10930006 +0x10930011 +0x10930012 +0x10930013 +0x10930015 +0x10930016 +0x10930017 +0x10930018 +0x10930021 +0x10930022 +0x10930023 +0x10930024 +0x10930025 +0x10930026 +0x10a20001 +0x10a20002 +0x10a3002e +0x10a3002f +0x10a30030 +0x10a30031 +0x10a30032 +0x10a30033 +0x10a30034 +0x10a30035 +0x10c70001 +0x10c70002 +0x10de0002 +0x10de0003 +0x10de0004 +0x10f60009 +0x10f60051 +0x20030001 +0x20030002 +0x20030006 +0x20030007 +0x20030008 +0x2003000c +0x2003000d +0x2003000e +0x2005000c +0x20050023 +0x20050030 +0x20050035 +0x20090009 +0x20110011 +0x2011001c +0x20110021 +0x201100a1 +0x201100a2 +0x201100a3 +0x201100a4 +0x201100aa +0x201100ab +0x201100c4 +0x20140011 +0x20210003 +0x20220005 +0x20220021 +0x20220022 +0x20220031 +0x20220032 +0x20240011 +0x20240013 +0x20240014 +0x20250038 +0x20510001 +0x20520002 +0x20520003 +0x20520004 +0x20530002 +0x20530003 +0x20530004 +0x20640001 +0x20910006 +0x20910007 +0x20910008 +0x20910009 +0x2091000a +0x20910010 +0x20910011 +0x20910012 +0x20910013 +0x20910014 +0x20910015 +0x20910016 +0x20910017 +0x20910018 +0x20910019 +0x2091001a +0x2091001b +0x2091001c +0x2091001d +0x2091001e +0x20910024 +0x20910025 +0x20910026 +0x20910027 +0x20910028 +0x20910029 +0x2091002a +0x2091002b +0x2091002c +0x2091002d +0x2091002e +0x2091002f +0x20910030 +0x20910031 +0x20910032 +0x20910033 +0x20910034 +0x20910035 +0x20910036 +0x20910037 +0x20910038 +0x20910039 +0x2091003a +0x2091003b +0x2091003c +0x2091003d +0x2091003e +0x2091003f +0x20910040 +0x20910041 +0x20910042 +0x20910043 +0x20910044 +0x20910045 +0x20910046 +0x20910047 +0x20910048 +0x20910049 +0x2091004a +0x2091004b +0x2091004c +0x2091004d +0x2091004e +0x2091004f +0x20910050 +0x20910051 +0x20910052 +0x20910053 +0x20910054 +0x20910055 +0x20910056 +0x20910057 +0x20910058 +0x20910059 +0x2091005a +0x2091005b +0x2091005c +0x2091005d +0x2091005e +0x2091005f +0x20910060 +0x20910061 +0x20910062 +0x20910063 +0x20910064 +0x20910065 +0x20910066 +0x20910067 +0x20910068 +0x20910069 +0x2091006a +0x2091006b +0x2091006c +0x2091006d +0x2091006e +0x2091007e +0x2091007f +0x20910080 +0x20910081 +0x20910082 +0x20910083 +0x20910084 +0x20910085 +0x20910086 +0x20910087 +0x20910088 +0x20910089 +0x2091008a +0x2091008b +0x2091008c +0x2091008d +0x2091008e +0x2091008f +0x20910090 +0x20910091 +0x20910092 +0x20910093 +0x20910094 +0x20910095 +0x20910096 +0x209100a1 +0x209100a2 +0x209100a3 +0x209100a4 +0x209100a5 +0x209100a6 +0x209100a7 +0x209100a8 +0x209100a9 +0x209100aa +0x209100ab +0x209100ac +0x209100ad +0x209100ae +0x209100af +0x209100b0 +0x209100b1 +0x209100b2 +0x209100b3 +0x209100b4 +0x209100b5 +0x209100b6 +0x209100b7 +0x209100b8 +0x209100b9 +0x209100ba +0x209100bb +0x209100bc +0x209100bd +0x209100be +0x209100bf +0x209100c0 +0x209100c1 +0x209100c2 +0x209100c3 +0x209100c4 +0x209100c5 +0x209100c6 +0x209100c7 +0x209100c8 +0x209100c9 +0x209100ca +0x209100cb +0x209100cc +0x209100cd +0x209100ce +0x209100cf +0x209100d0 +0x209100d1 +0x209100d2 +0x209100d3 +0x209100d4 +0x209100d5 +0x209100d6 +0x209100d7 +0x209100d8 +0x209100d9 +0x209100da +0x209100db +0x209100dc +0x209100dd +0x209100de +0x209100df +0x209100e0 +0x209100e1 +0x209100e7 +0x209100e8 +0x209100e9 +0x209100ea +0x209100eb +0x209100ec +0x209100ed +0x209100ee +0x209100ef +0x209100f0 +0x209100f1 +0x209100f2 +0x209100f3 +0x209100f4 +0x209100f5 +0x209100f6 +0x209100f7 +0x209100f8 +0x209100f9 +0x209100fa +0x2091015f +0x20910160 +0x20910161 +0x20910162 +0x20910163 +0x20910178 +0x20910179 +0x2091017a +0x2091017b +0x2091017c +0x2091017d +0x2091017e +0x2091017f +0x20910180 +0x20910181 +0x20910187 +0x20910188 +0x20910189 +0x2091018a +0x2091018b +0x20910196 +0x20910197 +0x20910198 +0x20910199 +0x2091019a +0x2091019b +0x2091019c +0x2091019d +0x2091019e +0x2091019f +0x209101a0 +0x209101a1 +0x209101a2 +0x209101a3 +0x209101a4 +0x209101a5 +0x209101a6 +0x209101a7 +0x209101a8 +0x209101a9 +0x209101b4 +0x209101b5 +0x209101b6 +0x209101b7 +0x209101b8 +0x209101b9 +0x209101ba +0x209101bb +0x209101bc +0x209101bd +0x20910204 +0x20910205 +0x20910206 +0x20910207 +0x20910208 +0x20910231 +0x20910232 +0x20910233 +0x20910234 +0x20910235 +0x20910259 +0x2091025a +0x2091025b +0x2091025c +0x2091025d +0x2091025e +0x2091025f +0x20910260 +0x20910261 +0x20910262 +0x20910268 +0x20910269 +0x2091026a +0x2091026b +0x2091026c +0x209102a4 +0x209102a5 +0x209102a6 +0x209102a7 +0x209102a8 +0x209102bd +0x209102be +0x209102bf +0x209102c0 +0x209102c1 +0x209102cc +0x209102cd +0x209102ce +0x209102cf +0x209102d0 +0x209102d1 +0x209102d2 +0x209102d3 +0x209102d4 +0x209102d5 +0x209102d6 +0x209102d7 +0x209102d8 +0x209102d9 +0x209102da +0x20910303 +0x20910304 +0x20910305 +0x20910306 +0x20910307 +0x20910318 +0x20910319 +0x2091031a +0x2091031b +0x2091031c +0x20910336 +0x20910337 +0x20910338 +0x20910339 +0x2091033a +0x20910345 +0x20910346 +0x20910347 +0x20910348 +0x20910349 +0x2091034f +0x20910350 +0x20910351 +0x20910352 +0x20910353 +0x20910354 +0x20910355 +0x20910356 +0x20910357 +0x20910358 +0x20910359 +0x2091035a +0x2091035b +0x2091035c +0x2091035d +0x2091035e +0x2091035f +0x20910360 +0x20910361 +0x20910362 +0x20910363 +0x20910364 +0x20910365 +0x20910366 +0x20910367 +0x20910368 +0x20910369 +0x2091036a +0x2091036b +0x2091036c +0x2091036d +0x2091036e +0x2091036f +0x20910370 +0x20910371 +0x20910386 +0x20910387 +0x20910388 +0x20910389 +0x2091038a +0x2091038b +0x2091038c +0x2091038d +0x2091038e +0x2091038f +0x20910400 +0x20910401 +0x20910402 +0x20910403 +0x20910404 +0x20910415 +0x20910416 +0x20910417 +0x20910418 +0x20910419 +0x20910430 +0x20910431 +0x20910432 +0x20910433 +0x20910434 +0x20910435 +0x20910436 +0x20910437 +0x20910438 +0x20910439 +0x20910465 +0x20910466 +0x20910467 +0x20910468 +0x20910469 +0x20910475 +0x20910476 +0x20910477 +0x20910478 +0x20910479 +0x20910480 +0x20910481 +0x20910482 +0x20910483 +0x20910484 +0x20910485 +0x20910486 +0x20910487 +0x20910488 +0x20910489 +0x20910490 +0x20910491 +0x20910492 +0x20910493 +0x20910494 +0x20910495 +0x20910496 +0x20910497 +0x20910498 +0x20910499 +0x20910500 +0x20910501 +0x20910502 +0x20910503 +0x20910504 +0x20910505 +0x20910506 +0x20910507 +0x20910508 +0x20910509 +0x20910510 +0x20910511 +0x20910512 +0x20910513 +0x20910514 +0x20910515 +0x20910516 +0x20910517 +0x20910518 +0x20910519 +0x20910520 +0x20910521 +0x20910522 +0x20910523 +0x20910524 +0x20910525 +0x20910526 +0x20910527 +0x20910528 +0x20910529 +0x20910530 +0x20910531 +0x20910532 +0x20910533 +0x20910534 +0x20910535 +0x20910536 +0x20910537 +0x20910538 +0x20910539 +0x20910540 +0x20910541 +0x20910542 +0x20910543 +0x20910544 +0x20910545 +0x20910546 +0x20910547 +0x20910548 +0x20910549 +0x20910550 +0x20910551 +0x20910552 +0x20910553 +0x20910554 +0x20910555 +0x20910556 +0x20910557 +0x20910558 +0x20910559 +0x20910560 +0x20910561 +0x20910562 +0x20910563 +0x20910564 +0x20910565 +0x20910566 +0x20910567 +0x20910568 +0x20910569 +0x20910575 +0x20910576 +0x20910577 +0x20910578 +0x20910579 +0x20910605 +0x20910606 +0x20910607 +0x20910608 +0x20910609 +0x20910634 +0x20910635 +0x20910636 +0x20910637 +0x20910638 +0x20910652 +0x20910653 +0x20910654 +0x20910655 +0x20910656 +0x20910657 +0x20910658 +0x20910659 +0x2091065a +0x2091065b +0x2091065c +0x2091065d +0x2091065e +0x2091065f +0x20910660 +0x20910661 +0x20910662 +0x20910663 +0x20910664 +0x20910665 +0x20910666 +0x20910667 +0x20910668 +0x20910669 +0x2091066a +0x20910670 +0x20910671 +0x20910672 +0x20910673 +0x20910674 +0x2091067f +0x20910680 +0x20910681 +0x20910682 +0x20910683 +0x20910689 +0x2091068a +0x2091068b +0x2091068c +0x2091068d +0x2091069d +0x2091069e +0x2091069f +0x209106a0 +0x209106a1 +0x209106a2 +0x209106a3 +0x209106a4 +0x209106a5 +0x209106a6 +0x209106a7 +0x209106a8 +0x209106a9 +0x209106aa +0x209106ab +0x209106b6 +0x209106b7 +0x209106b8 +0x209106b9 +0x209106ba +0x20920001 +0x20920002 +0x20920003 +0x20920004 +0x20920005 +0x20920006 +0x20920007 +0x20920008 +0x20920009 +0x2092000a +0x20930001 +0x20930002 +0x20930007 +0x20930031 +0x20930032 +0x20a20003 +0x20a20005 +0x20a30036 +0x20a30037 +0x20a30038 +0x20a30054 +0x20a30055 +0x20a30056 +0x20a70001 +0x20c70003 +0x30050001 +0x30090001 +0x30090008 +0x30110017 +0x301100b1 +0x301100b2 +0x301100b3 +0x301100b4 +0x301100b5 +0x30210001 +0x30210002 +0x3025003b +0x30360008 +0x30370008 +0x3065000a +0x3065000b +0x3065000c +0x30930033 +0x30a20004 +0x30a3003c +0x30de0005 +0x30de0006 +0x30de0007 +0x30f6000a +0x30f6000b +0x40030003 +0x40030004 +0x40030005 +0x40030009 +0x4003000a +0x4003000b +0x4003000f +0x40030010 +0x40030011 +0x40050002 +0x40050003 +0x40050004 +0x40050005 +0x40050006 +0x40050024 +0x40050025 +0x40110064 +0x40110065 +0x40110066 +0x40110067 +0x40110068 +0x40110069 +0x4011006a +0x401100c1 +0x401100c2 +0x40240021 +0x40240022 +0x40240023 +0x40240031 +0x40240032 +0x40240033 +0x40240041 +0x40240042 +0x40240043 +0x40240051 +0x40240052 +0x40240053 +0x40520001 +0x40530001 +0x40de0008 +0x5005002a +0x5005002b +0x50110062 +0x50110063 +0x50360006 +0x5065000d +0x5065000e +0x5065000f +0x50650010 +0x50650011 +0x50650012 +0x50650013 +0x50650014 +0x50650015 +0x50650016 +0x50650017 +0x50650018 +0x50c70004 +0x50c70005 +0x50c70006 +0x50c70007 diff --git a/keys/F9-HPS-1.21_InterfaceDescription_UBX-21019746_keys_sorted.txt b/keys/u-blox-F9-HPS-1.30_InterfaceDescription_UBX-22010984_keys_sorted.txt similarity index 75% rename from keys/F9-HPS-1.21_InterfaceDescription_UBX-21019746_keys_sorted.txt rename to keys/u-blox-F9-HPS-1.30_InterfaceDescription_UBX-22010984_keys_sorted.txt index ce066e9..4e4ead6 100644 --- a/keys/F9-HPS-1.21_InterfaceDescription_UBX-21019746_keys_sorted.txt +++ b/keys/u-blox-F9-HPS-1.30_InterfaceDescription_UBX-22010984_keys_sorted.txt @@ -14,10 +14,14 @@ 0x1007000f 0x10070010 0x10070011 +0x1007001c 0x10080001 0x10110013 0x10110025 0x10110061 +0x101100d7 +0x10170001 +0x10170002 0x10240012 0x10240020 0x10240030 @@ -31,6 +35,7 @@ 0x1031000d 0x1031000e 0x10310012 +0x10310014 0x10310015 0x10310018 0x1031001a @@ -45,8 +50,10 @@ 0x10360003 0x10360004 0x10360005 -0x1041000d -0x10410013 +0x10360007 +0x10370005 +0x10370006 +0x10370007 0x10510002 0x10510003 0x10520005 @@ -116,6 +123,7 @@ 0x10c70001 0x10c70002 0x10f60009 +0x10f60051 0x2005000c 0x20050023 0x20050030 @@ -146,9 +154,6 @@ 0x20240013 0x20240014 0x20250038 -0x20410001 -0x20410002 -0x20410010 0x20510001 0x20520002 0x20520003 @@ -462,6 +467,11 @@ 0x20910315 0x20910316 0x20910317 +0x20910336 +0x20910337 +0x20910338 +0x20910339 +0x2091033a 0x20910345 0x20910346 0x20910347 @@ -482,6 +492,11 @@ 0x2091035b 0x2091035c 0x2091035d +0x20910386 +0x20910387 +0x20910388 +0x20910389 +0x2091038a 0x2091038b 0x2091038c 0x2091038d @@ -492,6 +507,121 @@ 0x20910402 0x20910403 0x20910404 +0x20910415 +0x20910416 +0x20910417 +0x20910418 +0x20910419 +0x20910430 +0x20910431 +0x20910432 +0x20910433 +0x20910434 +0x20910435 +0x20910436 +0x20910437 +0x20910438 +0x20910439 +0x20910465 +0x20910466 +0x20910467 +0x20910468 +0x20910469 +0x20910470 +0x20910471 +0x20910472 +0x20910473 +0x20910474 +0x20910480 +0x20910481 +0x20910482 +0x20910483 +0x20910484 +0x20910485 +0x20910486 +0x20910487 +0x20910488 +0x20910489 +0x20910490 +0x20910491 +0x20910492 +0x20910493 +0x20910494 +0x20910495 +0x20910496 +0x20910497 +0x20910498 +0x20910499 +0x20910500 +0x20910501 +0x20910502 +0x20910503 +0x20910504 +0x20910505 +0x20910506 +0x20910507 +0x20910508 +0x20910509 +0x20910510 +0x20910511 +0x20910512 +0x20910513 +0x20910514 +0x20910515 +0x20910516 +0x20910517 +0x20910518 +0x20910519 +0x20910525 +0x20910526 +0x20910527 +0x20910528 +0x20910529 +0x20910530 +0x20910531 +0x20910532 +0x20910533 +0x20910534 +0x20910535 +0x20910536 +0x20910537 +0x20910538 +0x20910539 +0x20910540 +0x20910541 +0x20910542 +0x20910543 +0x20910544 +0x20910545 +0x20910546 +0x20910547 +0x20910548 +0x20910549 +0x20910550 +0x20910551 +0x20910552 +0x20910553 +0x20910554 +0x20910555 +0x20910556 +0x20910557 +0x20910558 +0x20910559 +0x20910560 +0x20910561 +0x20910562 +0x20910563 +0x20910564 +0x20910565 +0x20910566 +0x20910567 +0x20910568 +0x20910569 +0x20910575 +0x20910576 +0x20910577 +0x20910578 +0x20910579 0x20910605 0x20910606 0x20910607 @@ -502,11 +632,66 @@ 0x2091062c 0x2091062d 0x2091062e +0x2091062f +0x20910630 +0x20910631 +0x20910632 +0x20910633 0x20910634 0x20910635 0x20910636 0x20910637 0x20910638 +0x20910652 +0x20910653 +0x20910654 +0x20910655 +0x20910656 +0x20910657 +0x20910658 +0x20910659 +0x2091065a +0x2091065b +0x2091065c +0x2091065d +0x2091065e +0x2091065f +0x20910660 +0x20910661 +0x20910662 +0x20910663 +0x20910664 +0x20910665 +0x20910666 +0x20910667 +0x20910668 +0x20910669 +0x2091066a +0x20910670 +0x20910671 +0x20910672 +0x20910673 +0x20910674 +0x2091067f +0x20910680 +0x20910681 +0x20910682 +0x20910683 +0x20910689 +0x2091068a +0x2091068b +0x2091068c +0x2091068d +0x2091069d +0x2091069e +0x2091069f +0x209106a0 +0x209106a1 +0x209106b6 +0x209106b7 +0x209106b8 +0x209106b9 +0x209106ba 0x20920001 0x20920002 0x20920003 @@ -530,6 +715,9 @@ 0x20a30054 0x20a30055 0x20a30056 +0x20a30063 +0x20a30064 +0x20a70001 0x20c70003 0x30050001 0x30060007 @@ -551,6 +739,7 @@ 0x30210001 0x30210002 0x3025003b +0x30370008 0x3065000a 0x3065000b 0x3065000c diff --git a/keys/ZED-F9T-10B_InterfaceDescription_UBX-20033631_keys_sorted.txt b/keys/u-blox-F9-TIM-2.20_InterfaceDescription_UBX-21048598_keys_sorted.txt similarity index 91% rename from keys/ZED-F9T-10B_InterfaceDescription_UBX-20033631_keys_sorted.txt rename to keys/u-blox-F9-TIM-2.20_InterfaceDescription_UBX-21048598_keys_sorted.txt index a116d31..87947d3 100644 --- a/keys/ZED-F9T-10B_InterfaceDescription_UBX-20033631_keys_sorted.txt +++ b/keys/u-blox-F9-TIM-2.20_InterfaceDescription_UBX-21048598_keys_sorted.txt @@ -24,21 +24,28 @@ 0x10240040 0x10240050 0x10310001 +0x10310003 0x10310004 0x10310005 0x10310007 0x10310009 +0x1031000a 0x1031000d +0x1031000e 0x1031000f 0x10310012 +0x10310015 0x10310017 0x10310018 +0x1031001a +0x1031001d 0x1031001f 0x10310020 0x10310021 0x10310022 0x10310024 0x10310025 +0x10310026 0x10310028 0x10340014 0x10360002 @@ -51,7 +58,6 @@ 0x10510003 0x10520005 0x10530005 -0x10530006 0x10640002 0x10640003 0x10640005 @@ -98,6 +104,7 @@ 0x10930015 0x10930016 0x10930017 +0x10930018 0x10930021 0x10930022 0x10930023 @@ -456,6 +463,11 @@ 0x209102d8 0x209102d9 0x209102da +0x209102fe +0x209102ff +0x20910300 +0x20910301 +0x20910302 0x20910303 0x20910304 0x20910305 @@ -486,6 +498,26 @@ 0x2091035b 0x2091035c 0x2091035d +0x2091035e +0x2091035f +0x20910360 +0x20910361 +0x20910362 +0x20910363 +0x20910364 +0x20910365 +0x20910366 +0x20910367 +0x20910368 +0x20910369 +0x2091036a +0x2091036b +0x2091036c +0x2091036d +0x2091036e +0x2091036f +0x20910370 +0x20910371 0x20910381 0x20910382 0x20910383 @@ -656,6 +688,26 @@ 0x2091068b 0x2091068c 0x2091068d +0x2091069d +0x2091069e +0x2091069f +0x209106a0 +0x209106a1 +0x209106a2 +0x209106a3 +0x209106a4 +0x209106a5 +0x209106a6 +0x209106a7 +0x209106a8 +0x209106a9 +0x209106aa +0x209106ab +0x209106b6 +0x209106b7 +0x209106b8 +0x209106b9 +0x209106ba 0x20920001 0x20920002 0x20920003 @@ -755,6 +807,24 @@ 0x5005002d 0x50110062 0x50110063 +0x50180001 +0x50180002 +0x50180003 +0x50180004 +0x50180005 +0x50180006 +0x50180007 +0x50180008 +0x50180009 +0x5018000a +0x5018000b +0x5018000c +0x5018000d +0x5018000e +0x5018000f +0x50180010 +0x50180011 +0x50180012 0x50360006 0x5065000d 0x5065000e diff --git a/keys/u-blox_config_keys_sorted.txt b/keys/u-blox_config_keys_sorted.txt index 0e4a7a9..22273db 100644 --- a/keys/u-blox_config_keys_sorted.txt +++ b/keys/u-blox_config_keys_sorted.txt @@ -19,6 +19,7 @@ 0x1007000f 0x10070010 0x10070011 +0x1007001c 0x10080001 0x10110013 0x10110019 @@ -31,6 +32,7 @@ 0x10220002 0x10220003 0x10220004 +0x10230001 0x10240012 0x10240020 0x10240030 @@ -52,18 +54,21 @@ 0x10310017 0x10310018 0x1031001a +0x1031001d 0x1031001f 0x10310020 0x10310021 0x10310022 0x10310024 0x10310025 +0x10310026 0x10310028 0x10340014 0x10360002 0x10360003 0x10360004 0x10360005 +0x10360007 0x10370005 0x10370006 0x10370007 @@ -72,6 +77,7 @@ 0x10510002 0x10510003 0x10520005 +0x10520006 0x10530005 0x10530006 0x10640002 @@ -89,6 +95,7 @@ 0x10720004 0x10730001 0x10730002 +0x10730003 0x10730004 0x10730005 0x10740001 @@ -103,6 +110,7 @@ 0x10760004 0x10770001 0x10770002 +0x10770003 0x10770004 0x10770005 0x10780001 @@ -125,6 +133,7 @@ 0x10930015 0x10930016 0x10930017 +0x10930018 0x10930021 0x10930022 0x10930023 @@ -133,6 +142,10 @@ 0x10930026 0x10a20001 0x10a20002 +0x10a30018 +0x10a30019 +0x10a30029 +0x10a3002c 0x10a3002e 0x10a3002f 0x10a30030 @@ -141,6 +154,7 @@ 0x10a30033 0x10a30034 0x10a30035 +0x10a30047 0x10b10014 0x10b10016 0x10b10019 @@ -153,6 +167,7 @@ 0x10de0003 0x10de0004 0x10f60009 +0x10f60051 0x20030001 0x20030002 0x20030006 @@ -314,6 +329,9 @@ 0x2091006c 0x2091006d 0x2091006e +0x20910079 +0x2091007a +0x2091007d 0x2091007e 0x2091007f 0x20910080 @@ -504,6 +522,11 @@ 0x20910206 0x20910207 0x20910208 +0x20910209 +0x2091020a +0x2091020b +0x2091020c +0x2091020d 0x20910231 0x20910232 0x20910233 @@ -584,6 +607,16 @@ 0x2091031f 0x20910320 0x20910321 +0x20910322 +0x20910323 +0x20910324 +0x20910325 +0x20910326 +0x20910331 +0x20910332 +0x20910333 +0x20910334 +0x20910335 0x20910336 0x20910337 0x20910338 @@ -674,6 +707,11 @@ 0x20910467 0x20910468 0x20910469 +0x20910470 +0x20910471 +0x20910472 +0x20910473 +0x20910474 0x20910475 0x20910476 0x20910477 @@ -794,6 +832,11 @@ 0x2091062c 0x2091062d 0x2091062e +0x2091062f +0x20910630 +0x20910631 +0x20910632 +0x20910633 0x20910634 0x20910635 0x20910636 @@ -844,6 +887,16 @@ 0x2091069f 0x209106a0 0x209106a1 +0x209106a2 +0x209106a3 +0x209106a4 +0x209106a5 +0x209106a6 +0x209106a7 +0x209106a8 +0x209106a9 +0x209106aa +0x209106ab 0x209106b6 0x209106b7 0x209106b8 @@ -866,12 +919,16 @@ 0x20930032 0x20a20003 0x20a20005 +0x20a30025 0x20a30036 0x20a30037 0x20a30038 0x20a30054 0x20a30055 0x20a30056 +0x20a30057 +0x20a30063 +0x20a30064 0x20a70001 0x20c70003 0x20d0000b @@ -895,13 +952,16 @@ 0x301100b5 0x30210001 0x30210002 +0x30230002 0x3025003b +0x30360008 0x30370008 0x3065000a 0x3065000b 0x3065000c 0x30930033 0x30a20004 +0x30a3003c 0x30b10012 0x30b10013 0x30b10015 @@ -961,6 +1021,10 @@ 0x40240053 0x40520001 0x40530001 +0x40a30028 +0x40a3002a +0x40a3002b +0x40a4000d 0x40b10011 0x40d0000f 0x40de0008 @@ -970,6 +1034,29 @@ 0x5005002d 0x50110062 0x50110063 +0x50180001 +0x50180002 +0x50180003 +0x50180004 +0x50180005 +0x50180006 +0x50180007 +0x50180008 +0x50180009 +0x5018000a +0x5018000b +0x5018000c +0x5018000d +0x5018000e +0x5018000f +0x50180010 +0x50180011 +0x50180012 +0x50180013 +0x50180014 +0x50180016 +0x50180017 +0x50180018 0x50360006 0x5065000d 0x5065000e diff --git a/keywords.txt b/keywords.txt index 5c58569..6930897 100644 --- a/keywords.txt +++ b/keywords.txt @@ -244,6 +244,7 @@ setAopCfg KEYWORD2 setDynamicSPARTNKey KEYWORD2 setDynamicSPARTNKeys KEYWORD2 +parseSPARTN KEYWORD2 getUniqueChipId KEYWORD2 getUniqueChipIdStr KEYWORD2 @@ -478,6 +479,7 @@ setAutoRXMSFRBX KEYWORD2 setAutoRXMSFRBXrate KEYWORD2 setAutoRXMSFRBXcallback KEYWORD2 setAutoRXMSFRBXcallbackPtr KEYWORD2 +setAutoRXMSFRBXmessageCallbackPtr KEYWORD2 assumeAutoRXMSFRBX KEYWORD2 flushRXMSFRBX KEYWORD2 logRXMSFRBX KEYWORD2 @@ -719,6 +721,11 @@ getHNRroll KEYWORD2 getHNRpitch KEYWORD2 getHNRheading KEYWORD2 +getLNAMode KEYWORD2 +setLNAMode KEYWORD2 +getGPSL5HealthOverride KEYWORD2 +setGPSL5HealthOverride KEYWORD2 + setNMEALoggingMask KEYWORD2 getNMEALoggingMask KEYWORD2 setProcessNMEAMask KEYWORD2 @@ -926,6 +933,7 @@ UBX_NAV_TIMEGAL LITERAL1 UBX_NAV_TIMEGLO LITERAL1 UBX_NAV_TIMEGPS LITERAL1 UBX_NAV_TIMELS LITERAL1 +UBX_NAV_TIMENAVIC LITERAL1 UBX_NAV_TIMEUTC LITERAL1 UBX_NAV_VELECEF LITERAL1 UBX_NAV_VELNED LITERAL1 @@ -936,11 +944,14 @@ UBX_MON_HW3 LITERAL1 UBX_MON_HW LITERAL1 UBX_MON_IO LITERAL1 UBX_MON_MSGPP LITERAL1 +UBX_MON_PMP LITERAL1 +UBX_MON_PT2 LITERAL1 UBX_MON_RF LITERAL1 UBX_MON_RXBUF LITERAL1 UBX_MON_RXR LITERAL1 UBX_MON_SPAN LITERAL1 UBX_MON_SYS LITERAL1 +UBX_MON_TEMP LITERAL1 UBX_MON_TXBUF LITERAL1 UBX_RXM_PMP LITERAL1 diff --git a/library.properties b/library.properties index 3d1d2a3..c643e9a 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=SparkFun u-blox GNSS v3 -version=3.0.16 +version=3.1.0 author=SparkFun Electronics maintainer=SparkFun Electronics sentence=Library for I2C, Serial and SPI Communication with u-blox GNSS modules

diff --git a/src/u-blox_Class_and_ID.h b/src/u-blox_Class_and_ID.h index daf59d2..a505d46 100644 --- a/src/u-blox_Class_and_ID.h +++ b/src/u-blox_Class_and_ID.h @@ -226,11 +226,14 @@ const uint8_t UBX_MON_HW = 0x09; // Hardware Status const uint8_t UBX_MON_IO = 0x02; // I/O Subsystem Status const uint8_t UBX_MON_MSGPP = 0x06; // Message Parse and Process Status const uint8_t UBX_MON_PATCH = 0x27; // Output information about installed patches +const uint8_t UBX_MON_PMP = 0x35; // PMP monitoring data +const uint8_t UBX_MON_PT2 = 0x2B; // Multi-GNSS production test monitor const uint8_t UBX_MON_RF = 0x38; // RF information const uint8_t UBX_MON_RXBUF = 0x07; // Receiver Buffer Status const uint8_t UBX_MON_RXR = 0x21; // Receiver Status Information const uint8_t UBX_MON_SPAN = 0x31; // Signal characteristics const uint8_t UBX_MON_SYS = 0x39; // Current system performance information +const uint8_t UBX_MON_TEMP = 0x0E; // Temperature value and state const uint8_t UBX_MON_TXBUF = 0x08; // Transmitter Buffer Status. Used for query tx buffer size/state. const uint8_t UBX_MON_VER = 0x04; // Receiver/Software Version. Used for obtaining Protocol Version. @@ -265,6 +268,7 @@ const uint8_t UBX_NAV_TIMEGAL = 0x25; // Galileo Time Solution const uint8_t UBX_NAV_TIMEGLO = 0x23; // GLO Time Solution const uint8_t UBX_NAV_TIMEGPS = 0x20; // GPS Time Solution const uint8_t UBX_NAV_TIMELS = 0x26; // Leap second event information +const uint8_t UBX_NAV_TIMENAVIC = 0x63; // NavIC time solution const uint8_t UBX_NAV_TIMEUTC = 0x21; // UTC Time Solution const uint8_t UBX_NAV_VELECEF = 0x11; // Velocity Solution in ECEF const uint8_t UBX_NAV_VELNED = 0x12; // Velocity Solution in NED @@ -471,3 +475,11 @@ enum sfe_ublox_antenna_status_e SFE_UBLOX_ANTENNA_STATUS_SHORT, SFE_UBLOX_ANTENNA_STATUS_OPEN }; + +// NEO-F10N LNA Mode +enum sfe_ublox_lna_mode_e +{ + SFE_UBLOX_LNA_MODE_NORMAL, // Default - full gain + SFE_UBLOX_LNA_MODE_LOWGAIN, + SFE_UBLOX_LNA_MODE_BYPASS +}; diff --git a/src/u-blox_GNSS.cpp b/src/u-blox_GNSS.cpp index e3527ea..f366900 100644 --- a/src/u-blox_GNSS.cpp +++ b/src/u-blox_GNSS.cpp @@ -375,6 +375,10 @@ void DevUBLOXGNSS::end(void) { delete packetUBXRXMSFRBX->callbackData; } + if (packetUBXRXMSFRBX->callbackMessageData != nullptr) + { + delete[] packetUBXRXMSFRBX->callbackMessageData; + } delete packetUBXRXMSFRBX; packetUBXRXMSFRBX = nullptr; } @@ -465,7 +469,7 @@ void DevUBLOXGNSS::end(void) { if (packetUBXESFMEAS->callbackData != nullptr) { - delete packetUBXESFMEAS->callbackData; + delete[] packetUBXESFMEAS->callbackData; } delete packetUBXESFMEAS; packetUBXESFMEAS = nullptr; @@ -4117,11 +4121,42 @@ void DevUBLOXGNSS::processUBXpacket(ubxPacket *msg) packetUBXRXMSFRBX->moduleQueried = true; // Check if we need to copy the data for the callback - if ((packetUBXRXMSFRBX->callbackData != nullptr) // If RAM has been allocated for the copy of the data - && (packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid == false)) // AND the data is stale + if (packetUBXRXMSFRBX->callbackData != nullptr) // If RAM has been allocated for the copies of the data { - memcpy(&packetUBXRXMSFRBX->callbackData->gnssId, &packetUBXRXMSFRBX->data.gnssId, sizeof(UBX_RXM_SFRBX_data_t)); - packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid = true; + for (uint32_t i = 0; i < UBX_RXM_SFRBX_CALLBACK_BUFFERS; i++) // Check all available buffers + { + if ((packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid & (1 << i)) == 0) // AND the buffer is empty + { + memcpy(&packetUBXRXMSFRBX->callbackData[i].gnssId, &packetUBXRXMSFRBX->data.gnssId, sizeof(UBX_RXM_SFRBX_data_t)); + packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid |= (1 << i); + break; // Only copy once - into first available buffer + } + } + } + + // Check if we need to copy the data for the message callbacks + if (packetUBXRXMSFRBX->callbackMessageData != nullptr) // If RAM has been allocated for the copies of the data + { + for (uint32_t i = 0; i < UBX_RXM_SFRBX_CALLBACK_BUFFERS; i++) // Check all available buffers + { + if ((packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackMessageCopyValid & (1 << i)) == 0) // AND the buffer is empty + { + packetUBXRXMSFRBX->callbackMessageData[i].sync1 = UBX_SYNCH_1; + packetUBXRXMSFRBX->callbackMessageData[i].sync2 = UBX_SYNCH_2; + packetUBXRXMSFRBX->callbackMessageData[i].cls = UBX_CLASS_RXM; + packetUBXRXMSFRBX->callbackMessageData[i].ID = UBX_RXM_SFRBX; + packetUBXRXMSFRBX->callbackMessageData[i].lengthLSB = msg->len & 0xFF; + packetUBXRXMSFRBX->callbackMessageData[i].lengthMSB = msg->len >> 8; + + memcpy(&packetUBXRXMSFRBX->callbackMessageData[i].payload, msg->payload, msg->len); + + packetUBXRXMSFRBX->callbackMessageData[i].checksumA = msg->checksumA; + packetUBXRXMSFRBX->callbackMessageData[i].checksumB = msg->checksumB; + + packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackMessageCopyValid |= (1 << i); + break; // Only copy once - into first available buffer + } + } } // Check if we need to copy the data into the file buffer @@ -4431,11 +4466,17 @@ void DevUBLOXGNSS::processUBXpacket(ubxPacket *msg) packetUBXESFMEAS->data.calibTtag = extractLong(msg, 8 + (packetUBXESFMEAS->data.flags.bits.numMeas * 4)); // Check if we need to copy the data for the callback - if ((packetUBXESFMEAS->callbackData != nullptr) // If RAM has been allocated for the copy of the data - && (packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid == false)) // AND the data is stale + if (packetUBXESFMEAS->callbackData != nullptr) // If RAM has been allocated for the copy of the data { - memcpy(&packetUBXESFMEAS->callbackData->timeTag, &packetUBXESFMEAS->data.timeTag, sizeof(UBX_ESF_MEAS_data_t)); - packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid = true; + for (uint16_t i = 0; i < UBX_ESF_MEAS_CALLBACK_BUFFERS; i++) + { + if ((packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid & (1 << i)) == 0) // AND the data is stale + { + memcpy(&packetUBXESFMEAS->callbackData[i].timeTag, &packetUBXESFMEAS->data.timeTag, sizeof(UBX_ESF_MEAS_data_t)); + packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid |= (1 << i); + break; // Only copy once + } + } } // Check if we need to copy the data into the file buffer @@ -5789,16 +5830,37 @@ void DevUBLOXGNSS::checkCallbacks(void) packetUBXRXMCOR->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale } - if (packetUBXRXMSFRBX != nullptr) // If RAM has been allocated for message storage - if (packetUBXRXMSFRBX->callbackData != nullptr) // If RAM has been allocated for the copy of the data - if (packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid == true) // If the copy of the data is valid + if (packetUBXRXMSFRBX != nullptr) // If RAM has been allocated for message storage + { + if (packetUBXRXMSFRBX->callbackData != nullptr) // If RAM has been allocated for the copies of the data + { + for (uint32_t i = 0; i < UBX_RXM_SFRBX_CALLBACK_BUFFERS; i++) + { + if ((packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid & (1 << i)) != 0) // If the copy of the data is valid + { + if (packetUBXRXMSFRBX->callbackPointerPtr != nullptr) // If the pointer to the callback has been defined + { + packetUBXRXMSFRBX->callbackPointerPtr(&packetUBXRXMSFRBX->callbackData[i]); // Call the callback + } + packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid &= ~(1 << i); // Mark the data as stale + } + } + } + if (packetUBXRXMSFRBX->callbackMessageData != nullptr) // If RAM has been allocated for the copies of the data + { + for (uint32_t i = 0; i < UBX_RXM_SFRBX_CALLBACK_BUFFERS; i++) { - if (packetUBXRXMSFRBX->callbackPointerPtr != nullptr) // If the pointer to the callback has been defined + if ((packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackMessageCopyValid & (1 << i)) != 0) // If the copy of the data is valid { - packetUBXRXMSFRBX->callbackPointerPtr(packetUBXRXMSFRBX->callbackData); // Call the callback + if (packetUBXRXMSFRBX->callbackMessagePointerPtr != nullptr) // If the pointer to the callback has been defined + { + packetUBXRXMSFRBX->callbackMessagePointerPtr(&packetUBXRXMSFRBX->callbackMessageData[i]); // Call the callback + } + packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackMessageCopyValid &= ~(1 << i); // Mark the data as stale } - packetUBXRXMSFRBX->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale } + } + } if (packetUBXRXMRAWX != nullptr) // If RAM has been allocated for message storage if (packetUBXRXMRAWX->callbackData != nullptr) // If RAM has been allocated for the copy of the data @@ -5881,13 +5943,16 @@ void DevUBLOXGNSS::checkCallbacks(void) if (packetUBXESFMEAS != nullptr) // If RAM has been allocated for message storage if (packetUBXESFMEAS->callbackData != nullptr) // If RAM has been allocated for the copy of the data - if (packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid == true) // If the copy of the data is valid + for (uint16_t i = 0; i < UBX_ESF_MEAS_CALLBACK_BUFFERS; i++) { - if (packetUBXESFMEAS->callbackPointerPtr != nullptr) // If the pointer to the callback has been defined + if ((packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid & (1 << i)) != 0) // If the copy of the data is valid { - packetUBXESFMEAS->callbackPointerPtr(packetUBXESFMEAS->callbackData); // Call the callback + if (packetUBXESFMEAS->callbackPointerPtr != nullptr) // If the pointer to the callback has been defined + { + packetUBXESFMEAS->callbackPointerPtr(&packetUBXESFMEAS->callbackData[i]); // Call the callback + } + packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid &= ~(1 << i); // Mark the data as stale } - packetUBXESFMEAS->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale } if (packetUBXESFRAW != nullptr) // If RAM has been allocated for message storage @@ -6107,7 +6172,7 @@ bool DevUBLOXGNSS::pushRawData(uint8_t *dataBytes, size_t numDataBytes, bool cal bytesLeftToWrite -= (size_t)bytesToWrite; dataBytes += bytesToWrite; - if (callProcessBuffer) // Try and prevent data loss during large pushes by calling checkUbloxSerial between chunks + if (callProcessBuffer) // Try and prevent data loss during large pushes by calling checkUbloxSerial between chunks checkUbloxSerial(&packetCfg, 0, 0); // Don't call checkUbloxInternal as we already have the lock! } } @@ -8950,6 +9015,395 @@ bool DevUBLOXGNSS::setDynamicSPARTNKeys(uint8_t keyLengthBytes1, uint16_t validF return (sendCommand(&packetCfg, 0) == SFE_UBLOX_STATUS_SUCCESS); // UBX-RXM-SPARTNKEY is silent. It does not ACK (or NACK) } +// Support for SPARTN parsing +// Mostly stolen from https://github.com/u-blox/ubxlib/blob/master/common/spartn/src/u_spartn_crc.c + +uint8_t DevUBLOXGNSS::uSpartnCrc4(const uint8_t *pU8Msg, size_t size) +{ + // Initialize local variables + uint8_t u8TableRemainder; + uint8_t u8Remainder = 0; // Initial remainder + + // Compute the CRC value + // Divide each byte of the message by the corresponding polynomial + for (size_t x = 0; x < size; x++) { + u8TableRemainder = pU8Msg[x] ^ u8Remainder; + u8Remainder = sfe_ublox_u8Crc4Table[u8TableRemainder]; + } + + return u8Remainder; +} + +uint8_t DevUBLOXGNSS::uSpartnCrc8(const uint8_t *pU8Msg, size_t size) +{ + // Initialize local variables + uint8_t u8TableRemainder; + uint8_t u8Remainder = 0; // Initial remainder + + // Compute the CRC value + // Divide each byte of the message by the corresponding polynomial + for (size_t x = 0; x < size; x++) { + u8TableRemainder = pU8Msg[x] ^ u8Remainder; + u8Remainder = sfe_ublox_u8Crc8Table[u8TableRemainder]; + } + + return u8Remainder; +} + +uint16_t DevUBLOXGNSS::uSpartnCrc16(const uint8_t *pU8Msg, size_t size) +{ + // Initialize local variables + uint16_t u16TableRemainder; + uint16_t u16Remainder = 0; // Initial remainder + uint8_t u8NumBitsInCrc = (8 * sizeof(uint16_t)); + + // Compute the CRC value + // Divide each byte of the message by the corresponding polynomial + for (size_t x = 0; x < size; x++) { + u16TableRemainder = pU8Msg[x] ^ (u16Remainder >> (u8NumBitsInCrc - 8)); + u16Remainder = sfe_ublox_u16Crc16Table[u16TableRemainder] ^ (u16Remainder << 8); + } + + return u16Remainder; +} + +uint32_t DevUBLOXGNSS::uSpartnCrc24(const uint8_t *pU8Msg, size_t size) +{ + // Initialize local variables + uint32_t u32TableRemainder; + uint32_t u32Remainder = 0; // Initial remainder + uint8_t u8NumBitsInCrc = (8 * sizeof(uint8_t) * 3); + + // Compute the CRC value + // Divide each byte of the message by the corresponding polynomial + for (size_t x = 0; x < size; x++) { + u32TableRemainder = pU8Msg[x] ^ (u32Remainder >> (u8NumBitsInCrc - 8)); + u32Remainder = sfe_ublox_u32Crc24Table[u32TableRemainder] ^ (u32Remainder << 8); + u32Remainder = u32Remainder & 0x00FFFFFF; // Only interested in 24 bits + } + + return u32Remainder; +} + +uint32_t DevUBLOXGNSS::uSpartnCrc32(const uint8_t *pU8Msg, size_t size) +{ + // Initialize local variables + uint32_t u32TableRemainder; + uint32_t u32Remainder = 0xFFFFFFFFU; // Initial remainder + uint8_t u8NumBitsInCrc = (8 * sizeof(uint32_t)); + uint32_t u32FinalXORValue = 0xFFFFFFFFU; + + // Compute the CRC value + // Divide each byte of the message by the corresponding polynomial + for (size_t x = 0; x < size; x++) { + u32TableRemainder = pU8Msg[x] ^ (u32Remainder >> (u8NumBitsInCrc - 8)); + u32Remainder = sfe_ublox_u32Crc32Table[u32TableRemainder] ^ (u32Remainder << 8); + } + + u32Remainder = u32Remainder ^ u32FinalXORValue; + + return u32Remainder; +} + +// Parse SPARTN data +uint8_t * DevUBLOXGNSS::parseSPARTN(uint8_t incoming, bool &valid, uint16_t &len) +{ + typedef enum { + waitingFor73, + TF002_TF006, + TF007, + TF009, + TF016, + TF017, + TF018 + } parseStates; + static parseStates parseState = waitingFor73; + + static uint8_t spartn[1100]; + + static uint16_t frameCount; + static uint8_t messageType; + static uint16_t payloadLength; + static uint16_t EAF; + static uint8_t crcType; + static uint16_t crcBytes; + static uint8_t frameCRC; + static uint8_t messageSubtype; + static uint16_t timeTagType; + static uint16_t authenticationIndicator; + static uint16_t embeddedApplicationLengthBytes; + static uint16_t TF007toTF016; + + valid = false; + + switch(parseState) + { + case waitingFor73: + if (incoming == 0x73) + { + parseState = TF002_TF006; + frameCount = 0; + spartn[0] = incoming; + } + break; + case TF002_TF006: + spartn[1 + frameCount] = incoming; + if (frameCount == 0) + { + messageType = incoming >> 1; + payloadLength = incoming & 0x01; + } + if (frameCount == 1) + { + payloadLength <<= 8; + payloadLength |= incoming; + } + if (frameCount == 2) + { + payloadLength <<= 1; + payloadLength |= incoming >> 7; + EAF = (incoming >> 6) & 0x01; + crcType = (incoming >> 4) & 0x03; + switch (crcType) + { + case 0: + crcBytes = 1; + break; + case 1: + crcBytes = 2; + break; + case 2: + crcBytes = 3; + break; + default: + crcBytes = 4; + break; + } + frameCRC = incoming & 0x0F; + spartn[3] = spartn[3] & 0xF0; // Zero the 4 LSBs before calculating the CRC + if (uSpartnCrc4(&spartn[1], 3) == frameCRC) + { + spartn[3] = incoming; // Restore TF005 and TF006 now we know the data is valid + parseState = TF007; +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.print(F("SPARTN Header CRC is valid: payloadLength ")); + _debugSerial.print(payloadLength); + _debugSerial.print(F(" EAF ")); + _debugSerial.print(EAF); + _debugSerial.print(F(" crcType ")); + _debugSerial.println(crcType); + } +#endif + } + else + { + parseState = waitingFor73; +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.println(F("SPARTN Header CRC is INVALID")); + } +#endif + } + } + frameCount++; + break; + case TF007: + spartn[4] = incoming; + messageSubtype = incoming >> 4; + timeTagType = (incoming >> 3) & 0x01; +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.print(F("SPARTN timeTagType ")); + _debugSerial.println(timeTagType); + } +#endif + if (timeTagType == 0) + TF007toTF016 = 4; + else + TF007toTF016 = 6; + if (EAF > 0) + TF007toTF016 += 2; + parseState = TF009; + frameCount = 1; + break; + case TF009: + spartn[4 + frameCount] = incoming; + frameCount++; + if (frameCount == TF007toTF016) + { + if (EAF == 0) + { + authenticationIndicator = 0; + embeddedApplicationLengthBytes = 0; + } + else + { + authenticationIndicator = (incoming >> 3) & 0x07; +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.print(F("SPARTN authenticationIndicator ")); + _debugSerial.println(authenticationIndicator); + } +#endif + if (authenticationIndicator <= 1) + embeddedApplicationLengthBytes = 0; + else + { + switch(incoming & 0x07) + { + case 0: + embeddedApplicationLengthBytes = 8; // 64 bits + break; + case 1: + embeddedApplicationLengthBytes = 12; // 96 bits + break; + case 2: + embeddedApplicationLengthBytes = 16; // 128 bits + break; + case 3: + embeddedApplicationLengthBytes = 32; // 256 bits + break; + default: + embeddedApplicationLengthBytes = 64; // 512 / TBD bits + break; + } + } +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.print(F("SPARTN embeddedApplicationLengthBytes ")); + _debugSerial.println(embeddedApplicationLengthBytes); + } +#endif + } + parseState = TF016; + frameCount = 0; + } + break; + case TF016: + spartn[4 + TF007toTF016 + frameCount] = incoming; + frameCount++; + if (frameCount == payloadLength) + { + if (embeddedApplicationLengthBytes > 0) + { + parseState = TF017; + frameCount = 0; + } + else + { + parseState = TF018; + frameCount = 0; + } + } + break; + case TF017: + spartn[4 + TF007toTF016 + payloadLength + frameCount] = incoming; + frameCount++; + if (frameCount == embeddedApplicationLengthBytes) + { + parseState = TF018; + frameCount = 0; + } + break; + case TF018: + spartn[4 + TF007toTF016 + payloadLength + embeddedApplicationLengthBytes + frameCount] = incoming; + frameCount++; + if (frameCount == crcBytes) + { + parseState = waitingFor73; + uint16_t numBytes = 4 + TF007toTF016 + payloadLength + embeddedApplicationLengthBytes; +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.print(F("SPARTN numBytes ")); + _debugSerial.println(numBytes); + } +#endif + uint8_t *ptr = &spartn[numBytes]; + switch (crcType) + { + case 0: + { + uint8_t expected = *ptr; + if (uSpartnCrc8(&spartn[1], numBytes - 1) == expected) // Don't include the preamble in the CRC + { + valid = true; + len = numBytes + 1; + } + } + break; + case 1: + { + uint16_t expected = *ptr++; + expected <<= 8; + expected |= *ptr; + if (uSpartnCrc16(&spartn[1], numBytes - 1) == expected) // Don't include the preamble in the CRC + { + valid = true; + len = numBytes + 2; + } + } + break; + case 2: + { + uint32_t expected = *ptr++; + expected <<= 8; + expected |= *ptr++; + expected <<= 8; + expected |= *ptr; + uint32_t crc = uSpartnCrc24(&spartn[1], numBytes - 1); // Don't include the preamble in the CRC + if (crc == expected) + { + valid = true; + len = numBytes + 3; + } + else + { +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if (_printDebug == true) + { + _debugSerial.print(F("SPARTN CRC-24 is INVALID: 0x")); + _debugSerial.print(expected, HEX); + _debugSerial.print(F(" vs 0x")); + _debugSerial.println(crc, HEX); + } +#endif + } + } + break; + default: + { + uint32_t expected = *ptr++; + expected <<= 8; + expected |= *ptr++; + expected <<= 8; + expected |= *ptr++; + expected <<= 8; + expected |= *ptr; + if (uSpartnCrc32(&spartn[1], numBytes - 1) == expected) + { + valid = true; + len = numBytes + 4; + } + } + break; + } + } + break; + } + + (void)messageType; // Avoid pesky compiler warnings-as-errors + (void)messageSubtype; + + return &spartn[0]; +} + // Get the unique chip ID using UBX-SEC-UNIQID // The ID is five bytes on the F9 and M9 (version 1) but six bytes on the M10 (version 2) bool DevUBLOXGNSS::getUniqueChipId(UBX_SEC_UNIQID_data_t *data, uint16_t maxWait) @@ -9015,7 +9469,6 @@ const char *DevUBLOXGNSS::getUniqueChipIdStr(UBX_SEC_UNIQID_data_t *data, uint16 return ((const char *)uniqueId); } - // CONFIGURATION INTERFACE (protocol v27 and above) // Given a key, load the payload with data that can then be extracted to 8, 16, or 32 bits @@ -13117,7 +13570,7 @@ bool DevUBLOXGNSS::setAutoRXMSFRBXcallbackPtr(void (*callbackPointerPtr)(UBX_RXM if (packetUBXRXMSFRBX->callbackData == nullptr) // Check if RAM has been allocated for the callback copy { - packetUBXRXMSFRBX->callbackData = new UBX_RXM_SFRBX_data_t; // Allocate RAM for the main struct + packetUBXRXMSFRBX->callbackData = new UBX_RXM_SFRBX_data_t[UBX_RXM_SFRBX_CALLBACK_BUFFERS]; // Allocate RAM for the main struct } if (packetUBXRXMSFRBX->callbackData == nullptr) @@ -13132,6 +13585,31 @@ bool DevUBLOXGNSS::setAutoRXMSFRBXcallbackPtr(void (*callbackPointerPtr)(UBX_RXM packetUBXRXMSFRBX->callbackPointerPtr = callbackPointerPtr; return (true); } +// Use this if you want all of the SFRBX message (including sync chars, checksum, etc.) to push to the PointPerfect Library +bool DevUBLOXGNSS::setAutoRXMSFRBXmessageCallbackPtr(void (*callbackMessagePointerPtr)(UBX_RXM_SFRBX_message_data_t *), uint8_t layer, uint16_t maxWait) +{ + // Enable auto messages. Set implicitUpdate to false as we expect the user to call checkUblox manually. + bool result = setAutoRXMSFRBX(true, false, layer, maxWait); + if (!result) + return (result); // Bail if setAuto failed + + if (packetUBXRXMSFRBX->callbackMessageData == nullptr) // Check if RAM has been allocated for the callback copy + { + packetUBXRXMSFRBX->callbackMessageData = new UBX_RXM_SFRBX_message_data_t[UBX_RXM_SFRBX_CALLBACK_BUFFERS]; // Allocate RAM for the main struct + } + + if (packetUBXRXMSFRBX->callbackMessageData == nullptr) + { +#ifndef SFE_UBLOX_REDUCED_PROG_MEM + if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging + _debugSerial.println(F("setAutoRXMSFRBXmessageCallbackPtr: RAM alloc failed!")); +#endif + return (false); + } + + packetUBXRXMSFRBX->callbackMessagePointerPtr = callbackMessagePointerPtr; + return (true); +} // In case no config access to the GNSS is possible and SFRBX is send cyclically already // set config to suitable parameters @@ -13166,6 +13644,8 @@ bool DevUBLOXGNSS::initPacketUBXRXMSFRBX() packetUBXRXMSFRBX->automaticFlags.flags.all = 0; packetUBXRXMSFRBX->callbackPointerPtr = nullptr; packetUBXRXMSFRBX->callbackData = nullptr; + packetUBXRXMSFRBX->callbackMessagePointerPtr = nullptr; + packetUBXRXMSFRBX->callbackMessageData = nullptr; packetUBXRXMSFRBX->moduleQueried = false; return (true); } @@ -14611,7 +15091,7 @@ bool DevUBLOXGNSS::setAutoESFMEAScallbackPtr(void (*callbackPointerPtr)(UBX_ESF_ if (packetUBXESFMEAS->callbackData == nullptr) // Check if RAM has been allocated for the callback copy { - packetUBXESFMEAS->callbackData = new UBX_ESF_MEAS_data_t; // Allocate RAM for the main struct + packetUBXESFMEAS->callbackData = new UBX_ESF_MEAS_data_t[UBX_ESF_MEAS_CALLBACK_BUFFERS]; // Allocate RAM for the main struct } if (packetUBXESFMEAS->callbackData == nullptr) @@ -17795,6 +18275,24 @@ sfe_ublox_antenna_status_e DevUBLOXGNSS::getAntennaStatus(uint16_t maxWait) return ((sfe_ublox_antenna_status_e)packetUBXMONHW->data.aStatus); } +// ***** Helper functions for the NEO-F10N +bool DevUBLOXGNSS::getLNAMode(sfe_ublox_lna_mode_e *mode, uint8_t layer, uint16_t maxWait) +{ + return getVal8(UBLOX_CFG_HW_RF_LNA_MODE, (uint8_t *)mode, layer, maxWait); // Get the LNA mode +} +bool DevUBLOXGNSS::setLNAMode(sfe_ublox_lna_mode_e mode, uint8_t layer, uint16_t maxWait) +{ + return setVal8(UBLOX_CFG_HW_RF_LNA_MODE, (uint8_t)mode, layer, maxWait); // Set the LNA mode +} +bool DevUBLOXGNSS::getGPSL5HealthOverride(bool *override, uint8_t layer, uint16_t maxWait) +{ + return getVal8(UBLOX_CFG_SIGNAL_GPS_L5_HEALTH_OVERRIDE, (uint8_t *) override, layer, maxWait); // Get the GPS L5 health override status +} +bool DevUBLOXGNSS::setGPSL5HealthOverride(bool override, uint8_t layer, uint16_t maxWait) +{ + return setVal8(UBLOX_CFG_SIGNAL_GPS_L5_HEALTH_OVERRIDE, (uint8_t) override, layer, maxWait); // Set the GPS L5 health override status +} + #ifndef SFE_UBLOX_DISABLE_ESF // ***** ESF Helper Functions diff --git a/src/u-blox_GNSS.h b/src/u-blox_GNSS.h index 6b40e8f..101b4c6 100644 --- a/src/u-blox_GNSS.h +++ b/src/u-blox_GNSS.h @@ -386,6 +386,7 @@ class DevUBLOXGNSS bool setDGNSSConfiguration(sfe_ublox_dgnss_mode_e dgnssMode = SFE_UBLOX_DGNSS_MODE_FIXED, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Set the DGNSS differential mode // Read the module's protocol version + // For safety, call getProtocolVersion etc. inside an if(getModuleInfo()) uint8_t getProtocolVersionHigh(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the PROTVER XX.00 from UBX-MON-VER register uint8_t getProtocolVersionLow(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the PROTVER 00.XX from UBX-MON-VER register uint8_t getFirmwareVersionHigh(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the FWVER XX.00 from UBX-MON-VER register @@ -393,7 +394,7 @@ class DevUBLOXGNSS const char *getFirmwareType(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the firmware type (SPG, HPG, ADR, etc.) from UBX-MON-VER register const char *getModuleName(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the module name (ZED-F9P, ZED-F9R, etc.) from UBX-MON-VER register bool getProtocolVersion(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Deprecated. Use getModuleInfo. - bool getModuleInfo(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Queries module, extracts info + bool getModuleInfo(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Queries module, extracts info. Returns true if MON-VER was read successfully protected: bool prepareModuleInfo(uint16_t maxWait); @@ -463,6 +464,14 @@ class DevUBLOXGNSS bool setDynamicSPARTNKeys(uint8_t keyLengthBytes1, uint16_t validFromWno1, uint32_t validFromTow1, const uint8_t *key1, uint8_t keyLengthBytes2, uint16_t validFromWno2, uint32_t validFromTow2, const uint8_t *key2); + // Support for SPARTN parsing + uint8_t uSpartnCrc4(const uint8_t *pU8Msg, size_t size); + uint8_t uSpartnCrc8(const uint8_t *pU8Msg, size_t size); + uint16_t uSpartnCrc16(const uint8_t *pU8Msg, size_t size); + uint32_t uSpartnCrc24(const uint8_t *pU8Msg, size_t size); + uint32_t uSpartnCrc32(const uint8_t *pU8Msg, size_t size); + uint8_t * parseSPARTN(uint8_t incoming, bool &valid, uint16_t &len); + // Get unique chip ID - UBX-SEC-UNIQID bool getUniqueChipId(UBX_SEC_UNIQID_data_t *data = nullptr, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Get the unique chip ID using UBX_SEC_UNIQID const char *getUniqueChipIdStr(UBX_SEC_UNIQID_data_t *data = nullptr, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Get the unique chip ID using UBX_SEC_UNIQID @@ -927,11 +936,13 @@ class DevUBLOXGNSS bool setRXMCORcallbackPtr(void (*callbackPointerPtr)(UBX_RXM_COR_data_t *)); // RXM COR + // Note: RXM-SFRBX is output-only. It cannot be polled. Strictly getRXMSFRBX should be deprecated bool getRXMSFRBX(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // RXM SFRBX bool setAutoRXMSFRBX(bool enabled, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Enable/disable automatic RXM SFRBX reports at the navigation frequency bool setAutoRXMSFRBX(bool enabled, bool implicitUpdate, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Enable/disable automatic RXM SFRBX reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update bool setAutoRXMSFRBXrate(uint8_t rate, bool implicitUpdate = true, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Set the rate for automatic SFRBX reports bool setAutoRXMSFRBXcallbackPtr(void (*callbackPointerPtr)(UBX_RXM_SFRBX_data_t *), uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Enable automatic SFRBX reports at the navigation frequency. Data is accessed from the callback. + bool setAutoRXMSFRBXmessageCallbackPtr(void (*callbackMessagePointerPtr)(UBX_RXM_SFRBX_message_data_t *), uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Use this if you want all of the SFRBX message (including sync chars, checksum, etc.) to push to the PointPerfect Library bool assumeAutoRXMSFRBX(bool enabled, bool implicitUpdate = true); // In case no config access to the GPS is possible and RXM SFRBX is send cyclically already void flushRXMSFRBX(); // Mark all the data as read/stale void logRXMSFRBX(bool enabled = true); // Log data to file buffer @@ -1078,6 +1089,7 @@ class DevUBLOXGNSS uint16_t getNavigationRate(uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Unsafe overload // Helper functions for DOP + // For safety, call these inside an if(getDOP()) uint16_t getGeometricDOP(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); uint16_t getPositionDOP(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); @@ -1088,12 +1100,14 @@ class DevUBLOXGNSS uint16_t getEastingDOP(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Helper functions for ATT + // For safety, call these inside an if(getNAVATT()) float getATTroll(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as degrees float getATTpitch(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as degrees float getATTheading(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as degrees // Helper functions for PVT + // For safety, call these inside an if(getPVT()) uint32_t getTimeOfWeek(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); uint16_t getYear(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); @@ -1145,6 +1159,7 @@ class DevUBLOXGNSS int32_t getGeoidSeparation(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Helper functions for HPPOSECEF + // For safety, call these inside an if(getNAVHPPOSECEF()) uint32_t getPositionAccuracy(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the 3D accuracy of the current high-precision fix, in mm. Supported on NEO-M8P, ZED-F9P, int32_t getHighResECEFX(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the ECEF X coordinate (cm) @@ -1155,6 +1170,7 @@ class DevUBLOXGNSS int8_t getHighResECEFZHp(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the ECEF Z coordinate High Precision Component (0.1 mm) // Helper functions for HPPOSLLH + // For safety, call these inside an if(getHPPOSLLH()) uint32_t getTimeOfWeekFromHPPOSLLH(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); int32_t getHighResLongitude(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); @@ -1169,6 +1185,7 @@ class DevUBLOXGNSS uint32_t getVerticalAccuracy(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Helper functions for PVAT + // For safety, call these inside an if(getNAVPVAT()) int32_t getVehicleRoll(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns vehicle roll in degrees * 10^-5 int32_t getVehiclePitch(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns vehicle pitch in degrees * 10^-5 @@ -1176,6 +1193,7 @@ class DevUBLOXGNSS int32_t getMotionHeading(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the motion heading in degrees * 10^-5 // Helper functions for SVIN + // For safety, call these inside an if(getSurveyStatus()) bool getSurveyInActive(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); bool getSurveyInValid(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); @@ -1184,11 +1202,13 @@ class DevUBLOXGNSS float getSurveyInMeanAccuracy(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as m // Helper functions for TIMELS + // For safety, call these inside an if(getLeapSecondEvent()) uint8_t getLeapIndicator(int32_t &timeToLsEvent, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); int8_t getCurrentLeapSeconds(sfe_ublox_ls_src_e &source, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Helper functions for RELPOSNED + // For safety, call these inside an if(getRELPOSNED()) float getRelPosN(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as m float getRelPosE(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as m @@ -1198,11 +1218,13 @@ class DevUBLOXGNSS float getRelPosAccD(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as m // Helper functions for AOPSTATUS + // For safety, call these inside an if(getAOPSTATUS()) uint8_t getAOPSTATUSuseAOP(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the UBX-NAV-AOPSTATUS useAOP flag. Don't confuse this with getAopCfg - which returns the aopCfg byte from UBX-CFG-NAVX5 uint8_t getAOPSTATUSstatus(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the UBX-NAV-AOPSTATUS status field. A host application can determine the optimal time to shut down the receiver by monitoring the status field for a steady 0. // Helper functions for TIM TP + // For safety, call these inside an if(getTIMTP()) uint32_t getTIMTPtowMS(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the UBX-TIM-TP towMS time pulse of week (ms) uint32_t getTIMTPtowSubMS(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns the UBX-TIM-TP submillisecond part of towMS (ms * 2^-32) @@ -1210,12 +1232,14 @@ class DevUBLOXGNSS uint32_t getTIMTPAsEpoch(uint32_t µsecond, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Convert TIM TP to Unix Epoch - CAUTION! Assumes the time base is UTC and the week number is GPS // Helper function for hardware status (including jamming) + // For safety, call getAntennaStatus inside an if(getMONHW()) bool getHWstatus(UBX_MON_HW_data_t *data = nullptr, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Get the hardware status using UBX_MON_HW sfe_ublox_antenna_status_e getAntennaStatus(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Get the antenna status (aStatus) using UBX_MON_HW #ifndef SFE_UBLOX_DISABLE_ESF // Helper functions for ESF + // For safety, call getESFroll/pitch/yaw inside an if(getESFALG()) float getESFroll(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as degrees float getESFpitch(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as degrees @@ -1228,6 +1252,7 @@ class DevUBLOXGNSS #ifndef SFE_UBLOX_DISABLE_HNR // Helper functions for HNR + // For safety, call getHNRroll/pitch/yaw inside an if(getHNRATT()) bool setHNRNavigationRate(uint8_t rate, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns true if the setHNRNavigationRate is successful uint8_t getHNRNavigationRate(uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returns 0 if the getHNRNavigationRate fails @@ -1236,6 +1261,12 @@ class DevUBLOXGNSS float getHNRheading(uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Returned as degrees #endif + // Helper functions for the NEO-F10N + bool getLNAMode(sfe_ublox_lna_mode_e *mode, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Get the LNA mode + bool setLNAMode(sfe_ublox_lna_mode_e mode, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Set the LNA mode + bool getGPSL5HealthOverride(bool *override, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Get the GPS L5 health override status + bool setGPSL5HealthOverride(bool override, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); // Set the GPS L5 health override status + // Set the mainTalkerId used by NMEA messages - allows all NMEA messages except GSV to be prefixed with GP instead of GN bool setMainTalkerID(sfe_ublox_talker_ids_e id = SFE_UBLOX_MAIN_TALKER_ID_DEFAULT, uint8_t layer = VAL_LAYER_RAM_BBR, uint16_t maxWait = kUBLOXGNSSDefaultMaxWait); diff --git a/src/u-blox_config_keys.h b/src/u-blox_config_keys.h index a97eb56..7a1e4ed 100644 --- a/src/u-blox_config_keys.h +++ b/src/u-blox_config_keys.h @@ -92,28 +92,33 @@ const uint8_t VAL_ID_I2C_ADDRESS = 0x01; // The following enum allows automatic identification of the Configuration Item data type. // These are OR'd into the reserved bits in each Config Key ID. // Based on an idea by Michael Ammann. Thank you @mazgch -const uint32_t UBX_CFG_L = 0x01001000; // bool -const uint32_t UBX_CFG_U1 = 0x01002000; // uint8_t -const uint32_t UBX_CFG_U2 = 0x01003000; // uint16_t -const uint32_t UBX_CFG_U4 = 0x01004000; // uint32_t -const uint32_t UBX_CFG_U8 = 0x01005000; // uint64_t -const uint32_t UBX_CFG_I1 = 0x01006000; // int8_t -const uint32_t UBX_CFG_I2 = 0x01007000; // int16_t -const uint32_t UBX_CFG_I4 = 0x01008000; // int32_t -const uint32_t UBX_CFG_I8 = 0x01009000; // int64_t -const uint32_t UBX_CFG_R4 = 0x0100A000; // float (32-bit) -const uint32_t UBX_CFG_R8 = 0x0100B000; // double (64-bit) -const uint32_t UBX_CFG_E1 = 0x0100C000; // 8-bit enum == uint8_t -const uint32_t UBX_CFG_E2 = 0x0100D000; // 16-bit enum == uint16_t -const uint32_t UBX_CFG_E4 = 0x0100E000; // 32-bit enum == uint32_t -const uint32_t UBX_CFG_X1 = 0x0100F000; // 8-bit bitfield / string == uint8_t -const uint32_t UBX_CFG_X2 = 0x02001000; // 16-bit bitfield / string == uint16_t -const uint32_t UBX_CFG_X4 = 0x02002000; // 32-bit bitfield / string == uint32_t -const uint32_t UBX_CFG_X8 = 0x02003000; // 64-bit bitfield / string == uint64_t +const uint32_t UBX_CFG_L = 0x01001000; // bool +const uint32_t UBX_CFG_U1 = 0x01002000; // uint8_t +const uint32_t UBX_CFG_U2 = 0x01003000; // uint16_t +const uint32_t UBX_CFG_U4 = 0x01004000; // uint32_t +const uint32_t UBX_CFG_U8 = 0x01005000; // uint64_t +const uint32_t UBX_CFG_I1 = 0x01006000; // int8_t +const uint32_t UBX_CFG_I2 = 0x01007000; // int16_t +const uint32_t UBX_CFG_I4 = 0x01008000; // int32_t +const uint32_t UBX_CFG_I8 = 0x01009000; // int64_t +const uint32_t UBX_CFG_R4 = 0x0100A000; // float (32-bit) +const uint32_t UBX_CFG_R8 = 0x0100B000; // double (64-bit) +const uint32_t UBX_CFG_E1 = 0x0100C000; // 8-bit enum == uint8_t +const uint32_t UBX_CFG_E2 = 0x0100D000; // 16-bit enum == uint16_t +const uint32_t UBX_CFG_E4 = 0x0100E000; // 32-bit enum == uint32_t +const uint32_t UBX_CFG_X1 = 0x0100F000; // 8-bit bitfield / string == uint8_t +const uint32_t UBX_CFG_X2 = 0x02001000; // 16-bit bitfield / string == uint16_t +const uint32_t UBX_CFG_X4 = 0x02002000; // 32-bit bitfield / string == uint32_t +const uint32_t UBX_CFG_X8 = 0x02003000; // 64-bit bitfield / string == uint64_t const uint32_t UBX_CFG_SIZE_MASK = 0x0F00F000; // Bit mask // Below are the key values for a given configuration setting +// UNDOCUMENTED Keys for the NEO-F10N (SPG 6.00) +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- +// From the code example in the NEO-F10N Integration Manual. Set True to override the GPS L5 health status with GPS L1. +const uint32_t UBLOX_CFG_SIGNAL_GPS_L5_HEALTH_OVERRIDE = UBX_CFG_L | 0x10320001; + // CFG-ANA: AssistNow Autonomous and Offline configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_ANA_USE_ANA = UBX_CFG_L | 0x10230001; // Use AssistNow Autonomous @@ -123,6 +128,10 @@ const uint32_t UBLOX_CFG_ANA_ORBMAXERR = UBX_CFG_U2 | 0x30230002; // Maximum acc //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_BDS_USE_PRN_1_TO_5 = UBX_CFG_L | 0x10340014; // Use BeiDou geostationary satellites (PRN 1-5) +// CFG-CLOCK: System clock configuration +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- +const uint32_t UBLOX_CFG_CLOCK_OSC_FREQ = UBX_CFG_U4 | 0x40a4000d; // Oscillator speed + // CFG-GEOFENCE: Geofencing configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_GEOFENCE_CONFLVL = UBX_CFG_E1 | 0x20240011; // Required confidence level for state evaluation @@ -148,20 +157,33 @@ const uint32_t UBLOX_CFG_GEOFENCE_FENCE4_RAD = UBX_CFG_U4 | 0x40240053; // Radiu // CFG-HW: Hardware configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_HW_ANT_CFG_VOLTCTRL = UBX_CFG_L | 0x10a3002e; // Active antenna voltage control flag -const uint32_t UBLOX_CFG_HW_ANT_CFG_SHORTDET = UBX_CFG_L | 0x10a3002f; // Short antenna detection flag -const uint32_t UBLOX_CFG_HW_ANT_CFG_SHORTDET_POL = UBX_CFG_L | 0x10a30030; // Short antenna detection polarity -const uint32_t UBLOX_CFG_HW_ANT_CFG_OPENDET = UBX_CFG_L | 0x10a30031; // Open antenna detection flag -const uint32_t UBLOX_CFG_HW_ANT_CFG_OPENDET_POL = UBX_CFG_L | 0x10a30032; // Open antenna detection polarity -const uint32_t UBLOX_CFG_HW_ANT_CFG_PWRDOWN = UBX_CFG_L | 0x10a30033; // Power down antenna flag -const uint32_t UBLOX_CFG_HW_ANT_CFG_PWRDOWN_POL = UBX_CFG_L | 0x10a30034; // Power down antenna logic polarity -const uint32_t UBLOX_CFG_HW_ANT_CFG_RECOVER = UBX_CFG_L | 0x10a30035; // Automatic recovery from short state flag -const uint32_t UBLOX_CFG_HW_ANT_SUP_SWITCH_PIN = UBX_CFG_U1 | 0x20a30036; // ANT1 PIO number -const uint32_t UBLOX_CFG_HW_ANT_SUP_SHORT_PIN = UBX_CFG_U1 | 0x20a30037; // ANT0 PIO number -const uint32_t UBLOX_CFG_HW_ANT_SUP_OPEN_PIN = UBX_CFG_U1 | 0x20a30038; // ANT2 PIO number -const uint32_t UBLOX_CFG_HW_ANT_SUP_ENGINE = UBX_CFG_E1 | 0x20a30054; // Antenna supervisor engine selection -const uint32_t UBLOX_CFG_HW_ANT_SUP_SHORT_THR = UBX_CFG_U1 | 0x20a30055; // Antenna supervisor MADC engine short detection threshold -const uint32_t UBLOX_CFG_HW_ANT_SUP_OPEN_THR = UBX_CFG_U1 | 0x20a30056; // Antenna supervisor MADC engine open detection threshold +const uint32_t UBLOX_CFG_HW_DCDC_DIS = UBX_CFG_L | 0x10a30018; // DCDC converter disabled +const uint32_t UBLOX_CFG_HW_SINGLE_CLK = UBX_CFG_L | 0x10a30019; // Single-clock system +const uint32_t UBLOX_CFG_HW_OSC_TYPE = UBX_CFG_E1 | 0x20a30025; // Oscillator type +const uint32_t UBLOX_CFG_HW_CLK_OFFSET = UBX_CFG_I4 | 0x40a30028; // Clock offset +const uint32_t UBLOX_CFG_HW_CLK_OFFSET_VALID = UBX_CFG_L | 0x10a30029; // Clock offset valid +const uint32_t UBLOX_CFG_HW_CLK_PRECISION = UBX_CFG_U4 | 0x40a3002a; // Precision of the clock offset +const uint32_t UBLOX_CFG_HW_CLK_MAX_CALIB_DEV = UBX_CFG_U4 | 0x40a3002b; // Maximum calibration deviation +const uint32_t UBLOX_CFG_HW_CLK_MAX_CALIB_DEV_VALID = UBX_CFG_L | 0x10a3002c; // Max calibration deviation valid +const uint32_t UBLOX_CFG_HW_CLK_IS_TCXO = UBX_CFG_L | 0x10a30047; // Oscillator type indicator +const uint32_t UBLOX_CFG_HW_ANT_CFG_VOLTCTRL = UBX_CFG_L | 0x10a3002e; // Active antenna voltage control flag +const uint32_t UBLOX_CFG_HW_ANT_CFG_SHORTDET = UBX_CFG_L | 0x10a3002f; // Short antenna detection flag +const uint32_t UBLOX_CFG_HW_ANT_CFG_SHORTDET_POL = UBX_CFG_L | 0x10a30030; // Short antenna detection polarity +const uint32_t UBLOX_CFG_HW_ANT_CFG_OPENDET = UBX_CFG_L | 0x10a30031; // Open antenna detection flag +const uint32_t UBLOX_CFG_HW_ANT_CFG_OPENDET_POL = UBX_CFG_L | 0x10a30032; // Open antenna detection polarity +const uint32_t UBLOX_CFG_HW_ANT_CFG_PWRDOWN = UBX_CFG_L | 0x10a30033; // Power down antenna flag +const uint32_t UBLOX_CFG_HW_ANT_CFG_PWRDOWN_POL = UBX_CFG_L | 0x10a30034; // Power down antenna logic polarity +const uint32_t UBLOX_CFG_HW_ANT_CFG_RECOVER = UBX_CFG_L | 0x10a30035; // Automatic recovery from short state flag +const uint32_t UBLOX_CFG_HW_ANT_SUP_SWITCH_PIN = UBX_CFG_U1 | 0x20a30036; // ANT1 PIO number +const uint32_t UBLOX_CFG_HW_ANT_SUP_SHORT_PIN = UBX_CFG_U1 | 0x20a30037; // ANT0 PIO number +const uint32_t UBLOX_CFG_HW_ANT_SUP_OPEN_PIN = UBX_CFG_U1 | 0x20a30038; // ANT2 PIO number +const uint32_t UBLOX_CFG_HW_ANT_ON_SHORT_US = UBX_CFG_U2 | 0x30a3003c; // ANT on->short timeout[us] +const uint32_t UBLOX_CFG_HW_ANT_SUP_ENGINE = UBX_CFG_E1 | 0x20a30054; // Antenna supervisor engine selection +const uint32_t UBLOX_CFG_HW_ANT_SUP_SHORT_THR = UBX_CFG_U1 | 0x20a30055; // Antenna supervisor MADC engine short detection threshold +const uint32_t UBLOX_CFG_HW_ANT_SUP_OPEN_THR = UBX_CFG_U1 | 0x20a30056; // Antenna supervisor MADC engine open detection threshold +const uint32_t UBLOX_CFG_HW_SENS_WOM_MODE = UBX_CFG_E1 | 0x20a30063; // Select Wake-On-Motion mode +const uint32_t UBLOX_CFG_HW_SENS_WOM_THLD = UBX_CFG_U1 | 0x20a30064; // Wake-On-Motion threshold +const uint32_t UBLOX_CFG_HW_RF_LNA_MODE = UBX_CFG_E1 | 0x20a30057; // Mode for internal LNA (NEO-F10) // CFG-I2C: Configuration of the I2C interface //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @@ -556,6 +578,11 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMELS_SPI = UBX_CFG_U1 | 0x20910064; const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMELS_UART1 = UBX_CFG_U1 | 0x20910061; // Output rate of the UBX-NAV-TIMELS message on port UART1 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMELS_UART2 = UBX_CFG_U1 | 0x20910062; // Output rate of the UBX-NAV-TIMELS message on port UART2 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMELS_USB = UBX_CFG_U1 | 0x20910063; // Output rate of the UBX-NAV-TIMELS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMENAVIC_I2C = UBX_CFG_U1 | 0x209106a2; // Output rate of the UBX-NAV-TIMENAVIC message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMENAVIC_SPI = UBX_CFG_U1 | 0x209106a6; // Output rate of the UBX-NAV-TIMENAVIC message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMENAVIC_UART1 = UBX_CFG_U1 | 0x209106a3; // Output rate of the UBX-NAV-TIMENAVIC message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMENAVIC_UART2 = UBX_CFG_U1 | 0x209106a4; // Output rate of the UBX-NAV-TIMENAVIC message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMENAVIC_USB = UBX_CFG_U1 | 0x209106a5; // Output rate of the UBX-NAV-TIMENAVIC message on port USB const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMEQZSS_I2C = UBX_CFG_U1 | 0x20910386; // Output rate of the UBX-NAV-TIMEQZSSmessage on port I2C const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMEQZSS_SPI = UBX_CFG_U1 | 0x2091038a; // Output rate of the UBX-NAV-TIMEQZSSmessage on port SPI const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_TIMEQZSS_UART1 = UBX_CFG_U1 | 0x20910387; // Output rate of the UBX-NAV-TIMEQZSSmessage on port UART1 @@ -680,7 +707,7 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PVAT_UART2 = UBX_CFG_U1 | 0x2091062c; const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PVAT_USB = UBX_CFG_U1 | 0x2091062d; // Output rate of the UBX-NAV-PVAT message on port USB const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PVAT_SPI = UBX_CFG_U1 | 0x2091062e; // Output rate of the UBX-NAV-PVAT message on port SPI -// Additional CFG_MSGOUT keys for the M10 +// Additional CFG_MSGOUT keys for the M10 / F10 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_AOPSTATUS_I2C = UBX_CFG_U1 | 0x20910079; const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_AOPSTATUS_SPI = UBX_CFG_U1 | 0x2091007d; @@ -688,199 +715,214 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_AOPSTATUS_UART1 = UBX_CFG_U1 | 0x2091007 // Additional CFG_MSGOUT keys for the ZED-F9T //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_I2C = UBX_CFG_U1 | 0x20910661; // Output rate of the NMEA-NAV2-GX-GGA message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_SPI = UBX_CFG_U1 | 0x20910665; // Output rate of the NMEA-NAV2-GX-GGA message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_UART1 = UBX_CFG_U1 | 0x20910662; // Output rate of the NMEA-NAV2-GX-GGA message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_UART2 = UBX_CFG_U1 | 0x20910663; // Output rate of the NMEA-NAV2-GX-GGA message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_USB = UBX_CFG_U1 | 0x20910664; // Output rate of the NMEA-NAV2-GX-GGA message on port USB -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_I2C = UBX_CFG_U1 | 0x20910670; // Output rate of the NMEA-NAV2-GX-GLL message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_SPI = UBX_CFG_U1 | 0x20910674; // Output rate of the NMEA-NAV2-GX-GLL message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_UART1 = UBX_CFG_U1 | 0x20910671; // Output rate of the NMEA-NAV2-GX-GLL message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_UART2 = UBX_CFG_U1 | 0x20910672; // Output rate of the NMEA-NAV2-GX-GLL message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_USB = UBX_CFG_U1 | 0x20910673; // Output rate of the NMEA-NAV2-GX-GLL message on port USB -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_I2C = UBX_CFG_U1 | 0x2091065c; // Output rate of the NMEA-NAV2-GX-GNS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_SPI = UBX_CFG_U1 | 0x20910660; // Output rate of the NMEA-NAV2-GX-GNS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_UART1 = UBX_CFG_U1 | 0x2091065d; // Output rate of the NMEA-NAV2-GX-GNS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_UART2 = UBX_CFG_U1 | 0x2091065e; // Output rate of the NMEA-NAV2-GX-GNS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_USB = UBX_CFG_U1 | 0x2091065f; // Output rate of the NMEA-NAV2-GX-GNS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_I2C = UBX_CFG_U1 | 0x20910666; // Output rate of the NMEA-NAV2-GX-GSA message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_SPI = UBX_CFG_U1 | 0x2091066a; // Output rate of the NMEA-NAV2-GX-GSA message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_UART1 = UBX_CFG_U1 | 0x20910667; // Output rate of the NMEA-NAV2-GX-GSA message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_UART2 = UBX_CFG_U1 | 0x20910668; // Output rate of the NMEA-NAV2-GX-GSA message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_USB = UBX_CFG_U1 | 0x20910669; // Output rate of the NMEA-NAV2-GX-GSA message on port USB -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_I2C = UBX_CFG_U1 | 0x20910652; // Output rate of the NMEA-NAV2-GX-RMC message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_SPI = UBX_CFG_U1 | 0x20910656; // Output rate of the NMEA-NAV2-GX-RMC message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_UART1 = UBX_CFG_U1 | 0x20910653; // Output rate of the NMEA-NAV2-GX-RMC message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_UART2 = UBX_CFG_U1 | 0x20910654; // Output rate of the NMEA-NAV2-GX-RMC message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_USB = UBX_CFG_U1 | 0x20910655; // Output rate of the NMEA-NAV2-GX-RMC message on port USB -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_I2C = UBX_CFG_U1 | 0x20910657; // Output rate of the NMEA-NAV2-GX-VTG message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_SPI = UBX_CFG_U1 | 0x2091065b; // Output rate of the NMEA-NAV2-GX-VTG message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_UART1 = UBX_CFG_U1 | 0x20910658; // Output rate of the NMEA-NAV2-GX-VTG message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_UART2 = UBX_CFG_U1 | 0x20910659; // Output rate of the NMEA-NAV2-GX-VTG message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_USB = UBX_CFG_U1 | 0x2091065a; // Output rate of the NMEA-NAV2-GX-VTG message on port USB -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_I2C = UBX_CFG_U1 | 0x2091067f; // Output rate of the NMEA-NAV2-GX-ZDA message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_SPI = UBX_CFG_U1 | 0x20910683; // Output rate of the NMEA-NAV2-GX-ZDA message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_UART1 = UBX_CFG_U1 | 0x20910680; // Output rate of the NMEA-NAV2-GX-ZDA message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_UART2 = UBX_CFG_U1 | 0x20910681; // Output rate of the NMEA-NAV2-GX-ZDA message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_USB = UBX_CFG_U1 | 0x20910682; // Output rate of the NMEA-NAV2-GX-ZDA message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_I2C = UBX_CFG_U1 | 0x20910430; // Output rate of the UBX-NAV2-CLOCK message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_SPI = UBX_CFG_U1 | 0x20910434; // Output rate of the UBX-NAV2-CLOCK message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_UART1 = UBX_CFG_U1 | 0x20910431; // Output rate of the UBX-NAV2-CLOCK message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_UART2 = UBX_CFG_U1 | 0x20910432; // Output rate of the UBX-NAV2-CLOCK message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_USB = UBX_CFG_U1 | 0x20910433; // Output rate of the UBX-NAV2-CLOCK message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_I2C = UBX_CFG_U1 | 0x20910435; // Output rate of the UBX-NAV2-COV message onport I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_SPI = UBX_CFG_U1 | 0x20910439; // Output rate of the UBX-NAV2-COV message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_UART1 = UBX_CFG_U1 | 0x20910436; // Output rate of the UBX-NAV2-COV message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_UART2 = UBX_CFG_U1 | 0x20910437; // Output rate of the UBX-NAV2-COV message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_USB = UBX_CFG_U1 | 0x20910438; // Output rate of the UBX-NAV2-COV message onport USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_I2C = UBX_CFG_U1 | 0x20910465; // Output rate of the UBX-NAV2-DOP message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_SPI = UBX_CFG_U1 | 0x20910469; // Output rate of the UBX-NAV2-DOP message onport SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_UART1 = UBX_CFG_U1 | 0x20910466; // Output rate of the UBX-NAV2-DOP message onport UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_UART2 = UBX_CFG_U1 | 0x20910467; // Output rate of the UBX-NAV2-DOP message onport UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_USB = UBX_CFG_U1 | 0x20910468; // Output rate of the UBX-NAV2-DOP message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_I2C = UBX_CFG_U1 | 0x20910661; // Output rate of the NMEA-NAV2-GX-GGA message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_SPI = UBX_CFG_U1 | 0x20910665; // Output rate of the NMEA-NAV2-GX-GGA message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_UART1 = UBX_CFG_U1 | 0x20910662; // Output rate of the NMEA-NAV2-GX-GGA message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_UART2 = UBX_CFG_U1 | 0x20910663; // Output rate of the NMEA-NAV2-GX-GGA message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_USB = UBX_CFG_U1 | 0x20910664; // Output rate of the NMEA-NAV2-GX-GGA message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_I2C = UBX_CFG_U1 | 0x20910670; // Output rate of the NMEA-NAV2-GX-GLL message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_SPI = UBX_CFG_U1 | 0x20910674; // Output rate of the NMEA-NAV2-GX-GLL message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_UART1 = UBX_CFG_U1 | 0x20910671; // Output rate of the NMEA-NAV2-GX-GLL message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_UART2 = UBX_CFG_U1 | 0x20910672; // Output rate of the NMEA-NAV2-GX-GLL message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GLL_USB = UBX_CFG_U1 | 0x20910673; // Output rate of the NMEA-NAV2-GX-GLL message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_I2C = UBX_CFG_U1 | 0x2091065c; // Output rate of the NMEA-NAV2-GX-GNS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_SPI = UBX_CFG_U1 | 0x20910660; // Output rate of the NMEA-NAV2-GX-GNS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_UART1 = UBX_CFG_U1 | 0x2091065d; // Output rate of the NMEA-NAV2-GX-GNS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_UART2 = UBX_CFG_U1 | 0x2091065e; // Output rate of the NMEA-NAV2-GX-GNS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GNS_USB = UBX_CFG_U1 | 0x2091065f; // Output rate of the NMEA-NAV2-GX-GNS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_I2C = UBX_CFG_U1 | 0x20910666; // Output rate of the NMEA-NAV2-GX-GSA message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_SPI = UBX_CFG_U1 | 0x2091066a; // Output rate of the NMEA-NAV2-GX-GSA message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_UART1 = UBX_CFG_U1 | 0x20910667; // Output rate of the NMEA-NAV2-GX-GSA message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_UART2 = UBX_CFG_U1 | 0x20910668; // Output rate of the NMEA-NAV2-GX-GSA message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GSA_USB = UBX_CFG_U1 | 0x20910669; // Output rate of the NMEA-NAV2-GX-GSA message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_I2C = UBX_CFG_U1 | 0x20910652; // Output rate of the NMEA-NAV2-GX-RMC message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_SPI = UBX_CFG_U1 | 0x20910656; // Output rate of the NMEA-NAV2-GX-RMC message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_UART1 = UBX_CFG_U1 | 0x20910653; // Output rate of the NMEA-NAV2-GX-RMC message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_UART2 = UBX_CFG_U1 | 0x20910654; // Output rate of the NMEA-NAV2-GX-RMC message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_RMC_USB = UBX_CFG_U1 | 0x20910655; // Output rate of the NMEA-NAV2-GX-RMC message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_I2C = UBX_CFG_U1 | 0x20910657; // Output rate of the NMEA-NAV2-GX-VTG message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_SPI = UBX_CFG_U1 | 0x2091065b; // Output rate of the NMEA-NAV2-GX-VTG message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_UART1 = UBX_CFG_U1 | 0x20910658; // Output rate of the NMEA-NAV2-GX-VTG message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_UART2 = UBX_CFG_U1 | 0x20910659; // Output rate of the NMEA-NAV2-GX-VTG message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_VTG_USB = UBX_CFG_U1 | 0x2091065a; // Output rate of the NMEA-NAV2-GX-VTG message on port USB +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_I2C = UBX_CFG_U1 | 0x2091067f; // Output rate of the NMEA-NAV2-GX-ZDA message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_SPI = UBX_CFG_U1 | 0x20910683; // Output rate of the NMEA-NAV2-GX-ZDA message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_UART1 = UBX_CFG_U1 | 0x20910680; // Output rate of the NMEA-NAV2-GX-ZDA message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_UART2 = UBX_CFG_U1 | 0x20910681; // Output rate of the NMEA-NAV2-GX-ZDA message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_ZDA_USB = UBX_CFG_U1 | 0x20910682; // Output rate of the NMEA-NAV2-GX-ZDA message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_I2C = UBX_CFG_U1 | 0x20910430; // Output rate of the UBX-NAV2-CLOCK message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_SPI = UBX_CFG_U1 | 0x20910434; // Output rate of the UBX-NAV2-CLOCK message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_UART1 = UBX_CFG_U1 | 0x20910431; // Output rate of the UBX-NAV2-CLOCK message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_UART2 = UBX_CFG_U1 | 0x20910432; // Output rate of the UBX-NAV2-CLOCK message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_CLOCK_USB = UBX_CFG_U1 | 0x20910433; // Output rate of the UBX-NAV2-CLOCK message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_I2C = UBX_CFG_U1 | 0x20910435; // Output rate of the UBX-NAV2-COV message onport I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_SPI = UBX_CFG_U1 | 0x20910439; // Output rate of the UBX-NAV2-COV message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_UART1 = UBX_CFG_U1 | 0x20910436; // Output rate of the UBX-NAV2-COV message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_UART2 = UBX_CFG_U1 | 0x20910437; // Output rate of the UBX-NAV2-COV message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_COV_USB = UBX_CFG_U1 | 0x20910438; // Output rate of the UBX-NAV2-COV message onport USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_I2C = UBX_CFG_U1 | 0x20910465; // Output rate of the UBX-NAV2-DOP message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_SPI = UBX_CFG_U1 | 0x20910469; // Output rate of the UBX-NAV2-DOP message onport SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_UART1 = UBX_CFG_U1 | 0x20910466; // Output rate of the UBX-NAV2-DOP message onport UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_UART2 = UBX_CFG_U1 | 0x20910467; // Output rate of the UBX-NAV2-DOP message onport UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_DOP_USB = UBX_CFG_U1 | 0x20910468; // Output rate of the UBX-NAV2-DOP message on port USB const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EELL_I2C = UBX_CFG_U1 | 0x20910470; // Output rate of the UBX-NAV2-EELL message onport I2C const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EELL_SPI = UBX_CFG_U1 | 0x20910474; // Output rate of the UBX-NAV2-EELL message on port SPI const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EELL_UART1 = UBX_CFG_U1 | 0x20910471; // Output rate of the UBX-NAV2-EELL message on port UART1 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EELL_UART2 = UBX_CFG_U1 | 0x20910472; // Output rate of the UBX-NAV2-EELL message on port UART2 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EELL_USB = UBX_CFG_U1 | 0x20910473; // Output rate of the UBX-NAV2-EELL message onport USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_I2C = UBX_CFG_U1 | 0x20910565; // Output rate of the UBX-NAV2-EOE message onport I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_SPI = UBX_CFG_U1 | 0x20910569; // Output rate of the UBX-NAV2-EOE message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_UART1 = UBX_CFG_U1 | 0x20910566; // Output rate of the UBX-NAV2-EOE message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_UART2 = UBX_CFG_U1 | 0x20910567; // Output rate of the UBX-NAV2-EOE message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_USB = UBX_CFG_U1 | 0x20910568; // Output rate of the UBX-NAV2-EOE message onport USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_I2C = UBX_CFG_U1 | 0x20910475; // Output rate of the UBX-NAV2-ODO message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_SPI = UBX_CFG_U1 | 0x20910479; // Output rate of the UBX-NAV2-ODO message onport SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_UART1 = UBX_CFG_U1 | 0x20910476; // Output rate of the UBX-NAV2-ODO message onport UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_UART2 = UBX_CFG_U1 | 0x20910477; // Output rate of the UBX-NAV2-ODO message onport UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_USB = UBX_CFG_U1 | 0x20910478; // Output rate of the UBX-NAV2-ODO message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_I2C = UBX_CFG_U1 | 0x20910480; // Output rate of the UBX-NAV2-POSECEF message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_SPI = UBX_CFG_U1 | 0x20910484; // Output rate of the UBX-NAV2-POSECEF message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_UART1 = UBX_CFG_U1 | 0x20910481; // Output rate of the UBX-NAV2-POSECEF message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_UART2 = UBX_CFG_U1 | 0x20910482; // Output rate of the UBX-NAV2-POSECEF message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_USB = UBX_CFG_U1 | 0x20910483; // Output rate of the UBX-NAV2-POSECEF message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_I2C = UBX_CFG_U1 | 0x20910485; // Output rate of the UBX-NAV2-POSLLH message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_SPI = UBX_CFG_U1 | 0x20910489; // Output rate of the UBX-NAV2-POSLLH message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_UART1 = UBX_CFG_U1 | 0x20910486; // Output rate of the UBX-NAV2-POSLLH message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_UART2 = UBX_CFG_U1 | 0x20910487; // Output rate of the UBX-NAV2-POSLLH message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_USB = UBX_CFG_U1 | 0x20910488; // Output rate of the UBX-NAV2-POSLLH message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_I2C = UBX_CFG_U1 | 0x20910565; // Output rate of the UBX-NAV2-EOE message onport I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_SPI = UBX_CFG_U1 | 0x20910569; // Output rate of the UBX-NAV2-EOE message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_UART1 = UBX_CFG_U1 | 0x20910566; // Output rate of the UBX-NAV2-EOE message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_UART2 = UBX_CFG_U1 | 0x20910567; // Output rate of the UBX-NAV2-EOE message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_EOE_USB = UBX_CFG_U1 | 0x20910568; // Output rate of the UBX-NAV2-EOE message onport USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_I2C = UBX_CFG_U1 | 0x20910475; // Output rate of the UBX-NAV2-ODO message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_SPI = UBX_CFG_U1 | 0x20910479; // Output rate of the UBX-NAV2-ODO message onport SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_UART1 = UBX_CFG_U1 | 0x20910476; // Output rate of the UBX-NAV2-ODO message onport UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_UART2 = UBX_CFG_U1 | 0x20910477; // Output rate of the UBX-NAV2-ODO message onport UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_ODO_USB = UBX_CFG_U1 | 0x20910478; // Output rate of the UBX-NAV2-ODO message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_I2C = UBX_CFG_U1 | 0x20910480; // Output rate of the UBX-NAV2-POSECEF message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_SPI = UBX_CFG_U1 | 0x20910484; // Output rate of the UBX-NAV2-POSECEF message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_UART1 = UBX_CFG_U1 | 0x20910481; // Output rate of the UBX-NAV2-POSECEF message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_UART2 = UBX_CFG_U1 | 0x20910482; // Output rate of the UBX-NAV2-POSECEF message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSECEF_USB = UBX_CFG_U1 | 0x20910483; // Output rate of the UBX-NAV2-POSECEF message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_I2C = UBX_CFG_U1 | 0x20910485; // Output rate of the UBX-NAV2-POSLLH message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_SPI = UBX_CFG_U1 | 0x20910489; // Output rate of the UBX-NAV2-POSLLH message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_UART1 = UBX_CFG_U1 | 0x20910486; // Output rate of the UBX-NAV2-POSLLH message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_UART2 = UBX_CFG_U1 | 0x20910487; // Output rate of the UBX-NAV2-POSLLH message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_POSLLH_USB = UBX_CFG_U1 | 0x20910488; // Output rate of the UBX-NAV2-POSLLH message on port USB const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVAT_I2C = UBX_CFG_U1 | 0x2091062f; // Output rate of the UBX-NAV2-PVAT message onport I2C const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVAT_SPI = UBX_CFG_U1 | 0x20910633; // Output rate of the UBX-NAV2-PVAT message on port SPI const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVAT_UART1 = UBX_CFG_U1 | 0x20910630; // Output rate of the UBX-NAV2-PVAT message on port UART1 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVAT_UART2 = UBX_CFG_U1 | 0x20910631; // Output rate of the UBX-NAV2-PVAT message on port UART2 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVAT_USB = UBX_CFG_U1 | 0x20910632; // Output rate of the UBX-NAV2-PVAT message onport USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_I2C = UBX_CFG_U1 | 0x20910490; // Output rate of the UBX-NAV2-PVT message onport I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_SPI = UBX_CFG_U1 | 0x20910494; // Output rate of the UBX-NAV2-PVT message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_UART1 = UBX_CFG_U1 | 0x20910491; // Output rate of the UBX-NAV2-PVT message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_UART2 = UBX_CFG_U1 | 0x20910492; // Output rate of the UBX-NAV2-PVT message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_USB = UBX_CFG_U1 | 0x20910493; // Output rate of the UBX-NAV2-PVT message onport USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_I2C = UBX_CFG_U1 | 0x20910495; // Output rate of the UBX-NAV2-SAT message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_SPI = UBX_CFG_U1 | 0x20910499; // Output rate of the UBX-NAV2-SAT message onport SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_UART1 = UBX_CFG_U1 | 0x20910496; // Output rate of the UBX-NAV2-SAT message onport UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_UART2 = UBX_CFG_U1 | 0x20910497; // Output rate of the UBX-NAV2-SAT message onport UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_USB = UBX_CFG_U1 | 0x20910498; // Output rate of the UBX-NAV2-SAT message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_I2C = UBX_CFG_U1 | 0x20910500; // Output rate of the UBX-NAV2-SBAS messageon port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_SPI = UBX_CFG_U1 | 0x20910504; // Output rate of the UBX-NAV2-SBAS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_UART1 = UBX_CFG_U1 | 0x20910501; // Output rate of the UBX-NAV2-SBAS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_UART2 = UBX_CFG_U1 | 0x20910502; // Output rate of the UBX-NAV2-SBAS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_USB = UBX_CFG_U1 | 0x20910503; // Output rate of the UBX-NAV2-SBAS messageon port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_I2C = UBX_CFG_U1 | 0x20910505; // Output rate of the UBX-NAV2-SIG message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_SPI = UBX_CFG_U1 | 0x20910509; // Output rate of the UBX-NAV2-SIG message onport SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_UART1 = UBX_CFG_U1 | 0x20910506; // Output rate of the UBX-NAV2-SIG message onport UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_UART2 = UBX_CFG_U1 | 0x20910507; // Output rate of the UBX-NAV2-SIG message onport UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_USB = UBX_CFG_U1 | 0x20910508; // Output rate of the UBX-NAV2-SIG message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_I2C = UBX_CFG_U1 | 0x20910510; // Output rate of the UBX-NAV2-SLAS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_SPI = UBX_CFG_U1 | 0x20910514; // Output rate of the UBX-NAV2-SLAS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_UART1 = UBX_CFG_U1 | 0x20910511; // Output rate of the UBX-NAV2-SLAS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_UART2 = UBX_CFG_U1 | 0x20910512; // Output rate of the UBX-NAV2-SLAS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_USB = UBX_CFG_U1 | 0x20910513; // Output rate of the UBX-NAV2-SLAS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_I2C = UBX_CFG_U1 | 0x20910515; // Output rate of the UBX-NAV2-STATUS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_SPI = UBX_CFG_U1 | 0x20910519; // Output rate of the UBX-NAV2-STATUS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_UART1 = UBX_CFG_U1 | 0x20910516; // Output rate of the UBX-NAV2-STATUS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_UART2 = UBX_CFG_U1 | 0x20910517; // Output rate of the UBX-NAV2-STATUS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_USB = UBX_CFG_U1 | 0x20910518; // Output rate of the UBX-NAV2-STATUS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_I2C = UBX_CFG_U1 | 0x20910520; // Output rate of the UBX-NAV2-SVIN message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_SPI = UBX_CFG_U1 | 0x20910524; // Output rate of the UBX-NAV2-SVIN message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_UART1 = UBX_CFG_U1 | 0x20910521; // Output rate of the UBX-NAV2-SVIN message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_UART2 = UBX_CFG_U1 | 0x20910522; // Output rate of the UBX-NAV2-SVIN message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_USB = UBX_CFG_U1 | 0x20910523; // Output rate of the UBX-NAV2-SVIN message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_I2C = UBX_CFG_U1 | 0x20910525; // Output rate of the UBX-NAV2-TIMEBDS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_SPI = UBX_CFG_U1 | 0x20910529; // Output rate of the UBX-NAV2-TIMEBDS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_UART1 = UBX_CFG_U1 | 0x20910526; // Output rate of the UBX-NAV2-TIMEBDS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_UART2 = UBX_CFG_U1 | 0x20910527; // Output rate of the UBX-NAV2-TIMEBDS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_USB = UBX_CFG_U1 | 0x20910528; // Output rate of the UBX-NAV2-TIMEBDS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_I2C = UBX_CFG_U1 | 0x20910530; // Output rate of the UBX-NAV2-TIMEGAL message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_SPI = UBX_CFG_U1 | 0x20910534; // Output rate of the UBX-NAV2-TIMEGAL message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_UART1 = UBX_CFG_U1 | 0x20910531; // Output rate of the UBX-NAV2-TIMEGAL message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_UART2 = UBX_CFG_U1 | 0x20910532; // Output rate of the UBX-NAV2-TIMEGAL message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_USB = UBX_CFG_U1 | 0x20910533; // Output rate of the UBX-NAV2-TIMEGAL message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_I2C = UBX_CFG_U1 | 0x20910535; // Output rate of the UBX-NAV2-TIMEGLO message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_SPI = UBX_CFG_U1 | 0x20910539; // Output rate of the UBX-NAV2-TIMEGLO message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_UART1 = UBX_CFG_U1 | 0x20910536; // Output rate of the UBX-NAV2-TIMEGLO message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_UART2 = UBX_CFG_U1 | 0x20910537; // Output rate of the UBX-NAV2-TIMEGLO message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_USB = UBX_CFG_U1 | 0x20910538; // Output rate of the UBX-NAV2-TIMEGLO message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_I2C = UBX_CFG_U1 | 0x20910540; // Output rate of the UBX-NAV2-TIMEGPS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_SPI = UBX_CFG_U1 | 0x20910544; // Output rate of the UBX-NAV2-TIMEGPS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_UART1 = UBX_CFG_U1 | 0x20910541; // Output rate of the UBX-NAV2-TIMEGPS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_UART2 = UBX_CFG_U1 | 0x20910542; // Output rate of the UBX-NAV2-TIMEGPS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_USB = UBX_CFG_U1 | 0x20910543; // Output rate of the UBX-NAV2-TIMEGPS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_I2C = UBX_CFG_U1 | 0x20910545; // Output rate of the UBX-NAV2-TIMELS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_SPI = UBX_CFG_U1 | 0x20910549; // Output rate of the UBX-NAV2-TIMELS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_UART1 = UBX_CFG_U1 | 0x20910546; // Output rate of the UBX-NAV2-TIMELS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_UART2 = UBX_CFG_U1 | 0x20910547; // Output rate of the UBX-NAV2-TIMELS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_USB = UBX_CFG_U1 | 0x20910548; // Output rate of the UBX-NAV2-TIMELS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_I2C = UBX_CFG_U1 | 0x20910575; // Output rate of the UBX-NAV2-TIMEQZSS message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_SPI = UBX_CFG_U1 | 0x20910579; // Output rate of the UBX-NAV2-TIMEQZSS message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_UART1 = UBX_CFG_U1 | 0x20910576; // Output rate of the UBX-NAV2-TIMEQZSS message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_UART2 = UBX_CFG_U1 | 0x20910577; // Output rate of the UBX-NAV2-TIMEQZSS message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_USB = UBX_CFG_U1 | 0x20910578; // Output rate of the UBX-NAV2-TIMEQZSS message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_I2C = UBX_CFG_U1 | 0x20910550; // Output rate of the UBX-NAV2-TIMEUTC message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_SPI = UBX_CFG_U1 | 0x20910554; // Output rate of the UBX-NAV2-TIMEUTC message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_UART1 = UBX_CFG_U1 | 0x20910551; // Output rate of the UBX-NAV2-TIMEUTC message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_UART2 = UBX_CFG_U1 | 0x20910552; // Output rate of the UBX-NAV2-TIMEUTC message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_USB = UBX_CFG_U1 | 0x20910553; // Output rate of the UBX-NAV2-TIMEUTC message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_I2C = UBX_CFG_U1 | 0x20910555; // Output rate of the UBX-NAV2-VELECEF message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_SPI = UBX_CFG_U1 | 0x20910559; // Output rate of the UBX-NAV2-VELECEF message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_UART1 = UBX_CFG_U1 | 0x20910556; // Output rate of the UBX-NAV2-VELECEF message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_UART2 = UBX_CFG_U1 | 0x20910557; // Output rate of the UBX-NAV2-VELECEF message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_USB = UBX_CFG_U1 | 0x20910558; // Output rate of the UBX-NAV2-VELECEF message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_I2C = UBX_CFG_U1 | 0x20910560; // Output rate of the UBX-NAV2-VELNED message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_SPI = UBX_CFG_U1 | 0x20910564; // Output rate of the UBX-NAV2-VELNED message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_UART1 = UBX_CFG_U1 | 0x20910561; // Output rate of the UBX-NAV2-VELNED message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_UART2 = UBX_CFG_U1 | 0x20910562; // Output rate of the UBX-NAV2-VELNED message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_USB = UBX_CFG_U1 | 0x20910563; // Output rate of the UBX-NAV2-VELNED message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_I2C = UBX_CFG_U1 | 0x20910590; // Output rate of the UBX-NAV-NMI message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_SPI = UBX_CFG_U1 | 0x20910594; // Output rate of the UBX-NAV-NMI message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_UART1 = UBX_CFG_U1 | 0x20910591; // Output rate of the UBX-NAV-NMI message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_UART2 = UBX_CFG_U1 | 0x20910592; // Output rate of the UBX-NAV-NMI message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_USB = UBX_CFG_U1 | 0x20910593; // Output rate of the UBX-NAV-NMI message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_I2C = UBX_CFG_U1 | 0x20910610; // Output rate of the UBX-RXM-TM message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_SPI = UBX_CFG_U1 | 0x20910614; // Output rate of the UBX-RXM-TM message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_UART1 = UBX_CFG_U1 | 0x20910611; // Output rate of the UBX-RXM-TM message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_UART2 = UBX_CFG_U1 | 0x20910612; // Output rate of the UBX-RXM-TM message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_USB = UBX_CFG_U1 | 0x20910613; // Output rate of the UBX-RXM-TM message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_I2C = UBX_CFG_U1 | 0x20910689; // Output rate of the UBX-SEC-SIGLOG message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_SPI = UBX_CFG_U1 | 0x2091068d; // Output rate of the UBX-SEC-SIGLOG message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_UART1 = UBX_CFG_U1 | 0x2091068a; // Output rate of the UBX-SEC-SIGLOG message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_UART2 = UBX_CFG_U1 | 0x2091068b; // Output rate of the UBX-SEC-SIGLOG message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_USB = UBX_CFG_U1 | 0x2091068c; // Output rate of the UBX-SEC-SIGLOG message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_I2C = UBX_CFG_U1 | 0x20910097; // Output rate of the UBX-TIM-SVIN message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_SPI = UBX_CFG_U1 | 0x2091009b; // Output rate of the UBX-TIM-SVIN message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_UART1 = UBX_CFG_U1 | 0x20910098; // Output rate of the UBX-TIM-SVIN message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_UART2 = UBX_CFG_U1 | 0x20910099; // Output rate of the UBX-TIM-SVIN message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_USB = UBX_CFG_U1 | 0x2091009a; // Output rate of the UBX-TIM-SVIN message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_I2C = UBX_CFG_U1 | 0x20910490; // Output rate of the UBX-NAV2-PVT message onport I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_SPI = UBX_CFG_U1 | 0x20910494; // Output rate of the UBX-NAV2-PVT message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_UART1 = UBX_CFG_U1 | 0x20910491; // Output rate of the UBX-NAV2-PVT message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_UART2 = UBX_CFG_U1 | 0x20910492; // Output rate of the UBX-NAV2-PVT message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_PVT_USB = UBX_CFG_U1 | 0x20910493; // Output rate of the UBX-NAV2-PVT message onport USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_I2C = UBX_CFG_U1 | 0x20910495; // Output rate of the UBX-NAV2-SAT message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_SPI = UBX_CFG_U1 | 0x20910499; // Output rate of the UBX-NAV2-SAT message onport SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_UART1 = UBX_CFG_U1 | 0x20910496; // Output rate of the UBX-NAV2-SAT message onport UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_UART2 = UBX_CFG_U1 | 0x20910497; // Output rate of the UBX-NAV2-SAT message onport UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SAT_USB = UBX_CFG_U1 | 0x20910498; // Output rate of the UBX-NAV2-SAT message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_I2C = UBX_CFG_U1 | 0x20910500; // Output rate of the UBX-NAV2-SBAS messageon port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_SPI = UBX_CFG_U1 | 0x20910504; // Output rate of the UBX-NAV2-SBAS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_UART1 = UBX_CFG_U1 | 0x20910501; // Output rate of the UBX-NAV2-SBAS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_UART2 = UBX_CFG_U1 | 0x20910502; // Output rate of the UBX-NAV2-SBAS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SBAS_USB = UBX_CFG_U1 | 0x20910503; // Output rate of the UBX-NAV2-SBAS messageon port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_I2C = UBX_CFG_U1 | 0x20910505; // Output rate of the UBX-NAV2-SIG message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_SPI = UBX_CFG_U1 | 0x20910509; // Output rate of the UBX-NAV2-SIG message onport SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_UART1 = UBX_CFG_U1 | 0x20910506; // Output rate of the UBX-NAV2-SIG message onport UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_UART2 = UBX_CFG_U1 | 0x20910507; // Output rate of the UBX-NAV2-SIG message onport UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_USB = UBX_CFG_U1 | 0x20910508; // Output rate of the UBX-NAV2-SIG message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_I2C = UBX_CFG_U1 | 0x20910510; // Output rate of the UBX-NAV2-SLAS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_SPI = UBX_CFG_U1 | 0x20910514; // Output rate of the UBX-NAV2-SLAS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_UART1 = UBX_CFG_U1 | 0x20910511; // Output rate of the UBX-NAV2-SLAS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_UART2 = UBX_CFG_U1 | 0x20910512; // Output rate of the UBX-NAV2-SLAS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_USB = UBX_CFG_U1 | 0x20910513; // Output rate of the UBX-NAV2-SLAS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_I2C = UBX_CFG_U1 | 0x20910515; // Output rate of the UBX-NAV2-STATUS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_SPI = UBX_CFG_U1 | 0x20910519; // Output rate of the UBX-NAV2-STATUS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_UART1 = UBX_CFG_U1 | 0x20910516; // Output rate of the UBX-NAV2-STATUS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_UART2 = UBX_CFG_U1 | 0x20910517; // Output rate of the UBX-NAV2-STATUS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_USB = UBX_CFG_U1 | 0x20910518; // Output rate of the UBX-NAV2-STATUS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_I2C = UBX_CFG_U1 | 0x20910520; // Output rate of the UBX-NAV2-SVIN message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_SPI = UBX_CFG_U1 | 0x20910524; // Output rate of the UBX-NAV2-SVIN message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_UART1 = UBX_CFG_U1 | 0x20910521; // Output rate of the UBX-NAV2-SVIN message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_UART2 = UBX_CFG_U1 | 0x20910522; // Output rate of the UBX-NAV2-SVIN message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_USB = UBX_CFG_U1 | 0x20910523; // Output rate of the UBX-NAV2-SVIN message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_I2C = UBX_CFG_U1 | 0x20910525; // Output rate of the UBX-NAV2-TIMEBDS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_SPI = UBX_CFG_U1 | 0x20910529; // Output rate of the UBX-NAV2-TIMEBDS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_UART1 = UBX_CFG_U1 | 0x20910526; // Output rate of the UBX-NAV2-TIMEBDS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_UART2 = UBX_CFG_U1 | 0x20910527; // Output rate of the UBX-NAV2-TIMEBDS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_USB = UBX_CFG_U1 | 0x20910528; // Output rate of the UBX-NAV2-TIMEBDS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_I2C = UBX_CFG_U1 | 0x20910530; // Output rate of the UBX-NAV2-TIMEGAL message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_SPI = UBX_CFG_U1 | 0x20910534; // Output rate of the UBX-NAV2-TIMEGAL message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_UART1 = UBX_CFG_U1 | 0x20910531; // Output rate of the UBX-NAV2-TIMEGAL message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_UART2 = UBX_CFG_U1 | 0x20910532; // Output rate of the UBX-NAV2-TIMEGAL message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGAL_USB = UBX_CFG_U1 | 0x20910533; // Output rate of the UBX-NAV2-TIMEGAL message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_I2C = UBX_CFG_U1 | 0x20910535; // Output rate of the UBX-NAV2-TIMEGLO message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_SPI = UBX_CFG_U1 | 0x20910539; // Output rate of the UBX-NAV2-TIMEGLO message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_UART1 = UBX_CFG_U1 | 0x20910536; // Output rate of the UBX-NAV2-TIMEGLO message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_UART2 = UBX_CFG_U1 | 0x20910537; // Output rate of the UBX-NAV2-TIMEGLO message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGLO_USB = UBX_CFG_U1 | 0x20910538; // Output rate of the UBX-NAV2-TIMEGLO message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_I2C = UBX_CFG_U1 | 0x20910540; // Output rate of the UBX-NAV2-TIMEGPS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_SPI = UBX_CFG_U1 | 0x20910544; // Output rate of the UBX-NAV2-TIMEGPS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_UART1 = UBX_CFG_U1 | 0x20910541; // Output rate of the UBX-NAV2-TIMEGPS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_UART2 = UBX_CFG_U1 | 0x20910542; // Output rate of the UBX-NAV2-TIMEGPS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEGPS_USB = UBX_CFG_U1 | 0x20910543; // Output rate of the UBX-NAV2-TIMEGPS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_I2C = UBX_CFG_U1 | 0x20910545; // Output rate of the UBX-NAV2-TIMELS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_SPI = UBX_CFG_U1 | 0x20910549; // Output rate of the UBX-NAV2-TIMELS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_UART1 = UBX_CFG_U1 | 0x20910546; // Output rate of the UBX-NAV2-TIMELS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_UART2 = UBX_CFG_U1 | 0x20910547; // Output rate of the UBX-NAV2-TIMELS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_USB = UBX_CFG_U1 | 0x20910548; // Output rate of the UBX-NAV2-TIMELS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMENAVIC_I2C = UBX_CFG_U1 | 0x209106a7; // Output rate of the UBX-NAV2-TIMENAVIC message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMENAVIC_SPI = UBX_CFG_U1 | 0x209106ab; // Output rate of the UBX-NAV2-TIMENAVIC message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMENAVIC_UART1 = UBX_CFG_U1 | 0x209106a8; // Output rate of the UBX-NAV2-TIMENAVIC message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMENAVIC_UART2 = UBX_CFG_U1 | 0x209106a9; // Output rate of the UBX-NAV2-TIMENAVIC message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMENAVIC_USB = UBX_CFG_U1 | 0x209106aa; // Output rate of the UBX-NAV2-TIMENAVIC message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_I2C = UBX_CFG_U1 | 0x20910575; // Output rate of the UBX-NAV2-TIMEQZSS message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_SPI = UBX_CFG_U1 | 0x20910579; // Output rate of the UBX-NAV2-TIMEQZSS message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_UART1 = UBX_CFG_U1 | 0x20910576; // Output rate of the UBX-NAV2-TIMEQZSS message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_UART2 = UBX_CFG_U1 | 0x20910577; // Output rate of the UBX-NAV2-TIMEQZSS message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_USB = UBX_CFG_U1 | 0x20910578; // Output rate of the UBX-NAV2-TIMEQZSS message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_I2C = UBX_CFG_U1 | 0x20910550; // Output rate of the UBX-NAV2-TIMEUTC message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_SPI = UBX_CFG_U1 | 0x20910554; // Output rate of the UBX-NAV2-TIMEUTC message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_UART1 = UBX_CFG_U1 | 0x20910551; // Output rate of the UBX-NAV2-TIMEUTC message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_UART2 = UBX_CFG_U1 | 0x20910552; // Output rate of the UBX-NAV2-TIMEUTC message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_USB = UBX_CFG_U1 | 0x20910553; // Output rate of the UBX-NAV2-TIMEUTC message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_I2C = UBX_CFG_U1 | 0x20910555; // Output rate of the UBX-NAV2-VELECEF message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_SPI = UBX_CFG_U1 | 0x20910559; // Output rate of the UBX-NAV2-VELECEF message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_UART1 = UBX_CFG_U1 | 0x20910556; // Output rate of the UBX-NAV2-VELECEF message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_UART2 = UBX_CFG_U1 | 0x20910557; // Output rate of the UBX-NAV2-VELECEF message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELECEF_USB = UBX_CFG_U1 | 0x20910558; // Output rate of the UBX-NAV2-VELECEF message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_I2C = UBX_CFG_U1 | 0x20910560; // Output rate of the UBX-NAV2-VELNED message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_SPI = UBX_CFG_U1 | 0x20910564; // Output rate of the UBX-NAV2-VELNED message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_UART1 = UBX_CFG_U1 | 0x20910561; // Output rate of the UBX-NAV2-VELNED message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_UART2 = UBX_CFG_U1 | 0x20910562; // Output rate of the UBX-NAV2-VELNED message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_VELNED_USB = UBX_CFG_U1 | 0x20910563; // Output rate of the UBX-NAV2-VELNED message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_I2C = UBX_CFG_U1 | 0x20910590; // Output rate of the UBX-NAV-NMI message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_SPI = UBX_CFG_U1 | 0x20910594; // Output rate of the UBX-NAV-NMI message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_UART1 = UBX_CFG_U1 | 0x20910591; // Output rate of the UBX-NAV-NMI message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_UART2 = UBX_CFG_U1 | 0x20910592; // Output rate of the UBX-NAV-NMI message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_NMI_USB = UBX_CFG_U1 | 0x20910593; // Output rate of the UBX-NAV-NMI message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_I2C = UBX_CFG_U1 | 0x20910610; // Output rate of the UBX-RXM-TM message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_SPI = UBX_CFG_U1 | 0x20910614; // Output rate of the UBX-RXM-TM message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_UART1 = UBX_CFG_U1 | 0x20910611; // Output rate of the UBX-RXM-TM message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_UART2 = UBX_CFG_U1 | 0x20910612; // Output rate of the UBX-RXM-TM message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_TM_USB = UBX_CFG_U1 | 0x20910613; // Output rate of the UBX-RXM-TM message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_I2C = UBX_CFG_U1 | 0x20910689; // Output rate of the UBX-SEC-SIGLOG message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_SPI = UBX_CFG_U1 | 0x2091068d; // Output rate of the UBX-SEC-SIGLOG message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_UART1 = UBX_CFG_U1 | 0x2091068a; // Output rate of the UBX-SEC-SIGLOG message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_UART2 = UBX_CFG_U1 | 0x2091068b; // Output rate of the UBX-SEC-SIGLOG message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_SEC_SIGLOG_USB = UBX_CFG_U1 | 0x2091068c; // Output rate of the UBX-SEC-SIGLOG message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_I2C = UBX_CFG_U1 | 0x20910097; // Output rate of the UBX-TIM-SVIN message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_SPI = UBX_CFG_U1 | 0x2091009b; // Output rate of the UBX-TIM-SVIN message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_UART1 = UBX_CFG_U1 | 0x20910098; // Output rate of the UBX-TIM-SVIN message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_UART2 = UBX_CFG_U1 | 0x20910099; // Output rate of the UBX-TIM-SVIN message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_USB = UBX_CFG_U1 | 0x2091009a; // Output rate of the UBX-TIM-SVIN message on port USB // Additional CFG_MSGOUT keys for the NEO-D9S //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C = UBX_CFG_U1 | 0x2091031d; // Output rate of the UBX_RXM_PMP message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_SPI = UBX_CFG_U1 | 0x20910321; // Output rate of the UBX_RXM_PMP message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1 = UBX_CFG_U1 | 0x2091031e; // Output rate of the UBX_RXM_PMP message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2 = UBX_CFG_U1 | 0x2091031f; // Output rate of the UBX_RXM_PMP message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_USB = UBX_CFG_U1 | 0x20910320; // Output rate of the UBX_RXM_PMP message on port USB -const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_I2C = UBX_CFG_U1 | 0x20910322; // Output rate of the UBX_MON_PMP message on port I2C -const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_SPI = UBX_CFG_U1 | 0x20910326; // Output rate of the UBX_MON_PMP message on port SPI -const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_UART1 = UBX_CFG_U1 | 0x20910323; // Output rate of the UBX_MON_PMP message on port UART1 -const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_UART2 = UBX_CFG_U1 | 0x20910324; // Output rate of the UBX_MON_PMP message on port UART2 -const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_USB = UBX_CFG_U1 | 0x20910325; // Output rate of the UBX_MON_PMP message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C = UBX_CFG_U1 | 0x2091031d; // Output rate of the UBX_RXM_PMP message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_SPI = UBX_CFG_U1 | 0x20910321; // Output rate of the UBX_RXM_PMP message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1 = UBX_CFG_U1 | 0x2091031e; // Output rate of the UBX_RXM_PMP message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2 = UBX_CFG_U1 | 0x2091031f; // Output rate of the UBX_RXM_PMP message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_USB = UBX_CFG_U1 | 0x20910320; // Output rate of the UBX_RXM_PMP message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_I2C = UBX_CFG_U1 | 0x20910322; // Output rate of the UBX_MON_PMP message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_SPI = UBX_CFG_U1 | 0x20910326; // Output rate of the UBX_MON_PMP message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_UART1 = UBX_CFG_U1 | 0x20910323; // Output rate of the UBX_MON_PMP message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_UART2 = UBX_CFG_U1 | 0x20910324; // Output rate of the UBX_MON_PMP message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_USB = UBX_CFG_U1 | 0x20910325; // Output rate of the UBX_MON_PMP message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PT2_I2C = UBX_CFG_U1 | 0x20910209; // Output rate of the UBX_MON_PT2 message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PT2_SPI = UBX_CFG_U1 | 0x2091020d; // Output rate of the UBX_MON_PT2 message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PT2_UART1 = UBX_CFG_U1 | 0x2091020a; // Output rate of the UBX_MON_PT2 message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PT2_UART2 = UBX_CFG_U1 | 0x2091020b; // Output rate of the UBX_MON_PT2 message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PT2_USB = UBX_CFG_U1 | 0x2091020c; // Output rate of the UBX_MON_PT2 message on port USB +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TEMP_I2C = UBX_CFG_U1 | 0x20910331; // Output rate of the UBX_MON_TEMP message on port I2C +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TEMP_SPI = UBX_CFG_U1 | 0x20910335; // Output rate of the UBX_MON_TEMP message on port SPI +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TEMP_UART1 = UBX_CFG_U1 | 0x20910332; // Output rate of the UBX_MON_TEMP message on port UART1 +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TEMP_UART2 = UBX_CFG_U1 | 0x20910333; // Output rate of the UBX_MON_TEMP message on port UART2 +const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TEMP_USB = UBX_CFG_U1 | 0x20910334; // Output rate of the UBX_MON_TEMP message on port USB // Additional CFG_MSGOUT keys for the NEO-D9S //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @@ -899,6 +941,35 @@ const uint32_t UBLOX_CFG_NAV2_SBAS_USE_INTEGRITY = UBX_CFG_L | 0x10170002; // Us //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_NAVHPG_DGNSSMODE = UBX_CFG_E1 | 0x20140011; // Differential corrections mode +// CFG-NAVMASK: Satellite Elevation Mask Configuration (ZED_F9T) +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_000_020 = UBX_CFG_X8 | 0x50180001; // Elevation masks for azimuth range 0 <= az < 20 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_020_040 = UBX_CFG_X8 | 0x50180002; // Elevation masks for azimuth range 20 <= az < 40 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_040_060 = UBX_CFG_X8 | 0x50180003; // Elevation masks for azimuth range 40 <= az < 60 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_060_080 = UBX_CFG_X8 | 0x50180004; // Elevation masks for azimuth range 60 <= az < 80 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_080_100 = UBX_CFG_X8 | 0x50180005; // Elevation masks for azimuth range 80 <= az < 100 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_100_120 = UBX_CFG_X8 | 0x50180006; // Elevation masks for azimuth range 100 <= az < 120 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_120_140 = UBX_CFG_X8 | 0x50180007; // Elevation masks for azimuth range 120 <= az < 140 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_140_160 = UBX_CFG_X8 | 0x50180008; // Elevation masks for azimuth range 140 <= az < 160 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_160_180 = UBX_CFG_X8 | 0x50180009; // Elevation masks for azimuth range 160 <= az < 180 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_180_200 = UBX_CFG_X8 | 0x5018000a; // Elevation masks for azimuth range 180 <= az < 200 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_200_220 = UBX_CFG_X8 | 0x5018000b; // Elevation masks for azimuth range 200 <= az < 220 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_220_240 = UBX_CFG_X8 | 0x5018000c; // Elevation masks for azimuth range 220 <= az < 240 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_240_260 = UBX_CFG_X8 | 0x5018000d; // Elevation masks for azimuth range 240 <= az < 260 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_260_280 = UBX_CFG_X8 | 0x5018000e; // Elevation masks for azimuth range 260 <= az < 280 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_280_300 = UBX_CFG_X8 | 0x5018000f; // Elevation masks for azimuth range 280 <= az < 300 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_300_320 = UBX_CFG_X8 | 0x50180010; // Elevation masks for azimuth range 300 <= az < 320 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_320_340 = UBX_CFG_X8 | 0x50180011; // Elevation masks for azimuth range 320 <= az < 340 deg +const uint32_t UBLOX_CFG_NAVMASK_EL_MASK_340_360 = UBX_CFG_X8 | 0x50180012; // Elevation masks for azimuth range 340 <= az < 360 deg + +// CFG-NAVMASK: Satellite Mask Configuration (F10) +//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- +const uint32_t UBLOX_CFG_NAVMASK_SV_MASK_GPS = UBX_CFG_X8 | 0x50180013; // Satellite mask for the GPS system +const uint32_t UBLOX_CFG_NAVMASK_SV_MASK_GAL = UBX_CFG_X8 | 0x50180014; // Satellite mask for the GALILEO system +const uint32_t UBLOX_CFG_NAVMASK_SV_MASK_BDS = UBX_CFG_X8 | 0x50180016; // Satellite mask for the BeiDou system +const uint32_t UBLOX_CFG_NAVMASK_SV_MASK_QZSS = UBX_CFG_X8 | 0x50180017; // Satellite mask for the QZSS system +const uint32_t UBLOX_CFG_NAVMASK_SV_MASK_NAVIC = UBX_CFG_X8 | 0x50180018; // Satellite mask for the NavIC system + // CFG-NAVSPG: Standard precision navigation configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_NAVSPG_FIXMODE = UBX_CFG_E1 | 0x20110011; // Position fix mode @@ -950,6 +1021,7 @@ const uint32_t UBLOX_CFG_NMEA_FILT_GAL = UBX_CFG_L | 0x10930013; // Disable const uint32_t UBLOX_CFG_NMEA_FILT_QZSS = UBX_CFG_L | 0x10930015; // Disable reporting of QZSS satellites const uint32_t UBLOX_CFG_NMEA_FILT_GLO = UBX_CFG_L | 0x10930016; // Disable reporting of GLONASS satellites const uint32_t UBLOX_CFG_NMEA_FILT_BDS = UBX_CFG_L | 0x10930017; // Disable reporting of BeiDou satellites +const uint32_t UBLOX_CFG_NMEA_FILT_NAVIC = UBX_CFG_L | 0x10930018; // Disable reporting of NavIC satellites const uint32_t UBLOX_CFG_NMEA_OUT_INVFIX = UBX_CFG_L | 0x10930021; // Enable position output for failed or invalid fixes const uint32_t UBLOX_CFG_NMEA_OUT_MSKFIX = UBX_CFG_L | 0x10930022; // Enable position output for invalid fixes const uint32_t UBLOX_CFG_NMEA_OUT_INVTIME = UBX_CFG_L | 0x10930023; // Enable time output for invalid times @@ -1043,17 +1115,20 @@ const uint32_t UBLOX_CFG_RTCM_DF003_IN_FILTER = UBX_CFG_E1 | 0x20090009; // RTCM // CFG-SBAS: SBAS configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_SBAS_USE_TESTMODE = UBX_CFG_L | 0x10360002; // Use SBAS data when it is in test mode (SBAS msg 0) -const uint32_t UBLOX_CFG_SBAS_USE_RANGING = UBX_CFG_L | 0x10360003; // Use SBAS GEOs as a ranging source (for navigation) -const uint32_t UBLOX_CFG_SBAS_USE_DIFFCORR = UBX_CFG_L | 0x10360004; // Use SBAS differential corrections -const uint32_t UBLOX_CFG_SBAS_USE_INTEGRITY = UBX_CFG_L | 0x10360005; // Use SBAS integrity information -const uint32_t UBLOX_CFG_SBAS_PRNSCANMASK = UBX_CFG_X8 | 0x50360006; // SBAS PRN search configuration - -// CFG-SEC: Security configuration (ZED-F9R) +const uint32_t UBLOX_CFG_SBAS_USE_TESTMODE = UBX_CFG_L | 0x10360002; // Use SBAS data when it is in test mode (SBAS msg 0) +const uint32_t UBLOX_CFG_SBAS_USE_RANGING = UBX_CFG_L | 0x10360003; // Use SBAS GEOs as a ranging source (for navigation) +const uint32_t UBLOX_CFG_SBAS_USE_DIFFCORR = UBX_CFG_L | 0x10360004; // Use SBAS differential corrections +const uint32_t UBLOX_CFG_SBAS_USE_INTEGRITY = UBX_CFG_L | 0x10360005; // Use SBAS integrity information +const uint32_t UBLOX_CFG_SBAS_ACCEPT_NOT_IN_PRNMASK = UBX_CFG_X2 | 0x30360008; // Accept corrections from SBAS SV +const uint32_t UBLOX_CFG_SBAS_USE_IONOONLY = UBX_CFG_L | 0x10360007; // Use SBAS ionosphere correction only +const uint32_t UBLOX_CFG_SBAS_PRNSCANMASK = UBX_CFG_X8 | 0x50360006; // SBAS PRN search configuration + +// CFG-SEC: Security configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_SEC_CFG_LOCK = UBX_CFG_L | 0x10f60009; // Configuration lockdown -const uint32_t UBLOX_CFG_SEC_CFG_LOCK_UNLOCKGRP1 = UBX_CFG_U2 | 0x30f6000a; // Configuration lockdown exempted group 1 -const uint32_t UBLOX_CFG_SEC_CFG_LOCK_UNLOCKGRP2 = UBX_CFG_U2 | 0x30f6000b; // Configuration lockdown exempted group 2 +const uint32_t UBLOX_CFG_SEC_CFG_LOCK = UBX_CFG_L | 0x10f60009; // Configuration lockdown +const uint32_t UBLOX_CFG_SEC_CFG_LOCK_UNLOCKGRP1 = UBX_CFG_U2 | 0x30f6000a; // Configuration lockdown exempted group 1 +const uint32_t UBLOX_CFG_SEC_CFG_LOCK_UNLOCKGRP2 = UBX_CFG_U2 | 0x30f6000b; // Configuration lockdown exempted group 2 +const uint32_t UBLOX_CFG_SEC_JAMDET_SENSITIVITY_HI = UBX_CFG_L | 0x10f60051; // go for a more sensitive jamming detection // CFG-SFCORE: Sensor fusion (SF) core configuration (ZED-F9R) //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @@ -1122,6 +1197,8 @@ const uint32_t UBLOX_CFG_SIGNAL_QZSS_L2C_ENA = UBX_CFG_L | 0x10310015; // QZSS const uint32_t UBLOX_CFG_SIGNAL_GLO_ENA = UBX_CFG_L | 0x10310025; // GLONASS enable const uint32_t UBLOX_CFG_SIGNAL_GLO_L1_ENA = UBX_CFG_L | 0x10310018; // GLONASS L1 const uint32_t UBLOX_CFG_SIGNAL_GLO_L2_ENA = UBX_CFG_L | 0x1031001a; // GLONASS L2 (only on u-blox F9 platform products) +const uint32_t UBLOX_CFG_SIGNAL_NAVIC_ENA = UBX_CFG_L | 0x10310026; // NavIC +const uint32_t UBLOX_CFG_SIGNAL_NAVIC_L5_ENA = UBX_CFG_L | 0x1031001d; // NavIC L5 // CFG-SPARTN: Configuration of the SPARTN interface //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @@ -1129,7 +1206,7 @@ const uint32_t UBLOX_CFG_SPARTN_USE_SOURCE = UBX_CFG_E1 | 0x20a70001; // CFG-SPI: Configuration of the SPI interface //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_SPI_MAXFF = UBX_CFG_U1 | 0x20640001; // Number of bytes containing 0xFF to receive before switching off reception. Range: 0 (mechanism off) - 63 +const uint32_t UBLOX_CFG_SPI_MAXFF = UBX_CFG_U1 | 0x20640001; // Number of bytes containing 0xFF to receive before switching off reception. Range: 0 (mechanism off) - 63 const uint32_t UBLOX_CFG_SPI_CPOLARITY = UBX_CFG_L | 0x10640002; // Clock polarity select: 0: Active Hight Clock, SCLK idles low, 1: Active Low Clock, SCLK idles high const uint32_t UBLOX_CFG_SPI_CPHASE = UBX_CFG_L | 0x10640003; // Clock phase select: 0: Data captured on first edge of SCLK, 1: Data captured on second edge of SCLK const uint32_t UBLOX_CFG_SPI_EXTENDEDTIMEOUT = UBX_CFG_L | 0x10640005; // Flag to disable timeouting the interface after 1.5s @@ -1182,11 +1259,11 @@ const uint32_t UBLOX_CFG_TP_LEN_LOCK_TP1 = UBX_CFG_U4 | 0x40050005; // Time const uint32_t UBLOX_CFG_TP_DUTY_TP1 = UBX_CFG_R8 | 0x5005002a; // Time pulse duty cycle (TP1) const uint32_t UBLOX_CFG_TP_DUTY_LOCK_TP1 = UBX_CFG_R8 | 0x5005002b; // Time pulse duty cycle when locked to GNSS time (TP1) const uint32_t UBLOX_CFG_TP_USER_DELAY_TP1 = UBX_CFG_I4 | 0x40050006; // User-configurable time pulse delay (TP1) -const uint32_t UBLOX_CFG_TP_TP1_ENA = UBX_CFG_L | 0x10050007; // Enable the first timepulse -const uint32_t UBLOX_CFG_TP_SYNC_GNSS_TP1 = UBX_CFG_L | 0x10050008; // Sync time pulse to GNSS time or local clock (TP1) -const uint32_t UBLOX_CFG_TP_USE_LOCKED_TP1 = UBX_CFG_L | 0x10050009; // Use locked parameters when possible (TP1) -const uint32_t UBLOX_CFG_TP_ALIGN_TO_TOW_TP1 = UBX_CFG_L | 0x1005000a; // Align time pulse to top of second (TP1) -const uint32_t UBLOX_CFG_TP_POL_TP1 = UBX_CFG_L | 0x1005000b; // Set time pulse polarity (TP1) +const uint32_t UBLOX_CFG_TP_TP1_ENA = UBX_CFG_L | 0x10050007; // Enable the first timepulse +const uint32_t UBLOX_CFG_TP_SYNC_GNSS_TP1 = UBX_CFG_L | 0x10050008; // Sync time pulse to GNSS time or local clock (TP1) +const uint32_t UBLOX_CFG_TP_USE_LOCKED_TP1 = UBX_CFG_L | 0x10050009; // Use locked parameters when possible (TP1) +const uint32_t UBLOX_CFG_TP_ALIGN_TO_TOW_TP1 = UBX_CFG_L | 0x1005000a; // Align time pulse to top of second (TP1) +const uint32_t UBLOX_CFG_TP_POL_TP1 = UBX_CFG_L | 0x1005000b; // Set time pulse polarity (TP1) const uint32_t UBLOX_CFG_TP_TIMEGRID_TP1 = UBX_CFG_E1 | 0x2005000c; // Time grid to use (TP1) const uint32_t UBLOX_CFG_TP_PERIOD_TP2 = UBX_CFG_U4 | 0x4005000d; // Time pulse period (TP2) const uint32_t UBLOX_CFG_TP_PERIOD_LOCK_TP2 = UBX_CFG_U4 | 0x4005000e; // Time pulse period when locked to GNSS time @@ -1197,19 +1274,19 @@ const uint32_t UBLOX_CFG_TP_LEN_LOCK_TP2 = UBX_CFG_U4 | 0x40050010; // Time const uint32_t UBLOX_CFG_TP_DUTY_TP2 = UBX_CFG_R8 | 0x5005002c; // Time pulse duty cycle (TP2) const uint32_t UBLOX_CFG_TP_DUTY_LOCK_TP2 = UBX_CFG_R8 | 0x5005002d; // Time pulse duty cycle when locked to GNSS time const uint32_t UBLOX_CFG_TP_USER_DELAY_TP2 = UBX_CFG_I4 | 0x40050011; // User-configurable time pulse delay (TP2) -const uint32_t UBLOX_CFG_TP_TP2_ENA = UBX_CFG_L | 0x10050012; // Enable the second timepulse -const uint32_t UBLOX_CFG_TP_SYNC_GNSS_TP2 = UBX_CFG_L | 0x10050013; // Sync time pulse to GNSS time or local clock -const uint32_t UBLOX_CFG_TP_USE_LOCKED_TP2 = UBX_CFG_L | 0x10050014; // Use locked parameters when possible (TP2) -const uint32_t UBLOX_CFG_TP_ALIGN_TO_TOW_TP2 = UBX_CFG_L | 0x10050015; // Align time pulse to top of second (TP2) -const uint32_t UBLOX_CFG_TP_POL_TP2 = UBX_CFG_L | 0x10050016; // Set time pulse polarity (TP2) +const uint32_t UBLOX_CFG_TP_TP2_ENA = UBX_CFG_L | 0x10050012; // Enable the second timepulse +const uint32_t UBLOX_CFG_TP_SYNC_GNSS_TP2 = UBX_CFG_L | 0x10050013; // Sync time pulse to GNSS time or local clock +const uint32_t UBLOX_CFG_TP_USE_LOCKED_TP2 = UBX_CFG_L | 0x10050014; // Use locked parameters when possible (TP2) +const uint32_t UBLOX_CFG_TP_ALIGN_TO_TOW_TP2 = UBX_CFG_L | 0x10050015; // Align time pulse to top of second (TP2) +const uint32_t UBLOX_CFG_TP_POL_TP2 = UBX_CFG_L | 0x10050016; // Set time pulse polarity (TP2) const uint32_t UBLOX_CFG_TP_TIMEGRID_TP2 = UBX_CFG_E1 | 0x20050017; // Time grid to use (TP2) const uint32_t UBLOX_CFG_TP_DRSTR_TP1 = UBX_CFG_E1 | 0x20050035; // Set drive strength of TP1 const uint32_t UBLOX_CFG_TP_DRSTR_TP2 = UBX_CFG_E1 | 0x20050036; // Set drive strength of TP2 // CFG-TXREADY: TX ready configuration //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_TXREADY_ENABLED = UBX_CFG_L | 0x10a20001; // Flag to indicate if TX ready pin mechanism should be enabled -const uint32_t UBLOX_CFG_TXREADY_POLARITY = UBX_CFG_L | 0x10a20002; // The polarity of the TX ready pin: false:high- active, true:low-active +const uint32_t UBLOX_CFG_TXREADY_ENABLED = UBX_CFG_L | 0x10a20001; // Flag to indicate if TX ready pin mechanism should be enabled +const uint32_t UBLOX_CFG_TXREADY_POLARITY = UBX_CFG_L | 0x10a20002; // The polarity of the TX ready pin: false:high- active, true:low-active const uint32_t UBLOX_CFG_TXREADY_PIN = UBX_CFG_U1 | 0x20a20003; // Pin number to use for the TX ready functionality const uint32_t UBLOX_CFG_TXREADY_THRESHOLD = UBX_CFG_U2 | 0x30a20004; // Amount of data that should be ready on the interface before triggering the TX ready pin const uint32_t UBLOX_CFG_TXREADY_INTERFACE = UBX_CFG_E1 | 0x20a20005; // Interface where the TX ready feature should be linked to @@ -1220,12 +1297,14 @@ const uint32_t UBLOX_CFG_UART1_BAUDRATE = UBX_CFG_U4 | 0x40520001; // The baud r const uint32_t UBLOX_CFG_UART1_STOPBITS = UBX_CFG_E1 | 0x20520002; // Number of stopbits that should be used on UART1 const uint32_t UBLOX_CFG_UART1_DATABITS = UBX_CFG_E1 | 0x20520003; // Number of databits that should be used on UART1 const uint32_t UBLOX_CFG_UART1_PARITY = UBX_CFG_E1 | 0x20520004; // Parity mode that should be used on UART1 -const uint32_t UBLOX_CFG_UART1_ENABLED = UBX_CFG_L | 0x10520005; // Flag to indicate if the UART1 should be enabled +const uint32_t UBLOX_CFG_UART1_ENABLED = UBX_CFG_L | 0x10520005; // Flag to indicate if the UART1 should be enabled +const uint32_t UBLOX_CFG_UART1_REMAP = UBX_CFG_L | 0x10520006; // UART1 Remapping // CFG-UART1INPROT: Input protocol configuration of the UART1 interface //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_UART1INPROT_UBX = UBX_CFG_L | 0x10730001; // Flag to indicate if UBX should be an input protocol on UART1 const uint32_t UBLOX_CFG_UART1INPROT_NMEA = UBX_CFG_L | 0x10730002; // Flag to indicate if NMEA should be an input protocol on UART1 +const uint32_t UBLOX_CFG_UART1INPROT_RTCM2X = UBX_CFG_L | 0x10730003; // Flag to indicate if RTCM2X should be an input protocol on UART1 const uint32_t UBLOX_CFG_UART1INPROT_RTCM3X = UBX_CFG_L | 0x10730004; // Flag to indicate if RTCM3X should be an input protocol on UART1 const uint32_t UBLOX_CFG_UART1INPROT_SPARTN = UBX_CFG_L | 0x10730005; // Flag to indicate if SPARTN should be an input protocol on UART1 @@ -1241,8 +1320,8 @@ const uint32_t UBLOX_CFG_UART2_BAUDRATE = UBX_CFG_U4 | 0x40530001; // The baud r const uint32_t UBLOX_CFG_UART2_STOPBITS = UBX_CFG_E1 | 0x20530002; // Number of stopbits that should be used on UART2 const uint32_t UBLOX_CFG_UART2_DATABITS = UBX_CFG_E1 | 0x20530003; // Number of databits that should be used on UART2 const uint32_t UBLOX_CFG_UART2_PARITY = UBX_CFG_E1 | 0x20530004; // Parity mode that should be used on UART2 -const uint32_t UBLOX_CFG_UART2_ENABLED = UBX_CFG_L | 0x10530005; // Flag to indicate if the UART2 should be enabled -const uint32_t UBLOX_CFG_UART2_REMAP = UBX_CFG_L | 0x10530006; // UART2 Remapping +const uint32_t UBLOX_CFG_UART2_ENABLED = UBX_CFG_L | 0x10530005; // Flag to indicate if the UART2 should be enabled +const uint32_t UBLOX_CFG_UART2_REMAP = UBX_CFG_L | 0x10530006; // UART2 Remapping // CFG-UART2INPROT: Input protocol configuration of the UART2 interface //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- @@ -1259,8 +1338,8 @@ const uint32_t UBLOX_CFG_UART2OUTPROT_RTCM3X = UBX_CFG_L | 0x10760004; // Flag t // CFG-USB: Configuration of the USB interface //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -const uint32_t UBLOX_CFG_USB_ENABLED = UBX_CFG_L | 0x10650001; // Flag to indicate if the USB interface should be enabled -const uint32_t UBLOX_CFG_USB_SELFPOW = UBX_CFG_L | 0x10650002; // Self-powered device +const uint32_t UBLOX_CFG_USB_ENABLED = UBX_CFG_L | 0x10650001; // Flag to indicate if the USB interface should be enabled +const uint32_t UBLOX_CFG_USB_SELFPOW = UBX_CFG_L | 0x10650002; // Self-powered device const uint32_t UBLOX_CFG_USB_VENDOR_ID = UBX_CFG_U2 | 0x3065000a; // Vendor ID const uint32_t UBLOX_CFG_USB_PRODUCT_ID = UBX_CFG_U2 | 0x3065000b; // Vendor ID const uint32_t UBLOX_CFG_USB_POWER = UBX_CFG_U2 | 0x3065000c; // Power consumption @@ -1281,6 +1360,7 @@ const uint32_t UBLOX_CFG_USB_SERIAL_NO_STR3 = UBX_CFG_X8 | 0x50650018; // Serial //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- const uint32_t UBLOX_CFG_USBINPROT_UBX = UBX_CFG_L | 0x10770001; // Flag to indicate if UBX should be an input protocol on USB const uint32_t UBLOX_CFG_USBINPROT_NMEA = UBX_CFG_L | 0x10770002; // Flag to indicate if NMEA should be an input protocol on USB +const uint32_t UBLOX_CFG_USBINPROT_RTCM2X = UBX_CFG_L | 0x10770003; // Flag to indicate if RTCM2X should be an input protocol on USB const uint32_t UBLOX_CFG_USBINPROT_RTCM3X = UBX_CFG_L | 0x10770004; // Flag to indicate if RTCM3X should be an input protocol on USB const uint32_t UBLOX_CFG_USBINPROT_SPARTN = UBX_CFG_L | 0x10770005; // Flag to indicate if SPARTN should be an input protocol on USB diff --git a/src/u-blox_external_typedefs.h b/src/u-blox_external_typedefs.h index ee3b36b..c0bbe34 100644 --- a/src/u-blox_external_typedefs.h +++ b/src/u-blox_external_typedefs.h @@ -336,3 +336,184 @@ const uint16_t SFE_UBLOX_DAYS_SINCE_MONTH[2][12] = const uint32_t SFE_UBLOX_JAN_1ST_2020_WEEK = 2086; // GPS Week Number for Jan 1st 2020 const uint32_t SFE_UBLOX_EPOCH_WEEK_2086 = 1577836800 - 259200; // Epoch for the start of GPS week 2086 const uint32_t SFE_UBLOX_SECS_PER_WEEK = 60 * 60 * 24 * 7; // Seconds per week + +//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= + +// SPARTN CRC calculation +// Stolen from https://github.com/u-blox/ubxlib/blob/master/common/spartn/src/u_spartn_crc.c + +const uint8_t sfe_ublox_u8Crc4Table[] = { + 0x00U, 0x0BU, 0x05U, 0x0EU, 0x0AU, 0x01U, 0x0FU, 0x04U, + 0x07U, 0x0CU, 0x02U, 0x09U, 0x0DU, 0x06U, 0x08U, 0x03U, + 0x0EU, 0x05U, 0x0BU, 0x00U, 0x04U, 0x0FU, 0x01U, 0x0AU, + 0x09U, 0x02U, 0x0CU, 0x07U, 0x03U, 0x08U, 0x06U, 0x0DU, + 0x0FU, 0x04U, 0x0AU, 0x01U, 0x05U, 0x0EU, 0x00U, 0x0BU, + 0x08U, 0x03U, 0x0DU, 0x06U, 0x02U, 0x09U, 0x07U, 0x0CU, + 0x01U, 0x0AU, 0x04U, 0x0FU, 0x0BU, 0x00U, 0x0EU, 0x05U, + 0x06U, 0x0DU, 0x03U, 0x08U, 0x0CU, 0x07U, 0x09U, 0x02U, + 0x0DU, 0x06U, 0x08U, 0x03U, 0x07U, 0x0CU, 0x02U, 0x09U, + 0x0AU, 0x01U, 0x0FU, 0x04U, 0x00U, 0x0BU, 0x05U, 0x0EU, + 0x03U, 0x08U, 0x06U, 0x0DU, 0x09U, 0x02U, 0x0CU, 0x07U, + 0x04U, 0x0FU, 0x01U, 0x0AU, 0x0EU, 0x05U, 0x0BU, 0x00U, + 0x02U, 0x09U, 0x07U, 0x0CU, 0x08U, 0x03U, 0x0DU, 0x06U, + 0x05U, 0x0EU, 0x00U, 0x0BU, 0x0FU, 0x04U, 0x0AU, 0x01U, + 0x0CU, 0x07U, 0x09U, 0x02U, 0x06U, 0x0DU, 0x03U, 0x08U, + 0x0BU, 0x00U, 0x0EU, 0x05U, 0x01U, 0x0AU, 0x04U, 0x0FU, + 0x09U, 0x02U, 0x0CU, 0x07U, 0x03U, 0x08U, 0x06U, 0x0DU, + 0x0EU, 0x05U, 0x0BU, 0x00U, 0x04U, 0x0FU, 0x01U, 0x0AU, + 0x07U, 0x0CU, 0x02U, 0x09U, 0x0DU, 0x06U, 0x08U, 0x03U, + 0x00U, 0x0BU, 0x05U, 0x0EU, 0x0AU, 0x01U, 0x0FU, 0x04U, + 0x06U, 0x0DU, 0x03U, 0x08U, 0x0CU, 0x07U, 0x09U, 0x02U, + 0x01U, 0x0AU, 0x04U, 0x0FU, 0x0BU, 0x00U, 0x0EU, 0x05U, + 0x08U, 0x03U, 0x0DU, 0x06U, 0x02U, 0x09U, 0x07U, 0x0CU, + 0x0FU, 0x04U, 0x0AU, 0x01U, 0x05U, 0x0EU, 0x00U, 0x0BU, + 0x04U, 0x0FU, 0x01U, 0x0AU, 0x0EU, 0x05U, 0x0BU, 0x00U, + 0x03U, 0x08U, 0x06U, 0x0DU, 0x09U, 0x02U, 0x0CU, 0x07U, + 0x0AU, 0x01U, 0x0FU, 0x04U, 0x00U, 0x0BU, 0x05U, 0x0EU, + 0x0DU, 0x06U, 0x08U, 0x03U, 0x07U, 0x0CU, 0x02U, 0x09U, + 0x0BU, 0x00U, 0x0EU, 0x05U, 0x01U, 0x0AU, 0x04U, 0x0FU, + 0x0CU, 0x07U, 0x09U, 0x02U, 0x06U, 0x0DU, 0x03U, 0x08U, + 0x05U, 0x0EU, 0x00U, 0x0BU, 0x0FU, 0x04U, 0x0AU, 0x01U, + 0x02U, 0x09U, 0x07U, 0x0CU, 0x08U, 0x03U, 0x0DU, 0x06U +}; + +const uint8_t sfe_ublox_u8Crc8Table[] = { + 0x00U, 0x07U, 0x0EU, 0x09U, 0x1CU, 0x1BU, 0x12U, 0x15U, + 0x38U, 0x3FU, 0x36U, 0x31U, 0x24U, 0x23U, 0x2AU, 0x2DU, + 0x70U, 0x77U, 0x7EU, 0x79U, 0x6CU, 0x6BU, 0x62U, 0x65U, + 0x48U, 0x4FU, 0x46U, 0x41U, 0x54U, 0x53U, 0x5AU, 0x5DU, + 0xE0U, 0xE7U, 0xEEU, 0xE9U, 0xFCU, 0xFBU, 0xF2U, 0xF5U, + 0xD8U, 0xDFU, 0xD6U, 0xD1U, 0xC4U, 0xC3U, 0xCAU, 0xCDU, + 0x90U, 0x97U, 0x9EU, 0x99U, 0x8CU, 0x8BU, 0x82U, 0x85U, + 0xA8U, 0xAFU, 0xA6U, 0xA1U, 0xB4U, 0xB3U, 0xBAU, 0xBDU, + 0xC7U, 0xC0U, 0xC9U, 0xCEU, 0xDBU, 0xDCU, 0xD5U, 0xD2U, + 0xFFU, 0xF8U, 0xF1U, 0xF6U, 0xE3U, 0xE4U, 0xEDU, 0xEAU, + 0xB7U, 0xB0U, 0xB9U, 0xBEU, 0xABU, 0xACU, 0xA5U, 0xA2U, + 0x8FU, 0x88U, 0x81U, 0x86U, 0x93U, 0x94U, 0x9DU, 0x9AU, + 0x27U, 0x20U, 0x29U, 0x2EU, 0x3BU, 0x3CU, 0x35U, 0x32U, + 0x1FU, 0x18U, 0x11U, 0x16U, 0x03U, 0x04U, 0x0DU, 0x0AU, + 0x57U, 0x50U, 0x59U, 0x5EU, 0x4BU, 0x4CU, 0x45U, 0x42U, + 0x6FU, 0x68U, 0x61U, 0x66U, 0x73U, 0x74U, 0x7DU, 0x7AU, + 0x89U, 0x8EU, 0x87U, 0x80U, 0x95U, 0x92U, 0x9BU, 0x9CU, + 0xB1U, 0xB6U, 0xBFU, 0xB8U, 0xADU, 0xAAU, 0xA3U, 0xA4U, + 0xF9U, 0xFEU, 0xF7U, 0xF0U, 0xE5U, 0xE2U, 0xEBU, 0xECU, + 0xC1U, 0xC6U, 0xCFU, 0xC8U, 0xDDU, 0xDAU, 0xD3U, 0xD4U, + 0x69U, 0x6EU, 0x67U, 0x60U, 0x75U, 0x72U, 0x7BU, 0x7CU, + 0x51U, 0x56U, 0x5FU, 0x58U, 0x4DU, 0x4AU, 0x43U, 0x44U, + 0x19U, 0x1EU, 0x17U, 0x10U, 0x05U, 0x02U, 0x0BU, 0x0CU, + 0x21U, 0x26U, 0x2FU, 0x28U, 0x3DU, 0x3AU, 0x33U, 0x34U, + 0x4EU, 0x49U, 0x40U, 0x47U, 0x52U, 0x55U, 0x5CU, 0x5BU, + 0x76U, 0x71U, 0x78U, 0x7FU, 0x6AU, 0x6DU, 0x64U, 0x63U, + 0x3EU, 0x39U, 0x30U, 0x37U, 0x22U, 0x25U, 0x2CU, 0x2BU, + 0x06U, 0x01U, 0x08U, 0x0FU, 0x1AU, 0x1DU, 0x14U, 0x13U, + 0xAEU, 0xA9U, 0xA0U, 0xA7U, 0xB2U, 0xB5U, 0xBCU, 0xBBU, + 0x96U, 0x91U, 0x98U, 0x9FU, 0x8AU, 0x8DU, 0x84U, 0x83U, + 0xDEU, 0xD9U, 0xD0U, 0xD7U, 0xC2U, 0xC5U, 0xCCU, 0xCBU, + 0xE6U, 0xE1U, 0xE8U, 0xEFU, 0xFAU, 0xFDU, 0xF4U, 0xF3U +}; + +const uint16_t sfe_ublox_u16Crc16Table[] = { + 0x0000U, 0x1021U, 0x2042U, 0x3063U, 0x4084U, 0x50A5U, 0x60C6U, 0x70E7U, + 0x8108U, 0x9129U, 0xA14AU, 0xB16BU, 0xC18CU, 0xD1ADU, 0xE1CEU, 0xF1EFU, + 0x1231U, 0x0210U, 0x3273U, 0x2252U, 0x52B5U, 0x4294U, 0x72F7U, 0x62D6U, + 0x9339U, 0x8318U, 0xB37BU, 0xA35AU, 0xD3BDU, 0xC39CU, 0xF3FFU, 0xE3DEU, + 0x2462U, 0x3443U, 0x0420U, 0x1401U, 0x64E6U, 0x74C7U, 0x44A4U, 0x5485U, + 0xA56AU, 0xB54BU, 0x8528U, 0x9509U, 0xE5EEU, 0xF5CFU, 0xC5ACU, 0xD58DU, + 0x3653U, 0x2672U, 0x1611U, 0x0630U, 0x76D7U, 0x66F6U, 0x5695U, 0x46B4U, + 0xB75BU, 0xA77AU, 0x9719U, 0x8738U, 0xF7DFU, 0xE7FEU, 0xD79DU, 0xC7BCU, + 0x48C4U, 0x58E5U, 0x6886U, 0x78A7U, 0x0840U, 0x1861U, 0x2802U, 0x3823U, + 0xC9CCU, 0xD9EDU, 0xE98EU, 0xF9AFU, 0x8948U, 0x9969U, 0xA90AU, 0xB92BU, + 0x5AF5U, 0x4AD4U, 0x7AB7U, 0x6A96U, 0x1A71U, 0x0A50U, 0x3A33U, 0x2A12U, + 0xDBFDU, 0xCBDCU, 0xFBBFU, 0xEB9EU, 0x9B79U, 0x8B58U, 0xBB3BU, 0xAB1AU, + 0x6CA6U, 0x7C87U, 0x4CE4U, 0x5CC5U, 0x2C22U, 0x3C03U, 0x0C60U, 0x1C41U, + 0xEDAEU, 0xFD8FU, 0xCDECU, 0xDDCDU, 0xAD2AU, 0xBD0BU, 0x8D68U, 0x9D49U, + 0x7E97U, 0x6EB6U, 0x5ED5U, 0x4EF4U, 0x3E13U, 0x2E32U, 0x1E51U, 0x0E70U, + 0xFF9FU, 0xEFBEU, 0xDFDDU, 0xCFFCU, 0xBF1BU, 0xAF3AU, 0x9F59U, 0x8F78U, + 0x9188U, 0x81A9U, 0xB1CAU, 0xA1EBU, 0xD10CU, 0xC12DU, 0xF14EU, 0xE16FU, + 0x1080U, 0x00A1U, 0x30C2U, 0x20E3U, 0x5004U, 0x4025U, 0x7046U, 0x6067U, + 0x83B9U, 0x9398U, 0xA3FBU, 0xB3DAU, 0xC33DU, 0xD31CU, 0xE37FU, 0xF35EU, + 0x02B1U, 0x1290U, 0x22F3U, 0x32D2U, 0x4235U, 0x5214U, 0x6277U, 0x7256U, + 0xB5EAU, 0xA5CBU, 0x95A8U, 0x8589U, 0xF56EU, 0xE54FU, 0xD52CU, 0xC50DU, + 0x34E2U, 0x24C3U, 0x14A0U, 0x0481U, 0x7466U, 0x6447U, 0x5424U, 0x4405U, + 0xA7DBU, 0xB7FAU, 0x8799U, 0x97B8U, 0xE75FU, 0xF77EU, 0xC71DU, 0xD73CU, + 0x26D3U, 0x36F2U, 0x0691U, 0x16B0U, 0x6657U, 0x7676U, 0x4615U, 0x5634U, + 0xD94CU, 0xC96DU, 0xF90EU, 0xE92FU, 0x99C8U, 0x89E9U, 0xB98AU, 0xA9ABU, + 0x5844U, 0x4865U, 0x7806U, 0x6827U, 0x18C0U, 0x08E1U, 0x3882U, 0x28A3U, + 0xCB7DU, 0xDB5CU, 0xEB3FU, 0xFB1EU, 0x8BF9U, 0x9BD8U, 0xABBBU, 0xBB9AU, + 0x4A75U, 0x5A54U, 0x6A37U, 0x7A16U, 0x0AF1U, 0x1AD0U, 0x2AB3U, 0x3A92U, + 0xFD2EU, 0xED0FU, 0xDD6CU, 0xCD4DU, 0xBDAAU, 0xAD8BU, 0x9DE8U, 0x8DC9U, + 0x7C26U, 0x6C07U, 0x5C64U, 0x4C45U, 0x3CA2U, 0x2C83U, 0x1CE0U, 0x0CC1U, + 0xEF1FU, 0xFF3EU, 0xCF5DU, 0xDF7CU, 0xAF9BU, 0xBFBAU, 0x8FD9U, 0x9FF8U, + 0x6E17U, 0x7E36U, 0x4E55U, 0x5E74U, 0x2E93U, 0x3EB2U, 0x0ED1U, 0x1EF0U +}; + +const uint32_t sfe_ublox_u32Crc24Table[] = { + 0x00000000U, 0x00864CFBU, 0x008AD50DU, 0x000C99F6U, 0x0093E6E1U, 0x0015AA1AU, 0x001933ECU, 0x009F7F17U, + 0x00A18139U, 0x0027CDC2U, 0x002B5434U, 0x00AD18CFU, 0x003267D8U, 0x00B42B23U, 0x00B8B2D5U, 0x003EFE2EU, + 0x00C54E89U, 0x00430272U, 0x004F9B84U, 0x00C9D77FU, 0x0056A868U, 0x00D0E493U, 0x00DC7D65U, 0x005A319EU, + 0x0064CFB0U, 0x00E2834BU, 0x00EE1ABDU, 0x00685646U, 0x00F72951U, 0x007165AAU, 0x007DFC5CU, 0x00FBB0A7U, + 0x000CD1E9U, 0x008A9D12U, 0x008604E4U, 0x0000481FU, 0x009F3708U, 0x00197BF3U, 0x0015E205U, 0x0093AEFEU, + 0x00AD50D0U, 0x002B1C2BU, 0x002785DDU, 0x00A1C926U, 0x003EB631U, 0x00B8FACAU, 0x00B4633CU, 0x00322FC7U, + 0x00C99F60U, 0x004FD39BU, 0x00434A6DU, 0x00C50696U, 0x005A7981U, 0x00DC357AU, 0x00D0AC8CU, 0x0056E077U, + 0x00681E59U, 0x00EE52A2U, 0x00E2CB54U, 0x006487AFU, 0x00FBF8B8U, 0x007DB443U, 0x00712DB5U, 0x00F7614EU, + 0x0019A3D2U, 0x009FEF29U, 0x009376DFU, 0x00153A24U, 0x008A4533U, 0x000C09C8U, 0x0000903EU, 0x0086DCC5U, + 0x00B822EBU, 0x003E6E10U, 0x0032F7E6U, 0x00B4BB1DU, 0x002BC40AU, 0x00AD88F1U, 0x00A11107U, 0x00275DFCU, + 0x00DCED5BU, 0x005AA1A0U, 0x00563856U, 0x00D074ADU, 0x004F0BBAU, 0x00C94741U, 0x00C5DEB7U, 0x0043924CU, + 0x007D6C62U, 0x00FB2099U, 0x00F7B96FU, 0x0071F594U, 0x00EE8A83U, 0x0068C678U, 0x00645F8EU, 0x00E21375U, + 0x0015723BU, 0x00933EC0U, 0x009FA736U, 0x0019EBCDU, 0x008694DAU, 0x0000D821U, 0x000C41D7U, 0x008A0D2CU, + 0x00B4F302U, 0x0032BFF9U, 0x003E260FU, 0x00B86AF4U, 0x002715E3U, 0x00A15918U, 0x00ADC0EEU, 0x002B8C15U, + 0x00D03CB2U, 0x00567049U, 0x005AE9BFU, 0x00DCA544U, 0x0043DA53U, 0x00C596A8U, 0x00C90F5EU, 0x004F43A5U, + 0x0071BD8BU, 0x00F7F170U, 0x00FB6886U, 0x007D247DU, 0x00E25B6AU, 0x00641791U, 0x00688E67U, 0x00EEC29CU, + 0x003347A4U, 0x00B50B5FU, 0x00B992A9U, 0x003FDE52U, 0x00A0A145U, 0x0026EDBEU, 0x002A7448U, 0x00AC38B3U, + 0x0092C69DU, 0x00148A66U, 0x00181390U, 0x009E5F6BU, 0x0001207CU, 0x00876C87U, 0x008BF571U, 0x000DB98AU, + 0x00F6092DU, 0x007045D6U, 0x007CDC20U, 0x00FA90DBU, 0x0065EFCCU, 0x00E3A337U, 0x00EF3AC1U, 0x0069763AU, + 0x00578814U, 0x00D1C4EFU, 0x00DD5D19U, 0x005B11E2U, 0x00C46EF5U, 0x0042220EU, 0x004EBBF8U, 0x00C8F703U, + 0x003F964DU, 0x00B9DAB6U, 0x00B54340U, 0x00330FBBU, 0x00AC70ACU, 0x002A3C57U, 0x0026A5A1U, 0x00A0E95AU, + 0x009E1774U, 0x00185B8FU, 0x0014C279U, 0x00928E82U, 0x000DF195U, 0x008BBD6EU, 0x00872498U, 0x00016863U, + 0x00FAD8C4U, 0x007C943FU, 0x00700DC9U, 0x00F64132U, 0x00693E25U, 0x00EF72DEU, 0x00E3EB28U, 0x0065A7D3U, + 0x005B59FDU, 0x00DD1506U, 0x00D18CF0U, 0x0057C00BU, 0x00C8BF1CU, 0x004EF3E7U, 0x00426A11U, 0x00C426EAU, + 0x002AE476U, 0x00ACA88DU, 0x00A0317BU, 0x00267D80U, 0x00B90297U, 0x003F4E6CU, 0x0033D79AU, 0x00B59B61U, + 0x008B654FU, 0x000D29B4U, 0x0001B042U, 0x0087FCB9U, 0x001883AEU, 0x009ECF55U, 0x009256A3U, 0x00141A58U, + 0x00EFAAFFU, 0x0069E604U, 0x00657FF2U, 0x00E33309U, 0x007C4C1EU, 0x00FA00E5U, 0x00F69913U, 0x0070D5E8U, + 0x004E2BC6U, 0x00C8673DU, 0x00C4FECBU, 0x0042B230U, 0x00DDCD27U, 0x005B81DCU, 0x0057182AU, 0x00D154D1U, + 0x0026359FU, 0x00A07964U, 0x00ACE092U, 0x002AAC69U, 0x00B5D37EU, 0x00339F85U, 0x003F0673U, 0x00B94A88U, + 0x0087B4A6U, 0x0001F85DU, 0x000D61ABU, 0x008B2D50U, 0x00145247U, 0x00921EBCU, 0x009E874AU, 0x0018CBB1U, + 0x00E37B16U, 0x006537EDU, 0x0069AE1BU, 0x00EFE2E0U, 0x00709DF7U, 0x00F6D10CU, 0x00FA48FAU, 0x007C0401U, + 0x0042FA2FU, 0x00C4B6D4U, 0x00C82F22U, 0x004E63D9U, 0x00D11CCEU, 0x00575035U, 0x005BC9C3U, 0x00DD8538U +}; + +const uint32_t sfe_ublox_u32Crc32Table[] = { + 0x00000000U, 0x04C11DB7U, 0x09823B6EU, 0x0D4326D9U, 0x130476DCU, 0x17C56B6BU, 0x1A864DB2U, 0x1E475005U, + 0x2608EDB8U, 0x22C9F00FU, 0x2F8AD6D6U, 0x2B4BCB61U, 0x350C9B64U, 0x31CD86D3U, 0x3C8EA00AU, 0x384FBDBDU, + 0x4C11DB70U, 0x48D0C6C7U, 0x4593E01EU, 0x4152FDA9U, 0x5F15ADACU, 0x5BD4B01BU, 0x569796C2U, 0x52568B75U, + 0x6A1936C8U, 0x6ED82B7FU, 0x639B0DA6U, 0x675A1011U, 0x791D4014U, 0x7DDC5DA3U, 0x709F7B7AU, 0x745E66CDU, + 0x9823B6E0U, 0x9CE2AB57U, 0x91A18D8EU, 0x95609039U, 0x8B27C03CU, 0x8FE6DD8BU, 0x82A5FB52U, 0x8664E6E5U, + 0xBE2B5B58U, 0xBAEA46EFU, 0xB7A96036U, 0xB3687D81U, 0xAD2F2D84U, 0xA9EE3033U, 0xA4AD16EAU, 0xA06C0B5DU, + 0xD4326D90U, 0xD0F37027U, 0xDDB056FEU, 0xD9714B49U, 0xC7361B4CU, 0xC3F706FBU, 0xCEB42022U, 0xCA753D95U, + 0xF23A8028U, 0xF6FB9D9FU, 0xFBB8BB46U, 0xFF79A6F1U, 0xE13EF6F4U, 0xE5FFEB43U, 0xE8BCCD9AU, 0xEC7DD02DU, + 0x34867077U, 0x30476DC0U, 0x3D044B19U, 0x39C556AEU, 0x278206ABU, 0x23431B1CU, 0x2E003DC5U, 0x2AC12072U, + 0x128E9DCFU, 0x164F8078U, 0x1B0CA6A1U, 0x1FCDBB16U, 0x018AEB13U, 0x054BF6A4U, 0x0808D07DU, 0x0CC9CDCAU, + 0x7897AB07U, 0x7C56B6B0U, 0x71159069U, 0x75D48DDEU, 0x6B93DDDBU, 0x6F52C06CU, 0x6211E6B5U, 0x66D0FB02U, + 0x5E9F46BFU, 0x5A5E5B08U, 0x571D7DD1U, 0x53DC6066U, 0x4D9B3063U, 0x495A2DD4U, 0x44190B0DU, 0x40D816BAU, + 0xACA5C697U, 0xA864DB20U, 0xA527FDF9U, 0xA1E6E04EU, 0xBFA1B04BU, 0xBB60ADFCU, 0xB6238B25U, 0xB2E29692U, + 0x8AAD2B2FU, 0x8E6C3698U, 0x832F1041U, 0x87EE0DF6U, 0x99A95DF3U, 0x9D684044U, 0x902B669DU, 0x94EA7B2AU, + 0xE0B41DE7U, 0xE4750050U, 0xE9362689U, 0xEDF73B3EU, 0xF3B06B3BU, 0xF771768CU, 0xFA325055U, 0xFEF34DE2U, + 0xC6BCF05FU, 0xC27DEDE8U, 0xCF3ECB31U, 0xCBFFD686U, 0xD5B88683U, 0xD1799B34U, 0xDC3ABDEDU, 0xD8FBA05AU, + 0x690CE0EEU, 0x6DCDFD59U, 0x608EDB80U, 0x644FC637U, 0x7A089632U, 0x7EC98B85U, 0x738AAD5CU, 0x774BB0EBU, + 0x4F040D56U, 0x4BC510E1U, 0x46863638U, 0x42472B8FU, 0x5C007B8AU, 0x58C1663DU, 0x558240E4U, 0x51435D53U, + 0x251D3B9EU, 0x21DC2629U, 0x2C9F00F0U, 0x285E1D47U, 0x36194D42U, 0x32D850F5U, 0x3F9B762CU, 0x3B5A6B9BU, + 0x0315D626U, 0x07D4CB91U, 0x0A97ED48U, 0x0E56F0FFU, 0x1011A0FAU, 0x14D0BD4DU, 0x19939B94U, 0x1D528623U, + 0xF12F560EU, 0xF5EE4BB9U, 0xF8AD6D60U, 0xFC6C70D7U, 0xE22B20D2U, 0xE6EA3D65U, 0xEBA91BBCU, 0xEF68060BU, + 0xD727BBB6U, 0xD3E6A601U, 0xDEA580D8U, 0xDA649D6FU, 0xC423CD6AU, 0xC0E2D0DDU, 0xCDA1F604U, 0xC960EBB3U, + 0xBD3E8D7EU, 0xB9FF90C9U, 0xB4BCB610U, 0xB07DABA7U, 0xAE3AFBA2U, 0xAAFBE615U, 0xA7B8C0CCU, 0xA379DD7BU, + 0x9B3660C6U, 0x9FF77D71U, 0x92B45BA8U, 0x9675461FU, 0x8832161AU, 0x8CF30BADU, 0x81B02D74U, 0x857130C3U, + 0x5D8A9099U, 0x594B8D2EU, 0x5408ABF7U, 0x50C9B640U, 0x4E8EE645U, 0x4A4FFBF2U, 0x470CDD2BU, 0x43CDC09CU, + 0x7B827D21U, 0x7F436096U, 0x7200464FU, 0x76C15BF8U, 0x68860BFDU, 0x6C47164AU, 0x61043093U, 0x65C52D24U, + 0x119B4BE9U, 0x155A565EU, 0x18197087U, 0x1CD86D30U, 0x029F3D35U, 0x065E2082U, 0x0B1D065BU, 0x0FDC1BECU, + 0x3793A651U, 0x3352BBE6U, 0x3E119D3FU, 0x3AD08088U, 0x2497D08DU, 0x2056CD3AU, 0x2D15EBE3U, 0x29D4F654U, + 0xC5A92679U, 0xC1683BCEU, 0xCC2B1D17U, 0xC8EA00A0U, 0xD6AD50A5U, 0xD26C4D12U, 0xDF2F6BCBU, 0xDBEE767CU, + 0xE3A1CBC1U, 0xE760D676U, 0xEA23F0AFU, 0xEEE2ED18U, 0xF0A5BD1DU, 0xF464A0AAU, 0xF9278673U, 0xFDE69BC4U, + 0x89B8FD09U, 0x8D79E0BEU, 0x803AC667U, 0x84FBDBD0U, 0x9ABC8BD5U, 0x9E7D9662U, 0x933EB0BBU, 0x97FFAD0CU, + 0xAFB010B1U, 0xAB710D06U, 0xA6322BDFU, 0xA2F33668U, 0xBCB4666DU, 0xB8757BDAU, 0xB5365D03U, 0xB1F740B4U +}; + diff --git a/src/u-blox_structs.h b/src/u-blox_structs.h index 7b90c5d..0a7264f 100644 --- a/src/u-blox_structs.h +++ b/src/u-blox_structs.h @@ -431,7 +431,7 @@ typedef struct uint8_t all; struct { - uint8_t invalidLlh : 1; // 1 = Invalid lon, lat, height and hMSL + uint8_t invalidLlh : 1; // 1 = Invalid lon, lat, height and hMSL uint8_t lastCorrectionAge : 4; // Age of the most recently received differential correction: // 0: Not available // 1: Age between 0 and 1 second @@ -1426,9 +1426,11 @@ typedef struct // RXM-specific structs // UBX-RXM-SFRBX (0x02 0x13): Broadcast navigation data subframe +// Note: SFRBX is output-only. Polling is not possible // Note: length is variable // Note: on protocol version 17: numWords is (0..16) // on protocol version 18+: numWords is (0..10) +#define UBX_RXM_SFRBX_CALLBACK_BUFFERS 14 // 14 data buffers, 14 message buffers, 3 flags, in uint32_t const uint8_t UBX_RXM_SFRBX_MAX_WORDS = 16; const uint16_t UBX_RXM_SFRBX_MAX_LEN = 8 + (4 * UBX_RXM_SFRBX_MAX_WORDS); @@ -1445,13 +1447,46 @@ typedef struct uint32_t dwrd[UBX_RXM_SFRBX_MAX_WORDS]; // The data words } UBX_RXM_SFRBX_data_t; +// Define a struct to hold the entire SFRBX message so the whole thing can be pushed to the PointPerfect Library +// Remember that the length of the payload will be variable. typedef struct { - ubxAutomaticFlags automaticFlags; + uint8_t sync1; // 0xB5 + uint8_t sync2; // 0x62 + uint8_t cls; + uint8_t ID; + uint8_t lengthLSB; + uint8_t lengthMSB; + uint8_t payload[UBX_RXM_SFRBX_MAX_LEN]; + uint8_t checksumA; + uint8_t checksumB; +} UBX_RXM_SFRBX_message_data_t; + +struct ubxSFRBXAutomaticFlags +{ + union + { + uint32_t all; + struct + { + uint32_t automatic : 1; // Will this message be delivered and parsed "automatically" (without polling) + uint32_t implicitUpdate : 1; // Is the update triggered by accessing stale data (=true) or by a call to checkUblox (=false) + uint32_t addToFileBuffer : 1; // Should the raw UBX data be added to the file buffer? + uint32_t callbackCopyValid : UBX_RXM_SFRBX_CALLBACK_BUFFERS; // Are the copies of the data struct used by the callback valid/fresh? + uint32_t callbackMessageCopyValid : UBX_RXM_SFRBX_CALLBACK_BUFFERS; // Are the copies of the data structs used by the callback valid/fresh? + } bits; + } flags; +}; + +typedef struct +{ + ubxSFRBXAutomaticFlags automaticFlags; UBX_RXM_SFRBX_data_t data; bool moduleQueried; void (*callbackPointerPtr)(UBX_RXM_SFRBX_data_t *); - UBX_RXM_SFRBX_data_t *callbackData; + UBX_RXM_SFRBX_data_t *callbackData; // This is an array of buffers + void (*callbackMessagePointerPtr)(UBX_RXM_SFRBX_message_data_t *); + UBX_RXM_SFRBX_message_data_t *callbackMessageData; // This is an array of buffers } UBX_RXM_SFRBX_t; // UBX-RXM-MEASX (0x02 0x14): Receiver Manager Messages: i.e. Satellite Status, RTC Status. @@ -1798,7 +1833,7 @@ typedef struct uint8_t reserved2[2]; // Reserved uint32_t pinIrq; // Mask of pins value using the PIO Irq uint32_t pullH; // Mask of pins value using the PIO pull high resistor - uint32_t pullL; // Mask of pins value using the PIO pull low resistor + uint32_t pullL; // Mask of pins value using the PIO pull low resistor } UBX_MON_HW_data_t; typedef struct @@ -2202,6 +2237,7 @@ typedef struct // UBX-ESF-MEAS (0x10 0x02): External sensor fusion measurements // Note: length is variable // Note: ESF RAW data cannot be polled. It is "Output" only +#define UBX_ESF_MEAS_CALLBACK_BUFFERS 6 const uint16_t UBX_ESF_MEAS_MAX_LEN = 8 + (4 * DEF_MAX_NUM_ESF_MEAS) + 4; typedef struct @@ -2238,12 +2274,27 @@ typedef struct uint32_t calibTtag; // OPTIONAL: Receiver local time calibrated: ms } UBX_ESF_MEAS_data_t; +struct ubxESFMEASAutomaticFlags +{ + union + { + uint16_t all; + struct + { + uint16_t automatic : 1; // Will this message be delivered and parsed "automatically" (without polling) + uint16_t implicitUpdate : 1; // Is the update triggered by accessing stale data (=true) or by a call to checkUblox (=false) + uint16_t addToFileBuffer : 1; // Should the raw UBX data be added to the file buffer? + uint16_t callbackCopyValid : UBX_ESF_MEAS_CALLBACK_BUFFERS; // Are the copies of the data struct used by the callback valid/fresh? + } bits; + } flags; +}; + typedef struct { - ubxAutomaticFlags automaticFlags; + ubxESFMEASAutomaticFlags automaticFlags; UBX_ESF_MEAS_data_t data; void (*callbackPointerPtr)(UBX_ESF_MEAS_data_t *); - UBX_ESF_MEAS_data_t *callbackData; + UBX_ESF_MEAS_data_t *callbackData; // This is an array of buffers } UBX_ESF_MEAS_t; // UBX-ESF-RAW (0x10 0x03): Raw sensor measurements @@ -2793,8 +2844,8 @@ struct rtcmAutomaticFlags uint8_t all; struct { - uint8_t dataValid : 1; // Is the copy of the data used by the get function valid/fresh? 0 = invalid, 1 = valid - uint8_t dataRead : 1; // Has the data been read? 0 = unread, 1 = read + uint8_t dataValid : 1; // Is the copy of the data used by the get function valid/fresh? 0 = invalid, 1 = valid + uint8_t dataRead : 1; // Has the data been read? 0 = unread, 1 = read uint8_t callbackDataValid : 1; // Is the copy of the data used by the callback valid/fresh? 0 = invalid/stale, 1 = valid/fresh } bits; } flags; @@ -2815,19 +2866,19 @@ const uint16_t RTCM_1005_MSG_LEN_BYTES = 19; typedef struct { - uint16_t MessageNumber; // Message Number (“1005” = 0x3ED) - uint16_t ReferenceStationID; // Reference Station ID - uint8_t ITRFRealizationYear; // ITRF Realization Year - bool GPSIndicator; // GPS Indicator - bool GLONASSIndicator; // GLONASS Indicator - bool GalileoIndicator; // Galileo Indicator - bool ReferenceStationIndicator; // Reference-Station Indicator - int64_t AntennaReferencePointECEFX; // Antenna Reference Point ECEF-X (0.0001m) + uint16_t MessageNumber; // Message Number (“1005” = 0x3ED) + uint16_t ReferenceStationID; // Reference Station ID + uint8_t ITRFRealizationYear; // ITRF Realization Year + bool GPSIndicator; // GPS Indicator + bool GLONASSIndicator; // GLONASS Indicator + bool GalileoIndicator; // Galileo Indicator + bool ReferenceStationIndicator; // Reference-Station Indicator + int64_t AntennaReferencePointECEFX; // Antenna Reference Point ECEF-X (0.0001m) bool SingleReceiverOscillatorIndicator; // Single Receiver Oscillator Indicator - bool Reserved; // Reserved - int64_t AntennaReferencePointECEFY; // Antenna Reference Point ECEF-Y (0.0001m) - uint8_t QuarterCycleIndicator; // Quarter Cycle Indicator - int64_t AntennaReferencePointECEFZ; // Antenna Reference Point ECEF-Z (0.0001m) + bool Reserved; // Reserved + int64_t AntennaReferencePointECEFY; // Antenna Reference Point ECEF-Y (0.0001m) + uint8_t QuarterCycleIndicator; // Quarter Cycle Indicator + int64_t AntennaReferencePointECEFZ; // Antenna Reference Point ECEF-Z (0.0001m) } RTCM_1005_data_t; typedef struct @@ -2844,18 +2895,18 @@ const uint16_t RTCM_1006_MSG_LEN_BYTES = 21; typedef struct { - uint16_t MessageNumber; // Message Number (“1006” = 0x3EE) - uint16_t ReferenceStationID; // Reference Station ID - uint8_t ITRFRealizationYear; // ITRF Realization Year - bool GPSIndicator; // GPS Indicator - bool GLONASSIndicator; // GLONASS Indicator - bool GalileoIndicator; // Galileo Indicator - bool ReferenceStationIndicator; // Reference-Station Indicator - int64_t AntennaReferencePointECEFX; // Antenna Reference Point ECEF-X (0.0001m) + uint16_t MessageNumber; // Message Number (“1006” = 0x3EE) + uint16_t ReferenceStationID; // Reference Station ID + uint8_t ITRFRealizationYear; // ITRF Realization Year + bool GPSIndicator; // GPS Indicator + bool GLONASSIndicator; // GLONASS Indicator + bool GalileoIndicator; // Galileo Indicator + bool ReferenceStationIndicator; // Reference-Station Indicator + int64_t AntennaReferencePointECEFX; // Antenna Reference Point ECEF-X (0.0001m) bool SingleReceiverOscillatorIndicator; // Single Receiver Oscillator Indicator - bool Reserved; // Reserved - int64_t AntennaReferencePointECEFY; // Antenna Reference Point ECEF-Y (0.0001m) - uint8_t QuarterCycleIndicator; // Quarter Cycle Indicator - int64_t AntennaReferencePointECEFZ; // Antenna Reference Point ECEF-Z (0.0001m) - uint16_t AntennaHeight; // Antenna Height above the marker used in the survey campaign (0.0001m) + bool Reserved; // Reserved + int64_t AntennaReferencePointECEFY; // Antenna Reference Point ECEF-Y (0.0001m) + uint8_t QuarterCycleIndicator; // Quarter Cycle Indicator + int64_t AntennaReferencePointECEFZ; // Antenna Reference Point ECEF-Z (0.0001m) + uint16_t AntennaHeight; // Antenna Height above the marker used in the survey campaign (0.0001m) } RTCM_1006_data_t;