diff --git a/.github/workflows/compile-sketch.yml b/.github/workflows/compile-sketch.yml index dea85789..14f86dee 100644 --- a/.github/workflows/compile-sketch.yml +++ b/.github/workflows/compile-sketch.yml @@ -2,8 +2,8 @@ name: Compile Sketch on: # - push - - pull_request - + pull_request: + workflow_dispatch: jobs: compile-sketch: @@ -100,6 +100,7 @@ jobs: - source-path: ./ sketch-paths: | - examples/Example20_SendCustomCommand + # - examples/NEO-M8P-2/Example2_StartRTCMBase_virtual/Example2_StartRTCMBase_virtual enable-warnings-report: true enable-deltas-report: true # verbose: true diff --git a/examples/NEO-M8P-2/Example2_StartRTCMBase_virtual/Example2_StartRTCMBase_virtual.ino b/examples/NEO-M8P-2/Example2_StartRTCMBase_virtual/Example2_StartRTCMBase_virtual.ino new file mode 100644 index 00000000..af122b1a --- /dev/null +++ b/examples/NEO-M8P-2/Example2_StartRTCMBase_virtual/Example2_StartRTCMBase_virtual.ino @@ -0,0 +1,168 @@ +/* + Note: compiles OK with v2.0 but is currently untested + + Send UBX binary commands to enable RTCM sentences on u-blox NEO-M8P-2 module + By: Nathan Seidle + SparkFun Electronics + Date: September 7th, 2018 + License: MIT. See license file for more information but you can + basically do whatever you want with this code. + + This example does all steps to configure and enable a NEO-M8P-2 as a base station: + Begin Survey-In + Once we've achieved 2m accuracy and 300s have passed, survey is complete + Enable four RTCM messages + Begin outputting RTCM bytes + + Feel like supporting open source hardware? + Buy a board from SparkFun! + ZED-F9P RTK2: https://www.sparkfun.com/products/15136 + NEO-M8P RTK: https://www.sparkfun.com/products/15005 + SAM-M8Q: https://www.sparkfun.com/products/15106 + + Hardware Connections: + Plug a Qwiic cable into the GNSS 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 GNSS + +#include //http://librarymanager/All#SparkFun_u-blox_GNSS + +class MY_SFE_UBLOX_GNSS : public SFE_UBLOX_GNSS +{ + //This function gets called from the SparkFun u-blox Arduino Library. + //As each RTCM byte comes in you can specify what to do with it + //Useful for passing the RTCM correction data to a radio, Ntrip broadcaster, etc. + virtual void processRTCM_v(uint8_t incoming) + { + //Let's just pretty-print the HEX values for now + if (rtcmFrameCounter % 16 == 0) Serial.println(); + Serial.print(F(" ")); + if (incoming < 0x10) Serial.print(F("0")); + Serial.print(incoming, HEX); + } +}; + +MY_SFE_UBLOX_GNSS myGNSS; + +void setup() +{ + Serial.begin(115200); + while (!Serial); //Wait for user to open terminal + Serial.println(F("u-blox NEO-M8P-2 base station example")); + + Wire.begin(); + Wire.setClock(400000); //Increase I2C clock speed to 400kHz + + 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 | COM_TYPE_NMEA | COM_TYPE_RTCM3); // Ensure RTCM3 is enabled + myGNSS.saveConfiguration(); //Save the current settings to flash and BBR + + while (Serial.available()) Serial.read(); //Clear any latent chars in serial buffer + Serial.println(F("Press any key to send commands to begin Survey-In")); + while (Serial.available() == 0) ; //Wait for user to press a key + + bool response; + + //Check if Survey is in Progress before initiating one + // From v2.0, the data from getSurveyStatus (UBX-NAV-SVIN) is returned in UBX_NAV_SVIN_t packetUBXNAVSVIN + // Please see u-blox_structs.h for the full definition of UBX_NAV_SVIN_t + // You can either read the data from packetUBXNAVSVIN directly + // or can use the helper functions: getSurveyInActive; getSurveyInValid; getSurveyInObservationTime; and getSurveyInMeanAccuracy + response = myGNSS.getSurveyStatus(2000); //Query module for SVIN status with 2000ms timeout (request can take a long time) + + if (response == false) // Check if fresh data was received + { + Serial.println(F("Failed to get Survey In status. Freezing...")); + while (1); //Freeze + } + + if (myGNSS.getSurveyInActive() == true) // Use the helper function + { + Serial.print(F("Survey already in progress.")); + } + else + { + //Start survey + response = myGNSS.enableSurveyMode(300, 2.000); //Enable Survey in, 300 seconds, 2.0m + if (response == false) + { + Serial.println(F("Survey start failed. Freezing...")); + while (1); + } + Serial.println(F("Survey started. This will run until 300s has passed and less than 2m accuracy is achieved.")); + } + + while(Serial.available()) Serial.read(); //Clear buffer + + //Begin waiting for survey to complete + while (myGNSS.getSurveyInValid() == false) // Call the helper function + { + if(Serial.available()) + { + byte incoming = Serial.read(); + if(incoming == 'x') + { + //Stop survey mode + response = myGNSS.disableSurveyMode(); //Disable survey + Serial.println(F("Survey stopped")); + break; + } + } + + // From v2.0, the data from getSurveyStatus (UBX-NAV-SVIN) is returned in UBX_NAV_SVIN_t packetUBXNAVSVIN + // Please see u-blox_structs.h for the full definition of UBX_NAV_SVIN_t + // You can either read the data from packetUBXNAVSVIN directly + // or can use the helper functions: getSurveyInActive; getSurveyInValid; getSurveyInObservationTime; and getSurveyInMeanAccuracy + response = myGNSS.getSurveyStatus(2000); //Query module for SVIN status with 2000ms timeout (req can take a long time) + if (response == true) // Check if fresh data was received + { + Serial.print(F("Press x to end survey - ")); + Serial.print(F("Time elapsed: ")); + Serial.print((String)myGNSS.getSurveyInObservationTime()); + + Serial.print(F(" Accuracy: ")); + Serial.print((String)myGNSS.getSurveyInMeanAccuracy()); + Serial.println(); + } + else + { + Serial.println(F("SVIN request failed")); + } + + delay(1000); + } + Serial.println(F("Survey valid!")); + + response = true; + response &= myGNSS.enableRTCMmessage(UBX_RTCM_1005, COM_PORT_I2C, 1); //Enable message 1005 to output through I2C port, message every second + response &= myGNSS.enableRTCMmessage(UBX_RTCM_1077, COM_PORT_I2C, 1); + response &= myGNSS.enableRTCMmessage(UBX_RTCM_1087, COM_PORT_I2C, 1); + response &= myGNSS.enableRTCMmessage(UBX_RTCM_1230, COM_PORT_I2C, 10); //Enable message every 10 seconds + + if (response == true) + { + Serial.println(F("RTCM messages enabled")); + } + else + { + Serial.println(F("RTCM failed to enable. Are you sure you have an NEO-M8P?")); + while (1); //Freeze + } + + Serial.println(F("Base survey complete! RTCM now broadcasting.")); +} + +void loop() +{ + myGNSS.checkUblox(); //See if new data is available. Process bytes as they come in. + + delay(250); //Don't pound too hard on the I2C bus +} diff --git a/keywords.txt b/keywords.txt index 6f1b29ec..6ff142fa 100644 --- a/keywords.txt +++ b/keywords.txt @@ -107,8 +107,11 @@ checkUbloxSPI KEYWORD2 process KEYWORD2 processNMEA KEYWORD2 +processNMEA_v KEYWORD2 processRTCMframe KEYWORD2 +processRTCMframe_v KEYWORD2 processRTCM KEYWORD2 +processRTCM_v KEYWORD2 processUBX KEYWORD2 processUBXpacket KEYWORD2 @@ -563,6 +566,7 @@ getConfirmedDate KEYWORD2 getConfirmedTime KEYWORD2 getFixType KEYWORD2 getGnssFixOk KEYWORD2 +getNAVPVTPSMMode KEYWORD2 getDiffSoln KEYWORD2 getHeadVehValid KEYWORD2 getCarrierSolutionType KEYWORD2 @@ -677,6 +681,9 @@ getLatestNMEAGNZDA KEYWORD2 setNMEAGNZDAcallback KEYWORD2 setNMEAGNZDAcallbackPtr KEYWORD2 +setupPowerMode KEYWORD2 +setPowerManagement KEYWORD2 + extractLong KEYWORD2 extractSignedLong KEYWORD2 extractInt KEYWORD2 @@ -889,3 +896,14 @@ SFE_UBLOX_MAIN_TALKER_ID_GQ LITERAL1 SFE_UBLOX_DGNSS_MODE_FLOAT LITERAL1 SFE_UBLOX_DGNSS_MODE_FIXED LITERAL1 + +SFE_UBLOX_PMS_MODE_FULLPOWER LITERAL1 +SFE_UBLOX_PMS_MODE_BALANCED LITERAL1 +SFE_UBLOX_PMS_MODE_INTERVAL LITERAL1 +SFE_UBLOX_PMS_MODE_AGGRESSIVE_1HZ LITERAL1 +SFE_UBLOX_PMS_MODE_AGGRESSIVE_2HZ LITERAL1 +SFE_UBLOX_PMS_MODE_AGGRESSIVE_4HZ LITERAL1 +SFE_UBLOX_PMS_MODE_INVALID LITERAL1 + +SFE_UBLOX_CFG_RXM_CONTINUOUS LITERAL1 +SFE_UBLOX_CFG_RXM_POWERSAVE LITERAL1 diff --git a/library.properties b/library.properties index 283a3485..5a44632f 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=SparkFun u-blox GNSS Arduino Library -version=2.2.24 +version=2.2.25 author=SparkFun Electronics maintainer=SparkFun Electronics sentence=Library for I2C, Serial and SPI Communication with u-blox GNSS modules

