hal/src/fsfw_hal/common/gpio/gpioDefinitions.h

@@ -11,7 +11,7 @@ namespace gpio {
 
 enum Levels : uint8_t { LOW = 0, HIGH = 1, NONE = 99 };
 
-enum Direction : uint8_t { IN = 0, OUT = 1 };
+enum Direction : uint8_t { DIR_IN = 0, DIR_OUT = 1 };
 
 enum GpioOperation { READ, WRITE };
 
@@ -20,7 +20,7 @@ enum class GpioTypes {
   GPIO_REGULAR_BY_CHIP,
   GPIO_REGULAR_BY_LABEL,
   GPIO_REGULAR_BY_LINE_NAME,
-  CALLBACK
+  TYPE_CALLBACK
 };
 
 static constexpr gpioId_t NO_GPIO = -1;
@@ -57,7 +57,7 @@ class GpioBase {
   // Can be used to cast GpioBase to a concrete child implementation
   gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
   std::string consumer;
-  gpio::Direction direction = gpio::Direction::IN;
+  gpio::Direction direction = gpio::Direction::DIR_IN;
   gpio::Levels initValue = gpio::Levels::NONE;
 };
 
@@ -79,8 +79,8 @@ class GpiodRegularBase : public GpioBase {
 class GpiodRegularByChip : public GpiodRegularBase {
  public:
   GpiodRegularByChip()
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, std::string(), gpio::Direction::IN,
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, std::string(),
-                         gpio::LOW, 0) {}
+                         gpio::Direction::DIR_IN, gpio::LOW, 0) {}
 
   GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_,
                      gpio::Direction direction_, gpio::Levels initValue_)
@@ -89,7 +89,7 @@ class GpiodRegularByChip : public GpiodRegularBase {
         chipname(chipname_) {}
 
   GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_, gpio::Direction::IN,
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_, gpio::Direction::DIR_IN,
                          gpio::LOW, lineNum_),
         chipname(chipname_) {}
 
@@ -105,7 +105,7 @@ class GpiodRegularByLabel : public GpiodRegularBase {
         label(label_) {}
 
   GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_, gpio::Direction::IN,
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_, gpio::Direction::DIR_IN,
                          gpio::LOW, lineNum_),
         label(label_) {}
 
@@ -126,8 +126,8 @@ class GpiodRegularByLineName : public GpiodRegularBase {
         lineName(lineName_) {}
 
   GpiodRegularByLineName(std::string lineName_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_, gpio::Direction::IN,
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_,
-                         gpio::LOW),
+                         gpio::Direction::DIR_IN, gpio::LOW),
         lineName(lineName_) {}
 
   std::string lineName;
@@ -137,7 +137,7 @@ class GpioCallback : public GpioBase {
  public:
   GpioCallback(std::string consumer, gpio::Direction direction_, gpio::Levels initValue_,
                gpio::gpio_cb_t callback, void* callbackArgs)
-      : GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
+      : GpioBase(gpio::GpioTypes::TYPE_CALLBACK, consumer, direction_, initValue_),
         callback(callback),
         callbackArgs(callbackArgs) {}
 

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -10,7 +10,7 @@ GyroHandlerL3GD20H::GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceC
       transitionDelayMs(transitionDelayMs),
       dataset(this) {
 #if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(3);
+  debugDivider = new PeriodicOperationDivider(10);
 #endif
 }
 

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -13,7 +13,7 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom
       dataset(this),
       transitionDelay(transitionDelay) {
 #if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(3);
+  debugDivider = new PeriodicOperationDivider(10);
 #endif
   // Set to default values right away
   registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
@@ -264,7 +264,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       int16_t mgmMeasurementRawZ =
           packet[MGMLIS3MDL::Z_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::Z_LOWBYTE_IDX];
 
-      /* Target value in microtesla */
+      // Target value in microtesla
       float mgmX = static_cast<float>(mgmMeasurementRawX) * sensitivityFactor *
                    MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
       float mgmY = static_cast<float>(mgmMeasurementRawY) * sensitivityFactor *
@@ -462,7 +462,9 @@ ReturnValue_t MgmLIS3MDLHandler::prepareCtrlRegisterWrite() {
   return RETURN_OK;
 }
 
-void MgmLIS3MDLHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {}
+void MgmLIS3MDLHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+  DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
+}
 
 uint32_t MgmLIS3MDLHandler::getTransitionDelayMs(Mode_t from, Mode_t to) { return transitionDelay; }
 

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -12,7 +12,7 @@ MgmRM3100Handler::MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommu
       primaryDataset(this),
       transitionDelay(transitionDelay) {
 #if FSFW_HAL_RM3100_MGM_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(3);
+  debugDivider = new PeriodicOperationDivider(10);
 #endif
 }
 

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -74,7 +74,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         configureGpioByLineName(gpioConfig.first, *regularGpio);
         break;
       }
