Add support for serial protocol, plus factory reset command

tve · tve · commit 185b7a6b75ed · 2019-01-28T12:12:45.000-08:00
diff --git a/examples/Example11_UseUart/Example11_UseUart.ino b/examples/Example11_UseUart/Example11_UseUart.ino
@@ -0,0 +1,94 @@
+/*
+  Reading lat and long via UBX binary commands using UART @38400 baud - free from I2C
+  By: Nathan Seidle, Adapted from Example3_GetPosition by Thorsten von Eicken
+  SparkFun Electronics
+  Date: January 28rd, 2019
+  License: MIT. See license file for more information but you can
+  basically do whatever you want with this code.
+
+  This example shows how to configure the library and U-Blox for serial port use as well as
+  switching the module from the default 9600 baud to 38400.
+
+  Note: Long/lat are large numbers because they are * 10^7. To convert lat/long
+  to something google maps understands simply divide the numbers by 10,000,000. We 
+  do this so that we don't have to use floating point numbers.
+
+  Leave NMEA parsing behind. Now you can simply ask the module for the datums you want!
+
+  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:
+  Connect the U-Blox serial port to Serial1
+  Open the serial monitor at 115200 baud to see the output
+*/
+
+#include "SparkFun_Ublox_Arduino_Library.h" //http://librarymanager/All#SparkFun_Ublox_GPS
+SFE_UBLOX_GPS myGPS;
+
+long lastTime = 0; //Simple local timer. Limits amount if I2C traffic to Ublox module.
+
+void setup()
+{
+  Serial.begin(115200);
+  while (!Serial); //Wait for user to open terminal
+  Serial.println("SparkFun Ublox Example");
+
+  //Assume that the U-Blox GPS is running at 9600 baud (the default) or at 38400 baud.
+  //Loop until we're in sync and then ensure it's at 38400 baud.
+  do {
+    Serial.println("GPS: trying 38400 baud");
+    Serial1.begin(38400);
+    if (myGPS.begin(Serial1)) break;
+
+    delay(100);
+    Serial.println("GPS: trying 9600 baud");
+    Serial1.begin(9600);
+    if (myGPS.begin(Serial1)) {
+        Serial.println("GPS: connected at 9600 baud, switching to 38400");
+        myGPS.setSerialRate(38400);
+        delay(100);
+    } else {
+        //gps.factoryReset();
+        delay(2000); //Wait a bit before trying again to limit the Serial output
+    }
+  } while(1);
+  Serial.println("GPS serial connected");
+
+  myGPS.setUART1Output(COM_TYPE_UBX); //Set the UART port to output UBX only
+  myGPS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
+  myGPS.saveConfiguration(); //Save the current settings to flash and BBR
+}
+
+void loop()
+{
+  //Query module only every second. Doing it more often will just cause I2C traffic.
+  //The module only responds when a new position is available
+  if (millis() - lastTime > 1000)
+  {
+    lastTime = millis(); //Update the timer
+    
+    long latitude = myGPS.getLatitude();
+    Serial.print(F("Lat: "));
+    Serial.print(latitude);
+
+    long longitude = myGPS.getLongitude();
+    Serial.print(F(" Long: "));
+    Serial.print(longitude);
+    Serial.print(F(" (degrees * 10^-7)"));
+
+    long altitude = myGPS.getAltitude();
+    Serial.print(F(" Alt: "));
+    Serial.print(altitude);
+    Serial.print(F(" (mm)"));
+
+    byte SIV = myGPS.getSIV();
+    Serial.print(F(" SIV: "));
+    Serial.print(SIV);
+
+    Serial.println();
+  }
+}
diff --git a/src/SparkFun_Ublox_Arduino_Library.cpp b/src/SparkFun_Ublox_Arduino_Library.cpp
@@ -48,10 +48,70 @@ boolean SFE_UBLOX_GPS::begin(TwoWire &wirePort, uint8_t deviceAddress)
 	//_i2cPort->begin();
 
 	_gpsI2Caddress = deviceAddress; //Store the I2C address from user
