proposing hooks for adding mutex that allow multiple tasks to write directly the gnss with different priorities

- also propose to align the ping return type.

Author: mazgch

src/u-blox_GNSS.cpp

@@ -665,9 +665,12 @@ uint16_t DevUBLOXGNSS::available()
 }
 // For I2C, ping the _address
 // Not Applicable for SPI and Serial
-uint16_t DevUBLOXGNSS::ping()
+bool DevUBLOXGNSS::ping()
 {
-  return _sfeBus->ping();
+  if (!lock()) return 0;
+  bool ok = _sfeBus->ping();
+  unlock();
+  return ok;
 }
 // For Serial, do Serial.write
 // For I2C, push data to register 0xFF. Chunkify if necessary. Prevent single byte writes as these are illegal
@@ -1014,12 +1017,15 @@ bool DevUBLOXGNSS::checkUblox(uint8_t requestedClass, uint8_t requestedID)
 // PRIVATE: Called regularly to check for available bytes on the user' specified port
 bool DevUBLOXGNSS::checkUbloxInternal(ubxPacket *incomingUBX, uint8_t requestedClass, uint8_t requestedID)
 {
+  if (!lock()) return false;
+  bool ok = false;
   if (_commType == COMM_TYPE_I2C)
-    return (checkUbloxI2C(incomingUBX, requestedClass, requestedID));
+    ok = (checkUbloxI2C(incomingUBX, requestedClass, requestedID));
   else if (_commType == COMM_TYPE_SERIAL)
-    return (checkUbloxSerial(incomingUBX, requestedClass, requestedID));
+    ok = (checkUbloxSerial(incomingUBX, requestedClass, requestedID));
   else if (_commType == COMM_TYPE_SPI)
-    return (checkUbloxSpi(incomingUBX, requestedClass, requestedID));
+    ok = (checkUbloxSpi(incomingUBX, requestedClass, requestedID));
+  unlock();
   return false;
 }
 