-      case (gpio::GpioTypes::CALLBACK): {
+      case (gpio::GpioTypes::TYPE_CALLBACK): {
         auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
         if (gpioCallback->callback == nullptr) {
           return GPIO_INVALID_INSTANCE;
@@ -161,11 +161,11 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   consumer = regularGpio.consumer;
   /* Configure direction and add a description to the GPIO */
   switch (direction) {
-    case (gpio::OUT): {
+    case (gpio::DIR_OUT): {
       result = gpiod_line_request_output(lineHandle, consumer.c_str(), regularGpio.initValue);
       break;
     }
-    case (gpio::IN): {
+    case (gpio::DIR_IN): {
       result = gpiod_line_request_input(lineHandle, consumer.c_str());
       break;
     }
@@ -326,7 +326,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
         }
         break;
       }
-      case (gpio::GpioTypes::CALLBACK): {
+      case (gpio::GpioTypes::TYPE_CALLBACK): {
         auto callbackGpio = dynamic_cast<GpioCallback*>(gpioConfig.second);
         if (callbackGpio == nullptr) {
           return GPIO_TYPE_FAILURE;
@@ -366,13 +366,13 @@ ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
       case (gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
-        if (gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::CALLBACK) {
+        if (gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::TYPE_CALLBACK) {
           eraseDuplicateDifferentType = true;
         }
         break;
       }
-      case (gpio::GpioTypes::CALLBACK): {
+      case (gpio::GpioTypes::TYPE_CALLBACK): {
-        if (gpioType != gpio::GpioTypes::CALLBACK) {
+        if (gpioType != gpio::GpioTypes::TYPE_CALLBACK) {
           eraseDuplicateDifferentType = true;
         }
       }

hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -8,8 +8,7 @@
 
 #include <cstring>
 
-#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/serviceinterface.h"
 #include "fsfw_hal/linux/UnixFileGuard.h"
 #include "fsfw_hal/linux/utility.h"
 
@@ -104,7 +103,7 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
     return result;
   }
 
-  if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
+  if (write(fd, sendData, sendLen) != (int)sendLen) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
                   "device with error code "

hal/src/fsfw_hal/linux/rpi/GpioRPi.cpp

@@ -7,7 +7,7 @@
 
 ReturnValue_t gpio::createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int bcmPin,
                                         std::string consumer, gpio::Direction direction,
-                                        int initValue) {
+                                        gpio::Levels initValue) {
   if (cookie == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }

hal/src/fsfw_hal/linux/rpi/GpioRPi.h

@@ -21,7 +21,8 @@ namespace gpio {
  * @return
  */
 ReturnValue_t createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int bcmPin,
-                                  std::string consumer, gpio::Direction direction, int initValue);
+                                  std::string consumer, gpio::Direction direction,
+                                  gpio::Levels initValue);
 }  // namespace gpio
 
 #endif /* BSP_RPI_GPIO_GPIORPI_H_ */

hal/src/fsfw_hal/linux/uart/UartComIF.cpp

@@ -7,7 +7,6 @@
 
 #include <cstring>
 
-#include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"
 #include "fsfw_hal/linux/utility.h"
 
@@ -313,7 +312,7 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
 
   fd = uartDeviceMapIter->second.fileDescriptor;
 
-  if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
+  if (write(fd, sendData, sendLen) != (int)sendLen) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "UartComIF::sendMessage: Failed to send data with error code " << errno
                << ": Error description: " << strerror(errno) << std::endl;

hal/src/fsfw_hal/linux/uart/UartCookie.cpp

@@ -1,6 +1,6 @@
 #include "fsfw_hal/linux/uart/UartCookie.h"
 
-#include <fsfw/serviceinterface.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
 
 UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
                        uint32_t baudrate, size_t maxReplyLen)

hal/src/fsfw_hal/linux/uio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+	UioMapper.cpp
+)

hal/src/fsfw_hal/linux/uio/UioMapper.cpp

@@ -0,0 +1,66 @@
+#include "UioMapper.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+UioMapper::UioMapper(std::string uioFile, int mapNum) : uioFile(uioFile), mapNum(mapNum) {}
+
+UioMapper::~UioMapper() {}
+
+ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permissions) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  int fd = open(uioFile.c_str(), O_RDWR);
+  if (fd < 1) {
+    sif::warning << "PtmeAxiConfig::initialize: Invalid UIO device file" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  size_t size = 0;
+  result = getMapSize(&size);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  *address = static_cast<uint32_t*>(
+      mmap(NULL, size, static_cast<int>(permissions), MAP_SHARED, fd, mapNum * getpagesize()));
+
+  if (*address == MAP_FAILED) {
+    sif::warning << "UioMapper::getMappedAdress: Failed to map physical address of uio device "
+                 << uioFile.c_str() << " and map" << static_cast<int>(mapNum) << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t UioMapper::getMapSize(size_t* size) {
+  std::stringstream namestream;
+  namestream << UIO_PATH_PREFIX << uioFile.substr(5, std::string::npos) << MAP_SUBSTR << mapNum
+             << SIZE_FILE_PATH;
+  FILE* fp;
+  fp = fopen(namestream.str().c_str(), "r");
+  if (fp == nullptr) {
+    sif::warning << "UioMapper::getMapSize: Failed to open file " << namestream.str() << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  char hexstring[SIZE_HEX_STRING] = "";
+  int items = fscanf(fp, "%s", hexstring);
+  if (items != 1) {
+    sif::warning << "UioMapper::getMapSize: Failed with error code " << errno
+                 << " to read size "
+                    "string from file "
+                 << namestream.str() << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  items = sscanf(hexstring, "%x", size);
+  if (items != 1) {
+    sif::warning << "UioMapper::getMapSize: Failed with error code " << errno << "to convert "
+                 << "size of map" << mapNum << " to integer" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  fclose(fp);
+  return HasReturnvaluesIF::RETURN_OK;
+}

hal/src/fsfw_hal/linux/uio/UioMapper.h

@@ -0,0 +1,58 @@
+#ifndef FSFW_HAL_SRC_FSFW_HAL_LINUX_UIO_UIOMAPPER_H_
+#define FSFW_HAL_SRC_FSFW_HAL_LINUX_UIO_UIOMAPPER_H_
+
+#include <sys/mman.h>
+
+#include <string>
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief   Class to help opening uio device files and mapping the physical addresses into the user
+ *          address space.
+ *
+ * @author  J. Meier
+ */
+class UioMapper {
+ public:
+  enum class Permissions : int {
+    READ_ONLY = PROT_READ,
+    WRITE_ONLY = PROT_WRITE,
+    READ_WRITE = PROT_READ | PROT_WRITE
+  };
+
+  /**
+   * @brief   Constructor
+   *
+   * @param uioFile   The device file of the uiO to open
+   * @param uioMap    Number of memory map. Most UIO drivers have only one map which has than 0.
+   */
+  UioMapper(std::string uioFile, int mapNum = 0);
+  virtual ~UioMapper();
+
+  /**
+   * @brief   Maps the physical address into user address space and returns the mapped address
+   *
+   * @address The mapped user space address
+   * @permissions Specifies the read/write permissions of the address region
+   */
+  ReturnValue_t getMappedAdress(uint32_t** address, Permissions permissions);
+
+ private:
+  static constexpr char UIO_PATH_PREFIX[] = "/sys/class/uio/";
+  static constexpr char MAP_SUBSTR[] = "/maps/map";
+  static constexpr char SIZE_FILE_PATH[] = "/size";
+  static constexpr int SIZE_HEX_STRING = 10;
+
+  std::string uioFile;
+  int mapNum = 0;
+
+  /**
+   * @brief   Reads the map size from the associated sysfs size file
+   *
+   * @param size  The read map size
+   */
+  ReturnValue_t getMapSize(size_t* size);
+};
+
+#endif /* FSFW_HAL_SRC_FSFW_HAL_LINUX_UIO_UIOMAPPER_H_ */

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -291,3 +291,5 @@ float LocalPoolDataSetBase::getCollectionInterval() const {
     return 0.0;
   }
 }
+
+void LocalPoolDataSetBase::printSet() { return; }

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -171,6 +171,11 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    */
   float getCollectionInterval() const;
 
+  /**
+   * @brief   Can be overwritten by a specific implementation of a dataset to print the set.
+   */
+  virtual void printSet();
+
  protected:
   sid_t sid;
   //! This mutex is used if the data is created by one object only.

src/fsfw/datapoollocal/LocalPoolObjectBase.cpp

@@ -47,13 +47,14 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
   HasLocalDataPoolIF* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(poolOwner);
   if (hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalPoolVariable: The supplied pool owner did not implement the correct "
+    sif::error << "LocalPoolVariable: The supplied pool owner 0x" << std::hex << poolOwner
-                  "interface HasLocalDataPoolIF!"
+               << std::dec << " did not implement the correct interface "
-               << std::endl;
+               << "HasLocalDataPoolIF" << std::endl;
 #else
     sif::printError(
-        "LocalPoolVariable: The supplied pool owner did not implement the correct "
+        "LocalPoolVariable: The supplied pool owner 0x%08x did not implement the correct "
-        "interface HasLocalDataPoolIF!\n");
+        "interface HasLocalDataPoolIF\n",
+        poolOwner);
 #endif
     return;
   }

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -665,6 +665,11 @@ void DeviceHandlerBase::doGetWrite() {
 void DeviceHandlerBase::doSendRead() {
   ReturnValue_t result;
 
+  result = doSendReadHook();
+  if (result != RETURN_OK) {
+    return;
+  }
+
   size_t replyLen = 0;
   if (cookieInfo.pendingCommand != deviceCommandMap.end()) {
     replyLen = getNextReplyLength(cookieInfo.pendingCommand->first);
@@ -920,6 +925,8 @@ void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
   }
 }
 
+ReturnValue_t DeviceHandlerBase::doSendReadHook() { return RETURN_OK; }
+
 ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
   return DeviceHandlerBase::NO_SWITCH;
 }

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -1082,6 +1082,12 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   void commandSwitch(ReturnValue_t onOff);
 
+  /**
+   * @brief   This function can be used to insert device specific code during the do-send-read
+   *          step.
+   */
+  virtual ReturnValue_t doSendReadHook();
+
  private:
   /**
    * State a cookie is in.

src/fsfw/timemanager/Clock.h

@@ -99,6 +99,13 @@ class Clock {
    */
   static ReturnValue_t getDateAndTime(TimeOfDay_t *time);
 
+  /**
+   * Convert to time of day struct given the POSIX timeval struct
+   * @param from
+   * @param to
+   * @return
+   */
+  static ReturnValue_t convertTimevalToTimeOfDay(const timeval *from, TimeOfDay_t *to);
   /**
    * Converts a time of day struct to POSIX seconds.
    * @param time The time of day as input

src/fsfw/timemanager/ClockCommon.cpp

@@ -1,3 +1,5 @@
+#include <ctime>
+
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/timemanager/Clock.h"
 
@@ -42,6 +44,19 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t* to) {
+  struct tm* timeInfo;
+  timeInfo = gmtime(&from->tv_sec);
+  to->year = timeInfo->tm_year + 1900;
+  to->month = timeInfo->tm_mon + 1;
+  to->day = timeInfo->tm_mday;
+  to->hour = timeInfo->tm_hour;
+  to->minute = timeInfo->tm_min;
+  to->second = timeInfo->tm_sec;
+  to->usecond = from->tv_usec;
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t Clock::checkOrCreateClockMutex() {
   if (timeMutex == nullptr) {
     MutexFactory* mutexFactory = MutexFactory::instance();

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -172,6 +172,7 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
   }
 
   if (tmFifo->full()) {
+    if (warningLatch) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
                       "of stored packet IDs reached!"
@@ -181,6 +182,8 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
           "TmTcBridge::storeDownlinkData: TM downlink max. number "
           "of stored packet IDs reached!\n");
 #endif
+      warningLatch = true;
+    }
     if (overwriteOld) {
       tmFifo->retrieve(&storeId);
       tmStore->deleteData(storeId);

src/fsfw/tmtcservices/TmTcBridge.h

@@ -72,6 +72,8 @@ class TmTcBridge : public AcceptsTelemetryIF,
   virtual uint16_t getIdentifier() override;
   virtual MessageQueueId_t getRequestQueue() override;
 
+  bool warningLatch = true;
+
  protected:
   //! Cached for initialize function.
   object_id_t tmStoreId = objects::NO_OBJECT;