-	
+
+	return(isConnected());
+}
+
+//Initialize the Serial port
+boolean SFE_UBLOX_GPS::begin(Stream &serialPort)
+{
+	commType = COMM_TYPE_SERIAL;
+	_serialPort = &serialPort; //Grab which port the user wants us to use
+
 	return(isConnected());
 }
 
+void SFE_UBLOX_GPS::factoryReset() {
+    // Copy default settings to permanent
+    packetCfg.cls = UBX_CLASS_CFG;
+    packetCfg.id = UBX_CFG_CFG;
+    packetCfg.len = 13;
+    packetCfg.startingSpot = 0;
+    for (int i=0; i<4; i++) {
+        payloadCfg[0+i] = 0xff; // clear mask: copy default config to permanent config
+        payloadCfg[4+i] = 0x00; // save mask: don't save current to permanent
+        payloadCfg[8+i] = 0x00; // load mask: don't copy permanent config to current
+    }
+    payloadCfg[12] = 0xff; // all forms of permanent memory
+    sendCommand(packetCfg, 0); // don't expect ACK
+
+    // Issue hard reset
+    packetCfg.cls = UBX_CLASS_CFG;
+    packetCfg.id = UBX_CFG_RST;
+    packetCfg.len = 4;
+    packetCfg.startingSpot = 0;
+    payloadCfg[0] = 0xff; // cold start
+    payloadCfg[1] = 0xff; // cold start
+    payloadCfg[2] = 0; // 0=HW reset
+    payloadCfg[3] = 0; // reserved
+    sendCommand(packetCfg, 0); // don't expect ACK
+}
+
+//Changes the serial baud rate of the Ublox module, can't return success/fail 'cause ACK from modem
+//is lost due to baud rate change
+void SFE_UBLOX_GPS::setSerialRate(uint32_t baudrate, uint16_t maxWait) {
+	//Get the current config values for the UART port
+	getPortSettings(COM_PORT_UART1, maxWait); //This will load the payloadCfg array with current port settings
+        Serial.printf("Current baud rate: %d\n",
+                ((uint32_t)payloadCfg[10]<<16) | ((uint32_t)payloadCfg[9]<<8) | payloadCfg[8]);
+
+	packetCfg.cls = UBX_CLASS_CFG;
+	packetCfg.id = UBX_CFG_PRT;
+	packetCfg.len = 20;
+	packetCfg.startingSpot = 0;
+
+	//payloadCfg is now loaded with current bytes. Change only the ones we need to
+	payloadCfg[8] = baudrate;
+	payloadCfg[9] = baudrate>>8;
+	payloadCfg[10] = baudrate>>16;
+	payloadCfg[11] = baudrate>>24;
+        Serial.printf("Next baud rate: %d=0x%x\n",
+                ((uint32_t)payloadCfg[10]<<16) | ((uint32_t)payloadCfg[9]<<8) | payloadCfg[8],
+                ((uint32_t)payloadCfg[10]<<16) | ((uint32_t)payloadCfg[9]<<8) | payloadCfg[8]);
+
+	sendCommand(packetCfg);
+}
+
 //Changes the I2C address that the Ublox module responds to
 //0x42 is the default but can be changed with this command
 boolean SFE_UBLOX_GPS::setI2CAddress(uint8_t deviceAddress, uint16_t maxWait)
@@ -89,6 +149,7 @@ boolean SFE_UBLOX_GPS::checkUblox()
 		checkUbloxI2C();
 	else if(commType == COMM_TYPE_SERIAL)
 		checkUbloxSerial();
+        return false;
 }
 
 //Polls I2C for data, passing any new bytes to process()
@@ -150,12 +211,14 @@ boolean SFE_UBLOX_GPS::checkUbloxI2C()
 
 } //end checkUbloxI2C()
 
