run auto-formatter

CMakeLists.txt

@@ -1,12 +1,8 @@
-add_subdirectory(mission)
-add_subdirectory(test)
 add_subdirectory(config)
-add_subdirectory(utility)
+add_subdirectory(example)
 
-target_include_directories(${TARGET_NAME} PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
 if(TGT_BSP MATCHES "arm/stm32h743zi-nucleo")
-    add_subdirectory(stm32h7)
+  add_subdirectory(stm32h7)
 endif()

config/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${TARGET_NAME} PRIVATE
-    commonPollingSequenceFactory.cpp
-)
+target_sources(${TARGET_NAME} PRIVATE commonPollingSequenceFactory.cpp)
 
-target_include_directories(${TARGET_NAME} PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}
-)
+target_include_directories(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

config/OBSWVersion.h

@@ -1,8 +1,8 @@
 #ifndef COMMON_OBSWVERSION_H_
 #define COMMON_OBSWVERSION_H_
 
-#define FSFW_EXAMPLE_VERSION        1
-#define FSFW_EXAMPLE_SUBVERSION     4
-#define FSFW_EXAMPLE_REVISION       0
+#define FSFW_EXAMPLE_VERSION 1
+#define FSFW_EXAMPLE_SUBVERSION 5
+#define FSFW_EXAMPLE_REVISION 0
 
 #endif /* COMMON_OBSWVERSION_H_ */

config/common/definitions.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+
+/**
+ * Enumerations for used PUS service IDs.
+ */
+namespace pus {
+enum ServiceIds : uint8_t {
+  PUS_SERVICE_1 = 1,
+  PUS_SERVICE_2 = 2,
+  PUS_SERVICE_3 = 3,
+  PUS_SERVICE_5 = 5,
+  PUS_SERVICE_8 = 8,
+  PUS_SERVICE_9 = 9,
+  PUS_SERVICE_11 = 11,
+  PUS_SERVICE_17 = 17,
+  PUS_SERVICE_20 = 20,
+  PUS_SERVICE_200 = 200
+};
+}

config/commonClassIds.h

@@ -4,10 +4,10 @@
 #include "fsfw/returnvalues/FwClassIds.h"
 
 namespace CLASS_ID {
-enum commonClassIds: uint8_t {
-    COMMON_CLASS_ID_START = FW_CLASS_ID_COUNT,
-    DUMMY_HANDLER, //DDH
-    COMMON_CLASS_ID_END // [EXPORT] : [END]
+enum commonClassIds : uint8_t {
+  COMMON_CLASS_ID_START = FW_CLASS_ID_COUNT,
+  DUMMY_HANDLER,      // DDH
+  COMMON_CLASS_ID_END // [EXPORT] : [END]
 };
 }
 

config/commonConfig.h.in

@@ -4,7 +4,9 @@
 #ifndef COMMON_COMMONCONFIG_H_
 #define COMMON_COMMONCONFIG_H_
 
-#include <stdint.h>
+#include <cstdint>
+
+#cmakedefine01 FSFW_ADD_FMT_TESTS
 
 //! Specify the debug output verbose level
 #define OBSW_VERBOSE_LEVEL              1
@@ -42,24 +44,10 @@ static const uint16_t COMMON_APID = 0xEF;
 
 #ifdef __cplusplus
 
-#include <fsfw/events/fwSubsystemIdRanges.h>
-#include <fsfw/returnvalues/FwClassIds.h>
+namespace cfg {
+
+static constexpr uint32_t OBSW_MAX_SCHEDULED_TCS = @OBSW_MAX_SCHEDULED_TCS@;
 
-/**
- * Enumerations for used PUS service IDs.
- */
-namespace pus {
-enum ServiceIds: uint8_t {
-    PUS_SERVICE_1 = 1,
-    PUS_SERVICE_2 = 2,
-    PUS_SERVICE_3 = 3,
-    PUS_SERVICE_5 = 5,
-    PUS_SERVICE_8 = 8,
-    PUS_SERVICE_9 = 9,
-    PUS_SERVICE_17 = 17,
-    PUS_SERVICE_20 = 20,
-    PUS_SERVICE_200 = 200
-};
 }
 
 #endif /* __cplusplus */

config/commonObjects.h

@@ -0,0 +1,39 @@
+#ifndef COMMON_COMMONSYSTEMOBJECTS_H_
+#define COMMON_COMMONSYSTEMOBJECTS_H_
+
+#include <fsfw/objectmanager/frameworkObjects.h>
+
+#include <cstdint>
+
+namespace objects {
+enum commonObjects : object_id_t {
+
+  /* 0x41 ('A') for Assemblies */
+  TEST_ASSEMBLY = 0x4100CAFE,
+
+  /* 0x43 ('C') for Controllers */
+  TEST_CONTROLLER = 0x4301CAFE,
+
+  /* 0x44 ('D') for Device Handlers */
+  TEST_DEVICE_HANDLER_0 = 0x4401AFFE,
+  TEST_DEVICE_HANDLER_1 = 0x4402AFFE,
+
+  /* 0x49 ('I') for Communication Interfaces */
+  TEST_ECHO_COM_IF = 0x4900AFFE,
+
+  /* 0x63 ('C') for core objects */
+  CCSDS_DISTRIBUTOR = 0x63000000,
+  PUS_DISTRIBUTOR = 0x63000001,
+  TM_FUNNEL = 0x63000002,
+
+  /* 0x74 ('t') for test and example objects  */
+  TEST_TASK = 0x7400CAFE,
+  TEST_DUMMY_1 = 0x74000001,
+  TEST_DUMMY_2 = 0x74000002,
+  TEST_DUMMY_3 = 0x74000003,
+  TEST_DUMMY_4 = 0x74000004,
+  TEST_DUMMY_5 = 0x74000005,
+};
+}
+
+#endif /* COMMON_COMMONSYSTEMOBJECTS_H_ */

config/commonPollingSequenceFactory.cpp

@@ -1,81 +1,87 @@
-#include <pollingsequence/pollingSequenceFactory.h>
-#include <objects/systemObjectList.h>
-
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
-#include <test/FsfwExampleTask.h>
 
-ReturnValue_t pst::pollingSequenceExamples(FixedTimeslotTaskIF* thisSequence) {
-    uint32_t length = thisSequence->getPeriodMs();
+#include "example/test/FsfwExampleTask.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
 
-    thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0,
-            FsfwExampleTask::OpCodes::SEND_RAND_NUM);
-    thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0,
-            FsfwExampleTask::OpCodes::SEND_RAND_NUM);
-    thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0,
-            FsfwExampleTask::OpCodes::SEND_RAND_NUM);
+ReturnValue_t pst::pollingSequenceExamples(FixedTimeslotTaskIF *thisSequence) {
+  uint32_t length = thisSequence->getPeriodMs();
 
-    thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.2,
-            FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM);
-    thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0.2,
-            FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM);
-    thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.2,
-            FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM);
+  thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0,
+                        FsfwExampleTask::OpCodes::SEND_RAND_NUM);
+  thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0,
+                        FsfwExampleTask::OpCodes::SEND_RAND_NUM);
+  thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0,
+                        FsfwExampleTask::OpCodes::SEND_RAND_NUM);
 
-    thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.5,
-            FsfwExampleTask::OpCodes::DELAY_SHORT);
-    thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0.5,
-            FsfwExampleTask::OpCodes::DELAY_SHORT);
-    thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.5,
-            FsfwExampleTask::OpCodes::DELAY_SHORT);
+  thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.2,
+                        FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM);
+  thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0.2,
+                        FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM);
+  thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.2,
+                        FsfwExampleTask::OpCodes::RECEIVE_RAND_NUM);
 
-    if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
+  thisSequence->addSlot(objects::TEST_DUMMY_1, length * 0.5,
+                        FsfwExampleTask::OpCodes::DELAY_SHORT);
+  thisSequence->addSlot(objects::TEST_DUMMY_2, length * 0.5,
+                        FsfwExampleTask::OpCodes::DELAY_SHORT);
+  thisSequence->addSlot(objects::TEST_DUMMY_3, length * 0.5,
+                        FsfwExampleTask::OpCodes::DELAY_SHORT);
+
+  if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    return HasReturnvaluesIF::RETURN_OK;
+  } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "pst::pollingSequenceInitFunction: Initialization errors!" << std::endl;
+    sif::error << "pst::pollingSequenceInitFunction: Initialization errors!"
+               << std::endl;
 #else
-        sif::printError("pst::pollingSequenceInitFunction: Initialization errors!\n");
+    sif::printError(
+        "pst::pollingSequenceInitFunction: Initialization errors!\n");
 #endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
 }
 
 ReturnValue_t pst::pollingSequenceDevices(FixedTimeslotTaskIF *thisSequence) {
-    uint32_t length = thisSequence->getPeriodMs();
+  uint32_t length = thisSequence->getPeriodMs();
 
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0, DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
 
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.3, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.3, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.3 * length,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.3 * length,
+                        DeviceHandlerIF::SEND_WRITE);
 
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.45 * length,
-            DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.45 * length,
-            DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.45 * length,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.45 * length,
+                        DeviceHandlerIF::GET_WRITE);
 
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.6 * length, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.6 * length, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.6 * length,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.6 * length,
+                        DeviceHandlerIF::SEND_READ);
 
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.8 * length, DeviceHandlerIF::GET_READ);
-    thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.8 * length, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_0, 0.8 * length,
+                        DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TEST_DEVICE_HANDLER_1, 0.8 * length,
+                        DeviceHandlerIF::GET_READ);
 
-    if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
+  if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    return HasReturnvaluesIF::RETURN_OK;
+  } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "pst::pollingSequenceTestFunction: Initialization errors!" << std::endl;
+    sif::error << "pst::pollingSequenceTestFunction: Initialization errors!"
+               << std::endl;
 #else
-        sif::printError("pst::pollingSequenceTestFunction: Initialization errors!\n");
+    sif::printError(
+        "pst::pollingSequenceTestFunction: Initialization errors!\n");
 #endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
 }
-
-
-
-

config/commonSubsystemIds.h

@@ -7,12 +7,11 @@
  * The subsystem IDs will be part of the event IDs used throughout the FSFW.
  */
 namespace SUBSYSTEM_ID {
-enum commonSubsystemId: uint8_t {
-    COMMON_SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
-    TEST_TASK_ID = 105,
-    COMMON_SUBSYSTEM_ID_END
+enum commonSubsystemId : uint8_t {
+  COMMON_SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+  TEST_TASK_ID = 105,
+  COMMON_SUBSYSTEM_ID_END
 };
 }
 
-
 #endif /* COMMON_CONFIG_COMMONSUBSYSTEMIDS_H_ */

config/commonSystemObjects.h

@@ -1,40 +0,0 @@
-#ifndef COMMON_COMMONSYSTEMOBJECTS_H_
-#define COMMON_COMMONSYSTEMOBJECTS_H_
-
-#include <cstdint>
-#include <fsfw/objectmanager/frameworkObjects.h>
-
-namespace objects {
-enum commonObjects: object_id_t {
-
-	/* 0x41 ('A') for Assemblies */
-	TEST_ASSEMBLY = 0x4100CAFE,
-
-    /* 0x43 ('C') for Controllers */
-    TEST_CONTROLLER = 0x4301CAFE,
-
-    /* 0x44 ('D') for Device Handlers */
-    TEST_DEVICE_HANDLER_0 = 0x4401AFFE,
-    TEST_DEVICE_HANDLER_1 = 0x4402AFFE,
-
-    /* 0x49 ('I') for Communication Interfaces */
-    TEST_ECHO_COM_IF = 0x4900AFFE,
-
-    /* 0x63 ('C') for core objects */
-    CCSDS_DISTRIBUTOR = 0x63000000,
-    PUS_DISTRIBUTOR = 0x63000001,
-    TM_FUNNEL = 0x63000002,
-
-    /* 0x74 ('t') for test and example objects  */
-    TEST_TASK = 0x7400CAFE,
-    TEST_DUMMY_1 = 0x74000001,
-    TEST_DUMMY_2 = 0x74000002,
-    TEST_DUMMY_3= 0x74000003,
-    TEST_DUMMY_4 = 0x74000004,
-    TEST_DUMMY_5 = 0x74000005,
-};
-}
-
-
-
-#endif /* COMMON_COMMONSYSTEMOBJECTS_H_ */

example/CMakeLists.txt

@@ -1,5 +1,5 @@
+add_subdirectory(controller)
 add_subdirectory(core)
 add_subdirectory(devices)
+add_subdirectory(test)
 add_subdirectory(utility)
-add_subdirectory(controller)
-add_subdirectory(assemblies)

example/controller/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${TARGET_NAME} PRIVATE FsfwTestController.cpp)

example/controller/FsfwTestController.cpp

@@ -0,0 +1,233 @@
+#include "FsfwTestController.h"
+
+#include <fsfw/datapool/PoolReadGuard.h>
+
+FsfwTestController::FsfwTestController(object_id_t objectId,
+                                       object_id_t device0, object_id_t device1,
+                                       uint8_t verboseLevel)
+    : TestController(objectId, objects::NO_OBJECT, 5), device0Id(device0),
+      device1Id(device1), deviceDataset0(device0), deviceDataset1(device1) {}
+
+FsfwTestController::~FsfwTestController() {}
+
+ReturnValue_t
+FsfwTestController::handleCommandMessage(CommandMessage *message) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FsfwTestController::initializeLocalDataPool(
+    localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FsfwTestController::performControlOperation() {
+  // We will trace variables if we received an update notification or snapshots
+  if (verboseLevel >= 1) {
+    if (not traceVariable) {
+      return;
+    }
+    switch (currentTraceType) {
+    case (NONE): {
+      break;
+    }
+    case (TRACE_DEV_0_UINT8): {
+      if (traceCounter == 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "Tracing finished" << std::endl;
+#else
+        sif::printInfo("Tracing finished\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        traceVariable = false;
+        traceCounter = traceCycles;
+        currentTraceType = TraceTypes::NONE;
+        break;
+      }
+      PoolReadGuard readHelper(&deviceDataset0.testUint8Var);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << "Tracing device 0 variable 0 (UINT8), current value: "
+                << static_cast<int>(deviceDataset0.testUint8Var.value)
+                << std::endl;
+#else
+      sif::printInfo("Tracing device 0 variable 0 (UINT8), current value: %d\n",
+                     deviceDataset0.testUint8Var.value);
+#endif
+      traceCounter--;
+      break;
+    }
+    case (TRACE_DEV_0_VECTOR): {
+      break;
+    }
+    }
+  }
+}
+
+ReturnValue_t FsfwTestController::initializeAfterTaskCreation() {
+  namespace td = testdevice;
+  ReturnValue_t result = TestController::initializeAfterTaskCreation();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  HasLocalDataPoolIF *device0 =
+      ObjectManager::instance()->get<HasLocalDataPoolIF>(
+          deviceDataset0.getCreatorObjectId());
+  if (device0 == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning
+        << "TestController::initializeAfterTaskCreation: Test device handler 0 "
+           "handle invalid!"
+        << std::endl;
+#else
+    sif::printWarning(
+        "TestController::initializeAfterTaskCreation: Test device handler 0 "
+        "handle invalid!");
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  ProvidesDataPoolSubscriptionIF *subscriptionIF =
+      device0->getSubscriptionInterface();
+  if (subscriptionIF != nullptr) {
+    /* For DEVICE_0, we only subscribe for notifications */
+    subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(),
+                                                 getCommandQueue(), false);
+    subscriptionIF->subscribeForVariableUpdateMessage(
+        td::PoolIds::TEST_UINT8_ID, getObjectId(), getCommandQueue(), false);
+  }
+
+  HasLocalDataPoolIF *device1 =
+      ObjectManager::instance()->get<HasLocalDataPoolIF>(
+          deviceDataset0.getCreatorObjectId());
+  if (device1 == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning
+        << "TestController::initializeAfterTaskCreation: Test device handler 1 "
+           "handle invalid!"
+        << std::endl;
+#else
+    sif::printWarning(
+        "TestController::initializeAfterTaskCreation: Test device handler 1 "
+        "handle invalid!");
+#endif
+  }
+
+  subscriptionIF = device1->getSubscriptionInterface();
+  if (subscriptionIF != nullptr) {
+    /* For DEVICE_1, we will subscribe for snapshots */
+    subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(),
+                                                 getCommandQueue(), true);
+    subscriptionIF->subscribeForVariableUpdateMessage(
+        td::PoolIds::TEST_UINT8_ID, getObjectId(), getCommandQueue(), true);
+  }
+  return result;
+}
+
+LocalPoolDataSetBase *FsfwTestController::getDataSetHandle(sid_t sid) {
+  return nullptr;
+}
+
+ReturnValue_t FsfwTestController::checkModeCommand(Mode_t mode,
+                                                   Submode_t submode,
+                                                   uint32_t *msToReachTheMode) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void FsfwTestController::handleChangedDataset(sid_t sid,
+                                              store_address_t storeId,
+                                              bool *clearMessage) {
+  using namespace std;
+
+  if (verboseLevel >= 1) {
+    char const *printout = nullptr;
+    if (storeId == storeId::INVALID_STORE_ADDRESS) {
+      printout = "Notification";
+    } else {
+      printout = "Snapshot";
+    }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "FsfwTestController::handleChangedDataset: " << printout
+              << " update"
+                 "from object ID "
+              << setw(8) << setfill('0') << hex << sid.objectId
+              << " and set ID " << sid.ownerSetId << dec << setfill(' ')
+              << endl;
+#else
+    sif::printInfo(
+        "FsfwTestController::handleChangedPoolVariable: %s update from"
+        "object ID 0x%08x and set ID %lu\n",
+        printout, sid.objectId, sid.ownerSetId);
+#endif
+
+    if (storeId == storeId::INVALID_STORE_ADDRESS) {
+      if (sid.objectId == device0Id) {
+        PoolReadGuard readHelper(&deviceDataset0.testFloat3Vec);
+        float floatVec[3];
+        floatVec[0] = deviceDataset0.testFloat3Vec.value[0];
+        floatVec[1] = deviceDataset0.testFloat3Vec.value[1];
+        floatVec[2] = deviceDataset0.testFloat3Vec.value[2];
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "Current float vector (3) values: [" << floatVec[0] << ", "
+                  << floatVec[1] << ", " << floatVec[2] << "]" << std::endl;
+#else
+        sif::printInfo("Current float vector (3) values: [%f, %f, %f]\n",
+                       floatVec[0], floatVec[1], floatVec[2]);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      }
+    }
+  }
+
+  /* We will trace the variables for snapshots and update notifications */
+  if (not traceVariable) {
+    traceVariable = true;
+    traceCounter = traceCycles;
+    currentTraceType = TraceTypes::TRACE_DEV_0_VECTOR;
+  }
+}
+
+void FsfwTestController::handleChangedPoolVariable(gp_id_t globPoolId,
+                                                   store_address_t storeId,
+                                                   bool *clearMessage) {
+  using namespace std;
+
+  if (verboseLevel >= 1) {
+    char const *printout = nullptr;
+    if (storeId == storeId::INVALID_STORE_ADDRESS) {
+      printout = "Notification";
+    } else {
+      printout = "Snapshot";
+    }
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestController::handleChangedPoolVariable: " << printout
+              << " update from object "
+                 "ID 0x"
+              << setw(8) << setfill('0') << hex << globPoolId.objectId
+              << " and local pool ID " << globPoolId.localPoolId << dec
+              << setfill(' ') << endl;
+#else
+    sif::printInfo("TestController::handleChangedPoolVariable: %s update from "
+                   "object ID 0x%08x and "
+                   "local pool ID %lu\n",
+                   printout, globPoolId.objectId, globPoolId.localPoolId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+    if (storeId == storeId::INVALID_STORE_ADDRESS) {
+      if (globPoolId.objectId == device0Id) {
+        PoolReadGuard readHelper(&deviceDataset0.testUint8Var);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "Current test variable 0 (UINT8) value: "
+                  << static_cast<int>(deviceDataset0.testUint8Var.value)
+                  << std::endl;
+#else
+        sif::printInfo("Current test variable 0 (UINT8) value %d\n",
+                       deviceDataset0.testUint8Var.value);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      }
+    }
+  }
+
+  /* We will trace the variables for snapshots and update notifications */
+  if (not traceVariable) {
+    traceVariable = true;
+    traceCounter = traceCycles;
+    currentTraceType = TraceTypes::TRACE_DEV_0_UINT8;
+  }
+}

example/controller/FsfwTestController.h

@@ -0,0 +1,46 @@
+#ifndef EXAMPLE_COMMON_EXAMPLE_CONTROLLER_FSFWTESTCONTROLLER_H_
+#define EXAMPLE_COMMON_EXAMPLE_CONTROLLER_FSFWTESTCONTROLLER_H_
+
+#include "fsfw/controller/ExtendedControllerBase.h"
+#include "fsfw_tests/integration/controller/TestController.h"
+
+class FsfwTestController : public TestController {
+public:
+  FsfwTestController(object_id_t objectId, object_id_t device0,
+                     object_id_t device1, uint8_t verboseLevel = 0);
+  virtual ~FsfwTestController();
+  ReturnValue_t handleCommandMessage(CommandMessage *message) override;
+
+  /**
+   * Periodic helper from ControllerBase, implemented by child class.
+   */
+  void performControlOperation() override;
+
+private:
+  object_id_t device0Id;
+  object_id_t device1Id;
+  testdevice::TestDataSet deviceDataset0;
+  testdevice::TestDataSet deviceDataset1;
+
+  uint8_t verboseLevel = 0;
+  bool traceVariable = false;
+  uint8_t traceCycles = 5;
+  uint8_t traceCounter = traceCycles;
+
+  enum TraceTypes { NONE, TRACE_DEV_0_UINT8, TRACE_DEV_0_VECTOR };
+  TraceTypes currentTraceType = TraceTypes::NONE;
+
+  ReturnValue_t initializeAfterTaskCreation() override;
+  void handleChangedDataset(sid_t sid, store_address_t storeId,
+                            bool *clearMessage) override;
+  void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+                                 bool *clearMessage) override;
+  ReturnValue_t
+  initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                          LocalDataPoolManager &poolManager) override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t *msToReachTheMode) override;
+};
+
+#endif /* EXAMPLE_COMMON_EXAMPLE_CONTROLLER_FSFWTESTCONTROLLER_H_ */

example/core/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${TARGET_NAME} PRIVATE GenericFactory.cpp)

example/core/GenericFactory.cpp

@@ -0,0 +1,161 @@
+#include "GenericFactory.h"
+
+#include "OBSWConfig.h"
+#include "common/definitions.h"
+#include "example/test/FsfwExampleTask.h"
+#include "example/test/FsfwReaderTask.h"
+#include "example/utility/TmFunnel.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/devicehandlers/CookieIF.h"
+#include "fsfw/events/EventManager.h"
+#include "fsfw/health/HealthTable.h"
+#include "fsfw/internalerror/InternalErrorReporter.h"
+#include "fsfw/pus/CService200ModeCommanding.h"
+#include "fsfw/pus/Service11TelecommandScheduling.h"
+#include "fsfw/pus/Service17Test.h"
+#include "fsfw/pus/Service1TelecommandVerification.h"
+#include "fsfw/pus/Service20ParameterManagement.h"
+#include "fsfw/pus/Service2DeviceAccess.h"
+#include "fsfw/pus/Service3Housekeeping.h"
+#include "fsfw/pus/Service5EventReporting.h"
+#include "fsfw/pus/Service8FunctionManagement.h"
+#include "fsfw/pus/Service9TimeManagement.h"
+#include "fsfw/tcdistribution/CCSDSDistributor.h"
+#include "fsfw/tcdistribution/PUSDistributor.h"
+#include "fsfw/timemanager/TimeStamper.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw_tests/integration/assemblies/TestAssembly.h"
+#include "fsfw_tests/integration/controller/TestController.h"
+#include "fsfw_tests/integration/devices/TestCookie.h"
+#include "fsfw_tests/integration/devices/TestDeviceHandler.h"
+#include "fsfw_tests/integration/devices/TestEchoComIF.h"
+#include "fsfw_tests/internal/InternalUnitTester.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+
+void ObjectFactory::produceGenericObjects() {
+#if OBSW_ADD_CORE_COMPONENTS == 1
+  /* Framework objects */
+  new EventManager(objects::EVENT_MANAGER);
+  new HealthTable(objects::HEALTH_TABLE);
+  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+  new TimeStamper(objects::TIME_STAMPER);
+  auto *ccsdsDistrib =
+      new CCSDSDistributor(apid::APID, objects::CCSDS_DISTRIBUTOR);
+  new PUSDistributor(apid::APID, objects::PUS_DISTRIBUTOR,
+                     objects::CCSDS_DISTRIBUTOR);
+  new TmFunnel(objects::TM_FUNNEL);
+#endif /* OBSW_ADD_CORE_COMPONENTS == 1 */
+
+  /* PUS stack */
+#if OBSW_ADD_PUS_STACK == 1
+  new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION,
+                                      apid::APID, pus::PUS_SERVICE_1,
+                                      objects::TM_FUNNEL, 5);
+  new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, apid::APID,
+                           pus::PUS_SERVICE_2, 3, 10);
+  new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::APID,
+                           pus::PUS_SERVICE_3);
+  new Service5EventReporting(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::APID,
+                             pus::PUS_SERVICE_5, 50);
+  new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT,
+                                 apid::APID, pus::PUS_SERVICE_8, 3, 10);
+  new Service9TimeManagement(objects::PUS_SERVICE_9_TIME_MGMT, apid::APID,
+                             pus::PUS_SERVICE_9);
+  new Service17Test(objects::PUS_SERVICE_17_TEST, apid::APID,
+                    pus::PUS_SERVICE_17);
+  new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS,
+                                   apid::APID, pus::PUS_SERVICE_20);
+  new Service11TelecommandScheduling<cfg::OBSW_MAX_SCHEDULED_TCS>(
+      objects::PUS_SERVICE_11_TC_SCHEDULER, apid::APID, pus::PUS_SERVICE_11,
+      ccsdsDistrib);
+  new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, apid::APID,
+                                pus::PUS_SERVICE_200);
+#endif /* OBSW_ADD_PUS_STACK == 1 */
+
+#if OBSW_ADD_TASK_EXAMPLE == 1
+  /* Demo objects */
+  new FsfwExampleTask(objects::TEST_DUMMY_1);
+  new FsfwExampleTask(objects::TEST_DUMMY_2);
+  new FsfwExampleTask(objects::TEST_DUMMY_3);
+
+  bool enablePrintout = false;
+#if OBSW_TASK_EXAMPLE_PRINTOUT == 1
+  enablePrintout = true;
+#endif
+  new FsfwReaderTask(objects::TEST_DUMMY_4, enablePrintout);
+#endif /* OBSW_ADD_TASK_EXAMPLE == 1 */
+
+#if OBSW_ADD_DEVICE_HANDLER_DEMO == 1
+
+#if OBSW_DEVICE_HANDLER_PRINTOUT == 1
+  bool enableInfoPrintout = true;
+#else
+  bool enableInfoPrintout = false;
+#endif /* OBSW_DEVICE_HANDLER_PRINTOUT == 1 */
+
+  /* Demo device handler object */
+  size_t expectedMaxReplyLen = 64;
+  CookieIF *testCookie =
+      new TestCookie(static_cast<address_t>(testdevice::DeviceIndex::DEVICE_0),
+                     expectedMaxReplyLen);
+  new TestEchoComIF(objects::TEST_ECHO_COM_IF);
+  new TestDevice(objects::TEST_DEVICE_HANDLER_0, objects::TEST_ECHO_COM_IF,
+                 testCookie, testdevice::DeviceIndex::DEVICE_0,
+                 enableInfoPrintout);
+  testCookie =
+      new TestCookie(static_cast<address_t>(testdevice::DeviceIndex::DEVICE_1),
+                     expectedMaxReplyLen);
+  new TestDevice(objects::TEST_DEVICE_HANDLER_1, objects::TEST_ECHO_COM_IF,
+                 testCookie, testdevice::DeviceIndex::DEVICE_1,
+                 enableInfoPrintout);
+
+  new TestAssembly(objects::TEST_ASSEMBLY, objects::NO_OBJECT,
+                   objects::TEST_DEVICE_HANDLER_0,
+                   objects::TEST_DEVICE_HANDLER_1);
+
+#endif /* OBSW_ADD_DEVICE_HANDLER_DEMO == 1 */
+
+  /* Demo controller object */
+#if OBSW_ADD_CONTROLLER_DEMO == 1
+
+#if OBSW_CONTROLLER_PRINTOUT == 1
+#endif
+  new TestController(objects::TEST_CONTROLLER, objects::NO_OBJECT);
+
+#endif /* OBSW_ADD_CONTROLLER_DEMO == 1 */
+
+#if OBSW_PERFORM_INTERNAL_UNITTEST == 1
+  InternalUnitTester::TestConfig testCfg;
+  testCfg.testArrayPrinter = false;
+#if defined FSFW_OSAL_HOST
+  // Not implemented yet for hosted OSAL (requires C++20)
+  testCfg.testSemaphores = false;
+#endif
+  InternalUnitTester unittester;
+  unittester.performTests(testCfg);
+#endif /* OBSW_PERFORM_INTERNAL_UNITTEST == 1 */
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+  MonitoringReportContent<float>::timeStamperId = objects::TIME_STAMPER;
+  MonitoringReportContent<double>::timeStamperId = objects::TIME_STAMPER;
+  MonitoringReportContent<uint32_t>::timeStamperId = objects::TIME_STAMPER;
+  MonitoringReportContent<int32_t>::timeStamperId = objects::TIME_STAMPER;
+  MonitoringReportContent<int16_t>::timeStamperId = objects::TIME_STAMPER;
+  MonitoringReportContent<uint16_t>::timeStamperId = objects::TIME_STAMPER;
+
+  TmFunnel::downlinkDestination = objects::DOWNLINK_DESTINATION;
+  // No storage object for now.
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+
+  PusServiceBase::packetSource = objects::PUS_DISTRIBUTOR;
+  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}

example/core/GenericFactory.h

@@ -11,7 +11,6 @@ namespace ObjectFactory {
  */
 void produceGenericObjects();
 
-}
-
+} // namespace ObjectFactory
 
 #endif /* MISSION_CORE_GENERICFACTORY_H_ */

example/devices/CMakeLists.txt

@@ -0,0 +1 @@
+

example/devices/TestDeviceHandler.h

@@ -0,0 +1,10 @@
+#ifndef EXAMPLE_COMMON_DEVICES_TESTDEVICEHANDLER_H_
+#define EXAMPLE_COMMON_DEVICES_TESTDEVICEHANDLER_H_
+
+//#include "fsfw_tests/integration/TestDeviceHandler.h"
+//
+// class FsfwTestDeviceHandler: public TestDeviceHandler {
+//
+//};
+
+#endif /* EXAMPLE_COMMON_DEVICES_TESTDEVICEHANDLER_H_ */

example/test/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(${TARGET_NAME} PRIVATE FsfwReaderTask.cpp FsfwExampleTask.cpp
+                                      MutexExample.cpp FsfwTestTask.cpp)
+
+if(FSFW_ADD_FMT_TESTS)
+  target_sources(${TARGET_NAME} PRIVATE testFmt.cpp)
+endif()

example/test/FsfwExampleTask.cpp