@@ -4162,7 +4168,6 @@ void DevUBLOXGNSS::addToChecksum(uint8_t incoming)
 sfe_ublox_status_e DevUBLOXGNSS::sendCommand(ubxPacket *outgoingUBX, uint16_t maxWait, bool expectACKonly)
 {
   sfe_ublox_status_e retVal = SFE_UBLOX_STATUS_SUCCESS;
-
   calcChecksum(outgoingUBX); // Sets checksum A and B bytes of the packet
 
 #ifndef SFE_UBLOX_REDUCED_PROG_MEM
@@ -4173,6 +4178,7 @@ sfe_ublox_status_e DevUBLOXGNSS::sendCommand(ubxPacket *outgoingUBX, uint16_t ma
   }
 #endif
 
+  if (!lock()) return SFE_UBLOX_STATUS_FAIL;
   if (_commType == COMM_TYPE_I2C)
   {
     retVal = sendI2cCommand(outgoingUBX);
@@ -4195,7 +4201,8 @@ sfe_ublox_status_e DevUBLOXGNSS::sendCommand(ubxPacket *outgoingUBX, uint16_t ma
   {
     sendSpiCommand(outgoingUBX);
   }
-
+  unlock();
+  
   if (maxWait > 0)
   {
     // Depending on what we just sent, either we need to look for an ACK or not
@@ -5341,12 +5348,14 @@ bool DevUBLOXGNSS::pushRawData(uint8_t *dataBytes, size_t numDataBytes, bool cal
 {
   // Return now if numDataBytes is zero
   if (numDataBytes == 0)
-    return (false); // Indicate to the user that there was no data to push
+    return false; // Indicate to the user that there was no data to push
 
+  if (!lock()) return SFE_UBLOX_STATUS_FAIL;
+  bool ok = false;
   if (_commType == COMM_TYPE_SERIAL)
   {
     // Serial: write all the bytes in one go
-    return writeBytes(dataBytes, numDataBytes) == numDataBytes;
+    ok = writeBytes(dataBytes, numDataBytes) == numDataBytes;
   }
   else if (_commType == COMM_TYPE_I2C)
   {
@@ -5362,55 +5371,56 @@ bool DevUBLOXGNSS::pushRawData(uint8_t *dataBytes, size_t numDataBytes, bool cal
     {
       _pushThisSingleByte = *dataBytes;
       _pushSingleByte = true;
-      return (false); // Indicate to the user that their data has not been pushed yet
-    }
+      ok = false; // Indicate to the user that their data has not been pushed yet
+    } else {
 
-    // I2C: split the data up into packets of i2cTransactionSize
-    size_t bytesLeftToWrite = numDataBytes;
-    size_t bytesWrittenTotal = 0;
+      // I2C: split the data up into packets of i2cTransactionSize
+      size_t bytesLeftToWrite = numDataBytes;
+      size_t bytesWrittenTotal = 0;
 
-    if (_pushSingleByte == true) // Increment bytesLeftToWrite if we have a single byte waiting to be pushed
-      bytesLeftToWrite++;
+      if (_pushSingleByte == true) // Increment bytesLeftToWrite if we have a single byte waiting to be pushed
+        bytesLeftToWrite++;
 
-    while (bytesLeftToWrite > 0)
-    {
-      size_t bytesToWrite; // Limit bytesToWrite to i2cTransactionSize
+      while (bytesLeftToWrite > 0)
+      {
+        size_t bytesToWrite; // Limit bytesToWrite to i2cTransactionSize
 
-      if (bytesLeftToWrite > i2cTransactionSize)
-        bytesToWrite = i2cTransactionSize;
-      else
-        bytesToWrite = bytesLeftToWrite;
+        if (bytesLeftToWrite > i2cTransactionSize)
+          bytesToWrite = i2cTransactionSize;
+        else
+          bytesToWrite = bytesLeftToWrite;
 
-      // If there would be one byte left to be written next time, send one byte less now
-      if ((bytesLeftToWrite - bytesToWrite) == 1)
-        bytesToWrite--;
+        // If there would be one byte left to be written next time, send one byte less now
+        if ((bytesLeftToWrite - bytesToWrite) == 1)
+          bytesToWrite--;
 
-      size_t bytesWritten = 0;
+        size_t bytesWritten = 0;
 
-      if (_pushSingleByte == true)
-      {
-        uint8_t buf[i2cTransactionSize];
+        if (_pushSingleByte == true)
+        {
+          uint8_t buf[i2cTransactionSize];
 
-        buf[0] = _pushThisSingleByte;
+          buf[0] = _pushThisSingleByte;
 
-        for (uint16_t x = 1; x < bytesToWrite; x++)
-          buf[x] = dataBytes[x - 1];
+          for (uint16_t x = 1; x < bytesToWrite; x++)
+            buf[x] = dataBytes[x - 1];
 
-        bytesWritten += writeBytes(buf, bytesToWrite); // Write the bytes
-        dataBytes += bytesToWrite - 1;                 // Point to fresh data
-        _pushSingleByte = false;                       // Clear the flag
-      }
-      else
-      {
-        bytesWritten += writeBytes(dataBytes, bytesToWrite); // Write the bytes
-        dataBytes += bytesToWrite;                           // Point to fresh data
+          bytesWritten += writeBytes(buf, bytesToWrite); // Write the bytes
+          dataBytes += bytesToWrite - 1;                 // Point to fresh data
+          _pushSingleByte = false;                       // Clear the flag
+        }
+        else
+        {
+          bytesWritten += writeBytes(dataBytes, bytesToWrite); // Write the bytes
+          dataBytes += bytesToWrite;                           // Point to fresh data
+        }
+
+        bytesWrittenTotal += bytesWritten; // Update the totals
+        bytesLeftToWrite -= bytesToWrite;
       }
 
-      bytesWrittenTotal += bytesWritten; // Update the totals
-      bytesLeftToWrite -= bytesToWrite;
+      ok = (bytesWrittenTotal == numDataBytes); // Return true if the correct number of bytes were written
     }
-
-    return (bytesWrittenTotal == numDataBytes); // Return true if the correct number of bytes were written
   }
   else if (_commType == COMM_TYPE_SPI)
   {
@@ -5446,9 +5456,10 @@ bool DevUBLOXGNSS::pushRawData(uint8_t *dataBytes, size_t numDataBytes, bool cal
         processSpiBuffer(&packetCfg, 0, 0); // This will hopefully prevent any lost data?
     }
 
-    return (true);
+    ok = true;
   }
-  return false;
+  unlock();
+  return ok;
 }
 
 // Push MGA AssistNow data to the module.

src/u-blox_GNSS.h

@@ -108,7 +108,7 @@ class DevUBLOXGNSS
   void setCommunicationBus(SparkFun_UBLOX_GNSS::GNSSDeviceBus &theBus);
   // For I2C, ping the _address
   // Not Applicable for SPI and Serial
-  uint16_t ping();
+  bool ping();
   // For Serial, return Serial.available()
   // For I2C, read registers 0xFD and 0xFE. Return bytes available as uint16_t
   // Not Applicable for SPI
@@ -130,6 +130,8 @@ class DevUBLOXGNSS
   // Flag to indicate if we are connected to UART1 or UART2
   // Needed to select the correct config items when enabling a periodic message
   bool _UART2 = false; // Default to UART1
+  virtual bool lock(void) { return true; }
+  virtual void unlock(void) { }
 public:
   void connectedToUART2(bool connected = true) { _UART2 = connected; }