-//Polls Serial for data, passing any new bytes to process()
-//Times out after given amount of time
+//Checks Serial for data, passing any new bytes to process()
 boolean SFE_UBLOX_GPS::checkUbloxSerial()
 {
-	//Todo
-	return (true);
+    while (_serialPort->available())
+    {
+        process(_serialPort->read());
+    }
+    return (true);
 
 } //end checkUbloxSerial()
 
@@ -406,20 +469,35 @@ void SFE_UBLOX_GPS::processUBXpacket(ubxPacket *msg)
   }
 }
 
-//Given a packet and payload, send everything including CRC bytes
-//Poll for a response, returning true if command was ack'd, false if we time out waiting for response
-//Setting timeout to 0 will skip checking for response - handy if you need to scan a raw response (like checking the PROTVER)
+//Given a packet and payload, send everything including CRC bytes via I2C port
 boolean SFE_UBLOX_GPS::sendCommand(ubxPacket outgoingUBX, uint16_t maxWait)
 {
-  commandAck = false; //We're about to send a command. Begin waiting for ack.
-
-  calcChecksum(&outgoingUBX); //Sets checksum A and B bytes of the packet
+    commandAck = false; //We're about to send a command. Begin waiting for ack.
+    calcChecksum(&outgoingUBX); //Sets checksum A and B bytes of the packet
 
 #ifdef DEBUG
-			debug.print("Sending: ");
-			printPacket(&outgoingUBX);
+    debug.print("Sending: ");
+    printPacket(&outgoingUBX);
 #endif
 
+    if(commType == COMM_TYPE_I2C)
+    {
+        if (!sendI2cCommand(outgoingUBX, maxWait)) return false;
+    } else if(commType == COMM_TYPE_SERIAL)
+    {
+        sendSerialCommand(outgoingUBX);
+    }
+
+    if (maxWait > 0)
+    {
+        //Give waitForResponse the cls/id to check for
+        return waitForResponse(outgoingUBX.cls, outgoingUBX.id, maxWait); //Wait for Ack response
+    }
+    return true;
+}
+
+boolean SFE_UBLOX_GPS::sendI2cCommand(ubxPacket outgoingUBX, uint16_t maxWait)
+{
   //Point at 0xFF data register
   _i2cPort->beginTransmission((uint8_t)_gpsI2Caddress); //There is no register to write to, we just begin writing data bytes
   _i2cPort->write(0xFF);
@@ -468,27 +546,54 @@ boolean SFE_UBLOX_GPS::sendCommand(ubxPacket outgoingUBX, uint16_t maxWait)
   if (bytesToSend == 1) _i2cPort->write(outgoingUBX.payload, 1);
   _i2cPort->write(outgoingUBX.checksumA);
   _i2cPort->write(outgoingUBX.checksumB);
-	
+
   //All done transmitting bytes. Release bus.
   if (_i2cPort->endTransmission() != 0)
 	return (false); //Sensor did not ACK
-
-  if (maxWait > 0)
-  {
-	//Give waitForResponse the cls/id to check for
-    if (waitForResponse(outgoingUBX.cls, outgoingUBX.id, maxWait) == false) //Wait for Ack response
-      return (false);
-  }
   return (true);
 }
 