@@ -0,0 +1,275 @@
+#include "FsfwExampleTask.h"
+
+#include <fsfw/ipc/CommandMessage.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/TaskFactory.h>
+
+#include "OBSWConfig.h"
+#include "commonObjects.h"
+#include "objects/systemObjectList.h"
+
+FsfwExampleTask::FsfwExampleTask(object_id_t objectId)
+    : SystemObject(objectId), poolManager(this, nullptr), demoSet(this),
+      monitor(objectId, MONITOR_ID,
+              gp_id_t(objectId, FsfwDemoSet::VARIABLE_LIMIT), 30, 10) {
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      10, CommandMessage::MAX_MESSAGE_SIZE);
+}
+
+FsfwExampleTask::~FsfwExampleTask() {}
+
+ReturnValue_t FsfwExampleTask::performOperation(uint8_t operationCode) {
+  if (operationCode == OpCodes::DELAY_SHORT) {
+    TaskFactory::delayTask(5);
+  }
+
+  // TODO: Move this to new test controller?
+  ReturnValue_t result = performMonitoringDemo();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+
+  if (operationCode == OpCodes::SEND_RAND_NUM) {
+    result = performSendOperation();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+
+  if (operationCode == OpCodes::RECEIVE_RAND_NUM) {
+    result = performReceiveOperation();
+  }
+
+  return 0;
+}
+
+object_id_t FsfwExampleTask::getNextRecipient() {
+  switch (this->getObjectId()) {
+  case (objects::TEST_DUMMY_1): {
+    return objects::TEST_DUMMY_2;
+  }
+  case (objects::TEST_DUMMY_2): {
+    return objects::TEST_DUMMY_3;
+  }
+  case (objects::TEST_DUMMY_3): {
+    return objects::TEST_DUMMY_1;
+  }
+  default:
+    return objects::TEST_DUMMY_1;
+  }
+}
+
+object_id_t FsfwExampleTask::getSender() {
+  switch (this->getObjectId()) {
+  case (objects::TEST_DUMMY_1): {
+    return objects::TEST_DUMMY_3;
+  }
+  case (objects::TEST_DUMMY_2): {
+    return objects::TEST_DUMMY_1;
+  }
+  case (objects::TEST_DUMMY_3): {
+    return objects::TEST_DUMMY_2;
+  }
+  default:
+    return objects::TEST_DUMMY_1;
+  }
+}
+
+ReturnValue_t FsfwExampleTask::initialize() {
+  // Get the dataset of the sender. Will be cached for later checks.
+  object_id_t sender = getSender();
+  HasLocalDataPoolIF *senderIF =
+      ObjectManager::instance()->get<HasLocalDataPoolIF>(sender);
+  if (senderIF == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "FsfwDemoTask::initialize: Sender object invalid!"
+               << std::endl;
+#else
+    sif::printError("FsfwDemoTask::initialize: Sender object invalid!\n");
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  // we need a private copy of the previous dataset.. or we use the shared
+  // dataset.
+  senderSet = new FsfwDemoSet(senderIF);
+  if (senderSet == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "FsfwDemoTask::initialize: Sender dataset invalid!"
+               << std::endl;
+#else
+    sif::printError("FsfwDemoTask::initialize: Sender dataset invalid!\n");
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return poolManager.initialize(commandQueue);
+}
+
+ReturnValue_t FsfwExampleTask::initializeAfterTaskCreation() {
+  return poolManager.initializeAfterTaskCreation();
+}
+
+object_id_t FsfwExampleTask::getObjectId() const {
+  return SystemObject::getObjectId();
+}
+
+MessageQueueId_t FsfwExampleTask::getMessageQueueId() {
+  return commandQueue->getId();
+}
+
+void FsfwExampleTask::setTaskIF(PeriodicTaskIF *task) { this->task = task; }
+
+LocalPoolDataSetBase *FsfwExampleTask::getDataSetHandle(sid_t sid) {
+  return &demoSet;
+}
+
+uint32_t FsfwExampleTask::getPeriodicOperationFrequency() const {
+  return task->getPeriodMs();
+}
+
+ReturnValue_t
+FsfwExampleTask::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                         LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE,
+                           new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE_LIMIT,
+                           new PoolEntry<uint16_t>({0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FsfwExampleTask::performMonitoringDemo() {
+  ReturnValue_t result =
+      demoSet.variableLimit.read(MutexIF::TimeoutType::WAITING, 20);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    /* Configuration error */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DummyObject::performOperation: Could not read variableLimit!"
+               << std::endl;
+#else
+    sif::printError(
+        "DummyObject::performOperation: Could not read variableLimit!\n");
+#endif
+    return result;
+  }
+  if (this->getObjectId() == objects::TEST_DUMMY_5) {
+    if (demoSet.variableLimit.value > 20) {
+      demoSet.variableLimit.value = 0;
+    }
+    demoSet.variableLimit.value++;
+    demoSet.variableLimit.commit(20);
+    monitor.check();
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FsfwExampleTask::performSendOperation() {
+  object_id_t nextRecipient = getNextRecipient();
+  FsfwExampleTask *target =
+      ObjectManager::instance()->get<FsfwExampleTask>(nextRecipient);
+  if (target == nullptr) {
+    /* Configuration error */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error
+        << "DummyObject::performOperation: Next recipient does not exist!"
+        << std::endl;
+#else
+    sif::printError(
+        "DummyObject::performOperation: Next recipient does not exist!\n");
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  uint32_t randomNumber = rand() % 100;
+  CommandMessage message;
+  message.setParameter(randomNumber);
+  message.setParameter2(this->getMessageQueueId());
+
+  /* Send message using own message queue */
+  ReturnValue_t result =
+      commandQueue->sendMessage(target->getMessageQueueId(), &message);
+  if (result != HasReturnvaluesIF::RETURN_OK &&
+      result != MessageQueueIF::FULL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "FsfwDemoTask::performSendOperation: Send failed with "
+               << result << std::endl;
+#else
+    sif::printError(
+        "FsfwDemoTask::performSendOperation: Send failed with %hu\n", result);
+#endif
+  }
+
+  /* Send message without via MessageQueueSenderIF */
+  result = MessageQueueSenderIF::sendMessage(target->getMessageQueueId(),
+                                             &message, commandQueue->getId());
+  if (result != HasReturnvaluesIF::RETURN_OK &&
+      result != MessageQueueIF::FULL) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "FsfwDemoTask::performSendOperation: Send failed with "
+               << result << std::endl;
+#else
+    sif::printError(
+        "FsfwDemoTask::performSendOperation: Send failed with %hu\n", result);
+#endif
+  }
+
+  demoSet.variableWrite.value = randomNumber;
+  result = demoSet.variableWrite.commit(20);
+
+  return result;
+}
+
+ReturnValue_t FsfwExampleTask::performReceiveOperation() {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  while (result != MessageQueueIF::EMPTY) {
+    CommandMessage receivedMessage;
+    result = commandQueue->receiveMessage(&receivedMessage);
+    if (result != HasReturnvaluesIF::RETURN_OK &&
+        result != MessageQueueIF::EMPTY) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::debug << "Receive failed with " << result << std::endl;
+#endif
+      break;
+    }
+    if (result != MessageQueueIF::EMPTY) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if OBSW_VERBOSE_LEVEL >= 2
+      sif::debug << "Message Received by " << getObjectId() << " from Queue "
+                 << receivedMessage.getSender() << " ObjectId "
+                 << receivedMessage.getParameter() << " Queue "
+                 << receivedMessage.getParameter2() << std::endl;
+#endif
+#endif
+
+      if (senderSet == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+      }
+
+      result = senderSet->variableRead.read(MutexIF::TimeoutType::WAITING, 20);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      if (senderSet->variableRead.value != receivedMessage.getParameter()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "FsfwDemoTask::performReceiveOperation: Variable "
+                   << std::hex << "0x"
+                   << senderSet->variableRead.getDataPoolId() << std::dec
+                   << " has wrong value." << std::endl;
+        sif::error << "Value: " << demoSet.variableRead.value
+                   << ", expected: " << receivedMessage.getParameter()
+                   << std::endl;
+#endif
+      }
+    }
+  }
+  return result;
+}
+
+MessageQueueId_t FsfwExampleTask::getCommandQueue() const {
+  return commandQueue->getId();
+}
+
+LocalDataPoolManager *FsfwExampleTask::getHkManagerHandle() {
+  return &poolManager;
+}

example/test/FsfwExampleTask.h

@@ -0,0 +1,108 @@
+#ifndef MISSION_DEMO_FSFWDEMOTASK_H_
+#define MISSION_DEMO_FSFWDEMOTASK_H_
+
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/monitoring/AbsLimitMonitor.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+
+#include "testdefinitions/demoDefinitions.h"
+
+class PeriodicTaskIF;
+
+/**
+ * @brief 	This demo set shows the local data pool functionality and fixed
+ * 			timeslot capabilities of the FSFW.
+ *
+ * @details
+ * There will be multiple demo objects. Each demo object will generate a random
+ * number and send that number via message queues to the next demo object
+ * (e.g. DUMMY_1 sends the number to DUMMY_2 etc.). The receiving object
+ * will check the received value against the sent value by extracting the sent
+ * value directly from the sender via the local data pool interface.
+ * If the timing is set up correctly, the values will always be the same.
+ */
+class FsfwExampleTask : public ExecutableObjectIF,
+                        public SystemObject,
+                        public HasLocalDataPoolIF {
+public:
+  enum OpCodes { SEND_RAND_NUM, RECEIVE_RAND_NUM, DELAY_SHORT };
+
+  static constexpr uint8_t MONITOR_ID = 2;
+
+  /**
+   * @brief 	Simple constructor, only expects object ID.
+   * @param objectId
+   */
+  FsfwExampleTask(object_id_t objectId);
+
+  virtual ~FsfwExampleTask();
+
+  /**
+   * @brief	The performOperation method is executed in a task.
+   * @details	There are no restrictions for calls within this method, so any
+   * 			other member of the class can be used.
+   * @return	Currently, the return value is ignored.
+   */
+  virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+  /**
+   * @brief 	This function will be called by the global object manager
+   * @details
+   * This function will always be called before any tasks are started.
+   * It can also be used to return error codes in the software initialization
+   * process cleanly.
+   * @return
+   */
+  virtual ReturnValue_t initialize() override;
+
+  /**
+   * @brief 	This function will be called by the OSAL task handlers
+   * @details
+   * This function will be called before the first #performOperation
+   * call after the tasks have been started. It can be used if some
+   * initialization process requires task specific properties like
+   * periodic intervals (by using the PeriodicTaskIF* handle).
+   * @return
+   */
+  virtual ReturnValue_t initializeAfterTaskCreation() override;
+
+  /**
+   * This function will be called by the OSAL task handler. The
+   * task interface handle can be cached to access task specific properties.
+   * @param task
+   */
+  void setTaskIF(PeriodicTaskIF *task) override;
+
+  object_id_t getObjectId() const override;
+
+  MessageQueueId_t getMessageQueueId();
+
+private:
+  LocalDataPoolManager poolManager;
+  FsfwDemoSet *senderSet = nullptr;
+  FsfwDemoSet demoSet;
+  AbsLimitMonitor<int32_t> monitor;
+  PeriodicTaskIF *task = nullptr;
+  MessageQueueIF *commandQueue = nullptr;
+
+  /* HasLocalDatapoolIF overrides */
+  MessageQueueId_t getCommandQueue() const override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
+  uint32_t getPeriodicOperationFrequency() const override;
+  ReturnValue_t
+  initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                          LocalDataPoolManager &poolManager) override;
+  LocalDataPoolManager *getHkManagerHandle() override;
+
+  object_id_t getNextRecipient();
+  object_id_t getSender();
+
+  ReturnValue_t performMonitoringDemo();
+  ReturnValue_t performSendOperation();
+  ReturnValue_t performReceiveOperation();
+};
+
+#endif /* MISSION_DEMO_FSFWDEMOTASK_H_ */

example/test/FsfwReaderTask.cpp

@@ -0,0 +1,56 @@
+#include "FsfwReaderTask.h"
+
+#include <OBSWConfig.h>
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+
+FsfwReaderTask::FsfwReaderTask(object_id_t objectId, bool enablePrintout)
+    : SystemObject(objectId), printoutEnabled(enablePrintout), opDivider(10),
+      readSet(this->getObjectId(),
+              gp_id_t(objects::TEST_DUMMY_1, FsfwDemoSet::PoolIds::VARIABLE),
+              gp_id_t(objects::TEST_DUMMY_2, FsfwDemoSet::PoolIds::VARIABLE),
+              gp_id_t(objects::TEST_DUMMY_3, FsfwDemoSet::PoolIds::VARIABLE)) {
+  /* Special protection for set reading because each variable is read from a
+   * different pool */
+  readSet.setReadCommitProtectionBehaviour(true);
+}
+
+FsfwReaderTask::~FsfwReaderTask() {}
+
+ReturnValue_t FsfwReaderTask::initializeAfterTaskCreation() {
+  /* Give other task some time to set up local data pools. */
+  TaskFactory::delayTask(20);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t FsfwReaderTask::performOperation(uint8_t operationCode) {
+  PoolReadGuard readHelper(&readSet);
+
+  uint32_t variable1 = readSet.variable1.value;
+  uint32_t variable2 = readSet.variable2.value;
+  uint32_t variable3 = readSet.variable3.value;
+
+#if OBSW_VERBOSE_LEVEL >= 1
+  if (opDivider.checkAndIncrement() and printoutEnabled) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "FsfwPeriodicTask::performOperation: Reading variables."
+              << std::endl;
+    sif::info << "Variable read from demo object 1: " << variable1 << std::endl;
+    sif::info << "Variable read from demo object 2: " << variable2 << std::endl;
+    sif::info << "Variable read from demo object 3: " << variable3 << std::endl;
+#else
+    sif::printInfo(
+        "FsfwPeriodicTask::performOperation: Reading variables.\n\r");
+    sif::printInfo("Variable read from demo object 1: %d\n\r", variable1);
+    sif::printInfo("Variable read from demo object 2: %d\n\r", variable2);
+    sif::printInfo("Variable read from demo object 3: %d\n\r", variable3);
+#endif
+  }
+#else
+  if (variable1 and variable2 and variable3) {
+  };
+#endif
+  return HasReturnvaluesIF::RETURN_OK;
+}

example/test/FsfwReaderTask.h

@@ -0,0 +1,24 @@
+#ifndef MISSION_DEMO_FSFWPERIODICTASK_H_
+#define MISSION_DEMO_FSFWPERIODICTASK_H_
+
+#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+
+#include "testdefinitions/demoDefinitions.h"
+
+class FsfwReaderTask : public ExecutableObjectIF, public SystemObject {
+public:
+  FsfwReaderTask(object_id_t objectId, bool enablePrintout);
+  ~FsfwReaderTask() override;
+
+  ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+private:
+  bool printoutEnabled = false;
+  PeriodicOperationDivider opDivider;
+  CompleteDemoReadSet readSet;
+};
+
+#endif /* MISSION_DEMO_FSFWPERIODICTASK_H_ */

example/test/FsfwTestTask.cpp

@@ -0,0 +1,21 @@
+#include "FsfwTestTask.h"
+
+#include <commonConfig.h>
+
+#if FSFW_ADD_FMT_TESTS == 1
+#include "testFmt.h"
+#endif
+
+FsfwTestTask::FsfwTestTask(object_id_t objectId, bool periodicEvent)
+    : TestTask(objectId), periodicEvent(periodicEvent) {
+#if FSFW_ADD_FMT_TESTS == 1
+  fmtTests();
+#endif
+}
+
+ReturnValue_t FsfwTestTask::performPeriodicAction() {
+  if (periodicEvent) {
+    triggerEvent(TEST_EVENT, 0x1234, 0x4321);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}

example/test/FsfwTestTask.h

@@ -0,0 +1,21 @@
+#ifndef EXAMPLE_COMMON_EXAMPLE_TEST_FSFWTESTTASK_H_
+#define EXAMPLE_COMMON_EXAMPLE_TEST_FSFWTESTTASK_H_
+
+#include "events/subsystemIdRanges.h"
+#include "fsfw/events/Event.h"
+#include "fsfw_tests/integration/task/TestTask.h"
+
+class FsfwTestTask : public TestTask {
+public:
+  FsfwTestTask(object_id_t objectId, bool periodicEvent);
+
+  ReturnValue_t performPeriodicAction() override;
+
+private:
+  bool periodicEvent = false;
+  static constexpr uint8_t subsystemId = SUBSYSTEM_ID::TEST_TASK_ID;
+  static constexpr Event TEST_EVENT =
+      event::makeEvent(subsystemId, 0, severity::INFO);
+};
+
+#endif /* EXAMPLE_COMMON_EXAMPLE_TEST_FSFWTESTTASK_H_ */

example/test/MutexExample.cpp

@@ -0,0 +1,50 @@
+#include "MutexExample.h"
+
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+void MutexExample::example() {
+  MutexIF *mutex = MutexFactory::instance()->createMutex();
+  MutexIF *mutex2 = MutexFactory::instance()->createMutex();
+
+  ReturnValue_t result =
+      mutex->lockMutex(MutexIF::TimeoutType::WAITING, 2 * 60 * 1000);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "MutexExample::example: Lock Failed with " << result
+               << std::endl;
+#else
+    sif::printError("MutexExample::example: Lock Failed with %hu\n", result);
+#endif
+  }
+
+  result = mutex2->lockMutex(MutexIF::TimeoutType::BLOCKING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "MutexExample::example: Lock Failed with " << result
+               << std::endl;
+#else
+    sif::printError("MutexExample::example: Lock Failed with %hu\n", result);
+#endif
+  }
+
+  result = mutex->unlockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "MutexExample::example: Unlock Failed with " << result
+               << std::endl;
+#else
+    sif::printError("MutexExample::example: Unlock Failed with %hu\n", result);
+#endif
+  }
+
+  result = mutex2->unlockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "MutexExample::example: Unlock Failed with " << result
+               << std::endl;
+#else
+    sif::printError("MutexExample::example: Unlock Failed with %hu\n", result);
+#endif
+  }
+}

example/test/MutexExample.h

@@ -0,0 +1,8 @@
+#ifndef EXAMPLE_COMMON_MUTEXEXAMPLE_H_
+#define EXAMPLE_COMMON_MUTEXEXAMPLE_H_
+
+namespace MutexExample {
+void example();
+};
+
+#endif /* EXAMPLE_COMMON_MUTEXEXAMPLE_H_ */

example/test/testFmt.cpp

@@ -0,0 +1,14 @@
+#include "testFmt.h"
+
+void fmtTests() {
+  sif::fdebug(__FILENAME__, __LINE__, "Hello {} {}", "World\n");
+  sif::fdebug_t(__FILENAME__, __LINE__, "Hallo\n");
+  FSFW_LOGD("{}", "Hallo\n");
+  // MY_LOG("{}", "test\n");
+  // sif::finfo_t("Hallo\n");
+  // sif::finfo("Hallo\n");
+  // sif::fwarning("Hello\n");
+  // sif::fwarning_t("Hello\n");
+  // sif::ferror("Hello\n");
+  // sif::ferror_t("Hello\n");
+}

example/test/testFmt.h

@@ -0,0 +1,183 @@
+#ifndef FSFW_EXAMPLE_HOSTED_TESTFMT_H
+#define FSFW_EXAMPLE_HOSTED_TESTFMT_H
+
+#include <fmt/chrono.h>
+#include <fmt/color.h>
+#include <fmt/compile.h>
+#include <fmt/core.h>
+
+#include <array>
+#include <cstdint>
+
+#include "fsfw/ipc/MutexFactory.h"
+#include "fsfw/ipc/MutexGuard.h"
+#include "fsfw/ipc/MutexIF.h"
+#include "fsfw/timemanager/Clock.h"
+
+#define __FILENAME_REL__ (((const char *)__FILE__ + SOURCE_PATH_SIZE))
+#define __FILENAME__                                                           \
+  (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+
+void fmtTests();
+
+namespace sif {
+
+static std::array<char, 524> PRINT_BUF = {};
+
+static const char INFO_PREFIX[] = "INFO";
+static const char DEBUG_PREFIX[] = "DEBUG";
+static const char WARNING_PREFIX[] = "WARNING";
+static const char ERROR_PREFIX[] = "ERROR";
+
+enum class LogLevel : unsigned int {
+  DEBUG = 0,
+  INFO = 1,
+  WARNING = 2,
+  ERROR = 3
+};
+
+static const char *PREFIX_ARR[4] = {DEBUG_PREFIX, INFO_PREFIX, WARNING_PREFIX,
+                                    ERROR_PREFIX};
+
+static const std::array<fmt::color, 4> LOG_COLOR_ARR = {
+    fmt::color::deep_sky_blue, fmt::color::forest_green, fmt::color::orange_red,
+    fmt::color::red};
+
+static MutexIF *PRINT_MUTEX = MutexFactory::instance()->createMutex();
+
+static size_t writeTypePrefix(LogLevel level) {
+  auto idx = static_cast<unsigned int>(level);
+  const auto result = fmt::format_to_n(
+      PRINT_BUF.begin(), PRINT_BUF.size() - 1,
+      fmt::runtime(fmt::format(fg(LOG_COLOR_ARR[idx]), PREFIX_ARR[idx])));
+  return result.size;
+}
+
+template <typename... T>
+size_t logTraced(LogLevel level, const char *file, unsigned int line,
+                 bool timed, fmt::format_string<T...> fmt,
+                 T &&...args) noexcept {
+  try {
+    MutexGuard mg(PRINT_MUTEX);
+    size_t bufPos = writeTypePrefix(level);
+    auto currentIter = PRINT_BUF.begin() + bufPos;
+    if (timed) {
+      Clock::TimeOfDay_t logTime;
+      Clock::getDateAndTime(&logTime);
+      const auto result =
+          fmt::format_to_n(currentIter, PRINT_BUF.size() - 1 - bufPos,
+                           " | {}[l.{}] | {:02}:{:02}:{:02}.{:03} | {}", file,
+                           line, logTime.hour, logTime.minute, logTime.second,
+                           logTime.usecond / 1000, fmt::format(fmt, args...));
+      *result.out = '\0';
+      bufPos += result.size;
+    } else {
+      const auto result = fmt::format_to_n(
+          currentIter, PRINT_BUF.size() - 1 - bufPos, " | {}[l.{}] | {}", file,
+          line, fmt::format(fmt, args...));
+      *result.out = '\0';
+      bufPos += result.size;
+    }
+
+    fmt::print(fmt::runtime(PRINT_BUF.data()));
+    return bufPos;
+  } catch (const fmt::v8::format_error &e) {
+    fmt::print("Printing failed with error: {}\n", e.what());
+    return 0;
+  }
+}
+
+template <typename... T>
+size_t log(LogLevel level, bool timed, fmt::format_string<T...> fmt,
+           T &&...args) noexcept {
+  try {
+    MutexGuard mg(PRINT_MUTEX);
+    size_t bufPos = writeTypePrefix(level);
+    auto currentIter = PRINT_BUF.begin() + bufPos;
+    if (timed) {
+      Clock::TimeOfDay_t logTime;
+      Clock::getDateAndTime(&logTime);
+      const auto result = fmt::format_to_n(
+          currentIter, PRINT_BUF.size() - bufPos,
+          " | {:02}:{:02}:{:02}.{:03} | {}", logTime.hour, logTime.minute,
+          logTime.second, logTime.usecond / 1000, fmt::format(fmt, args...));
+      bufPos += result.size;
+    }
+    fmt::print(fmt::runtime(PRINT_BUF.data()));
+    return bufPos;
+  } catch (const fmt::v8::format_error &e) {
+    fmt::print("Printing failed with error: {}\n", e.what());
+    return 0;
+  }
+}
+
+template <typename... T>
+void fdebug(const char *file, unsigned int line, fmt::format_string<T...> fmt,
+            T &&...args) noexcept {
+  logTraced(LogLevel::DEBUG, file, line, false, fmt, args...);
+}
+
+template <typename... T>
+void fdebug_t(const char *file, unsigned int line, fmt::format_string<T...> fmt,
+              T &&...args) noexcept {
+  logTraced(LogLevel::DEBUG, file, line, true, fmt, args...);
+}
+
+template <typename... T>
+void finfo_t(fmt::format_string<T...> fmt, T &&...args) {
+  log(LogLevel::INFO, true, fmt, args...);
+}
+
+template <typename... T> void finfo(fmt::format_string<T...> fmt, T &&...args) {
+  log(LogLevel::INFO, false, fmt, args...);
+}
+
+template <typename... T>
+void fwarning(const char *file, unsigned int line, fmt::format_string<T...> fmt,
+              T &&...args) {
+  logTraced(LogLevel::WARNING, file, line, false, fmt, args...);
+}
+
+template <typename... T>
+void fwarning_t(const char *file, unsigned int line,
+                fmt::format_string<T...> fmt, T &&...args) {
+  logTraced(LogLevel::WARNING, file, line, true, fmt, args...);
+}
+
+template <typename... T>
+void ferror(const char *file, unsigned int line, fmt::format_string<T...> fmt,
+            T &&...args) {
+  logTraced(LogLevel::ERROR, file, line, false, fmt, args...);
+}
+
+template <typename... T>
+void ferror_t(const char *file, unsigned int line, fmt::format_string<T...> fmt,
+              T &&...args) {
+  logTraced(LogLevel::ERROR, file, line, true, fmt, args...);
+}
+
+} // namespace sif
+
+#define FSFW_LOGI(format, ...) finfo(FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGIT(format, ...) finfo_t(FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGD(format, ...)                                                 \
+  sif::fdebug(__FILENAME__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGDT(format, ...)                                                \
+  fdebug_t(__FILENAME__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGW(format, ...)                                                 \
+  fdebug(__FILENAME__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGWT(format, ...)                                                \
+  fdebug_t(__FILENAME__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGE(format, ...)                                                 \
+  fdebug(__FILENAME__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+#define FSFW_LOGET(format, ...)                                                \
+  fdebug_t(__FILENAME__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+#endif // FSFW_EXAMPLE_HOSTED_TESTFMT_H

example/test/testdefinitions/demoDefinitions.h

@@ -0,0 +1,56 @@
+#ifndef MISSION_DEMO_DEMODEFINITIONS_H_
+#define MISSION_DEMO_DEMODEFINITIONS_H_
+
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+
+/**
+ * @brief 	This demo set showcases the local data pool functionality of the
+ * 			FSFW
+ * @details
+ * Each demo object will have an own instance of this set class, which contains
+ * pool variables (for read and write access respectively).
+ */
+class FsfwDemoSet : public StaticLocalDataSet<3> {
+public:
+  static constexpr uint32_t DEMO_SET_ID = 0;
+
+  enum PoolIds { VARIABLE, VARIABLE_LIMIT };
+
+  FsfwDemoSet(HasLocalDataPoolIF *hkOwner)
+      : StaticLocalDataSet(hkOwner, DEMO_SET_ID) {}
+
+  lp_var_t<uint32_t> variableRead = lp_var_t<uint32_t>(
+      sid.objectId, PoolIds::VARIABLE, this, pool_rwm_t::VAR_READ);
+  lp_var_t<uint32_t> variableWrite = lp_var_t<uint32_t>(
+      sid.objectId, PoolIds::VARIABLE, this, pool_rwm_t::VAR_WRITE);
+  lp_var_t<uint16_t> variableLimit =
+      lp_var_t<uint16_t>(sid.objectId, PoolIds::VARIABLE_LIMIT, this);
+
+private:
+};
+
+/**
+ * This set will enable object to read the dummy variables from the dataset
+ * above. An example application would be a consumer object like a controller
+ * which reads multiple sensor values at once.
+ */
+class CompleteDemoReadSet : public StaticLocalDataSet<3> {
+public:
+  static constexpr uint32_t DEMO_SET_ID = 0;
+
+  CompleteDemoReadSet(object_id_t owner, gp_id_t variable1, gp_id_t variable2,
+                      gp_id_t variable3)
+      : StaticLocalDataSet(sid_t(owner, DEMO_SET_ID)),
+        variable1(variable1, this, pool_rwm_t::VAR_READ),
+        variable2(variable2, this, pool_rwm_t::VAR_READ),
+        variable3(variable3, this, pool_rwm_t::VAR_READ) {}
+
+  lp_var_t<uint32_t> variable1;
+  lp_var_t<uint32_t> variable2;
+  lp_var_t<uint32_t> variable3;
+
+private:
+};
+
+#endif /* MISSION_DEMO_DEMODEFINITIONS_H_ */

example/utility/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${TARGET_NAME} PRIVATE utility.cpp TmFunnel.cpp)

example/utility/PusPacketCreator.cpp

@@ -1,10 +1,9 @@
-#include <fsfw/tmtcpacket/pus/tc.h>
-#include <fsfw/tmtcpacket/pus/tm.h>
 #include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tmtcpacket/pus/tc.h>
+#include <fsfw/tmtcpacket/pus/tm.h>
 #include <mission/utility/PusPacketCreator.h>
 
 void PusPacketCreator::createPusPacketAndPrint() {
-	// TODO: use TC packet stored here instead..
-
+  // TODO: use TC packet stored here instead..
 }

example/utility/PusPacketCreator.h

@@ -10,7 +10,7 @@
 
 class PusPacketCreator {
 public:
-	static void createPusPacketAndPrint();
+  static void createPusPacketAndPrint();
 };
 
 #endif /* MISSION_UTILITY_PUSPACKETCREATOR_H_ */

example/utility/TaskCreation.h

@@ -0,0 +1,22 @@
+#ifndef MISSION_UTILITY_TASKCREATION_H_
+#define MISSION_UTILITY_TASKCREATION_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+namespace task {
+
+void printInitError(const char *objName, object_id_t objectId) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::error << "InitMission: Adding object " << objName << "(" << std::setw(8)
+             << std::setfill('0') << std::hex << objectId << std::dec
+             << ") failed." << std::endl;
+#else
+  sif::printError("InitMission: Adding object %s (0x%08x) failed.\n", objName,
+                  static_cast<unsigned int>(objectId));
+#endif
+}
+
+} // namespace task
+
+#endif /* MISSION_UTILITY_TASKCREATION_H_ */

example/utility/TmFunnel.cpp

@@ -0,0 +1,122 @@
+#include "TmFunnel.h"
+
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tmtcpacket/pus/tm.h>
+
+object_id_t TmFunnel::downlinkDestination = objects::NO_OBJECT;
+object_id_t TmFunnel::storageDestination = objects::NO_OBJECT;
+
+TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth)
+    : SystemObject(objectId), messageDepth(messageDepth) {
+  tmQueue = QueueFactory::instance()->createMessageQueue(
+      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE);
+  storageQueue = QueueFactory::instance()->createMessageQueue(
+      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE);
+}
+
+TmFunnel::~TmFunnel() {}
+
+MessageQueueId_t TmFunnel::getReportReceptionQueue(uint8_t virtualChannel) {
+  return tmQueue->getId();
+}
+
+ReturnValue_t TmFunnel::performOperation(uint8_t operationCode) {
+  TmTcMessage currentMessage;
+  ReturnValue_t status = tmQueue->receiveMessage(&currentMessage);
+  while (status == HasReturnvaluesIF::RETURN_OK) {
+    status = handlePacket(&currentMessage);
+    if (status != HasReturnvaluesIF::RETURN_OK) {
+      break;
+    }
+    status = tmQueue->receiveMessage(&currentMessage);
+  }
+
+  if (status == MessageQueueIF::EMPTY) {
+    return HasReturnvaluesIF::RETURN_OK;
+  } else {
+    return status;
+  }
+}
+
+ReturnValue_t TmFunnel::handlePacket(TmTcMessage *message) {
+  uint8_t *packetData = nullptr;
+  size_t size = 0;
+  ReturnValue_t result =
+      tmPool->modifyData(message->getStorageId(), &packetData, &size);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  TmPacketPusC packet(packetData);
+  packet.setPacketSequenceCount(this->sourceSequenceCount);
+  sourceSequenceCount++;
+  sourceSequenceCount =
+      sourceSequenceCount % SpacePacketBase::LIMIT_SEQUENCE_COUNT;
+  packet.setErrorControl();
+
+  result = tmQueue->sendToDefault(message);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    tmPool->deleteData(message->getStorageId());
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TmFunnel::handlePacket: Error sending to downlink handler"
+               << std::endl;
+#endif
+    return result;
+  }
+
+  if (storageDestination != objects::NO_OBJECT) {
+    result = storageQueue->sendToDefault(message);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      tmPool->deleteData(message->getStorageId());
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "TmFunnel::handlePacket: Error sending to storage handler"
+                 << std::endl;
+#endif
+      return result;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t TmFunnel::initialize() {
+  tmPool = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+  if (tmPool == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TmFunnel::initialize: TM store not set." << std::endl;
+    sif::error << "Make sure the tm store is set up properly and implements "
+                  "StorageManagerIF"
+               << std::endl;
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+
+  AcceptsTelemetryIF *tmTarget =
+      ObjectManager::instance()->get<AcceptsTelemetryIF>(downlinkDestination);
+  if (tmTarget == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TmFunnel::initialize: Downlink Destination not set."
+               << std::endl;
+    sif::error << "Make sure the downlink destination object is set up "
+                  "properly and implements "
+                  "AcceptsTelemetryIF"
+               << std::endl;
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  tmQueue->setDefaultDestination(tmTarget->getReportReceptionQueue());
+
+  // Storage destination is optional.
+  if (storageDestination == objects::NO_OBJECT) {
+    return SystemObject::initialize();
+  }
+
+  AcceptsTelemetryIF *storageTarget =
+      ObjectManager::instance()->get<AcceptsTelemetryIF>(storageDestination);
+  if (storageTarget != nullptr) {
+    storageQueue->setDefaultDestination(
+        storageTarget->getReportReceptionQueue());
+  }
+
+  return SystemObject::initialize();
+}

example/utility/TmFunnel.h

@@ -0,0 +1,51 @@
+#ifndef MISSION_UTILITY_TMFUNNEL_H_
+#define MISSION_UTILITY_TMFUNNEL_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
+#include <fsfw/tmtcservices/TmTcMessage.h>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief       TM Recipient.
+ * @details
+ * Main telemetry receiver. All generated telemetry is funneled into
+ * this object.
+ * @ingroup     utility
+ * @author      J. Meier
+ */
+class TmFunnel : public AcceptsTelemetryIF,
+                 public ExecutableObjectIF,
+                 public SystemObject {
+  friend void(Factory::setStaticFrameworkObjectIds)();
+
+public:
+  TmFunnel(object_id_t objectId, uint32_t messageDepth = 20);
+  virtual ~TmFunnel();
+
+  virtual MessageQueueId_t
+  getReportReceptionQueue(uint8_t virtualChannel = 0) override;
+  virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+  virtual ReturnValue_t initialize() override;
+
+protected:
+  static object_id_t downlinkDestination;
+  static object_id_t storageDestination;
+
+private:
+  uint16_t sourceSequenceCount = 0;
+  MessageQueueIF *tmQueue = nullptr;
+  MessageQueueIF *storageQueue = nullptr;
+
+  StorageManagerIF *tmPool = nullptr;
+  uint32_t messageDepth = 0;
+
+  ReturnValue_t handlePacket(TmTcMessage *message);
+};
+
+#endif /* MISSION_UTILITY_TMFUNNEL_H_ */

example/utility/compile_time.h

@@ -0,0 +1,99 @@
+/*
+ *
+ * Created: 29.03.2018
+ *
+ * Authors:
+ *
+ * Assembled from the code released on Stackoverflow by:
+ *   Dennis (instructable.com/member/nqtronix)    |
+ * https://stackoverflow.com/questions/23032002/c-c-how-to-get-integer-unix-timestamp-of-build-time-not-string
+ * and
+ *   Alexis Wilke                                 |
+ * https://stackoverflow.com/questions/10538444/do-you-know-of-a-c-macro-to-compute-unix-time-and-date
+ *
+ * Assembled by Jean Rabault
+ *
+ * UNIX_TIMESTAMP gives the UNIX timestamp (unsigned long integer of seconds
+ * since 1st Jan 1970) of compilation from macros using the compiler defined
+ * __TIME__ macro. This should include Gregorian calendar leap days, in
+ * particular the 29ths of February, 100 and 400 years modulo leaps.
+ *
+ * Careful: __TIME__ is the local time of the computer, NOT the UTC time in
+ * general!
+ *
+ */
+
+#ifndef COMPILE_TIME_H_
+#define COMPILE_TIME_H_
+
+// Some definitions for calculation
+#define SEC_PER_MIN 60UL
+#define SEC_PER_HOUR 3600UL
+#define SEC_PER_DAY 86400UL
+#define SEC_PER_YEAR (SEC_PER_DAY * 365)
+
+// extracts 1..4 characters from a string and interprets it as a decimal value
+#define CONV_STR2DEC_1(str, i) (str[i] > '0' ? str[i] - '0' : 0)
+#define CONV_STR2DEC_2(str, i) (CONV_STR2DEC_1(str, i) * 10 + str[i + 1] - '0')
+#define CONV_STR2DEC_3(str, i) (CONV_STR2DEC_2(str, i) * 10 + str[i + 2] - '0')
+#define CONV_STR2DEC_4(str, i) (CONV_STR2DEC_3(str, i) * 10 + str[i + 3] - '0')
+
+// Custom "glue logic" to convert the month name to a usable number
+#define GET_MONTH(str, i)                                                      \
+  (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n'   ? 1               \
+   : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b' ? 2               \
+   : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r' ? 3               \
+   : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r' ? 4               \
+   : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y' ? 5               \
+   : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n' ? 6               \
+   : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l' ? 7               \
+   : str[i] == 'A' && str[i + 1] == 'u' && str[i + 2] == 'g' ? 8               \
+   : str[i] == 'S' && str[i + 1] == 'e' && str[i + 2] == 'p' ? 9               \
+   : str[i] == 'O' && str[i + 1] == 'c' && str[i + 2] == 't' ? 10              \
+   : str[i] == 'N' && str[i + 1] == 'o' && str[i + 2] == 'v' ? 11              \
+   : str[i] == 'D' && str[i + 1] == 'e' && str[i + 2] == 'c' ? 12              \
+                                                             : 0)
+
+// extract the information from the time string given by __TIME__ and __DATE__
+#define __TIME_SECONDS__ CONV_STR2DEC_2(__TIME__, 6)
+#define __TIME_MINUTES__ CONV_STR2DEC_2(__TIME__, 3)
+#define __TIME_HOURS__ CONV_STR2DEC_2(__TIME__, 0)
+#define __TIME_DAYS__ CONV_STR2DEC_2(__DATE__, 4)
+#define __TIME_MONTH__ GET_MONTH(__DATE__, 0)
+#define __TIME_YEARS__ CONV_STR2DEC_4(__DATE__, 7)
+
+// Days in February
+#define _UNIX_TIMESTAMP_FDAY(year)                                             \
+  (((year) % 400) == 0UL                                                       \
+       ? 29UL                                                                  \
+       : (((year) % 100) == 0UL ? 28UL : (((year) % 4) == 0UL ? 29UL : 28UL)))
+
+// Days in the year
+#define _UNIX_TIMESTAMP_YDAY(year, month, day)                                 \
+  (/* January */ day /* February */ + (month >= 2 ? 31UL : 0UL) /* March */ +  \
+   (month >= 3 ? _UNIX_TIMESTAMP_FDAY(year) : 0UL) /* April */ +               \
+   (month >= 4 ? 31UL : 0UL) /* May */ +                                       \
+   (month >= 5 ? 30UL : 0UL) /* June */ +                                      \
+   (month >= 6 ? 31UL : 0UL) /* July */ +                                      \
+   (month >= 7 ? 30UL : 0UL) /* August */ +                                    \
+   (month >= 8 ? 31UL : 0UL) /* September */ +                                 \
+   (month >= 9 ? 31UL : 0UL) /* October */ +                                   \
+   (month >= 10 ? 30UL : 0UL) /* November */ +                                 \
+   (month >= 11 ? 31UL : 0UL) /* December */ + (month >= 12 ? 30UL : 0UL))
+
+// get the UNIX timestamp from a digits representation
+#define _UNIX_TIMESTAMP(year, month, day, hour, minute, second)                \
+  (/* time */ second + minute * SEC_PER_MIN + hour * SEC_PER_HOUR +            \
+   /* year day (month + day) */ (_UNIX_TIMESTAMP_YDAY(year, month, day) - 1) * \
+       SEC_PER_DAY +                                                           \
+   /* year */ (year - 1970UL) * SEC_PER_YEAR +                                 \
+   ((year - 1969UL) / 4UL) * SEC_PER_DAY -                                     \
+   ((year - 1901UL) / 100UL) * SEC_PER_DAY +                                   \
+   ((year - 1601UL) / 400UL) * SEC_PER_DAY)
+
+// the UNIX timestamp
+#define UNIX_TIMESTAMP                                                         \
+  (_UNIX_TIMESTAMP(__TIME_YEARS__, __TIME_MONTH__, __TIME_DAYS__,              \
+                   __TIME_HOURS__, __TIME_MINUTES__, __TIME_SECONDS__))
+
+#endif

example/utility/utility.cpp

@@ -0,0 +1,24 @@
+#include "utility.h"
+
+#include <FSFWConfig.h>
+#include <OBSWVersion.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+void utility::commonInitPrint(const char *const os, const char *const board) {
+  if (os == nullptr or board == nullptr) {
+    return;
+  }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  std::cout << "-- FSFW Example (" << os << ") v" << FSFW_EXAMPLE_VERSION << "."
+            << FSFW_EXAMPLE_SUBVERSION << "." << FSFW_EXAMPLE_REVISION << " --"
+            << std::endl;
+  std::cout << "-- Compiled for " << board << " --" << std::endl;
+  std::cout << "-- Compiled on " << __DATE__ << " " << __TIME__ << " --"
+            << std::endl;
+#else
+  printf("\n\r-- FSFW Example (%s) v%d.%d.%d --\n", os, FSFW_EXAMPLE_VERSION,
+         FSFW_EXAMPLE_SUBVERSION, FSFW_EXAMPLE_REVISION);
+  printf("-- Compiled for %s --\n", board);
+  printf("-- Compiled on %s %s --\n", __DATE__, __TIME__);
+#endif
+}

example/utility/utility.h

@@ -3,9 +3,8 @@
 
 namespace utility {
 
-void commonInitPrint(const char *const os, const char* const board);
+void commonInitPrint(const char *const os, const char *const board);
 
 }
 
-
 #endif /* COMMON_UTILITY_UTILITY_H_ */

mission/assemblies/CMakeLists.txt

@@ -1,3 +0,0 @@
-target_sources(${TARGET_NAME} PRIVATE
-    TestAssembly.cpp
-)

mission/assemblies/TestAssembly.cpp

@@ -1,200 +0,0 @@
-#include "commonSystemObjects.h"
-
-#include <mission/assemblies/TestAssembly.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-
-
-TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId):
-        AssemblyBase(objectId, parentId) {
-	ModeListEntry newModeListEntry;
-	newModeListEntry.setObject(objects::TEST_DEVICE_HANDLER_0);
-	newModeListEntry.setMode(MODE_OFF);
-	newModeListEntry.setSubmode(SUBMODE_NONE);
-
-	commandTable.insert(newModeListEntry);
-
-	newModeListEntry.setObject(objects::TEST_DEVICE_HANDLER_1);
-	newModeListEntry.setMode(MODE_OFF);
-	newModeListEntry.setSubmode(SUBMODE_NONE);
-
-	commandTable.insert(newModeListEntry);
-
-}
-
-TestAssembly::~TestAssembly() {
-}
-
-ReturnValue_t TestAssembly::commandChildren(Mode_t mode,
-		Submode_t submode) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "TestAssembly: Received command to go to mode " << mode <<
-            " submode " << (int) submode << std::endl;
-#else
-    sif::printInfo("TestAssembly: Received command to go to mode %d submode %d\n", mode, submode);
-#endif
-	ReturnValue_t result = RETURN_OK;
-	if(mode == MODE_OFF){
-		commandTable[0].setMode(MODE_OFF);
-		commandTable[0].setSubmode(SUBMODE_NONE);
-		commandTable[1].setMode(MODE_OFF);
-		commandTable[1].setSubmode(SUBMODE_NONE);
-	}
-	else if(mode == DeviceHandlerIF::MODE_NORMAL) {
-		if(submode == submodes::SINGLE){
-			commandTable[0].setMode(MODE_OFF);
-			commandTable[0].setSubmode(SUBMODE_NONE);
-			commandTable[1].setMode(MODE_OFF);
-			commandTable[1].setSubmode(SUBMODE_NONE);
-			// We try to prefer 0 here but we try to switch to 1 even if it might fail
-			if(isDeviceAvailable(objects::TEST_DEVICE_HANDLER_0)) {
-				if (childrenMap[objects::TEST_DEVICE_HANDLER_0].mode == MODE_ON) {
-					commandTable[0].setMode(mode);
-					commandTable[0].setSubmode(SUBMODE_NONE);
-				}
-				else {
-					commandTable[0].setMode(MODE_ON);
-					commandTable[0].setSubmode(SUBMODE_NONE);
-				    result = NEED_SECOND_STEP;
-				}
-			}
-			else {
-				if (childrenMap[objects::TEST_DEVICE_HANDLER_1].mode == MODE_ON) {
-					commandTable[1].setMode(mode);
-					commandTable[1].setSubmode(SUBMODE_NONE);
-				}
-				else{
-					commandTable[1].setMode(MODE_ON);
-					commandTable[1].setSubmode(SUBMODE_NONE);
-				    result = NEED_SECOND_STEP;
-				}
-			}
-		}
-		else{
-			// Dual Mode Normal
-			if (childrenMap[objects::TEST_DEVICE_HANDLER_0].mode == MODE_ON) {
-				commandTable[0].setMode(mode);
-				commandTable[0].setSubmode(SUBMODE_NONE);
-			}
-			else{
-				commandTable[0].setMode(MODE_ON);
-				commandTable[0].setSubmode(SUBMODE_NONE);
-			    result = NEED_SECOND_STEP;
-			}
-			if (childrenMap[objects::TEST_DEVICE_HANDLER_1].mode == MODE_ON) {
-				commandTable[1].setMode(mode);
-				commandTable[1].setSubmode(SUBMODE_NONE);
-			}
-			else{
-				commandTable[1].setMode(MODE_ON);
-				commandTable[1].setSubmode(SUBMODE_NONE);
-			    result = NEED_SECOND_STEP;
-			}
-		}
-	}
-	else{
-		//Mode ON
-		if(submode == submodes::SINGLE){
-			commandTable[0].setMode(MODE_OFF);
-			commandTable[0].setSubmode(SUBMODE_NONE);
-			commandTable[1].setMode(MODE_OFF);
-			commandTable[1].setSubmode(SUBMODE_NONE);
-			// We try to prefer 0 here but we try to switch to 1 even if it might fail
-			if(isDeviceAvailable(objects::TEST_DEVICE_HANDLER_0)){
-				commandTable[0].setMode(MODE_ON);
-				commandTable[0].setSubmode(SUBMODE_NONE);
-			}
-			else{
-				commandTable[1].setMode(MODE_ON);
-				commandTable[1].setSubmode(SUBMODE_NONE);
-			}
-		}
-		else{
-			commandTable[0].setMode(MODE_ON);
-			commandTable[0].setSubmode(SUBMODE_NONE);
-			commandTable[1].setMode(MODE_ON);
-			commandTable[1].setSubmode(SUBMODE_NONE);
-		}
-	}
-
-
-
-	HybridIterator<ModeListEntry> iter(commandTable.begin(),
-			commandTable.end());
-	executeTable(iter);
-	return result;
-}
-
-ReturnValue_t TestAssembly::isModeCombinationValid(Mode_t mode,
-		Submode_t submode) {
-	switch (mode) {
-	case MODE_OFF:
-		if (submode == SUBMODE_NONE) {
-			return RETURN_OK;
-		} else {
-			return INVALID_SUBMODE;
-		}
-	case DeviceHandlerIF::MODE_NORMAL:
-	case MODE_ON:
-		if (submode < 3) {
-			return RETURN_OK;
-		} else {
-			return INVALID_SUBMODE;
-		}
-	}
-	return INVALID_MODE;
-}
-
-ReturnValue_t TestAssembly::initialize() {
-	ReturnValue_t result = AssemblyBase::initialize();
-	if(result != RETURN_OK){
-		return result;
-	}
-	handler0 = ObjectManager::instance()->get<TestDevice>(objects::TEST_DEVICE_HANDLER_0);
-	handler1 = ObjectManager::instance()->get<TestDevice>(objects::TEST_DEVICE_HANDLER_1);
-	if((handler0 == nullptr) or (handler1 == nullptr)){
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	handler0->setParentQueue(this->getCommandQueue());
-	handler1->setParentQueue(this->getCommandQueue());
-
-
-	result = registerChild(objects::TEST_DEVICE_HANDLER_0);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	result = registerChild(objects::TEST_DEVICE_HANDLER_1);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return result;
-}
-
-ReturnValue_t TestAssembly::checkChildrenStateOn(
-		Mode_t wantedMode, Submode_t wantedSubmode) {
-	if(submode == submodes::DUAL){
-		for(const auto& info:childrenMap) {
-			if(info.second.mode != wantedMode or info.second.mode != wantedSubmode){
-				return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
-			}
-		}
-		return RETURN_OK;
-	}
-	else if(submode == submodes::SINGLE) {
-		for(const auto& info:childrenMap) {
-			if(info.second.mode == wantedMode and info.second.mode != wantedSubmode){
-				return RETURN_OK;
-			}
-		}
-	}
-	return INVALID_SUBMODE;
-}
-
-bool TestAssembly::isDeviceAvailable(object_id_t object) {
-	if(healthHelper.healthTable->getHealth(object) == HasHealthIF::HEALTHY){
-		return true;
-	}
-	else{
-		return false;
-	}
-}

mission/assemblies/TestAssembly.h

@@ -1,53 +0,0 @@
-#ifndef MISSION_ASSEMBLIES_TESTASSEMBLY_H_
-#define MISSION_ASSEMBLIES_TESTASSEMBLY_H_
-
-#include <fsfw/devicehandlers/AssemblyBase.h>
-#include "../devices/TestDeviceHandler.h"
-
-class TestAssembly: public AssemblyBase {
-public:
-	TestAssembly(object_id_t objectId, object_id_t parentId);
-	virtual ~TestAssembly();
-	ReturnValue_t initialize() override;
-
-	enum submodes: Submode_t{
-		SINGLE = 0,
-		DUAL = 1
-	};
-
-protected:
-	/**
-	 * Command children to reach [mode,submode] combination
-	 * Can be done by setting #commandsOutstanding correctly,
-	 * or using executeTable()
-	 * @param mode
-	 * @param submode
-	 * @return
-	 *    - @c RETURN_OK if ok
-	 *    - @c NEED_SECOND_STEP if children need to be commanded again
-	 */
-	ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
-    /**
-     * Check whether desired assembly mode was achieved by checking the modes
-     * or/and health states of child device handlers.
-     * The assembly template class will also call this function if a health
-     * or mode change of a child device handler was detected.
-     * @param wantedMode
-     * @param wantedSubmode
-     * @return
-     */
-	ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode)
-			override;
-
-	ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
-			Submode_t wantedSubmode) override;
-private:
-	FixedArrayList<ModeListEntry, 2> commandTable;
-	TestDevice* handler0 = nullptr;
-	TestDevice* handler1 = nullptr;
-
-
-	bool isDeviceAvailable(object_id_t object);
-};
-
-#endif /* MISSION_ASSEMBLIES_TESTASSEMBLY_H_ */

mission/controller/CMakeLists.txt

@@ -1,3 +0,0 @@
-target_sources(${TARGET_NAME} PRIVATE
-    TestController.cpp
-)

mission/controller/TestController.cpp

@@ -1,214 +0,0 @@
-#include "TestController.h"
-#include "OBSWConfig.h"
-
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-TestController::TestController(object_id_t objectId, size_t commandQueueDepth):
-        ExtendedControllerBase(objectId, objects::NO_OBJECT, commandQueueDepth),
-        deviceDataset0(objects::TEST_DEVICE_HANDLER_0),
-        deviceDataset1(objects::TEST_DEVICE_HANDLER_1) {
-}
-
-TestController::~TestController() {
-}
-
-ReturnValue_t TestController::handleCommandMessage(CommandMessage *message) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void TestController::performControlOperation() {
-    /* We will trace vaiables if we received an update notification or snapshots */
-#if OBSW_CONTROLLER_PRINTOUT == 1
-    if(not traceVariable) {
-        return;
-    }
-
-    switch(currentTraceType) {
-    case(NONE): {
-        break;
-    }
-    case(TRACE_DEV_0_UINT8): {
-        if(traceCounter == 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "Tracing finished" << std::endl;
-#else
-            sif::printInfo("Tracing finished\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-            traceVariable = false;
-            traceCounter = traceCycles;
-            currentTraceType = TraceTypes::NONE;
-            break;
-        }
-
-        PoolReadGuard readHelper(&deviceDataset0.testUint8Var);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "Tracing device 0 variable 0 (UINT8), current value: " <<
-                static_cast<int>(deviceDataset0.testUint8Var.value) << std::endl;
-#else
-        sif::printInfo("Tracing device 0 variable 0 (UINT8), current value: %d\n",
-                deviceDataset0.testUint8Var.value);
-#endif
-        traceCounter--;
-        break;
-    }
-    case(TRACE_DEV_0_VECTOR): {
-        break;
-    }
-
-    }
-#endif /* OBSW_CONTROLLER_PRINTOUT == 1 */
-}
-
-void TestController::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) {
-    using namespace std;
-
-#if OBSW_CONTROLLER_PRINTOUT == 1
-    char const* printout = nullptr;
-    if(storeId == storeId::INVALID_STORE_ADDRESS) {
-        printout = "Notification";
-    }
-    else {
-        printout = "Snapshot";
-    }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "TestController::handleChangedDataset: " << printout << " update from object "
-            "ID " << setw(8) << setfill('0') << hex << sid.objectId <<
-            " and set ID " << sid.ownerSetId << dec << setfill(' ') << endl;
-#else
-    sif::printInfo("TestController::handleChangedPoolVariable: %s update from object ID 0x%08x and "
-            "set ID %lu\n", printout, sid.objectId, sid.ownerSetId);
-#endif
-
-    if (storeId == storeId::INVALID_STORE_ADDRESS) {
-        if(sid.objectId == objects::TEST_DEVICE_HANDLER_0) {
-            PoolReadGuard readHelper(&deviceDataset0.testFloat3Vec);
-            float floatVec[3];
-            floatVec[0] = deviceDataset0.testFloat3Vec.value[0];
-            floatVec[1] = deviceDataset0.testFloat3Vec.value[1];
-            floatVec[2] = deviceDataset0.testFloat3Vec.value[2];
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "Current float vector (3) values: ["  << floatVec[0] << ", " <<
-                    floatVec[1] << ", " << floatVec[2] << "]" << std::endl;
-#else
-            sif::printInfo("Current float vector (3) values: [%f, %f, %f]\n",
-                    floatVec[0], floatVec[1], floatVec[2]);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        }
-    }
-#endif /* OBSW_CONTROLLER_PRINTOUT == 1 */
-
-    /* We will trace the variables for snapshots and update notifications */
-    if(not traceVariable) {
-        traceVariable = true;
-        traceCounter = traceCycles;
-        currentTraceType = TraceTypes::TRACE_DEV_0_VECTOR;
-    }
-}
-
-void TestController::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
-        bool* clearMessage) {
-    using namespace std;
-
-#if OBSW_CONTROLLER_PRINTOUT == 1
-    char const* printout = nullptr;
-    if (storeId == storeId::INVALID_STORE_ADDRESS) {
-        printout = "Notification";
-    }
-    else {
-        printout = "Snapshot";
-    }
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "TestController::handleChangedPoolVariable: " << printout << " update from object "
-            "ID 0x" << setw(8) << setfill('0') << hex << globPoolId.objectId <<
-            " and local pool ID " << globPoolId.localPoolId << dec << setfill(' ') << endl;
-#else
-    sif::printInfo("TestController::handleChangedPoolVariable: %s update from object ID 0x%08x and "
-            "local pool ID %lu\n", printout, globPoolId.objectId, globPoolId.localPoolId);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-
-    if (storeId == storeId::INVALID_STORE_ADDRESS) {
-        if(globPoolId.objectId == objects::TEST_DEVICE_HANDLER_0) {
-            PoolReadGuard readHelper(&deviceDataset0.testUint8Var);
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "Current test variable 0 (UINT8) value: " << static_cast<int>(
-                    deviceDataset0.testUint8Var.value) << std::endl;
-#else
-            sif::printInfo("Current test variable 0 (UINT8) value %d\n",
-                    deviceDataset0.testUint8Var.value);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        }
-    }
-#endif /* OBSW_CONTROLLER_PRINTOUT == 1 */
-
-    /* We will trace the variables for snapshots and update notifications */
-    if(not traceVariable) {
-        traceVariable = true;
-        traceCounter = traceCycles;
-        currentTraceType = TraceTypes::TRACE_DEV_0_UINT8;
-    }
-}
-
-LocalPoolDataSetBase* TestController::getDataSetHandle(sid_t sid) {
-    return nullptr;
-}
-
-ReturnValue_t TestController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-        LocalDataPoolManager &poolManager) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TestController::initializeAfterTaskCreation() {
-    namespace td = testdevice;
-    HasLocalDataPoolIF* device0 = ObjectManager::instance()->get<HasLocalDataPoolIF>(
-            objects::TEST_DEVICE_HANDLER_0);
-    if(device0 == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TestController::initializeAfterTaskCreation: Test device handler 0 "
-                "handle invalid!" << std::endl;
-#else
-        sif::printWarning("TestController::initializeAfterTaskCreation: Test device handler 0 "
-                "handle invalid!");
-#endif
-        return ObjectManagerIF::CHILD_INIT_FAILED;
-    }
-    ProvidesDataPoolSubscriptionIF* subscriptionIF = device0->getSubscriptionInterface();
-    if(subscriptionIF != nullptr) {
-        /* For DEVICE_0, we only subscribe for notifications */
-        subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(),
-                getCommandQueue(), false);
-        subscriptionIF->subscribeForVariableUpdateMessage(td::PoolIds::TEST_UINT8_ID,
-                getObjectId(), getCommandQueue(), false);
-    }
-
-
-    HasLocalDataPoolIF* device1 = ObjectManager::instance()->get<HasLocalDataPoolIF>(
-            objects::TEST_DEVICE_HANDLER_1);
-    if(device1 == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TestController::initializeAfterTaskCreation: Test device handler 1 "
-                "handle invalid!" << std::endl;
-#else
-        sif::printWarning("TestController::initializeAfterTaskCreation: Test device handler 1 "
-                "handle invalid!");
-#endif
-    }
-
-    subscriptionIF = device1->getSubscriptionInterface();
-    if(subscriptionIF != nullptr) {
-        /* For DEVICE_1, we will subscribe for snapshots */
-        subscriptionIF->subscribeForSetUpdateMessage(td::TEST_SET_ID, getObjectId(),
-                getCommandQueue(), true);
-        subscriptionIF->subscribeForVariableUpdateMessage(td::PoolIds::TEST_UINT8_ID,
-                getObjectId(), getCommandQueue(), true);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t TestController::checkModeCommand(Mode_t mode, Submode_t submode,
-        uint32_t *msToReachTheMode) {
-    return HasReturnvaluesIF::RETURN_OK;
-}
-

mission/controller/TestController.h

@@ -1,50 +0,0 @@
-#ifndef MISSION_CONTROLLER_TESTCONTROLLER_H_
-#define MISSION_CONTROLLER_TESTCONTROLLER_H_
-
-#include "../devices/devicedefinitions/testDeviceDefinitions.h"
-#include <fsfw/controller/ExtendedControllerBase.h>
-
-
-class TestController:
-        public ExtendedControllerBase {
-public:
-    TestController(object_id_t objectId, size_t commandQueueDepth = 10);
-    virtual~ TestController();
-protected:
-    testdevice::TestDataSet deviceDataset0;
-    testdevice::TestDataSet deviceDataset1;
-
-    /* Extended Controller Base overrides */
-    ReturnValue_t handleCommandMessage(CommandMessage *message) override;
-    void performControlOperation() override;
-
-    /* HasLocalDatapoolIF callbacks */
-    void handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) override;
-    void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
-            bool* clearMessage) override;
-
-    LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                LocalDataPoolManager& poolManager) override;
-
-    ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-            uint32_t *msToReachTheMode) override;
-
-    ReturnValue_t initializeAfterTaskCreation() override;
-
-private:
-
-    bool traceVariable = false;
-    uint8_t traceCycles = 5;
-    uint8_t traceCounter = traceCycles;
-
-    enum TraceTypes {
-        NONE,
-        TRACE_DEV_0_UINT8,
-        TRACE_DEV_0_VECTOR
-    };
-    TraceTypes currentTraceType = TraceTypes::NONE;
-};
-
-
-#endif /* MISSION_CONTROLLER_TESTCONTROLLER_H_ */