diff --git a/src/SparkFun_u-blox_GNSS_Arduino_Library.cpp b/src/SparkFun_u-blox_GNSS_Arduino_Library.cpp index 460dbceb..6d689564 100644 --- a/src/SparkFun_u-blox_GNSS_Arduino_Library.cpp +++ b/src/SparkFun_u-blox_GNSS_Arduino_Library.cpp @@ -2288,13 +2288,18 @@ bool SFE_UBLOX_GNSS::processThisNMEA() // This is the default or generic NMEA processor. We're only going to pipe the data to serial port so we can see it. // User could overwrite this function to pipe characters to nmea.process(c) of tinyGPS or MicroNMEA // Or user could pipe each character to a buffer, radio, etc. -void SFE_UBLOX_GNSS::processNMEA(char incoming) +void SFE_UBLOX_GNSS::processNMEA_v(char incoming) { // If user has assigned an output port then pipe the characters there if (_nmeaOutputPort != NULL) _nmeaOutputPort->write(incoming); // Echo this byte to the serial port } +void SFE_UBLOX_GNSS::processNMEA(char incoming) +{ + processNMEA_v(incoming); +} + #ifndef SFE_UBLOX_DISABLE_AUTO_NMEA // Check if the NMEA message (in nmeaAddressField) is "auto" (i.e. has RAM allocated for it) bool SFE_UBLOX_GNSS::isThisNMEAauto() @@ -2882,7 +2887,7 @@ nmeaAutomaticFlags *SFE_UBLOX_GNSS::getNMEAFlagsPtr() // Byte 2: 10-bits of length of this packet including the first two-ish header bytes, + 6. // byte 3 + 4 bits: Msg type 12 bits // Example: D3 00 7C 43 F0 ... / 0x7C = 124+6 = 130 bytes in this packet, 0x43F = Msg type 1087 -SFE_UBLOX_GNSS::sfe_ublox_sentence_types_e SFE_UBLOX_GNSS::processRTCMframe(uint8_t incoming, uint16_t *rtcmFrameCounter) +SFE_UBLOX_GNSS::sfe_ublox_sentence_types_e SFE_UBLOX_GNSS::processRTCMframe_v(uint8_t incoming, uint16_t *rtcmFrameCounter) { static uint16_t rtcmLen = 0; @@ -2912,10 +2917,15 @@ SFE_UBLOX_GNSS::sfe_ublox_sentence_types_e SFE_UBLOX_GNSS::processRTCMframe(uint return (*rtcmFrameCounter == rtcmLen) ? SFE_UBLOX_SENTENCE_TYPE_NONE : SFE_UBLOX_SENTENCE_TYPE_RTCM; } +SFE_UBLOX_GNSS::sfe_ublox_sentence_types_e SFE_UBLOX_GNSS::processRTCMframe(uint8_t incoming, uint16_t *rtcmFrameCounter) +{ + return processRTCMframe_v(incoming, rtcmFrameCounter); +} + // This function is called for each byte of an RTCM frame // Ths user can overwrite this function and process the RTCM frame as they please // Bytes can be piped to Serial or other interface. The consumer could be a radio or the internet (Ntrip broadcaster) -void SFE_UBLOX_GNSS::processRTCM(uint8_t incoming) +void SFE_UBLOX_GNSS::processRTCM_v(uint8_t incoming) { // Radio.sendReliable((String)incoming); //An example of passing this byte to a radio @@ -2930,6 +2940,11 @@ void SFE_UBLOX_GNSS::processRTCM(uint8_t incoming) (void)incoming; // Do something with incoming just to get rid of the pesky compiler warning! } +void SFE_UBLOX_GNSS::processRTCM(uint8_t incoming) +{ + processRTCM_v(incoming); +} + // Given a character, file it away into the uxb packet structure // Set valid to VALID or NOT_VALID once sentence is completely received and passes or fails CRC // The payload portion of the packet can be 100s of bytes but the max array size is packetCfgPayloadSize bytes. @@ -7963,28 +7978,7 @@ bool SFE_UBLOX_GNSS::powerSaveMode(bool power_save, uint16_t maxWait) } // Now let's change the power setting using UBX-CFG-RXM - packetCfg.cls = UBX_CLASS_CFG; - packetCfg.id = UBX_CFG_RXM; - packetCfg.len = 0; - packetCfg.startingSpot = 0; - - // Ask module for the current power management settings. Loads into payloadCfg. - if (sendCommand(&packetCfg, maxWait) != SFE_UBLOX_STATUS_DATA_RECEIVED) // We are expecting data and an ACK - return (false); - - if (power_save) - { - payloadCfg[1] = 1; // Power Save Mode - } - else - { - payloadCfg[1] = 0; // Continuous Mode - } - - packetCfg.len = 2; - packetCfg.startingSpot = 0; - - return (sendCommand(&packetCfg, maxWait) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK + return setupPowerMode(power_save ? SFE_UBLOX_CFG_RXM_POWERSAVE : SFE_UBLOX_CFG_RXM_CONTINUOUS, maxWait); } // Get Power Save Mode @@ -8150,6 +8144,51 @@ bool SFE_UBLOX_GNSS::powerOffWithInterrupt(uint32_t durationInMs, uint32_t wakeu } } +bool SFE_UBLOX_GNSS::setPowerManagement(sfe_ublox_pms_mode_e mode, uint16_t period, uint16_t onTime, uint16_t maxWait) +{ + // INVALID only valid in response + if (mode == SFE_UBLOX_PMS_MODE_INVALID) + return false; + packetCfg.cls = UBX_CLASS_CFG; + packetCfg.id = UBX_CFG_PMS; + packetCfg.len = 8; + packetCfg.startingSpot = 0; + + packetCfg.payload[0] = 0x0; //message version + packetCfg.payload[1] = mode; + // only valid if mode==SFE_UBLOX_PMS_MODE_INTERVAL + if (mode == SFE_UBLOX_PMS_MODE_INTERVAL) + { + packetCfg.payload[2] = period >> 8; + packetCfg.payload[3] = period & 0xff; + packetCfg.payload[4] = onTime >> 8; + packetCfg.payload[5] = onTime & 0xff; + } + else + { + packetCfg.payload[2] = 0; + packetCfg.payload[3] = 0; + packetCfg.payload[4] = 0; + packetCfg.payload[5] = 0; + } + packetCfg.payload[6] = 0x0; //reserved + packetCfg.payload[7] = 0x0; //reserved + return sendCommand(&packetCfg, maxWait); +} + +bool SFE_UBLOX_GNSS::setupPowerMode(sfe_ublox_rxm_mode_e mode, uint16_t maxWait) +{ + packetCfg.cls = UBX_CLASS_CFG; + packetCfg.id = UBX_CFG_RXM; + packetCfg.len = 2; + packetCfg.startingSpot = 0; + + packetCfg.payload[0] = 0x0; //reserved + packetCfg.payload[1] = mode; //low power mode + + return sendCommand(&packetCfg, maxWait); +} + // Dynamic Platform Model // Change the dynamic platform model using UBX-CFG-NAV5 @@ -8293,6 +8332,7 @@ bool SFE_UBLOX_GNSS::enableGNSS(bool enable, sfe_ublox_gnss_ids_e id, uint16_t m payloadCfg[(block * 8) + 4 + 4] |= 0x01; // Set the enable bit in flags (Little Endian) else payloadCfg[(block * 8) + 4 + 4] &= 0xFE; // Clear the enable bit in flags (Little Endian) + break; } } @@ -8310,8 +8350,6 @@ bool SFE_UBLOX_GNSS::isGNSSenabled(sfe_ublox_gnss_ids_e id, uint16_t maxWait) if (sendCommand(&packetCfg, maxWait) != SFE_UBLOX_STATUS_DATA_RECEIVED) // We are expecting data and an ACK return (false); - bool retVal = false; - uint8_t numConfigBlocks = payloadCfg[3]; // Extract the numConfigBlocks for (uint8_t block = 0; block < numConfigBlocks; block++) // Check each configuration block @@ -8320,11 +8358,11 @@ bool SFE_UBLOX_GNSS::isGNSSenabled(sfe_ublox_gnss_ids_e id, uint16_t maxWait) { // We have a match so check the enable bit in flags if ((payloadCfg[(block * 8) + 4 + 4] & 0x01) > 0) // Check the enable bit in flags (Little Endian) - retVal = true; + return true; } } - return (retVal); + return false; } // Reset ESF automatic IMU-mount alignment @@ -17369,6 +17407,21 @@ bool SFE_UBLOX_GNSS::getDiffSoln(uint16_t maxWait) return (packetUBXNAVPVT->data.flags.bits.diffSoln); } +// Get power save mode from NAV-PVT +bool SFE_UBLOX_GNSS::getNAVPVTPSMMode(uint16_t maxWait) +{ + if (packetUBXNAVPVT == NULL) + initPacketUBXNAVPVT(); // Check that RAM has been allocated for the PVT data + if (packetUBXNAVPVT == NULL) // Bail if the RAM allocation failed + return 0; + + if (packetUBXNAVPVT->moduleQueried.moduleQueried1.bits.psmState== false) + getPVT(maxWait); + packetUBXNAVPVT->moduleQueried.moduleQueried1.bits.psmState= false; // Since we are about to give this to user, mark this data as stale + packetUBXNAVPVT->moduleQueried.moduleQueried1.bits.all = false; + return (packetUBXNAVPVT->data.flags.bits.psmState); +} + // Get whether head vehicle valid or not bool SFE_UBLOX_GNSS::getHeadVehValid(uint16_t maxWait) { diff --git a/src/SparkFun_u-blox_GNSS_Arduino_Library.h b/src/SparkFun_u-blox_GNSS_Arduino_Library.h index c83f002e..fedd63a4 100644 --- a/src/SparkFun_u-blox_GNSS_Arduino_Library.h +++ b/src/SparkFun_u-blox_GNSS_Arduino_Library.h @@ -581,6 +581,25 @@ enum sfe_ublox_dgnss_mode_e SFE_UBLOX_DGNSS_MODE_FIXED // Ambiguities are fixed whenever possible }; +// Values for UBX-CFG-PMS +enum sfe_ublox_pms_mode_e +{ + SFE_UBLOX_PMS_MODE_FULLPOWER = 0, + SFE_UBLOX_PMS_MODE_BALANCED, + SFE_UBLOX_PMS_MODE_INTERVAL, + SFE_UBLOX_PMS_MODE_AGGRESSIVE_1HZ, + SFE_UBLOX_PMS_MODE_AGGRESSIVE_2HZ, + SFE_UBLOX_PMS_MODE_AGGRESSIVE_4HZ, + SFE_UBLOX_PMS_MODE_INVALID = 0xff +}; + +//Values for UBX-CFG-RXM +enum sfe_ublox_rxm_mode_e +{ + SFE_UBLOX_CFG_RXM_CONTINUOUS = 0, + SFE_UBLOX_CFG_RXM_POWERSAVE = 1 +}; + //-=-=-=-=- #ifndef MAX_PAYLOAD_SIZE @@ -660,7 +679,7 @@ class SFE_UBLOX_GNSS { public: SFE_UBLOX_GNSS(void); - ~SFE_UBLOX_GNSS(void); + virtual ~SFE_UBLOX_GNSS(void); // Depending on the sentence type the processor will load characters into different arrays enum sfe_ublox_sentence_types_e @@ -764,8 +783,11 @@ class SFE_UBLOX_GNSS void process(uint8_t incoming, ubxPacket *incomingUBX, uint8_t requestedClass, uint8_t requestedID); // Processes NMEA and UBX binary sentences one byte at a time void processNMEA(char incoming) __attribute__((weak)); // Given a NMEA character, do something with it. User can overwrite if desired to use something like tinyGPS or MicroNMEA libraries + virtual void processNMEA_v(char incoming); // Given a NMEA character, do something with it. User can overwrite if desired to use something like tinyGPS or MicroNMEA libraries sfe_ublox_sentence_types_e processRTCMframe(uint8_t incoming, uint16_t *rtcmFrameCounter) __attribute__((weak)); // Monitor the incoming bytes for start and length bytes + virtual sfe_ublox_sentence_types_e processRTCMframe_v(uint8_t incoming, uint16_t *rtcmFrameCounter); // Monitor the incoming bytes for start and length bytes void processRTCM(uint8_t incoming) __attribute__((weak)); // Given rtcm byte, do something with it. User can overwrite if desired to pipe bytes to radio, internet, etc. + virtual void processRTCM_v(uint8_t incoming); // Given rtcm byte, do something with it. User can overwrite if desired to pipe bytes to radio, internet, etc. void processUBX(uint8_t incoming, ubxPacket *incomingUBX, uint8_t requestedClass, uint8_t requestedID); // Given a character, file it away into the uxb packet structure void processUBXpacket(ubxPacket *msg); // Once a packet has been received and validated, identify this packet's class/id and update internal flags @@ -920,6 +942,9 @@ class SFE_UBLOX_GNSS uint8_t getPowerSaveMode(uint16_t maxWait = defaultMaxWait); // Returns 255 if the sendCommand fails bool powerOff(uint32_t durationInMs, uint16_t maxWait = defaultMaxWait); bool powerOffWithInterrupt(uint32_t durationInMs, uint32_t wakeupSources = VAL_RXM_PMREQ_WAKEUPSOURCE_EXTINT0, bool forceWhileUsb = true, uint16_t maxWait = defaultMaxWait); + // Power Mode Setup. Values period and onTime are only valid if mode is SFE_UBLOX_PMS_MODE_INTERVAL + bool setPowerManagement(sfe_ublox_pms_mode_e mode, uint16_t period=0, uint16_t onTime=0, uint16_t maxWait = defaultMaxWait); + bool setupPowerMode(sfe_ublox_rxm_mode_e mode, uint16_t maxWait = defaultMaxWait); // Change the dynamic platform model using UBX-CFG-NAV5 bool setDynamicModel(dynModel newDynamicModel = DYN_MODEL_PORTABLE, uint16_t maxWait = defaultMaxWait); @@ -1396,6 +1421,7 @@ class SFE_UBLOX_GNSS uint8_t getFixType(uint16_t maxWait = defaultMaxWait); // Returns the type of fix: 0=no, 3=3D, 4=GNSS+Deadreckoning bool getGnssFixOk(uint16_t maxWait = defaultMaxWait); // Get whether we have a valid fix (i.e within DOP & accuracy masks) + bool getNAVPVTPSMMode(uint16_t maxWait = defaultMaxWait); // Not fully documented power save mode value bool getDiffSoln(uint16_t maxWait = defaultMaxWait); // Get whether differential corrections were applied bool getHeadVehValid(uint16_t maxWait = defaultMaxWait); uint8_t getCarrierSolutionType(uint16_t maxWait = defaultMaxWait); // Returns RTK solution: 0=no, 1=float solution, 2=fixed solution