+//Given a packet and payload, send everything including CRC bytesA via Serial port
+void SFE_UBLOX_GPS::sendSerialCommand(ubxPacket outgoingUBX)
+{
+    //Write header bytes
+    _serialPort->write(UBX_SYNCH_1); //μ - oh ublox, you're funny. I will call you micro-blox from now on.
+    _serialPort->write(UBX_SYNCH_2); //b
+    _serialPort->write(outgoingUBX.cls);
+    _serialPort->write(outgoingUBX.id);
+    _serialPort->write(outgoingUBX.len & 0xFF); //LSB
+    _serialPort->write(outgoingUBX.len >> 8); //MSB
+
+    //Write payload.
+    for (int i=0; i<outgoingUBX.len; i++)
+    {
+        _serialPort->write(outgoingUBX.payload[i]);
+    }
+
+    //Write checksum
+    _serialPort->write(outgoingUBX.checksumA);
+    _serialPort->write(outgoingUBX.checksumB);
+}
+
 //Returns true if I2C device ack's
 boolean SFE_UBLOX_GPS::isConnected()
 {
-  _i2cPort->beginTransmission((uint8_t)_gpsI2Caddress);
-  if (_i2cPort->endTransmission() != 0)
-    return (false); //Sensor did not ACK
-  return (true);
+    if(commType == COMM_TYPE_I2C)
+    {
+        _i2cPort->beginTransmission((uint8_t)_gpsI2Caddress);
+        return _i2cPort->endTransmission() == 0;
+    }
+    else if(commType == COMM_TYPE_SERIAL)
+    {
+        // Query navigation rate to see whether we get a meaningful response
+        packetCfg.cls = UBX_CLASS_CFG;
+        packetCfg.id = UBX_CFG_RATE;
+        packetCfg.len = 0;
+        packetCfg.startingSpot = 0;
+
+        return sendCommand(packetCfg);
+    }
+    return false;
 }
 
 //Given a message, calc and store the two byte "8-Bit Fletcher" checksum over the entirety of the message
diff --git a/src/SparkFun_Ublox_Arduino_Library.h b/src/SparkFun_Ublox_Arduino_Library.h
@@ -93,6 +93,7 @@ const uint8_t UBX_CLASS_SEC = 0x27;
 const uint8_t UBX_CLASS_HNR = 0x28;
 
 const uint8_t UBX_CFG_PRT = 0x00; //Used to configure port specifics
+const uint8_t UBX_CFG_RST = 0x04; //Used to reset device
 const uint8_t UBX_CFG_RATE = 0x08; //Used to set port baud rates
 const uint8_t UBX_CFG_CFG = 0x09; //Used to save current configuration
 const uint8_t UBX_CFG_VALSET = 0x8A; //Used for config of higher version Ublox modules (ie protocol v27 and above)
@@ -181,6 +182,8 @@ class SFE_UBLOX_GPS
 
     //By default use the default I2C address, and use Wire port
     boolean begin(TwoWire &wirePort = Wire, uint8_t deviceAddress = 0x42); //Returns true if module is detected
+    //By default use 9600 baud
+    boolean begin(Stream &serialPort); //Returns true if module is detected
 
 	boolean isConnected(); //Returns turn if device answers on _gpsI2Caddress address
 
@@ -198,10 +201,15 @@ class SFE_UBLOX_GPS
 	
 	void calcChecksum(ubxPacket *msg); //Sets the checksumA and checksumB of a given messages
 	boolean sendCommand(ubxPacket outgoingUBX, uint16_t maxWait = 250); //Given a packet and payload, send everything including CRC bytes
+	boolean sendI2cCommand(ubxPacket outgoingUBX, uint16_t maxWait = 250);
+	void sendSerialCommand(ubxPacket outgoingUBX);
 
 	void printPacket(ubxPacket *packet); //Useful for debugging
 
+        void factoryReset(); //Send factory reset sequence
+
 	boolean setI2CAddress(uint8_t deviceAddress, uint16_t maxTime = 250); //Changes the I2C address of the Ublox module
+	void setSerialRate(uint32_t baudrate, uint16_t maxTime = 250); //Changes the serial baud rate of the Ublox module
 	void setNMEAOutputPort(Stream &nmeaOutputPort); //Sets the internal variable for the port to direct NMEA characters to
 	
 	boolean setNavigationFrequency(uint8_t navFreq, uint16_t maxWait = 250); //Set the number of nav solutions sent per second
@@ -311,6 +319,7 @@ class SFE_UBLOX_GPS
 
 	//Variables
     TwoWire *_i2cPort; //The generic connection to user's chosen I2C hardware
+    Stream *_serialPort; //The generic connection to user's chosen Serial hardware
 	Stream *_nmeaOutputPort = NULL; //The user can assign an output port to print NMEA sentences if they wish
 	
 	uint8_t _gpsI2Caddress = 0x42; //Default 7-bit unshifted address of the ublox 6/7/8/M8/F9 series