mission/controller/ctrldefinitions/testCtrlDefinitions.h

@@ -1,18 +0,0 @@
-#ifndef MISSION_CONTROLLER_CTRLDEFINITIONS_TESTCTRLDEFINITIONS_H_
-#define MISSION_CONTROLLER_CTRLDEFINITIONS_TESTCTRLDEFINITIONS_H_
-
-#include <fsfw/objectmanager/SystemObjectIF.h>
-#include <OBSWConfig.h>
-
-namespace testcontroller {
-
-enum sourceObjectIds: object_id_t {
-    DEVICE_0_ID = objects::TEST_DEVICE_HANDLER_0,
-    DEVICE_1_ID = objects::TEST_DEVICE_HANDLER_1,
-};
-
-}
-
-
-
-#endif /* MISSION_CONTROLLER_CTRLDEFINITIONS_TESTCTRLDEFINITIONS_H_ */

mission/core/CMakeLists.txt

@@ -1,4 +0,0 @@
-target_sources(${TARGET_NAME} 
-	PRIVATE
-		GenericFactory.cpp
-)

mission/core/GenericFactory.cpp

@@ -1,158 +0,0 @@
-#include "GenericFactory.h"
-
-#include "OBSWConfig.h"
-#include "fsfw/FSFW.h"
-#include "tmtc/apid.h"
-#include "tmtc/pusIds.h"
-#include "objects/systemObjectList.h"
-
-#include "fsfw_tests/internal/InternalUnitTester.h"
-#include "test/FsfwExampleTask.h"
-#include "test/FsfwReaderTask.h"
-
-#include "mission/assemblies/TestAssembly.h"
-#include "mission/devices/TestCookie.h"
-#include "mission/devices/TestDeviceHandler.h"
-#include "mission/devices/TestEchoComIF.h"
-#include "mission/utility/TmFunnel.h"
-#include "mission/controller/TestController.h"
-
-#include "fsfw/devicehandlers/CookieIF.h"
-#include "fsfw/events/EventManager.h"
-#include "fsfw/health/HealthTable.h"
-#include "fsfw/internalerror/InternalErrorReporter.h"
-#include "fsfw/pus/CService200ModeCommanding.h"
-#include "fsfw/pus/Service17Test.h"
-#include "fsfw/pus/Service1TelecommandVerification.h"
-#include "fsfw/pus/Service20ParameterManagement.h"
-#include "fsfw/pus/Service2DeviceAccess.h"
-#include "fsfw/pus/Service3Housekeeping.h"
-#include "fsfw/pus/Service5EventReporting.h"
-#include "fsfw/pus/Service8FunctionManagement.h"
-#include "fsfw/pus/Service9TimeManagement.h"
-#include "fsfw/tcdistribution/CCSDSDistributor.h"
-#include "fsfw/tcdistribution/PUSDistributor.h"
-#include "fsfw/timemanager/TimeStamper.h"
-#include "fsfw/tmtcpacket/pus/tm.h"
-
-
-
-void ObjectFactory::produceGenericObjects() {
-#if OBSW_ADD_CORE_COMPONENTS == 1
-    /* Framework objects */
-    new EventManager(objects::EVENT_MANAGER);
-    new HealthTable(objects::HEALTH_TABLE);
-    new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
-    new TimeStamper(objects::TIME_STAMPER);
-    new CCSDSDistributor(apid::APID, objects::CCSDS_DISTRIBUTOR);
-    new PUSDistributor(apid::APID, objects::PUS_DISTRIBUTOR,
-            objects::CCSDS_DISTRIBUTOR);
-    new TmFunnel(objects::TM_FUNNEL);
-#endif /* OBSW_ADD_CORE_COMPONENTS == 1 */
-
-    /* PUS stack */
-#if OBSW_ADD_PUS_STACK == 1
-    new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION,
-            apid::APID, pus::PUS_SERVICE_1, objects::TM_FUNNEL, 5);
-    new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS,
-            apid::APID, pus::PUS_SERVICE_2, 3, 10);
-    new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::APID, pus::PUS_SERVICE_3);
-    new Service5EventReporting(objects::PUS_SERVICE_5_EVENT_REPORTING,
-            apid::APID, pus::PUS_SERVICE_5, 50);
-    new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT,
-            apid::APID, pus::PUS_SERVICE_8, 3, 10);
-    new Service9TimeManagement(objects::PUS_SERVICE_9_TIME_MGMT, apid::APID,
-            pus::PUS_SERVICE_9);
-    new Service17Test(objects::PUS_SERVICE_17_TEST, apid::APID,
-            pus::PUS_SERVICE_17);
-    new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, apid::APID,
-            pus::PUS_SERVICE_20);
-    new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT,
-            apid::APID, pus::PUS_SERVICE_200);
-#endif /* OBSW_ADD_PUS_STACK == 1 */
-
-#if OBSW_ADD_TASK_EXAMPLE == 1
-    /* Demo objects */
-    new FsfwExampleTask(objects::TEST_DUMMY_1);
-    new FsfwExampleTask(objects::TEST_DUMMY_2);
-    new FsfwExampleTask(objects::TEST_DUMMY_3);
-
-
-    bool enablePrintout = false;
-#if OBSW_TASK_EXAMPLE_PRINTOUT == 1
-    enablePrintout = true;
-#endif
-    new FsfwReaderTask(objects::TEST_DUMMY_4, enablePrintout);
-#endif /* OBSW_ADD_TASK_EXAMPLE == 1 */
-
-#if OBSW_ADD_DEVICE_HANDLER_DEMO == 1
-
-#if OBSW_DEVICE_HANDLER_PRINTOUT == 1
-    bool enableInfoPrintout = true;
-#else
-    bool enableInfoPrintout = false;
-#endif /* OBSW_DEVICE_HANDLER_PRINTOUT == 1 */
-
-    /* Demo device handler object */
-    size_t expectedMaxReplyLen = 64;
-    CookieIF* testCookie = new DummyCookie(
-            static_cast<address_t>(testdevice::DeviceIndex::DEVICE_0), expectedMaxReplyLen);
-    new TestEchoComIF(objects::TEST_ECHO_COM_IF);
-    new TestDevice(objects::TEST_DEVICE_HANDLER_0, objects::TEST_ECHO_COM_IF, testCookie,
-            testdevice::DeviceIndex::DEVICE_0, enableInfoPrintout);
-    testCookie = new DummyCookie(static_cast<address_t>(testdevice::DeviceIndex::DEVICE_1),
-            expectedMaxReplyLen);
-    new TestDevice(objects::TEST_DEVICE_HANDLER_1, objects::TEST_ECHO_COM_IF, testCookie,
-            testdevice::DeviceIndex::DEVICE_1, enableInfoPrintout);
-
-    new TestAssembly(objects::TEST_ASSEMBLY, objects::NO_OBJECT);
-
-#endif /* OBSW_ADD_DEVICE_HANDLER_DEMO == 1 */
-
-
-    /* Demo controller object */
-#if OBSW_ADD_CONTROLLER_DEMO == 1
-
-#if OBSW_CONTROLLER_PRINTOUT == 1
-#endif
-    new TestController(objects::TEST_CONTROLLER);
-
-#endif /* OBSW_ADD_CONTROLLER_DEMO == 1 */
-
-#if OBSW_PERFORM_INTERNAL_UNITTEST == 1
-    InternalUnitTester::TestConfig testCfg;
-    testCfg.testArrayPrinter = false;
-#if defined FSFW_OSAL_HOST
-    // Not implemented yet for hosted OSAL (requires C++20)
-    testCfg.testSemaphores = false;
-#endif
-    InternalUnitTester unittester;
-    unittester.performTests(testCfg);
-#endif /* OBSW_PERFORM_INTERNAL_UNITTEST == 1 */
-}
-
-void Factory::setStaticFrameworkObjectIds() {
-    MonitoringReportContent<float>::timeStamperId = objects::TIME_STAMPER;
-    MonitoringReportContent<double>::timeStamperId = objects::TIME_STAMPER;
-    MonitoringReportContent<uint32_t>::timeStamperId = objects::TIME_STAMPER;
-    MonitoringReportContent<int32_t>::timeStamperId = objects::TIME_STAMPER;
-    MonitoringReportContent<int16_t>::timeStamperId = objects::TIME_STAMPER;
-    MonitoringReportContent<uint16_t>::timeStamperId = objects::TIME_STAMPER;
-
-    TmFunnel::downlinkDestination = objects::DOWNLINK_DESTINATION;
-    // No storage object for now.
-    TmFunnel::storageDestination = objects::NO_OBJECT;
-
-    PusServiceBase::packetSource = objects::PUS_DISTRIBUTOR;
-    PusServiceBase::packetDestination = objects::TM_FUNNEL;
-
-    CommandingServiceBase::defaultPacketSource = objects::PUS_DISTRIBUTOR;
-    CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
-
-    VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-
-    TmPacketBase::timeStamperId = objects::TIME_STAMPER;
-
-}
-
-

mission/devices/CMakeLists.txt

@@ -1,6 +0,0 @@
-target_sources(${TARGET_NAME} 
-	PRIVATE
-		TestCookie.cpp
-		TestDeviceHandler.cpp
-		TestEchoComIF.cpp
-)

mission/devices/TestCookie.cpp

