printout fixes

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -126,10 +126,7 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
     tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
   }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent
+  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent << " bytes were sent" << std::endl;
-             << " bytes were"
-                " sent."
-             << std::endl;
 #endif
   return returnvalue::OK;
 }

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -160,7 +160,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
   // (See requirement for Time margin)
   timeval tNow = {};
   Clock::getClock_timeval(&tNow);
-  if (timestamp < tNow.tv_sec + RELEASE_TIME_MARGIN_SECONDS) {
+  if (timestamp < static_cast<uint32_t>(tNow.tv_sec + RELEASE_TIME_MARGIN_SECONDS)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "Service11TelecommandScheduling::doInsertActivity: Release time too close to "
                     "current time"

src/fsfw/tasks/FixedTimeslotTaskBase.cpp

@@ -15,10 +15,10 @@ ReturnValue_t FixedTimeslotTaskBase::addSlot(object_id_t execId, ExecutableObjec
                                              uint32_t slotTimeMs, int8_t executionStep) {
   if (execObj == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Component 0x" << std::hex << std::setw(8) << std::setfill('0') << execObj
+    sif::error << "Component 0x" << std::hex << std::setw(8) << std::setfill('0') << execId
                << std::setfill(' ') << " not found, not adding it to PST" << std::dec << std::endl;
 #else
-    sif::printError("Component 0x%08x not found, not adding it to PST\n");
+    sif::printError("Component 0x%08x not found, not adding it to PST\n", execId);
 #endif
     return returnvalue::FAILED;
   }

src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -6,14 +6,11 @@
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"
 
-UnixFileGuard::UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+UnixFileGuard::UnixFileGuard(const std::string& device, int& fileDescriptor, int flags,
                              std::string diagnosticPrefix)
-    : fileDescriptor(fileDescriptor) {
+    : fdRef(fileDescriptor) {
-  if (fileDescriptor == nullptr) {
+  fileDescriptor = open(device.c_str(), flags);
-    return;
+  if (fileDescriptor < 0) {
-  }
-  *fileDescriptor = open(device.c_str(), flags);
-  if (*fileDescriptor < 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << diagnosticPrefix << ": Opening device failed with error code " << errno << ": "
@@ -27,10 +24,6 @@ UnixFileGuard::UnixFileGuard(const std::string& device, int* fileDescriptor, int
   }
 }
 
-UnixFileGuard::~UnixFileGuard() {
+UnixFileGuard::~UnixFileGuard() { close(fdRef); }
-  if (fileDescriptor != nullptr) {
-    close(*fileDescriptor);
-  }
-}
 
 ReturnValue_t UnixFileGuard::getOpenResult() const { return openStatus; }

src/fsfw_hal/linux/UnixFileGuard.h

@@ -15,7 +15,15 @@ class UnixFileGuard {
 
   static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;
 
-  UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+  /**
+   * Open a device and assign the given file descriptor variable
+   * @param device [in] Device name.
+   * @param fileDescriptor [in/out] Will be assigned by file guard and re-used to
+   *    close the guard.
+   * @param flags
+   * @param diagnosticPrefix
+   */
+  UnixFileGuard(const std::string& device, int& fileDescriptor, int flags,
                 std::string diagnosticPrefix = "");
 
   virtual ~UnixFileGuard();
@@ -23,7 +31,7 @@ class UnixFileGuard {
   ReturnValue_t getOpenResult() const;
 
  private:
-  int* fileDescriptor = nullptr;
+  int& fdRef;
   ReturnValue_t openStatus = returnvalue::OK;
 };
 

src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -66,8 +66,7 @@ ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
 
 ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
   ReturnValue_t result;
-  int fd;
+  int fd = 0;
-  std::string deviceFile;
 
   if (sendData == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -98,12 +97,12 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
     return returnvalue::FAILED;
   }
 
-  deviceFile = i2cCookie->getDeviceFile();
+  const auto& deviceFile = i2cCookie->getDeviceFile();
-  UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
+  UnixFileGuard fileHelper(deviceFile, fd, O_RDWR, "I2cComIF::sendMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
     return fileHelper.getOpenResult();
   }
-  result = openDevice(deviceFile, i2cAddress, &fd);
+  result = openI2cSlave(deviceFile, i2cAddress, fd);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -131,8 +130,7 @@ ReturnValue_t I2cComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::O
 
 ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   ReturnValue_t result;
-  int fd;
+  int fd = 0;
-  std::string deviceFile;
 
   if (requestLen == 0) {
     return returnvalue::OK;
@@ -157,12 +155,12 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
   }
   i2cDeviceMapIter->second.replyLen = 0;
 
-  deviceFile = i2cCookie->getDeviceFile();
+  auto& deviceFile = i2cCookie->getDeviceFile();
-  UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
+  UnixFileGuard fileHelper(deviceFile, fd, O_RDWR, "I2cComIF::requestReceiveMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
     return fileHelper.getOpenResult();
   }
-  result = openDevice(deviceFile, i2cAddress, &fd);
+  result = openI2cSlave(deviceFile, i2cAddress, fd);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -220,9 +218,9 @@ ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   return returnvalue::OK;
 }
 
-ReturnValue_t I2cComIF::openDevice(std::string deviceFile, address_t i2cAddress,
+ReturnValue_t I2cComIF::openI2cSlave(const std::string& deviceFile, address_t i2cAddress,
-                                   int* fileDescriptor) {
+                                     int& fileDescriptor) {
-  if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
+  if (ioctl(fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."

src/fsfw_hal/linux/i2c/I2cComIF.h

@@ -49,7 +49,8 @@ class I2cComIF : public DeviceCommunicationIF, public SystemObject {
    * @param fileDescriptor	Pointer to device descriptor.
    * @return	returnvalue::OK if successful, otherwise returnvalue::FAILED.
    */
-  ReturnValue_t openDevice(std::string deviceFile, address_t i2cAddress, int *fileDescriptor);
+  ReturnValue_t openI2cSlave(const std::string &deviceFile, address_t i2cAddress,
+                             int &fileDescriptor);
 };
 
 #endif /* LINUX_I2C_I2COMIF_H_ */

src/fsfw_hal/linux/i2c/I2cCookie.cpp

@@ -1,12 +1,12 @@
 #include "fsfw_hal/linux/i2c/I2cCookie.h"
 
 I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_, std::string deviceFile_)
-    : i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(deviceFile_) {}
+    : i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(std::move(deviceFile_)) {}
 
 address_t I2cCookie::getAddress() const { return i2cAddress; }
 
 size_t I2cCookie::getMaxReplyLen() const { return maxReplyLen; }
 
-std::string I2cCookie::getDeviceFile() const { return deviceFile; }
+const std::string& I2cCookie::getDeviceFile() const { return deviceFile; }
 
 I2cCookie::~I2cCookie() {}

src/fsfw_hal/linux/i2c/I2cCookie.h

@@ -25,7 +25,7 @@ class I2cCookie : public CookieIF {
 
   address_t getAddress() const;
   size_t getMaxReplyLen() const;
-  std::string getDeviceFile() const;
+  const std::string& getDeviceFile() const;
 
   uint8_t errorCounter = 0;
 

src/fsfw_hal/linux/spi/ManualCsLockGuard.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <fsfw_hal/linux/spi/SpiCookie.h>
 #include "fsfw/ipc/MutexIF.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_hal/common/gpio/GpioIF.h"

src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -75,7 +75,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   spiCookie->getSpiParameters(spiMode, spiSpeed, &params);
 
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
+  UnixFileGuard fileHelper(dev, fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
     return fileHelper.getOpenResult();
   }
@@ -171,7 +171,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   int retval = 0;
   /* Prepare transfer */
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  UnixFileGuard fileHelper(dev, fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
     return OPENING_FILE_FAILED;
   }
@@ -285,7 +285,7 @@ ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   ReturnValue_t result = returnvalue::OK;
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
+  UnixFileGuard fileHelper(dev, fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
     return OPENING_FILE_FAILED;
   }