@@ -1,14 +0,0 @@
-#include "TestCookie.h"
-
-DummyCookie::DummyCookie(address_t address, size_t replyMaxLen):
-		address(address), replyMaxLen(replyMaxLen) {}
-
-DummyCookie::~DummyCookie() {}
-
-address_t DummyCookie::getAddress() const {
-	return address;
-}
-
-size_t DummyCookie::getReplyMaxLen() const {
-	return replyMaxLen;
-}

mission/devices/TestCookie.h

@@ -1,22 +0,0 @@
-#ifndef MISSION_DEVICES_TESTCOOKIE_H_
-#define MISSION_DEVICES_TESTCOOKIE_H_
-
-#include <fsfw/devicehandlers/CookieIF.h>
-#include <cstddef>
-
-/**
- * @brief	Really simple cookie which does not do a lot.
- */
-class DummyCookie: public CookieIF {
-public:
-	DummyCookie(address_t address, size_t maxReplyLen);
-	virtual ~DummyCookie();
-
-	address_t getAddress() const;
-	size_t getReplyMaxLen() const;
-private:
-	address_t address = 0;
-	size_t replyMaxLen = 0;
-};
-
-#endif /* MISSION_DEVICES_TESTCOOKIE_H_ */

mission/devices/TestDeviceHandler.cpp

@@ -1,804 +0,0 @@
-#include "TestDeviceHandler.h"
-#include <OBSWConfig.h>
-
-#include <fsfw/datapool/PoolReadGuard.h>
-
-#include <cstdlib>
-
-TestDevice::TestDevice(object_id_t objectId, object_id_t comIF,
-        CookieIF * cookie, testdevice::DeviceIndex deviceIdx, bool fullInfoPrintout,
-        bool changingDataset):
-        DeviceHandlerBase(objectId, comIF, cookie), deviceIdx(deviceIdx),
-        dataset(this), fullInfoPrintout(fullInfoPrintout) {
-}
-
-TestDevice::~TestDevice() {}
-
-void TestDevice::performOperationHook() {
-    if(periodicPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice" << deviceIdx << "::performOperationHook: Alive!" << std::endl;
-#else
-        sif::printInfo("TestDevice%d::performOperationHook: Alive!", deviceIdx);
-#endif
-    }
-
-    if(oneShot) {
-        oneShot = false;
-    }
-}
-
-
-void TestDevice::doStartUp() {
-    if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice" << deviceIdx << "::doStartUp: Switching On" << std::endl;
-#else
-        sif::printInfo("TestDevice%d::doStartUp: Switching On\n", static_cast<int>(deviceIdx));
-#endif
-    }
-
-    setMode(_MODE_TO_ON);
-    return;
-}
-
-
-void TestDevice::doShutDown() {
-    if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice" << deviceIdx << "::doShutDown: Switching Off" << std::endl;
-#else
-        sif::printInfo("TestDevice%d::doShutDown: Switching Off\n", static_cast<int>(deviceIdx));
-#endif
-    }
-
-    setMode(_MODE_SHUT_DOWN);
-    return;
-}
-
-
-ReturnValue_t TestDevice::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-    using namespace testdevice;
-    *id = TEST_NORMAL_MODE_CMD;
-    if(DeviceHandlerBase::isAwaitingReply()) {
-        return NOTHING_TO_SEND;
-    }
-    return buildCommandFromCommand(*id, nullptr, 0);
-}
-
-ReturnValue_t TestDevice::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-    if(mode == _MODE_TO_ON) {
-        if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::buildTransitionDeviceCommand: Was called"
-                    " from _MODE_TO_ON mode" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::buildTransitionDeviceCommand: "
-                    "Was called from _MODE_TO_ON mode\n", deviceIdx);
-#endif
-        }
-
-    }
-    if(mode == _MODE_TO_NORMAL) {
-        if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::buildTransitionDeviceCommand: Was called "
-                    "from _MODE_TO_NORMAL mode" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::buildTransitionDeviceCommand: Was called from "
-                    " _MODE_TO_NORMAL mode\n", deviceIdx);
-#endif
-        }
-
-        setMode(MODE_NORMAL);
-    }
-    if(mode == _MODE_SHUT_DOWN) {
-        if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::buildTransitionDeviceCommand: Was called "
-                    "from _MODE_SHUT_DOWN mode" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::buildTransitionDeviceCommand: Was called from "
-                    "_MODE_SHUT_DOWN mode\n", deviceIdx);
-#endif
-        }
-
-        setMode(MODE_OFF);
-    }
-    return NOTHING_TO_SEND;
-}
-
-void TestDevice::doTransition(Mode_t modeFrom, Submode_t submodeFrom) {
-    if(mode == _MODE_TO_NORMAL) {
-        if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::doTransition: Custom transition to "
-                    "normal mode" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::doTransition: Custom transition to normal mode\n",
-                    deviceIdx);
-#endif
-        }
-
-    }
-    else {
-        DeviceHandlerBase::doTransition(modeFrom, submodeFrom);
-    }
-}
-
-ReturnValue_t TestDevice::buildCommandFromCommand(
-        DeviceCommandId_t deviceCommand, const uint8_t* commandData,
-        size_t commandDataLen) {
-    using namespace testdevice;
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(deviceCommand) {
-    case(TEST_NORMAL_MODE_CMD): {
-        commandSent =  true;
-        result = buildNormalModeCommand(deviceCommand, commandData, commandDataLen);
-        break;
-    }
-
-    case(TEST_COMMAND_0): {
-        commandSent =  true;
-        result = buildTestCommand0(deviceCommand, commandData, commandDataLen);
-        break;
-    }
-
-    case(TEST_COMMAND_1): {
-        commandSent =  true;
-        result = buildTestCommand1(deviceCommand, commandData, commandDataLen);
-        break;
-    }
-    case(TEST_NOTIF_SNAPSHOT_VAR): {
-        if(changingDatasets) {
-            changingDatasets = false;
-        }
-
-        PoolReadGuard readHelper(&dataset.testUint8Var);
-        if(deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
-            /* This will trigger a variable notification to the demo controller */
-            dataset.testUint8Var = 220;
-            dataset.testUint8Var.setValid(true);
-        }
-        else if(deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
-            /* This will trigger a variable snapshot to the demo controller */
-            dataset.testUint8Var = 30;
-            dataset.testUint8Var.setValid(true);
-        }
-
-        break;
-    }
-    case(TEST_NOTIF_SNAPSHOT_SET): {
-        if(changingDatasets) {
-            changingDatasets = false;
-        }
-
-        PoolReadGuard readHelper(&dataset.testFloat3Vec);
-
-        if(deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
-            /* This will trigger a variable notification to the demo controller */
-            dataset.testFloat3Vec.value[0] = 60;
-            dataset.testFloat3Vec.value[1] = 70;
-            dataset.testFloat3Vec.value[2] = 55;
-            dataset.testFloat3Vec.setValid(true);
-        }
-        else if(deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
-            /* This will trigger a variable notification to the demo controller */
-            dataset.testFloat3Vec.value[0] = -60;
-            dataset.testFloat3Vec.value[1] = -70;
-            dataset.testFloat3Vec.value[2] = -55;
-            dataset.testFloat3Vec.setValid(true);
-        }
-        break;
-    }
-    default:
-        result = DeviceHandlerIF::COMMAND_NOT_SUPPORTED;
-    }
-    return result;
-}
-
-
-ReturnValue_t TestDevice::buildNormalModeCommand(DeviceCommandId_t deviceCommand,
-        const uint8_t* commandData, size_t commandDataLen) {
-    if(fullInfoPrintout) {
-#if OBSW_VERBOSE_LEVEL >= 3
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice::buildTestCommand1: Building normal command" << std::endl;
-#else
-        sif::printInfo("TestDevice::buildTestCommand1: Building command from TEST_COMMAND_1\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* OBSW_VERBOSE_LEVEL >= 3 */
-    }
-
-    if(commandDataLen > MAX_BUFFER_SIZE - sizeof(DeviceCommandId_t)) {
-        return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
-    }
-    /* The command is passed on in the command buffer as it is */
-    passOnCommand(deviceCommand, commandData, commandDataLen);
-    return RETURN_OK;
-}
-
-ReturnValue_t TestDevice::buildTestCommand0(DeviceCommandId_t deviceCommand,
-        const uint8_t* commandData, size_t commandDataLen) {
-    using namespace testdevice;
-    if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice" << deviceIdx << "::buildTestCommand0: Executing simple command "
-                " with completion reply" << std::endl;
-#else
-        sif::printInfo("TestDevice%d::buildTestCommand0: Executing simple command with "
-                "completion reply\n", deviceIdx);
-#endif
-    }
-
-    if(commandDataLen > MAX_BUFFER_SIZE - sizeof(DeviceCommandId_t)) {
-        return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
-    }
-
-    /* The command is passed on in the command buffer as it is */
-    passOnCommand(deviceCommand, commandData, commandDataLen);
-    return RETURN_OK;
-}
-
-ReturnValue_t TestDevice::buildTestCommand1(DeviceCommandId_t deviceCommand,
-        const uint8_t* commandData,
-        size_t commandDataLen) {
-    using namespace testdevice;
-    if(commandDataLen < 7) {
-        return DeviceHandlerIF::INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
-    }
-    if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice" << deviceIdx << "::buildTestCommand1: Executing command with "
-                "data reply"  << std::endl;
-#else
-        sif::printInfo("TestDevice%d:buildTestCommand1: Executing command with data reply\n",
-                deviceIdx);
-#endif
-    }
-
-    deviceCommand = EndianConverter::convertBigEndian(deviceCommand);
-    memcpy(commandBuffer, &deviceCommand, sizeof(deviceCommand));
-
-    /* Assign and check parameters */
-    uint16_t parameter1 = 0;
-    size_t size = commandDataLen;
-    ReturnValue_t result = SerializeAdapter::deSerialize(&parameter1,
-            &commandData, &size, SerializeIF::Endianness::BIG);
-    if(result == HasReturnvaluesIF::RETURN_FAILED) {
-        return result;
-    }
-
-    /* Parameter 1 needs to be correct */
-    if(parameter1 != testdevice::COMMAND_1_PARAM1) {
-        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
-    }
-    uint64_t parameter2 = 0;
-    result = SerializeAdapter::deSerialize(&parameter2,
-            &commandData, &size, SerializeIF::Endianness::BIG);
-    if(parameter2!= testdevice::COMMAND_1_PARAM2){
-        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
-    }
-
-    /* Pass on the parameters to the Echo IF */
-    commandBuffer[4] = (parameter1 & 0xFF00) >> 8;
-    commandBuffer[5] = (parameter1 & 0xFF);
-    parameter2 = EndianConverter::convertBigEndian(parameter2);
-    memcpy(commandBuffer + 6, &parameter2, sizeof(parameter2));
-    rawPacket = commandBuffer;
-    rawPacketLen = sizeof(deviceCommand) + sizeof(parameter1) +
-            sizeof(parameter2);
-    return RETURN_OK;
-}
-
-void TestDevice::passOnCommand(DeviceCommandId_t command, const uint8_t *commandData,
-        size_t commandDataLen) {
-    DeviceCommandId_t deviceCommandBe = EndianConverter::convertBigEndian(command);
-    memcpy(commandBuffer, &deviceCommandBe, sizeof(deviceCommandBe));
-    memcpy(commandBuffer + 4, commandData, commandDataLen);
-    rawPacket = commandBuffer;
-    rawPacketLen = sizeof(deviceCommandBe) + commandDataLen;
-}
-
-void TestDevice::fillCommandAndReplyMap() {
-    namespace td = testdevice;
-    insertInCommandAndReplyMap(testdevice::TEST_NORMAL_MODE_CMD, 5, &dataset);
-    insertInCommandAndReplyMap(testdevice::TEST_COMMAND_0, 5);
-    insertInCommandAndReplyMap(testdevice::TEST_COMMAND_1, 5);
-
-    /* No reply expected for these commands */
-    insertInCommandMap(td::TEST_NOTIF_SNAPSHOT_SET);
-    insertInCommandMap(td::TEST_NOTIF_SNAPSHOT_VAR);
-}
-
-
-ReturnValue_t TestDevice::scanForReply(const uint8_t *start, size_t len,
-        DeviceCommandId_t *foundId, size_t *foundLen) {
-    using namespace testdevice;
-
-    /* Unless a command was sent explicitely, we don't expect any replies and ignore this
-    the packet. On a real device, there might be replies which are sent without a previous
-    command. */
-    if(not commandSent) {
-        return DeviceHandlerBase::IGNORE_FULL_PACKET;
-    }
-    else {
-        commandSent = false;
-    }
-
-    if(len < sizeof(object_id_t)) {
-        return DeviceHandlerIF::LENGTH_MISSMATCH;
-    }
-
-    size_t size = len;
-    ReturnValue_t result = SerializeAdapter::deSerialize(foundId, &start, &size,
-            SerializeIF::Endianness::BIG);
-    if (result != RETURN_OK) {
-        return result;
-    }
-
-    DeviceCommandId_t pendingCmd = this->getPendingCommand();
-
-    switch(pendingCmd) {
-
-    case(TEST_NORMAL_MODE_CMD): {
-        if(fullInfoPrintout) {
-#if OBSW_VERBOSE_LEVEL >= 3
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice::scanForReply: Reply for normal commnand (ID " <<
-                    TEST_NORMAL_MODE_CMD << ") received!" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::scanForReply: Reply for normal command (ID %d) "
-                    "received!\n", deviceIdx, TEST_NORMAL_MODE_CMD);
-#endif
-#endif
-        }
-
-        *foundLen = len;
-        *foundId = pendingCmd;
-        return RETURN_OK;
-    }
-
-    case(TEST_COMMAND_0): {
-        if(len < TEST_COMMAND_0_SIZE) {
-            return DeviceHandlerIF::LENGTH_MISSMATCH;
-        }
-        if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::scanForReply: Reply for simple command "
-                    "(ID " << TEST_COMMAND_0 << ") received!" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::scanForReply: Reply for simple command (ID %d) "
-                    "received!\n", deviceIdx, TEST_COMMAND_0);
-#endif
-        }
-
-        *foundLen = TEST_COMMAND_0_SIZE;
-        *foundId = pendingCmd;
-        return RETURN_OK;
-    }
-
-    case(TEST_COMMAND_1): {
-        if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::scanForReply: Reply for data command "
-                    "(ID " << TEST_COMMAND_1 << ") received!" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::scanForReply: Reply for data command (ID %d) "
-                    "received\n", deviceIdx, TEST_COMMAND_1);
-#endif
-        }
-
-        *foundLen = len;
-        *foundId = pendingCmd;
-        return RETURN_OK;
-    }
-
-    default:
-        return DeviceHandlerIF::DEVICE_REPLY_INVALID;
-    }
-}
-
-
-ReturnValue_t TestDevice::interpretDeviceReply(DeviceCommandId_t id,
-        const uint8_t* packet) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    switch(id) {
-    /* Periodic replies */
-    case testdevice::TEST_NORMAL_MODE_CMD: {
-        result = interpretingNormalModeReply();
-        break;
-    }
-    /* Simple reply */
-    case testdevice::TEST_COMMAND_0: {
-        result = interpretingTestReply0(id, packet);
-        break;
-    }
-    /* Data reply */
-    case testdevice::TEST_COMMAND_1: {
-        result = interpretingTestReply1(id, packet);
-        break;
-    }
-    default:
-        return DeviceHandlerIF::DEVICE_REPLY_INVALID;
-    }
-    return result;
-}
-
-ReturnValue_t TestDevice::interpretingNormalModeReply() {
-    CommandMessage directReplyMessage;
-    if(changingDatasets) {
-        PoolReadGuard readHelper(&dataset);
-        if(dataset.testUint8Var.value == 0) {
-            dataset.testUint8Var.value = 10;
-            dataset.testUint32Var.value = 777;
-            dataset.testFloat3Vec.value[0] = 2.5;
-            dataset.testFloat3Vec.value[1] = -2.5;
-            dataset.testFloat3Vec.value[2] = 2.5;
-            dataset.setValidity(true, true);
-        }
-        else {
-            dataset.testUint8Var.value = 0;
-            dataset.testUint32Var.value = 0;
-            dataset.testFloat3Vec.value[0] = 0.0;
-            dataset.testFloat3Vec.value[1] = 0.0;
-            dataset.testFloat3Vec.value[2] = 0.0;
-            dataset.setValidity(false, true);
-        }
-        return RETURN_OK;
-    }
-
-    PoolReadGuard readHelper(&dataset);
-    if(dataset.testUint8Var.value == 0) {
-        /* Reset state */
-        dataset.testUint8Var.value = 128;
-    }
-    else if(dataset.testUint8Var.value > 200) {
-        if(not resetAfterChange) {
-            /* This will trigger an update notification to the controller */
-            dataset.testUint8Var.setChanged(true);
-            resetAfterChange = true;
-            /* Decrement by 30 automatically. This will prevent any additional notifications. */
-            dataset.testUint8Var.value -= 30;
-        }
-    }
-    /* If the value is greater than 0, it will be decremented in a linear way */
-    else if(dataset.testUint8Var.value > 128) {
-        size_t sizeToDecrement = 0;
-        if(dataset.testUint8Var.value > 128 + 30) {
-            sizeToDecrement = 30;
-        }
-        else {
-            sizeToDecrement = dataset.testUint8Var.value - 128;
-            resetAfterChange = false;
-        }
-        dataset.testUint8Var.value -= sizeToDecrement;
-    }
-    else if(dataset.testUint8Var.value < 50) {
-        if(not resetAfterChange) {
-            /* This will trigger an update snapshot to the controller */
-            dataset.testUint8Var.setChanged(true);
-            resetAfterChange = true;
-        }
-        else {
-            /* Increment by 30 automatically. */
-            dataset.testUint8Var.value += 30;
-        }
-    }
-    /* Increment in linear way */
-    else if(dataset.testUint8Var.value < 128) {
-        size_t sizeToIncrement = 0;
-        if(dataset.testUint8Var.value < 128 - 20) {
-            sizeToIncrement = 20;
-        }
-        else {
-            sizeToIncrement = 128 - dataset.testUint8Var.value;
-            resetAfterChange = false;
-        }
-        dataset.testUint8Var.value += sizeToIncrement;
-    }
-
-    /* TODO: Same for vector */
-    float vectorMean = (dataset.testFloat3Vec.value[0] + dataset.testFloat3Vec.value[1] +
-            dataset.testFloat3Vec.value[2]) / 3.0;
-
-    /* Lambda (private local function) */
-    auto sizeToAdd = [](bool tooHigh, float currentVal) {
-        if(tooHigh) {
-            if(currentVal - 20.0 > 10.0) {
-                return -10.0;
-            }
-            else {
-                return 20.0 - currentVal;
-            }
-        }
-        else {
-            if(std::abs(currentVal + 20.0) > 10.0) {
-                return 10.0;
-            }
-            else {
-                return -20.0 - currentVal;
-            }
-        }
-    };
-
-    if(vectorMean > 20.0 and std::abs(vectorMean - 20.0) > 1.0) {
-        if(not resetAfterChange) {
-            dataset.testFloat3Vec.setChanged(true);
-            resetAfterChange = true;
-        }
-        else {
-            float sizeToDecrementVal0 = 0;
-            float sizeToDecrementVal1 = 0;
-            float sizeToDecrementVal2 = 0;
-
-            sizeToDecrementVal0 = sizeToAdd(true, dataset.testFloat3Vec.value[0]);
-            sizeToDecrementVal1 = sizeToAdd(true, dataset.testFloat3Vec.value[1]);
-            sizeToDecrementVal2 = sizeToAdd(true, dataset.testFloat3Vec.value[2]);
-
-            dataset.testFloat3Vec.value[0] += sizeToDecrementVal0;
-            dataset.testFloat3Vec.value[1] += sizeToDecrementVal1;
-            dataset.testFloat3Vec.value[2] += sizeToDecrementVal2;
-        }
-    }
-    else if (vectorMean < -20.0 and std::abs(vectorMean + 20.0) < 1.0) {
-        if(not resetAfterChange) {
-            dataset.testFloat3Vec.setChanged(true);
-            resetAfterChange = true;
-        }
-        else {
-            float sizeToDecrementVal0 = 0;
-            float sizeToDecrementVal1 = 0;
-            float sizeToDecrementVal2 = 0;
-
-            sizeToDecrementVal0 = sizeToAdd(false, dataset.testFloat3Vec.value[0]);
-            sizeToDecrementVal1 = sizeToAdd(false, dataset.testFloat3Vec.value[1]);
-            sizeToDecrementVal2 = sizeToAdd(false, dataset.testFloat3Vec.value[2]);
-
-            dataset.testFloat3Vec.value[0] += sizeToDecrementVal0;
-            dataset.testFloat3Vec.value[1] += sizeToDecrementVal1;
-            dataset.testFloat3Vec.value[2] += sizeToDecrementVal2;
-        }
-    }
-    else {
-        if(resetAfterChange) {
-            resetAfterChange = false;
-        }
-    }
-
-    return RETURN_OK;
-}
-
-ReturnValue_t TestDevice::interpretingTestReply0(DeviceCommandId_t id, const uint8_t* packet) {
-    CommandMessage commandMessage;
-    if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice::interpretingTestReply0: Generating step and finish reply" <<
-                std::endl;
-#else
-        sif::printInfo("TestDevice::interpretingTestReply0: Generating step and finish reply\n");
-#endif
-    }
-
-    MessageQueueId_t commander = getCommanderQueueId(id);
-    /* Generate one step reply and the finish reply */
-    actionHelper.step(1, commander, id);
-    actionHelper.finish(true, commander, id);
-
-    return RETURN_OK;
-}
-
-ReturnValue_t TestDevice::interpretingTestReply1(DeviceCommandId_t id,
-        const uint8_t* packet) {
-    CommandMessage directReplyMessage;
-    if(fullInfoPrintout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TestDevice" << deviceIdx << "::interpretingReply1: Setting data reply" <<
-                std::endl;
-#else
-        sif::printInfo("TestDevice%d::interpretingReply1: Setting data reply\n", deviceIdx);
-#endif
-    }
-
-    MessageQueueId_t commander = getCommanderQueueId(id);
-    /* Send reply with data */
-    ReturnValue_t result = actionHelper.reportData(commander, id, packet,
-            testdevice::TEST_COMMAND_1_SIZE, false);
-
-    if (result != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TestDevice" << deviceIdx << "::interpretingReply1: Sending data "
-                "reply failed!" << std::endl;
-#else
-        sif::printError("TestDevice%d::interpretingReply1: Sending data reply failed!\n",
-                deviceIdx);
-#endif
-        return result;
-    }
-
-    if(result == HasReturnvaluesIF::RETURN_OK) {
-        /* Finish reply */
-        actionHelper.finish(true, commander, id);
-    }
-    else {
-        /* Finish reply */
-        actionHelper.finish(false, commander, id, result);
-    }
-
-    return RETURN_OK;
-}
-
-uint32_t TestDevice::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
-    return 5000;
-}
-
-void TestDevice::enableFullDebugOutput(bool enable) {
-    this->fullInfoPrintout = enable;
-}
-
-ReturnValue_t TestDevice::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-        LocalDataPoolManager &poolManager) {
-    namespace td = testdevice;
-    localDataPoolMap.emplace(td::PoolIds::TEST_UINT8_ID, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(td::PoolIds::TEST_UINT32_ID, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(td::PoolIds::TEST_FLOAT_VEC_3_ID,
-            new PoolEntry<float>({0.0, 0.0, 0.0}));
-
-    sid_t sid;
-    if(deviceIdx == td::DeviceIndex::DEVICE_0) {
-        sid = td::TEST_SET_DEV_0_SID;
-    }
-    else {
-        sid = td::TEST_SET_DEV_1_SID;
-    }
-    /* Subscribe for periodic HK packets but do not enable reporting for now.
-    Non-diangostic with a period of one second */
-    poolManager.subscribeForPeriodicPacket(sid, false, 1.0, false);
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t TestDevice::getParameter(uint8_t domainId, uint8_t uniqueId,
-        ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
-        uint16_t startAtIndex) {
-    using namespace testdevice;
-    switch (uniqueId) {
-    case ParameterUniqueIds::TEST_UINT32_0: {
-        if(fullInfoPrintout) {
-            uint32_t newValue = 0;
-            ReturnValue_t result = newValues->getElement<uint32_t>(&newValue, 0, 0);
-            if(result == HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-                sif::info << "TestDevice" << deviceIdx << "::getParameter: Setting parameter 0 to "
-                        "new value " << newValue << std::endl;
-#else
-                sif::printInfo("TestDevice%d::getParameter: Setting parameter 0 to new value %lu\n",
-                        deviceIdx, static_cast<unsigned long>(newValue));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-            }
-        }
-        parameterWrapper->set(testParameter0);
-        break;
-    }
-    case ParameterUniqueIds::TEST_INT32_1: {
-        if(fullInfoPrintout) {
-            int32_t newValue = 0;
-            ReturnValue_t result = newValues->getElement<int32_t>(&newValue, 0, 0);
-            if(result == HasReturnvaluesIF::RETURN_OK) {
-#if OBSW_DEVICE_HANDLER_PRINTOUT == 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-                sif::info << "TestDevice" << deviceIdx << "::getParameter: Setting parameter 1 to "
-                        "new value " << newValue << std::endl;
-#else
-                sif::printInfo("TestDevice%d::getParameter: Setting parameter 1 to new value %lu\n",
-                        deviceIdx, static_cast<unsigned long>(newValue));
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* OBSW_DEVICE_HANDLER_PRINTOUT == 1 */
-            }
-        }
-        parameterWrapper->set(testParameter1);
-        break;
-    }
-    case ParameterUniqueIds::TEST_FLOAT_VEC3_2: {
-        if(fullInfoPrintout) {
-            float newVector[3];
-            if(newValues->getElement<float>(newVector, 0, 0) != RETURN_OK or
-                    newValues->getElement<float>(newVector + 1, 0, 1) != RETURN_OK or
-                    newValues->getElement<float>(newVector + 2, 0, 2) != RETURN_OK) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-#if OBSW_DEVICE_HANDLER_PRINTOUT == 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::getParameter: Setting parameter 3 to "
-                    "(float vector with 3 entries) to new values [" << newVector[0] << ", " <<
-                    newVector[1] << ", " << newVector[2] << "]" << std::endl;
-#else
-            sif::printInfo("TestDevice%d::getParameter: Setting parameter 3 to new values "
-                    "[%f, %f, %f]\n", deviceIdx, newVector[0], newVector[1], newVector[2]);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* OBSW_DEVICE_HANDLER_PRINTOUT == 1 */
-        }
-        parameterWrapper->setVector(vectorFloatParams2);
-        break;
-    }
-    case(ParameterUniqueIds::PERIODIC_PRINT_ENABLED): {
-        if(fullInfoPrintout) {
-            uint8_t enabled = 0;
-            ReturnValue_t result = newValues->getElement<uint8_t>(&enabled, 0, 0);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                return result;
-            }
-            char const* printout = nullptr;
-            if (enabled) {
-                printout = "enabled";
-            }
-            else {
-                printout = "disabled";
-            }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::getParameter: Periodic printout " <<
-                    printout << std::endl;
-#else
-            sif::printInfo("TestDevice%d::getParameter: Periodic printout %s", printout);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        }
-
-        parameterWrapper->set(periodicPrintout);
-        break;
-    }
-    case(ParameterUniqueIds::CHANGING_DATASETS): {
-
-        uint8_t enabled = 0;
-        ReturnValue_t result = newValues->getElement<uint8_t>(&enabled, 0, 0);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-        if(not enabled) {
-            PoolReadGuard readHelper(&dataset);
-            dataset.testUint8Var.value = 0;
-            dataset.testUint32Var.value = 0;
-            dataset.testFloat3Vec.value[0] = 0.0;
-            dataset.testFloat3Vec.value[0] = 0.0;
-            dataset.testFloat3Vec.value[1] = 0.0;
-        }
-
-        if(fullInfoPrintout) {
-            char const* printout = nullptr;
-            if (enabled) {
-                printout = "enabled";
-            }
-            else {
-                printout = "disabled";
-            }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::info << "TestDevice" << deviceIdx << "::getParameter: Changing datasets " <<
-                    printout << std::endl;
-#else
-            sif::printInfo("TestDevice%d::getParameter: Changing datasets %s", printout);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-        }
-
-        parameterWrapper->set(changingDatasets);
-        break;
-    }
-    default:
-        return INVALID_IDENTIFIER_ID;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-LocalPoolObjectBase* TestDevice::getPoolObjectHandle(lp_id_t localPoolId) {
-    namespace td = testdevice;
-    if (localPoolId == td::PoolIds::TEST_UINT8_ID) {
-        return &dataset.testUint8Var;
-    }
-    else if (localPoolId == td::PoolIds::TEST_UINT32_ID) {
-        return &dataset.testUint32Var;
-    }
-    else if(localPoolId == td::PoolIds::TEST_FLOAT_VEC_3_ID) {
-        return &dataset.testFloat3Vec;
-    }
-    else {
-        return nullptr;
-    }
-}

mission/devices/TestDeviceHandler.h

@@ -1,142 +0,0 @@
-#ifndef TEST_TESTDEVICES_TESTDEVICEHANDLER_H_
-#define TEST_TESTDEVICES_TESTDEVICEHANDLER_H_
-
-#include "devicedefinitions/testDeviceDefinitions.h"
-
-#include <fsfw/devicehandlers/DeviceHandlerBase.h>
-#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
-#include <fsfw/timemanager/Countdown.h>
-
-/**
- * @brief 	Basic dummy device handler to test device commanding without a physical device.
- * @details
- * This test device handler provided a basic demo for the device handler object.
- * It can also be commanded with the following PUS services, using
- * the specified object ID of the test device handler.
- *
- * 	1. PUS Service 8 - Functional commanding
- * 	2. PUS Service 2 - Device access, raw commanding
- * 	3. PUS Service 20 - Parameter Management
- * 	4. PUS Service 3 - Housekeeping
-
- * @author	R. Mueller
- * @ingroup devices
- */
-class TestDevice: public DeviceHandlerBase {
-public:
-	/**
-	 * Build the test device in the factory.
-	 * @param objectId This ID will be assigned to the test device handler.
-	 * @param comIF The ID of the Communication IF used by test device handler.
-	 * @param cookie Cookie object used by the test device handler. This is
-	 * also used and passed to the comIF object.
-	 * @param onImmediately This will start a transition to MODE_ON immediately
-	 * so the device handler jumps into #doStartUp. Should only be used
-	 * in development to reduce need of commanding while debugging.
-	 * @param changingDataset
-	 * Will be used later to change the local datasets containeds in the device.
-	 */
-	TestDevice(object_id_t objectId, object_id_t comIF, CookieIF * cookie,
-	        testdevice::DeviceIndex deviceIdx = testdevice::DeviceIndex::DEVICE_0,
-	        bool fullInfoPrintout = false, bool changingDataset = true);
-
-	/**
-	 * This can be used to enable and disable a lot of demo print output.
-	 * @param enable
-	 */
-	void enableFullDebugOutput(bool enable);
-
-	virtual ~ TestDevice();
-
-	//! Size of internal buffer used for communication.
-    static constexpr uint8_t MAX_BUFFER_SIZE = 255;
-
-    //! Unique index if the device handler is created multiple times.
-    testdevice::DeviceIndex deviceIdx = testdevice::DeviceIndex::DEVICE_0;
-
-protected:
-    testdevice::TestDataSet dataset;
-    //! This is used to reset the dataset after a commanded change has been made.
-    bool resetAfterChange = false;
-    bool commandSent = false;
-
-	/** DeviceHandlerBase overrides (see DHB documentation) */
-
-	/**
-	 * Hook into the DHB #performOperation call which is executed
-	 * periodically.
-	 */
-	void performOperationHook() override;
-
-	virtual void doStartUp() override;
-	virtual void doShutDown() override;
-
-	virtual ReturnValue_t buildNormalDeviceCommand(
-			DeviceCommandId_t * id) override;
-	virtual ReturnValue_t buildTransitionDeviceCommand(
-			DeviceCommandId_t * id) override;
-	virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t
-			deviceCommand, const uint8_t * commandData,
-			size_t commandDataLen) override;
-
-	virtual void fillCommandAndReplyMap() override;
-
-	virtual ReturnValue_t scanForReply(const uint8_t *start, size_t len,
-			DeviceCommandId_t *foundId, size_t *foundLen) override;
-	virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) override;
-	virtual uint32_t getTransitionDelayMs(Mode_t modeFrom,
-			Mode_t modeTo) override;
-
-	virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
-
-    virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                LocalDataPoolManager& poolManager) override;
-    virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
-
-	/* HasParametersIF  overrides */
-	virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
-			ParameterWrapper *parameterWrapper,
-			const ParameterWrapper *newValues, uint16_t startAtIndex) override;
-
-	uint8_t commandBuffer[MAX_BUFFER_SIZE];
-
-	bool fullInfoPrintout = false;
-	bool oneShot = true;
-
-	/* Variables for parameter service */
-	uint32_t testParameter0 = 0;
-	int32_t testParameter1 = -2;
-	float vectorFloatParams2[3] = {};
-
-	/* Change device handler functionality, changeable via parameter service */
-	uint8_t periodicPrintout = false;
-	uint8_t changingDatasets = false;
-
-	ReturnValue_t buildNormalModeCommand(DeviceCommandId_t deviceCommand,
-	        const uint8_t* commandData, size_t commandDataLen);
-	ReturnValue_t buildTestCommand0(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
-	        size_t commandDataLen);
-	ReturnValue_t buildTestCommand1(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
-	        size_t commandDataLen);
-	void passOnCommand(DeviceCommandId_t command, const uint8_t* commandData,
-	        size_t commandDataLen);
-
-	ReturnValue_t interpretingNormalModeReply();
-	ReturnValue_t interpretingTestReply0(DeviceCommandId_t id,
-			const uint8_t* packet);
-	ReturnValue_t interpretingTestReply1(DeviceCommandId_t id,
-			const uint8_t* packet);
-	ReturnValue_t interpretingTestReply2(DeviceCommandId_t id, const uint8_t* packet);
-
-	/* Some timer utilities */
-	static constexpr uint8_t divider1 = 2;
-	PeriodicOperationDivider opDivider1 = PeriodicOperationDivider(divider1);
-	static constexpr uint8_t divider2 = 10;
-	PeriodicOperationDivider opDivider2 = PeriodicOperationDivider(divider2);
-	static constexpr uint32_t initTimeout = 2000;
-	Countdown countdown1 = Countdown(initTimeout);
-};
-
-
-#endif /* TEST_TESTDEVICES_TESTDEVICEHANDLER_H_ */

mission/devices/TestEchoComIF.cpp

@@ -1,86 +0,0 @@
-#include "TestEchoComIF.h"
-#include "TestCookie.h"
-
-#include <fsfw/serialize/SerializeAdapter.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/tmtcservices/CommandingServiceBase.h>
-#include <fsfw/tmtcpacket/pus/tm.h>
-
-
-TestEchoComIF::TestEchoComIF(object_id_t objectId):
-	SystemObject(objectId) {
-}
-
-TestEchoComIF::~TestEchoComIF() {}
-
-ReturnValue_t TestEchoComIF::initializeInterface(CookieIF * cookie) {
-	DummyCookie* dummyCookie = dynamic_cast<DummyCookie*>(cookie);
-	if(dummyCookie == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "TestEchoComIF::initializeInterface: Invalid cookie!" << std::endl;
-#else
-		sif::printWarning("TestEchoComIF::initializeInterface: Invalid cookie!\n");
-#endif
-		return NULLPOINTER;
-	}
-
-	auto resultPair = replyMap.emplace(
-	        dummyCookie->getAddress(), ReplyBuffer(dummyCookie->getReplyMaxLen()));
-	if(not resultPair.second) {
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-ReturnValue_t TestEchoComIF::sendMessage(CookieIF *cookie,
-		const uint8_t * sendData, size_t sendLen) {
-    DummyCookie* dummyCookie = dynamic_cast<DummyCookie*>(cookie);
-    if(dummyCookie == nullptr) {
-        return NULLPOINTER;
-    }
-
-    ReplyBuffer& replyBuffer = replyMap.find(dummyCookie->getAddress())->second;
-	if(sendLen > replyBuffer.capacity()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "TestEchoComIF::sendMessage: Send length " << sendLen << " larger than "
-		        "current reply buffer length!" << std::endl;
-#else
-		sif::printWarning("TestEchoComIF::sendMessage: Send length %d larger than current "
-		        "reply buffer length!\n", sendLen);
-#endif
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	replyBuffer.resize(sendLen);
-	memcpy(replyBuffer.data(), sendData, sendLen);
-	return RETURN_OK;
-}
-
-ReturnValue_t TestEchoComIF::getSendSuccess(CookieIF *cookie) {
-	return RETURN_OK;
-}
-
-ReturnValue_t TestEchoComIF::requestReceiveMessage(CookieIF *cookie,
-		size_t requestLen) {
-	return RETURN_OK;
-}
-
-ReturnValue_t TestEchoComIF::readReceivedMessage(CookieIF *cookie,
-		uint8_t **buffer, size_t *size) {
-    DummyCookie* dummyCookie = dynamic_cast<DummyCookie*>(cookie);
-    if(dummyCookie == nullptr) {
-        return NULLPOINTER;
-    }
-
-    ReplyBuffer& replyBuffer = replyMap.find(dummyCookie->getAddress())->second;
-	*buffer = replyBuffer.data();
-	*size = replyBuffer.size();
-
-	dummyReplyCounter ++;
-	if(dummyReplyCounter == 10) {
-		// add anything that needs to be read periodically by dummy handler
-		dummyReplyCounter = 0;
-	}
-	return RETURN_OK;
-
-}
-

mission/devices/TestEchoComIF.h

@@ -1,56 +0,0 @@
-#ifndef TEST_TESTDEVICES_TESTECHOCOMIF_H_
-#define TEST_TESTDEVICES_TESTECHOCOMIF_H_
-
-#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
-
-#include <vector>
-
-/**
- * @brief Used to simply returned sent data from device handler
- * @details Assign this com IF in the factory when creating the device handler
- * @ingroup test
- */
-class TestEchoComIF: public DeviceCommunicationIF, public SystemObject {
-public:
-	TestEchoComIF(object_id_t objectId);
-	virtual ~TestEchoComIF();
-
-	/**
-	 * DeviceCommunicationIF overrides
-	 * (see DeviceCommunicationIF documentation
-	 */
-	ReturnValue_t initializeInterface(CookieIF * cookie) override;
-	ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
-	        size_t sendLen) override;
-	ReturnValue_t getSendSuccess(CookieIF *cookie) override;
-	ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-	        size_t requestLen) override;
-	ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
-	        size_t *size) override;
-
-private:
-
-	/**
-	 * Send TM packet which contains received data as TM[17,130].
-	 * Wiretapping will do the same.
-	 * @param data
-	 * @param len
-	 */
-	void sendTmPacket(const uint8_t *data,uint32_t len);
-
-	AcceptsTelemetryIF* funnel = nullptr;
-	MessageQueueIF* tmQueue = nullptr;
-	size_t replyMaxLen = 0;
-
-	using ReplyBuffer = std::vector<uint8_t>;
-	std::map<address_t, ReplyBuffer> replyMap;
-
-	uint8_t dummyReplyCounter = 0;
-
-	uint16_t packetSubCounter = 0;
-};
-
-#endif /* TEST_TESTDEVICES_TESTECHOCOMIF_H_ */

mission/devices/devicedefinitions/testDeviceDefinitions.h

@@ -1,100 +0,0 @@
-#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_
-#define MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_
-
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <commonSystemObjects.h>
-
-namespace testdevice {
-
-enum ParameterUniqueIds: uint8_t {
-    TEST_UINT32_0,
-    TEST_INT32_1,
-    TEST_FLOAT_VEC3_2,
-    PERIODIC_PRINT_ENABLED,
-    CHANGING_DATASETS
-};
-
-enum DeviceIndex: uint32_t {
-    DEVICE_0,
-    DEVICE_1
-};
-
-/** Normal mode command. This ID is also used to access the set variable via the housekeeping
-service */
-static constexpr DeviceCommandId_t TEST_NORMAL_MODE_CMD = 0;
-
-//! Test completion reply
-static constexpr DeviceCommandId_t TEST_COMMAND_0 = 1;
-//! Test data reply
-static constexpr DeviceCommandId_t TEST_COMMAND_1 = 2;
-
-/**
- * Can be used to trigger a notification to the demo controller. For DEVICE_0, only notifications
- * messages will be generated while for DEVICE_1, snapshot messages will be generated.
- *
- * DEVICE_0 VAR:    Sets the set variable 0 above a treshold (200) to trigger a variable
- *                  notification.
- * DEVICE_0 SET:    Sets the vector mean values above a treshold (mean larger than 20) to trigger a
- *                  set notification.
- *
- * DEVICE_1 VAR:    Sets the set variable 0 below a treshold (less than 50 but not 0) to trigger a
- *                  variable snapshot.
- * DEVICE_1 SET:    Sets the set vector mean values below a treshold (mean smaller than -20) to
- *                  trigger a set snapshot message.
- */
-static constexpr DeviceCommandId_t TEST_NOTIF_SNAPSHOT_VAR = 3;
-static constexpr DeviceCommandId_t TEST_NOTIF_SNAPSHOT_SET = 4;
-
-/**
- * Can be used to trigger a snapshot message to the demo controller.
- * Depending on the device index, a notification will be triggered for different set variables.
- *
- * DEVICE_0:    Sets the set variable 0 below a treshold (below 50 but not 0) to trigger
- *              a variable snapshot
- * DEVICE_1:    Sets the vector mean values below a treshold (mean less than -20) to trigger a
- *              set snapshot
- */
-static constexpr DeviceCommandId_t TEST_SNAPSHOT = 5;
-
-//! Generates a random value for variable 1 of the dataset.
-static constexpr DeviceCommandId_t GENERATE_SET_VAR_1_RNG_VALUE = 6;
-
-
-/**
- * These parameters are sent back with the command ID as a data reply
- */
-static constexpr uint16_t COMMAND_1_PARAM1 = 0xBAB0; //!< param1, 2 bytes
-//! param2, 8 bytes
-static constexpr uint64_t COMMAND_1_PARAM2 = 0x000000524F42494E;
-
-static constexpr size_t TEST_COMMAND_0_SIZE = sizeof(TEST_COMMAND_0);
-static constexpr size_t TEST_COMMAND_1_SIZE = sizeof(TEST_COMMAND_1) + sizeof(COMMAND_1_PARAM1) +
-        sizeof(COMMAND_1_PARAM2);
-
-enum PoolIds: lp_id_t {
-    TEST_UINT8_ID = 0,
-    TEST_UINT32_ID = 1,
-    TEST_FLOAT_VEC_3_ID = 2
-};
-
-static constexpr uint8_t TEST_SET_ID = TEST_NORMAL_MODE_CMD;
-static const sid_t TEST_SET_DEV_0_SID = sid_t(objects::TEST_DEVICE_HANDLER_0, TEST_SET_ID);
-static const sid_t TEST_SET_DEV_1_SID = sid_t(objects::TEST_DEVICE_HANDLER_1, TEST_SET_ID);
-
-class TestDataSet: public StaticLocalDataSet<3> {
-public:
-    TestDataSet(HasLocalDataPoolIF* owner): StaticLocalDataSet(owner, TEST_SET_ID) {}
-    TestDataSet(object_id_t owner): StaticLocalDataSet(sid_t(owner, TEST_SET_ID)) {}
-
-    lp_var_t<uint8_t> testUint8Var = lp_var_t<uint8_t>(
-            gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT8_ID), this);
-    lp_var_t<uint32_t> testUint32Var = lp_var_t<uint32_t>(
-            gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT32_ID), this);
-    lp_vec_t<float ,3> testFloat3Vec = lp_vec_t<float, 3>(
-            gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_FLOAT_VEC_3_ID), this);
-};
-
-}
-
-#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_ */

mission/mission.mk

@@ -1,17 +0,0 @@
-# add main and others
-CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/*.c)
-
-CSRC += $(wildcard $(CURRENTPATH)/core/*.c)
-CXXSRC += $(wildcard $(CURRENTPATH)/core/*.cpp)
-
-CXXSRC += $(wildcard $(CURRENTPATH)/devices/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/devices/*.c)
-
-CXXSRC += $(wildcard $(CURRENTPATH)/utility/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/utility/*.c)
-
-CXXSRC += $(wildcard $(CURRENTPATH)/test/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/test/*.c)
-
-

mission/utility/CMakeLists.txt

@@ -1,5 +0,0 @@
-target_sources(${TARGET_NAME} 
-	PRIVATE
-		PusPacketCreator.cpp
-		TmFunnel.cpp
-)

mission/utility/TaskCreation.h

@@ -1,22 +0,0 @@
-#ifndef MISSION_UTILITY_TASKCREATION_H_
-#define MISSION_UTILITY_TASKCREATION_H_
-
-#include <fsfw/objectmanager/SystemObjectIF.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-namespace task {
-
-void printInitError(const char* objName, object_id_t objectId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::error << "InitMission: Adding object " << objName << "("
-			<< std::setw(8) << std::setfill('0') << std::hex << objectId
-			<< std::dec << ") failed." << std::endl;
-#else
-	sif::printError("InitMission: Adding object %s (0x%08x) failed.\n",
-			objName, static_cast<unsigned int>(objectId));
-#endif
-}
-
-}
-
-#endif /* MISSION_UTILITY_TASKCREATION_H_ */

mission/utility/TmFunnel.cpp

@@ -1,119 +0,0 @@
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/tmtcpacket/pus/tm.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <mission/utility/TmFunnel.h>
-
-object_id_t TmFunnel::downlinkDestination = objects::NO_OBJECT;
-object_id_t TmFunnel::storageDestination = objects::NO_OBJECT;
-
-TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth):
-                SystemObject(objectId), messageDepth(messageDepth) {
-    tmQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
-            MessageQueueMessage::MAX_MESSAGE_SIZE);
-    storageQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
-            MessageQueueMessage::MAX_MESSAGE_SIZE);
-}
-
-TmFunnel::~TmFunnel() {
-}
-
-MessageQueueId_t TmFunnel::getReportReceptionQueue(uint8_t virtualChannel) {
-    return tmQueue->getId();
-}
-
-ReturnValue_t TmFunnel::performOperation(uint8_t operationCode) {
-    TmTcMessage currentMessage;
-    ReturnValue_t status = tmQueue->receiveMessage(&currentMessage);
-    while(status == HasReturnvaluesIF::RETURN_OK)
-    {
-        status = handlePacket(&currentMessage);
-        if(status != HasReturnvaluesIF::RETURN_OK){
-            break;
-        }
-        status = tmQueue->receiveMessage(&currentMessage);
-    }
-
-    if (status == MessageQueueIF::EMPTY) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-        return status;
-    }
-}
-
-ReturnValue_t TmFunnel::handlePacket(TmTcMessage* message) {
-    uint8_t* packetData = nullptr;
-    size_t size = 0;
-    ReturnValue_t result = tmPool->modifyData(message->getStorageId(),
-            &packetData, &size);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        return result;
-    }
-    TmPacketPusC packet(packetData);
-    packet.setPacketSequenceCount(this->sourceSequenceCount);
-    sourceSequenceCount++;
-    sourceSequenceCount = sourceSequenceCount %
-            SpacePacketBase::LIMIT_SEQUENCE_COUNT;
-    packet.setErrorControl();
-
-    result = tmQueue->sendToDefault(message);
-    if(result != HasReturnvaluesIF::RETURN_OK){
-        tmPool->deleteData(message->getStorageId());
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmFunnel::handlePacket: Error sending to downlink handler" << std::endl;
-#endif
-        return result;
-    }
-
-    if(storageDestination != objects::NO_OBJECT) {
-        result = storageQueue->sendToDefault(message);
-        if(result != HasReturnvaluesIF::RETURN_OK){
-            tmPool->deleteData(message->getStorageId());
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "TmFunnel::handlePacket: Error sending to storage handler" << std::endl;
-#endif
-            return result;
-        }
-    }
-    return result;
-}
-
-ReturnValue_t TmFunnel::initialize() {
-
-    tmPool = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
-    if(tmPool == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmFunnel::initialize: TM store not set." << std::endl;
-        sif::error << "Make sure the tm store is set up properly and implements StorageManagerIF" <<
-                std::endl;
-#endif
-        return ObjectManagerIF::CHILD_INIT_FAILED;
-    }
-
-    AcceptsTelemetryIF* tmTarget = ObjectManager::instance()->
-            get<AcceptsTelemetryIF>(downlinkDestination);
-    if(tmTarget == nullptr){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "TmFunnel::initialize: Downlink Destination not set." << std::endl;
-        sif::error << "Make sure the downlink destination object is set up properly and implements "
-                "AcceptsTelemetryIF" << std::endl;
-#endif
-        return ObjectManagerIF::CHILD_INIT_FAILED;
-    }
-    tmQueue->setDefaultDestination(tmTarget->getReportReceptionQueue());
-
-    // Storage destination is optional.
-    if(storageDestination == objects::NO_OBJECT) {
-        return SystemObject::initialize();
-    }
-
-    AcceptsTelemetryIF* storageTarget = ObjectManager::instance()->
-            get<AcceptsTelemetryIF>(storageDestination);
-    if(storageTarget != nullptr) {
-        storageQueue->setDefaultDestination(
-                storageTarget->getReportReceptionQueue());
-    }
-
-    return SystemObject::initialize();
-}

mission/utility/TmFunnel.h

@@ -1,51 +0,0 @@
-#ifndef MISSION_UTILITY_TMFUNNEL_H_
-#define MISSION_UTILITY_TMFUNNEL_H_
-
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/tasks/ExecutableObjectIF.h>
-#include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/tmtcservices/TmTcMessage.h>
-
-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
-/**
- * @brief       TM Recipient.
- * @details
- * Main telemetry receiver. All generated telemetry is funneled into
- * this object.
- * @ingroup     utility
- * @author      J. Meier
- */
-class TmFunnel:
-        public AcceptsTelemetryIF,
-        public ExecutableObjectIF,
-        public SystemObject {
-    friend void (Factory::setStaticFrameworkObjectIds)();
-public:
-    TmFunnel(object_id_t objectId, uint32_t messageDepth = 20);
-    virtual ~TmFunnel();
-
-    virtual MessageQueueId_t getReportReceptionQueue(
-            uint8_t virtualChannel = 0) override;
-    virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-    virtual ReturnValue_t initialize() override;
-
-protected:
-    static object_id_t downlinkDestination;
-    static object_id_t storageDestination;
-
-private:
-    uint16_t sourceSequenceCount = 0;
-    MessageQueueIF* tmQueue = nullptr;
-    MessageQueueIF* storageQueue = nullptr;
-
-    StorageManagerIF* tmPool = nullptr;
-    uint32_t messageDepth = 0;
-
-    ReturnValue_t handlePacket(TmTcMessage* message);
-};
-
-#endif /* MISSION_UTILITY_TMFUNNEL_H_ */

mission/utility/compile_time.h

@@ -1,97 +0,0 @@
-/*
- *
- * Created: 29.03.2018
- *
- * Authors:
- *
- * Assembled from the code released on Stackoverflow by:
- *   Dennis (instructable.com/member/nqtronix)    |   https://stackoverflow.com/questions/23032002/c-c-how-to-get-integer-unix-timestamp-of-build-time-not-string
- * and
- *   Alexis Wilke                                 |   https://stackoverflow.com/questions/10538444/do-you-know-of-a-c-macro-to-compute-unix-time-and-date
- *
- * Assembled by Jean Rabault
- *
- * UNIX_TIMESTAMP gives the UNIX timestamp (unsigned long integer of seconds since 1st Jan 1970) of compilation from macros using the compiler defined __TIME__ macro.
- * This should include Gregorian calendar leap days, in particular the 29ths of February, 100 and 400 years modulo leaps.
- *
- * Careful: __TIME__ is the local time of the computer, NOT the UTC time in general!
- *
- */
-
-#ifndef COMPILE_TIME_H_
-#define COMPILE_TIME_H_
-
-// Some definitions for calculation
-#define SEC_PER_MIN             60UL
-#define SEC_PER_HOUR            3600UL
-#define SEC_PER_DAY             86400UL
-#define SEC_PER_YEAR            (SEC_PER_DAY*365)
-
-// extracts 1..4 characters from a string and interprets it as a decimal value
-#define CONV_STR2DEC_1(str, i)  (str[i]>'0'?str[i]-'0':0)
-#define CONV_STR2DEC_2(str, i)  (CONV_STR2DEC_1(str, i)*10 + str[i+1]-'0')
-#define CONV_STR2DEC_3(str, i)  (CONV_STR2DEC_2(str, i)*10 + str[i+2]-'0')
-#define CONV_STR2DEC_4(str, i)  (CONV_STR2DEC_3(str, i)*10 + str[i+3]-'0')
-
-// Custom "glue logic" to convert the month name to a usable number
-#define GET_MONTH(str, i)      (str[i]=='J' && str[i+1]=='a' && str[i+2]=='n' ? 1 :     \
-                                str[i]=='F' && str[i+1]=='e' && str[i+2]=='b' ? 2 :     \
-                                str[i]=='M' && str[i+1]=='a' && str[i+2]=='r' ? 3 :     \
-                                str[i]=='A' && str[i+1]=='p' && str[i+2]=='r' ? 4 :     \
-                                str[i]=='M' && str[i+1]=='a' && str[i+2]=='y' ? 5 :     \
-                                str[i]=='J' && str[i+1]=='u' && str[i+2]=='n' ? 6 :     \
-                                str[i]=='J' && str[i+1]=='u' && str[i+2]=='l' ? 7 :     \
-                                str[i]=='A' && str[i+1]=='u' && str[i+2]=='g' ? 8 :     \
-                                str[i]=='S' && str[i+1]=='e' && str[i+2]=='p' ? 9 :     \
-                                str[i]=='O' && str[i+1]=='c' && str[i+2]=='t' ? 10 :    \
-                                str[i]=='N' && str[i+1]=='o' && str[i+2]=='v' ? 11 :    \
-                                str[i]=='D' && str[i+1]=='e' && str[i+2]=='c' ? 12 : 0)
-
-// extract the information from the time string given by __TIME__ and __DATE__
-#define __TIME_SECONDS__        CONV_STR2DEC_2(__TIME__, 6)
-#define __TIME_MINUTES__        CONV_STR2DEC_2(__TIME__, 3)
-#define __TIME_HOURS__          CONV_STR2DEC_2(__TIME__, 0)
-#define __TIME_DAYS__           CONV_STR2DEC_2(__DATE__, 4)
-#define __TIME_MONTH__          GET_MONTH(__DATE__, 0)
-#define __TIME_YEARS__          CONV_STR2DEC_4(__DATE__, 7)
-
-// Days in February
-#define _UNIX_TIMESTAMP_FDAY(year) \
-    (((year) % 400) == 0UL ? 29UL : \
-        (((year) % 100) == 0UL ? 28UL : \
-            (((year) % 4) == 0UL ? 29UL : \
-                28UL)))
-
-// Days in the year
-#define _UNIX_TIMESTAMP_YDAY(year, month, day) \
-    ( \
-        /* January */    day \
-        /* February */ + (month >=  2 ? 31UL : 0UL) \
-        /* March */    + (month >=  3 ? _UNIX_TIMESTAMP_FDAY(year) : 0UL) \
-        /* April */    + (month >=  4 ? 31UL : 0UL) \
-        /* May */      + (month >=  5 ? 30UL : 0UL) \
-        /* June */     + (month >=  6 ? 31UL : 0UL) \
-        /* July */     + (month >=  7 ? 30UL : 0UL) \
-        /* August */   + (month >=  8 ? 31UL : 0UL) \
-        /* September */+ (month >=  9 ? 31UL : 0UL) \
-        /* October */  + (month >= 10 ? 30UL : 0UL) \
-        /* November */ + (month >= 11 ? 31UL : 0UL) \
-        /* December */ + (month >= 12 ? 30UL : 0UL) \
-    )
-
-// get the UNIX timestamp from a digits representation
-#define _UNIX_TIMESTAMP(year, month, day, hour, minute, second) \
-    ( /* time */ second \
-                + minute * SEC_PER_MIN \
-                + hour * SEC_PER_HOUR \
-    + /* year day (month + day) */ (_UNIX_TIMESTAMP_YDAY(year, month, day) - 1) * SEC_PER_DAY \
-    + /* year */ (year - 1970UL) * SEC_PER_YEAR \
-                + ((year - 1969UL) / 4UL) * SEC_PER_DAY \
-                - ((year - 1901UL) / 100UL) * SEC_PER_DAY \
-                + ((year - 1601UL) / 400UL) * SEC_PER_DAY \
-    )
-
-// the UNIX timestamp
-#define UNIX_TIMESTAMP (_UNIX_TIMESTAMP(__TIME_YEARS__, __TIME_MONTH__, __TIME_DAYS__, __TIME_HOURS__, __TIME_MINUTES__, __TIME_SECONDS__))
-
-#endif

scripts/auto-formatter.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+counter=0
+common_example_dir="example_common"
+while [ ${counter} -lt 5 ]
+do
+    if [ ! -d ${common_example_dir} ];then
+        break
+    fi
+    counter=$((counter=counter + 1))
+    cd ..
+done
+
+if [ "${counter}" -ge 5 ];then
+    echo "${common_example_dir} not found in upper directories!"
+    exit 1
+fi
+
+folder_list=(
+  "./bsp_hosted"
+  "./example_common"
+)
+
+cmake_fmt="cmake-format"
+file_selectors="-iname CMakeLists.txt"
+if command -v ${cmake_fmt} &> /dev/null; then
+  echo "Auto-formatting all CMakeLists.txt files"
+  ${cmake_fmt} -i CMakeLists.txt
+  for dir in ${folder_list[@]}; do
+    find ${dir} ${file_selectors} | xargs ${cmake_fmt} -i
+  done
+else
+  echo "No ${cmake_fmt} tool found, not formatting CMake files"
+fi
+
+cpp_format="clang-format"
+file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
+if command -v ${cpp_format} &> /dev/null; then
+  for dir in ${folder_list[@]}; do
+    echo "Auto-formatting C/C++ files in ${dir} recursively"
+    find ${dir} ${file_selectors} | xargs ${cpp_format} --style=file -i
+  done
+else
+  echo "No ${cpp_format} tool found, not formatting C++/C files"
+fi

stm32h7/CMakeLists.txt

@@ -1,9 +1,7 @@
-target_sources(${TARGET_NAME} PRIVATE
-	STM32TestTask.cpp
-)
+target_sources(${TARGET_NAME} PRIVATE STM32TestTask.cpp)
 
 option(STM32_ADD_NETWORKING_CODE "Add networking code requiring lwIP" ON)
 
 if(STM32_ADD_NETWORKING_CODE)
-    add_subdirectory(networking)
-endif()
+  add_subdirectory(networking)
+endif()

stm32h7/STM32TestTask.cpp

@@ -1,22 +1,34 @@
 #include "STM32TestTask.h"
-#include "stm32h7xx_nucleo.h"
+
 #include "OBSWConfig.h"
+#include "stm32h7xx_nucleo.h"
 
 STM32TestTask::STM32TestTask(object_id_t objectId, bool enablePrintout,
-		bool blinkyLed): TestTask(objectId, enablePrintout),
-		blinkyLed(blinkyLed) {
-    BSP_LED_Init(LED1);
-    BSP_LED_Init(LED2);
-    BSP_LED_Init(LED3);
+                             bool blinkyLed)
+    : TestTask(objectId), blinkyLed(blinkyLed) {
+  BSP_LED_Init(LED1);
+  BSP_LED_Init(LED2);
+  BSP_LED_Init(LED3);
 }
 
 ReturnValue_t STM32TestTask::performPeriodicAction() {
-    if(blinkyLed) {
+  if (blinkyLed) {
 #if OBSW_ETHERNET_USE_LEDS == 0
-        BSP_LED_Toggle(LED1);
-        BSP_LED_Toggle(LED2);
+    BSP_LED_Toggle(LED1);
+    BSP_LED_Toggle(LED2);
 #endif
-        BSP_LED_Toggle(LED3);
-    }
-    return TestTask::performPeriodicAction();
+    BSP_LED_Toggle(LED3);
+  }
+  if (testSpi) {
+    spiTest->performOperation();
+  }
+  return TestTask::performPeriodicAction();
+}
+
+ReturnValue_t STM32TestTask::initialize() {
+  if (testSpi) {
+    spiComIF = new SpiComIF(objects::SPI_COM_IF);
+    spiTest = new SpiTest(*spiComIF);
+  }
+  return TestTask::initialize();
 }

stm32h7/STM32TestTask.h

@@ -1,19 +1,23 @@
 #ifndef BSP_STM32_BOARDTEST_STM32TESTTASK_H_
 #define BSP_STM32_BOARDTEST_STM32TESTTASK_H_
 
-#include "../test/TestTask.h"
+#include "bsp_stm32h7_freertos/boardtest/SpiTest.h"
+#include "fsfw_tests/integration/task/TestTask.h"
 
-class STM32TestTask: public TestTask {
+class STM32TestTask : public TestTask {
 public:
-	STM32TestTask(object_id_t objectId, bool enablePrintout, bool blinkyLed = true);
+  STM32TestTask(object_id_t objectId, bool enablePrintout,
+                bool blinkyLed = true);
+
+  ReturnValue_t initialize() override;
+  ReturnValue_t performPeriodicAction() override;
 
-	ReturnValue_t performPeriodicAction() override;
 private:
+  SpiComIF *spiComIF = nullptr;
+  SpiTest *spiTest = nullptr;
 
-	bool blinkyLed = false;
-
+  bool blinkyLed = false;
+  bool testSpi = true;
 };
 
-
-
 #endif /* BSP_STM32_BOARDTEST_STM32TESTTASK_H_ */

stm32h7/networking/CMakeLists.txt

@@ -1,14 +1,8 @@
 # These are part of the RTEMS BSP for RTEMS
 if(FSFW_OSAL MATCHES freertos)
-    target_sources(${TARGET_NAME} PRIVATE
-        ethernetif.c
-    )
+  target_sources(${TARGET_NAME} PRIVATE ethernetif.c)
 endif()
 
-target_sources(${TARGET_NAME} PRIVATE
-	UdpTcLwIpPollingTask.cpp
-	TmTcLwIpUdpBridge.cpp
-	networking.cpp
-    app_dhcp.cpp
-    app_ethernet.cpp
-)
+target_sources(
+  ${TARGET_NAME} PRIVATE UdpTcLwIpPollingTask.cpp TmTcLwIpUdpBridge.cpp
+                         networking.cpp app_dhcp.cpp app_ethernet.cpp)

stm32h7/networking/TmTcLwIpUdpBridge.cpp

@@ -1,204 +1,199 @@
 #include "TmTcLwIpUdpBridge.h"
-#include "udp_config.h"
+
+#include <OBSWConfig.h>
+#include <fsfw/ipc/MutexGuard.h>
+#include <fsfw/serialize/EndianConverter.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
 #include "app_ethernet.h"
 #include "ethernetif.h"
-#include <OBSWConfig.h>
-
-#include <fsfw/ipc/MutexGuard.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/serialize/EndianConverter.h>
-
+#include "udp_config.h"
 
 TmTcLwIpUdpBridge::TmTcLwIpUdpBridge(object_id_t objectId,
-        object_id_t ccsdsPacketDistributor, object_id_t tmStoreId,
-        object_id_t tcStoreId):
-        TmTcBridge(objectId, ccsdsPacketDistributor, tmStoreId, tcStoreId) {
-    TmTcLwIpUdpBridge::lastAdd.addr = IPADDR_TYPE_ANY;
+                                     object_id_t ccsdsPacketDistributor,
+                                     object_id_t tmStoreId,
+                                     object_id_t tcStoreId)
+    : TmTcBridge(objectId, ccsdsPacketDistributor, tmStoreId, tcStoreId) {
+  TmTcLwIpUdpBridge::lastAdd.addr = IPADDR_TYPE_ANY;
 }
 
 TmTcLwIpUdpBridge::~TmTcLwIpUdpBridge() {}
 
 ReturnValue_t TmTcLwIpUdpBridge::initialize() {
-    TmTcBridge::initialize();
-    bridgeLock = MutexFactory::instance()->createMutex();
-    if(bridgeLock == nullptr) {
-        return ObjectManagerIF::CHILD_INIT_FAILED;
-    }
-    ReturnValue_t result = udp_server_init();
-    return result;
+  TmTcBridge::initialize();
+  bridgeLock = MutexFactory::instance()->createMutex();
+  if (bridgeLock == nullptr) {
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  ReturnValue_t result = udp_server_init();
+  return result;
 }
 
 ReturnValue_t TmTcLwIpUdpBridge::udp_server_init(void) {
-    err_t err;
-    /* Create a new UDP control block  */
-    TmTcLwIpUdpBridge::upcb = udp_new();
-    if (TmTcLwIpUdpBridge::upcb)
-    {
-        /* Bind the upcb to the UDP_PORT port */
-        /* Using IP_ADDR_ANY allow the upcb to be used by any local interface */
-        err = udp_bind(TmTcLwIpUdpBridge::upcb, IP_ADDR_ANY, UDP_SERVER_PORT);
+  err_t err;
+  /* Create a new UDP control block  */
+  TmTcLwIpUdpBridge::upcb = udp_new();
+  if (TmTcLwIpUdpBridge::upcb) {
+    /* Bind the upcb to the UDP_PORT port */
+    /* Using IP_ADDR_ANY allow the upcb to be used by any local interface */
+    err = udp_bind(TmTcLwIpUdpBridge::upcb, IP_ADDR_ANY, UDP_SERVER_PORT);
 
-        if(err == ERR_OK)
-        {
-            /* Set a receive callback for the upcb */
-            udp_recv(TmTcLwIpUdpBridge::upcb, &udp_server_receive_callback,
-                    (void*) this);
-            return RETURN_OK;
-        }
-        else
-        {
-            udp_remove(TmTcLwIpUdpBridge::upcb);
-            return RETURN_FAILED;
-        }
+    if (err == ERR_OK) {
+      /* Set a receive callback for the upcb */
+      udp_recv(TmTcLwIpUdpBridge::upcb, &udp_server_receive_callback,
+               (void *)this);
+      return RETURN_OK;
     } else {
-        return RETURN_FAILED;
+      udp_remove(TmTcLwIpUdpBridge::upcb);
+      return RETURN_FAILED;
     }
+  } else {
+    return RETURN_FAILED;
+  }
 }
 
 ReturnValue_t TmTcLwIpUdpBridge::performOperation(uint8_t operationCode) {
-    TmTcBridge::performOperation();
+  TmTcBridge::performOperation();
 
 #if TCPIP_RECV_WIRETAPPING == 1
-    if(connectFlag) {
-        uint32_t ipAddress = ((ip4_addr*) &lastAdd)->addr;
-        int ipAddress1 = (ipAddress & 0xFF000000) >> 24;
-        int ipAddress2 = (ipAddress & 0xFF0000) >> 16;
-        int ipAddress3 = (ipAddress & 0xFF00) >> 8;
-        int ipAddress4 = ipAddress & 0xFF;
+  if (connectFlag) {
+    uint32_t ipAddress = ((ip4_addr *)&lastAdd)->addr;
+    int ipAddress1 = (ipAddress & 0xFF000000) >> 24;
+    int ipAddress2 = (ipAddress & 0xFF0000) >> 16;
+    int ipAddress3 = (ipAddress & 0xFF00) >> 8;
+    int ipAddress4 = ipAddress & 0xFF;
 #if OBSW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "TmTcLwIpUdpBridge: Client IP Address " << std::dec
-                << ipAddress4 << "." << ipAddress3 << "." << ipAddress2 << "."
-                << ipAddress1 << std::endl;
-        uint16_t portSwapped = EndianConverter::convertBigEndian(lastPort);
-        sif::info << "TmTcLwIpUdpBridge: Client IP Port "
-                << (int)portSwapped << std::endl;
+    sif::info << "TmTcLwIpUdpBridge: Client IP Address " << std::dec
+              << ipAddress4 << "." << ipAddress3 << "." << ipAddress2 << "."
+              << ipAddress1 << std::endl;
+    uint16_t portSwapped = EndianConverter::convertBigEndian(lastPort);
+    sif::info << "TmTcLwIpUdpBridge: Client IP Port " << (int)portSwapped
+              << std::endl;
 #else
-        sif::printInfo("TmTcLwIpUdpBridge: Client IP Address %d.%d.%d.%d\n",
-                ipAddress4, ipAddress3, ipAddress2, ipAddress1);
-        uint16_t portSwapped = EndianConverter::convertBigEndian(lastPort);
-        sif::printInfo("TmTcLwIpUdpBridge: Client IP Port: %d\n", portSwapped);
+    sif::printInfo("TmTcLwIpUdpBridge: Client IP Address %d.%d.%d.%d\n",
+                   ipAddress4, ipAddress3, ipAddress2, ipAddress1);
+    uint16_t portSwapped = EndianConverter::convertBigEndian(lastPort);
+    sif::printInfo("TmTcLwIpUdpBridge: Client IP Port: %d\n", portSwapped);
 #endif
 #endif
-        connectFlag = false;
-    }
+    connectFlag = false;
+  }
 #endif
 
-    return RETURN_OK;
+  return RETURN_OK;
 }
 
-ReturnValue_t TmTcLwIpUdpBridge::sendTm(const uint8_t * data, size_t dataLen) {
-    struct pbuf *p_tx = pbuf_alloc(PBUF_TRANSPORT, dataLen, PBUF_RAM);
-    if ((p_tx != nullptr) && (lastAdd.addr != IPADDR_TYPE_ANY) && (upcb != nullptr)) {
-        /* copy data to pbuf */
-        err_t err  = pbuf_take(p_tx, (char*) data, dataLen);
-        if(err!=ERR_OK){
-            pbuf_free(p_tx);
-            return err;
-        }
-        /* Connect to the remote client */
-        err = udp_connect(TmTcLwIpUdpBridge::upcb, &lastAdd , lastPort);
-        if(err != ERR_OK){
-            pbuf_free(p_tx);
-            return err;
-        }
-        /* Tell the client that we have accepted it */
-        err = udp_send(TmTcLwIpUdpBridge::upcb, p_tx);
-        pbuf_free(p_tx);
-        if(err!=ERR_OK){
-            return err;
-        }
-
-        /* free the UDP connection, so we can accept new clients */
-        udp_disconnect (TmTcLwIpUdpBridge::upcb);
+ReturnValue_t TmTcLwIpUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
+  struct pbuf *p_tx = pbuf_alloc(PBUF_TRANSPORT, dataLen, PBUF_RAM);
+  if ((p_tx != nullptr) && (lastAdd.addr != IPADDR_TYPE_ANY) &&
+      (upcb != nullptr)) {
+    /* copy data to pbuf */
+    err_t err = pbuf_take(p_tx, (char *)data, dataLen);
+    if (err != ERR_OK) {
+      pbuf_free(p_tx);
+      return err;
     }
-    else{
-        return RETURN_FAILED;
+    /* Connect to the remote client */
+    err = udp_connect(TmTcLwIpUdpBridge::upcb, &lastAdd, lastPort);
+    if (err != ERR_OK) {
+      pbuf_free(p_tx);
+      return err;
     }
-    return RETURN_OK;
-}
-
-
-void TmTcLwIpUdpBridge::udp_server_receive_callback(void* arg,
-        struct udp_pcb* upcb_, struct pbuf* p, const ip_addr_t* addr,
-        u16_t port) {
-    struct pbuf *p_tx = nullptr;
-    auto udpBridge = reinterpret_cast<TmTcLwIpUdpBridge*>(arg);
-    if(udpBridge == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid UDP bridge!" <<
-                std::endl;
-#else
-        sif::printWarning("TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid UDP bridge!\n");
-#endif
-    }
-    /* allocate pbuf from RAM*/
-    p_tx = pbuf_alloc(PBUF_TRANSPORT,p->len, PBUF_RAM);
-
-    if(p_tx != NULL)
-    {
-        if(udpBridge != nullptr) {
-            MutexGuard lg(udpBridge->bridgeLock);
-            udpBridge->upcb = upcb_;
-            udpBridge->lastAdd = *addr;
-            udpBridge->lastPort = port;
-            if(not udpBridge->comLinkUp()) {
-                udpBridge->registerCommConnect();
-#if TCPIP_RECV_WIRETAPPING == 1
-                udpBridge->connectFlag = true;
-#endif
-                /* This should have already been done, but we will still do it */
-                udpBridge->physicalConnectStatusChange(true);
-            }
-        }
-        pbuf_take(p_tx, (char*)p->payload, p->len);
-        /* send the received data to the uart port */
-        char* data = reinterpret_cast<char*>(p_tx->payload);
-        *(data+p_tx->len) = '\0';
-
-#if TCPIP_RECV_WIRETAPPING == 1
-        udpBridge->printData(p,data);
-#endif
-
-        store_address_t storeId;
-        ReturnValue_t returnValue = udpBridge->tcStore->addData(&storeId,
-                reinterpret_cast<uint8_t*>(p->payload), p->len);
-        if (returnValue != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "UDP Server: Data storage failed" << std::endl;
-#endif
-            pbuf_free(p_tx);
-            return;
-        }
-        TmTcMessage message(storeId);
-        if (udpBridge->tmTcReceptionQueue->sendToDefault(&message)
-                != RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "TmTcLwIpUdpBridgw::udp_server_receive_callback:"
-                    << " Sending message to queue failed" << std::endl;
-#endif
-            udpBridge->tcStore->deleteData(storeId);
-        }
-    }
-    /* Free the p_tx buffer */
+    /* Tell the client that we have accepted it */
+    err = udp_send(TmTcLwIpUdpBridge::upcb, p_tx);
     pbuf_free(p_tx);
+    if (err != ERR_OK) {
+      return err;
+    }
+
+    /* free the UDP connection, so we can accept new clients */
+    udp_disconnect(TmTcLwIpUdpBridge::upcb);
+  } else {
+    return RETURN_FAILED;
+  }
+  return RETURN_OK;
+}
+
+void TmTcLwIpUdpBridge::udp_server_receive_callback(void *arg,
+                                                    struct udp_pcb *upcb_,
+                                                    struct pbuf *p,
+                                                    const ip_addr_t *addr,
+                                                    u16_t port) {
+  struct pbuf *p_tx = nullptr;
+  auto udpBridge = reinterpret_cast<TmTcLwIpUdpBridge *>(arg);
+  if (udpBridge == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning
+        << "TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid UDP bridge!"
+        << std::endl;
+#else
+    sif::printWarning("TmTcLwIpUdpBridge::udp_server_receive_callback: Invalid "
+                      "UDP bridge!\n");
+#endif
+  }
+  /* allocate pbuf from RAM*/
+  p_tx = pbuf_alloc(PBUF_TRANSPORT, p->len, PBUF_RAM);
+
+  if (p_tx != NULL) {
+    if (udpBridge != nullptr) {
+      MutexGuard lg(udpBridge->bridgeLock);
+      udpBridge->upcb = upcb_;
+      udpBridge->lastAdd = *addr;
+      udpBridge->lastPort = port;
+      if (not udpBridge->comLinkUp()) {
+        udpBridge->registerCommConnect();
+#if TCPIP_RECV_WIRETAPPING == 1
+        udpBridge->connectFlag = true;
+#endif
+        /* This should have already been done, but we will still do it */
+        udpBridge->physicalConnectStatusChange(true);
+      }
+    }
+    pbuf_take(p_tx, (char *)p->payload, p->len);
+    /* send the received data to the uart port */
+    char *data = reinterpret_cast<char *>(p_tx->payload);
+    *(data + p_tx->len) = '\0';
+
+#if TCPIP_RECV_WIRETAPPING == 1
+    udpBridge->printData(p, data);
+#endif
+
+    store_address_t storeId;
+    ReturnValue_t returnValue = udpBridge->tcStore->addData(
+        &storeId, reinterpret_cast<uint8_t *>(p->payload), p->len);
+    if (returnValue != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "UDP Server: Data storage failed" << std::endl;
+#endif
+      pbuf_free(p_tx);
+      return;
+    }
+    TmTcMessage message(storeId);
+    if (udpBridge->tmTcReceptionQueue->sendToDefault(&message) != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "TmTcLwIpUdpBridgw::udp_server_receive_callback:"
+                   << " Sending message to queue failed" << std::endl;
+#endif
+      udpBridge->tcStore->deleteData(storeId);
+    }
+  }
+  /* Free the p_tx buffer */
+  pbuf_free(p_tx);
 }
 
 /* Caller must ensure thread-safety */
-bool TmTcLwIpUdpBridge::comLinkUp() const {
-    return communicationLinkUp;
-}
+bool TmTcLwIpUdpBridge::comLinkUp() const { return communicationLinkUp; }
 
 /* Caller must ensure thread-safety */
 void TmTcLwIpUdpBridge::physicalConnectStatusChange(bool connect) {
-    if(connect) {
-        /* Physical connection does not mean there is a recipient to send packets too.
-        This will be done by the receive callback! */
-        physicalConnection = true;
-    }
-    else {
-        physicalConnection = false;
-        /* If there is no physical connection, we can't send anything back */
-        registerCommDisconnect();
-    }
+  if (connect) {
+    /* Physical connection does not mean there is a recipient to send packets
+    too. This will be done by the receive callback! */
+    physicalConnection = true;
+  } else {
+    physicalConnection = false;
+    /* If there is no physical connection, we can't send anything back */
+    registerCommDisconnect();
+  }
 }

stm32h7/networking/TmTcLwIpUdpBridge.h

@@ -2,78 +2,78 @@
 #define BSP_STM32_RTEMS_NETWORKING_TMTCUDPBRIDGE_H_
 
 #include <fsfw/tmtcservices/TmTcBridge.h>
-
-#include <lwip/udp.h>
 #include <lwip/ip_addr.h>
+#include <lwip/udp.h>
 
 #define TCPIP_RECV_WIRETAPPING 0
 
 /**
- * This bridge is used to forward TMTC packets received via LwIP UDP to the internal software bus.
+ * This bridge is used to forward TMTC packets received via LwIP UDP to the
+ * internal software bus.
  */
 class TmTcLwIpUdpBridge : public TmTcBridge {
-    friend class UdpTcLwIpPollingTask;
+  friend class UdpTcLwIpPollingTask;
+
 public:
-    TmTcLwIpUdpBridge(object_id_t objectId,
-            object_id_t ccsdsPacketDistributor, object_id_t tmStoreId,
-            object_id_t tcStoreId);
-    virtual ~TmTcLwIpUdpBridge();
+  TmTcLwIpUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
+                    object_id_t tmStoreId, object_id_t tcStoreId);
+  virtual ~TmTcLwIpUdpBridge();
 
-    virtual ReturnValue_t initialize() override;
-    ReturnValue_t udp_server_init();
+  virtual ReturnValue_t initialize() override;
+  ReturnValue_t udp_server_init();
 
-    /**
-     * In addition to default implementation, ethernet link status is checked.
-     * @param operationCode
-     * @return
-     */
-    virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+  /**
+   * In addition to default implementation, ethernet link status is checked.
+   * @param operationCode
+   * @return
+   */
+  virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-    /** TM Send implementation uses udp_send function from lwIP stack
-     * @param data
-     * @param dataLen
-     * @return
-     */
-    virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
+  /** TM Send implementation uses udp_send function from lwIP stack
+   * @param data
+   * @param dataLen
+   * @return
+   */
+  virtual ReturnValue_t sendTm(const uint8_t *data, size_t dataLen) override;
 
-    /**
-     * @brief This function is called when an UDP datagram has been
-     * received on the port UDP_PORT.
-     * @param arg
-     * @param upcb_
-     * @param p
-     * @param addr Source address which will be bound to TmTcUdpBridge::lastAdd
-     * @param port
-     */
-    static void udp_server_receive_callback(void *arg,
-            struct udp_pcb *upcb_, struct pbuf *p, const ip_addr_t *addr,
-            u16_t port);
+  /**
+   * @brief This function is called when an UDP datagram has been
+   * received on the port UDP_PORT.
+   * @param arg
+   * @param upcb_
+   * @param p
+   * @param addr Source address which will be bound to TmTcUdpBridge::lastAdd
+   * @param port
+   */
+  static void udp_server_receive_callback(void *arg, struct udp_pcb *upcb_,
+                                          struct pbuf *p, const ip_addr_t *addr,
+                                          u16_t port);
 
-    /**
-     * Check whether the communication link is up.
-     * Caller must ensure thread-safety by using the bridge lock.
-     * @return
-     */
-    bool comLinkUp() const;
+  /**
+   * Check whether the communication link is up.
+   * Caller must ensure thread-safety by using the bridge lock.
+   * @return
+   */
+  bool comLinkUp() const;
 
 private:
-    struct udp_pcb *upcb = nullptr;
-    ip_addr_t lastAdd;
-    u16_t lastPort = 0;
-    bool physicalConnection = false;
-    MutexIF* bridgeLock = nullptr;
+  struct udp_pcb *upcb = nullptr;
+  ip_addr_t lastAdd;
+  u16_t lastPort = 0;
+  bool physicalConnection = false;
+  MutexIF *bridgeLock = nullptr;
 
 #if TCPIP_RECV_WIRETAPPING == 1
-    bool connectFlag = false;
+  bool connectFlag = false;
 #endif
 
-    /**
-     * Used to notify bridge about change in the physical ethernet connection.
-     * Connection does not mean that replies are possible (recipient not set yet), but
-     * disconnect means that we can't send anything. Caller must ensure thread-safety
-     * by using the bridge lock.
-     */
-    void physicalConnectStatusChange(bool connect);
+  /**
+   * Used to notify bridge about change in the physical ethernet connection.
+   * Connection does not mean that replies are possible (recipient not set yet),
+   * but disconnect means that we can't send anything. Caller must ensure
+   * thread-safety by using the bridge lock.
+   */
+  void physicalConnectStatusChange(bool connect);
 };
 
 #endif /* BSP_STM32_RTEMS_NETWORKING_TMTCUDPBRIDGE_H_ */

stm32h7/networking/UdpTcLwIpPollingTask.cpp

@@ -1,66 +1,63 @@
 #include "UdpTcLwIpPollingTask.h"
-#include "TmTcLwIpUdpBridge.h"
-#include "app_ethernet.h"
-#include "ethernetif.h"
-#include "app_dhcp.h"
-#include "networking.h"
+
 #include <hardware_init.h>
 
+#include "TmTcLwIpUdpBridge.h"
+#include "app_dhcp.h"
+#include "app_ethernet.h"
+#include "ethernetif.h"
 #include "fsfw/ipc/MutexGuard.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-
-
-
+#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "lwip/timeouts.h"
+#include "networking.h"
 
-UdpTcLwIpPollingTask::UdpTcLwIpPollingTask(object_id_t objectId, object_id_t bridgeId,
-            struct netif* gnetif):
-        SystemObject(objectId), periodicHandleCounter(0), bridgeId(bridgeId), gnetif(gnetif) {
-}
+UdpTcLwIpPollingTask::UdpTcLwIpPollingTask(object_id_t objectId,
+                                           object_id_t bridgeId,
+                                           struct netif *gnetif)
+    : SystemObject(objectId), periodicHandleCounter(0), bridgeId(bridgeId),
+      gnetif(gnetif) {}
 
-UdpTcLwIpPollingTask::~UdpTcLwIpPollingTask() {
-}
+UdpTcLwIpPollingTask::~UdpTcLwIpPollingTask() {}
 
 ReturnValue_t UdpTcLwIpPollingTask::initialize() {
-    udpBridge = ObjectManager::instance()->get<TmTcLwIpUdpBridge>(bridgeId);
-    if(udpBridge == nullptr) {
-        return ObjectManagerIF::CHILD_INIT_FAILED;
-    }
-    if (netif_is_link_up(gnetif)) {
-        networking::setEthCableConnected(true);
-    }
-    return RETURN_OK;
+  udpBridge = ObjectManager::instance()->get<TmTcLwIpUdpBridge>(bridgeId);
+  if (udpBridge == nullptr) {
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  if (netif_is_link_up(gnetif)) {
+    networking::setEthCableConnected(true);
+  }
+  return RETURN_OK;
 }
 
-
 /* Poll the EMAC Interface and pass content to the network interface (lwIP) */
 ReturnValue_t UdpTcLwIpPollingTask::performOperation(uint8_t operationCode) {
-    /* Read a received packet from the Ethernet buffers and send it
-	to the lwIP for handling */
-    ethernetif_input(gnetif);
+  /* Read a received packet from the Ethernet buffers and send it
+      to the lwIP for handling */
+  ethernetif_input(gnetif);
 
-    /* Handle timeouts */
-    sys_check_timeouts();
+  /* Handle timeouts */
+  sys_check_timeouts();
 
 #if LWIP_NETIF_LINK_CALLBACK == 1
-    networking::ethernetLinkPeriodicHandle(gnetif);
+  networking::ethernetLinkPeriodicHandle(gnetif);
 #endif
 
-    if(udpBridge != nullptr) {
-        MutexGuard lg(udpBridge->bridgeLock);
-        /* In case ethernet cable is disconnected */
-        if(not networking::getEthCableConnected() and udpBridge->comLinkUp()) {
-            udpBridge->physicalConnectStatusChange(false);
-        }
-        else if(networking::getEthCableConnected() and not udpBridge->comLinkUp()) {
-            udpBridge->physicalConnectStatusChange(true);
-        }
+  if (udpBridge != nullptr) {
+    MutexGuard lg(udpBridge->bridgeLock);
+    /* In case ethernet cable is disconnected */
+    if (not networking::getEthCableConnected() and udpBridge->comLinkUp()) {
+      udpBridge->physicalConnectStatusChange(false);
+    } else if (networking::getEthCableConnected() and
+               not udpBridge->comLinkUp()) {
+      udpBridge->physicalConnectStatusChange(true);
     }
+  }
 
 #if LWIP_DHCP == 1
-    DHCP_Periodic_Handle(gnetif);
+  DHCP_Periodic_Handle(gnetif);
 #endif
 
-    return RETURN_OK;
+  return RETURN_OK;
 }

stm32h7/networking/UdpTcLwIpPollingTask.h

@@ -2,9 +2,8 @@
 #define BSP_STM32_RTEMS_EMACPOLLINGTASK_H_
 
 #include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/tasks/ExecutableObjectIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
-
+#include <fsfw/tasks/ExecutableObjectIF.h>
 #include <lwip/netif.h>
 
 class TmTcLwIpUdpBridge;
@@ -13,29 +12,29 @@ class TmTcLwIpUdpBridge;
  * @brief Separate task to poll EMAC interface.
  * 		  Polled data is passed to the netif (lwIP)
  */
-class UdpTcLwIpPollingTask:
-        public SystemObject,
-        public ExecutableObjectIF,
-        public HasReturnvaluesIF {
+class UdpTcLwIpPollingTask : public SystemObject,
+                             public ExecutableObjectIF,
+                             public HasReturnvaluesIF {
 public:
-    UdpTcLwIpPollingTask(object_id_t objectId, object_id_t bridgeId, struct netif* gnetif);
-    virtual ~UdpTcLwIpPollingTask();
+  UdpTcLwIpPollingTask(object_id_t objectId, object_id_t bridgeId,
+                       struct netif *gnetif);
+  virtual ~UdpTcLwIpPollingTask();
 
-    virtual ReturnValue_t initialize() override;
+  virtual ReturnValue_t initialize() override;
+
+  /**
+   * Executed periodically.
+   * @param operationCode
+   * @return
+   */
+  virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-    /**
-     * Executed periodically.
-     * @param operationCode
-     * @return
-     */
-    virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 private:
-    static const uint8_t PERIODIC_HANDLE_TRIGGER = 5;
-    uint8_t periodicHandleCounter;
-    object_id_t bridgeId = 0;
-    TmTcLwIpUdpBridge* udpBridge = nullptr;
-    struct netif* gnetif = nullptr;
+  static const uint8_t PERIODIC_HANDLE_TRIGGER = 5;
+  uint8_t periodicHandleCounter;
+  object_id_t bridgeId = 0;
+  TmTcLwIpUdpBridge *udpBridge = nullptr;
+  struct netif *gnetif = nullptr;
 };
 
-
 #endif /* BSP_STM32_RTEMS_EMACPOLLINGTASK_H_ */

stm32h7/networking/app_dhcp.cpp

@@ -1,80 +1,78 @@
-#include "OBSWConfig.h"
-
 #include "app_dhcp.h"
-#include "app_ethernet.h"
-#include "networking.h"
-#include "udp_config.h"
-#include "ethernetif.h"
 
+#include "OBSWConfig.h"
+#include "app_ethernet.h"
+#include "ethernetif.h"
 #include "lwip/dhcp.h"
+#include "networking.h"
 #include "stm32h7xx_nucleo.h"
+#include "udp_config.h"
 
 #if LWIP_DHCP == 1
 
 uint8_t DHCP_state = DHCP_OFF;
 uint32_t DHCPfineTimer = 0;
 
-void handle_dhcp_timeout(struct netif* netif);
-void handle_dhcp_start(struct netif* netif);
-void handle_dhcp_wait(struct netif* netif, struct dhcp** dhcp);
-void handle_dhcp_down(struct netif* netif);
+void handle_dhcp_timeout(struct netif *netif);
+void handle_dhcp_start(struct netif *netif);
+void handle_dhcp_wait(struct netif *netif, struct dhcp **dhcp);
+void handle_dhcp_down(struct netif *netif);
 
 /**
  * @brief  DHCP_Process_Handle
  * @param  None
  * @retval None
  */
-void DHCP_Process(struct netif *netif)
-{
-    struct dhcp* dhcp = NULL;
-    switch (DHCP_state) {
-    case DHCP_START: {
-        handle_dhcp_start(netif);
-        break;
-    }
-    case DHCP_WAIT_ADDRESS: {
-        handle_dhcp_wait(netif, &dhcp);
-        break;
-    }
+void DHCP_Process(struct netif *netif) {
+  struct dhcp *dhcp = NULL;
+  switch (DHCP_state) {
+  case DHCP_START: {
+    handle_dhcp_start(netif);
+    break;
+  }
+  case DHCP_WAIT_ADDRESS: {
+    handle_dhcp_wait(netif, &dhcp);
+    break;
+  }
 
-    case DHCP_LINK_DOWN: {
-        handle_dhcp_down(netif);
-        break;
-    }
-    default: {
-        break;
-    }
-    }
+  case DHCP_LINK_DOWN: {
+    handle_dhcp_down(netif);
+    break;
+  }
+  default: {
+    break;
+  }
+  }
 }
 
-void handle_dhcp_timeout(struct netif* netif) {
-    ip_addr_t ipaddr;
-    ip_addr_t netmask;
-    ip_addr_t gw;
+void handle_dhcp_timeout(struct netif *netif) {
+  ip_addr_t ipaddr;
+  ip_addr_t netmask;
+  ip_addr_t gw;
 
-    DHCP_state = DHCP_TIMEOUT;
+  DHCP_state = DHCP_TIMEOUT;
 
-    /* Stop DHCP */
-    dhcp_stop(netif);
+  /* Stop DHCP */
+  dhcp_stop(netif);
 
-    /* Static address used */
-    networking::setLwipAddresses(&ipaddr, &netmask, &gw);
-    netif_set_addr(netif, &ipaddr, &netmask, &gw);
+  /* Static address used */
+  networking::setLwipAddresses(&ipaddr, &netmask, &gw);
+  netif_set_addr(netif, &ipaddr, &netmask, &gw);
 
-    printf("DHCP Timeout\n\r");
-    uint8_t iptxt[20];
-    sprintf((char *)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif)));
-    printf("Assigning static IP address: %s\n", iptxt);
+  printf("DHCP Timeout\n\r");
+  uint8_t iptxt[20];
+  sprintf((char *)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif)));
+  printf("Assigning static IP address: %s\n", iptxt);
 
 #if defined FSFW_OSAL_FREERTOS
-    ETH_HandleTypeDef* handle = getEthernetHandle();
-    handle->gState = HAL_ETH_STATE_READY;
+  ETH_HandleTypeDef *handle = getEthernetHandle();
+  handle->gState = HAL_ETH_STATE_READY;
 #endif
 
 #if OBSW_ETHERNET_TMTC_COMMANDING == 1
 #if OBSW_ETHERNET_USE_LED1_LED2 == 1
-    BSP_LED_On(LED1);
-    BSP_LED_Off(LED2);
+  BSP_LED_On(LED1);
+  BSP_LED_Off(LED2);
 #endif
 #endif
 }
@@ -84,74 +82,69 @@ void handle_dhcp_timeout(struct netif* netif) {
  * @param  netif
  * @retval None
  */
-void DHCP_Periodic_Handle(struct netif *netif)
-{
-    /* Fine DHCP periodic process every 500ms */
-    if (HAL_GetTick() - DHCPfineTimer >= DHCP_FINE_TIMER_MSECS) {
-        DHCPfineTimer =  HAL_GetTick();
-        /* process DHCP state machine */
-        DHCP_Process(netif);
-    }
+void DHCP_Periodic_Handle(struct netif *netif) {
+  /* Fine DHCP periodic process every 500ms */
+  if (HAL_GetTick() - DHCPfineTimer >= DHCP_FINE_TIMER_MSECS) {
+    DHCPfineTimer = HAL_GetTick();
+    /* process DHCP state machine */
+    DHCP_Process(netif);
+  }
 }
 
-void handle_dhcp_start(struct netif* netif) {
-    printf("handle_dhcp_start: Looking for DHCP server ...\n\r");
+void handle_dhcp_start(struct netif *netif) {
+  printf("handle_dhcp_start: Looking for DHCP server ...\n\r");
 #if OBSW_ETHERNET_TMTC_COMMANDING == 1
 #if OBSW_ETHERNET_USE_LED1_LED2 == 1
-    BSP_LED_Off(LED1);
+  BSP_LED_Off(LED1);
+  BSP_LED_Off(LED2);
+#endif
+#endif
+  ip_addr_set_zero_ip4(&netif->ip_addr);
+  ip_addr_set_zero_ip4(&netif->netmask);
+  ip_addr_set_zero_ip4(&netif->gw);
+  dhcp_start(netif);
+  DHCP_state = DHCP_WAIT_ADDRESS;
+}
+
+void handle_dhcp_wait(struct netif *netif, struct dhcp **dhcp) {
+  if (dhcp_supplied_address(netif)) {
+    DHCP_state = DHCP_ADDRESS_ASSIGNED;
+    printf("IP address assigned by a DHCP server: %s\n\r",
+           ip4addr_ntoa(netif_ip4_addr(netif)));
+    printf("Listener port: %d\n\r", UDP_SERVER_PORT);
+#if OBSW_ETHERNET_TMTC_COMMANDING == 1
+#if OBSW_ETHERNET_USE_LED1_LED2 == 1
+    BSP_LED_On(LED1);
     BSP_LED_Off(LED2);
 #endif
 #endif
-    ip_addr_set_zero_ip4(&netif->ip_addr);
-    ip_addr_set_zero_ip4(&netif->netmask);
-    ip_addr_set_zero_ip4(&netif->gw);
-    dhcp_start(netif);
-    DHCP_state = DHCP_WAIT_ADDRESS;
-}
+  } else {
+    *dhcp = (struct dhcp *)netif_get_client_data(
+        netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP);
 
-void handle_dhcp_wait(struct netif* netif, struct dhcp** dhcp) {
-    if (dhcp_supplied_address(netif)) {
-        DHCP_state = DHCP_ADDRESS_ASSIGNED;
-        printf("IP address assigned by a DHCP server: %s\n\r", ip4addr_ntoa(netif_ip4_addr(netif)));
-        printf("Listener port: %d\n\r", UDP_SERVER_PORT);
-#if OBSW_ETHERNET_TMTC_COMMANDING == 1
-#if OBSW_ETHERNET_USE_LED1_LED2 == 1
-        BSP_LED_On(LED1);
-        BSP_LED_Off(LED2);
-#endif
-#endif
-    }
-    else {
-        *dhcp = (struct dhcp*) netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP);
-
-        /* DHCP timeout */
-        if ((*dhcp)->tries > MAX_DHCP_TRIES)
-        {
-            handle_dhcp_timeout(netif);
-        }
+    /* DHCP timeout */
+    if ((*dhcp)->tries > MAX_DHCP_TRIES) {
+      handle_dhcp_timeout(netif);
     }
+  }
 }
 
-void handle_dhcp_down(struct netif* netif) {
-    DHCP_state = DHCP_OFF;
+void handle_dhcp_down(struct netif *netif) {
+  DHCP_state = DHCP_OFF;
 #if OBSW_ETHERNET_TMTC_COMMANDING == 1
-    printf("DHCP_Process: The network cable is not connected.\n\r");
+  printf("DHCP_Process: The network cable is not connected.\n\r");
 #if OBSW_ETHERNET_USE_LED1_LED2 == 1
-    BSP_LED_Off(LED1);
-    BSP_LED_On(LED2);
+  BSP_LED_Off(LED1);
+  BSP_LED_On(LED2);
 #endif
 #endif
 
-    /* Global boolean to track ethernet connection */
-    networking::setEthCableConnected(false);
+  /* Global boolean to track ethernet connection */
+  networking::setEthCableConnected(false);
 }
 
-uint8_t get_dhcp_state() {
-    return DHCP_state;
-}
+uint8_t get_dhcp_state() { return DHCP_state; }
 
-void set_dhcp_state(uint8_t new_state) {
-    DHCP_state = new_state;
-}
+void set_dhcp_state(uint8_t new_state) { DHCP_state = new_state; }
 
 #endif /* LWIP_DHCP == 1 */

stm32h7/networking/app_dhcp.h

@@ -12,12 +12,12 @@ extern "C" {
 #include "lwip/netif.h"
 
 /* DHCP process states */
-#define DHCP_OFF                   (uint8_t) 0
-#define DHCP_START                 (uint8_t) 1
-#define DHCP_WAIT_ADDRESS          (uint8_t) 2
-#define DHCP_ADDRESS_ASSIGNED      (uint8_t) 3
-#define DHCP_TIMEOUT               (uint8_t) 4
-#define DHCP_LINK_DOWN             (uint8_t) 5
+#define DHCP_OFF (uint8_t)0
+#define DHCP_START (uint8_t)1
+#define DHCP_WAIT_ADDRESS (uint8_t)2
+#define DHCP_ADDRESS_ASSIGNED (uint8_t)3
+#define DHCP_TIMEOUT (uint8_t)4
+#define DHCP_LINK_DOWN (uint8_t)5
 
 uint8_t get_dhcp_state();
 void set_dhcp_state(uint8_t new_state);

stm32h7/networking/app_ethernet.cpp

@@ -1,17 +1,18 @@
 /* Includes ------------------------------------------------------------------*/
 #include "app_ethernet.h"
+
 #include "ethernetif.h"
-#include "udp_config.h"
 #include "networking.h"
+#include "udp_config.h"
 
 #if LWIP_DHCP
 #include "app_dhcp.h"
 #endif
 
-#include <lwipopts.h>
-#include <lwip/netif.h>
-#include <stm32h7xx_nucleo.h>
 #include <OBSWConfig.h>
+#include <lwip/netif.h>
+#include <lwipopts.h>
+#include <stm32h7xx_nucleo.h>
 
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
@@ -20,8 +21,7 @@
 uint32_t ethernetLinkTimer = 0;
 
 /* Private function prototypes -----------------------------------------------*/
-void handle_status_change(struct netif* netif, bool link_up);
-
+void handle_status_change(struct netif *netif, bool link_up);
 
 /* Private functions ---------------------------------------------------------*/
 /**
@@ -29,48 +29,43 @@ void handle_status_change(struct netif* netif, bool link_up);
  * @param  netif: the network interface
  * @retval None
  */
-void networking::ethernetLinkStatusUpdated(struct netif *netif)
-{
-	if (netif_is_link_up(netif))
-	{
-		networking::setEthCableConnected(true);
-		handle_status_change(netif, true);
-	}
-	else
-	{
-	    networking::setEthCableConnected(false);
-		handle_status_change(netif, false);
-	}
+void networking::ethernetLinkStatusUpdated(struct netif *netif) {
+  if (netif_is_link_up(netif)) {
+    networking::setEthCableConnected(true);
+    handle_status_change(netif, true);
+  } else {
+    networking::setEthCableConnected(false);
+    handle_status_change(netif, false);
+  }
 }
 
-void handle_status_change(struct netif* netif, bool link_up) {
-	if(link_up) {
+void handle_status_change(struct netif *netif, bool link_up) {
+  if (link_up) {
 #if LWIP_DHCP
-		/* Update DHCP state machine */
-		set_dhcp_state(DHCP_START);
+    /* Update DHCP state machine */
+    set_dhcp_state(DHCP_START);
 #else
-		uint8_t iptxt[20];
-		sprintf((char *)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif)));
-		printf("\rNetwork cable connected. Static IP address: %s | Port: %d\n\r", iptxt,
-		        UDP_SERVER_PORT);
+    uint8_t iptxt[20];
+    sprintf((char *)iptxt, "%s", ip4addr_ntoa(netif_ip4_addr(netif)));
+    printf("\rNetwork cable connected. Static IP address: %s | Port: %d\n\r",
+           iptxt, UDP_SERVER_PORT);
 #if OBSW_ETHERNET_USE_LED1_LED2 == 1
-		BSP_LED_On(LED1);
-		BSP_LED_Off(LED2);
+    BSP_LED_On(LED1);
+    BSP_LED_Off(LED2);
 #endif
 #endif /* LWIP_DHCP */
-	}
-	else {
-		printf("Network cable disconnected\n\r");
+  } else {
+    printf("Network cable disconnected\n\r");
 #if LWIP_DHCP
-		/* Update DHCP state machine */
-		set_dhcp_state(DHCP_LINK_DOWN);
+    /* Update DHCP state machine */
+    set_dhcp_state(DHCP_LINK_DOWN);
 #else
 #if OBSW_ETHERNET_USE_LED1_LED2 == 1
-		BSP_LED_Off(LED1);
-		BSP_LED_On(LED2);
+    BSP_LED_Off(LED1);
+    BSP_LED_On(LED2);
 #endif
 #endif /* LWIP_DHCP */
-	}
+  }
 }
 
 #if LWIP_NETIF_LINK_CALLBACK
@@ -80,14 +75,12 @@ void handle_status_change(struct netif* netif, bool link_up) {
  * @param  netif
  * @retval None
  */
-void networking::ethernetLinkPeriodicHandle(struct netif *netif)
-{
-	/* Ethernet Link every 100ms */
-	if (HAL_GetTick() - ethernetLinkTimer >= 100)
-	{
-		ethernetLinkTimer = HAL_GetTick();
-		ethernet_link_check_state(netif);
-	}
+void networking::ethernetLinkPeriodicHandle(struct netif *netif) {
+  /* Ethernet Link every 100ms */
+  if (HAL_GetTick() - ethernetLinkTimer >= 100) {
+    ethernetLinkTimer = HAL_GetTick();
+    ethernet_link_check_state(netif);
+  }
 }
 
 #endif /* LWIP_NETIF_LINK_CALLBACK */

stm32h7/networking/app_ethernet.h

@@ -1,54 +1,54 @@
 /**
-  ******************************************************************************
-  * @file    LwIP/LwIP_UDP_Echo_Client/Inc/app_ethernet.h 
-  * @author  MCD Application Team
-  * @brief   Header for app_ethernet.c module
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
-  * All rights reserved.</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without
-  * modification, are permitted, provided that the following conditions are met:
-  *
-  * 1. Redistribution of source code must retain the above copyright notice,
-  *    this list of conditions and the following disclaimer.
-  * 2. Redistributions in binary form must reproduce the above copyright notice,
-  *    this list of conditions and the following disclaimer in the documentation
-  *    and/or other materials provided with the distribution.
-  * 3. Neither the name of STMicroelectronics nor the names of other
-  *    contributors to this software may be used to endorse or promote products
-  *    derived from this software without specific written permission.
-  * 4. This software, including modifications and/or derivative works of this
-  *    software, must execute solely and exclusively on microcontroller or
-  *    microprocessor devices manufactured by or for STMicroelectronics.
-  * 5. Redistribution and use of this software other than as permitted under
-  *    this license is void and will automatically terminate your rights under
-  *    this license.
-  *
-  * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
-  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-  * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
-  * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
-  * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+ ******************************************************************************
+ * @file    LwIP/LwIP_UDP_Echo_Client/Inc/app_ethernet.h
+ * @author  MCD Application Team
+ * @brief   Header for app_ethernet.c module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
+ * All rights reserved.</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted, provided that the following conditions are met:
+ *
+ * 1. Redistribution of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of other
+ *    contributors to this software may be used to endorse or promote products
+ *    derived from this software without specific written permission.
+ * 4. This software, including modifications and/or derivative works of this
+ *    software, must execute solely and exclusively on microcontroller or
+ *    microprocessor devices manufactured by or for STMicroelectronics.
+ * 5. Redistribution and use of this software other than as permitted under
+ *    this license is void and will automatically terminate your rights under
+ *    this license.
+ *
+ * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
+ * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
+ * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
 
 /* Define to prevent recursive inclusion -------------------------------------*/
 #ifndef EXAMPLE_COMMON_APP_ETHERNET_H
 #define EXAMPLE_COMMON_APP_ETHERNET_H
 
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif
 
 /* Includes ------------------------------------------------------------------*/
@@ -65,7 +65,7 @@ namespace networking {
 void ethernetLinkStatusUpdated(struct netif *netif);
 void ethernetLinkPeriodicHandle(struct netif *netif);
 
-}
+} // namespace networking
 
 #ifdef __cplusplus
 }
@@ -73,6 +73,4 @@ void ethernetLinkPeriodicHandle(struct netif *netif);
 
 #endif /* EXAMPLE_COMMON_APP_ETHERNET_H */
 
-
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
-

stm32h7/networking/ethernetif.c

@@ -1,59 +1,60 @@
 /**
-  ******************************************************************************
-  * @file    LwIP/LwIP_UDP_Echo_Client/Src/ethernetif.c
-  * @author  MCD Application Team
-  * @brief   This file implements Ethernet network interface drivers for lwIP
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
-  * All rights reserved.</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without
-  * modification, are permitted, provided that the following conditions are met:
-  *
-  * 1. Redistribution of source code must retain the above copyright notice,
-  *    this list of conditions and the following disclaimer.
-  * 2. Redistributions in binary form must reproduce the above copyright notice,
-  *    this list of conditions and the following disclaimer in the documentation
-  *    and/or other materials provided with the distribution.
-  * 3. Neither the name of STMicroelectronics nor the names of other
-  *    contributors to this software may be used to endorse or promote products
-  *    derived from this software without specific written permission.
-  * 4. This software, including modifications and/or derivative works of this
-  *    software, must execute solely and exclusively on microcontroller or
-  *    microprocessor devices manufactured by or for STMicroelectronics.
-  * 5. Redistribution and use of this software other than as permitted under
-  *    this license is void and will automatically terminate your rights under
-  *    this license.
-  *
-  * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
-  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-  * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
-  * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
-  * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+ ******************************************************************************
+ * @file    LwIP/LwIP_UDP_Echo_Client/Src/ethernetif.c
+ * @author  MCD Application Team
+ * @brief   This file implements Ethernet network interface drivers for lwIP
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
+ * All rights reserved.</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted, provided that the following conditions are met:
+ *
+ * 1. Redistribution of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of other
+ *    contributors to this software may be used to endorse or promote products
+ *    derived from this software without specific written permission.
+ * 4. This software, including modifications and/or derivative works of this
+ *    software, must execute solely and exclusively on microcontroller or
+ *    microprocessor devices manufactured by or for STMicroelectronics.
+ * 5. Redistribution and use of this software other than as permitted under
+ *    this license is void and will automatically terminate your rights under
+ *    this license.
+ *
+ * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
+ * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
+ * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
 
 /* Includes ------------------------------------------------------------------*/
-#include "fsfw/FSFW.h"
 #include "ethernetif.h"
 
-#include <string.h>
 #include <lan8742.h>
-#include <stm32h7xx_hal.h>
 #include <lwip/netif.h>
 #include <lwip/opt.h>
 #include <lwip/timeouts.h>
 #include <netif/etharp.h>
+#include <stm32h7xx_hal.h>
+#include <string.h>
+
+#include "fsfw/FSFW.h"
 
 #ifdef FSFW_OSAL_RTEMS
 #include <rtems.h>
@@ -69,17 +70,17 @@
 
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
-/* 
+/*
 @Note: This interface is implemented to operate in zero-copy mode only:
-        - Rx buffers are allocated statically and passed directly to the LwIP stack
-          they will return back to DMA after been processed by the stack.
-        - Tx Buffers will be allocated from LwIP stack memory heap, 
+        - Rx buffers are allocated statically and passed directly to the LwIP
+stack they will return back to DMA after been processed by the stack.
+        - Tx Buffers will be allocated from LwIP stack memory heap,
           then passed to ETH HAL driver.
 
-@Notes: 
-  1.a. ETH DMA Rx descriptors must be contiguous, the default count is 4, 
+@Notes:
+  1.a. ETH DMA Rx descriptors must be contiguous, the default count is 4,
        to customize it please redefine ETH_RX_DESC_CNT in stm32xxxx_hal_conf.h
-  1.b. ETH DMA Tx descriptors must be contiguous, the default count is 4, 
+  1.b. ETH DMA Tx descriptors must be contiguous, the default count is 4,
        to customize it please redefine ETH_TX_DESC_CNT in stm32xxxx_hal_conf.h
 
   2.a. Rx Buffers number must be between ETH_RX_DESC_CNT and 2*ETH_RX_DESC_CNT
@@ -87,35 +88,49 @@
        passed to ETH DMA in the init field (EthHandle.Init.RxBuffLen)
 */
 
-#if defined ( __ICCARM__ ) /*!< IAR Compiler */
+#if defined(__ICCARM__) /*!< IAR Compiler */
 
-#pragma location=0x30040000
-ETH_DMADescTypeDef  DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
-#pragma location=0x30040060
-ETH_DMADescTypeDef  DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */
-#pragma location=0x30040200
-uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; /* Ethernet Receive Buffers */
+#pragma location = 0x30040000
+ETH_DMADescTypeDef
+    DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
+#pragma location = 0x30040060
+ETH_DMADescTypeDef
+    DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */
+#pragma location = 0x30040200
+uint8_t Rx_Buff[ETH_RX_DESC_CNT]
+               [ETH_RX_BUFFER_SIZE]; /* Ethernet Receive Buffers */
 
-#elif defined ( __CC_ARM )  /* MDK ARM Compiler */
+#elif defined(__CC_ARM) /* MDK ARM Compiler */
 
-__attribute__((section(".RxDecripSection"))) ETH_DMADescTypeDef  DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
-__attribute__((section(".TxDecripSection"))) ETH_DMADescTypeDef  DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */
-__attribute__((section(".RxArraySection"))) uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; /* Ethernet Receive Buffer */
+__attribute__((section(".RxDecripSection"))) ETH_DMADescTypeDef
+    DMARxDscrTab[ETH_RX_DESC_CNT]; /* Ethernet Rx DMA Descriptors */
+__attribute__((section(".TxDecripSection"))) ETH_DMADescTypeDef
+    DMATxDscrTab[ETH_TX_DESC_CNT]; /* Ethernet Tx DMA Descriptors */
+__attribute__((section(".RxArraySection"))) uint8_t
+    Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]; /* Ethernet Receive Buffer */
 
-#elif defined ( __GNUC__ ) /* GNU Compiler */ 
+#elif defined(__GNUC__) /* GNU Compiler */
 
 #ifdef FSFW_OSAL_RTEMS
 /* Put into special RTEMS section and align correctly */
-ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((section(".bsp_nocache"), __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Rx DMA Descriptors */
+ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((
+    section(".bsp_nocache"),
+    __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Rx DMA Descriptors */
 /* Put into special RTEMS section and align correctly */
-ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT]  __attribute__((section(".bsp_nocache"), __aligned__(DMA_DESCRIPTOR_ALIGNMENT)));  /* Ethernet Tx DMA Descriptors */
-/* Ethernet Receive Buffers. Just place somewhere is BSS instead of explicitely placing it */
+ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__((
+    section(".bsp_nocache"),
+    __aligned__(DMA_DESCRIPTOR_ALIGNMENT))); /* Ethernet Tx DMA Descriptors */
+/* Ethernet Receive Buffers. Just place somewhere is BSS instead of explicitely
+ * placing it */
 uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE];
 #elif defined FSFW_OSAL_FREERTOS
 /* Placement and alignment specified in linker script here */
-ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((section(".RxDecripSection"))); /* Ethernet Rx DMA Descriptors */
-ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__((section(".TxDecripSection")));   /* Ethernet Tx DMA Descriptors */
-uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE] __attribute__((section(".RxArraySection"))); /* Ethernet Receive Buffers */
+ETH_DMADescTypeDef DMARxDscrTab[ETH_RX_DESC_CNT] __attribute__((
+    section(".RxDecripSection"))); /* Ethernet Rx DMA Descriptors */
+ETH_DMADescTypeDef DMATxDscrTab[ETH_TX_DESC_CNT] __attribute__((
+    section(".TxDecripSection"))); /* Ethernet Tx DMA Descriptors */
+uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE]
+    __attribute__((section(".RxArraySection"))); /* Ethernet Receive Buffers */
 #endif /* FSFW_FREERTOS */
 
 #endif /* defined ( __GNUC__ ) */
@@ -124,10 +139,10 @@ uint8_t Rx_Buff[ETH_RX_DESC_CNT][ETH_RX_BUFFER_SIZE] __attribute__((section(".Rx
 bool ethernet_cable_connected;
 
 struct pbuf_custom rx_pbuf[ETH_RX_DESC_CNT];
-uint32_t current_pbuf_idx =0;
+uint32_t current_pbuf_idx = 0;
 
 ETH_HandleTypeDef EthHandle;
-ETH_TxPacketConfig TxConfig; 
+ETH_TxPacketConfig TxConfig;
 
 lan8742_Object_t LAN8742;
 
@@ -136,72 +151,71 @@ u32_t sys_now(void);
 void pbuf_free_custom(struct pbuf *p);
 
 int32_t ETH_PHY_IO_Init(void);
-int32_t ETH_PHY_IO_DeInit (void);
-int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal);
-int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal);
+int32_t ETH_PHY_IO_DeInit(void);
+int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr,
+                           uint32_t *pRegVal);
+int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr,
+                            uint32_t RegVal);
 int32_t ETH_PHY_IO_GetTick(void);
 
-
-lan8742_IOCtx_t  LAN8742_IOCtx = {ETH_PHY_IO_Init,
-                               ETH_PHY_IO_DeInit,
-                               ETH_PHY_IO_WriteReg,
-                               ETH_PHY_IO_ReadReg,
-                               ETH_PHY_IO_GetTick};
+lan8742_IOCtx_t LAN8742_IOCtx = {ETH_PHY_IO_Init, ETH_PHY_IO_DeInit,
+                                 ETH_PHY_IO_WriteReg, ETH_PHY_IO_ReadReg,
+                                 ETH_PHY_IO_GetTick};
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
-                       LL Driver Interface ( LwIP stack --> ETH) 
+                       LL Driver Interface ( LwIP stack --> ETH)
 *******************************************************************************/
 /**
-  * @brief In this function, the hardware should be initialized.
-  * Called from ethernetif_init().
-  *
-  * @param netif the already initialized lwip network interface structure
-  *        for this ethernetif
-  */
-static void low_level_init(struct netif *netif)
-{
+ * @brief In this function, the hardware should be initialized.
+ * Called from ethernetif_init().
+ *
+ * @param netif the already initialized lwip network interface structure
+ *        for this ethernetif
+ */
+static void low_level_init(struct netif *netif) {
   uint32_t idx = 0;
-  uint8_t macaddress[6]= {ETH_MAC_ADDR0, ETH_MAC_ADDR1, ETH_MAC_ADDR2, ETH_MAC_ADDR3, ETH_MAC_ADDR4, ETH_MAC_ADDR5};
-  
-  EthHandle.Instance = ETH;  
+  uint8_t macaddress[6] = {ETH_MAC_ADDR0, ETH_MAC_ADDR1, ETH_MAC_ADDR2,
+                           ETH_MAC_ADDR3, ETH_MAC_ADDR4, ETH_MAC_ADDR5};
+
+  EthHandle.Instance = ETH;
   EthHandle.Init.MACAddr = macaddress;
   EthHandle.Init.MediaInterface = HAL_ETH_RMII_MODE;
   EthHandle.Init.RxDesc = DMARxDscrTab;
   EthHandle.Init.TxDesc = DMATxDscrTab;
   EthHandle.Init.RxBuffLen = ETH_RX_BUFFER_SIZE;
-  
+
   /* configure ethernet peripheral (GPIOs, clocks, MAC, DMA) */
   HAL_ETH_Init(&EthHandle);
 
   /* set MAC hardware address length */
   netif->hwaddr_len = ETHARP_HWADDR_LEN;
-  
+
   /* set MAC hardware address */
-  netif->hwaddr[0] =  0x02;
-  netif->hwaddr[1] =  0x00;
-  netif->hwaddr[2] =  0x00;
-  netif->hwaddr[3] =  0x00;
-  netif->hwaddr[4] =  0x00;
-  netif->hwaddr[5] =  0x00;
-  
+  netif->hwaddr[0] = 0x02;
+  netif->hwaddr[1] = 0x00;
+  netif->hwaddr[2] = 0x00;
+  netif->hwaddr[3] = 0x00;
+  netif->hwaddr[4] = 0x00;
+  netif->hwaddr[5] = 0x00;
+
   /* maximum transfer unit */
   netif->mtu = ETH_MAX_PAYLOAD;
-  
+
   /* device capabilities */
   /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
   netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
-  
-  for(idx = 0; idx < ETH_RX_DESC_CNT; idx ++)
-  {
+
+  for (idx = 0; idx < ETH_RX_DESC_CNT; idx++) {
     HAL_ETH_DescAssignMemory(&EthHandle, idx, Rx_Buff[idx], NULL);
-    
+
     /* Set Custom pbuf free function */
     rx_pbuf[idx].custom_free_function = pbuf_free_custom;
   }
-  
+
   /* Set Tx packet config common parameters */
-  memset(&TxConfig, 0 , sizeof(ETH_TxPacketConfig));
-  TxConfig.Attributes = ETH_TX_PACKETS_FEATURES_CSUM | ETH_TX_PACKETS_FEATURES_CRCPAD;
+  memset(&TxConfig, 0, sizeof(ETH_TxPacketConfig));
+  TxConfig.Attributes =
+      ETH_TX_PACKETS_FEATURES_CSUM | ETH_TX_PACKETS_FEATURES_CRCPAD;
   TxConfig.ChecksumCtrl = ETH_CHECKSUM_IPHDR_PAYLOAD_INSERT_PHDR_CALC;
   TxConfig.CRCPadCtrl = ETH_CRC_PAD_INSERT;
 
@@ -212,47 +226,43 @@ static void low_level_init(struct netif *netif)
   LAN8742_Init(&LAN8742);
 
   ethernet_link_check_state(netif);
-
 }
 
 /**
-  * @brief This function should do the actual transmission of the packet. The packet is
-  * contained in the pbuf that is passed to the function. This pbuf
-  * might be chained.
-  *
-  * @param netif the lwip network interface structure for this ethernetif
-  * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
-  * @return ERR_OK if the packet could be sent
-  *         an err_t value if the packet couldn't be sent
-  *
-  * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
-  *       strange results. You might consider waiting for space in the DMA queue
-  *       to become availale since the stack doesn't retry to send a packet
-  *       dropped because of memory failure (except for the TCP timers).
-  */
-static err_t low_level_output(struct netif *netif, struct pbuf *p)
-{
-  uint32_t i=0, framelen = 0;
+ * @brief This function should do the actual transmission of the packet. The
+ * packet is contained in the pbuf that is passed to the function. This pbuf
+ * might be chained.
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ * @param p the MAC packet to send (e.g. IP packet including MAC addresses and
+ * type)
+ * @return ERR_OK if the packet could be sent
+ *         an err_t value if the packet couldn't be sent
+ *
+ * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
+ *       strange results. You might consider waiting for space in the DMA queue
+ *       to become availale since the stack doesn't retry to send a packet
+ *       dropped because of memory failure (except for the TCP timers).
+ */
+static err_t low_level_output(struct netif *netif, struct pbuf *p) {
+  uint32_t i = 0, framelen = 0;
   struct pbuf *q;
   err_t errval = ERR_OK;
   ETH_BufferTypeDef Txbuffer[ETH_TX_DESC_CNT];
-  
-  for(q = p; q != NULL; q = q->next)
-  {
-    if(i >= ETH_TX_DESC_CNT)	
+
+  for (q = p; q != NULL; q = q->next) {
+    if (i >= ETH_TX_DESC_CNT)
       return ERR_IF;
-    
+
     Txbuffer[i].buffer = q->payload;
     Txbuffer[i].len = q->len;
     framelen += q->len;
-    
-    if(i>0)
-    {
-      Txbuffer[i-1].next = &Txbuffer[i];
+
+    if (i > 0) {
+      Txbuffer[i - 1].next = &Txbuffer[i];
     }
-    
-    if(q->next == NULL)
-    {
+
+    if (q->next == NULL) {
       Txbuffer[i].next = NULL;
     }
 
@@ -264,78 +274,74 @@ static err_t low_level_output(struct netif *netif, struct pbuf *p)
 
   HAL_StatusTypeDef ret = HAL_ETH_Transmit(&EthHandle, &TxConfig, 20);
 
-  if(ret != HAL_OK) {
-	  printf("low_level_output: Could not transmit ethernet packet, code %d!\n\r", ret);
+  if (ret != HAL_OK) {
+    printf("low_level_output: Could not transmit ethernet packet, code %d!\n\r",
+           ret);
   }
-  
+
   return errval;
 }
 
 /**
-  * @brief Should allocate a pbuf and transfer the bytes of the incoming
-  * packet from the interface into the pbuf.
-  *
-  * @param netif the lwip network interface structure for this ethernetif
-  * @return a pbuf filled with the received packet (including MAC header)
-  *         NULL on memory error
-  */
-static struct pbuf * low_level_input(struct netif *netif)
-{
+ * @brief Should allocate a pbuf and transfer the bytes of the incoming
+ * packet from the interface into the pbuf.
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ * @return a pbuf filled with the received packet (including MAC header)
+ *         NULL on memory error
+ */
+static struct pbuf *low_level_input(struct netif *netif) {
   struct pbuf *p = NULL;
   ETH_BufferTypeDef RxBuff;
   uint32_t framelength = 0;
 
-  if (HAL_ETH_IsRxDataAvailable(&EthHandle))
-  {
+  if (HAL_ETH_IsRxDataAvailable(&EthHandle)) {
     HAL_ETH_GetRxDataBuffer(&EthHandle, &RxBuff);
     HAL_ETH_GetRxDataLength(&EthHandle, &framelength);
-    
+
     /* Invalidate data cache for ETH Rx Buffers */
-    SCB_InvalidateDCache_by_Addr((uint32_t *)Rx_Buff, (ETH_RX_DESC_CNT*ETH_RX_BUFFER_SIZE));
-    
-    p = pbuf_alloced_custom(PBUF_RAW, framelength, PBUF_POOL, &rx_pbuf[current_pbuf_idx], RxBuff.buffer, ETH_RX_BUFFER_SIZE);
-    if(current_pbuf_idx < (ETH_RX_DESC_CNT -1))
-    {
+    SCB_InvalidateDCache_by_Addr((uint32_t *)Rx_Buff,
+                                 (ETH_RX_DESC_CNT * ETH_RX_BUFFER_SIZE));
+
+    p = pbuf_alloced_custom(PBUF_RAW, framelength, PBUF_POOL,
+                            &rx_pbuf[current_pbuf_idx], RxBuff.buffer,
+                            ETH_RX_BUFFER_SIZE);
+    if (current_pbuf_idx < (ETH_RX_DESC_CNT - 1)) {
       current_pbuf_idx++;
-    }
-    else
-    {
+    } else {
       current_pbuf_idx = 0;
     }
 
     return p;
-  }
-  else
-  {
+  } else {
     return NULL;
   }
 }
 
 /**
-  * @brief This function is the ethernetif_input task, it is processed when a packet 
-  * is ready to be read from the interface. It uses the function low_level_input() 
-  * that should handle the actual reception of bytes from the network
-  * interface. Then the type of the received packet is determined and
-  * the appropriate input function is called.
-  *
-  * @param netif the lwip network interface structure for this ethernetif
-  */
-void ethernetif_input(struct netif *netif)
-{
+ * @brief This function is the ethernetif_input task, it is processed when a
+ * packet is ready to be read from the interface. It uses the function
+ * low_level_input() that should handle the actual reception of bytes from the
+ * network interface. Then the type of the received packet is determined and the
+ * appropriate input function is called.
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ */
+void ethernetif_input(struct netif *netif) {
   err_t err;
   struct pbuf *p;
-  
+
   /* move received packet into a new pbuf */
   p = low_level_input(netif);
 
   /* no packet could be read, silently ignore this */
-  if (p == NULL) return;
+  if (p == NULL)
+    return;
 
   /* entry point to the LwIP stack */
   err = netif->input(p, netif);
 
-  if (err != ERR_OK)
-  {
+  if (err != ERR_OK) {
     LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
     pbuf_free(p);
     p = NULL;
@@ -345,19 +351,18 @@ void ethernetif_input(struct netif *netif)
 }
 
 /**
-  * @brief Should be called at the beginning of the program to set up the
-  * network interface. It calls the function low_level_init() to do the
-  * actual setup of the hardware.
-  *
-  * This function should be passed as a parameter to netif_add().
-  *
-  * @param netif the lwip network interface structure for this ethernetif
-  * @return ERR_OK if the loopif is initialized
-  *         ERR_MEM if private data couldn't be allocated
-  *         any other err_t on error
-  */
-err_t ethernetif_init(struct netif *netif)
-{
+ * @brief Should be called at the beginning of the program to set up the
+ * network interface. It calls the function low_level_init() to do the
+ * actual setup of the hardware.
+ *
+ * This function should be passed as a parameter to netif_add().
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ * @return ERR_OK if the loopif is initialized
+ *         ERR_MEM if private data couldn't be allocated
+ *         any other err_t on error
+ */
+err_t ethernetif_init(struct netif *netif) {
   LWIP_ASSERT("netif != NULL", (netif != NULL));
 
 #if LWIP_NETIF_HOSTNAME
@@ -381,14 +386,12 @@ err_t ethernetif_init(struct netif *netif)
 }
 
 /**
-  * @brief  Custom Rx pbuf free callback
-  * @param  pbuf: pbuf to be freed
-  * @retval None
-  */
-void pbuf_free_custom(struct pbuf *p)
-{
-  if(p != NULL)
-  {
+ * @brief  Custom Rx pbuf free callback
+ * @param  pbuf: pbuf to be freed
+ * @retval None
+ */
+void pbuf_free_custom(struct pbuf *p) {
+  if (p != NULL) {
     p->flags = 0;
     p->next = NULL;
     p->len = p->tot_len = 0;
@@ -398,37 +401,34 @@ void pbuf_free_custom(struct pbuf *p)
 }
 
 /**
-  * @brief  Returns the current time in milliseconds
-  *         when LWIP_TIMERS == 1 and NO_SYS == 1
-  * @param  None
-  * @retval Current Time value
-  */
-u32_t sys_now(void)
-{
-  return HAL_GetTick();
-}
+ * @brief  Returns the current time in milliseconds
+ *         when LWIP_TIMERS == 1 and NO_SYS == 1
+ * @param  None
+ * @retval Current Time value
+ */
+u32_t sys_now(void) { return HAL_GetTick(); }
 
 /*******************************************************************************
                        Ethernet MSP Routines
 *******************************************************************************/
 /**
-  * @brief  Initializes the ETH MSP.
-  * @param  heth: ETH handle
-  * @retval None
-*/
-void HAL_ETH_MspInit(ETH_HandleTypeDef *heth)
-{
+ * @brief  Initializes the ETH MSP.
+ * @param  heth: ETH handle
+ * @retval None
+ */
+void HAL_ETH_MspInit(ETH_HandleTypeDef *heth) {
   GPIO_InitTypeDef GPIO_InitStructure;
-  
+
   /* Ethernett MSP init: RMII Mode */
-  
+
   /* Enable GPIOs clocks */
   __HAL_RCC_GPIOA_CLK_ENABLE();
   __HAL_RCC_GPIOB_CLK_ENABLE();
   __HAL_RCC_GPIOC_CLK_ENABLE();
   __HAL_RCC_GPIOG_CLK_ENABLE();
 
-/* Ethernet pins configuration ************************************************/
+  /* Ethernet pins configuration
+   * ************************************************/
   /*
         RMII_REF_CLK ----------------------> PA1
         RMII_MDIO -------------------------> PA2
@@ -445,29 +445,29 @@ void HAL_ETH_MspInit(ETH_HandleTypeDef *heth)
   /* Configure PA1, PA2 and PA7 */
   GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
   GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
-  GPIO_InitStructure.Pull = GPIO_NOPULL; 
+  GPIO_InitStructure.Pull = GPIO_NOPULL;
   GPIO_InitStructure.Alternate = GPIO_AF11_ETH;
   GPIO_InitStructure.Pin = GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_7;
   HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
-  
+
   /* Configure PB13 */
   GPIO_InitStructure.Pin = GPIO_PIN_13;
   HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
-  
+
   /* Configure PC1, PC4 and PC5 */
   GPIO_InitStructure.Pin = GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5;
   HAL_GPIO_Init(GPIOC, &GPIO_InitStructure);
 
   /* Configure PG2, PG11, PG13 and PG14 */
-  GPIO_InitStructure.Pin =  GPIO_PIN_2 | GPIO_PIN_11 | GPIO_PIN_13;
-  HAL_GPIO_Init(GPIOG, &GPIO_InitStructure);	
-  
+  GPIO_InitStructure.Pin = GPIO_PIN_2 | GPIO_PIN_11 | GPIO_PIN_13;
+  HAL_GPIO_Init(GPIOG, &GPIO_InitStructure);
+
 #if NO_SYS == 0
   /* Enable the Ethernet global Interrupt */
   HAL_NVIC_SetPriority(ETH_IRQn, 0x7, 0);
   HAL_NVIC_EnableIRQ(ETH_IRQn);
 #endif
-  
+
   /* Enable Ethernet clocks */
   __HAL_RCC_ETH1MAC_CLK_ENABLE();
   __HAL_RCC_ETH1TX_CLK_ENABLE();
@@ -478,97 +478,86 @@ void HAL_ETH_MspInit(ETH_HandleTypeDef *heth)
                        PHI IO Functions
 *******************************************************************************/
 /**
-  * @brief  Initializes the MDIO interface GPIO and clocks.
-  * @param  None
-  * @retval 0 if OK, -1 if ERROR
-  */
-int32_t ETH_PHY_IO_Init(void)
-{  
+ * @brief  Initializes the MDIO interface GPIO and clocks.
+ * @param  None
+ * @retval 0 if OK, -1 if ERROR
+ */
+int32_t ETH_PHY_IO_Init(void) {
   /* We assume that MDIO GPIO configuration is already done
-     in the ETH_MspInit() else it should be done here 
+     in the ETH_MspInit() else it should be done here
   */
-  
+
   /* Configure the MDIO Clock */
   HAL_ETH_SetMDIOClockRange(&EthHandle);
-  
+
   return 0;
 }
 
 /**
-  * @brief  De-Initializes the MDIO interface .
-  * @param  None
-  * @retval 0 if OK, -1 if ERROR
-  */
-int32_t ETH_PHY_IO_DeInit (void)
-{
-  return 0;
-}
+ * @brief  De-Initializes the MDIO interface .
+ * @param  None
+ * @retval 0 if OK, -1 if ERROR
+ */
+int32_t ETH_PHY_IO_DeInit(void) { return 0; }
 
 /**
-  * @brief  Read a PHY register through the MDIO interface.
-  * @param  DevAddr: PHY port address
-  * @param  RegAddr: PHY register address
-  * @param  pRegVal: pointer to hold the register value 
-  * @retval 0 if OK -1 if Error
-  */
-int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t *pRegVal)
-{
-  if(HAL_ETH_ReadPHYRegister(&EthHandle, DevAddr, RegAddr, pRegVal) != HAL_OK)
-  {
+ * @brief  Read a PHY register through the MDIO interface.
+ * @param  DevAddr: PHY port address
+ * @param  RegAddr: PHY register address
+ * @param  pRegVal: pointer to hold the register value
+ * @retval 0 if OK -1 if Error
+ */
+int32_t ETH_PHY_IO_ReadReg(uint32_t DevAddr, uint32_t RegAddr,
+                           uint32_t *pRegVal) {
+  if (HAL_ETH_ReadPHYRegister(&EthHandle, DevAddr, RegAddr, pRegVal) !=
+      HAL_OK) {
     return -1;
   }
-  
+
   return 0;
 }
 
 /**
-  * @brief  Write a value to a PHY register through the MDIO interface.
-  * @param  DevAddr: PHY port address
-  * @param  RegAddr: PHY register address
-  * @param  RegVal: Value to be written 
-  * @retval 0 if OK -1 if Error
-  */
-int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr, uint32_t RegVal)
-{
-  if(HAL_ETH_WritePHYRegister(&EthHandle, DevAddr, RegAddr, RegVal) != HAL_OK)
-  {
+ * @brief  Write a value to a PHY register through the MDIO interface.
+ * @param  DevAddr: PHY port address
+ * @param  RegAddr: PHY register address
+ * @param  RegVal: Value to be written
+ * @retval 0 if OK -1 if Error
+ */
+int32_t ETH_PHY_IO_WriteReg(uint32_t DevAddr, uint32_t RegAddr,
+                            uint32_t RegVal) {
+  if (HAL_ETH_WritePHYRegister(&EthHandle, DevAddr, RegAddr, RegVal) !=
+      HAL_OK) {
     return -1;
   }
-  
+
   return 0;
 }
 
 /**
-  * @brief  Get the time in millisecons used for internal PHY driver process.
-  * @retval Time value
-  */
-int32_t ETH_PHY_IO_GetTick(void)
-{
-  return HAL_GetTick();
-}
+ * @brief  Get the time in millisecons used for internal PHY driver process.
+ * @retval Time value
+ */
+int32_t ETH_PHY_IO_GetTick(void) { return HAL_GetTick(); }
 
 /**
-  * @brief
-  * @retval None
-  */
-void ethernet_link_check_state(struct netif *netif)
-{
+ * @brief
+ * @retval None
+ */
+void ethernet_link_check_state(struct netif *netif) {
   ETH_MACConfigTypeDef MACConf;
   uint32_t PHYLinkState;
-  uint32_t linkchanged = 0, speed = 0, duplex =0;
-  
+  uint32_t linkchanged = 0, speed = 0, duplex = 0;
+
   PHYLinkState = LAN8742_GetLinkState(&LAN8742);
 
-  if(netif_is_link_up(netif) && (PHYLinkState <= LAN8742_STATUS_LINK_DOWN))
-  {
+  if (netif_is_link_up(netif) && (PHYLinkState <= LAN8742_STATUS_LINK_DOWN)) {
     HAL_ETH_Stop(&EthHandle);
     netif_set_down(netif);
     netif_set_link_down(netif);
-  }
-  else if(!netif_is_link_up(netif) && (PHYLinkState > LAN8742_STATUS_LINK_DOWN))
-  {
-    switch (PHYLinkState)
-    {
+  } else if (!netif_is_link_up(netif) &&
+             (PHYLinkState > LAN8742_STATUS_LINK_DOWN)) {
+    switch (PHYLinkState) {
     case LAN8742_STATUS_100MBITS_FULLDUPLEX:
       duplex = ETH_FULLDUPLEX_MODE;
       speed = ETH_SPEED_100M;
@@ -593,8 +582,7 @@ void ethernet_link_check_state(struct netif *netif)
       break;
     }
 
-    if(linkchanged)
-    {
+    if (linkchanged) {
       /* Get MAC Config MAC */
       HAL_ETH_GetMACConfig(&EthHandle, &MACConf);
       MACConf.DuplexMode = duplex;
@@ -607,8 +595,6 @@ void ethernet_link_check_state(struct netif *netif)
   }
 }
 
-ETH_HandleTypeDef* getEthernetHandle() {
-	return &EthHandle;
-}
+ETH_HandleTypeDef *getEthernetHandle() { return &EthHandle; }
 
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

stm32h7/networking/ethernetif.h

@@ -1,65 +1,66 @@
 /**
-  ******************************************************************************
-  * @file    LwIP/LwIP_HTTP_Server_Netconn_RTOS/Inc/ethernetif.h 
-  * @author  MCD Application Team
-  * @brief   Header for ethernetif.c module
-  ******************************************************************************
-  * @attention
-  *
-  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
-  * All rights reserved.</center></h2>
-  *
-  * Redistribution and use in source and binary forms, with or without
-  * modification, are permitted, provided that the following conditions are met:
-  *
-  * 1. Redistribution of source code must retain the above copyright notice,
-  *    this list of conditions and the following disclaimer.
-  * 2. Redistributions in binary form must reproduce the above copyright notice,
-  *    this list of conditions and the following disclaimer in the documentation
-  *    and/or other materials provided with the distribution.
-  * 3. Neither the name of STMicroelectronics nor the names of other
-  *    contributors to this software may be used to endorse or promote products
-  *    derived from this software without specific written permission.
-  * 4. This software, including modifications and/or derivative works of this
-  *    software, must execute solely and exclusively on microcontroller or
-  *    microprocessor devices manufactured by or for STMicroelectronics.
-  * 5. Redistribution and use of this software other than as permitted under
-  *    this license is void and will automatically terminate your rights under
-  *    this license.
-  *
-  * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
-  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-  * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
-  * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
-  * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-  *
-  ******************************************************************************
-  */
+ ******************************************************************************
+ * @file    LwIP/LwIP_HTTP_Server_Netconn_RTOS/Inc/ethernetif.h
+ * @author  MCD Application Team
+ * @brief   Header for ethernetif.c module
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics International N.V.
+ * All rights reserved.</center></h2>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted, provided that the following conditions are met:
+ *
+ * 1. Redistribution of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of other
+ *    contributors to this software may be used to endorse or promote products
+ *    derived from this software without specific written permission.
+ * 4. This software, including modifications and/or derivative works of this
+ *    software, must execute solely and exclusively on microcontroller or
+ *    microprocessor devices manufactured by or for STMicroelectronics.
+ * 5. Redistribution and use of this software other than as permitted under
+ *    this license is void and will automatically terminate your rights under
+ *    this license.
+ *
+ * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
+ * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
+ * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
 
 #ifndef __ETHERNETIF_H__
 #define __ETHERNETIF_H__
 
+#include <stdbool.h>
+#include <stm32h7xx_hal.h>
+
 #include "lwip/err.h"
 #include "lwip/netif.h"
-#include <stm32h7xx_hal.h>
-#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define ETH_RX_BUFFER_SIZE                     (1536UL)
+#define ETH_RX_BUFFER_SIZE (1536UL)
 
 /* Exported types ------------------------------------------------------------*/
 
-ETH_HandleTypeDef* getEthernetHandle();
+ETH_HandleTypeDef *getEthernetHandle();
 err_t ethernetif_init(struct netif *netif);
 void ethernetif_input(struct netif *netif);
 void ethernet_link_check_state(struct netif *netif);

stm32h7/networking/networking.cpp

@@ -1,19 +1,18 @@
-#include "udp_config.h"
 #include "networking.h"
 
+#include "udp_config.h"
+
 bool ethernetCableConnected = false;
 
 void networking::setEthCableConnected(bool status) {
-    ethernetCableConnected = status;
+  ethernetCableConnected = status;
 }
 
-bool networking::getEthCableConnected() {
-    return ethernetCableConnected;
-}
+bool networking::getEthCableConnected() { return ethernetCableConnected; }
 
-void networking::setLwipAddresses(ip_addr_t* ipaddr, ip_addr_t* netmask, ip_addr_t* gw) {
-    IP4_ADDR(ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
-    IP4_ADDR(netmask, NETMASK_ADDR0, NETMASK_ADDR1 ,
-            NETMASK_ADDR2, NETMASK_ADDR3);
-    IP4_ADDR(gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
+void networking::setLwipAddresses(ip_addr_t *ipaddr, ip_addr_t *netmask,
+                                  ip_addr_t *gw) {
+  IP4_ADDR(ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
+  IP4_ADDR(netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
+  IP4_ADDR(gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
 }

stm32h7/networking/networking.h

@@ -7,8 +7,8 @@ namespace networking {
 
 void setEthCableConnected(bool status);
 bool getEthCableConnected();
-void setLwipAddresses(ip_addr_t* ipaddr, ip_addr_t* netmask, ip_addr_t* gw);
+void setLwipAddresses(ip_addr_t *ipaddr, ip_addr_t *netmask, ip_addr_t *gw);
 
-}
+} // namespace networking
 
 #endif /* BSP_STM32H7_RTEMS_NETWORKING_NETWORKING_H_ */

stm32h7/networking/udp_config.h

@@ -6,31 +6,32 @@ extern "C" {
 #endif
 
 /* UDP local connection port. Client needs to bind to this port */
-#define UDP_SERVER_PORT    7
+#define UDP_SERVER_PORT 7
 
-/*Static DEST IP ADDRESS: DEST_IP_ADDR0.DEST_IP_ADDR1.DEST_IP_ADDR2.DEST_IP_ADDR3 */
-#define DEST_IP_ADDR0   ((uint8_t)169U)
-#define DEST_IP_ADDR1   ((uint8_t)254U)
-#define DEST_IP_ADDR2   ((uint8_t)39U)
-#define DEST_IP_ADDR3   ((uint8_t)2U)
+/*Static DEST IP ADDRESS:
+ * DEST_IP_ADDR0.DEST_IP_ADDR1.DEST_IP_ADDR2.DEST_IP_ADDR3 */
+#define DEST_IP_ADDR0 ((uint8_t)169U)
+#define DEST_IP_ADDR1 ((uint8_t)254U)
+#define DEST_IP_ADDR2 ((uint8_t)39U)
+#define DEST_IP_ADDR3 ((uint8_t)2U)
 
 /*Static IP ADDRESS*/
-#define IP_ADDR0   169
-#define IP_ADDR1   254
-#define IP_ADDR2   1
-#define IP_ADDR3   38
+#define IP_ADDR0 169
+#define IP_ADDR1 254
+#define IP_ADDR2 1
+#define IP_ADDR3 38
 
 /*NETMASK*/
-#define NETMASK_ADDR0   255
-#define NETMASK_ADDR1   255
-#define NETMASK_ADDR2   0
-#define NETMASK_ADDR3   0
+#define NETMASK_ADDR0 255
+#define NETMASK_ADDR1 255
+#define NETMASK_ADDR2 0
+#define NETMASK_ADDR3 0
 
 /*Gateway Address*/
-#define GW_ADDR0   192
-#define GW_ADDR1   168
-#define GW_ADDR2   178
-#define GW_ADDR3   1
+#define GW_ADDR0 192
+#define GW_ADDR1 168
+#define GW_ADDR2 178
+#define GW_ADDR3 1
 
 #ifdef __cplusplus
 }

test/CMakeLists.txt

@@ -1,7 +0,0 @@
-target_sources(${TARGET_NAME} 
-	PRIVATE
-		TestTask.cpp
-        FsfwReaderTask.cpp
-        FsfwExampleTask.cpp
-        MutexExample.cpp
-)

test/FsfwExampleTask.cpp

@@ -1,264 +0,0 @@
-#include "FsfwExampleTask.h"
-#include "OBSWConfig.h"
-#include "commonSystemObjects.h"
-#include "objects/systemObjectList.h"
-
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/ipc/CommandMessage.h>
-
-
-FsfwExampleTask::FsfwExampleTask(object_id_t objectId): SystemObject(objectId),
-        poolManager(this, nullptr), demoSet(this),
-        monitor(objectId, MONITOR_ID, gp_id_t(objectId, FsfwDemoSet::VARIABLE_LIMIT), 30, 10)
-{
-    commandQueue = QueueFactory::instance()->createMessageQueue(10,
-            CommandMessage::MAX_MESSAGE_SIZE);
-}
-
-FsfwExampleTask::~FsfwExampleTask() {
-}
-
-ReturnValue_t FsfwExampleTask::performOperation(uint8_t operationCode) {
-    if(operationCode == OpCodes::DELAY_SHORT){
-        TaskFactory::delayTask(5);
-    }
-
-    // TODO: Move this to new test controller?
-    ReturnValue_t result = performMonitoringDemo();
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-
-    if (operationCode == OpCodes::SEND_RAND_NUM) {
-        result = performSendOperation();
-        if(result != HasReturnvaluesIF::RETURN_OK) {
-            return result;
-        }
-    }
-
-
-    if (operationCode == OpCodes::RECEIVE_RAND_NUM) {
-        result = performReceiveOperation();
-
-    }
-
-    return 0;
-}
-
-object_id_t FsfwExampleTask::getNextRecipient() {
-    switch(this->getObjectId()) {
-    case(objects::TEST_DUMMY_1): {
-        return objects::TEST_DUMMY_2;
-    }
-    case(objects::TEST_DUMMY_2): {
-        return objects::TEST_DUMMY_3;
-    }
-    case(objects::TEST_DUMMY_3): {
-        return objects::TEST_DUMMY_1;
-    }
-    default:
-        return objects::TEST_DUMMY_1;
-    }
-}
-
-object_id_t FsfwExampleTask::getSender() {
-    switch(this->getObjectId()) {
-    case(objects::TEST_DUMMY_1): {
-        return objects::TEST_DUMMY_3;
-    }
-    case(objects::TEST_DUMMY_2): {
-        return objects::TEST_DUMMY_1;
-    }
-    case(objects::TEST_DUMMY_3): {
-        return objects::TEST_DUMMY_2;
-    }
-    default:
-        return objects::TEST_DUMMY_1;
-    }
-}
-
-
-ReturnValue_t FsfwExampleTask::initialize() {
-    // Get the dataset of the sender. Will be cached for later checks.
-    object_id_t sender = getSender();
-    HasLocalDataPoolIF* senderIF = ObjectManager::instance()->get<HasLocalDataPoolIF>(sender);
-    if(senderIF == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FsfwDemoTask::initialize: Sender object invalid!" << std::endl;
-#else
-        sif::printError("FsfwDemoTask::initialize: Sender object invalid!\n");
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-    // we need a private copy of the previous dataset.. or we use the shared dataset.
-    senderSet = new FsfwDemoSet(senderIF);
-    if(senderSet == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FsfwDemoTask::initialize: Sender dataset invalid!" << std::endl;
-#else
-        sif::printError("FsfwDemoTask::initialize: Sender dataset invalid!\n");
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return poolManager.initialize(commandQueue);
-}
-
-ReturnValue_t FsfwExampleTask::initializeAfterTaskCreation() {
-    return poolManager.initializeAfterTaskCreation();
-}
-
-object_id_t FsfwExampleTask::getObjectId() const {
-    return SystemObject::getObjectId();
-}
-
-MessageQueueId_t FsfwExampleTask::getMessageQueueId(){
-    return commandQueue->getId();
-}
-
-void  FsfwExampleTask::setTaskIF(PeriodicTaskIF* task){
-    this->task = task;
-}
-
-LocalPoolDataSetBase* FsfwExampleTask::getDataSetHandle(sid_t sid) {
-    return &demoSet;
-}
-
-uint32_t FsfwExampleTask::getPeriodicOperationFrequency() const {
-    return task->getPeriodMs();
-}
-
-ReturnValue_t FsfwExampleTask::initializeLocalDataPool(
-        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
-    localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(FsfwDemoSet::PoolIds::VARIABLE_LIMIT, new PoolEntry<uint16_t>({0}));
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FsfwExampleTask::performMonitoringDemo() {
-    ReturnValue_t result = demoSet.variableLimit.read(
-            MutexIF::TimeoutType::WAITING, 20);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-        /* Configuration error */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DummyObject::performOperation: Could not read variableLimit!" << std::endl;
-#else
-        sif::printError("DummyObject::performOperation: Could not read variableLimit!\n");
-#endif
-        return result;
-    }
-    if(this->getObjectId() == objects::TEST_DUMMY_5){
-        if(demoSet.variableLimit.value > 20){
-            demoSet.variableLimit.value = 0;
-        }
-        demoSet.variableLimit.value++;
-        demoSet.variableLimit.commit(20);
-        monitor.check();
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FsfwExampleTask::performSendOperation() {
-    object_id_t nextRecipient = getNextRecipient();
-    FsfwExampleTask* target = ObjectManager::instance()->get<FsfwExampleTask>(nextRecipient);
-    if (target == nullptr) {
-        /* Configuration error */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "DummyObject::performOperation: Next recipient does not exist!" << std::endl;
-#else
-        sif::printError("DummyObject::performOperation: Next recipient does not exist!\n");
-#endif
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
-
-    uint32_t randomNumber = rand() % 100;
-    CommandMessage message;
-    message.setParameter(randomNumber);
-    message.setParameter2(this->getMessageQueueId());
-
-    /* Send message using own message queue */
-    ReturnValue_t result = commandQueue->sendMessage(target->getMessageQueueId(), &message);
-    if (result != HasReturnvaluesIF::RETURN_OK
-            && result != MessageQueueIF::FULL) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FsfwDemoTask::performSendOperation: Send failed with " << result <<
-                std::endl;
-#else
-        sif::printError("FsfwDemoTask::performSendOperation: Send failed with %hu\n", result);
-#endif
-    }
-
-    /* Send message without via MessageQueueSenderIF */
-    result = MessageQueueSenderIF::sendMessage(target->getMessageQueueId(), &message,
-            commandQueue->getId());
-    if (result != HasReturnvaluesIF::RETURN_OK
-            && result != MessageQueueIF::FULL) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FsfwDemoTask::performSendOperation: Send failed with " << result << std::endl;
-#else
-        sif::printError("FsfwDemoTask::performSendOperation: Send failed with %hu\n", result);
-#endif
-    }
-
-    demoSet.variableWrite.value = randomNumber;
-    result = demoSet.variableWrite.commit(20);
-
-    return result;
-}
-
-ReturnValue_t FsfwExampleTask::performReceiveOperation() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    while (result != MessageQueueIF::EMPTY) {
-        CommandMessage receivedMessage;
-        result = commandQueue->receiveMessage(&receivedMessage);
-        if (result != HasReturnvaluesIF::RETURN_OK
-                && result != MessageQueueIF::EMPTY) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::debug << "Receive failed with " << result << std::endl;
-#endif
-            break;
-        }
-        if (result != MessageQueueIF::EMPTY) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-#if OBSW_VERBOSE_LEVEL >= 2
-            sif::debug << "Message Received by " << getObjectId() << " from Queue " <<
-                    receivedMessage.getSender() << " ObjectId " << receivedMessage.getParameter() <<
-                    " Queue " << receivedMessage.getParameter2() << std::endl;
-#endif
-#endif
-
-            if(senderSet == nullptr) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-
-            result = senderSet->variableRead.read(MutexIF::TimeoutType::WAITING,
-                    20);
-            if(result != HasReturnvaluesIF::RETURN_OK) {
-                return result;
-            }
-            if(senderSet->variableRead.value != receivedMessage.getParameter()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-                sif::error << "FsfwDemoTask::performReceiveOperation: Variable " << std::hex <<
-                        "0x" << senderSet->variableRead.getDataPoolId() << std::dec <<
-                        " has wrong value." << std::endl;
-                sif::error << "Value: "  << demoSet.variableRead.value << ", expected: " <<
-                        receivedMessage.getParameter() << std::endl;
-#endif
-            }
-
-        }
-    }
-    return result;
-}
-
-MessageQueueId_t FsfwExampleTask::getCommandQueue() const {
-    return commandQueue->getId();
-}
-
-LocalDataPoolManager* FsfwExampleTask::getHkManagerHandle() {
-    return &poolManager;
-}

test/FsfwExampleTask.h

@@ -1,116 +0,0 @@
-#ifndef MISSION_DEMO_FSFWDEMOTASK_H_
-#define MISSION_DEMO_FSFWDEMOTASK_H_
-
-#include "testdefinitions/demoDefinitions.h"
-
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-#include <fsfw/tasks/ExecutableObjectIF.h>
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/ipc/MessageQueueIF.h>
-#include <fsfw/monitoring/AbsLimitMonitor.h>
-
-class PeriodicTaskIF;
-
-
-/**
- * @brief 	This demo set shows the local data pool functionality and fixed
- * 			timeslot capabilities of the FSFW.
- *
- * @details
- * There will be multiple demo objects. Each demo object will generate a random
- * number and send that number via message queues to the next demo object
- * (e.g. DUMMY_1 sends the number to DUMMY_2 etc.). The receiving object
- * will check the received value against the sent value by extracting the sent
- * value directly from the sender via the local data pool interface.
- * If the timing is set up correctly, the values will always be the same.
- */
-class FsfwExampleTask:
-        public ExecutableObjectIF,
-        public SystemObject,
-        public HasLocalDataPoolIF {
-public:
-    enum OpCodes {
-        SEND_RAND_NUM,
-        RECEIVE_RAND_NUM,
-        DELAY_SHORT
-    };
-
-    static constexpr uint8_t MONITOR_ID = 2;
-
-    /**
-     * @brief 	Simple constructor, only expects object ID.
-     * @param objectId
-     */
-    FsfwExampleTask(object_id_t objectId);
-
-    virtual ~FsfwExampleTask();
-
-    /**
-     * @brief	The performOperation method is executed in a task.
-     * @details	There are no restrictions for calls within this method, so any
-     * 			other member of the class can be used.
-     * @return	Currently, the return value is ignored.
-     */
-    virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
-
-    /**
-     * @brief 	This function will be called by the global object manager
-     * @details
-     * This function will always be called before any tasks are started.
-     * It can also be used to return error codes in the software initialization
-     * process cleanly.
-     * @return
-     */
-    virtual ReturnValue_t initialize() override;
-
-    /**
-     * @brief 	This function will be called by the OSAL task handlers
-     * @details
-     * This function will be called before the first #performOperation
-     * call after the tasks have been started. It can be used if some
-     * initialization process requires task specific properties like
-     * periodic intervals (by using the PeriodicTaskIF* handle).
-     * @return
-     */
-    virtual ReturnValue_t initializeAfterTaskCreation() override;
-
-    /**
-     * This function will be called by the OSAL task handler. The
-     * task interface handle can be cached to access task specific properties.
-     * @param task
-     */
-    void setTaskIF(PeriodicTaskIF* task) override;
-
-    object_id_t getObjectId() const override;
-
-    MessageQueueId_t getMessageQueueId();
-
-
-private:
-    LocalDataPoolManager poolManager;
-    FsfwDemoSet* senderSet = nullptr;
-    FsfwDemoSet demoSet;
-    AbsLimitMonitor<int32_t> monitor;
-    PeriodicTaskIF* task = nullptr;
-    MessageQueueIF* commandQueue = nullptr;
-
-    /* HasLocalDatapoolIF overrides */
-    MessageQueueId_t getCommandQueue() const override;
-    LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    uint32_t getPeriodicOperationFrequency() const override;
-    virtual ReturnValue_t initializeLocalDataPool(
-            localpool::DataPool& localDataPoolMap,
-            LocalDataPoolManager& poolManager) override;
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
-
-    object_id_t getNextRecipient();
-    object_id_t getSender();
-
-    ReturnValue_t performMonitoringDemo();
-    ReturnValue_t performSendOperation();
-    ReturnValue_t performReceiveOperation();
-    uint8_t execCounter = 0;
-};
-
-#endif /* MISSION_DEMO_FSFWDEMOTASK_H_ */

test/FsfwReaderTask.cpp

@@ -1,55 +0,0 @@
-#include "FsfwReaderTask.h"
-
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <fsfw/timemanager/Stopwatch.h>
-
-#include <OBSWConfig.h>
-
-
-FsfwReaderTask::FsfwReaderTask(object_id_t objectId, bool enablePrintout):
-		SystemObject(objectId), printoutEnabled(enablePrintout), opDivider(10),
-		readSet(this->getObjectId(),
-				gp_id_t(objects::TEST_DUMMY_1, FsfwDemoSet::PoolIds::VARIABLE),
-				gp_id_t(objects::TEST_DUMMY_2, FsfwDemoSet::PoolIds::VARIABLE),
-				gp_id_t(objects::TEST_DUMMY_3, FsfwDemoSet::PoolIds::VARIABLE)) {
-    /* Special protection for set reading because each variable is read from a different pool */
-	readSet.setReadCommitProtectionBehaviour(true);
-}
-
-FsfwReaderTask::~FsfwReaderTask() {
-}
-
-ReturnValue_t FsfwReaderTask::initializeAfterTaskCreation() {
-	/* Give other task some time to set up local data pools. */
-	TaskFactory::delayTask(20);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t FsfwReaderTask::performOperation(uint8_t operationCode) {
-	PoolReadGuard readHelper(&readSet);
-
-	uint32_t variable1 = readSet.variable1.value;
-	uint32_t variable2 = readSet.variable2.value;
-	uint32_t variable3 = readSet.variable3.value;
-
-#if OBSW_VERBOSE_LEVEL >= 1
-	if(opDivider.checkAndIncrement() and printoutEnabled) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::info << "FsfwPeriodicTask::performOperation: Reading variables." << std::endl;
-		sif::info << "Variable read from demo object 1: " << variable1 << std::endl;
-		sif::info << "Variable read from demo object 2: " << variable2 << std::endl;
-		sif::info << "Variable read from demo object 3: " << variable3 << std::endl;
-#else
-		sif::printInfo("FsfwPeriodicTask::performOperation: Reading variables.\n\r");
-		sif::printInfo("Variable read from demo object 1: %d\n\r", variable1);
-		sif::printInfo("Variable read from demo object 2: %d\n\r", variable2);
-		sif::printInfo("Variable read from demo object 3: %d\n\r", variable3);
-#endif
-	}
-#else
-	if(variable1 and variable2 and variable3) {};
-#endif
-	return HasReturnvaluesIF::RETURN_OK;
-}

test/FsfwReaderTask.h

@@ -1,24 +0,0 @@
-#ifndef MISSION_DEMO_FSFWPERIODICTASK_H_
-#define MISSION_DEMO_FSFWPERIODICTASK_H_
-
-#include "testdefinitions/demoDefinitions.h"
-
-#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
-#include <fsfw/tasks/ExecutableObjectIF.h>
-#include <fsfw/objectmanager/SystemObject.h>
-
-class FsfwReaderTask: public ExecutableObjectIF, public SystemObject {
-public:
-    FsfwReaderTask(object_id_t objectId, bool enablePrintout);
-    virtual ~FsfwReaderTask();
-
-    ReturnValue_t initializeAfterTaskCreation() override;
-    virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
-
-private:
-    bool printoutEnabled = false;
-    PeriodicOperationDivider opDivider;
-    CompleteDemoReadSet readSet;
-};
-
-#endif /* MISSION_DEMO_FSFWPERIODICTASK_H_ */

test/MutexExample.cpp

@@ -1,47 +0,0 @@
-#include "MutexExample.h"
-
-#include <fsfw/ipc/MutexFactory.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-
-void MutexExample::example(){
-	MutexIF* mutex = MutexFactory::instance()->createMutex();
-	MutexIF* mutex2 = MutexFactory::instance()->createMutex();
-
-	ReturnValue_t result = mutex->lockMutex(MutexIF::TimeoutType::WAITING,
-			2 * 60 * 1000);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "MutexExample::example: Lock Failed with " << result << std::endl;
-#else
-		sif::printError("MutexExample::example: Lock Failed with %hu\n", result);
-#endif
-	}
-
-	result = mutex2->lockMutex(MutexIF::TimeoutType::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "MutexExample::example: Lock Failed with " << result << std::endl;
-#else
-        sif::printError("MutexExample::example: Lock Failed with %hu\n", result);
-#endif
-	}
-
-	result = mutex->unlockMutex();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "MutexExample::example: Unlock Failed with " << result << std::endl;
-#else
-        sif::printError("MutexExample::example: Unlock Failed with %hu\n", result);
-#endif
-	}
-
-	result = mutex2->unlockMutex();
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "MutexExample::example: Unlock Failed with " << result << std::endl;
-#else
-        sif::printError("MutexExample::example: Unlock Failed with %hu\n", result);
-#endif
-	}
-}

test/MutexExample.h

@@ -1,8 +0,0 @@
-#ifndef MISSION_DEMO_MUTEXEXAMPLE_H_
-#define MISSION_DEMO_MUTEXEXAMPLE_H_
-
-namespace MutexExample {
-	void example();
-};
-
-#endif /* MISSION_DEMO_MUTEXEXAMPLE_H_ */

test/TestTask.cpp

@@ -1,80 +0,0 @@
-#include "TestTask.h"
-
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-bool TestTask::oneShotAction = true;
-MutexIF* TestTask::testLock = nullptr;
-
-TestTask::TestTask(object_id_t objectId, bool periodicPrintout, bool periodicEvent):
-	SystemObject(objectId), testMode(testModes::A),
-	periodicPrinout(periodicPrintout), periodicEvent(periodicEvent) {
-	if(testLock == nullptr) {
-		testLock = MutexFactory::instance()->createMutex();
-	}
-	IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-}
-
-TestTask::~TestTask() {
-}
-
-ReturnValue_t TestTask::performOperation(uint8_t operationCode) {
-	ReturnValue_t result = RETURN_OK;
-	testLock->lockMutex(MutexIF::TimeoutType::WAITING, 20);
-	if(oneShotAction) {
-		// Add code here which should only be run once
-		performOneShotAction();
-		oneShotAction = false;
-	}
-	testLock->unlockMutex();
-
-	// Add code here which should only be run once per performOperation
-	performPeriodicAction();
-
-	// Add code here which should only be run on alternating cycles.
-	if(testMode == testModes::A) {
-		performActionA();
-		testMode = testModes::B;
-	}
-	else if(testMode == testModes::B) {
-		performActionB();
-		testMode = testModes::A;
-	}
-	return result;
-}
-
-ReturnValue_t TestTask::performOneShotAction() {
-	/* Everything here will only be performed once. */
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t TestTask::performPeriodicAction() {
-    /* This is performed each task cycle */
-	ReturnValue_t result = RETURN_OK;
-
-	if(periodicPrinout) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::info << "TestTask::performPeriodicAction: Hello World!" << std::endl;
-#else
-		sif::printInfo("TestTask::performPeriodicAction: Hello World!\n");
-#endif
-	}
-	if(periodicEvent) {
-	    triggerEvent(TEST_EVENT, 0x1234, 0x4321);
-	}
-	return result;
-}
-
-ReturnValue_t TestTask::performActionA() {
-    /* This is performed each alternating task cycle */
-	ReturnValue_t result = RETURN_OK;
-	return result;
-}
-
-ReturnValue_t TestTask::performActionB() {
-    /* This is performed each alternating task cycle */
-	ReturnValue_t result = RETURN_OK;
-	return result;
-}
-

test/TestTask.h

@@ -1,56 +0,0 @@
-#ifndef MISSION_DEMO_TESTTASK_H_
-#define MISSION_DEMO_TESTTASK_H_
-
-#include <fsfw/tasks/ExecutableObjectIF.h>
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/storagemanager/StorageManagerIF.h>
-
-#include "fsfw/events/Event.h"
-#include "events/subsystemIdRanges.h"
-
-/**
- * @brief 	Test class for general C++ testing and any other code which will not be part of the
- *          primary mission software.
- * @details
- * Should not be used for board specific tests. Instead, a derived board test class should be used.
- */
-class TestTask :
-        public SystemObject,
-        public ExecutableObjectIF,
-        public HasReturnvaluesIF {
-public:
-    TestTask(object_id_t objectId, bool periodicPrintout = false, bool periodicEvent = false);
-    virtual ~TestTask();
-    virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
-
-    static constexpr uint8_t subsystemId = SUBSYSTEM_ID::TEST_TASK_ID;
-    static constexpr Event TEST_EVENT = event::makeEvent(subsystemId, 0, severity::INFO);
-
-protected:
-    virtual ReturnValue_t performOneShotAction();
-    virtual ReturnValue_t performPeriodicAction();
-    virtual ReturnValue_t performActionA();
-    virtual ReturnValue_t performActionB();
-
-    enum testModes: uint8_t {
-        A,
-        B
-    };
-
-    testModes testMode;
-    bool periodicPrinout = false;
-    bool periodicEvent = false;
-
-    bool testFlag = false;
-    uint8_t counter { 1 };
-    uint8_t counterTrigger { 3 };
-
-    void performPusInjectorTest();
-    void examplePacketTest();
-private:
-    static bool oneShotAction;
-    static MutexIF* testLock;
-    StorageManagerIF* IPCStore;
-};
-
-#endif /* TESTTASK_H_ */

test/testdefinitions/demoDefinitions.h

@@ -1,63 +0,0 @@
-#ifndef MISSION_DEMO_DEMODEFINITIONS_H_
-#define MISSION_DEMO_DEMODEFINITIONS_H_
-
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-
-/**
- * @brief 	This demo set showcases the local data pool functionality of the
- * 			FSFW
- * @details
- * Each demo object will have an own instance of this set class, which contains
- * pool variables (for read and write access respectively).
- */
-class FsfwDemoSet: public StaticLocalDataSet<3> {
-public:
-
-	static constexpr uint32_t DEMO_SET_ID = 0;
-
-	enum PoolIds {
-		VARIABLE,
-		VARIABLE_LIMIT
-	};
-
-	FsfwDemoSet(HasLocalDataPoolIF* hkOwner):
-			StaticLocalDataSet(hkOwner, DEMO_SET_ID) {}
-
-	lp_var_t<uint32_t> variableRead = lp_var_t<uint32_t>(sid.objectId,
-			PoolIds::VARIABLE, this, pool_rwm_t::VAR_READ);
-	lp_var_t<uint32_t> variableWrite = lp_var_t<uint32_t>(sid.objectId,
-			PoolIds::VARIABLE, this, pool_rwm_t::VAR_WRITE);
-	lp_var_t<uint16_t> variableLimit = lp_var_t<uint16_t>(sid.objectId,
-			PoolIds::VARIABLE_LIMIT, this);
-private:
-
-};
-
-/**
- * This set will enable object to read the dummy variables from the dataset
- * above. An example application would be a consumer object like a controller
- * which reads multiple sensor values at once.
- */
-class CompleteDemoReadSet: public StaticLocalDataSet<3> {
-public:
-	static constexpr uint32_t DEMO_SET_ID = 0;
-
-	CompleteDemoReadSet(object_id_t owner, gp_id_t variable1,
-			gp_id_t variable2, gp_id_t variable3):
-			StaticLocalDataSet(sid_t(owner, DEMO_SET_ID)),
-			variable1(variable1, this, pool_rwm_t::VAR_READ),
-			variable2(variable2, this, pool_rwm_t::VAR_READ),
-			variable3(variable3, this, pool_rwm_t::VAR_READ) {}
-
-
-	lp_var_t<uint32_t> variable1;
-	lp_var_t<uint32_t> variable2;
-	lp_var_t<uint32_t> variable3;
-private:
-};
-
-
-
-
-#endif /* MISSION_DEMO_DEMODEFINITIONS_H_ */

utility/CMakeLists.txt

@@ -1,3 +0,0 @@
-target_sources(${TARGET_NAME} PRIVATE
-	utility.cpp
-)

utility/utility.cpp

@@ -1,22 +0,0 @@
-#include "utility.h"
-#include <FSFWConfig.h>
-#include <OBSWVersion.h>
-
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-void utility::commonInitPrint(const char *const os, const char* const board) {
-    if(os == nullptr or board == nullptr) {
-        return;
-    }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    std::cout << "-- FSFW Example (" << os<< ") v" << FSFW_EXAMPLE_VERSION << "." <<
-            FSFW_EXAMPLE_SUBVERSION << "." << FSFW_EXAMPLE_REVISION  << " --" << std::endl;
-    std::cout << "-- Compiled for " << board << " --" << std::endl;
-    std::cout << "-- Compiled on " << __DATE__ << " " << __TIME__ << " --" << std::endl;
-#else
-    printf("\n\r-- FSFW Example (%s) v%d.%d.%d --\n", os, FSFW_EXAMPLE_VERSION,
-            FSFW_EXAMPLE_SUBVERSION, FSFW_EXAMPLE_REVISION);
-    printf("-- Compiled for %s --\n", board);
-    printf("-- Compiled on %s %s --\n", __DATE__, __TIME__);
-#endif
-}